Sbloccare il potere dell’apprendimento a pochi scatti

Sbloccare apprendimento rapido

Introduzione

Benvenuti nel mondo dell’apprendimento a poche istanze, dove le macchine sfidano le probabilità dei dati e imparano a conquistare compiti con solo qualche esempio etichettato. In questa guida, intraprenderemo un emozionante viaggio nel cuore dell’apprendimento a poche istanze. Esploreremo come questi algoritmi intelligenti raggiungano l’eccellenza con pochi dati, aprendo nuove possibilità nell’intelligenza artificiale.

Obiettivi di apprendimento

Prima di immergerci nei dettagli tecnici, delineiamo gli obiettivi di apprendimento di questa guida:

Comprendere il concetto, come si differenzia dall’apprendimento automatico tradizionale e l’importanza di questo approccio in scenari con pochi dati
Esplorare varie metodologie e algoritmi utilizzati nell’apprendimento a poche istanze, come i metodi basati sulla metrica, gli approcci basati sul modello e i loro principi sottostanti.
Come applicare tecniche di apprendimento a poche istanze in scenari diversi? Comprendere le migliori pratiche per l’addestramento ed la valutazione efficace dei modelli di apprendimento a poche istanze.
Scoprire applicazioni reali dell’apprendimento a poche istanze.
Comprendere i vantaggi e le limitazioni dell’apprendimento a poche istanze.

Ora, immergiamoci in ogni sezione della guida e comprendiamo come raggiungere questi obiettivi.

Questo articolo è stato pubblicato come parte del Data Science Blogathon.

Cos’è l’apprendimento a poche istanze?

L’apprendimento a poche istanze è un sottoinsieme dell’apprendimento automatico che affronta la sfida di addestrare modelli per riconoscere e generalizzare a partire da un numero limitato di esempi etichettati per classe o compito. L’apprendimento a poche istanze sfida la tradizionale idea di modelli avidi di dati. Invece di fare affidamento su dataset massicci, l’apprendimento a poche istanze consente agli algoritmi di apprendere solo da un pugno di campioni etichettati. Questa capacità di generalizzare da dati scarsamente disponibili apre possibilità notevoli in scenari in cui acquisire estesi dataset etichettati è impraticabile o costoso.

Immaginate un modello che possa rapidamente comprendere nuovi concetti, riconoscere oggetti, comprendere linguaggi complessi o fare previsioni accurate anche con esempi di addestramento limitati. L’apprendimento a poche istanze permette alle macchine di fare proprio questo, trasformando il nostro approccio a diverse sfide in diversi ambiti. L’obiettivo principale dell’apprendimento a poche istanze è sviluppare algoritmi e tecniche in grado di apprendere da dati scarsi e generalizzare bene a nuove istanze non viste. Spesso implica l’utilizzo della conoscenza precedente o l’utilizzo di informazioni da compiti correlati per generalizzare efficientemente a nuovi compiti.

Principali differenze rispetto all’apprendimento automatico tradizionale

Tipicamente, i modelli di apprendimento automatico tradizionali richiedono molti dati etichettati per l’addestramento. Le prestazioni di questi modelli tendono a migliorare all’aumentare del volume dei dati. Nell’apprendimento automatico tradizionale, la scarsità dei dati può essere una sfida significativa, specialmente in domini specializzati o quando l’acquisizione di dati etichettati è costosa e richiede tempo. I modelli di apprendimento a poche istanze apprendono efficacemente con solo alcuni esempi per classe o compito. Questi modelli possono fare previsioni accurate anche quando addestrati con solo pochi o un singolo esempio etichettato per classe. Risolvono il problema della scarsità dei dati addestrando modelli per imparare efficacemente con pochi dati etichettati. Si adattano rapidamente a nuove classi o compiti con pochi aggiornamenti o adattamenti.

Terminologie dell’apprendimento a poche istanze

Nel campo dell’apprendimento a poche istanze, diverse terminologie e concetti descrivono diversi aspetti del processo di apprendimento e degli algoritmi. Alcune delle principali terminologie comuni nell’apprendimento a poche istanze sono:

