Esplorazione di grandi modelli di linguaggio – Parte 3

Exploration of large language models - Part 3

Raffinamento, Quantizzazione del Modello, Adattatori a Basso Rango, Tuning Istruito e utilizzo di LLM per generare dati di addestramento

Questo articolo è scritto principalmente per l’autodidattica. Pertanto, è ampio e approfondito. Sentiti libero di saltare alcune sezioni in base ai tuoi interessi o di cercare l’area che ti interessa.

Ecco alcune delle domande che mi hanno intrigato o sono emerse durante il tentativo di raffinare LLM. L’articolo è un tentativo di rispondere a queste domande e condividere queste informazioni con altri curiosi.

Dato che LLM si basa su una NeuralNet con funzione di perdita, tutto l’addestramento di LLM non è addestramento supervisionato? Perché viene generalmente definito addestramento non supervisionato? Puoi addestrare un LLM in una frase molto breve per illustrare come funziona l’addestramento di LLM in pratica? Cosa sono Masked e Causal LM? Puoi spiegare l’intuizione dietro l’Architettura del Transformer in un’unica immagine? Cosa si intende esattamente per addestramento non supervisionato in LLM? Perché lo stesso architetto principale di ChatGPT – Ilya Suverskar – considera l’addestramento non supervisionato come il Santo Graal dell’apprendimento automatico? Cosa si intende per Emergenza/Comprensione di LLM?

Quali sono i casi d’uso di LLM? Perché LLM sono più adatti come assistenti per la produttività? Cosa è il modello di recupero delle informazioni di tipo Vettore DB/Embedding? LLM possono essere utilizzati per scopi diversi da quelli testuali? Cosa è il ragionamento causale? Qual è il problema con LLM? Perché menti come Yan LeCun pensano che gli attuali LLM siano senza speranza? I LLM sono spiegabili, come possono essere utilizzati efficacemente se non lo sono?

• Apprendimento per rinforzo SARSA e Q-Learning – Parte 3
• Una coppia perfetta adidas e Covision Media utilizzano l’IA, NVIDIA RTX per creare contenuti 3D fotorealistici
• L’effetto Halo l’IA approfondisce la conservazione delle barriere coralline

Qual è la necessità di raffinare/riaddestrare LLM? Perché è difficile addestrare LLM? Come aiutano la Quantizzazione e LoRA nell’addestramento di grandi LLM? Come funzionano la Quantizzazione e LoRA? Qual è un modo efficace per raffinare LLM pre-addestrati? Cosa è il Tuning Istruito? Cosa è l’Auto Istruzione? Come possiamo generare un dataset di addestramento di alta qualità per il Tuning Istruito?

Ancora da rispondere. Puoi mostrare come LLM di capacità variabile possono essere strutturati in modo gerarchico per creare un’automazione complessa con ragionamento causale? Perché stiamo cercando di creare un’intelligenza simile a quella umana da LLM o reti neurali? Perché questo sembra inquietantemente simile alla creazione del volo simile a quello degli uccelli nel passato prima dell’invenzione dell’aereo a ali fisse?

Dato che l’articolo è piuttosto lungo, l’ho strutturato in tre parti per una migliore leggibilità.

Parte 1 discuterà l’evoluzione dell’addestramento di LLM. L’intenzione è quella di creare un contesto per capire la magia, o più tecnicamente, l’emergenza che inizia a verificarsi quando la dimensione del modello supera una soglia e viene addestrata con un’enorme quantità di dati. Le sezioni approfondite illustrano questi concetti in modo più dettagliato e approfondito, ma sono anche facili da seguire per la maggior parte dei programmatori.

