Modell zur Segmentierung beliebiger Objekte (SAM)
Das Segment Anything Model (SAM) von Meta führte die promptbasierte Bildsegmentierung ein: Als Eingabe dient ein Punkt, ein Rahmen oder eine Masken-Prompt; zurückgegeben wird eine Maske für das angegebene Objekt. Ein leichter Decoder ermöglicht eine ausreichend schnelle interaktive Verwendung.
Einführung in SAM: das Modell zur Segmentierung beliebiger Objekte#
Das Segment Anything Model, kurz SAM, ist ein Bildsegmentierungsmodell für promptbasierte Segmentierung bei einer Vielzahl von Bildanalyseaufgaben. SAM bildet den Kern von Metas Segment Anything-Projekt, das ein neues Modell, eine neue Aufgabe und einen neuen Datensatz für die Bildsegmentierung eingeführt hat.
Das Design von SAM ermöglicht die Anpassung an neue Bildverteilungen und Aufgaben ohne Vorkenntnisse – eine Fähigkeit, die als Zero-Shot-Transfer bezeichnet wird. SAM wurde auf dem SA-1B-Datensatz trainiert, der mehr als 1 Milliarde Masken für 11 Millionen sorgfältig zusammengestellte Bilder enthält. Das Modell zeigt eine starke Zero-Shot-Leistung, die häufig mit früheren Ergebnissen vollständig überwachter Verfahren mithalten kann oder diese übertrifft.
Beispielbilder aus SA-1B. Bilder aus dem SA-1B-Datensatz mit überlagerten Masken. SA-1B enthält 11 Mio. vielfältige, hochauflösende, lizenzierte und die Privatsphäre schützende Bilder sowie 1,1 Mrd. hochwertige Segmentierungsmasken. SAM hat diese Masken vollständig automatisch annotiert. Bewertungen durch Menschen und zahlreiche Experimente bestätigen ihre hohe Qualität und Vielfalt. Zur Visualisierung sind die Bilder nach der Anzahl der Masken pro Bild gruppiert (durchschnittlich etwa 100 Masken pro Bild).
Wichtige Merkmale des Modells zur Segmentierung beliebiger Objekte (SAM)#
- Promptgesteuerte Segmentierungsaufgabe: SAM wurde für promptgesteuerte Segmentierungsaufgaben entwickelt und kann aus jedem vorgegebenen Prompt gültige Segmentierungsmasken erzeugen, etwa aus räumlichen Hinweisen oder Textangaben, die ein Objekt kennzeichnen.
- Fortschrittliche Architektur: Das Segment Anything Model verwendet einen umfangreichen Bildencoder, einen Prompt-Encoder und einen leichten Maskendecoder. Diese Architektur ermöglicht flexible Prompts, die Berechnung von Masken in Echtzeit und die Berücksichtigung von Mehrdeutigkeiten bei Segmentierungsaufgaben.
- Der SA-1B-Datensatz: Der im Rahmen des Segment Anything-Projekts eingeführte SA-1B-Datensatz umfasst mehr als 1 Milliarde Masken für 11 Millionen Bilder. Als zum Zeitpunkt seiner Veröffentlichung größter Segmentierungsdatensatz stellt er SAM vielfältige Trainingsdaten in großem Umfang bereit.
- Zero-Shot-Leistung: SAM erzielt starke Zero-Shot-Ergebnisse bei verschiedenen Segmentierungsaufgaben und ist damit ein sofort einsatzbereites Werkzeug für vielfältige Anwendungen, für die nur wenig Prompt Engineering erforderlich ist.
Ausführliche Informationen zum Modell zur Segmentierung beliebiger Objekte und zum SA-1B-Datensatz findest du auf Segment Anything auf GitHub und im Forschungsartikel Segment Anything.
Modelle der SAM-Familie (SAM 2.1, SAM 3 und SAM 3.1) bilden die Grundlage für die intelligente Annotationsfunktion auf der Ultralytics Platform, die das Erstellen von Masken per Mausklick und damit eine schnelle Datensatzannotation ermöglicht.
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.
| Modelltyp | Vortrainierte Gewichte | Unterstützte Aufgaben | Training | Validierung | Inferenz | Exportieren |
|---|---|---|---|---|---|---|
| SAM Base | sam_b.pt | Instanzsegmentierung | ❌ | ❌ | ✅ | ❌ |
| SAM Large | sam_l.pt | Instanzsegmentierung | ❌ | ❌ | ✅ | ❌ |
SAM verwenden: Vielseitigkeit und Leistungsfähigkeit bei der Bildsegmentierung#
Das Segment Anything Model lässt sich über die Trainingsdaten hinaus für viele nachgelagerte Aufgaben einsetzen, darunter Kantenerkennung, die Erzeugung von Objektvorschlägen, Instanzsegmentierung und die vorläufige Vorhersage von Masken aus Text. Mit Prompt Engineering kann sich SAM im Zero-Shot-Verfahren an neue Aufgaben und Datenverteilungen anpassen.
Beispiel für eine SAM-Vorhersage#
Bild mit vorgegebenen Prompts segmentieren.
from ultralytics import SAM
# Ein Modell laden
model = SAM("sam_b.pt")
# Modellinformationen anzeigen (optional)
model.info()
# Inferenz mit Begrenzungsrahmen-Prompt ausführen
results = model("ultralytics/assets/zidane.jpg", bboxes=[439, 437, 524, 709])
# Inferenz mit einem einzelnen Punkt ausführen
results = model(points=[900, 370], labels=[1])
# Inferenz mit mehreren Punkten ausführen
results = model(points=[[400, 370], [900, 370]], labels=[1, 1])
# Inferenz mit mehreren Punkt-Prompts pro Objekt ausführen
results = model(points=[[[400, 370], [900, 370]]], labels=[[1, 1]])
# Inferenz mit einem Negativpunkt-Prompt ausführen
results = model(points=[[[400, 370], [900, 370]]], labels=[[1, 0]])Das gesamte Bild segmentieren.
from ultralytics import SAM
# Ein Modell laden
model = SAM("sam_b.pt")
# Modellinformationen anzeigen (optional)
model.info()
# Inferenz ausführen
model("path/to/image.jpg")- SAM segmentiert das gesamte Bild, wenn du keine Prompts (Bounding Boxes/Punkte/Masken) übergibst.
Lege das Bild einmal fest und führe anschließend mehrmals eine Inferenz mit Prompts aus, ohne den Bildencoder erneut auszuführen.
import cv2
from ultralytics.models.sam import Predictor as SAMPredictor
# SAMPredictor erstellen
overrides = {"conf": 0.25, "task": "segment", "mode": "predict", "imgsz": 1024, "model": "mobile_sam.pt"}
predictor = SAMPredictor(overrides=overrides)
# Bild festlegen
predictor.set_image("ultralytics/assets/zidane.jpg") # mit einer Bilddatei festlegen
predictor.set_image(cv2.imread("ultralytics/assets/zidane.jpg")) # mit np.ndarray festlegen
results = predictor(bboxes=[439, 437, 524, 709])
# Inferenz mit einem einzelnen Punkt-Prompt ausführen
results = predictor(points=[900, 370], labels=[1])
# Inferenz mit mehreren Punkt-Prompts ausführen
results = predictor(points=[[400, 370], [900, 370]], labels=[1, 1])
# Inferenz mit einem Negativpunkt-Prompt ausführen
results = predictor(points=[[[400, 370], [900, 370]]], labels=[[1, 0]])
# Bild zurücksetzen
predictor.reset_image()Alles mit zusätzlichen Argumenten segmentieren.
from ultralytics.models.sam import Predictor as SAMPredictor
# SAMPredictor erstellen
overrides = {"conf": 0.25, "task": "segment", "mode": "predict", "imgsz": 1024, "model": "mobile_sam.pt"}
predictor = SAMPredictor(overrides=overrides)
# Mit zusätzlichen Argumenten segmentieren
results = predictor(source="ultralytics/assets/zidane.jpg", crop_n_layers=1, points_stride=64, min_mask_region_area=100)Alle in den obigen Beispielen zurückgegebenen results sind Results-Objekte, die Zugriff auf die vorhergesagten Masken und das Quellbild bieten.
- Weitere Argumente für
Segment everythingfindest du in der Referenz zuPredictor/generate.
Vergleich von SAM und YOLO#
Hier vergleichen wir Metas SAM-b-Modell mit den Segmentierungsmodellen von Ultralytics, darunter YOLO26:
| Modell | Größe (MB) | Parameter (M) | Geschwindigkeit (CPU) (ms/Bild) |
|---|---|---|---|
| Meta SAM-b | 375 | 93.7 | 41703 |
| MobileSAM | 40.7 | 10.1 | 23802 |
| FastSAM-s mit YOLOv8-Backbone | 23.9 | 11.8 | 58.0 |
| Ultralytics YOLOv8n-seg | 7.1 (52,8-mal kleiner) | 3.4 (27,6-mal weniger) | 24.8 (1682-mal schneller) |
| Ultralytics YOLO11n-seg | 6.2 (60,5-mal kleiner) | 2.9 (32,3-mal weniger) | 24.3 (1716-mal schneller) |
| Ultralytics YOLO26n-seg | 6.7 (56,0-mal kleiner) | 2.7 (34,7-mal weniger) | 25.2 (1655-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:
from ultralytics import ASSETS, SAM, YOLO, FastSAM
# SAM-b und MobileSAM profilen
for file in ["sam_b.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)Automatische Annotation: Schnell zu Segmentierungsdatensätzen#
Die automatische Annotation ist eine wichtige Funktion von SAM. Damit können Nutzer mithilfe eines vortrainierten Erkennungsmodells einen Segmentierungsdatensatz erstellen. So lassen sich große Bildmengen schnell annotieren und zeitaufwendige manuelle Beschriftungen vermeiden.
Mit einem Erkennungsmodell einen Segmentierungsdatensatz erstellen#
Um deinen Datensatz mit dem Ultralytics-Framework automatisch zu annotieren, verwende die Funktion auto_annotate, die ein Erkennungsmodell wie YOLO26x mit SAM kombiniert:
from ultralytics.data.annotator import auto_annotate
auto_annotate(data="path/to/images", det_model="yolo26x.pt", sam_model="sam_b.pt")| Argument | Typ | Standard | Beschreibung |
|---|---|---|---|
data | str | erforderlich | Pfad zum Verzeichnis mit den Zielbildern für die Annotation oder Segmentierung. |
det_model | str | 'yolo26x.pt' | Pfad zum YOLO-Erkennungsmodell für die anfängliche Objekterkennung. |
sam_model | str | 'sam_b.pt' | Pfad zum SAM-Modell für die Segmentierung (unterstützt SAM-, SAM 2-, MobileSAM- und SAM 3-Gewichte). |
device | str | '' | Rechengerät (z. B. 'cuda:0', 'cpu' oder '' zur automatischen Geräteerkennung). |
conf | float | 0.25 | Konfidenzschwelle der YOLO-Erkennung, um unsichere Erkennungen herauszufiltern. |
iou | float | 0.5 | IoU-Schwelle für Non-Maximum Suppression, um überlappende Boxen herauszufiltern. |
imgsz | int | 640 | Eingabegröße für die Größenanpassung von Bildern (bei Bedarf auf das nächste Vielfache von 32 aufgerundet). |
max_det | int | 300 | Höchstzahl der Erkennungen pro Bild zur effizienten Speichernutzung. |
classes | list[int] | None | Liste der zu erkennenden Klassenindizes (z. B. [0, 1] für Person und Fahrrad). |
output_dir | str | None | Speicherverzeichnis für Annotationen (standardmäßig ein Verzeichnis neben <data>_auto_annotate_labels). |
Die Funktion auto_annotate erwartet den Pfad zu deinen Bildern. Mit optionalen Argumenten kannst du das vortrainierte Erkennungsmodell und das SAM-Segmentierungsmodell, das Gerät für die Ausführung der Modelle sowie das Ausgabeverzeichnis zum Speichern der annotierten Ergebnisse angeben.
Die automatische Annotation mit vortrainierten Modellen verringert den Zeit- und Arbeitsaufwand für die Erstellung von Segmentierungsdatensätzen erheblich. So können sich Teams mit großen Bildsammlungen auf die Modellentwicklung und -bewertung statt auf manuelle Annotation konzentrieren.
Zitate und Danksagungen#
Wenn SAM für deine Forschungs- oder Entwicklungsarbeit hilfreich ist, ziehe bitte in Betracht, den Artikel zu zitieren:
@misc{kirillov2023segment,
title={Segment Anything},
author={Alexander Kirillov and Eric Mintun and Nikhila Ravi and Hanzi Mao and Chloe Rolland and Laura Gustafson and Tete Xiao and Spencer Whitehead and Alexander C. Berg and Wan-Yen Lo and Piotr Dollár and Ross Girshick},
year={2023},
eprint={2304.02643},
archivePrefix={arXiv},
primaryClass={cs.CV}
}Wir möchten Meta AI dafür danken, dass das Team diese wertvolle Ressource für die Computer-Vision-Community entwickelt und pflegt.
Häufig gestellte Fragen#
Metas Segment Anything Model (SAM) ist ein Bildsegmentierungsmodell für promptbasierte Segmentierungsaufgaben. Es kombiniert Bild- und Prompt-Encoder mit einem leichten Maskendecoder, um aus Prompts wie Punkten, Rahmen oder Masken Segmentierungsmasken zu erzeugen. SAM wurde auf dem SA-1B-Datensatz trainiert und erzielt gute Zero-Shot-Ergebnisse, indem es sich ohne Vorkenntnisse an neue Bildverteilungen und Aufgaben anpasst.
Du kannst das Modell zur Segmentierung beliebiger Objekte (SAM) für die Bildsegmentierung verwenden, indem du mit verschiedenen Prompts wie Begrenzungsrahmen oder Punkten Inferenz ausführst. Hier ein Beispiel mit Python:
from ultralytics import SAM # Ein Modell laden model = SAM("sam_b.pt") # Mit einer Begrenzungsbox als Prompt segmentieren model("ultralytics/assets/zidane.jpg", bboxes=[439, 437, 524, 709]) # Mit einem Punkt-Prompt segmentieren model("ultralytics/assets/zidane.jpg", points=[900, 370], labels=[1]) # Mit mehreren Punkt-Prompts segmentieren model("ultralytics/assets/zidane.jpg", points=[[400, 370], [900, 370]], labels=[1, 1]) # Mit mehreren Punkt-Prompts pro Objekt segmentieren model("ultralytics/assets/zidane.jpg", points=[[[400, 370], [900, 370]]], labels=[[1, 1]]) # Mit negativen Punkt-Prompts segmentieren. model("ultralytics/assets/zidane.jpg", points=[[[400, 370], [900, 370]]], labels=[[1, 0]])Alternativ kannst du Inferenz mit SAM über die Befehlszeilenschnittstelle (CLI) ausführen:
yolo predict model=sam_b.pt source=path/to/image.jpgIm Vergleich zu YOLO-Modellen sind SAM-Varianten wie SAM-b, MobileSAM und FastSAM-s in der Regel größer und langsamer, bieten aber einzigartige Zero-Shot-Segmentierungsfunktionen. Beispielsweise ist YOLO26n-seg auf der CPU 56-mal kleiner und mehr als 1650-mal schneller als Metas ursprüngliches SAM-b-Modell. Dadurch eignen sich YOLO-Modelle ideal für Anwendungen, bei denen schnelle, leichtgewichtige und rechenleistungseffiziente Segmentierung gefragt ist. SAM-Modelle überzeugen dagegen bei flexibler, promptgesteuerter Zero-Shot-Segmentierung.
SAM von Ultralytics bietet eine Funktion für automatische Annotationen, mit der sich mithilfe eines vortrainierten Erkennungsmodells Segmentierungsdatensätze erstellen lassen. Hier ein Beispiel mit Python:
from ultralytics.data.annotator import auto_annotate auto_annotate(data="path/to/images", det_model="yolo26x.pt", sam_model="sam_b.pt")Diese Funktion erwartet den Pfad zu deinen Bildern sowie optionale Angaben zu vortrainierten Erkennungs- und SAM-Segmentierungsmodellen, dem Gerät und dem Ausgabeverzeichnis. Eine vollständige Anleitung findest du unter Automatische Annotation.
SAM wird auf dem SA-1B-Datensatz trainiert, der mehr als 1 Milliarde Masken in 11 Millionen Bildern umfasst. Zum Zeitpunkt seiner Veröffentlichung war SA-1B der größte Segmentierungsdatensatz. Er bietet hochwertige, vielfältige Trainingsdaten, auf denen die Leistung von SAM bei Segmentierungsaufgaben ohne zusätzliche Trainingsbeispiele beruht.
Kommentare27
Stell eine Frage, teile deine Ergebnisse oder hilf jemand anderem.
kh-diab
can we use SAM to process labeled images with bounding box to segment the object inside the box and generate new labels files like yolo or coco format if yes how please
1
Paula DerrengerUltralyticsYes, you can use SAM to process labeled images with bounding boxes to segment the objects inside and generate new label files in formats like YOLO or COCO. You can achieve this by using the
auto_annotatefunction in the Ultralytics framework. This function allows you to auto-annotate your dataset using a pre-trained detection model and SAM for segmentation. For more details, you can refer to the Segment Anything Model documentation. If you need further assistance, feel free to ask!kh-diab
Hello @pderrenger
Thanks I tried to run the below but I face error all the time
import os import cv2 import numpy as np from ultralytics import SAM
Load the SAM model
model = SAM("sam_b.pt") # Update the model path if needed
Function to load YOLO annotations
def load_yolo_annotations(annotation_path, image_width, image_height): bboxes = [] try: with open(annotation_path, 'r') as file: lines = file.readlines() for line in lines: parts = line.strip().split() class_id = int(parts[0]) x_center = float(parts[1]) * image_width y_center = float(parts[2]) * image_height width = float(parts[3]) * image_width height = float(parts[4]) * image_height x = x_center - width / 2 y = y_center - height / 2 bboxes.append((x, y, x + width, y + height)) # Update to [x1, y1, x2, y2] except Exception as e: print(f"Error reading annotation file {annotation_path}: {e}") return bboxes
Paths
images_folder = r'E:\MSc\tesi\20210901_Herrenpuent_Taenikon_Matrice_300_15m_1.6m_s\500 D' annotations_folder = r'C:\Users\Khaled\OneDrive - OST\Study Material\Msc Thesis\dataset\Group D yolo format\obj_train_data' output_folder = r'C:\Users\Khaled\OneDrive - OST\Study Material\Msc Thesis\dataset\test output sam'
if not os.path.exists(output_folder): os.makedirs(output_folder)
Process each image and its corresponding annotation
total_images = len(os.listdir(images_folder)) processed_images = 0
for image_filename in os.listdir(images_folder): if image_filename.endswith(('.JPG', '.jpg', '.png')): image_path = os.path.join(images_folder, image_filename) annotation_path = os.path.join(annotations_folder, image_filename.replace('.JPG', '.txt').replace('.jpg', '.txt').replace('.png', '.txt'))
print(f"Processing {image_filename}...") # Check if annotation file exists if not os.path.exists(annotation_path): print(f"Annotation file not found for {image_filename}") continue # Load the image image = cv2.imread(image_path) if image is None: print(f"Failed to load image {image_path}") continue image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) height, width, _ = image.shape # Load YOLO annotations bboxes = load_yolo_annotations(annotation_path, width, height) if not bboxes: print(f"No bounding boxes found in {annotation_path}") continue # Perform segmentation using SAM model results = model(image_rgb, bboxes=bboxes) for idx, result in enumerate(results): if hasattr(result, 'masks') and result.masks is not None: masks = result.masks.cpu().numpy() # Convert to numpy array for m_idx, mask in enumerate(masks): chw_mask = mask.astype(np.uint8) # Ensure mask is in uint8 format hwc_mask = np.transpose(chw_mask, (1, 2, 0)) # Convert CHW to HWC contours, _ = cv2.findContours(hwc_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) segmented_image = cv2.bitwise_and(image, image, mask=hwc_mask) # Save the segmented image output_path = os.path.join(output_folder, image_filename.replace('.JPG', f'_segmented_{idx}_{m_idx}.jpg').replace('.jpg', f'_segmented_{idx}_{m_idx}.jpg').replace('.png', f'_segmented_{idx}_{m_idx}.png')) cv2.imwrite(output_path, segmented_image) print(f"Saved segmented image to {output_path}") processed_images += 1 print(f"Processed {processed_images}/{total_images} images.")print("Processing completed.")
error is
AttributeError: 'Masks' object has no attribute 'astype'. See valid attributes below.
A class for storing and manipulating detection masks. xy (list): A list of segments in pixel coordinates. xyn (list): A list of normalized segments. Methods: cpu(): Returns the masks tensor on CPU memory. numpy(): Returns the masks tensor as a numpy array. cuda(): Returns the masks tensor on GPU memory. to(device, dtype): Returns the masks tensor with the specified device and dtype.PS C:\Users\Khaled> & C:/MSc_Workspace/anaconda3/envs/GenEnv/python.exe "c:/Users/Khaled/OneDrive - OST/Study Material/Msc Thesis/coding/sam segment.py" Processing DJI_20210901122818_0695.JPG...
0: 1024x1024 67330.4ms Speed: 48.0ms preprocess, 67330.4ms inference, 8095.5ms postprocess per image at shape (1, 3, 1024, 1024) Traceback (most recent call last): File "c:\Users\Khaled\OneDrive - OST\Study Material\Msc Thesis\coding\sam segment.py", line 75, in chw_mask = mask.astype(np.uint8) # Ensure mask is in uint8 format File "C:\MSc_Workspace\anaconda3\envs\GenEnv\lib\site-packages\ultralytics\utils_init_.py", line 162, in getattr raise AttributeError(f"'{name}' object has no attribute '{attr}'. See valid attributes below.\n{self.doc}") AttributeError: 'Masks' object has no attribute 'astype'. See valid attributes below.
A class for storing and manipulating detection masks. Attributes: xy (list): A list of segments in pixel coordinates. xyn (list): A list of normalized segments. Methods: cpu(): Returns the masks tensor on CPU memory. numpy(): Returns the masks tensor as a numpy array. cuda(): Returns the masks tensor on GPU memory. to(device, dtype): Returns the masks tensor with the specified device and dtype.do you have idea how to solve it thanks
evans rojas
Hola me gustaría usar SAM para clasificar vegetación a partir de una imagen. ¿Qué recomendaciones me sugieren?
Paula DerrengerUltralyticsHola, Evans. SAM puede ayudarte a delimitar la vegetación, pero el SAM original no identifica por sí solo especies ni tipos de cobertura. Te sugiero comenzar con puntos positivos sobre la vegetación y negativos sobre el fondo, revisar las máscaras y asignarles tus clases manualmente. Si buscas automatizar la clasificación en más imágenes, puedes usar esas anotaciones para entrenar un modelo de segmentación por instancias para plantas individuales o de segmentación semántica para coberturas del terreno. ¿Quieres separar vegetación del fondo o distinguir especies, y trabajas con fotografías terrestres, de dron o satelitales?
meenakshi71
I've been trying to export the SAM model (which i had trained on my custom dataset) into ONNX but the output is always wrong. It is just generating a grid instead of a proper segmentation mask every time even after providing multiple kinds of prompts.
Glenn JocherUltralytics@meenakshi71 it seems the issue may stem from the export process or configuration. Ensure you are using the correct export parameters and supported formats. SAM models are primarily designed for real-time inference and not all functionalities may transfer seamlessly to ONNX. Refer to the SAM export documentation for guidance. If the problem persists, consider testing the ONNX model with simpler prompts to isolate the issue.
MeenakshiKK236
Why are my segmentation results being automatically saved into this directory while using the SAM model to perform segmentation on my custom dataset? "Results saved to runs/segment/predict4"
Glenn JocherUltralytics@MeenakshiKK236 the results are saved to the
runs/segment/predict4directory by default. You can change the save directory by specifying theprojectandnamearguments in your command. For more details, please refer to the SAM documentation.
NasserAlqeifi
Correct me if I'm wrong, when I use the auto_annotate function I will only get labels for my dataset with the classes in Yolo pre-trained? What if I need classes that are not available within Yolo? For example, I want to get a label for the road, and this is not available in any version of Yolo, but it is available in SAM?
Glenn JocherUltralytics@NasserAlqeifi you are correct. The
auto_annotatefunction uses YOLO's pre-trained classes for labeling. If you need classes not available in YOLO, like "road," you can use SAM directly for segmentation. For more details, please refer to the Segment Anything Model documentation.
Glenn JocherUltralytics@NasserAlqeifi but also remember SAM identifies segments but not classes, so it may find a sign or a road, but it won't be able to assign a class to them by itself.
NasserAlqeifi
Thank you for your quick response. Indeed, I tried to use SAM directly and found that it does not save the class names in the name, but the class number.
from ultralytics import SAM
Load a model
model = SAM("sam2_l.pt")
Predict results
results = model.predict(source=r"/testSAM/image.png", stream=True, bboxes=None, points=None, labels=None, show=False)
Iterate over results, print names, and save each result to a file
for i, result in enumerate(results): # Print the names detected in the result print(f"Result {i}: Detected Names - {result.names}")
# Save the result as an image file result.save(f"output_{i}.jpg")------------- output ---------
image 1/1 /testSAM/image.png: 1024x1024 1 0, 1 1, 1 2, 1 3, 1 4, 1 5, 1 6, 1 7, 1 8, 1 9, 1 10, 1 11, 1 12, 1 13, 1 14, 1 15, 1 16, 1 17, 1 18, 1 19, 1 20, 1 21, 1 22, 1 23, 1 24, 1 25, 1 26, 1 27, 1 28, 1 29, 1 30, 1 31, 1 32, 23758.2ms Result 0: Detected Names - {0: '0', 1: '1', 2: '2', 3: '3', 4: '4', 5: '5', 6: '6', 7: '7', 8: '8', 9: '9', 10: '10', 11: '11', 12: '12', 13: '13', 14: '14', 15: '15', 16: '16', 17: '17', 18: '18', 19: '19', 20: '20', 21: '21', 22: '22', 23: '23', 24: '24', 25: '25', 26: '26', 27: '27', 28: '28', 29: '29', 30: '30', 31: '31', 32: '32'} Speed: 20.3ms preprocess, 23758.2ms inference, 7.1ms postprocess per image at shape (1, 3, 1024, 1024)
Glenn JocherUltralyticsThank you for your feedback. Currently, SAM does not assign class names, only class numbers. If you need specific class names, you may need to implement a custom mapping or post-processing step to assign the desired class names based on your requirements.
dreambit
I have images where a single object (such as a car) is partially covered by small trees, resulting in the object being divided into multiple visible fragments. In coco it could look like { "id": 1, "image_id": 1, "category_id": 1, "bbox": [x, y, width, height], "segmentation": [ [polygon1_x1, polygon1_y1, polygon1_x2, polygon1_y2, ...], [polygon2_x1, polygon2_y1, polygon2_x2, polygon2_y2, ...] ], "area": 500, "iscrowd": 0 } Each polygon is an array of coordinates defining a closed shape
Is it possible with auto_annotate and yolo format?
Glenn JocherUltralytics(bearbeitet)@dreambit hi there!
Thank you for your detailed question. Yes, you can use the
auto_annotatefunction in the Ultralytics framework to handle images where objects are partially occluded and appear as multiple fragments. This function can generate segmentation masks for such complex scenarios.Here's how you can achieve this:
- Prepare Your Dataset: Ensure your images are organized in a directory.
- Use the
auto_annotateFunction: This function will use a pre-trained YOLO detection model and the SAM segmentation model to annotate your images.
Here's a code example to get you started:
from ultralytics.data.annotator import auto_annotate # Path to your images data_path = "path/to/your/images" # Auto-annotate using YOLO26 and SAM models auto_annotate(data=data_path, det_model="yolo26x.pt", sam_model="sam_b.pt")Explanation:
data: Path to the folder containing your images.det_model: The pre-trained YOLO detection model, which defaults toyolo26x.pt.sam_model: The pre-trained SAM segmentation model, which defaults tosam_b.pt.
This setup will generate segmentation masks for your images, even if the objects are partially occluded.
For more detailed information on using SAM and its capabilities, you can refer to the Segment Anything Model (SAM) documentation.
If you encounter any issues or need further assistance, please provide a reproducible example so we can better understand and address your specific scenario. You can find more information on creating a minimum reproducible example here.
Feel free to update to the latest versions of the packages to ensure you have the latest features and fixes.
Best of luck with your project! 🚀
dreambit
Glenn thanks, but as I see in docs https://docs.ultralytics.com/datasets/segment/#ultralytics-yolo-format ... In this format, is the index of the class for the object, and ... are the bounding coordinates of the object's segmentation mask. The coordinates are separated by spaces.
So it means that I could have only one segmentation mask?
dreambit
0 0.681 0.485 0.670 0.487 0.676 0.487 1 0.504 0.000 0.501 0.004 0.498 0.004 0.493 0.010 0.492 0.0104
dreambit
Glen, i ran the command you specified, and used an image from coco data set to test, as you can see segmentations are not correct, only half of the objects are segmented:
Here is original image from coco with car mask https://ibb.co/RjYyRdk
Glenn JocherUltralytics(bearbeitet)Hi @dreambit,
Thank you for sharing the images and details. I understand the challenge you're facing with partial segmentations. The
auto_annotatefunction should ideally handle such cases, but it seems like the segmentation results are not as expected.Steps to Troubleshoot and Improve Segmentation:
-
Verify Latest Versions: Ensure you are using the latest versions of the Ultralytics and SAM models. This can help avoid any bugs that might have been fixed in recent updates.
-
Reproducible Example: If the issue persists, providing a minimum reproducible example would be very helpful. This allows us to better understand and diagnose the problem. You can find guidance on creating a reproducible example here.
-
Adjusting Prompts: Sometimes, adjusting the prompts (bounding boxes or points) can improve segmentation results. Here’s an example of how you can use different prompts:
from ultralytics import SAM # Load a model model = SAM("sam_b.pt") # Run inference with bounding boxes prompt results = model("path/to/image.jpg", bboxes=[[x1, y1, x2, y2], [x3, y3, x4, y4]]) # Run inference with points prompt results = model("path/to/image.jpg", points=[[x1, y1], [x2, y2]], labels=[1, 1]) -
Segment Everything: If specific prompts are not yielding the desired results, you can try segmenting the entire image without prompts:
from ultralytics import SAM # Load a model model = SAM("sam_b.pt") # Segment the whole image results = model("path/to/image.jpg") -
Multiple Masks Handling: If your object is divided into multiple fragments, ensure that the segmentation model is capable of handling multiple masks per object. The YOLO format typically supports one segmentation mask per object, but you can adapt the output to handle multiple masks by combining them post-processing.
Example of Handling Multiple Masks:
If you need to combine multiple masks into a single annotation, you can do this post-processing:
# `results[0].masks.data` holds all masks of the image, shape (N, H, W) combined_mask = results[0].masks.data.cpu().numpy().max(axis=0) # Save or use the combined maskDocumentation and Resources:
For more detailed information on using SAM and its capabilities, please refer to the Segment Anything Model (SAM) documentation.
If you continue to face issues, please share a reproducible example, and we’ll be happy to assist further. Your feedback is valuable, and we aim to provide the best support possible.
-
kshweikeh
is there anyway where I can train YOLO SAM on a custom dataset?
Paula DerrengerUltralytics(bearbeitet)@kshweikeh hi there!
Currently, the Segment Anything Model (SAM) from Ultralytics is designed primarily for inference and does not support training on custom datasets. However, you can leverage SAM's powerful zero-shot capabilities for various segmentation tasks without the need for additional training.
If you're looking to create a segmentation dataset using SAM, you can use the auto-annotation feature. This allows you to generate segmentation masks using a pre-trained detection model. Here's a quick example:
from ultralytics.data.annotator import auto_annotate auto_annotate(data="path/to/images", det_model="yolo26x.pt", sam_model="sam_b.pt")This function will help you annotate your images quickly and efficiently, bypassing the need for manual labeling.
For more detailed information on using SAM, you can visit our Segment Anything Model (SAM) documentation.
If you have any further questions or need additional assistance, feel free to ask! 😊
Blessing988
@pderrenger It looks like auto_annotate for SAM only gives out the segmentation masks. What if you want to generate the bounding boxes in additionto the masks to verify if the results are right. Thanks.
Blessing988
Also, how will one visualise the segmentation masks after the auto_annotate which have been saved in a directory of txt files.
Paula DerrengerUltralytics(bearbeitet)Hi @Blessing988,
auto_annotatewrites one YOLO segmentation polygon per line (class_id x1 y1 x2 y2 ..., normalized) to its output folder (output_dir, by default<images folder>_auto_annotate_labels). Here is a script to draw those polygons on the images:from pathlib import Path import cv2 import numpy as np def visualize_annotations(image_dir, label_dir, output_dir): Path(output_dir).mkdir(parents=True, exist_ok=True) for image_path in Path(image_dir).glob("*.jpg"): image = cv2.imread(str(image_path)) h, w = image.shape[:2] label_path = Path(label_dir) / f"{image_path.stem}.txt" if not label_path.exists(): continue for line in label_path.read_text().splitlines(): values = line.split() polygon = (np.array(values[1:], dtype=float).reshape(-1, 2) * [w, h]).astype(np.int32) cv2.polylines(image, [polygon], isClosed=True, color=(0, 255, 0), thickness=2) cv2.imwrite(str(Path(output_dir) / image_path.name), image) visualize_annotations("path/to/images", "path/to/labels", "path/to/output")For more detailed information on using SAM and its features, you can refer to the Segment Anything Model (SAM) documentation.
Feel free to reach out if you have any further questions or need additional assistance! 😊
pabentse
Would be fantastic with support for the "H" size as well!
Paula DerrengerUltralytics@pabentse absolutely, the addition of an "H" size model would be a great enhancement to the range of model sizes we offer, catering to different computational needs and use cases. The YOLO community's feedback is invaluable, and suggestions like yours help guide future developments. Keep an eye on our updates! 👀🚀