Insieme di supporto: L’insieme di supporto è un sottoinsieme del dataset nei compiti di apprendimento a poche istanze. Contiene un numero limitato di esempi etichettati (immagini, campioni di testo, ecc.) per ogni classe nel dataset. Lo scopo dell’insieme di supporto è fornire al modello informazioni rilevanti ed esempi per imparare e generalizzare sulle classi durante la fase di meta-addestramento.
Insieme di query: L’insieme di query è un altro sottoinsieme del dataset nei compiti di apprendimento a poche istanze. È composto da esempi non etichettati (immagini, campioni di testo, ecc.) che devono essere classificati in una delle classi presenti nell’insieme di supporto. Dopo l’addestramento sull’insieme di supporto, viene valutata la capacità del modello di classificare correttamente gli esempi dell’insieme di query.
N-Way K-Shot: Nell’apprendimento a poche istanze, “n-way k-shot” è una notazione standard per descrivere il numero di classi (n) e il numero di esempi di supporto per classe (k) in ogni episodio o compito di apprendimento a poche istanze. Ad esempio, “5-way 1-shot” significa che ogni episodio contiene cinque classi e al modello viene fornito solo un esempio di supporto per classe. Allo stesso modo, “5-way 5-shot” significa che ogni episodio contiene cinque classi e al modello vengono forniti cinque esempi di supporto per classe.

Tecniche di Apprendimento a Pochi Esempi

Approcci Basati su Metriche

Reti Siamesi: Le reti Siamesi imparano a calcolare embedding (rappresentazioni) per i campioni di input e poi utilizzano metriche di distanza per confrontare gli embedding per una classificazione basata sulla similarità. Confronta e misura la similarità tra due input ed è particolarmente utile quando esistono esempi per ogni classe. Nel contesto dell’apprendimento a pochi esempi, si utilizzano le reti Siamesi per imparare una metrica di similarità tra gli esempi del set di supporto e gli esempi del set di query. Il set di supporto è composto da esempi etichettati (ad esempio, uno o pochi esempi per classe), mentre il set di query contiene esempi non etichettati che devono essere classificati in una delle classi presenti nel set di supporto.
Reti Prototipiche: Sono un approccio popolare ed efficace nei compiti di apprendimento a pochi esempi. Le reti prototipiche utilizzano l’idea di “prototipi” per ogni classe, che sono le medie degli embedding dei pochi esempi. Il campione di query confronta i prototipi durante l’infereza per determinare la sua classe. L’idea chiave è rappresentare ogni classe calcolando un vettore prototipo come media degli embedding delle sue istanze nel set di supporto. Durante l’infereza, un esempio di query viene classificato in base alla sua vicinanza ai prototipi delle diverse classi. Sono efficienti dal punto di vista computazionale e non richiedono strategie complesse di meta-apprendimento, rendendoli una scelta popolare per implementazioni pratiche in vari domini, tra cui visione artificiale e elaborazione del linguaggio naturale.

Approcci Basati sul Modello

Reti con Memoria-Aumentata: Le reti con memoria-aumentata (MANNs) utilizzano una memoria esterna per memorizzare informazioni provenienti da esempi di apprendimento a pochi esempi. Utilizzano meccanismi di attenzione per recuperare informazioni rilevanti durante la classificazione. Le MANNs mirano a superare i limiti delle reti neurali standard, che spesso faticano con compiti che richiedono ampie informazioni di contesto o dipendenze a lungo raggio. L’idea chiave dietro le MANNs è dotare il modello di un modulo di memoria che può leggere e scrivere informazioni, consentendo di memorizzare informazioni rilevanti durante l’addestramento e utilizzarle durante l’infereza. Questa memoria esterna è una risorsa aggiuntiva a cui il modello può accedere e aggiornare per facilitare il ragionamento e la presa di decisioni.
Meta-Apprendimento (Apprendimento per Apprendere): Il meta-apprendimento mira a migliorare l’apprendimento a pochi esempi addestrando i modelli ad adattarsi rapidamente a nuovi compiti sulla base di una fase di meta-addestramento con vari compiti. L’idea centrale dietro il meta-apprendimento è consentire ai modelli di estrarre conoscenza dalle esperienze precedenti (meta-addestramento) e utilizzare quella conoscenza per adattarsi rapidamente a nuovi compiti o compiti non visti in precedenza (meta-test). Il meta-apprendimento affronta queste sfide introducendo il concetto di “meta-conoscenza” o “conoscenza precedente” che guida il processo di apprendimento del modello.
Meta-Apprendimento Basato sui Gradienti (ad esempio, MAML): Il meta-apprendimento basato sui gradienti modifica i parametri del modello per facilitare un adattamento più rapido a nuovi compiti durante il meta-test. L’obiettivo principale di MAML è consentire ai modelli di adattarsi rapidamente a nuovi compiti con solo pochi esempi, un tema centrale negli scenari di apprendimento a pochi esempi e di meta-apprendimento.

