0%

Hoofdstuk 2 · oefening

Gesprekken en instructies

Een model onthoudt niets

In hoofdstuk 1 las je dat een model niets bewaart tussen aanroepen. Deze les laat dat in de praktijk zien en lost het daarna op de enige manier op die werkt: je programma stuurt het gesprek bij elk request opnieuw mee.

Je project voor dit hoofdstuk

Open conversation.py in de projecteditor. Het begint met een import:

from llm_basics import MODEL, answer_text, ask_model, send_body

llm_basics.py is de afgeronde code uit hoofdstuk 1, die ernaast is meegeleverd, zodat ask_model, send_body en answer_text werken zoals jij ze hebt gebouwd. Je hoeft dat bestand niet aan te passen. De controle van je werk gebruikt een eigen kopie ervan, dus een wijziging daarin kan geen beoordeling veranderen, maar wel de demonstratie laten vastlopen.

Onder de import staan twee constanten die je later in het hoofdstuk gebruikt en acht onafgemaakte functies. Net als in hoofdstuk 1 voert python conversation.py het bestand uit, en de demonstratie onderaan roept elke functie aan zodra die bestaat.

Twee aanroepen die elkaar niet kennen

Voer in de Shell nu python conversation.py uit, voordat je iets verandert. De demonstratie stuurt My name is Sam. met ask_model en stuurt daarna What is my name? met een tweede, losse aanroep van ask_model:

Two separate calls:
  You: My name is Sam.
  Model: Nice to meet you, Sam.
  You: What is my name?
  Model: I don't know your name. You haven't told me in this conversation.
One call that carries the history:
Run stopped at the next function to build: remembering_messages is built in Lesson 1.

De laatste regel is dezelfde stopregel als in hoofdstuk 1: de demonstratie stopt bij de eerste functie die je nog niet hebt gebouwd. Het tweede request bevatte één bericht, What is my name?, en verder niets. Voor het model is dat request het hele gesprek. Het eerste request heeft wel plaatsgevonden, maar niets ervan bereikte het tweede.

Een echt model gedraagt zich net zo. Het gescripte model geeft precies dit antwoord omdat het zo geschreven is, maar een live model dat alleen What is my name? krijgt, kan het antwoord evenmin weten.

Stuur de geschiedenis mee

Om het model te laten antwoorden, moet het tweede request naast de nieuwe vraag ook de eerste uitwisseling bevatten. De lijst messages van een chatrequest bevat het gesprek op volgorde, het oudste eerst:

messages = [
    {"role": "user", "content": "My name is Sam."},
    {"role": "assistant", "content": "Nice to meet you, Sam."},
    {"role": "user", "content": "What is my name?"},
]
for message in messages:
    print(message["role"], "said:", message["content"])

Wat jij typte gaat erin als een user-bericht, zoals in hoofdstuk 1. Het eerdere antwoord van het model gaat terug als een assistant-bericht, zodat het model kan zien wat het eerder zei. Les 2 bekijkt deze rollen, en een derde, van dichterbij.

Deze lijst is de geschiedenis van het gesprek. Het model slaat die nergens op. Je programma bewaart haar en stuurt alles elke keer mee, en het model leest het bij elke aanroep opnieuw. Zo lijkt elke chatapp die je ooit hebt gebruikt iets te onthouden.

Bouw remembering_messages

remembering_messages() geeft precies die lijst van drie berichten terug: My name is Sam. van de gebruiker, Nice to meet you, Sam. van de assistent en What is my name? van de gebruiker, in die volgorde en met precies die tekst.

Geef bij elke aanroep een nieuwe lijst terug. Dat gebeurt vanzelf als je de lijst in de functie zelf uitschrijft, want Python bouwt elke keer dat de regel wordt uitgevoerd een verse lijst. Als de functie in plaats daarvan één lijst teruggaf die bovenaan het bestand staat, zouden alle aanroepers die delen, en een aanroeper die er een bericht aan toevoegt, zou veranderen wat de volgende aanroeper krijgt. Les 3 rekent op geschiedenissen die niet achter je rug om veranderen.

Voer python conversation.py opnieuw uit. De demonstratie stuurt je lijst met send_body:

response = send_body({"model": MODEL, "messages": remembering_messages()})

en deze keer antwoordt het model vanuit de geschiedenis:

One call that carries the history:
  Model: Your name is Sam.
A system message first:
Run stopped at the next function to build: system_message is built in Lesson 2.

Het gescripte model heeft een voorbereid antwoord op What is my name? dat het alleen geeft als een eerder gebruikersbericht my name is sam zegt. SCRIPTED_MODEL.md noemt die regel. Het is een vervanger voor wat een echt model doet door de geschiedenis te lezen, zodat je het verschil kunt zien zonder live model.

Een chatapp toont een lang gesprek, en het nieuwste antwoord van het model verwijst naar iets wat je tien berichten geleden zei. Wat maakte dat mogelijk?

In de geschiedenis die je stuurt, staat het eerdere antwoord van het model, Nice to meet you, Sam., als bericht met welke rol?

Opdracht

Vervang in conversation.py de onafgemaakte body van remembering_messages().

Geef een nieuwe lijst van drie berichten terug, in deze volgorde:

  1. {"role": "user", "content": "My name is Sam."}

  2. {"role": "assistant", "content": "Nice to meet you, Sam."}

  3. {"role": "user", "content": "What is my name?"}

Voer python conversation.py uit om het model vanuit de geschiedenis te zien antwoorden, en controleer daarna je werk.