Tutorial sul Prompt Chaining: cos’è e come usarlo

Ti è mai capitato di montare un mobile senza leggere le istruzioni? Se ti va bene, qualche pezzo va al suo posto, ma senza una guida passo passo il risultato rischia di essere caotico. È un po’ la stessa sfida che affrontano i large language model (LLM) quando si trovano davanti a problemi complessi. Hanno un potenziale enorme, ma spesso mancano il bersaglio quando un’attività richiede un ragionamento articolato in più passaggi.

Con un singolo prompt, gli LLM possono fornire risposte troppo generiche, poco approfondite o che tralasciano dettagli critici. Questo limite nasce dalla difficoltà di catturare tutto il contesto necessario e fornire una guida adeguata all’interno di un solo prompt.

La soluzione è il prompt chaining.

Il prompt chaining consiste nel suddividere un compito complesso in una serie di prompt più piccoli e gestibili. Ogni prompt affronta una parte specifica dell’attività e l’output di un prompt diventa l’input per quello successivo. Questo metodo consente un approccio più strutturato, guidando l’LLM attraverso una catena di passaggi logici che porta a una risposta più accurata e completa. Seguendo una sequenza di prompt coerente, possiamo sfruttare appieno gli LLM per risolvere efficacemente problemi complessi.

Questo tutorial fa parte della serie di articoli “Prompt Engineering: From Zero to Hero”:

1. Prompt Engineering per tutti
2. Zero-Shot Prompting
3. Few-Shot Prompting
4. Prompt Chaining

Che cos’è il Prompt Chaining?

Il prompt chaining è un metodo in cui l’output di un prompt per un LLM viene utilizzato come input per il prompt successivo in una sequenza. Questa tecnica prevede la creazione di una serie di prompt collegati, ciascuno focalizzato su una parte specifica del problema complessivo. Seguendo questa sequenza, l’LLM viene guidato in un processo di ragionamento strutturato, che lo aiuta a produrre risposte più accurate e dettagliate.

Lo scopo principale del prompt chaining è migliorare prestazioni, affidabilità e chiarezza delle applicazioni basate su LLM. Per attività complesse, un singolo prompt spesso non offre sufficiente profondità e contesto per una buona risposta. Il prompt chaining risolve questo problema spezzando l’attività in passi più piccoli, assicurando che ogni passaggio sia gestito con cura. Questo metodo migliora la qualità dell’output dell’LLM e rende più semplice capire come si è arrivati al risultato finale.

Vediamo alcuni vantaggi del prompt chaining:

Come implementare il Prompt Chaining

Implementare il prompt chaining richiede un approccio sistematico per scomporre un’attività complessa e guidare un LLM attraverso una serie di passaggi ben definiti. 

Vediamo come creare ed eseguire efficacemente una catena di prompt.

Identifica le sottoattività

Il primo passo nel prompt chaining è scomporre il compito complesso in sottoattività più piccole e gestibili. Ogni sottoattività dovrebbe rappresentare un aspetto distinto del problema complessivo. In questo modo, l’LLM può concentrarsi su una parte alla volta.

Per esempio, supponiamo di voler far scrivere all’LLM un report completo sul cambiamento climatico. Le sottoattività potrebbero includere:

• Ricerca di dati climatici storici
• Sintesi dei principali risultati della letteratura scientifica
• Analisi dell’impatto del cambiamento climatico sui diversi ecosistemi
• Proposta di possibili soluzioni e strategie di mitigazione

Progetta i prompt

Successivamente, progetta prompt chiari e concisi per ciascuna sottoattività. Ogni prompt deve essere specifico e diretto, in modo che l’LLM capisca il compito e possa generare un output pertinente. È importante che l’output di un prompt sia adatto a diventare input per il successivo, creando un flusso di informazioni.

Per le sottoattività sopra, potremmo creare i seguenti prompt:

• Prompt Sottoattività 1: "Riepiloga le principali tendenze dei cambiamenti della temperatura globale nell’ultimo secolo."
• Prompt Sottoattività 2: "In base alle tendenze identificate, elenca i principali studi scientifici che trattano le cause di questi cambiamenti."
• Prompt Sottoattività 3: "Sintetizza i risultati degli studi elencati, concentrandoti sull’impatto del cambiamento climatico sugli ecosistemi marini."
• Prompt Sottoattività 4: "In base ai risultati sintetizzati, proponi tre strategie per mitigare l’impatto del cambiamento climatico sugli ecosistemi marini."

Esecuzione della catena