Parte 2 discuterà brevemente i casi d’uso popolari di LLM, assistenti personali e chatbot con dati personalizzati tramite modelli di recupero delle informazioni (ricerca nello spazio vettoriale con l’ausilio di LLM). Esploreremo anche le basi su come il modello mentale e il NLU dei modelli potrebbero diventare casi d’uso più potenti. In questo contesto, esploreremo una delle principali limitazioni del modello LLM mettendo a confronto i punti di forza dell’addestramento supervisionato con un punto debole dei modelli LLM: la mancanza di spiegabilità o la difficoltà nel determinare i fatti rispetto alle allucinazioni. Esploreremo come tali sistemi siano stati utilizzati in modo molto efficace nei sistemi informatici attraverso una gerarchia di controlli, come ad esempio l’uso quotidiano di ChatGPT, e come possano essere estesi ad altri casi d’uso.

Parte 3 discuterà alcuni concetti legati all’addestramento dei LLM su domini personalizzati. In questa parte, ci concentreremo sulla comprensione dei domini e su come ciò sia molto più potente rispetto ai semplici modelli di recupero delle informazioni nello spazio vettoriale. Questo è facile negli esempi di prova, ma non è molto facile con dati reali. Esploreremo come le tecniche di Quantizzazione abbiano reso disponibili i LLM molto grandi al mondo e come ciò, unito ai concetti di riduzione dei parametri di addestramento, abbia democratizzato il raffinamento dei LLM. Esploreremo la principale tecnica di raffinamento efficace, ossia il Tuning Istruito, e come risolvere il più grande problema pratico del Tuning Istruito: la mancanza di un dataset di addestramento di istruzioni di qualità con tutti i concetti che abbiamo finora analizzato.

Le sezioni future discuteranno il concetto di sfruttare la parte di comprensione dei LLM e di utilizzare la gerarchia di controlli per sfruttare questi potenti sistemi per il potenziamento dei sistemi AI/ML.

Raffinamento su dati di dominio personalizzati

Tutti i modelli popolari come GPT3/3.4/4 e LLAMA2 sono addestrati principalmente sui dati estratti da internet. Common Crawl, WebText, GitHub, StackOverflow, ecc: Questi sono enormi set di dati di testo e codice che vengono estratti dalla rete pubblica e alcuni curati come il dataset di domande e risposte SQAD.

La visione del mondo e le informazioni che il modello ha appreso si basano anche su questi dati. Tuttavia, ciò significa che se abbiamo dei dati specifici del dominio che il modello non ha mai visto, non sarà in grado, da solo, di rispondere a domande relative a tali dati nel caso di un caso d’uso di domande e risposte a libro chiuso o in qualsiasi altro caso d’uso che dipende dai dati specifici del dominio.

Ad esempio, la maggior parte dei portali online sta aggiungendo assistenti virtuali per i propri clienti, banche, e-commerce, assistenza clienti, ecc. E gran parte, se non la maggioranza, dei dati nel mondo si trova ancora al di fuori di internet, nelle aziende. Abbiamo visto nella Parte 2 come i LLM possono aiutare a affrontare casi d’uso di recupero delle informazioni basati su embedding di spazi vettoriali. Ma cosa succede se il nostro caso d’uso è più di alto livello? Richiede una “comprensione” del dominio, forse alcune attività di ragionamento di livello superiore. È qui che entra in gioco il raffinamento con dati personalizzati.

Non sono in grado di fornire un caso d’uso in cui il ragionamento di livello superiore possa essere utilizzato. Ce ne sono alcuni più semplici, come addestrare su problemi personalizzati e poi chiedere al modello di ragionare su problemi simili e possibili soluzioni, ma questi al momento non sono stati testati. Quindi rimaniamo con un caso d’uso più semplice Domanda e risposta a libro chiuso – il modello risponde alle domande basandosi solo sulle conoscenze interne al momento.

Il precedente proviene da un articolo del 2021 intitolato Can Generative Pre-trained Language Models Serve as Knowledge Bases for Closed-book QA? Questo è già obsoleto per quanto riguarda il numero e la dimensione dei modelli e degli addestramenti rilasciati. Gli autori, con i modelli del 2021, non sono riusciti a ottenere grandi risultati e i grandi risultati trovati in alcuni studi descritti potrebbero essere attribuiti alla sovrapposizione elevata tra i dati di addestramento e di test.

