Fondamentaux

Le Machine Learning (apprentissage automatique) est le domaine de l’informatique qui permet aux ordinateurs d’apprendre à partir de données sans être explicitement programmés pour chaque tâche. C’est la branche de la science computationnelle qui se concentre sur l’analyse et l’interprétation de patterns et structures dans les données pour permettre l’apprentissage, le raisonnement et la prise de décision sans intervention humaine directe.

Contraste avec la programmation classique :

Évolution et dynamisme

Propriétés du domaine :

• Évolution constante : Nouveaux algorithmes chaque année
• Peu de standards figés : Best practices en évolution
• Interdisciplinarité : Mathématiques, statistiques, informatique
• Accessibilité croissante : Outils de plus en plus simples (sklearn, TensorFlow)

⚠️ Conseil : Restez à jour ! Suivez les conférences (NeurIPS, ICML), blogs (Towards Data Science), et implémentations (Papers with Code).

Taxonomie du Machine Learning

                    Machine Learning
                          |
        ┌─────────────────┴─────────────────┐
        │                                   │
   Supervisé                          Non-supervisé
        │                                   │
   ┌────┴────┐                    ┌─────────┼──────────┐
   │         │                    │         │          │
Regression Classification    Clustering  Dim.     Anomaly
                                        Reduction Detection
   │         │                    │         │          │
  Linéaire Logistique          K-Means    PCA    Isolation
  Ridge    SVM                 DBSCAN    t-SNE    Forest
  Lasso  Random Forest       Hierarchical UMAP
         Neural Networks

Apprentissage supervisé

Caractéristiques :

• Données étiquetées (labeled)
• Objectif : Apprendre une fonction $f: X \rightarrow y$
• Évaluation : Comparaison prédictions vs vraies valeurs

Regression vs Classification

Différence fondamentale : Nature de la variable cible.

Autres tâches supervisées

Ranking : Ordonner des éléments par pertinence

• Moteurs de recherche
• Systèmes de recommandation

Apprentissage non-supervisé

Caractéristiques :

• Données non-étiquetées
• Objectif : Découvrir la structure cachée
• Pas de “bonne réponse” à comparer

Clustering (Regroupement)

Objectif : Trouver des groupes naturels dans les données.

Exemples :

• Segmentation de clients
• Identification de familles de molécules similaires
• Compression d’images (K-means)

Dimensionality Reduction (Réduction de dimension)

Objectif : Réduire le nombre de features tout en préservant l’information.

Usages :

• Visualisation de données haute-dimension
• Pré-traitement avant modélisation
• Compression

Méthodes courantes : PCA, t-SNE, UMAP

Anomaly Detection (Détection d’anomalies)

Objectif : Identifier les points atypiques.

Applications :

• Détection de fraudes
• Maintenance prédictive
• Contrôle qualité en production chimique

Terminologie

Notation standard :

• $X$ : Matrice de features (majuscule, gras)
• $y$ : Vecteur target (minuscule)
• $n$ : Nombre d’échantillons
• $p$ : Nombre de features
• $\hat{y}$ : Prédictions

Domaines et tâches

Tâches par domaine :

Pipeline Machine Learning

Dataset
   ↓
Data Retrieval (Collecte)
   ↓
Data Preparation
   ├─ Data Processing & Wrangling
   ├─ Feature Extraction & Engineering
   └─ Feature Scaling & Selection
   ↓
Modeling ←─── Machine Learning Algorithms
   ↓
Model Evaluation & Tuning
   ↓ (si insatisfaisant, retour à Data Preparation)
   ↓
Deployment & Monitoring

Étape 1 : Data Retrieval

Collecter et charger les données.

Sources courantes :

• Bases de données (SQL)
• APIs (REST, GraphQL)
• Fichiers (CSV, JSON, Parquet)
• Web scraping
• Instruments de mesure (spectroscopie, chromatographie)

Étape 2 : Data Preparation

2.1 Data Processing & Wrangling

Nettoyer et structurer les données.

Tâches courantes :

• Gestion des valeurs manquantes
• Suppression des doublons
• Correction des erreurs de saisie
• Conversion de types
• Fusion de datasets

2.2 Feature Extraction & Engineering

Créer de nouvelles features à partir des données brutes.

Exemples :

• Extraire année, mois, jour d’une date
• Créer des interactions (produit de deux features)
• Calculer des descripteurs moléculaires (à partir de SMILES)
• One-hot encoding de variables catégorielles

2.3 Feature Scaling & Selection

Scaling : Normaliser les échelles des features

• StandardScaler : $(x - \mu) / \sigma$
• MinMaxScaler : $(x - x_{min}) / (x_{max} - x_{min})$

Selection : Choisir les features les plus informatives

• Variance threshold
• Corrélation avec la target
• Importance dans un modèle

Étape 3 : Modeling

Entraîner un modèle sur les données préparées.

Choix du modèle : Dépend de :

• Type de problème (regression, classification)
• Taille du dataset
• Interprétabilité requise
• Contraintes computationnelles

Étape 4 : Model Evaluation & Tuning

Évaluer et améliorer le modèle.

Processus itératif :

1. Évaluer les performances
2. Identifier les faiblesses
3. Ajuster hyperparamètres ou revenir au preprocessing
4. Répéter jusqu’à satisfaction

Étape 5 : Deployment & Monitoring

Deployment : Mettre le modèle en production

• API REST (Flask, FastAPI)
• Batch predictions
• Edge deployment (mobile, IoT)

Monitoring : Surveiller les performances

• Drift de données
• Dégradation du modèle
• Latence, erreurs

Modélisations linéaires avec Scikit-learn

Généralités

• Open-source et très maintenu
• API cohérente entre tous les modèles
• Documentation excellente
• Intégration NumPy/Pandas
• Performance : Implémentations optimisées (C/Cython)

Structure de Scikit-learn

Organisation :

• Sklearn est organisé en modules
• Chaque module contient des outils sous forme de classes

Principaux modules :

Imports : Bonnes pratiques

Exemple avec linear_model :

# ❌ NE FONCTIONNE PAS avec sklearn
import sklearn
model = sklearn.linear_model.LinearRegression()

# ❌ Import du module entier (verbeux)
import sklearn.linear_model
model = sklearn.linear_model.LinearRegression()

# ❌ Import du module (toujours verbeux)
from sklearn import linear_model
model = linear_model.LinearRegression()

# ❌ Import wildcard (non-explicite)
from sklearn.linear_model import *
model = LinearRegression()  # D'où vient-il ?

# ✅ BONNE PRATIQUE : Import explicite de la classe
from sklearn.linear_model import LinearRegression
model = LinearRegression()  # Clair et concis

Workflow et exemple

Les 5 étapes standard :

# 1. Import du modèle
from sklearn.linear_model import LinearRegression

# 2. Instanciation du modèle
model = LinearRegression()

# 3. Entraînement du modèle
model.fit(X_train, y_train)

# 4. Évaluation du modèle
score = model.score(X_test, y_test)

# 5. Prédictions
predictions = model.predict(X_new)

Dataset

import pandas as pd

data = pd.read_csv('houses.csv')

# Mélanger les données (important !)
data = data.sample(frac=1)

data.head()

Objectif : Prédire SalePrice (y) en fonction de GrLivArea (X).

# Sélectionner les colonnes pertinentes
livecode_data = data[['GrLivArea', 'SalePrice']]

Exploration visuelle

import matplotlib.pyplot as plt

plt.scatter(data['GrLivArea'], data['SalePrice'])
plt.xlabel("Surface habitable (ft²)")
plt.ylabel("Prix de vente ($)")
plt.title("Relation surface-prix")
plt.show()

Observation : Tendance linéaire positive (plus grand → plus cher).

Entraînement

from sklearn.linear_model import LinearRegression

# 1. Instancier le modèle (aussi appelé "estimator")
model = LinearRegression()

# 2. Définir X et y
X = data[['GrLivArea']]  # ⚠️ Double crochets → DataFrame
y = data['SalePrice']     # ⚠️ Simple crochet → Series

# 3. Entraîner le modèle
model.fit(X, y)

Attributs du modèle

Après entraînement, les paramètres optimaux sont stockés comme attributs (suffixe _).

# Pente (a)
print(f"Pente : {model.coef_[0]:.2f}")

Pente : 105.01

# Intercept (b)
print(f"Intercept : {model.intercept_:.2f}")

Intercept : 22104.12

Interprétation :

• Chaque ft² supplémentaire ajoute ~105$ au prix
• Une maison de 0 ft² aurait un “prix de base” de ~22,104$ (n’a pas de sens physiquement, mais nécessaire mathématiquement)

Évaluation (Score)

Chaque algorithme sklearn a une métrique par défaut.

Pour LinearRegression : Coefficient de détermination ($R^2$)

Définition : $R^2$ représente la proportion de la variance de $y$ expliquée par $X$.

Propriétés :

• Varie typiquement entre 0 et 1
• 0 : Le modèle n’explique rien
• 1 : Le modèle explique parfaitement
• Plus haut = meilleur

  # Évaluer la performance
  score = model.score(X, y)
  print(f"R² : {score:.3f}")
  

  R² : 0.490

Interprétation : Le modèle explique ~49% de la variance des prix.

💡 Métrique par défaut : Consultez la documentation de .score() pour chaque modèle.

Exemples :

• LogisticRegression : Accuracy
• SVC : Accuracy
• Régresseurs : Généralement $R^2$

Prédictions

# Prédire sur de nouvelles données
new_data = pd.DataFrame({'GrLivArea': [1000]})

prediction = model.predict(new_data)
print(f"Prix prédit : ${prediction[0]:,.0f}")

Prix prédit : $127,113

Interprétation : Un appartement de 1000 ft² est estimé à ~127K$.

Généralisation

The Holdout Method

Méthode d’évaluation consistant à diviser le dataset en deux ensembles :

• Training set (~70%) : Pour entraîner le modèle
• Test set (~30%) : Pour évaluer la généralisation

1. Le modèle apprend sur le training set
2. On mesure sa performance sur le test set (données inédites)
3. Le score sur le test set estime la performance en production

