Empezar

Modelo de segmentación de cualquier cosa (SAM)

Evolución de SAM

Este es el modelo SAM original de Meta. Para obtener capacidades mejoradas, consulta SAM 2 para la segmentación de vídeo o SAM 3 para la segmentación de conceptos guiada por indicaciones con texto e imágenes de ejemplo.

How to use Segment Anything In Colab

El Segment Anything Model (SAM) de Meta introdujo la segmentación de imágenes mediante indicaciones: al proporcionarle una indicación de punto, cuadro o máscara, devuelve una máscara del objeto indicado, con un decodificador ligero lo bastante rápido para su uso interactivo.

Introducción a SAM: el modelo de segmentación de cualquier cosa#

El Segment Anything Model, o SAM, es un modelo de segmentación de imágenes diseñado para segmentar mediante indicaciones en una amplia variedad de tareas de análisis de imágenes. SAM es el núcleo del proyecto Segment Anything de Meta, que introdujo un nuevo modelo, tarea y conjunto de datos para la segmentación de imágenes.

El diseño de SAM le permite adaptarse a nuevas distribuciones de imágenes y tareas sin conocimientos previos, una capacidad conocida como transferencia zero-shot. Entrenado con el conjunto de datos SA-1B, que contiene más de 1.000 millones de máscaras en 11 millones de imágenes seleccionadas, SAM muestra un sólido rendimiento zero-shot, a menudo comparable o superior al de resultados anteriores totalmente supervisados.

Ejemplo del conjunto de datos SA-1B con máscaras de segmentación automática Imágenes de ejemplo de SA-1B. Imágenes con máscaras superpuestas del conjunto de datos SA-1B. SA-1B contiene 11 millones de imágenes diversas, de alta resolución, con licencia y que protegen la privacidad, así como 1.100 millones de máscaras de segmentación de alta calidad. SAM anotó estas máscaras de forma totalmente automática y, según confirman las valoraciones humanas y numerosos experimentos, son de gran calidad y diversidad. Las imágenes se agrupan según el número de máscaras por imagen para su visualización (hay una media de ∼100 máscaras por imagen).

Características principales del Modelo de segmentación de cualquier cosa (SAM)#

  • Tarea de segmentación guiada por indicaciones: SAM se diseñó para realizar tareas de segmentación guiadas por indicaciones, lo que le permite generar máscaras de segmentación válidas a partir de cualquier indicación, como pistas espaciales o textuales que identifican un objeto.
  • Arquitectura avanzada: El Segment Anything Model utiliza un codificador de imágenes pesado, un codificador de indicaciones y un decodificador de máscaras ligero. Esta arquitectura permite introducir indicaciones de forma flexible, calcular máscaras en tiempo real y tener en cuenta la ambigüedad en las tareas de segmentación.
  • El conjunto de datos SA-1B: Presentado por el proyecto Segment Anything, el conjunto de datos SA-1B incluye más de 1.000 millones de máscaras en 11 millones de imágenes. En el momento de su publicación, era el conjunto de datos de segmentación más grande y proporciona a SAM una fuente de datos de entrenamiento diversa y a gran escala.
  • Rendimiento zero-shot: SAM muestra un sólido rendimiento zero-shot en diversas tareas de segmentación, por lo que es una herramienta lista para usar en distintas aplicaciones que apenas requiere ingeniería de indicaciones.

Para conocer en profundidad el Modelo de segmentación de cualquier cosa y el conjunto de datos SA-1B, visita el GitHub de Segment Anything y consulta el artículo de investigación Segment Anything.

SAM en la plataforma Ultralytics

Los modelos de la familia SAM (SAM 2.1, SAM 3 y SAM 3.1) impulsan la función de anotación inteligente en Ultralytics Platform, que permite crear máscaras con clics para etiquetar conjuntos de datos rápidamente.

Modelos disponibles, tareas compatibles y modos de funcionamiento#

Esta tabla muestra los modelos disponibles, sus pesos preentrenados específicos, las tareas que admiten y su compatibilidad con distintos modos de funcionamiento, como Entrenamiento, Validación, Inferencia y Exportación. Los modos admitidos se indican con ✅ y los no admitidos, con ❌.

Tipo de modeloPesos preentrenadosTareas compatiblesEntrenamientoValidaciónInferenciaExportar
SAM basesam_b.ptSegmentación de instancias❌❌✅❌
SAM grandesam_l.ptSegmentación de instancias❌❌✅❌

Cómo usar SAM: versatilidad y potencia en la segmentación de imágenes#

