Lernen Implementierung des Gradientenabstiegs in Python

Gradientenabstieg folgt einer einfachen, aber wirkungsvollen Idee: Bewegung in Richtung des steilsten Abstiegs, um eine Funktion zu minimieren.

Die mathematische Regel lautet:

theta = theta - alpha * gradient(theta)

Dabei gilt:

theta ist der zu optimierende Parameter;
alpha ist die Lernrate (Schrittweite);
gradient(theta) ist der Gradient der Funktion an der Stelle theta.

1. Definition der Funktion und ihrer Ableitung

Wir beginnen mit einer einfachen quadratischen Funktion:

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

Ihre Ableitung (Gradient) ist:

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

f(theta): Dies ist unsere Funktion, für die wir den Wert von theta finden möchten, der sie minimiert;
gradient(theta): Gibt die Steigung an jedem Punkt theta an, die zur Bestimmung der Aktualisierungsrichtung verwendet wird.

2. Initialisierung der Parameter für den Gradientenabstieg

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

alpha (Lernrate): Steuert die Größe jedes Schrittes;
theta (Anfangswert): Startpunkt für den Abstieg;
tolerance: Sobald die Aktualisierungen sehr klein werden, wird gestoppt;
max_iterations: Verhindert eine Endlosschleife.

3. Gradientenabstieg durchführen

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

Berechnung des Gradienten bei theta;
Aktualisierung von theta mit der Gradientenabstiegsformel;
Abbruch, wenn die Aktualisierungen zu klein sind (Konvergenz);
Ausgabe jedes Schritts zur Überwachung des Fortschritts.

4. Visualisierung des Gradientenabstiegs


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

Dieses Diagramm zeigt:

Die Funktionskurve $f(θ) = θ^2$ ;
Rote Punkte, die jeden Schritt des Gradientenabstiegs bis zur Konvergenz darstellen.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 3. Kapitel 10

Fragen Sie AI

Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen

Awesome!

Completion rate improved to 1.96

Swipe um das Menü anzuzeigen