Ora dobbiamo eseguire i prompt in sequenza, passando l’output di un prompt come input al successivo. Questa esecuzione passo passo fa sì che l’LLM costruisca sui risultati precedenti, creando un output coerente e completo.

Nel nostro esempio, gli output delle sottoattività potrebbero essere simili a questi:

• Output Sottoattività 1: "La temperatura globale è aumentata di circa 1,2 gradi Celsius nell’ultimo secolo, con incrementi significativi osservati negli ultimi 20 anni."
• Input per Sottoattività 2: "Dato che le temperature globali sono aumentate di 1,2 gradi Celsius nell’ultimo secolo, elenca i principali studi scientifici che discutono le cause di questi cambiamenti."
• Output Sottoattività 2: "Studi chiave includono: 'The Role of Greenhouse Gases in Global Warming' di Dr. Smith, 'Deforestation and Climate Change' di Dr. Jones e 'Oceanic Changes and Climate Patterns' di Dr. Lee."
• Input per Sottoattività 3: "Sintetizza i risultati di 'The Role of Greenhouse Gases in Global Warming' di Dr. Smith, 'Deforestation and Climate Change' di Dr. Jones e 'Oceanic Changes and Climate Patterns' di Dr. Lee, concentrandoti sull’impatto del cambiamento climatico sugli ecosistemi marini."

Gestione degli errori

Implementare meccanismi di gestione degli errori è fondamentale per affrontare potenziali problemi durante l’esecuzione dei prompt. Questo può includere controlli per verificare qualità e pertinenza dell’output prima di passare al prompt successivo e la creazione di prompt di fallback per riportare l’LLM sulla giusta strada se devia dal percorso atteso. Per esempio:

• Controllo errore 1: Dopo ogni output, verifica che le informazioni siano pertinenti e complete. Se il riepilogo delle tendenze delle temperature globali è incompleto, chiedi all’LLM di fornire ulteriori dettagli.
• Prompt di fallback: Se l’LLM non elenca studi scientifici pertinenti, usa un prompt più specifico come "Elenca cinque studi peer-reviewed dell’ultimo decennio che trattano le cause dell’aumento della temperatura globale."

Implementazione

Vediamo come implementarlo in Python!

Passo 1: Configurare l’ambiente

Per prima cosa, importiamo le librerie necessarie. Useremo la classe OpenAI dal pacchetto openai e os per gestire le variabili d’ambiente.

import openai
import os

È fondamentale archiviare in modo sicuro le informazioni sensibili, come le API key. Un modo per farlo è impostare la chiave API come variabile d’ambiente. Puoi farlo utilizzando una OpenAI API key.

os.environ['OPENAI_API_KEY'] = 'your-api-key-here'

Assicurati di sostituire 'your-api-key-here' con la tua effettiva OpenAI API key.

Con la chiave API impostata, puoi inizializzare il client OpenAI. Questo client verrà usato per effettuare le chiamate API ai servizi di OpenAI.

Client = OpenAI ()

Passo 2: Definire una funzione per interagire con la chat completions API di OpenAI.

Ora creeremo una funzione Python per interagire con la chat completions API di OpenAI. Questa funzione invierà il prompt all’API e restituirà la risposta generata.

def get_completion(prompt, model="gpt-3.5-turbo"):
    try:
        response = client.chat.completions.create(
            model=model,
            messages=[
                {"role": "system", "content": "You are a helpful assistant."},
                {"role": "user", "content": prompt}
            ],
            temperature=0,
        )
        return response.choices[0].message.content
    except Exception as e:
        print(f"An error occurred: {e}")
        return None

Vediamo nel dettaglio cosa fa questa funzione:

• Accetta un prompt e un parametro opzionale del modello.
• Effettua una chiamata all’API di OpenAI usando l’endpoint delle chat completions.
• Imposta la conversazione con un messaggio di sistema e un messaggio dell’utente (il prompt).
• Imposta la temperatura a 0 per output più deterministici (aumentala per risultati più creativi).
• Restituisce il contenuto della risposta o None in caso di errore.

Passo 3: Mettere in catena più prompt

Ora creeremo una funzione Python che mette in catena più prompt, passando l’output di un prompt come input a quello successivo.

def prompt_chain(initial_prompt, follow_up_prompts):
    result = get_completion(initial_prompt)
    if result is None:
        return "Initial prompt failed."
    print(f"Initial output: {result}\n")
    for i, prompt in enumerate(follow_up_prompts, 1):
        full_prompt = f"{prompt}\n\nPrevious output: {result}"
        result = get_completion(full_prompt)
        if result is None:
            return f"Prompt {i} failed."
        print(f"Step {i} output: {result}\n")
    return result

