Module predefinite: Predict, ChainOfThought, ProgramOfThought, BestOfN, Refine în DSPy & Programare Algoritmică LLM: explicație și exemple

Aceeași semnătură poate fi dată oricărui modul, deci strategiile se pot compara direct pe aceeași sarcină. dspy.Predict face un apel. dspy.ChainOfThought adaugă un câmp reasoning înaintea ieșirilor. dspy.ReAct folosește unelte (vezi pagina despre ReAct). Documentația spune că aceste trei module acoperă majoritatea programelor; celelalte sunt rețete construite peste ele.

dspy.BestOfN și dspy.Refine rulează modulul de până la N ori, cu rollout_id diferit și temperature=1.0, ca să nu primească același răspuns din cache. Fiecare încercare este notată de reward_fn(args, pred); rularea se oprește când scorul atinge threshold, altfel se întoarce încercarea cu scorul cel mai mare. Refine generează în plus, după fiecare încercare ratată, sfaturi pentru încercarea următoare. dspy.MultiChainComparison primește mai multe răspunsuri deja generate și scrie unul sintetizat.

dspy.ProgramOfThought cere modelului cod Python, îl execută și extrage ieșirile din rezultat; dspy.CodeAct combină ReAct cu execuția de cod. Ambele folosesc PythonInterpreter, un sandbox Deno + Pyodide (WASM), fără acces implicit la fișiere sau rețea; Deno se instalează cu pip install "dspy[deno]". Pentru multe intrări, Module.batch(exemple) rulează un modul în paralel, iar dspy.Parallel rulează perechi (modul, exemplu) diferite.

Concepte cheie și caracteristici

Concept / Parametru	Descriere practică
`dspy.Predict(semnatura)`	Un apel la model pentru semnătură.
`dspy.ChainOfThought(semnatura)`	Adaugă ieșirea `reasoning` înaintea câmpurilor declarate.
`dspy.ProgramOfThought(semnatura, max_iters=3)`	Generează și rulează cod; la eroare cere o variantă corectată, de cel mult `max_iters` ori.
`dspy.BestOfN(module, N, reward_fn, threshold, fail_count=None)`	Până la `N` încercări; întoarce prima care atinge `threshold` sau pe cea mai bună. `fail_count` (implicit `N`) limitează erorile tolerate.
`dspy.Refine(module, N, reward_fn, threshold, fail_count=None)`	Ca BestOfN, cu sfaturi generate de model între încercări.
`dspy.MultiChainComparison(semnatura, M=3, temperature=0.7)`	Compară `M` răspunsuri date de apelant și produce unul final.
`Module.batch(examples, num_threads=None, ...)`	Rulează modulul pe o listă de `dspy.Example`, în paralel; întoarce predicțiile în ordinea intrărilor.
`dspy.Parallel(num_threads=None, timeout=120, ...)`	Rulează perechi (modul, exemplu); nu este un `Module`, deci optimizatorii îl ignoră.
`dspy.majority(predictie)`	Funcție fără apel la model: alege valoarea cea mai frecventă din mai multe completări.

Exemple practice și scenarii reale

Exemplul 1: BestOfN: cel mai bun din trei încercări

După exemplul din documentație: recompensa cere un răspuns dintr-un singur cuvânt.

import dspy

dspy.configure(lm=dspy.LM("openai/gpt-6-luna"))

def un_cuvant(args, pred: dspy.Prediction) -> float:
    return 1.0 if len(pred.answer.split()) == 1 else 0.0

best_of_3 = dspy.BestOfN(
    module=dspy.ChainOfThought("question -> answer"),
    N=3,
    reward_fn=un_cuvant,
    threshold=1.0,
)
rez = best_of_3(question="Care este capitala Belgiei?")
print(rez.answer)

Exemplul 2: Refine: încercări cu sfaturi între ele

refine = dspy.Refine(
    module=dspy.ChainOfThought("question -> answer"),
    N=3,
    reward_fn=un_cuvant,
    threshold=1.0,
)
rez = refine(question="Care este capitala Belgiei?")

Exemplul 3: ProgramOfThought pentru un calcul

Necesită Deno (pip install "dspy[deno]").

pot = dspy.ProgramOfThought("question -> answer: float")
rez = pot(question="Un produs costă 240 de lei. Cât costă după o reducere de 15%?")
print(rez.answer)

Exemplul 4: Același modul pe mai multe intrări

qa = dspy.Predict("question -> answer")
intrebari = ["Ce este TCP?", "Ce este UDP?", "Ce este QUIC?"]
exemple = [dspy.Example(question=q).with_inputs("question") for q in intrebari]

rezultate = qa.batch(exemple, num_threads=3)
for ex, rez in zip(exemple, rezultate):
    print(ex.question, "->", rez.answer)

Greșeli frecvente și capcane

Alegi modulul după impresie. Același program cu Predict, ChainOfThought sau ReAct se poate măsura cu dspy.Evaluate pe același set de date.
Uiți costul: BestOfN și Refine pot face până la N rulări complete ale modulului, iar Refine adaugă apelurile pentru sfaturi.
Rulezi ProgramOfThought sau CodeAct fără Deno instalat. Interpretorul nu pornește; instalează extra-ul deno sau un Deno 2.x în PATH.
Pornești propriul ThreadPoolExecutor cu module DSPy. Firele simple nu moștenesc dspy.context; Module.batch și dspy.Parallel copiază setările în fiecare fir.

`Module predefinite: Predict, ChainOfThought, ProgramOfThought, BestOfN, Refine` în DSPy & Programare Algoritmică LLM