Skip to main content
AI EducademyAIEducademy
🌳

AI-Fundamenten

🌱
AI Seeds

AI-geletterdheid voor de echte wereld

🌿
AI Sprouts

De fundamenten achter intelligente systemen

🌳
AI Branches

Bouw met de huidige AI-mogelijkheden

🏕️
AI Canopy

Ontwikkel betrouwbare GenAI-systemen

🌲
AI Forest

Verstuur AI-producten op verantwoorde wijze

🔨

AI-Meesterschap

✏️
AI Sketch

Technische basis voor AI-bouwers

🪨
AI Chisel

Patronen voor het oplossen van moeilijkere problemen

⚒️
AI Craft

Ontwerp systemen die AI schalen

💎
AI Polish

Communiceer en geef leiding in het AI-tijdperk

🏆
AI Masterpiece

Het sluitstuk van uw productie-AI

🚀

Carrière Klaar

🚀
Interview Startplatform

Navigeer door de AI-engineering-banenmarkt

🌟
Gedragsinterview Meesterschap

Vertel het verhaal over hoe jij impact creëert

💻
Technische Interviews

Oplossen, ontwerpen en communiceren onder druk

🤖
AI- & ML-interviews

Bereid je voor op moderne ML- en GenAI-interviews

🏆
Aanbod & verder

Maak een zelfverzekerde, geïnformeerde volgende stap

Alle programma's bekijken→

Laboratorium

7 experimenten geladen
🧠Neuraal netwerk speeltuin🤖AI of mens?💬Prompt-lab🎨Beeldgenerator😊Sentimentanalyse💡Chatbot bouwer⚖️Ethiek simulator
🎯Proef-sollicitatieGa het laboratorium binnen→
TrajectBloggen
🎯
Over ons

AI-onderwijs toegankelijk maken voor iedereen, overal

❓
Veelgestelde vragen

Veelgestelde vragen beantwoord

🧰
AI-tools

Zorgvuldig gekozen tools die we gebruiken en aanraden

✉️
Contacteer

Neem contact met ons op

⭐
Open source

Openbaar gebouwd op GitHub

Prijzen
Begin met leren
AI EducademyAIEducademy

© 2026 AI Educademy. Alle rechten voorbehouden.

Leren

  • Opleidingen
  • Lessen
  • Laboratorium
  • AI-starterskit
  • Prijzen

Gemeenschap

  • GitHub
  • Bijdragen
  • Gedragscode
  • Over ons
  • Veelgestelde vragen

Ondersteuning

  • Koop een koffie voor me ☕
  • Servicevoorwaarden
  • Privacybeleid
  • Contacteer
  • Sitemap
AI & Engineering Opleidingen›🏕️ AI Canopy›Lessen›Grote taalmodellen - De motoren achter moderne AI
🤖
AI Canopy • Gevorderd⏱️ 20 min leestijd

Grote taalmodellen - De motoren achter moderne AI

Grote taalmodellen - De motoren achter moderne AI

Grote taalmodellen hebben fundamenteel veranderd wat machines met tekst, code en redeneren kunnen doen. In deze les kijken we achter de schermen: hoe ze werken, waarom ze zo krachtig zijn en waar ze nog tekortschieten.

Wat is een LLM precies?

Een groot taalmodel is een neuraal netwerk dat op enorme hoeveelheden tekst is getraind om het volgende token in een reeks te voorspellen. "Groot" verwijst naar het aantal parameters: leerbare gewichten die patronen uit trainingsdata vastleggen.

  • GPT-6 Astra vertegenwoordigt de huidige grens van OpenAI, met niet-gepubliceerde modelinterne details.
  • Llama 4 Scout and Maverick gebruiken mixture-of-experts-ontwerpen met 17 miljard actieve parameters en veel grotere totale aantallen parameters.
  • Mistral 7B laat zien dat kleinere modellen veel beter kunnen presteren dan hun omvang doet vermoeden.

Deze modellen worden getraind op honderden miljarden woorden uit boeken, websites, code-repositories en academische papers. De enorme schaal van data en parameters geeft LLM's hun opmerkelijke veelzijdigheid.

Tokens, geen woorden: LLM's verwerken geen volledige woorden. Ze werken met tokens, eenheden die kleiner zijn dan woorden. Het woord "understanding" kan bijvoorbeeld worden gesplitst in "under" + "stand" + "ing". Een gemiddeld Engels woord is ongeveer 1,3 token. Deze tokenisatie helpt modellen zeldzame woorden, technisch jargon en zelfs meerdere talen te verwerken zonder een onmogelijk grote woordenschat.