El Segment Anything Model puede utilizarse en muchas tareas posteriores que van más allá de sus datos de entrenamiento, como la detección de bordes, la generación de propuestas de objetos, la segmentación de instancias y la predicción preliminar de texto a máscara. Mediante la ingeniería de indicaciones, SAM puede adaptarse a nuevas tareas y distribuciones de datos de forma zero-shot.

Ejemplo de predicción de SAM#

Segmentar con indicaciones

Segmenta la imagen con las indicaciones proporcionadas.

from ultralytics import SAM

# Cargar un modelo
model = SAM("sam_b.pt")

# Mostrar información del modelo (opcional)
model.info()

# Ejecutar inferencia con una indicación de cuadros delimitadores
results = model("ultralytics/assets/zidane.jpg", bboxes=[439, 437, 524, 709])

# Ejecutar inferencia con un único punto
results = model(points=[900, 370], labels=[1])

# Ejecutar inferencia con varios puntos
results = model(points=[[400, 370], [900, 370]], labels=[1, 1])

# Ejecutar inferencia con una indicación de varios puntos por objeto
results = model(points=[[[400, 370], [900, 370]]], labels=[[1, 1]])

# Ejecutar inferencia con una indicación de puntos negativos
results = model(points=[[[400, 370], [900, 370]]], labels=[[1, 0]])
Segmentarlo todo

Segmenta toda la imagen.

from ultralytics import SAM

# Cargar un modelo
model = SAM("sam_b.pt")

# Mostrar información del modelo (opcional)
model.info()

# Ejecutar inferencia
model("path/to/image.jpg")
  • SAM segmenta toda la imagen si no se le proporciona ninguna indicación (bboxes/puntos/máscaras).
Ejemplo de SAMPredictor

Establece la imagen una sola vez y, a continuación, ejecuta la inferencia con indicaciones varias veces sin volver a ejecutar el codificador de imágenes.

import cv2

from ultralytics.models.sam import Predictor as SAMPredictor

# Crear SAMPredictor
overrides = {"conf": 0.25, "task": "segment", "mode": "predict", "imgsz": 1024, "model": "mobile_sam.pt"}
predictor = SAMPredictor(overrides=overrides)

# Configura la imagen
predictor.set_image("ultralytics/assets/zidane.jpg")  # Establecer con un archivo de imagen
predictor.set_image(cv2.imread("ultralytics/assets/zidane.jpg"))  # Establecer con np.ndarray
results = predictor(bboxes=[439, 437, 524, 709])

# Ejecutar inferencia con una indicación de un solo punto
results = predictor(points=[900, 370], labels=[1])

# Ejecutar inferencia con indicaciones de varios puntos
results = predictor(points=[[400, 370], [900, 370]], labels=[1, 1])

# Ejecutar inferencia con una indicación de puntos negativos
results = predictor(points=[[[400, 370], [900, 370]]], labels=[[1, 0]])

# Restablecer imagen
predictor.reset_image()

Segmentarlo todo con argumentos adicionales.

from ultralytics.models.sam import Predictor as SAMPredictor

# Crear SAMPredictor
overrides = {"conf": 0.25, "task": "segment", "mode": "predict", "imgsz": 1024, "model": "mobile_sam.pt"}
predictor = SAMPredictor(overrides=overrides)

# Segmentar con argumentos adicionales
results = predictor(source="ultralytics/assets/zidane.jpg", crop_n_layers=1, points_stride=64, min_mask_region_area=100)
Nota

Todos los results devueltos en los ejemplos anteriores son objetos Results que proporcionan acceso a las máscaras predichas y a la imagen de origen.

Comparación de SAM frente a YOLO#

Aquí comparamos el modelo SAM-b de Meta con modelos de segmentación de Ultralytics, incluido YOLO26:

ModeloTamaño
(MB)
Parámetros
(M)
Velocidad (CPU)
(ms/im)
SAM-b de Meta37593.741703
MobileSAM40.710.123802
FastSAM-s con backbone YOLOv823.911.858.0
Ultralytics YOLOv8n-seg7.1 (52.8x más pequeño)3.4 (27.6x menos)24.8 (1682x más rápido)
Ultralytics YOLO11n-seg6.2 (60.5x más pequeño)2.9 (32.3x menos)24.3 (1716x más rápido)
Ultralytics YOLO26n-seg6.7 (56.0x más pequeño)2.7 (34.7x menos)25.2 (1655x más rápido)

Esta comparación muestra las diferencias considerables de tamaño y velocidad entre las variantes de SAM y los modelos de segmentación YOLO. Aunque SAM ofrece capacidades únicas de segmentación automática, los modelos YOLO, en particular YOLOv8n-seg, YOLO11n-seg y YOLO26n-seg, son mucho más pequeños, rápidos y eficientes desde el punto de vista computacional.