Applicazioni dell’Apprendimento a Pochi Esempi

L’apprendimento a pochi esempi ha numerose applicazioni pratiche in vari settori. Ecco alcune applicazioni notevoli dell’apprendimento a pochi esempi:

Classificazione delle Immagini e Riconoscimento degli Oggetti: Nei compiti di classificazione delle immagini, i modelli possono riconoscere e classificare rapidamente gli oggetti con un numero limitato di esempi etichettati. È particolarmente utile per riconoscere oggetti rari o nuovi non presenti nel set di addestramento.
Elaborazione del Linguaggio Naturale: Nell’NLP, l’apprendimento a pochi esempi consente ai modelli di eseguire compiti come l’analisi del sentimento, la classificazione del testo e il riconoscimento di entità nominate con pochi dati etichettati. È utile in scenari in cui i dati di testo etichettati sono scarsi o costosi da ottenere.
Diagnosi Medica e Assistenza Sanitaria: L’apprendimento a pochi esempi mostra promesse nell’analisi e nella diagnosi delle immagini mediche. Può contribuire a identificare malattie rare, rilevare anomalie e prevedere l’esito dei pazienti con pochi dati medici.
Sistemi di Raccomandazione: Suggeriscono contenuti o prodotti personalizzati agli utenti in base a un piccolo numero di interazioni o preferenze degli utenti.
Marketing e Pubblicità Personalizzati: Aiutano le aziende a mirare a segmenti specifici di clienti con campagne di marketing personalizzate basate su pochi dati sui clienti.

Vantaggi dell’Apprendimento a Pochi Esempi

Efficienza dei Dati: L’apprendimento a pochi esempi richiede solo un piccolo numero di esempi etichettati per classe, rendendolo altamente efficiente in termini di dati. Questo è particolarmente vantaggioso quando l’acquisizione di grandi set di dati etichettati è costosa o impraticabile.
Generalizzazione a Nuovi Compiti: I modelli di apprendimento a pochi esempi eccellono nell’adattarsi rapidamente a nuovi compiti o classi con pochi esempi etichettati. Questa flessibilità consente loro di gestire efficacemente dati non visti, rendendoli adatti a ambienti dinamici ed in evoluzione.
Addestramento Rapido del Modello: Con meno esempi da elaborare, i modelli vengono addestrati rapidamente rispetto ai modelli di apprendimento automatico tradizionali che richiedono un ampio numero di dati etichettati.
Gestione della Scarsità dei Dati: Affronta direttamente il problema della scarsità dei dati, consentendo ai modelli di ottenere buone prestazioni anche quando i dati di addestramento sono scarsi o non disponibili per classi o compiti specifici.
Trasferimento dell’Apprendimento: I modelli di apprendimento a pochi esempi possiedono intrinsecamente capacità di trasferimento dell’apprendimento. La conoscenza delle classi di apprendimento a pochi esempi migliora le prestazioni su compiti o domini correlati.
Personalizzazione e Personalizzazione: Facilitano soluzioni personalizzate, poiché i modelli possono adattarsi rapidamente alle preferenze individuali degli utenti o ai requisiti specifici.
Riduzione degli Sforzi di Annotazione: Riduce l’onere dell’annotazione manuale dei dati, richiede meno esempi etichettati per l’addestramento, risparmiando tempo e risorse.

Limitazioni

