In de vorige delen van de workshopreeks over de OpenAI-API hebben we teksten samengevat, vertaald en er informatie uit gehaald. Dat bleef telkens beperkt tot één vraag en één antwoord. In dit laatste deel gaan we een stap verder: je gaat in je eigen Python-programma’s volwaardige conversaties voeren met het taalmodel van ChatGPT.

Je weet ondertussen hoe je in je Python-programma’s een vraag aan ChatGPT stelt via de OpenAI-API. We hebben dit in de vorige vier delen van deze workshopreeks geïllustreerd met talloze toepassingen. Maar onze programma’s hadden daarbij telkens dezelfde structuur: je stelt een vraag (de prompt), je krijgt een antwoord (de completion) en dan stopt de interactie.

Als je al eens van ChatGPT gebruikgemaakt hebt op de OpenAI-website, weet je dat je er ook volledige conversaties mee kunt voeren. Die mogelijkheid gaan we nu ook in onze eigen Python-programma’s inbouwen. In plaats van een klassieke, beperkte interface met invoer in een vast patroon, creëer je zo een conversationele interface. 

Basiscode

In de vorige delen van deze reeks maakten we altijd gebruik van een basisfunctie get_completion waaraan we een gebruikersprompt en eventueel een systeemprompt gaven, met optioneel ook een model. Die functie stuurde de prompt(s) door aan de OpenAI-API en gaf het antwoord terug.

Om een conversatie te voeren, moet het taalmodel toegang tot de hele context hebben, met de vorige boodschappen die het taalmodel en jij hebben uitgewisseld. Daarom maken we in dit deel een nieuwe hulpfunctie: get_completion_from_messages. Daaraan geef je de hele geschiedenis van boodschappen door. Onze basiscode ziet er dan als volgt uit:

Klik daarom in Visual Studio Code op File / New File en kies Python File. Plaats daarin de voorgaande Python-code. De API-sleutel moet je zelf aanmaken in je account bij OpenAI, net zoals in de vorige delen van deze workshopreeks.

Rollen

Waaruit bestaan die boodschappen nu? Het argument messages dat we aan de functie get_completion_from_messages moeten doorgeven, is een lijst van Python-dictionary’s, een datastructuur die sleutels en waardes heeft. Elke dictionary in de lijst messages heeft twee sleutels: "role" en "content". De eerste beschrijft de rol van de boodschap in de conversatie en de tweede de inhoud (de tekst).

De OpenAI-API kent drie rollen: system, user en assistant. Een boodschap met de rol system beschrijft een systeemprompt. Zoals we in de vorige delen uitlegden, geeft een systeemprompt algemene instructies aan het taalmodel. Een boodschap met de rol user beschrijft een vraag van de gebruiker. En een boodschap met de rol assistant beschrijft een antwoord van het taalmodel.

Een conversatie met de OpenAI-API kan er dan in Python als volgt uitzien in de vorm van boodschappen met een rol en inhoud:

Voeg deze lijst aan je code toe. Daarna kun je aan de OpenAI-API vragen om de conversatie in deze boodschappen voort te zetten:

Sla dit bestand in Visual Studio Code op met Ctrl+S en geef het een naam. Klik dan op Terminal / New Terminal, waarna er onder je code een nieuw deelvenster opent met een opdrachtprompt. Klik rechts bovenaan op het afspeelknopje (het driehoekje met de tooltip Run Python File als je erboven blijft hangen). Als alles goed gaat, krijg je nu in de terminal een antwoord als “Voor het geval dat de cloud gaat regenen!”.

Met deze kennis over de rollen weet je nu ook waarom er in de laatste regel van de functie get_completion_from_messages (en de functie get_completion die we in de eerdere workshops gebruikten) response.choices[0].message["content"] staat. Het stukje message["content"] geeft de tekst van het antwoord van het taalmodel terug. Als je message["role"] in die functie zou tonen, zou je "assistant" te zien krijgen.

Wat onthoudt de chatbot?

Je hebt gezien dat elke conversatie die je met het taalmodel voert, bestaat uit een lijst van boodschappen. Het taalmodel houdt rekening met alle informatie die in deze boodschappen te vinden is. Vertel je bijvoorbeeld in één boodschap je naam, dan kun je daar in een van de boodschappen erna naar vragen en kan het taalmodel daar perfect op antwoorden. Vervang de lijst messages uit het vorige voorbeeld maar eens door deze lijst en voer het programma uit:

De conversatie is eenvoudig. Het taalmodel krijgt de instructie dat het een vriendelijke chatbot is. Daarna stelt de gebruiker zich voor en vraagt het taalmodel wat het kan doen. De gebruiker vraagt dan wat zijn naam is.

