Ir al contenido

Uso de Python

¡Bienvenido a la documentación de uso de Ultralytics YOLO con python! Esta guía está diseñada para ayudarte a integrar sin problemas Ultralytics YOLO en tus proyectos de python para la detección de objetos, la segmentación y la clasificación. Aquí, aprenderás a cargar y utilizar modelos preentrenados, a entrenar nuevos modelos y a realizar predicciones en imágenes. La interfaz de python, fácil de usar, es un recurso valioso para cualquiera que desee incorporar YOLO a sus proyectos de python, permitiéndote implementar rápidamente capacidades avanzadas de detección de objetos. ¡Empecemos!



Ver: Dominando Ultralytics YOLO: Python

Por ejemplo, los usuarios pueden cargar un modelo, entrenarlo, evaluar su rendimiento en un conjunto de validación e incluso exportarlo a formato ONNX con sólo unas pocas líneas de código.

Python

from ultralytics import YOLO

# Create a new YOLO model from scratch
model = YOLO("yolo11n.yaml")

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

# Train the model using the 'coco8.yaml' dataset for 3 epochs
results = model.train(data="coco8.yaml", epochs=3)

# Evaluate the model's performance on the validation set
results = model.val()

# Perform object detection on an image using the model
results = model("https://ultralytics.com/images/bus.jpg")

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

Entrenar

El modo de entrenamiento se utiliza para entrenar un modelo YOLO en un conjunto de datos personalizado. En este modo, el modelo se entrena utilizando el conjunto de datos y los hiperparámetros especificados. El proceso de entrenamiento implica la optimización de los parámetros del modelo para que pueda predecir con precisión las clases y ubicaciones de los objetos en una imagen.

Entrenar

from ultralytics import YOLO

model = YOLO("yolo11n.pt")  # pass any model type
results = model.train(epochs=5)

from ultralytics import YOLO

model = YOLO("yolo11n.yaml")
results = model.train(data="coco8.yaml", epochs=5)

model = YOLO("last.pt")
results = model.train(resume=True)

Ejemplos de Train

Val

El modo Val se utiliza para validar un modelo YOLO después de haber sido entrenado. En este modo, el modelo se evalúa en un conjunto de validación para medir su precisión y rendimiento de generalización. Este modo se puede utilizar para ajustar los hiperparámetros del modelo para mejorar su rendimiento.

Val

from ultralytics import YOLO

# Load a YOLO model
model = YOLO("yolo11n.yaml")

# Train the model
model.train(data="coco8.yaml", epochs=5)

# Validate on training data
model.val()

from ultralytics import YOLO

# Load a YOLO model
model = YOLO("yolo11n.yaml")

# Train the model
model.train(data="coco8.yaml", epochs=5)

# Validate on separate data
model.val(data="path/to/separate/data.yaml")

Ejemplos de Val

Predecir

El modo de predicción se utiliza para realizar predicciones utilizando un modelo YOLO entrenado en nuevas imágenes o videos. En este modo, el modelo se carga desde un archivo de punto de control y el usuario puede proporcionar imágenes o videos para realizar la inferencia. El modelo predice las clases y ubicaciones de los objetos en las imágenes o videos de entrada.

Predecir

import cv2
from PIL import Image

from ultralytics import YOLO

model = YOLO("model.pt")
# accepts all formats - image/dir/Path/URL/video/PIL/ndarray. 0 for webcam
results = model.predict(source="0")
results = model.predict(source="folder", show=True)  # Display preds. Accepts all YOLO predict arguments

# from PIL
im1 = Image.open("bus.jpg")
results = model.predict(source=im1, save=True)  # save plotted images

# from ndarray
im2 = cv2.imread("bus.jpg")
results = model.predict(source=im2, save=True, save_txt=True)  # save predictions as labels

# from list of PIL/ndarray
results = model.predict(source=[im1, im2])