Discriminazione di classe limitata: La configurazione potrebbe non fornire abbastanza esempi per catturare le differenze di classe dettagliate, portando a una ridotta potenza discriminante per classi strettamente correlate.
Dipendenza da esempi di pochi colpi: I modelli si basano pesantemente sulla qualità e rappresentatività degli esempi di pochi colpi forniti durante l’addestramento.
Complessità del compito: L’apprendimento di pochi colpi potrebbe avere difficoltà con compiti altamente complessi che richiedono una comprensione più approfondita di modelli intricati nei dati. Potrebbe richiedere un set più esteso di esempi etichettati o un diverso paradigma di apprendimento.
Vulnerabilità al rumore: Più sensibile a esempi etichettati rumorosi o erronei, poiché sono necessari meno punti dati per l’apprendimento.
Cambiamento nella distribuzione dei dati: I modelli potrebbero avere difficoltà quando la distribuzione dei dati di test si discosta significativamente dalla distribuzione dei dati di addestramento di pochi colpi.
Complessità del design del modello: La progettazione di modelli di apprendimento di pochi colpi efficaci comporta spesso architetture e metodologie di addestramento più intricate, che possono essere impegnative e computazionalmente costose.
Difficoltà con gli outlier: I modelli potrebbero avere difficoltà con gli outlier o le istanze rare che sono significativamente diverse dagli esempi di pochi colpi visti durante l’addestramento.

Implementazione pratica dell’apprendimento di pochi colpi

Prendiamo ad esempio un compito di classificazione delle immagini di pochi colpi.

Classificheremo le immagini di oggetti diversi nelle rispettive classi. Le immagini appartengono a tre classi: “gatto”, “cane”, e “tulipano”. L’obiettivo del compito di classificazione è predire l’etichetta di classe (cioè “gatto”, “cane” o “tulipano”) per una determinata immagine di query in base alla sua somiglianza con i prototipi delle classi nel set di supporto. Il primo passo è la preparazione dei dati. Ottenere e preelaborare il dataset di apprendimento di pochi colpi, suddividendolo in set di supporto (etichettati) e query (non etichettati) per ogni compito. Assicurarsi che il dataset rappresenti gli scenari del mondo reale che il modello incontrerà durante la distribuzione. Qui raccogliamo un dataset diversificato di immagini contenenti varie specie animali e vegetali, etichettate con le rispettive classi. Per ogni compito, selezionare casualmente alcuni esempi (ad esempio, da 1 a 5 immagini) come set di supporto.

Queste immagini di supporto verranno utilizzate per “insegnare” al modello la classe specifica. Le immagini della stessa classe costituiscono il set di query e valutano la capacità del modello di classificare istanze non viste. Creare più compiti di pochi colpi selezionando casualmente diverse classi e creando set di supporto e query per ogni compito. Applicare tecniche di aumento dei dati per aumentare le immagini del set di supporto, ad esempio rotazioni casuali, inversioni o regolazioni della luminosità. L’aumento dei dati aiuta ad aumentare la dimensione adeguata del set di supporto e migliorare la robustezza del modello. Organizzare i dati in coppie o mini-batch, ognuna composta dal set di supporto e dal set di query corrispondente.

Esempi

Ad esempio, un compito di pochi colpi potrebbe apparire così:

Set di supporto: [cat_1.jpg, cat_2.jpg, cat_3.jpg]
Set di query: [cat_4.jpg, cat_5.jpg, cat_6.jpg, cat_7.jpg]

Set di supporto: [dog_1.jpg, dog_2.jpg]
Set di query: [dog_3.jpg, dog_4.jpg, dog_5.jpg, dog_6.jpg]

Set di supporto: [tulip_1.jpg, tulip_2.jpg]
Set di query: [tulip_3.jpg, tulip_4.jpg, tulip_5.jpg, tulip_6.jpg]

E così via…

import numpy as np
import random

# Esempio di dataset di immagini e relative etichette di classe
dataset = [
    {"image": "cat_1.jpg", "label": "gatto"},
    {"image": "cat_2.jpg", "label": "gatto"},
    {"image": "cat_3.jpg", "label": "gatto"},
    {"image": "cat_4.jpg", "label": "gatto"},
    {"image": "dog_1.jpg", "label": "cane"},
    {"image": "dog_2.jpg", "label": "cane"},
    {"image": "dog_3.jpg", "label": "cane"},
    {"image": "dog_4.jpg", "label": "cane"},
    {"image": "tulip_1.jpg", "label": "tulipano"},
    {"image": "tulip_2.jpg", "label": "tulipano"},
    {"image": "tulip_3.jpg", "label": "tulipano"},
    {"image": "tulip_4.jpg", "label": "tulipano"},
]

