Python Utilización

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

Observa: Dominio de Ultralytics YOLO: Python

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

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")

Tren

El modo Entrenar 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 consiste en optimizar los parámetros del modelo para que pueda predecir con precisión las clases y ubicaciones de los objetos en una imagen.

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 trenes

Val

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

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")

Val Ejemplos

Predecir

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

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()

Predecir Ejemplos

Exportar

El modo de exportación se utiliza para exportar un modelo YOLO a un formato que pueda utilizarse para su despliegue. 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 despliega el modelo en entornos de producción.

from ultralytics import YOLO

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

from ultralytics import YOLO

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

Ejemplos de exportación

Pista

El modo Track se utiliza para el seguimiento de objetos en tiempo real utilizando un modelo YOLO . En este modo, el modelo se carga desde un archivo de puntos de control, y el usuario puede proporcionar un flujo de vídeo en directo para realizar el seguimiento de objetos en tiempo real. Este modo es útil para aplicaciones como los sistemas de vigilancia o los coches autoconducidos.

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 vías

Punto de referencia

Modo Benchmark se utiliza para perfilar la velocidad y precisión de varios formatos de exportación para YOLO. Los puntos de referencia 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 (para clasificación), y el tiempo de inferencia en milisegundos por imagen en varios formatos de exportación como ONNX, OpenVINOTensorRT 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 en función de sus requisitos de velocidad y precisión.

from ultralytics.utils.benchmarks import benchmark

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

Ejemplos de puntos de referencia

Uso de formadores

En YOLO sirve de envoltorio 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.

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 Trainers para que admita tareas personalizadas o explore ideas de investigación y desarrollo. El diseño modular de Ultralytics YOLO le permite adaptar el marco a sus necesidades específicas, tanto si está trabajando en una nueva tarea de visión por ordenador como si está ajustando modelos existentes para mejorar su rendimiento.

Tutoriales de personalización

PREGUNTAS FRECUENTES

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

Integrar Ultralytics YOLO en sus proyectos Python es sencillo. Puede cargar un modelo preentrenado o entrenar un nuevo modelo desde cero. He aquí 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()

Vea ejemplos más detallados en nuestra sección Modo Predecir.

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

Ultralytics YOLO ofrece varios modos para adaptarse a diferentes flujos de trabajo de aprendizaje automático. Entre ellos se incluyen:

• Tren: Entrena un modelo utilizando conjuntos de datos personalizados.
• Val: Valida el rendimiento del modelo en un conjunto de validación.
• Predecir: Realiza predicciones sobre nuevas imágenes o secuencias de vídeo.
• Exportar: Exporta modelos a varios formatos como ONNX y TensorRT.
• Pista: Seguimiento de objetos en tiempo real en secuencias de vídeo.
• Referencia: Compara el rendimiento del modelo con diferentes configuraciones.

Cada modo está diseñado para ofrecer funcionalidades completas para las distintas fases de desarrollo e implantación de modelos.

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

Para entrenar un modelo YOLO personalizado, es necesario especificar el conjunto de datos y otros hiperparámetros. He aquí 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 más detalles sobre la formación y enlaces a ejemplos de uso, visite nuestra página Modo Tren.

¿Cómo se exportan los modelos YOLO para su despliegue?

Exportar modelos YOLO en un formato adecuado para su despliegue es sencillo con la herramienta 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 sobre el 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. Tras el entrenamiento, puede 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")

Consulta la página Modo Val para ver ejemplos detallados y su uso.

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

Comentarios