Modèle Segment Anything rapide (FastSAM)#

Le Modèle Segment Anything rapide (FastSAM) est une nouvelle solution en temps réel basée sur un CNN pour la tâche Segment Anything. Cette tâche est conçue pour segmenter n'importe quel objet dans une image à partir de diverses invites d'interaction utilisateur 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 est conçu pour remédier aux limitations du Modèle Segment Anything (SAM), un modèle [Transformer](https://ultralytics-translation-1.invalid lourd nécessitant d'importantes ressources de calcul. FastSAM découple la tâche Segment Anything en deux étapes séquentielles : la segmentation d'instances de toutes les instances, puis la sélection guidée par une invite. La première étape utilise YOLOv8-seg pour produire les masques de segmentation de toutes les instances présentes dans l'image. Lors de la seconde étape, il génère la région d'intérêt correspondant à l'invite.

Fonctionnalités clés#

1. Solution en temps réel : En exploitant l'efficacité de calcul des CNN, FastSAM fournit une solution en temps réel pour la tâche Segment Anything, ce qui la rend utile pour les applications industrielles nécessitant 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, mais avec des ressources de calcul fortement réduites, ce qui permet une utilisation en temps réel.

3. Segmentation guidée par une invite : FastSAM peut segmenter n'importe quel objet dans une image à l'aide de diverses invites d'interaction utilisateur, offrant flexibilité et adaptabilité dans différents scénarios.

4. Basé sur YOLOv8-seg : FastSAM est basé sur YOLOv8-seg, un détecteur d'objets doté d'une branche de segmentation d'instances. Cela lui permet de produire efficacement les masques de segmentation de toutes les instances présentes dans 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, démontrant ainsi son efficacité et ses capacités.

6. Applications pratiques : L'approche proposée offre une nouvelle solution pratique pour un grand nombre de tâches de vision, à une vitesse très élevée, des dizaines ou des centaines de fois supérieure à celle des méthodes actuelles.

7. Faisabilité de la compression du modèle : FastSAM démontre la faisabilité d'une approche permettant de réduire considérablement l'effort de calcul en introduisant un a priori artificiel dans la structure, ouvrant ainsi de nouvelles possibilités pour les architectures de grands modèles destinées 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 avec leurs poids préentraînés spécifiques, les tâches qu’ils prennent en charge et leur compatibilité avec différents modes de fonctionnement tels que l’inférence, la validation, l’entraînement et l’exportation, indiquée par des emojis ✅ pour les modes pris en charge et des emojis ❌ pour ceux qui ne le sont pas.

Comparaison de FastSAM avec YOLO#

Voici une comparaison de FastSAM-s avec les variantes SAM de Meta et les modèles de segmentation d'Ultralytics, incluant 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. Bien que SAM offre des capacités uniques de segmentation automatique, les modèles YOLO, notamment 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 sont mesurées avec PyTorch, celles de YOLO avec ONNX Runtime. Les tests ont été effectués sur un Apple M4 Air de 2025 doté de 16 Go de RAM, à l'aide de torch==2.10.0, ultralytics==8.4.31 et onnxruntime==1.24.4. Pour reproduire ce test :

from ultralytics import ASSETS, SAM, YOLO, FastSAM

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

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

# Profile YOLO models (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)  # YOLO26 NMS-free head; no-op for YOLOv8/YOLO11
    model = YOLO(onnx_path)
    model(ASSETS)

Exemples d’utilisation#

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

Utilisation de Predict#

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

from ultralytics import FastSAM

# Define an inference source
source = "path/to/bus.jpg"

# Create a FastSAM model
model = FastSAM("FastSAM-s.pt")  # or FastSAM-x.pt

# Run inference on an image
everything_results = model(source, device="cpu", retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)

# Run inference with bboxes prompt
results = model(source, bboxes=[439, 437, 524, 709])

# Run inference with points prompt
results = model(source, points=[[200, 200]], labels=[1])

# Run inference with texts prompt
results = model(source, texts="a photo of a dog")

# Run inference with bboxes and points and texts prompt at the same time
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 d'effectuer une prédiction sur une image.

from ultralytics.models.fastsam import FastSAMPredictor

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

# Segment everything
everything_results = predictor("ultralytics/assets/bus.jpg")

# Prompt inference
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 de Val#

Note que FastSAM ne prend en charge que la détection et la segmentation d'une seule classe d'objets. Cela signifie qu'il reconnaît et segmente tous les objets comme appartenant à la même classe. Par conséquent, lors de la préparation du jeu de données, tu dois convertir tous les identifiants de catégorie d'objet en 0.

La validation du modèle sur un jeu de données peut être effectuée comme suit :

from ultralytics import FastSAM

# Create a FastSAM model
model = FastSAM("FastSAM-s.pt")  # or FastSAM-x.pt

# Validate the model
results = model.val(data="coco8-seg.yaml")

Utilisation de Track#

Pour effectuer le suivi d'objets sur une image, utilise la méthode track comme illustré ci-dessous :

from ultralytics import FastSAM

# Create a FastSAM model
model = FastSAM("FastSAM-s.pt")  # or FastSAM-x.pt

# Track with a FastSAM model on a video
results = model.track(source="path/to/video.mp4", imgsz=640)

Utilisation officielle de FastSAM#

FastSAM est également disponible directement depuis le dépôt CASIA-LMC-Lab/FastSAM. Voici un bref aperçu des étapes typiques que tu pourrais suivre 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 de modèle.

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

   • Segmente tout dans 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 des objets dans 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 des objets proches 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]"

De plus, tu peux essayer FastSAM via la démo Colab de CASIA-LMC-Lab.

Citations et remerciements#

Nous souhaitons remercier les auteurs de FastSAM pour leurs contributions importantes dans le 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 mis leur travail à la disposition du public, et le code source est accessible sur GitHub. Nous saluons leurs efforts pour faire progresser ce domaine et rendre leur travail accessible à une communauté plus large.

FAQ#