Esplorare l’uso di LLM e BERT per compiti linguistici | Intelligenza-Artificiale

introduzione

Nel panorama in rapida evoluzione dell’intelligenza artificiale, soprattutto in PNLi modelli linguistici di grandi dimensioni (LLM) hanno rapidamente trasformato le interazioni con la tecnologia. Dall’innovativo documento “L’attenzione è tutto ciò di cui hai bisogno” nel 2017, l’architettura Transformer, esemplificata in particolare da ChatGPT, è diventata fondamentale. GPT-3, un ottimo esempio, eccelle nel generare testo coerente. Questo articolo esplora l’utilizzo degli LLM con BERT per le attività attraverso la formazione preliminare, la messa a punto e la guida, svelando le chiavi delle loro prestazioni eccezionali.

Prerequisiti: Conoscenza di Transformers, BERT e Large Language Models.

Cosa sono gli LLM?

LLM sta per Modello linguistico di grandi dimensioni. Gli LLM sono modelli di deep learning progettati per comprendere il significato di testo simile a quello umano ed eseguire varie attività come l’analisi del sentiment, la modellazione del linguaggio (previsione della parola successiva), la generazione di testo, il riepilogo del testo e molto altro. Sono addestrati su un’enorme quantità di dati di testo.

Utilizziamo quotidianamente applicazioni basate su questi LLM senza nemmeno rendercene conto. Google utilizza BERT (Bidirection Encoder Representations for Transformers) per varie applicazioni come il completamento delle query, la comprensione del contesto delle query, la produzione di risultati di ricerca più pertinenti e accurati, la traduzione linguistica e altro ancora.

Apprendimento approfondito tecniche, in particolare reti neurali profonde e metodi avanzati come l’autoattenzione, sono alla base della costruzione di questi modelli. Imparano i modelli, le strutture e la semantica della lingua addestrandosi su ampi dati di testo. Data la loro dipendenza da enormi set di dati, addestrarli da zero consuma molto tempo e risorse, rendendolo poco pratico.

Esistono tecniche mediante le quali possiamo utilizzare direttamente questi modelli per un compito specifico. Quindi parliamone in dettaglio!

Modi per addestrare modelli linguistici di grandi dimensioni

Sebbene sia possibile addestrare questi modelli per eseguire un compito specifico mediante un perfezionamento convenzionale, esistono anche altri approcci semplici che sono possibili ora, ma prima discutiamo del pre-addestramento di LLM.

Pre-allenamento

Nel pre-addestramento, una grande quantità di testo senza etichetta funge da dati di addestramento per un modello linguistico di grandi dimensioni. La domanda è: “Come possiamo addestrare un modello su dati senza etichetta e poi aspettarci che il modello preveda i dati in modo accurato?”. Ecco che nasce il concetto di “Apprendimento Auto-Supervisionato”. Nell’apprendimento auto-supervisionato, un modello maschera una parola e cerca di prevedere la parola successiva con l’aiuto delle parole precedenti.

Ad esempio, supponiamo di avere una frase: “Sono uno scienziato dei dati”.

Il modello può creare i propri dati etichettati da questa frase come:

Questa è la previsione della parola successiva e i modelli sono autoregressivi. Questo può essere fatto da un MLM (Masked Language Model). BERT, un modello di linguaggio mascherato, utilizza questa tecnica per prevedere la parola mascherata. Possiamo pensare al MLM come al concetto di “riempire gli spazi vuoti”, in cui il modello prevede quale parola può rientrare nello spazio vuoto.

Esistono diversi modi per prevedere la parola successiva, ma in questo articolo parleremo solo di BERT, il MLM. BERT può guardare sia la parola precedente che quella successiva per comprendere il contesto della frase e prevedere la parola mascherata.

Quindi, come panoramica di alto livello del pre-addestramento, è una tecnica in cui il modello impara a prevedere la parola successiva nel testo.

Ritocchi

Il finetuning consiste nel modificare i parametri del modello per renderlo adatto all’esecuzione di un compito specifico. Dopo la formazione preliminare, il modello viene sottoposto a messa a punto, durante la quale ti alleni per attività specifiche come l’analisi del sentiment, la generazione di testo e la ricerca di somiglianze nei documenti, solo per citarne alcuni. Noi facciamono è necessario addestrare nuovamente il modello su un testo di grandi dimensioni. Piuttosto, utilizzare il modello addestrato per eseguire un’attività che vogliamo eseguire. Discuteremo come mettere a punto un modello linguistico di grandi dimensioni in dettaglio più avanti in questo articolo.

Suggestivo

Il suggerimento è la più semplice delle 3 tecniche, ma è un po’ complicata. Si tratta di fornire al modello un contesto (prompt) in base al quale il modello esegue le attività.