# Mescolare il dataset
random.shuffle(dataset)

# Suddividere il dataset in set di supporto e query per un compito di pochi colpi
numero_esempi_supporto = 3
numero_esempi_query = 4

compito_pochi_colpi = dataset[:numero_esempi_supporto + numero_esempi_query]

# Preparare set di supporto e query
set_supporto = compito_pochi_colpi[:numero_esempi_supporto]
set_query = compito_pochi_colpi[numero_esempi_supporto:]#import csv

Una semplice funzione, load_image, è definita per simulare il caricamento dell’immagine, e un’altra funzione, get_embedding, è definita per simulare l’estrazione delle caratteristiche dell’immagine (embedding). In questa implementazione, la funzione load_image utilizza le trasformazioni di PyTorch per preprocessare l’immagine e convertirla in un tensore. La funzione carica un modello ResNet-18 pre-addestrato dal model hub di PyTorch, esegue un passaggio in avanti sull’immagine ed estrae le caratteristiche da uno dei livelli convoluzionali intermedi. Le caratteristiche vengono appiattite e convertite in un array NumPy, che calcolerà gli embedding e le distanze nell’esempio di apprendimento a poche istanze.

def load_image(image_path):
    image = Image.open(image_path).convert("RGB")
    transform = transforms.Compose([
        transforms.Resize((224, 224)),     
        transforms.ToTensor(),             
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) 
    ])
    return transform(image)

# Genera gli embedding delle caratteristiche per le immagini utilizzando una CNN pre-addestrata (ad esempio, ResNet-18)
def get_embedding(image):
    model = torch.hub.load('pytorch/vision', 'resnet18', pretrained=True)
    model.eval()

    with torch.no_grad():
        image = image.unsqueeze(0)   # Aggiungi la dimensione del batch al tensore dell'immagine
        features = model(image)      # Passaggio in avanti attraverso il modello per ottenere le caratteristiche

    # Restituisci l'embedding delle caratteristiche (appiattisci il tensore)
    return features.squeeze().numpy()#import csv

Tecnica di Apprendimento a Pochi Istanti

Seleziona una tecnica di apprendimento a pochi istanti adatta alle specifiche esigenze del tuo compito e alle risorse disponibili.

# Crea dei prototipi per ogni classe nel set di supporto
class_prototypes = {}
for example in support_set:
    image = load_image(example["image"])
    embedding = get_embedding(image)

    if example["label"] not in class_prototypes:
        class_prototypes[example["label"]] = []

    class_prototypes[example["label"]].append(embedding)


for label, embeddings in class_prototypes.items():
    class_prototypes[label] = np.mean(embeddings, axis=0)


for query_example in query_set:
    image = load_image(query_example["image"])
    embedding = get_embedding(image)


    distances = {label: np.linalg.norm(embedding - prototype) for label, 
    prototype in class_prototypes.items()}

    predicted_label = min(distances, key=distances.get)
    print(f"Query Image: {query_example['image']}, Etichetta Prevista: {predicted_label}")

Questo è un setup di apprendimento a poche istanze di base per la classificazione delle immagini utilizzando i Prototypical Networks. Il codice crea dei prototipi per ogni classe nel set di supporto. I prototipi vengono calcolati come la media degli embedding degli esempi di supporto nella stessa classe. I prototipi rappresentano il punto centrale dello spazio delle caratteristiche per ogni classe. Per ogni esempio di query nel set di query, il codice calcola la distanza tra l’embedding dell’esempio di query e i prototipi di ogni classe nel set di supporto. L’esempio di query viene assegnato alla classe con il prototipo più vicino in base alle distanze calcolate. Infine, il codice stampa il nome del file dell’immagine di query e l’etichetta di classe prevista in base al processo di apprendimento a poche istanze.

# Funzione di perdita (distanza euclidea)
def euclidean_distance(a, b):
    return np.linalg.norm(a - b)

# Calcola la perdita (log-verosimiglianza negativa) per la classe prevista
query_label = query_example["label"]
loss = -np.log(np.exp(-euclidean_distance(query_set_prototype, 
class_prototypes[query_label])) / np.sum(np.exp(-euclidean_distance(query_set_prototype,
 prototype)) for prototype in class_prototypes.values()))

