Modèle de segmentation universelle (SAM)
Le Segment Anything Model (SAM) de Meta a introduit la segmentation d’image guidée par des prompts : à partir d’un prompt sous forme de point, de boîte ou de masque, le modèle renvoie le masque de l’objet indiqué, grâce à un décodeur léger suffisamment rapide pour une utilisation interactive.
Présentation de SAM : le modèle de segmentation universelle#
Le Segment Anything Model, ou SAM, est un modèle de segmentation d’image conçu pour effectuer une segmentation guidée par des prompts dans un large éventail de tâches d’analyse d’images. SAM est au cœur du projet Segment Anything de Meta, qui a introduit un nouveau modèle, une nouvelle tâche et un nouveau jeu de données pour la segmentation d’images.
La conception de SAM lui permet de s’adapter à de nouvelles distributions d’images et à de nouvelles tâches sans connaissances préalables, une capacité appelée transfert zero-shot. Entraîné sur le jeu de données SA-1B, qui contient plus d’un milliard de masques répartis sur 11 millions d’images sélectionnées, SAM affiche de solides performances en zero-shot, souvent comparables ou supérieures aux résultats précédents obtenus en supervision complète.
Exemples d’images SA-1B. Images du jeu de données SA-1B avec des masques superposés. SA-1B contient 11 millions d’images variées, haute résolution, sous licence et respectueuses de la vie privée, ainsi que 1,1 milliard de masques de segmentation de haute qualité. SAM a entièrement annoté ces masques automatiquement et, comme le confirment les évaluations humaines et de nombreuses expériences, ils sont de grande qualité et variés. Pour la visualisation, les images sont regroupées selon le nombre de masques par image (en moyenne, il y a ∼100 masques par image).
Principales fonctionnalités du modèle de segmentation universelle (SAM)#
- Tâche de segmentation guidée par des invites : SAM a été conçu pour effectuer des tâches de segmentation guidées par des invites. Il peut ainsi générer des masques de segmentation valides à partir de n’importe quelle invite, comme des indices spatiaux ou textuels permettant d’identifier un objet.
- Architecture avancée : le Segment Anything Model utilise un encodeur d’image de grande taille, un encodeur de prompts et un décodeur de masques léger. Cette architecture permet de formuler des prompts de manière flexible, de calculer des masques en temps réel et de prendre en compte les ambiguïtés dans les tâches de segmentation.
- Le jeu de données SA-1B : introduit par le projet Segment Anything, le jeu de données SA-1B contient plus d’un milliard de masques sur 11 millions d’images. Plus grand jeu de données de segmentation à sa sortie, il fournit à SAM une source de données d’entraînement variée et à grande échelle.
- Performances en zero-shot : SAM affiche de solides performances en zero-shot sur diverses tâches de segmentation, ce qui en fait un outil prêt à l’emploi pour de nombreuses applications, avec un recours limité à l’ingénierie de prompts.
Pour en savoir plus sur le modèle de segmentation universelle et le jeu de données SA-1B, consulte le dépôt GitHub Segment Anything et l’article de recherche Segment Anything.
Les modèles de la famille SAM (SAM 2.1, SAM 3 et SAM 3.1) alimentent la fonctionnalité d’annotation intelligente sur Ultralytics Platform, qui permet de créer rapidement des masques pour annoter des jeux de données en cliquant sur les images.
Modèles disponibles, tâches prises en charge et modes de fonctionnement#
Ce tableau présente les modèles disponibles, leurs poids préentraînés spécifiques, les tâches qu’ils prennent en charge et leur compatibilité avec différents modes d’utilisation, comme l’entraînement, la validation, l’inférence et l’export. Les modes pris en charge sont indiqués par ✅ et les modes non pris en charge par ❌.
| Type de modèle | Poids préentraînés | Tâches prises en charge | Entraînement | Validation | Inférence | Export |
|---|---|---|---|---|---|---|
| SAM base | sam_b.pt | Segmentation d'instances | ❌ | ❌ | ✅ | ❌ |
| SAM large | sam_l.pt | Segmentation d'instances | ❌ | ❌ | ✅ | ❌ |
Comment utiliser SAM : polyvalence et puissance pour la segmentation d’images#
Le Segment Anything Model peut être utilisé pour de nombreuses tâches en aval qui dépassent les données d’entraînement, notamment la détection des contours, la génération de propositions d’objets, la segmentation d’instances et la prédiction préliminaire de masques à partir de texte. Grâce à l’ingénierie de prompts, SAM peut s’adapter à de nouvelles tâches et distributions de données en zero-shot.
Exemple de prédiction avec SAM#
Segmenter une image à l’aide des invites fournies.
from ultralytics import SAM
# Charger un modèle
model = SAM("sam_b.pt")
# Afficher les informations du modèle (facultatif)
model.info()
# Exécuter l’inférence avec des bboxes comme invite
results = model("ultralytics/assets/zidane.jpg", bboxes=[439, 437, 524, 709])
# Exécuter l’inférence avec un seul point
results = model(points=[900, 370], labels=[1])
# Exécuter l’inférence avec plusieurs points
results = model(points=[[400, 370], [900, 370]], labels=[1, 1])
# Exécuter l’inférence avec une invite à plusieurs points par objet
results = model(points=[[[400, 370], [900, 370]]], labels=[[1, 1]])
# Exécuter l’inférence avec une invite de points négatifs
results = model(points=[[[400, 370], [900, 370]]], labels=[[1, 0]])Segmenter l’image entière.
from ultralytics import SAM
# Charger un modèle
model = SAM("sam_b.pt")
# Afficher les informations du modèle (facultatif)
model.info()
# Exécuter l’inférence
model("path/to/image.jpg")- SAM segmente l’image entière si tu ne fournis aucun prompt (bboxes/points/masques).
Définis l’image une seule fois, puis exécute l’inférence avec plusieurs prompts sans relancer l’encodeur d’image.
import cv2
from ultralytics.models.sam import Predictor as SAMPredictor
# Créer SAMPredictor
overrides = {"conf": 0.25, "task": "segment", "mode": "predict", "imgsz": 1024, "model": "mobile_sam.pt"}
predictor = SAMPredictor(overrides=overrides)
# Définir l’image
predictor.set_image("ultralytics/assets/zidane.jpg") # Définir le fichier image
predictor.set_image(cv2.imread("ultralytics/assets/zidane.jpg")) # Définir avec np.ndarray
results = predictor(bboxes=[439, 437, 524, 709])
# Exécuter l’inférence avec une invite à un seul point
results = predictor(points=[900, 370], labels=[1])
# Exécuter l’inférence avec une invite à plusieurs points
results = predictor(points=[[400, 370], [900, 370]], labels=[1, 1])
# Exécuter l’inférence avec une invite de points négatifs
results = predictor(points=[[[400, 370], [900, 370]]], labels=[[1, 0]])
# Réinitialiser l’image
predictor.reset_image()Tout segmenter avec des arguments supplémentaires.
from ultralytics.models.sam import Predictor as SAMPredictor
# Créer SAMPredictor
overrides = {"conf": 0.25, "task": "segment", "mode": "predict", "imgsz": 1024, "model": "mobile_sam.pt"}
predictor = SAMPredictor(overrides=overrides)
# Segmenter avec des arguments supplémentaires
results = predictor(source="ultralytics/assets/zidane.jpg", crop_n_layers=1, points_stride=64, min_mask_region_area=100)Tous les objets results renvoyés dans les exemples ci-dessus sont des objets Results qui donnent accès aux masques prédits et à l’image source.
- Pour en savoir plus sur les arguments
Segment everything, consulte la référencePredictor/generate.
Comparaison de SAM et YOLO#
Nous comparons ici le modèle SAM-b de Meta aux modèles de segmentation d’Ultralytics, notamment YOLO26 :
| Modèle | Taille (MB) | Paramètres (M) | Vitesse (CPU) (ms/im) |
|---|---|---|---|
| Meta SAM-b | 375 | 93.7 | 41703 |
| MobileSAM | 40.7 | 10.1 | 23802 |
| FastSAM-s avec le réseau de base YOLOv8 | 23.9 | 11.8 | 58.0 |
| Ultralytics YOLOv8n-seg | 7.1 (52.8x plus petit) | 3.4 (27.6x de moins) | 24.8 (1682x plus rapide) |
| Ultralytics YOLO11n-seg | 6.2 (60.5x plus petit) | 2.9 (32.3x de moins) | 24.3 (1716x plus rapide) |
| Ultralytics YOLO26n-seg | 6.7 (56.0x plus petit) | 2.7 (34.7x de moins) | 25.2 (1655x plus rapide) |
Cette comparaison met en évidence les différences considérables de taille et de vitesse entre les variantes de SAM et les modèles de segmentation YOLO. SAM offre des capacités uniques de segmentation automatique, mais les modèles YOLO, en particulier YOLOv8n-seg, YOLO11n-seg et YOLO26n-seg, sont nettement plus petits, plus rapides et plus efficaces sur le plan des calculs.
Les vitesses de SAM ont été mesurées avec PyTorch, et celles de YOLO avec ONNX Runtime. Les tests ont été réalisés sur un Apple M4 Air de 2025 doté de 16 Go de RAM, avec torch==2.10.0, ultralytics==8.4.31 et onnxruntime==1.24.4. Pour reproduire ce test :
from ultralytics import ASSETS, SAM, YOLO, FastSAM
# Évaluer SAM-b et MobileSAM
for file in ["sam_b.pt", "mobile_sam.pt"]:
model = SAM(file)
model.info()
model(ASSETS)
# Profiler FastSAM-s
model = FastSAM("FastSAM-s.pt")
model.info()
model(ASSETS)
# Profiler les modèles 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) # Tête sans NMS de YOLO26 ; sans effet pour YOLOv8/YOLO11
model = YOLO(onnx_path)
model(ASSETS)Annotation automatique : une méthode rapide pour créer des jeux de données de segmentation#
L’annotation automatique est une fonctionnalité clé de SAM qui permet aux utilisateurs de générer un jeu de données de segmentation à l’aide d’un modèle de détection préentraîné. Cette fonctionnalité permet d’annoter rapidement un grand nombre d’images, sans passer par un étiquetage manuel fastidieux.
Générer un jeu de données de segmentation à l’aide d’un modèle de détection#
Pour annoter automatiquement ton jeu de données avec le framework Ultralytics, utilise la fonction auto_annotate, qui associe un détecteur comme YOLO26x à SAM :
from ultralytics.data.annotator import auto_annotate
auto_annotate(data="path/to/images", det_model="yolo26x.pt", sam_model="sam_b.pt")| Argument | Type | Valeur par défaut | Description |
|---|---|---|---|
data | str | obligatoire | Chemin vers le répertoire contenant les images à annoter ou à segmenter. |
det_model | str | 'yolo26x.pt' | Chemin vers le modèle de détection YOLO pour la détection initiale des objets. |
sam_model | str | 'sam_b.pt' | Chemin vers le modèle SAM pour la segmentation (prend en charge les poids SAM, SAM 2, MobileSAM et SAM 3). |
device | str | '' | Périphérique de calcul (par exemple, 'cuda:0', 'cpu' ou '' pour la détection automatique du périphérique). |
conf | float | 0.25 | Seuil de confiance de détection YOLO pour filtrer les détections peu fiables. |
iou | float | 0.5 | Seuil IoU pour la suppression non maximale afin de filtrer les boîtes qui se chevauchent. |
imgsz | int | 640 | Taille d’entrée pour le redimensionnement des images (arrondie au multiple de 32 supérieur si nécessaire). |
max_det | int | 300 | Nombre maximal de détections par image pour limiter l’utilisation de la mémoire. |
classes | list[int] | None | Liste des indices de classes à détecter (par exemple, [0, 1] pour personne et vélo). |
output_dir | str | None | Répertoire d’enregistrement des annotations (par défaut : répertoire frère de <data>_auto_annotate_labels). |
La fonction auto_annotate prend le chemin d’accès à tes images et accepte des arguments facultatifs pour spécifier les modèles de détection et de segmentation SAM préentraînés, l’appareil sur lequel exécuter les modèles et le répertoire de sortie où enregistrer les résultats annotés.
L’annotation automatique à l’aide de modèles préentraînés réduit considérablement le temps et les efforts nécessaires à la création de jeux de données de segmentation. Les équipes disposant de grandes collections d’images peuvent ainsi se concentrer sur le développement et l’évaluation des modèles plutôt que sur l’annotation manuelle.
Citations et remerciements#
Si SAM t’est utile dans tes travaux de recherche ou de développement, pense à citer l’article :
@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}
}Nous remercions Meta AI d’avoir créé et maintenu cette ressource précieuse pour la communauté de la vision par ordinateur.
FAQ#
Le Segment Anything Model (SAM) de Meta est un modèle de segmentation d’images conçu pour les tâches de segmentation guidée par des prompts. Il associe des encodeurs d’image et de prompts à un décodeur de masques léger afin de générer des masques de segmentation à partir de prompts tels que des points, des boîtes ou des masques. Entraîné sur le jeu de données SA-1B, SAM est performant en zero-shot et s’adapte à de nouvelles distributions d’images et à de nouvelles tâches sans connaissances préalables.
Tu peux utiliser le modèle de segmentation universelle (SAM) pour segmenter des images en exécutant une inférence avec différentes invites, comme des boîtes englobantes ou des points. Voici un exemple avec Python :
from ultralytics import SAM # Charger un modèle model = SAM("sam_b.pt") # Segmenter à l’aide d’une invite de boîte englobante model("ultralytics/assets/zidane.jpg", bboxes=[439, 437, 524, 709]) # Segmenter avec une invite de points model("ultralytics/assets/zidane.jpg", points=[900, 370], labels=[1]) # Segmenter avec une invite à plusieurs points model("ultralytics/assets/zidane.jpg", points=[[400, 370], [900, 370]], labels=[1, 1]) # Segmenter avec une invite à plusieurs points par objet model("ultralytics/assets/zidane.jpg", points=[[[400, 370], [900, 370]]], labels=[[1, 1]]) # Segmenter avec une invite de points négatifs. model("ultralytics/assets/zidane.jpg", points=[[[400, 370], [900, 370]]], labels=[[1, 0]])Tu peux aussi exécuter l’inférence avec SAM depuis l’interface en ligne de commande (CLI) :
yolo predict model=sam_b.pt source=path/to/image.jpgComparées aux modèles YOLO, les variantes de SAM telles que SAM-b, MobileSAM et FastSAM-s sont généralement plus volumineuses et plus lentes, mais offrent des capacités uniques de segmentation zero-shot. Par exemple, YOLO26n-seg est 56x plus petit et plus de 1650x plus rapide que le modèle SAM-b original de Meta sur CPU. Les modèles YOLO sont donc idéaux pour les applications qui nécessitent une segmentation rapide, légère et efficace en calcul, tandis que les modèles SAM excellent dans les tâches de segmentation flexible, guidée par des invites et zero-shot.
SAM d’Ultralytics propose une fonctionnalité d’annotation automatique qui permet de générer des jeux de données de segmentation à l’aide d’un modèle de détection préentraîné. Voici un exemple avec Python :
from ultralytics.data.annotator import auto_annotate auto_annotate(data="path/to/images", det_model="yolo26x.pt", sam_model="sam_b.pt")Cette fonction prend le chemin d’accès à tes images et accepte des arguments facultatifs pour les modèles de détection et de segmentation SAM préentraînés, ainsi que pour spécifier l’appareil et le répertoire de sortie. Pour consulter le guide complet, voir Annotation automatique.
SAM est entraîné sur le jeu de données SA-1B, qui comprend plus d’un milliard de masques répartis sur 11 millions d’images. À sa sortie, SA-1B était le plus grand jeu de données de segmentation. Il fournit des données d’entraînement de haute qualité et diversifiées, qui soutiennent les performances zero-shot de SAM dans les tâches de segmentation.
Commentaires27
Pose une question, partage tes résultats ou aide quelqu’un d’autre.
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(modifié)@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(modifié)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(modifié)@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(modifié)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! 👀🚀