Introductie tot Large Language Models

Introductie

Wat is precies een Large Language Model? Om die vraag te beantwoorden, beginnen we met iets vertrouwds. Stel je voor dat je een tekstbericht typt op je telefoon. Nadat je een paar woorden hebt getypt, suggereert je telefoon het volgende woord — en soms is het zo accuraat dat je gewoon op de suggestie tikt om door te typen. Die voorspellende tekstfunctie is een zeer eenvoudige vorm van een taalmodel. Een Large Language Model (LLM) werkt volgens hetzelfde basisidee, maar op een enorm grotere schaal.

Een LLM is een neuraal netwerk getraind op enorme hoeveelheden tekst — boeken, artikelen, websites, code en meer. Tijdens dit trainingsproces leest het model miljarden zinnen en leert het de statistische relaties tussen woorden en zinsdelen. Het ontdekt patronen zoals: wanneer bepaalde woorden verschijnen, welke woorden er meestal op volgen; hoe zinnen worden gestructureerd; hoe context de betekenis verandert; en hoe verschillende stukken informatie met elkaar verband houden. Zodra de training is voltooid, kan het model samenhangende, contextueel passende tekst genereren als antwoord op een door u verstrekte prompt.

Het "Large" in Large Language Model verwijst tegelijk naar twee dingen. Ten eerste naar de schaal van de trainingsgegevens — moderne LLM's worden getraind op datasets die honderden miljarden tot biljoenen tokens bevatten (waarbij een token ongeveer een woord of deel van een woord is). Ten tweede naar het model zelf — deze modellen bevatten miljarden parameters, dit zijn de interne numerieke waarden die alles coderen wat het model heeft geleerd. Een model met 7 miljard parameters heeft bijvoorbeeld 7 miljard instelbare getallen die samen zijn kennis van taal vertegenwoordigen.

Waarom is dit belangrijk voor u als Jetson-ontwikkelaar? Tot voor kort vereiste het uitvoeren van een model van deze schaal dure cloudservers met meerdere high-end GPU's. De grote doorbraak in de afgelopen twee jaar is dat technieken zoals kwantisatie — comprimeren van de numerieke precisie van het model — het nu mogelijk maken om capabele LLM's uit te voeren op edge-apparaten zoals de NVIDIA Jetson Orin Nano en Orin NX. Dit betekent dat u AI-gestuurde toepassingen kunt bouwen die volledig offline werken, uw gegevens privé houden en de afhankelijkheid van internetverbindingen elimineren.

Hoe LLM's Werken

Nu u begrijpt wat een LLM is, is de natuurlijke vraag: hoe produceert het eigenlijk tekst? Het antwoord draait om één kernoperatie — het voorspellen van het volgende token in een sequentie.

Tokens: De Bouwstenen

Voordat we bespreken hoe het model tekst genereert, moeten we verduidelijken wat het betekent om tekst als "tokens" te verwerken. Een LLM leest geen ruwe tekst zoals mensen dat doen. In plaats daarvan breekt een tokenizer uw input op in kleinere eenheden die tokens worden genoemd. Een token kan een heel woord zijn zoals "computer", een veelvoorkomend woordfragment zoals "the", of zelfs een enkel teken in een onbekende taal. Bijvoorbeeld:

"The reComputer runs Linux"
→ ["The", " re", "Computer", " runs", " Linux"]   (5 tokens)

De vocabulaire van de tokenizer bevat doorgaans tussen 30.000 en 100.000 tokens. Elk stuk tekst dat het model ziet wordt omgezet in een sequentie van deze tokens voordat enige verwerking plaatsvindt.

Het Trainingsproces

Het trainen van een LLM omvat drie sleutelfasen, elk voortbouwend op de vorige:

