Lära Implementering av Gradientnedstigning i Python

Gradientnedstigning följer en enkel men kraftfull idé: rör dig i riktning mot brantaste nedstigning för att minimera en funktion.

Den matematiska regeln är:

theta = theta - alpha * gradient(theta)

Där:

theta är parametern vi optimerar;
alpha är inlärningshastigheten (stegstorlek);
gradient(theta) är gradienten av funktionen vid theta.

1. Definiera funktionen och dess derivata

Vi börjar med en enkel kvadratisk funktion:

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

Dess derivata (gradient) är:

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

f(theta): detta är vår funktion, och vi vill hitta det värde på theta som minimerar den;
gradient(theta): detta anger lutningen vid varje punkt theta, vilket vi använder för att bestämma uppdateringsriktningen.

2. Initiera parametrar för gradientnedstigning

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

alpha (inlärningshastighet): styr hur stora stegen är;
theta (initialt gissning): startpunkt för nedstigningen;
tolerance: när uppdateringarna blir mycket små, avbryts processen;
max_iterations: säkerställer att vi inte fastnar i en oändlig loop.

3. Utför gradientnedstigning

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

Beräkna gradienten vid theta;
Uppdatera theta med gradientnedstigningsformeln;
Avsluta när uppdateringarna är för små (konvergens);
Skriv ut varje steg för att övervaka processen.

4. Visualisering av gradientnedstigning


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

Detta diagram visar:

Funktionskurvan $f(θ) = θ^2$ ;
Röda punkter som representerar varje steg i gradientnedstigningen tills konvergens.

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 3. Kapitel 10

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

Awesome!

Completion rate improved to 1.96

Svep för att visa menyn