Clasificación de imágenes

La clasificación de imágenes es la más sencilla de las tres tareas y consiste en clasificar una imagen completa en una de un conjunto de clases predefinidas.

El resultado de un clasificador de imágenes es una etiqueta de clase única y una puntuación de confianza. La clasificación de imágenes es útil cuando solo necesitas saber a qué clase pertenece una imagen y no requieres conocer la ubicación o la forma exacta de los objetos de dicha clase.

Modelos

Aquí se muestran los modelos de clasificación preentrenados de YOLO26. Los modelos de detección, segmentación y pose están preentrenados en el conjunto de datos COCO, mientras que los modelos de clasificación están preentrenados en el conjunto de datos ImageNet.

Los modelos se descargan automáticamente desde la última versión de Ultralytics en el primer uso.

• Los valores acc son las precisiones del modelo en el conjunto de validación de ImageNet.
  Reproduce esto con yolo val classify data=path/to/ImageNet device=0
• Velocidad promediada sobre imágenes de validación de ImageNet utilizando una instancia Amazon EC2 P4d.
  Reproduce esto con yolo val classify data=path/to/ImageNet batch=1 device=0|cpu
• Los valores de Params y FLOPs corresponden al modelo fusionado tras model.fuse(), que combina capas Conv y BatchNorm. Los puntos de control preentrenados conservan la arquitectura de entrenamiento completa y pueden mostrar recuentos más altos.

Entrenar (Train)

Entrena YOLO26n-cls en el conjunto de datos MNIST160 durante 100 épocas con un tamaño de imagen de 64. Para obtener una lista completa de los argumentos disponibles, consulta la página de Configuración.

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 del conjunto de datos

El formato del conjunto de datos de clasificación YOLO se detalla en la Guía de conjuntos de datos. Los conjuntos de datos de clasificación también pueden gestionarse y etiquetarse en la Plataforma Ultralytics.

Validar (Val)

Valida la precisión del modelo YOLO26n-cls entrenado en el conjunto de datos MNIST160. No se necesitan argumentos, ya que el model conserva sus data y argumentos de entrenamiento como atributos del 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

Predecir

Usa un modelo YOLO26n-cls entrenado para realizar predicciones en imágenes.

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

Consulta los detalles completos del modo predict en la página Predict.

Exportar (Export)

Exporta un modelo YOLO26n-cls a un 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")

Los formatos de exportación disponibles para YOLO26-cls se encuentran en la tabla siguiente. Puedes exportar a cualquier formato usando el argumento format, es decir, format='onnx' o format='engine'. Puedes predecir o validar directamente en modelos exportados, por ejemplo: yolo predict model=yolo26n-cls.onnx. Se muestran ejemplos de uso para tu modelo después de completar la exportación.

Consulta todos los detalles de export en la página Export.

Preguntas frecuentes

¿Cuál es el propósito de YOLO26 en la clasificación de imágenes?

Los modelos YOLO26, como yolo26n-cls.pt, están diseñados para una clasificación de imágenes eficiente. Asignan una única etiqueta de clase a una imagen completa junto con una puntuación de confianza. Esto es particularmente útil para aplicaciones donde saber la clase específica de una imagen es suficiente, en lugar de identificar la ubicación o la forma de los objetos dentro de la imagen.

¿Cómo entreno un modelo YOLO26 para la clasificación de imágenes?

Para entrenar un modelo YOLO26, puedes usar comandos de Python o de la CLI. Por ejemplo, para entrenar un modelo yolo26n-cls en el conjunto de datos MNIST160 durante 100 épocas con un tamaño de imagen 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 ver más opciones de configuración, visita la página de Configuración.

¿Dónde puedo encontrar modelos de clasificación YOLO26 preentrenados?

Los modelos de clasificación YOLO26 preentrenados se pueden encontrar en la sección Modelos. Modelos como yolo26n-cls.pt, yolo26s-cls.pt, yolo26m-cls.pt, etc., están preentrenados en el conjunto de datos ImageNet y pueden descargarse y usarse fácilmente para diversas tareas de clasificación de imágenes.

¿Cómo puedo exportar un modelo YOLO26 entrenado a diferentes formatos?

Puedes exportar un modelo YOLO26 entrenado a varios formatos utilizando comandos de Python o de la CLI. Por ejemplo, para exportar un modelo al 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 ver opciones detalladas de exportación, consulta la página de Exportación.

¿Cómo valido un modelo de clasificación YOLO26 entrenado?

Para validar la precisión de un modelo entrenado en un conjunto de datos como MNIST160, puedes usar los siguientes comandos de Python o de la 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 obtener más información, visita la sección Validación.