mirror of
https://github.com/dair-ai/Prompt-Engineering-Guide
synced 2024-11-10 01:13:36 +00:00
Merge pull request #354 from giornaledisistema/giornaledisistema-patch-3
Updated Italian translation
This commit is contained in:
Elvis Saravia
GitHub
commit
d6449e7f35
@ -1,5 +1,91 @@
|
||||
# Tecniche di Prompting
|
||||
|
||||
A questo punto, dovrebbe essere ovvio che è utile migliorare i prompt per ottenere risultati migliori su compiti diversi. Questa è l'idea alla base dell'ingegneria dei prompt.
|
||||
import {Cards, Card} from 'nextra-theme-docs'
|
||||
import { CardsIcon, OneIcon, WarningIcon, FilesIcon} from 'components/icons'
|
||||
|
||||
Se gli esempi di base sono stati divertenti, in questa sezione tratteremo tecniche più avanzate di ingegneria dei prompt, che ci permettono di realizzare compiti più complessi e interessanti.
|
||||
L'ingegneria dei prompt aiuta a progettare e migliorare efficacemente i prompt per ottenere risultati migliori in diversi compiti con gli LLM.
|
||||
|
||||
Se gli esempi di base sono stati divertenti, in questa sezione tratteremo tecniche più avanzate di ingegneria dei prompt, che ci permettono di realizzare compiti più complessi e di migliorare l'affidabilità e le prestazioni degli LLM.
|
||||
|
||||
<Cards>
|
||||
<Card
|
||||
icon={<FilesIcon />}
|
||||
title="Zero-Shot Prompting"
|
||||
href="/techniques/zeroshot"
|
||||
/>
|
||||
<Card
|
||||
icon={<FilesIcon />}
|
||||
title="Few-Shot Prompting"
|
||||
href="/techniques/fewshot"
|
||||
/>
|
||||
<Card
|
||||
icon={<FilesIcon />}
|
||||
title="Chain-of-Thought Prompting"
|
||||
href="/techniques/cot"
|
||||
/>
|
||||
<Card
|
||||
icon={<FilesIcon />}
|
||||
title="Self-Consistency"
|
||||
href="/techniques/consistency"
|
||||
/>
|
||||
<Card
|
||||
icon={<FilesIcon />}
|
||||
title="General Knowledge Prompting"
|
||||
href="/techniques/knowledge"
|
||||
/>
|
||||
<Card
|
||||
icon={<FilesIcon />}
|
||||
title="Prompt Chaining"
|
||||
href="/techniques/prompt_chaining"
|
||||
/>
|
||||
<Card
|
||||
icon={<FilesIcon />}
|
||||
title="Tree of Thoughts Prompting"
|
||||
href="/techniques/tot"
|
||||
/>
|
||||
<Card
|
||||
icon={<FilesIcon />}
|
||||
title="Retrieval Augmented Generation"
|
||||
href="/techniques/rag"
|
||||
/>
|
||||
<Card
|
||||
icon={<FilesIcon />}
|
||||
title="Automatic Reasoning and Tool-Use"
|
||||
href="/techniques/art"
|
||||
/>
|
||||
<Card
|
||||
icon={<FilesIcon />}
|
||||
title="Automatic Prompt Engineer"
|
||||
href="/techniques/ape"
|
||||
/>
|
||||
<Card
|
||||
icon={<FilesIcon />}
|
||||
title="Active-Prompt"
|
||||
href="/techniques/activeprompt"
|
||||
/>
|
||||
<Card
|
||||
icon={<FilesIcon />}
|
||||
title="Direct Stimulus Prompting"
|
||||
href="/techniques/dsp"
|
||||
/>
|
||||
<Card
|
||||
icon={<FilesIcon />}
|
||||
title="Program-Aided Language"
|
||||
href="/techniques/pal"
|
||||
/>
|
||||
<Card
|
||||
icon={<FilesIcon />}
|
||||
title="ReAct"
|
||||
href="/techniques/react"
|
||||
/>
|
||||
<Card
|
||||
icon={<FilesIcon />}
|
||||
title="Multimodal CoT"
|
||||
href="/techniques/multimodalcot"
|
||||
/>
|
||||
<Card
|
||||
icon={<FilesIcon />}
|
||||
title="Graph Prompting"
|
||||
href="/techniques/graph"
|
||||
/>
|
||||
</Cards>
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
# Self-Consistency
|
||||
|
||||
Forse una delle tecniche più avanzate per l'ingegneria del prompt è l'autoconsistenza. Proposta da [Wang et al. (2022)](https://arxiv.org/pdf/2203.11171.pdf), l'autoconsistenza mira a "sostituire l'ingenua decodifica avida utilizzata nel prompt a catena di pensieri". L'idea è quella di campionare percorsi di ragionamento multipli e diversificati attraverso la CoT a pochi colpi e di utilizzare le generazioni per selezionare la risposta più coerente. Questo aiuta a migliorare le prestazioni della richiesta di CoT su compiti che coinvolgono l'aritmetica e il ragionamento di senso comune.
|
||||
Forse una delle tecniche più avanzate per l'ingegneria del prompt è l'autoconsistenza. Proposta da [Wang et al. (2022)](https://arxiv.org/pdf/2203.11171.pdf), l'autoconsistenza mira a "sostituire l'ingenua decodifica avida utilizzata nel prompt a catena di pensieri". L'idea è quella di campionare percorsi di ragionamento multipli e diversificati attraverso la few-shot CoT e di utilizzare le generazioni per selezionare la risposta più coerente. Questo aiuta a migliorare le prestazioni dei prompt CoT su compiti che coinvolgono l'aritmetica e il ragionamento di senso comune.
|
||||
|
||||
Proviamo il seguente esempio di ragionamento aritmetico:
|
||||
|
||||
@ -15,24 +15,21 @@ Ora ho 70 anni, quanti ne ha mia sorella?
|
||||
35
|
||||
```
|
||||
|
||||
L'output è sbagliato! Come possiamo migliorare questo risultato con l'autoconsistenza? Proviamo. Utilizzeremo gli esempi di pochi scatti di Wang et al. 2022 (Tabella 17):
|
||||
L'output è sbagliato! Come possiamo migliorare questo risultato con l'autoconsistenza? Proviamo. Utilizzeremo gli esempi few-shot di Wang et al. 2022 (Tabella 17):
|
||||
|
||||
*Prompt:*
|
||||
```
|
||||
D: Nel boschetto ci sono 15 alberi. Gli operai del boschetto pianteranno gli alberi oggi. Quando avranno finito,
|
||||
ci saranno 21 alberi. Quanti alberi hanno piantato oggi gli operai del boschetto?
|
||||
D: Nel boschetto ci sono 15 alberi. Gli operai del boschetto pianteranno gli alberi oggi. Quando avranno finito, ci saranno 21 alberi. Quanti alberi hanno piantato oggi gli operai del boschetto?
|
||||
R: Iniziamo con 15 alberi. Successivamente abbiamo 21 alberi. La differenza deve essere il numero di alberi che hanno piantato. Quindi, devono aver piantato 21 - 15 = 6 alberi. La risposta è 6.
|
||||
|
||||
D: Se ci sono 3 auto nel parcheggio e ne arrivano altre 2, quante auto ci sono nel parcheggio?
|
||||
R: Ci sono già 3 macchine nel parcheggio. Ne arrivano altre 2. Ora ci sono 3 + 2 = 5 auto. La risposta è 5.
|
||||
|
||||
D: Leah aveva 32 cioccolatini e sua sorella 42. Se ne hanno mangiati 35, quanti pezzi sono rimasti in totale?
|
||||
R: Leah aveva 32 cioccolatini e la sorella di Leah ne aveva 42. Ciò significa che in origine c'erano 32 + 42 = 74
|
||||
cioccolatini. 35 sono stati mangiati. Quindi in totale hanno ancora 74 - 35 = 39 cioccolatini. La risposta è 39.
|
||||
R: Leah aveva 32 cioccolatini e la sorella di Leah ne aveva 42. Ciò significa che in origine c'erano 32 + 42 = 74 cioccolatini. 35 sono stati mangiati. Quindi in totale hanno ancora 74 - 35 = 39 cioccolatini. La risposta è 39.
|
||||
|
||||
D: Jason aveva 20 lecca-lecca. Ha dato a Denny alcuni lecca-lecca. Ora Jason ha 12 lecca-lecca. Quanti lecca-lecca Jason ha dato a Denny?
|
||||
R: Jason aveva 20 lecca-lecca. Poiché ora ne ha solo 12, deve aver dato il resto a Denny. Il numero di
|
||||
lecca-lecca che ha dato a Denny deve essere 20 - 12 = 8 lecca-lecca. La risposta è 8.
|
||||
R: Jason aveva 20 lecca-lecca. Poiché ora ne ha solo 12, deve aver dato il resto a Denny. Il numero di lecca-lecca che ha dato a Denny deve essere 20 - 12 = 8 lecca-lecca. La risposta è 8.
|
||||
|
||||
D: Shawn ha cinque giocattoli. Per Natale ha ricevuto due giocattoli ciascuno da mamma e papà. Quanti giocattoli ha ora?
|
||||
R: Ha 5 giocattoli. Ne ha ricevuti 2 dalla mamma, quindi ha 5 + 2 = 7 giocattoli. Poi ne ha ricevuti altri 2 dal papà, quindi in totale ha 7 + 2 = 9 giocattoli. La risposta è 9.
|
||||
@ -43,10 +40,10 @@ R: Ci sono 4 giorni da lunedì a giovedì. Ogni giorno sono stati aggiunti 5 com
|
||||
D: Michael aveva 58 palline da golf. Martedì ha perso 23 palline da golf. Mercoledì ha perso altre 2 palline. Quante palline da golf alla fine di mercoledì?
|
||||
R: Michael aveva inizialmente 58 palline. Martedì ne ha perse 23, quindi ha 58 - 23 = 35 palline. Il mercoledì ne ha perse altre 2, quindi ora ha 35 - 2 = 33 palline. La risposta è 33.
|
||||
|
||||
D: Olivia ha 23 euro e ha comprato cinque bagel a 3 euro l'uno. Quanti soldi le sono rimasti?
|
||||
R: Ha comprato 5 bagel a 3 euro l'uno. Ciò significa che ha speso 5
|
||||
D: Olivia ha 23 dollari e ha comprato cinque bagel a 3 dollari l'uno. Quanti soldi le rimangono?
|
||||
R: Ha comprato 5 bagel a 3 dollari l'uno. Ciò significa che ha speso 15 dollari. Le rimangono 8 dollari.
|
||||
|
||||
D: Quando avevo 6 anni mia sorella aveva la metà dei miei anni. Ora che ho 70 anni, quanti ne ha mia sorella?
|
||||
D: Quando avevo 6 anni mia sorella aveva la metà dei miei anni. Ora che ho 70 anni, quanti anni ha mia sorella?
|
||||
R:
|
||||
```
|
||||
|
||||
|
||||
@ -1,15 +1,16 @@
|
||||
# Prompt Chain-of-Thought
|
||||
|
||||
import { Callout } from 'nextra/components'
|
||||
import {Screenshot} from 'components/screenshot'
|
||||
import COT from '../../img/cot.png'
|
||||
import ZEROCOT from '../../img/zero-cot.png'
|
||||
import AUTOCOT from '../../img/auto-cot.png'
|
||||
|
||||
## Prompt Chain-of-Thought (CoT)
|
||||
|
||||
## Chain-of-Thought (CoT) Prompt
|
||||
<Screenshot src={COT} alt="CoT" />
|
||||
|
||||
<Screenshot src={COT} alt="COT" />
|
||||
|
||||
sorgente immagine: [Wei et al. (2022)](https://arxiv.org/abs/2201.11903)
|
||||
Fonte immagine: [Wei et al. (2022)](https://arxiv.org/abs/2201.11903)
|
||||
|
||||
Introdotto in [Wei et al. (2022)](https://arxiv.org/abs/2201.11903), il prompt a catena di pensieri (CoT) consente di ottenere capacità di ragionamento complesse attraverso fasi di ragionamento intermedie. Si può combinare con il prompt few-shot per ottenere risultati migliori su compiti più complessi che richiedono un ragionamento prima di rispondere.
|
||||
|
||||
@ -54,13 +55,13 @@ La somma dei numeri dispari (15, 5, 13, 7, 1) è 41. La risposta è Falsa.
|
||||
|
||||
Si tenga presente che gli autori sostengono che si tratta di una capacità emergente che si manifesta con modelli linguistici sufficientemente grandi.
|
||||
|
||||
## Zero-shot COT Prompting
|
||||
## Prompt Zero-shot CoT
|
||||
|
||||
<Screenshot src={ZEROCOT} alt="Zero-shot COT" />
|
||||
<Screenshot src={ZEROCOT} alt="Zero-shot CoT" />
|
||||
|
||||
sorgente immagine: [Kojima et al. (2022)](https://arxiv.org/abs/2205.11916)
|
||||
Fonte immagine: [Kojima et al. (2022)](https://arxiv.org/abs/2205.11916)
|
||||
|
||||
Un'idea emersa più di recente è quella della [zero-shot CoT](https://arxiv.org/abs/2205.11916) (Kojima et al. 2022) che consiste essenzialmente nell'aggiungere "Pensiamo passo dopo passo" al prompt originale. Proviamo un problema semplice e vediamo come si comporta il modello:
|
||||
Un'idea emersa più di recente è quella della [zero-shot CoT](https://arxiv.org/abs/2205.11916) (Kojima et al. 2022) che consiste essenzialmente nell'aggiungere la frase "Pensiamo passo dopo passo" al prompt originale. Proviamo un problema semplice e vediamo come si comporta il modello:
|
||||
|
||||
*Prompt:*
|
||||
```
|
||||
@ -83,10 +84,29 @@ Pensiamo passo dopo passo.
|
||||
|
||||
*Output:*
|
||||
```
|
||||
In primo luogo, si è partiti da 10 mele.
|
||||
Innanzitutto, si è partiti da 10 mele.
|
||||
Hai dato via 2 mele al vicino e 2 all'operaio, quindi ti sono rimaste 6 mele.
|
||||
Poi ha comprato altre 5 mele, per cui ora ne ha 11.
|
||||
Infine, avete mangiato 1 mela, quindi ti rimarranno 10 mele.
|
||||
Poi hai comprato altre 5 mele, per cui ora ne hai 11.
|
||||
Infine, hai mangiato 1 mela, quindi ti sono rimaste 10 mele.
|
||||
```
|
||||
|
||||
È impressionante come questo semplice prompt sia efficace nello svolgere questo compito. Dimostra di essere particolarmente utile quando non si hanno molti esempi da utilizzare nel prompt.
|
||||
|
||||
## Chain-of-Thought automatico (Auto-CoT)
|
||||
|
||||
Quando si applica il prompt a catena di pensieri tramite spiegazioni, il processo comporta la creazione manuale di esempi efficaci e diversi. Questo sforzo manuale potrebbe portare a soluzioni non ottimali. [Zhang et al. (2022)](https://arxiv.org/abs/2210.03493) propongono un approccio per eliminare gli sforzi manuali sfruttando gli LLM con il prompt "Pensiamo passo dopo passo" per generare catene di ragionamento per le dimostrazioni una per una. Questo processo automatico può comunque portare a errori nelle catene generate. Per mitigare gli effetti degli errori, è importante la diversità delle spiegazioni. Questo lavoro propone Auto-CoT, che campiona domande diverse e genera catene di ragionamento per costruire le spiegazioni.
|
||||
|
||||
L'Auto-CoT si compone di due fasi principali:
|
||||
|
||||
- Fase 1): **suddivisione (clustering) delle domande**: suddividere le domande di un dato insieme di dati in gruppi (cluster)
|
||||
- Fase 2): **campionamento**: selezionare una domanda rappresentativa da ogni cluster e generare la relativa catena di ragionamento utilizzando Zero-Shot-CoT con semplici euristiche
|
||||
|
||||
Semplici euristiche potrebbero essere la lunghezza delle domande (ad esempio, 60 token) e il numero di fasi del ragionamento (ad esempio, 5 fasi del ragionamento). Questo incoraggia il modello a utilizzare dimostrazioni semplici e accurate.
|
||||
|
||||
Il processo è illustrato qui di seguito:
|
||||
|
||||
<Screenshot src={AUTOCOT} alt="AUTOCOT" />
|
||||
|
||||
Fonte immagine: [Zhang et al. (2022)](https://arxiv.org/abs/2210.03493)
|
||||
|
||||
Il codice di Auto-CoT è disponibile [qui].(https://github.com/amazon-science/auto-cot).
|
||||
|
||||
@ -4,7 +4,7 @@ Sebbene i modelli di grandi dimensioni dimostrino notevoli capacità di apprendi
|
||||
|
||||
Secondo [Touvron et al. 2023](https://arxiv.org/pdf/2302.13971.pdf) l'uso di poche proprietà appaiono per la prima volta quando i modelli vengono scalati a una dimensione sufficiente [(Kaplan et al., 2020)](https://arxiv.org/abs/2001.08361).
|
||||
|
||||
Dimostriamo il prompt a pochi colpi con un esempio presentato da [Brown et al. 2020](https://arxiv.org/abs/2005.14165). Nell'esempio, il compito consiste nell'utilizzare correttamente una nuova parola in una frase.
|
||||
Mostriamo il prompt few-shot con un esempio presentato da [Brown et al. 2020](https://arxiv.org/abs/2005.14165). Nell'esempio, il compito consiste nell'utilizzare correttamente una nuova parola in una frase.
|
||||
|
||||
*Prompt:*
|
||||
```
|
||||
@ -16,18 +16,18 @@ Un esempio di frase che usa la parola farduddle è:
|
||||
|
||||
*Output:*
|
||||
```
|
||||
Quando abbiamo vinto la partita, abbiamo iniziato a festeggiare tutti insieme.
|
||||
Quando abbiamo vinto la partita, abbiamo iniziato a fare farduddle tutti insieme.
|
||||
```
|
||||
|
||||
Possiamo osservare che il modello ha in qualche modo imparato a svolgere il compito fornendogli un solo esempio (cioè, 1-shot). Per compiti più difficili, possiamo sperimentare l'aumento delle dimostrazioni (ad esempio, 3-shot, 5-shot, 10-shot, ecc.).
|
||||
|
||||
Seguendo i risultati di [Min et al. (2022)](https://arxiv.org/abs/2202.12837), ecco qualche altro consiglio sulle dimostrazioni/esempi quando si fanno pochi shot:
|
||||
Seguendo i risultati di [Min et al. (2022)](https://arxiv.org/abs/2202.12837), ecco qualche altro consiglio sulle dimostrazioni/esempi quando si fa few-shot:
|
||||
|
||||
- "lo spazio delle etichette e la distribuzione del testo di input specificato dalle dimostrazioni sono entrambi importanti (indipendentemente dal fatto che le etichette siano corrette per i singoli input)".
|
||||
- anche il formato utilizzato gioca un ruolo fondamentale nelle prestazioni, anche se si utilizzano solo etichette casuali, è molto meglio che non averne affatto.
|
||||
- ulteriori risultati mostrano che anche la selezione di etichette casuali da una vera distribuzione di etichette aiuta (invece che da una distribuzione uniforme).
|
||||
|
||||
Proviamo alcuni esempi. Partiamo innanzitutto un esempio con etichette casuali (cioè le etichette Negativo e Positivo assegnate in modo casuale agli ingressi):
|
||||
Proviamo alcuni esempi. Proviamo innanzitutto un esempio con etichette casuali (cioè le etichette Negativo e Positivo sono assegnate in modo casuale agli input):
|
||||
|
||||
*Prompt:*
|
||||
```
|
||||
@ -60,9 +60,9 @@ Negativo
|
||||
|
||||
Non c'è coerenza nel formato di cui sopra, ma il modello ha comunque previsto l'etichetta corretta. Dobbiamo condurre un'analisi più approfondita per confermare se questo vale per compiti diversi e più complessi, comprese diverse varianti di prompt.
|
||||
|
||||
### Limiti di un Few-shot Prompting
|
||||
### Limiti di un prompt Few-shot
|
||||
|
||||
Il prompt standard di few-shot funziona bene per molti compiti, ma non è ancora una tecnica perfetta, soprattutto quando si tratta di compiti di ragionamento più complessi. Dimostriamo perché questo è il caso. Ricordate l'esempio precedente in cui abbiamo fornito il seguente compito:
|
||||
Il prompt standard few-shot funziona bene per molti compiti, ma non è ancora una tecnica perfetta, soprattutto quando si tratta di compiti di ragionamento più complessi. Mostriamo perché questo è il caso. Ricordate l'esempio precedente in cui abbiamo fornito il seguente compito:
|
||||
|
||||
```
|
||||
La somma dei numeri dispari di questo gruppo è un numero pari: 15, 32, 5, 13, 82, 7, 1.
|
||||
@ -103,6 +103,6 @@ R:
|
||||
La risposta è Corretta
|
||||
```
|
||||
|
||||
Non ha funzionato. Sembra che un prompt di few-shot non sia sufficiente per ottenere risposte affidabili per questo tipo di problemi di ragionamento. L'esempio precedente fornisce informazioni di base sul compito. Se si guarda più da vicino, il tipo di compito che abbiamo introdotto comporta alcune fasi di ragionamento in più. In altre parole, potrebbe essere utile scomporre il problema in fasi e dimostrarlo al modello. Più recentemente, il [chain-of-thought (CoT) prompting] (https://arxiv.org/abs/2201.11903) è stato diffuso per affrontare compiti più complessi di ragionamento aritmetico, di senso comune e simbolico.
|
||||
Non ha funzionato. Sembra che un prompt few-shot non sia sufficiente per ottenere risposte affidabili per questo tipo di problemi di ragionamento. L'esempio precedente fornisce informazioni di base sul compito. Se si guarda più da vicino, il tipo di compito che abbiamo introdotto comporta alcune fasi di ragionamento in più. In altre parole, potrebbe essere utile scomporre il problema in fasi e mostrarlo al modello. Più recentemente, il [chain-of-thought (CoT) prompting] (https://arxiv.org/abs/2201.11903) è stato diffuso per affrontare compiti più complessi di ragionamento aritmetico, di senso comune e simbolico.
|
||||
|
||||
Nel complesso, sembra che fornire esempi sia utile per risolvere alcuni compiti. Quando il prompt zero-shot e quello a few-shot non sono sufficienti, potrebbe significare che quanto appreso dal modello non è sufficiente per svolgere bene il compito. Da qui si consiglia di iniziare a pensare a una messa a punto dei modelli o a sperimentare tecniche di prompt più avanzate. A seguire parleremo di una delle tecniche di prompting più diffuse, chiamata prompting a catena di pensieri (chain of thought), che ha guadagnato molta popolarità.
|
||||
Nel complesso, sembra che fornire esempi sia utile per risolvere alcuni compiti. Quando il prompt zero-shot e quello few-shot non sono sufficienti, potrebbe significare che quanto appreso dal modello non è sufficiente per svolgere bene il compito. Da qui si consiglia di iniziare a pensare a una messa a punto dei modelli o a sperimentare tecniche di prompt più avanzate. A seguire parleremo di una delle tecniche di prompting più diffuse, chiamata prompt a catena di pensieri (chain of thought), che ha guadagnato molta popolarità.
|
||||
|
||||
@ -5,9 +5,9 @@ import GENKNOW from '../../img/gen-knowledge.png'
|
||||
|
||||
<Screenshot src={GENKNOW} alt="GENKNOW" />
|
||||
|
||||
Fonte dell'immagine: [Liu et al. 2022](https://arxiv.org/pdf/2110.08387.pdf)
|
||||
Fonte immagine: [Liu et al. 2022](https://arxiv.org/pdf/2110.08387.pdf)
|
||||
|
||||
I LLM continuano a essere migliorati ed una tecnica popolare include la capacità di incorporare conoscenze o informazioni per aiutare il modello a fare previsioni più accurate.
|
||||
Gli LLM continuano a essere migliorati ed una tecnica popolare include la capacità di incorporare conoscenze o informazioni per aiutare il modello a fare previsioni più accurate.
|
||||
|
||||
Utilizzando un'idea simile, è possibile utilizzare il modello anche per generare conoscenza prima di fare una previsione? È quello che si cerca di fare nell'articolo di [Liu et al. 2022](https://arxiv.org/pdf/2110.08387.pdf): generare conoscenza da utilizzare come parte del prompt. In particolare, quanto è utile per compiti come il ragionamento di senso compiuto?
|
||||
|
||||
@ -35,14 +35,14 @@ Conoscenza: La Grecia ha una superficie di circa 131.957 km², mentre il Messico
|
||||
Input: Gli occhiali si appannano sempre.
|
||||
Conoscenza: La condensa si verifica sulle lenti degli occhiali quando il vapore acqueo prodotto dal sudore, dall'alito e dall'umidità ambientale si deposita su una superficie fredda, si raffredda e si trasforma in minuscole gocce di liquido, formando una pellicola che si presenta come nebbia. Le lenti saranno relativamente fresche rispetto al respiro, soprattutto quando l'aria esterna è fredda.
|
||||
|
||||
Input: Un pesce è capace di pensare.
|
||||
Conoscenza: I pesci sono più intelligenti di quanto sembri. In molte aree, come la memoria, i loro poteri cognitivi corrispondono o superano quelli dei vertebrati "superiori", compresi i primati non umani. La memoria a lungo termine dei pesci li aiuta a tenere traccia di complesse relazioni sociali.
|
||||
Input: Un pesce è in grado di pensare.
|
||||
Conoscenza: I pesci sono più intelligenti di quanto sembri. In molte aree, come la memoria, le loro capacità cognitive corrispondono o superano quelli dei vertebrati "superiori", compresi i primati non umani. La memoria a lungo termine dei pesci li aiuta a tenere traccia di complesse relazioni sociali.
|
||||
|
||||
Input: Un effetto comune del fumare molte sigarette nel corso della vita è una probabilità più alta del normale di ammalarsi di cancro ai polmoni.
|
||||
Conoscenza: Coloro che fumavano costantemente meno di una sigaretta al giorno nel corso della loro vita avevano un rischio nove volte superiore di morire di cancro ai polmoni rispetto ai non fumatori. Tra le persone che fumavano tra una e 10 sigarette al giorno, il rischio di morire di cancro ai polmoni era quasi 12 volte superiore a quello dei non fumatori.
|
||||
|
||||
Input: Un sasso ha le stesse dimensioni di un sassolino.
|
||||
Knowledge: Un ciottolo è un clasto di roccia con una dimensione delle particelle compresa tra 4 e 64 millimetri secondo la scala Udden-Wentworth della sedimentologia. I ciottoli sono generalmente considerati più grandi dei granuli (da 2 a 4 millimetri di diametro) e più piccoli dei ciottoli (da 64 a 256 millimetri di diametro).
|
||||
Knowledge: Un ciottolo è un frammento di roccia con una dimensione delle particelle compresa tra 4 e 64 millimetri secondo la scala Udden-Wentworth della sedimentologia. I ciottoli sono generalmente considerati più grandi dei granuli (da 2 a 4 millimetri di diametro) e più piccoli dei ciottoli (da 64 a 256 millimetri di diametro).
|
||||
|
||||
Input: Una parte del golf consiste nel cercare di ottenere un totale di punti più alto degli altri.
|
||||
Conoscenza:
|
||||
@ -50,7 +50,7 @@ Conoscenza:
|
||||
|
||||
*Conoscenza 1:*
|
||||
```
|
||||
L'obiettivo del golf è giocare una serie di buche nel minor numero di colpi. Un round di golf consiste tipicamente in 18 buche. Ogni buca viene giocata una volta nel corso del round su un campo da golf standard. Ogni colpo viene conteggiato come un punto e il numero totale di colpi viene utilizzato per determinare il vincitore della partita.
|
||||
L'obiettivo del golf è giocare una serie di buche nel minor numero di colpi. Un percorso di golf consiste tipicamente in 18 buche. Ogni buca viene giocata una volta nel corso del giro su un campo da golf standard. Ogni colpo viene conteggiato come un punto e il numero totale di colpi viene utilizzato per determinare il vincitore della partita.
|
||||
```
|
||||
|
||||
*Conoscenza 2:*
|
||||
@ -66,9 +66,9 @@ Il passo successivo è integrare le conoscenze e ottenere una previsione. Ho rif
|
||||
```
|
||||
Domanda: Una parte del golf consiste nel cercare di ottenere un totale di punti più alto degli altri. Sì o no?
|
||||
|
||||
Conoscenza: L'obiettivo del golf è giocare una serie di buche nel minor numero di colpi. Un round di golf consiste tipicamente in 18 buche. Ogni buca viene giocata una volta nel corso del round su un campo da golf standard. Ogni colpo viene conteggiato come un punto e il numero totale di colpi viene utilizzato per determinare il vincitore della partita.
|
||||
Conoscenza: L'obiettivo del golf è giocare una serie di buche nel minor numero di colpi. Un percorso di golf consiste tipicamente in 18 buche. Ogni buca viene giocata una volta nel corso del percorso su un campo da golf standard. Ogni colpo viene conteggiato come un punto e il numero totale di colpi viene utilizzato per determinare il vincitore della partita.
|
||||
|
||||
Spiegazione e risposta:
|
||||
Spiega e rispondi:
|
||||
```
|
||||
|
||||
*Risposta 1 (fiducia molto alta):*
|
||||
@ -81,7 +81,7 @@ Domanda: Una parte del golf consiste nel cercare di ottenere un totale di punti
|
||||
|
||||
Conoscenza: Il golf è uno sport di precisione con bastoni e palline in cui i giocatori (o golfisti) usano diversi tipi di bastoni per colpire le palline in una serie di buche su un campo utilizzando il minor numero di colpi. L'obiettivo è completare il percorso con il punteggio più basso, calcolato sommando il numero totale di colpi effettuati su ogni buca. Il giocatore con il punteggio più basso vince la partita.
|
||||
|
||||
Spiegazione e risposta:
|
||||
Spiega e rispondi:
|
||||
```
|
||||
|
||||
*Risposta 2 (la fiducia è molto più bassa):*
|
||||
|
||||
@ -1,3 +1,105 @@
|
||||
# Prompt Chaining
|
||||
|
||||
This page needs a translation! Feel free to contribute a translation by clicking the `Edit this page` button on the right side.
|
||||
import {Screenshot} from 'components/screenshot'
|
||||
import PC1 from '../../img/prompt_chaining/prompt-chaining-1.png'
|
||||
|
||||
## Introduzione al Prompt Chaining (concatenamento di prompt)
|
||||
|
||||
Per migliorare l'affidabilità e le prestazioni degli LLM, una delle principali tecniche di prompting consiste nel suddividere i compiti in sottocompiti. Una volta identificati i sottocompiti, all'LLM viene dato un prompt per il sottocompito e poi la sua risposta viene utilizzata come input per un altro prompt. Si tratta del cosiddetto prompt chaining (concatenamento di prompt), in cui un compito viene suddiviso in sottocompiti con l'idea di creare una catena di operazioni di prompt.
|
||||
|
||||
Il concatenamento dei prompt è utile per realizzare compiti complessi che un LLM potrebbe faticare ad affrontare se sollecitato con un prompt molto dettagliato. Nel concatenamento di prompt, i prompt della catena eseguono trasformazioni o processi aggiuntivi sulle risposte generate prima di raggiungere lo stato finale desiderato.
|
||||
|
||||
Oltre a ottenere prestazioni migliori, il concatenamento di prompt contribuisce a migliorare la trasparenza della vostra applicazione LLM, aumentando la controllabilità e l'affidabilità. Ciò significa che è possibile eseguire il debug dei problemi con le risposte del modello in modo molto più semplice e analizzare e migliorare le prestazioni nelle diverse fasi che necessitano di miglioramenti.
|
||||
|
||||
Il concatenamento dei prompt è particolarmente utile per la creazione di assistenti conversazionali basati su LLM e per migliorare la personalizzazione e l'esperienza utente delle applicazioni.
|
||||
|
||||
## Casi d'uso per il Prompt Chaining
|
||||
|
||||
### Prompt Chaining per domande/risposte su documenti (Document QA - Question Answering)
|
||||
|
||||
Il concatenamento dei prompt può essere utilizzato in diversi scenari che possono comportare diverse operazioni o trasformazioni. Ad esempio, un caso d'uso comune dei LLM prevede la risposta a domande su un documento di testo di grandi dimensioni. È utile progettare due prompt diversi, dove il primo prompt è responsabile dell'estrazione delle citazioni rilevanti per rispondere a una domanda, ed un secondo prompt prende in input le citazioni e il documento originale per rispondere a una determinata domanda. In altre parole, si creeranno due prompt diversi per eseguire il compito di rispondere a una domanda data da un documento.
|
||||
|
||||
Il primo prompt qui di seguito estrae le citazioni rilevanti dal documento oggetto della domanda. Si noti che per semplicità è stato aggiunto un segnaposto `{{document}}` al posto del documento. Per testare il prompt si può copiare e incollare un articolo da Wikipedia, come questa pagina per [prompt engineering](https://en.wikipedia.org/wiki/Prompt_engineering). A causa del contesto più ampio utilizzato per questo compito, stiamo utilizzando il modello `gpt-4-1106-preview` di OpenAI. È possibile utilizzare il prompt con altri LLM a contesto lungo come Claude.
|
||||
|
||||
Prompt 1:
|
||||
```
|
||||
Sei un assistente disponibile. Il tuo compito è aiutare a rispondere a una domanda posta in un documento. Il primo passo consiste nell'estrarre dal documento le citazioni rilevanti per la domanda, delimitate da ####. Per favore produci l'elenco delle citazioni utilizzando <quotes></quotes>. Rispondi con "Non sono state trovate citazioni pertinenti!" se non sono state trovate citazioni pertinenti.
|
||||
|
||||
|
||||
####
|
||||
{{document}}
|
||||
####
|
||||
```
|
||||
|
||||
Ecco una schermata dell'intero prompt, compresa la domanda che viene passata utilizzando il ruolo `user`.
|
||||
|
||||
<Screenshot src={PC1} alt="Prompt Chaining Parte 1" />
|
||||
|
||||
Output del Prompt 1:
|
||||
```
|
||||
<quotes>
|
||||
- Chain-of-thought (CoT) prompting[27]
|
||||
- Generated knowledge prompting[37]
|
||||
- Least-to-most prompting[38]
|
||||
- Self-consistency decoding[39]
|
||||
- Complexity-based prompting[41]
|
||||
- Self-refine[42]
|
||||
- Tree-of-thought prompting[43]
|
||||
- Maieutic prompting[45]
|
||||
- Directional-stimulus prompting[46]
|
||||
- Textual inversion and embeddings[59]
|
||||
- Using gradient descent to search for prompts[61][62][63][64]
|
||||
- Prompt injection[65][66][67]
|
||||
</quotes>
|
||||
```
|
||||
|
||||
Le citazioni restituite nel primo prompt possono ora essere utilizzate come input per il secondo prompt sotto. Si noti che è possibile ripulire ancora un po' le citazioni, cioè rimuoverle. Queste citazioni potrebbero essere rimosse o utilizzate come parte di un altro prompt della catena, ma per ora le si ignora. Il secondo prompt prende quindi le citazioni rilevanti estratte dal prompt 1 e prepara una risposta utile alla domanda, dato il documento e le citazioni estratte. Il secondo prompt può essere il seguente:
|
||||
|
||||
Prompt 2:
|
||||
```
|
||||
Dato un insieme di citazioni rilevanti (delimitate da <quotes></quotes>) estratte da un documento ed il documento originale (delimitato da ####), per favore componi una risposta alla domanda. Assicurati che la risposta sia accurata, abbia un tono amichevole e suoni utile.
|
||||
|
||||
####
|
||||
{{document}}
|
||||
####
|
||||
|
||||
<quotes>
|
||||
- Chain-of-thought (CoT) prompting[27]
|
||||
- Generated knowledge prompting[37]
|
||||
- Least-to-most prompting[38]
|
||||
- Self-consistency decoding[39]
|
||||
- Complexity-based prompting[41]
|
||||
- Self-refine[42]
|
||||
- Tree-of-thought prompting[43]
|
||||
- Maieutic prompting[45]
|
||||
- Directional-stimulus prompting[46]
|
||||
- Textual inversion and embeddings[59]
|
||||
- Using gradient descent to search for prompts[61][62][63][64]
|
||||
- Prompt injection[65][66][67]
|
||||
</quotes>
|
||||
```
|
||||
|
||||
Output of Prompt 2:
|
||||
|
||||
```
|
||||
Le tecniche di prompting menzionate nel documento includono:
|
||||
|
||||
1. Chain-of-thought (CoT) prompting[27]
|
||||
2. Generated knowledge prompting[37]
|
||||
3. Least-to-most prompting[38]
|
||||
4. Self-consistency decoding[39]
|
||||
5. Complexity-based prompting[41]
|
||||
6. Self-refine[42]
|
||||
7. Tree-of-thought prompting[43]
|
||||
8. Maieutic prompting[45]
|
||||
9. Directional-stimulus prompting[46]
|
||||
10. Textual inversion and embeddings[59]
|
||||
11. Using gradient descent to search for prompts[61][62][63][64]
|
||||
12. Prompt injection[65][66][67]
|
||||
|
||||
Ognuna di queste tecniche impiega strategie uniche per migliorare o specificare le interazioni con i modelli linguistici di grandi dimensioni per produrre i risultati desiderati.
|
||||
```
|
||||
|
||||
Come si può vedere, la semplificazione e la creazione di catene di prompt è un approccio utile quando le risposte devono subire diverse operazioni o trasformazioni. Come esercizio, provate a progettare un prompt che rimuova le citazioni (ad esempio, [27]) dalla risposta prima di inviarla come risposta finale all'utente della vostra applicazione.
|
||||
|
||||
Si possono trovare altri esempi di concatenamento di prompt in questa [documentazione](https://docs.anthropic.com/claude/docs/prompt-chaining) che sfrutta l'LLM di Claude. Il nostro esempio è ispirato ed adattato dai loro esempi.
|
||||
|
||||
@ -1,25 +1,44 @@
|
||||
# Retrieval Augmented Generation (RAG)
|
||||
|
||||
import {Cards, Card} from 'nextra-theme-docs'
|
||||
import {TerminalIcon} from 'components/icons'
|
||||
import {CodeIcon} from 'components/icons'
|
||||
import {Screenshot} from 'components/screenshot'
|
||||
import RAG from '../../img/rag.png'
|
||||
import { Callout } from 'nextra/components'
|
||||
|
||||
I modelli di linguaggio di uso generale possono essere perfezionati per svolgere diversi compiti comuni come l'analisi del sentimento e il riconoscimento delle entità nominate. Questi compiti generalmente non richiedono ulteriori conoscenze di base.
|
||||
I modelli di linguaggio di uso generale possono essere messi a punto per svolgere diversi compiti comuni come l'analisi del sentimento e il riconoscimento delle entità denominate. Questi compiti generalmente non richiedono conoscenze di base aggiuntive.
|
||||
|
||||
Per compiti più complessi e che richiedono molte conoscenze, è possibile costruire un sistema basato su un modello di linguaggio che accede a fonti di conoscenza esterne per completare i compiti. Questo consente una maggiore coerenza dei fatti, migliora l'affidabilità delle risposte generate e aiuta a mitigare il problema dell'"allucinazione".
|
||||
Per compiti più complessi e che richiedono molte conoscenze, è possibile costruire un sistema basato su un modello di linguaggio che acceda a fonti di conoscenza esterne per completare i compiti. Questo consente una maggiore coerenza dei fatti, migliora l'affidabilità delle risposte generate e aiuta a mitigare il problema dell'"allucinazione".
|
||||
|
||||
I ricercatori di Meta AI hanno introdotto un metodo chiamato [Generazione aumentata dal recupero (RAG)](https://ai.facebook.com/blog/retrieval-augmented-generation-streamlining-the-creation-of-intelligent-natural-language-processing-models/) per affrontare tali compiti che richiedono molte conoscenze. RAG combina un componente di recupero delle informazioni con un modello generatore di testo. RAG può essere perfezionato e la sua conoscenza interna può essere modificata in modo efficiente e senza la necessità di riaddestrare l'intero modello.
|
||||
I ricercatori di Meta AI hanno introdotto un metodo chiamato [Generazione potenziata dal recupero (RAG)](https://ai.facebook.com/blog/retrieval-augmented-generation-streamlining-the-creation-of-intelligent-natural-language-processing-models/) per affrontare tali compiti che richiedono molte conoscenze. RAG combina una componente di recupero delle informazioni con un modello generatore di testo. RAG può essere perfezionato e la sua conoscenza interna può essere modificata in modo efficiente e senza la necessità di riaddestrare l'intero modello.
|
||||
|
||||
RAG prende un input e recupera un insieme di documenti rilevanti/supportativi dati una fonte (ad esempio, Wikipedia). I documenti vengono concatenati come contesto con il prompt di input originale e inviati al generatore di testo che produce l'output finale. Questo rende RAG adattivo per situazioni in cui i fatti potrebbero evolvere nel tempo. Questo è molto utile poiché la conoscenza parametrica dei LLM è statica. RAG consente ai modelli di linguaggio di bypassare la ri-formazione, consentendo l'accesso alle informazioni più recenti per generare output affidabili attraverso la generazione basata sul recupero.
|
||||
RAG prende un input e recupera un insieme di documenti rilevanti/supportanti dati da una fonte (ad esempio, Wikipedia). I documenti vengono concatenati come contesto con il prompt di input originale e inviati al generatore di testo che produce l'output finale. Questo rende RAG adattivo per situazioni in cui i fatti potrebbero evolvere nel tempo. Questo è molto utile poiché la conoscenza parametrica degli LLM è statica. RAG consente ai modelli di linguaggio di bypassare il riaddestramento, consentendo l'accesso alle informazioni più recenti per generare output affidabili attraverso la generazione basata sul recupero (delle informazioni).
|
||||
|
||||
Lewis et al., (2021) hanno proposto una ricetta generale per il perfezionamento di RAG. Un modello seq2seq pre-addestrato viene utilizzato come memoria parametrica e un indice vettoriale denso di Wikipedia viene utilizzato come memoria non parametrica (accessibile tramite un recupero pre-addestrato neurale). Di seguito è riportata una panoramica di come funziona l'approccio:
|
||||
Lewis et al., (2021) hanno proposto una ricetta generale per il perfezionamento di RAG. Un modello seq2seq pre-addestrato viene utilizzato come memoria parametrica e un indice vettoriale denso di Wikipedia viene utilizzato come memoria non parametrica (accessibile tramite un modulo di recupero neurale pre-addestrato). Di seguito è riportata una panoramica di come funziona l'approccio:
|
||||
|
||||
<Screenshot src={RAG} alt="RAG" />
|
||||
Fonte dell'immagine: [Lewis et al. (2021)](https://arxiv.org/pdf/2005.11401.pdf)
|
||||
Fonte immagine: [Lewis et al. (2021)](https://arxiv.org/pdf/2005.11401.pdf)
|
||||
|
||||
RAG si comporta in modo forte su diversi benchmark come [Natural Questions](https://ai.google.com/research/NaturalQuestions), [WebQuestions](https://paperswithcode.com/dataset/webquestions), e CuratedTrec. RAG genera risposte che sono più fattuali, specifiche e diverse quando testate su domande MS-MARCO e Jeopardy. RAG migliora anche i risultati sulla verifica dei fatti FEVER.
|
||||
RAG ha ottenuto ottimi risultati su diversi benchmark come [Natural Questions](https://ai.google.com/research/NaturalQuestions), [WebQuestions](https://paperswithcode.com/dataset/webquestions), e CuratedTrec. RAG genera risposte che sono più fattuali, specifiche e diversificate quando testate su domande MS-MARCO e Jeopardy. RAG migliora anche i risultati nella verifica dei fatti di FEVER.
|
||||
|
||||
Questo mostra il potenziale di RAG come opzione valida per migliorare gli output dei modelli di linguaggio nei compiti che richiedono molte conoscenze.
|
||||
|
||||
Più recentemente, questi approcci basati su recupero sono diventati più popolari e sono combinati con LLM popolari come ChatGPT per migliorare le capacità e la coerenza fattuale.
|
||||
|
||||
Puoi trovare un [esempio semplice di come usare i recuperatori e i LLM per rispondere alle domande con le fonti](https://python.langchain.com/docs/use_cases/question_answering/how_to/vector_db_qa) dalla documentazione di LangChain.
|
||||
## Casi d'uso di RAG: generare titoli amichevoli per articoli ML
|
||||
|
||||
Di seguito, abbiamo preparato un tutorial che illustra l'uso di LLM open-source per costruire un sistema RAG per generare titoli brevi e concisi di articoli sull'apprendimento automatico:
|
||||
|
||||
<Cards>
|
||||
<Card
|
||||
icon={<CodeIcon />}
|
||||
title="Getting Started with RAG"
|
||||
href="https://github.com/dair-ai/Prompt-Engineering-Guide/blob/main/notebooks/pe-rag.ipynb"
|
||||
/>
|
||||
</Cards>
|
||||
|
||||
## Riferimenti
|
||||
|
||||
- [Retrieval-Augmented Generation for Large Language Models: A Survey](https://arxiv.org/abs/2312.10997) (Dec 2023)
|
||||
- [Retrieval Augmented Generation: Streamlining the creation of intelligent natural language processing models](https://ai.meta.com/blog/retrieval-augmented-generation-streamlining-the-creation-of-intelligent-natural-language-processing-models/) (Sep 2020)
|
||||
|
||||
@ -6,19 +6,19 @@ import TOT from '../../img/TOT.png'
|
||||
import TOT2 from '../../img/TOT2.png'
|
||||
import TOT3 from '../../img/TOT3.png'
|
||||
|
||||
Le tradizionali tecniche di prompting risultano inefficienti per task più complessi, che possono richiedere strategia o esplorazione di più possibilità. [Yao et el. (2023)](https://arxiv.org/abs/2305.10601) e [Long (2023)](https://arxiv.org/abs/2305.08291) hanno proposto Tree of Thoughts (ToT), una generalizzazione della tecnica di chain-of-thought prompting che incoraggia l'esplorazione di più "pensieri" che vengono utilizzati come step intermedi per effettuare problem solving con i Language Model (LM).
|
||||
Per i compiti complessi che richiedono un'esplorazione o una visione strategica in avanti, le tecniche di prompting tradizionali o semplici non sono all'altezza. [Yao et el. (2023)](https://arxiv.org/abs/2305.10601) e [Long (2023)](https://arxiv.org/abs/2305.08291) hanno recentemente proposto Tree of Thoughts (ToT, albero dei pensieri), un framework che generalizza la richiesta di catene di pensieri e incoraggia l'esplorazione di pensieri che servono come passi intermedi per la risoluzione di problemi generali con modelli linguistici.
|
||||
|
||||
La tecnica ToT crea un albero di pensieri, dove i pensieri sono sequenze linguistiche che rappresentano i passi per raggiungere la risoluzione del problema. Questo approccio permette ad un LM di valutare i suoi stessi progressi intermedi verso la risoluzione del problema. L'abilità del LM di generare e valutare i "pensieri" viene combinata con algoritmi di ricerca (es.: breadth-first search e depth-first search), in modo da esplorare i pensieri con lookahead e backtracking.
|
||||
La tecnica ToT crea un albero di pensieri, dove i pensieri sono sequenze linguistiche coerenti che servono come passi intermedi per raggiungere la risoluzione del problema. Questo approccio permette ad un LM di valutare i suoi stessi progressi intermedi verso la risoluzione del problema. L'abilità dell'LM di generare e valutare i pensieri viene combinata con algoritmi di ricerca (es.: breadth-first search e depth-first search), in modo da esplorare sistematicamente i pensieri con lookahead e backtracking.
|
||||
|
||||
La tecnica ToT è illustrata nella seguente immagine:
|
||||
|
||||
<Screenshot src={TOT} alt="TOT" />
|
||||
Fonte: [Yao et el. (2023)](https://arxiv.org/abs/2305.10601)
|
||||
|
||||
Quando si usa la tecnica ToT, è necessario definire il numero di pensieri candidati (i più promettenti) e il numero di passi di necessari che il LM deve effettuare per raggiungere la soluzione.
|
||||
Quando si usa la tecnica ToT, è necessario definire il numero di pensieri candidati (i più promettenti) ed il numero di passi necessari che l'LM deve effettuare per raggiungere la soluzione.
|
||||
Nel paper, il [Gioco del 24](https://en.wikipedia.org/wiki/24_(puzzle)) viene utilizzato come task di ragionamento matematico che richiede una decomposizione in 3 passi, ognuno avente una equazione intermedia. Ad ogni passo, i migliori b=5 candidati vengono salvati.
|
||||
|
||||
Per effettuare una BFS nella tecnica ToT per il Gioco del 24, ogni passo candidato viene valutato in base alla possibilità di raggiungere il numero 24 attraverso l'operazione matematica proposta.
|
||||
Per effettuare una BFS (breadth-first search) nella tecnica ToT per il Gioco del 24, ogni passo candidato viene valutato in base alla possibilità di raggiungere il numero 24 attraverso l'operazione matematica proposta.
|
||||
Ad ognuno viene assegnata un'etichetta tra "sicuro/forse/impossibile". Come affermato dagli autori, lo scopo è quello di promuovere le soluzioni parziali corrette, che possono essere verificate guardando in avanti di pochi passi, eliminare le soluzioni parziali impossibili basandosi, per esempio, sulla grandezza del numero "il numero è troppo piccolo/grande per raggiungere 24 nei prossimi step", e tenere il resto, quelle etichettate con "forse". I valori vengono campionati 3 volte per ogni passo. Il processo è illustrato nell'immagine:
|
||||
|
||||
<Screenshot src={TOT2} alt="TOT2" />
|
||||
@ -29,17 +29,20 @@ Dai risultati riportati nella figura sotto, la tecnica ToT risulta migliore dell
|
||||
<Screenshot src={TOT3} alt="TOT3" />
|
||||
Fonte: [Yao et el. (2023)](https://arxiv.org/abs/2305.10601)
|
||||
|
||||
Codice disponibile [qui](https://github.com/princeton-nlp/tree-of-thought-llm) and [here](https://github.com/jieyilong/tree-of-thought-puzzle-solver)
|
||||
Codice disponibile [qui](https://github.com/princeton-nlp/tree-of-thought-llm) e [qui](https://github.com/jieyilong/tree-of-thought-puzzle-solver)
|
||||
|
||||
Ad alto livello, le principali idee di [Yao et el. (2023)](https://arxiv.org/abs/2305.10601) e [Long (2023)](https://arxiv.org/abs/2305.08291) sono simili. Entrambe potenziano le capacità dei Large Language Model di risolvere compiti complessi utilizzando una ricerca su albero con una conversazione a più giri. Una delle differenze principali sta nelle strategie di ricerca utilizzate: [Yao et el. (2023)](https://arxiv.org/abs/2305.10601) utilizza algoritmi generici di ricerca come DFS/BFS/beam search, mentre la strategia di ricerca (cioè quando effettuare backtracking e di quanti livelli nell'albero, ecc.) proposta da [Long (2023)](https://arxiv.org/abs/2305.08291) è controllata da un "ToT Controller", addestrato utilizzando il reinforcement learning (RL). DFS/BFS/Beam search sono algoritmi di ricerca generici, che non si adattano al problema specifico che si sta cercando di risolvere. Un ToT Controller, invece, essendo addestrato con through RL potrebbe essere in grado di imparare da dati nuovi o attraverso self-play (AlphaGo vs brute force search). Quindi, il sistema ToT basato su RL può continuare ad evolversi ed adattarsi ad un LLM prefissato.
|
||||
Ad alto livello, le principali idee di [Yao et el. (2023)](https://arxiv.org/abs/2305.10601) e [Long (2023)](https://arxiv.org/abs/2305.08291) sono simili. Entrambe potenziano le capacità dei Large Language Model di risolvere problemi complessi utilizzando una ricerca ad albero tramite una conversazione a più turni. Una delle differenze principali sta nelle strategie di ricerca utilizzate: [Yao et el. (2023)](https://arxiv.org/abs/2305.10601) utilizza algoritmi generici di ricerca come DFS/BFS/beam search, mentre la strategia di ricerca (cioè quando effettuare backtracking e di quanti livelli nell'albero, ecc.) proposta da [Long (2023)](https://arxiv.org/abs/2305.08291) è controllata da un "ToT Controller", addestrato utilizzando il reinforcement learning (RL, apprendimento per rinforzo). DFS/BFS/Beam search sono algoritmi di ricerca generici, senza alcun adattamento a problemi specifici. Un ToT Controller, invece, essendo addestrato tramite RL potrebbe essere in grado di imparare da dati nuovi o attraverso il gioco contro se stesso (AlphaGo vs ricerca a forza bruta), e quindi il sistema di ToT basato su RL può continuare a evolversi e ad apprendere nuove conoscenze anche con un LLM fisso.
|
||||
|
||||
[Hulbert (2023)](https://github.com/dave1010/tree-of-thought-prompting) ha proposto la tecnica di Tree-of-Thought Prompting, che applica il concetto principale della tecnica ToT utilizzando un singolo prompt testuale. Un esempio di prompt è il seguente:
|
||||
[Hulbert (2023)](https://github.com/dave1010/tree-of-thought-prompting) ha proposto la tecnica di Tree-of-Thought Prompting, che applica il concetto principale della tecnica ToT facendo in modo che l'LLM valuti i pensieri intermedi utilizzando un singolo prompt testuale. Un esempio di prompt ToT è il seguente:
|
||||
|
||||
```
|
||||
Immagina che tre esperti stiano rispondendo a questa domanda.
|
||||
Immagina che tre differenti esperti rispondano a questa domanda.
|
||||
Tutti gli esperti scrivono un passo del loro ragionamento,
|
||||
poi lo condividono con il gruppo di esperti.
|
||||
poi lo condividono con il gruppo.
|
||||
In seguito, tutti gli esperti andranno al passo successivo, etc.
|
||||
Se uno degli esperti capisce di aver sbagliato, dopo essere arrivato ad un qualiasi passo, l'esperto abbandona il gruppo.
|
||||
Se uno degli esperti capisce di aver sbagliato dopo essere arrivato ad un qualsiasi passo, l'esperto abbandona il gruppo.
|
||||
La domanda è...
|
||||
```
|
||||
[Sun (2023)](https://github.com/holarissun/PanelGPT) benchmarked the Tree-of-Thought Prompting with large-scale experiments, and introduce PanelGPT --- an idea of prompting with Panel discussions among LLMs.
|
||||
|
||||
[Sun (2023)](https://github.com/holarissun/PanelGPT) ha effettuato un benchmark del prompt Tree-of-Thought con esperimenti su larga scala e ha introdotto PanelGPT --- un'idea di prompting con discussioni di gruppo tra gli LLM.
|
||||
|
||||
@ -1,11 +1,12 @@
|
||||
# Prompt Zero-Shot
|
||||
Oggi i LLM, addestrati su grandi quantità di dati e regolati per seguire le istruzioni, sono in grado di eseguire compiti a colpo zero. Nella sezione precedente abbiamo provato alcuni esempi a colpo zero. Ecco uno degli esempi utilizzati:
|
||||
I grandi LLM di oggi, come GPT-3, sono regolati per seguire le istruzioni e sono addestrati su grandi quantità di dati; quindi sono in grado di eseguire alcuni compiti "zero-shot".
|
||||
|
||||
Nella sezione precedente abbiamo provato alcuni esempi zero-shot. Ecco uno degli esempi utilizzati:
|
||||
*Prompt:*
|
||||
```
|
||||
Classificare il testo in neutro, negativo o positivo.
|
||||
|
||||
Testo: Penso che le vacanze vadano bene.
|
||||
Testo: Penso che le vacanze siano ok.
|
||||
Sentimento:
|
||||
```
|
||||
|
||||
@ -14,9 +15,9 @@ Sentimento:
|
||||
Neutro
|
||||
```
|
||||
|
||||
Si noti che nella richiesta di cui sopra non abbiamo fornito al modello alcun esempio: questa è la capacità di ripresa zero al lavoro.
|
||||
Si noti che nel prompt non abbiamo fornito al modello alcun esempio di testo insieme alle relative classificazioni; l'LLM capisce già il "sentiment": si tratta delle capacità zero-shot al lavoro.
|
||||
|
||||
La sintonizzazione delle istruzioni ha dimostrato di migliorare l'apprendimento a colpo zero [Wei et al. (2022)](https://arxiv.org/pdf/2109.01652.pdf). La sintonizzazione delle istruzioni è essenzialmente il concetto di perfezionamento dei modelli su insiemi di dati descritti tramite istruzioni. Inoltre, [RLHF](https://arxiv.org/abs/1706.03741) (apprendimento per rinforzo dal feedback umano) è stato adottato per scalare la sintonizzazione delle istruzioni, in cui il modello viene allineato per adattarsi meglio alle preferenze umane. Questo recente sviluppo alimenta modelli come ChatGPT. Discuteremo tutti questi approcci e metodi nelle prossime sezioni.
|
||||
La messa a punto delle istruzioni ha dimostrato di migliorare l'apprendimento zero-shot [Wei et al. (2022)](https://arxiv.org/pdf/2109.01652.pdf). La messa a punto delle istruzioni è essenzialmente il concetto di perfezionamento dei modelli su insiemi di dati descritti tramite istruzioni. Inoltre, l'[RLHF](https://arxiv.org/abs/1706.03741) (reinforcement learning from human feedback, apprendimento per rinforzo dal feedback umano) è stato adottato per scalare la sintonizzazione delle istruzioni, in cui il modello viene allineato per adattarsi meglio alle preferenze umane. Questo recente sviluppo alimenta modelli come ChatGPT. Discuteremo tutti questi approcci e metodi nelle prossime sezioni.
|
||||
|
||||
Quando zero-shot non funziona, si raccomanda di fornire dimostrazioni o esempi nel prompt, il che porta al few-shot prompt. Nella prossima sezione, dimostreremo il few-shot prompt.
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user