You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
226 lines
14 KiB
226 lines
14 KiB
--- |
|
comments: true |
|
description: Descubra cómo utilizar el modo predictivo de YOLOv8 para diversas tareas. Aprenda acerca de diferentes fuentes de inferencia como imágenes, videos y formatos de datos. |
|
keywords: Ultralytics, YOLOv8, modo predictivo, fuentes de inferencia, tareas de predicción, modo de transmisión, procesamiento de imágenes, procesamiento de videos, aprendizaje automático, IA |
|
--- |
|
|
|
# Predicción del Modelo con YOLO de Ultralytics |
|
|
|
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ecosistema de YOLO de Ultralytics e integraciones"> |
|
|
|
## Introducción |
|
|
|
En el mundo del aprendizaje automático y la visión por computadora, el proceso de dar sentido a los datos visuales se denomina 'inferencia' o 'predicción'. YOLOv8 de Ultralytics ofrece una característica poderosa conocida como **modo predictivo** que está diseñada para inferencias de alto rendimiento y en tiempo real en una amplia gama de fuentes de datos. |
|
|
|
<p align="center"> |
|
<br> |
|
<iframe width="720" height="405" src="https://www.youtube.com/embed/QtsI0TnwDZs?si=ljesw75cMO2Eas14" |
|
title="Reproductor de video de YouTube" frameborder="0" |
|
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" |
|
allowfullscreen> |
|
</iframe> |
|
<br> |
|
<strong>Ver:</strong> Cómo Extraer las Salidas del Modelo YOLOv8 de Ultralytics para Proyectos Personalizados. |
|
</p> |
|
|
|
## Aplicaciones en el Mundo Real |
|
|
|
| Manufactura | Deportes | Seguridad | |
|
|:-----------------------------------------------------------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------------------------------------------------------:|:-------------------------------------------------------------------------------------------------------------------------------------:| |
|
|  |  |  | |
|
| Detección de Repuestos de Vehículos | Detección de Jugadores de Fútbol | Detección de Caídas de Personas | |
|
|
|
## ¿Por Qué Utilizar YOLO de Ultralytics para la Inferencia? |
|
|
|
Estas son algunas razones para considerar el modo predictivo de YOLOv8 para sus necesidades de inferencia: |
|
|
|
- **Versatilidad:** Capaz de realizar inferencias en imágenes, videos e incluso transmisiones en vivo. |
|
- **Rendimiento:** Diseñado para procesamiento en tiempo real y de alta velocidad sin sacrificar precisión. |
|
- **Facilidad de Uso:** Interfaces de Python y CLI intuitivas para una rápida implementación y pruebas. |
|
- **Alta Personalización:** Diversos ajustes y parámetros para afinar el comportamiento de inferencia del modelo según sus requisitos específicos. |
|
|
|
### Características Principales del Modo Predictivo |
|
|
|
El modo predictivo de YOLOv8 está diseñado para ser robusto y versátil, y cuenta con: |
|
|
|
- **Compatibilidad con Múltiples Fuentes de Datos:** Ya sea que sus datos estén en forma de imágenes individuales, una colección de imágenes, archivos de video o transmisiones de video en tiempo real, el modo predictivo le tiene cubierto. |
|
- **Modo de Transmisión:** Utilice la función de transmisión para generar un generador eficiente de memoria de objetos `Results`. Active esto configurando `stream=True` en el método de llamada del predictor. |
|
- **Procesamiento por Lotes:** La capacidad de procesar múltiples imágenes o fotogramas de video en un solo lote, acelerando aún más el tiempo de inferencia. |
|
- **Amigable para la Integración:** Se integra fácilmente con pipelines de datos existentes y otros componentes de software, gracias a su API flexible. |
|
|
|
Los modelos YOLO de Ultralytics devuelven ya sea una lista de objetos `Results` de Python, o un generador de objetos `Results` de Python eficiente en memoria cuando se pasa `stream=True` al modelo durante la inferencia: |
|
|
|
!!! ejemplo "Predict" |
|
|
|
=== "Devolver una lista con `stream=False`" |
|
```python |
|
from ultralytics import YOLO |
|
|
|
# Cargar un modelo |
|
model = YOLO('yolov8n.pt') # modelo YOLOv8n preentrenado |
|
|
|
# Ejecutar inferencia por lotes en una lista de imágenes |
|
results = model(['im1.jpg', 'im2.jpg']) # devuelve una lista de objetos Results |
|
|
|
# Procesar lista de resultados |
|
for result in results: |
|
boxes = result.boxes # Objeto Boxes para salidas de bbox |
|
masks = result.masks # Objeto Masks para salidas de máscaras de segmentación |
|
keypoints = result.keypoints # Objeto Keypoints para salidas de postura |
|
probs = result.probs # Objeto Probs para salidas de clasificación |
|
``` |
|
|
|
=== "Devolver un generador con `stream=True`" |
|
```python |
|
from ultralytics import YOLO |
|
|
|
# Cargar un modelo |
|
model = YOLO('yolov8n.pt') # modelo YOLOv8n preentrenado |
|
|
|
# Ejecutar inferencia por lotes en una lista de imágenes |
|
results = model(['im1.jpg', 'im2.jpg'], stream=True) # devuelve un generador de objetos Results |
|
|
|
# Procesar generador de resultados |
|
for result in results: |
|
boxes = result.boxes # Objeto Boxes para salidas de bbox |
|
.masks = result.masks # Objeto Masks para salidas de máscaras de segmentación |
|
keypoints = result.keypoints # Objeto Keypoints para salidas de postura |
|
probs = result.probs # Objeto Probs para salidas de clasificación |
|
``` |
|
|
|
## Fuentes de Inferencia |
|
|
|
YOLOv8 puede procesar diferentes tipos de fuentes de entrada para la inferencia, como se muestra en la tabla a continuación. Las fuentes incluyen imágenes estáticas, transmisiones de video y varios formatos de datos. La tabla también indica si cada fuente se puede utilizar en modo de transmisión con el argumento `stream=True` ✅. El modo de transmisión es beneficioso para procesar videos o transmisiones en vivo ya que crea un generador de resultados en lugar de cargar todos los fotogramas en la memoria. |
|
|
|
!!! consejo "Consejo" |
|
|
|
Utilice `stream=True` para procesar videos largos o conjuntos de datos grandes para gestionar eficientemente la memoria. Cuando `stream=False`, los resultados de todos los fotogramas o puntos de datos se almacenan en la memoria, lo que puede aumentar rápidamente y causar errores de memoria insuficiente para entradas grandes. En contraste, `stream=True` utiliza un generador, que solo mantiene los resultados del fotograma o punto de datos actual en la memoria, reduciendo significativamente el consumo de memoria y previniendo problemas de falta de memoria. |
|
|
|
| Fuente | Argumento | Tipo | Notas | |
|
|---------------------|--------------------------------------------|----------------|---------------------------------------------------------------------------------------------------------------------------------| |
|
| imagen | `'image.jpg'` | `str` o `Path` | Archivo único de imagen. | |
|
| URL | `'https://ultralytics.com/images/bus.jpg'` | `str` | URL a una imagen. | |
|
| captura de pantalla | `'screen'` | `str` | Captura una captura de pantalla. | |
|
| PIL | `Image.open('im.jpg')` | `PIL.Image` | Formato HWC con canales RGB. | |
|
| OpenCV | `cv2.imread('im.jpg')` | `np.ndarray` | Formato HWC con canales BGR `uint8 (0-255)`. | |
|
| numpy | `np.zeros((640,1280,3))` | `np.ndarray` | Formato HWC con canales BGR `uint8 (0-255)`. | |
|
| torch | `torch.zeros(16,3,320,640)` | `torch.Tensor` | Formato BCHW con canales RGB `float32 (0.0-1.0)`. | |
|
| CSV | `'sources.csv'` | `str` o `Path` | Archivo CSV que contiene rutas a imágenes, videos o directorios. | |
|
| video ✅ | `'video.mp4'` | `str` o `Path` | Archivo de video en formatos como MP4, AVI, etc. | |
|
| directorio ✅ | `'path/'` | `str` o `Path` | Ruta a un directorio que contiene imágenes o videos. | |
|
| glob ✅ | `'path/*.jpg'` | `str` | Patrón glob para coincidir con múltiples archivos. Utilice el carácter `*` como comodín. | |
|
| YouTube ✅ | `'https://youtu.be/LNwODJXcvt4'` | `str` | URL a un video de YouTube. | |
|
| transmisión ✅ | `'rtsp://example.com/media.mp4'` | `str` | URL para protocolos de transmisión como RTSP, RTMP, TCP o una dirección IP. | |
|
| multi-transmisión ✅ | `'list.streams'` | `str` o `Path` | Archivo de texto `*.streams` con una URL de transmisión por fila, es decir, 8 transmisiones se ejecutarán con tamaño de lote 8. | |
|
|
|
A continuación se muestran ejemplos de código para usar cada tipo de fuente: |
|
|
|
!!! ejemplo "Fuentes de predicción" |
|
|
|
=== "imagen" |
|
Ejecute inferencia en un archivo de imagen. |
|
```python |
|
from ultralytics import YOLO |
|
|
|
# Cargar el modelo YOLOv8n preentrenado |
|
model = YOLO('yolov8n.pt') |
|
|
|
# Definir la ruta al archivo de imagen |
|
source = 'ruta/a/imagen.jpg' |
|
|
|
# Ejecutar inferencia en la fuente |
|
results = model(source) # lista de objetos Results |
|
``` |
|
|
|
=== "captura de pantalla" |
|
Ejecute inferencia en el contenido actual de la pantalla como captura de pantalla. |
|
```python |
|
from ultralytics import YOLO |
|
|
|
# Cargar el modelo YOLOv8n preentrenado |
|
model = YOLO('yolov8n.pt') |
|
|
|
# Definir captura de pantalla actual como fuente |
|
source = 'screen' |
|
|
|
# Ejecutar inferencia en la fuente |
|
results = model(source) # lista de objetos Results |
|
``` |
|
|
|
=== "URL" |
|
Ejecute inferencia en una imagen o video alojados remotamente a través de URL. |
|
```python |
|
from ultralytics import YOLO |
|
|
|
# Cargar el modelo YOLOv8n preentrenado |
|
model = YOLO('yolov8n.pt') |
|
|
|
# Definir URL remota de imagen o video |
|
source = 'https://ultralytics.com/images/bus.jpg' |
|
|
|
# Ejecutar inferencia en la fuente |
|
results = model(source) # lista de objetos Results |
|
``` |
|
|
|
=== "PIL" |
|
Ejecute inferencia en una imagen abierta con la Biblioteca de Imágenes de Python (PIL). |
|
```python |
|
from PIL import Image |
|
from ultralytics import YOLO |
|
|
|
# Cargar el modelo YOLOv8n preentrenado |
|
model = YOLO('yolov8n.pt') |
|
|
|
# Abrir una imagen usando PIL |
|
source = Image.open('ruta/a/imagen.jpg') |
|
|
|
# Ejecutar inferencia en la fuente |
|
results = model(source) # lista de objetos Results |
|
``` |
|
|
|
=== "OpenCV" |
|
Ejecute inferencia en una imagen leída con OpenCV. |
|
```python |
|
import cv2 |
|
from ultralytics import YOLO |
|
|
|
# Cargar el modelo YOLOv8n preentrenado |
|
model = YOLO('yolov8n.pt') |
|
|
|
# Leer una imagen usando OpenCV |
|
source = cv2.imread('ruta/a/imagen.jpg') |
|
|
|
# Ejecutar inferencia en la fuente |
|
results = model(source) # lista de objetos Results |
|
``` |
|
|
|
=== "numpy" |
|
Ejecute inferencia en una imagen representada como un array de numpy. |
|
```python |
|
import numpy as np |
|
from ultralytics import YOLO |
|
|
|
# Cargar el modelo YOLOv8n preentrenado |
|
model = YOLO('yolov8n.pt') |
|
|
|
# Crear un array aleatorio de numpy con forma HWC (640, 640, 3) con valores en rango [0, 255] y tipo uint8 |
|
source = np.random.randint(low=0, high=255, size=(640, 640, 3), dtype='uint8') |
|
|
|
# Ejecutar inferencia en la fuente |
|
results = model(source) # lista de objetos Results |
|
``` |
|
|
|
=== "torch" |
|
Ejecute inferencia en una imagen representada como un tensor de PyTorch. |
|
```python |
|
import torch |
|
from ultralytics import YOLO |
|
|
|
# Cargar el modelo YOLOv8n preentrenado |
|
model = YOLO('yolov8n.pt') |
|
|
|
# Crear un tensor aleatorio de torch con forma BCHW (1, 3, 640, 640) con valores en rango [0, 1] y tipo float32 |
|
source = torch.rand(1, 3, 640, 640, dtype=torch.float32) |
|
|
|
# Ejecutar inferencia en la fuente |
|
results = model(source) # lista de objetos Results
|
|
|