Des cours pour saisir les idées derrière le machine learning et le développement à l'ère de l'IA — les concepts, pas les équations.
Les idées et les grandes familles d'abord, puis les données, la mesure, les algorithmes, et la mise en production.
Les pièces d'une application web, un clic suivi de bout en bout, ce qui tourne chez le visiteur ou sur le serveur, et pourquoi on découpe parfois en services.
De l'adresse tapée à la page affichée : ce qui part vraiment de l'URL, le DNS, la distance, la connexion TCP puis le chiffrement TLS, la requête HTTP et ses codes, la cascade réseau et le cache. Pourquoi le nombre d'allers-retours compte plus que le débit, et comment un nom de fichier bien choisi évite de retélécharger.
Valeurs et types, noms, listes et dictionnaires, conditions et boucles, fonctions, modules, erreurs et traces, environnements, notebooks : les bases de la programmation, avec une console qui répond comme Python 3.12, au caractère près.
Se repérer, lire et filtrer des fichiers, assembler des tuyaux, brancher les flux, lire un code de sortie, comprendre Ctrl+C, les droits et les variables d'environnement, sur le dossier d'une petite radio.
Les trois zones, les commits et les branches, fusionner ou rebaser, et pourquoi deux lignes voisines font un conflit.
Machine physique ou virtuelle, système, services qui écoutent sur des ports, pare-feu, proxy inverse et certificats, SSH, journaux, processeur, mémoire et disque, redémarrages : ce qui se passe de l'autre côté d'une requête.
Une image, des conteneurs, des couches et un cache : écrire un Dockerfile, n'y laisser aucun secret, alléger l'image, puis comprendre volumes et réseaux.
Le contrat d'une route, le bon code de statut, l'ordre des contrôles, l'idempotence, la pagination, les appels à une autre API, la boucle d'événements et l'état partagé entre plusieurs exemplaires, sur une billetterie imaginaire.
Tables reliées par des clés, contraintes, normalisation, arbre B et plans d'exécution, transactions, accès simultanés et migrations : ce que la base garantit, à condition de le lui demander.
L'état d'un composant, les requêtes qui se croisent, l'hydratation, les pluriels, l'accessibilité, le contraste, le contenu qui saute et le mobile d'abord, sur la page d'une vidéo imaginaire.
Écrire le test qui rougit, ce qu'un test voit, la couverture et les mutants, les flottants, l'horloge, les tests par propriétés, les doublures et la CI, sur le fil d'une barre de progression de téléchargement.
Authentifier et autoriser, ranger un mot de passe, OAuth, cookie de session, comparer un secret, CORS, injections SQL et XSS, secrets dans Git : les protections d'une application web, et ce que chacune arrête vraiment.
Les jobs et leur chemin critique, l'ordre des étapes, le cache des couches, les plafonds à cliquet, la file de concurrence et le chemin d'une modification jusqu'à la production, sur un projet web ordinaire.
Environnements et configuration, déploiement et retour arrière, contrôles de santé, journaux, métriques et alertes, notions de cloud : comment mettre une boutique en ligne, la garder en vie et savoir quand elle ne va pas bien.
Lire, filtrer, regrouper et joindre des tables avec SQL : l'ordre dans lequel la base traite une requête, NULL la valeur inconnue, WHERE ou HAVING, la jointure qui multiplie les lignes sans prévenir, et le plan d'exécution qui décide de la vitesse.
Le modèle mental de pandas : des colonnes typées, alignées sur un index. Les types que read_csv devine, pourquoi un calcul « par position » mélange les lignes sans prévenir, ce que NaN fait à un filtre, ce que groupby fait des valeurs manquantes (pas comme SQL), et pourquoi écrire en chaîne ne modifie rien.
Octets et encodages, CSV, JSON, Parquet, types devinés, dates et fuseaux : les pièges de la lecture d'un fichier, sur les commandes d'une librairie en ligne.
Classes, quantificateurs, ancres, groupes, gourmand ou paresseux, Unicode et retour arrière catastrophique, sur des exemples du quotidien et un moteur qu'on regarde travailler.
Moyenne et médiane, forme d'une distribution, échantillon et population, coût de la précision, intervalle de confiance par bootstrap, p-valeur et test apparié, taille d'échantillon, comparaisons multiples : mesurer, et savoir à quel point on peut se fier à sa mesure.
Un graphique est un argument. Choisir ce que l'œil lit bien, ne pas cacher la forme derrière une moyenne, ne pas tricher avec un axe ni une fenêtre, traduire les chiffres en personnes, colorer selon la donnée, désencombrer, montrer l'incertitude, puis enchaîner contexte, constat, preuve et conséquence.
Lire vite et bien : les trois passes, relier chaque affirmation à sa preuve, se méfier d'une graine unique, d'une baseline mal réglée, d'un axe trompeur, d'un contrôle qui ne peut pas échouer, du vainqueur chanceux et des essais cachés.
Appeler une API, paginer sans rien perdre ni répéter, respecter les limites de débit, lire robots.txt, comprendre licences et données personnelles, et journaliser sa collecte pour la reprendre après une panne.
ETL et ELT, orchestration, planification avec cron et fraîcheur, contrôles de qualité, idempotence : comment une chaîne de traitement tourne seule chaque mois, se rattrape après une panne et ne paie jamais deux fois.
Une vue d'ensemble du domaine, avec des schémas interactifs : apprendre par l'exemple, les familles, features, sur-apprentissage, métriques. Les idées, pas les équations.
Poser le problème avant le modèle, soigner les étiquettes, commencer par une baseline, savoir quelle forme chaque modèle sait tracer — et ce qu'il fait là où il n'a rien vu. Avec des figures à manipuler.
Regrouper, résumer, repérer l'inhabituel, et laisser les données s'étiqueter elles-mêmes : ce qu'on peut apprendre sans réponse attendue, et comment ne pas se raconter d'histoires. Avec des figures à manipuler.
Un agent agit, reçoit des récompenses et apprend par essais et erreurs : la table Q qui se remplit, le taux α, la patience γ, explorer ou exploiter, et l'agent qui détourne la récompense qu'on lui a écrite. Avec des figures à manipuler.
Nettoyer, combler les vides, encoder, mettre à l'échelle, rééquilibrer, découper sans tricher : tout ce qui se passe avant le modèle, sur un site d'annonces de location imaginaire, avec des schémas à manipuler.
Précision, rappel, ROC, RMSE, R², calibration, validation croisée : apprendre à juger honnêtement un modèle, avec des figures à manipuler.
Avant d'entraîner : quelle décision servir, que prédire, pour quand, avec quelles données disponibles à cet instant, contre quelle baseline, et un modèle vaut-il la peine ? Sur le fil du retard d'un train.
Pente, pas d'apprentissage, minima locaux, mise à l'échelle, mini-lots, momentum et Adam : comprendre comment un modèle trouve tout seul ses réglages, avec des figures à manipuler.
Pourquoi un modèle simple peut sur-apprendre, comment λ le bride, ce que Ridge rétrécit et ce que Lasso élimine, biais contre variance : avec des figures à manipuler.
Comment un arbre découpe l'espace en questions, pourquoi il sur-apprend, et comment des centaines d'arbres, en forêt ou en boosting, deviennent les champions des données en tableau. Avec des figures à manipuler, un schéma et un laboratoire.
Trois modèles classiques qui raisonnent autrement : par la distance (k-NN), par la marge (SVM) et par les probabilités (Bayes naïf). Ce qu'ils supposent, où ils brillent, et les pièges qu'on ne voit qu'en les regardant de près.
Paramètre ou hyperparamètre, grille ou hasard, échelle logarithmique, optimisation bayésienne, malédiction du gagnant, taux d'apprentissage et nombre d'arbres, arrêt précoce, élimination successive : régler un modèle sans se mentir sur son score. Avec des figures à manipuler.
Comparer des familles de modèles sans se mentir : barres d'erreur, coût réel une fois entraîné, arbre du choix, et le cas où la bonne réponse est de ne pas faire de machine learning.
Tendance et saison, mémoire d'une série, baseline selon l'horizon, variables sans fuite, validation dans l'ordre du temps et prévision sur plusieurs pas, sur la consommation d'une ville imaginaire.
Importance par permutation et ses pièges, dépendance partielle et courbes individuelles, valeurs de Shapley et choix de la référence, modèle substitut, explications contrefactuelles, et la frontière entre corrélation et cause.
Un bon score moyen peut cacher un groupe mal servi. Variables de substitution, définitions de l'équité qui se contredisent, seuils par groupe, petits groupes et croisements, avec un hôpital imaginaire pour terrain.
Le cycle de vie d'un modèle, la variation d'un entraînement à l'autre, les contrôles de données en amont, ce qu'un essai doit enregistrer, la malédiction du gagnant, le registre de modèles et un pipeline rejouable.
Mettre un modèle au service d'une application : par lots ou à la demande, le trajet d'une requête, le contrat d'entrée, l'écart entre l'entraînement et la production, la latence qui compte vraiment, remplacer un modèle sans tout casser, et le piège du fichier pickle.
Le monde change après la mise en production : les entrées dérivent, la relation apprise aussi. Mesurer la dérive (KS, PSI, Wasserstein) sans se laisser piéger par la taille de l'échantillon, distinguer une dérive sans dommage d'un dommage sans dérive, et savoir quand ré-entraîner.
Ce que calcule un neurone, pourquoi il faut des couches et une activation, comment poser les coudes d'une courbe, compter les paramètres et calculer un gradient de rétropropagation, puis apprendre une spirale.
Pourquoi le gradient s'éteint ou explose avec la profondeur, ce que change l'échelle des poids, la normalisation et les raccourcis, et comment lire deux courbes d'apprentissage : surapprentissage, pas trop grand, freins.
Un filtre qu'on écrit soi-même, des poids partagés, un champ de vision qui grandit, la pile de LeNet à ResNet et le transfert d'apprentissage. Puis la détection et les pièges.
Du ticket de caisse photographié au champ « total » : séparer l'encre du fond, lire une ligne, mesurer le CER, décider de la relecture avec les clés de contrôle, et ce que changent les modèles vision-langage.
Autoencodeur et espace latent, VAE, GAN, diffusion, conditionnement par la consigne, audio, mesure (FID) et provenance : comment une machine apprend à créer, expliqué sur des chats dessinés en 16 × 16.
L'architecture derrière les grands modèles de langage : attention, Q/K/V, têtes multiples, décodeur — avec des schémas que tu peux manipuler.
Le trajet d'une phrase du texte à la réponse, le BPE fusion après fusion, la taille du vocabulaire, le prix d'un texte selon la langue, les pièges du découpage et les tokens spéciaux qui mettent une conversation à plat.
Comment des vecteurs appris à partir des contextes rapprochent les mots de même sens, ce que cache une carte en 2D, pourquoi on compare au cosinus, comment une recherche sémantique va de la question aux résultats, et comment chercher vite parmi des millions de vecteurs.
Appeler un modèle par son API, les rôles d'une conversation, le tirage et la température, montrer des exemples, obtenir des sorties qu'un programme peut lire, et savoir combien d'essais il faut pour croire un prompt fiable.
Ce qu'un modèle lit à chaque appel, son prix en tokens et en calcul, le milieu qu'il lit mal, ce qu'on fait quand c'est plein, le cache de prompt et les très longues fenêtres.
Lire le paysage des modèles de langage comme un choix d'ingénieur : mélange d'experts, tailles et lois d'échelle, modèles multimodaux, raisonnement au moment de répondre, petits modèles, poids ouverts ou API, et fiche de modèle.
Ce qui se passe entre ton prompt et le premier mot : lire puis écrire, le délai avant le premier token, le cache KV qui remplit la mémoire du GPU, les lots, le décodage spéculatif, et ce qui fait le prix d'un token.
Écrire les nombres d'un modèle sur moins d'octets : FP32, BF16, INT8, 4 bits, ce qu'on gagne en mémoire et en vitesse, ce qu'on perd, les formats des modèles locaux, et les petits modèles distillés.
Ajustement supervisé, gabarit de conversation, préférences et modèle de récompense, RLHF et sa laisse KL, DPO, apprentissage par récompenses vérifiables : comment un modèle qui complète du texte devient un assistant qui répond.
Quand affiner plutôt qu'écrire une consigne ou chercher, ce que coûte un affinage en mémoire, LoRA et QLoRA, combien d'époques, et pourquoi tout commence par relire ses données.
Chercher les passages utiles et les donner au modèle : les deux temps d'un RAG, découper un document, combien de passages envoyer, ce qui se passe quand la recherche rate, vérifier une citation, garder l'index à jour.
Le RAG naïf marche en démo et casse en production. Recherche par les mots et par le sens, relecture, découpage, boucle agentique, graphe d'entités, et comment savoir où ça casse.
Noter avec une grille, le bruit d'une évaluation, la comparaison question par question, les biais d'un modèle utilisé comme juge, les régressions cachées dans une moyenne, la contamination des bancs publics, et combien de questions il faut.
Un modèle de langage ne sépare pas les données des ordres : tout ce qu'il lit peut le commander. Cache une consigne dans un e-mail, compte pourquoi un filtre à 99 % cède, suis une fuite par image sans un clic, paramètre une requête, place les droits au bon endroit et range six situations dans le Top 10 de l'OWASP.
Lire le règlement européen sur l'IA à partir d'un cas concret, une PME qui lance un assistant client : les rôles, les quatre niveaux de risque, les pratiques interdites, la transparence, les modèles à usage général, le calendrier (report compris) et les sanctions.
Ce qui a été mesuré sur les assistants de code, les compétences qui comptent, et comment apprendre avec l'IA plutôt qu'à sa place.
Un modèle dans une boucle, avec des outils : quand un agent vaut mieux qu'un workflow, pourquoi la fiabilité se multiplie, et comment il se souvient.
Ce que fait le modèle et ce que fait le logiciel autour de lui dans un agent de code : la boucle, les outils fournis, les permissions, le terminal et les retours en arrière, le contexte, les sous-agents.
Le schéma d'un outil, la demande structurée du modèle, qui exécute vraiment, le résultat renvoyé, les appels parallèles, les erreurs lisibles et le choix forcé d'un outil.
Le protocole qui relie un agent à des outils et à des données : hôtes, clients et serveurs, outils, ressources et prompts, les deux transports, écrire un petit serveur, les permissions, et la sécurité des serveurs tiers.
Ce qu'est une skill (un dossier, un SKILL.md, des scripts et des ressources), le chargement progressif, qui la déclenche et quand, la différence avec les règles du projet et un serveur MCP, et comment écrire une bonne description.
Ce qu'un agent sait à chaque tour : couches du contexte, fichiers de règles, mémoire, compaction ; les hooks qui imposent une règle avant ou après un outil ; et comment repérer un agent qui oublie.
Choisir son harnais sans le confondre avec le modèle, comprendre ce que coûte une conversation (cache, pauses, longueur), puis mener une tâche de bout en bout avec un agent : brief vérifiable, plan, tests, commit, relecture du diff, ce qu'on laisse et ce qu'on garde.
Sous-agents à contexte isolé, sessions en parallèle, worktrees git, verrou de fusion, messages entre sessions, découpage des périmètres, et quand paralléliser ou non, à partir d'une équipe d'agents qui construit une boutique en ligne.
Permissions et modes, bac à sable, confirmation humaine, secrets, trio dangereux, injection par un contenu, un outil ou un serveur MCP, et hooks de garde : ce qui protège une machine d'un agent qui se trompe ou qu'on trompe.
Juger le résultat et le chemin, faire des tests le juge, pass@k et pass^k, bancs d'essai, bruit et régressions entre versions, relire le diff d'un agent et vérifier que ses tests testent vraiment.