Reti neurali: dal neurone al transformer
Costruisci reti neurali con le tue mani, da un singolo neurone a un transformer, poi modelli generativi, diffusione, leggi di scala e lo sguardo dentro un modello, in semplice Python e NumPy, addestrati nel tuo browser. Scrivi il tuo autograd, diagnostica gli addestramenti rotti, giudica le affermazioni in base alle prove, e finisci con un progetto finale che puoi rieseguire. Gratis, senza account.
Veri Python e NumPy sono pronti in questa scheda.
Niente installazione, niente account, niente configurazione. Ogni rete di questo corso si addestra sul tuo dispositivo, e niente di ciò che scrivi lo lascia. Il modulo 1 ripassa il Python e il NumPy che ti servono. Li sai già? La sua ultima lezione è un breve test d'ingresso che puoi fare subito: superalo e il corso ti porta direttamente avanti.
Ripasso giornaliero
La ripetizione dilazionata evita che ciò che hai imparato svanisca.
Modulo 0: Linea di partenza
Saprai: dire come funziona il corso e che cosa misura; fare una previsione e confrontarla con un'esecuzione; registrare il tuo punteggio di partenza sui quattro quadranti; misurare la velocità del tuo dispositivo in FLOP.
Modulo 1: Python per questo corso
Saprai: scrivere e verificare funzioni su liste e dizionari; usare array, forme, slicing e broadcasting di NumPy al posto dei cicli; fissare il seme della casualità in modo riproducibile; scrivere piccole classi e closure. Verificato dal cancello di Python (lo conosci già bene? affrontalo per primo: superarlo salta il modulo).
Modulo 2: Matematica e probabilità, solo quanto serve
Saprai: calcolare prodotti scalari, moltiplicazioni di matrici e broadcasting; trovare pendenze spostando di poco e con la regola della catena, per numeri e per matrici intere; spiegare come si somma la dispersione e che cosa fa un autovalore; ricavare il gradiente della softmax; scrivere log-sum-exp, softmax e cross-entropy che non vanno mai in overflow (il cancello).
Modulo 3: Dal neurone all'MLP
Saprai: costruire un neurone, le attivazioni e una rete a due layer in NumPy; ricavare a mano la backprop e verificarla con un controllore del gradiente; addestrare un lettore di cifre oltre il 95%; costruire e addestrare la tua rete per un nuovo dataset (il cancello).
Modulo 4: Il tuo motore di autograd
Saprai: costruire un motore di autograd in modalità inversa (grafo, ordine topologico, regole all'indietro, broadcasting, riduzioni); verificarlo con gli spostamenti; addestrarci sopra una rete senza gradienti scritti a mano; aggiungere da solo una nuova operazione (il cancello).
Modulo 5: Ottimizzazione
Saprai: spiegare perché un paesaggio allungato è lento; costruire SGD a minibatch, momentum, RMSProp, Adam e AdamW, schedulazioni e clipping; scegliere e regolare un ottimizzatore per un problema che non hai visto, con un budget (il cancello).
Modulo 6: Pesi iniziali e normalizzazione
Saprai: misurare i segnali attraverso la profondità e scegliere le scale Xavier, LeCun o He; trovare le unità morte; costruire BatchNorm in avanti e all'indietro, LayerNorm e RMSNorm; evitare la trappola addestramento/valutazione; usare le scorciatoie nelle reti profonde.
Modulo 7: Lavorare su dati nuovi
Saprai: misurare overfitting e underfitting, bias e varianza; usare weight decay, dropout, augmentation ed early stopping; leggere con onestà il double descent e le curve di apprendimento; regolare un modello sui dati di validazione e riportarlo su dati tenuti da parte (il cancello).
Modulo 8: Clinica degli addestramenti I
Saprai: eseguire i due primi controlli su qualsiasi addestramento; scegliere sonde che separano i difetti probabili; diagnosticare e correggere addestramenti rotti con una piccola modifica, con un budget (il cancello); giudicare con le prove le diagnosi di un aiutante IA.
Modulo 9: È davvero migliore?
Saprai: dividere i dati senza fughe; usare precisione e richiamo; misurare la dispersione tra semi; mettere barre d'errore bootstrap su un punteggio; misurare la calibrazione; confrontare due modelli con un intervallo appaiato e prendere la decisione (il cancello).
Modulo 10: Reti che vedono (CNN)
Saprai: costruire convoluzione, padding, pooling e i loro gradienti, e im2col; addestrare CNN sul motore di casa; leggere esecuzioni registrate su più semi; mettere alla prova la salienza contro un riferimento; usare il transfer; progettare una CNN con un budget di pesi (il cancello).
Modulo 11: Reti con memoria (RNN)
Saprai: costruire una RNN e un modello di caratteri; ricavare la backprop nel tempo; misurare i gradienti che svaniscono; costruire i gate di una LSTM; leggere esperimenti registrati sulla memoria e sul collo di bottiglia; campionare con la temperatura; riparare un modello ricorrente rotto (il cancello).
Modulo 12: Parole come numeri (embedding)
Saprai: trattare un embedding come una ricerca in tabella; costruire un tokenizer che unisce coppie; creare vettori di parole contando e con lo skip-gram; misurare e togliere una distorsione che hanno copiato; fare tutto questo da solo su un mondo che non hai visto (il cancello).
Modulo 13: Attenzione e transformer
Saprai: costruire l'attenzione, la maschera causale, le teste, le posizioni, il layer norm e un blocco intero che coincide con un modello vero; ricavare la passata all'indietro dell'attenzione; addestrare un piccolo GPT; leggere esecuzioni registrate; generare con una cache; collegare il tuo motore a PyTorch; riparare un transformer rotto (il cancello).
Modulo 14: Clinica degli addestramenti II
Saprai: diagnosticare modelli di sequenze rotti, compresi imbrogli che sembrano ottimi, blocchi, dimensioni dei passi e difetti di campionamento; leggere esecuzioni registrate fallite; giudicare con le prove un aiutante IA; diagnosticare da solo con un budget (il cancello); confrontare il tuo esame finale con quello di partenza.
Modulo 15: Schiaccia, ricostruisci, genera (autoencoder e VAE)
Saprai: schiacciare cifre in pochi numeri e ricostruirle; dire, con misure, perché un autoencoder non può creare cifre nuove; calcolare la KL tra due curve a campana e l'ELBO; campionare in un modo attraverso cui puoi addestrare; addestrare un VAE che crea cifre nuove; camminare tra le cifre; diagnosticare e correggere da solo un VAE collassato (il cancello).
Modulo 16: Due reti in una partita (GAN, facoltativo)
Modulo facoltativo, non serve per il certificato. Saprai: scrivere le loss delle GAN e dire dalle loro pendenze quando quella saturante si blocca; addestrare una GAN su otto macchie e giudicarne la copertura; far succedere il collasso dei modi; testare trucchi di stabilizzazione su seed registrati e riferire che cosa ha aiutato; eseguire un generatore convoluzionale; salvare da solo una GAN rotta (il cancello).
Modulo 17: Dentro il rumore, fuori le immagini (diffusione)
Saprai: aggiungere rumore secondo un programma, passo per passo e in un salto solo; leggere le frecce della rete fino ai dati; addestrare un predittore di rumore; campionare con DDPM e dire perché la stima pulita viene tagliata; confrontare programmi di rumore e input del tempo con misure; costruire una U-Net; campionare in meno passi con DDIM; guidare i campioni con la classifier-free guidance; rifinire un modello addestrato; adattarti da solo a una forma nuova (il cancello).
Modulo 18: Imparare senza etichette
Saprai: giudicare le feature con l'accordo tra vicini più prossimi e con una sonda lineare scritta da te; pre-addestrare con la previsione mascherata; scrivere InfoNCE e dire perché è cross-entropy; pre-addestrare con SimCLR e leggere che cosa decidono le sue augmentation; abbinare didascalie a immagini (facoltativo); testare da solo le feature su oggetti che il modello non ha mai visto (il cancello).
Modulo 19: Più grande, e quanto migliore (leggi di scala)
Saprai: calcolare il costo di un addestramento in FLOP; fare il fit di una legge di potenza con un pavimento e barre d'errore; leggere se a limitare un'esecuzione sono i pesi o i dati; pianificare la dimensione migliore del modello per un budget fisso; prevedere un'esecuzione più grande e controllarla; distinguere un salto vero da una metrica che lo crea; pianificare da solo un'esecuzione (il cancello).
Modulo 20: Adattare a poco prezzo un modello addestrato
Saprai: mostrare l'oblio catastrofico; contare, costruire e controllare il gradiente di LoRA; sceglierne il rango a partire da misure; fare il fine-tuning di un modello sul tuo testo senza rovinarlo; dire quando la distillazione aiuta; quantizzare i pesi e prevederne il costo; rifinire le preferenze con DPO e fermarti in tempo; scegliere un metodo per una situazione; raggiungere da solo un obiettivo di adattamento con un budget (il cancello).
Modulo 21: Guardare dentro un modello
Saprai: dire se una prova sull'interno di un modello è uno schema, un effetto o un meccanismo; eseguire una sonda con un controllo; fare activation patching per trovare dove sta l'informazione; togliere parti e controllare se ci sono riserve; testare un meccanismo da manuale sul modello che hai davanti; mostrare la sovrapposizione in un modello giocattolo; addestrare uno sparse autoencoder e testare l'etichetta di una feature su testo mai visto; leggere il grokking da esecuzioni registrate e controllarne le onde togliendole; trovare da solo dove sta l'informazione su input nuovi (il cancello).
Modulo 22: Giudicare le affermazioni
Saprai: trovare un insieme di test trapelato tramite sovrapposizione e riportare il punteggio pulito; scomporre una loss media lungo la parte che conta; dire in che cosa differiscono l'ablazione a zero e quella con la media e riportare il metodo; distinguere una differenza su un solo seed da una misurata con gli errori standard; replicare un risultato su seed nuovi e trovare l'impostazione in cui smette di valere; esaminare da solo un'affermazione (il cancello).
Modulo 23: Studio del progetto finale: una model card che puoi eseguire
Saprai: pianificare un progetto con un budget di FLOP; indovinare ed eseguire una baseline su più seed; giudicare i cambiamenti con barre d'errore; trovare con il controllo del gradiente un bug che addestra comunque; fare una scoperta dentro il tuo modello rispetto a un controllo non addestrato; valutare una sola volta su un insieme nascosto con barre d'errore; scrivere una model card in cui ogni numero coincide con il registro delle esecuzioni; esportare un unico file offline le cui esecuzioni si possono rieseguire.
Modulo 24: Esame finale e nuovo test
Saprai: mostrare, con l'IA spenta, che cosa ha insegnato la Parte 2 su tutti e quattro i quadranti (forma C); confrontare i tuoi quadranti dalla linea di partenza alla fine della Parte 2; controllare un mese dopo che cosa è rimasto (forma D, facoltativa).
Solo tu puoi stamparli o salvarli. I link sono salvati in questo browser. Per mostrarli a qualcuno, condividi il link di verifica dal certificato.