Link to this sectionFast 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.

Link to this sectionArchitecture du modèle#

Link to this sectionPrésentation#

FastSAM est conçu pour surmonter les limitations du Segment Anything Model (SAM), un modèle Transformer lourd aux besoins en ressources de calcul considérables. FastSAM découple la tâche de segmentation en deux étapes séquentielles : la segmentation d'instances complète 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 dans l'image. Dans la deuxième étape, il génère la région d'intérêt correspondant à l'invite.

Link to this sectionFonctionnalité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 équipé d'une branche de segmentation d'instances. Cela lui permet de produire efficacement les masques de segmentation de toutes les instances dans une image.

5. Résultats compétitifs sur les benchmarks : Sur 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 une seule NVIDIA RTX 3090, démontrant 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.

Link to this sectionModè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és par des émojis ✅ pour les modes pris en charge et des émojis ❌ pour les modes non pris en charge.

Link to this sectionComparaison 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, y compris 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 de SAM mesurées avec PyTorch, vitesses de YOLO mesurées avec ONNX Runtime. Tests effectués sur un Apple M4 Air 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)

Link to this sectionExemples 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.

Link to this sectionUtilisation pour la prédiction#

Pour effectuer une détection d'objets sur une image, utilise la méthode predict comme illustré 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 = dict(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")

Link to this sectionUtilisation pour la validation#

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

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.

Link to this sectionUtilisation pour le suivi#

Pour effectuer un 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)

Link to this sectionUtilisation 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 :

Link to this sectionInstallation#

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

Link to this sectionExemple d'utilisation#

1. Télécharge un checkpoint du 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 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 à l'intérieur d'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 démo Colab de CASIA-IVA-Lab.

Link to this sectionCitations 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}
  }

L'article original sur FastSAM peut être trouvé sur arXiv. Les auteurs ont rendu leur travail publiquement accessible, et la base de code peut être consultée sur GitHub. Nous apprécions leurs efforts pour faire avancer le domaine et rendre leurs travaux accessibles à une communauté plus large.

Link to this sectionFAQ#

Link to this sectionQu'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 réseau de neurones convolutifs (CNN) conçue pour réduire les exigences de calcul tout en maintenant des performances élevées 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.

Link to this sectionComment 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.

Link to this sectionQuelles sont les applications pratiques de FastSAM ?#

FastSAM est pratique pour une variété de tâches de vision par ordinateur 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
• Véhicules autonomes 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.

Link to this sectionComment 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 Utilisation pour la prédiction de la documentation.

Link to this sectionQuels 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é à travers différentes applications. Pour plus d'informations sur l'utilisation de ces invites, reporte-toi à la section Fonctionnalités clés.