Come ho eseguito l’etichettatura automatica delle immagini utilizzando il grounding DINO.

I used DINO grounding for automatic image labeling.

Sono entusiasta di condividere che i recenti progressi nel campo della visione artificiale, come l’emergere di rivoluzionari detector di oggetti zero-shot come Grounding DINO, hanno rivoluzionato il processo di etichettatura delle immagini.

Come sviluppatore di Machine Learning, personalmente ritengo che l’etichettatura delle immagini sia un compito noioso, dispendioso in termini di tempo e costoso. Ma fortunatamente, con gli sviluppi recenti nel dominio della visione artificiale, in particolare l’introduzione di potenti rilevatori di oggetti zero-shot come Grounding DINO, possiamo effettivamente automatizzare la maggior parte del processo di etichettatura delle immagini per la maggior parte dei casi d’uso. Possiamo scrivere uno script Python che farà il 95% del lavoro per noi. Il nostro unico compito è quello di rivedere quelle annotazioni alla fine e eventualmente aggiungere o rimuovere alcune bounding box.

Prima di entrare nell’Auto Image Labeling, dovremmo sapere cos’è Grounding DINO e perché lo stiamo usando.

Grounding DINO può rilevare oggetti dominanti con input di prompt dati come nomi di categoria o espressioni di riferimento. La soluzione primaria per la rilevazione degli oggetti a insieme aperto consiste nell’introduzione del linguaggio in un rilevatore a insieme chiuso. DINO per la generalizzazione del concetto a insieme aperto: per fondere efficacemente le modalità di linguaggio e visione, dividiamo concettualmente un rilevatore a insieme chiuso in tre fasi: backbone, neck e head. Proponiamo quindi una soluzione di fusione stretta mediante la fusione delle informazioni linguistiche nell’inizializzazione della query del collo e in Grounding DINO. Quest’ultimo include un miglioratore delle caratteristiche, una selezione delle query guidata dal linguaggio e un decodificatore di cross-modalità per la fusione di cross-modalità.

Grounding DINO raggiunge una percentuale AP (Average Precision) del 52,5% sul benchmark di trasferimento zero shot di rilevamento del dataset COCO, ovvero senza alcun dato di formazione dal dataset COCO. Dopo il fine-tuning sul dataset COCO, raggiunge il 63,0 AP. Con una media di 26,1 AP, stabilisce un nuovo record sul benchmark zero shot di OdinW. Esploriamo anche come sfruttare il DINO pre-addestrato addestrando solo i moduli di linguaggio e fusione. Grounding DINO da DINO converge molto più rapidamente rispetto ai modelli di base.

Il nostro Grounding DINO può anche collaborare con la diffusione stabile per la modifica delle immagini, ad esempio possiamo rilevare la Montagna Verde nell’immagine e generare nuove immagini con un prompt di testo Montagna Rossa. Inoltre, può modificare lo sfondo di una persona rilevando prima un volto. Possiamo anche utilizzare GLIGEN per controlli più dettagliati come assegnare ad ogni box un oggetto. Questo è il nostro modello Grounding DINO per la rilevazione degli oggetti a insieme aperto.

Okay, entriamo nella parte dell’etichettatura automatica delle immagini, e qui sto usando Google colab per una potenza di calcolo elevata.

Iniziamo,

Assicuriamoci di avere accesso alla GPU. Possiamo utilizzare il comando nvidia-smi per verificare se la GPU è connessa o meno. In caso di problemi, navigare su Modifica -> Impostazioni del notebook -> Acceleratore hardware, impostarlo su GPU e quindi fare clic su Salva. in questo modo si accorcerà notevolmente il tempo necessario per completare l’etichettatura automatica.

nvidia-smi

Installare il modello Grounding DINO

Il nostro progetto utilizzerà un design innovativo – Grounding DINO per la rilevazione zero-shot. Dobbiamo installarlo prima.

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

Il pacchetto di indice python supervision ci aiuterà a elaborare, filtrare e visualizzare le nostre rilevazioni e a salvare il nostro dataset e sará la colla che tiene insieme tutti i pezzi della nostra demo. Con Grounding DINO, è stato installata una versione ridotta di “supervision”. Ma per questa dimostrazione, abbiamo bisogno delle nuove funzionalità aggiunte nelle iterazioni più recenti. Per installare la versione “0.6.0”, disinstalliamo prima la versione corrente di “supervision”.

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

