Modelo rápido Segment Anything (FastSAM)#

El modelo rápido Segment Anything (FastSAM) es una solución novedosa basada en CNN y en tiempo real para la tarea Segment Anything. Esta tarea permite segmentar cualquier objeto de una imagen a partir de distintas indicaciones de interacción del usuario. FastSAM reduce significativamente las exigencias computacionales y mantiene un rendimiento competitivo, por lo que es una opción práctica para diversas tareas de visión.

Arquitectura del modelo#

Descripción general#

FastSAM está diseñado para abordar las limitaciones de Segment Anything Model (SAM), un modelo Transformer de gran tamaño que requiere muchos recursos computacionales. FastSAM divide la tarea Segment Anything en dos etapas secuenciales: segmentación de instancias de todas ellas y selección guiada por indicaciones. En la primera etapa, se usa YOLOv8-seg para generar las máscaras de segmentación de todas las instancias de la imagen. En la segunda etapa, se obtiene la región de interés correspondiente a la indicación.

Características principales#

1. Solución en tiempo real: FastSAM aprovecha la eficiencia computacional de las CNN para ofrecer una solución en tiempo real a la tarea Segment Anything, lo que la hace valiosa para aplicaciones industriales que requieren resultados rápidos.

2. Eficiencia y rendimiento: FastSAM reduce significativamente las exigencias computacionales y de recursos sin comprometer la calidad del rendimiento. Alcanza un rendimiento comparable al de SAM, pero con muchos menos recursos computacionales, lo que permite su uso en aplicaciones en tiempo real.

3. Segmentación guiada por indicaciones: FastSAM puede segmentar cualquier objeto de una imagen siguiendo distintas indicaciones de interacción del usuario, lo que aporta flexibilidad y adaptabilidad en diferentes situaciones.

4. Basado en YOLOv8-seg: FastSAM se basa en YOLOv8-seg, un detector de objetos con una rama de segmentación de instancias. Esto le permite generar eficazmente las máscaras de segmentación de todas las instancias de una imagen.

5. Resultados competitivos en pruebas de referencia: En la tarea de propuestas de objetos de MS COCO, FastSAM obtiene puntuaciones altas y funciona mucho más rápido que SAM en una sola NVIDIA RTX 3090, lo que demuestra su eficiencia y capacidad.

6. Aplicaciones prácticas: El enfoque propuesto ofrece una solución práctica y novedosa para numerosas tareas de visión, con una velocidad muy alta: decenas o cientos de veces superior a la de los métodos actuales.

7. Viabilidad de la compresión de modelos: FastSAM demuestra que es posible reducir significativamente el esfuerzo computacional introduciendo un sesgo inductivo en la estructura, lo que abre nuevas posibilidades para las arquitecturas de modelos grandes destinadas a tareas de visión generales.

Modelos disponibles, tareas compatibles y modos de funcionamiento#

Esta tabla presenta los modelos disponibles con sus pesos preentrenados específicos, las tareas compatibles y su compatibilidad con distintos modos de funcionamiento, como Inferencia, Validación, Entrenamiento y Exportación. Los emojis ✅ indican los modos compatibles y los emojis ❌, los modos no compatibles.

Comparación de FastSAM con YOLO#

Aquí comparamos FastSAM-s con las variantes de SAM de Meta y los modelos de segmentación de Ultralytics, incluido YOLO26n-seg:

Esta comparación muestra las diferencias considerables de tamaño y velocidad entre las variantes de SAM y los modelos de segmentación YOLO. Aunque SAM ofrece capacidades únicas de segmentación automática, los modelos YOLO, en particular YOLOv8n-seg, YOLO11n-seg y YOLO26n-seg, son mucho más pequeños, rápidos y eficientes desde el punto de vista computacional.

Las velocidades de SAM se han medido con PyTorch y las de YOLO, con ONNX Runtime. Las pruebas se han realizado en un Apple M4 Air de 2025 con 16 GB de RAM usando torch==2.10.0, ultralytics==8.4.31 y onnxruntime==1.24.4. Para reproducir esta prueba:

from ultralytics import ASSETS, SAM, YOLO, FastSAM

# Perfilar SAM2-t, SAM2-b, SAM-b, MobileSAM
for file in ["sam_b.pt", "sam2_b.pt", "sam2_t.pt", "mobile_sam.pt"]:
    model = SAM(file)
    model.info()
    model(ASSETS)

# Perfilar FastSAM-s
model = FastSAM("FastSAM-s.pt")
model.info()
model(ASSETS)

