Dans ce guide, nous allons analyser en profondeur trois techniques d'encodage appliquées à un dataset réel de 42 588 arbres parisiens (Platanes), en expliquant les fondements théoriques, les pièges à éviter, et les bonnes pratiques industrielles.

Le Dataset : Arbres Remarquables de Paris

Nous travaillons sur un sous-ensemble du patrimoine arboré parisien, filtré sur les Platanes uniquement. Ce dataset contient plusieurs variables catégorielles représentatives des défis courants en Data Science :

• remarquable : Variable binaire (OUI/NON) indiquant si l'arbre a un intérêt historique ou esthétique exceptionnel
• stade_de_developpement : Variable ordinale (Jeune → Adulte → Mature) avec une progression logique
• espece : Variable nominale (Platane, Chêne, Érable, etc.) sans hiérarchie naturelle

Ce cas d'usage est idéal pour illustrer les trois familles d'encodage : binaire, ordinal et nominal.

Problématique Technique : Pourquoi les Catégories Doivent Devenir des Nombres

L'Incompatibilité Fondamentale

Les algorithmes ML reposent sur des opérations mathématiques : multiplication matricielle, calcul de distances euclidiennes, gradients de fonctions de coût. Ces opérations nécessitent des valeurs numériques.

Exemple concret : Si on entraîne un modèle de régression pour prédire la hauteur d'un arbre à partir de son stade de développement, l'algorithme a besoin de calculer :

Hauteur prédite = w₁ × stade + w₂ × circonférence + b

Si stade = "Adulte" (chaîne de caractères), cette équation n'a aucun sens mathématique. Il faut transformer "Adulte" en un nombre (par exemple, 3).

Le Piège de l'Encodage Naïf

La solution la plus simple serait d'assigner arbitrairement :

• Jeune → 1
• Adulte → 2
• Mature → 3

Mais cette approche fonctionne uniquement si l'ordre a du sens (variables ordinales). Pour des catégories nominales comme les espèces d'arbres, cela créerait une hiérarchie artificielle que le modèle pourrait mal interpréter. Par exemple, si Chêne=1, Érable=2, Platane=3, le modèle pourrait "apprendre" que Platane = Chêne + Érable, ce qui est absurde.

Technique 1 : Encodage Binaire Manuel (0/1) — La Variable remarquable

Contexte et Distribution

La variable remarquable est une variable binaire : un arbre est soit remarquable (OUI), soit ordinaire (NON). C'est le cas le plus simple d'encodage catégoriel.

Distribution observée :

• NON : 42 493 arbres (99.8%)
• OUI : 95 arbres (0.2%)

Cette distribution déséquilibrée (class imbalance) est typique des problèmes de classification d'événements rares (fraude bancaire, pannes industrielles, etc.).

Méthode d'Encodage

L'encodage manuel est direct et explicite :

df.loc[df.remarquable == "NON", "remarquable"] = 0
df.loc[df.remarquable == "OUI", "remarquable"] = 1

Pourquoi cette méthode ?

1. Sémantique claire : 0 = absence de propriété, 1 = présence. Cette convention est universelle.
2. Performance : Pas besoin d'instancier un encodeur complexe pour deux valeurs.
3. Interprétabilité : Dans un modèle de régression logistique, le coefficient associé aura une interprétation directe (impact sur le log-odds).

Analogie technique : C'est l'équivalent d'un bit en informatique — un interrupteur qui ne peut être que OFF (0) ou ON (1).

Avantages et Limites

✅ Avantages :

• Simple et lisible
• Aucune dépendance externe (pas besoin de bibliothèques spécialisées)
• Économie de mémoire : un seul entier par ligne

❌ Limites :

• Ne généralise pas aux variables avec plus de deux catégories
• Nécessite une gestion manuelle des nouvelles données

Technique 2 : Encodage Ordinal — La Variable stade_de_developpement

Théorie des Variables Ordinales

Une variable ordinale est une catégorie où l'ordre relatif a une signification intrinsèque. Le stade de développement d'un arbre suit une progression biologique naturelle :

Ø (manquant) → Jeune → Jeune/Adulte → Adulte → Mature

Cette séquence est non interchangeable : un arbre ne peut pas être "Mature" avant d'avoir été "Jeune". C'est différent d'une variable nominale (espèce) où aucun ordre n'existe.

Analogie : Les niveaux scolaires (Maternelle → Primaire → Collège → Lycée) suivent une progression ordonnée. On ne peut pas être au lycée avant d'avoir terminé le collège.

Implémentation avec OrdinalEncoder

L'utilisation de category_encoders.OrdinalEncoder offre plusieurs avantages sur un mapping manuel :

from category_encoders.ordinal import OrdinalEncoder

mapping = [
    {
        "col": "stade_de_developpement",
        "mapping": {
            np.nan: 0,              # Valeur manquante
            "Jeune (arbre)": 1,
            "Jeune (arbre)Adulte": 2,
            "Adulte": 3,
            "Mature": 4,
        },
    }
]

encoder = OrdinalEncoder(mapping=mapping)
stade = encoder.fit_transform(df[["stade_de_developpement"]])

Gestion des Valeurs Manquantes

Un point critique : la présence de np.nan (valeurs manquantes). Dans ce dataset, certains arbres n'ont pas de stade renseigné. L'encodeur ordinal les mappe explicitement à 0, ce qui permet :

1. Conservation des données : On ne perd pas les lignes incomplètes
2. Distinction sémantique : 0 = "information inconnue", différent de 1 = "Jeune"
3. Compatibilité algorithmique : La plupart des algorithmes ML gèrent les 0, mais pas les NaN

Bonnes pratiques :

• Toujours vérifier value_counts(dropna=False) avant et après encodage
• Documenter explicitement la signification de la valeur 0
• Envisager des stratégies alternatives (imputation par la médiane, modèle prédictif) si les valeurs manquantes représentent >20% des données

Application au DataFrame

Un piège classique pour les débutants est d'oublier d'intégrer l'encodage au DataFrame original :

# ❌ Erreur : l'encodage reste isolé
stade = encoder.fit_transform(df[["stade_de_developpement"]])

# ✅ Correct : intégration au DataFrame
df["stade_de_developpement"] = stade["stade_de_developpement"].copy()

Pourquoi .copy() ? Pour éviter les avertissements SettingWithCopyWarning de Pandas et garantir une copie mémoire indépendante.

Analogie : Remplacer le moteur d'une voiture. Ce n'est pas suffisant de construire un nouveau moteur à côté ; il faut l'installer dans le châssis pour que la voiture fonctionne.

Technique 3 : Encodage Binaire (Binary Encoding) — La Variable espece

Le Défi des Variables Nominales à Haute Cardinalité

La variable espece présente un problème différent : il n'y a aucun ordre naturel entre un Platane, un Chêne ou un Érable. De plus, le dataset complet contient des dizaines voire centaines d'espèces différentes (haute cardinalité).

Pourquoi One-Hot Encoding N'est Pas Optimal Ici

La technique classique pour les variables nominales est le One-Hot Encoding :

• Chêne → [1, 0, 0]
• Érable → [0, 1, 0]
• Platane → [0, 0, 1]

Mais si on a 100 espèces, cela crée 100 colonnes dans le DataFrame, ce qui :

1. Augmente drastiquement la dimensionnalité (curse of dimensionality)
2. Crée une matrice creuse (sparse matrix) coûteuse en mémoire
3. Ralentit l'entraînement des modèles

Binary Encoding : La Solution Compacte

Le Binary Encoding représente chaque catégorie en code binaire, comme en informatique :

Espèce A (1)   → [0, 0, 0, 1]
Espèce B (2)   → [0, 0, 1, 0]
Espèce C (3)   → [0, 0, 1, 1]
Espèce D (4)   → [0, 1, 0, 0]
...
Espèce 100 (100) → [1, 1, 0, 0, 1, 0, 0]  # 2^7 = 128 > 100

Avantage majeur : Pour encoder N catégories, on n'a besoin que de log₂(N) colonnes.