Implémentation

from sklearn.model_selection import train_test_split

# Préparer X et y
X = livecode_data[['GrLivArea']]
y = livecode_data['SalePrice']

# Split en Train/Test (70/30)
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.3  # 30% pour le test
)

Résultat : 4 objets créés

X_train  →  Features d'entraînement   (70% des lignes)
y_train  →  Target d'entraînement     (70% des lignes)
X_test   →  Features de test          (30% des lignes)
y_test   →  Target de test            (30% des lignes)

Alternative : Split directement le DataFrame

# Split le DataFrame complet
train_data, test_data = train_test_split(livecode_data, test_size=0.3)

# Puis extraire X et y
X_train = train_data[['GrLivArea']]
y_train = train_data['SalePrice']
X_test = test_data[['GrLivArea']]
y_test = test_data['SalePrice']

Entraînement et évaluation

# Instancier
model = LinearRegression()

# Entraîner sur le Training set
model.fit(X_train, y_train)

# Évaluer sur le Test set
test_score = model.score(X_test, y_test)
print(f"Score sur test : {test_score:.3f}")

Score sur test : 0.482

Comparaison :

• Score sur toutes les données : 0.490
• Score sur test set : 0.482

Interprétation : Légère baisse acceptable (le modèle généralise bien).

Limitations

K-Fold Cross Validation

Processus

1. Le dataset est divisé en K “folds” (plis)
2. Pour chaque fold :
   • Il sert de test set
   • Les K-1 autres servent de training set
   • Un sous-modèle est entraîné et évalué
3. Le score final = moyenne des K scores

Vue DataFrame :

Propriété clé : On n’entraîne pas de modèle final, on estime simplement le score d’un modèle hypothétique entraîné sur tout le dataset.

Implémentation

from sklearn.model_selection import cross_validate

# Instancier le modèle
model = LinearRegression()

# Cross-validation à 5 folds
cv_results = cross_validate(model, X, y, cv=5)

# Afficher les 5 scores
print("Scores des 5 folds :")
print(cv_results['test_score'])

# Moyenne des scores
mean_score = cv_results['test_score'].mean()
print(f"\nScore moyen : {mean_score:.3f}")

Scores des 5 folds : [0.300 0.434 0.553 0.592 0.515]

Score moyen : 0.479

Interprétation :

• Score plus robuste (moyenne de 5 évaluations)
• Variabilité visible entre folds
• Utilise toutes les données

Choisir K

Compromis : Fiabilité vs Coût computationnel

Règle empirique : K=5 ou K=10

Propriétés :

• Plus K est grand → Score plus représentatif
• Plus K est grand → Temps de calcul plus long
• K=n (Leave-One-Out) : Maximum d’information, mais très lent

Le compromis Biais-Variance

No Free Lunch Theorem

Il n’existe pas de modèle universel optimal pour tous les problèmes.

C’est à nous, data scientists, de :

1. Faire des hypothèses sur les données
2. Tester plusieurs modèles
3. Évaluer leur généralisation

Donc par exemples :

• Données linéaires → Regression linéaire
• Données non-linéaires → Polynomial, Random Forest
• Relations complexes → Neural Networks

Learning Curves

On augmente progressivement la taille du training set et on observe l’évolution des scores.

Comportement typique :

À mesure que la taille d’entraînement augmente :

• Le score d’entraînement diminue (plus difficile de “mémoriser”)
• Le score de test augmente (meilleure généralisation)
• Les courbes convergent généralement

High Bias (Underfitting)

Interprétation : Le modèle est trop simple pour capturer les patterns.

Solutions :

• Modèle plus complexe
• Plus de features
• Feature engineering

High Variance (Overfitting)

Interprétation : Le modèle mémorise le bruit des données d’entraînement.

Solutions :

• Plus de données d’entraînement
• Modèle plus simple
• Régularisation
• Réduction de features

Courbes idéales

Interprétation : Le modèle généralise parfaitement !

Implémentation avec Scikit-learn

import numpy as np
from sklearn.model_selection import learning_curve
import matplotlib.pyplot as plt

# Définir les tailles d'entraînement à tester
train_sizes = [25, 50, 75, 100, 250, 500, 750, 1000, 1150]

# Calculer les courbes d'apprentissage
train_sizes, train_scores, test_scores = learning_curve(
    estimator=LinearRegression(),
    X=X,
    y=y,
    train_sizes=train_sizes,
    cv=5  # 5-fold pour chaque taille
)

# Moyennes des scores (sur les 5 folds)
train_scores_mean = np.mean(train_scores, axis=1)
test_scores_mean = np.mean(test_scores, axis=1)

# Tracer les courbes
plt.figure(figsize=(10, 6))
plt.plot(train_sizes, train_scores_mean, label='Score entraînement', marker='o')
plt.plot(train_sizes, test_scores_mean, label='Score test', marker='o')
plt.xlabel('Taille du training set', fontsize=14)
plt.ylabel('R² score', fontsize=14)
plt.title('Courbes d\'apprentissage', fontsize=18)
plt.legend()
plt.grid(alpha=0.3)
plt.show()

Observation 1 : Les courbes ont convergé et plafonné

• Le modèle fait de son mieux avec les patterns disponibles
• Ajouter plus de données n’améliorera pas la performance

Observation 2 : Le score reste relativement bas (R² ~ 0.5)

• Suggère qu’on pourrait améliorer le modèle
• Solutions : features supplémentaires, modèle non-linéaire, feature engineering

Classification Multi-classes

Exemples :

• Reconnaître des chiffres manuscrits (0-9) : 10 classes
• Identifier des espèces de fleurs (Iris) : 3 classes
• Classifier des types de réactions chimiques : n classes
• Prédire des espèces de pingouins : 3 classes

On peut se demander si la généralisation du problème binaire à n classes ne constitue pas un défi algorithmique fondamental en Machine Learning ?

Dataset d’exemple : Palmer Penguins

Source : Dataset intégré à Seaborn, collecté par Dr. Kristen Gorman à la station Palmer en Antarctique.

Objectif : Classifier trois espèces de pingouins en fonction de leurs mesures physiques.

import seaborn as sns
import pandas as pd
import matplotlib.pyplot as plt

# Charger le dataset
penguins = sns.load_dataset('penguins')

# Aperçu
penguins.head()

Les trois espèces :

• Adelie (Pygoscelis adeliae)
• Chinstrap (Pygoscelis antarcticus)
• Gentoo (Pygoscelis papua)

  # Distribution des espèces
  penguins['species'].value_counts()
  

  Adelie 152 Gentoo 124 Chinstrap 68 Name: species, dtype: int64

Exploration visuelle

# Visualisation des features par espèce
sns.pairplot(penguins, hue='species',
             vars=['bill_length_mm', 'bill_depth_mm',
                   'flipper_length_mm', 'body_mass_g'])
plt.suptitle('Caractéristiques physiques des pingouins par espèce', y=1.02)
plt.show()

Observations :

• Gentoo : Nageoires plus longues, bec moins profond
• Chinstrap : Bec plus long
• Adelie : Bec plus court et profond
• Séparabilité visible mais pas parfaite ```python

  Scatter plot de deux features clés

  plt.figure(figsize=(10, 6)) for species in penguins[‘species’].unique(): subset = penguins[penguins[‘species’] == species] plt.scatter(subset[‘bill_length_mm’], subset[‘bill_depth_mm’], label=species, alpha=0.6, s=100)

plt.xlabel(‘Longueur du bec (mm)’, fontsize=12) plt.ylabel(‘Profondeur du bec (mm)’, fontsize=12) plt.title(‘Séparation des espèces par dimensions du bec’, fontsize=14) plt.legend() plt.grid(alpha=0.3) plt.show()

**Propriété importante** : Les classes ne sont pas parfaitement linéairement séparables, mais des frontières peuvent être établies.

### Préparation des données
```python
# Nettoyer les données
penguins_clean = penguins.dropna()

# Séparer features et target
X = penguins_clean[['bill_length_mm', 'bill_depth_mm',
                     'flipper_length_mm', 'body_mass_g']]
y = penguins_clean['species']

# Vérifier les dimensions
print(f"X shape : {X.shape}")
print(f"y shape : {y.shape}")
print(f"Nombre de classes : {y.nunique()}")

