Clasificación de imágenes con Ultralytics YOLO#

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

La salida de un clasificador de imágenes es una única etiqueta de clase y una puntuación de confianza. La clasificación de imágenes resulta útil cuando solo necesitas saber a qué clase pertenece una imagen y no necesitas saber dónde están los objetos de esa clase ni cuál es su forma exacta.

Modelos#

A continuación se muestran los modelos YOLO26 Classify preentrenados con el conjunto de datos ImageNet.

Los modelos se descargan automáticamente desde la versión más reciente de Ultralytics al usarlos por primera vez.

• Los valores de acc corresponden a la precisión de los modelos en el conjunto de validación de ImageNet.
  Reprodúcelo con yolo classify val data=path/to/ImageNet device=0
• Velocidad media en imágenes de validación de ImageNet, con ONNX en CPU y TensorRT10 en una GPU NVIDIA T4.
  Reprodúcela con yolo classify val data=path/to/ImageNet batch=1 device=0|cpu
• Los valores de parámetros y FLOPs corresponden al modelo fusionado tras model.fuse(), que combina las capas Conv y BatchNorm. Los puntos de control preentrenados conservan la arquitectura de entrenamiento completa y pueden mostrar valores más altos.

Consulta la vista previa no publicada de YOLO27 para ver las velocidades preliminares de clasificación y los tamaños de los modelos.

Entrenar#

Entrena YOLO26n-cls con el conjunto de datos MNIST160 durante 100 épocas con un tamaño de imagen de 64. Consulta la página de Configuración para ver la lista completa de argumentos disponibles.

from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n-cls.yaml")  # Crea un modelo nuevo a partir de YAML
model = YOLO("yolo26n-cls.pt")  # Carga un modelo preentrenado (recomendado para el entrenamiento)
model = YOLO("yolo26n-cls.yaml").load("yolo26n-cls.pt")  # Crea el modelo a partir de YAML y transfiere los pesos

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

Consulta todos los detalles del modo train en la página Entrenar. También puedes entrenar modelos de clasificación con el entrenamiento en la nube de Ultralytics Platform.

Formato del conjunto de datos#

Encontrarás todos los detalles sobre el formato de los conjuntos de datos de clasificación YOLO en la Guía de conjuntos de datos. También puedes gestionar y etiquetar conjuntos de datos de clasificación con las herramientas de anotación de Ultralytics Platform.

Transformaciones personalizadas#

La clasificación de Ultralytics YOLO usa torchvision.transforms.RandomResizedCrop para el entrenamiento y torchvision.transforms.CenterCrop para la validación y la inferencia. Estas transformaciones basadas en recortes presuponen entradas cuadradas y pueden recortar regiones importantes de imágenes con relaciones de aspecto extremas. Para conservar la imagen completa, sustituye los recortes por torchvision.transforms.Resize, que cambia el tamaño a imgsz × imgsz en lugar de recortar, mediante un ClassificationDataset, ClassificationTrainer y 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)

        # Añade aquí tus transformaciones de entrenamiento personalizadas
        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),
            ]
        )

        # Añade aquí tus transformaciones de validación personalizadas
        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#

Valida la precisión de un modelo YOLO26n-cls entrenado. No se necesitan argumentos, ya que model conserva los atributos de entrenamiento data y sus argumentos: path/to/best.pt del ejemplo de entrenamiento valida con MNIST160. Los pesos oficiales registran una ruta al conjunto de datos de entrenamiento que no existe en tu equipo, así que recurren al valor predeterminado de la tarea imagenet10 y muestran una advertencia. Pasa data para validar con otro conjunto de datos.

from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n-cls.pt")  # carga un modelo oficial
model = YOLO("path/to/best.pt")  # cargar un modelo personalizado

# Valida el modelo
metrics = model.val()  # no hacen falta argumentos; se recuerdan el conjunto de datos y los ajustes
metrics.top1  # top1 accuracy
metrics.top5  # top5 accuracy

Predecir#

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

from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n-cls.pt")  # carga un modelo oficial
model = YOLO("path/to/best.pt")  # cargar un modelo personalizado

# Haz predicciones con el modelo
results = model("https://ultralytics.com/images/bus.jpg")  # haz una predicción sobre una imagen

# Accede a los resultados
for result in results:
    top1 = result.probs.top1  # ID de la clase predicha con mayor puntuación
    top1_conf = result.probs.top1conf  # confianza de la predicción con mayor puntuación
    top1_name = result.names[top1]  # nombre de la clase predicha con mayor puntuación

Consulta todos los detalles del modo predict en la página de predicción.

Resultados de salida#

La clasificación de imágenes devuelve un objeto Results por imagen. El campo principal de predicción es result.probs, que contiene el vector de probabilidades de clase y métodos auxiliares para las predicciones principales.

Para consultar los campos Results específicos de cada tarea, visita la sección resultados de predicción por tarea.

Exportar#

Exporta un modelo YOLO26n-cls a otro formato, como ONNX, CoreML, etc.

from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n-cls.pt")  # carga un modelo oficial
model = YOLO("path/to/best.pt")  # cargar un modelo personalizado

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

Los formatos de exportación disponibles para YOLO26-cls se muestran en la tabla siguiente. Puedes exportar a cualquier formato mediante el argumento format, por ejemplo, format='onnx' o format='engine'. Puedes predecir o validar directamente con los modelos exportados, por ejemplo, yolo predict model=yolo26n-cls.onnx. Cuando termine la exportación, se mostrarán ejemplos de uso para tu modelo.

nms=None usa de forma predeterminada salidas sin procesar para NMS externa. Establece nms=False para seleccionar una cabeza sin NMS disponible; los formatos no compatibles recurren a su ruta de salida nativa. Las entradas nms anteriores identifican los formatos que pueden integrar NMS con nms=True.

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

Preguntas frecuentes#