Le code de chaque modèle : importer, télécharger par API, ajuster, prédire

Six briques suffisent pour lire un listing

Presque chaque ligne d'un script d'apprentissage automatique est l'une de six choses : un nom pour une valeur, une collection, une fonction, une boucle, un import ou un tableau.

La première partie vise ceux qui n'ont presque jamais écrit de code. Elle n'enseigne pas la programmation en général ; elle donne ce qu'il faut pour suivre le reste du deck, chaque brique avec un minuscule listing sur des températures et sa vraie sortie.

Pas à pas

1. Une variable. Une étiquette collée sur une valeur. Le signe = range, il ne compare pas (comparer s'écrit ==). Trois types couvrent l'essentiel : le texte (str), le décimal (float, toujours avec un point) et l'entier (int) ; type() dit lequel on tient.
2. Une liste et un dictionnaire. Une liste garde des valeurs dans un ordre et se lit par position, à partir de 0 ; un dictionnaire garde des paires clé, valeur et se lit par nom. Un dictionnaire a exactement la forme du JSON que renvoient les API.
3. Une fonction. Une recette nommée, déclarée par def, dont le corps indenté renvoie un résultat. Les arguments peuvent avoir une valeur par défaut, et en changer une par son nom est le geste de tous les jours avec scikit-learn, comme dans LogisticRegression(max_iter=1000).
4. Une boucle et un test. for répète un bloc pour chaque élément, if choisit entre deux blocs, while répète tant qu'une condition tient, ce qui sert à parcourir les pages d'une API.
5. Un import. Un paquet (package) est la boîte à outils de quelqu'un d'autre : installé une fois avec pip install, ouvert dans chaque script par import, en général sous un alias court comme np ou pd.
6. Un DataFrame pandas. Un tableau de données (DataFrame) avec des colonnes nommées et un index. Trois réflexes devant tout nouveau tableau : .head(), .shape et .describe().

Trois habitudes complètent la partie. Un message d'erreur (traceback) se lit par le bas : la dernière ligne dit ce qui ne va pas, la ligne qui cite votre fichier dit où, et tout ce qui se passe dans la bibliothèque est du bruit. Les suspects habituels sont KeyError (un nom de colonne mal écrit), NameError (une cellule de notebook sautée) et ModuleNotFoundError (un paquet absent de cet environnement). La documentation est à un help() ou à un point d'interrogation. Et le même code tourne sur Kaggle, sur Colab ou dans VS Code ; la séance outils détaille les comptes.

La partie se termine par les objets et les classes, parce qu'ils expliquent la suite du cours. Une classe est un moule, un objet porte ses propres données (attributs) et ses actions (méthodes), et une classe fille hérite de tout ce que fait sa mère en ne changeant que ce qui diffère. Tous les modèles de scikit-learn héritent des mêmes classes de base, et le classifieur de XGBoost a été écrit pour en hériter aussi. Ce contrat commun explique qu'une seule boucle entraîne une régression logistique, un arbre et un boosting avec des appels identiques.

Retour au sommaire.

Un squelette et trois verbes : créer, ajuster, prédire

Tous les modèles du cours s'utilisent de la même façon : on le choisit, on le laisse apprendre sur des exemples dont on connaît la réponse, puis on l'interroge sur des lignes qu'il n'a jamais vues.

Chaque listing de modèle suit les mêmes huit étapes, toujours dans cet ordre : importer les outils, télécharger les données, construire le tableau d'entrée X et la cible y, couper en une partie d'apprentissage et une partie de test, ajuster sur la première, prédire sur la seconde, mesurer avec une métrique, imprimer. Quand un listing paraît opaque, se demander à laquelle des huit étapes appartient une ligne suffit presque toujours à le débloquer.

Dans ce squelette, scikit-learn se résume à trois verbes. On crée un objet modèle avec ses réglages, on appelle fit(X, y) sur les lignes d'apprentissage, puis predict (ou predict_proba pour une probabilité) sur de nouvelles lignes. Ce que le modèle a appris est rangé dans des attributs dont le nom finit par un tiret bas, comme coef_ et intercept_. Pour essayer une forêt, un SVM ou un réseau de neurones, seule la ligne de création change. Le listing ci-dessous, écrit pour cette page sur des données simulées, montre le motif.

# Les trois mêmes verbes pour tout modèle de scikit-learn
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

X, y = make_classification(n_samples=400, random_state=1)    # tableau simulé
X_tr, X_te, y_tr, y_te = train_test_split(
    X, y, test_size=0.25, stratify=y, random_state=0)

model = LogisticRegression(max_iter=1000)  # 1. créer (seule ligne à changer)
model.fit(X_tr, y_tr)                      # 2. ajuster sur l'apprentissage
proba = model.predict_proba(X_te)[:, 1]    # 3. prédire sur des lignes inédites
print(model.score(X_te, y_te), proba[:3].round(2))

Le squelette sur de vraies données

Le premier listing complet prédit la température maximale du jour à Marseille en 2025 à partir de la minimale et de l'humidité, sur 365 jours téléchargés chez Open-Meteo, dont un quart tiré au hasard pour le test. Le plan ajusté, tel qu'imprimé le 12 octobre 2026, est :

Lire le résultat

1. Coefficients. Un degré de minimale en plus ajoute environ 0,96 degré de maximale à humidité égale ; un point d'humidité en plus retire environ 0,12. Pour un jour à 10 °C de minimale et 80 % d'humidité, le plan donne 15,53 + 9,57 − 9,20 = 15,9 °C.
2. Erreur. Sur les 92 jours de test, la racine de l'erreur quadratique moyenne (RMSE) vaut 1,91 °C, contre 5,77 °C pour un modèle naïf qui annonce toujours la moyenne d'apprentissage. Une métrique n'a de sens qu'à côté d'un tel point de comparaison.
3. Le piège. Deux jours voisins se ressemblent, donc un tirage au hasard donne à chaque jour de test des quasi-jumeaux dans l'apprentissage, et l'erreur est un peu optimiste. Pour prévoir, on coupe dans le temps.

Le même modèle passé à statsmodels donne les mêmes coefficients, plus les erreurs-types et les p-valeurs : scikit-learn sert à prédire, statsmodels à faire de l'inférence. La démonstration des moindres carrés est dans la première séance.

Retour au sommaire.

Du binaire à la vidéo : toute donnée devient un tableau de nombres

Une machine ne range que des nombres en base 2 : un texte, une photo, un son ou un film finissent toujours en tableau de nombres, dont seuls la forme et la taille changent.

Un bit vaut 0 ou 1, un octet (byte) compte huit bits et peut prendre 256 valeurs, de 0 à 255. En base 2, chaque position vaut le double de sa voisine de droite : l'octet 01000001 vaut donc 64 + 1 = 65, le code de la lettre A.

Deux pièges en découlent, et le deck les montre en code. Un tableau numpy d'entiers sur un octet (uint8, le type des images) repart de zéro sans prévenir : 250 + 10 donne 4, sans avertissement. Et un nombre à virgule flottante, ou flottant (floating-point number), ne sait pas écrire 0,1 exactement en base 2, si bien que 0.1 + 0.2 == 0.3 est faux ; on compare des flottants avec une tolérance (np.isclose), jamais avec ==. La mémoire suit le type : un tableau de 30 000 lignes et 24 colonnes en flottants 64 bits pèse 5,76 Mo, moitié moins en 32 bits, qui gardent environ 7 chiffres significatifs au lieu de 16 et ne distinguent plus deux entiers voisins au-delà de $2^{24}$ ; les identifiants restent donc en entiers ou en texte.

Le texte passe par deux couches. Unicode donne un numéro à chaque caractère et UTF-8 écrit ce numéro sur un à quatre octets, d'où les accents abîmés d'un CSV ouvert avec le mauvais encodage. Un modèle de langue découpe ensuite le texte en morceaux de mots tirés d'un vocabulaire fixe, chacun un jeton (token), et lit leurs codes entiers ; un mot rare est coupé en plusieurs morceaux. L'article sur l'attention montre ce qu'un transformer fait ensuite de ces jetons.

Une image est un tableau à trois dimensions, et ce qu'en fait un réseau convolutif est montré en miniature : un filtre 3 × 3 glisse sur les pixels, multiplie et additionne, et répond fort sur un bord. Un son est mesuré 44 100 fois par seconde, c'est l'échantillonnage (sampling), assez pour garder les fréquences jusqu'à 20 000 Hz environ ; deux secondes de son mono font 88 200 entiers de 2 octets, plus un en-tête WAV de 44 octets :

Une transformée de Fourier de ce vecteur place le pic à 440 Hz, la note fabriquée. La vidéo brute est si lourde qu'elle est toujours compressée, et un modèle lit des images décodées, quelques-unes par seconde, réduites. Pour les tableaux, cas courant du cours, la dernière étape est l'encodage one-hot (one-hot encoding) : une colonne de texte à trois valeurs possibles devient trois colonnes de 0 et de 1, et chaque client devient un simple vecteur de nombres.

Retour au sommaire.

Télécharger par API, puis figer une copie datée

Une API est une adresse web qu'un programme peut interroger ; elle répond en texte structuré que pandas transforme en tableau, et ce tableau est écrit une fois, daté, puis jamais modifié.

Une API web reçoit sa question dans l'adresse même : après le point d'interrogation viennent des paramètres nom=valeur séparés par &. Le serveur répond par un code d'état (200 pour un succès, 404 pour introuvable, 429 pour trop de requêtes) et un corps, presque toujours en JSON ou en CSV. Le JSON est fait des deux conteneurs de la première partie, dictionnaires et listes, et se lit donc comme un dictionnaire Python.

Trois gestes rendent un téléchargement solide : passer les paramètres en dictionnaire à requests.get, fixer un timeout pour ne pas attendre indéfiniment, et appeler raise_for_status() pour qu'un refus arrête le script tout de suite avec un message clair, au lieu d'une erreur obscure trois lignes plus loin. Le listing ci-dessous est écrit pour cette page ; il suit le motif du deck sur une autre ville et une autre variable.

import requests
import pandas as pd

url = "https://archive-api.open-meteo.com/v1/archive"
params = {"latitude": 49.61, "longitude": 6.13,          # Luxembourg-ville
          "start_date": "2024-01-01", "end_date": "2024-12-31",
          "daily": "precipitation_sum", "timezone": "Europe/Luxembourg"}
r = requests.get(url, params=params, timeout=30)
r.raise_for_status()                       # arrêt immédiat si le serveur refuse
rain = pd.DataFrame(r.json()["daily"])     # du dictionnaire JSON au tableau
rain.to_parquet("data/raw/rain_lux_2024.parquet")  # copie brute, jamais modifiée
print(rain.shape)

Chaque source a ses manies, et le deck donne sa licence et ses conditions dans les notes. La Banque mondiale renvoie une page à la fois et mêle pays et agrégats comme la zone euro ; FRED laisse des jours vides quand le marché américain est fermé, qu'il faut retirer plutôt que remplir de zéros ; les cours Yahoo sont à usage personnel, donc un dépôt public partage le script, jamais les fichiers de cours. Comme les sources en ligne sont révisées, le résultat brut est écrit dans data/raw/ au format Parquet, typé et en colonnes, avec la date du téléchargement dans le nom du fichier, et ce dossier reste hors de Git.

Retour au sommaire.

Tour des familles de modèles, un listing chacune

Le deck fait tourner chaque famille du cours avec le même squelette, sur de vraies données publiques, et lit chaque sortie avec des mots simples.

Chaque famille s'ouvre sur une idée en une phrase, puis le listing, puis ce que veut dire la sortie, et renvoie à la séance qui démontre le modèle. Viennent d'abord deux versions pénalisées des moindres carrés : ridge ajoute la somme des carrés des coefficients, lasso la somme de leurs valeurs absolues, ce qui en pousse certains exactement à zéro.

La régression logistique fait passer une somme pondérée dans la sigmoïde pour obtenir une probabilité de défaut ; son listing, avec les colonnes numériques standardisées et les catégorielles encodées en 0 et 1 dans un Pipeline, devient le modèle de toutes les parties de classification. Une probabilité ne décide rien tant qu'on n'a pas choisi de seuil, et ce choix est une affaire de coûts, sujet de la quatrième séance.

Plusieurs exécutions sont là pour montrer un échec plutôt qu'une réussite. Le modèle à un seul voisin apprend l'apprentissage par cœur : c'est le sur-apprentissage (overfitting) à l'état pur. Le même SVM, nourri d'un montant de crédit non standardisé, ne voit plus que cette variable. Un arbre sans limite atteint 146 feuilles et fait moins bien en test qu'une seule question. Le petit perceptron passe de la dernière à la première place du deck quand on change la patience de son arrêt précoce (early stopping), rappel que sur un tableau de 750 lignes les arbres boostés sont le pari le plus sûr. Côté non supervisé, k-means rend toujours le nombre de groupes demandé, et le BIC du mélange gaussien dit que ces indicateurs de pays forment un continuum. Sur l'euro-dollar, un ARIMA(1, 1, 1) est presque une marche aléatoire, et la validation en marche avant (walk-forward validation) d'un AR(1) ne fait pas mieux que prévoir un rendement nul, tandis qu'un GARCH(1, 1) montre à quel point la volatilité persiste.

Les démonstrations sont dans les séances : régularisation, noyaux et arbres, forêts et boosting, ACP et partitionnement, réseaux de neurones, et le projet de prix d'actif pour les séries et FinBERT, où l'on réutilise un modèle déjà entraîné par d'autres : c'est l'apprentissage par transfert (transfer learning). Le panorama des modèles les place tous sur une même carte.

Retour au sommaire.

Comparer honnêtement, puis passer du notebook au script

Plusieurs scores sur un même test, c'est surtout du bruit : on compare les modèles par validation croisée sur l'apprentissage, et on n'ouvre le test qu'une fois, pour le seul modèle retenu.

Une fois tous les classifieurs passés sur la même coupe, la tentation est de couronner la plus haute AUC de test. Le deck refuse : le meilleur SVM a été choisi parmi six réglages en regardant ce test même, le réseau dépend de sa patience, et avec 75 défauts et 175 bons clients l'erreur-type d'une AUC proche de 0,8 vaut environ 0,03 (Hanley et McNeil, 1982). Des écarts d'un centième ne disent rien. Les scores du jeu de test (test set) ne servent donc pas à choisir.

La méthode honnête est la validation croisée (cross-validation) stratifiée en cinq plis sur l'apprentissage : cinq ajustements, chacun mesuré sur le pli mis de côté, avec les mêmes plis pour chaque candidat, si bien que la comparaison est appariée. La règle de décision est écrite avant le calcul, et le candidat simple sert de modèle de référence (baseline).

Les écarts sont plus petits que les écarts-types, donc la règle fixée d'avance s'applique : garder le modèle le plus simple. La régression logistique, lisible et défendable en notation de crédit, est réajustée sur l'ensemble des données d'apprentissage, puis le test sert une seule fois et donne 0,794. Ce nombre, et aucun autre, entre dans le rapport.

La dernière partie déplace le même squelette d'un notebook vers un script train.py qui lit tous ses réglages dans un fichier config.yaml, sauvegarde le modèle ajusté avec joblib et écrit sa métrique dans un fichier JSON, pour qu'une seule commande refasse tout. Changer une profondeur ou une graine se fait alors dans la configuration, dans un commit qui dit pourquoi, jamais en modifiant le code. Un modèle sauvegardé avec une version de scikit-learn se relit avec la même version, raison de plus pour noter les versions. Chaque sorte de listing trouve ensuite sa place dans le dépôt décrit par le modèle de référence du projet.

Retour au sommaire.

À retenir

1. Six briques de Python (variable, liste et dictionnaire, fonction, boucle, import, DataFrame) suffisent pour lire tous les listings du cours.
2. Chaque modèle suit les mêmes huit étapes, et scikit-learn les réduit à trois verbes : créer, ajuster, prédire ; seule la ligne de création change d'un modèle à l'autre.
3. Texte, images, son et vidéo deviennent tous des tableaux de nombres : attention au débordement des uint8, jamais de == entre flottants, et pas d'identifiants en flottants 32 bits.
4. On télécharge avec des paramètres, un délai maximal et une vérification du code d'état, puis on écrit le résultat brut une fois, daté, et l'on partage le script plutôt que les données.
5. Les modèles fondés sur des distances (voisins, SVM, réseaux, régressions pénalisées) exigent la standardisation (feature scaling) dans le pipeline ; les arbres, non.
6. Une métrique se lit à côté d'un modèle naïf, et l'on compare les modèles par validation croisée, en n'ouvrant le test qu'une seule fois.

Glossaire

paquet (package)

Bibliothèque écrite par d'autres, installée une fois avec pip et ouverte dans chaque script par import.

tableau de données (DataFrame)

Le tableau de pandas : colonnes nommées, une ligne par observation, un index à gauche.

API

Adresse web qu'un programme interroge avec des paramètres ; elle répond en JSON ou en CSV avec un code d'état.

octet (byte)

Huit bits, soit 256 valeurs de 0 à 255, l'unité dans laquelle on mesure la mémoire.

standardisation (feature scaling)

Ramener chaque colonne numérique à moyenne nulle et écart-type un, indispensable aux modèles fondés sur des distances.

encodage one-hot (one-hot encoding)

Remplacer une colonne de texte par une colonne de 0 et de 1 par valeur possible.

jeu de test (test set)

Lignes mises de côté et utilisées une seule fois, à la fin, pour mesurer le modèle retenu.

modèle de référence (baseline)

Le point de comparaison simple qu'un modèle doit battre, par exemple annoncer toujours la moyenne.

validation croisée (cross-validation)

Ajuster plusieurs fois en mesurant chaque fois sur un pli différent de l'apprentissage, mis de côté.

sur-apprentissage (overfitting)

Un modèle qui apprend par cœur les lignes d'apprentissage et fait moins bien sur de nouvelles.

jeton (token)

Morceau de mot tiré d'un vocabulaire fixe, l'unité qu'un modèle de langue lit sous forme d'entier.

flottant (floating-point number)

Le décimal approché de la machine, environ 16 chiffres significatifs sur 64 bits.

échantillonnage (sampling)

Mesurer un signal continu à intervalles réguliers, 44 100 fois par seconde pour le son d'un CD.

validation en marche avant (walk-forward validation)

Réajuster sur le seul passé, jour après jour, et prévoir le jour suivant.

Les autres fiches du cours

Un résumé public par deck, dans l'ordre du cours.

Précédent : Rendements boursiers : XGBoost et sentimentSuivant : Deep learning, l'essentiel

1. IntroductionHivers de l'IA, emploi et méthode
2. OutilsKaggle, GitHub, Python : les outils
3. Séance 1Cadrage de projet et moindres carrés
4. Séance 2Vraisemblance et régression logistique
5. Séance 3Descente de gradient, ridge et lasso
6. Séance 4Seuil de décision et ML reproductible
7. DevoirUn modèle de référence défendable
8. Séance 5Noyaux, SVM et arbres de décision
9. Séance 6Forêts, boosting, comparaison honnête
10. Séance 7SHAP, équité, ACP et partitionnement
11. DevoirUn modèle champion documenté
12. Séance 8Réseaux de neurones, dérive, prédiction conforme
13. DevoirUn projet de machine learning livré
14. Séance 9Soutenir un projet de machine learning
15. RéférenceProjet de score de défaut de crédit
16. RéférenceRendements boursiers : XGBoost et sentiment
17. RéférenceLe code Python de chaque modèle
18. RéférenceDeep learning, l'essentiel
19. RéférenceDonnées ouvertes et projets par secteur
20. RéférenceManuel de l'expert data et IA
21. RéférenceData engineering, SRE et cloud
22. RéférencePanorama des modèles de machine learning

Toutes les fiches, en liste de lecture

L'attention et le transformer, pas à pas

À propos de ces fiches

Écrites par l'enseignant à partir des slides du deck, comme un résumé public : les idées clés, les formules et un exemple calculé. Les exercices, leurs corrigés, les contrôles et la notation restent dans le deck, pour les élèves du cours.

Révision : 16 octobre 2026.