Lære Implementering af Gradientnedstigning i Python

Gradient descent følger en simpel, men kraftfuld idé: bevæg dig i retningen af stejleste fald for at minimere en funktion.

Den matematiske regel er:

theta = theta - alpha * gradient(theta)

Hvor:

theta er parameteren, vi optimerer;
alpha er læringsraten (skridtlængde);
gradient(theta) er gradienten af funktionen ved theta.

1. Definer funktionen og dens afledte

Vi starter med en simpel kvadratisk funktion:

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

Dens afledte (gradient) er:

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

f(theta): dette er vores funktion, og vi ønsker at finde den værdi af theta, der minimerer den;
gradient(theta): dette angiver hældningen ved ethvert punkt theta, hvilket bruges til at bestemme opdateringsretningen.

2. Initialiser gradient descent-parametre

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

alpha (læringsrate): styrer hvor store hvert skridt er;
theta (startgæt): udgangspunktet for descent;
tolerance: når opdateringerne bliver meget små, stopper vi;
max_iterations: sikrer, at vi ikke kører i en uendelig løkke.

3. Udfø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

Beregn gradienten ved theta;
Opdater theta ved hjælp af gradientnedstigningsformlen;
Stop, når opdateringerne er for små (konvergens);
Udskriv hvert trin for at overvåge fremdriften.

4. Visualisering af 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()

Dette plot viser:

Funktionskurven $f(θ) = θ^2$ ;
Røde prikker repræsenterer hvert gradient descent-trin indtil konvergens.

Var alt klart?

Tak for dine kommentarer!

Sektion 3. Kapitel 10

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

Awesome!

Completion rate improved to 1.96

Stryg for at vise menuen