AI-agenter · leksjon

Verdensmodeller og fremoverskuing

Forutsi resultatet av en handling før De utfører den, og velg handlingen med det beste forventede utfallet.

Leksjon 3 av 415 trinn

Verdensmodeller og fremoverskuing er en gratis leksjon i AI-agenter på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i AI-agenter, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i AI-agenter inneholder totalt 4 leksjoner.

Deler av denne leksjonen er ennå ikke oversatt og vises på engelsk.

Forutsi før du handler

De beste agentene prøver ikke bare ting – de forutsier først resultatene, velger det beste alternativet og handler deretter. Det er samme idé som å se N trekk fremover i sjakk.

Hva er en verdensmodell?

En verdensmodell forutsier: Gitt den nåværende tilstanden S og handlingen A, hva er den neste tilstanden S'?

For en LLM-agent kan LLM-en selv være verdensmodellen:

prediction_prompt = '''
Current state: {state}
Proposed action: {action}
What is the most likely outcome? Return JSON: {new_state, success_probability}.
'''

Hvorfor lookahead hjelper

Noen handlinger kan ikke gjøres om, som å sende e-post eller slette data. Ved å forutsi først kan du unngå kostbare feil.

Andre handlinger har uklare resultater. Forutsigelser tvinger agenten til å tenke gjennom konsekvensene.

Simple 1-Step Lookahead

candidates = [a1, a2, a3]
predictions = [predict(state, a) for a in candidates]
best = max(zip(predictions, candidates), key=lambda p: p[0].success_probability)[1]
act(best)

Lookahead over flere trinn (tresøk)

Utvid søket flere trinn fremover. For hvert kandidatvalg forutsier du resultatene, og forutsier deretter resultatene av disse resultatene:

def search(state, depth=2):
    if depth == 0:
        return value(state)
    actions = candidate_actions(state)
    best_score = -math.inf
    for a in actions:
        next_state = predict(state, a)
        score = search(next_state, depth - 1)
        best_score = max(best_score, score)
    return best_score

Tree of Thoughts

Yao et al. 2023 – utvider CoT til et tre. Agenten genererer flere «tankestier», evaluerer hver av dem og utvider den mest lovende:

import random

def continue_thought(question):
    return question + ' -> idea' + str(random.randint(1, 100))

def score(t):
    return len(t)

def expand_top_k(thoughts, scores, k):
    ranked = sorted(zip(thoughts, scores), key=lambda x: -x[1])
    return [t for t, s in ranked[:k]]

def ToT(question):
    thoughts = [continue_thought(question) for _ in range(5)]
    for depth in range(2):
        scores = [score(t) for t in thoughts]
        thoughts = expand_top_k(thoughts, scores, k=3)
    return thoughts

result = ToT('How to reduce agent latency?')
print('Top thoughts:', result)

Monte Carlo Tree Search (MCTS)

For svært store søketrær: Ta utvalg av stier, gi resultatene poeng, og før poengene tilbake oppover for å påvirke fremtidige valg. Brukes mye i spillbasert AI og blir stadig mer brukt i agentforskning.

Kostnaden ved lookahead

Hver forutsagte handling er et LLM-kall. Lookahead med dybde=2 og forgrening=3 krever 9 kall bare for å velge ÉN handling. Bruk bare lookahead ved avgjørelser med høy risiko.

Heuristisk beskjæring

Hopp over forutsigelser for handlinger som åpenbart er dårlige. Filtrer kandidatene på forhånd med en billig klassifikator eller regel.

Kalibrer forutsigelsene

LLM-forutsigelser er ufullkomne. Kalibrer dem ved av og til å sammenligne forutsagte og faktiske resultater:

for trace in recent_traces:
    predicted = trace.predicted_outcome
    actual = trace.actual_outcome
    log.info('prediction-accuracy', match=(predicted == actual))

Når du IKKE bør bruke lookahead

Billige, reversible handlinger – bare prøv dem
Stier der forsinkelse er kritisk
Oppgaver der resultatene er åpenbare

Når du BØR bruke lookahead

Handlinger som ikke kan gjøres om (økonomi og kommunikasjon)
Planer over flere trinn der feil forsterkes
Områder med høy risiko (medisin og juss)
Motstanderpregede oppgaver (spill og debatt)

Lookahead internt i o1-stil

Resonneringsmodellene OpenAI o1 og o3 utfører automatisk intern lookahead under «tenkefasen». De utforsker mange fortsettelser før de bestemmer seg. Du trenger ikke å implementere dette eksternt.

Avveiningen ved lookahead

Hva er den viktigste kostnaden ved lookahead over flere trinn?

Besvar den i den interaktive leksjonen

Oppsummering

Forutsi før du handler. Lookahead i ett trinn er billig og nyttig, mens tresøk er kostbart, men kraftig. Resonneringsmodeller som o1 og o3 automatiserer dette. Bruk det med måte.

Gratis å komme i gang

Lær deg AI-agenter med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 60
Leksjoner: 239

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Verdensmodeller og fremoverskuing» gratis?

Ja – hele teksten i «Verdensmodeller og fremoverskuing» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av AI-agenter-kurset, kan du oppgradere til CoddyKit PRO. Kurset i AI-agenter inneholder totalt 4 leksjoner.

Hva lærer jeg i «Verdensmodeller og fremoverskuing»?

Forutsi resultatet av en handling før De utfører den, og velg handlingen med det beste forventede utfallet. Du øver på AI-agenter med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med AI-agenter?

Ingen tidligere erfaring er nødvendig. AI-agenter på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Verdensmodeller og fremoverskuing»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne AI-agenter-leksjonen?

Ja. Alle AI-agenter-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til AI-agenter