X shape : (333, 4) y shape : (333,) Nombre de classes : 3 ```python from sklearn.model_selection import train_test_split

Split Train/Test

X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.3, random_state=42, stratify=y # Préserve les proportions de classes )

print(f”Training set : {len(X_train)} échantillons”) print(f”Test set : {len(X_test)} échantillons”)

> Training set : 233 échantillons
> Test set : 100 échantillons

**Propriété du paramètre `stratify`** : Assure que les proportions de chaque classe sont maintenues dans train et test.

### Stratégies pour la classification multi-classes

La plupart des algorithmes de classification sont naturellement **binaires** (deux classes). Comment gérer n classes ?

Deux stratégies principales :

| Stratégie | Principe | Nombre de modèles | Décision finale |
|-----------|----------|-------------------|-----------------|
| **One-vs-Rest (OvR)** | Une classe vs toutes les autres | n | Score le plus élevé |
| **One-vs-One (OvO)** | Chaque paire de classes | n(n-1)/2 | Vote majoritaire |

#### One-vs-Rest (OvR) / One-vs-All (OvA)

**Définition** : Entraîner un classificateur binaire pour chaque classe contre toutes les autres.

**Processus** :
1. Pour la classe 1 : Entraîner un modèle "Classe 1 vs (Classe 2 + Classe 3)"
2. Pour la classe 2 : Entraîner un modèle "Classe 2 vs (Classe 1 + Classe 3)"
3. Pour la classe 3 : Entraîner un modèle "Classe 3 vs (Classe 1 + Classe 2)"

**Prédiction** : Choisir la classe avec le **score le plus élevé** parmi les n modèles.

┌──────────────────────────────────────────────┐ │ Classificateur 1: Adelie vs (Chinstrap+Gentoo) │ │ Score: 0.85 │ ├──────────────────────────────────────────────┤ │ Classificateur 2: Chinstrap vs (Adelie+Gentoo) │ │ Score: 0.32 │ ├──────────────────────────────────────────────┤ │ Classificateur 3: Gentoo vs (Adelie+Chinstrap) │ │ Score: 0.21 │ └──────────────────────────────────────────────┘ ↓ Prédiction: Adelie (score max)

**Propriétés** :
- ✅ Simple à implémenter
- ✅ Efficace computationnellement (n modèles)
- ❌ Classes déséquilibrées dans chaque modèle binaire

#### One-vs-One (OvO)

**Définition** : Entraîner un classificateur binaire pour **chaque paire** de classes.

**Nombre de modèles** : $\frac{n(n-1)}{2}$ où n = nombre de classes

Pour 3 classes : $\frac{3 \times 2}{2} = 3$ modèles

**Processus** :
1. Modèle 1 : Adelie vs Chinstrap
2. Modèle 2 : Adelie vs Gentoo
3. Modèle 3 : Chinstrap vs Gentoo

**Prédiction** : Chaque modèle vote pour une classe, la classe avec le **plus de votes** gagne.

┌────────────────────────────────┐ │ Modèle 1: Adelie vs Chinstrap │ │ Vote: Adelie │ ├────────────────────────────────┤ │ Modèle 2: Adelie vs Gentoo │ │ Vote: Adelie │ ├────────────────────────────────┤ │ Modèle 3: Chinstrap vs Gentoo │ │ Vote: Gentoo │ └────────────────────────────────┘ ↓ Votes: Adelie=2, Chinstrap=0, Gentoo=1 ↓ Prédiction: Adelie (majorité)

**Propriétés** :
- ✅ Classes équilibrées dans chaque modèle binaire
- ✅ Souvent plus précis pour petits datasets
- ❌ Coût computationnel élevé ($O(n^2)$ modèles)
- ❌ Temps de prédiction plus long

#### Comparaison OvR vs OvO

| Critère | One-vs-Rest | One-vs-One |
|---------|-------------|------------|
| **Nb de modèles (3 classes)** | 3 | 3 |
| **Nb de modèles (10 classes)** | 10 | 45 |
| **Temps d'entraînement** | Rapide | Lent pour beaucoup de classes |
| **Équilibre des classes** | Déséquilibré (1 vs n-1) | Équilibré (1 vs 1) |
| **Précision** | Bonne | Souvent meilleure |
| **Sklearn défaut** | Oui (pour la plupart) | Non |

### Implémentation avec Scikit-learn

#### Logistic Regression Multi-classes

**Propriété** : `LogisticRegression` de sklearn gère automatiquement le multi-classes avec OvR par défaut.
```python
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report

# Instancier le modèle
model_ovr = LogisticRegression(multi_class='ovr', max_iter=1000)

# Entraîner
model_ovr.fit(X_train, y_train)

# Prédire
y_pred_ovr = model_ovr.predict(X_test)

# Évaluer
accuracy_ovr = accuracy_score(y_test, y_pred_ovr)
print(f"Accuracy (OvR) : {accuracy_ovr:.3f}")

Accuracy (OvR) : 0.970

Rapport de classification détaillé :

print(classification_report(y_test, y_pred_ovr))

          precision    recall  f1-score   support

  Adelie       0.98      0.98      0.98        46    Chinstrap       0.95      0.95      0.95        19
  Gentoo       0.97      0.97      0.97        35

accuracy                           0.97       100    macro avg       0.97      0.97      0.97       100 weighted avg       0.97      0.97      0.97       100

Interprétation :

• Precision : Parmi les prédictions “Adelie”, 98% sont correctes
• Recall : Parmi les vrais “Adelie”, 98% sont détectés
• F1-score : Moyenne harmonique de precision et recall
• Support : Nombre d’échantillons par classe

One-vs-One explicite

# Forcer la stratégie OvO
model_ovo = LogisticRegression(multi_class='ovr', max_iter=1000)

# Alternative : Wrapper explicite
from sklearn.multiclass import OneVsOneClassifier
from sklearn.svm import SVC

model_ovo_svm = OneVsOneClassifier(SVC(kernel='linear'))
model_ovo_svm.fit(X_train, y_train)

y_pred_ovo = model_ovo_svm.predict(X_test)

accuracy_ovo = accuracy_score(y_test, y_pred_ovo)
print(f"Accuracy (OvO avec SVM) : {accuracy_ovo:.3f}")

Accuracy (OvO avec SVM) : 0.980

Propriété : OneVsOneClassifier est un wrapper qui peut s’appliquer à n’importe quel classificateur binaire.

Visualisation des frontières de décision

Objectif : Visualiser comment le modèle sépare les trois espèces dans l’espace des features.

Simplification : Utiliser seulement 2 features pour la visualisation 2D.

from sklearn.preprocessing import StandardScaler
import numpy as np

# Sélectionner 2 features pour visualisation
X_2d = penguins_clean[['bill_length_mm', 'bill_depth_mm']]
y = penguins_clean['species']

# Standardiser (important pour SVM)
scaler = StandardScaler()
X_2d_scaled = scaler.fit_transform(X_2d)

# Split
X_train_2d, X_test_2d, y_train_2d, y_test_2d = train_test_split(
    X_2d_scaled, y, test_size=0.3, random_state=42, stratify=y
)

# Entraîner un SVM
from sklearn.svm import SVC
model_2d = SVC(kernel='rbf', gamma='auto')
model_2d.fit(X_train_2d, y_train_2d)

# Créer une grille pour visualiser les frontières
h = 0.02  # Pas de la grille
x_min, x_max = X_2d_scaled[:, 0].min() - 1, X_2d_scaled[:, 0].max() + 1
y_min, y_max = X_2d_scaled[:, 1].min() - 1, X_2d_scaled[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))

# Prédire sur la grille
Z = model_2d.predict(np.c_[xx.ravel(), yy.ravel()])
Z = pd.Categorical(Z).codes  # Convertir en codes numériques
Z = Z.reshape(xx.shape)

# Tracer
plt.figure(figsize=(12, 8))
plt.contourf(xx, yy, Z, alpha=0.3, cmap='viridis')

# Tracer les points d'entraînement
colors = {'Adelie': 'red', 'Chinstrap': 'blue', 'Gentoo': 'green'}
for species in penguins_clean['species'].unique():
    subset = penguins_clean[penguins_clean['species'] == species]
    subset_scaled = scaler.transform(subset[['bill_length_mm', 'bill_depth_mm']])
    plt.scatter(subset_scaled[:, 0], subset_scaled[:, 1],
                c=colors[species], label=species,
                edgecolors='k', s=100, alpha=0.7)

plt.xlabel('Longueur du bec (standardisée)', fontsize=12)
plt.ylabel('Profondeur du bec (standardisée)', fontsize=12)
plt.title('Frontières de décision - Classification des pingouins', fontsize=14)
plt.legend()
plt.show()

Interprétation :

• Les zones colorées représentent les régions où le modèle prédit chaque classe
• Les points sont les données d’entraînement
• Les frontières séparent les régions de décision

Matrice de confusion

Définition : Tableau croisé montrant les prédictions vs les vraies classes.

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

# Calculer la matrice de confusion
cm = confusion_matrix(y_test, y_pred_ovr, labels=model_ovr.classes_)

# Visualiser
disp = ConfusionMatrixDisplay(confusion_matrix=cm,
                               display_labels=model_ovr.classes_)
disp.plot(cmap='Blues', values_format='d')
plt.title('Matrice de confusion - Pingouins')
plt.show()

Lecture :

              Prédictions
              Adelie  Chinstrap  Gentoo
Vraies Adelie    45        1        0
     Chinstrap    0       18        1
       Gentoo     1        0       34

Interprétation :

• Diagonale : Prédictions correctes
• Hors diagonale : Erreurs
• 1 Adelie prédit comme Chinstrap
• 1 Chinstrap prédit comme Gentoo
• 1 Gentoo prédit comme Adelie

Probabilités de prédiction

Propriété : Les classificateurs sklearn peuvent retourner des probabilités d’appartenance à chaque classe.

# Probabilités pour les 5 premiers échantillons du test set
probas = model_ovr.predict_proba(X_test[:5])

# Créer un DataFrame pour affichage
proba_df = pd.DataFrame(
    probas,
    columns=model_ovr.classes_,
    index=[f"Échantillon {i+1}" for i in range(5)]
)

print(proba_df.round(3))

         Adelie  Chinstrap  Gentoo Échantillon 1   0.981      0.018   0.001 Échantillon 2   0.002      0.125   0.873 Échantillon 3   0.003      0.989   0.008 Échantillon 4   0.975      0.024   0.001 Échantillon 5   0.001      0.005   0.994

Propriétés :

• Chaque ligne somme à 1.0
• Plus la probabilité est proche de 1, plus le modèle est confiant
• Utile pour définir des seuils de décision personnalisés

  # Prédictions avec les vraies classes
  for i in range(5):
    predicted_class = model_ovr.classes_[probas[i].argmax()]
    true_class = y_test.iloc[i]
    confidence = probas[i].max()
  
    print(f"Échantillon {i+1}: Prédit={predicted_class} (confiance={confidence:.1%}), "
          f"Vrai={true_class}")
  

  Échantillon 1: Prédit=Adelie (confiance=98.1%), Vrai=Adelie Échantillon 2: Prédit=Gentoo (confiance=87.3%), Vrai=Gentoo Échantillon 3: Prédit=Chinstrap (confiance=98.9%), Vrai=Chinstrap Échantillon 4: Prédit=Adelie (confiance=97.5%), Vrai=Adelie Échantillon 5: Prédit=Gentoo (confiance=99.4%), Vrai=Gentoo

Algorithmes natifs multi-classes

Certains algorithmes gèrent naturellement le multi-classes sans stratégie OvR/OvO :

Exemple avec Random Forest :

from sklearn.ensemble import RandomForestClassifier

# Random Forest gère nativement le multi-classes
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)