Als je dit programma uitvoert, zul je zien dat het taalmodel de naam heeft onthouden. Je krijgt dan immers een antwoord als: “Je naam is Koen. Dat heb je net verteld! Is er nog iets specifieks waar je meer over wilt weten?”

In een andere conversatie waarin je je naam niet vertelt, zal de chatmodel niet op de vraag kunnen antwoorden wat je naam is. Deze conversatie bijvoorbeeld:

Dan krijg je als antwoord iets als: “Sorry, maar ik ben een chatbot en heb geen toegang tot persoonlijke informatie. Ik ken je naam niet.”

Het is belangrijk om te weten dat elke conversatie die je met het taalmodel voert volledig losstaat van de andere. Dat je eerder je naam verteld hebt in de andere conversatie, is geen informatie die in de nieuwe conversatie beschikbaar is. Het taalmodel kent alleen de algemene informatie waarop het is getraind en de lijst met boodschappen die je eraan doorgeeft. 

Conversaties voeren

Hierboven hebben we de boodschappen in de programmacode gezet. Maar we willen de gebruiker zelf invoer laten geven. Hoe doen we dat? Met nog een extra hulpfunctie, die de lijst met boodschappen opbouwt en telkens nieuwe invoer vraagt en de uitvoer toont. Dat doen we door de basiscode uit te breiden met:

Als je dit programma uitvoert, kun je een vraag intypen en met een druk op Enter doorsturen. De functie converse voegt je vraag als prompt toe aan de lijst met boodschappen in de variabele context. Ook het antwoord van het taalmodel voegt de functie aan de lijst toe en dat antwoord wordt getoond. We blijven in een oneindige lus (met while True) de functie oproepen, waarbij de context telkens wordt uitgebreid met je vraag en het antwoord. Daardoor onthoudt het taalmodel de voorgaande boodschappen en kunnen we een echte conversatie voeren.

Conversationele interface

We hebben nu in wezen een eenvoudige interface voor ChatGPT gebouwd in een terminalvenster. Maar we willen hier een conversationele interface van maken om op een gebruiksvriendelijke manier invoer voor een groter programma te verkrijgen. Als voorbeeld nemen we een computerspel, waarbij je in het begin je spelpersonage moet ontwerpen.

Een spelpersonage bestaat uit enkele eigenschappen, zoals naam, vaardigheid, uitrusting en ras. Het spel zou je dat allemaal in een formulier kunnen laten invullen, maar waarom niet in een conversatie? Dat gaan we in de rest van dit artikel programmeren. Als eerste stap moeten we dus een uitgebreide systeemprompt creëren die de conversatie kadert:

Ja, de systeemprompt moet echt zo lang zijn. Als we niet expliciet zeggen wat de chatbot wel en niet mag doen, krijgen we uiteindelijk niet wat we willen: een JSON-string met de eigenschappen van het personage. 

JSON

Een groot deel van onze systeemprompt bestaat uit instructies om de uiteindelijke keuzes van de gebruiker in de vorm van JSON (JavaScript Object Notation) te geven. Waarom is dat zo belangrijk? Omdat we de rest van ons programma alleen met gestructureerde gegevens kunnen laten omgaan, niet met tekst.

Dus als de gebruiker in een conversatie met onze assistent een speler met de naam Born heeft gekozen, die een orkenschurk is met een boog, dan moet ons programma dit uiteindelijk in de volgende vorm kunnen inlezen:

Converseren naar een doel

Het doel van onze conversatie is dus dat we uiteindelijk een JSON-string als hierboven krijgen, zodat het programma verder kan en we het spel kunnen spelen. We kunnen onze conversatie dus laten stoppen wanneer de uitvoer van de assistent een geldige JSON-string is.

Om JSON in Python te gebruiken, importeer je eerst de gelijknamige bibliotheek helemaal in het begin van het programma:

Daarna komt onze basiscode en de systeemprompt met de uitgebreide instructies van hierboven, en daarna creëren we de volgende functie converse:

Deze functie vraagt dus invoer van de gebruiker, voegt die aan de context toe en stelt de vraag aan de OpenAI-API. Het antwoord van de assistent voegen we aan de context toe.

Daarna probeert de functie om het antwoord van de assistent als een JSON-object in te laden. Lukt dat, dan geeft de functie dit JSON-object terug. Lukt dat niet, dan geeft Python de foutmelding json.decoder.JSONDecodeError terug en reageren we daarop door gewoon het antwoord van de assistent te tonen. Het is dan immers niet het laatste antwoord met de gestructureerde data in JSON-vorm, maar een vraag. In dat geval geeft de functie None terug, omdat de data nog niet volledig zijn.

