Lære Implementering av Gradient Descent i Python

Gradient descent følger en enkel, men kraftfull idé: beveg deg i retning av bratteste nedstigning for å minimere en funksjon.

Den matematiske regelen er:

theta = theta - alpha * gradient(theta)

Hvor:

theta er parameteren vi optimaliserer;
alpha er læringsraten (størrelsen på steget);
gradient(theta) er gradienten til funksjonen ved theta.

1. Definer funksjonen og dens derivert

Vi starter med en enkel kvadratisk funksjon:

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

Dens derivert (gradient) er:

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

f(theta): dette er funksjonen vår, og vi ønsker å finne verdien av theta som minimerer den;
gradient(theta): dette gir oss stigningstallet ved et hvilket som helst punkt theta, som vi bruker for å bestemme oppdateringsretningen.

2. Initialiser parametere for gradient descent

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 steg er;
theta (startverdi): startpunktet for nedstigningen;
tolerance: når oppdateringene blir svært små, stopper vi;
max_iterations: sikrer at vi ikke havner i en uendelig løkke.

3. Utføre 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;
Oppdater theta ved hjelp av formelen for gradientnedstigning;
Stopp når oppdateringene blir for små (konvergens);
Skriv ut hvert steg for å overvåke fremdriften.

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

Dette plottet viser:

Funksjonskurven $f(θ) = θ^2$ ;
Røde prikker som representerer hvert gradientnedstigningssteg frem til konvergens.

Alt var klart?

Takk for tilbakemeldingene dine!

Seksjon 3. Kapittel 10

Spør AI

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Awesome!

Completion rate improved to 1.96

Sveip for å vise menyen