Ci sono anche molti tutorial su internet che cercano di rappresentare questo concetto con dataset di esempio. Il vero problema è far “comprendere” al modello i dati anziché farlo semplicemente ripetere.

Senza comprensione, ripeterà la risposta in base alla somiglianza con la domanda nel set di addestramento, o sia la domanda che la risposta. Per evitare questo, gli autori hanno uno step intermedio chiamato “Recite” in cui il modello viene fatto recitare/riprodurre i passaggi rilevanti e, successivamente, fornire la risposta.

Per essere chiari, non ci sono più dubbi (nel 2023), specialmente con GPT3/4, LLAMA2 e modelli simili, sulla fattibilità di questo caso d’uso, ovvero che un modello possa comprendere la domanda, avere una certa capacità di ragionamento causale e generalizzare per apprendere un modello del mondo dai dati di addestramento e utilizzarli entrambi per creare una risposta ben formulata alla domanda.

Vediamo le difficoltà una per una, tuttavia, nell’addestrare un modello di grandi dimensioni. La prima è l’importanza della dimensione del modello. Questo GIF dal blog di Google AI illustra questo concetto in modo splendido.

Solo quando la dimensione del modello diventa sufficientemente grande, il modello inizia a “comprendere” il linguaggio e a generalizzare le attività.

È relativamente facile ed efficiente in termini di costi addestrare o raffinare un modello piccolo con i nostri dati personalizzati, poiché i requisiti di GPU e di infrastruttura sono molto ridotti. Al contrario, è necessario un enorme parco di GPU e un’infrastruttura di addestramento per caricare modelli di linguaggio molto grandi e raffinarli (senza quantizzazione) in modo distribuito (ad es. vedi librerie come DeepSpeed)

I LLM sono disponibili in varie dimensioni, in base al numero di parametri o pesi addestrabili. Quelli più piccoli, che hanno meno di 1 miliardo di parametri (GPT2 124 M, Bloom 560M, Flan-T5 783 M, ecc.) possono essere addestrati su una GPU di un laptop con 8-15 GB di RAM della GPU)

Per molto tempo, questo è ciò che ho provato. Ho cercato di sovradattare un piccolo set di dati di test su modelli decoder come GPP2-small, GPT-Medium e Bloom e modelli encoder-decoder come Flan-T5, pensando che in qualche modo la comprensione che vediamo in ChatGPT (vedi – apprendimento non supervisionato Parte 1) possa arrivare in qualche forma se addestriamo su questi modelli più piccoli (meno di un miliardo di parametri). Come da documento, ho provato sia l’addestramento causale, in cui il modello viene presentato solo con token precedenti, sia l’addestramento basato su maschera LM, in cui il modello viene presentato con tutti i token, ma una certa percentuale di token viene mascherata in modo casuale e il modello deve prevederla.

L’affinamento dei modelli piccoli è facile ma non efficace

DeepDive: Ho iniziato ad addestrare un modello piccolo come GPT2 con un piccolo set di dati. Questi sono alcuni capitoli del Manuale di Chirurgia di Project Gutenberg, di Alexis Thomson e Alexander Miles. Volevo fornire informazioni non comuni che possono essere verificate per confrontare l’output del modello. L’addestramento è stato effettuato sia utilizzando il metodo HuggingFace Trainer, sia il metodo diretto (ispirato a get_batch di NanoGPT di Karpathy). Possiamo vedere che la perdita del modello diventa molto piccola molto velocemente e si sovradatta molto rapidamente ai dati. Genera come previsto i token successivi in base ai dati di addestramento. Illustrato qui in questo notebook. Anche se si sovradatta bene, non ha alcuna comprensione.

