Ich habe mir meine Beiträge bis zum letzten Mal angesehen, aber es ist sehr schwer zu erkennen ... Ich muss nach und nach eine Schreibweise entwickeln. Hallo, das ist Ikki. Preferred Networks, das ich neulich auf der Roboterausstellung gesehen habe, hat es in Zusammenarbeit mit FANUC entwickelt. " Der Blog über Lernen von 0 für Massenroboter mit tiefem Lernen wurde aktualisiert. Oder besser gesagt, es wurde bereits gepostet, als ich es das letzte Mal gepostet habe. .. .. Ich habe mir die Geschichte während des Workshops angehört und war überrascht zu hören, dass dieser Roboter in 3 Monaten hergestellt wurde. Herr Nishikawa sagte: "Es hätte drei Jahre für einen normalen Menschen gedauert (lacht)", aber ich habe nicht die Fähigkeit, dies zu tun, selbst wenn es drei Jahre dauert.
Die Einführung ist also lang geworden, aber dieses Mal geht es nach dem vorherigen Artikel um das Problem "Nicht genügend GPU-Speicher". ..
Von den Ratschlägen von Reo Aoki und MATS bis zum vorherigen Artikel konnte ich ein Programm erstellen, das Bilder lernt und erkennt, ohne Fehler zu werfen, aber die Anzahl der Bilder, die gegessen werden können, ist gering und nicht gut genug. Die Erkennungsgenauigkeit ist nicht gut. Sollte ich ein Bild (Datensatz) erstellen, das trainiert werden soll? Ich denke auch, aber wenn möglich, würde ich es gerne innerhalb des Programms lösen. In Zukunft möchte ich Trainingsdaten erstellen, ohne Fehler zu werfen, egal wie viele Bilder gegessen werden! Ich denke. (Obwohl es eine Grenze für "wie viel" gibt)
Das aktuelle Programm ist wie folgt. Auch dieses Mal werde ich auf [Identifizierung der Produktionsfirma von Anime Yuruyuri mit dem Kivantium-Aktivitätstagebuch TensorFlow] verweisen (http://kivantium.hateblo.jp/entry/2015/11/18/233834). Vielen Dank.
#!/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):
####################################################################
#Funktionen, die Vorhersagemodelle erstellen
#Streit:
# images_placeholder:Platzhalter fuer Bild
# keep_prob:Platzhalter für Abbrecherquote
#Rückgabewert:
# y_conv:Wahrscheinlichkeit jeder Klasse(Etwas wie)
####################################################################
#Gewichtsstandardabweichung 0.Initialisiert mit einer Normalverteilung von 1
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
#Vorspannung zur Standardabweichung 0.Initialisiert mit einer Normalverteilung von 1
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
#Erstellen einer Faltungsschicht
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
#Erstellen einer Poolebene
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1], padding='SAME')
#Transformiere den Eingang in 28x28x3
x_images = tf.reshape(images_placeholder, [-1, IMAGE_SIZE, IMAGE_SIZE, 3])
#Erzeugung der Faltungsschicht 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)
#Erstellung der Pooling-Schicht 1
with tf.name_scope('pool1') as scope:
h_pool1 = max_pool_2x2(h_conv1)
#Erzeugung der Faltungsschicht 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)
#Erstellung der Pooling-Schicht 2
with tf.name_scope('pool2') as scope:
h_pool2 = max_pool_2x2(h_conv2)
#Erstellung der vollständig verbundenen Schicht 1
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)
#Dropout-Einstellungen
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
#Erstellung der vollständig verbundenen Schicht 2
with tf.name_scope('fc2') as scope:
W_fc2 = weight_variable([1024, NUM_CLASSES])
b_fc2 = bias_variable([NUM_CLASSES])
#Normalisierung durch Softmax-Funktion
with tf.name_scope('softmax') as scope:
y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
#Gibt so etwas wie die Wahrscheinlichkeit jedes Etiketts zurück
return y_conv
def loss(logits, labels):
####################################################################
#Funktion zur Berechnung des Verlustes
#Streit:
# logits:Logit Tensor, float - [batch_size, NUM_CLASSES]
# labels:Tensor beschriften, int32 - [batch_size, NUM_CLASSES]
#Rückgabewert:
# cross_entropy:Gekreuzter Entropietensor, float
####################################################################
#Berechnung der Kreuzentropie
cross_entropy = -tf.reduce_sum(labels*tf.log(logits))
#Geben Sie an, dass in TensorBoard angezeigt werden soll
tf.scalar_summary("cross_entropy", cross_entropy)
return cross_entropy
def training(loss, learning_rate):
####################################################################
#Funktionen, die Trainingsoperationen definieren
#Streit:
# loss:Verlusttensor, loss()Ergebnis von
# learning_rate:Lernkoeffizient
#Rückgabewert:
# train_step:Training op
####################################################################
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)
return train_step
def accuracy(logits, labels):
####################################################################
#Richtige Antwortrate(accuracy)Funktion zum Berechnen
#Streit:
# logits: inference()Ergebnis von
# labels:Tensor beschriften, int32 - [batch_size, NUM_CLASSES]
#Rückgabewert:
# accuracy:Richtige Antwortrate(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__':
#Datei öffnen
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)
#Bereit zum Speichern
saver = tf.train.Saver()
sess = tf.Session()
sess.run(tf.initialize_all_variables())
#Festlegen des Werts, der auf TensorBoard angezeigt werden soll
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})
#Speichern Sie das endgültige Modell
save_path = saver.save(sess, FLAGS.save_model)
Wie für den Inhalt des Programms ・ Lernen durch Lesen von 2 Bildklassen aus train.txt und test.txt ・ Die Größe des Bildes variiert, wurde jedoch durch Größenänderung auf 28 * 28 geändert.
Ich habe auch einen Thread gesehen, dass dieses Problem ein Speicherzuordnungsproblem ist und durch Aktualisieren von TensorFlow auf die neueste Version behoben werden kann, aber es hat es doch nicht gelöst. ・ ・ ・
Wie kann ich 20.000 oder 30.000 Bilder füttern? Wir werden weiter untersuchen. .. ..
** Wahrscheinlich gelöst! !! ** → TensorFlow Um aus einer großen Anzahl von Bildern zu lernen ... ~ (fast) Lösung ~
Recommended Posts