Dans ce qui précède, j'ai mentionné que le document de Deep Learning Framework "TensorFlow" est difficile. Dans cet article, je voudrais essayer de résoudre MNIST (Handwritten Number Classification Problem) en utilisant le réseau à deux couches de TensorFlow.
En parcourant le didacticiel TensorFlow, il semble qu'il y ait un saut de niveau assez technique, avec "MNIST pour les débutants" d'abord et ensuite "Deep MNIST pour les experts".
--Pour les débutants ... Régression Softmax (multi-classe par fonction softmax, régression logistique)
Ne serait-il pas préférable de le comprendre étape par étape en insérant un modèle de réseau multicouche (MLP) au lieu de soudainement CNN (réseau neuronal convolutif)? Dans cet article, j'ai créé un code de didacticiel qui comble une telle lacune. Les caractéristiques sont les suivantes.
(Ce que vous faites peut être proche de l'exemple de code "mnist.py" pour le modèle entièrement connecté dans le référentiel GitHub TensorFlow, mais nous visions un code court facile à comprendre.)
Ci-dessous, je voudrais regarder le code pour chaque partie.
import tensorflow as tf
# Import data
import input_data
mnist = input_data.read_data_sets("../MNIST_data/", one_hot=True)
Tout d'abord, import du module nécessaire. Si c'est vrai, il aurait peut-être été préférable de lire "input_data.py", mais comme il contient pas mal de fonctions, cette fois sans analyser le contenu J'ai décidé de l'utiliser comme une boîte noire.
Vient ensuite la préparation des variables à utiliser.
# Variables
x = tf.placeholder("float", [None, 784])
y_ = tf.placeholder("float", [None, 10])
w_h = tf.Variable(tf.random_normal([784, 625], mean=0.0, stddev=0.05))
w_o = tf.Variable(tf.random_normal([625, 10], mean=0.0, stddev=0.05))
b_h = tf.Variable(tf.zeros([625]))
b_o = tf.Variable(tf.zeros([10]))
x et y_ sont des espaces réservés pour stocker les données d'entraînement (données de test), et w_h, w_o, b_h, b_o sont des paramètres d'apprentissage (poids et biais, couche cachée et couche de sortie). L'initialisation aléatoire se fait avec "tf.random_normal ()" qui génère des nombres aléatoires avec une distribution normale. Les paramètres du nombre aléatoire ont été fixés à moyenne = 0,0 et stddev = 0,05 selon la norme approximative de «petite valeur». (Pour le biais, initialisez avec zéro.)
# Create the model
def model(X, w_h, b_h, w_o, b_o):
h = tf.sigmoid(tf.matmul(X, w_h) + b_h)
pyx = tf.nn.softmax(tf.matmul(h, w_o) + b_o)
return pyx
y_hypo = model(x, w_h, b_h, w_o, b_o)
# Cost Function basic term
cross_entropy = -tf.reduce_sum(y_*tf.log(y_hypo))
C'est la partie importante de ce code, la partie qui décrit le modèle du réseau neuronal.
La couche masquée calcule un prédicteur linéaire à partir de la valeur de la couche d'entrée et la place dans la fonction sigmoïde.
\textbf{u} ^{(h)} = \textbf{w} ^{(h)} \textbf{z} ^{(i)} + \textbf{b}^{(h)}
\textbf{z} ^{(h)} = f^{(h)}(\textbf{u}^{(h)})
f^{(h)} \ : \ Sigmoid()\ ...\ \texttt{activation function}
Le calque de sortie calcule un prédicteur linéaire à partir de la valeur du calque masqué et le place dans la fonction Softmax.
\textbf{u} ^{(o)} = \textbf{w} ^{(o)} \textbf{z} ^{(h)} + \textbf{b}^{(o)}
\textbf{z} ^{(o)} = f^{(o)} (\textbf{u} ^{(o)})
f^{(o)} \ :\ Softmax()\ ...\ \texttt{activation function}
(Ce qui précède est le contenu de def model ())
Calculez la valeur y_hypo de votre propre modèle avec ce modèle et trouvez la valeur d'entropie croisée avec l'étiquette de données d'apprentissage y_ (C'est la partie principale de la fonction de coût.)
Ensuite, le terme de régularisation est calculé.
# Regularization terms (weight decay)
L2_sqr = tf.nn.l2_loss(w_h) + tf.nn.l2_loss(w_o)
lambda_2 = 0.01
Pour le terme de régularisation, la norme carrée (L2_sqr) (atténuation du poids) a été utilisée. TensorFlow prend en charge "tf.nn.l2_loss ()" pour calculer cela.
# the loss and accuracy
loss = cross_entropy + lambda_2 * L2_sqr
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
correct_prediction = tf.equal(tf.argmax(y_hypo,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
C'est là que la définition de l'optimiseur et les valeurs numériques associées sont calculées. L'optimiseur évalue une fonction de coût avec un terme régulier ajouté. Nous avons choisi la méthode d'optimisation de la descente de gradient et avons fixé son taux d'apprentissage à 0,001. De plus, la formule permettant d'évaluer le résultat de la classification et de calculer sa précision est décrite.
# Train
init = tf.initialize_all_variables()
with tf.Session() as sess:
sess.run(init)
print('Training...')
for i in range(20001):
batch_xs, batch_ys = mnist.train.next_batch(100)
train_step.run({x: batch_xs, y_: batch_ys})
if i % 2000 == 0:
train_accuracy = accuracy.eval({x: batch_xs, y_: batch_ys})
print(' step, accurary = %6d: %6.3f' % (i, train_accuracy))
Après avoir initialisé les variables, démarrez une session et apprenez les paramètres à l'aide des données d'entraînement. Cette fois, le calcul du nombre prédéterminé de répétitions (20 000 fois +) est effectué sans effectuer de jugement de convergence ni d'interruption anticipée.
Lorsque la formation est terminée, la précision du classificateur est calculée à l'aide des données de test.
# （with tf.Session() as sess:Sera à l'intérieur)
# Test trained model
print('accuracy = ', accuracy.eval({x: mnist.test.images, y_: mnist.test.labels}))
Le code expliqué ci-dessus est résumé et affiché à nouveau. (Environ 60 lignes de code.)
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow as tf
# Import data
import input_data
mnist = input_data.read_data_sets("../MNIST_data/", one_hot=True)
# Variables
x = tf.placeholder("float", [None, 784])
y_ = tf.placeholder("float", [None, 10])
w_h = tf.Variable(tf.random_normal([784, 625], mean=0.0, stddev=0.05))
w_o = tf.Variable(tf.random_normal([625, 10], mean=0.0, stddev=0.05))
b_h = tf.Variable(tf.zeros([625]))
b_o = tf.Variable(tf.zeros([10]))
# Create the model
def model(X, w_h, b_h, w_o, b_o):
h = tf.sigmoid(tf.matmul(X, w_h) + b_h)
pyx = tf.nn.softmax(tf.matmul(h, w_o) + b_o)
return pyx
y_hypo = model(x, w_h, b_h, w_o, b_o)
# Cost Function basic term
cross_entropy = -tf.reduce_sum(y_*tf.log(y_hypo))
# Regularization terms (weight decay)
L2_sqr = tf.nn.l2_loss(w_h) + tf.nn.l2_loss(w_o)
lambda_2 = 0.01
# the loss and accuracy
loss = cross_entropy + lambda_2 * L2_sqr
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
correct_prediction = tf.equal(tf.argmax(y_hypo,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
# Train
init = tf.initialize_all_variables()
with tf.Session() as sess:
sess.run(init)
print('Training...')
for i in range(20001):
batch_xs, batch_ys = mnist.train.next_batch(100)
train_step.run({x: batch_xs, y_: batch_ys})
if i % 2000 == 0:
train_accuracy = accuracy.eval({x: batch_xs, y_: batch_ys})
print(' step, accurary = %6d: %6.3f' % (i, train_accuracy))
# Test trained model
print('accuracy = ', accuracy.eval({x: mnist.test.images, y_: mnist.test.labels}))
(Remarque: les trois premières lignes de __future__ ... sont des déclarations de compatibilité avec Python-3.)
La situation dans laquelle ce code est exécuté est la suivante.
Training...
step, accurary = 0: 0.130
step, accurary = 2000: 0.900
step, accurary = 4000: 0.910
step, accurary = 6000: 0.930
step, accurary = 8000: 0.920
step, accurary = 10000: 0.960
step, accurary = 12000: 0.950
step, accurary = 14000: 0.950
step, accurary = 16000: 0.960
step, accurary = 18000: 0.960
step, accurary = 20000: 0.960
accuracy = 0.9546
La précision de la classification des données d'essai était de 95,46%. Comme prévu, la valeur était presque intermédiaire entre la valeur calculée par la fonction Softmax (91%) et la précision par le réseau neuronal convolutif (99,2%). (On a le sentiment de viser un peu.)
--Classification dans d'autres ensembles de données. (Cela signifie que les données sont autres que "MNIST".) --Visualisation graphique par "TensorBoard".
(J'étudie toujours, mais j'espère pouvoir partager le code TensoFlow tout en l'essayant petit à petit.)
Recommended Posts