Modèle de segmentation rapide (FastSAM)

Le Fast Segment Anything Model (FastSAM) est une solution innovante basée sur les CNN, conçue pour la tâche de segmentation en temps réel Segment Anything. Cette tâche est prévue pour segmenter n'importe quel objet dans une image à partir de divers prompts d'interaction 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 surmonter les limites du Segment Anything Model (SAM), un modèle Transformer lourd avec des besoins importants en ressources de calcul. FastSAM dissocie la tâche de segmentation en deux étapes séquentielles : la segmentation d'instances complète 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 dans l'image. Dans la deuxième étape, il génère 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é computationnelle des CNN, FastSAM offre 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 prompt : FastSAM peut segmenter n'importe quel objet dans une image guidé par divers prompts d'interaction utilisateur possibles, 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 équipé d'une branche de segmentation d'instance. 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 offre une solution nouvelle et pratique pour un grand nombre de tâches de vision à très haute vitesse, des dizaines ou des centaines de fois plus rapide que les méthodes actuelles.

7. Faisabilité de la compression de modèle : FastSAM démontre la faisabilité d'une voie pouvant réduire considérablement l'effort de calcul en introduisant un a priori artificiel dans la structure, ouvrant ainsi de nouvelles possibilités pour l'architecture des grands modèles pour des 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 Inférence, Validation, Entraînement, et Exportation, indiqués par des émojis ✅ pour les modes pris en charge et ❌ pour les modes non pris en charge.

Comparaison FastSAM vs YOLO

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

Cette comparaison démontre les différences substantielles de tailles et de vitesses de modèles 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 significativement plus petits, plus rapides et plus efficaces sur le plan computationnel.

Vitesses SAM mesurées avec PyTorch, vitesses 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)

Exemples d'utilisation

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

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

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

Utilisation de la validation

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

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îtra et segmentera tous les objets comme étant de 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'objets à 0.

Utilisation du suivi

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 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 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 point de contrôle 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 en utilisant un prompt texte :

     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 démo Colab du CASIA-IVA-Lab.

Citations et remerciements

Nous tenons à 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 est disponible sur arXiv. Les auteurs ont rendu leur travail publiquement disponible, et la base de code 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 les réseaux de neurones convolutifs (CNN) conçue pour réduire les besoins en 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 Transformer, FastSAM tire parti de Ultralytics YOLOv8-seg pour une segmentation d'instance efficace en deux étapes : la segmentation de toutes les instances suivie d'une sélection guidée par prompt.

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

FastSAM atteint une segmentation en temps réel en dissociant la tâche de segmentation en une segmentation de toutes les instances avec YOLOv8-seg et des étapes de sélection guidée par prompt. 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 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 divers prompts d'interaction utilisateur rend FastSAM adaptable et flexible pour différents scénarios.

Comment puis-je 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 de la prédiction de la documentation.

Quels types de prompts FastSAM prend-il en charge pour les tâches de segmentation ?

FastSAM prend en charge plusieurs types de prompts pour guider les tâches de segmentation :

• Prompt Tout (Everything) : Génère une segmentation pour tous les objets visibles.
• Prompt Bounding Box (BBox) : Segmente les objets à l'intérieur d'une bounding box spécifiée.
• Prompt Texte : Utilise un texte descriptif pour segmenter les objets correspondant à la description.
• Prompt Point : Segmente les objets près 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, améliorant son utilité à travers différentes applications. Pour plus d'informations sur l'utilisation de ces prompts, réfère-toi à la section Fonctionnalités clés.