La funzione prompt_chain implementa il prompt chaining. In particolare:

• Parte da un prompt iniziale e ne ottiene il completamento.
• Itera su un elenco di prompt successivi.
• Per ciascun prompt successivo, combina il prompt con l’output precedente, ottiene un completamento e aggiorna il risultato.
• Se un passaggio fallisce, restituisce un messaggio di errore.
• Stampa l’output di ogni passaggio per visibilità.

Passo 4: Esempio d’uso

Mostriamo ora come usare la funzione prompt_chain per creare una sequenza di prompt che si costruiscono l’uno sull’altro. Questo esempio si concentra sul riassumere le principali tendenze nei cambiamenti della temperatura globale ed esplorare gli studi scientifici correlati e le strategie di mitigazione, ma puoi adattarlo al tuo caso d’uso!

initial_prompt = "Summarize the key trends in global temperature changes over the past century."
follow_up_prompts = [
    "Based on the trends identified, list the major scientific studies that discuss the causes of these changes.",
    "Summarize the findings of the listed studies, focusing on the impact of climate change on marine ecosystems.",
    "Propose three strategies to mitigate the impact of climate change on marine ecosystems based on the summarized findings."
]
final_result = prompt_chain(initial_prompt, follow_up_prompts)
print("Final result:", final_result)

Qui definiamo un prompt iniziale sui cambiamenti della temperatura globale e poi impostiamo un elenco di prompt successivi che si costruiscono l’uno sull’altro. Quindi chiamiamo la funzione prompt_chain con questi prompt e, infine, stampiamo il risultato finale.

Come funziona tutto insieme

Ricapitoliamo il processo:

1. Il prompt iniziale ottiene un riepilogo delle tendenze della temperatura.
2. Il primo follow-up usa questo riepilogo per trovare studi pertinenti.
3. Il secondo follow-up sintetizza i risultati di questi studi sugli ecosistemi marini.
4. Il prompt finale usa tutte queste informazioni per proporre strategie di mitigazione.

Questa catena consente un approccio passo passo a query complesse, in cui ogni passaggio si basa sulle informazioni dei precedenti.

Tecniche di Prompt Chaining

Il prompt chaining può essere implementato in vari modi in base al tipo di attività e ai requisiti. Qui esploriamo tre tecniche principali: chaining sequenziale, condizionale e iterativo (looping).

Chaining sequenziale

Il chaining sequenziale collega i prompt in una sequenza lineare e semplice. Ogni prompt dipende dall’output del precedente, creando un flusso di informazioni e compiti passo dopo passo. Questa tecnica è ideale per attività che richiedono una progressione logica da una fase alla successiva, come:

• Sintesi di testi: Suddividere un documento lungo in sezioni sintetizzate e poi combinare queste sintesi in un riepilogo complessivo coerente.
• Generazione di codice: Produrre snippet di codice passo dopo passo, ad esempio definendo prima le funzioni, poi implementandole e infine scrivendo i test.

Lo snippet di codice nella sezione precedente è un esempio di chaining sequenziale.

Chaining condizionale

Il chaining condizionale introduce diramazioni nella catena di prompt in base all’output dell’LLM. Questa tecnica consente workflow più flessibili e adattabili, permettendo all’LLM di intraprendere percorsi diversi a seconda delle risposte generate.

Vediamo come implementare il chaining condizionale per eseguire un’analisi del sentiment.

def analyze_sentiment(text):
    prompt = f"Analyze the sentiment of the following text and respond with only one word - 'positive', 'negative', or 'neutral': {text}"
    sentiment = get_completion(prompt)
    return sentiment.strip().lower()

def conditional_prompt_chain(initial_prompt):
    result = get_completion(initial_prompt)
    if result is None:
        return "Initial prompt failed."
    print(f"Initial output: {result}\n")
    sentiment = analyze_sentiment(result)
    print(f"Sentiment: {sentiment}\n")
    if sentiment == 'positive':
        follow_up = "Given this positive outlook, what are three potential opportunities we can explore?"
    elif sentiment == 'negative':
        follow_up = "Considering these challenges, what are three possible solutions we can implement?"
    else:  # neutral
        follow_up = "Based on this balanced view, what are three key areas we should focus on for a comprehensive approach?"
    final_result = get_completion(f"{follow_up}\n\nContext: {result}")
    return final_result

# Example usage
initial_prompt = "Analyze the current state of renewable energy adoption globally."
final_result = conditional_prompt_chain(initial_prompt)
print("Final result:", final_result)

