TP – Régression linéaire par descente de gradient¶

Méthode MANUELLE (sans scikit-learn)¶

Cours : Machine Learning
Auteur : Pr. El Alam

Objectif du TP¶

L’objectif de ce travail pratique est de comprendre pas à pas comment un modèle de Machine Learning apprend à partir des données.

Dans ce TP :

  • nous n’utilisons aucune bibliothèque de Machine Learning,
  • nous implémentons manuellement la descente de gradient,
  • nous cherchons à comprendre chaque étape de l’apprentissage.

1. Importation des bibliothèques¶

In [1]:
# NumPy pour les calculs numériques
import numpy as np

# Matplotlib pour les graphiques
import matplotlib.pyplot as plt

2. Génération des données fictives¶

Nous créons un jeu de données artificiel afin de simplifier l’apprentissage. Les données suivent une relation presque linéaire, avec des erreurs (bruit).

In [2]:
# Fixer l'aléatoire pour avoir toujours les mêmes résultats
np.random.seed(42)

# Nombre d'observations
n = 200

# Variable d'entrée x (entre 0 et 10)
X = np.random.uniform(0, 10, size=n)

# Paramètres réels (connus uniquement par le professeur)
a_true = 3.0
b_true = 2.0

# Bruit : erreurs réalistes
noise = np.random.normal(0, 2, size=n)

# Variable de sortie y
y = a_true * X + b_true + noise

⚠️ Remarque importante : Le modèle ne connaît pas les valeurs a_true et b_true. Il voit uniquement les données X et y.

3. Visualisation des données¶

In [3]:
plt.scatter(X, y)
plt.xlabel("x (entrée)")
plt.ylabel("y (sortie)")
plt.title("Données fictives avec bruit")
plt.show()

4. Modèle linéaire¶

Nous utilisons le modèle suivant :

ŷ = a·x + b

Au début :

  • a = 0
  • b = 0

Le modèle ne sait rien et va apprendre progressivement.

In [4]:
# Initialisation des paramètres du modèle
a = 0.0
b = 0.0

5. Principe de la descente de gradient¶

La descente de gradient consiste à :

  1. prédire les valeurs de y,
  2. calculer l'erreur,
  3. corriger les paramètres a et b,
  4. répéter ce processus plusieurs fois.
In [5]:
# Hyperparamètres de la descente de gradient
learning_rate = 0.01  # taille du pas
n_iter = 1000         # nombre d'itérations

6. Apprentissage du modèle (boucle)¶

In [6]:
for i in range(n_iter):
    # Prédiction du modèle
    y_pred = a * X + b

    # Calcul de l'erreur
    error = y - y_pred

    # Calcul des gradients
    da = -2 * np.mean(X * error)
    db = -2 * np.mean(error)

    # Mise à jour des paramètres
    a = a - learning_rate * da
    b = b - learning_rate * db

7. Paramètres appris¶

Après l'apprentissage, le modèle a appris les paramètres a et b.

In [7]:
print("Pente apprise (a) =", round(a, 3))
print("Intercept appris (b) =", round(b, 3))

Pente apprise (a) = 2.986
Intercept appris (b) = 2.202

8. Visualisation du modèle appris¶

In [8]:
plt.scatter(X, y, label="Données")
plt.plot(X, a * X + b, color="red", label="Modèle appris")
plt.legend()
plt.show()

Conclusion¶

Ce TP montre que :

  • un modèle commence sans connaissance,
  • il fait des erreurs,
  • il corrige progressivement ses paramètres,
  • il converge vers une solution.

C’est le principe fondamental du Machine Learning.

In [ ]: