Modèle rapide Segment Anything (FastSAM)#

Le modèle rapide Segment Anything (FastSAM) est une nouvelle solution en temps réel basée sur un CNN pour la tâche Segment Anything. Cette tâche vise à segmenter n’importe quel objet dans une image à partir de différents prompts d’interaction possibles. FastSAM réduit considérablement les besoins en calcul tout en conservant des performances compétitives, ce qui en fait un choix pratique pour diverses tâches de vision.

Architecture du modèle#

Présentation#

FastSAM vise à remédier aux limites du modèle Segment Anything (SAM), un modèle Transformer volumineux qui nécessite d’importantes ressources de calcul. FastSAM divise la tâche Segment Anything en deux étapes successives : la segmentation de toutes les instances et la sélection guidée par prompt. La première étape utilise YOLOv8-seg pour produire les masques de segmentation de toutes les instances de l’image. Lors de la deuxième étape, il renvoie la région d’intérêt correspondant au prompt.

Fonctionnalités clés#

1. Solution en temps réel : en tirant parti de l’efficacité de calcul des CNN, FastSAM fournit une solution en temps réel pour la tâche Segment Anything. Il est ainsi utile dans les applications industrielles qui nécessitent des résultats rapides.

2. Efficacité et performances : FastSAM réduit considérablement les besoins en calcul et en ressources sans compromettre la qualité des performances. Il atteint des performances comparables à celles de SAM tout en nécessitant beaucoup moins de ressources de calcul, ce qui permet une utilisation en temps réel.

3. Segmentation guidée par prompt : FastSAM peut segmenter n’importe quel objet d’une image à partir de différents prompts d’interaction possibles, ce qui lui apporte flexibilité et adaptabilité selon les scénarios.

4. Basé sur YOLOv8-seg : FastSAM repose sur YOLOv8-seg, un détecteur d’objets doté d’une branche de segmentation d’instances. Il peut ainsi produire efficacement les masques de segmentation de toutes les instances d’une image.

5. Résultats compétitifs sur les benchmarks : pour la tâche de proposition d’objets sur MS COCO, FastSAM obtient des scores élevés à une vitesse nettement supérieure à celle de SAM sur un seul NVIDIA RTX 3090, ce qui démontre son efficacité et ses capacités.

6. Applications pratiques : l’approche proposée offre une nouvelle solution pratique pour de nombreuses tâches de vision, à une vitesse très élevée, de dix à cent fois supérieure à celle des méthodes actuelles.

7. Viabilité de la compression des modèles : FastSAM démontre qu’une approche consistant à introduire un a priori artificiel dans la structure peut réduire considérablement les efforts de calcul, ouvrant ainsi de nouvelles possibilités pour les architectures de grands modèles dédiés aux tâches générales de vision.

Modèles disponibles, tâches prises en charge et modes de fonctionnement#

Ce tableau présente les modèles disponibles et leurs poids préentraînés, les tâches qu’ils prennent en charge ainsi que leur compatibilité avec différents modes de fonctionnement, tels que l’inférence, la validation, l’entraînement et l’exportation. Les modes pris en charge sont indiqués par l’émoji ✅ et les modes non pris en charge par l’émoji ❌.

Comparaison de FastSAM avec YOLO#

Nous comparons ici FastSAM-s aux variantes SAM de Meta et aux modèles de segmentation Ultralytics, notamment YOLO26n-seg :

Cette comparaison met en évidence les différences considérables de taille et de vitesse entre les variantes de SAM et les modèles de segmentation YOLO. SAM offre des capacités uniques de segmentation automatique, mais les modèles YOLO, en particulier YOLOv8n-seg, YOLO11n-seg et YOLO26n-seg, sont nettement plus petits, plus rapides et plus efficaces sur le plan des calculs.

Les vitesses de SAM ont été mesurées avec PyTorch, et celles de YOLO avec ONNX Runtime. Les tests ont été réalisés sur un Apple M4 Air de 2025 doté de 16 Go de RAM, avec torch==2.10.0, ultralytics==8.4.31 et onnxruntime==1.24.4. Pour reproduire ce test :

from ultralytics import ASSETS, SAM, YOLO, FastSAM

# Profiler 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)

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

