Manuelle Implementierung der Kettenregel
Konstruieren Sie eine zusammengesetzte Funktion, berechnen Sie manuell lokale Gradienten Schicht für Schicht und multiplizieren Sie sie, dann verifizieren Sie mit sympy.
Nach Abschluss dieses Falls verstehen Sie:Der Kern der Backpropagation ist die Kettenregel—jede Schicht berechnet nur ihren eigenen lokalen Gradienten, und der endgültige Gradient ist das Produkt der Gradienten jeder Schicht.
Einführung aus dem Alltag
Die Domino-Produktionslinie
Eine Fabrik hat drei Prozesse: Rohmaterial → Halbfertigprodukt A → Halbfertigprodukt B → Fertigprodukt. Sie möchten wissen: "Wenn das Rohmaterial um 1 kg erhöht wird, wie viele zusätzliche Fertigprodukte entstehen dann?"
Sie müssen die Formel für den gesamten Prozess nicht von Grund auf herleiten. Jeder Prozess berechnet nur sein eigenes "lokales Verhältnis": Wenn Halbfertigprodukt A um 1 zunimmt, wie viele zusätzliche Halbfertigprodukte B entstehen dann? Wenn Halbfertigprodukt B um 1 zunimmt, wie viele zusätzliche Fertigprodukte? Multiplizieren Sie die drei Verhältnisse, und Sie erhalten die Antwort.
Dies istdie Kettenregel—jede Schicht kümmert sich nur um sich selbst, und die endgültige Auswirkung = das Produkt der Auswirkungen jeder Schicht.
Intuitive Vorstellung
Konstruieren Sie eine dreischichtige zusammengesetzte Funktion:
x^2+1
3*sin(u)
v^2
Praktische Python-Übung
Beispiel
import numpy as np
def g(x): return x ** 2 + 1
def f(u): return 3 * np.sin(u)
def g_prime(x): return 2 * x
def f_prime(u): return 3 * np.cos(u)
x0 = 1.5
# ---- Manuelle Kettenregel ----
u0 = g(x0)
dy_du = f_prime(u0) # Lokaler Gradient von Schicht 2
du_dx = g_prime(x0) # Lokaler Gradient von Schicht 1
manual_grad = dy_du * du_dx
print("=" * 55)
print("BEISPIEL Manuelle Kettenregel")
print(f"x0 = {x0}, u = g(x0) = {u0:.4f}")
print(f"dy/du = 3*cos(u) = {dy_du:.4f}")
print(f"du/dx = 2*x0 = {du_dx:.4f}")
print(f"Kettenmultiplikation: dy/dx = {manual_grad:.4f}")
# ---- sympy automatische Differentiation (Standardantwort) ----
x = sp.Symbol('x')
y_expr = 3 * sp.sin(x**2 + 1)
auto_grad = float(sp.diff(y_expr, x).subs(x, x0))
print(f"\n"BEISPIEL sympy automatische Differentiation = {auto_grad:.4f}")
print(f"Die beiden Methoden stimmen überein: {np.isclose(manual_grad, auto_grad)}")
# ---- Erweiterung: dreischichtige Komposition ----
def h(v): return v ** 2
def h_prime(v): return 2 * v
v0 = f(u0)
dy_dv = h_prime(v0)
grad_3layer = dy_dv * dy_du * du_dx
print(f"\n"BEISPIEL dreischichtige Gradientenfortpflanzung: ")
print(f" Schicht 3: {dy_dv:.4f} x Schicht 2: {dy_du:.4f} x Schicht 1: {du_dx:.4f} = {grad_3layer:.4f}")
======================================================= EXAMPLE 手动链式法则 x0 = 1.5, u = g(x0) = 3.2500 dy/du = 3*cos(u) = -2.9838 du/dx = 2*x0 = 3.0000 链式相乘: dy/dx = -8.9514 EXAMPLE sympy 自动求导 = -8.9514 两种方法一致: True EXAMPLE 三层梯度传递： 第3层: 6.5000 x 第2层: -2.9838 x 第1层: 3.0000 = -58.1841
Anwendungsszenarien in der KI
| Szenario | Beziehung zur Kettenregel |
|---|---|
| Backpropagation | Jede Schicht eines neuronalen Netzes berechnet nur ihren eigenen lokalen Gradienten und gibt ihn dann an die vorherige Schicht weiter. |
| PyTorch-Autograd | Jede Operation automatisch verfolgen, um einen Rechengraphen aufzubauen, und während der Backpropagation automatisch die Kettenregel anwenden |
| Gradientenprüfung | Nachdem Sie die Backpropagation manuell implementiert haben, überprüfen Sie sie mit numerischen Gradienten – das ist in diesem Fall Methode 1 vs. Methode 2 |