Per prima cosa definiamo una nuova funzione, analyze_sentiment(), che usa il modello linguistico per determinare il sentiment di un testo. Poi, nella funzione conditional_prompt_chain(), partiamo da un prompt iniziale sull’adozione globale delle energie rinnovabili. Dopo aver ottenuto la prima risposta, ne analizziamo il sentiment. In base al sentiment, scegliamo un prompt di follow-up diverso:

•  Per un sentiment positivo, chiediamo delle opportunità.
•  Per un sentiment negativo, chiediamo delle soluzioni.
•  Per un sentiment neutro, chiediamo le aree chiave su cui concentrarsi.

Il prompt di follow-up scelto viene poi inviato al modello linguistico insieme al contesto della risposta iniziale. Il risultato finale è la risposta a questo follow-up condizionale.

Nota che la scelta del secondo prompt non è prestabilita ma dipende dal contenuto della prima risposta. Inoltre, il flusso della conversazione si adatta in base all’analisi del sentiment, mostrando come la catena possa diramarsi in percorsi diversi. Questo consente interazioni più dinamiche e sensibili al contesto con il modello linguistico.

Eseguendo questo codice, la domanda di follow-up specifica dipenderà dal fatto che l’analisi iniziale sull’adozione delle energie rinnovabili sia percepita come positiva, negativa o neutra. Si crea così una catena di prompt più adattiva e reattiva.

Chaining iterativo (looping)

Il chaining iterativo introduce dei cicli all’interno della catena per iterare su dati o eseguire attività ripetitive. Questa tecnica è utile quando si gestiscono elenchi o raccolte di elementi che richiedono passaggi simili. Tra i benefici e le sfide di questo approccio ci sono:

• Efficienza: automatizza compiti ripetitivi, risparmiando tempo e sforzi.
• Elaborazione dati: adatto per attività come l’elaborazione di più record, la sintesi in batch o i miglioramenti iterativi.
• Sfide: richiede attenzione per evitare cicli infiniti e garantire che ogni iterazione produca un avanzamento significativo.

Vediamo come implementare il chaining iterativo per un compito di verifica della completezza del testo:

def check_completeness(text):
    prompt = f"Analyze the following text and respond with only 'complete' if it covers all necessary aspects, or 'incomplete' if more information is needed:\n\n{text}"
    response = get_completion(prompt)
    return response.strip().lower() == 'complete'

def looping_prompt_chain(initial_prompt, max_iterations=5):
    current_response = get_completion(initial_prompt)
    if current_response is None:
        return "Initial prompt failed."
    print(f"Initial output: {current_response}\n")
    iteration = 0
    while iteration < max_iterations:
        if check_completeness(current_response):
            print(f"Complete response achieved after {iteration + 1} iterations.")
            return current_response
        print(f"Iteration {iteration + 1}: Response incomplete. Expanding...")
        expand_prompt = f"The following response is incomplete. Please expand on it to make it more comprehensive:\n\n{current_response}"
        new_response = get_completion(expand_prompt)
        if new_response is None:
            return f"Expansion failed at iteration {iteration + 1}."
        current_response = new_response
        print(f"Expanded response: {current_response}\n")
        iteration += 1
    print(f"Maximum iterations ({max_iterations}) reached without achieving completeness.")
    return current_response

# Example usage
initial_prompt = "Explain the process of photosynthesis."
final_result = looping_prompt_chain(initial_prompt)
print("Final result:", final_result)

Per prima cosa definiamo una nuova funzione, check_completeness(), che usa il modello linguistico per determinare se una risposta è completa o necessita di ulteriori informazioni.

Poi, nella funzione looping_prompt_chain(), partiamo dal prompt iniziale sulla fotosintesi. Dopo aver ottenuto la prima risposta, entriamo in un ciclo:

• Verifichiamo se l’attuale risposta è completa usando check_completeness().
• Se è completa, usciamo dal ciclo e restituiamo il risultato.
• Se è incompleta, generiamo un nuovo prompt chiedendo di espandere la risposta precedente.
• Otteniamo quindi una nuova risposta basata su questo prompt di espansione.

Il processo continua finché non otteniamo una risposta ritenuta completa o finché non raggiungiamo il numero massimo di iterazioni (impostato di default a 5).

Il ciclo assicura che si continui a raffinare ed espandere la risposta finché non è considerata completa o finché non si raggiunge il limite di iterazioni.

