Link to this sectionClassificação de Imagem#

A classificação de imagem é a mais simples das tarefas suportadas e envolve classificar uma imagem inteira em uma de um conjunto de classes predefinidas.

O resultado de um classificador de imagem é um rótulo de classe único e uma pontuação de confiança. A classificação de imagem é útil quando você precisa apenas saber a qual classe uma imagem pertence e não precisa saber onde os objetos dessa classe estão localizados ou qual é a sua forma exata.

Link to this sectionModelos#

Os modelos de classificação pré-treinados YOLO26 são mostrados aqui. Os modelos de detecção, segmentação e pose são pré-treinados no conjunto de dados COCO, os modelos Semânticos são pré-treinados no Cityscapes e os modelos de classificação são pré-treinados no conjunto de dados ImageNet.

Os modelos são baixados automaticamente do release mais recente da Ultralytics no primeiro uso.

• Os valores de acc são as precisões do modelo no conjunto de validação do conjunto de dados ImageNet.
  Reproduza usando yolo val classify data=path/to/ImageNet device=0
• Velocidade calculada sobre as imagens de validação do ImageNet usando uma instância Amazon EC2 P4d.
  Reproduza usando yolo val classify data=path/to/ImageNet batch=1 device=0|cpu
• Os valores de Params e FLOPs são para o modelo fundido após model.fuse(), que mescla camadas Conv e BatchNorm. Checkpoints pré-treinados mantêm a arquitetura de treinamento completa e podem mostrar contagens mais altas.

Link to this sectionTreinar#

Treine o YOLO26n-cls no conjunto de dados MNIST160 por 100 épocas com tamanho de imagem 64. Para uma lista completa de argumentos disponíveis, veja a página de Configuração.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.yaml")  # build a new model from YAML
model = YOLO("yolo26n-cls.pt")  # load a pretrained model (recommended for training)
model = YOLO("yolo26n-cls.yaml").load("yolo26n-cls.pt")  # build from YAML and transfer weights

# Train the model
results = model.train(data="mnist160", epochs=100, imgsz=64)

import torch
import torchvision.transforms as T

from ultralytics import YOLO
from ultralytics.data.dataset import ClassificationDataset
from ultralytics.models.yolo.classify import ClassificationTrainer, ClassificationValidator

class CustomizedDataset(ClassificationDataset):
    """A customized dataset class for image classification with enhanced data augmentation transforms."""

    def __init__(self, root: str, args, augment: bool = False, prefix: str = ""):
        """Initialize a customized classification dataset with enhanced data augmentation transforms."""
        super().__init__(root, args, augment, prefix)

        # Add your custom training transforms here
        train_transforms = T.Compose(
            [
                T.Resize((args.imgsz, args.imgsz)),
                T.RandomHorizontalFlip(p=args.fliplr),
                T.RandomVerticalFlip(p=args.flipud),
                T.RandAugment(interpolation=T.InterpolationMode.BILINEAR),
                T.ColorJitter(brightness=args.hsv_v, contrast=args.hsv_v, saturation=args.hsv_s, hue=args.hsv_h),
                T.ToTensor(),
                T.Normalize(mean=torch.tensor(0), std=torch.tensor(1)),
                T.RandomErasing(p=args.erasing, inplace=True),
            ]
        )

        # Add your custom validation transforms here
        val_transforms = T.Compose(
            [
                T.Resize((args.imgsz, args.imgsz)),
                T.ToTensor(),
                T.Normalize(mean=torch.tensor(0), std=torch.tensor(1)),
            ]
        )
        self.torch_transforms = train_transforms if augment else val_transforms

class CustomizedTrainer(ClassificationTrainer):
    """A customized trainer class for YOLO classification models with enhanced dataset handling."""

    def build_dataset(self, img_path: str, mode: str = "train", batch=None):
        """Build a customized dataset for classification training and the validation during training."""
        return CustomizedDataset(root=img_path, args=self.args, augment=mode == "train", prefix=mode)

class CustomizedValidator(ClassificationValidator):
    """A customized validator class for YOLO classification models with enhanced dataset handling."""

    def build_dataset(self, img_path: str):
        """Build a customized dataset for classification standalone validation (no augmentation)."""
        return CustomizedDataset(root=img_path, args=self.args, augment=False, prefix=self.args.split)

