Add Docs languages zh, es, ru, pt, fr, de, ja, ko (#6316)
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
GitHub
parent
e3a538bbde
commit
48e70f0921
144 changed files with 17632 additions and 76 deletions
127
docs/es/datasets/index.md
Normal file
127
docs/es/datasets/index.md
Normal file
|
|
@ -0,0 +1,127 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore diferentes conjuntos de datos de visión por computadora soportados por Ultralytics para la detección de objetos, segmentación, estimación de poses, clasificación de imágenes y seguimiento de múltiples objetos.
|
||||
keywords: visión por computadora, conjuntos de datos, Ultralytics, YOLO, detección de objetos, segmentación de instancias, estimación de poses, clasificación de imágenes, seguimiento de múltiples objetos
|
||||
---
|
||||
|
||||
# Resumen de Conjuntos de Datos
|
||||
|
||||
Ultralytics brinda soporte para varios conjuntos de datos para facilitar tareas de visión por computadora como detección, segmentación de instancias, estimación de poses, clasificación y seguimiento de múltiples objetos. A continuación se presenta una lista de los principales conjuntos de datos de Ultralytics, seguido por un resumen de cada tarea de visión por computadora y los respectivos conjuntos de datos.
|
||||
|
||||
!!! note
|
||||
|
||||
🚧 Nuestra documentación multilingüe está actualmente en construcción y estamos trabajando arduamente para mejorarla. ¡Gracias por su paciencia! 🙏
|
||||
|
||||
## [Conjuntos de Datos de Detección](../../datasets/detect/index.md)
|
||||
|
||||
La detección de objetos con cuadros delimitadores es una técnica de visión por computadora que implica detectar y localizar objetos en una imagen dibujando un cuadro alrededor de cada objeto.
|
||||
|
||||
- [Argoverse](../../datasets/detect/argoverse.md): Un conjunto de datos que contiene datos de seguimiento en 3D y predicción de movimientos en entornos urbanos con anotaciones detalladas.
|
||||
- [COCO](../../datasets/detect/coco.md): Un conjunto de datos a gran escala diseñado para detección de objetos, segmentación y subtitulado con más de 200 mil imágenes etiquetadas.
|
||||
- [COCO8](../../datasets/detect/coco8.md): Contiene las primeras 4 imágenes de COCO train y COCO val, adecuado para pruebas rápidas.
|
||||
- [Global Wheat 2020](../../datasets/detect/globalwheat2020.md): Un conjunto de datos de imágenes de cabezas de trigo recolectadas alrededor del mundo para tareas de detección y localización de objetos.
|
||||
- [Objects365](../../datasets/detect/objects365.md): Un conjunto de datos a gran escala y de alta calidad para la detección de objetos con 365 categorías y más de 600 mil imágenes anotadas.
|
||||
- [OpenImagesV7](../../datasets/detect/open-images-v7.md): Un conjunto de datos completo de Google con 1.7 millones de imágenes de entrenamiento y 42 mil imágenes de validación.
|
||||
- [SKU-110K](../../datasets/detect/sku-110k.md): Un conjunto de datos que presenta detección de objetos densa en entornos minoristas con más de 11 mil imágenes y 1.7 millones de cuadros delimitadores.
|
||||
- [VisDrone](../../datasets/detect/visdrone.md): Un conjunto de datos que contiene datos de detección de objetos y seguimiento de múltiples objetos de imágenes capturadas por drones con más de 10 mil imágenes y secuencias de video.
|
||||
- [VOC](../../datasets/detect/voc.md): El conjunto de datos de Clases de Objetos Visuales de Pascal (VOC) para la detección de objetos y segmentación con 20 clases de objetos y más de 11 mil imágenes.
|
||||
- [xView](../../datasets/detect/xview.md): Un conjunto de datos para la detección de objetos en imágenes aéreas con 60 categorías de objetos y más de un millón de objetos anotados.
|
||||
|
||||
## [Conjuntos de Datos de Segmentación de Instancias](../../datasets/segment/index.md)
|
||||
|
||||
La segmentación de instancias es una técnica de visión por computadora que implica identificar y localizar objetos en una imagen a nivel de píxel.
|
||||
|
||||
- [COCO](../../datasets/segment/coco.md): Un conjunto de datos a gran escala diseñado para tareas de detección de objetos, segmentación y subtitulado con más de 200 mil imágenes etiquetadas.
|
||||
- [COCO8-seg](../../datasets/segment/coco8-seg.md): Un conjunto de datos más pequeño para tareas de segmentación de instancias, que contiene un subconjunto de 8 imágenes de COCO con anotaciones de segmentación.
|
||||
|
||||
## [Estimación de Poses](../../datasets/pose/index.md)
|
||||
|
||||
La estimación de poses es una técnica utilizada para determinar la pose del objeto en relación con la cámara o el sistema de coordenadas del mundo.
|
||||
|
||||
- [COCO](../../datasets/pose/coco.md): Un conjunto de datos a gran escala con anotaciones de pose humana diseñado para tareas de estimación de poses.
|
||||
- [COCO8-pose](../../datasets/pose/coco8-pose.md): Un conjunto de datos más pequeño para tareas de estimación de poses, que contiene un subconjunto de 8 imágenes de COCO con anotaciones de pose humana.
|
||||
- [Tiger-pose](../../datasets/pose/tiger-pose.md): Un conjunto de datos compacto que consiste en 263 imágenes centradas en tigres, anotadas con 12 puntos clave por tigre para tareas de estimación de poses.
|
||||
|
||||
## [Clasificación](../../datasets/classify/index.md)
|
||||
|
||||
La clasificación de imágenes es una tarea de visión por computadora que implica categorizar una imagen en una o más clases o categorías predefinidas basadas en su contenido visual.
|
||||
|
||||
- [Caltech 101](../../datasets/classify/caltech101.md): Un conjunto de datos que contiene imágenes de 101 categorías de objetos para tareas de clasificación de imágenes.
|
||||
- [Caltech 256](../../datasets/classify/caltech256.md): Una versión extendida de Caltech 101 con 256 categorías de objetos y imágenes más desafiantes.
|
||||
- [CIFAR-10](../../datasets/classify/cifar10.md): Un conjunto de datos de 60 mil imágenes a color de 32x32 en 10 clases, con 6 mil imágenes por clase.
|
||||
- [CIFAR-100](../../datasets/classify/cifar100.md): Una versión extendida de CIFAR-10 con 100 categorías de objetos y 600 imágenes por clase.
|
||||
- [Fashion-MNIST](../../datasets/classify/fashion-mnist.md): Un conjunto de datos compuesto por 70 mil imágenes en escala de grises de 10 categorías de moda para tareas de clasificación de imágenes.
|
||||
- [ImageNet](../../datasets/classify/imagenet.md): Un conjunto de datos a gran escala para detección de objetos y clasificación de imágenes con más de 14 millones de imágenes y 20 mil categorías.
|
||||
- [ImageNet-10](../../datasets/classify/imagenet10.md): Un subconjunto más pequeño de ImageNet con 10 categorías para experimentación y pruebas más rápidas.
|
||||
- [Imagenette](../../datasets/classify/imagenette.md): Un subconjunto más pequeño de ImageNet que contiene 10 clases fácilmente distinguibles para entrenamientos y pruebas más rápidos.
|
||||
- [Imagewoof](../../datasets/classify/imagewoof.md): Un subconjunto más desafiante de ImageNet que contiene 10 categorías de razas de perros para tareas de clasificación de imágenes.
|
||||
- [MNIST](../../datasets/classify/mnist.md): Un conjunto de datos de 70 mil imágenes en escala de grises de dígitos escritos a mano para tareas de clasificación de imágenes.
|
||||
|
||||
## [Cuadros Delimitadores Orientados (OBB)](../../datasets/obb/index.md)
|
||||
|
||||
Los Cuadros Delimitadores Orientados (OBB) es un método en visión por computadora para detectar objetos angulados en imágenes utilizando cuadros delimitadores rotados, a menudo aplicado en imágenes aéreas y satelitales.
|
||||
|
||||
- [DOTAv2](../../datasets/obb/dota-v2.md): Un popular conjunto de datos de imágenes aéreas de OBB con 1.7 millones de instancias y 11,268 imágenes.
|
||||
|
||||
## [Seguimiento de Múltiples Objetos](../../datasets/track/index.md)
|
||||
|
||||
El seguimiento de múltiples objetos es una técnica de visión por computadora que implica detectar y seguir múltiples objetos a lo largo del tiempo en una secuencia de video.
|
||||
|
||||
- [Argoverse](../../datasets/detect/argoverse.md): Un conjunto de datos que contiene datos de seguimiento en 3D y predicción de movimientos en entornos urbanos con anotaciones detalladas para tareas de seguimiento de múltiples objetos.
|
||||
- [VisDrone](../../datasets/detect/visdrone.md): Un conjunto de datos que contiene datos de detección de objetos y seguimiento de múltiples objetos de imágenes capturadas por drones con más de 10 mil imágenes y secuencias de video.
|
||||
|
||||
## Contribuir con Nuevos Conjuntos de Datos
|
||||
|
||||
Contribuir con un nuevo conjunto de datos implica varios pasos para garantizar que se alinee bien con la infraestructura existente. A continuación, se presentan los pasos necesarios:
|
||||
|
||||
### Pasos para Contribuir con un Nuevo Conjunto de Datos
|
||||
|
||||
1. **Recolectar Imágenes**: Reúne las imágenes que pertenecen al conjunto de datos. Estas podrían ser recopiladas de varias fuentes, tales como bases de datos públicas o tu propia colección.
|
||||
|
||||
2. **Annotar Imágenes**: Anota estas imágenes con cuadros delimitadores, segmentos o puntos clave, dependiendo de la tarea.
|
||||
|
||||
3. **Exportar Anotaciones**: Convierte estas anotaciones en el formato de archivo *.txt de YOLO que Ultralytics soporta.
|
||||
|
||||
4. **Organizar Conjunto de Datos**: Organiza tu conjunto de datos en la estructura de carpetas correcta. Deberías tener directorios de nivel superior `train/` y `val/`, y dentro de cada uno, un subdirectorio `images/` y `labels/`.
|
||||
|
||||
```
|
||||
dataset/
|
||||
├── train/
|
||||
│ ├── images/
|
||||
│ └── labels/
|
||||
└── val/
|
||||
├── images/
|
||||
└── labels/
|
||||
```
|
||||
|
||||
5. **Crear un Archivo `data.yaml`**: En el directorio raíz de tu conjunto de datos, crea un archivo `data.yaml` que describa el conjunto de datos, clases y otra información necesaria.
|
||||
|
||||
6. **Optimizar Imágenes (Opcional)**: Si deseas reducir el tamaño del conjunto de datos para un procesamiento más eficiente, puedes optimizar las imágenes usando el código a continuación. Esto no es requerido, pero se recomienda para tamaños de conjuntos de datos más pequeños y velocidades de descarga más rápidas.
|
||||
|
||||
7. **Comprimir Conjunto de Datos**: Comprime toda la carpeta del conjunto de datos en un archivo .zip.
|
||||
|
||||
8. **Documentar y PR**: Crea una página de documentación describiendo tu conjunto de datos y cómo encaja en el marco existente. Después de eso, envía una Solicitud de Extracción (PR). Consulta las [Pautas de Contribución de Ultralytics](https://docs.ultralytics.com/help/contributing) para obtener más detalles sobre cómo enviar una PR.
|
||||
|
||||
### Código de Ejemplo para Optimizar y Comprimir un Conjunto de Datos
|
||||
|
||||
!!! example "Optimizar y Comprimir un Conjunto de Datos"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from pathlib import Path
|
||||
from ultralytics.data.utils import compress_one_image
|
||||
from ultralytics.utils.downloads import zip_directory
|
||||
|
||||
# Definir el directorio del conjunto de datos
|
||||
path = Path('ruta/al/conjunto-de-datos')
|
||||
|
||||
# Optimizar imágenes en el conjunto de datos (opcional)
|
||||
for f in path.rglob('*.jpg'):
|
||||
compress_one_image(f)
|
||||
|
||||
# Comprimir el conjunto de datos en 'ruta/al/conjunto-de-datos.zip'
|
||||
zip_directory(path)
|
||||
```
|
||||
|
||||
Siguiendo estos pasos, puedes contribuir con un nuevo conjunto de datos que se integre bien con la estructura existente de Ultralytics.
|
||||
82
docs/es/index.md
Normal file
82
docs/es/index.md
Normal file
|
|
@ -0,0 +1,82 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore una guía completa sobre Ultralytics YOLOv8, un modelo de alta velocidad y precisión para detección de objetos y segmentación de imágenes. Tutoriales de instalación, predicción, entrenamiento y más.
|
||||
keywords: Ultralytics, YOLOv8, detección de objetos, segmentación de imágenes, aprendizaje automático, aprendizaje profundo, visión por computadora, instalación YOLOv8, predicción YOLOv8, entrenamiento YOLOv8, historia de YOLO, licencias YOLO
|
||||
---
|
||||
|
||||
<div align="center">
|
||||
<p>
|
||||
<a href="https://yolovision.ultralytics.com" target="_blank">
|
||||
<img width="1024" src="https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/banner-yolov8.png" alt="Banner de Ultralytics YOLO"></a>
|
||||
</p>
|
||||
<a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="3%" alt="GitHub de Ultralytics"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="3%" alt="LinkedIn de Ultralytics"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="3%" alt="Twitter de Ultralytics"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://youtube.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="3%" alt="YouTube de Ultralytics"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="3%" alt="TikTok de Ultralytics"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://www.instagram.com/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-instagram.png" width="3%" alt="Instagram de Ultralytics"></a>
|
||||
<img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%">
|
||||
<a href="https://ultralytics.com/discord"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="3%" alt="Discord de Ultralytics"></a>
|
||||
<br>
|
||||
<br>
|
||||
<a href="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml"><img src="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml/badge.svg" alt="Integración continua de Ultralytics"></a>
|
||||
<a href="https://codecov.io/github/ultralytics/ultralytics"><img src="https://codecov.io/github/ultralytics/ultralytics/branch/main/graph/badge.svg?token=HHW7IIVFVY" alt="Cobertura de código de Ultralytics"></a>
|
||||
<a href="https://zenodo.org/badge/latestdoi/264818686"><img src="https://zenodo.org/badge/264818686.svg" alt="Cita de YOLOv8"></a>
|
||||
<a href="https://hub.docker.com/r/ultralytics/ultralytics"><img src="https://img.shields.io/docker/pulls/ultralytics/ultralytics?logo=docker" alt="Descargas de Docker"></a>
|
||||
<br>
|
||||
<a href="https://console.paperspace.com/github/ultralytics/ultralytics"><img src="https://assets.paperspace.io/img/gradient-badge.svg" alt="Ejecutar en Gradient"/></a>
|
||||
<a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Abrir en Colab"></a>
|
||||
<a href="https://www.kaggle.com/ultralytics/yolov8"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Abrir en Kaggle"></a>
|
||||
</div>
|
||||
|
||||
Presentamos [Ultralytics](https://ultralytics.com) [YOLOv8](https://github.com/ultralytics/ultralytics), la última versión del aclamado modelo para detección de objetos y segmentación de imágenes en tiempo real. YOLOv8 está construido sobre avances de vanguardia en aprendizaje profundo y visión por computadora, ofreciendo un rendimiento sin paralelo en términos de velocidad y precisión. Su diseño simplificado lo hace adecuado para varias aplicaciones y fácilmente adaptable a diferentes plataformas de hardware, desde dispositivos de borde hasta API en la nube.
|
||||
|
||||
Explore los documentos de YOLOv8, un recurso integral diseñado para ayudarle a comprender y utilizar sus características y capacidades. Independientemente de que sea un practicante experimentado en aprendizaje automático o nuevo en el campo, este centro tiene como objetivo maximizar el potencial de YOLOv8 en sus proyectos.
|
||||
|
||||
!!! note
|
||||
|
||||
🚧 Nuestra documentación en varios idiomas está actualmente en construcción y estamos trabajando duro para mejorarla. ¡Gracias por su paciencia! 🙏
|
||||
|
||||
## Dónde empezar
|
||||
|
||||
- **Instalar** `ultralytics` con pip y comenzar a funcionar en minutos [:material-clock-fast: Comenzar](quickstart.md){ .md-button }
|
||||
- **Predecir** nuevas imágenes y videos con YOLOv8 [:octicons-image-16: Predecir en Imágenes](modes/predict.md){ .md-button }
|
||||
- **Entrenar** un nuevo modelo YOLOv8 en su propio conjunto de datos personalizado [:fontawesome-solid-brain: Entrenar un Modelo](modes/train.md){ .md-button }
|
||||
- **Explorar** tareas de YOLOv8 como segmentar, clasificar, posar y seguir [:material-magnify-expand: Explorar Tareas](tasks/index.md){ .md-button }
|
||||
|
||||
<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 Su Conjunto de Datos Personalizado en <a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb" target="_blank">Google Colab</a>.
|
||||
</p>
|
||||
|
||||
## YOLO: Una Breve Historia
|
||||
|
||||
[YOLO](https://arxiv.org/abs/1506.02640) (You Only Look Once), un modelo popular de detección de objetos y segmentación de imágenes, fue desarrollado por Joseph Redmon y Ali Farhadi en la Universidad de Washington. Lanzado en 2015, YOLO rápidamente ganó popularidad por su alta velocidad y precisión.
|
||||
|
||||
- [YOLOv2](https://arxiv.org/abs/1612.08242), lanzado en 2016, mejoró el modelo original incorporando normalización por lotes, cajas ancla y clústeres de dimensiones.
|
||||
- [YOLOv3](https://pjreddie.com/media/files/papers/YOLOv3.pdf), lanzado en 2018, mejoró aún más el rendimiento del modelo usando una red dorsal más eficiente, múltiples anclas y agrupación piramidal espacial.
|
||||
- [YOLOv4](https://arxiv.org/abs/2004.10934) fue lanzado en 2020, introduciendo innovaciones como la ampliación de datos del mosaico, un nuevo cabezal de detección sin ancla y una nueva función de pérdida.
|
||||
- [YOLOv5](https://github.com/ultralytics/yolov5) mejoró aún más el rendimiento del modelo y agregó nuevas características como la optimización de hiperparámetros, seguimiento de experimentos integrados y exportación automática a formatos de exportación populares.
|
||||
- [YOLOv6](https://github.com/meituan/YOLOv6) fue publicado en código abierto por [Meituan](https://about.meituan.com/) en 2022 y se utiliza en muchos de los robots de entrega autónomos de la empresa.
|
||||
- [YOLOv7](https://github.com/WongKinYiu/yolov7) añadió tareas adicionales como la estimación de posturas en el conjunto de datos COCO keypoints.
|
||||
- [YOLOv8](https://github.com/ultralytics/ultralytics) es la última versión de YOLO de Ultralytics. Como un modelo de vanguardia y del estado del arte (SOTA), YOLOv8 se basa en el éxito de las versiones anteriores, introduciendo nuevas características y mejoras para obtener un rendimiento mejorado, flexibilidad y eficiencia. YOLOv8 soporta una gama completa de tareas de IA de visión, incluyendo [detección](tasks/detect.md), [segmentación](tasks/segment.md), [estimación de pose](tasks/pose.md), [seguimiento](modes/track.md) y [clasificación](tasks/classify.md). Esta versatilidad permite a los usuarios aprovechar las capacidades de YOLOv8 en una amplia gama de aplicaciones y dominios.
|
||||
|
||||
## Licencias de YOLO: ¿Cómo están licenciados los YOLO de Ultralytics?
|
||||
|
||||
Ultralytics ofrece dos opciones de licencia para acomodar casos de uso diversos:
|
||||
|
||||
- **Licencia AGPL-3.0**: Esta licencia de código abierto aprobada por [OSI](https://opensource.org/licenses/) es ideal para estudiantes y entusiastas, promoviendo la colaboración abierta y el intercambio de conocimiento. Consulte el archivo [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) para obtener más detalles.
|
||||
- **Licencia Empresarial**: Diseñada para uso comercial, esta licencia permite la integración sin problemas de software de Ultralytics y modelos de IA en bienes y servicios comerciales, eludiendo los requisitos de código abierto de AGPL-3.0. Si su escenario implica la incorporación de nuestras soluciones en una oferta comercial, póngase en contacto a través de [Licencias de Ultralytics](https://ultralytics.com/license).
|
||||
|
||||
Nuestra estrategia de licenciamiento está diseñada para asegurar que cualquier mejora a nuestros proyectos de código abierto se devuelva a la comunidad. Mantenemos los principios del código abierto cerca de nuestros corazones ❤️, y nuestra misión es garantizar que nuestras contribuciones puedan ser utilizadas y ampliadas de formas que sean beneficiosas para todos.
|
||||
94
docs/es/models/index.md
Normal file
94
docs/es/models/index.md
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explora la amplia gama de modelos de la familia YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS y RT-DETR compatibles con Ultralytics. Comienza con ejemplos de uso tanto para CLI como para Python.
|
||||
keywords: Ultralytics, documentación, YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS, RT-DETR, modelos, arquitecturas, Python, CLI
|
||||
---
|
||||
|
||||
# Modelos soportados por Ultralytics
|
||||
|
||||
¡Bienvenido a la documentación de modelos de Ultralytics! Ofrecemos soporte para una amplia gama de modelos, cada uno adaptado a tareas específicas como [detección de objetos](../tasks/detect.md), [segmentación de instancias](../tasks/segment.md), [clasificación de imágenes](../tasks/classify.md), [estimación de postura](../tasks/pose.md) y [seguimiento de múltiples objetos](../modes/track.md). Si estás interesado en contribuir con tu arquitectura de modelo a Ultralytics, consulta nuestra [Guía de Contribución](../../help/contributing.md).
|
||||
|
||||
!!! note
|
||||
|
||||
🚧 Nuestra documentación en varios idiomas está actualmente en construcción y estamos trabajando arduamente para mejorarla. ¡Gracias por tu paciencia! 🙏
|
||||
|
||||
## Modelos Destacados
|
||||
|
||||
Aquí tienes algunos de los modelos clave soportados:
|
||||
|
||||
1. **[YOLOv3](../../models/yolov3.md)**: La tercera iteración de la familia de modelos YOLO, originalmente creada por Joseph Redmon, conocida por su capacidad de detección de objetos en tiempo real de manera eficiente.
|
||||
2. **[YOLOv4](../../models/yolov4.md)**: Una actualización para la red oscura de YOLOv3, lanzada por Alexey Bochkovskiy en 2020.
|
||||
3. **[YOLOv5](../../models/yolov5.md)**: Una versión mejorada de la arquitectura YOLO por Ultralytics, que ofrece mejores compensaciones de rendimiento y velocidad en comparación con versiones anteriores.
|
||||
4. **[YOLOv6](../../models/yolov6.md)**: Lanzado por [Meituan](https://about.meituan.com/) en 2022, y utilizado en muchos de los robots autónomos de entrega de la compañía.
|
||||
5. **[YOLOv7](../../models/yolov7.md)**: Modelos YOLO actualizados lanzados en 2022 por los autores de YOLOv4.
|
||||
6. **[YOLOv8](../../models/yolov8.md)**: La última versión de la familia YOLO, que presenta capacidades mejoradas como segmentación de instancias, estimación de postura/puntos clave y clasificación.
|
||||
7. **[Modelo de Segmentación de Cualquier Cosa (SAM)](../../models/sam.md)**: El Modelo de Segmentación de Cualquier Cosa (SAM) de Meta.
|
||||
8. **[Modelo de Segmentación de Cualquier Cosa Móvil (MobileSAM)](../../models/mobile-sam.md)**: MobileSAM para aplicaciones móviles, por la Universidad Kyung Hee.
|
||||
9. **[Modelo de Segmentación de Cualquier Cosa Rápida (FastSAM)](../../models/fast-sam.md)**: FastSAM del Grupo de Análisis de Imágenes y Video, Instituto de Automatización, Academia China de Ciencias.
|
||||
10. **[YOLO-NAS](../../models/yolo-nas.md)**: Modelos de Búsqueda de Arquitectura Neural de YOLO (NAS).
|
||||
11. **[Transformadores de Detección en Tiempo Real (RT-DETR)](../../models/rtdetr.md)**: Modelos de Transformadores de Detección en Tiempo Real (RT-DETR) de Baidu PaddlePaddle.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/MWq1UxqTClU?si=nHAW-lYDzrz68jR0"
|
||||
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> Ejecuta modelos YOLO de Ultralytics en solo unas pocas líneas de código.
|
||||
</p>
|
||||
|
||||
## Comenzando: Ejemplos de Uso
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
Los modelos preentrenados en PyTorch `*.pt` así como los archivos de configuración `*.yaml` pueden pasarse a las clases `YOLO()`, `SAM()`, `NAS()` y `RTDETR()` para crear una instancia de modelo en Python:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo YOLOv8n preentrenado en COCO
|
||||
modelo = YOLO('yolov8n.pt')
|
||||
|
||||
# Mostrar información del modelo (opcional)
|
||||
modelo.info()
|
||||
|
||||
# Entrenar el modelo en el conjunto de datos de ejemplo COCO8 durante 100 épocas
|
||||
resultados = modelo.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# Ejecutar inferencia con el modelo YOLOv8n en la imagen 'bus.jpg'
|
||||
resultados = modelo('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
Comandos CLI están disponibles para ejecutar directamente los modelos:
|
||||
|
||||
```bash
|
||||
# Cargar un modelo YOLOv8n preentrenado en COCO y entrenarlo en el conjunto de datos de ejemplo COCO8 durante 100 épocas
|
||||
yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# Cargar un modelo YOLOv8n preentrenado en COCO y ejecutar inferencia en la imagen 'bus.jpg'
|
||||
yolo predict model=yolov8n.pt source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## Contribuyendo con Nuevos Modelos
|
||||
|
||||
¿Interesado en contribuir con tu modelo a Ultralytics? ¡Genial! Siempre estamos abiertos a expandir nuestro portafolio de modelos.
|
||||
|
||||
1. **Haz un Fork del Repositorio**: Comienza haciendo un fork del [repositorio de GitHub de Ultralytics](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
2. **Clona tu Fork**: Clona tu fork en tu máquina local y crea una nueva rama para trabajar.
|
||||
|
||||
3. **Implementa tu Modelo**: Añade tu modelo siguiendo los estándares y guías de codificación proporcionados en nuestra [Guía de Contribución](../../help/contributing.md).
|
||||
|
||||
4. **Prueba a Fondo**: Asegúrate de probar tu modelo rigurosamente, tanto de manera aislada como parte del pipeline.
|
||||
|
||||
5. **Crea un Pull Request**: Una vez que estés satisfecho con tu modelo, crea un pull request al repositorio principal para su revisión.
|
||||
|
||||
6. **Revisión de Código y Fusión**: Después de la revisión, si tu modelo cumple con nuestros criterios, se fusionará en el repositorio principal.
|
||||
|
||||
Consulta nuestra [Guía de Contribución](../../help/contributing.md) para los pasos detallados.
|
||||
94
docs/es/modes/benchmark.md
Normal file
94
docs/es/modes/benchmark.md
Normal 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
108
docs/es/modes/export.md
Normal 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
73
docs/es/modes/index.md
Normal 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
226
docs/es/modes/predict.md
Normal 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 | 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
200
docs/es/modes/track.md
Normal 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 | 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
206
docs/es/modes/train.md
Normal 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
86
docs/es/modes/val.md
Normal 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' |
|
||||
|
|
||||
187
docs/es/quickstart.md
Normal file
187
docs/es/quickstart.md
Normal file
|
|
@ -0,0 +1,187 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore diversos métodos para instalar Ultralytics usando pip, conda, git y Docker. Aprende cómo usar Ultralytics con la interfaz de línea de comandos o dentro de tus proyectos de Python.
|
||||
keywords: instalación de Ultralytics, pip install Ultralytics, instalación de Docker Ultralytics, interfaz de línea de comandos de Ultralytics, interfaz de Python de Ultralytics
|
||||
---
|
||||
|
||||
## Instalar Ultralytics
|
||||
|
||||
Ultralytics ofrece varios métodos de instalación incluyendo pip, conda y Docker. Instala YOLOv8 a través del paquete `ultralytics` de pip para la última versión estable o clonando el [repositorio de GitHub de Ultralytics](https://github.com/ultralytics/ultralytics) para obtener la versión más actualizada. Docker se puede utilizar para ejecutar el paquete en un contenedor aislado, evitando la instalación local.
|
||||
|
||||
!!! example "Instalar"
|
||||
|
||||
=== "Instalación con Pip (recomendado)"
|
||||
Instala el paquete `ultralytics` usando pip o actualiza una instalación existente ejecutando `pip install -U ultralytics`. Visita el Índice de Paquetes de Python (PyPI) para más detalles sobre el paquete `ultralytics`: [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/).
|
||||
|
||||
[](https://badge.fury.io/py/ultralytics) [](https://pepy.tech/project/ultralytics)
|
||||
|
||||
```bash
|
||||
# Instalar el paquete ultralytics desde PyPI
|
||||
pip install ultralytics
|
||||
```
|
||||
|
||||
También puedes instalar el paquete `ultralytics` directamente del [repositorio](https://github.com/ultralytics/ultralytics) en GitHub. Esto puede ser útil si quieres la última versión de desarrollo. Asegúrate de tener la herramienta de línea de comandos Git instalada en tu sistema. El comando `@main` instala la rama `main` y puede modificarse a otra rama, es decir, `@my-branch`, o eliminarse por completo para volver por defecto a la rama `main`.
|
||||
|
||||
```bash
|
||||
# Instalar el paquete ultralytics desde GitHub
|
||||
pip install git+https://github.com/ultralytics/ultralytics.git@main
|
||||
```
|
||||
|
||||
|
||||
=== "Instalación con Conda"
|
||||
Conda es un gestor de paquetes alternativo a pip que también puede utilizarse para la instalación. Visita Anaconda para más detalles en [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics). El repositorio de paquetes de alimentación de Ultralytics para actualizar el paquete de conda está en [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/).
|
||||
|
||||
|
||||
[](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics) [](https://anaconda.org/conda-forge/ultralytics)
|
||||
|
||||
```bash
|
||||
# Instalar el paquete ultralytics usando conda
|
||||
conda install -c conda-forge ultralytics
|
||||
```
|
||||
|
||||
!!! note
|
||||
|
||||
Si estás instalando en un entorno CUDA, la mejor práctica es instalar `ultralytics`, `pytorch` y `pytorch-cuda` en el mismo comando para permitir que el gestor de paquetes de conda resuelva cualquier conflicto, o en su defecto instalar `pytorch-cuda` al final para permitir que sobrescriba el paquete específico de CPU `pytorch` si es necesario.
|
||||
```bash
|
||||
# Instalar todos los paquetes juntos usando conda
|
||||
conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
|
||||
```
|
||||
|
||||
### Imagen Docker de Conda
|
||||
|
||||
Las imágenes Docker de Conda de Ultralytics también están disponibles en [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics). Estas imágenes están basadas en [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) y son una manera simple de comenzar a usar `ultralytics` en un entorno Conda.
|
||||
|
||||
```bash
|
||||
# Establecer el nombre de la imagen como una variable
|
||||
t=ultralytics/ultralytics:latest-conda
|
||||
|
||||
# Descargar la última imagen de ultralytics de Docker Hub
|
||||
sudo docker pull $t
|
||||
|
||||
# Ejecutar la imagen de ultralytics en un contenedor con soporte para GPU
|
||||
sudo docker run -it --ipc=host --gpus all $t # todas las GPUs
|
||||
sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # especificar GPUs
|
||||
```
|
||||
|
||||
=== "Clonar con Git"
|
||||
Clona el repositorio `ultralytics` si estás interesado en contribuir al desarrollo o deseas experimentar con el código fuente más reciente. Después de clonar, navega al directorio e instala el paquete en modo editable `-e` usando pip.
|
||||
```bash
|
||||
# Clonar el repositorio ultralytics
|
||||
git clone https://github.com/ultralytics/ultralytics
|
||||
|
||||
# Navegar al directorio clonado
|
||||
cd ultralytics
|
||||
|
||||
# Instalar el paquete en modo editable para desarrollo
|
||||
pip install -e .
|
||||
```
|
||||
|
||||
Consulta el archivo [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt) de `ultralytics` para ver una lista de dependencias. Ten en cuenta que todos los ejemplos anteriores instalan todas las dependencias requeridas.
|
||||
|
||||
!!! tip "Consejo"
|
||||
|
||||
Los requisitos de PyTorch varían según el sistema operativo y los requisitos de CUDA, por lo que se recomienda instalar primero PyTorch siguiendo las instrucciones en [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally).
|
||||
|
||||
<a href="https://pytorch.org/get-started/locally/">
|
||||
<img width="800" alt="Instrucciones de Instalación de PyTorch" src="https://user-images.githubusercontent.com/26833433/228650108-ab0ec98a-b328-4f40-a40d-95355e8a84e3.png">
|
||||
</a>
|
||||
|
||||
## Usar Ultralytics con CLI
|
||||
|
||||
La interfaz de línea de comandos (CLI) de Ultralytics permite el uso de comandos simples de una sola línea sin la necesidad de un entorno de Python. La CLI no requiere personalización ni código Python. Puedes simplemente ejecutar todas las tareas desde el terminal con el comando `yolo`. Consulta la [Guía de CLI](../usage/cli.md) para aprender más sobre el uso de YOLOv8 desde la línea de comandos.
|
||||
|
||||
!!! example
|
||||
|
||||
=== "Sintaxis"
|
||||
|
||||
Los comandos `yolo` de Ultralytics usan la siguiente sintaxis:
|
||||
```bash
|
||||
yolo TAREA MODO ARGUMENTOS
|
||||
|
||||
Donde TAREA (opcional) es uno de [detectar, segmentar, clasificar]
|
||||
MODO (requerido) es uno de [train, val, predict, export, track]
|
||||
ARGUMENTOS (opcionales) son cualquier número de pares personalizados 'arg=valor' como 'imgsz=320' que sobrescriben los valores por defecto.
|
||||
```
|
||||
Ver todos los ARGUMENTOS en la guía completa [Configuration Guide](../usage/cfg.md) o con `yolo cfg`
|
||||
|
||||
=== "Entrenar"
|
||||
|
||||
Entrenar un modelo de detección durante 10 épocas con una tasa de aprendizaje inicial de 0.01
|
||||
```bash
|
||||
yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
|
||||
```
|
||||
|
||||
=== "Predecir"
|
||||
|
||||
Predecir un video de YouTube usando un modelo de segmentación preentrenado con un tamaño de imagen de 320:
|
||||
```bash
|
||||
yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
|
||||
```
|
||||
|
||||
=== "Validar"
|
||||
|
||||
Validar un modelo de detección preentrenado con un tamaño de lote de 1 y un tamaño de imagen de 640:
|
||||
```bash
|
||||
yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640
|
||||
```
|
||||
|
||||
=== "Exportar"
|
||||
|
||||
Exportar un modelo de clasificación YOLOv8n a formato ONNX con un tamaño de imagen de 224 por 128 (no se requiere TAREA)
|
||||
```bash
|
||||
yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
|
||||
```
|
||||
|
||||
=== "Especial"
|
||||
|
||||
Ejecutar comandos especiales para ver la versión, ver configuraciones, ejecutar chequeos y más:
|
||||
```bash
|
||||
yolo help
|
||||
yolo checks
|
||||
yolo version
|
||||
yolo settings
|
||||
yolo copy-cfg
|
||||
yolo cfg
|
||||
```
|
||||
|
||||
!!! warning "Advertencia"
|
||||
|
||||
Los argumentos deben pasarse como pares `arg=valor`, separados por un signo igual `=` y delimitados por espacios ` ` entre pares. No utilices prefijos de argumentos `--` ni comas `,` entre los argumentos.
|
||||
|
||||
- `yolo predict model=yolov8n.pt imgsz=640 conf=0.25` ✅
|
||||
- `yolo predict model yolov8n.pt imgsz 640 conf 0.25` ❌
|
||||
- `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25` ❌
|
||||
|
||||
[Guía de CLI](../usage/cli.md){.md-button .md-button--primary}
|
||||
|
||||
## Usar Ultralytics con Python
|
||||
|
||||
La interfaz de Python de YOLOv8 permite una integración perfecta en tus proyectos de Python, facilitando la carga, ejecución y procesamiento de la salida del modelo. Diseñada con sencillez y facilidad de uso en mente, la interfaz de Python permite a los usuarios implementar rápidamente la detección de objetos, segmentación y clasificación en sus proyectos. Esto hace que la interfaz de Python de YOLOv8 sea una herramienta invaluable para cualquier persona que busque incorporar estas funcionalidades en sus proyectos de 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 solo unas pocas líneas de código. Consulta la [Guía de Python](../usage/python.md) para aprender más sobre el uso de YOLOv8 dentro de tus proyectos de Python.
|
||||
|
||||
!!! example
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Crear un nuevo modelo YOLO desde cero
|
||||
model = YOLO('yolov8n.yaml')
|
||||
|
||||
# Cargar un modelo YOLO preentrenado (recomendado para entrenamiento)
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# Entrenar el modelo usando el conjunto de datos 'coco128.yaml' durante 3 épocas
|
||||
results = model.train(data='coco128.yaml', epochs=3)
|
||||
|
||||
# Evaluar el rendimiento del modelo en el conjunto de validación
|
||||
results = model.val()
|
||||
|
||||
# Realizar detección de objetos en una imagen usando el modelo
|
||||
results = model('https://ultralytics.com/images/bus.jpg')
|
||||
|
||||
# Exportar el modelo al formato ONNX
|
||||
success = model.export(format='onnx')
|
||||
```
|
||||
|
||||
[Guía de Python](../usage/python.md){.md-button .md-button--primary}
|
||||
172
docs/es/tasks/classify.md
Normal file
172
docs/es/tasks/classify.md
Normal file
|
|
@ -0,0 +1,172 @@
|
|||
---
|
||||
comments: true
|
||||
description: Aprenda sobre los modelos de clasificación de imágenes YOLOv8 Classify. Obtenga información detallada sobre la Lista de Modelos Preentrenados y cómo Entrenar, Validar, Predecir y Exportar modelos.
|
||||
keywords: Ultralytics, YOLOv8, Clasificación de imágenes, Modelos preentrenados, YOLOv8n-cls, Entrenamiento, Validación, Predicción, Exportación de modelos
|
||||
---
|
||||
|
||||
# Clasificación de Imágenes
|
||||
|
||||
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418606-adf35c62-2e11-405d-84c6-b84e7d013804.png" alt="Ejemplos de clasificación de imágenes">
|
||||
|
||||
La clasificación de imágenes es la tarea más sencilla de las tres y consiste en 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 conocer dónde están ubicados los objetos de esa clase o cuál es su forma exacta.
|
||||
|
||||
!!! tip "Consejo"
|
||||
|
||||
Los modelos YOLOv8 Classify utilizan el sufijo `-cls`, por ejemplo, `yolov8n-cls.pt` y están preentrenados en [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
|
||||
|
||||
## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
|
||||
|
||||
Los modelos Classify preentrenados YOLOv8 se muestran aquí. Los modelos Detect, Segment y Pose están preentrenados en el conjunto de datos [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), mientras que los modelos Classify están preentrenados en el conjunto de datos [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
|
||||
|
||||
Los [modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se descargan automáticamente desde el último [lanzamiento](https://github.com/ultralytics/assets/releases) de Ultralytics en el primer uso.
|
||||
|
||||
| Modelo | Tamaño<br><sup>(píxeles) | Exactitud<br><sup>top1 | Exactitud<br><sup>top5 | Velocidad<br><sup>CPU ONNX<br>(ms) | Velocidad<br><sup>A100 TensorRT<br>(ms) | Parámetros<br><sup>(M) | FLOPs<br><sup>(B) en 640 |
|
||||
|----------------------------------------------------------------------------------------------|--------------------------|------------------------|------------------------|------------------------------------|-----------------------------------------|------------------------|--------------------------|
|
||||
| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-cls.pt) | 224 | 66.6 | 87.0 | 12.9 | 0.31 | 2.7 | 4.3 |
|
||||
| [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-cls.pt) | 224 | 72.3 | 91.1 | 23.4 | 0.35 | 6.4 | 13.5 |
|
||||
| [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-cls.pt) | 224 | 76.4 | 93.2 | 85.4 | 0.62 | 17.0 | 42.7 |
|
||||
| [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-cls.pt) | 224 | 78.0 | 94.1 | 163.0 | 0.87 | 37.5 | 99.7 |
|
||||
| [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-cls.pt) | 224 | 78.4 | 94.3 | 232.0 | 1.01 | 57.4 | 154.8 |
|
||||
|
||||
- Los valores de **Exactitud** son las precisiones de los modelos en el conjunto de datos de validación de [ImageNet](https://www.image-net.org/).
|
||||
<br>Para reproducir usar `yolo val classify data=path/to/ImageNet device=0`
|
||||
- **Velocidad** promediada sobre imágenes de validación de ImageNet usando una instancia de [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/)
|
||||
<br>Para reproducir usar `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu`
|
||||
|
||||
## Entrenamiento
|
||||
|
||||
Entrena el modelo YOLOv8n-cls en el conjunto de datos MNIST160 durante 100 épocas con un tamaño de imagen de 64. Para obtener una lista completa de argumentos disponibles, consulte la página de [Configuración](../../usage/cfg.md).
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo
|
||||
model = YOLO('yolov8n-cls.yaml') # construir un nuevo modelo desde YAML
|
||||
model = YOLO('yolov8n-cls.pt') # cargar un modelo preentrenado (recomendado para entrenamiento)
|
||||
model = YOLO('yolov8n-cls.yaml').load('yolov8n-cls.pt') # construir desde YAML y transferir pesos
|
||||
|
||||
# Entrenar el modelo
|
||||
results = model.train(data='mnist160', epochs=100, imgsz=64)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Construir un nuevo modelo desde YAML y empezar entrenamiento desde cero
|
||||
yolo classify train data=mnist160 model=yolov8n-cls.yaml epochs=100 imgsz=64
|
||||
|
||||
# Empezar entrenamiento desde un modelo *.pt preentrenado
|
||||
yolo classify train data=mnist160 model=yolov8n-cls.pt epochs=100 imgsz=64
|
||||
|
||||
# Construir un nuevo modelo desde YAML, transferir pesos preentrenados e iniciar entrenamiento
|
||||
yolo classify train data=mnist160 model=yolov8n-cls.yaml pretrained=yolov8n-cls.pt epochs=100 imgsz=64
|
||||
```
|
||||
|
||||
### Formato del conjunto de datos
|
||||
|
||||
El formato del conjunto de datos de clasificación YOLO puede encontrarse en detalle en la [Guía de Conjuntos de Datos](../../datasets/classify/index.md).
|
||||
|
||||
## Validación
|
||||
|
||||
Validar la exactitud del modelo YOLOv8n-cls entrenado en el conjunto de datos MNIST160. No es necesario pasar ningún argumento ya que el `modelo` retiene su `data` y argumentos como atributos del modelo.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo
|
||||
model = YOLO('yolov8n-cls.pt') # cargar un modelo oficial
|
||||
model = YOLO('path/to/best.pt') # cargar un modelo personalizado
|
||||
|
||||
# Validar el modelo
|
||||
metrics = model.val() # no se necesitan argumentos, el conjunto de datos y configuraciones se recuerdan
|
||||
metrics.top1 # precisión top1
|
||||
metrics.top5 # precisión top5
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo classify val model=yolov8n-cls.pt # validar modelo oficial
|
||||
yolo classify val model=path/to/best.pt # validar modelo personalizado
|
||||
```
|
||||
|
||||
## Predicción
|
||||
|
||||
Usar un modelo YOLOv8n-cls entrenado para realizar predicciones en imágenes.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo
|
||||
model = YOLO('yolov8n-cls.pt') # cargar un modelo oficial
|
||||
model = YOLO('path/to/best.pt') # cargar un modelo personalizado
|
||||
|
||||
# Predecir con el modelo
|
||||
results = model('https://ultralytics.com/images/bus.jpg') # predecir en una imagen
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo classify predict model=yolov8n-cls.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo oficial
|
||||
yolo classify predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo personalizado
|
||||
```
|
||||
|
||||
Ver detalles completos del modo `predict` en la página de [Predicción](https://docs.ultralytics.com/modes/predict/).
|
||||
|
||||
## Exportación
|
||||
|
||||
Exportar un modelo YOLOv8n-cls a un formato diferente como ONNX, CoreML, etc.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo
|
||||
model = YOLO('yolov8n-cls.pt') # cargar un modelo oficial
|
||||
model = YOLO('path/to/best.pt') # cargar un modelo entrenado personalizado
|
||||
|
||||
# Exportar el modelo
|
||||
model.export(format='onnx')
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo export model=yolov8n-cls.pt format=onnx # exportar modelo oficial
|
||||
yolo export model=path/to/best.pt format=onnx # exportar modelo entrenado personalizado
|
||||
```
|
||||
|
||||
Los formatos de exportación disponibles para YOLOv8-cls se encuentran en la tabla a continuación. Puede predecir o validar directamente en modelos exportados, por ejemplo, `yolo predict model=yolov8n-cls.onnx`. Ejemplos de uso se muestran para su modelo después de que se completa la exportación.
|
||||
|
||||
| Formato | Argumento `format` | Modelo | Metadatos | Argumentos |
|
||||
|--------------------------------------------------------------------|--------------------|-------------------------------|-----------|-----------------------------------------------------|
|
||||
| [PyTorch](https://pytorch.org/) | - | `yolov8n-cls.pt` | ✅ | - |
|
||||
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-cls.torchscript` | ✅ | `imgsz`, `optimize` |
|
||||
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-cls.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
|
||||
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-cls_openvino_model/` | ✅ | `imgsz`, `half` |
|
||||
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-cls.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
|
||||
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-cls.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` |
|
||||
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-cls_saved_model/` | ✅ | `imgsz`, `keras` |
|
||||
| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-cls.pb` | ❌ | `imgsz` |
|
||||
| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-cls.tflite` | ✅ | `imgsz`, `half`, `int8` |
|
||||
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-cls_edgetpu.tflite` | ✅ | `imgsz` |
|
||||
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-cls_web_model/` | ✅ | `imgsz` |
|
||||
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-cls_paddle_model/` | ✅ | `imgsz` |
|
||||
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-cls_ncnn_model/` | ✅ | `imgsz`, `half` |
|
||||
|
||||
Vea detalles completos de `exportación` en la página de [Exportación](https://docs.ultralytics.com/modes/export/).
|
||||
184
docs/es/tasks/detect.md
Normal file
184
docs/es/tasks/detect.md
Normal file
|
|
@ -0,0 +1,184 @@
|
|||
---
|
||||
comments: true
|
||||
description: Documentación oficial de YOLOv8 de Ultralytics. Aprende a entrenar, validar, predecir y exportar modelos en varios formatos. Incluyendo estadísticas detalladas de rendimiento.
|
||||
keywords: YOLOv8, Ultralytics, detección de objetos, modelos preentrenados, entrenamiento, validación, predicción, exportación de modelos, COCO, ImageNet, PyTorch, ONNX, CoreML
|
||||
---
|
||||
|
||||
# Detección de Objetos
|
||||
|
||||
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418624-5785cb93-74c9-4541-9179-d5c6782d491a.png" alt="Ejemplos de detección de objetos">
|
||||
|
||||
La detección de objetos es una tarea que implica identificar la ubicación y clase de objetos en una imagen o flujo de video.
|
||||
|
||||
La salida de un detector de objetos es un conjunto de cajas delimitadoras que encierran a los objetos en la imagen, junto con etiquetas de clase y puntajes de confianza para cada caja. La detección de objetos es una buena opción cuando necesitas identificar objetos de interés en una escena, pero no necesitas saber exactamente dónde se encuentra el objeto o su forma exacta.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/5ku7npMrW40?si=6HQO1dDXunV8gekh"
|
||||
title="Reproductor de video YouTube" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
permitir pantalla completa>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Ver:</strong> Detección de Objetos con Modelo Preentrenado YOLOv8 de Ultralytics.
|
||||
</p>
|
||||
|
||||
!!! tip "Consejo"
|
||||
|
||||
Los modelos YOLOv8 Detect son los modelos predeterminados de YOLOv8, es decir, `yolov8n.pt` y están preentrenados en [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
|
||||
|
||||
## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
|
||||
|
||||
Los modelos preentrenados de YOLOv8 Detect se muestran aquí. Los modelos de Detect, Segment y Pose están preentrenados en el conjunto de datos [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), mientras que los modelos de Classify están preentrenados en el conjunto de datos [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
|
||||
|
||||
Los [modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se descargan automáticamente desde el último lanzamiento de Ultralytics [release](https://github.com/ultralytics/assets/releases) en el primer uso.
|
||||
|
||||
| Modelo | tamaño<br><sup>(píxeles) | mAP<sup>val<br>50-95 | Velocidad<br><sup>CPU ONNX<br>(ms) | Velocidad<br><sup>A100 TensorRT<br>(ms) | parámetros<br><sup>(M) | FLOPs<br><sup>(B) |
|
||||
|--------------------------------------------------------------------------------------|--------------------------|----------------------|------------------------------------|-----------------------------------------|------------------------|-------------------|
|
||||
| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 |
|
||||
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 |
|
||||
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 |
|
||||
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 |
|
||||
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 |
|
||||
|
||||
- Los valores de **mAP<sup>val</sup>** son para un solo modelo a una sola escala en el conjunto de datos [COCO val2017](http://cocodataset.org).
|
||||
<br>Reproduce utilizando `yolo val detect data=coco.yaml device=0`
|
||||
- La **Velocidad** es el promedio sobre las imágenes de COCO val utilizando una instancia [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/).
|
||||
<br>Reproduce utilizando `yolo val detect data=coco128.yaml batch=1 device=0|cpu`
|
||||
|
||||
## Entrenamiento
|
||||
|
||||
Entrena a YOLOv8n en el conjunto de datos COCO128 durante 100 épocas a tamaño de imagen 640. Para una lista completa de argumentos disponibles, consulta la página [Configuración](../../usage/cfg.md).
|
||||
|
||||
!!! ejemplo ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo
|
||||
model = YOLO('yolov8n.yaml') # construye un nuevo modelo desde YAML
|
||||
model = YOLO('yolov8n.pt') # carga un modelo preentrenado (recomendado para entrenamiento)
|
||||
model = YOLO('yolov8n.yaml').load('yolov8n.pt') # construye desde YAML y transfiere los pesos
|
||||
|
||||
# Entrenar el modelo
|
||||
results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Construir un nuevo modelo desde YAML y comenzar entrenamiento desde cero
|
||||
yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
|
||||
|
||||
# Comenzar entrenamiento desde un modelo *.pt preentrenado
|
||||
yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
|
||||
# Construir un nuevo modelo desde YAML, transferir pesos preentrenados y comenzar entrenamiento
|
||||
yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### Formato del conjunto de datos
|
||||
|
||||
El formato del conjunto de datos de detección de YOLO se puede encontrar en detalle en la [Guía de Conjuntos de Datos](../../datasets/detect/index.md). Para convertir tu conjunto de datos existente desde otros formatos (como COCO, etc.) al formato YOLO, por favor usa la herramienta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) de Ultralytics.
|
||||
|
||||
## Validación
|
||||
|
||||
Valida 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.
|
||||
|
||||
!!! ejemplo ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo
|
||||
model = YOLO('yolov8n.pt') # cargar un modelo oficial
|
||||
model = YOLO('ruta/a/mejor.pt') # cargar un modelo personalizado
|
||||
|
||||
# Validar el modelo
|
||||
metrics = model.val() # sin argumentos necesarios, el conjunto de datos y configuraciones se recuerdan
|
||||
metrics.box.map # map50-95
|
||||
metrics.box.map50 # map50
|
||||
metrics.box.map75 # map75
|
||||
metrics.box.maps # una lista contiene map50-95 de cada categoría
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect val model=yolov8n.pt # validar modelo oficial
|
||||
yolo detect val model=ruta/a/mejor.pt # validar modelo personalizado
|
||||
```
|
||||
|
||||
## Predicción
|
||||
|
||||
Utiliza un modelo YOLOv8n entrenado para realizar predicciones en imágenes.
|
||||
|
||||
!!! ejemplo ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo
|
||||
model = YOLO('yolov8n.pt') # cargar un modelo oficial
|
||||
model = YOLO('ruta/a/mejor.pt') # cargar un modelo personalizado
|
||||
|
||||
# Predecir con el modelo
|
||||
results = model('https://ultralytics.com/images/bus.jpg') # predecir en una imagen
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo oficial
|
||||
yolo detect predict model=ruta/a/mejor.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo personalizado
|
||||
```
|
||||
|
||||
Consulta los detalles completos del modo `predict` en la página [Predicción](https://docs.ultralytics.com/modes/predict/).
|
||||
|
||||
## Exportación
|
||||
|
||||
Exporta un modelo YOLOv8n a un formato diferente como ONNX, CoreML, etc.
|
||||
|
||||
!!! ejemplo ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo
|
||||
model = YOLO('yolov8n.pt') # cargar un modelo oficial
|
||||
model = YOLO('ruta/a/mejor.pt') # cargar un modelo entrenado personalizado
|
||||
|
||||
# Exportar el modelo
|
||||
model.export(format='onnx')
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo export model=yolov8n.pt format=onnx # exportar modelo oficial
|
||||
yolo export model=ruta/a/mejor.pt format=onnx # exportar modelo entrenado personalizado
|
||||
```
|
||||
|
||||
Los formatos de exportación de YOLOv8 disponibles se encuentran en la tabla a continuación. Puedes predecir o validar directamente en modelos exportados, es decir, `yolo predict model=yolov8n.onnx`. Ejemplos de uso se muestran para tu modelo después de que la exportación se completa.
|
||||
|
||||
| Formato | Argumento `format` | Modelo | Metadata | Argumentos |
|
||||
|--------------------------------------------------------------------|--------------------|----------------------------|----------|------------------------------------------------------------------------|
|
||||
| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - |
|
||||
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimizar` |
|
||||
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `mitad`, `dinámico`, `simplificar`, `conjunto de operaciones` |
|
||||
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `modelo_yolov8n_openvino/` | ✅ | `imgsz`, `mitad` |
|
||||
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `mitad`, `dinámico`, `simplificar`, `espacio de trabajo` |
|
||||
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `mitad`, `int8`, `nms` |
|
||||
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `modelo_guardado_yolov8n/` | ✅ | `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`, `mitad`, `int8` |
|
||||
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` |
|
||||
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `modelo_web_yolov8n/` | ✅ | `imgsz` |
|
||||
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `modelo_yolov8n_paddle/` | ✅ | `imgsz` |
|
||||
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `modelo_ncnn_yolov8n/` | ✅ | `imgsz`, `mitad` |
|
||||
|
||||
Consulta los detalles completos de la `exportación` en la página [Exportar](https://docs.ultralytics.com/modes/export/).
|
||||
55
docs/es/tasks/index.md
Normal file
55
docs/es/tasks/index.md
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
---
|
||||
comments: true
|
||||
description: Aprenda sobre las tareas fundamentales de visión por computadora que YOLOv8 puede realizar, incluyendo detección, segmentación, clasificación y estimación de pose. Comprenda sus usos en sus proyectos de IA.
|
||||
keywords: Ultralytics, YOLOv8, Detección, Segmentación, Clasificación, Estimación de Pose, Marco de IA, Tareas de Visión por Computadora
|
||||
---
|
||||
|
||||
# Tareas de Ultralytics YOLOv8
|
||||
|
||||
<br>
|
||||
<img width="1024" src="https://raw.githubusercontent.com/ultralytics/assets/main/im/banner-tasks.png" alt="Tareas soportadas por Ultralytics YOLO">
|
||||
|
||||
YOLOv8 es un marco de trabajo de IA que soporta múltiples **tareas** de visión por computadora. El marco puede usarse para realizar [detección](detect.md), [segmentación](segment.md), [clasificación](classify.md) y estimación de [pose](pose.md). Cada una de estas tareas tiene un objetivo y caso de uso diferente.
|
||||
|
||||
!!! note
|
||||
|
||||
🚧 Nuestra documentación multilenguaje está actualmente en construcción y estamos trabajando arduamente para mejorarla. ¡Gracias por su paciencia! 🙏
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/NAs-cfq9BDw"
|
||||
title="Reproductor de video YouTube" frameborder="0"
|
||||
allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
|
||||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Mire:</strong> Explore las Tareas de Ultralytics YOLO: Detección de Objetos, Segmentación, Seguimiento y Estimación de Pose.
|
||||
</p>
|
||||
|
||||
## [Detección](detect.md)
|
||||
|
||||
La detección es la tarea principal soportada por YOLOv8. Implica detectar objetos en una imagen o cuadro de video y dibujar cuadros delimitadores alrededor de ellos. Los objetos detectados se clasifican en diferentes categorías basadas en sus características. YOLOv8 puede detectar múltiples objetos en una sola imagen o cuadro de video con alta precisión y velocidad.
|
||||
|
||||
[Ejemplos de Detección](detect.md){ .md-button .md-button--primary}
|
||||
|
||||
## [Segmentación](segment.md)
|
||||
|
||||
La segmentación es una tarea que implica segmentar una imagen en diferentes regiones basadas en el contenido de la imagen. A cada región se le asigna una etiqueta basada en su contenido. Esta tarea es útil en aplicaciones tales como segmentación de imágenes y imágenes médicas. YOLOv8 utiliza una variante de la arquitectura U-Net para realizar la segmentación.
|
||||
|
||||
[Ejemplos de Segmentación](segment.md){ .md-button .md-button--primary}
|
||||
|
||||
## [Clasificación](classify.md)
|
||||
|
||||
La clasificación es una tarea que implica clasificar una imagen en diferentes categorías. YOLOv8 puede usarse para clasificar imágenes basadas en su contenido. Utiliza una variante de la arquitectura EfficientNet para realizar la clasificación.
|
||||
|
||||
[Ejemplos de Clasificación](classify.md){ .md-button .md-button--primary}
|
||||
|
||||
## [Pose](pose.md)
|
||||
|
||||
La detección de pose/puntos clave es una tarea que implica detectar puntos específicos en una imagen o cuadro de video. Estos puntos se conocen como puntos clave y se utilizan para rastrear el movimiento o la estimación de la pose. YOLOv8 puede detectar puntos clave en una imagen o cuadro de video con alta precisión y velocidad.
|
||||
|
||||
[Ejemplos de Pose](pose.md){ .md-button .md-button--primary}
|
||||
|
||||
## Conclusión
|
||||
|
||||
YOLOv8 soporta múltiples tareas, incluyendo detección, segmentación, clasificación y detección de puntos clave. Cada una de estas tareas tiene diferentes objetivos y casos de uso. Al entender las diferencias entre estas tareas, puede elegir la tarea adecuada para su aplicación de visión por computadora.
|
||||
185
docs/es/tasks/pose.md
Normal file
185
docs/es/tasks/pose.md
Normal file
|
|
@ -0,0 +1,185 @@
|
|||
---
|
||||
comments: true
|
||||
description: Aprende a utilizar Ultralytics YOLOv8 para tareas de estimación de pose. Encuentra modelos preentrenados, aprende a entrenar, validar, predecir y exportar tus propios modelos.
|
||||
keywords: Ultralytics, YOLO, YOLOv8, estimación de pose, detección de puntos clave, detección de objetos, modelos preentrenados, aprendizaje automático, inteligencia artificial
|
||||
---
|
||||
|
||||
# Estimación de Pose
|
||||
|
||||
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418616-9811ac0b-a4a7-452a-8aba-484ba32bb4a8.png" alt="Ejemplos de estimación de pose">
|
||||
|
||||
La estimación de pose es una tarea que implica identificar la ubicación de puntos específicos en una imagen, comúnmente referidos como puntos clave. Estos puntos clave pueden representar varias partes del objeto, como articulaciones, puntos de referencia u otras características distintivas. La ubicación de los puntos clave generalmente se representa como un conjunto de coordenadas 2D `[x, y]` o 3D `[x, y, visible]`.
|
||||
|
||||
La salida de un modelo de estimación de pose es un conjunto de puntos que representan los puntos clave en un objeto de la imagen, generalmente junto con las puntuaciones de confianza para cada punto. La estimación de pose es una buena opción cuando se necesita identificar partes específicas de un objeto en una escena y su ubicación relativa entre ellas.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/Y28xXQmju64?si=pCY4ZwejZFu6Z4kZ"
|
||||
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> Estimación de Pose con Ultralytics YOLOv8.
|
||||
</p>
|
||||
|
||||
!!! tip "Consejo"
|
||||
|
||||
Los modelos _pose_ YOLOv8 utilizan el sufijo `-pose`, por ejemplo, `yolov8n-pose.pt`. Estos modelos están entrenados en el conjunto de datos [COCO keypoints](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml) y son adecuados para una variedad de tareas de estimación de pose.
|
||||
|
||||
## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
|
||||
|
||||
Aquí se muestran los modelos preentrenados de YOLOv8 Pose. Los modelos Detect, Segment y Pose están preentrenados en el conjunto de datos [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), mientras que los modelos Classify están preentrenados en el conjunto de datos [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
|
||||
|
||||
Los [modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se descargan automáticamente desde el último lanzamiento de Ultralytics [release](https://github.com/ultralytics/assets/releases) en el primer uso.
|
||||
|
||||
| Modelo | tamaño<br><sup>(píxeles) | mAP<sup>pose<br>50-95 | mAP<sup>pose<br>50 | Velocidad<br><sup>CPU ONNX<br>(ms) | Velocidad<br><sup>A100 TensorRT<br>(ms) | parámetros<br><sup>(M) | FLOPs<br><sup>(B) |
|
||||
|------------------------------------------------------------------------------------------------------|--------------------------|-----------------------|--------------------|------------------------------------|-----------------------------------------|------------------------|-------------------|
|
||||
| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-pose.pt) | 640 | 50.4 | 80.1 | 131.8 | 1.18 | 3.3 | 9.2 |
|
||||
| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-pose.pt) | 640 | 60.0 | 86.2 | 233.2 | 1.42 | 11.6 | 30.2 |
|
||||
| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-pose.pt) | 640 | 65.0 | 88.8 | 456.3 | 2.00 | 26.4 | 81.0 |
|
||||
| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-pose.pt) | 640 | 67.6 | 90.0 | 784.5 | 2.59 | 44.4 | 168.6 |
|
||||
| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose.pt) | 640 | 69.2 | 90.2 | 1607.1 | 3.73 | 69.4 | 263.2 |
|
||||
| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 |
|
||||
|
||||
- Los valores de **mAP<sup>val</sup>** son para un solo modelo a una sola escala en el conjunto de datos [COCO Keypoints val2017](http://cocodataset.org).
|
||||
<br>Reproducir con `yolo val pose data=coco-pose.yaml device=0`
|
||||
- **Velocidad** promediada sobre imágenes COCO val usando una instancia [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/).
|
||||
<br>Reproducir con `yolo val pose data=coco8-pose.yaml batch=1 device=0|cpu`
|
||||
|
||||
## Entrenar
|
||||
|
||||
Entrena un modelo YOLOv8-pose en el conjunto de datos COCO128-pose.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo
|
||||
model = YOLO('yolov8n-pose.yaml') # construir un nuevo modelo desde YAML
|
||||
model = YOLO('yolov8n-pose.pt') # cargar un modelo preentrenado (recomendado para entrenar)
|
||||
model = YOLO('yolov8n-pose.yaml').load('yolov8n-pose.pt') # construir desde YAML y transferir los pesos
|
||||
|
||||
# Entrenar el modelo
|
||||
results = model.train(data='coco8-pose.yaml', epochs=100, imgsz=640)
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Construir un nuevo modelo desde YAML y comenzar entrenamiento desde cero
|
||||
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml epochs=100 imgsz=640
|
||||
|
||||
# Empezar entrenamiento desde un modelo *.pt preentrenado
|
||||
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
|
||||
|
||||
# Construir un nuevo modelo desde YAML, transferir pesos preentrenados y comenzar entrenamiento
|
||||
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.yaml pretrained=yolov8n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### Formato del conjunto de datos
|
||||
|
||||
El formato del conjunto de datos de pose de YOLO se puede encontrar en detalle en la [Guía de Conjuntos de Datos](../../datasets/pose/index.md). Para convertir tu conjunto de datos existente de otros formatos (como COCO, etc.) al formato de YOLO, usa la herramienta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) de Ultralytics.
|
||||
|
||||
## Validar
|
||||
|
||||
Valida la precisión del modelo YOLOv8n-pose entrenado en el conjunto de datos COCO128-pose. No es necesario pasar ningún argumento ya que el `modelo` mantiene sus `datos` de entrenamiento y argumentos como atributos del modelo.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo
|
||||
model = YOLO('yolov8n-pose.pt') # cargar un modelo oficial
|
||||
model = YOLO('path/to/best.pt') # cargar un modelo personalizado
|
||||
|
||||
# Validar el modelo
|
||||
metrics = model.val() # no se necesitan argumentos, el conjunto de datos y configuraciones se recuerdan
|
||||
metrics.box.map # map50-95
|
||||
metrics.box.map50 # map50
|
||||
metrics.box.map75 # map75
|
||||
metrics.box.maps # una lista contiene map50-95 de cada categoría
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo pose val model=yolov8n-pose.pt # modelo oficial de val
|
||||
yolo pose val model=path/to/best.pt # modelo personalizado de val
|
||||
```
|
||||
|
||||
## Predecir
|
||||
|
||||
Usa un modelo YOLOv8n-pose entrenado para realizar predicciones en imágenes.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo
|
||||
model = YOLO('yolov8n-pose.pt') # cargar un modelo oficial
|
||||
model = YOLO('path/to/best.pt') # cargar un modelo personalizado
|
||||
|
||||
# Predecir con el modelo
|
||||
results = model('https://ultralytics.com/images/bus.jpg') # predecir en una imagen
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo pose predict model=yolov8n-pose.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo oficial
|
||||
yolo pose predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg' # predecir con modelo personalizado
|
||||
```
|
||||
|
||||
Consulta los detalles completos del modo `predict` en la página de [Predicción](https://docs.ultralytics.com/modes/predict/).
|
||||
|
||||
## Exportar
|
||||
|
||||
Exporta un modelo YOLOv8n Pose a un formato diferente como ONNX, CoreML, etc.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo
|
||||
model = YOLO('yolov8n-pose.pt') # cargar un modelo oficial
|
||||
model = YOLO('path/to/best.pt') # cargar un modelo entrenado personalizado
|
||||
|
||||
# Exportar el modelo
|
||||
model.export(format='onnx')
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo export model=yolov8n-pose.pt format=onnx # exportar modelo oficial
|
||||
yolo export model=path/to/best.pt format=onnx # exportar modelo entrenado personalizado
|
||||
```
|
||||
|
||||
Los formatos de exportación de YOLOv8-pose disponibles se muestran en la tabla a continuación. Puedes predecir o validar directamente en modelos exportados, por ejemplo, `yolo predict model=yolov8n-pose.onnx`. Los ejemplos de uso se muestran para tu modelo después de que la exportación se completa.
|
||||
|
||||
| Formato | Argumento `format` | Modelo | Metadatos | Argumentos |
|
||||
|--------------------------------------------------------------------|--------------------|--------------------------------|-----------|---------------------------------------------------------------|
|
||||
| [PyTorch](https://pytorch.org/) | - | `yolov8n-pose.pt` | ✅ | - |
|
||||
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-pose.torchscript` | ✅ | `imgsz`, `optimize` |
|
||||
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-pose.onnx` | ✅ | `imgsz`, `half`, `dinámico`, `simplify`, `opset` |
|
||||
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-pose_openvino_model/` | ✅ | `imgsz`, `half` |
|
||||
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-pose.engine` | ✅ | `imgsz`, `half`, `dinámico`, `simplify`, `espacio de trabajo` |
|
||||
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-pose.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` |
|
||||
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-pose_saved_model/` | ✅ | `imgsz`, `keras` |
|
||||
| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-pose.pb` | ❌ | `imgsz` |
|
||||
| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-pose.tflite` | ✅ | `imgsz`, `half`, `int8` |
|
||||
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-pose_edgetpu.tflite` | ✅ | `imgsz` |
|
||||
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-pose_web_model/` | ✅ | `imgsz` |
|
||||
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-pose_paddle_model/` | ✅ | `imgsz` |
|
||||
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-pose_ncnn_model/` | ✅ | `imgsz`, `half` |
|
||||
|
||||
Consulta los detalles completos del modo `export` en la página de [Exportación](https://docs.ultralytics.com/modes/export/).
|
||||
188
docs/es/tasks/segment.md
Normal file
188
docs/es/tasks/segment.md
Normal file
|
|
@ -0,0 +1,188 @@
|
|||
---
|
||||
comments: true
|
||||
description: Aprende a utilizar modelos de segmentación de instancias con Ultralytics YOLO. Instrucciones sobre entrenamiento, validación, predicción de imágenes y exportación de modelos.
|
||||
keywords: yolov8, segmentación de instancias, Ultralytics, conjunto de datos COCO, segmentación de imágenes, detección de objetos, entrenamiento de modelos, validación de modelos, predicción de imágenes, exportación de modelos.
|
||||
---
|
||||
|
||||
# Segmentación de Instancias
|
||||
|
||||
<img width="1024" src="https://user-images.githubusercontent.com/26833433/243418644-7df320b8-098d-47f1-85c5-26604d761286.png" alt="Ejemplos de segmentación de instancias">
|
||||
|
||||
La segmentación de instancias va un paso más allá de la detección de objetos e implica identificar objetos individuales en una imagen y segmentarlos del resto de la imagen.
|
||||
|
||||
La salida de un modelo de segmentación de instancias es un conjunto de máscaras o contornos que delimitan cada objeto en la imagen, junto con etiquetas de clase y puntajes de confianza para cada objeto. La segmentación de instancias es útil cuando necesitas saber no solo dónde están los objetos en una imagen, sino también cuál es su forma exacta.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
<iframe width="720" height="405" src="https://www.youtube.com/embed/o4Zd-IeMlSY?si=37nusCzDTd74Obsp"
|
||||
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> Ejecuta la Segmentación con el Modelo Ultralytics YOLOv8 Preentrenado en Python.
|
||||
</p>
|
||||
|
||||
!!! tip "Consejo"
|
||||
|
||||
Los modelos YOLOv8 Segment utilizan el sufijo `-seg`, es decir, `yolov8n-seg.pt` y están preentrenados en el [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
|
||||
|
||||
## [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
|
||||
|
||||
Aquí se muestran los modelos Segment preentrenados YOLOv8. Los modelos Detect, Segment y Pose están preentrenados en el conjunto de datos [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), mientras que los modelos Classify están preentrenados en el conjunto de datos [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
|
||||
|
||||
Los [Modelos](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) se descargan automáticamente desde el último lanzamiento de Ultralytics [release](https://github.com/ultralytics/assets/releases) en su primer uso.
|
||||
|
||||
| Modelo | Tamaño<br><sup>(píxeles) | mAP<sup>caja<br>50-95 | mAP<sup>máscara<br>50-95 | Velocidad<br><sup>CPU ONNX<br>(ms) | Velocidad<br><sup>A100 TensorRT<br>(ms) | Parámetros<br><sup>(M) | FLOPs<br><sup>(B) |
|
||||
|----------------------------------------------------------------------------------------------|--------------------------|-----------------------|--------------------------|------------------------------------|-----------------------------------------|------------------------|-------------------|
|
||||
| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 |
|
||||
| [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 |
|
||||
| [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 |
|
||||
| [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 |
|
||||
| [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
|
||||
|
||||
- Los valores **mAP<sup>val</sup>** son para un único modelo a una única escala en el conjunto de datos [COCO val2017](http://cocodataset.org).
|
||||
<br>Reproducir utilizando `yolo val segment data=coco.yaml device=0`
|
||||
- La **Velocidad** promediada sobre imágenes de COCO val utilizando una instancia de [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/).
|
||||
<br>Reproducir utilizando `yolo val segment data=coco128-seg.yaml batch=1 device=0|cpu`
|
||||
|
||||
## Entrenamiento
|
||||
|
||||
Entrena el modelo YOLOv8n-seg en el conjunto de datos COCO128-seg durante 100 épocas con tamaño de imagen de 640. Para una lista completa de argumentos disponibles, consulta la página de [Configuración](../../usage/cfg.md).
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo
|
||||
model = YOLO('yolov8n-seg.yaml') # construir un nuevo modelo desde YAML
|
||||
model = YOLO('yolov8n-seg.pt') # cargar un modelo preentrenado (recomendado para entrenamiento)
|
||||
model = YOLO('yolov8n-seg.yaml').load('yolov8n.pt') # construir desde YAML y transferir pesos
|
||||
|
||||
# Entrenar el modelo
|
||||
results = model.train(data='coco128-seg.yaml', epochs=100, imgsz=640)
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Construir un nuevo modelo desde YAML y comenzar a entrenar desde cero
|
||||
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml epochs=100 imgsz=640
|
||||
|
||||
# Comenzar a entrenar desde un modelo *.pt preentrenado
|
||||
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
|
||||
# Construir un nuevo modelo desde YAML, transferir pesos preentrenados y comenzar a entrenar
|
||||
yolo segment train data=coco128-seg.yaml model=yolov8n-seg.yaml pretrained=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### Formato del conjunto de datos
|
||||
|
||||
El formato del conjunto de datos de segmentación YOLO puede encontrarse detallado en la [Guía de Conjuntos de Datos](../../datasets/segment/index.md). Para convertir tu conjunto de datos existente de otros formatos (como COCO, etc.) al formato YOLO, utiliza la herramienta [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) de Ultralytics.
|
||||
|
||||
## Validación
|
||||
|
||||
Valida la precisión del modelo YOLOv8n-seg entrenado en el conjunto de datos COCO128-seg. No es necesario pasar ningún argumento ya que el `modelo` retiene sus `datos` de entrenamiento y argumentos como atributos del modelo.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo
|
||||
model = YOLO('yolov8n-seg.pt') # cargar un modelo oficial
|
||||
model = YOLO('ruta/a/mejor.pt') # cargar un modelo personalizado
|
||||
|
||||
# Validar el modelo
|
||||
metrics = model.val() # no se necesitan argumentos, el conjunto de datos y configuraciones se recuerdan
|
||||
metrics.box.map # map50-95(B)
|
||||
metrics.box.map50 # map50(B)
|
||||
metrics.box.map75 # map75(B)
|
||||
metrics.box.maps # una lista contiene map50-95(B) de cada categoría
|
||||
metrics.seg.map # map50-95(M)
|
||||
metrics.seg.map50 # map50(M)
|
||||
metrics.seg.map75 # map75(M)
|
||||
metrics.seg.maps # una lista contiene map50-95(M) de cada categoría
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo segment val model=yolov8n-seg.pt # validar el modelo oficial
|
||||
yolo segment val model=ruta/a/mejor.pt # validar el modelo personalizado
|
||||
```
|
||||
|
||||
## Predicción
|
||||
|
||||
Usa un modelo YOLOv8n-seg entrenado para realizar predicciones en imágenes.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo
|
||||
model = YOLO('yolov8n-seg.pt') # cargar un modelo oficial
|
||||
model = YOLO('ruta/a/mejor.pt') # cargar un modelo personalizado
|
||||
|
||||
# Predecir con el modelo
|
||||
results = model('https://ultralytics.com/images/bus.jpg') # predecir en una imagen
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo segment predict model=yolov8n-seg.pt source='https://ultralytics.com/images/bus.jpg' # predecir con el modelo oficial
|
||||
yolo segment predict model=ruta/a/mejor.pt source='https://ultralytics.com/images/bus.jpg' # predecir con el modelo personalizado
|
||||
```
|
||||
|
||||
Consulta todos los detalles del modo `predict` en la página de [Predicción](https://docs.ultralytics.com/modes/predict/).
|
||||
|
||||
## Exportación
|
||||
|
||||
Exporta un modelo YOLOv8n-seg a un formato diferente como ONNX, CoreML, etc.
|
||||
|
||||
!!! example ""
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo
|
||||
model = YOLO('yolov8n-seg.pt') # cargar un modelo oficial
|
||||
model = YOLO('ruta/a/mejor.pt') # cargar un modelo entrenado personalizado
|
||||
|
||||
# Exportar el modelo
|
||||
model.export(format='onnx')
|
||||
```
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo export model=yolov8n-seg.pt format=onnx # exportar el modelo oficial
|
||||
yolo export model=ruta/a/mejor.pt format=onnx # exportar el modelo entrenado personalizado
|
||||
```
|
||||
|
||||
Los formatos disponibles para exportar YOLOv8-seg se muestran en la tabla a continuación. Puedes predecir o validar directamente en modelos exportados, es decir, `yolo predict model=yolov8n-seg.onnx`. Se muestran ejemplos de uso para tu modelo después de que se completa la exportación.
|
||||
|
||||
| Formato | Argumento `format` | Modelo | Metadatos | Argumentos |
|
||||
|--------------------------------------------------------------------|--------------------|-------------------------------|-----------|-----------------------------------------------------|
|
||||
| [PyTorch](https://pytorch.org/) | - | `yolov8n-seg.pt` | ✅ | - |
|
||||
| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n-seg.torchscript` | ✅ | `imgsz`, `optimize` |
|
||||
| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n-seg.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
|
||||
| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n-seg_openvino_model/` | ✅ | `imgsz`, `half` |
|
||||
| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n-seg.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
|
||||
| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n-seg.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` |
|
||||
| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n-seg_saved_model/` | ✅ | `imgsz`, `keras` |
|
||||
| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n-seg.pb` | ❌ | `imgsz` |
|
||||
| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n-seg.tflite` | ✅ | `imgsz`, `half`, `int8` |
|
||||
| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n-seg_edgetpu.tflite` | ✅ | `imgsz` |
|
||||
| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n-seg_web_model/` | ✅ | `imgsz` |
|
||||
| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n-seg_paddle_model/` | ✅ | `imgsz` |
|
||||
| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n-seg_ncnn_model/` | ✅ | `imgsz`, `half` |
|
||||
|
||||
Consulta todos los detalles del modo `export` en la página de [Exportación](https://docs.ultralytics.com/modes/export/).
|
||||
Loading…
Add table
Add a link
Reference in a new issue