Fast Segment Anything Model (FastSAM)#

Le Fast Segment Anything Model (FastSAM) est une solution novatrice basée sur un CNN, conçue pour le temps réel et dédiée à la tâche de segmentation. Cette tâche vise à segmenter n'importe quel objet au sein d'une image en fonction de diverses interactions possibles de l'utilisateur. FastSAM réduit considérablement les besoins en calcul tout en maintenant des performances compétitives, ce qui en fait un choix pratique pour une variété de tâches de vision.

Architecture du modèle#

Présentation#

FastSAM est conçu pour répondre aux limites du Segment Anything Model (SAM), un modèle Transformer lourd nécessitant des ressources de calcul substantielles. FastSAM découpe la tâche de segmentation en deux étapes séquentielles : la segmentation d'instances globale et la sélection guidée par invite. La première étape utilise YOLOv8-seg pour produire les masques de segmentation de toutes les instances de l'image. Dans la seconde étape, il génère la région d'intérêt correspondant à l'invite.

Fonctionnalités clés#

1. Solution temps réel : En tirant parti de l'efficacité computationnelle des CNN, FastSAM fournit une solution en temps réel pour la tâche de segmentation, ce qui le rend précieux pour les applications industrielles nécessitant des résultats rapides.

2. Efficacité et performances : FastSAM offre une réduction significative des 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 considérablement réduites, permettant une application en temps réel.

3. Segmentation guidée par invite : FastSAM peut segmenter n'importe quel objet dans une image en étant guidé par diverses interactions possibles de l'utilisateur, offrant ainsi 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 d'une image.

5. Résultats compétitifs sur les benchmarks : Sur la tâche de proposition d'objets sur MS COCO, FastSAM atteint des scores élevés à une vitesse nettement supérieure à celle de SAM sur une seule NVIDIA RTX 3090, démontrant ainsi son efficacité et ses capacités.

6. Applications pratiques : L'approche proposée fournit une solution nouvelle et pratique pour un grand nombre de tâches de vision à une vitesse très élevée, des dizaines ou des centaines de fois plus rapide que les méthodes actuelles.

7. Faisabilité de la compression du modèle : FastSAM démontre la faisabilité d'une voie 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 dédiées aux tâches de vision générale.

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'Inference, la Validation, l'Training et l'Export, indiqués par des emojis ✅ pour les modes pris en charge et des emojis ❌ pour les modes non pris en charge.

Comparaison FastSAM vs YOLO#

Nous comparons ici les modèles SAM 2 de Meta, y compris la plus petite variante SAM2-t, avec les modèles de segmentation Ultralytics, dont YOLO26n-seg :

Cette comparaison démontre les différences substantielles de tailles et de vitesses de modèle entre les variantes de SAM et les modèles de segmentation YOLO. Bien que SAM offre des capacités de segmentation automatique uniques, 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 informatique.

Vitesses SAM mesurées avec PyTorch, vitesses YOLO mesurées avec ONNX Runtime. Tests exécutés sur un Apple M4 Air de 2025 avec 16 Go de RAM en utilisant 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)
    model = YOLO(onnx_path)
    model(ASSETS)

Exemples d'utilisation#

Les modèles FastSAM sont faciles à intégrer dans tes applications Python. Ultralytics fournit une API Python conviviale et des commandes CLI pour simplifier le développement.

Utilisation pour la prédiction#

Pour effectuer une object detection sur 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")

Ce snippet démontre la simplicité de charger un modèle pré-entraîné et d'exécuter 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 pour la validation#

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

La validation du modèle sur un dataset 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 pour le suivi#

Pour effectuer le suivi d'objets sur une image, utilise la méthode track comme indiqué 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 https://github.com/CASIA-IVA-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-IVA-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. Navigue vers le dépôt cloné et installe les packages 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 model checkpoint.

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 en utilisant 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 bounding box (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 près 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 Colab demo de CASIA-IVA-Lab.

Citations et remerciements#

Nous souhaitons remercier les auteurs de FastSAM pour leurs contributions significatives 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}
  }

Le document original sur FastSAM est disponible sur arXiv. Les auteurs ont rendu leur travail public et le code source est accessible sur GitHub. Nous apprécions leurs efforts pour faire progresser le domaine et rendre leur travail accessible à la communauté au sens large.

FAQ#

Qu'est-ce que FastSAM et en quoi diffère-t-il de SAM ?#

FastSAM, abréviation de Fast Segment Anything Model, est une solution en temps réel basée sur un convolutional neural network (CNN) conçue pour réduire les exigences de calcul tout en maintenant de hautes performances dans les tâches de segmentation d'objets. Contrairement au Segment Anything Model (SAM), qui utilise une architecture plus lourde basée sur un Transformer, FastSAM exploite Ultralytics YOLOv8-seg pour une segmentation d'instances efficace en deux étapes : la segmentation de toutes les instances suivie d'une sélection guidée par invite.

Comment FastSAM atteint-il des performances de segmentation en temps réel ?#

FastSAM atteint la segmentation en temps réel en découplant la tâche de segmentation en une étape de segmentation de toutes les instances avec YOLOv8-seg et une étape de sélection guidée par invite. En utilisant l'efficacité computationnelle des CNN, FastSAM offre des réductions significatives des besoins en calcul et en ressources tout en maintenant des performances compétitives. Cette approche en deux étapes permet à FastSAM de fournir une segmentation rapide et efficace, adaptée aux applications nécessitant des résultats rapides.

Quelles sont les applications pratiques de FastSAM ?#

FastSAM est pratique pour diverses tâches de computer vision nécessitant des performances de segmentation en temps réel. Les applications incluent :

• Automatisation industrielle pour le contrôle et l'assurance qualité
• Analyse vidéo en temps réel pour la sécurité et la surveillance
• Les Autonomous vehicles pour la détection et la segmentation d'objets
• Imagerie médicale pour des tâches de segmentation précises et rapides

Sa capacité à gérer diverses invites d'interaction utilisateur rend FastSAM adaptable et flexible pour des scénarios variés.

Comment utiliser le modèle FastSAM pour l'inférence en Python ?#

Pour utiliser FastSAM pour l'inférence en Python, tu peux suivre l'exemple 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")

Pour plus de détails sur les méthodes d'inférence, consulte la section Predict Usage de la documentation.

Quels types d'invites FastSAM prend-il en charge pour les tâches de segmentation ?#

FastSAM prend en charge plusieurs types d'invites pour guider les tâches de segmentation :

• Invite Tout (Everything Prompt) : Génère une segmentation pour tous les objets visibles.
• Invite Bounding Box (BBox) : Segmente les objets à l'intérieur d'une boîte englobante spécifiée.
• Invite Texte (Text Prompt) : Utilise un texte descriptif pour segmenter les objets correspondant à la description.
• Invite Point (Point Prompt) : Segmente les objets à proximité de points spécifiques définis par l'utilisateur.

Cette flexibilité permet à FastSAM de s'adapter à un large éventail de scénarios d'interaction utilisateur, renforçant son utilité dans différentes applications. Pour plus d'informations sur l'utilisation de ces invites, réfère-toi à la section Key Features.