Erste Schritte

Modell zur schnellen Segmentierung beliebiger Objekte (FastSAM)

Das Fast Segment Anything Model (FastSAM) ist eine echtzeitfähige, auf einem CNN basierende Lösung für die Segment Anything-Aufgabe. Dabei wird jedes Objekt in einem Bild anhand verschiedener möglicher Interaktions-Prompts des Nutzers segmentiert. FastSAM senkt den Rechenaufwand erheblich und bietet zugleich konkurrenzfähige Leistung. Damit ist es eine praktische Wahl für vielfältige Bildverarbeitungsaufgaben.



Ansehen: Objektverfolgung mit FastSAM über Ultralytics

Modellarchitektur#

Architekturübersicht des Modells zur schnellen Segmentierung beliebiger Objekte (FastSAM)

Übersicht#

FastSAM wurde entwickelt, um die Einschränkungen des Segment Anything Model (SAM) zu überwinden, eines umfangreichen Transformer-Modells mit hohem Rechenbedarf. FastSAM teilt die Segment Anything-Aufgabe in zwei aufeinanderfolgende Schritte auf: die Instanzsegmentierung aller Objekte und die promptgesteuerte Auswahl. Im ersten Schritt erzeugt YOLOv8-seg Segmentierungsmasken für alle Instanzen im Bild. Im zweiten Schritt gibt das Modell den Bereich aus, der dem Prompt entspricht.

Wichtige Funktionen#

  1. Echtzeitlösung: Durch die Recheneffizienz von CNNs bietet FastSAM eine Lösung für die Segment Anything-Aufgabe in Echtzeit. Damit eignet sich das Modell für industrielle Anwendungen, bei denen schnelle Ergebnisse erforderlich sind.

  2. Effizienz und Leistung: FastSAM senkt den Rechen- und Ressourcenbedarf erheblich und erreicht zugleich eine mit SAM vergleichbare Leistung, wodurch Echtzeitanwendungen möglich werden.

  3. Promptgesteuerte Segmentierung: FastSAM kann jedes Objekt in einem Bild anhand verschiedener Interaktions-Prompts des Nutzers segmentieren und bietet dadurch Flexibilität und Anpassungsfähigkeit in unterschiedlichen Szenarien.

  4. Basiert auf YOLOv8-seg: FastSAM basiert auf YOLOv8-seg, einem Objektdetektor mit einem Zweig für die Instanzsegmentierung. Dadurch kann das Modell Segmentierungsmasken für alle Instanzen in einem Bild effektiv erzeugen.

  5. Konkurrenzfähige Benchmark-Ergebnisse: Bei der Aufgabe der Objektauswahl auf MS COCO erzielt FastSAM auf einer einzelnen NVIDIA RTX 3090 hohe Werte und ist dabei deutlich schneller als SAM. Das belegt seine Effizienz und Leistungsfähigkeit.

  6. Praktische Anwendungen: Dieser Ansatz bietet eine praktische Lösung für viele Bildverarbeitungsaufgaben und ist dabei zehn- bis hundertmal schneller als frühere Segment Anything-Verfahren.

  7. Machbarkeit der Modellkomprimierung: FastSAM zeigt, dass sich der Rechenaufwand deutlich senken lässt, indem der Modellstruktur eine künstliche Vorannahme hinzugefügt wird. Dadurch eröffnen sich neue Möglichkeiten für große Modellarchitekturen für allgemeine Bildverarbeitungsaufgaben.

Verfügbare Modelle, unterstützte Aufgaben und Betriebsmodi#

Diese Tabelle zeigt die verfügbaren Modelle mit den jeweiligen vortrainierten Gewichten, den unterstützten Aufgaben und der Kompatibilität mit verschiedenen Betriebsmodi wie Training, Validierung, Inferenz und Export. Unterstützte Modi sind mit ✅, nicht unterstützte Modi mit ❌ gekennzeichnet.

ModelltypVortrainierte GewichteUnterstützte AufgabenTrainingValidierungInferenzExportieren
FastSAM-sFastSAM-s.ptInstanzsegmentierung❌✅✅✅
FastSAM-xFastSAM-x.ptInstanzsegmentierung❌✅✅✅