• 100 espèces → 7 colonnes (car 2⁷ = 128)
• 1000 espèces → 10 colonnes (car 2¹⁰ = 1024)

Versus 100 ou 1000 colonnes avec One-Hot Encoding !

Implémentation

from category_encoders.binary import BinaryEncoder

encoder = BinaryEncoder()
espece_bin = encoder.fit_transform(data[["espece"]])

print(f"Shape: {espece_bin.shape}")
# Résultat : (207641, 10) → 10 colonnes pour toutes les espèces

Note importante : Dans notre notebook, on applique l'encodage sur data (dataset complet), pas sur df (uniquement les Platanes), car df ne contient qu'une seule espèce. Encoder une seule catégorie n'a aucun intérêt pratique — c'est une démonstration technique.

Analogie : Les Codes-Barres

Un code-barres sur un produit de supermarché est composé de barres noires (1) et blanches (0). Il identifie uniquement le produit, sans suggérer qu'un code 12345 est "meilleur" ou "plus grand" qu'un code 67890. C'est exactement ce que fait le Binary Encoding : identifier de manière unique sans créer de hiérarchie artificielle.

Tableau Récapitulatif : Quelle Technique Choisir ?

Pièges Critiques à Éviter

1. Le Double Encodage

Erreur classique observée : Appliquer deux encodages successifs sur la même colonne.

# ❌ Double encodage (bug détecté dans la version initiale du notebook)
for category in df.stade_de_developpement.unique():
    df.loc[df.stade_de_developpement == category, "stade_de_developpement"] = code

encoder = OrdinalEncoder(mapping=mapping)
stade = encoder.fit_transform(df[["stade_de_developpement"]])

Symptôme : Résultats aberrants (valeurs -1.0 ou 0.0 uniquement) parce que l'encodeur cherche les catégories textuelles originales, mais trouve des nombres déjà transformés.

Solution : Supprimer l'encodage manuel et n'utiliser que OrdinalEncoder.

2. Oublier l'Intégration au DataFrame

# ❌ Erreur fréquente
espece_encoded = encoder.fit_transform(df[["espece"]])
# df contient toujours du texte ! Le modèle ne verra jamais les valeurs numériques.

# ✅ Correction
espece_encoded = encoder.fit_transform(df[["espece"]])
df = pd.concat([df, espece_encoded], axis=1)
df.drop("espece", axis=1, inplace=True)

Règle d'or : Toute variable transformée qui doit servir de feature dans un modèle ML DOIT être intégrée au DataFrame final. C'est comme préparer une recette : on ne peut pas donner farine, œufs et sucre dans des bols séparés au four. Il faut tout mélanger dans un seul récipient.

3. Créer une Hiérarchie Artificielle pour les Variables Nominales

# ❌ Mauvaise pratique pour les espèces
df["espece"] = df["espece"].map({"Chêne": 1, "Érable": 2, "Platane": 3})

Le modèle pourrait interpréter mathématiquement que Platane (3) = Chêne (1) + Érable (2), ce qui n'a aucun sens biologique.

Solution : Utiliser One-Hot ou Binary Encoding pour les variables nominales.

Bonnes Pratiques Industrielles

Vérification Systématique Après Transformation

Toujours inspecter les résultats avec value_counts() :

print("Avant encodage :")
print(df.stade_de_developpement.value_counts(dropna=False))

# ... encodage ...

print("Après encodage :")
print(df.stade_de_developpement.value_counts())

Cela permet de détecter immédiatement les anomalies (valeurs inattendues, perte de données).

Sauvegarde des Encodeurs pour la Production

En production, les nouvelles données doivent être encodées exactement de la même manière que les données d'entraînement. Il faut donc sauvegarder les encodeurs :

import joblib

# Après entraînement
joblib.dump(encoder, "ordinal_encoder_stade.pkl")

# En production
encoder = joblib.load("ordinal_encoder_stade.pkl")
new_data_encoded = encoder.transform(new_data[["stade_de_developpement"]])

Pipeline Scikit-Learn

Pour éviter les oublis et garantir la reproductibilité, intégrer les encodeurs dans un pipeline :

from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestRegressor

pipeline = Pipeline([
    ("encoder", OrdinalEncoder(mapping=mapping)),
    ("model", RandomForestRegressor())
])

pipeline.fit(X_train, y_train)
# L'encodage est automatiquement appliqué à chaque prédiction
predictions = pipeline.predict(X_test)

Cas Particulier : Pourquoi espece N'Est Pas Appliquée à Notre DataFrame ?

Dans notre notebook, l'encodage de la variable espece est appliqué sur le dataset complet (data), mais pas intégré au DataFrame filtré df. Pourquoi ?

Raison pédagogique : df ne contient que des Platanes (une seule espèce). Encoder une seule catégorie créerait une colonne constante (toujours la même valeur), ce qui est :

1. Inutile pour le modèle : Aucune variance, aucune information discriminante
2. Redondant : Le modèle apprendrait que cette colonne n'apporte rien

C'est une démonstration technique de la méthode Binary Encoding sur le dataset complet (plusieurs espèces), mais pas une étape réelle de preprocessing pour notre sous-ensemble.

Dans un projet réel avec plusieurs espèces dans df, il faudrait absolument appliquer l'encodage et l'intégrer au DataFrame.

Conclusion : L'Art du Preprocessing Catégoriel

Le choix de la technique d'encodage catégoriel n'est pas anodin. Il impacte directement :

• La performance du modèle : Un mauvais encodage (hiérarchie artificielle) introduit du biais
• Le temps de calcul : La dimensionnalité excessive ralentit l'entraînement
• L'interprétabilité : Comprendre la signification des coefficients appris

Les trois principes directeurs sont :

1. Respecter la nature de la variable : Binaire, ordinale ou nominale ?
2. Économiser les dimensions : Préférer Binary Encoding à One-Hot pour la haute cardinalité
3. Vérifier et valider : Toujours inspecter les distributions avant/après encodage

Ce guide, basé sur un dataset réel de 42 588 arbres parisiens, fournit un framework décisionnel réutilisable pour tout projet de Data Science nécessitant le preprocessing de variables catégorielles.

Ressources Complémentaires

Bibliothèques Utilisées

• Category Encoders : Bibliothèque complète d'encodeurs (Ordinal, Binary, Target, etc.)
• Pandas : Manipulation de DataFrames
• NumPy : Opérations numériques et gestion des valeurs manquantes

Techniques Avancées Non Couvertes

• Target Encoding : Encoder une catégorie par la moyenne de la variable cible (risque de fuite de données)
• Frequency Encoding : Remplacer chaque catégorie par sa fréquence d'apparition
• Embeddings : Représentation vectorielle apprise (utilisée en Deep Learning)

Dataset Source

Le dataset des arbres de Paris est fourni par OpenClassrooms dans le cadre du cours "Initiez-vous au Machine Learning". Il contient plus de 200 000 observations avec des métadonnées sur l'espèce, la localisation, les dimensions et l'état sanitaire des arbres.

Apprentissage Supervisé

Dans la régression et la classification, nous avions toujours une variable cible (la "réponse") :

• Régression: Prédire les ventes, le poids, le prix...
• Classification : Prédire si une tumeur est maligne/bénigne, si un email est spam/non-spam...

Analogie : C'est comme un professeur qui vous donne des exercices avec les réponses. Vous apprenez en voyant les bonnes réponses.

Apprentissage Non Supervisé (le Clustering)

Dans le clustering, il n'y a pas de variable cible. L'ordinateur doit trouver les groupes tout seul !

Analogie : C'est comme ranger des jouets dans des boîtes sans instructions. Vous devez décider vous-même quels jouets vont ensemble (les voitures ensemble, les poupées ensemble, les peluches ensemble...).

Le Critère Fondamental : La Distance

Question clé : Sans variable cible, comment l'ordinateur sait-il que deux éléments sont similaires ?

Réponse : Il utilise uniquement la distance entre les échantillons !

• Deux points proches (petite distance) → similaires → même groupe ✅
• Deux points éloignés (grande distance) → différents → groupes différents ❌

