[PYTHON] Erstellen Sie eine KI, die Zuckerbergs Gesicht mit tiefem Lernen identifiziert learning (Datenlernen)
Teil 1: Erstellen einer KI, die Zuckerbergs Gesicht mit tiefem Lernen identifiziert ① (Vorbereitung von Lerndaten) Teil 2: Erstellen einer KI, die Zuckerbergs Gesicht durch tiefes Lernen identifiziert ② (KI-Modellbau)
Dieser Artikel ist Teil 3. Was wir machen, ist "KI, die Zuckerbergs Gesicht identifiziert". Verwenden Sie TensorFlow aus der Deep Learning-Bibliothek von Google. Beispielvideos von dem, was ich dieses Mal gemacht habe, sind hier.
Vom letzten Mal an werde ich die Verarbeitung mit TensorFlow schreiben. Die Arbeit des TensorFlow-Teils ist ** "(1) Entwerfen eines Lernmodells für TensorFlow (erledigt!) -> (2) Lernen und Trainieren von Gesichtsdaten-> (3) Ermöglichen, das Gesicht eines Bildes anhand der Lernergebnisse zu beurteilen" * Es ist ein allgemeiner Fluss von *.
Teil 2 hat ** "(1) Entwurf des TensorFlow-Lernmodells (neuronales Netzwerk)" ** abgeschlossen, also diesmal [Teil 2] Teil 1]((http://qiita.com/AkiyoshiOkano/items/72f3e4ba9caf514460ee)) Basierend auf der großen Menge an Gesichtsdaten von Zuckerberg, Billgates und Earon Mask, tatsächlich ** "Gesichtsbilddaten" Lass uns "**" lernen.
Es fühlt sich an, als wäre das tiefe Lernen mit TensorFlow endlich vorbei. (Die Mindestdokumente, die für die Voraussetzung von Deep Learning und TensorFlow erforderlich zu sein scheinen, sowie die Artikel, auf die ich mich bezog, sind in [Teil 2] zusammengefasst (http://qiita.com/AkiyoshiOkano/items/959006f9298df72a841a). Ich hoffe du kannst dich darauf beziehen.)
Lassen wir AI tatsächlich die Daten lernen! Ich freue mich darauf!
③ Lernen Sie die gesammelten Gesichtsbilddaten
1. Schreiben Sie die Verarbeitung des Datentrainings von TensorFlow
Wir werden die Verarbeitung des TensorFlow-Teils erstellen, der die Trainingsdaten tatsächlich trainiert. Wie ich im vorherigen Artikel geschrieben habe, sieht die Verzeichnisstruktur dieses Projekts so aus.
Verzeichnisaufbau
/tensoflow
main.py(Ich werde hier das Lernmodell und den Lernprozess schreiben)
eval.py(Eine Datei, die die Fallergebnisse eines Bildes zurückgibt)
/data(Im vorherigen Artikel gesammelte Gesichtsdaten)
/train
/zuckerbuerg
/elonmusk
/billgates
data.txt
/test
/zuckerbuerg
/elonmusk
/billgates
data.txt
Danach befinden sich die Ordner und Dateien, die bei der Installation von Tensorflow erstellt wurden, im Tensorflow-Ordner.
Wir werden die Verarbeitung des Lernteils zur zuletzt verwendeten Datei main.py hinzufügen.
(Der Code für den Gebäudeteil des ** zuletzt erstellten Lernmodells ** ist in dieser `` `main.py```-Datei enthalten, wird jedoch dupliziert und lang, sodass der Code für den vorherigen Teil unten beschrieben wird. Ich habe es weggelassen, aber wenn Sie es tatsächlich ausführen, fügen Sie bitte auch den Code des vorherigen Lernmodellteils in diese Datei ein. Es kann sinnvoll sein, es in eine andere Datei zu trennen und zu importieren.)
main.py(Datenlernen Teil)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import cv2
import random
import numpy as np
import tensorflow as tf
import tensorflow.python.platform
#Anzahl der Identifikationsetiketten(Diesmal drei)
NUM_CLASSES = 3
#Bildgröße beim Lernen(px)
IMAGE_SIZE = 28
#Anzahl der Abmessungen des Bildes(28px*28px*3(Farbe))
IMAGE_PIXELS = IMAGE_SIZE*IMAGE_SIZE*3
#Flag ist eine in TensorFlow integrierte Funktion, mit der Standardwerte registriert und Erklärungen wie Konstanten angezeigt werden können.
flags = tf.app.flags
FLAGS = flags.FLAGS
#Trainingsdaten
flags.DEFINE_string('train', './data/train/data.txt', 'File name of train data')
#Überprüfungsdaten
flags.DEFINE_string('test', './data/test/data.txt', 'File name of train data')
#TensorBoard-Datenspeicherordner
flags.DEFINE_string('train_dir', './data', 'Directory to put the training data.')
#Anzahl der Lernversuche
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. zart
flags.DEFINE_float('learning_rate', 1e-4, 'Initial learning rate.')
#------------------------------------------------
##################################################
#Main habe ich das letzte Mal in dieser Zeit geschrieben.Enthält den Code zum Erstellen eines Lernmodells für py.#
#Es kann sinnvoll sein, nur hier eine separate Datei zu erstellen und diese zu importieren und zu lesen.#
##################################################
#------------------------------------------------
#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(logits, labels):
#Berechnung der gekreuzten Entropie
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)
#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 die Parameter durch Optimieren basierend auf dem Fehler angepasst werden(?)
# (Die Erklärung des Buches "Übersteigt künstliche Intelligenz den Menschen?")
def training(loss, learning_rate):
#Wie diese Funktion macht das alles
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(logits, labels):
#Vergleichen Sie, ob das Vorhersageetikett und das richtige Antwortetikett gleich sind. Gibt True zurück, wenn sie identisch sind
#argmax ist der Index des Teils mit dem größten Wert im Array(=Die Nummer des Etiketts, die die richtigste Antwort zu sein scheint)Gib es zurück
correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 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, "float"))
#Auf TensorBoard anzeigen lassen
tf.scalar_summary("accuracy", accuracy)
return accuracy
if __name__ == '__main__':
#Tensor-Format, damit Lernbilder von TensorFlow gelesen werden können(Warteschlange)Umstellung auf
#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()
#Ebenso Tensor-Format, damit Verifizierungsbilder von TensorFlow gelesen werden können(Warteschlange)Umstellung auf
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():
#Tensor zum Einfügen von Bildern(28*28*3(IMAGE_PIXELS)Beliebig viele dimensionale Bilder(None)Ich habe eine Minute)
images_placeholder = tf.placeholder("float", 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("float", shape=(None, NUM_CLASSES))
#Temporärer Tensor für die Abbrecherquote
keep_prob = tf.placeholder("float")
# inference()Ein Modell machen
logits = inference(images_placeholder, keep_prob)
# loss()Den Verlust berechnen
loss_value = loss(logits, labels_placeholder)
# training()Trainieren und Anpassen der Parameter des Lernmodells
train_op = training(loss_value, FLAGS.learning_rate)
#Berechnung der Genauigkeit
acc = accuracy(logits, 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.initialize_all_variables())
#TensorBoard-Anzeigeeinstellungen(Tensor Board deklarativ?)
summary_op = tf.merge_all_summaries()
# train_Geben Sie den Pfad für die Ausgabe des TensorBoard-Protokolls mit dir an
summary_writer = tf.train.SummaryWriter(FLAGS.train_dir, sess.graph_def)
#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_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})
#Berechnen Sie die Genauigkeit nach jedem Schritt
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)
#Fügen Sie nach jedem Schritt einen 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)
#Anzeigegenauigkeit für Testdaten nach dem Training
print "test accuracy %g"%sess.run(acc, 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")
Damit ist die Verarbeitung des Lernteils von TensorFlow abgeschlossen.
Dieses Mal hat es übrigens fast die gleiche Zusammensetzung wie Kivantium von Identifizierung der Produktionsfirma von Anime Yuruyuri mit TensorFlow. ist. Zuerst habe ich verschiedene Dinge selbst gemacht, aber (ich konnte nicht dafür sorgen, dass es sich gut anfühlt) ich habe endlich versucht, dasselbe zu tun. m (_ _) m
Der Datenleseteil ist nicht OpenCV, aber es scheint, dass Sie ihn besser schreiben können, indem Sie die in TensorFlow integrierten Funktionen tf.TextLineReader und decode_jpeg verwenden, aber ich kann es nicht gut und ich kann es doch nicht ... orz
Ich dachte: "Es ist ein bisschen dasselbe, einen Artikel zu schreiben wie er ist ...", also schrieb ich einen Kommentar zum Code-Erklärungsteil für einen Super-Anfänger wie mich ausführlicher. (Bitte lassen Sie mich wissen, wenn etwas mit der Erklärung m (_ _) m nicht stimmt.)
2. Lernen Sie tatsächlich Gesichtsdaten
Nachdem das Lernmodell entworfen und der Datenlernteil verarbeitet wurde, wird die Datei main.py zusammen mit den Gesichtsbilddaten im Verzeichnis abgelegt und TensorFlow mit source bin / activ gestartet. Führen Sie dann die Datei main.py mit python main.py aus, und Sie sollten tatsächlich mit dem Lernen beginnen und die Datei model.ckpt des endgültigen Lernergebnisses ausgeben. Lassen Sie uns tatsächlich Daten lernen!
① cd tensorflow (in das Tensorflow-Verzeichnis verschieben)
② Quellbehälter / aktivieren (Tensorflow starten)
③ python main.py (Ausführung lernen!)
④ Generieren Sie eine model.ckpt Datei des endgültigen Lernergebnisses
Es ist sehr einfach, solange Sie den Prozess schreiben. In meinem Fall dauerte es ungefähr 30 Minuten, um bei 200 STEP zu lernen. Ich denke, es wird lange dauern, 100 Millionen Mal zu lernen.
3. Sehen Sie sich die Lernergebnisse an
Sie können den Übergang von Genauigkeitsrate (Genauigkeit) und Fehler (cross_entropy) sehen, wenn Sie das Lernen ausführen, da es als Grafik auf TensorBoard ausgegeben wird.
Ich denke, dass sich das Lernergebnis abhängig von den Trainingsdaten auch mit demselben Lernmodell ändern wird, aber in meinem Fall war es so. Ich denke, dass die richtige Antwortrate während des Lernens auch an die Konsole ausgegeben wird. Übrigens wurden die Anzahl der Schulungen und die Anzahl der Chargen angemessen festgelegt, indem auf die Artikel anderer Personen Bezug genommen und die Anzahl der Schulungen auf 100 bis 200 und die Anzahl der Chargen auf 10 bis 20 festgelegt wurde. Welche Art von Werteinstellung ist gut?
** Genauigkeitsgrafik (korrekte Antwortrate) **
Ich habe die Anzahl der Stapel und die Anzahl der Lernvorgänge geändert und dreimal ausgeführt, aber die Genauigkeit hat sich überhaupt nicht von 0,33 (1/3) bis zum Ende beim 1. und 2. Mal und beim 3. Mal unter den gleichen Bedingungen wie beim 2. Mal geändert Nach dem Ausführen des Lernens stieg die Genauigkeit entsprechend der Anzahl der STEPs ordnungsgemäß an. (Dieses Verhalten, dass die richtige Antwortrate beim dritten Lernen dieses Mal plötzlich anstieg, ich habe keinen Hunger, ich möchte, dass mir jemand sagt, was passiert ist m (_ _) m)
(Die Ausgabe der Konsole zum Zeitpunkt des dritten Lernens. Die korrekte Antwortrate wurde 1 bei etwa 40 SCHRITTEN.)
In meinem Fall wurde die korrekte Antwortrate in etwa 40 Schritten 1, und ich hatte das Gefühl, dass sie seltsamerweise schneller war als die Fälle anderer Personen. Deshalb habe ich sie nur für Trainingsdaten optimiert und ein Modell erstellt, das nicht tatsächlich verwendet werden kann ** "Überlernen" **? Ich bezweifelte dies, aber die korrekte Antwortrate in den Testdaten für die nachfolgende Überprüfung betrug ungefähr 97%. Gibt es also ein Problem? Ich beschloss fortzufahren. (Ich dachte auch: "Ist es in Ordnung, wenn die richtige Antwortrate 1 ist? W". Ich frage mich, ob es in Ordnung war, so fortzufahren, wie es ist ...)
** Cross_entropy (Fehler) Grafik **
Das Diagramm von cross_entropy sieht folgendermaßen aus. (Zum Zeitpunkt der dritten Lernausführung)
Was ich nach dem bisherigen Versuch dachte, war ** "Dasselbe gilt für das Design von Lernmodellen (neuronalen Netzen), aber ich bin der Meinung, dass das Anpassen der Anzahl von Trainings und der Anzahl von Chargen ein Teil ist, der Sinn und Erfahrung erfordert." ** Es war ein Eindruck. Es ist hässlich!
Dies ist das Ende des Lernens. Es scheint, dass es eine Funktion gibt, die die Daten leicht aufblasen kann, indem sie die Trainingsdaten invertiert oder den Farbton mit der integrierten Funktion von TensorFlow ändert. Ich wollte sie verwenden, aber diesmal ist es die dritte Lernausführung Auch wenn ich keine Polsterung verwendet habe, sah es nach dem Lernergebnis aus, nach dem ich vorerst gesucht hatte, also gab ich es diesmal auf. (Referenz: Erfahren Sie, wie Sie Bilder aus dem TensorFlow-Code aufblasen)
Es war mein erstes Mal, dass ich TensorFlow gelernt habe, also habe ich ziemlich herumgetastet, aber wenn Sie etwas wie "Ich sollte das hier mehr tun" haben, lassen Sie es mich bitte wissen m (_ _) m
④ Ermöglichen Sie die Beurteilung des Gesichts eines Bildes
Schließlich werden die trainierten Modelldaten verwendet, um das Gesicht eines Bildes zu bestimmen. Mit TensorFlow und Flask, einem WEB-Anwendungsframework von Python, werden wir es implementieren, damit es auf der WEB-Schnittstelle ausgeführt werden kann.
Klicken Sie hier für den vierten Teil der Fortsetzung → Erstellen Sie eine KI, die Zuckerbergs Gesicht durch tiefes Lernen identifiziert ④ (WEB-Konstruktion)
** "Erstelle eine KI, die Zuckerbergs Gesicht mit tiefem Lernen identifiziert" <Vollständiger Artikel> ** Teil 1: Erstellen einer KI, die Zuckerbergs Gesicht mit tiefem Lernen identifiziert ① (Vorbereitung von Lerndaten) Teil 2: Erstellen einer KI, die Zuckerbergs Gesicht durch tiefes Lernen identifiziert ② (KI-Modellbau) Teil 3: Erstellen einer KI, die Zuckerbergs Gesicht mit tiefem Lernen identifiziert ③ (Datenlernen) Teil 4: Erstellen einer KI, die Zuckerbergs Gesicht mit tiefem Lernen identifiziert ④ (WEB-Konstruktion)
GitHub：https://github.com/AkiyoshiOkano/zuckerberg-detect-ai
Ergebnis der Bonusbeurteilung
Bonus-Urteilsbilder. Wenn diesmal keine der ** 3 Personen von Zuckerberg, Billgates und Ilone Mask 90% überschreitet, wird die Spezifikation ** als "Keine der 3 Personen" angezeigt.
Savannah Takahashi, die wie Zuckerberg manipuliert wird [^ 1]
KI, die Zuckerberg und Savannah Takahashi richtig identifiziert
Herr Zuckerberg
[^ 1]: Quelle: http://matsukonews.com/1555