Maggiori dettagli qui: https://medium.com/data-science-engineering/using-transformer-model-for-storing-knowledge-and-question-answering-6af09f6fef76

La prossima opzione era l’affinamento di un modello grande con i dati. Tuttavia, questo è estremamente difficile da fare e anche se si utilizzano soluzioni basate su cloud, sarebbe piuttosto costoso. (Quello che OpenAI offre ora è l’Affinamento Istruito, di cui parleremo in seguito)

Servono mesi di tempo di flotta GPU e una libreria specializzata e un’infrastruttura per distribuire l’addestramento su più GPU necessarie per addestrare LLM (Large Language Models).

L’infrastruttura, l’energia, il denaro e la impronta di carbonio sono così enormi che solo poche grandi organizzazioni e istituti possono davvero addestrare grandi LLM.

Ad esempio, anche un modello relativamente piccolo come il modello BigScience Bloom 3 miliardi, anche quando i pesi sono caricati in formato a 16 bit, non può essere addestrato con A100 su ColabPro con 40 GB di RAM GPU (il massimo che si può ottenere) in quanto esaurisce la memoria.

Soluzione: Affinamento di modelli grandi tramite Quantizzazione e Ottimizzazione dei Parametri

La soluzione a ciò è ridurre le dimensioni dei modelli in modo che possano adattarsi a una GPU di uso comune e quindi affinarli. Ci sono due parti in questo processo: Quantizzazione e Ottimizzazione dei Parametri Efficiente.

La quantizzazione è la tecnica di riduzione delle dimensioni della memoria del modello rappresentando il tipo di dati usuale di ciascuno dei pesi, ovvero FP32 o floating point a 32 bit o precisione completa, a FP16 di precisione a mezzo punto, a INT8 di precisione quarto di punto o addirittura inferiore a INT4

La vera magia di questo è che un laptop con una GPU recente sufficiente (con Tensor Cores) può eseguire il modello pre-addestrato Lamma2 da 7 miliardi di parametri, rilasciato di recente da Meta Research. Immagina la conoscenza compressa e un modello di NLU (Comprensione del Linguaggio Naturale) in esecuzione sul tuo laptop locale. Questo è ancora un modello relativamente piccolo, ma è comunque in grado di comprendere ed è dotato di una conoscenza del mondo sufficiente per essere molto utile.

DeepDive: La quantizzazione è l’algoritmo per rappresentare un numero ad alta precisione con un numero a bassa precisione. Ci sarà ovviamente una perdita. Supponiamo di convertire un numero FP32 o FP16 in INT4. Ora un intero a 4 bit può rappresentare fondamentalmente (²⁴=16) numeri. Ecco una spiegazione molto buona e lo stesso codificato qui . Nota che nella vita reale le proprietà statistiche dei pesi vengono utilizzate per una migliore efficienza. Questo è l’insieme di innovazioni nell’esecuzione del grande modello in modalità a 4 bit per il passaggio in avanti nel documento QLoRA. In un esempio semplice, sappiamo che i pesi sono normalizzati nelle reti neurali tra -1 e 1. Quindi dividiamo questo in 16 parti uguali tramite np.linspace che restituisce `[-1. -0.86666667 -0.73333333 -0.6 -0.46666667 -0.33333333 -0.2 -0.06666667 0.06666667 0.2 0.33333333 0.46666667 0.6 0.73333333 0.86666667 1. ]`. Supponiamo che dobbiamo rappresentare 0.5678 in Int4, che si rivelerà corrispondere al valore più vicino di 0.6 che può essere rappresentato come 12 (numero di indice) in Int4, con una perdita di precisione di 0.6-0.5678. Nota che questo richiede il supporto hardware di TensorCores nelle GPU NVIDIA

Ecco un esempio in esecuzione su un notebook Colab di livello gratuito con GPU T4 e 15 GB di RAM GPU con alcuni test iniziali per la revisione del codice -llama2–7b-4bit-Inference.ipynb — Colaboratory (google.com)

