Tu veux te lancer dans le machine learning mais tu ne sais pas par où commencer ? Pas de panique. Dans ce tutoriel, on va construire ensemble ton premier modèle de classification avec Python et scikit-learn. Pas besoin d’être un génie des maths — on va droit au but avec un projet concret.
Machine Learning avec Python : de quoi parle-t-on ?
Le machine learning (ou apprentissage automatique) est une branche de l’intelligence artificielle qui permet à un programme d’apprendre à partir de données, sans être explicitement programmé pour chaque situation. Concrètement, au lieu d’écrire des règles du type « si température > 30°, allumer la ventilation », tu fournis des exemples à l’ordinateur, et c’est lui qui découvre les règles tout seul.
Pour un développeur, le machine learning est un outil de plus dans ta boîte à outils. Tu n’as pas besoin d’être chercheur en IA pour l’utiliser — il te suffit de connaître les bases de Python et d’avoir un peu de logique.
Dans ce guide pratique, on va travailler avec le jeu de données Iris, un classique du domaine. L’objectif : prédire l’espèce d’une fleur à partir de ses caractéristiques (longueur et largeur des pétales, etc.).
Ce dont tu as besoin pour commencer
Avant de coder, assure-toi d’avoir Python installé (version 3.8 ou supérieure). Tu vas aussi avoir besoin de quelques bibliothèques. Ouvre ton terminal et installe-les avec pip :
pip install scikit-learn pandas matplotlib
Ces trois bibliothèques sont le couteau suisse du data scientist :
- scikit-learn : la bibliothèque de référence pour le machine learning en Python
- pandas : pour manipuler les données facilement (comme un tableaux Excel, mais en code)
- matplotlib : pour visualiser les données et les résultats sous forme de graphiques
Si tu travailles avec un environnement virtuel (bonne pratique !), pense à l’activer avant d’installer les dépendances.
Étape 1 : Charger et explorer les données
Le jeu de données Iris est intégré directement dans scikit-learn. Pas besoin de le télécharger ailleurs. Commençons par le charger et voir à quoi il ressemble :
from sklearn.datasets import load_iris
import pandas as pd
# Charger les données
iris = load_iris()
# Créer un DataFrame pandas pour visualiser les données
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['target'] = iris.target
df['species'] = df['target'].map({
0: 'setosa',
1: 'versicolor',
2: 'virginica'
})
# Afficher les 5 premières lignes
print(df.head())
Ce code te montre les premières lignes de ton jeu de données. Tu verras quatre caractéristiques (longueur et largeur des sépales et pétales) et l’espèce correspondante. C’est tout ce dont le modèle a besoin pour apprendre.
Petite vérification : combien d’exemplaires avons-nous pour chaque espèce ?
print(df['species'].value_counts())
Tu devrais obtenir 50 exemplaires de chaque espèce — un jeu de données bien équilibré pour commencer.
Étape 2 : Préparer les données pour l’entraînement
Avant de nourrir notre modèle, on doit séparer les données en deux ensembles :
- L’ensemble d’entraînement (80% des données) : celui sur lequel le modèle va apprendre
- L’ensemble de test (20% restant) : celui qui va permettre d’évaluer la performance du modèle sur des données qu’il n’a jamais vues
C’est une étape cruciale. Si tu évalues ton modèle sur les mêmes données que celles utilisées pour l’entraînement, tu risques de surestimer ses performances (on appelle ça le sur-apprentissage).
from sklearn.model_selection import train_test_split
# Séparer les caractéristiques (X) de la cible (y)
X = iris.data
y = iris.target
# Diviser en train/test
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
print(f"Données d'entraînement : {X_train.shape[0]} exemples")
print(f"Données de test : {X_test.shape[0]} exemples")
Le paramètre random_state=42 garantit que la division est reproductible — tu obtiendras exactement les mêmes résultats que moi. Pratique pour débugger !
Étape 3 : Entraîner ton premier modèle
On va utiliser un classifieur simple mais efficace : la régression logistique. Ne te laisse pas impressionner par le nom — c’est une méthode de classification parmi les plus utilisées.
from sklearn.linear_model import LogisticRegression
# Créer le modèle
model = LogisticRegression(max_iter=200)
# Entraîner le modèle sur les données d'entraînement
model.fit(X_train, y_train)
# Faire des prédictions sur les données de test
y_pred = model.predict(X_test)
# Afficher les premières prédictions
print("Prédictions :", y_pred[:10])
print("Vraies valeurs :", y_test[:10])
Regarde les premières prédictions : si les valeurs correspondent aux vraies valeurs, c’est que ton modèle commence à apprendre. Mais pour mesurer précisément sa performance, il faut une métrique plus fiable.
Étape 4 : Évaluer la performance de ton modèle
La façon la plus simple d’évaluer un modèle de classification est de calculer son accuracy (précision) : le pourcentage de prédictions correctes.
from sklearn.metrics import accuracy_score, classification_report
# Calculer la précision
accuracy = accuracy_score(y_test, y_pred)
print(f"Précision du modèle : {accuracy:.2%}")
# Rapport détaillé
print(classification_report(y_test, y_pred, target_names=iris.target_names))
Avec le jeu de données Iris et la régression logistique, tu devrais obtenir une précision d’au moins 95% — ce qui est excellent pour un premier modèle ! Le rapport de classification te donne plus de détails : la précision (combien de prédictions positives sont correctes), le rappel (combien de vrais positifs ont été identifiés), et le F1-score (la moyenne harmonieuse des deux).
Tu viens de créer, entraîner et évaluer ton premier modèle de machine learning. Félicitations !
Et maintenant ? Les prochaines étapes
Ce tutoriel t’a donné les bases. Mais le machine learning, c’est un vaste domaine. Voici quelques pistes pour aller plus loin :
- Essaie d’autres algorithmes : arbre de décision, k-plus proches voisins, ou même un petit réseau de neurones avec TensorFlow
- Utilise tes propres données : trouve un fichier CSV sur un sujet qui t’intéresse (météo, sport, vente immobilière) et essaie de prédire quelque chose
- Explore la visualisation : matplotlib et seaborn peuvent t’aider à comprendre tes données avant de les passer au modèle
- Plonge dans le deep learning : une fois que tu maîtrises les classifieurs classiques, les réseaux de neurones t’ouvriront encore plus de portes
Le plus important est de pratiquer. Un modèle imparfait que tu construis toi-même vaut mieux qu’un modèle parfait que tu ne fais que copier-coller.
Ce qu’il faut retenir
- Le machine learning permet à un programme d’apprendre à partir d’exemples, pas de règles explicites
- La séparation entraînement/test est essentielle pour évaluer correctement un modèle
- Scikit-learn rend le ML accessible à tous les développeurs Python
- Un modèle simple et bien construit peut déjà donner d’excellents résultats
- La pratique régulière est la clé pour progresser
Et toi, quel projet de machine learning aimerais-tu réaliser ? Commencer par un système de recommandation ? Un chatbot ? De la reconnaissance d’images ? Partage ton objectif en commentaire — c’est en échangeant qu’on progresse le plus.
Tu veux maîtriser Python et le machine learning en profondeur ? Ma formation Python complète te donne les bases solides pour construire tes propres projets.