Analogie : Dans une soirée, les gens qui se connaissent se regroupent naturellement. Ils sont "proches" socialement. Le clustering fait la même chose avec des données, mais en mesurant la proximité avec une formule mathématique.

La distance utilisée est généralement la distance euclidienne (la distance "à vol d'oiseau", la plus courte).

Formule : Pour deux points (x₁, y₁) et (x₂, y₂) :

distance = √[(x₂ - x₁)² + (y₂ - y₁)²]

L'Algorithme K-means : Comment ça Marche ?

Les Objectifs du K-means

L'algorithme k-means cherche à créer K groupes (clusters) avec deux objectifs :

1. Minimiser la distance à l'intérieur d'un groupe → groupes denses
2. Maximiser la distance entre les groupes → groupes bien séparés

Analogie : C'est comme organiser des tables dans une salle de classe :

• Les élèves d'une même table doivent être proches les uns des autres (groupe dense)
• Les tables doivent être éloignées les unes des autres (groupes séparés)

Le Processus Itératif : Les 2 Étapes qui se Répètent

Le k-means est un processus itératif : il répète les mêmes actions plusieurs fois jusqu'à trouver la meilleure solution.

Étape 1 : Attribution des Données (Assignation)

Ce qui se passe :

• Chaque échantillon (chaque point) regarde tous les centroïdes (centres de groupe)
• Il calcule la distance qui le sépare de chaque centroïde
• Il est assigné au centroïde le plus proche

Analogie : C'est comme si chaque élève dans une classe s'asseyait à la table dont le centre est le plus proche de lui. Si un élève est à 2 mètres de la table A et 5 mètres de la table B, il va vers la table A.

En code :

# Pour chaque point, trouver le centroïde le plus proche
for point in data:
    distances = [distance(point, centroid) for centroid in centroids]
    point.cluster = argmin(distances)  # Assigner au plus proche

Étape 2 : Mise à Jour des Centroïdes (Déplacement)

Ce qui se passe :

• Une fois que tous les points sont assignés, le centre de gravité (la moyenne) de chaque groupe est recalculé
• Le centroïde se déplace à cette nouvelle position

Analogie : Imaginez que les centres de table peuvent se déplacer. Après que tous les élèves se soient assis, chaque centre de table se repositionne pour être exactement au milieu de tous les élèves qui y sont assis.

En code :

# Recalculer la position de chaque centroïde
for cluster in clusters:
    points_in_cluster = get_points_in_cluster(cluster)
    new_centroid = mean(points_in_cluster)  # Moyenne de tous les points
    cluster.centroid = new_centroid

La Convergence : Quand S'Arrêter ?

Ces deux étapes se répètent jusqu'à ce que les centroïdes ne bougent presque plus.

Pourquoi s'arrêter quand les centroïdes ne bougent plus ?

Parce que cela signifie que le modèle a trouvé une configuration stable :

• Chaque point est déjà assigné au centroïde le plus proche
• Si on recalcule les centroïdes, ils tombent au même endroit
• Les groupes sont cohérents et optimaux

On dit que l'algorithme a convergé.

Analogie : C'est comme arrêter de réorganiser les meubles dans une pièce quand vous avez trouvé le meilleur agencement. Si vous bougez une chaise, vous la remettez au même endroit → c'est stable.

Illustration du Processus K-means

Voici comment l'algorithme k-means évolue étape par étape :

Ce que montre ce graphique :

• Gauche : Initialisation avec centroïdes aléatoires
• Milieu : Après quelques itérations, les groupes commencent à se former
• Droite : Convergence finale - les groupes sont bien définis et stables

Les couleurs représentent les différents clusters, et les étoiles (★) sont les centroïdes.

Évaluation du Clustering : Choisir le Bon K

Le Problème du Choix de K

Le point faible du k-means : il faut choisir le nombre de clusters K à l'avance !

• Si K = 2, on aura 2 groupes
• Si K = 5, on aura 5 groupes
• Mais quel est le bon K ?

Analogie : C'est comme essayer de ranger des livres. Combien de piles devez-vous faire ? 3 piles (romans, BD, documentaires) ? 5 piles (en ajoutant policiers et science-fiction) ? Il faut trouver le nombre qui a le plus de sens.

Le Coefficient de Silhouette

Le Coefficient de Silhouette est un score qui évalue la qualité des groupes en tenant compte de deux critères :

1. Densité du groupe : Les points sont-ils proches dans leur groupe ?
2. Séparation du groupe : Les groupes sont-ils éloignés des autres ?

Échelle du Coefficient de Silhouette :

Formule simplifiée :

Silhouette = (distance au groupe le plus proche - distance moyenne dans son groupe)
             / max(les deux distances)

Comment Trouver le K Optimal ?

Méthode :

1. Essais Multiples : Entraîner le modèle avec différentes valeurs de K

   • Essayer K=2, K=3, K=4... jusqu'à K=10

2. Calcul du Score : Pour chaque K, calculer le Coefficient de Silhouette

3. Observation Graphique : Tracer l'évolution du score

4. Choisir le Maximum : Le K qui donne le score le plus élevé (le pic) est le meilleur

Exemple de graphique :

Lecture du graphique :

• L'axe horizontal montre le nombre de clusters (K)
• L'axe vertical montre le score de Silhouette
• Le pic indique le meilleur K

Dans cet exemple, K=3 est optimal car il donne le meilleur score (≈0.60).

Interprétation :

• K=3 donne le meilleur compromis entre groupes denses et bien séparés
• K=2 : pas assez de groupes, on mélange des choses différentes
• K=7 : trop de groupes, on divise des choses similaires

Application : Le Dataset Iris

Présentation du Dataset

Le dataset Iris est un classique du machine learning :

• 150 échantillons de fleurs
• 3 familles : Setosa, Versicolor, Virginica
• 4 caractéristiques : longueur/largeur des pétales et sépales

Analogie : C'est comme avoir 150 fleurs de 3 espèces différentes et mesurer la taille de leurs pétales et feuilles. Le défi : peut-on regrouper les fleurs similaires sans connaître leur espèce ?

Application du K-means

Paramètres :

• K = 3 clusters (on demande 3 groupes)
• Résultat : Coefficient de Silhouette = 0.55

Qu'est-ce que 0.55 signifie ?

Rappelons l'échelle :

• 1 = parfait
• 0 = ambigu
• -1 = mauvais

0.55 est à mi-chemin entre 0 et 1, ce qui indique :

• ✅ Le clustering a plutôt bien réussi
• ✅ Les groupes sont cohérents et bien séparés
• ⚠️ Ce n'est pas parfait, il y a un peu de chevauchement

Analogie : C'est comme obtenir 11/20 à un examen. Ce n'est pas excellent, mais c'est correct et au-dessus de la moyenne.

Comparaison avec les Vraies Familles

Question intéressante : Les 3 groupes trouvés par le k-means correspondent-ils aux 3 vraies familles de fleurs ?

Pour le savoir, on compare :

• Clusters trouvés par k-means (Cluster 0, 1, 2)
• Vraies familles du dataset (Setosa, Versicolor, Virginica)

Résultat : Accuracy = 88.7%

Qu'est-ce que 88.7% signifie ?

Cela signifie que le k-means a réussi à regrouper 88.7% des fleurs dans des clusters qui correspondent exactement à leurs vraies familles, sans jamais avoir vu les noms des familles pendant l'entraînement !

C'est impressionnant car :

• L'algorithme n'avait que les mesures physiques (longueur/largeur)
• Il n'avait aucune information sur les espèces
• Pourtant, il a retrouvé les groupes naturels avec 88.7% de précision

Analogie : C'est comme si on vous demandait de trier 150 photos de chiens en 3 piles (Berger Allemand, Golden Retriever, Chihuahua) sans vous dire les races. Vous devez juste observer les ressemblances. Si vous réussissez à 88.7%, c'est excellent !

Analyse de la Matrice de Confusion 🔍

Puisque 88.7% est une bonne performance, regardons les 11.3% d'erreurs (17 fleurs mal classées).