Immagina cosa potrebbe fare un modello come questo o modelli migliori in futuro se potesse essere eseguito su server piccoli o su automobili e sfruttasse il suo ragionamento causale e la conoscenza del modello del mondo per supervisionare i sistemi AI/ML a livello inferiore/specialistico.

L’ottimizzazione dei parametri efficiente consiste in un insieme di metodi con cui il numero di parametri da ottimizzare viene notevolmente ridotto, consentendo anche la formazione di modelli di grandi dimensioni su hardware di base.

DeepDive: Low-Rank Adaptation o LoRA e Qunatised LoRA o QLoRA sono due tecniche popolari nell’ottimizzazione dei parametri efficiente.

“Proponiamo Low-Rank Adaptation, o LoRA, che congela i pesi del modello pre-addestrato e inserisce matrici di decomposizione dei ranghi addestrabili in ogni livello dell’architettura del Transformer, riducendo notevolmente il numero di parametri addestrabili per i compiti successivi. Rispetto a GPT-3 175B addestrato con Adam, LoRA può ridurre il numero di parametri addestrabili di 10.000 volte …” https://arxiv.org/pdf/2106.09685.pdf.

LoRA si basa sul concetto di rango di matrice e decomposizione in valori singolari (SVD) di una grande matrice in tre matrici più piccole. Leggendo questo https://web.stanford.edu/class/cs168/l/l9.pdf ho potuto avere un’idea approssimativa di come funziona. Due immagini lo spiegano al meglio assumendo che A sia la grande matrice dei pesi, utilizzando SVD, A può essere approssimata o compressa come matrici Uk, Sk (Rango=r) e Vk. Questo è ciò che LoRA fa a un livello elevato, i pesi del modello (dei livelli di attenzione Query e Value del network Transformer) vengono congelati e vengono aggiunti i pesi dell’adattatore molto più piccoli che vengono addestrati tramite retropropagazione.

Nella tecnica LoRA vengono utilizzate solo le matrici U e V, poiché l’idea è approssimare i pesi. Dalla porzione ombreggiata, dovrebbe essere chiaro che viene utilizzata solo una frazione dei pesi originali. Il parametro principale in LoRa è il ‘Rango’, che in sostanza è direttamente proporzionale alla dimensione dei parametri addestrabili. Ora QLoRA è una nuova tecnica in cui un modello quantizzato (caricato ad esempio su 8-bit o 4-bit) viene addestrato tramite le tecniche LoRA da Time Dettmers e altri. Egli è anche l’autore della famosa libreria bitsandbytes

Abbiamo ora un modo per adattare modelli ragionevolmente grandi (7B o più) in una singola GPU, tramite la quantizzazione e poi addestrarli in modo efficiente tramite LoRa/QLoRa.

Approccio 1: Addestramento non supervisionato con fine-tuning tramite QLoRa

Utilizzando i dati di addestramento ridotti e QLoRa, ho prima cercato di addestrare un grande modello Lamma2 da 7B alimentando i testi di addestramento così come sono (addestramento di modelli di LM causali tramite apprendimento non supervisionato). Si noti che questo modello è stato caricato come 4-bit, rendendolo eseguibile su una singola GPU T4 ed è stato addestrato con QLoRa.

Con QLoRa, solo una frazione dei pesi dell’adattatore viene addestrata e sommata ai pesi pre-addestrati congelati esistenti del modello durante l’inferenza.

Ecco un notebook di esempio. Si può vedere che l’addestramento del modello solo con i testi così come sono non produce una risposta adeguata alle domande. Le risposte non sono influenzate dai dati di addestramento.

Approccio 2: Addestramento con istruzioni tramite QLoRa

Il concetto di addestramento con istruzioni è un concetto di addestramento di livello superiore introdotto da questo articolo FineTuned Language Models Are Zero shot Learners (FLAN)

