Premiers pas

Premiers pas avec le machine learning en Python

Ce chapitre introduit le machine learning avec Python. Vous apprendrez ce qu'est le machine learning, pourquoi Python est le langage dominant dans ce domaine, comment configurer un environnement de travail et comment s'articule le flux de travail ML de bout en bout — des données brutes à un modèle entraîné et évalué.

À la fin, vous aurez exécuté un exemple complet de classification en utilisant les trois bibliothèques fondamentales : NumPy, pandas et scikit-learn.

Qu'est-ce que le machine learning ?

Le machine learning (ML) est une branche de l'intelligence artificielle dans laquelle un programme apprend des motifs à partir de données plutôt que de suivre des règles écrites à la main. Vous fournissez des exemples (des données), spécifiez ce que vous souhaitez prédire ou découvrir, et un algorithme ML détermine la correspondance.

Il existe trois grandes catégories :

Cette série se concentre sur l'apprentissage supervisé, car c'est la catégorie la plus utilisée en pratique.

Pourquoi Python pour le machine learning ?

Python est devenu le langage par défaut pour le ML pour plusieurs raisons :

• Syntaxe lisible — les algorithmes peuvent être prototypés rapidement sans code superflu.
• Écosystème riche — scikit-learn, TensorFlow, PyTorch et Keras disposent tous d'API Python de première classe.
• Outils de données — NumPy et pandas simplifient la manipulation des données.
• Communauté — la plus grande communauté ML, ce qui signifie une abondance de tutoriels, de réponses Stack Overflow et de modèles pré-entraînés.

Configurer votre environnement

Installer Python

Téléchargez Python 3.10 ou une version plus récente depuis python.org. Vérifiez l'installation :

python3 --version

Vous devriez voir une sortie comme Python 3.10.15 (ou une version plus récente).

Créer un environnement virtuel

Un environnement virtuel isole les packages de votre projet de l'installation Python système. Cela évite les conflits de versions entre les projets.

python3 -m venv ml-env

Activez-le :

# macOS / Linux
source ml-env/bin/activate

# Windows (Command Prompt)
ml-env\Scripts\activate.bat

Votre invite affichera désormais (ml-env) pour confirmer que l'environnement est actif.

Installer les bibliothèques principales

Avec l'environnement virtuel actif, installez les trois bibliothèques que vous utiliserez tout au long de cette série :

pip install numpy pandas scikit-learn

Enregistrez les versions exactes pour la reproductibilité :

pip freeze > requirements.txt

Toute personne qui clone votre projet pourra reproduire votre environnement avec pip install -r requirements.txt.

Le flux de travail du machine learning

Tout projet ML supervisé suit le même pipeline en cinq étapes :

Raw data → Clean & prepare → Split → Train model → Evaluate

Comprendre ce pipeline est plus important que de mémoriser un seul algorithme. Les sections ci-dessous décrivent chaque étape avec du code.

Étape 1 — Comprendre vos données avec NumPy et pandas

Avant d'entraîner quoi que ce soit, vous devez savoir à quoi ressemblent vos données. NumPy fournit une arithmétique de tableaux rapide ; pandas ajoute des tableaux étiquetés (DataFrames) qui facilitent l'exploration.

NumPy : inspecter un tableau numérique

import numpy as np

data = np.array([2.1, 3.4, 1.8, 5.0, 2.7])
print('Mean:', data.mean())   # 3.0
print('Std: ', round(data.std(), 4))  # 1.1402
print('Max: ', data.max())    # 5.0

pandas : construire un petit jeu de données

import pandas as pd

df = pd.DataFrame({
    'age':    [25, 30, 22, 35, 28],
    'income': [40000, 55000, 32000, 70000, 48000],
    'bought': [0,     1,     0,     1,     0],
})

print(df.shape)             # (5, 3)
print(df['income'].mean())  # 49000.0
print(df.isnull().sum())    # 0 missing values in each column

df.shape vous indique le nombre de lignes et de colonnes. isnull().sum() compte les valeurs manquantes par colonne — vérifiez toujours cela avant de modéliser.

Étape 2 — Nettoyer et préparer les données

Les jeux de données réels ont presque toujours des valeurs manquantes, des formats incohérents ou des caractéristiques à des échelles très différentes. Vous devez y remédier avant l'entraînement.

Gérer les valeurs manquantes

Remplacez les nombres manquants par la médiane de la colonne (robuste aux valeurs aberrantes) ou par la moyenne :

import pandas as pd

