Modello Fast Segment Anything (FastSAM)
Fast Segment Anything Model (FastSAM) è una soluzione in tempo reale basata su CNN per l'attività Segment Anything. Questa attività è progettata per segmentare qualsiasi oggetto in un'immagine sulla base di diversi possibili prompt di interazione dell'utente. FastSAM riduce notevolmente i requisiti di calcolo mantenendo prestazioni competitive, rendendolo una scelta pratica per diverse attività di visione artificiale.
Guarda: Tracking degli oggetti con FastSAM e Ultralytics
Architettura del modello#

Panoramica#
FastSAM è progettato per superare i limiti di Segment Anything Model (SAM), un modello Transformer pesante che richiede notevoli risorse di calcolo. FastSAM suddivide l'attività Segment Anything in due fasi sequenziali: segmentazione di tutte le istanze e selezione guidata da prompt. La prima fase usa YOLOv8-seg per produrre le maschere di segmentazione di tutte le istanze nell'immagine. Nella seconda fase, restituisce la regione di interesse corrispondente al prompt.
Funzionalità principali#
-
Soluzione in tempo reale: sfruttando l'efficienza computazionale delle CNN, FastSAM offre una soluzione in tempo reale per l'attività Segment Anything, risultando utile nelle applicazioni industriali che richiedono risultati rapidi.
-
Efficienza e prestazioni: FastSAM riduce notevolmente i requisiti di calcolo e di risorse, ottenendo prestazioni paragonabili a SAM e consentendo applicazioni in tempo reale.
-
Segmentazione guidata da prompt: FastSAM può segmentare qualsiasi oggetto in un'immagine sulla base di diversi prompt di interazione dell'utente, offrendo flessibilità e adattabilità in scenari diversi.
-
Basato su YOLOv8-seg: FastSAM si basa su YOLOv8-seg, un rilevatore di oggetti dotato di un ramo per la segmentazione di istanze. Questo gli consente di produrre efficacemente le maschere di segmentazione di tutte le istanze presenti in un'immagine.
-
Risultati competitivi nei benchmark: nell'attività di generazione di proposte di oggetti su MS COCO, FastSAM ottiene punteggi elevati a una velocità notevolmente superiore a quella di SAM su una singola NVIDIA RTX 3090, dimostrando la propria efficienza e capacità.
-
Applicazioni pratiche: questo approccio offre una soluzione pratica per numerose attività di visione artificiale ed è da decine a centinaia di volte più veloce dei precedenti metodi Segment Anything.
-
Fattibilità della compressione del modello: FastSAM dimostra la fattibilità di un approccio in grado di ridurre significativamente il carico computazionale introducendo un prior artificiale nella struttura e aprendo così nuove possibilità per le architetture di modelli di grandi dimensioni dedicate alle attività generali di visione artificiale.
Modelli disponibili, attività supportate e modalità operative#
Questa tabella presenta i modelli disponibili, i relativi pesi preaddestrati, le attività supportate e la compatibilità con diverse modalità operative, come Addestramento, Validazione, Inferenza ed Esportazione. Le modalità supportate sono indicate con ✅ e quelle non supportate con ❌.
| Tipo di modello | Pesi preaddestrati | Attività supportate | Addestramento | Validazione | Inferenza | Esporta |
|---|---|---|---|---|---|---|
| FastSAM-s | FastSAM-s.pt | Segmentazione di istanze | ❌ | ✅ | ✅ | ✅ |
| FastSAM-x | FastSAM-x.pt | Segmentazione di istanze | ❌ | ✅ | ✅ | ✅ |
Confronto tra FastSAM e YOLO#
Qui confrontiamo FastSAM-s con le varianti SAM di Meta e i modelli di segmentazione Ultralytics, incluso YOLO26:
| Modello | Dimensione (MB) | Parametri (M) | Velocità (CPU) (ms/im) |
|---|---|---|---|
| Meta SAM-b | 375 | 93.7 | 41703 |
| Meta SAM2-b | 162 | 80.8 | 28867 |
| Meta SAM2-t | 78.1 | 38.9 | 23430 |
| MobileSAM | 40.7 | 10.1 | 23802 |
| FastSAM-s con backbone YOLOv8 | 23.9 | 11.8 | 58.0 |
| Ultralytics YOLOv8n-seg | 7.1 (11.0x più piccolo) | 3.4 (11.4x in meno) | 24.8 (945x più veloce) |
| Ultralytics YOLO11n-seg | 6.2 (12.6x più piccolo) | 2.9 (13.4x in meno) | 24.3 (964x più veloce) |
| Ultralytics YOLO26n-seg | 6.7 (11.7x più piccolo) | 2.7 (14.4x in meno) | 25.2 (930x più veloce) |
Questo confronto evidenzia le notevoli differenze nelle dimensioni e nella velocità dei modelli tra le varianti SAM e i modelli di segmentazione YOLO. Sebbene SAM offra capacità uniche di segmentazione automatica, i modelli YOLO, in particolare YOLOv8n-seg, YOLO11n-seg e YOLO26n-seg, sono significativamente più piccoli, più veloci e più efficienti dal punto di vista computazionale.
Le velocità di SAM sono state misurate con PyTorch, quelle di YOLO con ONNX Runtime. I test sono stati eseguiti su un Apple M4 Air del 2025 con 16 GB di RAM usando torch==2.10.0, ultralytics==8.4.31 e onnxruntime==1.24.4. Per riprodurre questo test:
from ultralytics import ASSETS, SAM, YOLO, FastSAM
# Profila 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)
# Profilo FastSAM-s
model = FastSAM("FastSAM-s.pt")
model.info()
model(ASSETS)
# Profila i modelli YOLO (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) # Head senza NMS di YOLO26; non fa nulla per YOLOv8/YOLO11
model = YOLO(onnx_path)
model(ASSETS)Esempi d'uso#
I modelli FastSAM sono facili da integrare nelle tue applicazioni Python. Ultralytics fornisce sia un'API Python sia comandi CLI.
Uso di predict#
Per segmentare un'immagine, usa il metodo predict come mostrato di seguito:
from ultralytics import FastSAM
# Definisci una sorgente di inferenza
source = "path/to/bus.jpg"
# Crea un modello FastSAM
model = FastSAM("FastSAM-s.pt") # oppure FastSAM-x.pt
# Esegui l'inferenza su un'immagine
everything_results = model(source, device="cpu", retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
# Esegui l'inferenza con il prompt dei riquadri di delimitazione
results = model(source, bboxes=[439, 437, 524, 709])
# Esegui l'inferenza con un prompt basato su punti
results = model(source, points=[[200, 200]], labels=[1])
# Esegui l'inferenza con prompt testuali
results = model(source, texts="a photo of a dog")
# Esegui contemporaneamente l'inferenza con bbox, punti e prompt testuali
results = model(source, bboxes=[439, 437, 524, 709], points=[[200, 200]], labels=[1], texts="a photo of a dog")Questo frammento di codice mostra quanto sia semplice caricare un modello preaddestrato ed eseguire una previsione su un'immagine.
Esegui una volta l'inferenza su un'immagine per ottenere tutti i segmenti results, quindi applica più volte i prompt ai risultati senza ripetere l'inferenza.
from ultralytics.models.fastsam import FastSAMPredictor
# Crea FastSAMPredictor
overrides = {"conf": 0.25, "task": "segment", "mode": "predict", "model": "FastSAM-s.pt", "save": False, "imgsz": 1024}
predictor = FastSAMPredictor(overrides=overrides)
# Segmenta tutto
everything_results = predictor("ultralytics/assets/bus.jpg")
# Inferenza con prompt
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")Tutti gli oggetti results restituiti negli esempi precedenti sono oggetti Results che consentono di accedere alle maschere previste e all'immagine sorgente.
Uso di val#
FastSAM supporta solo il rilevamento e la segmentazione di una singola classe di oggetti, quindi riconosce e segmenta tutti gli oggetti come appartenenti alla stessa classe. Quando prepari il dataset, converti tutti gli ID delle categorie di oggetti in 0.
La convalida del modello su un dataset può essere eseguita come segue:
from ultralytics import FastSAM
# Crea un modello FastSAM
model = FastSAM("FastSAM-s.pt") # oppure FastSAM-x.pt
# Convalida il modello
results = model.val(data="coco8-seg.yaml")Tracciamento#
Per eseguire il tracciamento degli oggetti in un'immagine, usa il metodo track come mostrato di seguito:
from ultralytics import FastSAM
# Crea un modello FastSAM
model = FastSAM("FastSAM-s.pt") # oppure FastSAM-x.pt
# Traccia con un modello FastSAM su un video
results = model.track(source="path/to/video.mp4", imgsz=640)Uso ufficiale di FastSAM#
FastSAM è disponibile anche direttamente dal repository CASIA-LMC-Lab/FastSAM. Ecco una breve panoramica dei passaggi tipici da seguire per usare FastSAM:
Installazione#
-
Clona il repository FastSAM:
git clone https://github.com/CASIA-LMC-Lab/FastSAM.git -
Crea e attiva un ambiente Conda con Python 3.9:
conda create -n FastSAM python=3.9 conda activate FastSAM -
Accedi al repository clonato e installa i pacchetti richiesti:
cd FastSAM pip install -r requirements.txt -
Installa il modello CLIP:
pip install git+https://github.com/ultralytics/CLIP.git
Esempio d'uso#
-
Scarica un checkpoint del modello.
-
Usa FastSAM per l'inferenza. Esempi di comandi:
-
Segmenta tutti gli oggetti in un'immagine:
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg -
Segmenta oggetti specifici usando un prompt testuale:
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --text_prompt "the yellow dog" -
Segmenta gli oggetti all'interno di un riquadro di delimitazione (fornisci le coordinate del riquadro in formato xywh):
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --box_prompt "[570,200,230,400]" -
Segmenta gli oggetti in prossimità di punti specifici:
python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --point_prompt "[[520,360],[620,300]]" --point_label "[1,0]"
-
Inoltre, puoi provare FastSAM tramite la demo Colab di CASIA-LMC-Lab.
Citazioni e ringraziamenti#
Desideriamo ringraziare gli autori di FastSAM per il loro significativo contributo nel campo della segmentazione di istanze in tempo reale:
@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'articolo originale su FastSAM è disponibile su arXiv. Gli autori hanno reso il loro lavoro disponibile al pubblico e il codice sorgente è accessibile su GitHub. Apprezziamo il loro impegno nel far progredire il settore e nel rendere il loro lavoro accessibile alla comunità più ampia.
Domande frequenti#
FastSAM, abbreviazione di Fast Segment Anything Model, è una soluzione in tempo reale basata su rete neurale convoluzionale (CNN), progettata per ridurre i requisiti di calcolo mantenendo prestazioni elevate nelle attività di segmentazione degli oggetti. A differenza di Segment Anything Model (SAM), che utilizza un'architettura più pesante basata su Transformer, FastSAM usa Ultralytics YOLOv8-seg per eseguire in modo efficiente la segmentazione di istanze in due fasi: segmentazione di tutte le istanze seguita dalla selezione guidata da prompt.
FastSAM esegue la segmentazione in tempo reale suddividendo l'attività in due fasi: la segmentazione di tutte le istanze con YOLOv8-seg e la selezione guidata da prompt. Grazie all'efficienza computazionale delle CNN, FastSAM riduce notevolmente i requisiti di calcolo e di risorse mantenendo prestazioni competitive. Questo approccio in due fasi consente a FastSAM di offrire una segmentazione rapida ed efficiente, adatta alle applicazioni che richiedono risultati tempestivi.
FastSAM è adatto a diverse attività di visione artificiale che richiedono prestazioni di segmentazione in tempo reale. Le applicazioni includono:
- Automazione industriale per il controllo e la garanzia della qualità
- Analisi video in tempo reale per la sicurezza e la sorveglianza
- Veicoli autonomi per il rilevamento e la segmentazione degli oggetti
- Imaging medico per attività di segmentazione rapide e precise
La capacità di gestire vari prompt di interazione con l'utente rende FastSAM adattabile e flessibile in scenari diversi.
Per usare FastSAM per l'inferenza in Python, puoi seguire l'esempio seguente:
from ultralytics import FastSAM # Definisci una sorgente di inferenza source = "path/to/bus.jpg" # Crea un modello FastSAM model = FastSAM("FastSAM-s.pt") # oppure FastSAM-x.pt # Esegui l'inferenza su un'immagine everything_results = model(source, device="cpu", retina_masks=True, imgsz=1024, conf=0.4, iou=0.9) # Esegui l'inferenza con il prompt dei riquadri di delimitazione results = model(source, bboxes=[439, 437, 524, 709]) # Esegui l'inferenza con un prompt basato su punti results = model(source, points=[[200, 200]], labels=[1]) # Esegui l'inferenza con prompt testuali results = model(source, texts="a photo of a dog") # Esegui contemporaneamente l'inferenza con bbox, punti e prompt testuali results = model(source, bboxes=[439, 437, 524, 709], points=[[200, 200]], labels=[1], texts="a photo of a dog")Per maggiori dettagli sui metodi di inferenza, consulta la sezione Uso della predizione della documentazione.
FastSAM supporta diversi tipi di prompt per guidare le attività di segmentazione:
- Prompt per tutti gli oggetti: genera la segmentazione di tutti gli oggetti visibili.
- Prompt per riquadro di delimitazione (BBox): Segmenta gli oggetti all'interno di un riquadro di delimitazione specificato. Un riquadro che non si sovrappone ad alcuna maschera rilevata non seleziona nulla.
- Prompt testuale: usa una descrizione testuale per segmentare gli oggetti che corrispondono alla descrizione.
- Prompt con punti: segmenta gli oggetti in prossimità di punti definiti dall'utente.
Questa flessibilità consente a FastSAM di adattarsi a un'ampia gamma di scenari di interazione con l'utente, ampliandone l'utilità nelle diverse applicazioni. Per ulteriori informazioni sull'uso di questi prompt, consulta la sezione Caratteristiche principali.
Commenti26
Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.
qinfendekaizhou
why is the postprocess times is so long
PrashantDixit0(modificato)
@qinfendekaizhou, can you share the reproducible code for it? Or the reference from where u noticed this.
In general, post-process time gets increased because of the post-processes involved to show the results, like
- NMS
- filtering by confidence score/ labels
- Scaling results to the original given inputs
- Number of objects to be annotated,
- Type of annotation, like BB or Segmentation
juliopchile
Will someone try to do a FastSAM for SAM2?
shahedmomenzadeh
Hi, I have a question Can I use the generated bbox cordinates by a yolo detection model like yolov11 as bboxes prompt for FastSAM ?
Glenn JocherUltralytics@shahedmomenzadeh yes, you can use YOLO detection model-generated bbox coordinates as prompts for FastSAM. The FastSAM documentation shows examples of passing bbox coordinates directly to the model using either the Python API or CLI. Just ensure your coordinates are in XYXY format as shown in the examples.
ismailwale
How can I make an inference of a video using frame by frame in loop using FastSam ?because I tried multiple times making inference directly with video predictor I constantly running out of memory despite setting stream =True since SAM is trying to keep the memory of 2000 frames of the video at ones . I will appreciate any ideal on how to predict and segment the video as a single frame image at every instance and put everything in a loop.
Similar question win MobileSam
Glenn JocherUltralytics@ismailwale to process a video frame by frame and avoid memory overload with FastSAM or MobileSAM, load the video as a frame sequence using a tool like OpenCV. Loop through each frame, run inference on it individually, and clear any cached results to free up memory between frames. For reference on frame-wise usage, consult OpenCV and FastSAM integration. Let me know if you need further clarifications!
ismailwale
Thanks so much for your guide .I appreciate it sir.
llu025
Thank you all for your great work! I am having troubles with prompting with a bounding box, it seems the FastSAM model ignores it and detects objects all over the video frames. This is how I obtain the results:
results = model( input_filename, device=device, imgsz=(736, 1280), verbose=False, stream=True, bboxes=[0, 0, 360, 640], retina_masks=True, conf=0.4, iou=0.9, )I also tried with
bboxes=[[0, 0, 360, 640]],without success. The model should detect objects in the top left quadrant of the video, instead it detects everywhere. Also, it oddly does not raise any error or warnings, both withbboxesas list of integers orbboxesas list of lists of integers.
Glenn JocherUltralyticsIt seems the bounding box prompts aren't being applied as expected. Ensure the
bboxesformat is correct (e.g.,[[x1, y1, x2, y2]]as a list of lists). Additionally, try using theFastSAMPredictorapproach for more controlled prompt application, as shown in this example. Let me know if the issue persists!llu025
Thank you @glenn-jocher for the "prompt" response ;-)
I need to use
stream=Truesince I am working with large videos. I cannot use it coupled withFastSAMPredictor, because it does not support it. My only alternative is to grab frames on my own with OpenCV, is that correct?By the way, in your examples in here
bboxesis passed as a list of integers, I followed those in the beginning. I see in the examples withFastSAMPredictorthat a list of lists is used instead. In any case, I ensured that I was using a list of lists, and it did not work anyway.Here's a minimal example of what I am trying to do, i.e., detecting objects in the top left part of the video:
from ultralytics import FastSAM import os import ffmpeg input_filename = "test_video.mp4" base_name = os.path.splitext(os.path.basename(input_filename))[0] output_filename = os.path.join("output", f"{base_name}.avi") model = FastSAM("models/FastSAM-x.pt") process2 = ( ffmpeg.input( "pipe:", format="rawvideo", pix_fmt="rgb24", s="1280x720", loglevel="-8", ) .output( output_filename, pix_fmt="yuv420p", vcodec="libx264", loglevel="-8", crf=17, ) .overwrite_output() .run_async(pipe_stdin=True) ) results = model( input_filename, device="cuda", imgsz=(736, 1280), verbose=False, stream=True, bboxes=[[0, 0, 360, 640]], retina_masks=True, conf=0.4, iou=0.9, ) for result in results: frame = result.plot() # Save on disk with process2 process2.stdin.write(frame.tobytes()) process2.stdin.close() process2.wait()
Glenn JocherUltralyticsThank you for the detailed explanation and example. Yes, you're correct—using OpenCV to manually grab frames is a valid and efficient approach, especially when working with
stream=Truefor large videos, as it avoids memory issues. Regardingbboxes, FastSAM expects a list of lists in the format[[x1, y1, x2, y2]]. If this still doesn't work as intended, please ensure your bounding box coordinates are correct and within the frame dimensions. Let us know if you encounter any further issues!llu025
I still encounter the same issue. I used
bboxes=[[20, 20, 500, 500]]just to be 100% sure the coordinates are within the the frame dimensions (1280x720), nothing changed. Since I have to grab frames with OpenCV anyway, I will just crop them myself, but I am quite sure this option is not working as intended.
Glenn JocherUltralytics@llu025 thank you for the update. If you’re certain the
bboxesparameter is properly configured and still not working as intended, cropping frames manually with OpenCV before passing them to the model is indeed a reliable workaround. It may also be worth checking the latest FastSAM updates or reporting this as a potential issue to ensure the bounding box prompt functionality is reviewed. Let us know if you need further assistance!
chongkuiqi
Thanks for your great work! I'm using FastSAM-x with bboxes prompt, the original image shape is [720, 1280], and I set 'imgsz' 1024. However, the results mask shape is [576, 1024], but I remembered in ultralytics-8.2.10, I can get masks with the same shape as the original image. May I ask why this change happened ?
chongkuiqi
Sorry, I forgot to set 'Retina_masks', problem solved, thanks again.
feiwenxiong
how many boxes are supported in thsi api, it cound only segment 2 boxes at most.
Glenn JocherUltralytics@feiwenxiong fastSAM should support multiple boxes. If you're experiencing limitations, please ensure your input format is correct. For further assistance, you might want to check the latest updates or documentation.
YuechengLiu
Thanks the authors for the great work!
I'm using FastSAM-x for instance segmentation (bboxes as the prompt), but I find that the shape of the predicted masks mismatch with the bounding box number. (e.g. the model takes 18 bboxes as input, but the shape of the predicted mask is (17, H, W)) . I tried to set
conf=0.01andiou=0.999, but it doesn't work. How can I solve that? Thanks!
Glenn JocherUltralytics@YuechengLiu thank you for your kind words! The issue you're experiencing might be due to a mismatch in the bounding box prompts and the segmentation results. Please ensure you're using the latest version of the FastSAM model. If the problem persists, consider checking the input format and the bounding box coordinates. For further assistance, you can refer to the FastSAM documentation: https://docs.ultralytics.com/models/fast-sam/.
YuechengLiu
Thanks for your kind reply! The bounding boxes I'm using are predicted by yolov10x (result.boxes.xyxy), so I think the input format might be right. I also tried the same bounding boxes for
mobile_sam, and the output dimension is as expected (same as the input dimension). The problem does not always occur. Do you have any idea about that? Thanks!YuechengLiu
And I'm using the latest version of ultralytics
Glenn JocherUltralyticsThanks for confirming you're using the latest version. Given that the issue is intermittent, it might be related to the specific bounding boxes or the image content. Please try running the model with a different set of bounding boxes or images to see if the issue persists. If it does, consider opening an issue on the GitHub repository with detailed information for further investigation.
nguyenvandang1998
Hi! I am using the FastSAM model and trying to obtain information about the bounding box and mask image of the object, but I don't know how to do it. I hope you can help me. Thank you very much!!
nguyenvandang1998
Currently, I can obtain information about the bounding box, but I still don't know how to get the mask image!!
Glenn JocherUltralytics(modificato)Hi there! 🙌 To extract both bounding boxes and mask images using the FastSAM model, you would typically work with the
resultsobject returned by the model's prediction method. For the bounding boxes, you can access them directly as shown in the documentation or examples provided. For the mask images, since FastSAM is designed for real-time segmentation, the results should also include segmentation masks corresponding to detected objects.Here's a simplified way to access both:
from ultralytics import FastSAM # Define your image source source = 'path/to/your/image.jpg' # Load the FastSAM model (ensure you've chosen the correct model path) model = FastSAM('FastSAM-s.pt') # or another appropriate model # Perform inference results = model(source) # Accessing bounding boxes (assuming XYXY format) boxes = results[0].boxes.xyxy # Accessing segmentation masks # The masks are directly associated with detected objects in the results masks = results[0].masks # To visualize or further process masks and boxes, you would iterate through these objectsTo visualize or save the masks, you'd typically iterate over the
masksobject, and each mask can be processed according to your requirements (e.g., overlaying on the original image or saving as separate mask images).Remember, the exact attribute names (
boxes,masks) and methods might vary based on the model output specification, so it's always good to refer to the specific documentation or example codes for guidance.Hope this helps! Let us know if you have more questions. 😊
2