Clasificación de imágenes

La clasificación de imágenes es la más sencilla de las tres tareas e implica clasificar una imagen completa en una de un conjunto de 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 es útil cuando solo necesita saber a qué clase pertenece una imagen y no necesita saber dónde se encuentran los objetos de esa clase o cuál es su forma exacta.

Ver: Explore las tareas de Ultralytics YOLO: Clasificación de imágenes utilizando Ultralytics HUB

Modelos

Aquí se muestran los modelos de clasificación preentrenados de YOLO11. Los modelos Detect, Segment y Pose están preentrenados en el conjunto de datos COCO, mientras que los modelos Classify 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.

• acc los valores son las precisiones del modelo en el ImageNet conjunto de validación del conjunto de datos.
  Reproducir mediante yolo val classify data=path/to/ImageNet device=0
• Velocidad promediado sobre imágenes val de ImageNet usando un instancia de Amazon EC2 P4d .
  Reproducir mediante yolo val classify data=path/to/ImageNet batch=1 device=0|cpu

Entrenar

Entrena YOLO11n-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("yolo11n-cls.yaml")  # build a new model from YAML
model = YOLO("yolo11n-cls.pt")  # load a pretrained model (recommended for training)
model = YOLO("yolo11n-cls.yaml").load("yolo11n-cls.pt")  # build from YAML and transfer weights

# Train the model
results = model.train(data="mnist160", epochs=100, imgsz=64)

# Build a new model from YAML and start training from scratch
yolo classify train data=mnist160 model=yolo11n-cls.yaml epochs=100 imgsz=64

# Start training from a pretrained *.pt model
yolo classify train data=mnist160 model=yolo11n-cls.pt epochs=100 imgsz=64

# Build a new model from YAML, transfer pretrained weights to it and start training
yolo classify train data=mnist160 model=yolo11n-cls.yaml pretrained=yolo11n-cls.pt 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("yolo11n-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 dataset

El formato del conjunto de datos de clasificación YOLO se puede encontrar detallado en la Guía del conjunto de datos.

Val

Validar el modelo YOLO11n-cls entrenado precisión en el dataset MNIST160. No se necesitan argumentos, ya que model conserva su entrenamiento data y argumentos como atributos del modelo.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n-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

yolo classify val model=yolo11n-cls.pt  # val official model
yolo classify val model=path/to/best.pt # val custom model

Predecir

Utiliza un modelo YOLO11n-cls entrenado para ejecutar predicciones en imágenes.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n-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

yolo classify predict model=yolo11n-cls.pt source='https://ultralytics.com/images/bus.jpg'  # predict with official model
yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predict with custom model

Ver detalles completos del predict modo en la Predecir página.

Exportar

Exporta un modelo YOLO11n-cls a un formato diferente como ONNX, CoreML, etc.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n-cls.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom trained model

# Export the model
model.export(format="onnx")

yolo export model=yolo11n-cls.pt format=onnx  # export official model
yolo export model=path/to/best.pt format=onnx # export custom trained model

Los formatos de exportación disponibles para YOLO11-cls se encuentran en la tabla a continuación. Puedes exportar a cualquier formato utilizando el format argumento, por ejemplo: format='onnx' o format='engine'. Puedes predecir o validar directamente en modelos exportados, es decir, yolo predict model=yolo11n-cls.onnxDespués de que finalice la exportación, se mostrarán ejemplos de uso para su modelo.

Ver detalles completos del export detalles en la Exportar página.

Preguntas frecuentes

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

Los modelos YOLO11, como yolo11n-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 conocer 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 YOLO11 para la clasificación de imágenes?

Para entrenar un modelo YOLO11, puedes usar comandos de python o de la CLI. Por ejemplo, para entrenar un modelo yolo11n-cls en el dataset MNIST160 durante 100 épocas con un tamaño de imagen de 64:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n-cls.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="mnist160", epochs=100, imgsz=64)

yolo classify train data=mnist160 model=yolo11n-cls.pt epochs=100 imgsz=64

Para obtener más opciones de configuración, visita la página de Configuración.

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

Los modelos de clasificación YOLO11 preentrenados se pueden encontrar en la Modelos sección. Modelos como yolo11n-cls.pt, yolo11s-cls.pt, yolo11m-cls.pt, etc., están preentrenados en el ImageNet dataset y se pueden descargar y utilizar fácilmente para diversas tareas de clasificación de imágenes.

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

Puedes exportar un modelo YOLO11 entrenado a varios formatos utilizando comandos de python o de la CLI. Por ejemplo, para exportar un modelo a formato ONNX:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n-cls.pt")  # load the trained model

# Export the model to ONNX
model.export(format="onnx")

yolo export model=yolo11n-cls.pt format=onnx # export the trained model to ONNX format

Para obtener opciones de exportación detalladas, consulta la página de Exportar.

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

Para validar la precisión de un modelo entrenado en un dataset como MNIST160, puedes utilizar los siguientes comandos de python o de la CLI:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo11n-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

yolo classify val model=yolo11n-cls.pt # validate the trained model

Para obtener más información, visita la sección de Validar.

📅 Creado hace 1 año ✏️ Actualizado hace 26 días

Comentarios