Beplanning + Loop-waardes
'n agent wat kan optree kan ook optree vir altyd. Die nommer een manier waarop 'n regte agent geld verbrand en 'n aanwigs-ingenieur bel is 'n loop sonder remme: dit roep dieselfde tool aan, kry dieselfde observation, en besluit nooit dat dit klaar is nie. Hierdie les voeg die twee dinge by wat 'n agent veilig maak om werklik te hardloop: 'n kleinieë planner wat 'n doel in geordende subtake breek, en 'n loop guard wat die agent stop voordat dit uitbeur.
Eersens, beplanning. decompose(goal) verander 'n een-reël doelwit in 'n genommerde lys van subtake. Ons hou dit deterministies en reëlgebaseerd (die LLM doen dit in produksie, maar die shape is wat saak maak): verdeel die doelwit by die woord "then", verwyder die spasies van elke stuk, en nommer hulle vanaf 1.
decompose("find the team size then multiply by 2 then report")
# ["1. find the team size", "2. multiply by 2", "3. report"]Nou die wag. run_with_guard(policy, state, max_steps) dryf 'n beleid stap vir stap, maar dit weier om weg te hardloop. 'n Beleid hier is 'n funksie policy(state) -> action ( 'n string wat die aksie benoem wat dit wil neem); die toepassing van 'n aksie voeg dit net by 'n history-lys by. Die wag stop vir een van drie redes en rapporteer watter een:
- klaar: die beleid gee die aksie
"done"-> halt met rede"done"terug. - geen vordering: die beleid gee die deurmekaar aksie twee keer agtereeneen terug -> stop met rede
"repeat". Dit is die klassieke vasgevang-in-lus sein: die agent leer nie van sy waarnemings nie. - budget: dit bereik
max_stepssonder om klaar te maak -> stop met rede"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"}Gee 'n dict {"history": [...], "reason": ...}. Die "repeat" kontrole is wat jou red: 'n foutiewe of verwarde policy wat vir ewig "search" uitstoot, word gestop by die tweede identiese aksie, met 'n rede wat jy kan log en waarna jy kan waarsku. 'n Goeie policy wat vordering maak en dan "done" sê, eindig skoon binne sy begroting. Die grader kontroleer of 'n loopende policy stop met "repeat", 'n weglopende policy "max_steps" tref, en 'n goeie policy eindig met "done", plus dat daardie decompose getalle korrek is. Druk Run om al drie uitkomste te sien.
Skryf decompose(goal): split goal op " then ", strip elke deel, en gee hulle terug as "1. part", "2. part", ... Skryf dan run_with_guard(policy, state, max_steps) waar policy(state) 'n aksiestring teruggee. Dryf die beleid tot max_steps keer en gee {"history": [...], "reason": ...} terug: stop met rede "done" wanneer die aksie "done" is; stop met rede "repeat" wanneer 'n aksie gelyk is aan die een voor dit (geen vordering nie); stop met rede "max_steps" as die begrooting opraak. Voeg elke aanvaarde aksie by aan history.
Sien jy 'n probleem in hierdie les? Rapporteer dit · Vra oor hierdie les
Hierdie oefening open binnekort
Voltooi die lesie voor dit en hierdie een sal ontvanklik wees. Die hele kursus is gratis, geen rekening nodig nie, en jy kan hierdie les nou lees.
Hierdie blutser blokkeer koekies vir learn.floati.life, so lesse wat jy hier voltooi het kan nie in volgorde oopgaan nie. Laat koekies vir hierdie webwerf toe en laai nuut.