FastSAM im Vergleich zu YOLO#

Hier vergleichen wir FastSAM-s mit Metas SAM-Varianten und den Segmentierungsmodellen von Ultralytics, darunter YOLO26:

ModellGröße
(MB)
Parameter
(M)
Geschwindigkeit (CPU)
(ms/Bild)
Meta SAM-b37593.741703
Meta SAM2-b16280.828867
Meta SAM2-t78.138.923430
MobileSAM40.710.123802
FastSAM-s mit YOLOv8-Backbone23.911.858.0
Ultralytics YOLOv8n-seg7.1 (11.0-mal kleiner)3.4 (11.4-mal weniger)24.8 (945-mal schneller)
Ultralytics YOLO11n-seg6.2 (12.6-mal kleiner)2.9 (13.4-mal weniger)24.3 (964-mal schneller)
Ultralytics YOLO26n-seg6.7 (11.7-mal kleiner)2.7 (14.4-mal weniger)25.2 (930-mal schneller)

Dieser Vergleich zeigt die erheblichen Unterschiede bei Modellgrößen und Geschwindigkeiten zwischen SAM-Varianten und YOLO-Segmentierungsmodellen. SAM bietet zwar einzigartige Möglichkeiten zur automatischen Segmentierung, doch YOLO-Modelle, insbesondere YOLOv8n-seg, YOLO11n-seg und YOLO26n-seg, sind deutlich kleiner, schneller und recheneffizienter.

Die Geschwindigkeiten von SAM wurden mit PyTorch gemessen, die von YOLO mit ONNX Runtime. Die Tests wurden auf einem Apple M4 Air aus dem Jahr 2025 mit 16 GB RAM und torch==2.10.0, ultralytics==8.4.31 und onnxruntime==1.24.4 durchgeführt. So kannst du diesen Test reproduzieren:

Beispiel
from ultralytics import ASSETS, SAM, YOLO, FastSAM

# SAM2-t, SAM2-b, SAM-b, MobileSAM profilieren
for file in ["sam_b.pt", "sam2_b.pt", "sam2_t.pt", "mobile_sam.pt"]:
    model = SAM(file)
    model.info()
    model(ASSETS)

# FastSAM-s profilieren
model = FastSAM("FastSAM-s.pt")
model.info()
model(ASSETS)

# YOLO-Modelle profilieren (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)  # NMS-freier YOLO26-Head; für YOLOv8/YOLO11 ohne Funktion
    model = YOLO(onnx_path)
    model(ASSETS)

Anwendungsbeispiele#

Die FastSAM-Modelle lassen sich problemlos in deine Python-Anwendungen integrieren. Ultralytics stellt sowohl eine Python-API als auch CLI-Befehle bereit.

Verwendung für Vorhersagen#

Verwende zur Segmentierung eines Bildes die Methode predict wie unten gezeigt:

Beispiel
from ultralytics import FastSAM

# Inferenzquelle definieren
source = "path/to/bus.jpg"

# Ein FastSAM-Modell erstellen
model = FastSAM("FastSAM-s.pt")  # oder FastSAM-x.pt

# Eine Inferenz auf einem Bild ausführen
everything_results = model(source, device="cpu", retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)

# Inferenz mit Begrenzungsrahmen-Prompt ausführen
results = model(source, bboxes=[439, 437, 524, 709])

# Inferenz mit Punktvorgaben ausführen
results = model(source, points=[[200, 200]], labels=[1])

# Inferenz mit Textvorgaben ausführen
results = model(source, texts="a photo of a dog")

# Inferenz gleichzeitig mit BBoxes, Punkten und Textvorgaben ausführen
results = model(source, bboxes=[439, 437, 524, 709], points=[[200, 200]], labels=[1], texts="a photo of a dog")

Dieses Codebeispiel zeigt, wie einfach es ist, ein vortrainiertes Modell zu laden und eine Vorhersage für ein Bild auszuführen.

FastSAMPredictor-Beispiel

Führe einmal eine Inferenz auf einem Bild aus, um alle Segment-results zu erhalten. Wende dann mehrmals Prompts auf diese Ergebnisse an, ohne die Inferenz erneut auszuführen.

