J'ai essayé d'exécuter TensorFlow, une bibliothèque d'apprentissage automatique publiée par un enseignant de Google. Il sera touché par Python. Installez-le depuis Anaconda avec la commande pip. Je ferai référence aux sites suivants.
L'installation de TensorFlow sur Windows était facile même pour les débutants en Python
Cela n'a pas fonctionné au début, mais quand j'ai spécifié que la version de TensorFlow était un peu ancienne, cela a fonctionné. Alors, déplaçons le code du tutoriel ??? immédiatement. Essayez-le avec le code que vous pouvez obtenir avec GetStart, une simple analyse de régression linéaire. J'ai essayé de me référer au site suivant.
Probablement l'introduction la plus simple à TensorFlow
y=0.1x+0.3
Le problème est de prélever un échantillon d'environ 100 points sur le graphique et d'estimer les paramètres des équations 0,1 et 0,3.
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]
C'est un très bon exemple en termes d'utilisation de TensorFlow, mais je ne suis pas sûr car l'API est en boîte noire. J'ai réfléchi à diverses choses et analysé ce que je faisais. Apparemment, les valeurs initiales des paramètres w et b sont fixées de manière appropriée, et l'opération de convergence est effectuée en utilisant la méthode du gradient le plus raide pour la fonction de coût du carré minimum.
[Méthode de descente la plus raide (Wikipedia)](https://ja.wikipedia.org/wiki/%E6%9C%80%E6%80%A5%E9%99%8D%E4%B8%8B%E6%B3% 95)
L'algorithme lui-même n'est pas un gros problème, et il n'y a pas de problème si vous mettez à jour la fonction d'évaluation avec la différenciation partielle unique du paramètre comme quantité de mise à jour. Plus précisément ... l'échantillon est défini comme suit. (Dans cet exemple, cela ressemble à N = 100)
\left\{ \left( x_n,y_n \right) \right\}_{n=1}^N
À ce stade, la relation entre x_n et y_n est configurée comme suit. (Dans cet exemple, w = 0,1, b = 0,3 sont des valeurs vraies)
y_n=wx_n+b
Et puisque la fonction de coût est la somme des carrés des résidus, elle devient comme suit. Vous pouvez considérer w et b comme des paramètres initiaux.
L(w,b)=\sum_{n=1}^N \left(y_n - (wx_n+b) \right)^2
Bien sûr, quand w et b sont des valeurs correctes, je suis content
L(w,b)=0
Par conséquent, vous devez rechercher w et b qui minimisent L.
Dans la méthode du gradient le plus raide, les paramètres initiaux sont mis à jour une fois par différenciation partielle, donc obtenez chacun.
\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)
En utilisant cela, il semble que pour mettre à jour une certaine valeur initiale de paramètre, w ^ (k), b ^ (k), procédez comme suit.
\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)
Je suis vraiment désolé, mais le coefficient α est décidé comme suit. Ceci est déterminé par les caractéristiques des coefficients transmis à la bibliothèque TensorFlow.
\alpha = \frac{1}{N} \beta
β ... Y a-t-il un nom? Il semble que ce soit le premier paramètre de réglage de la convergence. Dans cet échantillon, β = 0,5.
Alors, créons notre propre classe et vérifions-la.
Et la sensation suivante?
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
Il n'y a que deux méthodes, une pour l'initialisation et une pour l'apprentissage. En utilisant ceci pour modifier le premier échantillon, il ressemble à ceci:
# 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]
En regardant le résultat de l'exécution ...
[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
Il semble que ce soit une bonne idée car il comporte environ 7 chiffres après la virgule décimale.
Eh bien, je pense que je comprends un peu ce que fait l'Optimiseur de descente de gradient de TensorFlow.
Recommended Posts