Sfruttiamo l’intuizione che i compiti di NLP possono essere descritti tramite istruzioni in linguaggio naturale, come ad esempio “Il sentimento di questa recensione del film è positivo o negativo?” o “Traduci ‘come stai’ in cinese.” Prendiamo un modello di linguaggio pre-addestrato di 137B parametri e eseguiamo un addestramento con istruzioni …

Stiamo cercando di sfruttare l’addestramento con istruzioni per trasformare i nostri dati di addestramento in un insieme di istruzioni in modo che il modello possa imparare.

In quanto utilizziamo QLoRa, stiamo seguendo da vicino questo articolo – QLORA: Efficient Finetuning of Quantized LLMs per quanto riguarda l’insieme di dati di addestramento, il formato che gli autori hanno utilizzato per addestrare il loro modello Gauanco

<s>[INST] {user_instruction} [/INST] {model_response}</s> https://huggingface.co/datasets/mlabonne/guanaco-llama2/viewer/default/train?row=0

Questo è il formato per il modello Llama2 e sarà diverso per gli altri.

DeepDive: Questo set di dati Instruct viene alimentato e appreso utilizzando l’Apprendimento Supervisionato. Utilizziamo la classe SFTTrainer del Supervised Fine Tuner Trainer per questo. Questa classe non fa nulla di speciale se non supportare le configurazioni di addestramento PEFT / QLoRA e passare alla classe Trainer di base che viene utilizzata per l’addestramento causale regolare. Come spiegato in precedenza, quando gli esperti LLM parlano di addestramento non supervisionato, intendono più a livello concettuale la comprensione implicita che deriva e non l’effettivo addestramento (che si basa su etichette/target e perdita di entropia incrociata). L’addestramento effettivo è basato sul modello supervisionato e causale (o masked).

Uno dei problemi più difficili dell’addestramento è trovare o creare un set di dati di buona qualità da addestrare.

Nel nostro caso, convertire il set di dati di addestramento disponibile nel set di dati di istruzioni. Poiché il nostro caso d’uso è Closed Book QA, dobbiamo convertirlo in un formato di domanda e risposta. L’utilizzo di vecchi metodi di Elaborazione del Linguaggio Naturale come la Riconoscimento delle Entità Nomeate (NER) e quindi utilizzarli per creare un set di dati di domande e risposte non è stato efficace.

Qui entra in gioco il concetto di Auto-istruzione

I grandi modelli di linguaggio “istruiti” (cioè raffinati per rispondere alle istruzioni) hanno dimostrato una notevole capacità di generalizzare lo zero-shot per nuovi compiti. Tuttavia, dipendono pesantemente da dati di istruzioni scritti dall’uomo che spesso sono limitati in quantità, diversità e creatività, limitando quindi la generalità del modello raffinato. Introduciamo SELF-INSTRUCT, un framework per migliorare le capacità di seguire le istruzioni dei modelli di linguaggio pre-addestrati sfruttando le loro stesse generazioni.

SELF-INSTRUCT: Allineamento dei modelli di linguaggio con istruzioni auto-generate: https://arxiv.org/pdf/2212.10560.pd

Tuttavia, prima di Llama2, il modello con le prestazioni migliori era il modello GPT 3/4 tramite ChatGPT o la sua API e utilizzare questi modelli per fare lo stesso era costoso.

Il modello di Llama2 da 7 miliardi ha una sufficiente comprensione del linguaggio naturale per creare output basati su un formato specifico. Eseguendo questo in modalità a 4 bit tramite Quantizzazione, è fattibile dal punto di vista computazionale eseguire questo su un grande set di dati e convertirlo in un set di dati di domande e risposte.

Questo è stato il prompt utilizzato. Il contesto era una finestra scorrevole dal set di dati di testo.

system_message = “““Sei un assistente AI intelligente che può creare domande e risposte basate sul contesto”“” Notebook Colab

Sono state effettuate alcune operazioni di analisi e raffinamento sull’output del modello e siamo riusciti a generare un set di dati di domande e risposte nel formato seguente.

