Fast Segment Anything Model (FastSAM)

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

Regarder : Suivi d'objets à l'aide de FastSAM avec Ultralytics

Architecture du modèle

Aperçu

FastSAM est conçu pour répondre aux limitations du Segment Anything Model (SAM), un modèle Transformer lourd avec des besoins importants en ressources de calcul. FastSAM découple la tâche de segmentation de tout en deux étapes séquentielles : la segmentation de toutes les instances et la sélection guidée par des invites. 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.

Principales caractéristiques

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 de segmentation de tout, ce qui la rend précieuse pour les applications industrielles qui nécessitent des résultats rapides.

2. Efficacité et performance : FastSAM offre une réduction significative des demandes de calcul et de ressources sans compromettre la qualité des performances. Il atteint des performances comparables à SAM mais avec des ressources de calcul considérablement réduites, ce qui permet une application en temps réel.

3. Segmentation guidée par invite : FastSAM peut segmenter n’importe quel objet dans une image, guidé par diverses invites 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 bancs d’essai : Sur la tâche de proposition d’objet sur MS COCO, FastSAM obtient des scores élevés à une vitesse nettement plus rapide que SAM sur un seul NVIDIA RTX 3090, ce qui démontre son efficacité et sa capacité.

6. Applications pratiques : L'approche proposée fournit 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 plus rapide que les méthodes actuelles.

7. Faisabilité de la compression des modèles : FastSAM démontre la faisabilité d’une approche qui peut réduire considérablement l’effort de calcul en introduisant une priorité artificielle à la structure, ouvrant ainsi de nouvelles possibilités pour l’architecture des modèles volumineux pour les tâches de vision générales.

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és par des emojis ✅ pour les modes pris en charge et des emojis ❌ 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 le plus petit modèle de segmentation d'Ultralytics, YOLO11n-seg :

Cette comparaison démontre les différences substantielles de taille et de vitesse des modèles entre les variantes 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 et YOLO11n-seg, sont considérablement plus petits, plus rapides et plus efficaces sur le plan computationnel.

Tests effectués sur un Apple M4 Pro 2025 avec 24 Go de RAM en utilisant torch==2.6.0 et ultralytics==8.3.90. 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
for file_name in ["yolov8n-seg.pt", "yolo11n-seg.pt"]:
    model = YOLO(file_name)
    model.info()
    model(ASSETS)

Exemples d'utilisation

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

Utilisation de la prédiction

Pour effectuer détection d'objets sur une image, utilisez le predict méthode 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")

# Load a FastSAM model and segment everything with it
yolo segment predict model=FastSAM-s.pt source=path/to/bus.jpg imgsz=640

Cet extrait illustre la simplicité du chargement d'un modèle pré-entraîné et de l'exécution d'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 Val

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

# Load a FastSAM model and validate it on the COCO8 example dataset at image size 640
yolo segment val model=FastSAM-s.pt data=coco8.yaml imgsz=640

Veuillez noter que FastSAM prend uniquement en charge la détection et la segmentation d'une seule classe d'objet. 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 de l'ensemble de données, vous devez convertir tous les ID de catégorie d'objet en 0.

Suivi de l'utilisation

Pour effectuer un suivi d'objet sur une image, utilisez le track méthode 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)

yolo segment track model=FastSAM-s.pt 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 vous pourriez suivre pour utiliser FastSAM :

Installation

1. Clonez le référentiel FastSAM :

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

2. Créer et activer un environnement Conda avec Python 3.9 :

   conda create -n FastSAM python=3.9
   conda activate FastSAM
   

3. Accédez au référentiel cloné et installez les packages requis :

   cd FastSAM
   pip install -r requirements.txt
   

4. Installer le modèle CLIP :

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

Exemple d'utilisation

1. Télécharger un point de contrôle du modèle.

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

   • Segmenter tout dans une image :

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

   • Segmenter 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"
     

   • Segmenter les objets dans une boîte englobante (fournir 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]"
     

   • Segmenter les 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, vous pouvez essayer FastSAM via la démo Colab de CASIA-IVA-Lab.

Citations et remerciements

Nous tenons à remercier les auteurs de FastSAM pour leurs contributions significatives dans le domaine de la segmentation d'instance 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 de FastSAM est disponible sur arXiv. Les auteurs ont rendu leur travail public, et le 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 un réseau neuronal convolutif (CNN) conçue pour réduire les demandes 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 Transformer, FastSAM exploite 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 des invites.

Comment FastSAM atteint-il une performance de segmentation en temps réel ?

FastSAM réalise une segmentation en temps réel en découplant la tâche de segmentation en une segmentation de toutes les instances avec YOLOv8-seg et des étapes de sélection guidées par des invites. En utilisant l'efficacité de calcul des CNN, FastSAM offre des réductions significatives des demandes de calcul et de 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 qui nécessitent des performances de segmentation en temps réel. Les applications incluent :

• Automatisation industrielle pour le contrôle qualité et l'assurance
• 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 divers scénarios.

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

Pour utiliser FastSAM pour l'inférence en Python, vous pouvez 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, consultez la section Utilisation de la prédiction 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 :

• Everything Prompt : Génère une segmentation pour tous les objets visibles.
• Invite de boîte englobante (BBox) : Segmente les objets dans une boîte englobante spécifiée.
• Invite de texte : Utilise un texte descriptif pour segmenter les objets correspondant à la description.
• Invite ponctuelle : Segmente les objets proches 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 ainsi son utilité dans différentes applications. Pour plus d'informations sur l'utilisation de ces invites, consultez la section Key Features.

📅 Créé il y a 1 an ✏️ Mis à jour il y a 2 mois

Commentaires