print(f"Perdita per l'Esempio di Query: {loss}")#import csv

Dopo aver calcolato le distanze tra il prototipo del set di query e ogni prototipo di classe, calcoliamo la perdita per la classe prevista utilizzando la log-verosimiglianza negativa (perdita di entropia incrociata). La perdita penalizza il modello se la distanza tra il prototipo del set di query e il prototipo corretto della classe è grande, incoraggiando il modello a ridurre al minimo questa distanza e a classificare correttamente l’esempio di query.

Questa era l’implementazione semplice. Di seguito è riportata l’implementazione completa dell’esempio di apprendimento a poche istanze con Prototypical Networks, inclusa la fase di addestramento:

import numpy as np
import random
import torch
import torch.nn as nn
import torchvision.transforms as transforms
from torch.optim import Adam
from PIL import Image

# Dataset di esempi di immagini e relative etichette di classe
# ... (come negli esempi precedenti)

# Mescola il dataset
random.shuffle(dataset)

# Suddividi il dataset in set di supporto e set di query per un compito a poche istanze
num_support_examples = 3
num_query_examples = 4

few_shot_task = dataset[:num_support_examples + num_query_examples]

# Prepara il set di supporto e il set di query
support_set = few_shot_task[:num_support_examples]
query_set = few_shot_task[num_support_examples:]

# Funzione di utilità per caricare un'immagine e trasformarla in un tensore
def load_image(image_path):
    image = Image.open(image_path).convert("RGB")
    transform = transforms.Compose([
        transforms.Resize((224, 224)),     
        transforms.ToTensor(),             
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  
    ])
    return transform(image)

# Genera gli embedding delle caratteristiche per le immagini utilizzando una CNN pre-addestrata (ad esempio, ResNet-18)
def get_embedding(image):
   
    model = torch.hub.load('pytorch/vision', 'resnet18', pretrained=True)
    model.eval()

    # Estrai le caratteristiche dall'immagine utilizzando i livelli convoluzionali del modello
    with torch.no_grad():
        image = image.unsqueeze(0)   # Aggiungi la dimensione del batch al tensore dell'immagine
        features = model(image)      # Passaggio in avanti attraverso il modello per ottenere le caratteristiche

    # Restituisci l'embedding delle caratteristiche (appiattisci il tensore)
    return features.squeeze()

# Modello Prototypical Networks
class PrototypicalNet(nn.Module):
    def __init__(self, input_size, output_size):
        super(PrototypicalNet, self).__init__()
        self.input_size = input_size
        self.output_size = output_size
        self.fc = nn.Linear(input_size, output_size)

    def forward(self, x):
        return self.fc(x)

# Addestramento
num_classes = len(set([example['label'] for example in support_set]))
input_size = 512   # Dimensione degli embedding delle caratteristiche (output della CNN)
output_size = num_classes

# Crea il modello Prototypical Networks
model = PrototypicalNet(input_size, output_size)

# Funzione di perdita (Entropia Incrociata)
criterion = nn.CrossEntropyLoss()

# Ottimizzatore (Adam)
optimizer = Adam(model.parameters(), lr=0.001)

# Ciclo di addestramento
num_epochs = 10

for epoch in range(num_epochs):
    model.train()  # Imposta il modello in modalità di addestramento

    for example in support_set:
        image = load_image(example["image"])
        embedding = get_embedding(image)

        # Converti l'etichetta di classe in un tensore
        label = torch.tensor([example["label"]])

        # Passaggio in avanti
        outputs = model(embedding)

        # Calcola la perdita
        loss = criterion(outputs, label)

        # Retropropagazione e ottimizzazione
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    print(f"Epoch [{epoch+1}/{num_epochs}], Perdita: {loss.item():.4f}")

# Inferenza (utilizzando il set di query)
model.eval()  # Imposta il modello in modalità di valutazione

query_set_embeddings = [get_embedding(load_image(example["image"])) 
for example in query_set]

# Calcola il prototipo del set di query
query_set_prototype = torch.mean(torch.stack(query_set_embeddings), dim=0)

# Classifica ogni esempio di query
predictions = model(query_set_prototype)

# Ottieni le etichette previste
_, predicted_labels = torch.max(predictions, 0)