Eseguendo questo codice, si tenterà di fornire una spiegazione completa della fotosintesi, potenzialmente attraverso più iterazioni, se le risposte iniziali sono giudicate incomplete. Si crea così una catena di prompt più approfondita e adattiva, con l’obiettivo di arrivare a un risultato finale completo.

Applicazioni pratiche del Prompt Chaining

Il prompt chaining può potenziare in modo significativo le capacità degli LLM in molte applicazioni. In questa sezione vediamo alcuni utilizzi pratici, mostrando come applicarlo a compiti reali.

Domande e risposte su documenti

Il prompt chaining può essere usato per riassumere documenti lunghi e poi generare risposte a domande specifiche. Si procede prima suddividendo il documento in sezioni gestibili, sintetizzando ciascuna sezione e poi utilizzando queste sintesi per rispondere a domande dettagliate.

Vediamo come implementarlo:

def split_document(document, max_length=1000):
    """Split the document into sections of approximately max_length characters."""
    words = document.split()
    sections = []
    current_section = []
    current_length = 0
    for word in words:
        if current_length + len(word) + 1 > max_length and current_section:
            sections.append(' '.join(current_section))
            current_section = []
            current_length = 0
        current_section.append(word)
        current_length += len(word) + 1
    if current_section:
        sections.append(' '.join(current_section))
    return sections

def summarize_section(section):
    prompt = f"Summarize the following text in a concise manner:\n\n{section}"
    return get_completion(prompt)

def answer_question(summaries, question):
    context = "\n\n".join(summaries)
    prompt = f"Given the following context, answer the question:\n\nContext:\n{context}\n\nQuestion: {question}"
    return get_completion(prompt)

def document_qa(document, questions):
    # Step 1: Split the document
    sections = split_document(document)
    print(f"Document split into {len(sections)} sections.")
    # Step 2: Summarize each section
    summaries = []
    for i, section in enumerate(sections):
        summary = summarize_section(section)
        summaries.append(summary)
        print(f"Section {i+1} summarized.")
    # Step 3: Answer questions
    answers = []
    for question in questions:
        answer = answer_question(summaries, question)
        answers.append((question, answer))
    return answers

# Example usage
long_document = """
[Insert a long document here. For brevity, we are using a placeholder. 
In a real scenario, this would be a much longer text, maybe several 
paragraphs or pages about a specific topic.]
This is a long document about climate change. It discusses various aspects 
including causes, effects, and potential solutions. The document covers 
topics such as greenhouse gas emissions, rising global temperatures, 
melting ice caps, sea level rise, extreme weather events, impact on 
biodiversity, and strategies for mitigation and adaptation.
The document also explores the economic implications of climate change, 
international agreements like the Paris Agreement, renewable energy 
technologies, and the role of individual actions in combating climate change.
[Continue with more detailed information about climate change...]
"""
questions = [
    "What are the main causes of climate change mentioned in the document?",
    "What are some of the effects of climate change discussed?",
    "What solutions or strategies are proposed to address climate change?"
]
results = document_qa(long_document, questions)
for question, answer in results:
    print(f"\nQ: {question}")
    print(f"A: {answer}")

Questo snippet mostra come usare il prompt chaining per compiti complessi come l’analisi di documenti e il question answering. Scompone un compito ampio (comprendere un documento lungo) in passaggi più gestibili (sintesi delle sezioni). Usa l’output di un passaggio (le sintesi) come input per il successivo (rispondere alle domande). Consente di gestire documenti troppo lunghi per essere processati con un singolo prompt.

Eseguendo il codice con un documento reale e lungo, questo verrà diviso in sezioni gestibili, ogni sezione verrà sintetizzata e queste sintesi verranno usate per rispondere alle domande fornite sulle cause, gli effetti e le soluzioni del cambiamento climatico.

Generazione di testo con verifica dei fatti

La generazione di testo con verifica dei fatti prevede di generare del testo e incorporare passaggi di fact-checking all’interno della catena di prompt. Questo garantisce che l’output non sia solo coerente, ma anche accurato.

def generate_text(topic):
    prompt = f"Write a short paragraph about {topic}."
    return get_completion(prompt)

def extract_facts(text):
    prompt = f"Extract the key factual claims from the following text, listing each claim on a new line:\n\n{text}"
    return get_completion(prompt)

def verify_facts(facts):
    verified_facts = []
    for fact in facts.split('\n'):
        if fact.strip():
            prompt = f"Verify the following statement and respond with 'True' if it's factually correct, 'False' if it's incorrect, or 'Uncertain' if it can't be verified without additional research: '{fact}'"
            verification = get_completion(prompt)
            verified_facts.append((fact, verification.strip()))
    return verified_facts