y_pred_rf = rf_model.predict(X_test)
accuracy_rf = accuracy_score(y_test, y_pred_rf)

print(f"Accuracy (Random Forest) : {accuracy_rf:.3f}")

Accuracy (Random Forest) : 0.990

Avantage : Pas besoin de wrapper, plus efficace computationnellement.

Application en chimie computationnelle

1. Classification de familles de molécules
   • Classes : Alcanes, Alcènes, Aromatiques, Hétérocycles
   • Features : Descripteurs moléculaires (MW, LogP, HBD, HBA)
2. Prédiction de types de réactions
   • Classes : Substitution, Addition, Élimination, Réarrangement
   • Features : Groupes fonctionnels, électronégativité, encombrement stérique
3. Classification de spectres
   • Classes : Composés purs identifiés
   • Features : Pics d’absorption, intensités
4. Prédiction de toxicité
   • Classes : Non-toxique, Faible, Modéré, Élevé
   • Features : Structure moléculaire, propriétés physico-chimiques

Code template pour classification chimique :

from rdkit import Chem
from rdkit.Chem import Descriptors
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_validate

# Calculer descripteurs depuis SMILES
def compute_descriptors(smiles):
    mol = Chem.MolFromSmiles(smiles)
    if mol is None:
        return None
    return {
        'MW': Descriptors.MolWt(mol),
        'LogP': Descriptors.MolLogP(mol),
        'HBD': Descriptors.NumHDonors(mol),
        'HBA': Descriptors.NumHAcceptors(mol),
        'TPSA': Descriptors.TPSA(mol),
        'RotBonds': Descriptors.NumRotatableBonds(mol)
    }

# Exemple de workflow
# df_molecules['descriptors'] = df_molecules['SMILES'].apply(compute_descriptors)
# X = pd.DataFrame(df_molecules['descriptors'].tolist())
# y = df_molecules['famille_chimique']
#
# model = RandomForestClassifier(n_estimators=200, random_state=42)
# cv_results = cross_validate(model, X, y, cv=5)
# print(f"Accuracy moyenne : {cv_results['test_score'].mean():.3f}")

Récapitulatif

Concepts clés :

• Classification multi-classes : n > 2 classes
• One-vs-Rest : n modèles binaires, score maximal
• One-vs-One : n(n-1)/2 modèles, vote majoritaire
• Algorithmes natifs multi-classes : plus efficaces

Dataset Palmer Penguins :

• 3 espèces (Adelie, Chinstrap, Gentoo)
• 4 features morphologiques
• Excellent exemple pédagogique

Métriques :

• Accuracy globale
• Precision/Recall/F1 par classe
• Matrice de confusion
• Probabilités de prédiction

Sklearn :

• multi_class='ovr' ou 'multinomial'
• OneVsOneClassifier wrapper
• predict_proba() pour probabilités
• classification_report() détaillé

Préparation des données

• 📚 Sklearn Preprocessing Guide
• 📚 Imbalanced-learn Documentation
• 📖 Feature Engineering for Machine Learning (A. Zheng & A. Casari)

La préparation des données est souvent considérée comme l’étape la plus chronophage du Machine Learning, représentant 60-80% du temps total d’un projet.

Trois raisons fondamentales au data pré-processing :

1. Les données b rutes peuvent être sales et bruitées
   • Valeurs manquantes
   • Doublons
   • Erreurs de saisie
   • Outliers
2. Contraintes algorithmiques
   • Certains algorithmes n’acceptent que des valeurs numériques,
   • sont sensibles aux échelles,
   • ou supposent des distributions spécifiques
3. Amélioration des performances
   • Transformations appropriées → Meilleur apprentissage
   • Feature engineering → Signaux plus forts
   • Sélection de features → Réduction du bruit

Dataset d’exemple utilisé dans cette partie

Pipeline de préparation

Workflow complet :

Data Exploration
    ↓
Deduplicate (Supprimer doublons)
    ↓
Missing Data (Gérer valeurs manquantes)
    ↓
Outliers (Traiter valeurs aberrantes)
    ↓
Scaling (Normaliser les échelles)
    ↓
Balancing (Équilibrer les classes)
    ↓
Encoding / Discretizing / Feature Creation
    ↓
Feature Correlation (Analyse)
    ↓
Modeling
    ↓
Feature Selection (Permutation)
    ↓
Remodel (Itération)

Duplicates

Une ligne dupliquée est une copie exacte d’une autre ligne dans le dataset.

Impact sur l’évaluation :

• Fausse l’évaluation de la généralisation
• Peut créer du data leakage si présent dans train ET test
• Gonfle artificiellement les scores

Exemple :

data[["GrLivArea", "SalePrice"]].head(10)

Data Leakage

Scénario problématique :

1. Dataset contient des doublons
2. Split train/test aléatoire
3. Même observation dans train ET test
4. Le modèle a “déjà vu” les données de test !
5. Score artificiellement élevé

Propriété : Pour évaluer la généralisation, les données du test set doivent être totalement inédites pendant l’entraînement.

Détection et suppression

Détection :

# Nombre de lignes avant
print(f"Nombre de lignes : {len(data)}")

Nombre de lignes : 1760

# Vérifier si chaque ligne est un doublon
print(data.duplicated())

0 False 1 False 2 False 3 False … 1755 True 1756 True 1757 True 1758 True 1759 True Length: 1760, dtype: bool

# Compter le nombre total de doublons
print(f"Nombre de doublons : {data.duplicated().sum()}")

Nombre de doublons : 303

Suppression :

# Supprimer les doublons
data = data.drop_duplicates()

# Vérifier le nouveau nombre de lignes
print(f"Nombre de lignes après nettoyage : {len(data)}")

Nombre de lignes après nettoyage : 1457

Propriété : drop_duplicates() garde la première occurrence et supprime les suivantes.

Missing Data

Causes et représentations courantes

Raisons des valeurs manquantes :

Valeurs manquantes déguisées :

• NaN (Not a Number) - Standard
• 999 ou -999 (Nombres suspects)
• ? (Caractère interrogation)
• ±∞ (Valeurs infinies)
• "" (Chaîne vide)
• NULL, None, NA

⚠️ Toujours explorer les données pour détecter ces représentations !

Détection

Comptage par colonne :

# Nombre de NaN par colonne (ordre décroissant)
missing_counts = data.isnull().sum().sort_values(ascending=False)
print(missing_counts)

WallMat 1452 Alley 1367 Pesos 10 GrLivArea 0 BedroomAbvGr 0 KitchenAbvGr 0 OverallCond 0 Street 0 SalePrice 0 dtype: int64

Pourcentage de valeurs manquantes :

# Pourcentage par colonne
missing_pct = (data.isnull().sum() / len(data)).sort_values(ascending=False)
print(missing_pct)

WallMat 0.997 (99.7% !) Alley 0.938 (93.8%) Pesos 0.007 (0.7%) GrLivArea 0.000 … dtype: float64

Stratégies de traitement

Questions à se poser :

1. Quelle est la cause des valeurs manquantes ?
2. Les valeurs manquantes racontent-elles une histoire ?
3. Puis-je les remplacer par une autre valeur ?
4. Puis-je me permettre de perdre ces données ?

⚠️ Connaissance du domaine : Essentielle pour choisir la bonne stratégie !

Cas 1 : WallMat (>99% manquant)

# Pourcentage de valeurs manquantes
pct_missing = data.WallMat.isnull().sum() / len(data)
print(f"WallMat : {pct_missing:.1%} manquant")

WallMat : 99.7% manquant

Décision : Supprimer la feature (trop de valeurs manquantes)

# Supprimer la colonne
data = data.drop(columns='WallMat')

Règle empirique : >30% manquant → Considérer suppression

Cas 2 : Alley (~94% manquant)

# Pourcentage de valeurs manquantes
pct_missing = data.Alley.isnull().sum() / len(data)
print(f"Alley : {pct_missing:.1%} manquant")

Alley : 93.8% manquant

Attention : Valeur manquante ≠ Absence d’information !

Interprétation : NaN signifie ici “la maison n’a pas d’allée”.

Solution : Remplacer par une catégorie explicite

# Remplacer NaN par "NoAlley"
data.Alley = data.Alley.replace(np.nan, "NoAlley")

# Vérifier les catégories
print(data.Alley.value_counts())

NoAlley 1367 Grvl 50 Pave 40 Name: Alley, dtype: int64

Propriété : Le NaN devient une information utile !

Cas 3 : Pesos (<1% manquant)

# Pourcentage de valeurs manquantes
pct_missing = data.Pesos.isnull().sum() / len(data)
print(f"Pesos : {pct_missing:.1%} manquant")

Pesos : 0.7% manquant

Deux options :

Option 1 : Supprimer les lignes

# Supprimer les lignes où Pesos est manquant
data_clean = data.dropna(subset=['Pesos'])

Option 2 : Imputer (remplacer) les valeurs

# Remplacer par la moyenne
data.Pesos = data.Pesos.replace(np.nan, data.Pesos.mean())

Comparaison des options :

Règles empiriques

==Imputer = Approximation → Peut introduire bruit et biais==

SimpleImputer de Scikit-learn

Outil pour remplacer les valeurs manquantes selon une stratégie.

Stratégies disponibles :

Implémentation :

from sklearn.impute import SimpleImputer

# 1. Instancier avec stratégie
imputer = SimpleImputer(strategy="mean")

# 2. Fit : Calculer la moyenne
imputer.fit(data[['Pesos']])

# 3. Transform : Appliquer la transformation
data['Pesos'] = imputer.transform(data[['Pesos']])

# Valeur stockée (moyenne)
print(f"Moyenne calculée : {imputer.statistics_[0]:,.0f}")

Moyenne calculée : 3,608,796

Fonctionnement interne :

.fit() :

1. Calcule la statistique (moyenne, médiane, etc.)
2. Stocke la valeur comme attribut

.transform() :

1. Identifie les valeurs manquantes
2. Les remplace par la valeur calculée dans .fit()

Propriété importante : Pattern fit/transform = Standard sklearn pour les transformateurs

