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