def revise_text(original_text, verified_facts):
    context = "Original text:\n" + original_text + "\n\nVerified facts:\n"
    for fact, verification in verified_facts:
        context += f"- {fact}: {verification}\n"
    
    prompt = f"{context}\n\nRewrite the original text, keeping the verified facts, removing or correcting any false information, and indicating any uncertain claims as 'It is claimed that...' or similar phrasing."
    return get_completion(prompt)

def text_generation_with_verification(topic):
    print(f"Generating text about: {topic}")
    # Step 1: Generate initial text
    initial_text = generate_text(topic)
    print("\nInitial Text:")
    print(initial_text)
    # Step 2: Extract facts
    extracted_facts = extract_facts(initial_text)
    print("\nExtracted Facts:")
    print(extracted_facts)
    # Step 3: Verify facts
    verified_facts = verify_facts(extracted_facts)
    print("\nVerified Facts:")
    for fact, verification in verified_facts:
        print(f"- {fact}: {verification}")
    # Step 4: Revise text
    revised_text = revise_text(initial_text, verified_facts)
    print("\nRevised Text:")
    print(revised_text)
    return revised_text

# Example usage
topic = "the effects of climate change on polar bears"
final_text = text_generation_with_verification(topic)

La funzione text_generation_with_verification() gestisce l’intero processo. Inizia usando generate_text() per creare un paragrafo iniziale sull’argomento. Poi extract_facts() estrae dal testo le affermazioni fattuali chiave. verify_facts() controlla queste affermazioni, etichettandole come True, False o Uncertain. Infine, revise_text() riscrive il testo originale, correggendo gli errori e segnalando le informazioni incerte. Questo processo aiuta a garantire che il testo finale sia informativo e accurato.

Il prompt chaining avviene in più passaggi: la generazione del testo iniziale, l’estrazione dei fatti dal testo generato, la verifica di ciascun fatto estratto e la revisione del testo in base ai fatti verificati.

Eseguendo questo codice con un tema come "the effects of climate change on polar bears", verrà generato un testo iniziale sull’argomento, verranno estratte le affermazioni fattuali, ciascuna verrà verificata e il testo verrà revisionato in base ai fatti verificati, così da ottenere un output finale più accurato. Ricorda che puoi usare un argomento a tua scelta!

Generazione di codice con debugging

Usare il prompt chaining per scrivere codice e poi testarlo può accelerare lo sviluppo. Questo metodo aiuta a garantire che il codice funzioni correttamente e faccia ciò per cui è stato progettato. Va oltre il semplice controllo che il codice giri senza errori.

def generate_code(task):
    prompt = f"Write a Python function to {task}. Include comments explaining the code."
    return get_completion(prompt)

def generate_test_cases(code):
    prompt = f"Given the following Python code, generate 3 test cases to verify its functionality. Include both input and expected output for each test case:\n\n{code}"
    return get_completion(prompt)

def run_tests(code, test_cases):
    prompt = f"""
    Given the following Python code and test cases, run the tests and report the results. 
    If any tests fail, explain why and suggest fixes.
    Code:
    {code}
    Test Cases:
    {test_cases}
    For each test case, respond with:
    1. "PASS" if the test passes
    2. "FAIL" if the test fails, along with an explanation of why it failed and a suggested fix
    """
    return get_completion(prompt)

def debug_code(code, test_results):
    prompt = f"""
    Given the following Python code and test results, debug the code to fix any issues.
    Provide the corrected code along with explanations of the changes made.
    Original Code:
    {code}
    Test Results:
    {test_results}
    """
    return get_completion(prompt)

def code_generation_with_debugging(task):
    print(f"Generating code for task: {task}")
    # Step 1: Generate initial code
    initial_code = generate_code(task)
    print("\nInitial Code:")
    print(initial_code)
    # Step 2: Generate test cases
    test_cases = generate_test_cases(initial_code)
    print("\nGenerated Test Cases:")
    print(test_cases)
    # Step 3: Run tests
    test_results = run_tests(initial_code, test_cases)
    print("\nTest Results:")
    print(test_results)
    # Step 4: Debug code if necessary
    if "FAIL" in test_results:
        print("\nDebugging code...")
        debugged_code = debug_code(initial_code, test_results)
        print("\nDebugged Code:")
        print(debugged_code)    
        # Optionally, you can run tests again on the debugged code
        print("\nRe-running tests on debugged code...")
        final_test_results = run_tests(debugged_code, test_cases)
        print("\nFinal Test Results:")
        print(final_test_results)    
        return debugged_code
    else:
        print("\nAll tests passed. No debugging necessary.")
        return initial_code

