Ich habe versucht, TensorFlow auszuführen, eine vom Google-Lehrer veröffentlichte Bibliothek für maschinelles Lernen. Es wird von Python berührt. Installieren Sie es von Anaconda mit dem Befehl pip. Ich werde auf die folgenden Seiten verweisen.
Die Installation von TensorFlow unter Windows war selbst für Python-Anfänger einfach
Anfangs hat es nicht funktioniert, aber als ich die Version von TensorFlow als etwas alt spezifizierte, hat es funktioniert. Verschieben wir also sofort den Code des Tutorials. Probieren Sie es mit dem Code aus, den Sie mit GetStart erhalten können, einer einfachen linearen Regressionsanalyse. Ich habe versucht, auf die folgende Seite zu verweisen.
Wahrscheinlich die einfachste Einführung in TensorFlow
y=0.1x+0.3
Das Problem besteht darin, eine Stichprobe von ungefähr 100 Punkten auf dem Plot zu nehmen und die Parameter der Gleichungen 0,1 und 0,3 zu schätzen.
import tensorflow as tf
import numpy as np
# Create 100 phony x, y data points in NumPy, y = x * 0.1 + 0.3
x_data = np.random.rand(100).astype(np.float32)
y_data = x_data * 0.1 + 0.3
# Try to find values for W and b that compute y_data = W * x_data + b
# (We know that W should be 0.1 and b 0.3, but Tensorflow will
# figure that out for us.)
W = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
b = tf.Variable(tf.zeros([1]))
y = W * x_data + b
# Minimize the mean squared errors.
loss = tf.reduce_mean(tf.square(y - y_data))
optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(loss)
# Before starting, initialize the variables. We will 'run' this first.
init = tf.initialize_all_variables()
# Launch the graph.
sess = tf.Session()
sess.run(init)
# Fit the line.
for step in range(201):
if step % 20 == 0:
print((step, sess.run(W), sess.run(b)))
sess.run(train)
# Learns best fit is W: [0.1], b: [0.3]
Es ist ein sehr gutes Beispiel für die Verwendung von TensorFlow, aber ich bin mir nicht sicher, da die API eine Blackbox enthält. Ich dachte über verschiedene Dinge nach und analysierte, was ich tat. Offensichtlich werden die Anfangswerte der Parameter w und b entsprechend eingestellt, und die Konvergenzoperation wird unter Verwendung der Methode mit dem steilsten Gradienten für die Kostenfunktion des minimalen Quadrats durchgeführt.
[Die Methode mit dem steilsten Abstieg (Wikipedia)](https://ja.wikipedia.org/wiki/%E6%9C%80%E6%80%A5%E9%99%8D%E4%B8%8B%E6%B3% 95)
Der Algorithmus selbst ist keine große Sache, und es ist in Ordnung, wenn Sie die Bewertungsfunktion mit der einmaligen teilweisen Differenzierung des Parameters als Aktualisierungsbetrag aktualisieren. Insbesondere ... ist die Stichprobe wie folgt definiert. (In diesem Beispiel sieht es aus wie N = 100)
\left\{ \left( x_n,y_n \right) \right\}_{n=1}^N
Zu diesem Zeitpunkt ist die Beziehung zwischen x_n und y_n wie folgt konfiguriert. (In diesem Beispiel sind w = 0,1, b = 0,3 wahre Werte)
y_n=wx_n+b
Und da die Kostenfunktion die Summe der Quadrate der Residuen ist, wird sie wie folgt. Sie können sich w und b als Anfangsparameter vorstellen.
L(w,b)=\sum_{n=1}^N \left(y_n - (wx_n+b) \right)^2
Wenn w und b korrekte Werte sind, bin ich natürlich glücklich
L(w,b)=0
Daher sollten Sie nach w und b suchen, die L minimieren.
Bei der Methode mit dem steilsten Gradienten werden die Anfangsparameter einmal durch partielle Differenzierung aktualisiert.
\frac{\partial}{\partial w}L(w,b)=-2\sum_{n=1}^N
\left( y_n - (wx_n+b)\right)x_n
\frac{\partial}{\partial b}L(w,b)=-2\sum_{n=1}^N
\left( y_n - (wx_n+b)\right)
Auf diese Weise scheint es, dass zum Aktualisieren eines bestimmten Parameteranfangswertes w ^ (k), b ^ (k) wie folgt vorgegangen wird.
\left(
\begin{matrix}
w^{(k+1)} \\
b^{(k+1)}
\end{matrix}
\right)
=
\left(
\begin{matrix}
w^{(k)} \\
b^{(k)}
\end{matrix}
\right)
- \alpha
\left(
\begin{matrix}
\frac{\partial L}{\partial w} \\
\frac{\partial L}{\partial b}
\end{matrix}
\right)
\\
=
\left(
\begin{matrix}
w^{(k)} \\
b^{(k)}
\end{matrix}
\right)
+ 2\alpha
\left(
\begin{matrix}
\sum (y_n - (wx_n+b))x_n \\
\sum (y_n - (wx_n+b))
\end{matrix}
\right)
Es tut mir sehr leid, aber der Koeffizient α wird wie folgt festgelegt. Dies wird durch die Eigenschaften der an die TensorFlow-Bibliothek übergebenen Koeffizienten bestimmt.
\alpha = \frac{1}{N} \beta
β ... Gibt es einen Namen? Es scheint, dass dies der erste Einstellparameter für die Konvergenz ist. In dieser Probe ist β = 0,5.
Erstellen wir also unsere eigene Klasse und überprüfen sie.
Wie wäre es mit dem folgenden Gefühl?
class calcWB:
def __init__(self,x,y,w,b):
self.x = x
self.y = y
self.w = w
self.b = b
# get length of sample data
self.N = len(x)
def run(self,beta):
# calculate current redisual
residual = self.y - (self.w*self.x + self.b)
# calc dL/dw
dw = -2*np.dot(residual,self.x)
# calc dL/db
db = -2*sum(residual)
# calc alpha
alpha = beta/self.N
# update param(w,b)
self.w = self.w - alpha*dw
self.b = self.b - alpha*db
return self.w,self.b
Es gibt nur zwei Methoden, eine zum Initialisieren und eine zum Lernen. Wenn Sie dies verwenden, um das erste Beispiel zu ändern, sieht es folgendermaßen aus:
# setting param init data
w_init = np.random.rand()-.5
b_init = np.random.rand()-.5
# GradientDescentOptimizer parameter
beta = 0.5
# Create 100 phony x, y data points in NumPy, y = x * 0.1 + 0.3
x_data = np.random.rand(100).astype(np.float32)
y_data = x_data * 0.1 + 0.3
# Try to find values for W and b that compute y_data = W * x_data + b
# (We know that W should be 0.1 and b 0.3, but TensorFlow will
# figure that out for us.)
#W = tf.Variable(tf.random_uniform([1], -10, 10))
W = tf.Variable(w_init)
#b = tf.Variable(tf.zeros([1]))
b = tf.Variable(b_init)
y = W * x_data + b
# Minimize the mean squared errors.
loss = tf.reduce_mean(tf.square(y - y_data))
optimizer = tf.train.GradientDescentOptimizer(beta)
train = optimizer.minimize(loss)
# Before starting, initialize the variables. We will 'run' this first.
init = tf.global_variables_initializer()
# Launch the graph.
sess = tf.Session()
sess.run(init)
# create calcWB object
objCalcWB = calcWB(x_data,y_data,w_init,b_init)
# Fit the line.
for step in range(201):
sess.run(train)
w_tmp,b_tmp = objCalcWB.run(beta)
if step % 20 == 0:
#print(step, sess.run(W), sess.run(b))
print('[from TensorFlow] k=%d w=%.10f b=%.10f' % (step, sess.run(W), sess.run(b)))
print('[from calcWB] k=%d w=%.10f b=%.10f' % (step,w_tmp,b_tmp))
# Learns best fit is W: [0.1], b: [0.3]
Betrachten Sie das Ausführungsergebnis ...
[from TensorFlow] k=0 w=0.4332985282 b=0.2284004837
[from calcWB] k=0 w=0.4332985584 b=0.2284004998
[from TensorFlow] k=20 w=0.1567724198 b=0.2680215836
[from calcWB] k=20 w=0.1567724287 b=0.2680215712
[from TensorFlow] k=40 w=0.1113634855 b=0.2935992479
[from calcWB] k=40 w=0.1113634986 b=0.2935992433
[from TensorFlow] k=60 w=0.1022744998 b=0.2987188399
[from calcWB] k=60 w=0.1022745020 b=0.2987188350
[from TensorFlow] k=80 w=0.1004552618 b=0.2997435629
[from calcWB] k=80 w=0.1004552578 b=0.2997435619
[from TensorFlow] k=100 w=0.1000911444 b=0.2999486625
[from calcWB] k=100 w=0.1000911188 b=0.2999486686
[from TensorFlow] k=120 w=0.1000182480 b=0.2999897301
[from calcWB] k=120 w=0.1000182499 b=0.2999897517
[from TensorFlow] k=140 w=0.1000036523 b=0.2999979556
[from calcWB] k=140 w=0.1000036551 b=0.2999979575
[from TensorFlow] k=160 w=0.1000007242 b=0.2999995947
[from calcWB] k=160 w=0.1000007308 b=0.2999995937
[from TensorFlow] k=180 w=0.1000001431 b=0.2999999225
[from calcWB] k=180 w=0.1000001444 b=0.2999999224
[from TensorFlow] k=200 w=0.1000000909 b=0.2999999523
[from calcWB] k=200 w=0.1000000255 b=0.2999999832
Es scheint, dass es eine gute Idee ist, weil es ungefähr 7 Stellen nach dem Dezimalpunkt hat.
Nun, ich glaube, ich verstehe ein wenig, was TensorFlows Gradient Descent Optimizer tut.
Recommended Posts