Il nuovo modello su vasta scala rivoluzionario di Meta AI – DINOv2 per l’estrazione delle caratteristiche dell’immagine

Meta AI's revolutionary large-scale model - DINOv2 for image feature extraction.

DINOv2 è uno dei migliori modelli DL basati su ViT auto-supervisionati per l’estrazione di caratteristiche delle immagini

Introduzione

Mete AI presenta una nuova versione del modello di estrazione di caratteristiche dell’immagine chiamato DINOv2 che estrae automaticamente le caratteristiche visive dall’immagine. Questo è un altro passo rivoluzionario nel campo dell’AI, soprattutto nel dominio della visione artificiale in termini di scalabilità dei dati e del modello.

Motivazione – Perché dovremmo preoccuparci?

DINOv2 è un modello auto-supervisionato che non richiede l’ottimizzazione fine e ha una buona performance. Inoltre, può essere utilizzato come base per molte diverse attività di visione artificiale come:

• Classificazione, classificazione a grana fine – ad esempio gatto vs cane o ad esempio identificatore di razza di cane
• Recupero immagine – ad esempio trova una borsa simile alla tua tra un gran numero di immagini su internet.
• Segmentazione semantica dell’immagine – Associa una etichetta o una categoria con ogni pixel in un’immagine.
• Comprensione video – riconosce automaticamente e interpreta vari aspetti dei video, come oggetti, azioni, eventi, scene e persino concetti di livello superiore.
• Stima della profondità monoculare – prevede se un oggetto si trova in primo piano o sullo sfondo in un’immagine.
• Clustering delle immagini – raggruppa le immagini in cluster in modo che le immagini all’interno degli stessi cluster siano simili tra loro
• Sistema di raccomandazione basato sui contenuti – consiglia elementi a un rappresentazione dell’utente basata su un’immagine.

DINOv2 completa un’altra recente ricerca sulla visione artificiale, tra cui Segment Anything. Segment Anything è un sistema di segmentazione promptable focalizzato sulla generalizzazione senza zeri a un insieme diversificato di compiti di segmentazione.

Puoi dare un’occhiata al Modello Segment Anything (SAM) nel mio post precedente.

• Deep Learning nei Sistemi di Raccomandazione Una Guida Introduttiva
• Chi sono i Citizen Data Scientist e cosa fanno?
• Sostituirà l’AI gli esseri umani?

Meta AI presenta un modello di segmentazione dell’immagine rivoluzionario addestrato su 1 miliardo di maschere

Segment Anything Model (SAM) – Il miglior modello DL per la segmentazione delle immagini

towardsdatascience.com

Metodologia

La principale contribuzione del paper può essere la seguente:

• Crea un grande e curato insieme di dati di addestramento
• Migliora l’algoritmo e l’implementazione di addestramento
• Progettazione di una pipeline di distillazione funzionale.

Crea un grande e curato insieme di dati di addestramento

I modelli di deep learning di grandi dimensioni hanno bisogno di grandi quantità di dati per l’addestramento. Ecco perché gli autori hanno creato una pipeline automatica mostrata nella figura sottostante per ottenere un insieme di dati di addestramento curato.

Hanno selezionato un insieme di immagini di partenza da una raccolta di circa 25 dataset di terze parti e il loro obiettivo era quello di aumentare queste immagini di partenza. Ecco come funziona. Hanno raccolto un gran numero di immagini non curate (circa 1,2 miliardi di immagini uniche) dal web. Dopo di che hanno creato embedding dell’immagine usando una rete auto-supervisionata ViT-H/16 pre-addestrata su ImageNet-22k. Successivamente, hanno utilizzato la similarità coseno come misura di distanza tra le immagini per filtrare le immagini duplicate al fine di ridurre la ridondanza e aumentare la diversità. Poiché le immagini duplicate sono state rimosse dal grande insieme di dati non curati, hanno quindi effettuato una fase di recupero dell’immagine, in cui sono state estratte le immagini simili alle immagini curate. Alla fine, questo approccio ha permesso loro di creare 142 milioni di immagini curate su 1,2 miliardi di database non curati di immagini.