from ultralytics.models.fastsam import FastSAMPredictor

# FastSAMPredictor erstellen
overrides = {"conf": 0.25, "task": "segment", "mode": "predict", "model": "FastSAM-s.pt", "save": False, "imgsz": 1024}
predictor = FastSAMPredictor(overrides=overrides)

# Alles segmentieren
everything_results = predictor("ultralytics/assets/bus.jpg")

# Inferenz mit Vorgaben
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")
Hinweis

Alle in den obigen Beispielen zurückgegebenen results sind Results-Objekte, die Zugriff auf die vorhergesagten Masken und das Quellbild bieten.

Verwendung zur Validierung#

FastSAM unterstützt nur die Erkennung und Segmentierung einer einzelnen Objektklasse. Daher erkennt und segmentiert das Modell alle Objekte als dieselbe Klasse. Wandle beim Vorbereiten des Datensatzes alle Objektkategorie-IDs in 0 um.

Die Validierung des Modells auf einem Datensatz kann wie folgt durchgeführt werden:

Beispiel
from ultralytics import FastSAM

# Ein FastSAM-Modell erstellen
model = FastSAM("FastSAM-s.pt")  # oder FastSAM-x.pt

# Das Modell validieren
results = model.val(data="coco8-seg.yaml")

Tracking-Nutzung#

Um Objekte in einem Bild zu verfolgen, verwende die Methode track wie unten gezeigt:

Beispiel
from ultralytics import FastSAM

# Ein FastSAM-Modell erstellen
model = FastSAM("FastSAM-s.pt")  # oder FastSAM-x.pt

# Tracking mit einem FastSAM-Modell in einem Video
results = model.track(source="path/to/video.mp4", imgsz=640)

Offizielle FastSAM-Nutzung#

FastSAM ist auch direkt im Repository CASIA-LMC-Lab/FastSAM verfügbar. Hier findest du einen kurzen Überblick über die üblichen Schritte zur Verwendung von FastSAM:

Installation#

  1. Klone das FastSAM-Repository:

    git clone https://github.com/CASIA-LMC-Lab/FastSAM.git
  2. Erstelle und aktiviere eine Conda-Umgebung mit Python 3.9:

    conda create -n FastSAM python=3.9
    conda activate FastSAM
  3. Wechsle in das geklonte Repository und installiere die erforderlichen Pakete:

    cd FastSAM
    pip install -r requirements.txt
  4. Installiere das CLIP-Modell:

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

Anwendungsbeispiel#

  1. Lade einen Modell-Checkpoint herunter.

  2. Verwende FastSAM für die Inferenz. Beispielbefehle:

    • Segmentiere alle Objekte in einem Bild:

      python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg
    • Segmentiere bestimmte Objekte mithilfe eines Text-Prompts:

      python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --text_prompt "the yellow dog"
    • Segmentiere Objekte innerhalb einer Begrenzungsbox (gib die Boxkoordinaten im xywh-Format an):

      python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --box_prompt "[570,200,230,400]"
    • Segmentiere Objekte in der Nähe bestimmter Punkte:

      python Inference.py --model_path ./weights/FastSAM.pt --img_path ./images/dogs.jpg --point_prompt "[[520,360],[620,300]]" --point_label "[1,0]"

Außerdem kannst du FastSAM über die Colab-Demo von CASIA-LMC-Lab ausprobieren.

Zitate und Danksagungen#

Wir möchten den FastSAM-Autoren für ihre bedeutenden Beiträge auf dem Gebiet der Echtzeit-Instanzsegmentierung danken:

Zitierung
@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}
}

Das Originalpaper zu FastSAM findest du auf arXiv. Die Autoren haben ihre Arbeit öffentlich zugänglich gemacht; der Code ist auf GitHub verfügbar. Wir schätzen ihre Bemühungen, das Fachgebiet voranzubringen und ihre Arbeit einer breiteren Community zugänglich zu machen.