# Ottieni l'etichetta prevista per l'esempio di query
predicted_label = predicted_labels.item()

# Stampa l'etichetta prevista per l'esempio di query
print(f"Immagine di Query: {query_set[0]['image']}, Etichetta Prevista: {predicted_label}")

In questa implementazione completa, definiamo un semplice modello di Prototypical Networks e eseguiamo l’addestramento utilizzando una perdita di Cross-Entropy e un ottimizzatore Adam. Dopo l’addestramento, utilizziamo il modello addestrato per classificare l’esempio di query basato sull’approccio delle Prototypical Networks.

Direzioni future e potenziali applicazioni

Questo campo ha mostrato un notevole progresso ma è ancora in evoluzione con molte direzioni future promettenti e potenziali applicazioni. Ecco alcune delle principali aree di interesse per il futuro:

Continui progressi nell’apprendimento meta: sono probabili ulteriori sviluppi. Miglioramenti negli algoritmi di ottimizzazione, nelle architetture e nelle strategie di apprendimento meta potrebbero portare a modelli di apprendimento few-shot più efficienti ed efficaci. La ricerca per affrontare sfide come il dimenticamento catastrofico e la scalabilità dei metodi di apprendimento meta è in corso.
Incorporazione della conoscenza di dominio: l’integrazione della conoscenza di dominio negli algoritmi di apprendimento few-shot può migliorare la loro capacità di generalizzare e trasferire conoscenza tra diverse attività e domini. La combinazione dell’apprendimento few-shot con il ragionamento simbolico o la rappresentazione strutturata della conoscenza potrebbe essere promettente.
Esplorazione dell’apprendimento few-shot gerarchico: estendere le impostazioni gerarchiche, in cui le attività e le classi sono organizzate in modo gerarchico, può consentire ai modelli di sfruttare le relazioni gerarchiche tra classi e attività, portando a una migliore generalizzazione.
Apprendimento few-shot rinforzato: l’integrazione con l’apprendimento rinforzato può consentire agli agenti di apprendere nuove attività con una limitata esperienza. Questa area è particolarmente rilevante per il controllo robotico e i sistemi autonomi.
Adattamento alle applicazioni reali: Le applicazioni e gli scenari del mondo reale, come la diagnosi medica, la scoperta di farmaci, i sistemi di raccomandazione personalizzati e l’insegnamento adattativo, offrono promettenti opportunità. La ricerca futura potrebbe concentrarsi nello sviluppo di tecniche di apprendimento few-shot specializzate per domini specifici.

Conclusioni

È un affascinante sottocampo dell’intelligenza artificiale e dell’apprendimento automatico che affronta la sfida di addestrare modelli con un numero minimo di dati. In questo blog, abbiamo esplorato la sua definizione, le differenze rispetto all’apprendimento automatico tradizionale, le Prototypical Networks e le applicazioni reali nella diagnosi medica e nelle raccomandazioni personalizzate. Eccitanti direzioni di ricerca includono l’apprendimento meta, le reti neurali grafiche e i meccanismi di attenzione, spingendo l’intelligenza artificiale ad adattarsi rapidamente e fare previsioni accurate.

Democratizzando l’intelligenza artificiale e consentendo l’adattabilità con dati limitati, si aprono porte per una più ampia adozione dell’intelligenza artificiale. Questo percorso verso lo sblocco di un potenziale inesplorato porterà a un futuro in cui macchine e esseri umani convivono in armonia, plasmando un panorama dell’intelligenza artificiale più intelligente e vantaggioso.

Punti chiave

L’apprendimento few-shot è un affascinante sottocampo dell’intelligenza artificiale e dell’apprendimento automatico che affronta la sfida di addestrare modelli con un numero limitato di esempi etichettati.
Le Prototypical Networks sono potenti tecniche utilizzate che consentono ai modelli di adattarsi e prevedere in modo efficiente con dati etichettati limitati.
Ha applicazioni reali nella diagnosi medica e nelle raccomandazioni personalizzate, dimostrando la sua versatilità e praticità. Potrebbe democratizzare l’intelligenza artificiale riducendo la dipendenza da grandi quantità di dati etichettati.

Domande frequenti

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e vengono utilizzati a discrezione dell’autore.

Applications,blogathon,Classes,few-shot learning,images,meta learning,Models,query,training