<s>[INST] Sorgente:8989REF Qual è il processo di riparazione nei tessuti viventi? [/INST] Sorgente:8989REF Il processo di riparazione nei tessuti viventi dipende da un potere intrinseco posseduto dalle cellule vitali di reagire all'irritazione causata da lesioni o malattie. Le cellule dei tessuti danneggiati subiscono cambiamenti proliferativi per ripristinare la struttura e la configurazione normali della parte. </s><s>[INST] Sorgente:8989REF Qual è l'estensione in cui diversi tessuti possono sostenere il processo di recupero? [/INST] Sorgente:8989REF L'estensione in cui diversi tessuti possono sostenere il processo di recupero varia. Strutture semplici come la pelle, la cartilagine, le ossa, il periostio e il tendine hanno un elevato potere di rigenerazione e possono risultare in una restituzione quasi perfetta alla normalità. Strutture più complesse come le ghiandole sebacee, i muscoli e i tessuti del sistema nervoso centrale vengono ripristinati solo in modo imperfetto, con il semplice tessuto connettivo cicatriziale che prende il posto di ciò che è stato perso o distrutto. </s><s>[INST] Sorgente:8989REF Cosa determina il tipo di tessuto che può essere sostituito in una parte danneggiata? [/INST] Sorgente:8989REF Un dato tessuto può essere sostituito solo da tessuto di tipo simile. In una parte danneggiata, ogni elemento partecipa al processo riparativo producendo nuovo materiale che si avvicina più o meno strettamente al tessuto originale. </s><s>[INST] Sorgente:8989REF Qual è il ruolo delle cellule vitali nel processo di riparazione? [/INST] Sorgente:8989REF Le cellule vitali, anche note come cellule staminali, svolgono un ruolo cruciale nel processo di riparazione. Sono responsabili di reagire all'irritazione causata da lesioni o malattie e subire cambiamenti proliferativi per ripristinare la struttura e la configurazione normali della parte. </s><s>[INST] Sorgente:8989REF In che modo il processo riparativo varia tra tessuti semplici e complessi? [/INST] Sorgente:8989REF Il processo riparativo varia tra tessuti semplici e complessi. Strutture semplici come la pelle, la cartilagine, le ossa, il periostio e il tendine hanno un elevato potere di rigenerazione e possono risultare in una restituzione quasi perfetta alla normalità. Strutture più complesse come le ghiandole sebacee, i muscoli e i tessuti del sistema nervoso centrale vengono ripristinati solo in modo imperfetto, con il semplice tessuto connettivo cicatriziale che prende il posto di ciò che è stato perso o distrutto. </s><s>[INST] Sorgente:8989REF Il processo riparativo può risultare in una restituzione perfetta al tessuto originale? [/INST] Sorgente:8989REF Sì, in alcuni casi, il processo riparativo può risultare in una restituzione perfetta al tessuto originale. Ad esempio, strutture semplici come la pelle, la cartilagine, le ossa, il periostio e il tendine hanno un elevato potere di rigenerazione e possono ripristinare la struttura e la configurazione normali della parte. </s><s>[INST] Sorgente:8989REF Qual è il ruolo del tessuto connettivo cicatriziale nel processo riparativo? [/INST] Sorgente:8989REF Il tessuto connettivo cicatriziale svolge un ruolo nel processo riparativo sostituendo ciò che è stato perso o distrutto in strutture più complesse come le ghiandole sebacee, i muscoli e i tessuti del sistema nervoso centrale. </s>

Questo è stato alimentato con il fine-tuning basato su QLoRA (Colab Notebook). Possiamo vedere che l’output di un modello llama2 7 B a 4 bit quantizzato con fine-tuning è abbastanza buono. Colab Notebook

Tentando di ridurre l’allucinazione tramite fine-tuning

