Impara Implementazione della Discesa del Gradiente in Python

Scorri per mostrare il menu

La discesa del gradiente segue un'idea semplice ma potente: muoversi nella direzione della massima discesa per minimizzare una funzione.

La regola matematica è:

theta = theta - alpha * gradient(theta)

Dove:

theta è il parametro che stiamo ottimizzando;
alpha è il tasso di apprendimento (dimensione del passo);
gradient(theta) è il gradiente della funzione in theta.

1. Definizione della funzione e della sua derivata

Si parte da una semplice funzione quadratica:

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

La sua derivata (gradiente) è:

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

f(theta): questa è la nostra funzione, e vogliamo trovare il valore di theta che la minimizza;
gradient(theta): indica la pendenza in ogni punto theta, che viene utilizzata per determinare la direzione dell'aggiornamento.

2. Inizializzazione dei parametri della discesa del gradiente

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

alpha (tasso di apprendimento): controlla l'ampiezza di ogni passo;
theta (ipotesi iniziale): punto di partenza per la discesa;
tolerance: quando gli aggiornamenti diventano molto piccoli, si interrompe il processo;
max_iterations: garantisce che il ciclo non sia infinito.

3. Esecuzione della discesa del gradiente

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

Calcolo del gradiente in theta;
Aggiornamento di theta utilizzando la formula della discesa del gradiente;
Arresto quando gli aggiornamenti sono troppo piccoli (convergenza);
Stampa di ogni passaggio per monitorare i progressi.

4. Visualizzazione della discesa del gradiente


              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()

Questo grafico mostra:

La curva della funzione $f(θ) = θ^2$ ;
Punti rossi che rappresentano ciascun passo della discesa del gradiente fino alla convergenza.

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 3. Capitolo 10

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Sezione 3. Capitolo 10