Neurale Netwerken: Van Neuron naar Transformer
Bouw zelf neurale netwerken, van één neuron tot een transformer, daarna generatieve modellen, diffusie, scaling laws en het bekijken van de binnenkant van een model, in pure Python en NumPy, getraind in je browser. Schrijf je eigen autograd, diagnoseer kapotte runs, beoordeel claims op basis van bewijs en eindig met een capstone die je kunt herhalen. Gratis, geen account nodig.
Real Python en NumPy zijn klaar in dit tabblad.
Geen installatie, geen account, geen setup. Elk netwerk in deze cursus traint op je eigen apparaat, en niets wat je schrijft verlaat het. Module 1 frist de Python en NumPy op die je nodig hebt. Al vloeiend? De laatste les is een korte gate die je eerst kunt doen: sla hem en de cursus zet je direct door.
Dagelijkse herhaling
Spaced repetition voorkomt dat wat je hebt geleerd vervaagt.
Module 0: Startlijn
Je zult in staat zijn om: te zeggen hoe de cursus werkt en wat het meet; een voorspelling doen en deze controleren tegen een run; je startscore op de vier wijzers vastleggen; de snelheid van je apparaat in FLOPs meten.
Module 1: Python voor deze cursus
Je zult in staat zijn om: functies schrijven en testen over lijsten en dictionaries; NumPy arrays, shapes, slicing en broadcasting gebruiken in plaats van lussen; willekeur reproduceerbaar zaaien; kleine klassen en closures schrijven. Gecontroleerd door de Python gate (al vloeiend? doe deze eerst: slagen overslaat het module).
Module 2: Wiskunde en kansberekening, alleen indien nodig
Je zult in staat zijn om: dot products, matrix multiplies en broadcasts te berekenen; hellingen te vinden door nudging en door de chain rule, voor getallen en voor hele matrices; uit te leggen hoe spread optelt en wat een eigenvalue doet; de softmax gradient af te leiden; log-sum-exp, softmax en cross-entropy te schrijven die nooit overflowen (the gate).
Module 3: Neuron naar MLP
Je zult in staat zijn om: een neuron, activaties en een netwerk met twee lagen bouwen in NumPy; backprop met de hand afleiden en controleren met een gradient checker; een cijferlezer trainen boven de 95%; je eigen netwerk bouwen en trainen voor een nieuwe dataset (the gate).
Module 4: Je eigen autograd engine
Je zult in staat zijn om: een reverse-mode autograd engine bouwen (graph, topological order, backward rules, broadcasting, reductions); deze controleren tegen nudging; een netwerk erop trainen zonder handgeschreven gradients; een nieuwe operatie alleen toevoegen (the gate).
Module 5: Optimalisatie
Je zult in staat zijn om: uit te leggen waarom een gestrekte landscape traag is; minibatch SGD, momentum, RMSProp, Adam en AdamW, schedules en clipping bouwen; een optimiser kiezen en afstemmen voor een probleem dat je nog niet hebt gezien, onder een Budget (de gate).
Module 6: Startgewichten en normalisatie
Je zult in staat zijn om: signalen meten door diepte en Xavier, LeCun of He schalen kiezen; dode eenheden vinden; BatchNorm forward en backward, LayerNorm en RMSNorm bouwen; de train/eval valkuil vermijden; shortcuts gebruiken in diepe netwerken.
Module 7: Werken met nieuwe data
Je zult in staat zijn om: over- en underfitting, bias en variantie te meten; weight decay, dropout, augmentation en early stopping te gebruiken; double descent en learning curves eerlijk te lezen; een model afstemmen op validatiedata en rapporteren op held-out data (de gate).
Module 8: Trainingskliniek I
Je zult in staat zijn om: de eerste twee checks op elke trainingsrun uit te voeren; probes te kiezen die waarschijnlijke fouten splitsen; kapotte runs met een kleine wijziging diagnosticeren en repareren, binnen een Budget (de gate); de diagnoses van een AI helper beoordelen op basis van bewijs.
Module 9: Is het echt beter?
Je zult in staat zijn om: data splitsen zonder lekkage; precisie en recall gebruiken; spreiding over seeds meten; bootstrap foutenbalken op een score zetten; kalibratie meten; twee modellen vergelijken met een gepaard interval en de beslissing nemen (de gate).
Module 10: Netwerken die zien (CNNs)
Je zult in staat zijn om: convolution, padding, pooling en hun gradiënten, en im2col te bouwen; CNNs trainen op de house engine; opgenomen runs over seeds lezen; saliency testen tegen een basislijn; transfer gebruiken; een CNN ontwerpen onder een weight budget (the gate).
Module 11: Netwerken met geheugen (RNNs)
Je zult in staat zijn om: een RNN en een character model bouwen; backprop through time afleiden; vanishing gradients meten; LSTM gates bouwen; recorded memory en bottleneck experimenten lezen; samplen met temperature; een kapot recurrent model (de gate) repareren.
Module 12: Woorden als getallen (embeddings)
Je zult in staat zijn om: een embedding behandelen als een lookup; een pair-merging tokenizer bouwen; woordvectoren maken door te tellen en door skip-gram; een skew die ze kopieerden meten en verwijderen; dit allemaal alleen doen in een wereld die je niet hebt gezien (the gate).
Module 13: Attention en transformers
Je zult in staat zijn om: aandacht op te bouwen, de causal mask, heads, positions, layer norm en een hele block die overeenkomt met een echt model; de backward pass van attention afleiden; een kleine GPT trainen; recorded runs lezen; genereren met een cache; je engine mappen naar PyTorch; een kapotte transformer (de gate) repareren.
Module 14: Trainingskliniek II
Je zult in staat zijn om: defecte sequentiemodellen te diagnosticeren, inclusief cheats die er goed uitzien, stalls, stapgroottes en samplingfouten; mislukte opgenomen runs te lezen; een AI helper beoordelen op basis van bewijs; alleen diagnosticeren met een Budget (de gate); je eindexamen vergelijken met je basislijn.
Module 15: Samendrukken, herbouwen, genereren (autoencoders en VAEs)
Je zult in staat zijn om: cijfers in een paar getallen persen en ze opnieuw opbouwen; zeggen, met metingen, waarom een autoencoder geen nieuwe cijfers kan maken; de KL tussen twee klokvormige curven en de ELBO berekenen; samplen op een manier die je kunt trainen; een VAE trainen die nieuwe cijfers maakt; tussen cijfers lopen; een ingestorte VAE alleen diagnosticeren en repareren (de gate).
Module 16: Twee netwerken in een spel (GANs, optioneel)
Optionele module, niet nodig voor het certificaat. Je zult in staat zijn om: de GAN losses te schrijven en aan hun hellingen zien wanneer de verzadigende stagneert; een GAN trainen op acht blobs en de coverage beoordelen; mode collapse veroorzaken; stabiliserende trucs testen over opgenomen seeds en rapporteren wat hielp; een convolutional generator draaien; een kapotte GAN alleen redden (the gate).
Module 17: Ruis erin, plaatjes eruit (diffusie)
Je zult in staat zijn om: ruis toevoegen via een schema, stap voor stap en in één keer; de pijlen van het netwerk teruglezen naar de data; een noise predictor trainen; samplen met DDPM en zeggen waarom de schone schatting is geknipt; noise schedules en tijdinputs vergelijken door meting; een U-Net bouwen; samplen in minder stappen met DDIM; samples sturen met classifier-free guidance; een getraind model finetunen; een nieuwe vorm alleen aanpassen (de gate).
Module 18: Leren zonder labels
Je zult in staat zijn om: features te beoordelen door nearest-neighbour agreement en door een lineaire probe die je schrijft; pretrainen met masked prediction; InfoNCE schrijven en zeggen waarom het cross-entropy is; pretrainen met SimCLR en lezen wat de augmentaties bepalen; captions aan pictures koppelen (optioneel); features testen op objects die het model nooit heeft gezien, alleen (the gate).
Module 19: Groter, en hoe veel beter (scaling laws)
Je zult in staat zijn om: een trainingsrun in FLOPs te berekenen; een power law met een floor en foutenbalken aanpassen; lezen of gewichten of data een run beperken; de beste modelgrootte voor een vast Budget plannen; een grotere run voorspellen en deze controleren; een echte sprong van een metric onderscheiden die er een maakt; een run alleen plannen (de gate).
Module 20: Een getraind model goedkoop aanpassen
Je zult in staat zijn om: catastrofaal vergeten te tonen; LoRA tellen, bouwen en gradient-checken; de rank ervan kiezen uit metingen; een model finetunen op je eigen tekst zonder het te verpesten; zeggen wanneer distillatie helpt; weights kwantiseren en de kosten voorspellen; voorkeuren afstemmen met DPO en op tijd stoppen; een methode kiezen voor een situatie; een adaptatiedoel alleen halen binnen een Budget (de gate).
Module 21: In een model kijken
Je zult in staat zijn om: te zeggen of bewijs over de binnenkant van een model een patroon, een effect of een mechanisme is; een probe uitvoeren met een controle; activaties patchen om te vinden waar informatie zich bevindt; delen verwijderen en controleren op back-up; een tekstboek mechanisme testen op het model voor je; superpositie laten zien in een toy; een sparse autoencoder trainen en een feature label testen op onbekende tekst; grokking lezen uit opgenomen runs en de golven controleren door ze te verwijderen; vinden waar informatie zich bevindt op nieuwe inputs alleen (de gate).
Module 22: Claims beoordelen
Je zult in staat zijn om: een gelekt testset vinden door overlap en de schone score rapporteren; een gemiddelde loss splitsen langs het deel dat ertoe doet; zeggen hoe zero en mean ablation verschillen en de methode rapporteren; een one-seed verschil onderscheiden van een gemeten verschil met standaardfouten; een resultaat repliceren op nieuwe seeds en de instelling vinden waar het stopt met gelden; een claim alleen beoordelen (de gate).
Module 23: Capstone studio: een model kaart die je kunt draaien
Je zult in staat zijn om: een project te plannen met een FLOP budget; een basislijn aanroepen en uitvoeren over seeds; veranderingen beoordelen met foutenbalken; een bug vinden die nog steeds traint door gradient checking; een bevinding doen binnen je model tegen een niet-getrainde controle; één keer evalueren op een verborgen set met foutenbalken; een model kaart schrijven waarvan elk getal overeenkomt met je run log; één offline bestand exporteren waarvan de runs worden hergespeeld.
Module 24: Eindexamen en hertoetsing
Je zult in staat zijn om: met AI uit te laten zien wat Deel 2 leerde op alle vier de draaiknoppen (form C); je draaiknoppen te vergelijken van de startlijn tot het einde van Deel 2; een maand later te controleren wat bleef (form D, optioneel).
Alleen jij kunt deze printen of opslaan. De links zijn opgeslagen in deze browser. Om iemand iets te laten zien, deel je de verify link van het certificaat.