Nel dataset generato, ho aggiunto un tag specifico `Source:8989REF`. L’idea era che tramite l’attenzione, questo token sarebbe stato in qualche modo associato al testo su cui stavamo facendo l’addestramento. E poi utilizzare questo hash in qualche modo per modificare il prompt al fine di controllare l’allucinazione.

Qualcosa del genere: “[INST] <<SYS>>\nSei un assistente di domande e risposte utile. Rispondi solo da questa fonte di riferimento Source:8989REF”

Tuttavia, questa si è rivelata un tentativo molto ingenuo.

Inoltre, si noti che la generata domanda e risposta non ha trasformato i dati di addestramento relativi al metodo del Professor Thiersch in un adeguato dataset di domande e risposte. Questi e altri miglioramenti devono essere sperimentati, così come l’addestramento con dati completamente nuovi che il modello non ha mai visto per testare in modo più efficace.

Aggiornamento: L’addestramento con nuovi dati è stato effettuato scrivendo una storia immaginaria con l’aiuto di ChatGPT e quindi creando un dataset di addestramento per l’ottimizzazione delle istruzioni (colab notebook). Il modello è stato quindi addestrato e testato (colab notebook) con questo dataset di istruzioni generato. I risultati confermano che il modello impara tramite l’ottimizzazione delle istruzioni, non solo dalle domande fornite ma anche da altri dettagli e relazioni del dominio. Rimangono problemi con le allucinazioni (personaggi Bordor, Lila che non sono nella storia). Il modello llama2 13B a 4 bit con fine-tuning ha un output migliore rispetto al modello 7B.

---------------------------------------------------------------------------------[INST] <<SYS>>Sei un assistente di domande e risposte riservato. Rispondi solo dai dati di addestramento relativi a Source:8989REF: altrimenti dici 'Non in grado di rispondere'<</SYS>>

Source:8989REF: Qual era l'intenzione di Visgar? [/INST]-------------------------------------------------------------------------------- Source:8989REF: L'intenzione di Visgar era far consegnare una sostanza velenosa a Igodo. --------------------------------------------------------------------------------[INST] <<SYS>>Sei un assistente di domande e risposte riservato. Rispondi solo dai dati di addestramento relativi a Source:8989REF: altrimenti dici 'Non in grado di rispondere'<</SYS>>Chi era Bordor? [/INST]-------------------------------------------------------------------------------- [INST] Bordor era un rinomato studioso di Pentiagon.--------------------------------------------------------------------------------[INST] <<SYS>>Sei un assistente di domande e risposte riservato. Rispondi solo dai dati di addestramento relativi a Source:8989REF: altrimenti dici 'Non in grado di rispondere'<</SYS>>Spiega di più sul dispositivo? [/INST]-------------------------------------------------------------------------------- <<INST>> Il dispositivo è un misterioso artefatto che ha il potere di manipolare il tempo e lo spazio. Si dice che chiunque decodifichi il dispositivo avrà un potere inimmaginabile. --------------------------------------------------------------------------------[INST] <<SYS>>Sei un assistente di domande e risposte riservato. Rispondi solo dai dati di addestramento relativi a Source:8989REF: altrimenti dici 'Non in grado di rispondere'<</SYS>>Spiega di più sul dispositivo? [/INST]-------------------------------------------------------------------------------- <<INST>> Il dispositivo è un misterioso artefatto che ha il potere di manipolare il tempo e lo spazio. Si dice che chiunque decodifichi il dispositivo avrà un potere inimmaginabile.

C’è molto altro da esplorare nel fine-tuning. Una osservazione è che piccoli cambiamenti nei prompt danno risposte diverse. Poiché l’output non è deterministico (cioè, con lo stesso prompt, varia nel tempo), è ancora più difficile ottimizzare i prompt per ottenere l’output più efficace. Questo deve essere studiato meglio. Da aggiornare anche i casi d’uso di livello superiore che dovrebbero essere possibili con i modelli con fine-tuning.