Cómo realicé la etiquetación automática de imágenes utilizando Grounding DINO

Automatic image labeling with Grounding DINO.

Estoy emocionado(a) de compartir que los avances recientes en el campo de la visión por computadora, como la aparición de detectores de objetos sin etiquetas innovadores como Grounding DINO, han revolucionado el proceso de etiquetado de imágenes.

Como desarrollador de Machine Learning, personalmente siento que la etiquetación de imágenes es aburrida, consume mucho tiempo y es una tarea costosa. Pero gracias a los recientes avances en el ámbito de la visión por computadora, particularmente la introducción de potentes detectores de objetos sin entrenamiento como Grounding DINO, podemos automatizar la mayor parte del proceso de etiquetado de imágenes para la mayoría de los casos de uso. Podemos escribir un script de Python que hará el 95% del trabajo por nosotros. Nuestra única tarea es revisar esas anotaciones al final y posiblemente agregar o eliminar algunas cajas delimitadoras.

Antes de entrar en el autoetiquetado de imágenes, debemos saber qué es Grounding DINO y por qué lo estamos usando.

Grounding DINO puede detectar objetos dominantes con entradas de indicación dadas, como nombres de categorías o expresiones de referencia. La solución principal para la detección de objetos de conjunto abierto es introducir lenguaje a un detector de conjunto cerrado. DINO para generalización de conceptos de conjunto abierto: para fusionar efectivamente las modalidades de lenguaje y visión, dividimos conceptualmente un detector de conjunto cerrado en tres fases: columna vertebral, cuello y cabeza. Luego proponemos una solución de fusión estrecha mediante la fusión de información de lenguaje en la inicialización de la consulta del cuello y la cabeza. Grounding DINO incluye un mejorador de características, selección de consulta guiada por lenguaje y un decodificador de cross-modalidad para la fusión de cross-modalidad.

Grounding DINO logra un 52,5% de AP (Precisión Promedio) en el conjunto de datos COCO de detección de transferencia sin cero disparos, sin ningún dato de entrenamiento del conjunto de datos COCO. Después de ajustarse en el conjunto de datos COCO, alcanza un AP de 63.0. Con una media de 26.1 AP, establece un nuevo récord en el conjunto de datos de cero disparos de OdinW. También exploramos cómo aprovechar el DINO pre-entrenado mediante el entrenamiento sólo de los módulos de lenguaje y fusión. Grounding DINO de DINO converge mucho más rápido que los modelos de línea de base.

Nuestro Grounding DINO también puede colaborar con la difusión estable para la edición de imágenes, por ejemplo, podemos detectar la Montaña Verde en la imagen y generar nuevas imágenes con una indicación de texto de Montaña Roja. También puede modificar el fondo de una persona detectando primero un rostro. También podemos usar GLIGEN para controles más detallados como asignar a cada caja un objeto. Este es nuestro modelo Grounding DINO para la detección de objetos de conjunto abierto.

Bien, vamos a la parte de autoetiquetado de imágenes, y aquí estoy usando Google colab para alta potencia de computación.

Empecemos,

Asegurémonos de tener acceso a la GPU. Podemos usar el comando nvidia-smi para verificar si la GPU está conectada o no. En caso de que encuentre algún problema, navegue a Editar -> Configuración del cuaderno -> Acelerador de hardware, selecciónelo como GPU y luego haga clic en Guardar, lo que acortará mucho el tiempo que tarda el autoetiquetado en completarse.

nvidia-smi

Instalar el modelo Grounding DINO

Nuestro proyecto utilizará un diseño innovador: Grounding DINO para la detección sin entrenamiento. Primero debemos instalarlo.

!git clone https://github.com/IDEA-Research/GroundingDINO.git
%cd GroundingDINO
!git checkout -q 57535c5a79791cb76e36fdb64975271354f10251
!pip install -q -e .