🤯

Het trainen van een frontier-taalmodel kan honderden miljoenen kosten aan rekenkracht, data, energie en engineering. Dat is ongeveer het budget van een grote film, behalve dat de "acteur" elke programmeertaal kan spreken.

De Transformer-architectuur

Elk modern LLM is gebouwd op de Transformer, geïntroduceerd in het paper uit 2017 Attention Is All You Need. De kerninnovatie is self-attention, een mechanisme waarmee het model weegt hoe belangrijk elk woord is ten opzichte van elk ander woord in de invoer.

Hoe self-attention werkt (vereenvoudigd):

  1. Elk token wordt omgezet in drie vectoren: Query, Key en .
Les 1 van 130% voltooid
←Terug naar programma
Verdergaan: Prompt Engineering - De Kunst en Wetenschap van Praten met AI→

Discussie

Meld je aan om deel te nemen aan de discussie

Stel een wijziging voor deze les voor
Value
  • Het model berekent attentiescores door elke Query met elke Key te vergelijken.
  • Deze scores bepalen hoeveel elk token "aandacht besteedt" aan elk ander token.
  • De gewogen som van Values levert een contextbewuste representatie op.
  • De wiskundige formule in het hart van attention is:

    Attention(Q, K, V) = softmax(QK^T / √d) × V

    De deling door √d (de vierkantswortel van de key-dimensie) voorkomt dat de dotproducten te groot worden, waardoor de softmax-functie in gebieden met extreem kleine gradiënten terecht zou komen. Deze eenvoudige schaaltruc was een van de belangrijkste inzichten die het trainen van diepe Transformers stabiel maakte.

    Dit wordt parallel herhaald over meerdere attention heads, waardoor het model tegelijk verschillende soorten relaties kan vastleggen, bijvoorbeeld syntaxis in de ene head en semantiek in een andere.

    Diagram dat het Transformer self-attention-mechanisme toont met Query-, Key- en Value-vectoren
    Self-attention laat elk token op elk ander token letten, waardoor afhankelijkheden over lange afstand worden vastgelegd.
    🤔
    Think about it:

    Als een zin 500 tokens heeft, vergelijkt self-attention elk token met elk ander token. Dat zijn 250.000 vergelijkingen per laag. Welk effect kan deze kwadratische kost hebben op wat LLM's kunnen verwerken?

    Belangrijke modellen in het landschap

    | Model | Maker | Opvallende eigenschap | |-------|---------|-----------------| | GPT-6 Astra | OpenAI | Frontier-redeneren, coderen, onderzoek en multimodale invoer | | Claude Opus 5.5 | Anthropic | Langlopende agentische codering en kenniswerk | | Gemini 3.1 Pro | Google DeepMind | Geavanceerd redeneren, coderen en multimodaliteit | | Llama 4 | Meta | Open gewichten, native multimodaliteit, lange context | | Mistral Large | Mistral AI | Efficiënt Europees alternatief |

    Het vakgebied beweegt buitengewoon snel. Tegen de tijd dat je dit leest, kunnen er alweer nieuwere modellen bestaan.

    Een cruciaal onderscheid in dit landschap is dat tussen gesloten modellen (GPT, Claude, Gemini), waarbij alleen de API beschikbaar is, en open-weight modellen (Llama, Mistral), waarbij de modelgewichten openbaar zijn vrijgegeven. Open-weight modellen laten organisaties inferentie draaien op hun eigen infrastructuur, fine-tunen voor specifieke domeinen en het gedrag van het model inspecteren, voordelen die bijzonder belangrijk zijn voor privacygevoelige sectoren.

    💡

    Niet alle "open" modellen zijn echt open source. Sommige geven gewichten vrij, maar beperken commercieel gebruik of delen de trainingsdata en code niet. Controleer altijd de licentie voordat je een open-weight model in productie inzet.

    Pre-training, fine-tuning en RLHF

    LLM's worden in fases gebouwd:

    1. Pre-training - Het model leest enorme hoeveelheden tekst en leert het volgende token te voorspellen. Deze fase is extreem duur en levert een basismodel op dat tekst kan aanvullen, maar nog niet bijzonder behulpzaam is.

    2. Supervised fine-tuning (SFT) - Door mensen geschreven voorbeelden van ideale antwoorden leren het model instructies volgen en vragen goed beantwoorden.

    3. RLHF (Reinforcement Learning from Human Feedback) - Menselijke beoordelaars rangschikken modeluitvoer van best naar slechtst. Een reward model leert deze voorkeuren, waarna het LLM wordt getraind om de beloning te maximaliseren. Dit maakt modellen behulpzaam, onschadelijk en eerlijk.

    🧠Snelle check

    Wat is het primaire doel van RLHF in LLM-training?

    Emergent capabilities

    Naarmate modellen groter worden, ontwikkelen ze vaardigheden waarvoor ze niet expliciet zijn getraind:

    • Complex redeneren - Logische deductie in meerdere stappen en wiskundige probleemoplossing.
    • Code genereren - Code schrijven, debuggen en uitleggen in tientallen talen.
    • Meertalige vloeiendheid - Tekst vertalen en genereren in talen met relatief weinig trainingsdata.
    • In-context learning - Gedrag aanpassen op basis van voorbeelden in de prompt, zonder updates van de gewichten.

    Deze emergente eigenschappen zijn een van de fascinerendste aspecten van schaalvergroting: vaardigheden die bijna "gratis" lijken te verschijnen zodra een model bepaalde groottedrempels overschrijdt.

    🤯

    Vroege frontier-modellen lieten het patroon duidelijk zien: ze konden moeilijke beroepsexamens halen, maar struikelden nog steeds over eenvoudige reken- of teltaken wanneer de prompt hun zwaktes blootlegde.

    Beperkingen die je moet begrijpen

    LLM's zijn krachtig, maar verre van perfect:

    • Hallucinaties - Modellen genereren tekst die zelfverzekerd klinkt, maar feitelijk onjuist is. Ze "kennen" geen feiten. Ze voorspellen waarschijnlijke tokenreeksen.
    • Contextvensterlimieten - Elk model heeft een maximale invoergrootte, van honderdduizenden tot meer dan een miljoen tokens voor huidige frontier-systemen. Informatie buiten dit venster is simpelweg onzichtbaar.
    • Kosten en latency - Inferentie op grote modellen vereist dure GPU-clusters. Een topklasse frontier-query kost aanzienlijk meer dan een query naar een klein of middelgroot model.
    • Gebrek aan echt begrip - LLM's manipuleren statistische patronen in tekst. Of dat als "begrip" telt, is een diep filosofisch debat.
    • Training data cutoffs - Modellen weten niets over gebeurtenissen nadat hun trainingsdata is verzameld, tenzij ze worden aangevuld met retrieval-systemen.
    💡

    Controleer kritieke feiten uit LLM-uitvoer altijd bij gezaghebbende bronnen. Behandel LLM's als een briljante maar onbetrouwbare onderzoeksassistent: buitengewoon nuttig, maar nooit het laatste woord over feitelijke zaken.

    🧠Snelle check

    Waarom produceren LLM's soms hallucinaties?

    Het schaaldebat

    Jarenlang was de dominante overtuiging dat groter altijd beter is: meer parameters, meer data en meer rekenkracht zouden de prestaties gestaag verbeteren. Deze "scaling law" hield opmerkelijk goed stand gedurende de GPT-2-, GPT-3- en GPT-4-generatie en latere frontier-systemen.

    Recent onderzoek suggereert echter dat we mogelijk afnemende meeropbrengsten bereiken met ruwe schaal alleen. De focus verschuift naar:

    • Betere datakwaliteit boven kwantiteit (gecureerde, gededupliceerde datasets).
    • Inference-time compute, waarbij modellen "langer nadenken" over moeilijke problemen in plaats van het model zelf groter te maken.
    • Gespecialiseerde architecturen, zoals mixture-of-experts-modellen die per query maar een fractie van de parameters activeren, waardoor efficiëntie verbetert zonder capaciteit op te offeren.

    Afronding

    Grote taalmodellen vormen een echte paradigmaverschuiving in computing. Hun architectuur, trainingspijplijn en beperkingen begrijpen is niet optioneel voor wie serieus met AI werkt. Het is basiskennis die je goed van pas komt terwijl het vakgebied zich blijft ontwikkelen.

    🧠Snelle check

    Welke fase van LLM-training is computationeel het duurst?

    🤔
    Think about it:

    Als een LLM het balie-examen kan halen, maar niet betrouwbaar het aantal letters in een woord kan tellen, wat zegt dat dan over het verschil tussen menselijke intelligentie en de mogelijkheden van taalmodellen?