Outliers

Points de données qui dévient significativement du reste des données.

Causes courantes :

Impact des outliers

Effets :

• Distributions : Distorsion des patterns
• Tendance centrale : Moyenne biaisée
• Dispersion : Écart-type gonflé
• Performance ML : Modèle perturbé

Exemple d’impact :

# Dataset sans outlier
data_normal = [10, 12, 11, 13, 12, 11, 10, 13]
print(f"Moyenne : {np.mean(data_normal):.1f}")

Moyenne : 11.5

# Même dataset avec un outlier
data_with_outlier = [10, 12, 11, 13, 12, 11, 10, 1000]
print(f"Moyenne : {np.mean(data_with_outlier):.1f}")

Moyenne : 135.9

Détection visuelle : Boxplot

Outil principal : Le boxplot (boîte à moustaches)

import matplotlib.pyplot as plt

# Boxplot de GrLivArea
data[['GrLivArea']].boxplot()
plt.title('Distribution de la surface habitable')
plt.ylabel('Surface (ft²)')
plt.show()

Lecture d’un boxplot :

         │
    ○    │  ← Outlier extrême
         │
    ●    │  ← Outlier léger
    ┬────┤  ← Moustache supérieure (Q3 + 1.5×IQR)
    │    │
    ├────┤  ← Q3 (75e percentile)
    │////│  ← Médiane (Q2, 50e percentile)
    ├────┤  ← Q1 (25e percentile)
    │    │
    ┴────┤  ← Moustache inférieure (Q1 - 1.5×IQR)
         │
    ●    │  ← Outlier

IQR (Interquartile Range) : $IQR = Q3 - Q1$

Ressources :

• 📚 pandas.DataFrame.boxplot
• 📚 matplotlib.pyplot.boxplot
• 📚 seaborn.boxplot

Investigation des outliers

Question clé : Tous les outliers sont-ils de “vrais” outliers ?

# Valeur minimale
print(f"Surface minimale : {data['GrLivArea'].min()} ft²")

Surface minimale : -1 ft²

Une surface de -1 ft² est physiquement impossible !

Traitement des outliers

Questions à se poser :

1. L’outlier est-il évidemment faux ?
2. Pourrait-il être une nouveauté légitime ?
3. Pourrait-il être utilisé comme feature ?

→ Les outliers peuvent être subjectifs. Comprendre avant de supprimer !

Cas 1 : Valeur manifestement fausse

# Identifier la ligne problématique
print(data['GrLivArea'] == -1)

0 False 1 False … 1455 False dtype: bool

Cas 2 : Valeurs extrêmes mais possibles

→ Définir des seuils raisonnables

# Créer un masque booléen
# Garder uniquement : 0 < surface < 5000 ft²
mask = (data['GrLivArea'] > 0) & (data['GrLivArea'] < 5000)

# Appliquer le filtre
data = data[mask].reset_index(drop=True)

# Vérifier le résultat
data[['GrLivArea']].boxplot()
plt.title('Distribution après nettoyage')
plt.show()

Propriété : reset_index(drop=True) réinitialise les indices après filtrage.

Scaling

Le feature scaling est le processus de transformation des features numériques vers une échelle commune plus petite.

Pourquoi scaler ?

Exemple de problème :

→ Pesos a des valeurs ~1000x plus grandes que GrLivArea. → Un algorithme basé sur les distances (KNN, SVM) sera biaisé vers Pesos.

Features numériques du dataset

data.head(3)

Features numériques : GrLivArea, BedroomAbvGr, KitchenAbvGr, OverallCond, Pesos

Conversion : 1 USD ≈ 20 Pesos (exemple de taux utilisé)

Les trois scalers principaux

StandardScaler

→ Distribution centrée sur 0 avec écart-type de 1.

Efficace pour features normalement distribuées Pas d’échelle exacte commune, mais ~99% dans [-3, +3] Sensible aux outliers (moyenne et std affectés) Distorsion possible des distances relatives

Quand l’utiliser :

• Features gaussiennes
• Régression linéaire, réseaux de neurones
• Par défaut pour débuter rapidement

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Pour retrouver les moyennes et écarts-types
scaler.mean_, scaler.scale_

Effet visuel :

MinMaxScaler

Méthode aussi appelée “Normalisation”.

→ Toutes les valeurs compressées dans [0, 1].

Échelle fixe garantie [0, 1] Ne réduit pas l’effet des outliers Préserve la sparsité (0 reste 0)

Quand l’utiliser :

• Features ordinales (ex: scores 1-5)
• Features positives ou matrices creuses (ex: pixels RGB 0-255)
• Algorithme KNN (K-Nearest Neighbors)

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler(feature_range=(0, 1))
X_scaled = scaler.fit_transform(X)

# Pour retrouver les bornes utilisées
scaler.data_min_, scaler.data_max_

Effet visuel :

RobustScaler

Où $IQR = Q3 - Q1$ (Interquartile Range)

Résistant aux outliers (médiane et IQR moins sensibles) Préserve les patterns sans être influencé par les extrêmes

Quand l’utiliser :

• Features avec outliers qu’on ne veut/peut pas supprimer
• Features très asymétriques (skewed)

from sklearn.preprocessing import RobustScaler

scaler = RobustScaler()
X_scaled = scaler.fit_transform(X)

# Pour retrouver la médiane et l'IQR
scaler.center_, scaler.scale_

Tableau comparatif et règles de décision des scalers

Arbre de décision pour le scaling :

Feature très asymétrique (skewed) ?
    ↓ OUI
Feature Engineering d'abord (ex: log)
    ↓ Si toujours problème
RobustScaler
    ↓
Sinon (distribution raisonnable)
    ↓
Feature positive / Matrice creuse ?
    ↓ OUI
MinMaxScaler
    ↓ NON
StandardScaler (défaut sûr)

Résumé des règles :

⚠️ Toute règle a des exceptions ! Toujours expérimenter.

Application dans l’exemple : GrLivArea

Exploration de la distribution

import seaborn as sns
import matplotlib.pyplot as plt

# Distribution de GrLivArea
sns.histplot(data['GrLivArea'], bins=200, kde=True)
plt.title('Distribution de la surface habitable')
plt.xlabel('Surface (ft²)')
plt.show()

→ Distribution légèrement asymétrique avec quelques valeurs élevées.

Détection des outliers

# Boxplot
sns.boxplot(data=data, x='GrLivArea')
plt.title('Outliers dans GrLivArea')
plt.show()

Observation : Présence de quelques outliers (points au-delà des moustaches).

Choix du scaler

Quel scaler appliquer à GrLivArea ?

Analyse :

• Distribution pas parfaitement gaussienne ❌ StandardScaler non optimal
• Présence d’outliers ✅ RobustScaler recommandé
• Pas de contrainte [0,1] nécessaire ❌ MinMaxScaler pas prioritaire

→ RobustScaler

Implémentation

from sklearn.preprocessing import RobustScaler

# Étape 0 : Instancier
rb_scaler = RobustScaler()

# Étape 1 : Fit (apprendre médiane et IQR)
rb_scaler.fit(data[['GrLivArea']])

# Afficher les valeurs apprises
print(f"Médiane : {rb_scaler.center_[0]:.0f}")
print(f"IQR : {rb_scaler.scale_[0]:.0f}")

# Étape 2 : Transform (appliquer la transformation)
data['GrLivArea'] = rb_scaler.transform(data[['GrLivArea']])

data.head()

Médiane : 1464 IQR : 555

Interprétation :

• Ligne 0 : Surface 0.38 IQR au-dessus de la médiane
• Ligne 1 : Surface 0.31 IQR en-dessous de la médiane

Dataset Balancing

Un dataset est déséquilibré (imbalanced) quand certaines classes sont sur-représentées ou sous-représentées.

Exemples :

Ressources :

• A. King & E. Puyol-Antón - AI Models can be racially biased
• Focus2030 - Gender equality data

Pourquoi équilibrer ?

Les algorithmes ML apprennent par l’exemple.

Problème :

• Classe minoritaire sous-représentée → Modèle apprend mal
• Modèle biaisé vers la classe majoritaire
• Prédictions erronées sur la classe minoritaire

Seuil de déséquilibre : Un ratio 70/30 peut déjà être considéré comme problématique en classification binaire.

Exemple :

# Dataset déséquilibré
class_counts = pd.Series([90, 10], index=['Classe A', 'Classe B'])
print(class_counts)

Classe A 90 Classe B 10

Conséquence : Un modèle “stupide” qui prédit toujours “Classe A” aura 90% d’accuracy !

Stratégies d’équilibrage

Deux approches principales :

🔗 Source

Comparaison :

Protocole d’oversampling

⚠️ ATTENTION : Ordre des opérations crucial pour éviter le data leakage !

Protocole correct :

1. Split Train/Test AVANT oversampling
2. Oversample UNIQUEMENT le train set
3. Évaluer sur le test set SANS oversampling

• Train : Le modèle doit apprendre la classe minoritaire → Oversampling OK
• Test : Doit refléter la vraie distribution → Pas d’oversampling

Erreur commune :

# ❌ MAUVAIS : Oversampling avant split
X_oversampled, y_oversampled = oversample(X, y)
X_train, X_test, y_train, y_test = train_test_split(X_oversampled, y_oversampled)

# Problème : Test set contient des duplicata → Data leakage !

Bonne pratique :

# ✅ BON : Split puis oversampling
X_train, X_test, y_train, y_test = train_test_split(X, y)
X_train_over, y_train_over = oversample(X_train, y_train)

# Test set reste authentique

SMOTE (Synthetic Minority Oversampling Technique)

SMOTE est un algorithme d’oversampling qui génère de nouvelles instances de la classe minoritaire par interpolation linéaire.

Principe :

1. Choisir un point minoritaire $x_i$
2. Trouver ses $k$ plus proches voisins (même classe)
3. Choisir aléatoirement un voisin $x_{nn}$
4. Créer un nouveau point entre $x_i$ et $x_{nn}$ :