El paquete de índice de Python de supervisión nos ayudará a procesar, filtrar y visualizar nuestras detecciones, así como a guardar nuestro conjunto de datos y será el pegamento que une todas las piezas de nuestra demostración. Con Grounding DINO, se instaló una versión inferior de “supervisión”. Pero para esta demostración, necesitamos las nuevas características agregadas en las iteraciones más recientes. Para instalar la versión “0.6.0”, primero desinstalamos la versión actual de “supervisión”.

!pip uninstall -y supervision
!pip install -q supervision==0.6.0

import supervision as svn
print(svn.__version__)

Descargar los pesos del modelo Grounding DINO

Necesitamos los archivos de configuración y pesos del modelo para ejecutar Grounding DINO. Ya hemos clonado el repositorio de Grounding DINO, que contiene el archivo de configuración. Por otro lado, debemos descargar el archivo de pesos. Verificamos si las rutas son precisas y si los archivos están presentes en el disco después de escribir las rutas de ambos archivos en las variables GROUNDING_DINO_CONFIG_PATH y GROUNDING_DINO_CHECKPOINT_PATH.

import os

GROUNDING_DINO_CONFIG_PATH = os.path.join("groundingdino/config/GroundingDINO_SwinT_OGC.py")
print(GROUNDING_DINO_CONFIG_PATH, "; existe:", os.path.isfile(GROUNDING_DINO_CONFIG_PATH))
!mkdir -p weights
%cd weights

!wget -q https://github.com/IDEA-Research/GroundingDINO/releases/download/v0.1.0-alpha/groundingdino_swint_ogc.pth
import os
%cd /content/GroundingDINO
GROUNDING_DINO_CHECKPOINT_PATH = os.path.join("weights/groundingdino_swint_ogc.pth")
print(GROUNDING_DINO_CHECKPOINT_PATH, "; existe:", os.path.isfile(GROUNDING_DINO_CHECKPOINT_PATH))

Suponiendo que ya ha instalado PyTorch, puede usar la siguiente línea de comando para importar torch y establecer el dispositivo a utilizar para el cálculo:

import torch

DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

Cargar modelo Grounding DINO

from groundingdino.util.inference import Model

grounding_dino_model = Model(model_config_path=GROUNDING_DINO_CONFIG_PATH, model_checkpoint_path=GROUNDING_DINO_CHECKPOINT_PATH)

Preparación del conjunto de datos

Crea una carpeta llamada data y mueve las imágenes sin etiquetar a esa carpeta.

!mkdir -p data

Anotación automática de máscara de imagen única

Antes de anotar automáticamente todo el conjunto de datos, centrémonos por un momento en una sola imagen.

SOURCE_IMAGE_PATH = "/content/GroundingDINO/data/example_image_3.png"
CLASSES = ['person','dog'] #agrega el nombre de la clase para etiquetar automáticamente
BOX_TRESHOLD = 0.35
TEXT_TRESHOLD = 0.15

Detección de objetos sin disparo con Grounding DINO

Usaremos la función enhance_class_name, que se describe a continuación, para usar algo de ingeniería de prompt para obtener una mejor detección de Grounding DINO.

from typing import List

def enhance_class_name(class_names: List[str]) -> List[str]:
   return [
       f"todos los {nombre_clase}s"
       para nombre_clase
       en class_names
   ]
import cv2
import supervision as sv

# cargar imagen
image = cv2.imread(SOURCE_IMAGE_PATH)

# detectar objetos
detections = grounding_dino_model.predict_with_classes(
   image=image,
   classes=enhance_class_name(class_names=CLASSES),
   box_threshold=BOX_TRESHOLD,
   text_threshold=TEXT_TRESHOLD
)

# anotar imagen con detecciones
box_annotator = svn.BoxAnnotator()
labels = [
   f"{CLASSES[class_id]} {confidence:0.2f}"
   para _, _, confidence, class_id, _
   en detecciones]
annotated_frame = box_annotator.annotate(scene=image.copy(), detections=detections, labels=labels)