model = YOLO("yolo26n-cls.pt")
model.train(data="imagenet1000", trainer=CustomizedTrainer, epochs=10, imgsz=224, batch=64)
model.val(data="imagenet1000", validator=CustomizedValidator, imgsz=224, batch=64)

Link to this sectionFormato do conjunto de dados#

O formato do conjunto de dados de classificação YOLO pode ser encontrado em detalhes no Guia de Conjunto de Dados. Os conjuntos de dados de classificação também podem ser gerenciados e rotulados na Plataforma Ultralytics.

Link to this sectionValidar#

Valide a precisão do modelo YOLO26n-cls treinado no conjunto de dados MNIST160. Nenhum argumento é necessário, pois o model mantém seus dados de data e argumentos como atributos do modelo.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Validate the model
metrics = model.val()  # no arguments needed, dataset and settings remembered
metrics.top1  # top1 accuracy
metrics.top5  # top5 accuracy

Link to this sectionPrever#

Use um modelo YOLO26n-cls treinado para executar previsões em imagens.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Predict with the model
results = model("https://ultralytics.com/images/bus.jpg")  # predict on an image

# Access the results
for result in results:
    top1 = result.probs.top1  # top predicted class ID
    top1_conf = result.probs.top1conf  # top prediction confidence
    top1_name = result.names[top1]  # top predicted class name

Veja os detalhes completos do modo predict na página Previsão.

Link to this sectionSaída de Resultados#

A classificação de imagem retorna um objeto Results por imagem. O campo principal de previsão é result.probs, que contém o vetor de probabilidade de classe e auxiliares para as melhores previsões.

Para campos de Results específicos de cada tarefa em todas as tarefas, veja a seção Resultados de Previsão por Tarefa.

Link to this sectionExportar#

Exporte um modelo YOLO26n-cls para um formato diferente como ONNX, CoreML, etc.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom-trained model

# Export the model
model.export(format="onnx")

Os formatos de exportação YOLO26-cls disponíveis estão na tabela abaixo. Você pode exportar para qualquer formato usando o argumento format, por exemplo, format='onnx' ou format='engine'. Você pode prever ou validar diretamente em modelos exportados, por exemplo, yolo predict model=yolo26n-cls.onnx. Exemplos de uso são mostrados para seu modelo após a conclusão da exportação.

Veja detalhes completos de export na página Export.

Link to this sectionFAQ#

Link to this sectionQual é o objetivo do YOLO26 na classificação de imagem?#

Os modelos YOLO26, como yolo26n-cls.pt, são projetados para classificação eficiente de imagens. Eles atribuem um único rótulo de classe a uma imagem inteira junto com uma pontuação de confiança. Isso é particularmente útil para aplicações onde saber a classe específica de uma imagem é suficiente, em vez de identificar a localização ou a forma dos objetos dentro da imagem.

Link to this sectionComo treino um modelo YOLO26 para classificação de imagem?#

Para treinar um modelo YOLO26, você pode usar comandos Python ou CLI. Por exemplo, para treinar um modelo yolo26n-cls no conjunto de dados MNIST160 por 100 épocas com tamanho de imagem 64:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="mnist160", epochs=100, imgsz=64)

Para mais opções de configuração, visite a página de Configuração.

Link to this sectionOnde posso encontrar modelos de classificação YOLO26 pré-treinados?#

Modelos de classificação YOLO26 pré-treinados podem ser encontrados na seção Modelos. Modelos como yolo26n-cls.pt, yolo26s-cls.pt, yolo26m-cls.pt, etc., são pré-treinados no conjunto de dados ImageNet e podem ser facilmente baixados e usados para várias tarefas de classificação de imagem.

Link to this sectionComo posso exportar um modelo YOLO26 treinado para diferentes formatos?#

Você pode exportar um modelo YOLO26 treinado para vários formatos usando comandos Python ou CLI. Por exemplo, para exportar um modelo para o formato ONNX:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load the trained model

# Export the model to ONNX
model.export(format="onnx")

Para opções detalhadas de exportação, consulte a página Exportar.

Link to this sectionComo valido um modelo de classificação YOLO26 treinado?#

Para validar a precisão de um modelo treinado em um conjunto de dados como o MNIST160, você pode usar os seguintes comandos Python ou CLI:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-cls.pt")  # load the trained model

# Validate the model
metrics = model.val()  # no arguments needed, uses the dataset and settings from training
metrics.top1  # top1 accuracy
metrics.top5  # top5 accuracy

Para mais informações, visite a seção Validar.