# Perfilar modelos YOLO (ONNX)
for file_name in ["yolov8n-seg.pt", "yolo11n-seg.pt", "yolo26n-seg.pt"]:
    model = YOLO(file_name)
    model.info()
    onnx_path = model.export(format="onnx", dynamic=True, nms=False)  # Cabezal sin NMS de YOLO26; no hace nada con YOLOv8/YOLO11
    model = YOLO(onnx_path)
    model(ASSETS)

Ejemplos de uso#

Los modelos FastSAM se integran fácilmente en tus aplicaciones Python. Ultralytics ofrece una API de Python y comandos CLI fáciles de usar para agilizar el desarrollo.

Uso de la predicción#

Para segmentar una imagen, usa el método predict como se muestra a continuación:

from ultralytics import FastSAM

# Define una fuente de inferencia
source = "path/to/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)

# Ejecutar inferencia con una indicación de cuadros delimitadores
results = model(source, bboxes=[439, 437, 524, 709])

# Ejecuta la inferencia con una indicación de puntos
results = model(source, points=[[200, 200]], labels=[1])

# Ejecuta la inferencia con indicaciones de texto
results = model(source, texts="a photo of a dog")

# Ejecuta la inferencia a la vez con indicaciones de cuadros delimitadores, puntos y texto
results = model(source, bboxes=[439, 437, 524, 709], points=[[200, 200]], labels=[1], texts="a photo of a dog")

Este fragmento muestra lo sencillo que es cargar un modelo preentrenado y ejecutar una predicción sobre una imagen.

from ultralytics.models.fastsam import FastSAMPredictor

# Crea FastSAMPredictor
overrides = {"conf": 0.25, "task": "segment", "mode": "predict", "model": "FastSAM-s.pt", "save": False, "imgsz": 1024}
predictor = FastSAMPredictor(overrides=overrides)

# Segmenta todo
everything_results = predictor("ultralytics/assets/bus.jpg")

# Inferencia con indicaciones
bbox_results = predictor.prompt(everything_results, bboxes=[[200, 200, 300, 300]])
point_results = predictor.prompt(everything_results, points=[200, 200])
text_results = predictor.prompt(everything_results, texts="a photo of a dog")

Uso de la validación#

Ten en cuenta que FastSAM solo admite la detección y segmentación de objetos de una única clase. Esto significa que reconocerá y segmentará todos los objetos como si pertenecieran a la misma clase. Por tanto, al preparar el conjunto de datos, debes convertir a 0 todos los ID de categoría de los objetos.

La validación del modelo en un conjunto de datos se puede realizar así:

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")

Seguimiento de uso#

Para realizar el seguimiento de objetos en una imagen, usa el método track como se muestra a continuación:

from ultralytics import FastSAM

# Crea un modelo FastSAM
model = FastSAM("FastSAM-s.pt")  # o FastSAM-x.pt

# Seguimiento con un modelo FastSAM en un vídeo
results = model.track(source="path/to/video.mp4", imgsz=640)

Uso oficial de FastSAM#

FastSAM también está disponible directamente en el repositorio CASIA-LMC-Lab/FastSAM. Aquí tienes un breve resumen de los pasos habituales para usar FastSAM:

Instalación#

1. Clona el repositorio de FastSAM:

   git clone https://github.com/CASIA-LMC-Lab/FastSAM.git

2. Crea y activa un entorno Conda con Python 3.9:

   conda create -n FastSAM python=3.9
   conda activate FastSAM

3. Ve al repositorio clonado e instala los paquetes necesarios:

   cd FastSAM
   pip install -r requirements.txt

4. Instala el modelo CLIP:

   pip install git+https://github.com/ultralytics/CLIP.git

Ejemplo de uso#

1. Descarga un punto de control del modelo.

2. Usa FastSAM para la inferencia. Ejemplos de comandos:

   • Segmenta todos los elementos de una imagen:

     python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg

   • Segmenta objetos concretos mediante una instrucción de texto:

     python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --text_prompt "the yellow dog"

   • Segmenta objetos dentro de un cuadro delimitador (indica las coordenadas del cuadro en formato xywh):

     python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --box_prompt "[570,200,230,400]"

   • Segmenta objetos cercanos a puntos concretos:

     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 en la demo de Colab de CASIA-LMC-Lab.

Citas y agradecimientos#

Queremos reconocer las importantes contribuciones de los autores de FastSAM al campo de la segmentación de instancias en tiempo real:

@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 está disponible en arXiv. Los autores han publicado su trabajo y puedes acceder al código en GitHub. Agradecemos sus esfuerzos por impulsar el campo y hacer que su trabajo esté al alcance de toda la comunidad.

Preguntas frecuentes#