Beaucoup de gens qui apprennent la programmation croisent le machine learning sous sa forme la plus intimidante. Des vidéos sur les réseaux de neurones, des schémas de couches empilées, des formules de descente de gradient, TensorFlow et PyTorch cités comme des passages obligés. Après quelques heures de ce régime, il reste une impression tenace: ce domaine demande un bagage en mathématiques que tu n'as pas, du matériel coûteux, et des semaines avant le premier résultat visible.
Cette impression bloque une chose pourtant accessible. Entraîner un modèle qui classe des données ou prédit une valeur ne réclame ni carte graphique, ni maîtrise du calcul matriciel, ni installation compliquée. La bibliothèque scikit-learn, développée en partie par des chercheurs de l'Inria, existe justement pour ça: une interface unique et lisible pour des dizaines d'algorithmes, utilisable après une seule commande d'installation.
Cet article te fait entraîner un vrai modèle, sur un vrai jeu de données, et l'évaluer. Tu vas écrire du code qui tourne, comprendre ce que chaque ligne fait, et repartir avec une base solide pour aller plus loin. Pas de théorie des probabilités en préambule, pas de couches cachées: juste le geste de base du machine learning, celui qu'on répète ensuite sur des problèmes de plus en plus gros.
Le vrai point de départ, souvent invisible dans les cours
La plupart des ressources en ligne commencent par expliquer comment un algorithme fonctionne à l'intérieur. La régression logistique, la forêt aléatoire, les vecteurs de support: chacun a droit à son chapitre théorique, ses équations, ses graphiques. C'est utile plus tard, quand tu veux choisir le bon outil ou régler ses paramètres. Au démarrage, ça place la barre très haut pour un geste qui est simple.
Le machine learning supervisé, celui qu'on pratique en premier, repose sur une idée qui tient en une phrase. Tu donnes à un algorithme des exemples déjà étiquetés, il en tire un modèle, et ce modèle sait ensuite étiqueter des exemples qu'il n'a jamais vus. Une liste de fleurs avec leurs mesures et leur espèce, et le modèle apprend à deviner l'espèce d'une nouvelle fleur à partir de ses seules mesures. Une liste de logements avec leurs caractéristiques et leur prix, et le modèle estime le prix d'un logement inconnu.
Deux mots reviennent tout le temps. Les features sont les caractéristiques que tu fournis en entrée, les colonnes qui décrivent chaque exemple. La cible (ou label) est ce que tu cherches à prédire. Longueur et largeur des pétales sont des features, l'espèce est la cible. Surface, nombre de pièces et quartier sont des features, le prix est la cible.
Le geste central de scikit-learn tient en deux méthodes. Tu appelles .fit() pour entraîner le modèle sur tes exemples, puis .predict() pour obtenir des prédictions sur de nouvelles données. Cette paire fonctionne à l'identique quel que soit l'algorithme choisi. C'est ce qui rend la bibliothèque agréable: tu changes une ligne pour passer d'un modèle à un autre, tout le reste du code ne bouge pas.
Installer et charger les données
La version stable au moment où j'écris est scikit-learn 1.9.0, sortie le 2 juin 2026. Elle tourne avec Python 3.11 à 3.14. Si tu débutes en Python, la formation Python pour débutants couvre les bases nécessaires pour suivre ce qui vient sans blocage.
L'installation tient en une commande, dans un environnement virtuel de préférence pour ne pas polluer ton Python système:
python -m venv .venv
source .venv/bin/activate
pip install scikit-learnscikit-learn embarque des jeux de données prêts à l'emploi, ce qui évite de chercher un fichier CSV avant même d'avoir écrit une ligne utile. On va utiliser le jeu Iris, un classique du domaine: 150 fleurs, quatre mesures par fleur, et trois espèces à distinguer. Il tient en mémoire, il est propre, et il permet de se concentrer sur la mécanique.
from sklearn.datasets import load_iris
data = load_iris()
X = data.data # les features, 150 lignes et 4 colonnes
y = data.target # la cible, l'espece de chaque fleur
print(X.shape) # (150, 4)
print(data.target_names) # ['setosa' 'versicolor' 'virginica']La convention X majuscule pour les features et y minuscule pour la cible se retrouve dans presque tous les exemples de la bibliothèque. Autant l'adopter dès le début, ça rend ton code lisible par n'importe qui d'autre dans le domaine.
Séparer les données avant d'entraîner
Voici l'étape que les débutants sautent le plus souvent, et celle qui change tout. Tu ne veux pas entraîner ton modèle sur la totalité des données, puis mesurer ses performances sur ces mêmes données. Ce serait comme donner à un élève les réponses de l'examen pendant qu'il révise: il aura une note parfaite qui ne dit rien de sa vraie capacité.
On coupe donc le jeu en deux. Une partie sert à l'entraînement, l'autre reste de côté pour l'évaluation, sur des exemples que le modèle n'a jamais vus. scikit-learn fournit une fonction dédiée:
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
X, y,
test_size=0.2, # 20% des donnees gardees pour le test
random_state=42 # pour un decoupage reproductible
)
print(len(X_train), len(X_test)) # 120 40Le paramètre test_size=0.2 réserve un cinquième des données pour l'évaluation. Le random_state=42 fixe la graine du tirage aléatoire, ce qui te garantit le même découpage à chaque exécution. Sans lui, tes résultats varieraient légèrement d'un lancement à l'autre, et tu ne saurais jamais si un changement vient de ton code ou du hasard.
Cette séparation entraînement/test est le premier réflexe de rigueur du métier. Un modèle qui affiche 99 % de réussite sur ses données d'entraînement et 60 % sur des données neuves n'a rien appris d'exploitable, il a mémorisé. Sans la coupure, tu ne verrais jamais la différence.
Entraîner le modèle et le faire prédire
On arrive au moment attendu. Pour un premier essai, un arbre de décision fait un bon candidat: il est simple à visualiser mentalement, il gère bien ce type de problème, et il ne demande aucun réglage particulier pour donner un résultat correct.
from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier(random_state=42)
model.fit(X_train, y_train) # l'entrainement
predictions = model.predict(X_test) # les predictions sur le test
print(predictions[:5]) # ex: [1 0 2 1 1]Trois lignes suffisent. Tu crées le modèle, tu l'entraînes avec .fit() sur les données d'entraînement, tu génères des prédictions avec .predict() sur les données de test. Chaque nombre renvoyé correspond à une espèce prédite pour une fleur du jeu de test.
Reste à savoir si ces prédictions sont bonnes. On compare ce que le modèle a prédit avec les vraies espèces mises de côté:
from sklearn.metrics import accuracy_score
score = accuracy_score(y_test, predictions)
print(f"Precision: {score:.2%}") # ex: Precision: 100.00%Sur le jeu Iris, un arbre de décision atteint souvent une précision proche de 95 à 100 % sur cet échantillon de test, parce que les espèces se distinguent nettement par leurs mesures. Ne te réjouis pas trop vite: un score aussi élevé est typique d'un jeu de données facile et propre. Sur des données réelles, bruitées et déséquilibrées, tu descendras vite, et c'est normal.
Le geste que tu viens de faire est celui que tu répéteras sur tous tes projets suivants. Charger, séparer, entraîner, prédire, évaluer. Cette boucle ne change pas, seuls le jeu de données et l'algorithme évoluent.
Changer d'algorithme sans réécrire le reste
La force de scikit-learn se voit quand tu veux comparer plusieurs modèles. Comme l'interface fit/predict est la même partout, tu remplaces une seule ligne pour tester une régression logistique à la place de l'arbre:
from sklearn.linear_model import LogisticRegression
model = LogisticRegression(max_iter=200)
model.fit(X_train, y_train)
score = accuracy_score(y_test, model.predict(X_test))
print(f"Precision: {score:.2%}")Le reste du script est identique. Cette régularité te permet d'essayer cinq algorithmes en cinq minutes, de noter leurs scores, et de garder celui qui marche le mieux sur ton problème. C'est une méthode de travail bien plus utile au début que de chercher à comprendre les entrailles de chaque modèle.
Le paramètre max_iter=200 sur la régression logistique augmente le nombre d'itérations d'optimisation. Sans lui, tu verrais parfois un avertissement de non-convergence, un message que scikit-learn affiche quand l'algorithme n'a pas fini de s'ajuster dans le temps imparti. Ce genre de détail s'apprend en lisant les messages plutôt qu'en les ignorant.
Les pièges qui faussent tes premiers résultats
Un premier modèle qui tourne donne un sentiment de réussite, parfois trompeur. Voici les erreurs qui reviennent le plus chez les personnes qui débutent, et qui transforment un bon score en illusion.
Évaluer sur les données d'entraînement
Mesurer la précision sur les mêmes exemples que ceux de l'entraînement donne un score gonflé qui ne prédit rien de la performance réelle. Garde toujours un jeu de test à part, et ne le touche qu'à la fin.
Oublier de mettre les features à la même échelle
Certains algorithmes, comme les k plus proches voisins ou les vecteurs de support, sont sensibles aux écarts d'unité entre colonnes. Une feature en milliers écrase une feature en dixièmes. Un StandardScaler corrige ça. Les arbres, eux, s'en moquent.
Se fier à la précision sur des classes déséquilibrées
Si 95 % de tes exemples appartiennent à une seule classe, un modèle qui répond toujours cette classe affiche 95 % de précision sans rien avoir appris. Regarde aussi le rappel et la matrice de confusion, pas seulement la précision globale.
Attendre du deep learning là où il n'a pas sa place
Sur des données tabulaires de taille modeste, un modèle classique de scikit-learn bat souvent un réseau de neurones, tout en étant plus rapide à entraîner et plus facile à expliquer. Le deep learning brille sur les images, le texte et le son, pas sur un tableau de 150 lignes.
Ces réflexes séparent un code qui donne un chiffre d'un code qui donne un chiffre fiable. Ils s'acquièrent en pratiquant sur plusieurs jeux de données, pas en lisant une définition. Le syndrome du tutoriel infini guette là comme partout: à un moment, il faut fermer la vidéo et lancer le script.
Où aller après ce premier modèle
Tu as maintenant la boucle de base en main. Pour la solidifier, reprends le même script avec un jeu de données différent. scikit-learn en propose plusieurs, dont un sur les vins et un sur les chiffres manuscrits. Change le chargement, garde le reste, observe comment le score évolue selon la difficulté du problème.
L'étape suivante consiste à travailler tes propres données, souvent dans un fichier CSV que tu charges avec pandas avant de le passer à scikit-learn. C'est là que le métier commence: nettoyer les valeurs manquantes, transformer les colonnes textuelles en nombres, choisir les bonnes features. Un premier projet de ce genre a aussi sa place sur ton portfolio, un point que détaille l'article sur le premier projet pour un CV de développeur junior.
Si tu veux un cadre structuré plutôt que d'avancer seul, la formation Introduction au machine learning avec Python reprend cette progression pas à pas, avec des jeux de données réels et un accompagnement sur les pièges qu'on ne voit pas venir seul. De quoi transformer ce premier script en compétence exploitable.