La Matrice de Confusion

Lecture de la matrice :

• Diagonale (50, 47, 36) : fleurs correctement regroupées ✅
• Hors diagonale (3, 14) : erreurs de regroupement ❌

Analyse Détaillée

Famille 0 (Setosa) : Perfection !

Vraie Famille 0 : 50 → Cluster 0
                   0 → Cluster 1
                   0 → Cluster 2

Interprétation :

• Toutes les 50 fleurs Setosa ont été correctement groupées
• 0 erreur : aucune confusion avec les autres familles
• Score : 100% pour cette famille

Qu'est-ce que cela signifie ?

Les fleurs Setosa ont des caractéristiques très distinctes des deux autres familles. Elles forment un nuage de points bien séparé.

Analogie : C'est comme avoir des Chihuahuas (très petits) parmi des Golden Retrievers et Bergers Allemands (grands). Le Chihuahua est tellement différent qu'il est facile à identifier.

Famille 1 (Versicolor) : Bon Résultat ✅

Vraie Famille 1 : 0  → Cluster 0
                  47 → Cluster 1  ✅
                   3 → Cluster 2  ❌

Interprétation :

• 47 fleurs sur 50 correctement groupées (94%)
• 3 fleurs confondues avec la Famille 2

Famille 2 (Virginica) : Le Plus d'Erreurs ⚠️

Vraie Famille 2 : 0  → Cluster 0
                  14 → Cluster 1  ❌ ← Plus grande erreur !
                  36 → Cluster 2  ✅

Interprétation :

• 36 fleurs sur 50 correctement groupées (72%)
• 14 fleurs confondues avec la Famille 1

Les Conclusions de l'Analyse

Observation 1 : Famille 0 Facile à Séparer

• Setosa est très distincte → 100% de réussite
• Ses caractéristiques (longueur/largeur) sont très différentes

Observation 2 : Familles 1 et 2 Se Chevauchent

• Versicolor et Virginica ont des caractéristiques similaires
• 14 + 3 = 17 erreurs entre ces deux familles
• C'est la preuve que leurs pétales/sépales ont des tailles proches

Analogie :

• Setosa = Chihuahua (facile à distinguer)
• Versicolor et Virginica = Golden Retriever vs Labrador Retriever (plus difficile car ils se ressemblent beaucoup)

Visualisation des clusters Iris :

Ce que montre ce graphique :

• Chaque couleur représente un cluster trouvé par k-means
• On voit clairement que le cluster violet (Setosa) est bien séparé
• Les clusters orange et vert (Versicolor et Virginica) se chevauchent partiellement

Récapitulatif : Les Points Clés

Ce qu'est le Clustering

Comment Fonctionne le K-means

1. Initialisation : Choisir K centroïdes au hasard
2. Itération :
   • Étape 1 : Assigner chaque point au centroïde le plus proche (distance)
   • Étape 2 : Recalculer les centroïdes (moyenne des points assignés)
3. Convergence : Répéter jusqu'à ce que les centroïdes ne bougent plus

Comment Choisir K

1. Essayer plusieurs valeurs de K (2, 3, 4...)
2. Calculer le Coefficient de Silhouette pour chaque K
3. Choisir le K qui donne le score maximum (pic de la courbe)

Comment Évaluer la Qualité

Cas d'Usage du Clustering

Segmentation de Clients

• Regrouper les clients par comportement d'achat
• Créer des campagnes marketing ciblées

Compression d'Images

• Réduire le nombre de couleurs en groupant les pixels similaires
• K-means pour la quantification des couleurs

Détection d'Anomalies

• Trouver des points isolés (pas dans aucun cluster dense)
• Détecter des fraudes, des pannes machines

Organisation de Documents

• Regrouper des articles par thème
• Créer des catégories automatiquement

Biologie

• Classifier des espèces selon leurs caractéristiques
• Exemple : Iris avec ses 3 familles

Limites du K-means

1. Il faut choisir K à l'avance

• Pas toujours évident de savoir combien de groupes existent
• Solution : Tester plusieurs K et utiliser le Coefficient de Silhouette

2. Sensible à l'initialisation

• Les centroïdes de départ sont aléatoires
• Peut donner des résultats légèrement différents
• Solution : Relancer plusieurs fois et garder le meilleur

3. Suppose des groupes sphériques

• K-means fonctionne mieux avec des groupes ronds
• Peut mal fonctionner avec des formes allongées ou complexes

4. Sensible aux valeurs extrêmes

• Un point très éloigné peut déplacer un centroïde
• Solution : Normaliser les données avant le clustering

Pour Aller Plus Loin

Autres Algorithmes de Clustering

• DBSCAN : Ne nécessite pas de choisir K, trouve des formes complexes
• Clustering Hiérarchique : Crée un arbre de groupes (dendrogramme)
• GMM (Gaussian Mixture Models) : Version probabiliste du k-means

Optimisations du K-means

• K-means++ : Meilleure initialisation des centroïdes
• Mini-batch K-means : Plus rapide pour de gros datasets

Visualisation

• PCA (Analyse en Composantes Principales) : Réduire à 2D pour visualiser
• t-SNE : Visualisation avancée de clusters en haute dimension

Conclusion

Le clustering est une technique puissante pour découvrir des structures cachées dans les données. Le k-means est l'algorithme le plus populaire car il est :

✅ Simple à comprendre
✅ Rapide à exécuter
✅ Efficace pour de nombreux cas d'usage

Son seul inconvénient : il faut choisir K. Mais avec le Coefficient de Silhouette, on peut trouver le K optimal !

L'exemple d'Iris montre que le k-means peut retrouver des groupes naturels (les 3 espèces de fleurs) avec 88.7% de précision, juste en analysant les mesures physiques. C'est la magie de l'apprentissage non supervisé ! 🌸✨

Différence fondamentale

Analogie :

• Régression = Donner une note sur 100 à un devoir
• Classification = Dire si l'élève a réussi (A/B/C/D/F)

Les Types de Classification

Classification Binaire ⚪⚫

Définition : Seulement 2 catégories possibles.

Exemples :

• Transaction : Fraude / Normale
• Email : Spam / Légitime
• Tumeur : Maligne / Bénigne
• Diagnostic : Malade / Sain

Représentation : 0 ou 1, Vrai ou Faux, Oui ou Non

Classification Multiclasse 🔴🔵🟢

Définition : Plus de 2 catégories différentes.

Exemples :

• Classifier des photos : Chien / Chat / Oiseau
• Note d'un film : ⭐ / ⭐⭐ / ⭐⭐⭐ / ⭐⭐⭐⭐ / ⭐⭐⭐⭐⭐
• Type de fleur : Iris / Rose / Tulipe

Classification Multilabel 🏷️🏷️

Définition : Un objet peut appartenir à plusieurs catégories simultanément.

Exemples :

• Film : "Action" ET "Comédie" ET "Science-Fiction"
• Article de presse : "Politique" ET "Économie"
• Maladie : Un patient peut avoir plusieurs pathologies

Catégories Ordinales vs Nominales

Ordinales : Il existe un ordre entre les catégories

• Mauvais < Moyen < Bon < Excellent
• Petite < Moyenne < Grande taille

Nominales : Pas d'ordre naturel

• Couleurs : Rouge, Bleu, Vert
• Pays : France, Japon, Brésil

La Régression Logistique : Le Pont entre Régression et Classification

Pourquoi "Régression" pour faire de la "Classification" ? 🤔

Le nom est trompeur ! La régression logistique utilise une régression pour faire de la classification.

Le Processus en 3 Étapes

Étape 1 : Régression Linéaire Classique

On commence comme avec la régression linéaire :

y = a × x₁ + b × x₂ + c × x₃ + d

Problème : y peut être n'importe quel nombre (-∞ à +∞)

• Si y = 150 → Que faire ?
• Si y = -50 → Ça n'a pas de sens pour une catégorie !

Étape 2 : Fonction Logistique (Sigmoïde)

On applique la fonction sigmoïde pour transformer y en probabilité z :