# Profiler les modèles 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)  # Tête sans NMS de YOLO26 ; sans effet pour YOLOv8/YOLO11
    model = YOLO(onnx_path)
    model(ASSETS)

Exemples d'utilisation#

Les modèles FastSAM s’intègrent facilement à tes applications Python. Ultralytics propose une API Python et des commandes CLI conviviales pour simplifier le développement.

Utilisation pour la prédiction#

Pour segmenter une image, utilise la méthode predict comme indiqué ci-dessous :

from ultralytics import FastSAM

# Définir une source d’inférence
source = "path/to/bus.jpg"

# Créer un modèle FastSAM
model = FastSAM("FastSAM-s.pt")  # ou FastSAM-x.pt

# Effectuer une inférence sur une image
everything_results = model(source, device="cpu", retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)

# Exécuter l’inférence avec des bboxes comme invite
results = model(source, bboxes=[439, 437, 524, 709])

# Lancer l’inférence avec des prompts de points
results = model(source, points=[[200, 200]], labels=[1])

# Lancer l’inférence avec des prompts textuels
results = model(source, texts="a photo of a dog")

# Lancer simultanément l’inférence avec des bboxes, des points et des prompts textuels
results = model(source, bboxes=[439, 437, 524, 709], points=[[200, 200]], labels=[1], texts="a photo of a dog")

Cet extrait montre à quel point il est simple de charger un modèle préentraîné et de lancer une prédiction sur une image.

from ultralytics.models.fastsam import FastSAMPredictor

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

# Tout segmenter
everything_results = predictor("ultralytics/assets/bus.jpg")

# Inférence avec prompt
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")

Utilisation pour la validation#

Note que FastSAM prend uniquement en charge la détection et la segmentation d’une seule classe d’objets. Il reconnaîtra et segmentera donc tous les objets comme appartenant à la même classe. Lors de la préparation du jeu de données, tu dois donc convertir tous les ID de catégorie d’objet en 0.

La validation du modèle sur un jeu de données peut se faire comme suit :

from ultralytics import FastSAM

# Créer un modèle FastSAM
model = FastSAM("FastSAM-s.pt")  # ou FastSAM-x.pt

# Valider le modèle
results = model.val(data="coco8-seg.yaml")

Suivi d’utilisation#

Pour effectuer le suivi d’objets dans une image, utilise la méthode track comme indiqué ci-dessous :

from ultralytics import FastSAM

# Créer un modèle FastSAM
model = FastSAM("FastSAM-s.pt")  # ou FastSAM-x.pt

# Suivre avec un modèle FastSAM dans une vidéo
results = model.track(source="path/to/video.mp4", imgsz=640)

Utilisation officielle de FastSAM#

FastSAM est également disponible directement dans le dépôt CASIA-LMC-Lab/FastSAM. Voici un bref aperçu des étapes habituelles pour utiliser FastSAM :

Installation#

1. Clone le dépôt FastSAM :

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

2. Crée et active un environnement Conda avec Python 3.9 :

   conda create -n FastSAM python=3.9
   conda activate FastSAM

3. Accède au dépôt cloné et installe les paquets requis :

   cd FastSAM
   pip install -r requirements.txt

4. Installe le modèle CLIP :

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

Exemple d’utilisation#

1. Télécharge un checkpoint du modèle.

2. Utilise FastSAM pour l’inférence. Exemples de commandes :

   • Segmente tous les éléments d’une image :

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

   • Segmente des objets spécifiques à l’aide d’une invite textuelle :

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

   • Segmente les objets à l’intérieur d’une boîte englobante (fournis les coordonnées de la boîte au format xywh) :

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

   • Segmente les objets à proximité de points spécifiques :

     python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --point_prompt "[[520,360],[620,300]]" --point_label "[1,0]"

Tu peux également essayer FastSAM grâce à la démo Colab de CASIA-LMC-Lab.

Citations et remerciements#

Nous souhaitons remercier les auteurs de FastSAM pour leurs contributions importantes au domaine de la segmentation d’instances en temps réel :

@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}
}

L’article original sur FastSAM est disponible sur arXiv. Les auteurs ont rendu leurs travaux publics, et le code source est accessible sur GitHub. Nous saluons leurs efforts pour faire progresser le domaine et rendre leurs travaux accessibles à une communauté plus large.

FAQ#