Pianificazione, riflessione e ripianificazione
Un solo ciclo ReAct va bene per una chiamata a uno strumento, ma i compiti reali hanno dei passi: fare ricerca su un argomento, poi riassumere; prenotare un volo, poi un hotel. Un agente capace non improvvisa un'azione alla volta: fa un piano, lo porta avanti, e riflette dopo ogni passo per decidere se continuare, correggere la rotta o fermarsi. Quel ciclo pianifica-agisci-rifletti è ciò che permette a un agente di finire un compito lungo senza vagare.
1. Scomponi l'obiettivo in un piano
Pianificare significa trasformare un obiettivo vago in una lista ordinata di sottocompiti. In produzione è il modello a scrivere questo piano; qui lo rendiamo deterministico e basato su parole chiave così si può testare. Stessa idea, uscita fissata:
def decompose(goal):
g = goal.lower()
if "research" in g or "report" in g:
return ["gather sources", "extract facts", "write summary"]
elif "trip" in g or "travel" in g:
return ["pick dates", "book flights", "book hotel"]
return ["understand goal", "do the work", "review result"]2. Rifletti sul risultato di ogni passo
Dopo che un sottocompito è stato eseguito, l'agente guarda l'esito e prende una decisione di controllo. Gli diamo un piccolo dict di risultato {"ok": bool, "last": bool} (il passo è riuscito, ed è l'ultimo passo) e tre decisioni possibili:
"replan": il passo è fallito. Qualunque cosa abbiamo provato non ha funzionato, quindi il piano attuale è sospetto."done": il passo è riuscito ed era l'ultimo. L'obiettivo è raggiunto."continue": è riuscito ma c'è ancora da fare. Passa al sottocompito successivo.
L'ordine conta: un fallimento significa "replan" anche all'ultimo passo (un passo finale rotto non è "done").
3. Ripianifica una volta in caso di fallimento
Il controllore lega tutto insieme. Percorre il piano, chiama execute(subtask) per ogni passo, segna se era l'ultimo, e riflette. Con "continue" avanza; con "done" si ferma con successo; con "replan" costruisce un nuovo piano di recupero e ricomincia, ma solo fino a max_replans volte, così un compito senza speranza non può ciclare per sempre (la disciplina delle protezioni dei cicli di prima). Finite le ripianificazioni si ferma con "failed".
def replan(goal, failed_step):
# retry the failed step, then still do every step that came after it
base = failed_step[len("retry: "):] if failed_step.startswith("retry: ") else failed_step
plan = decompose(goal)
rest = plan[plan.index(base) + 1:] if base in plan else []
return ["retry: " + base] + restQui execute è simulato: una funzione che passi tu e che restituisce {"ok": ...} per un sottocompito, al posto delle vere chiamate agli strumenti così il controllore è completamente deterministico e verificabile. In un agente dal vivo lo stesso controllore guida strumenti veri e un piano scritto dal modello senza cambiare la sua logica. Premi Run per guardare un piano riuscire, poi guardarne uno fallire un passo e riprendersi con la ripianificazione.
Costruisci un controllore di pianificazione. Scrivi decompose(goal) che restituisce la lista ordinata dei sottocompiti (research/report -> ["gather sources", "extract facts", "write summary"]; trip/travel -> ["pick dates", "book flights", "book hotel"]; altrimenti -> ["understand goal", "do the work", "review result"]). Scrivi reflect(step_result) su {"ok", "last"} che restituisce "replan" se non è ok, altrimenti "done" se è l'ultimo, altrimenti "continue". Scrivi replan(goal, failed_step) -> un piano di recupero che riprova il passo fallito e poi fa comunque ogni passo che veniva dopo in decompose(goal): per un obiettivo di ricerca che fallisce su "extract facts", ["retry: extract facts", "write summary"]. (Un piano di recupero che salta il lavoro rimasto e riporta "done" è il classico bug degli agenti: il riassunto non è mai stato scritto.) Se failed_step è già a sua volta un nuovo tentativo, togli prima il prefisso "retry: " così non viene raddoppiato. Poi scrivi run_plan(goal, execute, max_replans=1) che percorre il piano, chiama execute(subtask) (restituisce {"ok": bool}), riflette (imposti tu last), registra una traccia (subtask, ok, decision), ripianifica fino a max_replans volte in caso di fallimento (ricominciando il piano di recupero dal suo primo passo), e restituisce {"status": "done"|"failed", "trace": [...], "replans": int}.
Hai notato un problema in questa lezione? Segnalalo · Chiedi qualcosa su questa lezione
Questo esercizio si apre presto
Finisci la lezione precedente e questa si sblocca. L'intero corso è gratuito, senza account, e puoi leggere questa lezione subito.
Questo browser blocca i cookie per learn.floati.life, quindi le lezioni che hai finito qui non si possono aprire in ordine. Consenti i cookie per questo sito e ricarica.