z = 1 / (1 + e^(-y))

Résultat : z est toujours entre 0 et 1 → c'est une probabilité !

Graphique de la fonction sigmoïde :

  1 |         ________
    |        /
z   |       /
    |      /
  0 |_____/____________
      -∞   0   +∞
           y

Propriétés magiques :

• Si y = -∞ → z ≈ 0 (impossible)
• Si y = 0 → z = 0.5 (50% de chances)
• Si y = +∞ → z ≈ 1 (certain)

Étape 3 : Seuil de Classification

On transforme la probabilité en décision ferme :

if z >= 0.5:
    prédiction = 1  # Classe Positive
else:
    prédiction = 0  # Classe Négative

Exemple concret :

• Probabilité de spam = 0.78 (78%) → SPAM ✅
• Probabilité de spam = 0.23 (23%) → LÉGITIME ✅

Évaluer la Performance : L'Exactitude

L'Exactitude (Accuracy)

C'est quoi ? Le pourcentage de prédictions correctes.

Formule :

Exactitude = Nombre de bonnes prédictions / Nombre total de prédictions

Exemple :

• 100 emails testés
• 95 bien classés (spam ou légitime)
• Exactitude = 95% 🎉

Le Paradoxe de l'Exactitude 😱

Problème : L'exactitude peut être trompeuse !

Exemple de la Fraude Bancaire :

• Dans 100 transactions, seulement 1 est frauduleuse (1%)
• Un modèle stupide qui dit TOUJOURS "Pas de fraude" aura :
  • 99 bonnes prédictions (les 99 légitimes)
  • 1 erreur (la fraude non détectée)
  • Exactitude = 99% 😮

Conclusion : Ce modèle est inutile car il ne détecte aucune fraude, mais il a un score "excellent" !

C'est pourquoi on a besoin d'outils plus fins...

La Matrice de Confusion : Le Détective des Erreurs

Qu'est-ce que c'est ?

Un tableau 2×2 qui croise Réalité vs Prédiction pour voir les 4 résultats possibles.

Les 4 Résultats Possibles

Explications avec Exemples

✅ Vrai Positif (TP - True Positive)

• Réalité : Malade
• Prédiction : Malade
• Résultat : Bien détecté ! 👍

✅ Vrai Négatif (TN - True Negative)

• Réalité : Sain
• Prédiction : Sain
• Résultat : Bien ignoré ! 👍

❌ Faux Positif (FP - False Positive)

• Réalité : Sain
• Prédiction : Malade
• Résultat : Fausse alerte ! 🚨 (Alarme inutile)

Exemple : Email légitime envoyé dans les spams

❌ Faux Négatif (FN - False Negative)

• Réalité : Malade
• Prédiction : Sain
• Résultat : Cas manqué ! 😰 (Danger non détecté)

Exemple : Maladie non diagnostiquée

Quelle est l'Erreur la Plus Grave ? 🚨

Dans le contexte médical : Le Faux Négatif (FN) est catastrophique !

• Le patient est malade mais le modèle dit qu'il est sain
• La maladie n'est pas traitée → Conséquences potentiellement fatales

Dans le contexte du spam : Le Faux Positif (FP) est plus gênant

• Un email important est classé comme spam
• Risque de manquer une information cruciale

Le Rappel (Recall) : Ne Rien Manquer

Définition

Le Rappel mesure la capacité du modèle à détecter tous les cas positifs.

Question clé : Parmi tous les malades réels, combien ai-je détectés ?

Formule

Rappel = TP / (TP + FN)

Décryptage du dénominateur :

• TP = Vrais Positifs (bien détectés)
• FN = Faux Négatifs (malades manqués)
• TP + FN = TOUS les cas réellement positifs dans les données

Exemple Concret

Contexte : Détection de cancer, 100 patients, 20 sont malades

Calcul :

Rappel = 18 / (18 + 2) = 18 / 20 = 0.90 = 90%

Interprétation : Le modèle détecte 90% des malades, mais en manque 10% (2 personnes).

Quand privilégier le Rappel ?

✅ Situations critiques où manquer un cas est dangereux :

• Détection de maladies graves
• Détection de fraudes financières
• Détection d'intrusions informatiques
• Contrôle qualité (défauts de fabrication)

Objectif : NE RIEN MANQUER, même si ça génère des fausses alertes.

La Précision (Precision) : Éviter les Fausses Alertes

Définition

La Précision mesure la fiabilité des alertes du modèle.

Question clé : Parmi toutes mes alertes positives, combien étaient vraies ?

Formule

Précision = TP / (TP + FP)

Décryptage du dénominateur :

• TP = Vrais Positifs (alertes correctes)
• FP = Faux Positifs (fausses alertes)
• TP + FP = TOUTES les fois où le modèle a dit "Positif"

Exemple Concret

Contexte : Filtre anti-spam, 1000 emails

Calcul :

Précision = 180 / (180 + 20) = 180 / 200 = 0.90 = 90%

Interprétation : Quand le filtre dit "SPAM", il a raison 90% du temps, mais se trompe 10% du temps (20 emails légitimes perdus).

Quand privilégier la Précision ?

✅ Situations où les fausses alertes sont coûteuses :

