Plannen + lusbewakers
Een agent die kan handelen, kan ook eindeloos handelen. De belangrijkste manier waarop een echte agent geld verbrandt en een dienstdoende engineer uit bed belt, is een lus zonder rem: hij blijft dezelfde tool aanroepen, krijgt dezelfde observatie en besluit nooit dat hij klaar is. Deze les voegt de twee dingen toe die een agent veilig maken om echt te draaien: een kleine planner die een doel opsplitst in geordende deeltaken, en een lusbewaker die de agent stopt voordat hij doorslaat.
Eerst het plannen. decompose(goal) zet een doel van één regel om in een genummerde lijst deeltaken. We houden het deterministisch en op regels gebaseerd (in productie doet het LLM dit, maar het gaat om de vorm): splits het doel op het woord "then", haal de spaties rond elk stuk weg en nummer ze vanaf 1.
decompose("find the team size then multiply by 2 then report")
# ["1. find the team size", "2. multiply by 2", "3. report"]Nu de bewaker. run_with_guard(policy, state, max_steps) stuurt een policy stap voor stap aan, maar weigert door te slaan. Een policy is hier een functie policy(state) -> action (een string met de naam van de actie die hij wil doen); een actie toepassen voegt haar alleen toe aan een geschiedenislijst. De bewaker stopt om een van drie redenen en meldt welke:
- klaar: de policy geeft de actie
"done"terug -> stop met reden"done". - geen voortgang: de policy geeft twee keer achter elkaar dezelfde actie terug -> stop met reden
"repeat". Dit is het klassieke signaal van vastzitten in een lus: de agent leert niet van zijn observaties. - budget: hij bereikt
max_stepszonder klaar te zijn -> stop met reden"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"}Geef een dict {"history": [...], "reason": ...} terug. De controle op "repeat" is je redding: een kapotte of verwarde policy die eindeloos "search" blijft uitspugen, wordt bij de tweede identieke actie gestopt, met een reden die je kunt loggen en waarop je kunt alarmeren. Een policy die zich goed gedraagt, voortgang boekt en dan "done" zegt, eindigt netjes binnen zijn budget. De beoordelaar controleert dat een lussende policy stopt met "repeat", dat een op hol geslagen policy "max_steps" raakt en dat een goede policy eindigt met "done", plus dat decompose goed nummert. Druk op Run om alle drie de uitkomsten te zien.
Schrijf decompose(goal): split goal op " then ", strip elk deel en retourneer ze als "1. part", "2. part", ... Schrijf dan run_with_guard(policy, state, max_steps) waar policy(state) een actiestring retourneert. Voer de policy uit tot max_steps keer en retourneer {"history": [...], "reason": ...}: stop met reden "done" wanneer de actie "done" is; stop met reden "repeat" wanneer een actie gelijk is aan de direct vorige (geen vooruitgang); stop met reden "max_steps" als het Budget op is. Voeg elke geaccepteerde actie toe aan history.
Een probleem ontdekt in deze les? Meld het · Vraag naar deze les
Deze oefening opent binnenkort
Maak de les ervoor af voordat deze wordt ontgrendeld. De hele cursus is gratis, geen account nodig, en je kunt deze les nu lezen.
Deze browser blokkeert cookies voor learn.floati.life, dus lessen die je hier hebt afgerond kunnen niet in de juiste volgorde worden geopend. Sta cookies toe voor deze site en laad de pagina opnieuw.