Classificação de Imagem

Classificação de imagens é 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 é a sua forma exata.

Modelos

Os modelos Classify pré-treinados YOLO26 são mostrados aqui. Os modelos Detect, Segment e Pose são pré-treinados no conjunto de dados COCO, enquanto os modelos Classify são pré-treinados no conjunto de dados ImageNet.

Modelos são baixados automaticamente da versão mais recente do Ultralytics release no primeiro uso.

• acc valores são precisões de modelo no conjunto de validação ImageNet.
  Reproduza por yolo val classify data=path/to/ImageNet device=0
• Velocidade com média calculada sobre imagens de val do ImageNet usando uma instância Amazon EC2 P4d.
  Reproduza por yolo val classify data=path/to/ImageNet batch=1 device=0|cpu
• Params e FLOPs valores são para o modelo fundido 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, veja a 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 de Conjunto de Dados

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

Val

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

Previsão

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

Veja detalhes completos de predict detalhes do modo no Previsão.

Exportação

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 format, ex: format='onnx' ou format='engine'. Você pode prever ou validar diretamente em modelos exportados, ex: yolo predict model=yolo26n-cls.onnx. Exemplos de uso são mostrados para o seu modelo após a conclusão da exportação.

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

FAQ

Qual é o propósito do YOLO26 na classificação de imagem?

Os modelos YOLO26, como yolo26n-cls.pt, são projetados para classificação eficiente de imagem. Eles atribuem um único rótulo de classe a uma imagem inteira, juntamente 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 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 em um tamanho de imagem de 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 Configuração.

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

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

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