Gestructureerde data

Hoe maken we nu van die functie converse gebruik? Dat doen we met de volgende code:

We initialiseren eerst de variabele properties door ze de waarde None te geven. Dan tonen we de eerste boodschap van de assistent, waarin we de gebruiker naar de naam van het spelpersonage vragen.

Daarna roepen we de hele tijd de functie converse met de context aan, zolang de waarde die deze functie teruggeeft None is. Zoals we in die functie gezien hebben, geeft ze een JSON-string terug als de assistent JSON-data teruggeeft en anders None. Als de assistent de instructies correct volgt (zie het kader “Doet je programma niet wat het moet doen?”), stopt de conversatie dus wanneer de data volledig zijn.

Op dat moment wordt de code na het while-blok uitgevoerd. We kunnen nu de eigenschappen van het spelpersonage op een gestructureerde manier uit het JSON-object properties halen. We tonen ze hier één voor één. Uiteraard zou je nog wat controles moeten uitvoeren, zodat er geen ongeldige waardes in staan wanneer het taalmodel niet goed werkt. Maar dat is een oefening voor de lezer!

Lees ook:

Je zit op de bank en streamt probleemloos een 4K-video op je telefoon, maar zodra je je laptop openklapt om een webpagina te laden, lijkt het alsof de verbinding vastloopt. Ligt het aan de router of aan je computer? In dit artikel leggen we uit waarom wifi-snelheden zo sterk kunnen verschillen per apparaat en wat je eraan kunt doen.

Je betaalt voor een snelle internetverbinding, dus is de verwachting dat elk apparaat in huis die snelheid ook daadwerkelijk haalt. Toch voelt het surfen op je computer soms stroperig aan, terwijl je smartphone ernaast nergens last van heeft. Vaak wordt er direct naar de internetprovider gewezen, maar het probleem zit meestal in de apparatuur zelf. Het verschil in hardware, leeftijd en software tussen mobiele apparaten en computers is namelijk groter dan je denkt. Na het lezen van dit stuk weet je precies waar die vertraging vandaan komt.

Generatiekloof: waarom je laptop vaak achterloopt

Het snelheidsverschil tussen je telefoon en je computer komt vaak neer op een simpele generatiekloof. We vervangen onze telefoons gemiddeld elke twee tot drie jaar, waardoor ze vaak uitgerust zijn met de nieuwste wifi-chips (zoals wifi 6 of 6E). Een laptop gaat vaak veel langer mee, soms wel vijf tot zeven jaar. Hierdoor probeert een verouderde netwerkkaart in je laptop te communiceren met een moderne router, wat resulteert in een lagere maximumsnelheid.

Daarnaast speelt de manier waarop data wordt verwerkt een grote rol. Een telefoon is geoptimaliseerd voor directe consumptie: apps op de achtergrond worden gepauzeerd om de app die je nú gebruikt voorrang te geven. Een computer werkt anders. Terwijl jij probeert te surfen, kan Windows of macOS op de achtergrond bezig zijn met zware updates, het synchroniseren van clouddiensten of het maken van back-ups. Je laptop snoept dus al bandbreedte weg zonder dat jij het doorhebt, waardoor er voor je browser minder overblijft.

Wanneer je laptop de strijd wél wint

De laptop wint het van de telefoon wanneer de omstandigheden optimaal zijn voor stabiliteit in plaats van pure mobiliteit. Als je beschikt over een moderne laptop met een recente netwerkkaart en je bevindt je in dezelfde ruimte als de router, kan de laptop vaak stabieler grote bestanden binnenhalen.

Dat geldt vooral als je laptop verbonden is met de 5GHz-frequentieband. Deze frequentie is veel sneller dan de oude 2.4GHz-band, maar heeft een korter bereik. Als je dicht bij het toegangspunt zit, profiteert je laptop van zijn krachtigere processor om complexe webpagina's sneller op te bouwen dan een telefoon dat kan, mits de verbinding zelf niet de bottleneck is.

Waarom je telefoon soepeler aanvoelt

Het verschil wordt pijnlijk duidelijk zodra je verder van de wifi-bron af gaat zitten, bijvoorbeeld op zolder of in de tuin. Smartphones zijn vaak agressiever geprogrammeerd om het sterkste signaal te pakken of snel tussen frequenties te schakelen. Veel laptops blijven daarentegen te lang plakken op een zwak 5GHz-signaal of vallen onnodig terug op de trage en vaak overvolle 2.4GHz-band (het zogeheten 'sticky client'-probleem).

