Hallo, das ist Ikki. Schließlich löste ich das Problem, eine große Anzahl von Bildern an TensorFlow weiterzuleiten. Als ich es gelöst habe, war es wirklich peinlich. .. .. Nicht zur Hälfte kopieren und einfügen!
Hier hat ein Programm zum Lernen von Bildern veröffentlicht, die von mir selbst erstellt wurden. Es ist jedoch nicht möglich, Zehntausende von Bilddaten so wie sie sind zu lernen. Es war.
Also werde ich zuerst das modifizierte Programm veröffentlichen.
train.py
#!/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 = 3
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', 201, 'Number of steps to run trainer.')
flags.DEFINE_integer('batch_size', 256, '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 Modelle für tiefes Lernen erstellen
#Streit:
# images_placeholder: inputs()Platzhalter des in erstellten Bildes
# keep_prob:Abbrecherquote Ort_holder
#Rückgabewert:
# cross_entropy:Ergebnis der Modellberechnung
###############################################################
#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)
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:Ergebnis der Modellberechnung
###############################################################
cross_entropy = -tf.reduce_sum(labels*tf.log(tf.clip_by_value(logits,1e-10,1.0)))
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)
train_len = 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)
test_len = len(test_image)
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)
saver = tf.train.Saver()
sess = tf.Session()
sess.run(tf.initialize_all_variables())
summary_op = tf.merge_all_summaries()
summary_writer = tf.train.SummaryWriter(FLAGS.train_dir, sess.graph_def)
#Durchführung von Schulungen
if train_len % FLAGS.batch_size is 0:
train_batch = train_len/FLAGS.batch_size
else:
train_batch = (train_len/FLAGS.batch_size)+1
print "train_batch = "+str(train_batch)
for step in range(FLAGS.max_steps):
for i in range(train_batch):
batch = FLAGS.batch_size*i
batch_plus = FLAGS.batch_size*(i+1)
if batch_plus > train_len: batch_plus = train_len
# feed_Geben Sie die Daten an, die mit dict in den Platzhalter eingefügt werden sollen
sess.run(train_op, feed_dict={
images_placeholder: train_image[batch:batch_plus],
labels_placeholder: train_label[batch:batch_plus],
keep_prob: 0.5})
if step % 10 == 0:
train_accuracy = 0.0
for i in range(train_batch):
batch = FLAGS.batch_size*i
batch_plus = FLAGS.batch_size*(i+1)
if batch_plus > train_len: batch_plus = train_len
train_accuracy += sess.run(acc, feed_dict={
images_placeholder: train_image[batch:batch_plus],
labels_placeholder: train_label[batch:batch_plus],
keep_prob: 1.0})
if i is not 0: train_accuracy /= 2.0
#Fügen Sie nach jeweils 10 Schritten den Wert hinzu, der auf dem TensorBoard angezeigt werden soll
#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 "step %d, training accuracy %g"%(step, train_accuracy)
if test_len % FLAGS.batch_size is 0:
test_batch = test_len/FLAGS.batch_size
else:
test_batch = (test_len/FLAGS.batch_size)+1
print "test_batch = "+str(test_batch)
test_accuracy = 0.0
for i in range(test_batch):
batch = FLAGS.batch_size*i
batch_plus = FLAGS.batch_size*(i+1)
if batch_plus > train_len: batch_plus = train_len
test_accuracy += sess.run(acc, feed_dict={
images_placeholder: test_image[batch:batch_plus],
labels_placeholder: test_label[batch:batch_plus],
keep_prob: 1.0})
if i is not 0: test_accuracy /= 2.0
print "test accuracy %g"%(test_accuracy)
save_path = saver.save(sess, FLAGS.save_model)
Vorerst denke ich, dass es mit Kopieren und Einfügen funktionieren wird. (Lassen Sie uns nach dem Verständnis kopieren und einfügen!) Es gibt kleinere Korrekturen, aber die wichtigsten Änderungen, die zur Lösung geführt haben, sind train_accuracy und test_accuracy, die die Genauigkeit berechnen. Ich habe zur Stapelverarbeitung gewechselt. Nun, warum haben Sie die Stapelverarbeitung durchgeführt, bei der Sie gelernt haben, und haben dies nicht getan, als Sie die Genauigkeit berechnet haben ... ~~ Vielleicht lachen einige großartige Leute, wenn sie das Programm sehen und sagen: "Warum machst du das? Du wirst einen Speicherfehler mit Pupupu ~ www bekommen." Tatsächlich lachte ich in dem Moment, als ich es bemerkte. ~~ Abgesehen von den Negativen wird es einige Zeit dauern, egal wie viele Bilder Sie essen, aber ich denke, es wird Sie gut unterrichten.
Ich werde etwas detaillierter schreiben, wie man mit diesem Programm umgeht.
Platzieren Sie train.txt und test.txt im selben Ordner wie diese train.py. Der Inhalt jedes Textes ist wie folgt
lang:train.txt&test.txt
/home/picture/images/image1.jpg 0
/home/picture/images/image2.jpg 0
/home/picture/images/image3.jpg 1
/home/picture/images/image4.jpg 2
/home/picture/images/image5.jpg 1
/home/picture/images/image6.jpg 1
:
:
Ich fühle mich so. Dieses Mal ist es in 3 Klassen eingeteilt, also
Name der Bilddatei Klassenname (0 ~ 2)
Wird besorgt. In solchen Fällen schreibe ich immer mit einem absoluten Pfad. Diese Textdatei ist schwer selbst zu schreiben. Schreiben wir also ein Programm, um sie automatisch zu generieren. Ich werde es auf Anfrage posten, aber ...
Außerdem habe ich dieses Mal einen Ordner namens "training" im selben Ordner wie "train.py" erstellt und beide Textdateien darin abgelegt.
Wenn Sie einen Ordner mit dem Namen "models" erstellen, wird eine ".ckpt" -Datei mit den Lernergebnissen erstellt.
Dies ist nur ein Beispiel.
test.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import numpy as np
import tensorflow as tf
import cv2
import tensorflow.python.platform
from types import *
NUM_CLASSES = 3
IMAGE_SIZE = 28
IMAGE_PIXELS = IMAGE_SIZE*IMAGE_SIZE*3
flags = tf.app.flags
FLAGS = flags.FLAGS
flags.DEFINE_string('readmodels', 'models/model.ckpt', 'File name of model data')
def inference(images_placeholder, keep_prob):
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
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')
x_image = tf.reshape(images_placeholder, [-1, IMAGE_SIZE, IMAGE_SIZE, 3])
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_image, W_conv1) + b_conv1)
with tf.name_scope('pool1') as scope:
h_pool1 = max_pool_2x2(h_conv1)
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)
with tf.name_scope('pool2') as scope:
h_pool2 = max_pool_2x2(h_conv2)
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)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
with tf.name_scope('fc2') as scope:
W_fc2 = weight_variable([1024, NUM_CLASSES])
b_fc2 = bias_variable([NUM_CLASSES])
with tf.name_scope('softmax') as scope:
y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
return y_conv
if __name__ == '__main__':
test_image = []
for i in range(1, len(sys.argv)):
img = cv2.imread(sys.argv[i])
print img
img = cv2.resize(img, (IMAGE_SIZE, IMAGE_SIZE))
test_image.append(img.flatten().astype(np.float32)/255.0)
test_image = np.asarray(test_image)
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)
sess = tf.InteractiveSession()
saver = tf.train.Saver()
sess.run(tf.initialize_all_variables())
saver.restore(sess,FLAGS.readmodels)
for i in range(len(test_image)):
pr = logits.eval(feed_dict={
images_placeholder: [test_image[i]],
keep_prob: 1.0 })[0]
pred = np.argmax(pr)
print pr
print pred
print "finish"
python test.py image file
Wenn Sie es mit ausführen, sollten Sie das Erkennungsergebnis erhalten. Besonders die Erklärung ist gut.
Eigentlich ist train.py auch mit Tensorboard kompatibel, aber ich habe Probleme, weil der zusammenfassende Teil, der das Diagramm zeichnet, nicht stapelweise verarbeitet werden kann.
Das Problem ist, dass der Typ des von sess.run (summary_op, ~~) zurückgegebenen Werts str-Typ ist und es einige unbekannte Werte für Tensorboard gibt.
** Es ist nicht möglich zu sagen "Addiere die für jede Charge berechneten Ergebnisse und zeichne ein Diagramm (nimm den Durchschnitt)" **.
Bitte lassen Sie mich wissen, wenn Sie eine Lösung haben oder wenn Sie es bemerken. .. ..
Recommended Posts