# Example usage
task = "calculate the factorial of a number"
final_code = code_generation_with_debugging(task)

La funzione code_generation_with_debugging() gestisce l’intero processo. Funziona così: prima generate_code() scrive il codice Python per il compito. Poi generate_test_cases() crea i test per questo codice. run_tests() verifica se il codice supera i test. Se qualche test fallisce, debug_code() prova a risolvere i problemi.

Nota che ogni passaggio si basa sul precedente. Si parte dalla scrittura del codice, poi si creano i test, si eseguono e si correggono eventuali problemi. Così si scompone la programmazione in passi più semplici. Questo metodo mostra come il prompt chaining possa gestire compiti complessi come la scrittura di codice. Riproduce il modo di lavorare reale degli sviluppatori: scrivere, testare e correggere. Ogni passaggio sfrutta ciò che viene prima, consentendo un miglioramento progressivo del codice.

Eseguendo questo codice con un compito come "calculate the factorial of a number", verrà generato il codice Python iniziale per calcolare il fattoriale, creati i casi di test per questa funzione, simulata l’esecuzione dei test e riportati i risultati. Se qualche test fallisce, verrà tentato il debug e la correzione del codice, quindi verranno rieseguiti i test.

Compiti di ragionamento multi-step

Il prompt chaining può risolvere problemi complessi che richiedono più passaggi di ragionamento, come problemi matematici a testo o rompicapi logici. Ogni passaggio si basa sul precedente, garantendo un approccio strutturato e accurato.

def solve_step_by_step(problem):
    steps = []
    current_problem = problem
    while True:
        prompt = f"Solve the following problem step by step. Provide the next step only and explain it clearly:\n\n{current_problem}"
        step = get_completion(prompt)
        if step is None or "solution" in step.lower():
            break
        steps.append(step)
        current_problem = f"{current_problem}\n\n{step}"
        print(f"Step {len(steps)}: {step}\n")
    return steps

def combine_steps(steps):
    combined_steps = "\n".join(steps)
    prompt = f"Combine the following steps into a coherent solution for the problem:\n\n{combined_steps}"
    return get_completion(prompt)

def multi_step_reasoning(problem):
    print(f"Solving problem: {problem}")    
    # Step 1: Solve step by step
    steps = solve_step_by_step(problem)    
    # Step 2: Combine steps into a final solution
    final_solution = combine_steps(steps)
    print("\nFinal Solution:")
    print(final_solution)
    return final_solution

# Example usage
problem = "A car travels 60 miles per hour for 2 hours, then 40 miles per hour for 3 hours. What is the total distance traveled by the car?"
final_solution = multi_step_reasoning(problem)

Prima, solve_step_by_step() scompone il problema in parti più piccole. Chiede al modello AI ciascun passaggio, uno alla volta, fino al completamento della soluzione. Ogni passaggio viene salvato. Poi, combine_steps() prende tutti questi passaggi e chiede all’AI di unirli in una spiegazione chiara. La funzione get_completion() gestisce le chiamate all’API di OpenAI durante tutto il processo.

In questo esempio, risolverà il problema: "A car drives 60 miles per hour for 2 hours, then 40 miles per hour for 3 hours. How far does it go in total?"

Eseguendo il codice, il problema verrà scomposto in passaggi di ragionamento più piccoli, ciascun passaggio verrà raccolto e stampato, e i passaggi verranno combinati in una soluzione finale, che verrà stampata.

Best practice per il Prompt Chaining

Per massimizzare l’efficacia del prompt chaining è fondamentale seguire alcune best practice. Queste pratiche assicurano catene robuste, accurate ed efficienti, portando a risultati migliori e applicazioni LLM più affidabili.

Progettazione dei prompt

Prompt chiari e concisi sono essenziali per ottenere i risultati migliori da un LLM. Quando i prompt sono diretti, il modello capisce facilmente cosa serve, riducendo le ambiguità e migliorando la qualità delle risposte.

Ecco alcuni consigli:

• Usa un linguaggio semplice: evita parole complesse e gergo tecnico.
• Sii diretto: indica chiaramente cosa vuoi senza dettagli superflui.
• Concentrati su un compito alla volta: ogni prompt dovrebbe affrontare un singolo compito o domanda. 

Per esempio:

• Invece di: "Puoi per favore riassumere i punti chiave delle tendenze storiche delle temperature globali nell’ultimo secolo, concentrandoti su eventuali cambiamenti significativi e le loro possibili cause, oltre a eventi notevoli che potrebbero aver influenzato tali tendenze?"
• Usa: "Riassumi i punti chiave delle tendenze storiche delle temperature globali nell’ultimo secolo."

