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 medianteyolo val classify data=path/to/ImageNet device=0
- Velocidad promediado sobre imágenes val de ImageNet usando un instancia de Amazon EC2 P4d .
Reproducir medianteyolo 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.onnx
Despué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.