Daarnaast hebben smartphones een trucje dat laptops helaas moeten missen: wifi-assist (of een vergelijkbare term). Als de wifi even hapert, gebruikt de telefoon ongemerkt een beetje 4G- of 5G-data om de stroom stabiel te houden. Je laptop heeft die optie meestal niet en laat direct een laadicoontje zien. Hierdoor voelt de telefoon sneller aan, terwijl hij eigenlijk een beetje vals speelt door mobiele data bij te schakelen.

Harde grenzen: wanneer traagheid onvermijdelijk is

Er zijn situaties waarin je laptop de strijd sowieso verliest, ongeacht hoe dicht je bij de router zit. Dit zijn de harde grenzen:

Zo check je of jouw hardware het probleem is

Om te bepalen of je laptop de boosdoener is, moet je eerst kijken naar de verbinding. Klik op het wifi-icoon op je laptop en controleer of je verbonden bent met een 5GHz-netwerk (vaak te zien bij Eigenschappen of netwerkinformatie). Is dat niet het geval en sta je wel dicht bij de router? Dan is je netwerkkaart waarschijnlijk verouderd of staan de instellingen niet goed.

Kijk ook eens kritisch naar je gebruik. Heb je toevallig nog applicaties openstaan zoals Steam, OneDrive of Dropbox? Deze programma's kunnen de verbinding volledig dichttrekken. Op een telefoon gebeurt dit zelden automatisch op de achtergrond. Als je laptop ouder is dan vijf jaar, kan een simpele upgrade met een moderne wifi-usb-dongle het probleem vaak al verhelpen, zonder dat je een hele nieuwe computer hoeft aan te schaffen.

Kortom: leeftijd en software maken het verschil

Dat je telefoon sneller is op wifi dan je laptop, komt meestal doordat telefoons nieuwere netwerkchips hebben en slimmer omgaan met datastromen. Laptops hebben vaak last van zware achtergrondprocessen of blijven hangen op een tragere frequentieband. Daarnaast schakelen telefoons bij zwak wifi soms ongemerkt over op 4G/5G, wat de ervaring vloeiender maakt. Controleer of je laptop op de 5GHz-band zit en sluit zware achtergrondprogramma's af om snelheid te winnen.

Tomodachi Life: Waar Dromen Uitkomen komt op 16 april uit voor Nintendo Switch.

Dat heeft Nintendo vanmiddag aangekondigd in een speciale Direct-uitzending die om de game draait. Ondanks dat de game voor de eerste Switch verschijnt, zal hij via backwards compatibility ook speelbaar zijn op Nintendo Switch 2.

In de Tomodachi Life-games van Nintendo kunnen spelers zelf Mii-personages creëren en bijvoorbeeld baseren op het uiterlijk van henzelf, vrienden en familie of beroemdheden. Deze Mii's leiden vervolgens hun eigen leven op een eiland, wat allerlei gekke en hilarische situaties oplevert. Spelers kunnen zelf ook invloed uitoefenen op deze verschillende situaties.

Over Tomodachi Life: Waar Dromen Uitkomen

In de Direct-uitzending werd meer informatie gegeven over het aankomende Tomodachi Life: Waar Dromen Uitkomen. Zo is duidelijk dat spelers hun Mii-personages unieke persoonlijkheden, gewoontes en woningen kunnen geven. Spelers kunnen tijdens de game zien waar de personages aan denken, en ze helpen bij problemen. De tijd in de game verstrijkt daarbij net zo snel als in de echte wereld, wat het de moeite waard maakt om het spel op verschillende momenten op te starten.

Het is daarbij mogelijk om de verschillende Mii-personages kennis met elkaar te laten maken, om te zien wat er vervolgens gebeurd. Personages kunnen bijvoorbeeld praten over hun favoriete eten en filmgenres. Het is daarnaast mogelijk om acht Mii-personages bij elkaar in een huis te laten wonen, wat weer unieke reacties van de personages veroorzaakt.

Op het eiland waar de game zich afspeelt kunnen spelers de personages winkels te laten bezoeken. Bijvoorbeeld een supermarkt waar allerlei etenswaren worden verkocht, of de mogelijkheid om kleding en kostuums te kopen. In een speciale marktkraam worden redelijk geprijsde artikelen meerdere malen per dag ververst.

Ook is er een ontwerpatelier, waar spelers verschillende voorwerpen kunnen maken, waaronder kledingstukken, versiering voor huizen en zelfs huisdieren. Het eiland kan sowieso naar eigen smaak worden ingedeeld, met bankjes, bomen, planten en meer.