Immagina di insegnare a un bambino un capitolo del suo libro in dettaglio, essendo molto discreto riguardo alla spiegazione e poi chiedendogli di risolvere il problema relativo a quel capitolo.

Nel contesto di LLM, prendi, ad esempio, ChatGPT. Impostiamo un contesto e chiediamo al modello di seguire le istruzioni per risolvere il problema indicato.

Supponiamo che io voglia che ChatGPT mi chieda di intervistare domande solo su Transformers.

Per un’esperienza migliore e un risultato accurato, è necessario impostare un contesto adeguato e fornire una descrizione dettagliata dell’attività.

Esempio:

UN Data Scientist con 2 anni di esperienza e in preparazione per un colloquio di lavoro presso l’azienda XYZ. Amo il problem solving e attualmente lavoro con modelli PNL all’avanguardia. Sono aggiornato sulle ultime tendenze e tecnologie. UNfatemi domande molto difficili sul modello Transformer che l’intervistatore di questa azienda può porre in base alla precedente esperienza dell’azienda. Fammi 10 domande e dai anche le risposte alle domande.

Più le richieste sono dettagliate e specifiche, migliori saranno i risultati. La parte più divertente è che puoi generare il prompt dal modello stesso e quindi aggiungere un tocco personale o le informazioni necessarie.

Tecnica di messa a punto

Esistono diversi modi per mettere a punto un modello in modo convenzionale e i diversi approcci dipendono dal problema specifico che si desidera risolvere. Parliamo delle tecniche per mettere a punto un modello.

Esistono 3 modi per mettere a punto convenzionalmente un LLM.

• Estrazione delle caratteristiche: Questa tecnica viene utilizzata per estrarre le caratteristiche da un dato testo, ma perché dovremmo voler estrarre gli incorporamenti da un dato testo? La risposta è molto semplice. Poiché i computer non comprendono il testo, deve esserci una rappresentazione del testo che possa essere utilizzata per eseguire compiti diversi. Una volta estratti gli incorporamenti, possono analizzare il sentiment, trovare somiglianze tra documenti, ecc. Nell’estrazione delle funzionalità, gli strati portanti del modello sono congelati, ovvero i parametri di tali strati non vengono aggiornati e solo i parametri degli strati classificatore vengono aggiornato. Gli strati di classificazione coinvolgono la rete di strati completamente connessa.
• Messa a punto completa del modello: Come suggerisce il nome, questa tecnica addestra ogni livello del modello sul set di dati personalizzato per diverse epoche. I parametri di tutti i livelli nel modello vengono regolati in base al nuovo set di dati personalizzato. Ciò può migliorare la precisione del modello sui dati e sull’attività specifica che vogliamo eseguire. È computazionalmente costoso e richiede molto tempo per l’addestramento del modello, considerando che ci sono miliardi di parametri nel LLM.
• Ottimizzazione basata sull’adattatore: Il finetuning basato sull’adattatore è un concetto relativamente nuovo in cui viene aggiunto alla rete un ulteriore livello inizializzato casualmente o un modulo, che viene poi addestrato per un compito specifico. In questa tecnica, i parametri del modello vengono lasciati indisturbati oppure i parametri del modello non vengono modificati o ottimizzati. Piuttosto, vengono addestrati i parametri del livello adattatore. Questa tecnica aiuta a mettere a punto il modello in modo computazionalmente efficiente.

Messa a punto BERT

Ora che conosciamo le tecniche di perfezionamento, eseguiamo l’analisi del sentiment sulle recensioni dei film IMDB utilizzando BERT. BERT è un modello linguistico di grandi dimensioni che combina livelli di trasformazione ed è solo codificatore. Google lo ha sviluppato e ha dimostrato di funzionare molto bene in vari compiti. BERT è disponibile in diverse dimensioni e varianti come BERT-base-uncased, BERT Large, RoBERTa, LegalBERT e molti altri.

Usiamo il modello BERT per eseguire l’analisi del sentiment sulle recensioni di film su IMDB. Per la disponibilità gratuita della GPU, si consiglia di utilizzare Google Colab. Cominciamo la formazione caricando alcune importanti librerie. Poiché BERT (Bidirection Encoder Representations for Encoders) si basa sui trasformatori, il primo passo sarebbe installare i trasformatori nel nostro ambiente.

!pip install transformers

Carichiamo alcune librerie che ci aiuteranno a caricare i dati come richiesto dal modello BERT, tokenizzare i dati caricati, caricare il modello che utilizzeremo per la classificazione, eseguire train-test-split, caricare il nostro file CSV e alcune altre funzioni.

import pandas as pd

import numpy as np

import os