%matplotlib inline
svn.plot_image(annotated_frame, (16, 16))

Anotación automática de máscaras de conjunto de datos completo

import os

IMAGES_DIRECTORY = "./data"
IMAGES_EXTENSIONS = ['jpg', 'jpeg', 'png']

CLASSES = ['person','dog']
BOX_TRESHOLD = 0.35
TEXT_TRESHOLD = 0.15

Extraer etiquetas de imágenes

import cv2
from tqdm.notebook import tqdm

images = {}
annotations = {}

image_paths = svn.list_files_with_extensions(
   directory=IMAGES_DIRECTORY,
   extensions=IMAGES_EXTENSIONS)

para ruta_imagen en tqdm(image_paths):
   image_name = ruta_imagen.name
   image_path = str(ruta_imagen)
   image = cv2.imread(image_path)

   detections = grounding_dino_model.predict_with_classes(
       image=image,
       classes=enhance_class_name(class_names=CLASSES),
       box_threshold=BOX_TRESHOLD,
       text_threshold=TEXT_TRESHOLD
   )
   detections = detections[detections.class_id != None]
   images[image_name] = image
   annotations[image_name] = detections

Representación de los resultados

plot_images = []
plot_titles = []

box_annotator = svn.BoxAnnotator()
mask_annotator = svn.MaskAnnotator()

for image_name, detections in annotations.items():
   image = images[image_name]
   plot_images.append(image)
   plot_titles.append(image_name)

   labels = [
       f"{CLASSES[class_id]} {confidence:0.2f}"
       for _, _, confidence, class_id, _
       in detections]
   annotated_image = mask_annotator.annotate(scene=image.copy(), detections=detections)
   annotated_image = box_annotator.annotate(scene=annotated_image, detections=detections, labels=labels)
   plot_images.append(annotated_image)
   title = " ".join(set([
       CLASSES[class_id]
       for class_id
       in detections.class_id
   ]))
   plot_titles.append(title)

svn.plot_images_grid(
   images=plot_images,
   titles=plot_titles,
   grid_size=(len(annotations), 2),
   size=(2 * 4, len(annotations) * 4)

Guardar etiquetas en Pascal VOC XML

%cd /content/GroundingDINO
!mkdir annotations
ANNOTATIONS_DIRECTORY = "/content/GroundingDINO/annotations"

MIN_IMAGE_AREA_PERCENTAGE = 0.002
MAX_IMAGE_AREA_PERCENTAGE = 0.80
APPROXIMATION_PERCENTAGE = 0.75
svn.Dataset(
   classes=CLASSES,
   images=images,
   annotations=annotations
).as_pascal_voc(
   annotations_directory_path=ANNOTATIONS_DIRECTORY,
   min_image_area_percentage=MIN_IMAGE_AREA_PERCENTAGE,
   max_image_area_percentage=MAX_IMAGE_AREA_PERCENTAGE,
   approximation_percentage=APPROXIMATION_PERCENTAGE
)

¡¡¡Gracias por leer!!!

Aquí hay un enlace para el archivo de Colab completo.

Referencia: https://arxiv.org/abs/2303.05499 & https://github.com/IDEA-Research/GroundingDINO

Parthiban M actualmente vive en Chennai (India) y trabaja en SeeWise. Es un desarrollador de ML con amplia experiencia en la comprensión de problemas y la provisión de soluciones mediante el desarrollo de modelos de ML utilizando visión por computadora, TensorFlow y aprendizaje profundo.

Falcon LLM El Nuevo Rey de los LLM de Códig...
Cómo llevar a cabo MLOps como un jefe Una g...
Entrena a tu primer agente de aprendizaje p...
Resolviendo comentarios de revisión de códi...
Barkour Evaluando la agilidad animal a nive...
Modelos fundamentales para el razonamiento ...
Aprendizaje Automático

Aprendizaje Automático

Descubre el poder del aprendizaje automático para extraer ideas y realizar predicciones a partir de los datos