HongChuang/ultralytics-ascend
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 3

Add Docs languages zh, es, ru, pt, fr, de, ja, ko (#6316)

Browse source 
Signed-off-by: Glenn Jocher <glenn.jocher@ultralytics.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
This commit is contained in:
Glenn Jocher 2023-11-13 18:18:31 +01:00 • committed by GitHub
parent e3a538bbde
commit 48e70f0921
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
144 changed files with 17632 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

94
docs/es/modes/benchmark.md Normal file
View file

@ -0,0 +1,94 @@
---
comments: true
description: Aprenda cómo perfilar la velocidad y exactitud de YOLOv8 en varios formatos de exportación; obtenga perspectivas sobre las métricas mAP50-95, accuracy_top5 y más.
keywords: Ultralytics, YOLOv8, benchmarking, perfilado de velocidad, perfilado de exactitud, mAP50-95, accuracy_top5, ONNX, OpenVINO, TensorRT, formatos de exportación YOLO
---
# Model Benchmarking con Ultralytics YOLO
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ecosistema e integraciones de Ultralytics YOLO">
## Introducción
Una vez que su modelo está entrenado y validado, el siguiente paso lógico es evaluar su rendimiento en varios escenarios del mundo real. El modo benchmark en Ultralytics YOLOv8 cumple con este propósito proporcionando un marco sólido para valorar la velocidad y exactitud de su modelo a través de una gama de formatos de exportación.
## ¿Por Qué Es Crucial el Benchmarking?
- **Decisiones Informadas:** Obtenga perspectivas sobre el equilibrio entre velocidad y precisión.
- **Asignación de Recursos:** Entienda cómo diferentes formatos de exportación se desempeñan en diferentes hardware.
- **Optimización:** Aprenda cuál formato de exportación ofrece el mejor rendimiento para su caso de uso específico.
- **Eficiencia de Costo:** Haga un uso más eficiente de los recursos de hardware basado en los resultados del benchmark.
### Métricas Clave en el Modo Benchmark
- **mAP50-95:** Para detección de objetos, segmentación y estimación de pose.
- **accuracy_top5:** Para clasificación de imágenes.
- **Tiempo de Inferencia:** Tiempo tomado para cada imagen en milisegundos.
### Formatos de Exportación Soportados
- **ONNX:** Para un rendimiento óptimo de CPU
- **TensorRT:** Para la máxima eficiencia de GPU
- **OpenVINO:** Para la optimización en hardware de Intel
- **CoreML, TensorFlow SavedModel y Más:** Para necesidades de despliegue diversas.
!!! tip "Consejo"
* Exporte a ONNX o OpenVINO para acelerar la velocidad de CPU hasta 3 veces.
* Exporte a TensorRT para acelerar la velocidad de GPU hasta 5 veces.
## Ejemplos de Uso
Ejecute benchmarks de YOLOv8n en todos los formatos de exportación soportados incluyendo ONNX, TensorRT, etc. Vea la sección de Argumentos a continuación para una lista completa de argumentos de exportación.
!!! example ""
=== "Python"
```python
from ultralytics.utils.benchmarks import benchmark
# Benchmark en GPU
benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0)
```
=== "CLI"
```bash
yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0
```
## Argumentos
Argumentos como `model`, `data`, `imgsz`, `half`, `device`, y `verbose` proporcionan a los usuarios la flexibilidad de ajustar los benchmarks a sus necesidades específicas y comparar el rendimiento de diferentes formatos de exportación con facilidad.
| Clave | Valor | Descripción |
|-----------|---------|----------------------------------------------------------------------------------------------------------|
| `model` | `None` | ruta al archivo del modelo, es decir, yolov8n.pt, yolov8n.yaml |
| `data` | `None` | ruta a YAML que referencia el conjunto de datos de benchmarking (bajo la etiqueta `val`) |
| `imgsz` | `640` | tamaño de imagen como escalar o lista (h, w), es decir, (640, 480) |
| `half` | `False` | cuantificación FP16 |
| `int8` | `False` | cuantificación INT8 |
| `device` | `None` | dispositivo en el que se ejecutará, es decir, dispositivo cuda=0 o dispositivo=0,1,2,3 o dispositivo=cpu |
| `verbose` | `False` | no continuar en caso de error (bool), o umbral de piso de valor (float) |
## Formatos de Exportación
Los benchmarks intentarán ejecutarse automáticamente en todos los posibles formatos de exportación a continuación.
| Formato | Argumento `format` | Modelo | Metadatos | Argumentos |
|--------------------------------------------------------------------|--------------------|---------------------------|-----------|-----------------------------------------------------|
| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - |
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` |
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` |
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` |
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` |
| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` |
| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` |
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` |
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` |
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` |
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` |
Vea los detalles completos de `export` en la página [Export](https://docs.ultralytics.com/modes/export/).

108
docs/es/modes/export.md Normal file
View file

@ -0,0 +1,108 @@
---
comments: true
description: Guía paso a paso sobre cómo exportar sus modelos YOLOv8 a varios formatos como ONNX, TensorRT, CoreML y más para su despliegue. ¡Explora ahora!.
keywords: YOLO, YOLOv8, Ultralytics, Exportación de modelos, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, exportar modelo
---
# Exportación de Modelos con Ultralytics YOLO
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ecosistema de Ultralytics YOLO e integraciones">
## Introducción
El objetivo final de entrenar un modelo es desplegarlo para aplicaciones en el mundo real. El modo exportación en Ultralytics YOLOv8 ofrece una gama versátil de opciones para exportar tu modelo entrenado a diferentes formatos, haciéndolo desplegable en varias plataformas y dispositivos. Esta guía integral pretende guiarte a través de los matices de la exportación de modelos, mostrando cómo lograr la máxima compatibilidad y rendimiento.
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/WbomGeoOT_k?si=aGmuyooWftA0ue9X"
title="Reproductor de vídeo 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 Exportar un Modelo Entrenado Personalizado de Ultralytics YOLOv8 y Ejecutar Inferencia en Vivo en la Webcam.
</p>
## ¿Por Qué Elegir el Modo Exportación de YOLOv8?
- **Versatilidad:** Exporta a múltiples formatos incluyendo ONNX, TensorRT, CoreML y más.
- **Rendimiento:** Acelera hasta 5 veces la velocidad en GPU con TensorRT y 3 veces en CPU con ONNX o OpenVINO.
- **Compatibilidad:** Hacer que tu modelo sea universalmente desplegable en numerosos entornos de hardware y software.
- **Facilidad de Uso:** Interfaz de línea de comandos simple y API de Python para una exportación de modelos rápida y sencilla.
### Características Clave del Modo de Exportación
Aquí tienes algunas de las funcionalidades destacadas:
- **Exportación con Un Solo Clic:** Comandos simples para exportar a diferentes formatos.
- **Exportación por Lotes:** Exporta modelos capaces de inferencia por lotes.
- **Inferencia Optimizada:** Los modelos exportados están optimizados para tiempos de inferencia más rápidos.
- **Vídeos Tutoriales:** Guías y tutoriales en profundidad para una experiencia de exportación fluida.
!!! tip "Consejo"
* Exporta a ONNX u OpenVINO para acelerar la CPU hasta 3 veces.
* Exporta a TensorRT para acelerar la GPU hasta 5 veces.
## Ejemplos de Uso
Exporta un modelo YOLOv8n a un formato diferente como ONNX o TensorRT. Consulta la sección Argumentos más abajo para una lista completa de argumentos de exportación.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Carga un modelo
model = YOLO('yolov8n.pt') # carga un modelo oficial
model = YOLO('path/to/best.pt') # carga un modelo entrenado personalizado
# Exporta el modelo
model.export(format='onnx')
```
=== "CLI"
```bash
yolo export model=yolov8n.pt format=onnx # exporta modelo oficial
yolo export model=path/to/best.pt format=onnx # exporta modelo entrenado personalizado
```
## Argumentos
Los ajustes de exportación para modelos YOLO se refieren a las diversas configuraciones y opciones utilizadas para guardar o exportar el modelo para su uso en otros entornos o plataformas. Estos ajustes pueden afectar el rendimiento del modelo, su tamaño y su compatibilidad con diferentes sistemas. Algunos ajustes comunes de exportación de YOLO incluyen el formato del archivo del modelo exportado (p. ej., ONNX, TensorFlow SavedModel), el dispositivo en el que se ejecutará el modelo (p. ej., CPU, GPU) y la presencia de características adicionales como máscaras o múltiples etiquetas por caja. Otros factores que pueden afectar el proceso de exportación incluyen la tarea específica para la que se está utilizando el modelo y los requisitos o limitaciones del entorno o plataforma objetivo. Es importante considerar y configurar cuidadosamente estos ajustes para asegurar que el modelo exportado está optimizado para el caso de uso previsto y se pueda utilizar eficazmente en el entorno objetivo.
| Llave | Valor | Descripción |
|-------------|-----------------|-----------------------------------------------------------------|
| `format` | `'torchscript'` | formato al que exportar |
| `imgsz` | `640` | tamaño de imagen como escalar o lista (h, w), p. ej. (640, 480) |
| `keras` | `False` | usu Keras para la exportación de TF SavedModel |
| `optimize` | `False` | TorchScript: optimizar para móvil |
| `half` | `False` | cuantificación FP16 |
| `int8` | `False` | cuantificación INT8 |
| `dynamic` | `False` | ONNX/TensorRT: ejes dinámicos |
| `simplify` | `False` | ONNX/TensorRT: simplificar modelo |
| `opset` | `None` | ONNX: versión de opset (opcional, por defecto la más reciente) |
| `workspace` | `4` | TensorRT: tamaño del espacio de trabajo (GB) |
| `nms` | `False` | CoreML: añadir NMS |
## Formatos de Exportación
Los formatos de exportación disponibles de YOLOv8 están en la tabla a continuación. Puedes exportar a cualquier formato usando el argumento `format`, por ejemplo, `format='onnx'` o `format='engine'`.
| Formato | Argumento `format` | Modelo | Metadatos | Argumentos |
|--------------------------------------------------------------------|--------------------|---------------------------|-----------|-----------------------------------------------------|
| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - |
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` |
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` |
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` |
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` |
| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` |
| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` |
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` |
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` |
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` |
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` |

73
docs/es/modes/index.md Normal file
View file

@ -0,0 +1,73 @@
---
comments: true
description: Desde el entrenamiento hasta el seguimiento, aprovecha al máximo YOLOv8 con Ultralytics. Obtén información y ejemplos para cada modo compatible incluyendo validación, exportación y evaluación comparativa.
keywords: Ultralytics, YOLOv8, Aprendizaje Automático, Detección de Objetos, Entrenamiento, Validación, Predicción, Exportación, Seguimiento, Benchmarking
---
# Modos de Ultralytics YOLOv8
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ecosistema Ultralytics YOLO e integraciones">
## Introducción
Ultralytics YOLOv8 no es solo otro modelo de detección de objetos; es un marco de trabajo versátil diseñado para cubrir todo el ciclo de vida de los modelos de aprendizaje automático, desde la ingesta de datos y el entrenamiento del modelo hasta la validación, implementación y seguimiento en el mundo real. Cada modo sirve para un propósito específico y está diseñado para ofrecerte la flexibilidad y eficiencia necesarias para diferentes tareas y casos de uso.
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/j8uQc0qB91s?si=dhnGKgqvs7nPgeaM"
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>Mira:</strong> Tutorial de Modos Ultralytics: Entrenar, Validar, Predecir, Exportar y Hacer Benchmarking.
</p>
### Modos a Primera Vista
Comprender los diferentes **modos** que soporta Ultralytics YOLOv8 es crítico para sacar el máximo provecho a tus modelos:
- **Modo Entrenar (Train)**: Afina tu modelo en conjuntos de datos personalizados o pre-cargados.
- **Modo Validar (Val)**: Un punto de control post-entrenamiento para validar el rendimiento del modelo.
- **Modo Predecir (Predict)**: Libera el poder predictivo de tu modelo en datos del mundo real.
- **Modo Exportar (Export)**: Prepara tu modelo para la implementación en varios formatos.
- **Modo Seguir (Track)**: Extiende tu modelo de detección de objetos a aplicaciones de seguimiento en tiempo real.
- **Modo Benchmark (Benchmark)**: Analiza la velocidad y precisión de tu modelo en diversos entornos de implementación.
Esta guía completa tiene como objetivo proporcionarte una visión general y conocimientos prácticos de cada modo, ayudándote a aprovechar todo el potencial de YOLOv8.
## [Entrenar (Train)](train.md)
El modo Entrenar se utiliza para entrenar un modelo YOLOv8 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 optimizar los parámetros del modelo para que pueda predecir con precisión las clases y ubicaciones de los objetos en una imagen.
[Ejemplos de Entrenamiento](train.md){ .md-button .md-button--primary}
## [Validar (Val)](val.md)
El modo Validar se usa para validar un modelo YOLOv8 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 usar para ajustar los hiperparámetros del modelo y mejorar su rendimiento.
[Ejemplos de Validación](val.md){ .md-button .md-button--primary}
## [Predecir (Predict)](predict.md)
El modo Predecir se utiliza para realizar predicciones usando un modelo YOLOv8 entrenado en imágenes o videos nuevos. 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 inferencias. El modelo predice las clases y ubicaciones de los objetos en las imágenes o videos de entrada.
[Ejemplos de Predicción](predict.md){ .md-button .md-button--primary}
## [Exportar (Export)](export.md)
El modo Exportar se utiliza para exportar un modelo YOLOv8 a un formato que se pueda usar para la 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 al implementar el modelo en entornos de producción.
[Ejemplos de Exportación](export.md){ .md-button .md-button--primary}
## [Seguir (Track)](track.md)
El modo Seguir se usa para rastrear objetos en tiempo real utilizando un modelo YOLOv8. En este modo, el modelo se carga desde un archivo de punto de control, y el usuario puede proporcionar un flujo de video en vivo para realizar seguimiento de objetos en tiempo real. Este modo es útil para aplicaciones como sistemas de vigilancia o coches autónomos.
[Ejemplos de Seguimiento](track.md){ .md-button .md-button--primary}
## [Benchmark (Benchmark)](benchmark.md)
El modo Benchmark se utiliza para perfilar la velocidad y precisión de varios formatos de exportación de YOLOv8. Los benchmarks proporcionan información sobre el tamaño del formato de exportación, sus métricas de `mAP50-95` (para detección de objetos, segmentación y pose) o métricas de `accuracy_top5` (para clasificación), y el tiempo de inferencia en milisegundos por imagen a través de 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, basado en sus requerimientos de velocidad y precisión.
[Ejemplos de Benchmarking](benchmark.md){ .md-button .md-button--primary}

226
docs/es/modes/predict.md Normal file
View file

@ -0,0 +1,226 @@
---
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](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a0f802a8-0776-44cf-8f17-93974a4a28a1) | ![Detección de Jugadores de Fútbol](https://github.com/RizwanMunawar/ultralytics/assets/62513924/7d320e1f-fc57-4d7f-a691-78ee579c3442) | ![Detección de Caídas de Personas](https://github.com/RizwanMunawar/ultralytics/assets/62513924/86437c4a-3227-4eee-90ef-9efb697bdb43) |
| 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

200
docs/es/modes/track.md Normal file
View file

@ -0,0 +1,200 @@
---
comments: true
description: Aprende a utilizar Ultralytics YOLO para el seguimiento de objetos en flujos de video. Guías para usar diferentes rastreadores y personalizar la configuración del rastreador.
keywords: Ultralytics, YOLO, seguimiento de objetos, flujos de video, BoT-SORT, ByteTrack, guía de Python, guía de CLI
---
# Seguimiento de Múltiples Objetos con Ultralytics YOLO
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418637-1d6250fd-1515-4c10-a844-a32818ae6d46.png" alt="Ejemplos de seguimiento de múltiples objetos">
El seguimiento de objetos en el ámbito del análisis de video es una tarea crítica que no solo identifica la ubicación y clase de objetos dentro del cuadro, sino que también mantiene una ID única para cada objeto detectado a medida que avanza el video. Las aplicaciones son ilimitadas, desde vigilancia y seguridad hasta análisis deportivos en tiempo real.
## ¿Por Qué Elegir Ultralytics YOLO para el Seguimiento de Objetos?
La salida de los rastreadores de Ultralytics es consistente con la detección de objetos estándar, pero con el valor añadido de las IDs de objetos. Esto facilita el seguimiento de objetos en flujos de video y la realización de análisis posteriores. Aquí tienes algunas razones por las que deberías considerar usar Ultralytics YOLO para tus necesidades de seguimiento de objetos:
- **Eficiencia:** Procesa flujos de video en tiempo real sin comprometer la precisión.
- **Flexibilidad:** Soporta múltiples algoritmos de seguimiento y configuraciones.
- **Facilidad de Uso:** API simple de Python y opciones CLI para una rápida integración y despliegue.
- **Personalización:** Fácil de usar con modelos YOLO entrenados a medida, permitiendo la integración en aplicaciones específicas del dominio.
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/hHyHmOtmEgs?si=VNZtXmm45Nb9s-N-"
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> Detección de Objetos y Seguimiento con Ultralytics YOLOv8.
</p>
## Aplicaciones en el Mundo Real
| Transporte | Venta al por Menor | Acuicultura |
|:------------------------------------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------------:|:--------------------------------------------------------------------------------------------------------------------------:|
| ![Seguimiento de Vehículos](https://github.com/RizwanMunawar/ultralytics/assets/62513924/ee6e6038-383b-4f21-ac29-b2a1c7d386ab) | ![Seguimiento de Personas](https://github.com/RizwanMunawar/ultralytics/assets/62513924/93bb4ee2-77a0-4e4e-8eb6-eb8f527f0527) | ![Seguimiento de Peces](https://github.com/RizwanMunawar/ultralytics/assets/62513924/a5146d0f-bfa8-4e0a-b7df-3c1446cd8142) |
| Seguimiento de Vehículos | Seguimiento de Personas | Seguimiento de Peces |
## Características a Simple Vista
Ultralytics YOLO extiende sus características de detección de objetos para proporcionar un seguimiento de objetos robusto y versátil:
- **Seguimiento en Tiempo Real:** Rastrea sin problemas los objetos en videos de alta frecuencia de cuadros.
- **Soporte de Múltiples Rastreadores:** Elige entre una variedad de algoritmos de seguimiento establecidos.
- **Configuraciones de Rastreador Personalizables:** Adapta el algoritmo de seguimiento para satisfacer requisitos específicos ajustando diversos parámetros.
## Rastreadores Disponibles
Ultralytics YOLO soporta los siguientes algoritmos de seguimiento. Pueden ser habilitados pasando el archivo de configuración YAML relevante como `tracker=tracker_type.yaml`:
* [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - Usa `botsort.yaml` para habilitar este rastreador.
* [ByteTrack](https://github.com/ifzhang/ByteTrack) - Usa `bytetrack.yaml` para habilitar este rastreador.
El rastreador predeterminado es BoT-SORT.
## Seguimiento
Para ejecutar el rastreador en flujos de video, usa un modelo Detect, Segment o Pose entrenado tales como YOLOv8n, YOLOv8n-seg y YOLOv8n-pose.
!!! ejemplo ""
=== "Python"
```python
from ultralytics import YOLO
# Cargar un modelo oficial o personalizado
model = YOLO('yolov8n.pt') # Cargar un modelo oficial Detect
model = YOLO('yolov8n-seg.pt') # Cargar un modelo oficial Segment
model = YOLO('yolov8n-pose.pt') # Cargar un modelo oficial Pose
model = YOLO('path/to/best.pt') # Cargar un modelo entrenado a medida
# Realizar el seguimiento con el modelo
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True) # Seguimiento con el rastreador predeterminado
results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml") # Seguimiento con el rastreador ByteTrack
```
=== "CLI"
```bash
# Realizar seguimiento con varios modelos usando la interfaz de línea de comandos
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # Modelo oficial Detect
yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # Modelo oficial Segment
yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # Modelo oficial Pose
yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4" # Modelo entrenado a medida
# Realizar seguimiento usando el rastreador ByteTrack
yolo track model=path/to/best.pt tracker="bytetrack.yaml"
```
Como se puede ver en el uso anterior, el seguimiento está disponible para todos los modelos Detect, Segment y Pose ejecutados en videos o fuentes de transmisión.
## Configuración
### Argumentos de Seguimiento
La configuración de seguimiento comparte propiedades con el modo Predict, como `conf`, `iou` y `show`. Para configuraciones adicionales, consulta la página del modelo [Predict](https://docs.ultralytics.com/modes/predict/).
!!! ejemplo ""
=== "Python"
```python
from ultralytics import YOLO
# Configurar los parámetros de seguimiento y ejecutar el rastreador
model = YOLO('yolov8n.pt')
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)
```
=== "CLI"
```bash
# Configurar parámetros de seguimiento y ejecutar el rastreador usando la interfaz de línea de comandos
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show
```
### Selección de Rastreador
Ultralytics también te permite usar un archivo de configuración de rastreador modificado. Para hacerlo, simplemente haz una copia de un archivo de configuración de rastreador (por ejemplo, `custom_tracker.yaml`) de [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) y modifica cualquier configuración (excepto el `tracker_type`) según tus necesidades.
!!! ejemplo ""
=== "Python"
```python
from ultralytics import YOLO
# Cargar el modelo y ejecutar el rastreador con un archivo de configuración personalizado
model = YOLO('yolov8n.pt')
results = model.track(source="https://youtu.be/LNwODJXcvt4", tracker='custom_tracker.yaml')
```
=== "CLI"
```bash
# Cargar el modelo y ejecutar el rastreador con un archivo de configuración personalizado usando la interfaz de línea de comandos
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'
```
Para obtener una lista completa de los argumentos de seguimiento, consulta la página [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers).
## Ejemplos en Python
### Bucle de Seguimiento Persistente
Aquí hay un script en Python que utiliza OpenCV (`cv2`) y YOLOv8 para ejecutar el seguimiento de objetos en fotogramas de video. Este script aún asume que ya has instalado los paquetes necesarios (`opencv-python` y `ultralytics`). El argumento `persist=True` le indica al rastreador que la imagen o fotograma actual es el siguiente en una secuencia y que espera rastros de la imagen anterior en la imagen actual.
!!! ejemplo "Bucle de transmisión en vivo con seguimiento"
```python
import cv2
from ultralytics import YOLO
# Cargar el modelo YOLOv8
model = YOLO('yolov8n.pt')
# Abrir el archivo de video
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)
# Bucle a través de los fotogramas del video
while cap.isOpened():
# Leer un fotograma del video
success, frame = cap.read()
if success:
# Ejecutar seguimiento YOLOv8 en el fotograma, persistiendo los rastreos entre fotogramas
results = model.track(frame, persist=True)
# Visualizar los resultados en el fotograma
annotated_frame = results[0].plot()
# Mostrar el fotograma anotado
cv2.imshow("Seguimiento YOLOv8", annotated_frame)
# Romper el bucle si se presiona 'q'
if cv2.waitKey(1) & 0xFF == ord("q"):
break
else:
# Romper el bucle si se alcanza el final del video
break
# Liberar el objeto de captura de video y cerrar la ventana de visualización
cap.release()
cv2.destroyAllWindows()
```
Toma en cuenta el cambio de `model(frame)` a `model.track(frame)`, que habilita el seguimiento de objetos en lugar de simplemente la detección. Este script modificado ejecutará el rastreador en cada fotograma del video, visualizará los resultados y los mostrará en una ventana. El bucle puede ser terminado presionando 'q'.
## Contribuir con Nuevos Rastreadores
¿Eres experto en seguimiento de múltiples objetos y has implementado o adaptado exitosamente un algoritmo de seguimiento con Ultralytics YOLO? Te invitamos a contribuir en nuestra sección de Rastreadores en [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers)! Tus aplicaciones en el mundo real y soluciones podrían ser invaluables para los usuarios que trabajan en tareas de seguimiento.
Al contribuir en esta sección, ayudarás a ampliar el alcance de las soluciones de seguimiento disponibles dentro del marco de trabajo de Ultralytics YOLO, añadiendo otra capa de funcionalidad y utilidad para la comunidad.
Para iniciar tu contribución, por favor consulta nuestra [Guía de Contribución](https://docs.ultralytics.com/help/contributing) para obtener instrucciones completas sobre cómo enviar una Solicitud de Extracción (PR) 🛠️. ¡Estamos emocionados de ver lo que traes a la mesa!
Juntos, vamos a mejorar las capacidades de seguimiento del ecosistema Ultralytics YOLO 🙏!

206
docs/es/modes/train.md Normal file
View file

@ -0,0 +1,206 @@
---
comments: true
description: Guía paso a paso para entrenar modelos YOLOv8 con Ultralytics YOLO incluyendo ejemplos de entrenamiento con una sola GPU y múltiples GPUs
keywords: Ultralytics, YOLOv8, YOLO, detección de objetos, modo de entrenamiento, conjunto de datos personalizado, entrenamiento GPU, multi-GPU, hiperparámetros, ejemplos CLI, ejemplos Python
---
# Entrenamiento de Modelos con Ultralytics YOLO
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ecosistema e integraciones de Ultralytics YOLO">
## Introducción
Entrenar un modelo de aprendizaje profundo implica alimentarlo con datos y ajustar sus parámetros para que pueda hacer predicciones precisas. El modo de entrenamiento en Ultralytics YOLOv8 está diseñado para un entrenamiento efectivo y eficiente de modelos de detección de objetos, aprovechando al máximo las capacidades del hardware moderno. Esta guía tiene como objetivo cubrir todos los detalles que necesita para comenzar a entrenar sus propios modelos utilizando el robusto conjunto de características de YOLOv8.
<p align="center">
<br>
<iframe width="720" height="405" src="https://www.youtube.com/embed/LNwODJXcvt4?si=7n1UvGRLSd9p5wKs"
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 Entrenar un modelo YOLOv8 en Tu Conjunto de Datos Personalizado en Google Colab.
</p>
## ¿Por Qué Elegir Ultralytics YOLO para Entrenamiento?
Aquí hay algunas razones convincentes para optar por el modo Entrenamiento de YOLOv8:
- **Eficiencia:** Aprovecha al máximo tu hardware, ya sea en una configuración de una sola GPU o escalando entre múltiples GPUs.
- **Versatilidad:** Entrena con conjuntos de datos personalizados además de los ya disponibles como COCO, VOC e ImageNet.
- **Amigable al Usuario:** Interfaces CLI y Python simples pero potentes para una experiencia de entrenamiento sencilla.
- **Flexibilidad de Hiperparámetros:** Una amplia gama de hiperparámetros personalizables para ajustar el rendimiento del modelo.
### Características Clave del Modo Entrenamiento
Las siguientes son algunas características notables del modo Entrenamiento de YOLOv8:
- **Descarga Automática de Conjuntos de Datos:** Conjuntos de datos estándar como COCO, VOC e ImageNet se descargan automáticamente en el primer uso.
- **Soporte Multi-GPU:** Escala tus esfuerzos de entrenamiento sin problemas en múltiples GPUs para acelerar el proceso.
- **Configuración de Hiperparámetros:** La opción de modificar hiperparámetros a través de archivos de configuración YAML o argumentos CLI.
- **Visualización y Monitoreo:** Seguimiento en tiempo real de métricas de entrenamiento y visualización del proceso de aprendizaje para una mejor comprensión.
!!! consejo "Consejo"
* Los conjuntos de datos de YOLOv8 como COCO, VOC, ImageNet y muchos otros se descargan automáticamente en el primer uso, es decir, `yolo train data=coco.yaml`
## Ejemplos de Uso
Entrena YOLOv8n en el conjunto de datos COCO128 durante 100 épocas con un tamaño de imagen de 640. El dispositivo de entrenamiento se puede especificar usando el argumento `device`. Si no se pasa ningún argumento, se usará la GPU `device=0` si está disponible; de lo contrario, se usará `device=cpu`. Consulta la sección de Argumentos a continuación para una lista completa de argumentos de entrenamiento.
!!! ejemplo "Ejemplo de Entrenamiento con una sola GPU y CPU"
El dispositivo se determina automáticamente. Si hay una GPU disponible, se usará; de lo contrario, el entrenamiento comenzará en la CPU.
=== "Python"
```python
from ultralytics import YOLO
# Cargar un modelo
model = YOLO('yolov8n.yaml') # construir un modelo nuevo desde YAML
model = YOLO('yolov8n.pt') # cargar un modelo preentrenado (recomendado para entrenamiento)
model = YOLO('yolov8n.yaml').load('yolov8n.pt') # construir desde YAML y transferir pesos
# Entrenar el modelo
results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
```
=== "CLI"
```bash
# Construir un modelo nuevo desde YAML y comenzar el entrenamiento desde cero
yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
# Comenzar el entrenamiento desde un modelo preentrenado *.pt
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
# Construir un modelo nuevo desde YAML, transferir pesos preentrenados a él y comenzar el entrenamiento
yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
```
### Entrenamiento Multi-GPU
El entrenamiento Multi-GPU permite una utilización más eficiente de los recursos de hardware disponibles, distribuyendo la carga de entrenamiento en varias GPUs. Esta característica está disponible tanto a través de la API de Python como de la interfaz de línea de comandos. Para habilitar el entrenamiento Multi-GPU, especifica los IDs de los dispositivos GPU que deseas usar.
!!! ejemplo "Ejemplo de Entrenamiento Multi-GPU"
Para entrenar con 2 GPUs, dispositivos CUDA 0 y 1, usa los siguientes comandos. Amplía a GPUs adicionales según sea necesario.
=== "Python"
```python
from ultralytics import YOLO
# Cargar un modelo
model = YOLO('yolov8n.pt') # cargar un modelo preentrenado (recomendado para entrenamiento)
# Entrenar el modelo con 2 GPUs
results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1])
```
=== "CLI"
```bash
# Comenzar el entrenamiento desde un modelo preentrenado *.pt usando las GPUs 0 y 1
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1
```
### Entrenamiento con Apple M1 y M2 MPS
Con el soporte para los chips Apple M1 y M2 integrados en los modelos Ultralytics YOLO, ahora es posible entrenar tus modelos en dispositivos que utilizan el potente marco de Metal Performance Shaders (MPS). El MPS ofrece una forma de alto rendimiento para ejecutar tareas de cálculo y procesamiento de imágenes en el silicio personalizado de Apple.
Para habilitar el entrenamiento en chips Apple M1 y M2, debes especificar 'mps' como tu dispositivo al iniciar el proceso de entrenamiento. A continuación se muestra un ejemplo de cómo podrías hacer esto en Python y a través de la línea de comandos:
!!! ejemplo "Ejemplo de Entrenamiento MPS"
=== "Python"
```python
from ultralytics import YOLO
# Cargar un modelo
model = YOLO('yolov8n.pt') # cargar un modelo preentrenado (recomendado para entrenamiento)
# Entrenar el modelo con 2 GPUs
results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps')
```
=== "CLI"
```bash
# Comenzar el entrenamiento desde un modelo preentrenado *.pt usando las GPUs 0 y 1
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps
```
Al aprovechar el poder computacional de los chips M1/M2, esto permite un procesamiento más eficiente de las tareas de entrenamiento. Para obtener una guía más detallada y opciones de configuración avanzadas, consulta la [documentación de PyTorch MPS](https://pytorch.org/docs/stable/notes/mps.html).
## Registros (Logging)
Al entrenar un modelo YOLOv8, puedes encontrar valioso llevar un registro del rendimiento del modelo con el tiempo. Aquí es donde entra en juego el registro. Ultralytics' YOLO ofrece soporte para tres tipos de registradores: Comet, ClearML y TensorBoard.
Para usar un registrador, selecciónalo en el menú desplegable en el fragmento de código anterior y ejecútalo. El registrador elegido se instalará e inicializará.
### Comet
[Comet](https://www.comet.ml/site/) es una plataforma que permite a los científicos de datos y desarrolladores rastrear, comparar, explicar y optimizar experimentos y modelos. Ofrece funcionalidades como métricas en tiempo real, diferencias de código y seguimiento de hiperparámetros.
Para usar Comet:
!!! ejemplo ""
=== "Python"
```python
# pip install comet_ml
import comet_ml
comet_ml.init()
```
Recuerda iniciar sesión en tu cuenta de Comet en su sitio web y obtener tu clave API. Necesitarás agregar esto a tus variables de entorno o tu script para registrar tus experimentos.
### ClearML
[ClearML](https://www.clear.ml/) es una plataforma de código abierto que automatiza el seguimiento de experimentos y ayuda con la compartición eficiente de recursos. Está diseñado para ayudar a los equipos a gestionar, ejecutar y reproducir su trabajo de ML de manera más eficiente.
Para usar ClearML:
!!! ejemplo ""
=== "Python"
```python
# pip install clearml
import clearml
clearml.browser_login()
```
Después de ejecutar este script, necesitarás iniciar sesión en tu cuenta de ClearML en el navegador y autenticar tu sesión.
### TensorBoard
[TensorBoard](https://www.tensorflow.org/tensorboard) es una herramienta de visualización para TensorFlow. Te permite visualizar tu grafo TensorFlow, trazar métricas cuantitativas sobre la ejecución de tu grafo y mostrar datos adicionales como imágenes que lo atraviesan.
Para usar TensorBoard en [Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb):
!!! ejemplo ""
=== "CLI"
```bash
load_ext tensorboard
tensorboard --logdir ultralytics/runs # reemplazar con el directorio 'runs'
```
Para usar TensorBoard localmente, ejecuta el siguiente comando y visualiza los resultados en http://localhost:6006/.
!!! ejemplo ""
=== "CLI"
```bash
tensorboard --logdir ultralytics/runs # reemplazar con el directorio 'runs'
```
Esto cargará TensorBoard y lo dirigirá al directorio donde se guardan tus registros de entrenamiento.
Después de configurar tu registrador, puedes proceder con tu entrenamiento de modelo. Todas las métricas de entrenamiento se registrarán automáticamente en la plataforma elegida y podrás acceder a estos registros para monitorear el rendimiento de tu modelo con el tiempo, comparar diferentes modelos e identificar áreas de mejora.

86
docs/es/modes/val.md Normal file
View file

@ -0,0 +1,86 @@
---
comments: true
description: Guía para validar modelos YOLOv8. Aprenda a evaluar el rendimiento de sus modelos YOLO utilizando configuraciones y métricas de validación con ejemplos en Python y CLI.
keywords: Ultralytics, Documentación YOLO, YOLOv8, validación, evaluación de modelos, hiperparámetros, precisión, métricas, Python, CLI
---
# Validación de modelos con Ultralytics YOLO
<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ecosistema e integraciones de Ultralytics YOLO">
## Introducción
La validación es un paso crítico en el flujo de trabajo de aprendizaje automático, permitiéndole evaluar la calidad de sus modelos entrenados. El modo Val en Ultralytics YOLOv8 proporciona un robusto conjunto de herramientas y métricas para evaluar el rendimiento de sus modelos de detección de objetos. Esta guía sirve como un recurso completo para comprender cómo utilizar efectivamente el modo Val para asegurar que sus modelos sean precisos y confiables.
## ¿Por qué validar con Ultralytics YOLO?
Estas son las ventajas de usar el modo Val de YOLOv8:
- **Precisión:** Obtenga métricas precisas como mAP50, mAP75 y mAP50-95 para evaluar de manera integral su modelo.
- **Comodidad:** Utilice funciones integradas que recuerdan los ajustes de entrenamiento, simplificando el proceso de validación.
- **Flexibilidad:** Valide su modelo con el mismo conjunto de datos o diferentes conjuntos de datos y tamaños de imagen.
- **Ajuste de Hiperparámetros:** Use las métricas de validación para ajustar su modelo y mejorar el rendimiento.
### Características principales del modo Val
Estas son las funcionalidades notables ofrecidas por el modo Val de YOLOv8:
- **Configuraciones Automatizadas:** Los modelos recuerdan sus configuraciones de entrenamiento para una validación sencilla.
- **Soporte de Múltiples Métricas:** Evalúe su modelo basado en una gama de métricas de precisión.
- **CLI y API de Python:** Elija entre la interfaz de línea de comandos o API de Python basada en su preferencia para validación.
- **Compatibilidad de Datos:** Funciona sin problemas con conjuntos de datos utilizados durante la fase de entrenamiento así como con conjuntos de datos personalizados.
!!! tip "Consejo"
* Los modelos YOLOv8 recuerdan automáticamente sus ajustes de entrenamiento, así que puede validar un modelo en el mismo tamaño de imagen y en el conjunto de datos original fácilmente con solo `yolo val model=yolov8n.pt` o `model('yolov8n.pt').val()`
## Ejemplos de Uso
Valide la precisión del modelo YOLOv8n entrenado en el conjunto de datos COCO128. No es necesario pasar ningún argumento ya que el `modelo` retiene sus `datos` de entrenamiento y argumentos como atributos del modelo. Vea la sección de Argumentos a continuación para una lista completa de argumentos de exportación.
!!! example ""
=== "Python"
```python
from ultralytics import YOLO
# Cargar un modelo
model = YOLO('yolov8n.pt') # cargar un modelo oficial
model = YOLO('ruta/a/best.pt') # cargar un modelo personalizado
# Validar el modelo
metrics = model.val() # no se necesitan argumentos, el conjunto de datos y ajustes se recuerdan
metrics.box.map # map50-95
metrics.box.map50 # map50
metrics.box.map75 # map75
metrics.box.maps # una lista que contiene map50-95 de cada categoría
```
=== "CLI"
```bash
yolo detect val model=yolov8n.pt # val model oficial
yolo detect val model=ruta/a/best.pt # val model personalizado
```
## Argumentos
Los ajustes de validación para modelos YOLO se refieren a los diversos hiperparámetros y configuraciones utilizados para evaluar el rendimiento del modelo en un conjunto de datos de validación. Estos ajustes pueden afectar el rendimiento, la velocidad y la precisión del modelo. Algunos ajustes comunes de validación YOLO incluyen el tamaño del lote, la frecuencia con la que se realiza la validación durante el entrenamiento y las métricas utilizadas para evaluar el rendimiento del modelo. Otros factores que pueden afectar el proceso de validación incluyen el tamaño y la composición del conjunto de datos de validación y la tarea específica para la que se utiliza el modelo. Es importante ajustar y experimentar cuidadosamente con estos ajustes para asegurarse de que el modelo esté funcionando bien en el conjunto de datos de validación y para detectar y prevenir el sobreajuste.
| Clave | Valor | Descripción |
|---------------|---------|---------------------------------------------------------------------------------------------------|
| `data` | `None` | ruta al archivo de datos, por ejemplo coco128.yaml |
| `imgsz` | `640` | tamaño de las imágenes de entrada como entero |
| `batch` | `16` | número de imágenes por lote (-1 para AutoBatch) |
| `save_json` | `False` | guardar resultados en archivo JSON |
| `save_hybrid` | `False` | guardar versión híbrida de las etiquetas (etiquetas + predicciones adicionales) |
| `conf` | `0.001` | umbral de confianza del objeto para detección |
| `iou` | `0.6` | umbral de Intersección sobre Unión (IoU) para NMS |
| `max_det` | `300` | número máximo de detecciones por imagen |
| `half` | `True` | usar precisión de punto flotante de media preción (FP16) |
| `device` | `None` | dispositivo en el que se ejecuta, por ejemplo dispositivo cuda=0/1/2/3 o dispositivo=cpu |
| `dnn` | `False` | utilizar OpenCV DNN para inferencia ONNX |
| `plots` | `False` | mostrar gráficos durante el entrenamiento |
| `rect` | `False` | val rectangular con cada lote compilado para el mínimo relleno |
| `split` | `val` | división del conjunto de datos a utilizar para la validación, por ejemplo 'val', 'test' o 'train' |
|