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 se encuentran los objetos de esa clase ni cuál es su forma exacta.

Modelos#

Aquí se muestran los modelos Classify preentrenados de YOLO26. Los modelos Detect, Segment y Pose están preentrenados con el conjunto de datos COCO, los modelos Semantic están preentrenados con Cityscapes y los modelos Classify están preentrenados con el conjunto de datos ImageNet.

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

• Los valores de acc son las precisiones de los modelos en el conjunto de validación de ImageNet.
  Reprodúcelo con yolo val classify data=path/to/ImageNet device=0
• Speed es la velocidad media calculada sobre imágenes de validación de ImageNet usando una instancia Amazon EC2 P4d.
  Reprodúcelo con yolo val classify data=path/to/ImageNet batch=1 device=0|cpu
• Los valores de Params y FLOPs corresponden al modelo fusionado después de model.fuse(), que combina las capas Conv y BatchNorm. Los checkpoints preentrenados conservan la arquitectura completa de entrenamiento y pueden mostrar recuentos superiores.

Consulta la vista previa inédita de YOLO27 para ver la velocidad preliminar de clasificación y los tamaños de los modelos.

Entrenar#

Entrena YOLO26n-cls en el conjunto de datos MNIST160 durante 100 épocas con un tamaño de imagen de 64. Para consultar la lista completa de argumentos disponibles, visita 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):
        """Build a customized dataset for classification standalone validation (no augmentation)."""
        return CustomizedDataset(root=img_path, args=self.args, augment=False, prefix=self.args.split)

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)

Formato del conjunto de datos#

El formato de los conjuntos de datos de clasificación de YOLO se explica detalladamente en la Guía de conjuntos de datos. Los conjuntos de datos de clasificación también se pueden gestionar y etiquetar con las herramientas de anotación de Ultralytics Platform.

Val#

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

Utiliza un modelo YOLO26n-cls entrenado para ejecutar predicciones sobre 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

# Access the results
for result in results:
    top1 = result.probs.top1  # top predicted class ID
    top1_conf = result.probs.top1conf  # top prediction confidence
    top1_name = result.names[top1]  # top predicted class name

Consulta todos los detalles del modo predict en la página Predecir.

Salida de resultados#

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

Para consultar los campos específicos de la tarea de Results en todas las tareas, visita la sección Resultados de predicción por tarea.

Exportar#

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 muestran en la tabla siguiente. Puedes exportar a cualquier formato utilizando el argumento format, es decir, format='onnx' o format='engine'. Puedes predecir o validar directamente con los modelos exportados, es decir, yolo predict model=yolo26n-cls.onnx. Una vez finalizada la exportación, se muestran ejemplos de uso para tu modelo.

nms=None se establece por defecto en salidas sin procesar para la NMS externa. Configura nms=False para seleccionar una cabeza libre de NMS disponible; los formatos no compatibles recurren a su ruta de salida nativa. Las entradas nms anteriores identifican los formatos que pueden incrustar la NMS con nms=True.

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

Preguntas frecuentes#