Classificação de Imagem

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

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

Modelos

Os modelos YOLO26 Classify pré-treinados são mostrados aqui. Os modelos de Detecção (Detect), Segmentação (Segment) e Pose são pré-treinados no conjunto de dados COCO, os modelos Semantic são pré-treinados no Cityscapes e os modelos Classify são pré-treinados no conjunto de dados ImageNet.

Modelos são baixados automaticamente da última versão da Ultralytics no primeiro uso.

• acc values are model accuracies on the ImageNet dataset validation set.
  Reproduce by yolo val classify data=path/to/ImageNet device=0
• Speed averaged over ImageNet val images using an Amazon EC2 P4d instance.
  Reproduce by yolo val classify data=path/to/ImageNet batch=1 device=0|cpu
• Os valores de Params e FLOPs são para o modelo fundido (fused) após model.fuse(), que combina as camadas Conv e BatchNorm. Checkpoints pré-treinados mantêm a arquitetura de treinamento completa e podem mostrar contagens mais altas.

Treinar

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, consulte 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, mode: str = "train"):
        """Build a customized dataset for classification standalone validation."""
        return CustomizedDataset(root=img_path, args=self.args, augment=mode == "train", 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)

Formato do conjunto de dados

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

Validação

Valide a precisão do modelo YOLO26n-cls treinado no conjunto de dados MNIST160. Nenhum argumento é necessário, pois o model retém seus dados (data) de treinamento 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

Prever

Use um modelo YOLO26n-cls treinado para realizar 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

Veja detalhes completos do modo predict na página Predict.

Exportar

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 de Exportação.

FAQ

Qual é o objetivo do YOLO26 na classificação de imagem?

Os modelos YOLO26, como o yolo26n-cls.pt, são projetados para classificação de imagem eficiente. 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 de objetos dentro da imagem.

Como 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.

Onde posso encontrar modelos de classificação YOLO26 pré-treinados?

Modelos de classificação YOLO26 pré-treinados podem ser encontrados na seção Models. 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.

Como 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.

Como 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.