# results would be a list of Results object including all the predictions by default
# but be careful as it could occupy a lot memory when there're many images,
# especially the task is segmentation.
# 1. return as a list
results = model.predict(source="folder")

# results would be a generator which is more friendly to memory by setting stream=True
# 2. return as a generator
results = model.predict(source=0, stream=True)

for result in results:
    # Detection
    result.boxes.xyxy  # box with xyxy format, (N, 4)
    result.boxes.xywh  # box with xywh format, (N, 4)
    result.boxes.xyxyn  # box with xyxy format but normalized, (N, 4)
    result.boxes.xywhn  # box with xywh format but normalized, (N, 4)
    result.boxes.conf  # confidence score, (N, 1)
    result.boxes.cls  # cls, (N, 1)

    # Segmentation
    result.masks.data  # masks, (N, H, W)
    result.masks.xy  # x,y segments (pixels), List[segment] * N
    result.masks.xyn  # x,y segments (normalized), List[segment] * N

    # Classification
    result.probs  # cls prob, (num_class, )

# Each result is composed of torch.Tensor by default,
# in which you can easily use following functionality:
result = result.cuda()
result = result.cpu()
result = result.to("cpu")
result = result.numpy()

Ejemplos de Predict

Exportar

El modo de exportación se utiliza para exportar un modelo YOLO a un formato que se pueda utilizar para su implementación. En este modo, el modelo se convierte a un formato que puede ser utilizado por otras aplicaciones de software o dispositivos de hardware. Este modo es útil cuando se implementa el modelo en entornos de producción.

Exportar

Exporte un modelo YOLO oficial a ONNX con tamaño de lote y tamaño de imagen dinámicos. 

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
model.export(format="onnx", dynamic=True)

Exportar un modelo oficial de YOLO a TensorRT en device=0 para la aceleración en dispositivos CUDA. 

from ultralytics import YOLO

model = YOLO("yolo11n.pt")
model.export(format="engine", device=0)

Ejemplos de Export

Seguimiento

El modo de seguimiento se utiliza para rastrear objetos en tiempo real utilizando un modelo YOLO. En este modo, el modelo se carga desde un archivo de punto de control y el usuario puede proporcionar una transmisión de video en vivo para realizar el seguimiento de objetos en tiempo real. Este modo es útil para aplicaciones como sistemas de vigilancia o coches autónomos.

Seguimiento

from ultralytics import YOLO

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

# Track with the model
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")

Ejemplos de seguimiento

Benchmark

Modo de evaluación comparativa se utiliza para perfilar la velocidad y la precisión de varios formatos de exportación para YOLO. Los benchmarks proporcionan información sobre el tamaño del formato exportado, su mAP50-95 métricas (para la detección y segmentación de objetos) o accuracy_top5 métricas (para clasificación) y el tiempo de inferencia en milisegundos por imagen en varios formatos de exportación como ONNX, OpenVINO, TensorRT y otros. Esta información puede ayudar a los usuarios a elegir el formato de exportación óptimo para su caso de uso específico, basándose en sus requisitos de velocidad y precisión.

Benchmark

Realiza pruebas de rendimiento de un modelo YOLO oficial en todos los formatos de exportación. 

from ultralytics.utils.benchmarks import benchmark

# Benchmark
benchmark(model="yolo11n.pt", data="coco8.yaml", imgsz=640, half=False, device=0)

Ejemplos de evaluación comparativa

Uso de Entrenadores

El YOLO La clase model sirve como un contenedor de alto nivel para las clases Trainer. Cada tarea YOLO tiene su propio entrenador, que hereda de BaseTrainer. Esta arquitectura permite una mayor flexibilidad y personalización en su flujos de trabajo de aprendizaje automático.

Ejemplo de Detection Trainer

from ultralytics.models.yolo import DetectionPredictor, DetectionTrainer, DetectionValidator

# trainer
trainer = DetectionTrainer(overrides={})
trainer.train()
trained_model = trainer.best