Las velocidades de SAM se han medido con PyTorch y las de YOLO, con ONNX Runtime. Las pruebas se han realizado en un Apple M4 Air de 2025 con 16 GB de RAM usando torch==2.10.0, ultralytics==8.4.31 y onnxruntime==1.24.4. Para reproducir esta prueba:

Ejemplo
from ultralytics import ASSETS, SAM, YOLO, FastSAM

# Perfilar SAM-b, MobileSAM
for file in ["sam_b.pt", "mobile_sam.pt"]:
    model = SAM(file)
    model.info()
    model(ASSETS)

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

# Perfilar modelos 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)  # Cabezal sin NMS de YOLO26; no hace nada con YOLOv8/YOLO11
    model = YOLO(onnx_path)
    model(ASSETS)

Anotación automática: una forma rápida de crear conjuntos de datos de segmentación#

La anotación automática es una función clave de SAM que permite a los usuarios generar un conjunto de datos de segmentación mediante un modelo de detección preentrenado. Esta función permite anotar rápidamente grandes cantidades de imágenes y evita el etiquetado manual, que requiere mucho tiempo.

Genera tu conjunto de datos de segmentación con un modelo de detección#

Para anotar automáticamente tu conjunto de datos con el framework de Ultralytics, utiliza la función auto_annotate, que combina un detector como YOLO26x con SAM:

Ejemplo
from ultralytics.data.annotator import auto_annotate

auto_annotate(data="path/to/images", det_model="yolo26x.pt", sam_model="sam_b.pt")
ArgumentoTipoPredeterminadoDescripción
datastrobligatorioRuta al directorio que contiene las imágenes de destino que se van a anotar o segmentar.
det_modelstr'yolo26x.pt'Ruta al modelo de detección YOLO para la detección inicial de objetos.
sam_modelstr'sam_b.pt'Ruta al modelo SAM para la segmentación (admite los pesos de SAM, SAM 2, MobileSAM y SAM 3).
devicestr''Dispositivo de cálculo (p. ej., 'cuda:0', 'cpu' o '' para detectar automáticamente el dispositivo).
conffloat0.25Umbral de confianza de detección YOLO para filtrar las detecciones poco fiables.
ioufloat0.5Umbral de IoU para la supresión no máxima (NMS) y el filtrado de cajas superpuestas.
imgszint640Tamaño de entrada para cambiar el tamaño de las imágenes (se redondea al múltiplo de 32 más cercano por exceso si es necesario).
max_detint300Número máximo de detecciones por imagen para optimizar el uso de memoria.
classeslist[int]NoneLista de índices de clase que se van a detectar (p. ej., [0, 1] para persona y bicicleta).
output_dirstrNoneDirectorio donde se guardan las anotaciones (por defecto: directorio hermano de <data>_auto_annotate_labels).

La función auto_annotate recibe la ruta a tus imágenes y argumentos opcionales para especificar los modelos de detección y segmentación SAM preentrenados, el dispositivo en el que se ejecutarán los modelos y el directorio de salida donde se guardarán los resultados anotados.

La anotación automática con modelos preentrenados reduce considerablemente el tiempo y el esfuerzo necesarios para crear conjuntos de datos de segmentación, lo que permite a los equipos con grandes colecciones de imágenes centrarse en el desarrollo y la evaluación de modelos en lugar de en la anotación manual.

Citas y agradecimientos#

Si SAM te resulta útil en tus trabajos de investigación o desarrollo, considera citar el artículo:

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

Queremos dar las gracias a Meta AI por crear y mantener este valioso recurso para la comunidad de visión artificial.

