--DeepLearning hat mehrere Bibliotheken, aber TensorFlow hat eine Notation, die beim Erstellen von Modellen im Vergleich zu anderen Bibliotheken eher kompliziert ist.
slim_network.py
#!/usr/local/bin/python
# -*- coding: utf-8 -*-
import cv2
import numpy as np
import tensorflow as tf
import tensorflow.python.platform
import tensorflow.contrib.slim as slim
#Anzahl der Identifikationsetiketten(Diesmal Zuckerberg:0,Earon-Maske: 1,Bill Gates:2 so 3)
NUM_CLASSES = 3
#Bildgröße beim Lernen(px)
IMAGE_SIZE = 28
#Anzahl der Abmessungen des Bildes(28* 28*Farbe(?))
IMAGE_PIXELS = IMAGE_SIZE*IMAGE_SIZE*3
#Legen Sie den für das Lernen erforderlichen Datenpfad und den Lernumfang fest
#Integrierte TensorFlow-Funktion, mit der Parametereinstellungen, Standardwerte und Erklärungen zum Hilfebildschirm registriert werden können
flags = tf.app.flags
FLAGS = flags.FLAGS
#Trainingsdaten
flags.DEFINE_string('train', '/Users/neriai/Develops/workspace/dir/train/data.txt', 'File name of train data')
#Überprüfungstestdaten
flags.DEFINE_string('test', '/Users/neriai/Develops/workspace/dir/test/data.txt', 'File name of train data')
#Ordner, in dem Daten abgelegt werden
flags.DEFINE_string('train_dir', '/Users/neriai/Develops/workspace/dir/data', 'Directory to put the training data.')
#Anzahl der Trainingsversuche zum Datenlernen
flags.DEFINE_integer('max_steps', 100, 'Number of steps to run trainer.')
#Wie viele Bilder sollen in einer Studie verwendet werden?
flags.DEFINE_integer('batch_size', 20, 'Batch size Must divide evenly into the dataset sizes.')
#Wenn die Lernrate zu klein ist, wird das Lernen nicht fortgesetzt, und wenn sie zu groß ist, konvergiert oder divergiert der Fehler nicht.
flags.DEFINE_float('learning_rate', 1e-4, 'Initial learning rate.')
#Lernmodell Teil der KI(neurales Netzwerk)Erschaffen
# images_placeholder:Platzhalter fuer Bild, keep_prob:Abbrecherquote Ort_Inhaber wird ein Argument
#Gibt die Wahrscheinlichkeit jedes Etiketts für das Eingabebild aus und gibt sie zurück
def model(x_image, keep_prob):
with slim.arg_scope(
[slim.conv2d, slim.fully_connected],
activation_fn=tf.nn.relu,
weights_initializer=tf.truncated_normal_initializer(stddev=0.1),
biases_initializer=tf.constant_initializer(0.1)
):
with slim.arg_scope([slim.max_pool2d], padding='SAME'):
#Erstellen Sie die erste Ebene der Faltungsschicht
conv1 = slim.conv2d(x_image, 32, [5, 5])
#Erstellung der Pooling-Schicht 1
pool1 = slim.max_pool2d(conv1, [2, 2])
#Erzeugung der zweiten Schicht der Faltungsschicht
conv2 = slim.conv2d(pool1, 64, [5, 5])
#Erstellung der Pooling-Schicht 2
pool2 = slim.max_pool2d(conv2, [2, 2])
#Erstellung der vollständig verbundenen Schicht 1
pool2_flat = slim.flatten(pool2)
fc1 = slim.fully_connected(pool2_flat, 1024)
#Dropout-Einstellungen
dropout = slim.dropout(fc1, keep_prob)
#Erstellung der vollständig verbundenen Schicht 2
y_conv = slim.fully_connected(dropout, NUM_CLASSES, activation_fn=None)
# #Normalisierung durch Softmax-Funktion
y_conv = tf.nn.softmax(y_conv)
return y_conv
#Berechnen Sie, wie viel "Fehler" zwischen dem Vorhersageergebnis und der richtigen Antwort lag
#logits ist das Berechnungsergebnis: float - [batch_size, NUM_CLASSES]
#label ist das richtige Antwortetikett: int32 - [batch_size, NUM_CLASSES]
def loss(labels_placeholder, model):
#Berechnen Sie, wie viel "Fehler" zwischen dem Vorhersageergebnis und der richtigen Antwort lag
cross_entropy = -tf.reduce_sum(labels_placeholder*tf.log(model))
#Geben Sie an, dass in TensorBoard angezeigt werden soll
tf.summary.scalar("cross_entropy", cross_entropy)
#Wert der Fehlerrate(cross_entropy)Gib es zurück
return cross_entropy
#Error(loss)Trainieren Sie ein Lernmodell, das mit Hilfe der Fehler-Backpropagation basierend auf entwickelt wurde
#Ich bin mir nicht sicher, was hinter den Kulissen passiert, aber die Gewichte jeder Schicht des Lernmodells(w)Und so weiter
#Verstehen, dass es basierend auf dem Fehler optimiert und angepasst wird(?)
# (Die Erklärung des Buches "Übersteigt künstliche Intelligenz den Menschen?")
def training(learning_rate, loss):
#Error(loss)Trainieren Sie ein Lernmodell, das mit Hilfe der Fehler-Backpropagation basierend auf entwickelt wurde
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)
return train_step
#Berechnen Sie die korrekte Antwortrate des Vorhersageergebnisses, das das Lernmodell bei Inferenz angibt
def accuracy(model, labels_placeholder):
#Vergleichen Sie, ob das Vorhersageetikett und das richtige Antwortetikett gleich sind. Gibt True zurück, wenn sie identisch sind
correct_prediction = tf.equal(tf.argmax(model, 1), tf.argmax(labels_placeholder, 1))
#Boolescher Wert korrekt_Berechnen Sie die richtige Antwortrate, indem Sie die Vorhersage in float ändern
# false:0,true:In 1 konvertieren und berechnen
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
#Auf TensorBoard anzeigen lassen
tf.summary.scalar("accuracy", accuracy)
return accuracy
if __name__ == '__main__':
#Datei öffnen
f = open(FLAGS.train, 'r')
#Array zum Einfügen von Daten
train_image = []
train_label = []
for line in f:
#Durch Leerzeichen mit Ausnahme von Zeilenumbrüchen getrennt
line = line.rstrip()
l = line.split()
#Daten lesen und auf 28x28 reduzieren
img = cv2.imread(l[0])
img = cv2.resize(img, (IMAGE_SIZE, IMAGE_SIZE))
#Nach dem Anstehen 0-Auf einen Float-Wert von 1 setzen
train_image.append(img.flatten().astype(np.float32)/255.0)
#Etikett 1-of-Mit der k-Methode vorbereiten
tmp = np.zeros(NUM_CLASSES)
tmp[int(l[1])] = 1
train_label.append(tmp)
#In das Numpy-Format konvertieren
train_image = np.asarray(train_image)
train_label = np.asarray(train_label)
f.close()
f = open(FLAGS.test, 'r')
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)
f.close()
#Geben Sie den Bereich an, der in das TensorBoard-Diagramm ausgegeben werden soll
with tf.Graph().as_default() as graph:
#Tensor zum Einfügen von Bildern(28*28*3(IMAGE_PIXELS)Beliebig viele dimensionale Bilder(None)Ich habe eine Minute)
images_placeholder = tf.placeholder(tf.float32, shape=(None, IMAGE_PIXELS))
#Tensor, um ein Etikett zu setzen(3(NUM_CLASSES)Beliebig viele dimensionale Beschriftungen(None)Geben Sie die Minuten ein)
labels_placeholder = tf.placeholder(tf.float32, shape=(None, NUM_CLASSES))
#28px Bilddateneingabe im Vektorformat*Kehren Sie zum 28px-Bild zurück(?)。
#Diesmal ist es ein Farbbild also 3(1 für Monochrom)
x_image = tf.reshape(images_placeholder, [-1, IMAGE_SIZE, IMAGE_SIZE, 3])
#Temporärer Tensor für die Abbrecherquote
keep_prob = tf.placeholder(tf.float32)
# model()Ein Modell machen
model = model(x_image, keep_prob)
# loss()Den Verlust berechnen
loss = loss(labels_placeholder, model)
# training()Trainieren und Anpassen der Parameter des Lernmodells
train_step = training(FLAGS.learning_rate, loss)
#Berechnung der Genauigkeit
accuracy = accuracy(model, labels_placeholder)
#Bereit zum Speichern
saver = tf.train.Saver()
#Sitzung erstellen(TensorFlow-Berechnungen müssen in einer absoluten Sitzung durchgeführt werden)
sess = tf.Session()
#Variable Initialisierung(Nach dem Starten der Sitzung initialisieren)
sess.run(tf.global_variables_initializer())
#TensorBoard-Anzeigeeinstellungen(Tensor Board deklarativ?)
summary_step = tf.summary.merge_all()
# train_Geben Sie den Pfad für die Ausgabe des TensorBoard-Protokolls mit dir an
summary_writer = tf.summary.FileWriter(FLAGS.train_dir, sess.graph)
#Eigentlich max_Führen Sie das Training so oft wie Schritt durch
for step in range(FLAGS.max_steps):
for i in range(len(train_image)/FLAGS.batch_size):
# batch_Durchführung eines Trainings für Größenbilder
batch = FLAGS.batch_size*i
# feed_Geben Sie die Daten an, die mit dict in den Platzhalter eingefügt werden sollen
sess.run(
train_step,
feed_dict={
images_placeholder: train_image[batch:batch+FLAGS.batch_size],
labels_placeholder: train_label[batch:batch+FLAGS.batch_size],
keep_prob: 0.5
}
)
#Berechnen Sie die Genauigkeit nach jedem Schritt
train_accuracy = sess.run(
accuracy,
feed_dict={
images_placeholder: train_image,
labels_placeholder: train_label,
keep_prob: 1.0
}
)
print "step %d, training accuracy %g"%(step, train_accuracy)
#Fügen Sie nach jedem Schritt einen Wert hinzu, der auf dem TensorBoard angezeigt werden soll
summary_str = sess.run(
summary_step,
feed_dict={
images_placeholder: train_image,
labels_placeholder: train_label,
keep_prob: 1.0
}
)
summary_writer.add_summary(summary_str, step)
#Anzeigegenauigkeit für Testdaten nach dem Training
print "test accuracy %g"%sess.run(
accuracy,
feed_dict={
images_placeholder: test_image,
labels_placeholder: test_label,
keep_prob: 1.0
}
)
#Trainieren Sie die Daten und speichern Sie das endgültige Modell
# "model.ckpt"Ist der Name der Ausgabedatei
save_path = saver.save(sess, "model.ckpt")
Before
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')
After
with slim.arg_scope(
[slim.conv2d, slim.fully_connected],
activation_fn=tf.nn.relu,
weights_initializer=tf.truncated_normal_initializer(stddev=0.1),
biases_initializer=tf.constant_initializer(0.1)
):
with slim.arg_scope([slim.max_pool2d], padding='SAME'):
Before
W_conv1 = weight_variable([5, 5, 3, 32])
b_conv1 = bias_variable([32])
conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
After
conv1 = slim.conv2d(x_image, 32, [5, 5])
Before
pool1 = max_pool_2x2(conv1)
After
pool1 = slim.max_pool2d(conv1, [2, 2])
Before
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
After
conv2 = slim.conv2d(pool1, 64, [5, 5])
Before
pool2 = max_pool_2x2(conv2)
After
pool2 = slim.max_pool2d(conv2, [2, 2])
Before
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
pool2_flat = tf.reshape(pool2, [-1, 7*7*64])
fc1 = tf.nn.relu(tf.matmul(pool2_flat, W_fc1) + b_fc1)
After
pool2_flat = slim.flatten(pool2)
fc1 = slim.fully_connected(pool2_flat, 1024)
Before
dropout = tf.nn.dropout(fc1, keep_prob)
After
dropout = slim.dropout(fc1, keep_prob)
Before
W_fc2 = weight_variable([1024, NUM_CLASSES])
b_fc2 = bias_variable([NUM_CLASSES])
y_conv = tf.nn.softmax(tf.matmul(dropout, W_fc2) + b_fc2)
After
y_conv = slim.fully_connected(dropout, NUM_CLASSES, activation_fn=None)
y_conv = tf.nn.softmax(y_conv)
――Es fühlt sich etwas schlanker an, kann aber in Bezug auf die SSD-Klasse effektiv sein. ――Es ist eher ein Rätsel als ein Verständnis von Ersatz. ――Es schien, dass andere Dinge ersetzt werden könnten, aber da verschiedene Fehler und berechnete Werte fehlerhaft waren, habe ich sie nur im Modell behalten. ――Ich glaube, es war eine Paku-Ressource, aber es wurde ein wenig meine eigene.
Recommended Posts