Notes d'étude TF024 : TensorFlow implémente la régression Softmax (régression) pour reconnaître les chiffres manuscrits

TensorFlow implémente Softmax Regression pour reconnaître les chiffres manuscrits. MNIST (Mixed National Institute of Standards and Technology Database), un ensemble de données de vision industrielle simple, chiffres manuscrits de 28 x 28 pixels, uniquement des informations sur la valeur en niveaux de gris, la partie vide est 0, l'écriture manuscrite est prise à partir de [0, 1] en fonction de la profondeur de couleur , 784 dimensions, rejetant les informations spatiales bidimensionnelles, les cibles sont divisées en 10 catégories de 0 à 9. Chargement des données, data.read_data_sets, 55 000 échantillons, ensemble de tests 10 000 échantillons, ensemble de validation 5 000 échantillons. Exemple d'informations d'annotation, étiquette, vecteur à 10 dimensions, 10 types d'encodage à chaud. L'ensemble d'entraînement entraîne le modèle, l'ensemble de validation teste l'effet et l'ensemble de test évalue le modèle (précision, rappel, score F1).

Conception de l'algorithme, Softmax Regression entraîne le modèle de classification de reconnaissance des chiffres manuscrits, estime la probabilité de la catégorie et prend le nombre de probabilité maximale comme résultat de sortie du modèle. Des fonctionnalités de classe sont ajoutées pour déterminer la probabilité de classe. La formation par apprentissage du modèle ajuste les poids. softmax, divers types de fonction exp de calcul de caractéristiques, standardisées (la valeur de probabilité de sortie de toutes les catégories est 1). y = softmax(Wx+b).

NumPy utilise C, fortran et appelle les bibliothèques d'opérations matricielles openblas et mkl. Les opérations denses et complexes de TensorFlow sont effectuées en dehors de Python. Définissez le graphique de calcul. L'opération de calcul n'a pas besoin de retransférer les données calculées vers Python à chaque fois. Toutes les opérations sont exécutées en dehors de Python.

Importez le flux tensoriel au format tf, chargez la bibliothèque TensorFlow. less = tf.InteractiveSession(), crée une InteractiveSession et l'enregistre comme session par défaut. Les données et opérations des différentes sessions sont indépendantes les unes des autres. x = tf.placeholder(tf.float32, [Aucun,784]), créez un espace réservé pour recevoir les données d'entrée, le premier paramètre est le type de données et le deuxième paramètre représente la taille des données de forme du tenseur. Aucune Il n'y a pas de limite au nombre d'entrées, chaque entrée est un vecteur à 784 dimensions.

Tensor stocke les données et disparaîtra une fois utilisé. La variable est persistante dans les itérations de formation du modèle, existe depuis longtemps et est mise à jour à chaque itération. Les poids et biais des objets variables du modèle de régression Softmax sont initialisés à 0. La formation du modèle apprend automatiquement les valeurs appropriées. Pour les réseaux complexes, la méthode d'initialisation est importante. w = tf.Variable(tf.zeros([784, 10])), 784 dimensions de fonctionnalités, 10 catégories. Étiquette, un vecteur à 10 dimensions après encodage à chaud.

Algorithme de régression Softmax, y = tf.nn.softmax(tf.matmul(x, W) + b). tf.nn contient un grand nombre de composants de réseau neuronal. tf.matmul, fonction de multiplication matricielle. TensorFlow implémente automatiquement le contenu avant et arrière Tant que la perte est définie, la formation dérivera automatiquement la descente de gradient et terminera l'apprentissage automatique des paramètres du modèle de régression Softmax.

Définissez la fonction de perte pour décrire la précision de la classification du modèle de problème. Plus la perte est faible, plus le résultat de la classification du modèle est petit par rapport à la valeur réelle et plus il est précis. Les paramètres initiaux du modèle sont tous nuls, ce qui entraîne une perte initiale. L’objectif de la formation est de réduire les pertes et de trouver la solution optimale globale ou locale optimale. L'entropie croisée et la fonction de perte sont couramment utilisées dans les problèmes de classification. y distribution de probabilité prédite, y' distribution de probabilité réelle (codage Label one-hot), déterminez l'exactitude de la prédiction du modèle de la distribution de probabilité réelle. cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), réduction_indices=[1])). Définissez l'espace réservé et entrez le véritable label. tf.reduce_sum calcule la somme et tf.reduce_mean calcule la moyenne de chaque résultat de données par lots.

Définir l'algorithme d'optimisation, descente de gradient stochastique SGD (Stochastic Gradient Descent). Dérivation automatique basée sur le graphique de calcul, formation basée sur l'algorithme de propagation arrière et mise à jour itérative des paramètres à chaque tour pour réduire les pertes. Un optimiseur d'encapsulation est fourni pour itérer les données de flux à chaque tour. TensorFlow complète automatiquement l'opération en arrière-plan pour implémenter la rétropropagation et la descente de gradient. train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy). Appelez tf.train.GradientDescentOptimizer, définissez la vitesse d'apprentissage sur 0,5, définissez l'entropie croisée cible d'optimisation et obtenez l'opération de formation train_step.

