[PYTHON] Deep Learning von Grund auf neu 4.3.3 Zeichnen Sie einen Gradientenvektor Ihrer eigenen Funktion basierend auf dem Beispielcode der partiellen Differenzierung.
Einführung
4.3.3 Partielle Differenzierung liefert ein Beispiel für das Zeichnen eines Gradientenvektors von f = x0 ^ 2 + x1 ^ 2 mit Code.
Auf dieser Grundlage blieb ich stecken, als ich versuchte, das Ergebnis von f = x0 * x1 zu zeichnen, und werde die Lösung beschreiben.
Der ursprüngliche Beispielcode lautet Deep-Learning-from-Scratch / ch04 / gradient_2d.py. ) ist.
Das Ausführungsergebnis ist wie folgt.
Überprüfung
Zunächst wird der Verifizierungsergebniscode dieser Zeit angezeigt.
# coding: utf-8
# cf.http://d.hatena.ne.jp/white_wheels/20100327/p3
import numpy as np
import matplotlib.pylab as plt
from mpl_toolkits.mplot3d import Axes3D
def _numerical_gradient_no_batch(f, x):
h = 1e-4 # 0.0001
grad = np.zeros_like(x)
for idx in range(x.size):
tmp_val = x[idx]
x[idx] = float(tmp_val) + h
fxh1 = f(x) # f(x+h)
x[idx] = tmp_val - h
fxh2 = f(x) # f(x-h)
grad[idx] = (fxh1 - fxh2) / (2*h)
x[idx] = tmp_val #Stellen Sie den Wert wieder her
return grad
def numerical_gradient(f, X):
if X.ndim == 1:
return _numerical_gradient_no_batch(f, X)
else:
grad = np.zeros_like(X)
for idx, x in enumerate(X):
grad[idx] = _numerical_gradient_no_batch(f, x)
return grad
def function_2(x):
if x.ndim == 1:
return np.sum(x**2)
else:
return np.sum(x**2, axis=1)
# f = x0*x1, df/dx0 = x1, df/dx1 = x0
# can110
def function_xy(x):
if x.ndim == 1:
return x[0]*x[1]
else:
return x[:,0]*x[:,1]
# f = sin(x0*x1), df/dx0 = x1*cos(x0*x1), df/dx1 = x0*cos(x0*x1)
# can110
def function_sin_xy(x):
if x.ndim == 1:
return np.sin(x[0]*x[1])
else:
return np.sin(x[:,0]*x[:,1])
def tangent_line(f, x):
d = numerical_gradient(f, x)
print(d)
y = f(x) - d*x
return lambda t: d*t + y
if __name__ == '__main__':
x0 = np.arange(-2, 2.5, 0.25)
x1 = np.arange(-2, 2.5, 0.25)
X, Y = np.meshgrid(x0, x1)
X = X.flatten()
Y = Y.flatten()
a = np.array([X, Y])
a = a.T #Translokation. 1 Zeile=1 Vektor (Spalte=x0,x1) sollte can110 sein
#Überprüfung
#func = function_2 # df/dx0(=2*x0), df/dx1(=2*x1)Sind jeweils x0,Funktioniert es gerade, da es nur aus x1 berechnet wird?
func = function_xy
#func = function_sin_xy
#grad = numerical_gradient(function_2, np.array([X, Y]) )
grad = numerical_gradient(func, a)
grad = grad.T #Transponiert für Köcher (x0 pro Reihe,Platziere x1 Koordinatenwerte) can110
plt.figure()
plt.quiver(X, Y, -grad[0], -grad[1], angles="xy",color="#666666")#,headwidth=10,scale=40,color="#444444")
plt.xlim([-2, 2])
plt.ylim([-2, 2])
plt.xlabel('x0')
plt.ylabel('x1')
plt.grid()
plt.legend()
plt.draw()
plt.show()
Dieses Mal habe ich die Funktion f = x0 * x1 wie folgt definiert. Übrigens wird bei dieser Gradientenberechnung nur der Teil von "x.ndim == 1" aufgerufen.
def function_xy(x):
if x.ndim == 1:
return x[0]*x[1]
else:
return x[:,0]*x[:,1]
Ich habe dies durch das ursprüngliche function_2 ersetzt und es ausgeführt, aber mit einigen seltsamen Ergebnissen.
Also folgte ich dem eigentlichen Gradientenberechnungscode.
Die Funktion "numerischer Gradient" wird für mehrere Vektoren verwendet → Die Funktion "numerischer Gradient_no_batch" wird verwendet, um den Gradienten für einen Vektor zu berechnen.
Wenn Sie also x.shape in _numerical_gradient_no_batch betrachten, ist es (324,). Die Anzahl der Vektoren (zu zeichnende Punkte).
Dies sollte ** (2,) ** sein. Also, wenn Sie den Anrufer überprüfen
grad = numerical_gradient(function_2, np.array([X, Y]) )
Wir übergeben einen Satz von X (x0) - und Y (x1) -Koordinaten. Das ist die Ursache. Durch die Übersetzung von "np.array ([X, Y]" in die Form von "1 Zeile = 1 Vektor (Punkt)" wird es nun korrekt gezeichnet.
Zusammenfassung
- Übergeben Sie das transponierte Ergebnis (1 Zeile = 1 Vektor) an die Funktion "numerischer Gradient".
- Das Ergebnis von "numerischer Gradient" wird auch für die "Köcher" -Zeichnung transponiert (x0-, x1-Koordinatenwerte werden für jede Linie angeordnet).
Richtige / falsche Tabelle von "Deep Learning von Grund auf neu" ??
Recommended Posts