Update https://docs.ultralytics.com/models (#6513)
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
0c4e97443b
commit
16a13a1ce0
178 changed files with 14224 additions and 561 deletions
193
docs/es/models/fast-sam.md
Normal file
193
docs/es/models/fast-sam.md
Normal file
|
|
@ -0,0 +1,193 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explora FastSAM, una solución basada en CNN para la segmentación en tiempo real de objetos en imágenes. Ofrece una interacción mejorada del usuario, eficiencia computacional y es adaptable a diversas tareas de visión.
|
||||
keywords: FastSAM, aprendizaje automático, solución basada en CNN, segmentación de objetos, solución en tiempo real, Ultralytics, tareas de visión, procesamiento de imágenes, aplicaciones industriales, interacción del usuario
|
||||
---
|
||||
|
||||
# Modelo para Segmentar Cualquier Cosa Rápidamente (FastSAM)
|
||||
|
||||
El Modelo para Segmentar Cualquier Cosa Rápidamente (FastSAM) es una solución novedosa basada en CNN que funciona en tiempo real para la tarea de Segmentar Cualquier Cosa. Esta tarea está diseñada para segmentar cualquier objeto dentro de una imagen basándose en diversas indicaciones posibles de interacción del usuario. FastSAM reduce significativamente las demandas computacionales a la vez que mantiene un rendimiento competitivo, lo que lo convierte en una opción práctica para una variedad de tareas de visión.
|
||||
|
||||
|
||||
|
||||
## Descripción general
|
||||
|
||||
FastSAM está diseñado para abordar las limitaciones del [Modelo para Segmentar Cualquier Cosa (SAM)](sam.md), un modelo Transformer pesado con requerimientos sustanciales de recursos computacionales. FastSAM divide la tarea de segmentar cualquier cosa en dos etapas secuenciales: segmentación de todas las instancias y selección basada en indicaciones. La primera etapa utiliza [YOLOv8-seg](../tasks/segment.md) para producir las máscaras de segmentación de todas las instancias en la imagen. En la segunda etapa, produce la región de interés correspondiente a la indicación.
|
||||
|
||||
## Características principales
|
||||
|
||||
1. **Solución en tiempo real:** Al aprovechar la eficiencia computacional de las CNN, FastSAM proporciona una solución en tiempo real para la tarea de segmentar cualquier cosa, lo que lo hace valioso para aplicaciones industriales que requieren resultados rápidos.
|
||||
|
||||
2. **Eficiencia y rendimiento:** FastSAM ofrece una reducción significativa en las demandas computacionales y de recursos sin comprometer la calidad del rendimiento. Alcanza un rendimiento comparable al de SAM, pero con recursos computacionales drásticamente reducidos, lo que permite su aplicación en tiempo real.
|
||||
|
||||
3. **Segmentación guiada por indicaciones:** FastSAM puede segmentar cualquier objeto dentro de una imagen guiado por diversas indicaciones posibles de interacción del usuario, lo que proporciona flexibilidad y adaptabilidad en diferentes escenarios.
|
||||
|
||||
4. **Basado en YOLOv8-seg:** FastSAM se basa en [YOLOv8-seg](../tasks/segment.md), un detector de objetos equipado con una rama de segmentación de instancias. Esto le permite producir de manera efectiva las máscaras de segmentación de todas las instancias en una imagen.
|
||||
|
||||
5. **Resultados competitivos en pruebas de referencia:** En la tarea de propuesta de objetos de MS COCO, FastSAM alcanza puntuaciones altas a una velocidad significativamente más rápida que [SAM](sam.md) en una sola tarjeta NVIDIA RTX 3090, lo que demuestra su eficiencia y capacidad.
|
||||
|
||||
6. **Aplicaciones prácticas:** El enfoque propuesto proporciona una solución nueva y práctica para un gran número de tareas de visión a una velocidad muy alta, varias veces más rápida que los métodos actuales.
|
||||
|
||||
7. **Factibilidad de compresión del modelo:** FastSAM demuestra la factibilidad de un camino que puede reducir significativamente el esfuerzo computacional al introducir una prioridad artificial en la estructura, abriendo así nuevas posibilidades para la arquitectura de modelos grandes en tareas generales de visión.
|
||||
|
||||
## Modelos disponibles, tareas admitidas y modos de funcionamiento
|
||||
|
||||
Esta tabla presenta los modelos disponibles con sus pesos pre-entrenados específicos, las tareas que admiten y su compatibilidad con diferentes modos de funcionamiento, como [Inference](../modes/predict.md) (inferencia), [Validation](../modes/val.md) (validación), [Training](../modes/train.md) (entrenamiento) y [Export](../modes/export.md) (exportación), indicados mediante emojis ✅ para los modos admitidos y emojis ❌ para los modos no admitidos.
|
||||
|
||||
| Tipo de modelo | Pesos pre-entrenados | Tareas admitidas | Inferencia | Validación | Entrenamiento | Exportación |
|
||||
|----------------|----------------------|---------------------------------------------------|------------|------------|---------------|-------------|
|
||||
| FastSAM-s | `FastSAM-s.pt` | [Segmentación de Instancias](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
|
||||
| FastSAM-x | `FastSAM-x.pt` | [Segmentación de Instancias](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
|
||||
|
||||
## Ejemplos de uso
|
||||
|
||||
Los modelos FastSAM son fáciles de integrar en tus aplicaciones Python. Ultralytics proporciona una API y comandos de línea de comandos (CLI) fáciles de usar para agilizar el desarrollo.
|
||||
|
||||
### Uso de predicción
|
||||
|
||||
Para realizar la detección de objetos en una imagen, utiliza el método `predict` de la siguiente manera:
|
||||
|
||||
!!! Example "Ejemplo"
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
from ultralytics import FastSAM
|
||||
from ultralytics.models.fastsam import FastSAMPrompt
|
||||
|
||||
# Define una fuente de inferencia
|
||||
source = 'ruta/hacia/bus.jpg'
|
||||
|
||||
# Crea un modelo FastSAM
|
||||
model = FastSAM('FastSAM-s.pt') # o FastSAM-x.pt
|
||||
|
||||
# Ejecuta la inferencia en una imagen
|
||||
everything_results = model(source, device='cpu', retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
|
||||
|
||||
# Prepara un objeto de procesamiento de indicaciones
|
||||
prompt_process = FastSAMPrompt(source, everything_results, device='cpu')
|
||||
|
||||
# Indicación Everything
|
||||
ann = prompt_process.everything_prompt()
|
||||
|
||||
# Caja predeterminada [0,0,0,0] -> [x1,y1,x2,y2]
|
||||
ann = prompt_process.box_prompt(bbox=[200, 200, 300, 300])
|
||||
|
||||
# Indicación de texto
|
||||
ann = prompt_process.text_prompt(text='una foto de un perro')
|
||||
|
||||
# Indicación de punto
|
||||
# puntos predeterminados [[0,0]] [[x1,y1],[x2,y2]]
|
||||
# etiqueta_predeterminada [0] [1,0] 0:fondo, 1:primer plano
|
||||
ann = prompt_process.point_prompt(points=[[200, 200]], pointlabel=[1])
|
||||
prompt_process.plot(annotations=ann, output='./')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
```bash
|
||||
# Carga un modelo FastSAM y segmenta todo con él
|
||||
yolo segment predict model=FastSAM-s.pt source=ruta/hacia/bus.jpg imgsz=640
|
||||
```
|
||||
|
||||
Este fragmento de código demuestra la simplicidad de cargar un modelo pre-entrenado y realizar una predicción en una imagen.
|
||||
|
||||
### Uso de validación
|
||||
|
||||
La validación del modelo en un conjunto de datos se puede realizar de la siguiente manera:
|
||||
|
||||
!!! Example "Ejemplo"
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
from ultralytics import FastSAM
|
||||
|
||||
# Crea un modelo FastSAM
|
||||
model = FastSAM('FastSAM-s.pt') # o FastSAM-x.pt
|
||||
|
||||
# Valida el modelo
|
||||
results = model.val(data='coco8-seg.yaml')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
```bash
|
||||
# Carga un modelo FastSAM y valida en el conjunto de datos de ejemplo COCO8 con un tamaño de imagen de 640
|
||||
yolo segment val model=FastSAM-s.pt data=coco8.yaml imgsz=640
|
||||
```
|
||||
|
||||
Ten en cuenta que FastSAM solo admite la detección y segmentación de una sola clase de objeto. Esto significa que reconocerá y segmentará todos los objetos como si fueran de la misma clase. Por lo tanto, al preparar el conjunto de datos, debes convertir todos los IDs de categoría de objetos a 0.
|
||||
|
||||
## Uso oficial de FastSAM
|
||||
|
||||
FastSAM también está disponible directamente en el repositorio [https://github.com/CASIA-IVA-Lab/FastSAM](https://github.com/CASIA-IVA-Lab/FastSAM). Aquí hay una descripción general breve de los pasos típicos que podrías seguir para usar FastSAM:
|
||||
|
||||
### Instalación
|
||||
|
||||
1. Clona el repositorio de FastSAM:
|
||||
```shell
|
||||
git clone https://github.com/CASIA-IVA-Lab/FastSAM.git
|
||||
```
|
||||
|
||||
2. Crea y activa un entorno Conda con Python 3.9:
|
||||
```shell
|
||||
conda create -n FastSAM python=3.9
|
||||
conda activate FastSAM
|
||||
```
|
||||
|
||||
3. Navega hasta el repositorio clonado e instala los paquetes requeridos:
|
||||
```shell
|
||||
cd FastSAM
|
||||
pip install -r requirements.txt
|
||||
```
|
||||
|
||||
4. Instala el modelo CLIP:
|
||||
```shell
|
||||
pip install git+https://github.com/openai/CLIP.git
|
||||
```
|
||||
|
||||
### Ejemplo de uso
|
||||
|
||||
1. Descarga un [punto de control del modelo](https://drive.google.com/file/d/1m1sjY4ihXBU1fZXdQ-Xdj-mDltW-2Rqv/view?usp=sharing).
|
||||
|
||||
2. Utiliza FastSAM para inferencia. Ejemplos de comandos:
|
||||
|
||||
- Segmentar todo en una imagen:
|
||||
```shell
|
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg
|
||||
```
|
||||
|
||||
- Segmentar objetos específicos utilizando una indicación de texto:
|
||||
```shell
|
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --text_prompt "el perro amarillo"
|
||||
```
|
||||
|
||||
- Segmentar objetos dentro de una caja delimitadora (proporciona las coordenadas de la caja en formato xywh):
|
||||
```shell
|
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --box_prompt "[570,200,230,400]"
|
||||
```
|
||||
|
||||
- Segmentar objetos cerca de puntos específicos:
|
||||
```shell
|
||||
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --point_prompt "[[520,360],[620,300]]" --point_label "[1,0]"
|
||||
```
|
||||
|
||||
Además, puedes probar FastSAM a través de una [demostración en Colab](https://colab.research.google.com/drive/1oX14f6IneGGw612WgVlAiy91UHwFAvr9?usp=sharing) o en la [demostración web de HuggingFace](https://huggingface.co/spaces/An-619/FastSAM) para tener una experiencia visual.
|
||||
|
||||
## Citas y agradecimientos
|
||||
|
||||
Nos gustaría agradecer a los autores de FastSAM por sus importantes contribuciones en el campo de la segmentación de instancias en tiempo real:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{zhao2023fast,
|
||||
title={Fast Segment Anything},
|
||||
author={Xu Zhao and Wenchao Ding and Yongqi An and Yinglong Du and Tao Yu and Min Li and Ming Tang and Jinqiao Wang},
|
||||
year={2023},
|
||||
eprint={2306.12156},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
El artículo original de FastSAM se puede encontrar en [arXiv](https://arxiv.org/abs/2306.12156). Los autores han puesto su trabajo a disposición del público, y el código base se puede acceder en [GitHub](https://github.com/CASIA-IVA-Lab/FastSAM). Agradecemos sus esfuerzos para avanzar en el campo y hacer que su trabajo sea accesible a la comunidad en general.
|
||||
|
|
@ -1,32 +1,32 @@
|
|||
---
|
||||
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.
|
||||
description: Explore la amplia gama de modelos de la familia YOLO, SAM, MobileSAM, FastSAM, YOLO-NAS y RT-DETR soportados por Ultralytics. Comienza con ejemplos para el uso tanto de CLI como de 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).
|
||||
¡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 posturas](../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 "Nota"
|
||||
|
||||
🚧 Nuestra documentación en varios idiomas está actualmente en construcción y estamos trabajando arduamente para mejorarla. ¡Gracias por tu paciencia! 🙏
|
||||
🚧 Estamos trabajando arduamente para mejorar nuestra documentación en varios idiomas actualmente en construcción. ¡Gracias por tu paciencia! 🙏
|
||||
|
||||
## Modelos Destacados
|
||||
## Modelos destacados
|
||||
|
||||
Aquí tienes algunos de los modelos clave soportados:
|
||||
Aquí están 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.
|
||||
1. **[YOLOv3](yolov3.md)**: La tercera iteración de la familia de modelos YOLO, original de Joseph Redmon, conocida por su capacidad de detección de objetos en tiempo real eficientemente.
|
||||
2. **[YOLOv4](yolov4.md)**: Una actualización nativa de darknet para YOLOv3, lanzada por Alexey Bochkovskiy en 2020.
|
||||
3. **[YOLOv5](yolov5.md)**: Una versión mejorada de la arquitectura YOLO por Ultralytics, ofreciendo un mejor rendimiento y compromiso de velocidad comparado con versiones anteriores.
|
||||
4. **[YOLOv6](yolov6.md)**: Lanzado por [Meituan](https://about.meituan.com/) en 2022, y utilizado en muchos de los robots de entrega autónomos de la compañía.
|
||||
5. **[YOLOv7](yolov7.md)**: Modelos YOLO actualizados lanzados en 2022 por los autores de YOLOv4.
|
||||
6. **[YOLOv8](yolov8.md) NUEVO 🚀**: La última versión de la familia YOLO, con capacidades mejoradas como segmentación de instancias, estimación de posturas/puntos clave y clasificación.
|
||||
7. **[Modelo Segment Anything (SAM)](sam.md)**: Modelo Segment Anything (SAM) de Meta.
|
||||
8. **[Mobile Segment Anything Model (MobileSAM)](mobile-sam.md)**: MobileSAM para aplicaciones móviles, por la Universidad de Kyung Hee.
|
||||
9. **[Fast Segment Anything Model (FastSAM)](fast-sam.md)**: FastSAM por el Grupo de Análisis de Imagen y Video, Instituto de Automatización, Academia China de Ciencias.
|
||||
10. **[YOLO-NAS](yolo-nas.md)**: Modelos YOLO de Búsqueda de Arquitectura Neural (NAS).
|
||||
11. **[Transformadores de Detección en Tiempo Real (RT-DETR)](rtdetr.md)**: Modelos de Transformador de Detección en Tiempo Real (RT-DETR) de Baidu's PaddlePaddle.
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
|
|
@ -39,33 +39,37 @@ Aquí tienes algunos de los modelos clave soportados:
|
|||
<strong>Mira:</strong> Ejecuta modelos YOLO de Ultralytics en solo unas pocas líneas de código.
|
||||
</p>
|
||||
|
||||
## Comenzando: Ejemplos de Uso
|
||||
## Empezando: Ejemplos de Uso
|
||||
|
||||
Este ejemplo proporciona ejemplos simples de entrenamiento e inferencia YOLO. Para la documentación completa de estos y otros [modos](../modes/index.md), consulta las páginas de documentación de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md).
|
||||
|
||||
Nota que el siguiente ejemplo es para los modelos YOLOv8 [Detect](../tasks/detect.md) para detección de objetos. Para tareas adicionales soportadas, consulta la documentación de [Segment](../tasks/segment.md), [Classify](../tasks/classify.md) y [Pose](../tasks/pose.md).
|
||||
|
||||
!!! Example "Ejemplo"
|
||||
|
||||
=== "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:
|
||||
Los modelos pre-entrenados `*.pt` de PyTorch así como los archivos de configuración `*.yaml` se pueden pasar 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')
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# Mostrar información del modelo (opcional)
|
||||
modelo.info()
|
||||
model.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)
|
||||
results = model.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')
|
||||
results = model('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
Comandos CLI están disponibles para ejecutar directamente los modelos:
|
||||
Los 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
|
||||
|
|
@ -75,20 +79,20 @@ Aquí tienes algunos de los modelos clave soportados:
|
|||
yolo predict model=yolov8n.pt source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## Contribuyendo con Nuevos Modelos
|
||||
## Contribuir 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.
|
||||
2. **Clona tu Fork**: Clona tu fork a 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).
|
||||
3. **Implementa tu Modelo**: Añade tu modelo siguiendo los estándares de codificación y directrices proporcionadas 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.
|
||||
4. **Prueba Rigurosamente**: Asegúrate de probar tu modelo rigurosamente, tanto de forma aislada como parte del proceso.
|
||||
|
||||
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.
|
||||
5. **Crea un Pull Request**: Una vez que estés satisfecho con tu modelo, crea un pull request al repositorio principal para 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.
|
||||
6. **Revisión de Código y Fusión**: Después de la revisión, si tu modelo cumple con nuestros criterios, será fusionado al repositorio principal.
|
||||
|
||||
Consulta nuestra [Guía de Contribución](../../help/contributing.md) para los pasos detallados.
|
||||
Para pasos detallados, consulta nuestra [Guía de Contribución](../../help/contributing.md).
|
||||
|
|
|
|||
116
docs/es/models/mobile-sam.md
Normal file
116
docs/es/models/mobile-sam.md
Normal file
|
|
@ -0,0 +1,116 @@
|
|||
---
|
||||
comments: true
|
||||
description: Obtén más información sobre MobileSAM, su implementación, comparación con SAM original y cómo descargarlo y probarlo en el framework de Ultralytics. ¡Mejora tus aplicaciones móviles hoy mismo!
|
||||
keywords: MobileSAM, Ultralytics, SAM, aplicaciones móviles, Arxiv, GPU, API, codificador de imágenes, decodificador de máscaras, descarga de modelos, método de prueba
|
||||
---
|
||||
|
||||
|
||||
|
||||
# Segmentación Móvil de Cualquier Cosa (MobileSAM)
|
||||
|
||||
El artículo de MobileSAM ahora está disponible en [arXiv](https://arxiv.org/pdf/2306.14289.pdf).
|
||||
|
||||
Una demostración de MobileSAM funcionando en una CPU se puede acceder en este [enlace de demostración](https://huggingface.co/spaces/dhkim2810/MobileSAM). El rendimiento en una CPU Mac i5 tarda aproximadamente 3 segundos. En la demostración de Hugging Face, la interfaz y las CPUs de menor rendimiento contribuyen a una respuesta más lenta, pero sigue funcionando de manera efectiva.
|
||||
|
||||
MobileSAM se implementa en varios proyectos, incluyendo [Grounding-SAM](https://github.com/IDEA-Research/Grounded-Segment-Anything), [AnyLabeling](https://github.com/vietanhdev/anylabeling) y [Segment Anything in 3D](https://github.com/Jumpat/SegmentAnythingin3D).
|
||||
|
||||
MobileSAM se entrena en una sola GPU con un conjunto de datos de 100k (1% de las imágenes originales) en menos de un día. El código para este entrenamiento estará disponible en el futuro.
|
||||
|
||||
## Modelos Disponibles, Tareas Admitidas y Modos de Operación
|
||||
|
||||
Esta tabla presenta los modelos disponibles con sus pesos pre-entrenados específicos, las tareas que admiten y su compatibilidad con diferentes modos de operación como [Inference (Inferencia)](../modes/predict.md), [Validation (Validación)](../modes/val.md), [Training (Entrenamiento)](../modes/train.md) y [Export (Exportación)](../modes/export.md), indicados por emojis ✅ para los modos admitidos y emojis ❌ para los modos no admitidos.
|
||||
|
||||
| Tipo de Modelo | Pesos Pre-entrenados | Tareas Admitidas | Inferencia | Validación | Entrenamiento | Exportación |
|
||||
|----------------|----------------------|---------------------------------------------------|------------|------------|---------------|-------------|
|
||||
| MobileSAM | `mobile_sam.pt` | [Segmentación de Instancias](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
|
||||
|
||||
## Adaptación de SAM a MobileSAM
|
||||
|
||||
Dado que MobileSAM mantiene el mismo pipeline que SAM original, hemos incorporado el pre-procesamiento, post-procesamiento y todas las demás interfaces del original. En consecuencia, aquellos que actualmente utilizan SAM original pueden hacer la transición a MobileSAM con un esfuerzo mínimo.
|
||||
|
||||
MobileSAM tiene un rendimiento comparable a SAM original y mantiene el mismo pipeline excepto por un cambio en el codificador de imágenes. Específicamente, reemplazamos el codificador de imágenes original ViT-H pesado (632M) por uno más pequeño, Tiny-ViT (5M). En una sola GPU, MobileSAM funciona a aproximadamente 12ms por imagen: 8ms en el codificador de imágenes y 4ms en el decodificador de máscaras.
|
||||
|
||||
La siguiente tabla proporciona una comparación de los codificadores de imágenes basados en ViT:
|
||||
|
||||
| Codificador de Imágenes | SAM Original | MobileSAM |
|
||||
|-------------------------|--------------|-----------|
|
||||
| Parámetros | 611M | 5M |
|
||||
| Velocidad | 452ms | 8ms |
|
||||
|
||||
Tanto SAM original como MobileSAM utilizan el mismo decodificador de máscaras guiado por instrucciones:
|
||||
|
||||
| Decodificador de Máscaras | SAM Original | MobileSAM |
|
||||
|---------------------------|--------------|-----------|
|
||||
| Parámetros | 3.876M | 3.876M |
|
||||
| Velocidad | 4ms | 4ms |
|
||||
|
||||
Aquí está la comparación de todo el pipeline:
|
||||
|
||||
| Pipeline Completo (Enc+Dec) | SAM Original | MobileSAM |
|
||||
|-----------------------------|--------------|-----------|
|
||||
| Parámetros | 615M | 9.66M |
|
||||
| Velocidad | 456ms | 12ms |
|
||||
|
||||
El rendimiento de MobileSAM y SAM original se demuestra utilizando tanto un punto como una caja como instrucciones.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Con su rendimiento superior, MobileSAM es aproximadamente 5 veces más pequeño y 7 veces más rápido que el actual FastSAM. Más detalles están disponibles en la [página del proyecto de MobileSAM](https://github.com/ChaoningZhang/MobileSAM).
|
||||
|
||||
## Probando MobileSAM en Ultralytics
|
||||
|
||||
Al igual que SAM original, ofrecemos un método sencillo de prueba en Ultralytics, que incluye modos tanto para instrucciones de Punto como para Caja.
|
||||
|
||||
### Descarga del Modelo
|
||||
|
||||
Puedes descargar el modelo [aquí](https://github.com/ChaoningZhang/MobileSAM/blob/master/weights/mobile_sam.pt).
|
||||
|
||||
### Instrucción de Punto
|
||||
|
||||
!!! Example "Ejemplo"
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
from ultralytics import SAM
|
||||
|
||||
# Carga el modelo
|
||||
model = SAM('mobile_sam.pt')
|
||||
|
||||
# Predice un segmento basado en una instrucción de punto
|
||||
model.predict('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
|
||||
```
|
||||
|
||||
### Instrucción de Caja
|
||||
|
||||
!!! Example "Ejemplo"
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
from ultralytics import SAM
|
||||
|
||||
# Carga el modelo
|
||||
model = SAM('mobile_sam.pt')
|
||||
|
||||
# Predice un segmento basado en una instrucción de caja
|
||||
model.predict('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
|
||||
```
|
||||
|
||||
Hemos implementado `MobileSAM` y `SAM` utilizando la misma API. Para obtener más información sobre cómo usarlo, consulta la [página de SAM](sam.md).
|
||||
|
||||
## Citaciones y Reconocimientos
|
||||
|
||||
Si encuentras útil MobileSAM en tu investigación o trabajo de desarrollo, considera citar nuestro artículo:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{mobile_sam,
|
||||
title={Faster Segment Anything: Towards Lightweight SAM for Mobile Applications},
|
||||
author={Zhang, Chaoning and Han, Dongshen and Qiao, Yu and Kim, Jung Uk and Bae, Sung Ho and Lee, Seungkyu and Hong, Choong Seon},
|
||||
journal={arXiv preprint arXiv:2306.14289},
|
||||
year={2023}
|
||||
}
|
||||
93
docs/es/models/rtdetr.md
Normal file
93
docs/es/models/rtdetr.md
Normal file
|
|
@ -0,0 +1,93 @@
|
|||
---
|
||||
comments: true
|
||||
description: Descubre las características y beneficios de RT-DETR, un eficiente y adaptable detector de objetos en tiempo real desarrollado por Baidu y potenciado por Vision Transformers, que incluye modelos pre-entrenados.
|
||||
keywords: RT-DETR, Baidu, Vision Transformers, detección de objetos, rendimiento en tiempo real, CUDA, TensorRT, selección de consultas IoU, Ultralytics, API de Python, PaddlePaddle
|
||||
---
|
||||
|
||||
# RT-DETR de Baidu: Un Detector de Objetos en Tiempo Real Basado en Vision Transformers
|
||||
|
||||
## Resumen
|
||||
|
||||
Real-Time Detection Transformer (RT-DETR), desarrollado por Baidu, es un avanzado detector de objetos de extremo a extremo que proporciona un rendimiento en tiempo real manteniendo una alta precisión. Utiliza la potencia de Vision Transformers (ViT) para procesar de manera eficiente características de múltiples escalas mediante la descomposición de la interacción intra-escala y la fusión inter-escala. RT-DETR es altamente adaptable y permite ajustar de manera flexible la velocidad de inferencia utilizando diferentes capas de decodificador sin necesidad de volver a entrenar el modelo. El modelo se destaca en plataformas aceleradas como CUDA con TensorRT, superando a muchos otros detectores de objetos en tiempo real.
|
||||
|
||||
|
||||
**Resumen de RT-DETR de Baidu.** El diagrama de la arquitectura del modelo RT-DETR muestra las últimas tres etapas del canal (S3, S4, S5) como entrada al codificador. El eficiente codificador híbrido transforma características de múltiples escalas en una secuencia de características de imagen a través del módulo de interacción de características intra-escala (AIFI) y el módulo de fusión de características inter-escala (CCFM). Se utiliza la selección de consultas IoU-aware para seleccionar un número fijo de características de imagen que servirán como consultas iniciales de objetos para el decodificador. Finalmente, el decodificador con cabeceras de predicción auxiliares optimiza iterativamente las consultas de objetos para generar cajas y puntuaciones de confianza ([fuente](https://arxiv.org/pdf/2304.08069.pdf)).
|
||||
|
||||
### Características Clave
|
||||
|
||||
- **Codificador Híbrido Eficiente:** RT-DETR de Baidu utiliza un codificador híbrido eficiente que procesa características de múltiples escalas mediante la descomposición de la interacción intra-escala y la fusión inter-escala. Este diseño único basado en Vision Transformers reduce los costos computacionales y permite la detección de objetos en tiempo real.
|
||||
- **Selección de Consultas IoU-aware:** RT-DETR de Baidu mejora la inicialización de las consultas de objetos utilizando la selección de consultas IoU-aware. Esto permite que el modelo se enfoque en los objetos más relevantes de la escena, mejorando la precisión en la detección.
|
||||
- **Velocidad de Inferencia Adaptable:** RT-DETR de Baidu admite ajustes flexibles de la velocidad de inferencia utilizando diferentes capas de decodificador sin necesidad de volver a entrenar el modelo. Esta adaptabilidad facilita la aplicación práctica en diversos escenarios de detección de objetos en tiempo real.
|
||||
|
||||
## Modelos Pre-entrenados
|
||||
|
||||
La API de Python de Ultralytics proporciona modelos pre-entrenados de RT-DETR de PaddlePaddle en diferentes escalas:
|
||||
|
||||
- RT-DETR-L: 53.0% AP en COCO val2017, 114 FPS en GPU T4
|
||||
- RT-DETR-X: 54.8% AP en COCO val2017, 74 FPS en GPU T4
|
||||
|
||||
## Ejemplos de Uso
|
||||
|
||||
Este ejemplo proporciona ejemplos sencillos de entrenamiento e inferencia de RT-DETRR. Para obtener una documentación completa sobre estos y otros [modos](../modes/index.md), consulta las páginas de documentación de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md).
|
||||
|
||||
!!! Example "Ejemplo"
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import RTDETR
|
||||
|
||||
# Cargar un modelo RT-DETR-l pre-entrenado en COCO
|
||||
model = RTDETR('rtdetr-l.pt')
|
||||
|
||||
# Mostrar información del modelo (opcional)
|
||||
model.info()
|
||||
|
||||
# Entrenar el modelo en el conjunto de datos de ejemplo COCO8 durante 100 épocas
|
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# Realizar inferencia con el modelo RT-DETR-l en la imagen 'bus.jpg'
|
||||
results = model('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Cargar un modelo RT-DETR-l pre-entrenado en COCO y entrenarlo en el conjunto de datos de ejemplo COCO8 durante 100 épocas
|
||||
yolo train model=rtdetr-l.pt data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# Cargar un modelo RT-DETR-l pre-entrenado en COCO y realizar inferencia en la imagen 'bus.jpg'
|
||||
yolo predict model=rtdetr-l.pt source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## Tareas y Modos Admitidos
|
||||
|
||||
Esta tabla presenta los tipos de modelos, los pesos pre-entrenados específicos, las tareas admitidas por cada modelo y los diversos modos ([Train](../modes/train.md) , [Val](../modes/val.md), [Predict](../modes/predict.md), [Export](../modes/export.md)) admitidos, indicados por los emojis ✅.
|
||||
|
||||
| Tipo de Modelo | Pesos Pre-entrenados | Tareas Admitidas | Inferencia | Validación | Entrenamiento | Exportación |
|
||||
|---------------------|----------------------|--------------------------------------------|------------|------------|---------------|-------------|
|
||||
| RT-DETR Large | `rtdetr-l.pt` | [Detección de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| RT-DETR Extra-Large | `rtdetr-x.pt` | [Detección de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
|
||||
## Citaciones y Agradecimientos
|
||||
|
||||
Si utilizas RT-DETR de Baidu en tu investigación o trabajo de desarrollo, por favor cita el [artículo original](https://arxiv.org/abs/2304.08069):
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{lv2023detrs,
|
||||
title={DETRs Beat YOLOs on Real-time Object Detection},
|
||||
author={Wenyu Lv and Shangliang Xu and Yian Zhao and Guanzhong Wang and Jinman Wei and Cheng Cui and Yuning Du and Qingqing Dang and Yi Liu},
|
||||
year={2023},
|
||||
eprint={2304.08069},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
Nos gustaría agradecer a Baidu y al equipo de [PaddlePaddle](https://github.com/PaddlePaddle/PaddleDetection) por crear y mantener este valioso recurso para la comunidad de visión por computadora. Apreciamos enormemente su contribución al campo con el desarrollo del detector de objetos en tiempo real basado en Vision Transformers, RT-DETR.
|
||||
|
||||
*keywords: RT-DETR, Transformer, ViT, Vision Transformers, Baidu RT-DETR, PaddlePaddle, Paddle Paddle RT-DETR, detección de objetos en tiempo real, detección de objetos basada en Vision Transformers, modelos pre-entrenados PaddlePaddle RT-DETR, uso de RT-DETR de Baidu, API de Python de Ultralytics*
|
||||
226
docs/es/models/sam.md
Normal file
226
docs/es/models/sam.md
Normal file
|
|
@ -0,0 +1,226 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explora el revolucionario Segment Anything Model (SAM) de Ultralytics que permite la segmentación de imágenes en tiempo real. Aprende sobre su segmentación por indicación, rendimiento en la transferencia sin entrenamiento y cómo usarlo.
|
||||
keywords: Ultralytics, segmentación de imágenes, Segment Anything Model, SAM, SA-1B dataset, rendimiento en tiempo real, transferencia sin entrenamiento, detección de objetos, análisis de imágenes, aprendizaje automático
|
||||
---
|
||||
|
||||
# Segment Anything Model (SAM)
|
||||
|
||||
Bienvenido al frontera de la segmentación de imágenes con el Segment Anything Model, o SAM. Este modelo revolucionario ha cambiado el juego al introducir la segmentación de imágenes por indicación con rendimiento en tiempo real, estableciendo nuevos estándares en el campo.
|
||||
|
||||
## Introducción a SAM: Segment Anything Model
|
||||
|
||||
El Segment Anything Model, o SAM, es un modelo de segmentación de imágenes de vanguardia que permite la segmentación por indicación, ofreciendo una versatilidad sin igual en las tareas de análisis de imágenes. SAM forma el corazón de la iniciativa Segment Anything, un proyecto innovador que presenta un modelo, una tarea y un conjunto de datos nuevos para la segmentación de imágenes.
|
||||
|
||||
El diseño avanzado de SAM le permite adaptarse a nuevas distribuciones y tareas de imágenes sin conocimientos previos, una característica conocida como transferencia sin entrenamiento. Entrenado en el extenso [conjunto de datos SA-1B](https://ai.facebook.com/datasets/segment-anything/), que contiene más de mil millones de máscaras distribuidas en once millones de imágenes seleccionadas cuidadosamente, SAM ha demostrado un impresionante rendimiento en la transferencia sin entrenamiento, superando en muchos casos los resultados de supervisión completa anteriores.
|
||||
|
||||
|
||||
Imágenes de ejemplo con máscaras superpuestas de nuestro nuevo conjunto de datos, SA-1B. SA-1B contiene 11 millones de imágenes diversas de alta resolución, con licencia y protección de la privacidad, y 1.1 mil millones de máscaras de segmentación de alta calidad. Estas máscaras fueron anotadas completamente automáticamente por SAM y, según las calificaciones humanas y numerosos experimentos, tienen una alta calidad y diversidad. Las imágenes se agrupan por número de máscaras por imagen para su visualización (hay aproximadamente 100 máscaras por imagen en promedio).
|
||||
|
||||
## Características clave del Segment Anything Model (SAM)
|
||||
|
||||
- **Tarea de segmentación por indicación**: SAM fue diseñado teniendo en cuenta una tarea de segmentación por indicación, lo que le permite generar máscaras de segmentación válidas a partir de cualquier indicación dada, como pistas espaciales o de texto que identifican un objeto.
|
||||
- **Arquitectura avanzada**: El Segment Anything Model utiliza un potente codificador de imágenes, un codificador de indicaciones y un decodificador de máscaras ligero. Esta arquitectura única permite la indicación flexible, el cálculo de máscaras en tiempo real y la conciencia de ambigüedades en las tareas de segmentación.
|
||||
- **El conjunto de datos SA-1B**: Introducido por el proyecto Segment Anything, el conjunto de datos SA-1B cuenta con más de mil millones de máscaras en once millones de imágenes. Como el conjunto de datos de segmentación más grande hasta la fecha, proporciona a SAM una fuente de datos de entrenamiento diversa y a gran escala.
|
||||
- **Rendimiento en la transferencia sin entrenamiento**: SAM muestra un destacado rendimiento en la transferencia sin entrenamiento en diversas tareas de segmentación, lo que lo convierte en una herramienta lista para usar en diversas aplicaciones con una necesidad mínima de ingeniería de indicación.
|
||||
|
||||
Para obtener una visión más detallada del Segment Anything Model y el conjunto de datos SA-1B, visita el [sitio web de Segment Anything](https://segment-anything.com) y consulta el artículo de investigación [Segment Anything](https://arxiv.org/abs/2304.02643).
|
||||
|
||||
## Modelos disponibles, tareas admitidas y modos de funcionamiento
|
||||
|
||||
Esta tabla muestra los modelos disponibles con sus pesos pre-entrenados específicos, las tareas que admiten y su compatibilidad con diferentes modos de funcionamiento como [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md) y [Export](../modes/export.md), indicados con emojis ✅ para los modos admitidos y emojis ❌ para los modos no admitidos.
|
||||
|
||||
| Tipo de modelo | Pesos pre-entrenados | Tareas admitidas | Inference | Validation | Training | Export |
|
||||
|----------------|----------------------|---------------------------------------------------|-----------|------------|----------|--------|
|
||||
| SAM base | `sam_b.pt` | [Segmentación de instancias](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
|
||||
| SAM large | `sam_l.pt` | [Segmentación de instancias](../tasks/segment.md) | ✅ | ❌ | ❌ | ✅ |
|
||||
|
||||
## Cómo usar SAM: Versatilidad y potencia en la segmentación de imágenes
|
||||
|
||||
El Segment Anything Model se puede utilizar para una multitud de tareas posteriores que van más allá de sus datos de entrenamiento. Esto incluye detección de bordes, generación de propuestas de objetos, segmentación de instancias y predicción preliminar de texto a máscara. Con la ingeniería de indicación, SAM puede adaptarse rápidamente a nuevas tareas y distribuciones de datos de manera sin entrenamiento, estableciéndolo como una herramienta versátil y potente para todas tus necesidades de segmentación de imágenes.
|
||||
|
||||
### Ejemplo de predicción con SAM
|
||||
|
||||
!!! Example "Segmentar con indicaciones"
|
||||
|
||||
Segmenta la imagen con las indicaciones proporcionadas.
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import SAM
|
||||
|
||||
# Cargar un modelo
|
||||
modelo = SAM('sam_b.pt')
|
||||
|
||||
# Mostrar información del modelo (opcional)
|
||||
modelo.info()
|
||||
|
||||
# Ejecutar inferencia con indicaciones de bboxes
|
||||
modelo('ultralytics/assets/zidane.jpg', bboxes=[439, 437, 524, 709])
|
||||
|
||||
# Ejecutar inferencia con indicaciones de puntos
|
||||
modelo('ultralytics/assets/zidane.jpg', points=[900, 370], labels=[1])
|
||||
```
|
||||
|
||||
!!! Example "Segmentar todo"
|
||||
|
||||
Segmenta toda la imagen.
|
||||
|
||||
=== "Python"
|
||||
|
||||
```python
|
||||
from ultralytics import SAM
|
||||
|
||||
# Cargar un modelo
|
||||
modelo = SAM('sam_b.pt')
|
||||
|
||||
# Mostrar información del modelo (opcional)
|
||||
modelo.info()
|
||||
|
||||
# Ejecutar inferencia
|
||||
modelo('ruta/hacia/imagen.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Ejecutar inferencia con un modelo SAM
|
||||
yolo predict model=sam_b.pt source=ruta/hacia/imagen.jpg
|
||||
```
|
||||
|
||||
- La lógica aquí es segmentar toda la imagen si no se proporcionan indicaciones (bboxes/puntos/máscaras).
|
||||
|
||||
!!! Example "Ejemplo de SAMPredictor"
|
||||
|
||||
De esta manera, puedes configurar una imagen una vez y ejecutar inferencia con indicaciones múltiples sin ejecutar el codificador de imágenes múltiples veces.
|
||||
|
||||
=== "Inferencia con indicaciones"
|
||||
|
||||
```python
|
||||
from ultralytics.models.sam import Predictor as SAMPredictor
|
||||
|
||||
# Crear SAMPredictor
|
||||
opciones = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt")
|
||||
predictor = SAMPredictor(opciones=opciones)
|
||||
|
||||
# Establecer imagen
|
||||
predictor.set_image("ultralytics/assets/zidane.jpg") # establecer con archivo de imagen
|
||||
predictor.set_image(cv2.imread("ultralytics/assets/zidane.jpg")) # establecer con np.ndarray
|
||||
resultados = predictor(bboxes=[439, 437, 524, 709])
|
||||
resultados = predictor(points=[900, 370], labels=[1])
|
||||
|
||||
# Restablecer imagen
|
||||
predictor.reset_image()
|
||||
```
|
||||
|
||||
Segmentar todo con argumentos adicionales.
|
||||
|
||||
=== "Segmentar todo"
|
||||
|
||||
```python
|
||||
from ultralytics.models.sam import Predictor as SAMPredictor
|
||||
|
||||
# Crear SAMPredictor
|
||||
opciones = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model="mobile_sam.pt")
|
||||
predictor = SAMPredictor(opciones=opciones)
|
||||
|
||||
# Segmentar con argumentos adicionales
|
||||
resultados = predictor(source="ultralytics/assets/zidane.jpg", crop_n_layers=1, points_stride=64)
|
||||
```
|
||||
|
||||
- Más argumentos adicionales para `Segmentar todo` en [`Referencia de Predictor/generate`](../../reference/models/sam/predict.md).
|
||||
|
||||
## SAM comparado con YOLOv8
|
||||
|
||||
Aquí comparamos el modelo SAM más pequeño de Meta, SAM-b, con el modelo de segmentación más pequeño de Ultralytics, [YOLOv8n-seg](../tasks/segment.md):
|
||||
|
||||
| Modelo | Tamaño | Parámetros | Velocidad (CPU) |
|
||||
|-------------------------------------------------|-------------------------------------|------------------------------|-------------------------------------|
|
||||
| SAM-b de Meta | 358 MB | 94.7 M | 51096 ms/im |
|
||||
| [MobileSAM](mobile-sam.md) | 40.7 MB | 10.1 M | 46122 ms/im |
|
||||
| [FastSAM-s](fast-sam.md) con respaldo de YOLOv8 | 23.7 MB | 11.8 M | 115 ms/im |
|
||||
| YOLOv8n-seg de Ultralytics | **6.7 MB** (53.4 veces más pequeño) | **3.4 M** (27.9 veces menos) | **59 ms/im** (866 veces más rápido) |
|
||||
|
||||
Esta comparación muestra las diferencias de órdenes de magnitud en los tamaños y velocidades de los modelos. Si bien SAM presenta capacidades únicas para la segmentación automática, no es un competidor directo de los modelos de segmentación YOLOv8, que son más pequeños, más rápidos y más eficientes.
|
||||
|
||||
Las pruebas se realizaron en una MacBook Apple M2 de 2023 con 16 GB de RAM. Para reproducir esta prueba:
|
||||
|
||||
!!! Example "Ejemplo"
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
from ultralytics import FastSAM, SAM, YOLO
|
||||
|
||||
# Perfil del modelo SAM-b
|
||||
modelo = SAM('sam_b.pt')
|
||||
modelo.info()
|
||||
modelo('ultralytics/assets')
|
||||
|
||||
# Perfil de MobileSAM
|
||||
modelo = SAM('mobile_sam.pt')
|
||||
modelo.info()
|
||||
modelo('ultralytics/assets')
|
||||
|
||||
# Perfil de FastSAM-s
|
||||
modelo = FastSAM('FastSAM-s.pt')
|
||||
modelo.info()
|
||||
modelo('ultralytics/assets')
|
||||
|
||||
# Perfil de YOLOv8n-seg
|
||||
modelo = YOLO('yolov8n-seg.pt')
|
||||
modelo.info()
|
||||
modelo('ultralytics/assets')
|
||||
```
|
||||
|
||||
## Auto-anotación: un camino rápido hacia conjuntos de datos de segmentación
|
||||
|
||||
La auto-anotación es una característica clave de SAM que permite a los usuarios generar un [conjunto de datos de segmentación](https://docs.ultralytics.com/datasets/segment) utilizando un modelo de detección pre-entrenado. Esta función permite una anotación rápida y precisa de un gran número de imágenes, evitando la necesidad de una etiquetación manual que consume mucho tiempo.
|
||||
|
||||
### Generar tu conjunto de datos de segmentación utilizando un modelo de detección
|
||||
|
||||
Para auto-anotar tu conjunto de datos con el marco de trabajo de Ultralytics, utiliza la función `auto_annotate` como se muestra a continuación:
|
||||
|
||||
!!! Example "Ejemplo"
|
||||
|
||||
=== "Python"
|
||||
```python
|
||||
from ultralytics.data.annotator import auto_annotate
|
||||
|
||||
auto_annotate(data="ruta/a/las/imagenes", det_model="yolov8x.pt", sam_model='sam_b.pt')
|
||||
```
|
||||
|
||||
| Argumento | Tipo | Descripción | Predeterminado |
|
||||
|------------|---------------------|-----------------------------------------------------------------------------------------------------------------------|----------------|
|
||||
| data | str | Ruta a una carpeta que contiene las imágenes a anotar. | |
|
||||
| det_model | str, opcional | Modelo de detección YOLO pre-entrenado. Por defecto, 'yolov8x.pt'. | 'yolov8x.pt' |
|
||||
| sam_model | str, opcional | Modelo de segmentación SAM pre-entrenado. Por defecto, 'sam_b.pt'. | 'sam_b.pt' |
|
||||
| device | str, opcional | Dispositivo en el que ejecutar los modelos. Por defecto, una cadena vacía (CPU o GPU, si está disponible). | |
|
||||
| output_dir | str, None, opcional | Directorio para guardar los resultados anotados. Por defecto, una carpeta 'labels' en el mismo directorio que 'data'. | None |
|
||||
|
||||
La función `auto_annotate` toma la ruta de tus imágenes, con argumentos opcionales para especificar los modelos de detección y segmentación SAM pre-entrenados, el dispositivo en el que ejecutar los modelos, y el directorio de salida para guardar los resultados anotados.
|
||||
|
||||
La auto-anotación con modelos pre-entrenados puede reducir drásticamente el tiempo y el esfuerzo requeridos para crear conjuntos de datos de segmentación de alta calidad. Esta característica es especialmente beneficiosa para investigadores y desarrolladores que trabajan con grandes colecciones de imágenes, ya que les permite centrarse en el desarrollo y la evaluación de modelos en lugar de en la anotación manual.
|
||||
|
||||
## Citas y agradecimientos
|
||||
|
||||
Si encuentras útil SAM en tu trabajo de investigación o desarrollo, considera citar nuestro artículo:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{kirillov2023segment,
|
||||
title={Segment Anything},
|
||||
author={Alexander Kirillov and Eric Mintun and Nikhila Ravi and Hanzi Mao and Chloe Rolland and Laura Gustafson and Tete Xiao and Spencer Whitehead and Alexander C. Berg and Wan-Yen Lo and Piotr Dollár and Ross Girshick},
|
||||
year={2023},
|
||||
eprint={2304.02643},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
Nos gustaría expresar nuestro agradecimiento a Meta AI por crear y mantener este valioso recurso para la comunidad de visión por computadora.
|
||||
|
||||
*keywords: Segment Anything, Segment Anything Model, SAM, Meta SAM, segmentación de imágenes, segmentación por indicación, rendimiento en la transferencia sin entrenamiento, conjunto de datos SA-1B, arquitectura avanzada, auto-anotación, Ultralytics, modelos pre-entrenados, SAM base, SAM large, segmentación de instancias, visión por computadora, IA, inteligencia artificial, aprendizaje automático, anotación de datos, máscaras de segmentación, modelo de detección, modelo de detección YOLO, bibtex, Meta AI.*
|
||||
121
docs/es/models/yolo-nas.md
Normal file
121
docs/es/models/yolo-nas.md
Normal file
|
|
@ -0,0 +1,121 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explora la documentación detallada de YOLO-NAS, un modelo de detección de objetos superior. Aprende sobre sus características, modelos pre-entrenados, uso con la API de Ultralytics Python, y más.
|
||||
keywords: YOLO-NAS, Deci AI, detección de objetos, aprendizaje profundo, búsqueda de arquitectura neural, API de Ultralytics Python, modelo YOLO, modelos pre-entrenados, cuantización, optimización, COCO, Objects365, Roboflow 100
|
||||
---
|
||||
|
||||
# YOLO-NAS
|
||||
|
||||
## Visión general
|
||||
|
||||
Desarrollado por Deci AI, YOLO-NAS es un modelo revolucionario de detección de objetos. Es el producto de una tecnología avanzada de Búsqueda de Arquitectura Neural, meticulosamente diseñada para abordar las limitaciones de los modelos YOLO anteriores. Con mejoras significativas en el soporte de cuantización y el equilibrio entre precisión y latencia, YOLO-NAS representa un gran avance en la detección de objetos.
|
||||
|
||||
|
||||
**Visión general de YOLO-NAS.** YOLO-NAS utiliza bloques conscientes de cuantización y cuantización selectiva para un rendimiento óptimo. El modelo, cuando se convierte en su versión cuantizada INT8, experimenta una caída mínima de precisión, una mejora significativa en comparación con otros modelos. Estos avances culminan en una arquitectura superior con capacidades de detección de objetos sin precedentes y un rendimiento sobresaliente.
|
||||
|
||||
### Características clave
|
||||
|
||||
- **Bloque básico compatible con cuantización:** YOLO-NAS introduce un nuevo bloque básico que es compatible con la cuantización, abordando una de las limitaciones significativas de los modelos YOLO anteriores.
|
||||
- **Entrenamiento sofisticado y cuantización:** YOLO-NAS utiliza esquemas avanzados de entrenamiento y cuantización posterior para mejorar el rendimiento.
|
||||
- **Optimización AutoNAC y pre-entrenamiento:** YOLO-NAS utiliza la optimización AutoNAC y se pre-entrena en conjuntos de datos prominentes como COCO, Objects365 y Roboflow 100. Este pre-entrenamiento lo hace extremadamente adecuado para tareas de detección de objetos en entornos de producción.
|
||||
|
||||
## Modelos pre-entrenados
|
||||
|
||||
Experimenta el poder de la detección de objetos de próxima generación con los modelos pre-entrenados de YOLO-NAS proporcionados por Ultralytics. Estos modelos están diseñados para ofrecer un rendimiento de primera clase tanto en velocidad como en precisión. Elige entre una variedad de opciones adaptadas a tus necesidades específicas:
|
||||
|
||||
| Modelo | mAP | Latencia (ms) |
|
||||
|------------------|-------|---------------|
|
||||
| YOLO-NAS S | 47.5 | 3.21 |
|
||||
| YOLO-NAS M | 51.55 | 5.85 |
|
||||
| YOLO-NAS L | 52.22 | 7.87 |
|
||||
| YOLO-NAS S INT-8 | 47.03 | 2.36 |
|
||||
| YOLO-NAS M INT-8 | 51.0 | 3.78 |
|
||||
| YOLO-NAS L INT-8 | 52.1 | 4.78 |
|
||||
|
||||
Cada variante del modelo está diseñada para ofrecer un equilibrio entre la Precisión Promedio de las Areas (mAP, por sus siglas en inglés) y la latencia, ayudándote a optimizar tus tareas de detección de objetos en términos de rendimiento y velocidad.
|
||||
|
||||
## Ejemplos de uso
|
||||
|
||||
Ultralytics ha facilitado la integración de los modelos YOLO-NAS en tus aplicaciones de Python a través de nuestro paquete `ultralytics`. El paquete proporciona una API de Python fácil de usar para agilizar el proceso.
|
||||
|
||||
Los siguientes ejemplos muestran cómo usar los modelos YOLO-NAS con el paquete `ultralytics` para inferencia y validación:
|
||||
|
||||
### Ejemplos de inferencia y validación
|
||||
|
||||
En este ejemplo validamos YOLO-NAS-s en el conjunto de datos COCO8.
|
||||
|
||||
!!! Example "Ejemplo"
|
||||
|
||||
Este ejemplo proporciona un código simple de inferencia y validación para YOLO-NAS. Para manejar los resultados de la inferencia, consulta el modo [Predict](../modes/predict.md). Para usar YOLO-NAS con modos adicionales, consulta [Val](../modes/val.md) y [Export](../modes/export.md). El paquete `ultralytics` para YOLO-NAS no admite entrenamiento.
|
||||
|
||||
=== "Python"
|
||||
|
||||
Los archivos de modelos pre-entrenados `*.pt` de PyTorch se pueden pasar a la clase `NAS()` para crear una instancia del modelo en Python:
|
||||
|
||||
```python
|
||||
from ultralytics import NAS
|
||||
|
||||
# Carga un modelo YOLO-NAS-s pre-entrenado en COCO
|
||||
modelo = NAS('yolo_nas_s.pt')
|
||||
|
||||
# Muestra información del modelo (opcional)
|
||||
modelo.info()
|
||||
|
||||
# Valida el modelo en el conjunto de datos de ejemplo COCO8
|
||||
resultados = modelo.val(data='coco8.yaml')
|
||||
|
||||
# Ejecuta inferencia con el modelo YOLO-NAS-s en la imagen 'bus.jpg'
|
||||
resultados = modelo('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
Los comandos CLI están disponibles para ejecutar directamente los modelos:
|
||||
|
||||
```bash
|
||||
# Carga un modelo YOLO-NAS-s pre-entrenado en COCO y valida su rendimiento en el conjunto de datos de ejemplo COCO8
|
||||
yolo val model=yolo_nas_s.pt data=coco8.yaml
|
||||
|
||||
# Carga un modelo YOLO-NAS-s pre-entrenado en COCO y ejecuta inferencia en la imagen 'bus.jpg'
|
||||
yolo predict model=yolo_nas_s.pt source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## Tareas y modos compatibles
|
||||
|
||||
Ofrecemos tres variantes de los modelos YOLO-NAS: Small (s), Medium (m) y Large (l). Cada variante está diseñada para satisfacer diferentes necesidades computacionales y de rendimiento:
|
||||
|
||||
- **YOLO-NAS-s**: Optimizado para entornos donde los recursos computacionales son limitados pero la eficiencia es clave.
|
||||
- **YOLO-NAS-m**: Ofrece un enfoque equilibrado, adecuado para la detección de objetos de propósito general con mayor precisión.
|
||||
- **YOLO-NAS-l**: Adaptados para escenarios que requieren la mayor precisión, donde los recursos computacionales son menos restrictivos.
|
||||
|
||||
A continuación se muestra una descripción detallada de cada modelo, incluyendo enlaces a sus pesos pre-entrenados, las tareas que admiten y su compatibilidad con diferentes modos de funcionamiento.
|
||||
|
||||
| Tipo de modelo | Pesos pre-entrenados | Tareas admitidas | Inferencia | Validación | Entrenamiento | Exportación |
|
||||
|----------------|-----------------------------------------------------------------------------------------------|--------------------------------------------|------------|------------|---------------|-------------|
|
||||
| YOLO-NAS-s | [yolo_nas_s.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_s.pt) | [Detección de objetos](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
|
||||
| YOLO-NAS-m | [yolo_nas_m.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_m.pt) | [Detección de objetos](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
|
||||
| YOLO-NAS-l | [yolo_nas_l.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolo_nas_l.pt) | [Detección de objetos](../tasks/detect.md) | ✅ | ✅ | ❌ | ✅ |
|
||||
|
||||
## Citaciones y agradecimientos
|
||||
|
||||
Si utilizas YOLO-NAS en tu investigación o trabajo de desarrollo, por favor cita SuperGradients:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{supergradients,
|
||||
doi = {10.5281/ZENODO.7789328},
|
||||
url = {https://zenodo.org/record/7789328},
|
||||
author = {Aharon, Shay and {Louis-Dupont} and {Ofri Masad} and Yurkova, Kate and {Lotem Fridman} and {Lkdci} and Khvedchenya, Eugene and Rubin, Ran and Bagrov, Natan and Tymchenko, Borys and Keren, Tomer and Zhilko, Alexander and {Eran-Deci}},
|
||||
title = {Super-Gradients},
|
||||
publisher = {GitHub},
|
||||
journal = {GitHub repository},
|
||||
year = {2021},
|
||||
}
|
||||
```
|
||||
|
||||
Agradecemos al equipo de [SuperGradients](https://github.com/Deci-AI/super-gradients/) de Deci AI por sus esfuerzos en la creación y mantenimiento de este valioso recurso para la comunidad de visión por computadora. Creemos que YOLO-NAS, con su arquitectura innovadora y sus capacidades de detección de objetos superiores, se convertirá en una herramienta fundamental tanto para desarrolladores como para investigadores.
|
||||
|
||||
*keywords: YOLO-NAS, Deci AI, detección de objetos, aprendizaje profundo, búsqueda de arquitectura neural, API de Ultralytics Python, modelo YOLO, SuperGradients, modelos pre-entrenados, bloque básico compatible con cuantización, esquemas avanzados de entrenamiento, cuantización posterior, optimización AutoNAC, COCO, Objects365, Roboflow 100*
|
||||
98
docs/es/models/yolov3.md
Normal file
98
docs/es/models/yolov3.md
Normal file
|
|
@ -0,0 +1,98 @@
|
|||
---
|
||||
comments: true
|
||||
description: Obtén una descripción general de YOLOv3, YOLOv3-Ultralytics y YOLOv3u. Aprende sobre sus características clave, uso y tareas admitidas para la detección de objetos.
|
||||
keywords: YOLOv3, YOLOv3-Ultralytics, YOLOv3u, Detección de objetos, Inferencia, Entrenamiento, Ultralytics
|
||||
---
|
||||
|
||||
# YOLOv3, YOLOv3-Ultralytics y YOLOv3u
|
||||
|
||||
## Descripción general
|
||||
|
||||
Este documento presenta una descripción general de tres modelos de detección de objetos estrechamente relacionados, conocidos como [YOLOv3](https://pjreddie.com/darknet/yolo/), [YOLOv3-Ultralytics](https://github.com/ultralytics/yolov3) y [YOLOv3u](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
1. **YOLOv3:** Esta es la tercera versión del algoritmo de detección de objetos You Only Look Once (YOLO). Originalmente desarrollado por Joseph Redmon, YOLOv3 mejoró a sus predecesores al introducir características como predicciones multiescala y tres tamaños diferentes de núcleos de detección.
|
||||
|
||||
2. **YOLOv3-Ultralytics:** Esta es la implementación de YOLOv3 realizada por Ultralytics. Reproduce la arquitectura original de YOLOv3 y ofrece funcionalidades adicionales, como soporte para más modelos pre-entrenados y opciones de personalización más fáciles.
|
||||
|
||||
3. **YOLOv3u:** Esta es una versión actualizada de YOLOv3-Ultralytics que incorpora la cabeza dividida sin anclaje y sin objeto utilizada en los modelos YOLOv8. YOLOv3u mantiene la misma arquitectura de columna vertebral y cuello que YOLOv3, pero con la cabeza de detección actualizada de YOLOv8.
|
||||
|
||||
|
||||
|
||||
## Características clave
|
||||
|
||||
- **YOLOv3:** Introdujo el uso de tres escalas diferentes para la detección, aprovechando tres tamaños diferentes de núcleos de detección: 13x13, 26x26 y 52x52. Esto mejoró significativamente la precisión de detección para objetos de diferentes tamaños. Además, YOLOv3 añadió características como predicciones con múltiples etiquetas para cada cuadro delimitador y una mejor red extractora de características.
|
||||
|
||||
- **YOLOv3-Ultralytics:** La implementación de Ultralytics de YOLOv3 proporciona el mismo rendimiento que el modelo original, pero cuenta con soporte adicional para más modelos pre-entrenados, métodos de entrenamiento adicionales y opciones de personalización más fáciles. Esto lo hace más versátil y fácil de usar para aplicaciones prácticas.
|
||||
|
||||
- **YOLOv3u:** Este modelo actualizado incorpora la cabeza dividida sin anclaje y sin objeto de YOLOv8. Al eliminar la necesidad de cajas de anclaje predefinidas y puntuaciones de objeto, este diseño de cabeza de detección puede mejorar la capacidad del modelo para detectar objetos de diferentes tamaños y formas. Esto hace que YOLOv3u sea más robusto y preciso para tareas de detección de objetos.
|
||||
|
||||
## Tareas y modos admitidos
|
||||
|
||||
La serie YOLOv3, que incluye YOLOv3, YOLOv3-Ultralytics y YOLOv3u, está diseñada específicamente para tareas de detección de objetos. Estos modelos son reconocidos por su eficacia en diversos escenarios del mundo real, equilibrando precisión y velocidad. Cada variante ofrece características y optimizaciones únicas, lo que los hace adecuados para una variedad de aplicaciones.
|
||||
|
||||
Los tres modelos admiten un conjunto completo de modos, asegurando versatilidad en diversas etapas del despliegue y desarrollo del modelo. Estos modos incluyen [Inferencia](../modes/predict.md), [Validación](../modes/val.md), [Entrenamiento](../modes/train.md) y [Exportación](../modes/export.md), proporcionando a los usuarios un conjunto completo de herramientas para una detección de objetos efectiva.
|
||||
|
||||
| Tipo de modelo | Tareas admitidas | Inferencia | Validación | Entrenamiento | Exportación |
|
||||
|--------------------|--------------------------------------------|------------|------------|---------------|-------------|
|
||||
| YOLOv3 | [Detección de objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv3-Ultralytics | [Detección de objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv3u | [Detección de objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
|
||||
Esta tabla proporciona una visión rápida de las capacidades de cada variante de YOLOv3, destacando su versatilidad y aptitud para diversas tareas y modos operativos en flujos de trabajo de detección de objetos.
|
||||
|
||||
## Ejemplos de uso
|
||||
|
||||
Este ejemplo proporciona ejemplos sencillos de entrenamiento e inferencia de YOLOv3. Para obtener documentación completa sobre estos y otros [modos](../modes/index.md), consulta las páginas de documentación de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md).
|
||||
|
||||
!!! Example "Ejemplo"
|
||||
|
||||
=== "Python"
|
||||
|
||||
Los modelos pre-entrenados de PyTorch en archivos `*.pt`, así como los archivos de configuración `*.yaml`, se pueden pasar a la clase `YOLO()` para crear una instancia del modelo en Python:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo YOLOv3n pre-entrenado en COCO
|
||||
model = YOLO('yolov3n.pt')
|
||||
|
||||
# Mostrar información del modelo (opcional)
|
||||
model.info()
|
||||
|
||||
# Entrenar el modelo en el conjunto de datos de ejemplo COCO8 durante 100 épocas
|
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# Ejecutar inferencia con el modelo YOLOv3n en la imagen 'bus.jpg'
|
||||
results = model('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
Hay comandos de CLI disponibles para ejecutar directamente los modelos:
|
||||
|
||||
```bash
|
||||
# Cargar un modelo YOLOv3n pre-entrenado en COCO y entrenarlo en el conjunto de datos de ejemplo COCO8 durante 100 épocas
|
||||
yolo train model=yolov3n.pt data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# Cargar un modelo YOLOv3n pre-entrenado en COCO y ejecutar inferencia en la imagen 'bus.jpg'
|
||||
yolo predict model=yolov3n.pt source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## Citaciones y agradecimientos
|
||||
|
||||
Si utilizas YOLOv3 en tu investigación, por favor, cita los artículos originales de YOLO y el repositorio de YOLOv3 de Ultralytics:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{redmon2018yolov3,
|
||||
title={YOLOv3: An Incremental Improvement},
|
||||
author={Redmon, Joseph and Farhadi, Ali},
|
||||
journal={arXiv preprint arXiv:1804.02767},
|
||||
year={2018}
|
||||
}
|
||||
```
|
||||
|
||||
Gracias a Joseph Redmon y Ali Farhadi por desarrollar YOLOv3 original.
|
||||
71
docs/es/models/yolov4.md
Normal file
71
docs/es/models/yolov4.md
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explora nuestra detallada guía sobre YOLOv4, un detector de objetos en tiempo real de vanguardia. Comprende sus aspectos arquitectónicos destacados, características innovadoras y ejemplos de aplicación.
|
||||
keywords: ultralytics, YOLOv4, detección de objetos, red neuronal, detección en tiempo real, detector de objetos, aprendizaje automático
|
||||
---
|
||||
|
||||
# YOLOv4: Detección de objetos rápida y precisa
|
||||
|
||||
Bienvenido a la página de documentación de Ultralytics para YOLOv4, un detector de objetos en tiempo real de vanguardia lanzado en 2020 por Alexey Bochkovskiy en [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet). YOLOv4 está diseñado para ofrecer un equilibrio óptimo entre velocidad y precisión, lo que lo convierte en una excelente opción para muchas aplicaciones.
|
||||
|
||||
|
||||
**Diagrama de arquitectura de YOLOv4**. Muestra el intrincado diseño de red de YOLOv4, incluyendo los componentes backbone, neck y head, y sus capas interconectadas para una detección de objetos en tiempo real óptima.
|
||||
|
||||
## Introducción
|
||||
|
||||
YOLOv4 significa You Only Look Once versión 4. Es un modelo de detección de objetos en tiempo real desarrollado para abordar las limitaciones de versiones anteriores de YOLO como [YOLOv3](yolov3.md) y otros modelos de detección de objetos. A diferencia de otros detectores de objetos basados en redes neuronales convolucionales (CNN), YOLOv4 no solo es aplicable para sistemas de recomendación, sino también para la gestión de procesos independientes y la reducción de la entrada humana. Su funcionamiento en unidades de procesamiento de gráficos (GPU) convencionales permite su uso masivo a un precio asequible, y está diseñado para funcionar en tiempo real en una GPU convencional, siendo necesario solo una GPU para el entrenamiento.
|
||||
|
||||
## Arquitectura
|
||||
|
||||
YOLOv4 utiliza varias características innovadoras que trabajan juntas para optimizar su rendimiento. Estas incluyen Conexiones Residuales Ponderadas (WRC), Conexiones Parciales Cruzadas en Etapas (CSP), Normalización Cruzada de Mini-Batch (CmBN), Entrenamiento Autoadversarial (SAT), Activación Mish, Aumento de Datos Mosaico, Regularización DropBlock y Pérdida CIoU. Estas características se combinan para lograr resultados de vanguardia.
|
||||
|
||||
Un detector de objetos típico está compuesto por varias partes, incluyendo la entrada, el backbone (espinazo), el neck (cuello) y el head (cabeza). El backbone de YOLOv4 está pre-entrenado en ImageNet y se utiliza para predecir las clases y las cajas delimitadoras de los objetos. El backbone puede ser de varios modelos, incluyendo VGG, ResNet, ResNeXt o DenseNet. La parte del neck del detector se utiliza para recolectar mapas de características de diferentes etapas y generalmente incluye varias rutas de abajo hacia arriba y varias rutas de arriba hacia abajo. La parte de la cabeza es la que se utiliza para realizar las detecciones y clasificaciones finales de objetos.
|
||||
|
||||
## Bolsa de regalos
|
||||
|
||||
YOLOv4 también utiliza métodos conocidos como "bolsa de regalos" (bag of freebies), que son técnicas que mejoran la precisión del modelo durante el entrenamiento sin aumentar el costo de la inferencia. La ampliación de datos es una técnica común de la bolsa de regalos utilizada en la detección de objetos, que aumenta la variabilidad de las imágenes de entrada para mejorar la robustez del modelo. Algunos ejemplos de ampliación de datos incluyen distorsiones fotométricas (ajuste del brillo, contraste, matiz, saturación y ruido de una imagen) y distorsiones geométricas (agregar escalado, recorte, volteo y rotación aleatorios). Estas técnicas ayudan al modelo a generalizar mejor para diferentes tipos de imágenes.
|
||||
|
||||
## Características y rendimiento
|
||||
|
||||
YOLOv4 está diseñado para obtener una velocidad y precisión óptimas en la detección de objetos. La arquitectura de YOLOv4 incluye CSPDarknet53 como backbone, PANet como neck y YOLOv3 como cabeza de detección. Este diseño permite que YOLOv4 realice la detección de objetos a una velocidad impresionante, lo que lo hace adecuado para aplicaciones en tiempo real. YOLOv4 también sobresale en precisión, logrando resultados de vanguardia en los benchmarks de detección de objetos.
|
||||
|
||||
## Ejemplos de uso
|
||||
|
||||
Hasta el momento de escribir este documento, Ultralytics actualmente no admite modelos YOLOv4. Por lo tanto, cualquier usuario interesado en usar YOLOv4 deberá consultar directamente el repositorio de YOLOv4 en GitHub para obtener instrucciones de instalación y uso.
|
||||
|
||||
Aquí hay un resumen breve de los pasos típicos que podrías seguir para usar YOLOv4:
|
||||
|
||||
1. Visita el repositorio de YOLOv4 en GitHub: [https://github.com/AlexeyAB/darknet](https://github.com/AlexeyAB/darknet).
|
||||
|
||||
2. Sigue las instrucciones proporcionadas en el archivo README para la instalación. Esto generalmente implica clonar el repositorio, instalar las dependencias necesarias y configurar las variables de entorno necesarias.
|
||||
|
||||
3. Una vez que la instalación esté completa, puedes entrenar y usar el modelo según las instrucciones de uso proporcionadas en el repositorio. Esto normalmente implica preparar tu conjunto de datos, configurar los parámetros del modelo, entrenar el modelo y luego usar el modelo entrenado para realizar la detección de objetos.
|
||||
|
||||
Ten en cuenta que los pasos específicos pueden variar dependiendo de tu caso de uso específico y del estado actual del repositorio de YOLOv4. Por lo tanto, se recomienda encarecidamente consultar directamente las instrucciones proporcionadas en el repositorio de YOLOv4 en GitHub.
|
||||
|
||||
Lamentamos cualquier inconveniente que esto pueda causar y nos esforzaremos por actualizar este documento con ejemplos de uso para Ultralytics una vez que se implemente el soporte para YOLOv4.
|
||||
|
||||
## Conclusión
|
||||
|
||||
YOLOv4 es un modelo de detección de objetos potente y eficiente que logra un equilibrio entre velocidad y precisión. Su uso de características únicas y técnicas de bolsa de regalos durante el entrenamiento le permite realizar un excelente desempeño en tareas de detección de objetos en tiempo real. YOLOv4 puede ser entrenado y utilizado por cualquier persona con una GPU convencional, lo que lo hace accesible y práctico para una amplia gama de aplicaciones.
|
||||
|
||||
## Citaciones y agradecimientos
|
||||
|
||||
Nos gustaría reconocer a los autores de YOLOv4 por sus importantes contribuciones en el campo de la detección de objetos en tiempo real:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{bochkovskiy2020yolov4,
|
||||
title={YOLOv4: Optimal Speed and Accuracy of Object Detection},
|
||||
author={Alexey Bochkovskiy and Chien-Yao Wang and Hong-Yuan Mark Liao},
|
||||
year={2020},
|
||||
eprint={2004.10934},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
El artículo original de YOLOv4 se puede encontrar en [arXiv](https://arxiv.org/pdf/2004.10934.pdf). Los autores han puesto su trabajo a disposición del público, y el código se puede acceder en [GitHub](https://github.com/AlexeyAB/darknet). Apreciamos sus esfuerzos en el avance del campo y en hacer que su trabajo sea accesible para la comunidad en general.
|
||||
113
docs/es/models/yolov5.md
Normal file
113
docs/es/models/yolov5.md
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
---
|
||||
comments: true
|
||||
description: Descubra YOLOv5u, una versión mejorada del modelo YOLOv5 con un mejor equilibrio entre precisión y velocidad, y numerosos modelos pre-entrenados para diversas tareas de detección de objetos.
|
||||
keywords: YOLOv5u, detección de objetos, modelos pre-entrenados, Ultralytics, Inferencia, Validación, YOLOv5, YOLOv8, sin anclas, sin atención al objeto, aplicaciones en tiempo real, aprendizaje automático
|
||||
---
|
||||
|
||||
# YOLOv5
|
||||
|
||||
## Resumen
|
||||
|
||||
YOLOv5u representa un avance en las metodologías de detección de objetos. Originado a partir de la arquitectura fundamental del modelo [YOLOv5](https://github.com/ultralytics/yolov5) desarrollado por Ultralytics, YOLOv5u integra la división de la cabeza Ultralytics sin anclas y sin atención al objeto, una característica introducida previamente en los modelos [YOLOv8](yolov8.md). Esta adaptación perfecciona la arquitectura del modelo, resultando en un mejor equilibrio entre precisión y velocidad en tareas de detección de objetos. Con base en los resultados empíricos y sus características derivadas, YOLOv5u proporciona una alternativa eficiente para aquellos que buscan soluciones robustas tanto en investigación como en aplicaciones prácticas.
|
||||
|
||||
|
||||
|
||||
## Características clave
|
||||
|
||||
- **Cabeza dividida Ultralytics sin anclas:** Los modelos tradicionales de detección de objetos dependen de cajas de anclaje predefinidas para predecir la ubicación de los objetos. Sin embargo, YOLOv5u moderniza este enfoque. Al adoptar una cabeza Ultralytics dividida sin anclas, se garantiza un mecanismo de detección más flexible y adaptable, lo que en consecuencia mejora el rendimiento en diversos escenarios.
|
||||
|
||||
- **Equilibrio óptimo entre precisión y velocidad:** La velocidad y la precisión suelen ser contrapuestas. Pero YOLOv5u desafía este equilibrio. Ofrece un balance calibrado, garantizando detecciones en tiempo real sin comprometer la precisión. Esta característica es especialmente valiosa para aplicaciones que requieren respuestas rápidas, como vehículos autónomos, robótica y análisis de video en tiempo real.
|
||||
|
||||
- **Variedad de modelos pre-entrenados:** Entendiendo que diferentes tareas requieren diferentes herramientas, YOLOv5u proporciona una gran cantidad de modelos pre-entrenados. Ya sea que te enfoques en Inferencia, Validación o Entrenamiento, hay un modelo a la medida esperándote. Esta variedad asegura que no estés utilizando una solución genérica, sino un modelo específicamente ajustado para tu desafío único.
|
||||
|
||||
## Tareas y Modos Soportados
|
||||
|
||||
Los modelos YOLOv5u, con diferentes pesos pre-entrenados, sobresalen en las tareas de [Detección de Objetos](../tasks/detect.md). Soportan una amplia gama de modos que los hacen adecuados para diversas aplicaciones, desde el desarrollo hasta la implementación.
|
||||
|
||||
| Tipo de Modelo | Pesos Pre-entrenados | Tarea | Inferencia | Validación | Entrenamiento | Exportación |
|
||||
|----------------|-----------------------------------------------------------------------------------------------------------------------------|--------------------------------------------|------------|------------|---------------|-------------|
|
||||
| YOLOv5u | `yolov5nu`, `yolov5su`, `yolov5mu`, `yolov5lu`, `yolov5xu`, `yolov5n6u`, `yolov5s6u`, `yolov5m6u`, `yolov5l6u`, `yolov5x6u` | [Detección de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
|
||||
Esta tabla proporciona una descripción detallada de las variantes de modelos YOLOv5u, destacando su aplicabilidad en tareas de detección de objetos y el soporte para varios modos operativos como [Inferencia](../modes/predict.md), [Validación](../modes/val.md), [Entrenamiento](../modes/train.md) y [Exportación](../modes/export.md). Este soporte integral asegura que los usuarios puedan aprovechar al máximo las capacidades de los modelos YOLOv5u en una amplia gama de escenarios de detección de objetos.
|
||||
|
||||
## Métricas de Rendimiento
|
||||
|
||||
!!! Rendimiento
|
||||
|
||||
=== "Detección"
|
||||
|
||||
Consulta la [Documentación de Detección](https://docs.ultralytics.com/tasks/detect/) para obtener ejemplos de uso con estos modelos entrenados en [COCO](https://docs.ultralytics.com/datasets/detect/coco/), los cuales incluyen 80 clases pre-entrenadas.
|
||||
|
||||
| Modelo | YAML | 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) |
|
||||
|---------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------|-----------------------|----------------------|--------------------------------|-------------------------------------|--------------------|-------------------|
|
||||
| [yolov5nu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5nu.pt) | [yolov5n.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 34.3 | 73.6 | 1.06 | 2.6 | 7.7 |
|
||||
| [yolov5su.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5su.pt) | [yolov5s.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 43.0 | 120.7 | 1.27 | 9.1 | 24.0 |
|
||||
| [yolov5mu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5mu.pt) | [yolov5m.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 49.0 | 233.9 | 1.86 | 25.1 | 64.2 |
|
||||
| [yolov5lu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5lu.pt) | [yolov5l.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 52.2 | 408.4 | 2.50 | 53.2 | 135.0 |
|
||||
| [yolov5xu.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5xu.pt) | [yolov5x.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5.yaml) | 640 | 53.2 | 763.2 | 3.81 | 97.2 | 246.4 |
|
||||
| | | | | | | | |
|
||||
| [yolov5n6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5n6u.pt) | [yolov5n6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 42.1 | 211.0 | 1.83 | 4.3 | 7.8 |
|
||||
| [yolov5s6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5s6u.pt) | [yolov5s6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 48.6 | 422.6 | 2.34 | 15.3 | 24.6 |
|
||||
| [yolov5m6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5m6u.pt) | [yolov5m6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 53.6 | 810.9 | 4.36 | 41.2 | 65.7 |
|
||||
| [yolov5l6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5l6u.pt) | [yolov5l6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 55.7 | 1470.9 | 5.47 | 86.1 | 137.4 |
|
||||
| [yolov5x6u.pt](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov5x6u.pt) | [yolov5x6.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/models/v5/yolov5-p6.yaml) | 1280 | 56.8 | 2436.5 | 8.98 | 155.4 | 250.7 |
|
||||
|
||||
## Ejemplos de Uso
|
||||
|
||||
Este ejemplo proporciona ejemplos sencillos de entrenamiento e inferencia de YOLOv5. Para obtener documentación completa sobre estos y otros [modos](../modes/index.md), consulta las páginas de documentación de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md).
|
||||
|
||||
!!! Example "Ejemplo"
|
||||
|
||||
=== "Python"
|
||||
|
||||
Los modelos pre-entrenados `*.pt` de PyTorch, así como los archivos de configuración `*.yaml`, se pueden pasar a la clase `YOLO()` para crear una instancia de modelo en Python:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Cargar un modelo YOLOv5n pre-entrenado en COCO
|
||||
modelo = YOLO('yolov5n.pt')
|
||||
|
||||
# Mostrar información del modelo (opcional)
|
||||
modelo.info()
|
||||
|
||||
# Entrenar el modelo con 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 YOLOv5n en la imagen 'bus.jpg'
|
||||
resultados = modelo('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
Hay comandos de CLI disponibles para ejecutar directamente los modelos:
|
||||
|
||||
```bash
|
||||
# Cargar un modelo YOLOv5n pre-entrenado en COCO y entrenarlo con el conjunto de datos de ejemplo COCO8 durante 100 épocas
|
||||
yolo train model=yolov5n.pt data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# Cargar un modelo YOLOv5n pre-entrenado en COCO y ejecutar inferencia en la imagen 'bus.jpg'
|
||||
yolo predict model=yolov5n.pt source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## Citaciones y Reconocimientos
|
||||
|
||||
Si utilizas YOLOv5 o YOLOv5u en tu investigación, por favor cita el repositorio de Ultralytics YOLOv5 de la siguiente manera:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
```bibtex
|
||||
@software{yolov5,
|
||||
title = {Ultralytics YOLOv5},
|
||||
author = {Glenn Jocher},
|
||||
year = {2020},
|
||||
version = {7.0},
|
||||
license = {AGPL-3.0},
|
||||
url = {https://github.com/ultralytics/yolov5},
|
||||
doi = {10.5281/zenodo.3908559},
|
||||
orcid = {0000-0001-5950-6979}
|
||||
}
|
||||
```
|
||||
|
||||
Ten en cuenta que los modelos YOLOv5 se proporcionan bajo las licencias [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) y [Enterprise](https://ultralytics.com/license).
|
||||
107
docs/es/models/yolov6.md
Normal file
107
docs/es/models/yolov6.md
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explora Meituan YOLOv6, un modelo de detección de objetos de última generación que logra un equilibrio entre velocidad y precisión. Sumérgete en características, modelos pre-entrenados y el uso de Python.
|
||||
keywords: Meituan YOLOv6, detección de objetos, Ultralytics, documentación de YOLOv6, Concatenación Bidireccional, Entrenamiento con Anclas, modelos pre-entrenados, aplicaciones en tiempo real
|
||||
---
|
||||
|
||||
# Meituan YOLOv6
|
||||
|
||||
## Visión general
|
||||
|
||||
[Meituan](https://about.meituan.com/) YOLOv6 es un detector de objetos de última generación que ofrece un notable equilibrio entre velocidad y precisión, lo que lo convierte en una opción popular para aplicaciones en tiempo real. Este modelo presenta varias mejoras notables en su arquitectura y esquema de entrenamiento, que incluyen la implementación de un módulo de Concatenación Bidireccional (BiC), una estrategia de entrenamiento con anclas (AAT) y un diseño de columna vertebral y cuello mejorado para lograr una precisión de última generación en el conjunto de datos COCO.
|
||||
|
||||
|
||||
|
||||
**Visión general de YOLOv6.** Diagrama de la arquitectura del modelo que muestra los componentes de la red redesdiseñados y las estrategias de entrenamiento que han llevado a mejoras significativas en el rendimiento. (a) El cuello de YOLOv6 (N y S se muestran). Señalar que, en M/L, RepBlocks es reemplazado por CSPStackRep. (b) La estructura de un módulo BiC. (c) Un bloque SimCSPSPPF. ([fuente](https://arxiv.org/pdf/2301.05586.pdf)).
|
||||
|
||||
### Características clave
|
||||
|
||||
- **Módulo de Concatenación Bidireccional (BiC):** YOLOv6 introduce un módulo de BiC en el cuello del detector, mejorando las señales de localización y ofreciendo mejoras en el rendimiento con una degradación de velocidad despreciable.
|
||||
- **Estrategia de Entrenamiento con Anclas (AAT):** Este modelo propone AAT para disfrutar de los beneficios de los paradigmas basados en anclas y sin anclas sin comprometer la eficiencia de inferencia.
|
||||
- **Diseño de Columna Vertebral y Cuello Mejorado:** Al profundizar en YOLOv6 para incluir otra etapa en la columna vertebral y el cuello, este modelo logra un rendimiento de última generación en el conjunto de datos COCO con una entrada de alta resolución.
|
||||
- **Estrategia de Auto-Destilación:** Se implementa una nueva estrategia de auto-destilación para mejorar el rendimiento de los modelos más pequeños de YOLOv6, mejorando la rama de regresión auxiliar durante el entrenamiento y eliminándola durante la inferencia para evitar una marcada disminución de velocidad.
|
||||
|
||||
## Métricas de rendimiento
|
||||
|
||||
YOLOv6 proporciona varios modelos pre-entrenados con diferentes escalas:
|
||||
|
||||
- YOLOv6-N: 37.5% de precisión promedio (AP) en COCO val2017 a 1187 FPS con la GPU NVIDIA Tesla T4.
|
||||
- YOLOv6-S: 45.0% de AP a 484 FPS.
|
||||
- YOLOv6-M: 50.0% de AP a 226 FPS.
|
||||
- YOLOv6-L: 52.8% de AP a 116 FPS.
|
||||
- YOLOv6-L6: Precisión de última generación en tiempo real.
|
||||
|
||||
YOLOv6 también proporciona modelos cuantizados para diferentes precisiones y modelos optimizados para plataformas móviles.
|
||||
|
||||
## Ejemplos de uso
|
||||
|
||||
Este ejemplo proporciona ejemplos sencillos de entrenamiento e inferencia con YOLOv6. Para obtener documentación completa sobre estos y otros [modos](../modes/index.md), consulta las páginas de documentación de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md).
|
||||
|
||||
!!! Example "Ejemplo"
|
||||
|
||||
=== "Python"
|
||||
|
||||
Los modelos pre-entrenados en `*.pt` de PyTorch, así como los archivos de configuración `*.yaml`, se pueden pasar a la clase `YOLO()` para crear una instancia del modelo en Python:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Construir un modelo YOLOv6n desde cero
|
||||
modelo = YOLO('yolov6n.yaml')
|
||||
|
||||
# Mostrar información del modelo (opcional)
|
||||
modelo.info()
|
||||
|
||||
# Entrenar el modelo en el conjunto de datos de ejemplo COCO8 durante 100 epochs
|
||||
resultados = modelo.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# Ejecutar inferencia con el modelo YOLOv6n en la imagen 'bus.jpg'
|
||||
resultados = modelo('path/to/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
Se dispone de comandos de línea de comandos (CLI) para ejecutar directamente los modelos:
|
||||
|
||||
```bash
|
||||
# Construir un modelo YOLOv6n desde cero y entrenarlo en el conjunto de datos de ejemplo COCO8 durante 100 epochs
|
||||
yolo train model=yolov6n.yaml data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# Construir un modelo YOLOv6n desde cero y ejecutar inferencia en la imagen 'bus.jpg'
|
||||
yolo predict model=yolov6n.yaml source=path/to/bus.jpg
|
||||
```
|
||||
|
||||
## Tareas y Modos Soportados
|
||||
|
||||
La serie YOLOv6 ofrece una variedad de modelos, cada uno optimizado para [Detección de Objetos](../tasks/detect.md) de alto rendimiento. Estos modelos se adaptan a distintas necesidades computacionales y requisitos de precisión, lo que los hace versátiles para una amplia gama de aplicaciones.
|
||||
|
||||
| Tipo de Modelo | Pesos Pre-entrenados | Tareas Soportadas | Inferencia | Validación | Entrenamiento | Exportación |
|
||||
|----------------|----------------------|--------------------------------------------|------------|------------|---------------|-------------|
|
||||
| YOLOv6-N | `yolov6-n.pt` | [Detección de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv6-S | `yolov6-s.pt` | [Detección de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv6-M | `yolov6-m.pt` | [Detección de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv6-L | `yolov6-l.pt` | [Detección de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv6-L6 | `yolov6-l6.pt` | [Detección de Objetos](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
|
||||
Esta tabla proporciona una descripción detallada de las variantes del modelo YOLOv6, destacando sus capacidades en tareas de detección de objetos y su compatibilidad con varios modos operativos como [Inferencia](../modes/predict.md), [Validación](../modes/val.md), [Entrenamiento](../modes/train.md) y [Exportación](../modes/export.md). Este soporte integral garantiza que los usuarios puedan aprovechar al máximo las capacidades de los modelos YOLOv6 en una amplia gama de escenarios de detección de objetos.
|
||||
|
||||
## Citaciones y Agradecimientos
|
||||
|
||||
Nos gustaría agradecer a los autores por sus importantes contribuciones en el campo de la detección de objetos en tiempo real:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@misc{li2023yolov6,
|
||||
title={YOLOv6 v3.0: A Full-Scale Reloading},
|
||||
author={Chuyi Li and Lulu Li and Yifei Geng and Hongliang Jiang and Meng Cheng and Bo Zhang and Zaidan Ke and Xiaoming Xu and Xiangxiang Chu},
|
||||
year={2023},
|
||||
eprint={2301.05586},
|
||||
archivePrefix={arXiv},
|
||||
primaryClass={cs.CV}
|
||||
}
|
||||
```
|
||||
|
||||
Se puede encontrar el artículo original de YOLOv6 en [arXiv](https://arxiv.org/abs/2301.05586). Los autores han puesto su trabajo a disposición del público y el código fuente se puede acceder en [GitHub](https://github.com/meituan/YOLOv6). Agradecemos sus esfuerzos en avanzar en el campo y hacer que su trabajo sea accesible para la comunidad en general.
|
||||
66
docs/es/models/yolov7.md
Normal file
66
docs/es/models/yolov7.md
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explora el YOLOv7, un detector de objetos en tiempo real. Comprende su velocidad superior, precisión impresionante y enfoque único en la optimización de entrenamiento de bolsas de características entrenables.
|
||||
keywords: YOLOv7, detector de objetos en tiempo real, estado del arte, Ultralytics, conjunto de datos MS COCO, re-parametrización del modelo, asignación dinámica de etiquetas, escalado extendido, escalado compuesto
|
||||
---
|
||||
|
||||
# YOLOv7: Bolsa de Características Entrenable
|
||||
|
||||
YOLOv7 es un detector de objetos en tiempo real de última generación que supera a todos los detectores de objetos conocidos tanto en velocidad como en precisión en el rango de 5 FPS a 160 FPS. Tiene la mayor precisión (56.8% AP) entre todos los detectores de objetos en tiempo real conocidos con una velocidad de 30 FPS o superior en la GPU V100. Además, YOLOv7 supera a otros detectores de objetos como YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5 y muchos otros en cuanto a velocidad y precisión. El modelo se entrena desde cero utilizando el conjunto de datos MS COCO sin utilizar ningún otro conjunto de datos o pesos pre-entrenados. El código fuente de YOLOv7 está disponible en GitHub.
|
||||
|
||||
|
||||
**Comparación de los detectores de objetos de estado del arte.
|
||||
** Según los resultados en la Tabla 2, sabemos que el método propuesto tiene el mejor equilibrio entre velocidad y precisión de manera integral. Si comparamos YOLOv7-tiny-SiLU con YOLOv5-N (r6.1), nuestro método es 127 fps más rápido y un 10.7% más preciso en AP. Además, YOLOv7 tiene un AP del 51.4% a una velocidad de cuadro de 161 fps, mientras que PPYOLOE-L con el mismo AP tiene solo una velocidad de cuadro de 78 fps. En términos de uso de parámetros, YOLOv7 utiliza un 41% menos que PPYOLOE-L. Si comparamos YOLOv7-X con una velocidad de inferencia de 114 fps con YOLOv5-L (r6.1) con una velocidad de inferencia de 99 fps, YOLOv7-X puede mejorar el AP en un 3.9%. Si se compara YOLOv7-X con YOLOv5-X (r6.1) de una escala similar, la velocidad de inferencia de YOLOv7-X es 31 fps más rápida. Además, en términos de cantidad de parámetros y cálculos, YOLOv7-X reduce un 22% de los parámetros y un 8% de los cálculos en comparación con YOLOv5-X (r6.1), pero mejora el AP en un 2.2% ([Fuente](https://arxiv.org/pdf/2207.02696.pdf)).
|
||||
|
||||
## Descripción general
|
||||
|
||||
La detección de objetos en tiempo real es un componente importante en muchos sistemas de visión por computadora, incluyendo el seguimiento de múltiples objetos, conducción autónoma, robótica y análisis de imágenes médicas. En los últimos años, el desarrollo de la detección de objetos en tiempo real se ha centrado en el diseño de arquitecturas eficientes y en la mejora de la velocidad de inferencia de diversas CPUs, GPUs y unidades de procesamiento neural (NPUs). YOLOv7 es compatible tanto con GPU para dispositivos móviles como con GPU para dispositivos de escritorio, desde el borde hasta la nube.
|
||||
|
||||
A diferencia de los detectores de objetos en tiempo real tradicionales que se centran en la optimización de la arquitectura, YOLOv7 introduce un enfoque en la optimización del proceso de entrenamiento. Esto incluye módulos y métodos de optimización diseñados para mejorar la precisión de la detección de objetos sin aumentar el costo de inferencia, un concepto conocido como "bolsas de características entrenables".
|
||||
|
||||
## Características clave
|
||||
|
||||
YOLOv7 introduce varias características clave:
|
||||
|
||||
1. **Re-parametrización del modelo**: YOLOv7 propone un modelo re-parametrizado planificado, que es una estrategia aplicable a capas en diferentes redes con el concepto de propagación del gradiente.
|
||||
|
||||
2. **Asignación dinámica de etiquetas**: El entrenamiento del modelo con múltiples capas de salida presenta un nuevo problema: "¿Cómo asignar objetivos dinámicos para las salidas de diferentes ramas?" Para resolver este problema, YOLOv7 introduce un nuevo método de asignación de etiquetas llamado asignación de etiquetas guiadas de manera gruesa a fina.
|
||||
|
||||
3. **Escalado extendido y compuesto**: YOLOv7 propone métodos de "escalado extendido" y "escalado compuesto" para el detector de objetos en tiempo real que pueden utilizar eficazmente los parámetros y cálculos.
|
||||
|
||||
4. **Eficiencia**: El método propuesto por YOLOv7 puede reducir eficazmente aproximadamente el 40% de los parámetros y el 50% de los cálculos del detector de objetos en tiempo real de última generación y tiene una velocidad de inferencia más rápida y una mayor precisión de detección.
|
||||
|
||||
## Ejemplos de uso
|
||||
|
||||
Hasta la fecha de redacción de este documento, Ultralytics no admite actualmente modelos YOLOv7. Por lo tanto, los usuarios interesados en utilizar YOLOv7 deberán consultar directamente el repositorio de GitHub de YOLOv7 para obtener instrucciones de instalación y uso.
|
||||
|
||||
Aquí hay un resumen breve de los pasos típicos que podrías seguir para usar YOLOv7:
|
||||
|
||||
1. Visita el repositorio de GitHub de YOLOv7: [https://github.com/WongKinYiu/yolov7](https://github.com/WongKinYiu/yolov7).
|
||||
|
||||
2. Sigue las instrucciones proporcionadas en el archivo README para la instalación. Esto generalmente implica clonar el repositorio, instalar las dependencias necesarias y configurar las variables de entorno necesarias.
|
||||
|
||||
3. Una vez que la instalación esté completa, puedes entrenar y utilizar el modelo según las instrucciones de uso proporcionadas en el repositorio. Esto generalmente implica preparar tu conjunto de datos, configurar los parámetros del modelo, entrenar el modelo y luego utilizar el modelo entrenado para realizar la detección de objetos.
|
||||
|
||||
Ten en cuenta que los pasos específicos pueden variar según tu caso de uso específico y el estado actual del repositorio YOLOv7. Por lo tanto, se recomienda encarecidamente consultar directamente las instrucciones proporcionadas en el repositorio de GitHub de YOLOv7.
|
||||
|
||||
Lamentamos cualquier inconveniente que esto pueda causar y nos esforzaremos por actualizar este documento con ejemplos de uso para Ultralytics una vez que se implemente el soporte para YOLOv7.
|
||||
|
||||
## Citaciones y Agradecimientos
|
||||
|
||||
Nos gustaría agradecer a los autores de YOLOv7 por sus importantes contribuciones en el campo de la detección de objetos en tiempo real:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@article{wang2022yolov7,
|
||||
title={{YOLOv7}: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors},
|
||||
author={Wang, Chien-Yao and Bochkovskiy, Alexey and Liao, Hong-Yuan Mark},
|
||||
journal={arXiv preprint arXiv:2207.02696},
|
||||
year={2022}
|
||||
}
|
||||
```
|
||||
|
||||
El artículo original de YOLOv7 se puede encontrar en [arXiv](https://arxiv.org/pdf/2207.02696.pdf). Los autores han hecho su trabajo públicamente disponible y el código se puede acceder en [GitHub](https://github.com/WongKinYiu/yolov7). Agradecemos sus esfuerzos en el avance del campo y en hacer su trabajo accesible a la comunidad en general.
|
||||
162
docs/es/models/yolov8.md
Normal file
162
docs/es/models/yolov8.md
Normal file
|
|
@ -0,0 +1,162 @@
|
|||
---
|
||||
comments: true
|
||||
description: ¡Explora las emocionantes características de YOLOv8, la última versión de nuestro detector de objetos en tiempo real! Aprende cómo las arquitecturas avanzadas, los modelos preentrenados y el equilibrio óptimo entre precisión y velocidad hacen de YOLOv8 la elección perfecta para tus tareas de detección de objetos.
|
||||
keywords: YOLOv8, Ultralytics, detector de objetos en tiempo real, modelos preentrenados, documentación, detección de objetos, serie YOLO, arquitecturas avanzadas, precisión, velocidad
|
||||
---
|
||||
|
||||
# YOLOv8
|
||||
|
||||
## Descripción general
|
||||
|
||||
YOLOv8 es la última versión de la serie YOLO de detectores de objetos en tiempo real, ofreciendo un rendimiento de vanguardia en términos de precisión y velocidad. Basándose en los avances de las versiones anteriores de YOLO, YOLOv8 presenta nuevas características y optimizaciones que lo convierten en una opción ideal para diversas tareas de detección de objetos en una amplia gama de aplicaciones.
|
||||
|
||||
|
||||
|
||||
## Características principales
|
||||
|
||||
- **Arquitecturas avanzadas de columna vertebral y cuello:** YOLOv8 utiliza arquitecturas de columna vertebral y cuello de última generación, lo que resulta en una mejor extracción de características y rendimiento de detección de objetos.
|
||||
- **Cabeza Ultralytics dividida sin anclaje:** YOLOv8 adopta una cabeza Ultralytics dividida sin anclaje, lo que contribuye a una mejor precisión y a un proceso de detección más eficiente en comparación con los enfoques basados en anclaje.
|
||||
- **Equilibrio optimizado entre precisión y velocidad:** Con un enfoque en mantener un equilibrio óptimo entre precisión y velocidad, YOLOv8 es adecuado para tareas de detección de objetos en tiempo real en diversas áreas de aplicación.
|
||||
- **Variedad de modelos preentrenados:** YOLOv8 ofrece una variedad de modelos preentrenados para adaptarse a diversas tareas y requisitos de rendimiento, lo que facilita encontrar el modelo adecuado para tu caso de uso específico.
|
||||
|
||||
## Tareas y modos compatibles
|
||||
|
||||
La serie YOLOv8 ofrece una amplia gama de modelos, cada uno especializado en tareas específicas en visión por computadora. Estos modelos están diseñados para adaptarse a diversos requisitos, desde la detección de objetos hasta tareas más complejas como la segmentación de instancias, la detección de poses/puntos clave y la clasificación.
|
||||
|
||||
Cada variante de la serie YOLOv8 está optimizada para su respectiva tarea, garantizando un alto rendimiento y precisión. Además, estos modelos son compatibles con varios modos operativos, incluyendo [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md) y [Export](../modes/export.md), lo que facilita su uso en diferentes etapas de implementación y desarrollo.
|
||||
|
||||
| Modelo | Nombres de archivo | Tarea | Inferencia | Validación | Entrenamiento | Exportación |
|
||||
|-------------|----------------------------------------------------------------------------------------------------------------|---------------------------------------------------|------------|------------|---------------|-------------|
|
||||
| YOLOv8 | `yolov8n.pt` `yolov8s.pt` `yolov8m.pt` `yolov8l.pt` `yolov8x.pt` | [Detección](../tasks/detect.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv8-seg | `yolov8n-seg.pt` `yolov8s-seg.pt` `yolov8m-seg.pt` `yolov8l-seg.pt` `yolov8x-seg.pt` | [Segmentación de instancias](../tasks/segment.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv8-pose | `yolov8n-pose.pt` `yolov8s-pose.pt` `yolov8m-pose.pt` `yolov8l-pose.pt` `yolov8x-pose.pt` `yolov8x-pose-p6.pt` | [Pose/Puntos clave](../tasks/pose.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
| YOLOv8-cls | `yolov8n-cls.pt` `yolov8s-cls.pt` `yolov8m-cls.pt` `yolov8l-cls.pt` `yolov8x-cls.pt` | [Clasificación](../tasks/classify.md) | ✅ | ✅ | ✅ | ✅ |
|
||||
|
||||
Esta tabla proporciona una descripción general de las variantes de modelos YOLOv8, resaltando su aplicabilidad en tareas específicas y su compatibilidad con varios modos operativos como Inferencia, Validación, Entrenamiento y Exportación. Muestra la versatilidad y robustez de la serie YOLOv8, haciéndolos adecuados para una variedad de aplicaciones en visión por computadora.
|
||||
|
||||
## Métricas de rendimiento
|
||||
|
||||
!!! Rendimiento
|
||||
|
||||
=== "Detección (COCO)"
|
||||
|
||||
Consulta la [documentación de Detección](https://docs.ultralytics.com/tasks/detect/) para ejemplos de uso con estos modelos entrenados en [COCO](https://docs.ultralytics.com/datasets/detect/coco/), que incluyen 80 clases preentrenadas.
|
||||
|
||||
| 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 |
|
||||
|
||||
=== "Detección (Open Images V7)"
|
||||
|
||||
Consulta la [documentación de Detección](https://docs.ultralytics.com/tasks/detect/) para ejemplos de uso con estos modelos entrenados en [Open Image V7](https://docs.ultralytics.com/datasets/detect/open-images-v7/), que incluyen 600 clases preentrenadas.
|
||||
|
||||
| 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-oiv7.pt) | 640 | 18.4 | 142.4 | 1.21 | 3.5 | 10.5 |
|
||||
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8s-oiv7.pt) | 640 | 27.7 | 183.1 | 1.40 | 11.4 | 29.7 |
|
||||
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8m-oiv7.pt) | 640 | 33.6 | 408.5 | 2.26 | 26.2 | 80.6 |
|
||||
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8l-oiv7.pt) | 640 | 34.9 | 596.9 | 2.43 | 44.1 | 167.4 |
|
||||
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v0.0.0/yolov8x-oiv7.pt) | 640 | 36.3 | 860.6 | 3.56 | 68.7 | 260.6 |
|
||||
|
||||
=== "Segmentación (COCO)"
|
||||
|
||||
Consulta la [documentación de Segmentación](https://docs.ultralytics.com/tasks/segment/) para ejemplos de uso con estos modelos entrenados en [COCO](https://docs.ultralytics.com/datasets/segment/coco/), que incluyen 80 clases preentrenadas.
|
||||
|
||||
| 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 |
|
||||
|
||||
=== "Clasificación (ImageNet)"
|
||||
|
||||
Consulta la [documentación de Clasificación](https://docs.ultralytics.com/tasks/classify/) para ejemplos de uso con estos modelos entrenados en [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/), que incluyen 1000 clases preentrenadas.
|
||||
|
||||
| Modelo | tamaño<br><sup>(píxeles) | acc<br><sup>top1 | acc<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) a 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 |
|
||||
|
||||
=== "Pose (COCO)"
|
||||
|
||||
Consulta la [documentación de Estimación de Poses](https://docs.ultralytics.com/tasks/segment/) para ejemplos de uso con estos modelos entrenados en [COCO](https://docs.ultralytics.com/datasets/pose/coco/), que incluyen 1 clase preentrenada, 'person'.
|
||||
|
||||
| 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 |
|
||||
|
||||
## Ejemplos de uso
|
||||
|
||||
Este ejemplo proporciona ejemplos sencillos de entrenamiento e inferencia con YOLOv8. Para obtener documentación completa sobre estos y otros [modos](../modes/index.md), consulta las páginas de documentación de [Predict](../modes/predict.md), [Train](../modes/train.md), [Val](../modes/val.md) y [Export](../modes/export.md).
|
||||
|
||||
Ten en cuenta que el siguiente ejemplo es para modelos de detección YOLOv8. Para ver las tareas adicionales compatibles, consulta la documentación de [Segment](../tasks/segment.md), [Classify](../tasks/classify.md) y [Pose](../tasks/pose.md).
|
||||
|
||||
!!! Example "Ejemplo"
|
||||
|
||||
=== "Python"
|
||||
|
||||
Los modelos preentrenados en PyTorch `*.pt`, así como los archivos de configuración `*.yaml`, se pueden pasar a la clase `YOLO()` para crear una instancia del modelo en Python:
|
||||
|
||||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Carga un modelo YOLOv8n preentrenado en COCO
|
||||
model = YOLO('yolov8n.pt')
|
||||
|
||||
# Muestra información del modelo (opcional)
|
||||
model.info()
|
||||
|
||||
# Entrena el modelo en el conjunto de datos de ejemplo COCO8 durante 100 épocas
|
||||
results = model.train(data='coco8.yaml', epochs=100, imgsz=640)
|
||||
|
||||
# Realiza inferencia con el modelo YOLOv8n en la imagen 'bus.jpg'
|
||||
results = model('ruta/a/bus.jpg')
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
Hay comandos de CLI disponibles para ejecutar directamente los modelos:
|
||||
|
||||
```bash
|
||||
# Carga un modelo YOLOv8n preentrenado en COCO y entrénalo en el conjunto de datos de ejemplo COCO8 durante 100 épocas
|
||||
yolo train model=yolov8n.pt data=coco8.yaml epochs=100 imgsz=640
|
||||
|
||||
# Carga un modelo YOLOv8n preentrenado en COCO y realiza inferencia en la imagen 'bus.jpg'
|
||||
yolo predict model=yolov8n.pt source=ruta/a/bus.jpg
|
||||
```
|
||||
|
||||
## Citas y reconocimientos
|
||||
|
||||
Si utilizas el modelo YOLOv8 u otro software de este repositorio en tu trabajo, por favor cítalo utilizando el siguiente formato:
|
||||
|
||||
!!! Quote ""
|
||||
|
||||
=== "BibTeX"
|
||||
|
||||
```bibtex
|
||||
@software{yolov8_ultralytics,
|
||||
author = {Glenn Jocher and Ayush Chaurasia and Jing Qiu},
|
||||
title = {Ultralytics YOLOv8},
|
||||
version = {8.0.0},
|
||||
year = {2023},
|
||||
url = {https://github.com/ultralytics/ultralytics},
|
||||
orcid = {0000-0001-5950-6979, 0000-0002-7603-6750, 0000-0003-3783-7069},
|
||||
license = {AGPL-3.0}
|
||||
}
|
||||
```
|
||||
|
||||
Ten en cuenta que el DOI está pendiente y se agregará a la cita una vez que esté disponible. Los modelos de YOLOv8 se proporcionan bajo las licencias [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) y [Enterprise](https://ultralytics.com/license).
|
||||
Loading…
Add table
Add a link
Reference in a new issue