Ir al contenido

Clasificación de imágenes

Ejemplos de 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

Consejo

Los modelos de clasificación YOLO11 utilizan el -cls sufijo, p. ej. yolo11n-cls.pt y están pre-entrenados en ImageNet.

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.

Modelo tamaño
(píxeles)
acc
top1
acc
top5
Velocidad
CPU ONNX
(ms)
Velocidad
T4 TensorRT10
(ms)
parámetros
(M)
FLOPs
(B) a 224
YOLO11n-cls 224 70.0 89.4 5.0 ± 0.3 1.1 ± 0.0 1.6 0.5
YOLO11s-cls 224 75.4 92.7 7.9 ± 0.2 1.3 ± 0.0 5.5 1.6
YOLO11m-cls 224 77.3 93.9 17.2 ± 0.4 2.0 ± 0.0 10.4 5.0
YOLO11l-cls 224 78.3 94.3 23.2 ± 0.3 2.8 ± 0.0 12.9 6.2
YOLO11x-cls 224 79.5 94.9 41.4 ± 0.9 3.8 ± 0.0 28.4 13.7
  • 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.

Ejemplo

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

Consejo

La clasificación Ultralytics YOLO utiliza torchvision.transforms.RandomResizedCrop para entrenamiento y torchvision.transforms.CenterCrop para la validación y la inferencia. Estas transformaciones basadas en el recorte asumen entradas cuadradas y pueden recortar inadvertidamente regiones importantes de imágenes con relaciones de aspecto extremas, lo que podría causar la pérdida de información visual crítica durante el entrenamiento. Para preservar la imagen completa manteniendo sus proporciones, considere la posibilidad de utilizar torchvision.transforms.Resize en lugar de transformar los recortes.

Puede implementar esto personalizando su canalización de aumento a través de un ClassificationDataset y ClassificationTrainer.

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.

Ejemplo

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

Consejo

Como se mencionó en el sección de entrenamiento, puede manejar relaciones de aspecto extremas durante el entrenamiento utilizando un ClassificationTrainer. Debe aplicar el mismo enfoque para obtener resultados de validación consistentes implementando un ClassificationValidator al llamar al val() método. Consulte el ejemplo de código completo en el sección de entrenamiento para obtener detalles sobre la implementación.

Predecir

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

Ejemplo

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.

Ejemplo

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.

Formato format Argumento Modelo Metadatos Argumentos
PyTorch - yolo11n-cls.pt -
TorchScript torchscript yolo11n-cls.torchscript imgsz, half, dynamic, optimize, nms, batch, device
ONNX onnx yolo11n-cls.onnx imgsz, half, dynamic, simplify, opset, nms, batch, device
OpenVINO openvino yolo11n-cls_openvino_model/ imgsz, half, dynamic, int8, nms, batch, data, fraction, device
TensorRT engine yolo11n-cls.engine imgsz, half, dynamic, simplify, workspace, int8, nms, batch, data, fraction, device
CoreML coreml yolo11n-cls.mlpackage imgsz, half, int8, nms, batch, device
TF SavedModel saved_model yolo11n-cls_saved_model/ imgsz, keras, int8, nms, batch, device
TF GraphDef pb yolo11n-cls.pb imgsz, batch, device
TF Lite tflite yolo11n-cls.tflite imgsz, half, int8, nms, batch, data, fraction, device
TF Edge TPU edgetpu yolo11n-cls_edgetpu.tflite imgsz, device
TF.js tfjs yolo11n-cls_web_model/ imgsz, half, int8, nms, batch, device
PaddlePaddle paddle yolo11n-cls_paddle_model/ imgsz, batch, device
MNN mnn yolo11n-cls.mnn imgsz, batch, int8, half, device
NCNN ncnn yolo11n-cls_ncnn_model/ imgsz, half, batch, device
IMX500 imx yolo11n-cls_imx_model/ imgsz, int8, data, fraction, device
RKNN rknn yolo11n-cls_rknn_model/ imgsz, batch, name, device

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:

Ejemplo

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:

Ejemplo

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:

Ejemplo

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 6 días

Comentarios