Algoritmo di addestramento migliorato

DINOv2 utilizza un meccanismo student-teacher che è una tecnica di addestramento in cui una rete neurale più piccola, nota come studente, impara a imitare il comportamento di una rete neurale più grande o complessa, nota come insegnante. Studente e insegnante sono basati sull’architettura Vision Tranformer (ViT) [2]. Per la loss utilizzano la loss di cross-entropy per le somiglianze di funzionalità studente-insegnante. Al fine di apprendere sia le funzionalità locali che globali sull’immagine, hanno utilizzato diversi livelli di apprendimento. Per l’apprendimento globale, hanno utilizzato l’apprendimento a livello di immagine – aumento dei dati di ritaglio casuale sulla stessa immagine. Per l’apprendimento delle funzionalità locali, hanno utilizzato l’apprendimento a livello di patch – applicazione casuale di Maschera alle patch di input allo studente, ma non all’insegnante. Inoltre, hanno eseguito diverse tecniche di normalizzazione come la normalizzazione batch Sinkhorn-knop, ecc. Puoi trovare ulteriori dettagli nel paper.

Pipeline di distillazione.

Sono richiesti hardware potenti per effettuare predizioni (inferenza) utilizzando modelli di grandi dimensioni. Per superare questa limitazione, i grandi modelli vengono compressi in modelli più piccoli. La distillazione della conoscenza [5] mira a riprodurre l’output di un grande modello con un modello più piccolo minimizzando alcune distanze tra entrambi gli output per un insieme di input dati. L’algoritmo di training è basato sulla self-distillation, che rende semplice la compressione dei nostri grandi modelli in modelli più piccoli.

Risultato

Hanno valutato le prestazioni del modello su otto diverse attività di visione artificiale e confrontate con altri metodi.

Nel grafico qui sotto, i risultati dei modelli DINOv2 sono di colore blu scuro, gli altri metodi auto-supervisionati sono di colore arancione chiaro e i metodi debole-supervisionati sono evidenziati in rosa scuro. La linea tratteggiata orizzontale rappresenta il modello debole-supervisionato con le migliori prestazioni.

Come mostrano i risultati, i modelli DINOv2 migliorano drasticamente rispetto allo stato dell’arte precedente nell’apprendimento auto-supervisionato e raggiungono prestazioni comparabili alle caratteristiche debole-supervisionate.

Conclusioni

In sintesi, DINOv2 è un altro modello rivoluzionario del team Meta AI. Non richiede il fine-tuning e può essere utilizzato come spina dorsale per molti modelli di visione artificiale differenti. DINOv2 utilizza un meccanismo di auto-supervisione e può apprendere da qualsiasi collezione di immagini.

Demo DINOv2 – Classificazione di immagini dettagliate

In questa parte, cercherò di dimostrare come funziona DINOv2 in uno scenario reale. Creerò un’attività di classificazione di immagini dettagliate.

Flusso di lavoro per la classificazione:

• Scarica il dataset Food101 da PyTorch datasets.
• Estrai le caratteristiche dai dataset di training e di test utilizzando un piccolo DINOv2.
• Allena i modelli di classificazione ML (SVM, XGBoost e KNN) utilizzando le caratteristiche estratte dal dataset di training.
• Effettua una previsione sulle caratteristiche estratte dal dataset di test.
• Valuta l’accuratezza e l’F1score di ciascun modello ML.

Dati : Food 101 è un set di dati sfidante di 101 categorie alimentari con 101.000 immagini. Per ogni classe, sono fornite anche 250 immagini di prova esaminate manualmente e 750 immagini di training.

Modello : piccolo modello DINOv2 (ViT-S/14 distillato)

Modelli di ML : SVM, XGBoost, KNN.

Passaggio 1 – Configurazione (È possibile utilizzare Google Colab per eseguire il codice e attivare la GPU)