Häufig gestellte Fragen#

  • FastSAM, kurz für Fast Segment Anything Model, ist eine echtzeitfähige, auf einem Faltungsneuronalen Netzwerk (CNN) basierende Lösung. Sie wurde entwickelt, um den Rechenaufwand zu verringern und zugleich eine hohe Leistung bei der Objektsegmentierung beizubehalten. Anders als das Segment Anything Model (SAM), das eine umfangreichere Transformer-basierte Architektur nutzt, verwendet FastSAM Ultralytics YOLOv8-seg für eine effiziente Instanzsegmentierung in zwei Schritten: zunächst die Segmentierung aller Instanzen, dann die promptgesteuerte Auswahl.

  • FastSAM ermöglicht die Segmentierung in Echtzeit, indem es die Aufgabe in zwei Schritte aufteilt: die Segmentierung aller Instanzen mit YOLOv8-seg und die promptgesteuerte Auswahl. Dank der Recheneffizienz von CNNs verringert FastSAM den Rechen- und Ressourcenbedarf erheblich und bietet zugleich konkurrenzfähige Leistung. Mit diesem zweistufigen Ansatz ermöglicht FastSAM eine schnelle, effiziente Segmentierung für Anwendungen, bei denen rasche Ergebnisse erforderlich sind.

  • FastSAM eignet sich für verschiedene Aufgaben im Bereich Computer Vision, bei denen Segmentierung in Echtzeit erforderlich ist. Zu den Anwendungsbereichen gehören:

    • Industrielle Automatisierung für Qualitätskontrolle und Qualitätssicherung
    • Echtzeit-Videoanalyse für Sicherheit und Überwachung
    • Autonome Fahrzeuge zur Objekterkennung und Segmentierung
    • Medizinische Bildgebung für präzise und schnelle Segmentierungsaufgaben

    Dank seiner Fähigkeit, verschiedene Nutzereingaben zu verarbeiten, ist FastSAM flexibel und lässt sich an unterschiedliche Szenarien anpassen.

  • Für die Inferenz mit FastSAM in Python kannst du dem folgenden Beispiel folgen:

    from ultralytics import FastSAM
    
    # Inferenzquelle definieren
    source = "path/to/bus.jpg"
    
    # Ein FastSAM-Modell erstellen
    model = FastSAM("FastSAM-s.pt")  # oder FastSAM-x.pt
    
    # Eine Inferenz auf einem Bild ausführen
    everything_results = model(source, device="cpu", retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
    
    # Inferenz mit Begrenzungsrahmen-Prompt ausführen
    results = model(source, bboxes=[439, 437, 524, 709])
    
    # Inferenz mit Punktvorgaben ausführen
    results = model(source, points=[[200, 200]], labels=[1])
    
    # Inferenz mit Textvorgaben ausführen
    results = model(source, texts="a photo of a dog")
    
    # Inferenz gleichzeitig mit BBoxes, Punkten und Textvorgaben ausführen
    results = model(source, bboxes=[439, 437, 524, 709], points=[[200, 200]], labels=[1], texts="a photo of a dog")

    Weitere Informationen zu Inferenzmethoden findest du im Abschnitt Predict-Nutzung der Dokumentation.

  • FastSAM unterstützt mehrere Prompt-Arten zur Steuerung der Segmentierungsaufgaben:

    • Alles-Prompt: Erstellt Segmentierungen für alle sichtbaren Objekte.
    • Prompt für Begrenzungsrahmen (BBox): Segmentiert Objekte innerhalb eines vorgegebenen Begrenzungsrahmens. Ein Rahmen, der keine erkannte Maske überlappt, wählt nichts aus.
    • Text-Prompt: Verwendet eine beschreibende Texteingabe, um Objekte zu segmentieren, die der Beschreibung entsprechen.
    • Punkt-Prompt: Segmentiert Objekte in der Nähe bestimmter, vom Nutzer festgelegter Punkte.

    Diese Flexibilität ermöglicht es FastSAM, sich an vielfältige Szenarien der Benutzerinteraktion anzupassen und seinen Nutzen für unterschiedliche Anwendungen zu erhöhen. Weitere Informationen zur Verwendung dieser Prompts findest du im Abschnitt Hauptmerkmale.

Kommentare26

Stell eine Frage, teile deine Ergebnisse oder hilf jemand anderem.

    1. PrashantDixit0GitHub(bearbeitet)

      @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. Glenn JocherUltralytics(bearbeitet)

      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