tf.global_variables_initializer().run(). Initialiseur de paramètre global TensorFlow tf.golbal_variables_initializer.

batch_xs,batch_ys = mnist.train.next_batch(100). Opération de formation train_step. À chaque fois, 100 échantillons sont sélectionnés au hasard dans l'ensemble d'apprentissage pour former un mini-lot, introduit dans l'espace réservé, et les échantillons d'apprentissage train_step sont appelés. En utilisant un petit nombre d’échantillons pour la formation, la descente de gradient stochastique conduit à une convergence plus rapide. Tous les échantillons sont entraînés à chaque fois, ce qui nécessite une grande quantité de calculs et rend difficile la sortie de l'optimum local.

correct_prediction = tf.equal(tf.argmax(y,1), tf.argmzx(y_,1)), vérifiez la précision du modèle. tf.argmax trouve le numéro de séquence de valeur maximale à partir du tenseur, tf.argmax(y,1) trouve la probabilité numérique maximale prédite et tf.argmax(y_,1) trouve la vraie catégorie de nombres de l'échantillon. tf.equal détermine si la catégorie de nombres prédite est correcte et renvoie si l'opération de classification de calcul est correcte.

accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32)), compte la précision de la prédiction de tous les échantillons. tf.cast convertit le type de valeur de sortie correct_prediction.

print(accuracy.eval({x: mnist.test.images,y_: mnist.test.labels})). Testez les caractéristiques des données, étiquetez le processus d'évaluation des entrées et calculez la précision de l'ensemble de test du modèle. Classification et reconnaissance des données Softmax Regression MNIST, la précision moyenne de l'ensemble de tests est d'environ 92 %.

TensorFlow implémente des étapes simples d'algorithme machine :
1､Définir la formule de l'algorithme et le calcul direct du réseau neuronal.
2､Définissez la perte, sélectionnez l'optimiseur et spécifiez l'optimiseur pour optimiser la perte.
3､Données d'entraînement itératives.
4､ Précision de l'évaluation de l'ensemble de test et de l'ensemble de vérification.

La formule définie est simplement le graphique de calcul. Le calcul n'est exécuté que lorsque la méthode d'exécution et les données du flux sont appelées.

    <span style="color: #0000ff">from</span> tensorflow.examples.tutorials.mnist <span style="color: #0000ff">import</span><span style="color: #000000"> input_data
    mnist </span>= input_data.read_data_sets(<span style="color: #800000">"</span><span style="color: #800000">MNIST_data/</span><span style="color: #800000">"</span>, one_hot=<span style="color: #000000">True)
    </span><span style="color: #0000ff">print</span><span style="color: #000000">(mnist.train.images.shape, mnist.train.labels.shape)
    </span><span style="color: #0000ff">print</span><span style="color: #000000">(mnist.test.images.shape, mnist.test.labels.shape)
    </span><span style="color: #0000ff">print</span><span style="color: #000000">(mnist.validation.images.shape, mnist.validation.labels.shape)
    </span><span style="color: #0000ff">import</span><span style="color: #000000"> tensorflow as tf
    sess </span>=<span style="color: #000000"> tf.InteractiveSession()
    x </span>= tf.placeholder(tf.float32, [None, 784<span style="color: #000000">])
    W </span>= tf.Variable(tf.zeros([784, 10<span style="color: #000000">]))
    b </span>= tf.Variable(tf.zeros([10<span style="color: #000000">]))
    y </span>= tf.nn.softmax(tf.matmul(x, W) +<span style="color: #000000"> b)
    y_ </span>= tf.placeholder(tf.float32, [None, 10<span style="color: #000000">])
    cross_entropy </span>= tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1<span style="color: #000000">]))
    train_step </span>= tf.train.GradientDescentOptimizer(0.5<span style="color: #000000">).minimize(cross_entropy)
    tf.global_variables_initializer().run()
    </span><span style="color: #0000ff">for</span> i <span style="color: #0000ff">in</span> range(1000<span style="color: #000000">):
        batch_xs, batch_ys </span>= mnist.train.next_batch(100<span style="color: #000000">)
        train_step.run({x: batch_xs, y_: batch_ys})
    correct_prediction </span>= tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1<span style="color: #000000">))
    accuracy </span>=<span style="color: #000000"> tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    </span><span style="color: #0000ff">print</span>(accuracy.eval({x: mnist.test.images, y_: mnist.test.labels}))

Documents de référence :
« TensorFlow Practice »

Bienvenue pour payer la consultation (150 yuans par heure), mon WeChat : qingxingfengzi

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!