DSPy

DSPy è un framework Python open source per creare applicazioni basate su modelli linguistici di grandi dimensioni (LLM) come codice, anziché con prompt scritti a mano. Uno sviluppatore dichiara gli input e gli output di ogni passaggio, compone i passaggi in un programma e lascia che un ottimizzatore DSPy scriva e perfezioni i prompt o i pesi del modello, così da massimizzare una metrica su un insieme di esempi. Il nome sta per Declarative Self-improving Python e il progetto si definisce il framework per programmare i modelli linguistici, anziché limitarsi a scrivere prompt. Omar Khattab e colleghi di Stanford lo hanno presentato nell'articolo dell'ottobre 2023 DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines. In pochi minuti di compilazione, poche righe di DSPy hanno permesso a GPT-3.5 e Llama-2-13B-chat di creare pipeline che superavano il prompting few-shot standard di oltre il 25% e il 65% rispettivamente, e le pipeline con dimostrazioni scritte da esperti fino al 46% e al 40%.

Firme, moduli e ottimizzatori#

• Firme: dichiarazioni tipizzate degli input e degli output di un passaggio, scritte inline come "question -> answer" o come classe la cui docstring descrive l'attività. Indicano cosa fa un passaggio e lasciano a DSPy la formulazione del prompt.
• Moduli: strategie per eseguire una firma. dspy.Predict richiama il modello una volta, dspy.ChainOfThought aggiunge un campo di ragionamento prima della risposta, come nel prompting chain-of-thought, e dspy.ReAct esegue un ciclo che usa strumenti, secondo lo stile del prompting ReAct. I moduli si compongono come i livelli di PyTorch per creare programmi a più passaggi, ad esempio una pipeline di generazione aumentata dal recupero (RAG) che scrive una query di ricerca, recupera passaggi e risponde in base a essi.
• Adattatori: traducono una firma in messaggi di chat per il modello e riconvertono la risposta in campi tipizzati.
• Ottimizzatori: algoritmi che migliorano un programma rispetto a una metrica. BootstrapFewShot esegue il programma sugli esempi di addestramento e conserva come dimostrazioni le tracce che superano la metrica, MIPROv2 esplora le istruzioni proposte e gli insiemi di dimostrazioni, mentre BootstrapFinetune distilla un programma nei pesi del modello tramite fine-tuning.

Il ciclo di ottimizzazione rispecchia l'addestramento di un modello, con i prompt al posto dei parametri:

L'ottimizzatore GEPA del 2025, disponibile come dspy.GEPA, legge le tracce di esecuzione del programma e il feedback testuale, chiede a un LLM di riflettere sugli errori e da lì fa evolvere le istruzioni. Su sei attività ha superato in media del 6% e fino al 20% il metodo di apprendimento per rinforzo GRPO, usando fino a 35 volte meno rollout, e ha superato MIPROv2 di oltre il 10%.

Dalla firma al prompt#

DSPy genera il prompt a partire dalla firma, così è possibile ottimizzare nuovamente lo stesso programma per un modello diverso, anziché riscriverlo. Qui l'input è un riepilogo dei rilevamenti ottenuti con Ultralytics YOLO26: Results.verbose() restituisce un risultato in modalità predict sotto forma di conteggi per classe in una breve stringa, che una firma può accettare come testo, consentendo all'ottimizzatore di perfezionare il passaggio di ragionamento su output reali del rilevamento degli oggetti. Per formattare i messaggi non servono né un modello né una chiave API:

import dspy
from ultralytics import YOLO

model = YOLO("yolo26n.pt")
results = model("https://ultralytics.com/images/bus.jpg")


class SceneQA(dspy.Signature):
    """Answer a question about a photo from the objects a detector found in it."""

    detections: str = dspy.InputField()
    question: str = dspy.InputField()
    answer: str = dspy.OutputField()


# The adapter turns the signature and inputs into the chat messages the model will receive
inputs = {"detections": results[0].verbose(), "question": "How many people are in the photo?"}
messages = dspy.ChatAdapter().format(SceneQA, demos=[], inputs=inputs)
for message in messages:
    print(f"--- {message['role']} ---\n{message['content']}")

Il messaggio di sistema elenca i campi di input e output, i marcatori [[ ## field ## ]] usati da DSPy per analizzare la risposta e la docstring come obiettivo; il messaggio dell'utente contiene i conteggi del rilevatore. Un ottimizzatore migliora il programma riscrivendo quell'obiettivo e aggiungendo dimostrazioni ai messaggi, senza modificare il codice Python.

DSPy e i termini correlati#

• Prompt engineering: scrivere e rivedere i prompt a mano. DSPy trasforma questo lavoro in un problema di ottimizzazione basato su una metrica e su esempi.
• LangChain: framework di integrazioni, strumenti e cicli di agenti per comporre applicazioni LLM, con prompt gestiti dallo sviluppatore.
• Ottimizzazione degli iperparametri: ricerca tra le impostazioni di addestramento usando una metrica di validazione; è l'analogia più vicina alla ricerca dei prompt effettuata da DSPy.
• Sistemi di IA composti: applicazioni costruite con diverse chiamate a modelli, sistemi di recupero e strumenti. DSPy è stato progettato per ottimizzare queste pipeline da un capo all'altro, perfezionando il prompt di ogni passaggio rispetto alla metrica finale.