Anche prompt ben strutturati sono fondamentali per aiutare l’LLM a seguire il flusso logico di un compito. Quando i prompt sono organizzati e coerenti, il modello capisce meglio e risponde in modo più appropriato.

Ecco alcuni consigli:

• Scomponi i compiti complessi: dividi l’attività in passaggi più piccoli e gestibili.
• Assicura un flusso logico: fai in modo che ogni prompt si basi sul precedente e conduca logicamente al successivo.

Strutturare i prompt in questo modo guida l’LLM attraverso il compito passo dopo passo, portando a risposte migliori e più accurate. Per esempio:

• Passo 1: "Elenca i principali cambiamenti delle temperature globali nell’ultimo secolo."
• Passo 2: "Identifica le possibili cause per ciascun grande cambiamento delle temperature globali."

Sperimentazione

Compiti diversi richiedono modi diversi di concatenare i prompt. Scegliere il metodo giusto può fare una grande differenza. È una buona idea provare approcci differenti e vedere cosa funziona meglio per il tuo obiettivo. Test e confronto aiutano a trovare il modo più efficace per ottenere buoni risultati.

È importante verificare spesso come stanno funzionando le tue catene di prompt. Valuta accuratezza, completezza e pertinenza degli output. Questo ti aiuta a capire cosa funziona e cosa va migliorato. Facendolo regolarmente, puoi apportare modifiche e ottimizzazioni quando servono e assicurarti risultati sempre migliori.

Affinamento iterativo

Un affinamento iterativo basato su feedback e risultati porta a prompt più precisi ed efficaci. Puoi migliorare continuamente le prestazioni del tuo LLM raccogliendo feedback dagli output, identificando le carenze e regolando di conseguenza i prompt. Questo processo continuo fa sì che i tuoi prompt diventino via via più accurati e pertinenti. Per esempio:

• Prompt iniziale: "Descrivi l’impatto del cambiamento climatico."
• Prompt affinato: "Descrivi l’impatto del cambiamento climatico sugli ecosistemi costieri nell’ultimo decennio."

Affina la struttura della catena

Il modo in cui organizzi la tua catena di prompt può incidere molto sul risultato finale. È utile modificare l’ordine e la logica dei prompt in base a ciò che vedi funzionare. Così ti assicuri che ogni passaggio abbia senso rispetto al precedente. In questo modo otterrai risposte dall’AI più coerenti e logiche.

Gestione degli errori

Una gestione degli errori robusta assicura che la catena continui a funzionare anche se alcuni prompt falliscono. Impostando controlli di validità dell’output e usando prompt di fallback, puoi riportare l’LLM in carreggiata quando si verificano errori. Questo approccio mantiene il flusso e l’affidabilità della catena, garantendo prestazioni costanti.

Monitoraggio e logging

È importante tenere d’occhio come stanno funzionando le tue catene di prompt. Questo aiuta a capire cosa è efficace e a individuare eventuali problemi. Usa strumenti per registrare informazioni importanti come input dei prompt, output e tempi di esecuzione. Ad esempio, annota ogni passaggio della catena, ciò che ha prodotto e gli eventuali errori. Così puoi analizzare il processo e migliorarlo, ottenendo risultati migliori.

Mantenere registri dettagliati aiuta a risolvere i problemi e a migliorare le catene di prompt. Archivia questi log in modo ordinato per facilitarne l’analisi e l’apprendimento. Questo ti aiuta a individuare criticità e affinarle. Di conseguenza, puoi farle funzionare meglio e ottenere risposte più accurate

Seguendo queste best practice potrai creare catene di prompt efficaci e affidabili che migliorano le capacità degli LLM, assicurando prestazioni migliori e risultati più significativi in varie applicazioni.

Conclusione

In questo articolo abbiamo esplorato il prompt chaining, una tecnica per migliorare le prestazioni degli LLM su compiti complessi suddividendoli in prompt più piccoli e gestibili. Abbiamo visto diversi metodi di chaining, le loro applicazioni e le best practice per sfruttare efficacemente gli LLM in un’ampia gamma di casi d’uso.

Se vuoi approfondire il prompt engineering, ti consiglio questi articoli:

• Prompt Compression: una guida con esempi in Python
• Buffer of Thoughts (BoT)
• Che cos’è DSPy? Come funziona, casi d’uso e risorse
• Understanding Prompt Tuning