Preguntas frecuentes#

  • El Segment Anything Model (SAM) de Meta es un modelo de segmentación de imágenes diseñado para tareas de segmentación que admiten indicaciones. Combina codificadores de imágenes e indicaciones con un decodificador de máscaras ligero para generar máscaras de segmentación a partir de indicaciones como puntos, cuadros o máscaras. Entrenado con el conjunto de datos SA-1B, SAM ofrece un buen rendimiento zero-shot y se adapta a nuevas distribuciones de imágenes y tareas sin conocimientos previos.

  • Puedes utilizar el Modelo de segmentación de cualquier cosa (SAM) para segmentar imágenes ejecutando inferencias con distintas indicaciones, como cuadros delimitadores o puntos. Aquí tienes un ejemplo con Python:

    from ultralytics import SAM
    
    # Cargar un modelo
    model = SAM("sam_b.pt")
    
    # Segmentar con un prompt de caja delimitadora
    model("ultralytics/assets/zidane.jpg", bboxes=[439, 437, 524, 709])
    
    # Segmentar con una indicación de puntos
    model("ultralytics/assets/zidane.jpg", points=[900, 370], labels=[1])
    
    # Segmentar con indicaciones de varios puntos
    model("ultralytics/assets/zidane.jpg", points=[[400, 370], [900, 370]], labels=[1, 1])
    
    # Segmentar con indicaciones de varios puntos por objeto
    model("ultralytics/assets/zidane.jpg", points=[[[400, 370], [900, 370]]], labels=[[1, 1]])
    
    # Segmentar con una indicación de puntos negativos.
    model("ultralytics/assets/zidane.jpg", points=[[[400, 370], [900, 370]]], labels=[[1, 0]])

    También puedes ejecutar inferencias con SAM desde la interfaz de línea de comandos (CLI):

    yolo predict model=sam_b.pt source=path/to/image.jpg
  • En comparación con los modelos YOLO, las variantes de SAM, como SAM-b, MobileSAM y FastSAM-s, suelen ser más grandes y lentas, pero ofrecen capacidades únicas de segmentación zero-shot. Por ejemplo, YOLO26n-seg es 56x más pequeño y más de 1650x más rápido que el modelo SAM-b original de Meta en CPU. Esto hace que los modelos YOLO sean ideales para aplicaciones que requieren una segmentación rápida, ligera y eficiente desde el punto de vista computacional, mientras que los modelos SAM destacan en tareas de segmentación flexible, guiada por indicaciones y zero-shot.

  • SAM de Ultralytics ofrece una función de anotación automática que permite generar conjuntos de datos de segmentación mediante un modelo de detección preentrenado. Aquí tienes un ejemplo en Python:

    from ultralytics.data.annotator import auto_annotate
    
    auto_annotate(data="path/to/images", det_model="yolo26x.pt", sam_model="sam_b.pt")

    Esta función recibe la ruta a tus imágenes y argumentos opcionales para los modelos de detección y segmentación SAM preentrenados, además de especificaciones del dispositivo y del directorio de salida. Consulta Anotación automática para ver la guía completa.

  • SAM se entrena con el conjunto de datos SA-1B, que contiene más de mil millones de máscaras en 11 millones de imágenes. En el momento de su lanzamiento, SA-1B era el conjunto de datos de segmentación más grande y proporcionaba datos de entrenamiento diversos y de alta calidad que sustentan el rendimiento de cero disparos de SAM en tareas de segmentación.

Comentarios27

Haz una pregunta, comparte tus resultados o ayuda a otra persona.

  1. kh-diabGitHub

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

      Yes, 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_annotate function 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!

    2. kh-diabGitHub

      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

  2. evans rojas

    Hola me gustaría usar SAM para clasificar vegetación a partir de una imagen. ¿Qué recomendaciones me sugieren?

    1. Paula DerrengerUltralytics

      Hola, 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?

  3. meenakshi71GitHub

    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.

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

  4. MeenakshiKK236GitHub

    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"

    1. Glenn JocherUltralytics

      @MeenakshiKK236 the results are saved to the runs/segment/predict4 directory by default. You can change the save directory by specifying the project and name arguments in your command. For more details, please refer to the SAM documentation.

  5. NasserAlqeifiGitHub

    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?

    1. Glenn JocherUltralytics

      @NasserAlqeifi you are correct. The auto_annotate function 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.

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

    3. NasserAlqeifiGitHub

      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)

    4. Glenn JocherUltralytics

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

  6. dreambitGitHub

    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?

    1. Glenn JocherUltralytics(editado)

      @dreambit hi there!

      Thank you for your detailed question. Yes, you can use the auto_annotate function 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:

      1. Prepare Your Dataset: Ensure your images are organized in a directory.
      2. Use the auto_annotate Function: 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 to yolo26x.pt.
      • sam_model: The pre-trained SAM segmentation model, which defaults to sam_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! 🚀

    2. dreambitGitHub

      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

    3. Glenn JocherUltralytics(editado)

      Hi @dreambit,

      Thank you for sharing the images and details. I understand the challenge you're facing with partial segmentations. The auto_annotate function should ideally handle such cases, but it seems like the segmentation results are not as expected.

      Steps to Troubleshoot and Improve Segmentation:
      1. 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.

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

      3. 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])
      4. 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")
      5. 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 mask
      Documentation 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.

    1. Paula DerrengerUltralytics(editado)

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

    2. Blessing988GitHub

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

    3. Blessing988GitHub

      Also, how will one visualise the segmentation masks after the auto_annotate which have been saved in a directory of txt files.

    4. Paula DerrengerUltralytics(editado)

      Hi @Blessing988,

      auto_annotate writes 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! 😊

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