Link to this sectionClasificación de imágenes#

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

El resultado de un clasificador de imágenes es una única etiqueta de clase 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 necesitas saber dónde están ubicados los objetos de esa clase ni cuál es su forma exacta.

Link to this sectionModelos#

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, los modelos semánticos están preentrenados en Cityscapes, y 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 durante el primer uso.

• Los valores acc son las precisiones del modelo en el conjunto de validación de ImageNet.
  Reproduce esto mediante 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 mediante 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 puntos de control preentrenados conservan la arquitectura de entrenamiento completa y pueden mostrar recuentos más altos.

Link to this sectionEntrenar#

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):
        """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="imagenet1000", trainer=CustomizedTrainer, epochs=10, imgsz=224, batch=64)
model.val(data="imagenet1000", validator=CustomizedValidator, imgsz=224, batch=64)

Link to this sectionFormato del conjunto de datos#

El formato del conjunto de datos de clasificación de YOLO se puede encontrar en detalle en la Guía de conjuntos de datos. Los conjuntos de datos de clasificación también se pueden gestionar y etiquetar en la Plataforma Ultralytics.

Link to this sectionValidar#

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 de entrenamiento y los 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

Link to this sectionPredecir#

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

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

Link to this sectionResultado de la salida#

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 probabilidad de clase y ayudantes para las predicciones principales.

Para ver los campos de Results específicos de cada tarea, consulta la sección Resultados de predicción por tarea.

Link to this sectionExportar#

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 de YOLO26-cls disponibles se encuentran en la tabla a continuación. Puedes exportar a cualquier formato usando el argumento format, es decir, format='onnx' o format='engine'. Puedes predecir o validar directamente en modelos exportados, es decir, yolo predict model=yolo26n-cls.onnx. Se muestran ejemplos de uso para tu modelo una vez que se completa la exportación.

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

Link to this sectionFAQ#

Link to this section¿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 toda una imagen junto con una puntuación de confianza. Esto es particularmente útil para aplicaciones donde basta con saber la clase específica de una imagen, en lugar de identificar la ubicación o la forma de los objetos dentro de ella.

Link to this section¿Cómo entreno un modelo YOLO26 para la clasificación de imágenes?#

Para entrenar un modelo YOLO26, puedes usar Python o comandos de 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 obtener más opciones de configuración, visita la página de Configuración.

Link to this section¿Dónde puedo encontrar modelos de clasificación YOLO26 preentrenados?#

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

Link to this section¿Cómo puedo exportar un modelo YOLO26 entrenado a diferentes formatos?#

Puedes exportar un modelo YOLO26 entrenado a varios formatos utilizando Python o comandos de 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 obtener opciones de exportación detalladas, consulta la página de Exportar.

Link to this section¿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 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 Validar.