Classificação de imagens com Ultralytics YOLO#

A classificação de imagens é a mais simples das tarefas compatíveis e consiste em classificar uma imagem inteira em uma das classes predefinidas.

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

Modelos#

Os modelos YOLO26 Classify pré-treinados no conjunto de dados ImageNet são apresentados abaixo.

Os modelos são transferidos automaticamente da versão mais recente do Ultralytics na primeira utilização.

• Os valores de acc são as precisões dos modelos no conjunto de validação do ImageNet.
  Reproduza com yolo classify val data=path/to/ImageNet device=0
• Velocidade média nas imagens de validação do ImageNet com ONNX na CPU e TensorRT10 em uma GPU NVIDIA T4.
  Reproduza com yolo classify val data=path/to/ImageNet batch=1 device=0|cpu
• Os valores de Parâmetros e FLOPs correspondem ao modelo fundido após model.fuse(), que combina as camadas Conv e BatchNorm. Os checkpoints pré-treinados mantêm a arquitetura de treino completa e podem apresentar contagens superiores.

Consulte a prévia não lançada do YOLO27 para ver dados preliminares de velocidade e tamanhos dos modelos de classificação.

Treinar#

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

from ultralytics import YOLO

# Carregar um modelo
model = YOLO("yolo26n-cls.yaml")  # crie um novo modelo a partir de YAML
model = YOLO("yolo26n-cls.pt")  # carregue um modelo pré-treinado (recomendado para treinamento)
model = YOLO("yolo26n-cls.yaml").load("yolo26n-cls.pt")  # crie a partir de YAML e transfira os pesos

# Treinar o modelo
results = model.train(data="mnist160", epochs=100, imgsz=64)

Veja os detalhes completos do modo train na página Treinar. Os modelos de classificação também podem ser treinados com o treinamento na nuvem da Ultralytics Platform.

Formato do conjunto de dados#

Os detalhes do formato de conjunto de dados de classificação YOLO estão no Guia de conjuntos de dados. Os conjuntos de dados de classificação também podem ser gerenciados e rotulados com as ferramentas de anotação da Ultralytics Platform.

Transformações personalizadas#

A classificação Ultralytics YOLO usa torchvision.transforms.RandomResizedCrop para treinamento e torchvision.transforms.CenterCrop para validação e inferência. Essas transformações baseadas em recorte pressupõem entradas quadradas e podem cortar regiões importantes de imagens com proporções extremas. Para manter a imagem inteira, substitua os recortes por torchvision.transforms.Resize, que redimensiona para imgsz × imgsz em vez de recortar, usando um ClassificationDataset, ClassificationTrainer e ClassificationValidator personalizados:

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 = "", names=None):
        """Initialize a customized classification dataset with enhanced data augmentation transforms."""
        super().__init__(root, args, augment, prefix, names)

        # Adicione suas transformações personalizadas de treinamento aqui
        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),
            ]
        )

        # Adicione suas transformações personalizadas de validação aqui
        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="train" if mode == "train" else self.args.split,
            names=self.data["names"],
        )

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, names=self.names)

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

Validar#

Valide a precisão do modelo YOLO26n-cls treinado. Não são necessários argumentos, pois o model mantém o data de treinamento e os argumentos como atributos do modelo: path/to/best.pt do exemplo de Treinamento valida no MNIST160. Os pesos oficiais registram um caminho para o conjunto de dados de treinamento que não existe na sua máquina, então usam o padrão da tarefa imagenet10 como alternativa e exibem um aviso. Passe data para validar em outro conjunto de dados.

from ultralytics import YOLO

# Carregar um modelo
model = YOLO("yolo26n-cls.pt")  # carrega um modelo oficial
model = YOLO("path/to/best.pt")  # carregar um modelo personalizado

# Valida o modelo
metrics = model.val()  # não são necessários argumentos; o conjunto de dados e as definições são guardados
metrics.top1  # top1 accuracy
metrics.top5  # top5 accuracy

Prever#

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

from ultralytics import YOLO

# Carregar um modelo
model = YOLO("yolo26n-cls.pt")  # carrega um modelo oficial
model = YOLO("path/to/best.pt")  # carregar um modelo personalizado

# Faz previsões com o modelo
results = model("https://ultralytics.com/images/bus.jpg")  # faz uma previsão numa imagem

# Acede aos resultados
for result in results:
    top1 = result.probs.top1  # ID da classe com maior previsão
    top1_conf = result.probs.top1conf  # confiança da previsão mais alta
    top1_name = result.names[top1]  # nome da classe com maior previsão

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

Saída dos resultados#

A classificação de imagens retorna um objeto Results por imagem. O principal campo de previsão é result.probs, que contém o vetor de probabilidades das classes e auxiliares para as principais previsões.

Para ver os campos Results específicos de cada tarefa, consulta a secção Resultados da previsão por tarefa.

Exportar#

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

from ultralytics import YOLO

# Carregar um modelo
model = YOLO("yolo26n-cls.pt")  # carrega um modelo oficial
model = YOLO("path/to/best.pt")  # carregar um modelo personalizado

# Exporta o modelo
model.export(format="onnx")

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

nms=None usa por predefinição saídas brutas para NMS externo. Define nms=False para selecionar uma cabeça sem NMS disponível; os formatos não suportados recorrem ao respetivo caminho de saída nativo. As entradas nms acima identificam os formatos que podem incorporar NMS com nms=True.

Consulte os detalhes completos de export na página Exportação.

Perguntas frequentes#