Self-Refine Prompting (IT)

Self-Refine (auto-raffinamento o auto-correzione) — è un approccio nel campo del prompt engineering che consente ai grandi modelli linguistici (LLM) di migliorare iterativamente la risposta generata sulla base del proprio feedback. L'idea è stata proposta da un gruppo di ricercatori guidati da Aman Madaan nel 2023 ed è basata sull'osservazione che, analogamente agli esseri umani, i modelli linguistici non sempre generano il risultato migliore al primo tentativo.

In questo metodo, lo stesso LLM svolge sequenzialmente tre ruoli:

1. Generatore (Generator): crea una risposta bozza iniziale alla richiesta.
2. Critico (Feedback): valuta la propria risposta e fornisce un feedback costruttivo.
3. Redattore (Refiner): utilizza questo feedback per creare una versione migliorata della risposta.

Questo ciclo iterativo «generazione → feedback → miglioramento» può essere ripetuto più volte fino al raggiungimento della qualità richiesta o al soddisfacimento della condizione di arresto.

È importante notare che Self-Refine non richiede un ulteriore addestramento del modello, fine-tuning o dati esterni — l'intero processo è gestito esclusivamente tramite prompt nella fase di inference.

Meccanismo di implementazione

Il metodo Self-Refine viene implementato attraverso una sequenza di prompt appositamente costruiti che guidano il comportamento del modello.

1. Generazione iniziale. Il modello riceve il prompt originale e genera una risposta bozza.
2. Creazione del feedback. Il modello riceve l'istruzione di analizzare la propria risposta precedente e di identificarne i difetti. Ad esempio, può rilevare che la risposta non è sufficientemente dettagliata o contiene un errore logico. Il risultato è un feedback testuale con osservazioni e raccomandazioni specifiche.
3. Miglioramento iterativo. Il modello riceve come nuovo prompt la richiesta originale, la propria risposta iniziale e il feedback generato. Sulla base di ciò, crea una versione migliorata della risposta.

Questo ciclo a due fasi «critica → revisione» può essere eseguito più volte. Nel contesto di ogni nuova iterazione vengono incluse le versioni precedenti della risposta e i relativi commenti, il che aiuta il modello a evitare la ripetizione degli errori. Per gestire il comportamento del modello vengono spesso utilizzate tecniche di few-shot prompting, in cui nel prompt vengono inclusi esempi del formato desiderato di feedback e correzioni.

Efficacia e applicazioni

Il metodo Self-Refine ha dimostrato la propria efficacia su una serie di compiti che richiedono molteplici raffinamenti, quali:

• Generazione di risposte dialogiche.
• Continuazione creativa di storie.
• Soluzione di problemi matematici mediante ragionamento passo-passo.
• Ottimizzazione del codice.

Nella ricerca originale, le risposte ottenute con Self-Refine sono risultate in media del ~20% più preferite secondo le valutazioni umane e le metriche automatiche rispetto alla generazione in un unico passaggio. Il miglioramento è stato raggiunto anche per i modelli più avanzati, come GPT-4, il che indica che persino gli LLM più potenti spesso necessitano solo di un ulteriore passaggio di riflessione per correggere i propri errori.

Approcci simili, come RCI (Recursive Criticism and Improvement), hanno anch'essi mostrato un'elevata efficacia in compiti interattivi, ad esempio nel controllo del computer e nella soluzione di problemi logici. La combinazione di RCI con la tecnica della «catena di pensieri» (Chain-of-Thought) ha prodotto un effetto sinergico, migliorando notevolmente la capacità del modello di risolvere problemi complessi grazie a un passaggio integrato di auto-verifica.

Limitazioni e ricerche attuali

Nonostante i risultati incoraggianti, le ricerche mostrano che il miglioramento auto-iterativo presenta alcune limitazioni.

• Pregiudizio verso se stessi (self-bias): I modelli hanno difficoltà a giudicare imparzialmente le proprie risposte. Gli LLM tendono a valutare favorevolmente il testo da loro generato e a criticarlo in modo insufficiente, il che può portare a una stagnazione o addirittura a un peggioramento della qualità dopo alcune iterazioni.
• Eccessiva sicurezza: È stato osservato che, all'aumentare del numero di iterazioni di auto-correzione, il modello può acquisire un'eccessiva sicurezza nelle proprie risposte, anche se queste non sono diventate più accurate. Ciò porta a un aumento dellExpected Calibration Error (ECE) — la discrepanza tra la sicurezza del modello e l'accuratezza reale.
• Costi computazionali: Il metodo richiede più chiamate all'LLM per ottenere una singola risposta finale, il che aumenta significativamente la latenza e il costo rispetto alla generazione in un unico passaggio.

Le ricerche attuali sono orientate alla soluzione di questi problemi. Una direzione riguarda l'introduzione di meccanismi di calibrazione della sicurezza ad ogni passo dell'iterazione. Un'altra prevede il ricorso a fonti di informazione o strumenti esterni (ad esempio, esecuzione di codice, ricerca di dati) per una auto-valutazione più oggettiva.

Confronto con altre tecniche

• Chain-of-Thought (CoT): CoT si concentra sulla generazione di una catena lineare di ragionamenti per giungere a una risposta. Self-Refine, invece, si concentra sul miglioramento iterativo di una risposta già generata (che può includere CoT).
• Tree of Thoughts (ToT): ToT esplora molteplici percorsi di ragionamento paralleli sotto forma di albero, mentre Self-Refine migliora un singolo percorso in modo iterativo. ToT è una tecnica di esplorazione dello spazio delle soluzioni, mentre Self-Refine è una tecnica di ottimizzazione di una soluzione specifica.

Riferimenti

• Sito ufficiale del progetto Self-Refine
• Articolo scientifico originale "Self-Refine: Iterative Refinement with Self-Feedback"

Bibliografia

• Madaan, A. et al. (2023). Self-Refine: Iterative Refinement with Self-Feedback. arXiv:2303.17651.
• Kim, G. et al. (2023). Language Models Can Solve Computer Tasks. arXiv:2303.17491.
• Gou, Z. et al. (2023). CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing. arXiv:2305.11738.
• Huang, J. et al. (2023). Large Language Models Cannot Self-Correct Reasoning Yet. arXiv:2310.01798.
• Pan, L. et al. (2023). Automatically Correcting Large Language Models: Surveying the Landscape of Diverse Self-Correction Strategies. arXiv:2308.03188.
• Jiang, C. et al. (2024). Importance Weighting Can Help Large Language Models Self-Improve. arXiv:2408.09849.
• Liang, X. et al. (2024). Internal Consistency and Self-Feedback in Large Language Models: A Survey. arXiv:2407.14507.
• Zhu, D. et al. (2025). Beyond Accuracy: The Role of Calibration in Self-Improving Large Language Models. arXiv:2504.02902.
• Hao, Q. et al. (2025). RL of Thoughts: Navigating LLM Reasoning with Inference-time Reinforcement Learning. arXiv:2505.14140.
• Cui, Y. et al. (2023). Check Your Facts and Try Again: Improving Large Language Models by Reducing Hallucination. arXiv:2302.12813.
• Wei, Z. et al. (2024). ReSearch: Iterative Self-Reflection for Better LLM Calibration. arXiv:2405.13022.