# Validator
val = DetectionValidator(args=...)
val(model=trained_model)

# predictor
pred = DetectionPredictor(overrides={})
pred(source=SOURCE, model=trained_model)

# resume from last weight
overrides["resume"] = trainer.last
trainer = DetectionTrainer(overrides=overrides)

Puede personalizar fácilmente los Trainers para admitir tareas personalizadas o explorar ideas de investigación y desarrollo. El diseño modular de Ultralytics YOLO le permite adaptar el framework a sus necesidades específicas, ya sea que esté trabajando en una nueva tarea de visión artificial o ajustando los modelos existentes para obtener un mejor rendimiento.

Tutoriales de personalización

Preguntas frecuentes

¿Cómo puedo integrar YOLO en mi proyecto de python para la detección de objetos?

Integrar Ultralytics YOLO en tus proyectos de Python es sencillo. Puedes cargar un modelo preentrenado o entrenar uno nuevo desde cero. Aquí te mostramos cómo empezar:

from ultralytics import YOLO

# Load a pretrained YOLO model
model = YOLO("yolo11n.pt")

# Perform object detection on an image
results = model("https://ultralytics.com/images/bus.jpg")

# Visualize the results
for result in results:
    result.show()

Consulte ejemplos más detallados en nuestra sección de Modo de Predicción.

¿Cuáles son los diferentes modos disponibles en YOLO?

Ultralytics YOLO proporciona varios modos para atender a diferentes flujos de trabajo de aprendizaje automático. Estos incluyen:

  • Entrenar: Entrena un modelo utilizando conjuntos de datos personalizados.
  • Validar: Valida el rendimiento del modelo en un conjunto de validación.
  • Predecir: Realiza predicciones sobre nuevas imágenes o flujos de video.
  • Exportar: Exporte modelos a varios formatos como ONNX y TensorRT.
  • Seguimiento: Seguimiento de objetos en tiempo real en flujos de video.
  • Benchmark: Evalúa el rendimiento del modelo en diferentes configuraciones.

Cada modo está diseñado para proporcionar funcionalidades integrales para diferentes etapas del desarrollo e implementación de modelos.

¿Cómo entreno un modelo YOLO personalizado utilizando mi propio conjunto de datos?

Para entrenar un modelo YOLO personalizado, debes especificar tu conjunto de datos y otros hiperparámetros. Aquí tienes un ejemplo rápido:

from ultralytics import YOLO

# Load the YOLO model
model = YOLO("yolo11n.yaml")

# Train the model with custom dataset
model.train(data="path/to/your/dataset.yaml", epochs=10)

Para obtener más detalles sobre el entrenamiento e hipervínculos a ejemplos de uso, visite nuestra página de Modo de Entrenamiento.

¿Cómo puedo exportar modelos YOLO para su implementación?

Exportar modelos YOLO en un formato adecuado para la implementación es sencillo con la export función. Por ejemplo, puede exportar un modelo al formato ONNX:

from ultralytics import YOLO

# Load the YOLO model
model = YOLO("yolo11n.pt")

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

Para conocer las distintas opciones de exportación, consulte la documentación del Modo de Exportación.

¿Puedo validar mi modelo YOLO en diferentes conjuntos de datos?

Sí, es posible validar los modelos YOLO en diferentes conjuntos de datos. Después del entrenamiento, puedes utilizar el modo de validación para evaluar el rendimiento:

from ultralytics import YOLO

# Load a YOLO model
model = YOLO("yolo11n.yaml")

# Train the model
model.train(data="coco8.yaml", epochs=5)

# Validate the model on a different dataset
model.val(data="path/to/separate/data.yaml")

Consulte la página del Modo de Validación para obtener ejemplos detallados y su uso.



📅 Creado hace 1 año ✏️ Actualizado hace 5 meses
glenn-jocher jk4e leonnil RizwanMunawar UltralyticsAssistant MatthewNoyce IvorZhu331 AyushExel Laughing-q

Comentarios