Réseaux préférés Apprentissage de renforcement profond distribué Je veux faire quelque chose comme ça en regardant les nouvelles! J'ai commencé le Deep Learning. C'est ikki. L'autre jour, je suis allé à Robot Exhibition et exposé par Preferred Networks. J'ai participé à des activités et à des ateliers, et c'est merveilleux que la technologie soit rapide et que la façon de penser soit bonne. Je te respecte. Ensuite, utilisez Chainer! Il y a une opinion, mais c'est tout. Je pense étudier dur.
Cette fois, j'enregistrerai (j'oublie) le contenu lorsque j'ai commencé à faire TensorFlow l'autre jour. Tout d'abord, j'ai pensé à la méthode d'installation, mais j'en ai eu assez en chemin, alors j'ai arrêté. C'est bien organisé ailleurs. En passant, j'en ai parlé. Merci beaucoup. "J'ai installé TensorFlow (version GPU) sur Ubuntu"
J'ai essayé Deep MNIST for Experts. Cependant, beaucoup de ces tutoriels sont excellents, c'est donc presque comme écrire des notes. Je suis heureux de publier mon programme. C'est presque une copie. Cette fois, j'en ai parlé. Merci beaucoup. "Créez un classificateur avec un taux de reconnaissance de l'écriture manuscrite de 99,2% avec le réseau neuronal convolutif TensorFlow"
mnist_expert.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
####################################################################
#Implémenter mnist avec tensorflow
#C'est un peu difficile à voir car le code n'est pas divisé.
####################################################################
from __future__ import absolute_import,unicode_literals
import input_data
import tensorflow as tf
#Lire les données mnist
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
# cross_Mettre en œuvre l'entropie
sess = tf.InteractiveSession() #Démarrez une session interactive(Ne convient pas aux programmes à long terme)
#Paramètres variables utilisés dans les expressions
x = tf.placeholder("float", shape=[None,784]) #contribution
y_ = tf.placeholder("float", shape=[None,10]) #Variable pour la fonction d'erreur Distribution de classe vraie
W = tf.Variable(tf.zeros([784,10])) #poids
b = tf.Variable(tf.zeros([10])) #biais
sess.run(tf.initialize_all_variables()) #Initialisation variable(Doit être obligatoire lors de l'utilisation de variables)
y = tf.nn.softmax(tf.matmul(x,W)+b) # y=softmax(Wx+b)La différenciation se fait également sans autorisation
cross_entropy = -tf.reduce_sum(y_*tf.log(y)) #Définir l'entropie croisée
#Algorithme d'apprentissage et problème de minimisation
#La méthode de descente la plus raide ici(Méthode de descente de gradient)Résolvez la minimisation de. Taux d'apprentissage 0.01
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
#Apprenez 1000 fois la taille du lot 50(Le traitement de ce contenu est encore insuffisamment étudié)
for i in range(1000):
batch = mnist.train.next_batch(50)
train_step.run(feed_dict={x:batch[0],y_:batch[1]})
#Voir les résultats
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(y_,1))#Classe plausible ou argmax(y)Est égal au label enseignant
accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float"))#Évaluez chaque échantillon et calculez la moyenne
print accuracy.eval(feed_dict={x: mnist.test.images,y_: mnist.test.labels})#Image y sur x_Remplacez cette étiquette par
#Le résultat qui sort est exact 91 à ce stade%Avant et après
###############################################################
#Le réseau neuronal à convolution profonde est construit ci-dessous.
#Précision 99 en approfondissant%Il vise à.
###############################################################
#Initialisation du poids et du biais
#Une fonction qui initialise les poids avec une petite quantité de bruit pour le problème de disparition de gradient? Que voulez-vous dire?
def weight_variable(shape): #Initialisation du poids
initial = tf.truncated_normal(shape,stddev=0.1)
return tf.Variable(initial)
def bias_variable(shape): #Initialisation du biais
initial = tf.constant(0.1,shape=shape)
return tf.Variable(initial)
#Définition de la convolution et de la mise en commun
def conv2d(x,W):
return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
def max_pool_2x2(x):
return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
#Calculez 32 entités avec le patch 5x5 de 1ère couche
# [5,5,1,32]Est 5,5 est la taille du patch, 1 est le nombre de canaux d'entrée, 32 est le canal de sortie
W_conv1 = weight_variable([5,5,1,32]) #Définition variable
b_conv1 = bias_variable([32]) #Définition variable
x_image = tf.reshape(x,[-1,28,28,1]) #28 images*Convertir en 28 images monochromes
h_conv1 = tf.nn.relu(conv2d(x_image,W_conv1)+b_conv1) #Traitement ReLU?
h_pool1 = max_pool_2x2(h_conv1)#Création de la couche de pooling 1
#Calculez 64 entités avec le patch 5x5 de 2e couche
W_conv2 = weight_variable([5,5,32,64]) #Définition variable
b_conv2 = bias_variable([64]) #Définition variable
h_conv2 = tf.nn.relu(conv2d(h_pool1,W_conv2)+b_conv2)
h_pool2 = max_pool_2x2(h_conv2)#Création du pooling layer 2
#Conversion en couche entièrement connectée (couche de connexion complète)
W_fc1 = weight_variable([7*7*64,1024]) #Quel genre de conversion?
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat,W_fc1)+b_fc1)
#Abandonner
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)
#Lire la couche
W_fc2 = weight_variable([1024,10])
b_fc2 = bias_variable([10])
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop,W_fc2)+b_fc2)
#Apprentissage et évaluation de modèles
cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)#Utilise la méthode Adam.
correct_prediction = tf.equal(tf.argmax(y_conv,1),tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float")) # cast?
sess.run(tf.initialize_all_variables())
for i in range(20000):
batch = mnist.train.next_batch(50)
if i % 100 == 0:
train_accuracy = accuracy.eval(feed_dict={x: batch[0], y_: batch[1], keep_prob:1.0})
print "step %d, training accuracy %g" % (i,train_accuracy)
train_step.run(feed_dict={x:batch[0],y_:batch[1],keep_prob:0.5})# 0.Je le garde à 5?
#Affichage des résultats
print "test accuracy %g" % accuracy.eval(feed_dict={x:mnist.test.images,y_:mnist.test.labels,keep_prob:1.0})
Hmmm, j'ai réussi le programme, mais est-il difficile d'utiliser TensorBoard, qui sera l'application tueuse de TensorFlow telle quelle? Ou plutôt, c'est difficile à voir comme un programme.
Alors, j'ai essayé de l'améliorer. Merci pour votre aide cette fois. Je pense que cette personne est jeune mais vraiment excellente et fait toujours des choses intéressantes. Merci beaucoup. "Journal d'activité Kivantium: Identifiez la société de production de l'anime Yuruyuri avec TensorFlow"
mnist_expert_kai.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
####################################################################
#Implémenter mnist avec tensorflow
#C'est un peu difficile à voir car le code n'est pas divisé.(->Réparé)
####################################################################
import sys
import cv2
import numpy as np
import tensorflow as tf
import tensorflow.python.platform
import input_data
#Lire les données mnist
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
NUM_CLASSES = 10 #Nombre de classes de modèles
def inference(images_placeholder, keep_prob):
####################################################################
#Fonctions qui créent des modèles prédictifs
#argument:
# images_placeholder:Espace réservé pour l'image
# keep_prob:espace réservé pour le taux d'abandon
#Valeur de retour:
# y_conv:Probabilité de chaque classe(Quelque chose comme)
####################################################################
#Écart type de poids 0.Initialisé avec une distribution normale de 1
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
#Biais par rapport à l'écart type 0.Initialisé avec une distribution normale de 1
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
#Créer une couche convolutive
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
#Créer une couche de pooling
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],strides=[1, 2, 2, 1], padding='SAME')
#Transformez l'entrée en 28x28x1
x_image = tf.reshape(images_placeholder, [-1, 28, 28, 1])
#Création de la couche de convolution 1
with tf.name_scope('conv1') as scope:
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
#Création de la couche de pooling 1
with tf.name_scope('pool1') as scope:
h_pool1 = max_pool_2x2(h_conv1)
#Création de la couche de convolution 2
with tf.name_scope('conv2') as scope:
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
#Création du pooling layer 2
with tf.name_scope('pool2') as scope:
h_pool2 = max_pool_2x2(h_conv2)
#Création de la couche 1 entièrement connectée
with tf.name_scope('fc1') as scope:
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
#paramètres d'abandon
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
#Création de la couche 2 entièrement connectée
with tf.name_scope('fc2') as scope:
W_fc2 = weight_variable([1024, NUM_CLASSES])
b_fc2 = bias_variable([NUM_CLASSES])
#Normalisation par fonction softmax
with tf.name_scope('softmax') as scope:
y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
#Renvoie quelque chose comme la probabilité de chaque étiquette
return y_conv
def loss(logits, labels):
####################################################################
#Fonction pour calculer la perte
#argument:
# logits:Tenseur logit, float - [batch_size, NUM_CLASSES]
# labels:Tenseur d'étiquette, int32 - [batch_size, NUM_CLASSES]
#Valeur de retour:
# cross_entropy:Tenseur d'entropie croisée, float
####################################################################
#Calcul de l'entropie croisée
cross_entropy = -tf.reduce_sum(labels*tf.log(logits))
#Spécifier pour afficher dans TensorBoard
tf.scalar_summary("cross_entropy", cross_entropy)
return cross_entropy
def training(loss, learning_rate):
####################################################################
#Fonctions qui définissent les opérations d'entraînement
#argument:
# loss:Tenseur de perte, loss()Résultat de
# learning_rate:Coefficient d'apprentissage
#Valeur de retour:
# train_step:Op de formation
####################################################################
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)
return train_step
def accuracy(logits, labels):
####################################################################
#Taux de réponse correct(accuracy)Fonction à calculer
#argument:
# logits: inference()Résultat de
# labels:Tenseur d'étiquette, int32 - [batch_size, NUM_CLASSES]
#Valeur de retour:
# accuracy:Taux de réponse correct(float)
####################################################################
correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
tf.scalar_summary("accuracy", accuracy)
return accuracy
if __name__ == '__main__':
#Paramètres variables utilisés dans les expressions
x_image = tf.placeholder("float", shape=[None,784]) #contribution
y_label = tf.placeholder("float", shape=[None,10])
W = tf.Variable(tf.zeros([784,10])) #poids
b = tf.Variable(tf.zeros([10])) #biais
#y_label = tf.nn.softmax(tf.matmul(x_image,W)+b) # y=softmax(Wx+b)La différenciation se fait également sans autorisation
keep_prob = tf.placeholder("float")
#init_op = tf.initialize_all_variables() #Initialisation variable(Doit être obligatoire lors de l'utilisation de variables)
with tf.Session() as sess:
logits = inference(x_image,keep_prob) # inference()Pour créer un modèle
loss_value = loss(logits,y_label) # loss()Pour calculer la perte
train_op = training(loss_value,1e-4) # training()Appeler et former (1e-4 est le taux d'apprentissage)
accur = accuracy(logits,y_label) # accuracy()Pour calculer la précision
init_op = tf.initialize_all_variables()
sess.run(init_op)
for step in range(20001):
batch = mnist.train.next_batch(50)
if step % 100 == 0:
train_accur = accur.eval(feed_dict={x_image: batch[0], y_label: batch[1], keep_prob:1.0})
print "step %d, training accuracy %g" % (step,train_accur)
train_op.run(feed_dict={x_image:batch[0],y_label:batch[1],keep_prob:0.5})# 0.Je le garde à 5?
#Affichage des résultats
print "test accuracy %g" % accur.eval(feed_dict={x_image:mnist.test.images,y_label:mnist.test.labels,keep_prob:1.0})
J'y ai fait référence parce qu'il vaut mieux le diviser comme inférence (), loss (), training (), exactitude (). Il y avait deux problèmes ici. Le premier point est init_op dans main. Une erreur se produit lors de la définition de init_op en dehors de Session (). J'ai vu quelque part qu'il passait dans Session (), alors je l'ai réécrit dans Session (). Le deuxième point est la partie d'affichage du résultat final. J'ai eu l'erreur ** Out of GPU Memory ** que j'ai écrite ci-dessus. Dans ce cas, je l'ai résolu en réécrivant convolutional.py ici (Github TensorFlow # 157). Je ne comprends pas pourquoi les deux erreurs ont été corrigées. .. .. Je peux parler anglais ...
Alors, voici une version améliorée du programme ci-dessus que vous pouvez voir sur TensorBoard:
mnist_expert_kai2.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
####################################################################
#Implémenter mnist avec tensorflow
#C'est un peu difficile à voir car le code n'est pas divisé.(->Réparé)
####################################################################
import sys
import cv2
import numpy as np
import tensorflow as tf
import tensorflow.python.platform
import input_data
#Lire les données mnist
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
NUM_CLASSES = 10 #Nombre de classes de modèles
def inference(images_placeholder, keep_prob):
####################################################################
#Fonctions qui créent des modèles prédictifs
#argument:
# images_placeholder:Espace réservé pour l'image
# keep_prob:espace réservé pour le taux d'abandon
#Valeur de retour:
# y_conv:Probabilité de chaque classe(Quelque chose comme)
####################################################################
#Écart type de poids 0.Initialisé avec une distribution normale de 1
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
#Biais par rapport à l'écart type 0.Initialisé avec une distribution normale de 1
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
#Créer une couche convolutive
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
#Créer une couche de pooling
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],strides=[1, 2, 2, 1], padding='SAME')
#Transformez l'entrée en 28x28x1
x_images = tf.reshape(images_placeholder, [-1, 28, 28, 1])
#Création de la couche de convolution 1
with tf.name_scope('conv1') as scope:
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])
h_conv1 = tf.nn.relu(conv2d(x_images, W_conv1) + b_conv1)
#Création de la couche de pooling 1
with tf.name_scope('pool1') as scope:
h_pool1 = max_pool_2x2(h_conv1)
#Création de la couche de convolution 2
with tf.name_scope('conv2') as scope:
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
#Création du pooling layer 2
with tf.name_scope('pool2') as scope:
h_pool2 = max_pool_2x2(h_conv2)
#Création de la couche 1 entièrement connectée
with tf.name_scope('fc1') as scope:
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
#paramètres d'abandon
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
#Création de la couche 2 entièrement connectée
with tf.name_scope('fc2') as scope:
W_fc2 = weight_variable([1024, NUM_CLASSES])
b_fc2 = bias_variable([NUM_CLASSES])
#Normalisation par fonction softmax
with tf.name_scope('softmax') as scope:
y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
#Renvoie quelque chose comme la probabilité de chaque étiquette
return y_conv
def loss(logits, labels):
####################################################################
#Fonction pour calculer la perte
#argument:
# logits:Tenseur logit, float - [batch_size, NUM_CLASSES]
# labels:Tenseur d'étiquette, int32 - [batch_size, NUM_CLASSES]
#Valeur de retour:
# cross_entropy:Tenseur d'entropie croisée, float
####################################################################
#Calcul de l'entropie croisée
cross_entropy = -tf.reduce_sum(labels*tf.log(logits))
#Spécifier pour afficher dans TensorBoard
tf.scalar_summary("cross_entropy", cross_entropy)
return cross_entropy
def training(loss, learning_rate):
####################################################################
#Fonctions qui définissent les opérations d'entraînement
#argument:
# loss:Tenseur de perte, loss()Résultat de
# learning_rate:Coefficient d'apprentissage
#Valeur de retour:
# train_step:Op de formation
####################################################################
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)
return train_step
def accuracy(logits, labels):
####################################################################
#Taux de réponse correct(accuracy)Fonction à calculer
#argument:
# logits: inference()Résultat de
# labels:Tenseur d'étiquette, int32 - [batch_size, NUM_CLASSES]
#Valeur de retour:
# accuracy:Taux de réponse correct(float)
####################################################################
correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
tf.scalar_summary("accuracy", accuracy)
return accuracyｄ
if __name__ == '__main__':
with tf.Graph().as_default():
x_image = tf.placeholder("float", shape=[None,784]) #contribution
y_label = tf.placeholder("float", shape=[None,10]) #Variable pour la fonction d'erreur Distribution de classe vraie
W = tf.Variable(tf.zeros([784,10])) #poids
b = tf.Variable(tf.zeros([10])) #biais
#y_label = tf.nn.softmax(tf.matmul(x_image,W)+b) # y=softmax(Wx+b)La différenciation se fait également sans autorisation
keep_prob = tf.placeholder("float")
#init_op = tf.initialize_all_variables() #Initialisation variable(Doit être obligatoire lors de l'utilisation de variables)
logits = inference(x_image,keep_prob) # inference()Pour créer un modèle
loss_value = loss(logits,y_label) # loss()Pour calculer la perte
train_op = training(loss_value,1e-4) # training()Appeler et former (1e-4 est le taux d'apprentissage)
accur = accuracy(logits,y_label) # accuracy()Pour calculer la précision
init_op = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init_op)
#Définition de la valeur à afficher sur TensorBoard
summary_op = tf.merge_all_summaries()
summary_writer = tf.train.SummaryWriter('/tmp/mnist_data', sess.graph_def)
#Exécution de la formation
for step in range(20001):
batch = mnist.train.next_batch(50)
if step % 100 == 0:
train_accur = sess.run(accur,feed_dict={x_image: batch[0], y_label: batch[1], keep_prob:1.0})
print "step %d, training accuracy %g" % (step,train_accur)
sess.run(train_op,feed_dict={x_image:batch[0],y_label:batch[1],keep_prob:0.5})# 0.Je le garde à 5?
#Ajoutez la valeur à afficher sur le TensorBoard après chaque étape
summary_str = sess.run(summary_op, feed_dict={
x_image: batch[0],
y_label: batch[1],
keep_prob: 1.0})
summary_writer.add_summary(summary_str, step)
#Affichage des résultats
print "test accuracy %g"%sess.run(accur, feed_dict={
x_image:mnist.test.images,
y_label:mnist.test.labels,
keep_prob:1.0})
Le seul changement concerne le contenu de main. Il commence par tf.Graph (). As_default ():. En plus, il y a divers changements comme le résumé, mais je ne peux pas l'écrire car je ne comprends pas assez pour l'expliquer. .. .. Je suis désolé. Cela fonctionne pour le moment.
Après cela, exécutez-le dans le terminal comme suit. Cette fois, le graphique est dans '/ tmp / mnist_data'
tensorboard --logdir /tmp/mnist_data/
Si vous vous connectez à http: // localhost: 6006 / sur Google Chrome, vous pouvez voir des graphiques sympas.
Il y a encore de nombreuses parties que je n'ai pas abordées, donc si vous avez des problèmes, veuillez commenter.
Recommended Posts