4.4Machine learning & IA : scikit-learn, TensorFlow
L'essentiel en 30 secondes
- ML = apprendre depuis des exemples :
fit(X, y)apprend,predictprédit, et on évalue sur des données jamais vues (train_test_split). - Workflow en 5 lignes : split →
LogisticRegressionouRandomForest→fit→score→ matrice de confusion ; baseline simple d'abord. - Réflexe de Nabil : 100 % sur le train et 60 % en prod = évalué sur le train — le split n'est pas optionnel, et le modèle apprend aussi les biais.
Mini-cas filé — Nabil prédit les impayés
La direction demande à Nabil, à Alger : « peut-on repérer les clients à risque d'impayé ? » Plutôt que des règles artisanales, Nabil entraîne un RandomForest avec scikit-learn sur l'historique : split 80/20 avec random_state pour la reproductibilité, fit sur le train, score sur le test jamais vu. Première évaluation sur le train : 100 % — illusoire ; sur le test : 82 % — honnête. Il livre une baseline utile et documentée, avec un audit des biais avant toute décision. Quatrième jalon du fil rouge : de l'analyste qui décrit au modèle qui prédit — prudemment.
Suite du cas 4.1-4.3 — Nabil prédit depuis ses données historiques.
1. Apprendre depuis des exemples + le split sacré
Le machine learning remplace les règles codées à la main par une règle apprise depuis des exemples étiquetés : fit(X, y) entraîne, predict prédit sur du nouveau. La règle d'or : évaluer sur des données jamais vues avec train_test_split — sinon on mesure la mémoire, pas l'apprentissage. Nabil l'apprend à ses dépens : 100 % sur le train, 82 % sur le test — seul le second chiffre compte. random_state fixé = résultat reproductible.
2. scikit-learn d'abord, deep learning ensuite
scikit-learn couvre 80 % des besoins business tabulaires sans GPU : LogisticRegression, RandomForestClassifier, même API fit/predict/score, matrice de confusion pour lire les erreurs. Baseline simple d'abord, complexifier seulement si le simple échoue. Le deep learning (TensorFlow, PyTorch, réseaux de neurones, GPU) entre en jeu pour images, texte et audio — avec la règle d'or : partir de modèles pré-entraînés (Hugging Face) et les ajuster, jamais from-scratch. Et l'éthique : le modèle apprend les préjugés des données — Nabil audite les biais avant toute décision automatisée.
🔎 Exemple concret — 🔎 Exemple concret — La baseline de Nabil
Le workflow complet, avec les API réelles de scikit-learn :
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2, random_state=0)
modele = RandomForestClassifier().fit(Xtr, ytr) # apprend
print(modele.score(Xte, yte)) # ~0.96 : évalué sur jamais-vus
Règle → 100 % au train + 60 % en prod = fuite du splitLecture : split, fit, score — trois lignes, zéro magie.
Leçon : random_state = résultat reproductible et discutable.
Vocabulaire de la section
- Machine learning
- Apprendre une règle depuis des exemples étiquetés (fit) puis prédire sur du nouveau (predict), au lieu de coder des règles à la main.
Exemple simple : Nabil prédit les impayés depuis l'historique plutôt que des seuils artisanaux.
Ce que ce n'est pas : des règles si/alors codées une par une.
Réflexe : données étiquetées en quantité ? envisager le ML.
- Train/test split
- Séparer les données : apprendre sur le train, évaluer sur le test jamais vu — sinon on mesure la mémoire, pas l'apprentissage.
Exemple simple : Nabil : 100 % au train (mémoire), 82 % au test (réalité).
Ce que ce n'est pas : évaluer le modèle sur ses propres exemples d'entraînement.
Réflexe : split systématique, random_state fixé.
- scikit-learn (fit/predict)
- Bibliothèque ML tabulaire idéale pour débuter : API unique fit/predict/score, sans GPU, baseline en 5 lignes.
Exemple simple : Le RandomForest de Nabil en trois lignes : split, fit, score.
Ce que ce n'est pas : un réseau de neurones GPU pour un tableau clients.
Réflexe : baseline simple d'abord, complexifier si besoin.
- Deep learning / pré-entraînés
- Réseaux de neurones (TensorFlow, PyTorch, GPU) pour images/texte/audio ; on part de modèles pré-entraînés qu'on ajuste, jamais from-scratch.
Exemple simple : Nabil ajoutera un modèle pré-entraîné pour lire des avis clients, pas un réseau maison.
Ce que ce n'est pas : entraîner un géant depuis zéro sur son laptop.
Réflexe : image/texte/audio ? pré-entraîné + ajustement.
En pratique — En pratique — Entraîner une baseline
- Chargez un jeu tabulaire étiqueté (ex. load_iris ou vos propres données historiques nettoyées).
- Séparez avec train_test_split (test_size=0.2, random_state fixé) : le test reste intact jusqu'à l'évaluation.
- Entraînez une baseline (LogisticRegression ou RandomForestClassifier) : fit sur le train seul.
- Évaluez sur le test (score + matrice de confusion), comparez au score train, et notez biais et limites avant toute décision.
Script prêt à dire — présenter son modèle (30 s)
« C'est Nabil : baseline RandomForest, 82 % sur des données jamais vues — pas 100 % au train, ça c'est de la mémoire. Matrice de confusion lue, biais audités : le modèle aide la décision, il ne la remplace pas. »
À dire en comité ; montrez la matrice, pas juste le score.
Modèle copier-coller — baseline scikit-learn (code testé)
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import confusion_matrix
X, y = load_iris(return_X_y=True)
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2, random_state=0)
modele = RandomForestClassifier(random_state=0)
modele.fit(Xtr, ytr) # apprend sur le train SEUL
print("train :", modele.score(Xtr, ytr)) # mémoire (référence)
print("test :", modele.score(Xte, yte)) # apprentissage (vrai chiffre)
print(confusion_matrix(yte, modele.predict(Xte)))
Premier modèle
Un jeu simple (iris), une baseline, un split : comprenez fit/predict avant de toucher vos données.
Données tabulaires
Comme Nabil : scikit-learn suffit dans 80 % des cas business — sans GPU ni deep learning.
Image ou texte
Passez à TensorFlow/PyTorch via des modèles pré-entraînés à ajuster, jamais entraînés depuis zéro.
Décision sensible
Crédit, recrutement, santé : auditez les biais, gardez l'humain décideur, documentez les limites.
✓ Bonnes pratiques
- Split toujours : évaluer sur des jamais-vus.
- Baseline simple d'abord, complexifier si besoin.
- Auditer biais et limites avant décision.
✗ Pièges fréquents
- Évaluer sur le train (100 % illusoire).
- Sortir le deep learning pour un tableau.
- Ignorer les biais appris des données.
Points clés à retenir
- ML = MOTIFS appris depuis des exemples (fit → predict), pas des règles codées.
- API SKLEARN : fit()/predict()/score() ; SPLIT train/test OBLIGATOIRE.
- BASELINE simple d'abord (Logit, RandomForest) : 80 % du business sans GPU.
- DEEP = réseaux de neurones (images/texte) via PRÉ-ENTRAÎNÉS ; biais à auditer.
Défi 48h — appliquez demain
Entraînez 1 baseline sur un jeu tabulaire : split 80/20, fit, score test + matrice de confusion lue et commentée.
- Je peux citer fit/predict et le split train/test.
- Je sais expliquer le piège du 100 % au train.
- J'ai 1 baseline évaluée sur des jamais-vus.
Questions fréquentes
Faut-il des maths avant de faire du ML ?
Non pour une première baseline scikit-learn : le workflow (split, fit, score) s'apprend en pratique. Oui ensuite : statistiques et algèbre pour choisir un modèle, régler ses paramètres et comprendre ses erreurs. Nabil avance par paliers : baseline utile d'abord, théorie au fil des limites rencontrées.
scikit-learn ou TensorFlow pour débuter ?
scikit-learn sans hésiter : tabulaire, CPU, API unique, résultats en 5 lignes — 80 % des besoins business. TensorFlow ou PyTorch ensuite, pour images, texte et audio via des modèles pré-entraînés à ajuster. Le deep learning pour un tableau clients, c'est un camion pour livrer une lettre.
Quelle bibliothèque pour débuter en machine learning ?