J'ai regardé mes articles jusqu'à la dernière fois, mais c'est très difficile à voir ... Je dois inventer petit à petit une manière d'écrire. Salut, c'est ikki. Preferred Networks, que j'ai vu à l'exposition de robots l'autre jour, l'a développé en collaboration avec FANUC. " Le blog sur Learning from 0 for bulk robots with deep learning »a été mis à jour. Ou plutôt, il était déjà posté lorsque je l'ai posté la dernière fois. .. .. J'écoutais l'histoire à l'atelier, et j'ai été surpris d'apprendre que ce robot a été fabriqué en 3 mois. M. Nishikawa a dit: "Cela aurait pris trois ans pour une personne ordinaire (rires)", mais je n'ai pas la capacité de le faire même si cela prend trois ans.
Donc, l'introduction est devenue longue, mais cette fois, à la suite de l'article précédent, il s'agit du problème de "Out of GPU Memory". ..
Des conseils de Reo Aoki et MATS à l'article précédent, j'ai pu créer un programme qui apprend les images et les reconnaît sans lancer d'erreurs, mais le nombre d'images pouvant être alimentées est petit et ce n'est pas assez bon. La précision de la reconnaissance n'est pas bonne. Dois-je concevoir une image (ensemble de données) à former? Je pense aussi, mais si possible, j'aimerais le résoudre dans le cadre du programme. À l'avenir, je souhaite créer des données d'entraînement sans générer d'erreurs, quel que soit le nombre d'images consommées! Je pense. (Bien qu'il y ait une limite à "combien")
Le programme actuel est le suivant. Cette fois également, je me référerai à identifier la société de production de l'anime Yuruyuri avec le journal d'activité kivantium TensorFlow. Merci beaucoup.
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import cv2
import numpy as np
import tensorflow as tf
import tensorflow.python.platform
NUM_CLASSES = 2
IMAGE_SIZE = 28
IMAGE_PIXELS = IMAGE_SIZE*IMAGE_SIZE*3
flags = tf.app.flags
FLAGS = flags.FLAGS
flags.DEFINE_string('save_model', 'models/model.ckpt', 'File name of model data')
flags.DEFINE_string('train', 'training/train_.txt', 'File name of train data')
flags.DEFINE_string('test', 'training/test_.txt', 'File name of test data')
flags.DEFINE_string('train_dir', '/tmp/pict_data', 'Directory to put the training data.')
flags.DEFINE_integer('max_steps', 200, 'Number of steps to run trainer.')
flags.DEFINE_integer('batch_size', 128, 'Batch size'
'Must divide evenly into the dataset sizes.')
flags.DEFINE_float('learning_rate', 1e-4, 'Initial learning rate.')
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 28x28x3
x_images = tf.reshape(images_placeholder, [-1, IMAGE_SIZE, IMAGE_SIZE, 3])
#Création de la couche de convolution 1
with tf.name_scope('conv1') as scope:
W_conv1 = weight_variable([5, 5, 3, 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écifiez 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__':
#Fichier ouvert
with open(FLAGS.train, 'r') as f: # train.txt
train_image = []
train_label = []
for line in f:
line = line.rstrip()
l = line.split()
img = cv2.imread(l[0])
img = cv2.resize(img, (IMAGE_SIZE, IMAGE_SIZE))
train_image.append(img.flatten().astype(np.float32)/255.0)
tmp = np.zeros(NUM_CLASSES)
tmp[int(l[1])] = 1
train_label.append(tmp)
train_image = np.asarray(train_image)
train_label = np.asarray(train_label)
print len(train_image)
with open(FLAGS.test, 'r') as f: # test.txt
test_image = []
test_label = []
for line in f:
line = line.rstrip()
l = line.split()
img = cv2.imread(l[0])
img = cv2.resize(img, (IMAGE_SIZE, IMAGE_SIZE))
test_image.append(img.flatten().astype(np.float32)/255.0)
tmp = np.zeros(NUM_CLASSES)
tmp[int(l[1])] = 1
test_label.append(tmp)
test_image = np.asarray(test_image)
test_label = np.asarray(test_label)
with tf.Graph().as_default():
images_placeholder = tf.placeholder("float", shape=(None, IMAGE_PIXELS))
labels_placeholder = tf.placeholder("float", shape=(None, NUM_CLASSES))
keep_prob = tf.placeholder("float")
logits = inference(images_placeholder, keep_prob)
loss_value = loss(logits, labels_placeholder)
train_op = training(loss_value, FLAGS.learning_rate)
acc = accuracy(logits, labels_placeholder)
#Prêt à économiser
saver = tf.train.Saver()
sess = tf.Session()
sess.run(tf.initialize_all_variables())
#Définition de la valeur à afficher sur TensorBoard
summary_op = tf.merge_all_summaries()
summary_writer = tf.train.SummaryWriter(FLAGS.train_dir, sess.graph_def)
for step in range(FLAGS.max_steps):
for i in range(len(train_image)/FLAGS.batch_size):
batch = FLAGS.batch_size*i
sess.run(train_op, feed_dict={
images_placeholder: train_image[batch:batch+FLAGS.batch_size],
labels_placeholder: train_label[batch:batch+FLAGS.batch_size],
keep_prob: 0.5})
train_accuracy = sess.run(acc, feed_dict={
images_placeholder: train_image,
labels_placeholder: train_label,
keep_prob: 1.0})
print "step %d, training accuracy %g"%(step, train_accuracy)
summary_str = sess.run(summary_op, feed_dict={
images_placeholder: train_image,
labels_placeholder: train_label,
keep_prob: 1.0})
summary_writer.add_summary(summary_str, step)
print "test accuracy %g"%sess.run(acc, feed_dict={
images_placeholder: test_image,
labels_placeholder: test_label,
keep_prob: 1.0})
#Enregistrez le modèle final
save_path = saver.save(sess, FLAGS.save_model)
Quant au contenu du programme ・ Apprendre en lisant 2 classes d'images de train.txt et test.txt ・ La taille de l'image varie, mais elle a été redimensionnée à 28 * 28 par redimensionnement. -Output le résultat appris dans un fichier appelé model.ckpt "GeForce GTX TITAN X 12GB" est utilisé pour le GPU.
J'ai également vu un thread que ce problème est un problème d'allocateur de mémoire et peut être résolu en mettant à jour TensorFlow vers la dernière version, mais cela ne l'a pas résolu après tout. ・ ・ ・
Comment puis-je alimenter 20 000 ou 30 000 images? Nous continuerons d'enquêter. .. ..
** Probablement résolu! !! ** → TensorFlow Pour apprendre d'un grand nombre d'images ... ~ (presque) solution ~
Recommended Posts