où $\lambda \in [0, 1]$ est aléatoire.

Visualisation :

🔗 Source

Avantages :

• Crée des instances synthétiques (pas de duplication exacte)
• Réduit le risque d’overfitting vs simple duplication
• Points créés dans des régions “plausibles”

Implémentation :

# Installation nécessaire
# !pip install imbalanced-learn

from imblearn.over_sampling import SMOTE
from sklearn.model_selection import train_test_split

# Split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Distribution avant SMOTE
print(f"Train avant SMOTE: {pd.Series(y_train).value_counts()}")

# Instancier SMOTE
smote = SMOTE(random_state=42)

# Appliquer SMOTE sur train uniquement
X_train_balanced, y_train_balanced = smote.fit_resample(X_train, y_train)

# Distribution après SMOTE
print(f"Train après SMOTE: {pd.Series(y_train_balanced).value_counts()}")

Train avant SMOTE: 0 630 1 70

Train après SMOTE: 0 630 1 630

Propriété : La bibliothèque imbalanced-learn (import imblearn) s’appuie sur scikit-learn.

Encoding

L’encodage consiste à transformer des données non-numériques en une forme numérique équivalente.

Pourquoi encoder ?

OrdinalEncoder

OrdinalEncoder assigne un nombre à chaque catégorie.

Exemple : Feature “qualité”

example = pd.DataFrame({
    "classes": ["bad", "average", "average", "good", "good", "bad", "good"]
})
print(example)

Encodage par défaut (ordre alphabétique) :

from sklearn.preprocessing import OrdinalEncoder

# Instancier
ordinal_encoder = OrdinalEncoder()

# Fit
ordinal_encoder.fit(example[["classes"]])

# Catégories détectées
print(f"Catégories : {ordinal_encoder.categories_}")

# Transform
example["encoded_classes"] = ordinal_encoder.transform(example[["classes"]])
print(example)

Catégories : [array([‘average’, ‘bad’, ‘good’], dtype=object)]

Problème : Ordre alphabétique ! On voudrait bad=0, average=1, good=2.

Encodage avec ordre spécifié :

# Spécifier l'ordre logique
ordinal_encoder = OrdinalEncoder(categories=[["bad", "average", "good"]])

ordinal_encoder.fit(example[["classes"]])
example["encoded_classes"] = ordinal_encoder.transform(example[["classes"]])
print(example)

Quand utiliser OrdinalEncoder :

✅ Variables ordinales (ordre intrinsèque)

• Qualité : Mauvais < Moyen < Bon
• Éducation : Primaire < Secondaire < Supérieur
• Taille : S < M < L < XL

❌ Variables nominales (pas d’ordre)

• Types d’arbres : Chêne, Pin, Érable
• Couleurs : Rouge, Vert, Bleu
• Pays : France, USA, Japon

Problème avec les nominales :

Si on encode Chêne=0, Pin=1, Érable=2, on crée une fausse relation d’ordre :

• Le modèle pense que Érable > Pin > Chêne
• Aucun sens !

Solution : OneHotEncoder

OneHotEncoder

Créer une colonne binaire pour chaque catégorie possible.

Principe :

Avantages :

• Pas de relation d’ordre artificielle
• Chaque catégorie est indépendante
• Fonctionne pour variables nominales

Application : Alley (3 catégories)

from sklearn.preprocessing import OneHotEncoder

# Valeurs uniques
print(f"Valeurs uniques : {data.Alley.unique()}")

Valeurs uniques : [‘NoAlley’ ‘Grvl’ ‘Pave’] ```python

Instancier

ohe = OneHotEncoder(sparse_output=False)

Fit

ohe.fit(data[[‘Alley’]])

Catégories détectées

print(f”Catégories : {ohe.categories_}”)

> Catégories : [array(['Grvl', 'NoAlley', 'Pave'], dtype=object)]
```python
# Noms des nouvelles colonnes
print(f"Colonnes générées : {ohe.get_feature_names_out()}")

Colonnes générées : [‘Alley_Grvl’ ‘Alley_NoAlley’ ‘Alley_Pave’] ```python

Transform et ajouter au DataFrame

data[ohe.get_feature_names_out()] = ohe.transform(data[[‘Alley’]])

Supprimer la colonne originale

data = data.drop(columns=[“Alley”])

data.head(3)

| | GrLivArea | ... | SalePrice | Alley_Grvl | Alley_NoAlley | Alley_Pave |
|---|---|---|---|---|---|---|
| 0 | 0.380 | ... | 208500 | 0.0 | 1.0 | 0.0 |
| 1 | -0.312 | ... | 181500 | 0.0 | 1.0 | 0.0 |
| 2 | 0.498 | ... | 223500 | 0.0 | 1.0 | 0.0 |

**Interprétation** :
- Ligne 0 : `Alley_NoAlley=1` → Cette maison n'a pas d'allée
- Chaque ligne a exactement un `1` et deux `0` (exclusif)

#### Application : Street (2 catégories - Binaire)
```python
# Valeurs uniques
print(f"Valeurs uniques : {data.Street.unique()}")

Valeurs uniques : [‘Pave’ ‘Grvl’]

Optimisation pour binaire : drop='if_binary'

Propriété : Pour une variable binaire, une seule colonne suffit !

• Street_Pave = 0 → Grvl
• Street_Pave = 1 → Pave ```python

  Instancier avec drop

  ohe_binary = OneHotEncoder(sparse_output=False, drop=”if_binary”)

ohe_binary.fit(data[[‘Street’]]) print(f”Colonnes générées : {ohe_binary.get_feature_names_out()}”)

> Colonnes générées : ['Street_Pave']
```python
# Transform
data[ohe_binary.get_feature_names_out()] = ohe_binary.transform(data[['Street']])
data = data.drop(columns=["Street"])

data.head(3)

Économie : 1 colonne au lieu de 2 pour variable binaire !

LabelEncoder (Pour la target)

Encoder une target catégorielle (pas les features).

Exemple : Prédire l’espèce de pingouins

import seaborn as sns

# Charger dataset
penguins = sns.load_dataset("penguins")
target = penguins["species"]

print(target.value_counts())

Adelie 152 Gentoo 124 Chinstrap 68 Name: species, dtype: int64

Encodage :

from sklearn.preprocessing import LabelEncoder

# Instancier
label_encoder = LabelEncoder()

# Fit
label_encoder.fit(target)

# Classes encodées
print(f"Classes : {label_encoder.classes_}")

Classes : [‘Adelie’ ‘Chinstrap’ ‘Gentoo’] ```python

Transform

encoded_target = label_encoder.transform(target)

Comparaison

comparison = pd.DataFrame({ “target”: target, “encoded_target”: encoded_target }).sample(10) print(comparison)

| | target | encoded_target |
|---|---|---|
| 128 | Adelie | 0 |
| 275 | Gentoo | 2 |
| 215 | Chinstrap | 1 |
| 141 | Adelie | 0 |

**Décodage (inverse)** :
```python
# Revenir à l'original
original_target = label_encoder.inverse_transform(encoded_target)

pd.DataFrame({
    "encoded_target": encoded_target,
    "original_target": original_target,
    "target": target
}).sample(5)

💡 Important : Dans la plupart des cas, pas besoin d’encoder la target !

La plupart des modèles sklearn gèrent automatiquement l’encodage interne des targets catégorielles.

Règle : Essayez d’abord sans encoder la target. Encodez seulement si le modèle l’exige explicitement.

Discretizing

La discrétisation est le processus de transformation de données continues en données discrètes via des bins (intervalles).

Usages :

📚 pandas.cut() documentation

Exemple : SalePrice

Objectif : Au lieu de prédire le prix exact (régression), classifier comme “Cheap” ou “Expensive” (classification).

Stratégie : Utiliser la moyenne comme seuil.

# Créer bins basés sur la moyenne
data['SalePriceBinary'] = pd.cut(
    x=data['SalePrice'],
    bins=[
        data['SalePrice'].min() - 1,    # Début (inclus minimum)
        data['SalePrice'].mean(),       # Seuil
        data['SalePrice'].max() + 1     # Fin (inclus maximum)
    ],
    labels=['cheap', 'expensive']
)

data.head()

Interprétation :

• Prix > Moyenne → expensive
• Prix ≤ Moyenne → cheap

Variantes possibles :

Discrétisation en quartiles :

# Créer 4 catégories (quartiles)
data['SalePriceQuartile'] = pd.qcut(
    x=data['SalePrice'],
    q=4,
    labels=['Q1', 'Q2', 'Q3', 'Q4']
)

Discrétisation personnalisée :

# Seuils personnalisés
data['SalePriceCustom'] = pd.cut(
    x=data['SalePrice'],
    bins=[0, 100000, 200000, 300000, np.inf],
    labels=['Budget', 'Standard', 'Premium', 'Luxe']
)

Feature Engineering

La création de features consiste à introduire de la connaissance du domaine pour générer de nouveaux signaux.

Objectif :

• Créer de l’information supplémentaire
• Améliorer potentiellement les performances du modèle

Exemples de création

Domaine médical :

# Body Mass Index
df['BMI'] = df['weight'] / (df['height'] ** 2)

Domaine temporel :

# Délai entre événements
df['lag_time'] = df['delivered_date'] - df['dispatch_date']

# Extraction de composantes
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day_of_week'] = df['date'].dt.dayofweek

# Catégorisation
df['is_weekend'] = df['day_of_week'].isin([5, 6]).astype(int)

Domaine chimique :

# Descripteurs moléculaires
from rdkit import Chem
from rdkit.Chem import Descriptors

def compute_descriptors(smiles):
    mol = Chem.MolFromSmiles(smiles)
    return {
        'MW': Descriptors.MolWt(mol),
        'LogP': Descriptors.MolLogP(mol),
        'HBD': Descriptors.NumHDonors(mol),
        'HBA': Descriptors.NumHAcceptors(mol),
        'TPSA': Descriptors.TPSA(mol),
        'RotBonds': Descriptors.NumRotatableBonds(mol)
    }

# Appliquer
df_desc = df['SMILES'].apply(compute_descriptors)