Fase 1 — Vooraf trainen op ruwe tekst. Het model krijgt enorme hoeveelheden tekst gevoed (veelvoorkomende bronnen zijn onder andere Common Crawl, Wikipedia, GitHub-repository's en gepubliceerde boeken). In deze fase is de taak van het model bedrieglijk eenvoudig: gegeven een sequentie van tokens, voorspel het volgende token. Wanneer het model bijvoorbeeld "The Eiffel Tower is located in" ziet, leert het dat "Paris" het meest waarschijnlijke volgende token is. Door deze oefening te herhalen over miljarden voorbeelden bouwt het model geleidelijk een interne representatie op van grammatica, feiten, redeneerpatronen en zelfs programmeerlogica.

Fase 2 — Begeleide Fijnafstelling (SFT). Na het vooraf trainen heeft het model brede kennis maar geen idee hoe het zich moet gedragen als een nuttige assistent. In deze fase creëren menselijke annotatoren voorbeelden van hoogwaardige prompt-antwoord-paren. Het model wordt op deze voorbeelden getraind om de opmaak en stijl van nuttige antwoorden te leren.

Fase 3 — Uitlijning (RLHF of vergelijkbaar). In de laatste fase rangschikken menselijke beoordelaars meerdere modelantwoorden van beste tot slechtste. Deze feedback traint een beloningsmodel, dat op zijn beurt de LLM begeleidt om antwoorden te produceren die behulpzamer, onschadelijker en eerlijker zijn. Daarom produceren moderne chatmodellen samenhangendere en nuttigere antwoorden dan de voorfase alleen zou suggereren.

Inferentie: Tekst Genereren Één Token tegelijk

Zodra de training is voltooid, genereert het model tekst via een proces dat inferentie wordt genoemd. Hier is exact wat er gebeurt wanneer u een prompt typt:

De tokenizer converteert dit naar token-ID's. Het model verwerkt deze tokens en produceert een kansverdeling over alle tokens in zijn vocabulaire. Het token "Paris" ontvangt de hoogste waarschijnlijkheid, dus het wordt geselecteerd en aan de uitvoer toegevoegd. De bijgewerkte sequentie luidt nu "The capital of France is Paris", en het model herhaalt het proces — het volgende token voorspellen. Dit gaat door tot het model een speciaal einde-van-sequentie-token uitvoert, of tot een maximale lengtelimiet wordt bereikt.

Stap 1: "The capital of France is"         → "Paris" voorspellen
Stap 2: "The capital of France is Paris"    → "and" voorspellen
Stap 3: "The capital of France is Paris and"→ " the" voorspellen
Stap 4: ...doorgaan tot voltooiing

Een cruciaal punt om te begrijpen: het model "kent" het antwoord niet zoals een database-opzoeking werkt. Het produceert tekst die statistisch waarschijnlijk is gegeven zijn trainingsgegevens. Daarom kunnen LLM's soms plausibel klinkende maar onjuiste beweringen genereren — een beperking waar u rekening mee moet houden bij het bouwen van toepassingen.

Het hele proces — van uw prompt tot het complete antwoord — is wat er gebeurt tijdens elke interactie met een LLM. In de volgende sectie bekijken we de specifieke neurale netwerkarchitectuur die dit alles mogelijk maakt.

_{Hoe Large Language Models Tekst Verwerken en Genereren}

De Transformer-Architectuur

Bijna alle moderne LLM's zijn gebaseerd op de Transformer-architectuur, geïntroduceerd in het baanbrekende paper "Attention Is All You Need" (2017) door onderzoekers bij Google. Dit ene paper veranderde fundamenteel de koers van AI — en de modellen die u op Jetson zult uitvoeren (Llama, Qwen, DeepSeek, Gemma) zijn allemaal directe afstammelingen van deze architectuur.

De sleutelinnovatie is het zelf-Attention-mechanisme, dat het model in staat stelt het belang van verschillende woorden te wegen bij het verwerken van tekst — waardoor het context, relaties en betekenis op een ongekend niveau kan begrijpen.

_{De Transformer: Fundament van Moderne LLM's}

Van Sequentieel naar Parallel: Waarom Transformers Wonnen

Voor Transformers verwerkten modellen zoals RNN's (Recurrente Neurale Netwerken) en LSTM's tekst één woord tegelijk, sequentieel van links naar rechts. Dit veroorzaakte twee grote problemen:

1. Traag: Elk woord hing af van de berekening van het vorige woord — geen parallelisme mogelijk
2. Vergeetachtig: tegen de tijd dat het model het 100e woord bereikte, had het grotendeels het 1e woord "vergeten"

RNN (Oud):     "The" → "cat" → "sat" → "on" → "the" → "mat"   (traag, sequentieel)
Transformer:    ["The", "cat", "sat", "on", "the", "mat"] → allemaal tegelijk!   (snel, parallel)

De Transformer loste beide problemen op door alle woorden tegelijk te verwerken via zelf-Attention. Dit maakte het trainen dramatisch sneller en stelde modellen in staat om langdurige relaties effectief te vatten.

Hoe Zelf-Attention Werkt

Zelf-Attention is de kerninnovatie van de Transformer. Laten we het begrijpen via een concreet voorbeeld.

Een Real-World Analogie — Het Interview Selectieproces:

Stel je voor dat je een sollicitant zoekt en 5 CV's hebt ontvangen. Je moet elke kandidaat evalueren door ze te vergelijken met een "functiebeschrijving" (wat je zoekt). Zo werkt zelf-Attention:

• Elk CV is zowel kandidaat als functiebeschrijving — klinkt vreemd, maar zo behandelt zelf-Attention elk woord in een zin
• De "functiebeschrijving" voor het evalueren van kandidaat A heet de Query (Q)
• Elk CV heeft een sectie "kwalificaties" — dit zijn de Keys (K)
• De eigenlijke CV-inhoud (ervaring, vaardigheden, opleiding) is de Value (V)

Stel je nu voor dat je wilt uitzoeken waar het woord "it" naar verwijst in deze zin:

"The robot picked up the ball because it was heavy."

Hier is het stapsgewijze proces:

Stap 1: Genereer Q/K/V voor elk woord

Elk woord in de zin genereert zijn eigen Query-, Key- en Value-vectoren. Denk eraan als elk woord dat zowel een "zoekvraag" als "te delen inhoud" voorbereidt:

Stap 2: Bereken relevantiescores — het dot product

Voor het woord "it" nemen we zijn Query-vector en berekenen we dot producten met de Key-vectoren van ALLE andere woorden:

"it" Query × "robot" Key = 0.2 (lage relevantie — robots worden typisch niet als zwaar beschreven in deze context)
"it" Query × "picked" Key = 0.1 (irrelevant — "picked" zegt niets over gewicht)
"it" Query × "ball" Key = 0.9 (hoge relevantie — ballen kunnen zeker zwaar zijn!)

Stap 3: Pas softmax toe om te normaliseren

Deze ruwe scores gaan door softmax, wat ze omzet in waarschijnlijkheden die optellen tot 1:

"ball":  0.82 (82% — "it" verwijst hoogstwaarschijnlijk naar "ball")
"robot": 0.15 (15%)
"picked": 0.03 (3%)

Stap 4: Gewogen som van Values

Nu combineren we alle Value-vectoren met behulp van deze gewichten:

Nieuwe "it" representatie = 0.82 × ball.Value + 0.15 × robot.Value + 0.03 × picked.Value

Het resultaat? Het woord "it" "weet" nu dat het naar de bal verwijst, en draagt die betekenis voort.

Stap 5: Herhaal voor Elk woord

Dit exacte proces gebeurt voor elk woord in de zin tegelijk. "robot" kijkt naar "ball", "picked", etc. om zijn context te begrijpen. "ball" kijkt naar "robot" en "picked". Iedereen kijkt tegelijk "naar" iedereen anders via het Query-Key-Value-mechanisme.

De Wiskunde:

Dit proces kan als volgt worden geschreven:

Waarbij dₖ de vectordimensie is en √dₖ een schaalfactor is die voorkomt dat getallen te groot worden tijdens de dot product-berekening. De sleutelinzicht is niet de formule — het is dit: elk woord berekent hoe relevant elk ander woord voor zichzelf is, en verzamelt dienovereenkomstig informatie.

_{Zelf-Attention: Woorden Die Aandacht Aan Elkaar Besteden}

Multi-Head Attention

In de vorige sectie zag je hoe zelf-Attention elk woord elk ander woord laat bekijken en relevantiescores berekenen. Het resultaat is een nieuwe set vectoren waarbij elk woord al context heeft gemengd van de woorden waarnaar het heeft gekeken. Dit is krachtig, maar het heeft een beperking: een enkele Attention-doorgang kan slechts één type relatie tegelijk vastleggen.

Overweeg "The robot picked up the ball because it was heavy." De link tussen "it" en "ball" (voornaamwoordreferentie) en de link tussen "robot" en "picked" (onderwerp-werkwoord) zijn twee fundamenteel verschillende soorten relaties. Een enkele Attention-berekening kan er één ontdekken, maar om meerdere relatietypes tegelijk vast te leggen, heb je meerdere Attention-doorgangen parallel nodig.

Multi-Head Attention doet precies dit. Het idee is eenvoudig: in plaats van Attention één keer uit te voeren, voer het meerdere keren parallel uit, waarbij elke "head" zijn eigen onafhankelijke relatiepatroon leert.

Concreet heeft elke head zijn eigen aparte set Q, K, V-gewichtsmatrices. Dit betekent dat voor hetzelfde woord elke head het in andere Q, K, V-vectoren mapt, waardoor het naar andere andere woorden kijkt. Vier heads die dezelfde zin verwerken zijn als vier waarnemers die door filters van verschillende kleuren kijken, elk ziet een ander "aspect" van de zin:

Zin: [The] [robot] [picked] [up] [the] [ball] [because] [it] [was] [heavy]

Head 1 (grammatica):      robot ↔ picked   picked ↔ up
Head 2 (nabijheid):       the ↔ robot      picked ↔ up
Head 3 (semantiek):       heavy ↔ ball     robot ↔ machine
Head 4 (referentie):      it ↔ ball

Alle vier heads draaien tegelijk, elk produceert zijn eigen Attention-uitvoer. De vier uitvoeren worden vervolgens geconcateneerd en doorgegeven via een lineaire transformatie om ze samen te voegen tot één uniforme uitvoer:

   Head 1 (grammatica)    Head 2 (nabijheid)    Head 3 (semantiek)    Head 4 (referentie)
        ↓                    ↓                      ↓                    ↓
   [uitvoer 1]          [uitvoer 2]           [uitvoer 3]          [uitvoer 4]
        ↓                    ↓                      ↓                    ↓
                      Concateneren + Lineaire Transform
                                   ↓
                    [Uniforme uitvoer met alle vier informatietypes]

Deze uniforme uitvoer draagt alle vier dimensies van relationele informatie tegelijk, klaar voor de volgende netwerklaag. Daarom begrijpen Transformers taal zo diep — in plaats van een zin vanuit één hoek te bekijken, analyseren ze deze parallel vanuit meerdere dimensies.

De Transformer Blockstructuur

Je begrijpt nu de kern van multi-head Attention: door meerdere parallelle Attention-heads kan elk woord de zin tegelijk begrijpen vanuit grammatica-, semantiek- en referentieperspectief. Maar Attention alleen is niet het hele plaatje. Een Transformer-model wordt gebouwd door veel identieke blokken op elkaar te stapelen — Llama 3.2 3B stapelt bijvoorbeeld 28 ervan. Deze bouwstenen worden Transformer-blokken genoemd, en elk volgt dezelfde interne stroom.

Fase 1 — Multi-Head Zelf-Attention. Zoals je al weet, kijkt elk woord naar elk ander woord, berekent relevantiescores via Query-Key-matching en verzamelt informatie van zijn meest relevante buren. De uitvoer is een nieuwe representatie voor elk woord dat nu contextuele informatie uit de hele zin bevat.

Fase 2 — Feed-Forward Network (FFN). Nadat Attention elk woord met context heeft verrijkt, verwerkt het FFN elk woord onafhankelijk. Denk eraan als een klein tweelaags neuraal netwerk wiens taak het is om te vragen: "Nu ik de context ken, welke diepere kenmerken kan ik uit dit woord extraheren?" Het FFN slaat een verrassend deel van de eigenlijke "kennis" van het model op — het fungeert als een redeneermotor per woord.

Tussen en rond deze twee fasen zorgen twee belangrijke veiligheidsmaatregelen ervoor dat het diepe netwerk trainbaar blijft:

• Residuele Verbinding (Add): Na zowel de Attention- als de FFN-fase wordt de oorspronkelijke input terug toegevoegd aan de uitvoer. Dit is als het installeren van een zekering op een apparaat — zelfs als een tussentijds module een onvolmaakt resultaat produceert, gaan de oorspronkelijke informatie nooit verloren. Zonder dit mechanisme zou in een stapel van 28 lagen het trainingssignaal (gradiënt) tijdens backpropagation tot vrijwel nul vervallen, en zou het model helemaal niet kunnen leren.

• Laag Normalisatie: Na de residuele optelling worden alle waarden herschaald naar een stabiel bereik. Denk eraan als een spanningsregelaar in een elektrisch circuit — het voorkomt dat het signaal "explodeert" na het doorlopen van 28 opeenvolgende versterkingsfasen.

De kritische inzicht is dat elk opeenvolgend blok een dieper abstractieniveau bouwt. Vroege blokken vatten basissyntaxis — welke woorden buren zijn, welke woorden onderwerpen of objecten zijn. Middelste blokken beginnen semantiek te assembleren — "the ball" is een naamwoordelijke frase, "was heavy" is een beschrijving. Bij de laatste blokken heeft het model een rijk, gelaagd begrip van de hele input gebouwd, klaar voor naukeurige volgende-token-voorspelling.

Encoder vs. Decoder

De oorspronkelijke Transformer-architectuur beschreven in "Attention Is All You Need" (2017) had eigenlijk twee helften, elk met een andere taak. Het begrijpen van deze splitsing helpt verklaren waarom moderne LLM's zo zijn gebouwd als ze zijn.

De Encoder — de lezer. De taak van de Encoder is om een hele inputzin in één doorgang te lezen en een diep begrip van elk woord in context te bouwen. Het gebruikt bidirectionele Attention — wat betekent dat elk woord naar elk ander woord kan kijken, zowel links als rechts. Omdat het de hele zin tegelijk ziet, blinkt de Encoder uit in begripstaken: het samenvatten van een alinea, het classificeren van sentiment of het extraheren van het hoofdonderwerp van een document. BERT is het bekendste encoder-only model, en Qwen en Gemma bieden ook Encoder-varianten.

De Decoder — de schrijver. De taak van de Decoder is fundamenteel anders: het genereert tekst één token tegelijk, van links naar rechts. Het gebruikt gemaskeerde zelf-Attention, wat betekent dat bij het voorspellen van het derde woord het alleen het eerste en tweede woord kan zien — nooit de toekomst. Deze afgedwongen blindheid is essentieel: als het model zou kunnen "spieken" door naar het antwoord te kijken, zou het nooit leren om zelf te genereren. GPT, Llama en DeepSeek gebruiken allemaal deze decoder-only architectuur.

Encoder-Decoder — beide samen. Sommige taken vereisen zowel begrip als generatie: het vertalen van een zin van Engels naar Chinees vereist bijvoorbeeld eerst het lezen van de hele Engelse zin (Encoder), en vervolgens het woord-voor-woord genereren van de Chinese vertaling (Decoder). Whisper (het spraakherkenningsmodel dat je eerder in dit hoofdstuk tegenkwam) gebruikt deze gecombineerde architectuur.

De reden waarom moderne LLM's zoals Llama, GPT, Qwen en DeepSeek zich op decoder-only hebben gevestigd is elegant simpel: een Decoder getraind op voldoende data leert zowel begrijpen als tekst genereren. Wanneer het het volgende token voorspelt, moet het impliciet alles begrijpen wat ervoor kwam — en dat impliciete begrip blijkt voldoende voor een opmerkelijk breed scala aan taken.

Positionele Encoding: De Woordvolgorde Kennen

In de vorige secties zag je hoe zelf-Attention elk woord elk ander woord laat bekijken en relevantiescores berekenen. Maar er is een subtiele eigenschap die gemakkelijk over het hoofd wordt gezien: Attention heeft geen idee in welke volgorde de woorden verschijnen. Het berekent relevantie tussen alle woordparen, maar de berekening is volledig onafhankelijk van positie.

Dit betekent dat als je "The cat chased the dog" en "The dog chased the cat" in het model zou voeren, vanuit het Attention-perspectief de berekeningen identiek zouden zijn — beide zinnen bevatten exact dezelfde woorden, alleen in een andere volgorde. Dat is duidelijk onaanvaardbaar: het herschikken van dezelfde woorden verandert de betekenis volledig.

Positionele encoding is ontworpen om dit probleem exact op te lossen. Het idee is intuitief: voordat de vector van elk woord in Attention wordt gevoed, voeg je een positie-vingerafdruk toe — een wiskundig vervaardigde vector wiens enige doel is te zeggen "dit woord zit op deze positie". Denk eraan als een stoelnummer in een bioscoop: het stoelnummer vertelt je niets over de film, maar het stelt je in staat om altijd onderscheid te maken tussen rij 3 stoel 5 en rij 10 stoel 2.

In de praktijk wordt de vingerafdruk van elke positie gegenereerd met sinus- en cosinusfuncties:

Positie 0: "What"   + [0.00, 1.00, 0.00, 1.00, ...]
Positie 1: "is"     + [0.84, 0.54, 0.84, 0.54, ...]
Positie 2: "Jet"    + [0.91, -0.42, 0.91, -0.42, ...]

Waarom sinus en cosinus? Omdat aangrenzende posities altijd iets verschillende vingerafdrukwaarden produceren, en deze waarden continu zijn (niet eenvoudige gehele getallen 0, 1, 2). Dit betekent dat zelfs als het model alleen getraind is op zinnen tot 100 posities lang, het kan generaliseren naar zinnen van 200 posities — het "ritme" van de positionele encoding is voorspelbaar en regelmatig.

Moderne modellen zoals Llama en Qwen zijn overgestapt naar RoPE (Rotary Position Embedding). In plaats van een positiewaarde toe te voegen, draait RoPE de vector van elk woord in de hoogdimensionale ruimte met een hoek bepaald door zijn positie. Dit brengt een extra voordeel met zich mee: de relatieve afstand tussen twee woorden (hoeveel posities ze uit elkaar staan) wordt direct weerspiegeld in het hoekverschil tussen hun geroteerde vectoren, niet alleen in hun absolute posities. Dit maakt het model stabieler en flexibeler bij het verwerken van tekst van variërende lengtes.

Stap voor Stap: Hoe een Transformer Tekst Verwerkt

Nu je alle kerncomponenten van een Transformer hebt geleerd, laten we een volledig voorbeeld doorlopen om te zien hoe ze samenwerken. We volgen de vraag: "Wat is Jetson?"

Stap 1 — Tokenisatie De ruwe inputtekst wordt opgesplitst in tokens (typisch subwoordfragmenten):

Stap 2 — Embedding Elk token wordt omgezet in een hoogdimensionale numerieke vector. Llama 3.2 3B produceert bijvoorbeeld een 3072-dimensionale vector voor elk token:

"What" → [0.23, -0.45, 0.67, ..., 0.12]   (3072 getallen)
"is"   → [0.12, 0.89, -0.34, ..., 0.56]
"Jet"  → [0.78, 0.11, 0.56, ..., -0.33]
"son"  → [0.45, -0.23, 0.91, ..., 0.78]
"?"    → [0.67, 0.34, -0.12, ..., 0.45]

Stap 3 — Voeg Positionele Encoding Toe Een positionele encoding-vector wordt toegevoegd aan de embedding van elk token, waardoor het model bewustzijn van woordvolgorde krijgt, zoals in de vorige sectie in detail is uitgelegd.

Stap 4 — Zelf-Attention (herhaald over N lagen) Het model berekent Attention-scores tussen alle tokens om relaties te vinden:

"What" besteedt meeste aandacht aan:   "?" (0.5), "Jet" (0.4), "is" (0.3)
"is"  besteedt meeste aandacht aan:   "What" (0.4), "Jetson" (0.5)
"Jet" besteedt meeste aandacht aan:   "son" (0.8), "is" (0.3)

Na Attention bevat de representatie van elk token nu informatie van de woorden waarnaar het heeft gekeken.

Stap 5 — Feed-Forward Network De verrijkte representatie van elk token wordt onafhankelijk verwerkt via een klein neuraal netwerk om kenmerken op een hoger niveau te extraheren.

Stap 6 — Herhaal (N gestapelde lagen) Stappen 4 en 5 herhalen zich many times (28 keer voor Llama 3.2 3B). Elke laag bouwt een dieper begripsniveau:

• Vroege lagen vatten basissyntaxis en lokale relaties (woordvolgorde, collocaties)
• Middelste lagen assembleren semantiek ("Jetson" is een zelfstandig naamwoord dat verwijst naar een computerplatform)
• Late lagen vormen hoog niveau, taakspecifiek begrip klaar voor voorspelling

Stap 7 — Uitvoervoorspelling De representatie van het laatste token wordt geprojecteerd op de hele vocabulaire, en het token met de hoogste waarschijnlijkheid wordt geselecteerd als de voorspelling van het model voor het volgende woord:

{"NVIDIA": 0.92, "AI": 0.03, "a": 0.02, ...}
→ Voorspelling: "NVIDIA" (hoogste waarschijnlijkheid)

Belangrijke Transformer Concepten

Schaalwetten: Waarom Grotere Modellen Slimmer Zijn

Een van de meest opvallende ontdekkingen in AI-onderzoek is dat Transformer-prestaties schaalwetten volgen — voorspelbare verbeteringen naarmate je de schaal van het model, de data of het computerbudget vergroot. Deze ontdekking verklaart de snelle sprong in AI-capaciteit in het afgelopen decennium.

Schaalwetten omvatten drie sleuteldimensies:

• Meer Parameters (Modelgrootte): Het verhogen van het aantal parameters — van 3 miljard naar 70 miljard, bijvoorbeeld — verhoogt significant de diepte van begrip en expressiviteit van het model. Grotere modellen kunnen subtielere patronen vastleggen en meer kennis opslaan.

• Meer Trainingsdata: Een groter model getraind op onvoldoende data is als een grote eter met een kleine maaltijd — het kan zijn potentieel niet bereiken. Onderzoek toont aan dat modelgrootte en trainings-token-aantal idealiter samen moeten schalen, ruwweg in een verhouding van 1:1.

• Meer Compute: Het trainen van grotere modellen vereist meer GPU-tijd en budget. Grote AI-labs kunnen honderden miljoenen dollars uitgeven aan één trainingsrun, daarom overtreffen hun proprietaire modellen wat open-source projecten kunnen bereiken.

Omdat alle drie dimensies samen hebben geschaald, is het veld gevorderd van de originele Transformer in 2017 (slechts 110 miljoen parameters) naar de huidige 70+ miljard parameter modellen. Voor je Jetson-apparaat is de belangrijkere implicatie deze: zelfs 1-miljard tot 3-miljard parameter modellen bezitten solide begrips- en generatiecapaciteiten — meer dan genoeg om praktische AI-diensten aan de edge te leveren.

Modelgroottes en Lokale Implementatie

Niet alle LLM's hebben dezelfde grootte. Het begrijpen van modelschaal is cruciaal voor het kiezen van de juiste voor je hardware — parameteraantal bepaalt direct geheugenvereisten en inferentiesnelheid:

Voor Jetson-apparaten ligt de sweet spot bij 1B tot 8B. Modellen in het 1B–3B bereik leveren zeer vloeiende interactieve ervaringen op Orin Nano, terwijl 7B–8B modellen betrouwbaar draaien op de 16GB Orin NX.

Tip: Na kwantisatie (volgende sectie) daalt het geheugengebruik dramatisch. Een 7B model bij INT4-kwantisatie vereist slechts ongeveer 3.5GB geheugen — klein genoeg om op vrijwel elk Jetson-apparaat te draaien.

Populaire Open-Source LLM-Families

Hier zijn de meest prominente open-source LLM-families, die allemaal varianten aanbieden die goed draaien op Jetson:

Llama (Meta)

Meta's open-source LLM — momenteel de meest actieve community en rijkste ecosysteem.

• Llama 3.2 komt in 1B en 3B maten, speciaal gebouwd voor edge-apparaten met uitstekende balans tussen prestaties en voetafdruk
• Ondersteunt meerdere talen; de community biedt een breed scala aan fijnafgestelde varianten
• Beste ondersteunde modelfamilie in zowel Ollama als llama.cpp-ecosystemen

Qwen (Alibaba Cloud)

Alibaba's open-source LLM, leider onder open modellen in Chinese taalcapaciteit.

• Qwen3.5 strekt zich uit van 0.8B tot 122B parameters; de 0.8B-variant is ideaal voor resource-beperkte edge-scenario's
• Uitstekende tweetalige ondersteuning in zowel Chinees als Engels
• Ondersteunt native toolgebruik en chain-of-thought redeneren

DeepSeek

Een modelfamilie gericht op redeneren, uitstekend in wiskunde, codering en logische taken.

• DeepSeek-R1 biedt gedistilleerde versies (1.5B, 7B, 8B) die significant beter presteren dan modellen van dezelfde grootte op redeneerbenchmarks
• Goed geschikt voor edge AI-toepassingen die precise logische analyse vereisen
• De 7B gedistilleerde versie is een van de beste prijs-kwaliteitverhouding redeneermodellen op Jetson

Phi (Microsoft)

De compacte modelfamilie van Microsoft, gebouwd op de filosofie van "minder parameters, hogere kwaliteit".

• Phi-4-mini heeft slechts 3,8 miljard parameters maar evenaart of overtreft veel 7B modellen op standaard benchmarks
• Speciaal ontworpen voor resource-beperkte omgevingen — een natuurlijke pasvorm voor edge-implementatie
• Getraind op hoogwaardige "tekstboek-klasse" data met een onderscheidende trainingsmethodologie

Gemma (Google)

De lichtgewicht open-source modelfamilie van Google, van 1B tot 27B parameters.

• Gemma 4 in zijn 2B en 4B varianten draait zeer goed op Jetson
• Sterke prestaties in zowel taalbegrip als codegeneratie
• Beschikbaar in zowel voorgetrainde als instructie-fijnafgestelde versies

Kwantisatie: Modellen Kleiner Maken

Om een model met 7 miljard parameters soepel te draaien op een edge-apparaat zoals een Jetson, moet je kwantisatie toepassen — het reduceren van de numerieke precisie van de interne gewichten van het model, het verhandelen van "perfect maar zwaar" hoogprecieze getallen voor "ruw maar goed genoeg" laagprecieze getallen, waardoor het geheugengebruik dramatisch vermindert.

Intuïtief is het alsof je een 4K-afbeelding comprimeert naar 720p: de inhoud blijft volledig behouden, maar de bestandsgrootte neemt vele malen af. Voor een 7B model zijn de geheugenbesparingen op verschillende precisieniveaus aanzienlijk:

INT4-kwantisatie is het werkpaard van edge-implementatie: een 7B model past in 3.5GB geheugen, klein genoeg om soepel te draaien op de meeste Jetson-apparaten.

Veelvoorkomende Kwantisatieformaten

Verschillende inferentiemotoren ondersteunen verschillende gekwantiseerde bestandsformaten, elk met zijn eigen sterke punten:

• GGUF (llama.cpp-ecosysteem): Het dominante formaat voor lokale inferentie — native ondersteund door Ollama en llama.cpp, zelfbeschrijvend en klaar voor gebruik
• SafeTensors (HuggingFace-ecosysteem): Veiliger (voert geen willekeurige code uit bij laden), en het standaardformaat voor vLLM en HuggingFace-gebaseerde pipelines
• AWQ (Activatie-bewuste Gewichtskwantisatie): Geoptimaliseerd voor GPU-inferentie, veel gebruikt met vLLM, en de beste performer voor high-throughput scenario's

Overzicht van Inferentieframeworks

Zodra een model is getraind, heb je een inferentieframework nodig om het daadwerkelijk op je Jetson te draaien. Dit hoofdstuk behandelt drie mainstream frameworks — elk ontworpen voor een andere fase van de reis, van beginner tot productie-implementatie.

Ollama — De Snelste Manier om te Beginnen

Ollama is de snelste weg naar het lokaal draaien van een LLM. Installatie in één regel, ingebouwde modeldownloads en -beheer — het werkt out of the box en is zeer beginner-vriendelijk:

# Installeer Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Draai een model (eerste start downloadt automatisch)
ollama run llama3.2:3b

Het beste voor: Eerste LLM-ervaring, snel prototypen, leren en verkennen

llama.cpp — De Meest Precieze Controle

llama.cpp is een lichtgewicht C/C++ implementatie die modellen efficiënt draait op CPU en GPU. De sterke punten zijn minimaal resourcegebruik en brede ondersteuning voor gekwantiseerde formaten — waardoor het de favoriete keuze is voor resource-beperkte edge-apparaten:

# Kloon en bouw
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && make -j$(nproc)

# Voer inferentie uit
./llama-cli -m model.gguf -p "Hello, how are you?"

Het beste voor: Scenario's die maximale controle en prestatie-optimalisatie vereisen; lichtgewicht edge-implementatie

vLLM — Productieklasse Serving

vLLM is een high-performance inferentie-serving framework ontworpen voor productie-implementaties. Het ondersteunt geavanceerde functies zoals PagedAttention (geheugenpaginabeheer dat de gelijktijdigheid dramatisch verhoogt) en continue batching, met een OpenAI-compatibele API:

# Installeer vLLM
pip install vllm

# Start de API-server
vllm serve meta-llama/Llama-3.2-3B --host 0.0.0.0 --port 8000

Het beste voor: Productie API-serving, hoge gelijktijdigheid, high-throughput scenario's

Vergelijkingstabel

Elk framework heeft zijn sterke punten. De juiste keuze hangt af van je specifieke behoeften:

Wat Je in Dit Hoofdstuk Zult Leren

De rest van dit hoofdstuk begeleidt je door het instellen van LLM's op je Jetson en het bouwen van een complete spraak-AI-toepassing:

Module 5.2: Aan de Slag met Ollama

Installeer Ollama vanaf nul op je Jetson, pull je eerste model, en voer een lokaal gesprek met een AI — volledig offline.

Module 5.3: LLM's Draaien met llama.cpp

Ga dieper onder de motorkap: bouw llama.cpp vanaf source, leer GGUF-gekwantiseerde modellen te laden en draaien, en beheerst fijnmazige optimalisatietechnieken voor edge-apparaten.

Module 5.4: High-Performance Inferentie met vLLM

Stel een productieklasse LLM-serving infrastructuur in met een OpenAI-compatibele API, en verander je Jetson in een lokale AI-backend.

Module 5.5: Jetson Examples Snelstart

Implementeer LLM's met één commando met behulp van vooraf gebouwde Docker-containers uit de jetson-examples repository, waarbij je alle lastige omgevingsinstellingen overslaat.

Module 5.6: ASR + LLM + TTS Pipeline

Koppel spraakherkenning (ASR), een large language model (LLM) en tekst-naar-spraak (TTS) tot een complete spraak-AI-assistent — alles draait offline op je Jetson.

Oefening: Beoordeel Je Hardware

Voordat je doorgaat naar de implementatiemodules, controleer de hardwarecapaciteiten van je Jetson-apparaat zodat je het juiste model kunt kiezen:

# Controleer beschikbaar geheugen
free -h

# Controleer GPU-model en VRAM
nvidia-smi

# Controleer JetPack-versie (bepaalt CUDA en TensorRT-versies)
dpkg -l | grep nvidia-jetpack

# Controleer beschikbare opslag
df -h /

Noteer je resultaten:

• Totaal RAM: ______ GB
• GPU VRAM: ______ MB
• Vrije Opslag: ______ GB
• JetPack Versie: ___________

Met deze cijfers kun je bepalen welke modelgroottes comfortabel op je apparaat zullen draaien.

Oefening: Objecten Detecteren met een Visie-Taal Model

Nu je begrijpt hoe LLM's tekst verwerken, laten we een Visie-Taal Model (VLM) in actie zien — een dat afbeeldingen kan zien en beschrijven wat erin staat. Het onderstaande voorbeeld gebruikt Ollama om een lokale afbeelding naar een VLM te sturen, dat objectnamen en pixelcoördinaten retourneert. OpenCV tekent vervolgens gelabelde begrenzingsvakken op de afbeelding.

Vereisten

pip install ollama opencv-python Pillow
ollama pull llava:7b   # alleen de eerste keer, ~4.7GB

Draaien

cd code/
python vlm_object_detector.py --image your_photo.jpg
python vlm_object_detector.py --image photo.jpg --model minicpm-v --output results.jpg

VLM's zijn geen gespecialiseerde detectoren zoals YOLO (Hoofdstuk 4) — de nauwkeurigheid van begrenzingsvakken varieert per model. Het doel van deze oefening is om je praktische ervaring te geven met dezelfde token-gebaseerde redenering achter LLM's, uitgebreid naar afbeeldingen via multimodale modellen — tekst en visie volgen dezelfde weg binnen een Transformer.

Veelgestelde Vragen

Kan ik ChatGPT op Jetson draaien?

Niet precies. ChatGPT is OpenAI's proprietaire systeem dat draait op massieve serverclusters. Je kunt echter open-source modellen met vergelijkbare conversatiemogelijkheden lokaal draaien op je Jetson, met het extra voordeel van complete gegevensprivacy.

Heb ik internettoegang nodig om LLM's op Jetson te gebruiken?

Na de initiële modeldownload kun je LLM's volledig offline draaien. Dit is een van de belangrijkste voordelen voor edge-implementaties in gebieden met beperkte connectiviteit.

Hoe lang duurt het om een antwoord te genereren?

De responstijd hangt af van de modelgrootte en je hardware. Op een Jetson Orin NX 16GB met een 3B model kun je 10-30 tokens per seconde verwachten — snel genoeg voor realtime gesprekken.

Referenties

• Attention Is All You Need (Originele Transformer-paper)
• The Illustrated Transformer - Visuele gids door Jay Alammar
• https://huggingface.co/blog/Esmail-AGumaan/attention-is-all-you-need
• Hugging Face LLM Cursus - NLP en LLM-fundamenten
• Llama 3.2 Modelkaart
• Qwen3 Documentatie
• NVIDIA Jetson AI Lab - AI-ontwikkelingsbronnen voor Jetson

Volgende: Ga door naar Module 5.2: Aan de Slag met Ollama om je eerste LLM op Jetson te draaien!