import supervision as svn
print(svn.__version__)

Scaricare i pesi del modello Grounding DINO

Sono necessari il file di configurazione e i pesi del modello per eseguire Grounding DINO. Abbiamo già clonato il repository di Grounding DINO, che contiene il file di configurazione. D’altra parte, dobbiamo scaricare il file dei pesi. Controlliamo se i percorsi sono corretti e che i file siano presenti su disco dopo aver scritto i percorsi di entrambi i file alle variabili GROUNDING_DINO_CONFIG_PATH e GROUNDING_DINO_CHECKPOINT_PATH.

import os

GROUNDING_DINO_CONFIG_PATH = os.path.join("groundingdino/config/GroundingDINO_SwinT_OGC.py")
print(GROUNDING_DINO_CONFIG_PATH, "; esiste:", 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, "; esiste:", os.path.isfile(GROUNDING_DINO_CHECKPOINT_PATH))

Assumendo di aver già installato PyTorch, è possibile utilizzare la seguente riga di comando per importare torch e impostare il dispositivo da utilizzare per il calcolo:

import torch

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

Caricamento del Modello 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)

Preparazione del Dataset

Crea una cartella chiamata data e sposta le immagini non etichettate in quella cartella.

!mkdir -p data

Annotazione Automatica di Maschere per Immagini Singole

Prima di annotare automaticamente l’intero dataset concentriamoci su un’immagine singola.

SOURCE_IMAGE_PATH = "/content/GroundingDINO/data/example_image_3.png"
CLASSES = ['person','dog'] #aggiungi il nome della classe da etichettare automaticamente
BOX_TRESHOLD = 0.35
TEXT_TRESHOLD = 0.15

Rilevamento Oggetti Zero-Shot con Grounding DINO

Utilizzeremo la funzione enhance_class_name, descritta di seguito, per utilizzare l’ingegneria dei prompt per ottenere una migliore rilevazione di Grounding DINO.

from typing import List

def enhance_class_name(class_names: List[str]) -> List[str]:
   return [
       f"tutti {class_name}s"
       for class_name
       in class_names
   ]
import cv2
import supervision as sv

# carica l'immagine
image = cv2.imread(SOURCE_IMAGE_PATH)

# rileva gli oggetti
detections = grounding_dino_model.predict_with_classes(
   image=image,
   classes=enhance_class_name(class_names=CLASSES),
   box_threshold=BOX_TRESHOLD,
   text_threshold=TEXT_TRESHOLD
)

# annota l'immagine con le rilevazioni
box_annotator = svn.BoxAnnotator()
labels = [
   f"{CLASSES[class_id]} {confidence:0.2f}"
   for _, _, confidence, class_id, _
   in detections]
annotated_frame = box_annotator.annotate(scene=image.copy(), detections=detections, labels=labels)

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

Annotazione Automatica di Maschere per l’Intero Dataset

import os

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

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

Estrazione di Etichette dalle Immagini

import cv2
from tqdm.notebook import tqdm

images = {}
annotations = {}

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

for image_path in tqdm(image_paths):
   image_name = image_path.name
   image_path = str(image_path)
   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

Tracciamento dei risultati

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)

Salva le etichette in formato 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
)

Grazie per aver letto !!!

Ecco il link per l’intero file di colab.

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

Parthiban M attualmente vive a Chennai (India) e lavora presso SeeWise. È uno sviluppatore di ML con ampia esperienza nella comprensione dei problemi e nella fornitura di soluzioni mediante lo sviluppo di modelli di ML utilizzando la visione artificiale, TensorFlow e il deep learning.

Un’immersione profonda nei modelli GP...
Presentiamo MPT-7B un nuovo LLM open-source
LLM Apocalypse Now La Vendetta dei Cloni Op...
Apprendimento Profondo con R
I migliori framework di AutoML da considera...
Progetto RedPajama un’iniziativa open...
Apprendimento Automatico

Apprendimento Automatico

Scopri la potenza del machine learning nell'estrazione di informazioni e nella previsione dei dati.