import torchimport numpy as npimport torchvisionfrom torchvision import transformsfrom torch.utils.data import Subset, DataLoaderimport matplotlib.pyplot as pltimport timeimport osimport randomfrom tqdm import tqdmfrom xgboost import XGBClassifierfrom sklearn.svm import SVCfrom sklearn.neighbors import KNeighborsClassifierfrom sklearn.metrics import accuracy_score, f1_scoreimport pandas as pddef set_seed(no):    torch.manual_seed(no)    random.seed(no)    np.random.seed(no)    os.environ['PYTHONHASHSEED'] = str()    torch.backends.cudnn.benchmark = False    torch.backends.cudnn.deterministic = Trueset_seed(100)

Passaggio 2 – Creazione della trasformazione, download e creazione dei dataset Pytorch Food101, creazione degli oggetti dataloader di training e test.

batch_size = 8transformation = transforms.Compose([        transforms.Resize(256),        transforms.CenterCrop(224),        transforms.ToTensor(),        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])    ])trainset = torchvision.datasets.Food101(root='./data', split='train',                                        download=True, transform=transformation)testset = torchvision.datasets.Food101(root='./data', split='test',                                       download=True, transform=transformation)# train_indices = random.sample(range(len(trainset)), 20000)# test_indices = random.sample(range(len(testset)), 5000)# trainset = Subset(trainset, train_indices)# testset  = Subset(testset, test_indices)trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,                                          shuffle=True)testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,                                         shuffle=False)classes = trainset.classesprint(len(trainset), len(testset))print(len(trainloader), len(testloader))

[out] 75750 25250

[out] 9469 3157

Passaggio 3 (Opzionale) — Visualizza il batch del dataloader di training

# Ottieni un batch di immaginidataiter = iter(trainloader)immagini, label = next(dataiter)# Plotta le immaginifig, axes = plt.subplots(1, len(immagini),figsize=(12,12))for i, ax in enumerate(axes):    # Converti l'immagine tensor in formato numpy    immagine = immagini[i].numpy()    immagine = immagine.transpose((1, 2, 0))  # Trasponi in (altezza, larghezza, canali)    # Normalizza l'immagine    media = [0.485, 0.456, 0.406]    std = [0.229, 0.224, 0.225]    immagine_normalizzata = (immagine * std) + media    # Mostra l'immagine    ax.imshow(immagine_normalizzata)    ax.axis('off')    ax.set_title(f'Label: {label[i]}')# Mostra il graficoplt.show()

Passaggio 4 — Carica il modello DINOv2 ridotto e estrai le caratteristiche dai dataloader di training e di test.

dispositivo = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")dinov2_vits14 = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14').to(dispositivo)#trainingtrain_embeddings = []train_labels = []dinov2_vits14.eval()with torch.no_grad():  for data, labels in tqdm(trainloader):    batch_caratteristiche_immagini = dinov2_vits14(data.to(dispositivo))    train_embeddings.append(batch_caratteristiche_immagini.detach().cpu().numpy())    train_labels.append(labels.detach().cpu().numpy())#testingtest_embeddings = []test_labels = []dinov2_vits14.eval()with torch.no_grad():  for data, labels in tqdm(testloader):    batch_caratteristiche_immagini = dinov2_vits14(data.to(dispositivo))    test_embeddings.append(batch_caratteristiche_immagini.detach().cpu().numpy())    test_labels.append(labels.detach().cpu().numpy())#concatenate risultatitrain_embeddings_f = np.vstack(train_embeddings)train_labels_f = np.concatenate(train_labels).flatten()test_embeddings_f = np.vstack(test_embeddings)test_labels_f = np.concatenate(test_labels).flatten()train_embeddings_f.shape, train_labels_f.shape, test_embeddings_f.shape, test_labels_f.shape

[out] ((75750, 384), (75750,), (25250, 384), (25250,))

Passaggio 5 — Crea una funzione per i classificatori SVM, XGBoost e KNN.

