You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
193 lines
11 KiB
193 lines
11 KiB
--- |
|
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.
|
|
|