df = pd.DataFrame({
    'age':    [25, None, 22, 35, 28],
    'income': [40000, 55000, None, 70000, 48000],
})

df['age']    = df['age'].fillna(df['age'].median())
df['income'] = df['income'].fillna(df['income'].mean())

print(df.isnull().sum())
# age       0
# income    0

Mettre les caractéristiques à l'échelle

De nombreux algorithmes (k plus proches voisins, SVM, réseaux de neurones) sont sensibles à l'échelle des caractéristiques. Une colonne avec des valeurs en milliers dominera une colonne en chiffres simples si vous ne les normalisez pas. StandardScaler soustrait la moyenne et divise par l'écart type, de sorte que chaque caractéristique a une moyenne de 0 et un écart type de 1 :

from sklearn.preprocessing import StandardScaler
import numpy as np

X = np.array([[1.0, 200.0], [2.0, 400.0], [3.0, 300.0]])
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
print(X_scaled.round(2))
# [[-1.22 -1.22]
#  [ 0.    1.22]
#  [ 1.22  0.  ]]

Consultez Mise à l'échelle des caractéristiques pour plus de détails.

Étape 3 — Diviser en ensembles d'entraînement et de test

N'évaluez jamais un modèle sur les données sur lesquelles il a été entraîné — ce serait comme corriger son propre examen avec la feuille de réponses ouverte. Divisez les données pour que le modèle s'entraîne sur une partie et soit évalué sur une partie mise de côté qu'il n'a jamais vue.

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, random_state=42
)

test_size=0.2 réserve 20 % des données pour les tests. random_state=42 rend la division reproductible. Consultez le chapitre Division entraînement/test pour des stratégies comme la division stratifiée et la validation croisée.

Étape 4 — Entraîner un modèle

Avec des données propres et divisées, vous pouvez entraîner votre premier modèle. L'exemple ci-dessous utilise le jeu de données Iris — un benchmark classique avec 150 échantillons, 4 caractéristiques numériques et 3 espèces de fleurs à classifier.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# 1. Load
iris = load_iris()

# 2. Split
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)

# 3. Train
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# 4. Predict & evaluate
predictions = model.predict(X_test)
print(f'Test samples: {len(X_test)}')   # 30
print(f'Accuracy: {accuracy_score(y_test, predictions):.2f}')  # 1.00

Un RandomForestClassifier entraîne de nombreux arbres de décision sur des sous-ensembles aléatoires des données et combine leurs votes. Il gère bien les relations non linéaires et constitue une solide référence pour les tâches de classification. n_estimators=100 spécifie le nombre d'arbres.

Étape 5 — Évaluer le modèle

La précision (la proportion de prédictions correctes) est facile à comprendre, mais peut être trompeuse lorsqu'une classe est beaucoup plus rare que les autres. scikit-learn fournit une suite complète de métriques :

Pour un regard plus approfondi sur l'évaluation, consultez le chapitre Matrice de confusion.

Choisir le bon algorithme

Différents problèmes nécessitent différents algorithmes. Voici une orientation rapide :

Vous explorerez la plupart de ces algorithmes dans le reste de cette série. De bons points de départ sont K plus proches voisins, Arbre de décision et Régression linéaire.

Pièges pour les débutants

• Fuite de données — adapter le scaler sur l'ensemble du jeu de données (avant la division) fait fuiter les statistiques de l'ensemble de test dans l'entraînement. Adaptez toujours les transformateurs sur l'ensemble d'entraînement uniquement, puis appliquez-les à l'ensemble de test.
• Surapprentissage — un modèle qui mémorise les données d'entraînement est peu performant sur de nouvelles données. Utilisez la Validation croisée pour le détecter tôt.
• Ignorer le déséquilibre des classes — si 95 % de vos étiquettes sont « négatif », un modèle qui prédit toujours « négatif » obtient 95 % de précision mais est inutile. Vérifiez les distributions des classes avant de choisir une métrique.
• Sauter l'exploration — regardez toujours vos données avant de modéliser. Vérifiez les plages, les distributions et le nombre de valeurs manquantes.

Conclusion

Vous disposez maintenant d'un environnement Python ML fonctionnel et comprenez le pipeline complet d'apprentissage supervisé : charger les données, les nettoyer, les diviser, entraîner un modèle et évaluer sur des données mises de côté. Les chapitres suivants approfondissent chaque étape — en commençant par la préparation des données, en passant par les algorithmes individuels, et en terminant par des sujets avancés comme la validation croisée et l'optimisation des hyperparamètres.