def valuta_classificatori(X_train, y_train, X_test, y_test):    # Support Vector Machine (SVM)    svm_classifier = SVC()    svm_classifier.fit(X_train, y_train)    svm_predictions = svm_classifier.predict(X_test)    # Classificatore XGBoost    xgb_classifier = XGBClassifier(tree_method='gpu_hist')    xgb_classifier.fit(X_train, y_train)    xgb_predictions = xgb_classifier.predict(X_test)    # Classificatore K-Nearest Neighbors (KNN)    knn_classifier = KNeighborsClassifier()    knn_classifier.fit(X_train, y_train)    knn_predictions = knn_classifier.predict(X_test)    # Calcolo Top-1    top1_svm = accuracy_score(y_test, svm_predictions)    top1_xgb = accuracy_score(y_test, xgb_predictions)    top1_knn = accuracy_score(y_test, knn_predictions)    # Calcolo F1 Score    f1_svm = f1_score(y_test, svm_predictions, average='weighted')    f1_xgb = f1_score(y_test, xgb_predictions, average='weighted')    f1_knn = f1_score(y_test, knn_predictions, average='weighted')    return pd.DataFrame({        'SVM': {'Top-1 Accuracy': top1_svm, 'F1 Score': f1_svm},        'XGBoost': {'Top-1 Accuracy': top1_xgb,'F1 Score': f1_xgb},        'KNN': {'Top-1 Accuracy': top1_knn, 'F1 Score': f1_knn}    })X_train = train_embeddings_f  # Caratteristiche dei dati di trainingy_train = train_labels_f  # Etichette dei dati di trainingX_test = test_embeddings_f   # Caratteristiche dei dati di testy_test = test_labels_f   # Etichette dei dati di testrisultati = valuta_classificatori(X_train, y_train, X_test, y_test)print(risultati)

Risultati

Wow, i risultati sono fantastici! Come dimostrato, il modello SVM addestrato sulle caratteristiche estratte dal modello DINOv2 piccolo ha superato gli altri modelli di apprendimento automatico e ha raggiunto quasi il 90% di accuratezza.

Conclusione

Anche se abbiamo usato il modello DINOv2 piccolo per estrarre le caratteristiche, i modelli di apprendimento automatico (in particolare SVM) addestrati sulle caratteristiche estratte hanno dimostrato ottime prestazioni nel compito di classificazione dettagliata. Il modello può classificare oggetti con quasi il 90% di accuratezza su 101 diverse classi.

L’accuratezza migliorerebbe se venissero utilizzati i modelli DINOv2 grandi o giganti. È sufficiente cambiare dinov2_vits14 nella fase 4 con dinov2_vitb14, dinov2_vitl14 o dinov2_vitg14. Puoi provare e sentiti libero di condividere il risultato di accuratezza nella sezione commenti 🙂

Spero che tu abbia apprezzato l’articolo. Se hai domande o vuoi condividere i tuoi pensieri su questo articolo, sentiti libero di commentare, sarò felice di rispondere.

Se vuoi supportare il mio lavoro direttamente e ottenere accesso illimitato agli articoli di Nisoo, diventa un membro di Nisoo utilizzando il mio link di riferimento qui. Grazie un milione di volte e buona giornata!

Unisciti a Nisoo con il mio link di riferimento – Gurami Keretchashvili

Come membro di Nisoo, una parte della tua quota di iscrizione va agli scrittori che leggi e hai accesso completo a ogni storia…

Nisoo.com

Riferimenti

[1] Oquab, M., Darcet, T., Moutakanni, T., Vo, H., Szafraniec, M., Khalidov, V., … & Bojanowski, P. (2023). Dinov2: Learning robust visual features without supervision. arXiv preprint arXiv:2304.07193 .

[2] Dosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn, D., Zhai, X., Unterthiner, T., … & Houlsby, N. (2020). An image is worth 16×16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929 .ISO 690

[3] Il team di DINOv2, DINOv2: modelli di visione artificiale all’avanguardia con apprendimento auto-supervisionato

[4] DINOv2 Github

[5] Hinton, G., Vinyals, O., & Dean, J. (2015). Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531 .