Pianificazione + protezioni dei cicli
Un agente che può agire può anche agire per sempre. Il modo numero uno in cui un vero agente brucia soldi e sveglia un ingegnere di turno è un ciclo senza freni: continua a chiamare lo stesso strumento, ottiene la stessa osservazione, e non decide mai di aver finito. Questa lezione aggiunge le due cose che rendono un agente sicuro da far girare davvero: un piccolo pianificatore che divide un obiettivo in sottocompiti ordinati, e una protezione del ciclo che ferma l'agente prima che vada fuori controllo.
Prima, la pianificazione. decompose(goal) trasforma un obiettivo di una riga in una lista numerata di sottocompiti. La teniamo deterministica e basata su regole (in produzione lo fa l'LLM, ma ciò che conta è la forma): dividi l'obiettivo sulla parola "then", ripulisci ogni pezzo, e numerali da 1.
decompose("find the team size then multiply by 2 then report")
# ["1. find the team size", "2. multiply by 2", "3. report"]Ora la protezione. run_with_guard(policy, state, max_steps) guida una politica passo per passo, ma si rifiuta di andare fuori controllo. Qui una politica è una funzione policy(state) -> action (una stringa che nomina l'azione che vuole compiere); applicare un'azione la aggiunge semplicemente a una lista della cronologia. La protezione si ferma per uno di tre motivi e riporta quale:
- finito: la politica restituisce l'azione
"done"-> fermati con il motivo"done". - nessun progresso: la politica restituisce la stessa azione due volte di fila -> fermati con il motivo
"repeat". È il classico segnale di ciclo bloccato: l'agente non sta imparando dalle sue osservazioni. - budget: raggiunge
max_stepssenza finire -> fermati con il motivo"max_steps".
def run_with_guard(policy, state, max_steps):
history = []
for _ in range(max_steps):
action = policy(state)
if action == "done":
return {"history": history, "reason": "done"}
if history and action == history[-1]:
return {"history": history, "reason": "repeat"}
history.append(action)
# let the policy advance its own state here
...
return {"history": history, "reason": "max_steps"}Restituisci un dict {"history": [...], "reason": ...}. Il controllo "repeat" è ciò che ti salva: una politica bacata o confusa che continua a emettere "search" all'infinito viene fermata alla seconda azione identica, con un motivo che puoi registrare e su cui puoi far scattare allarmi. Una politica che si comporta bene, fa progressi e poi dice "done" finisce in modo pulito entro il suo budget. Il correttore controlla che una politica che cicla si fermi con "repeat", che una politica fuori controllo raggiunga "max_steps", e che una buona politica finisca con "done", più che decompose numeri correttamente. Premi Run per vedere tutti e tre gli esiti.
Scrivi decompose(goal): dividi goal su " then ", ripulisci ogni parte, e restituiscile come "1. part", "2. part", ... Poi scrivi run_with_guard(policy, state, max_steps) dove policy(state) restituisce una stringa di azione. Guida la politica fino a max_steps volte e restituisci {"history": [...], "reason": ...}: fermati con il motivo "done" quando l'azione è "done"; fermati con il motivo "repeat" quando un'azione è uguale a quella immediatamente precedente (nessun progresso); fermati con il motivo "max_steps" se il budget finisce. Aggiungi ogni azione accettata a history.
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.