Apprendre Implémentation de la Descente de Gradient en Python

La descente de gradient repose sur une idée simple mais puissante : se déplacer dans la direction de la plus forte pente descendante afin de minimiser une fonction.

La règle mathématique est :

theta = theta - alpha * gradient(theta)

Où :

theta est le paramètre que nous optimisons ;
alpha est le taux d'apprentissage (taille du pas) ;
gradient(theta) est le gradient de la fonction en theta.

1. Définir la fonction et sa dérivée

Nous commençons par une fonction quadratique simple :

def f(theta):
    return theta**2  # Function we want to minimize

Sa dérivée (gradient) est :

def gradient(theta):
    return 2 * theta  # Derivative: f'(theta) = 2*theta

f(theta) : il s'agit de notre fonction, et nous cherchons la valeur de theta qui la minimise ;
gradient(theta) : cela nous indique la pente en tout point theta, que nous utilisons pour déterminer la direction de mise à jour.

2. Initialiser les paramètres de la descente de gradient

alpha = 0.3  # Learning rate
theta = 3.0  # Initial starting point
tolerance = 1e-5  # Convergence threshold
max_iterations = 20  # Maximum number of updates

alpha (taux d'apprentissage) : contrôle la taille de chaque pas ;
theta (estimation initiale) : point de départ de la descente ;
tolerance : lorsque les mises à jour deviennent très petites, on arrête ;
max_iterations : garantit que l'on ne boucle pas indéfiniment.

3. Exécution de la descente de gradient

for i in range(max_iterations):
    grad = gradient(theta)  # Compute gradient
    new_theta = theta - alpha * grad  # Update rule
    if abs(new_theta - theta) < tolerance:
        print("Converged!")
        break
    theta = new_theta

Calcul du gradient en theta ;
Mise à jour de theta selon la formule de descente de gradient ;
Arrêt lorsque les mises à jour deviennent trop faibles (convergence) ;
Affichage de chaque étape pour suivre la progression.

4. Visualisation de la descente de gradient


              123456789101112131415161718192021222324252627282930313233343536373839
            
import matplotlib.pyplot as plt
import numpy as np

def f(theta):
    return theta**2  # Function we want to minimize

def gradient(theta):
    return 2 * theta  # Derivative: f'(theta) = 2*theta

alpha = 0.3           # Learning rate
theta = 3.0           # Initial starting point
tolerance = 1e-5      # Convergence threshold
max_iterations = 20   # Maximum number of updates

theta_values = [theta]          # Track parameter values
output_values = [f(theta)]      # Track function values

for i in range(max_iterations):
    grad = gradient(theta)                # Compute gradient
    new_theta = theta - alpha * grad      # Update rule
    if abs(new_theta - theta) < tolerance:
        break
    theta = new_theta
    theta_values.append(theta)
    output_values.append(f(theta))

# Prepare data for plotting the full function curve
theta_range = np.linspace(-4, 4, 100)
output_range = f(theta_range)

# Plot
plt.plot(theta_range, output_range, label="f(θ) = θ²", color='black')
plt.scatter(theta_values, output_values, color='red', label="Gradient Descent Steps")
plt.title("Gradient Descent Visualization")
plt.xlabel("θ")
plt.ylabel("f(θ)")
plt.legend()
plt.grid(True)
plt.show()

Ce graphique montre :

La courbe de la fonction $f(θ) = θ^2$ ;
Points rouges représentant chaque étape de la descente de gradient jusqu'à la convergence.

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 10

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Awesome!

Completion rate improved to 1.96

Glissez pour afficher le menu