Catégories de feature engineering

📚 sklearn.preprocessing - Plus d’outils

Sélection de features

La sélection de features est le processus d’élimination des features “non-informatives”.

Deux types principaux :

Pourquoi sélectionner ?

Garbage In → Garbage Out

Des features de mauvaise qualité produisent :

1. Bruit dans l’apprentissage
2. Instabilité du modèle
3. Sortie inutilisable

Malédiction de la dimensionnalité

Ne pas observer assez de données pour supporter une relation significative.

🔗 Source

Observation : À mesure que le nombre de dimensions augmente, la quantité de données nécessaire croît exponentiellement : $5^1, 5^2, 5^3, …, 5^n$.

🔗 Plus de détails

🚨 Attention au OneHotEncoder : Une feature catégorielle avec beaucoup de catégories génère beaucoup de colonnes !

Exemple :

• Feature “Ville” avec 1000 villes → 1000 colonnes binaires
• Nécessite beaucoup plus de données pour généraliser

Réduction de complexité

Avantages d’un modèle simple :

Feature Correlation

Supprimer une des deux features fortement corrélées entre elles.

Justification : Corrélation élevée entre A et B → Information redondante

Matrice de corrélation (Pearson)

import seaborn as sns

# Calculer la matrice de corrélation
correlation_matrix = data.select_dtypes('number').corr()

# Heatmap
sns.heatmap(
    correlation_matrix,
    xticklabels=correlation_matrix.columns,
    yticklabels=correlation_matrix.columns,
    cmap="bwr",  # Blue-White-Red
    center=0,
    vmin=-1,
    vmax=1
)
plt.title('Matrice de corrélation')
plt.show()

📚 Matplotlib colormaps

Analyse détaillée des corrélations

# Convertir en DataFrame
corr_df = correlation_matrix.stack().reset_index()
corr_df.columns = ['feature_1', 'feature_2', 'correlation']

# Supprimer les auto-corrélations (diagonale)
no_self_corr = (corr_df['feature_1'] != corr_df['feature_2'])
corr_df = corr_df[no_self_corr]

# Valeur absolue
corr_df['absolute_correlation'] = np.abs(corr_df['correlation'])

# Top 10 paires les plus corrélées
top_corr = corr_df.sort_values(
    by="absolute_correlation",
    ascending=False
).head(10)

print(top_corr)

Observation critique : Pesos et SalePrice corrélés à 0.99 !

Data Leakage : Pesos

Analyse :

# Vérifier le taux de change
print(f"Ratio moyen : {(data['Pesos'] / data['SalePrice']).mean():.1f}")

Ratio moyen : 20.0

Explication : Pesos = 20 × SalePrice (taux de change USD → MXN)

🚨 Data Leakage : Pesos contient directement l’information de SalePrice !

Solution : Supprimer Pesos

data = data.drop(columns=['Pesos'])

Modélisation

Maintenant que les données sont préparées, entraînons un modèle de classification.

data.head(3)

Préparation :

from sklearn.preprocessing import LabelEncoder, MinMaxScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score

# Encoder la target
target_encoder = LabelEncoder()
y = target_encoder.fit_transform(data['SalePriceBinary'])

# Features
X = data.drop(columns=['SalePrice', 'SalePriceBinary'])

# Scaler les features numériques (sauf GrLivArea déjà scalée)
minmax_scaler = MinMaxScaler()
X[["BedroomAbvGr", "KitchenAbvGr", "OverallCond"]] = minmax_scaler.fit_transform(
    X[["BedroomAbvGr", "KitchenAbvGr", "OverallCond"]]
)

# Modèle
log_reg = LogisticRegression(max_iter=1000)

# Cross-validation
scores = cross_val_score(log_reg, X, y, cv=10)
print(f"Accuracy moyenne : {scores.mean():.3f}")

Accuracy moyenne : 0.831

Interprétation : ~83% de précision → Semble bon… mais on a encore du Data Leakage !

On a scalé avant le split train/test dans la cross-validation, donc le scaler a “vu” les données du test set → Information leakée

Schéma du problème :

Pourquoi c’est grave ?

1. Scaler calcule min/max ou mean/std sur toutes les données
2. Ces statistiques incluent les données de test
3. Le modèle a indirectement “vu” le test set
4. Performance surestimée

Mauvaise approche : Fit le scaler deux fois

Problème : Statistiques différentes → Échelles incompatibles

Bonne approche :

Solutions :

Option 1 : K-Fold manuelle avec scaling dans la boucle

from sklearn.model_selection import KFold

kf = KFold(n_splits=5)
scores = []

for train_idx, val_idx in kf.split(X):
    # Split
    X_train, X_val = X.iloc[train_idx], X.iloc[val_idx]
    y_train, y_val = y[train_idx], y[val_idx]

    # Scaler sur train uniquement
    scaler = MinMaxScaler()
    X_train_scaled = scaler.fit_transform(X_train)
    X_val_scaled = scaler.transform(X_val)  # Même scaler !

    # Entraîner et évaluer
    model = LogisticRegression(max_iter=1000)
    model.fit(X_train_scaled, y_train)
    score = model.score(X_val_scaled, y_val)
    scores.append(score)

print(f"Accuracy moyenne : {np.mean(scores):.3f}")

Option 2 : Pipelines (recommandé)

→ Voir la partie suivante [[Machine Learning#Workflow]]

Feature Permutation

La permutation de features évalue l’importance de chaque feature en mesurant la dégradation de performance quand on mélange ses valeurs.

Workflow :

1. Entraîner le modèle avec toutes les features
2. Évaluer et enregistrer le score de base
3. Pour chaque feature :
   • Mélanger aléatoirement cette feature dans le test set
   • Évaluer le nouveau score
   • Calculer la baisse de score
4. Features avec grande baisse = importantes

Si mélanger une feature dégrade beaucoup le score, c’est qu’elle est cruciale !

Implémentation

Score de référence :

from sklearn.model_selection import cross_val_score

# Modèle baseline
log_model = LogisticRegression(max_iter=1000)

# Score de référence (cross-validation)
base_score = np.mean(cross_val_score(log_model, X, y, cv=5))
print(f"Score de référence : {base_score:.3f}")

Score de référence : 0.830

Permutation :

from sklearn.inspection import permutation_importance

# Entraîner le modèle
log_model = LogisticRegression(max_iter=1000)
log_model.fit(X, y)

# Permutation (répétée 10 fois pour robustesse)
permutation_score = permutation_importance(
    log_model, X, y,
    n_repeats=10,
    random_state=42
)

# Créer DataFrame des résultats
importance_df = pd.DataFrame({
    'feature': X.columns,
    'score_decrease': permutation_score.importances_mean
})

# Trier par importance
importance_df = importance_df.sort_values(
    by="score_decrease",
    ascending=False
)

print(importance_df)

Interprétation :

• GrLivArea : Feature la plus importante (baisse de 30% quand mélangée)
• Alley_Pave : Négligeable (score_decrease négatif = bruit)

Modèle simplifié

# Sélectionner les 2 features les plus importantes
strongest_features = X[["GrLivArea", "BedroomAbvGr"]]

# Ré-entraîner
log_reg_simple = LogisticRegression(max_iter=1000)
simple_score = np.mean(cross_val_score(log_reg_simple, strongest_features, y, cv=10))

print(f"Score avec 2 features : {simple_score:.3f}")
print(f"Score avec toutes features : {base_score:.3f}")
print(f"Différence : {base_score - simple_score:.3f}")

Score avec 2 features : 0.814 Score avec toutes features : 0.830 Différence : 0.016

Analyse :

• Avec 2 features au lieu de 8 → Perte de seulement 1.6%
• Modèle 4x plus simple !

Récapitulatif

Règles d’or

🚨 Règle 1 : Appliquer les mêmes transformations au train et test set

# ✅ BON
transformer = Transformer()
transformer.fit(X_train)
X_train_transformed = transformer.transform(X_train)
X_test_transformed = transformer.transform(X_test)

# ❌ MAUVAIS
transformer.fit(X_train)
X_train_transformed = transformer.transform(X_train)
transformer.fit(X_test)  # ⚠️ Re-fit !
X_test_transformed = transformer.transform(X_test)

🚨 Règle 2 : Ne jamais fit les transformateurs sur le test set !

🚨 Règle 3 : Attention aux biais humains introduits pendant le preprocessing

Exemples de biais :

• Choix subjectifs de seuils
• Suppression discriminatoire de données
• Encodage qui favorise certains groupes
• Balancing qui distord la réalité

Principe : Les décisions de preprocessing peuvent être nuisibles et non-inclusives même sans mauvaise intention.

Principaux modèles

{insérer ici les modèles de regression et KNN}

Modèles de régressions

[[Statistiques et probabilités#Régression simple|Régression linéaire]]

→ Optimiser la pente $a$ et l’intercept $b$ en minimisant les résidus entre $y$ réel et $\hat{y}$ prédit.

Méthode d’optimisation : Moindres carrés \(\min_{a,b} \sum_{i=1}^{n} (y_i - (ax_i + b))^2\)

[[Statistiques et probabilités#Régression Logistique|Régression logistique]]

Sortie : Probabilité entre 0 et 1

• Si $P > 0.5$ → Classe 1
• Si $P \leq 0.5$ → Classe 0

K-Nearest Neighbors (KNN)

Propriétés :

• Non-paramétrique : Pas d’hypothèse sur la distribution des données
• Lazy learning : Pas d’entraînement, calcul à la prédiction
• Basé sur les distances : Euclidienne, Manhattan, Minkowski

Fonctionnement

Pour la classification

Processus :

1. Calculer la distance entre le point à prédire et tous les points d’entraînement
2. Sélectionner les K plus proches voisins
3. Vote majoritaire : La classe la plus fréquente parmi les K voisins

Pour la régression

Processus : 1 et 2. Identique à la classification

1. Moyenne : Calculer la moyenne des valeurs y des K voisins

Choix de K

La valeur optimale de K varie selon le dataset.

Trade-off :

Règle empirique : $K = \sqrt{n}$ où n = nombre d’échantillons

Note : K impair évite les égalités en classification binaire

Implémentation sklearn

Classes disponibles :

from sklearn.neighbors import KNeighborsClassifier

# Instancier
knn = KNeighborsClassifier(n_neighbors=5)

# Entraîner (mémoriser les données)
knn.fit(X_train, y_train)

# Prédire
predictions = knn.predict(X_test)

Paramètres importants :

• n_neighbors : Nombre de voisins K
• metric : Distance (‘euclidean’, ‘manhattan’, ‘minkowski’)
• weights : ‘uniform’ ou ‘distance’ (pondération par distance)

Métriques de performance

3.4. Metrics and scoring: quantifying the quality of predictions — scikit-learn 1.7.2 documentation

Pourquoi plusieurs métriques ?

Principe fondamental : Une seule métrique ne raconte qu’une partie de l’histoire. Il est essentiel d’investiguer l’efficacité d’un modèle sous plusieurs angles.

Raisons :

• Perspectives différentes : Chaque métrique capture un aspect spécifique
• Contexte business : Différents problèmes nécessitent différentes priorités
• Trade-offs : Optimiser une métrique peut dégrader une autre
• Robustesse : Une vue d’ensemble évite les conclusions hâtives

Cycle de vie d’un modèle

Étapes du cycle

Workflow standard :

1. Définir le problème
   ↓
2. Collecter les données
   ↓
3. Explorer et nettoyer (EDA)
   ↓
4. Preprocessing
   ↓
5. Baseline (modèle simple)
   ↓
6. Modélisation itérative
   ↓
7. Évaluation (métriques)
   ↓
8. Analyse d'erreurs
   ↓
9. Amélioration (retour à 4 ou 6)
   ↓
10. Déploiement
   ↓
11. Monitoring

Importance de l’évaluation

Comment savoir si l’idée actuelle est meilleure que la précédente ? → Via des métriques d’évaluation objectives et reproductibles.

Propriété : Les métriques permettent de :

• Comparer différents modèles
• Suivre les progrès
• Identifier les faiblesses
• Justifier les décisions

Attention, une métrique ne reflète qu’une partie des résultats ! Il faut regarder l’ensemble des métriques du modèle pour évaluer sa performance.

Baseline Score

Le but est d’établir un seuil minimal que tout modèle sophistiqué doit surpasser: Si un modèle complexe ne bat pas le baseline, c’est qu’il y a un problème.

Avantages :

• Identification rapide d’obstacles
• Validation du pipeline (avant modèle complexe)
• Point de référence objectif
• Détection de problèmes (data leakage, etc.)

→ Un R² proche de 0 (ou négatif) indique que le baseline n’a aucun pouvoir prédictif.

Règle : Toujours commencer par un baseline avant d’investir dans des modèles sophistiqués.

DummyRegressor

from sklearn.dummy import DummyRegressor

# Baseline : Prédire toujours la moyenne
baseline = DummyRegressor(strategy="mean")
baseline.fit(X_train, y_train)

# Score (R²)
baseline_score = baseline.score(X_test, y_test)
print(f"Baseline R² : {baseline_score:.3f}")

Stratégies disponibles :

• 'mean' : Moyenne de y_train (défaut)
• 'median' : Médiane de y_train
• 'constant' : Valeur fixe (à spécifier)
• 'quantile' : Quantile spécifique

DummyClassifier

from sklearn.dummy import DummyClassifier

# Baseline : Prédire la classe majoritaire
baseline = DummyClassifier(strategy="most_frequent")
baseline.fit(X_train, y_train)

# Accuracy
baseline_score = baseline.score(X_test, y_test)

Stratégies :

• 'most_frequent' : Classe la plus fréquente
• 'stratified' : Respecte distribution des classes
• 'uniform' : Aléatoire uniforme
• 'constant' : Classe fixe

Métriques de régression

En régression, on prédit des valeurs continues. Les métriques mesurent l’écart entre prédictions et vraies valeurs.

• $y_i$ : Vraie valeur
• $\hat{y}_i$ : Valeur prédite
• $n$ : Nombre d’échantillons
• $\bar{y}$ : Moyenne des vraies valeurs

Coefficient de détermination (R²)

Quand utiliser R² :

Propriétés :

• Sans unité (entre 0 et 1 typiquement)
• Comparable entre datasets différents
• 1 = parfait, 0 = aussi bon que la moyenne
• Peut être négatif si pire que baseline

from sklearn.metrics import r2_score

r2 = r2_score(y_true, y_pred)
print(f"R² : {r2:.3f}")

Mean Squared Error (MSE)

Propriétés :

• Sensible aux outliers (erreurs au carré)
• Pénalise fortement les grandes erreurs
• Pas dans la même unité que la target
• Pas de sens de direction (positif/négatif)
• Différentiable partout (optimisation)

Quand utiliser MSE :

Exemple : Essais cliniques où une erreur de 4mg est beaucoup plus grave qu’une erreur de 2mg (pas juste 2× pire, mais 4× pire).

from sklearn.metrics import mean_squared_error

mse = mean_squared_error(y_true, y_pred)
print(f"MSE : {mse:.2f}")

Root Mean Squared Error (RMSE)

Propriétés :

• Même unité que la target (interprétable)
• Toujours sensible aux outliers
• Intuitive : Erreur “typique” en unités originales

import math
from sklearn.metrics import root_mean_squared_error

mse = mean_squared_error(y_true, y_pred)
rmse = math.sqrt(mse)

# Ou directement :
rmse = root_mean_squared_error(y_true, y_pred)

Mean Absolute Error (MAE)

Quand utiliser MAE :

Propriétés :

• Moins sensible aux outliers (linéaire)
• Même unité que la target
• Interprétation simple : Erreur moyenne
• Non différentiable en 0 (optimisation moins lisse)

from sklearn.metrics import mean_absolute_error

mae = mean_absolute_error(y_true, y_pred)
print(f"MAE : {mae:.2f}")

Max Error

Propriétés :

• Identifie le pire cas
• Très sensible à un seul outlier
• Critique pour contraintes strictes

from sklearn.metrics import max_error

me = max_error(y_true, y_pred)
print(f"Max Error : {me:.2f}")

Tableau comparatif

Métriques de classification

En classification, on prédit des catégories discrètes. L’évaluation se base sur la matrice de confusion.

Matrice de confusion

Structure (classification binaire) :

                 Prédictions
              Négatif  Positif
Vraies  Nég.    TN       FP
Classes Pos.    FN       TP

Implémentation :

pandas.crosstab documentation

from sklearn.metrics import confusion_matrix
import pandas as pd

# Calculer
cm = confusion_matrix(y_true, y_pred)

# Avec pandas (plus lisible)
cm_df = pd.crosstab(
    y_true,
    y_pred,
    rownames=['Actual'],
    colnames=['Predicted']
)

Accuracy

Propriétés :

• Simple et intuitive
• Trompeuse pour classes déséquilibrées
• Bonne si toutes les classes ont même importance

Quand utiliser Accuracy :

from sklearn.metrics import accuracy_score

acc = accuracy_score(y_true, y_pred)
print(f"Accuracy : {acc:.3f}")

Recall

Propriétés :

• Mesure la couverture de la classe positive
• N’indique pas le nombre de fausses alertes
• Crucial quand manquer un positif est grave

Interprétation :

Quand utiliser Recall :

Problème potentiel : Un modèle qui prédit toujours positif a Recall = 1.0 mais est inutile !

from sklearn.metrics import recall_score

recall = recall_score(y_true, y_pred)
print(f"Recall : {recall:.3f}")

Precision

Propriétés :

• Mesure la fiabilité des prédictions positives
• N’indique pas combien de positifs sont manqués
• Crucial quand faux positif est coûteux

Interprétation :

Quand utiliser Precision :

from sklearn.metrics import precision_score

precision = precision_score(y_true, y_pred)
print(f"Precision : {precision:.3f}")

Precision-Recall Trade-off

Il y a une relation inverse entre Precision et Recall.

• ↑ Seuil de classification → ↑ Precision, ↓ Recall
• ↓ Seuil de classification → ↓ Precision, ↑ Recall

Seuil = 0.9 (strict)
→ Peu de prédictions positives
→ Haute Precision (celles prédites sont fiables)
→ Basse Recall (beaucoup de positifs manqués)

Seuil = 0.3 (lâche)
→ Beaucoup de prédictions positives
→ Basse Precision (beaucoup de faux positifs)
→ Haute Recall (peu de positifs manqués)

F1 Score

Propriétés :

• Équilibre entre Precision et Recall
• Sensible à la plus basse des deux métriques
• Métrique unique pour comparaisons
• Peut masquer le détail du trade-off

Quand utiliser F1 :

from sklearn.metrics import f1_score

f1 = f1_score(y_true, y_pred)
print(f"F1 Score : {f1:.3f}")

ROC Curve (Receiver Operating Characteristic)

Propriétés :

• Indépendant du seuil (vue d’ensemble)
• Robuste au déséquilibre de classes
• Visualise tous les trade-offs possibles

Une courbe idéale monte rapidement vers (0, 1) = coin supérieur gauche

from sklearn.metrics import roc_curve
import matplotlib.pyplot as plt

# Calculer courbe
fpr, tpr, thresholds = roc_curve(y_true, y_proba)

# Tracer
plt.plot(fpr, tpr)
plt.plot([0, 1], [0, 1], 'k--')  # Diagonale (aléatoire)
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate (Recall)')
plt.title('ROC Curve')
plt.show()

AUC (Area Under Curve)

Interprétation :

Propriétés :

• Métrique unique pour performance globale
• Indépendant du seuil choisi
• Comparable entre modèles
• Moins informatif que courbe complète

Quand utiliser AUC :

from sklearn.metrics import roc_auc_score

auc = roc_auc_score(y_true, y_proba)
print(f"AUC : {auc:.3f}")

Tableau récapitulatif des métriques de classification

Classification Report

classification_report fournit toutes les métriques par classe.