• Filtre anti-spam (ne pas perdre d'emails importants)
• Système de recommandation (ne pas recommander n'importe quoi)
• Publicité ciblée (ne pas gaspiller le budget sur les mauvaises cibles)

Objectif : Être SÛR de ses alertes, même si on en rate quelques-unes.

Le Compromis Précision / Rappel

Le Dilemme

Problème : On ne peut pas maximiser les deux en même temps ! 😰

Scénario 1 : Modèle Ultra-Prudent (Précision Élevée)

Comportement : Le modèle ne dit "Positif" que quand il est TRÈS SÛR.

Conséquences :

• ✅ Précision élevée : Peu de fausses alertes (FP↓)
• ❌ Rappel faible : Beaucoup de cas manqués (FN↑)

Analogie : Un détecteur de fumée qui ne sonne que si la maison est en flammes

• Pas de fausses alarmes ✅
• Mais il rate les petits débuts d'incendie ❌

Scénario 2 : Modèle Ultra-Sensible (Rappel Élevé)

Comportement : Le modèle dit "Positif" au moindre doute.

Conséquences :

• ✅ Rappel élevé : Peu de cas manqués (FN↓)
• ❌ Précision faible : Beaucoup de fausses alertes (FP↑)

Analogie : Un détecteur de fumée ultra-sensible

• Il détecte tout ✅
• Mais il sonne pour un toast brûlé ❌

Le Rôle du Seuil de Classification

Rappel : On transforme la probabilité en décision avec un seuil (par défaut 0.5).

if probabilité >= seuil:
    prédiction = Positif
else:
    prédiction = Négatif

Baisser le Seuil (ex: 0.3)

if probabilité >= 0.3:  # Plus facile de dire "Positif"
    prédiction = Positif

Effet :

• 📈 Rappel augmente (on détecte plus de positifs)
• 📉 Précision diminue (plus de fausses alertes)

Augmenter le Seuil (ex: 0.7)

if probabilité >= 0.7:  # Plus difficile de dire "Positif"
    prédiction = Positif

Effet :

• 📉 Rappel diminue (on manque plus de positifs)
• 📈 Précision augmente (moins de fausses alertes)

Tableau Récapitulatif (Détection Cancer du Sein)

La Courbe ROC et l'AUC : Vue Globale

Problème

Comment évaluer un modèle indépendamment du seuil choisi ?

La Courbe ROC (Receiver Operating Characteristic)

Principe : Tracer le graphique du Rappel vs Taux de Faux Positifs pour tous les seuils possibles.

Axes :

• Axe Y : TPR (True Positive Rate) = Rappel = TP / (TP + FN)
• Axe X : FPR (False Positive Rate) = FP / (FP + TN)

  1 |    📈
    |   /|
TPR |  / |   ← Courbe du modèle
    | /  |
  0 |/_____|_____
    0    0.5    1
         FPR

Interprétation de la Courbe

Modèle Aléatoire (AUC = 0.5)

  1 |
    |    /
TPR |   /    ← Diagonale = Tirage au sort
    |  /
  0 |/_________
    0         1
       FPR

Signification : Le modèle est aussi bon qu'une pièce de monnaie 🪙

• Performance équivalente au hasard
• Inutile !

Modèle Parfait (AUC = 1.0)

  1 |_____
    |    |
TPR |    |    ← Coin supérieur gauche
    |    |
  0 |____|_____
    0         1
       FPR

Signification :

• TPR = 100% (tous les positifs détectés)
• FPR = 0% (aucune fausse alerte)
• Modèle idéal ! 🏆

Modèle Réaliste (AUC = 0.85)

  1 |    ___
    |   /  |
TPR |  /   |
    | /    |
  0 |/_____|___
    0         1
       FPR

Signification : Bon modèle, mais pas parfait

• Compromis entre détection et fausses alertes

L'AUC (Area Under the Curve)

Définition : La surface sous la courbe ROC.

Échelle d'interprétation :

Avantage : Métrique unique qui résume la performance sur tous les seuils.

Résumé : Quand Utiliser Quelle Métrique ?

Tableau de Décision

🎓 Concepts Clés à Retenir

1. Régression Logistique

✅ Utilise une régression linéaire + fonction sigmoïde
✅ Donne une probabilité entre 0 et 1
✅ Transformée en décision via un seuil (par défaut 0.5)

2. Matrice de Confusion

✅ TP : Vrai Positif (bien détecté)
✅ TN : Vrai Négatif (bien ignoré)
❌ FP : Faux Positif (fausse alerte)
❌ FN : Faux Négatif (cas manqué)

3. Métriques

✅ Exactitude : % de bonnes prédictions (attention au paradoxe !)
✅ Rappel : TP / (TP + FN) → Détecter tous les positifs
✅ Précision : TP / (TP + FP) → Fiabilité des alertes
✅ AUC : Surface sous courbe ROC → Évaluation globale

4. Compromis Précision/Rappel

✅ On ne peut pas maximiser les deux en même temps
✅ Le seuil permet d'ajuster le compromis
✅ Choix dépend du contexte métier

💡 Analogies pour Bien Comprendre

Le Détecteur de Fumée

Rappel = Détecteur ultra-sensible

• ✅ Détecte TOUS les incendies (même petits)
• ❌ Sonne pour un toast brûlé (fausses alertes)

Précision = Détecteur prudent

• ✅ Ne sonne que pour les vrais incendies
• ❌ Rate les petits débuts de feu

Le Contrôle de Sécurité à l'Aéroport

Rappel = Fouiller tout le monde systématiquement

• ✅ Aucun danger ne passe
• ❌ Files d'attente interminables

Précision = Fouiller seulement les suspects évidents

• ✅ Flux rapide, peu de personnes embêtées
• ❌ Risque de laisser passer un danger

Ce guide vous accompagne pas à pas dans l'analyse du dataset Advertising pour prédire les ventes en fonction des budgets publicitaires (TV, radio, journaux).

Télécharger le fichier CSV

Objectif : Comprendre comment construire un modèle de régression linéaire, l'évaluer, et l'améliorer avec des techniques simples.

Comprendre les données

Le dataset Advertising

200 observations avec 4 variables :

Première exploration

import pandas as pd

df = pd.read_csv("advertising.csv")
print(df.head())
print(df.describe())

Ce qu'on observe :

• Moyenne TV : ~147, Radio : ~23, Journaux : ~31
• Ventes moyennes : ~14
• Aucune valeur manquante ✅

Visualiser les relations

Pourquoi visualiser ?

Avant de construire un modèle, il faut voir si les variables sont liées aux ventes.

Les graphiques avec trendline (ligne de régression)

import plotly.express as px

fig = px.scatter(df, x="tv", y="ventes",
                 trendline="ols",  # Ordinary Least Squares
                 title="TV vs Ventes")
fig.show()

Ce que montre le paramètre trendline="ols" :

• Trace automatiquement la meilleure droite qui passe au plus près des points
• OLS = méthode mathématique pour trouver cette droite
• Si les points sont proches de la ligne → forte relation 💪
• Si les points sont dispersés → faible relation 😐

Les corrélations

Interprétation simple :

• 0.78 : Quand le budget TV augmente, les ventes augmentent beaucoup
• 0.23 : Les journaux ont peu d'impact sur les ventes

Construire le modèle de régression linéaire

Qu'est-ce qu'une régression linéaire ?

C'est trouver la formule mathématique qui relie les variables :

ventes = a × tv + b × radio + c × journaux + d

Le modèle va chercher les meilleurs coefficients a, b, c, d pour prédire au mieux les ventes.

Le code

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

# 1. Préparer les données
X = df[["tv", "radio", "journaux"]]  # Variables prédictives
y = df.ventes                        # Variable cible

# 2. Séparer en train (80%) et test (20%)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=42
)

# 3. Créer et entraîner le modèle
reg = LinearRegression()
reg.fit(X_train, y_train)  # Le modèle "apprend"

# 4. Faire des prédictions
y_pred_test = reg.predict(X_test)

🧠 Comprendre train_test_split

Pourquoi séparer les données ?

Imaginez que vous préparez un examen :

• Train (80%) = Les exercices que vous faites pour apprendre
• Test (20%) = L'examen final avec des questions que vous n'avez jamais vues

Si vous testez sur les mêmes données que l'entraînement, vous trichez ! Le modèle connaît déjà les réponses.

Le paramètre random_state=42 :

• Assure que la séparation est toujours la même
• Permet de reproduire les résultats
• Sans ça, chaque exécution donnerait des résultats différents

Évaluer le modèle

Les métriques d'évaluation

from sklearn.metrics import mean_squared_error, mean_absolute_percentage_error

rmse = mean_squared_error(y_test, y_pred_test)
mape = mean_absolute_percentage_error(y_test, y_pred_test)

print(f"RMSE : {rmse}")
print(f"MAPE : {mape}")

📏 RMSE (Root Mean Square Error)

C'est quoi ? L'erreur moyenne de vos prédictions.

Exemple concret :

• Si RMSE = 3.17
• En moyenne, vos prédictions se trompent de ±3.17 unités de ventes
• Si les vraies ventes sont 15, vous prédisez entre 11.83 et 18.17

Caractéristique : Pénalise fortement les grosses erreurs

• Se tromper de 10 compte plus que se tromper de 1 dix fois

🎯 MAPE (Mean Absolute Percentage Error)

C'est quoi ? L'erreur en pourcentage.

Exemple concret :

• Si MAPE = 0.15 (soit 15%)
• En moyenne, vos prédictions ont 15% d'erreur
• Si les vraies ventes sont 100, vous prédisez entre 85 et 115

Avantage : Plus intuitif et comparable entre différents projets

Est-ce bon ou mauvais ?

Pour le modèle simple :

• RMSE ≈ 3.17 → Pas mal 👍
• MAPE ≈ 0.15 (15%) → Correct mais peut mieux faire 🤔

Amélioration : La régression polynomiale

Le problème détecté

En regardant le graphique TV vs Ventes, on remarque que les points forment une courbe plutôt qu'une ligne droite.

Exemple visuel :

Budget TV faible (0-50)    → Les ventes augmentent lentement
Budget TV moyen (100-150)  → Les ventes augmentent normalement
Budget TV élevé (200-300)  → Les ventes augmentent rapidement

C'est une accélération = relation non-linéaire !

La solution : ajouter tv²

Au lieu de :

ventes = a × tv + ...

On fait :

ventes = a × tv + b × tv² + ...

Pourquoi tv² capture la courbure ?

Exemple simple :

Le terme tv² augmente beaucoup plus vite que tv, ce qui crée l'effet de courbure/accélération.

Normalisation : Pourquoi et comment ?

Le problème d'échelle

Après avoir créé tv², on a :

• tv : entre 0 et 300
• tv² : entre 0 et 90 000 ! 😱

Le modèle va penser que tv² est beaucoup plus important juste parce que les chiffres sont gros.

La solution : MinMaxScaler

Ce que ça fait : Ramène toutes les variables entre 0 et 1.

Exemple :

Avant :
tv = [0, 100, 200, 300]

Après normalisation :
tv = [0, 0.33, 0.66, 1.0]

Le code

from sklearn.preprocessing import MinMaxScaler

# 1. Créer tv²
df['tv2'] = df.tv ** 2

# 2. Normaliser
scaler = MinMaxScaler()
data_normalized = scaler.fit_transform(df)
df_normalized = pd.DataFrame(data_normalized,
                              columns=['tv', 'radio', 'journaux', 'ventes', 'tv2'])

# 3. Entraîner avec tv²
X_poly = df_normalized[['tv', 'radio', 'journaux', 'tv2']]
y_poly = df_normalized.ventes

X_train, X_test, y_train, y_test = train_test_split(
    X_poly, y_poly, test_size=0.20, random_state=42
)

reg_poly = LinearRegression()
reg_poly.fit(X_train, y_train)
y_pred_poly = reg_poly.predict(X_test)

Comprendre fit_transform

Les 4 étapes du scaler :

1. fit() : Le scaler regarde les données et calcule :

   • Le minimum de chaque colonne
   • Le maximum de chaque colonne

2. transform() : Le scaler applique la formule :

   valeur_normalisée = (valeur - min) / (max - min)
   

3. fit_transform() : Fait les 2 étapes d'un coup (plus rapide)

Exemple concret :

tv = [0, 100, 200, 300]

# Le scaler calcule :
min = 0
max = 300

# Puis transforme :
0   → (0 - 0) / 300 = 0
100 → (100 - 0) / 300 = 0.33
200 → (200 - 0) / 300 = 0.66
300 → (300 - 0) / 300 = 1.0

Comparaison des résultats

Tableau récapitulatif

Pourquoi c'est mieux ?

Le terme quadratique tv² permet de capturer la vraie relation entre TV et ventes :

• Pas juste une ligne droite
• Mais une courbe qui représente l'accélération des ventes avec le budget

Convention de nommage importante

La notation _pred

En machine learning, on utilise cette convention :

Pourquoi c'est important ?

• Distingue clairement la réalité des prédictions
• Évite les confusions dans le code
• Standard dans toute la communauté ML

Analogie :

• y_test = Les bonnes réponses de l'examen
• y_pred_test = Vos réponses (ce que le modèle pense)
• Les métriques (RMSE, MAPE) = La note de l'examen (comparaison des deux)

🎓 Concepts clés à retenir

1. Train/Test Split

✅ Toujours séparer les données
✅ Typiquement 80/20 ou 70/30
✅ Le modèle n'a jamais vu les données de test

2. Corrélation

✅ Entre -1 et +1
✅ Plus proche de ±1 = plus forte relation
✅ Proche de 0 = pas de relation

3. Régression polynomiale

✅ Ajouter des puissances (x²) capture les courbes
✅ Plus flexible que la régression linéaire simple
✅ Attention à ne pas "sur-complexifier" (overfitting)

4. Normalisation

✅ Met toutes les variables sur la même échelle
✅ Permet de comparer l'importance des coefficients
✅ Évite que les grandes valeurs dominent

5. Métriques d'évaluation

✅ RMSE : Erreur absolue, pénalise les grosses erreurs
✅ MAPE : Erreur en %, facile à interpréter
✅ Plus petit = meilleur modèle

🚀 Pour aller plus loin

Idées d'améliorations

1. Ajouter des termes croisés : tv × radio

   • Capture l'effet combiné de campagnes multi-canal

2. Retirer la variable journaux

   • Corrélation faible (0.23), peut simplifier le modèle

3. Tester d'autres modèles

   • Random Forest, Gradient Boosting
   • Comparer les performances

4. Analyser les résidus

   • Différence entre prédiction et réalité
   • Identifier les patterns d'erreurs

📝 Résumé du workflow complet

1. Charger les données
   ↓
2. Explorer (head, describe, visualisations)
   ↓
3. Analyser les corrélations
   ↓
4. Préparer X (variables) et y (cible)
   ↓
5. Split train/test
   ↓
6. Entraîner le modèle (fit)
   ↓
7. Prédire (predict)
   ↓
8. Évaluer (RMSE, MAPE)
   ↓
9. Améliorer (ajouter tv², normaliser)
   ↓
10. Comparer les résultats

💡 Analogies pour bien comprendre

Le modèle = Un étudiant

• fit() = Réviser avec les exercices du livre
• predict() = Passer l'examen
• Train set = Les exercices du livre
• Test set = L'examen avec de nouvelles questions
• RMSE/MAPE = La note de l'examen

La régression linéaire = Tracer une droite

• On a des points sur un graphique
• On cherche la meilleure droite qui passe près de tous les points
• Les coefficients = La pente et la hauteur de la droite
• L'erreur = La distance moyenne entre les points et la droite

La normalisation = Mettre tout en euros

• Sans normalisation : comparer des pommes (2€) et des voitures (20 000€)
• Avec normalisation : tout entre 0 et 1, on compare des proportions
• Comme mettre toutes les valeurs en "pourcentage du maximum"

Un exemple pratique : prédire le poids d'enfants

Imaginons un dataset contenant 237 échantillons d'enfants âgés de 11,5 à 20 ans, avec les informations suivantes :

• L'âge (exprimé en mois, de 139 à 250 mois)
• Le sexe (variable binaire : 0 pour les garçons, 1 pour les filles)
• La taille (entre 128,27 cm et 182,88 cm)
• Le poids (entre 22,9 kg et 77,78 kg)

Notre objectif est de construire un modèle qui prédit le poids d'un enfant en fonction de son sexe, son âge et sa taille.

Le principe de la régression linéaire

Le modèle que nous cherchons à construire s'exprime mathématiquement comme :

poids = a × sexe + b × age + c × taille + bruit

Où :

• a, b, c sont les coefficients que le modèle doit apprendre
• Le bruit représente l'information que le modèle ne peut pas capturer

Ce type de modèle, appelé régression linéaire, est l'un des plus simples mais aussi des plus puissants en Machine Learning.

Les trois étapes de l'entraînement

Étape 1 : Charger et préparer les données

La première étape consiste à organiser nos données :

• X (la matrice de design) : contient les variables prédictives (âge, sexe, taille)
• y (le vecteur cible) : contient la variable à prédire (le poids)

Par convention, X représente toujours les données d'entrée où chaque ligne correspond à un échantillon et chaque colonne à une variable.

Étape 2 : Entraîner le modèle

L'entraînement consiste à trouver les meilleurs coefficients a, b, c qui minimisent l'écart entre les prédictions du modèle et les vraies valeurs. Cette phase est automatiquement gérée par les bibliothèques de Machine Learning comme scikit-learn.

Étape 3 : Évaluer la performance

Une fois le modèle entraîné, il faut mesurer sa qualité. C'est là qu'interviennent les métriques d'évaluation.

Les fonctions de coût : le moteur de l'apprentissage

Une fonction de coût mesure l'écart entre les prédictions du modèle et les valeurs réelles. Le but de l'entraînement est de minimiser cette fonction.

Pour la régression linéaire, la fonction de coût la plus courante est la MSE (Mean Squared Error - Erreur Quadratique Moyenne) :

MSE = (1/N) × Σ(yₖ - ŷₖ)²

Où :

• N : le nombre d'échantillons
• yₖ : les valeurs réelles
• ŷₖ : les valeurs prédites par le modèle

Comment ça marche ?

Imaginez la fonction de coût comme une vallée. L'algorithme d'entraînement (comme la descente de gradient) explore cette vallée en calculant les dérivées pour trouver le chemin qui descend le plus rapidement vers le fond - c'est-à-dire le minimum d'erreur.

Mesurer la performance : les métriques d'évaluation

Une fois le modèle entraîné, nous devons évaluer sa qualité sur de nouvelles données. Plusieurs métriques existent selon le type de problème.

Pour les problèmes de régression

1. Le coefficient de détermination R²

• Varie de 0 (mauvais) à 1 (parfait)
• Mesure la proportion de variance expliquée par le modèle
• Plus il est proche de 1, meilleur est le modèle

2. La RMSE (Root Mean Square Error)

• Mesure l'écart moyen entre prédictions et valeurs réelles
• S'exprime dans la même unité que la variable cible
• Plus elle est petite, meilleur est le modèle

3. La MAE (Mean Absolute Error)

• Erreur absolue moyenne
• Moins sensible aux valeurs aberrantes que la RMSE
• Plus elle est petite, meilleur est le modèle

4. La MAPE (Mean Absolute Percentage Error)

• Exprime l'erreur en pourcentage
• Permet de comparer des modèles sur différents datasets
• Plus elle est petite, meilleur est le modèle

Exemple de résultats

Sur notre modèle prédisant le poids à partir du sexe et de l'âge uniquement, nous obtenons :

• RMSE : 45,17 kg
• MAE : 5,22 kg
• MAPE : 12%

En ajoutant la variable taille, les scores s'améliorent significativement, démontrant l'importance de choisir les bonnes variables prédictives.

Le processus complet d'entraînement

Voici la méthodologie à suivre pour tout projet de Machine Learning :

1. Charger les données : Importer et comprendre votre dataset
2. Transformer les données : Nettoyer, normaliser, créer de nouvelles features
3. Scinder en train/test : Séparer les données pour évaluer objectivement
4. Entraîner le modèle : Tester différentes configurations de paramètres
5. Calculer les scores : Comparer les performances de chaque version
6. Itérer : Recommencer pour améliorer les résultats

Cette approche systématique s'applique à tous les types de modèles : régression, classification, clustering.

Faire des prédictions

Une fois le modèle entraîné et évalué, il peut être utilisé pour faire des prédictions sur de nouvelles données. Par exemple, pour estimer le poids d'un nouveau garçon de 150 mois mesurant 153 cm, il suffit de fournir ces valeurs au modèle qui retournera une estimation basée sur les patterns appris.

En résumé

• La fonction de coût mesure l'erreur pendant l'entraînement. L'algorithme cherche à la minimiser.
• Les métriques d'évaluation mesurent la performance finale du modèle sur de nouvelles données.
• Pour la régression, attention aux directions :
  • R² proche de 1 = bon modèle
  • RMSE, MAE, MAPE proches de 0 = bon modèle
• Le choix des variables prédictives impacte fortement la qualité du modèle.
• L'évaluation rigoureuse nécessite de séparer les données en ensembles d'entraînement et de test.

La maîtrise de ces concepts d'évaluation est essentielle pour développer des modèles de Machine Learning fiables et performants. Dans les prochains articles, nous explorerons plus en détail les différents types de modèles et leurs spécificités.

La Régression Linéaire : Le Plan de Construction

Formule : y ∼ x₁ + x₂ + ⋯ + xₙ

Imaginez que vous voulez prédire le prix d'une maison. Vous avez plusieurs facteurs : la surface (x₁), le nombre de chambres (x₂), la distance au centre-ville (x₃), etc. La régression linéaire, c'est le plan de construction de votre modèle.

Ce qu'elle fait :

• Combine tous vos facteurs d'entrée (les x) pour prédire une valeur continue (y)
• Attribue un poids à chaque facteur selon son importance
• Trouve la meilleure "ligne" qui relie vos données

Logique à retenir : C'est comme une recette de cuisine. Chaque ingrédient (x) contribue au résultat final (y), et la formule vous dit dans quelles proportions les mélanger.

Exemple concret :

Prix maison ∼ (surface × 2000€) + (chambres × 10000€) - (distance × 500€)

RMSE : Le Juge de l'Erreur

Formule : RMSE = √(1/N × Σ(yₖ - ŷₖ)²)

Une fois votre modèle construit, il faut le juger. Le RMSE (Root Mean Square Error) est le juge impartial qui évalue la qualité de vos prédictions pour les valeurs continues.

Ce qu'elle fait :

• Compare vos prédictions (ŷ) avec les vraies valeurs (y)
• Calcule l'écart au carré pour chaque prédiction
• Fait la moyenne et prend la racine carrée

Logique à retenir : Plus le chiffre est petit, mieux c'est. Un RMSE de 0 signifierait des prédictions parfaites (en pratique impossible).

Pourquoi c'est important :

• Un RMSE de 5000€ sur des prédictions de prix de maison ? Acceptable.
• Un RMSE de 5000€ sur des prédictions de température ? Catastrophique !

Le RMSE doit être interprété dans le contexte de votre problème.

Le Rappel : L'Agent de Sécurité

Formule : Rappel = TP / (TP + FN)

Le rappel (ou recall en anglais) est votre agent de sécurité. Son job ? Ne rien manquer d'important.

Vocabulaire :

• TP (True Positive) : Alarmes justifiées qu'on a détectées
• FN (False Negative) : Alarmes qu'on a ratées (danger !)

Ce qu'elle mesure : Parmi tous les cas positifs réels, combien en avez-vous détectés ?

Logique à retenir : Minimiser les FN (Faux Négatifs). On ne veut rien manquer.

Exemples d'usage :

• Détection de spam : Un rappel de 95% = on a attrapé 95% des spams
• Diagnostic médical : Un rappel de 98% = on a détecté 98% des maladies
• Fraude bancaire : Un rappel de 90% = on a bloqué 90% des transactions frauduleuses

Le piège : On peut avoir un rappel de 100% en classant TOUT comme positif... mais on aura plein de fausses alertes ! D'où l'importance de la précision.

La Précision : Le Contrôleur Qualité

Formule : Précision = TP / (TP + FP)

La précision est le contrôleur qualité de vos alarmes. Elle répond à la question : "Quand mon modèle dit OUI, a-t-il raison ?"

Vocabulaire :

• TP (True Positive) : Alarmes justifiées
• FP (False Positive) : Fausses alarmes (danger !)

Ce qu'elle mesure : Parmi toutes vos alertes, combien sont vraiment justifiées ?

Logique à retenir : Minimiser les FP (Faux Positifs). On veut que l'alarme soit fiable.

Exemples d'usage :

• Filtre anti-spam : Précision de 99% = 99% des emails classés spam sont vraiment des spams
• Virement bancaire : Précision de 95% = 95% des virements bloqués sont réellement frauduleux
• Reconnaissance faciale : Précision de 98% = 98% des identifications sont correctes

Le piège : On peut avoir une précision de 100% en ne détectant que les cas ultra-évidents... mais on ratera beaucoup de cas ! D'où l'importance du rappel.

Le Dilemme Rappel vs Précision

En pratique, on doit souvent choisir :

Privilégier le Rappel (ne rien manquer) :

• Diagnostic médical (mieux vaut une fausse alerte qu'un cancer raté)
• Détection de fraude (on accepte de bloquer quelques virements légitimes)
• Système de sécurité (mieux vaut une fausse alarme qu'un intrus non détecté)

Privilégier la Précision (alarmes fiables) :

• Recommandations produits (ne pas spammer l'utilisateur)
• Validation de documents (ne bloquer que les vrais problèmes)
• Notifications push (éviter de fatiguer l'utilisateur avec de fausses alertes)

Conclusion : Les Formules comme Boussole

Ces formules ne sont pas de simples équations mathématiques. Ce sont des outils de décision qui guident la construction et l'évaluation des modèles d'IA :

1. Régression linéaire : Définit comment combiner les facteurs
2. RMSE : Évalue la qualité des prédictions continues
3. Rappel : S'assure qu'on ne rate rien d'important
4. Précision : S'assure que nos alertes sont fiables

Comprendre ces formules, c'est comprendre le langage des prédictions. Et dans un monde où l'IA prend des décisions de plus en plus importantes, savoir décoder ce langage devient essentiel.

Pour aller plus loin :

• F1-Score : La moyenne harmonique entre rappel et précision
• AUC-ROC : Pour évaluer globalement un modèle de classification
• MAE vs RMSE : Choisir la bonne métrique pour les régressions