from sklearn.model_selection import train_test_split

import torch

import torch.nn as nn

from transformers import BertTokenizer, BertModel

Dobbiamo cambiare il dispositivo da CPU a GPU per un calcolo più veloce.

device = torch.device("cuda")

Il passaggio successivo sarebbe caricare il nostro set di dati ed esaminare i primi 5 record nel set di dati.

df = pd.read_csv('/content/drive/MyDrive/movie.csv')

df.head()

Set di formazione e convalida

Suddivideremo il nostro set di dati in set di training e validazione. Puoi anche suddividere i dati in set di training, convalida e test, ma per motivi di semplicità, sto semplicemente suddividendo il set di dati in training e convalida.

x_train, x_val, y_train, y_val = train_test_split(df.text, df.label, random_state = 42, test_size = 0.2, stratify = df.label)

Importiamo e carichiamo il modello BERT e il tokenizzatore.

from transformers.models.bert.modeling_bert import BertForSequenceClassification

# import BERT-base pre-trained model

BERT = BertModel.from_pretrained('bert-base-uncased')

# Load the BERT tokenizer

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

Utilizzeremo il tokenizer per convertire il testo in token con una lunghezza massima di 250 e riempimento e troncamento quando richiesto.

train_tokens = tokenizer.batch_encode_plus(x_train.tolist(), max_length = 250, pad_to_max_length=True, truncation=True)

val_tokens = tokenizer.batch_encode_plus(x_val.tolist(), max_length = 250, pad_to_max_length=True, truncation=True)

Il tokenizzatore restituisce un dizionario con tre coppie chiave-valore contenenti gli input_ids, che sono i token relativi ad una particolare parola; token_type_ids, che è un elenco di numeri interi che distinguono tra diversi segmenti o parti dell’input; e Attention_mask, che indica a quale token prestare attenzione.

Convertire questi valori in tensori

train_ids = torch.tensor(train_tokens('input_ids'))

train_masks = torch.tensor(train_tokens('attention_mask'))

train_label = torch.tensor(y_train.tolist())

val_ids = torch.tensor(val_tokens('input_ids'))

val_masks = torch.tensor(val_tokens('attention_mask'))

val_label = torch.tensor(y_val.tolist())

Caricamento di TensorDataset e DataLoaders per preelaborare ulteriormente i dati e renderli adatti al modello.

from torch.utils.data import TensorDataset, DataLoader

train_data = TensorDataset(train_ids, train_masks, train_label)

val_data = TensorDataset(val_ids, val_masks, val_label)

train_loader = DataLoader(train_data, batch_size = 32, shuffle = True)

val_loader = DataLoader(val_data, batch_size = 32, shuffle = True)

Il nostro compito è congelare i parametri di BERT utilizzando il nostro classificatore e quindi ottimizzare tali livelli sul nostro set di dati personalizzato. Quindi, congeliamo i parametri del modello.

for param in BERT.parameters():

 param.requires_grad = False

Adesso dovremo definire il passaggio avanti e quello indietro per gli strati che abbiamo aggiunto. Il modello BERT fungerà da estrattore di feature mentre dovremo definire esplicitamente i passaggi avanti e indietro per la classificazione.

class Model(nn.Module):

   def __init__(self, bert):

       super(Model, self).__init__()

       self.bert = bert

       self.dropout = nn.Dropout(0.1)

       self.relu = nn.ReLU()

       self.fc1 = nn.Linear(768, 512)

       self.fc2 = nn.Linear(512, 2)

       self.softmax = nn.LogSoftmax(dim=1)

   def forward(self, sent_id, mask):

       # Pass the inputs to the model

       outputs = self.bert(sent_id, mask)

       cls_hs = outputs.last_hidden_state(:, 0, :)

       x = self.fc1(cls_hs)

       x = self.relu(x)

       x = self.dropout(x)

       x = self.fc2(x)

       x = self.softmax(x)

       return x

Spostiamo il modello sulla GPU.

model = Model(BERT)

# push the model to GPU

model = model.to(device)

Defining the optimizer

# optimizer from hugging face transformers

from transformers import AdamW

# define the optimizer

optimizer = AdamW(model.parameters(),lr = 1e-5)

Abbiamo preelaborato il set di dati e definito il nostro modello. Ora è il momento di addestrare il modello. Dobbiamo scrivere un codice per addestrare e valutare il modello.

La funzione del treno:

def train():

   model.train()

   total_loss, total_accuracy = 0, 0

   total_preds = ()

   for step, batch in enumerate(train_loader):

       # Move batch to GPU if available

       batch = (item.to(device) for item in batch)

       sent_id, mask, labels = batch

       # Clear previously calculated gradients

       optimizer.zero_grad()

       # Get model predictions for the current batch

       preds = model(sent_id, mask)

       # Calculate the loss between predictions and labels

       loss_function = nn.CrossEntropyLoss()

       loss = loss_function(preds, labels)

       # Add to the total loss

       total_loss += loss.item()

       # Backward pass and gradient update

       loss.backward()

       optimizer.step()

       # Move predictions to CPU and convert to numpy array

       preds = preds.detach().cpu().numpy()

       # Append the model predictions

       total_preds.append(preds)

   # Compute the average loss

   avg_loss = total_loss / len(train_loader)

   # Concatenate the predictions

   total_preds = np.concatenate(total_preds, axis=0)

   # Return the average loss and predictions

   return avg_loss, total_preds

The evaluation function:

def evaluate():

   model.eval()

   total_loss, total_accuracy = 0, 0

   total_preds = ()

   for step, batch in enumerate(val_loader):

       # Move batch to GPU if available

       batch = (item.to(device) for item in batch)

       sent_id, mask, labels = batch

       # Clear previously calculated gradients

       optimizer.zero_grad()

       # Get model predictions for the current batch

       preds = model(sent_id, mask)

       # Calculate the loss between predictions and labels

       loss_function = nn.CrossEntropyLoss()

       loss = loss_function(preds, labels)

       # Add to the total loss

       total_loss += loss.item()

       # Backward pass and gradient update

       loss.backward()

       optimizer.step()

       # Move predictions to CPU and convert to numpy array

       preds = preds.detach().cpu().numpy()

       # Append the model predictions

       total_preds.append(preds)

   # Compute the average loss

   avg_loss = total_loss / len(val_loader)

   # Concatenate the predictions

   total_preds = np.concatenate(total_preds, axis=0)

   # Return the average loss and predictions

   return avg_loss, total_preds

Addestrare il modello

Utilizzeremo ora queste funzioni per addestrare il modello:

# set initial loss to infinite

best_valid_loss = float('inf')

#defining epochs

epochs = 5

# empty lists to store training and validation loss of each epoch

train_losses=()

valid_losses=()

#for each epoch

for epoch in range(epochs):

   print('\n Epoch {:} / {:}'.format(epoch + 1, epochs))

   #train model

   train_loss, _ = train()

   #evaluate model

   valid_loss, _ = evaluate()

   #save the best model

   if valid_loss < best_valid_loss:

       best_valid_loss = valid_loss

       torch.save(model.state_dict(), 'saved_weights.pt')

   # append training and validation loss

   train_losses.append(train_loss)

   valid_losses.append(valid_loss)

   print(f'\nTraining Loss: {train_loss:.3f}')

   print(f'Validation Loss: {valid_loss:.3f}')

E il gioco è fatto. Puoi utilizzare il modello addestrato per dedurre qualsiasi dato o testo tu scelga.

Leggi anche: Perché e come utilizzare BERT per la classificazione dei testi NLP?

Conclusione

Questo articolo ha esplorato il mondo dei LLM e del BERT e il loro impatto significativo sull’elaborazione del linguaggio naturale (PNL). Abbiamo discusso del processo di preformazione, in cui i LLM vengono formati su grandi quantità di testo senza etichetta utilizzando l’apprendimento autosuperato. Abbiamo anche approfondito la messa a punto, che prevede l’adattamento di un modello pre-addestrato per compiti e suggerimenti specifici, in cui ai modelli viene fornito il contesto per generare risultati rilevanti. Inoltre, abbiamo esaminato diverse tecniche di perfezionamento, come l’estrazione delle funzionalità, il perfezionamento del modello completo e il perfezionamento basato sull’adattatore. Gli LLM hanno rivoluzionato la PNL e continuano a favorire progressi in varie applicazioni.

Punti chiave

• Gli LLM, come BERT, sono modelli potenti formati su grandi quantità di dati di testo, che consentono loro di comprendere e generare testo simile a quello umano.
• La preformazione prevede la formazione di LLM su testo senza etichetta utilizzando tecniche di apprendimento autocontrollato come il modellamento del linguaggio mascherato (MLM).
• Il finetuning consiste nell’adattare un LLM pre-addestrato per attività specifiche estraendo funzionalità, addestrando l’intero modello o utilizzando tecniche basate su adattatori, a seconda dei requisiti.

Domande frequenti

Padroneggia l’avanguardia della tecnologia GenAI con il nostro Programma di punta dell’intelligenza artificiale generativain cui ti immergerai in oltre 200 ore di apprendimento approfondito e riceverai oltre 75 sessioni esclusive di tutoraggio. Dai un’occhiata adesso e ottieni una tabella di marcia chiara per il lavoro dei tuoi sogni!

Imparentato