Mon précédent article TensorFlow pour la première fois - Régression linéaire en guise d'introduction a été écrit juste après la sortie de TensorFlow. Parmi eux, c'est un article que vous pouvez aimer. Il y a à peu près un an et demi, je voulais donc réviser l'article en tenant compte de la mise à niveau de la version de TensorFlow. Le contenu suit ce qui précède et est une régression linéaire et une régression logistique.
(L'environnement de programmation est le suivant. Au 29 mai 2017.)
Dans l'édition précédente de "First Time ...", nous avons présenté le Tutoriel de "Theano", Newmu / Theano-Tutorials --GitHub, et avons poursuivi la discussion en le portant sur TensorFlow. https://github.com/Newmu/Theano-Tutorials
L'autre jour, j'ai trouvé un tutoriel de TensorFlow avec presque le même contenu sur GitHub, donc je voudrais le présenter. https://github.com/nlintz/TensorFlow-Tutorials
TensorFlow-Tutorials
Introduction to deep learning based on Google's TensorFlow framework. These tutorials are direct ports of Newmu's Theano Tutorials.
Un court code de tutoriel est publié afin que vous puissiez approfondir votre compréhension de «TensorFlow» étape par étape. En plus du code Python, un notebook jupyter est également publié. Même si vous n'êtes plus un débutant, vous pouvez l'utiliser comme un livre de cuisine en téléchargeant (cloner) le référentiel sur votre PC et en le référençant lors du codage, nous vous recommandons donc de vous y référer. 00_multiply.py (multiplication simple) est suivi de 01_linear_regression.py (régression linéaire) et 02_logistic_regression.py (régression logistique), je voudrais donc expliquer cet article en conséquence. Cependant, le contenu a été légèrement personnalisé car il est ennuyeux de réimprimer le code.
Premièrement, à partir de la régression linéaire. Après avoir importé les modules associés, préparez les données à utiliser. (L'original était des données de test sans section b, mais ici il est inclus b (biais = 3.).)
import tensorflow as tf
import numpy as np
trX = np.linspace(-1, 1, 101)
#Le code d'origine n'a pas de terme de biais, mais ici il est biaisé(=3)Être un modèle qui comprend
target_w = 2.
target_b = 3.
noise_gain = 0.33
trY = target_w * trX + target_b + np.random.randn(*trX.shape) * noise_gain
model () est une fonction utilisée comme modèle de régression. (Fonction linéaire avec la pente w et la section b comme paramètres.)
def model(X, w, b):
#Modèle de prédicteur linéaire
#Dans le code d'origine tf.muliply()Est utilisé mais l'opérateur"*"D'accord.
# return tf.multiply(X, w) + b
return X * w + b
Ensuite, préparez les variables nécessaires.
# TensorFlow placeholders
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
# TensorFlow Variables
w = tf.Variable(0.0, name="weights") # zero initialize
b = tf.Variable(0.0, name="bias") # zero initialize
x et y sont préparés par la terminologie unique "placeholder". Puisqu'il s'agit d'un espace réservé, il n'y a pas de valeur réelle au moment de la déclaration et la valeur réelle sera affectée dans le traitement du programme suivant. Par contre, les valeurs initiales de w et b, qui sont des variables Tensor ordinaires, sont nulles.
Ensuite, nous décrivons la relation importante entre les variables appelées Graph.
y_model = model(X, w, b)
cost = tf.reduce_mean(tf.square(Y - y_model))
Le coût est une fonction de coût qui correspond à la différence entre votre modèle et les données réelles. "tf.reduce_mean ()" est une fonction pour calculer la moyenne. Par conséquent, le code ci-dessus calcule MSE (= erreur quadratique moyenne).
Ensuite, définissez la spécification de l'Optimiseur et sa méthode de calcul de la recherche de paramètre.
train_op = tf.train.GradientDescentOptimizer(0.01).minimize(cost)
Ici, l'optimiseur de la méthode de descente de gradient est spécifié, et le taux d'apprentissage de 0,01 est donné en argument.
Maintenant, je suis curieux d'Optimizer, mais TensorFlow prend actuellement en charge ce qui suit (une partie du tableau ci-dessous). http://www.tensorflow.org/api_docs/python/train.html#optimizers
| Optimizer name | Description (Lien de référence) |
|---|---|
| GradientDescentOptimizer | Méthode de descente de gradient https://ja.wikipedia.org/wiki/%E7%A2%BA%E7%8E%87%E7%9A%84%E5%8B%BE%E9%85%8D%E9%99%8D%E4%B8%8B%E6%B3%95 |
| AdagradOptimizer | Méthode AdaGrad https://ja.wikipedia.org/wiki/%E7%A2%BA%E7%8E%87%E7%9A%84%E5%8B%BE%E9%85%8D%E9%99%8D%E4%B8%8B%E6%B3%95#AdaGrad |
| MomentumOptimizer | Méthode Momentum https://ja.wikipedia.org/wiki/%E7%A2%BA%E7%8E%87%E7%9A%84%E5%8B%BE%E9%85%8D%E9%99%8D%E4%B8%8B%E6%B3%95#.E3.83.A2.E3.83.A1.E3.83.B3.E3.82.BF.E3.83.A0.E6.B3.95 |
| AdamOptimizer | Méthode Adam https://ja.wikipedia.org/wiki/%E7%A2%BA%E7%8E%87%E7%9A%84%E5%8B%BE%E9%85%8D%E9%99%8D%E4%B8%8B%E6%B3%95#Adam |
| RMSPropOptimizer | Méthode RMSProp https://ja.wikipedia.org/wiki/%E7%A2%BA%E7%8E%87%E7%9A%84%E5%8B%BE%E9%85%8D%E9%99%8D%E4%B8%8B%E6%B3%95#RMSProp |
Les paramètres qui doivent être définis varient en fonction de l'optimiseur, mais cette fois, nous utiliserons le GradientDescentOptimizer de base. (Le taux d'apprentissage des paramètres requis a été défini comme décrit ci-dessus.)
Maintenant que nous sommes presque prêts, nous commençons une session qui montre la partie principale du calcul.
# Launch the graph in a session
with tf.Session() as sess:
# you need to initialize variables (in this case just variable W)
tf.global_variables_initializer().run()
for i in range(100):
for (x, y) in zip(trX, trY):
sess.run(train_op, feed_dict={X: x, Y: y})
final_w, final_b = sess.run([w, b])
Immédiatement après le démarrage de la session, les variables (Variables) sont initialisées.
(Remarque. Dans la version précédente, j'ai écrit que "les variables doivent être initialisées avant de démarrer la session", mais c'est incorrect. Dans le code précédent, le traitement d'initialisation (init op) avant la session. ) Est défini, et après le démarrage de la session, il est exécuté par sess.run (init). Cette fois, le processus d'initialisation est défini et run () est exécuté immédiatement après la session.)
Pour le moment, si vous cochez "Initialisation des variables",
Il semble y avoir plusieurs façons d'écrire un programme pour exécuter Sessoin, mais comme mentionné ci-dessus, le délimiteur de session est clarifié en le plaçant dans l'instruction "with", et il est automatiquement ouvert lorsque le "with" est quitté. La session est fermée (), ce qui est pratique.
La première est qu'il est difficile de fournir des données Train dans TensorFlow. L'alimentation des données est une partie où le traitement change en fonction de la façon dont vous procédez à l'apprentissage, mais comme indiqué dans la liste ci-dessus, "feed_dict" sera utilisé, alors gardez à l'esprit.
Avec ce qui précède, les paramètres de régression sont calculés. (Remarque. Dans la version actuelle de tensorflow, cpu_feature_guard.cc génère un avertissement en fonction de l'environnement, mais vous pouvez l'ignorer. Vous pouvez arrêter l'avertissement en utilisant la variable d'environnement du shell.)
$ python 01_linear_regression.py
predicted model: y = [ 2.045] * x + [ 3.001]
target model : y = [ 2.000] * x + [ 3.000]
On voit que les paramètres de régression du modèle prédit sont des valeurs approximatives du modèle cible.
Ce qui précède est résumé et le programme est à nouveau affiché.
import tensorflow as tf
import numpy as np
trX = np.linspace(-1, 1, 101)
#Le code d'origine n'a pas de terme de biais, mais ici il est biaisé(=3)Être un modèle qui comprend
target_w = 2.
target_b = 3.
noise_gain = 0.33
trY = target_w * trX + target_b + np.random.randn(*trX.shape) * noise_gain
def model(X, w, b):
#Modèle de prédicteur linéaire
#Dans le code d'origine tf.muliply()Est utilisé mais l'opérateur"*"D'accord.
# return tf.multiply(X, w) + b
return X * w + b
# TensorFlow placeholders
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
# TensorFlow Variables
w = tf.Variable(0.0, name="weights") # zero initialize
b = tf.Variable(0.0, name="bias") # zero initialize
y_model = model(X, w, b)
#Définissez l'erreur carrée car il s'agit d'une fonction de coût et d'un modèle de régression
cost = tf.reduce_mean(tf.square(Y - y_model))
#Opérateur d'optimisation(optimiseur)Ensemble.Taux d'apprentissage= 0.01
train_op = tf.train.GradientDescentOptimizer(0.01).minimize(cost)
# Launch the graph in a session
with tf.Session() as sess:
# you need to initialize variables (in this case just variable W)
tf.global_variables_initializer().run()
for i in range(100):
for (x, y) in zip(trX, trY):
sess.run(train_op, feed_dict={X: x, Y: y})
final_w, final_b = sess.run([w, b])
# (w, b) = (2, 3)Devient une approximation de.
print('predicted model: y = [{:>8.3f}] * x + [{:>8.3f}]'.format(
final_w, final_b))
print('target model : y = [{:>8.3f}] * x + [{:>8.3f}]'.format(
target_w, target_b))
Le code de régression logistique original (https://github.com/nlintz/TensorFlow-Tutorials) traite de MNIST, mais ici il traite du jeu de données de caractères manuscrits légers "digits" fourni avec scikit-learn.
Tout d'abord, définissez une fonction de support pour l'initialisation des poids et un modèle.
#Fonction de support pour l'initialisation des poids
def init_weights(shape):
return tf.Variable(tf.random_normal(shape, stddev=0.01))
#Dans le code d'origine, le biais n'est pas inclus dans le modèle, mais ce code est inclus.
def model(X, w, b):
return tf.matmul(X, w) + b
Préparez les données "chiffres".
#chiffres est scikit-Ensemble de données de caractères manuscrites préparé par learn. pixel: 8 x 8
def load_data():
digits = load_digits()
digits_images = digits.data / 16. # scaling to (0 .. 1)
digits_target_ = []
for i in range(len(digits.target)):
target_one = np.zeros([10], dtype=np.float32)
target_one[digits.target[i]] = 1.
digits_target_.append(target_one)
digits_target_onehot = np.asarray(digits_target_)
return digits_images, digits_target_onehot
X, Y = load_data()
# train /Diviser en ensembles de tests
trX, teX, trY, teY = train_test_split(X, Y, test_size=0.2)
Après cela, suivez la régression linéaire de la section précédente pour définir le graphique.
# TensorFlow placeholders
X_ph = tf.placeholder(tf.float32, [None, 64])
Y_ph = tf.placeholder(tf.float32, [None, 10])
#Dans le code d'origine, le biais n'est pas inclus dans le modèle, mais il est inclus dans ce code.
w = init_weights([64, 10])
b = tf.zeros([10])
py_x = model(X_ph, w, b)
#Fonction de coût, optimiseur, prévision
cost = tf.nn.softmax_cross_entropy_with_logits(logits=py_x, labels=Y_ph)
train_op = tf.train.GradientDescentOptimizer(0.01).minimize(cost)
predict_op = tf.argmax(py_x, 1)
Dans la régression linéaire, la fonction de coût définie par MSE (Mean Square Error) est remplacée par une entropie croisée (entropie croisée softmax) dans la régression logistique. "Tf.nn.softmax_cross_entropy_with_logits ()" dans la seconde moitié de la liste ci-dessus est une fonction qui calcule l'entorpie croisée dans la classification multiclasse. (Cette fonction nécessite des mots clés pour logits = et labels =)
L'initialisation des variables et la façon de procéder avec Session sont les mêmes que dans le code précédent. Le code est à nouveau affiché ensemble.
import tensorflow as tf
import numpy as np
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
#Fonction de support pour l'initialisation des poids
def init_weights(shape):
return tf.Variable(tf.random_normal(shape, stddev=0.01))
#Dans le code d'origine, le biais n'est pas inclus dans le modèle, mais ce code est inclus.
def model(X, w, b):
return tf.matmul(X, w) + b
#chiffres est scikit-Ensemble de données de caractères manuscrites préparé par learn. pixel: 8 x 8
def load_data():
digits = load_digits()
digits_images = digits.data / 16. # scaling to (0 .. 1)
digits_target_ = []
for i in range(len(digits.target)):
target_one = np.zeros([10], dtype=np.float32)
target_one[digits.target[i]] = 1.
digits_target_.append(target_one)
digits_target_onehot = np.asarray(digits_target_)
return digits_images, digits_target_onehot
X, Y = load_data()
# train /Diviser en ensembles de tests
trX, teX, trY, teY = train_test_split(X, Y, test_size=0.2)
# TensorFlow placeholders
X_ph = tf.placeholder(tf.float32, [None, 64])
Y_ph = tf.placeholder(tf.float32, [None, 10])
#Dans le code d'origine, le biais n'est pas inclus dans le modèle, mais il est inclus dans ce code.
w = init_weights([64, 10])
b = tf.zeros([10])
py_x = model(X_ph, w, b)
#Fonction de coût, optimiseur, prévision
cost = tf.nn.softmax_cross_entropy_with_logits(logits=py_x, labels=Y_ph)
train_op = tf.train.GradientDescentOptimizer(0.01).minimize(cost)
predict_op = tf.argmax(py_x, 1)
# TensorFlow session
with tf.Session() as sess:
# you need to initialize all variables
tf.global_variables_initializer().run()
for i in range(100):
for start, end in zip(range(0, len(trX), 128), range(128, len(trX)+1, 128)):
train_fd = {X_ph: trX[start:end], Y_ph: trY[start:end]}
sess.run(train_op, feed_dict=train_fd)
#Taux de réponse correct au niveau numpy(accuracy)Calculer et sortir
if i % 10 == 0:
print('step {:>3d}: accuracy = {:>8.3f}'.format(
i, np.mean(np.argmax(teY, axis=1) ==
sess.run(predict_op, feed_dict={X_ph: teX}))))
TensorFlow peut être écrit de différentes manières, des API relativement primitives (ainsi que d'autres outils) aux API de haut niveau, y compris l'API Keras. Cela peut être désagréable, mais il serait préférable que les débutants apprennent d'abord l'utilisation primitive comme décrit ci-dessus, puis passent à l'API de haut niveau lorsque le contenu est compris dans une certaine mesure.
Récemment, j'ai commencé à étudier "PyTorch" en me concentrant sur l'intérêt, mais même si je connais TensorFlow, il y a de nombreux problèmes. Nous pensons que le code de didacticiel tel que la simple «régression linéaire» et la «régression logistique» devrait être utile pour une étude d'introduction dans n'importe quelle bibliothèque.
(Pour en savoir plus sur TensorFlow, encore une fois, consultez https://github.com/nlintz/TensorFlow-Tutorials!)
Recommended Posts