Inizia

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 dell'architettura del modello Fast Segment Anything (FastSAM)

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#

  1. 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.

  2. Efficienza e prestazioni: FastSAM riduce notevolmente i requisiti di calcolo e di risorse, ottenendo prestazioni paragonabili a SAM e consentendo applicazioni in tempo reale.

  3. 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.

  4. 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.

  5. 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à.

  6. 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.

  7. 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 modelloPesi preaddestratiAttività supportateAddestramentoValidazioneInferenzaEsporta
FastSAM-sFastSAM-s.ptSegmentazione di istanze❌✅✅✅
FastSAM-xFastSAM-x.ptSegmentazione 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:

ModelloDimensione
(MB)
Parametri
(M)
Velocità (CPU)
(ms/im)
Meta SAM-b37593.741703
Meta SAM2-b16280.828867
Meta SAM2-t78.138.923430
MobileSAM40.710.123802
FastSAM-s con backbone YOLOv823.911.858.0
Ultralytics YOLOv8n-seg7.1 (11.0x più piccolo)3.4 (11.4x in meno)24.8 (945x più veloce)
Ultralytics YOLO11n-seg6.2 (12.6x più piccolo)2.9 (13.4x in meno)24.3 (964x più veloce)
Ultralytics YOLO26n-seg6.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:

Esempio
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:

Esempio
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.

Esempio di FastSAMPredictor

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

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:

Esempio
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:

Esempio
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#

  1. Clona il repository FastSAM:

    git clone https://github.com/CASIA-LMC-Lab/FastSAM.git
  2. Crea e attiva un ambiente Conda con Python 3.9:

    conda create -n FastSAM python=3.9
    conda activate FastSAM
  3. Accedi al repository clonato e installa i pacchetti richiesti:

    cd FastSAM
    pip install -r requirements.txt
  4. Installa il modello CLIP:

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

Esempio d'uso#

  1. Scarica un checkpoint del modello.

  2. 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:

Citazione
@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.

    1. PrashantDixit0GitHub(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

      1. NMS
      2. filtering by confidence score/ labels
      3. Scaling results to the original given inputs
      4. Number of objects to be annotated,
      5. Type of annotation, like BB or Segmentation
  1. shahedmomenzadehGitHub

    Hi, I have a question Can I use the generated bbox cordinates by a yolo detection model like yolov11 as bboxes prompt for FastSAM ?

    1. 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.

  2. ismailwaleGitHub

    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

    1. 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!

    2. llu025GitHub

      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 with bboxes as list of integers or bboxes as list of lists of integers.

    3. Glenn JocherUltralytics

      It seems the bounding box prompts aren't being applied as expected. Ensure the bboxes format is correct (e.g., [[x1, y1, x2, y2]] as a list of lists). Additionally, try using the FastSAMPredictor approach for more controlled prompt application, as shown in this example. Let me know if the issue persists!

    4. llu025GitHub

      Thank you @glenn-jocher for the "prompt" response ;-)

      I need to use stream=True since I am working with large videos. I cannot use it coupled with FastSAMPredictor, 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 bboxes is passed as a list of integers, I followed those in the beginning. I see in the examples with FastSAMPredictor that 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()
    5. Glenn JocherUltralytics

      Thank 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=True for large videos, as it avoids memory issues. Regarding bboxes, 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!

    6. llu025GitHub

      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.

    7. Glenn JocherUltralytics

      @llu025 thank you for the update. If you’re certain the bboxes parameter 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!

  3. chongkuiqiGitHub

    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 ?

    1. 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.

  4. YuechengLiuGitHub

    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.01 and iou=0.999, but it doesn't work. How can I solve that? Thanks!

    1. 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/.

    2. YuechengLiuGitHub

      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!

    3. Glenn JocherUltralytics

      Thanks 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.

  5. nguyenvandang1998GitHub

    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!!

    1. nguyenvandang1998GitHub

      Currently, I can obtain information about the bounding box, but I still don't know how to get the mask image!!

    2. Glenn JocherUltralytics(modificato)

      Hi there! 🙌 To extract both bounding boxes and mask images using the FastSAM model, you would typically work with the results object 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 objects

      To visualize or save the masks, you'd typically iterate over the masks object, 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