[PYTHON] Erstellen Sie eine KI, die Zuckerbergs Gesicht mit tiefem Lernen identifiziert WE (WEB-Konstruktion)

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)

Dieser Artikel ist Teil 4. 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.

Im ersten bis dritten Teil haben wir die gesammelten Gesichtsdaten mit TensorFlow lernen lassen, also haben wir dieses Mal tatsächlich das Gesicht eines beliebigen Bildes mit dem Lernergebnis und das extrahierte Gesicht extrahiert Ich möchte feststellen können, wie nah ein Gesicht an einem gelernten Gesicht ist. Und schließlich verwenden wir Flask, das Webanwendungsframework von Python, um eine Reihe von Identifikationen über eine Weboberfläche durchzuführen. Wenn du es bis zum Ende machst, denke ich, wird es "Oh, das ist AI-ähnlich!" Sein. Ich wurde w

Betrachten Sie zunächst die Arbeitsverzeichnisstruktur (Vorbereitung).

In Anbetracht der späteren WEB-Zusammenarbeit sieht die Verzeichnisstruktur wie folgt aus.

Verzeichnisaufbau

/tensoflow
  main.py
  model.ckpt(Datei, in der Lernergebnisse gespeichert werden)
  eval.py(Beschrieb den Vorgang der Rückgabe des Fallergebnisses eines Bildes)
  web.py(Beschreiben der WEB-bezogenen Verarbeitung mit Flask)
  /opencv(Ich habe von opencv offiziellem Github geklont)
  /static(Platzieren Sie das verwendete Bild in Flask)
    /images
      /default
      /cut_dace
      /face_detect
  /data
    /train
      /zuckerbuerg
      /elonmusk
      /billgates
      data.txt
    /test
      /zuckerbuerg
      /elonmusk
      /billgates
      data.txt
Danach werden die Dateien erstellt, die bei der Installation von Tensorflow usw. erstellt wurden.

Dieses Mal werde ich hauptsächlich die Dateien eval.py und web.py bearbeiten. Um den Gesichtserkennungsteil des Eingabebildes und das Bild mit ausgeschnittenem Gesicht zu speichern, erstellen Sie ein Verzeichnis mit dem Namen "/ static / images", um die spätere WEB-Erstellung vorzubereiten, und speichern Sie das Eingabebild und das verarbeitete Bild in diesem Verzeichnis. Ich werde fortsetzen. Das in Teil 1 verwendete OpenCV wird auch zur Gesichtserkennung und zum Zuschneiden verwendet, daher OpenCV. Ich habe auch den von opencv / opencv geklonten Ordner abgelegt.

④ Machen Sie es möglich, jedes Bild anhand des Lernergebnisses zu beurteilen

Da ich Sie in Teil 3 des letzten Males tatsächlich Gesichtsdaten mit TensorFlow lernen ließ, wurde am Ende von main.py`` ein neuer `save_path = saver.save (sess," model.ckpt ") erstellt Ich denke, dass die in einer Zeile von angegebene Datei model.ckptabgeschlossen ist. Da die angepassten Parameter nach dem Datentraining in dieser Datei gespeichert werden, können Sie das von TensorFlow tatsächlich trainierte AI-Modell mithilfe dieser model.ckpt``-Datei problemlos verwenden. Ich werde.

Schreiben wir zunächst eine TensorFlow-bezogene Verarbeitung, damit das Gesicht anhand eines beliebigen Bildes beurteilt werden kann. (TensorFlow für die Gesichtserkennung von Momokuro-Mitgliedern (Teil 2) Ich habe auf den Artikel verwiesen. Vielen Dank m (_ _) m)

eval.py

#!/usr/bin/env python
#! -*- coding: utf-8 -*-

import sys
import numpy as np
import cv2
import tensorflow as tf
import os
import random
import main

#OpenCV-Standardpfad für Gesichtsklassifizierer
cascade_path = './opencv/data/haarcascades/haarcascade_frontalface_default.xml'
faceCascade = cv2.CascadeClassifier(cascade_path)

#Identifikationsetikett und der Name, der jeder Etikettennummer entspricht
HUMAN_NAMES = {
  0: u"Zuckerberg",
  1: u"Eron Maske",
  2: u"Bill Gates"
}

#Angegebenes Bild(img_path)Lernergebnisse(ckpt_path)Beurteilung mit
def evaluation(img_path, ckpt_path):
  #Graph Reset(Anscheinend bin ich mir nicht sicher, was ich tue ...)
  tf.reset_default_graph()
  #Bild öffnen
  f = open(img_path, 'r')
  #Bild wird geladen
  img = cv2.imread(img_path, cv2.IMREAD_COLOR)
  #In ein Schwarzweißbild konvertieren
  gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
  face = faceCascade.detectMultiScale(gray, 1.1, 3)
  if len(face) > 0:
    for rect in face:
      #Ich wollte dem verarbeiteten Bild einen passenden Namen geben, weil es keine Rolle spielt. Vielleicht das Datum und die Anzahl der Sekunden
      random_str = str(random.random())
      #Schreiben wir den Gesichtsteil mit einer roten Linie
      cv2.rectangle(img, tuple(rect[0:2]), tuple(rect[0:2]+rect[2:4]), (0, 0, 255), thickness=2)
      #Wo soll das Bild gespeichert werden, wobei das Gesicht von einer roten Linie umgeben ist?
      face_detect_img_path = './static/images/face_detect/' + random_str + '.jpg'
      #Speichern des Bildes mit dem Gesicht, das von einer roten Linie umgeben ist
      cv2.imwrite(face_detect_img_path, img)
      x = rect[0]
      y = rect[1]
      w = rect[2]
      h = rect[3]
      #Speichern Sie das Bild des erkannten Gesichtsausschnitts
      cv2.imwrite('./static/images/cut_face/' + random_str + '.jpg', img[y:y+h, x:x+w])
      #Schneiden Sie das Gesichtsbild aus, um es an TensorFlow weiterzuleiten
      target_image_path = './static/images/cut_face/' + random_str + '.jpg'
  else:
    #Wird kein Gesicht gefunden, endet der Vorgang
    print 'image:NoFace'
    return
  f.close()

  f = open(target_image_path, 'r')
  #Array zum Einfügen von Daten
  image = []
  #Bild wird geladen
  img = cv2.imread(target_image_path)
  # 28px*Größe auf 28px geändert
  img = cv2.resize(img, (28, 28))
  #Nach dem Anordnen der Bildinformationen in einer Reihe wird 0-Auf einen Float-Wert von 1 setzen
  image.append(img.flatten().astype(np.float32)/255.0)
  #In das Numpy-Format konvertieren, damit es von TensorFlow verarbeitet werden kann
  image = np.asarray(image)
  #Gibt die Wahrscheinlichkeit jedes Etiketts für das Eingabebild aus und gibt sie zurück(main.Anruf von py)
  logits = main.inference(image, 1.0)
  # We can just use 'c.eval()' without passing 'sess'
  sess = tf.InteractiveSession()
  # restore(Parameter lesen)Vorbereitung von
  saver = tf.train.Saver()
  #Variable Initialisierung
  sess.run(tf.initialize_all_variables())
  if ckpt_path:
    #Parameter nach dem Lernen lesen
    saver.restore(sess, ckpt_path)
  # sess.run(logits)Gleich wie
  softmax = logits.eval()
  #Urteilsergebnis
  result = softmax[0]
  #Urteilsergebnis%Und abrunden
  rates = [round(n * 100.0, 1) for n in result]
  humans = []
  #Erstellen Sie einen Hash für Etikettennummer, Name und Prozentsatz
  for index, rate in enumerate(rates):
    name = HUMAN_NAMES[index]
    humans.append({
      'label': index,
      'name': name,
      'rate': rate
    })
  #Nach höchstem Prozentsatz sortieren
  rank = sorted(humans, key=lambda x: x['rate'], reverse=True)

  #Gibt das Beurteilungsergebnis und den Pfad des verarbeiteten Bildes zurück
  return [rank, face_detect_img_path, target_image_path]

#Zum Testen über die Kommandozeile
if __name__ == '__main__':
  evaluation('testimage.jpg', './model2.ckpt')

Ich denke, dass der obige Prozess ein Array zurückgeben wird ** [Prozentsatz der Beurteilungsergebnisse, Bild mit Gesichtsteil, umgeben von roter Linie, Bild mit ausgeschnittenem Gesichtsteil] **. Jetzt müssen Sie nur noch eine Reihe von Vorgängen ausführen, z. B. (1) ein Bild hochladen → (2) das Gesicht ausschneiden und eine Beurteilung durch AI vornehmen → (3) das Beurteilungsergebnis auf der WEB-Schnittstelle ausgeben.

Das tiefe Lernen mit TensorFlow endet hier. Im Folgenden wird der Aufbau des WEB beschrieben.

⑤ Ermöglichen Sie die Beurteilung von Bildern im WEB

Dieses Mal werden wir Flask verwenden, ein Webanwendungsframework für Python. Flask ist ein Framework, das das Erstellen von Webanwendungen in Python sehr einfach macht. Dieses Mal werde ich die Verwendung von Flask weglassen. (Referenz: Versuchen Sie, das Webanwendungsframework Flask zu verwenden)

Es ist ganz einfach: "Bild hochladen-> Bild an eval.py übergeben-> Ergebnis anzeigen".

web.py

# -*- coding: utf-8 -*-

import tensorflow as tf
import multiprocessing as mp

from flask import Flask, render_template, request, redirect, url_for
import numpy as np
from werkzeug import secure_filename
import os
import eval

#Instanziieren Sie Ihren Namen als App
app = Flask(__name__)
app.config['DEBUG'] = True
#Wo soll das gepostete Bild gespeichert werden?
UPLOAD_FOLDER = './static/images/default'

#Routing./Beim Zugriff
@app.route('/')
def index():
  return render_template('index.html')

#Aktion beim Posten eines Bildes
@app.route('/post', methods=['GET','POST'])
def post():
  if request.method == 'POST':
    if not request.files['file'].filename == u'':
      #Speichern Sie die hochgeladene Datei
      f = request.files['file']
      img_path = os.path.join(UPLOAD_FOLDER, secure_filename(f.filename))
      f.save(img_path)
      # eval.Übergeben Sie das hochgeladene Bild an py
      result = eval.evaluation(img_path, './model2.ckpt')
    else:
      result = []
    return render_template('index.html', result=result)
  else:
  	#Wenn Sie aufgrund eines Fehlers umleiten möchten usw.
  	return redirect(url_for('index'))

if __name__ == '__main__':
  app.debug = True
  app.run(host='0.0.0.0')

Klicken Sie hier für Ansichts- und CSS-Dateien <** index.html > Hauptansicht https://github.com/AkiyoshiOkano/zuckerberg-detect-ai/blob/First_commit/templates/index.html < layout.html > Allgemeiner Layoutteil https://github.com/AkiyoshiOkano/zuckerberg-detect-ai/blob/First_commit/templates/layout.html < style.css **> CSS-Datei https://github.com/AkiyoshiOkano/zuckerberg-detect-ai/blob/First_commit/static/style.css

Die endgültige Verzeichnisstruktur sieht folgendermaßen aus.

Verzeichnisaufbau

/tensoflow
  main.py(Tensorflow-Lernmodell und Trainingsteil)
  model.ckpt(Datei, in der Lernergebnisse gespeichert werden)
  eval.py(Beschrieb den Vorgang der Rückgabe des Fallergebnisses eines Bildes)
  web.py(Beschreiben der WEB-bezogenen Verarbeitung mit Flask)
  /opencv(Ich habe von opencv offiziellem Github geklont)
  /static(Platzieren Sie die in Flask verwendeten Bilder und CSS)
    /images
      /default(Hochgeladenes Bild)
      /cut_dace(Bild mit beschnittenem Gesicht)
      /face_detect(Bild des Gesichts umgeben von roter Linie)
    style.css
  /templates(Teil der Flasche anzeigen)
    index.html
    layout.html
  /data
    /train
      /zuckerbuerg
      /elonmusk
      /billgates
      data.txt
    /test
      /zuckerbuerg
      /elonmusk
      /billgates
      data.txt
Danach werden die Dateien erstellt, die bei der Installation von Tensorflow usw. erstellt wurden.

TensorFlow scheint in der Lage zu sein, auf Heroku zu laufen, also werde ich es versuchen, wenn ich Zeit habe.

Damit ist das Verfahren zur Erstellung eines Zuckerberg-Detektors mit TensorFLow abgeschlossen. Vielen Dank an alle, die uns geholfen haben. Ich hoffe, mein Artikel ist hilfreich für jemanden m (_ _) m

Nachtrag der Entwicklung

Dies war mein erstes maschinelles Lernen (Deplanning), aber ich fand die Informationen im Internet großartig, weil ich sie bis zu einem gewissen Grad nur mit den Informationen im WEB bilden konnte, ohne Bücher usw. zu verwenden, und ich konnte so viel tiefes Lernen verstehen habe gedacht. Ich denke jedoch, dass ich diesmal angesprochen habe: "Ich denke, es ist wirklich der erste Schritt im maschinellen Lernen (Deep Learning)." (Ist es möglich, von einer "unerfahrenen Person" zu einem "Anfänger" zu wechseln?)

In Bezug auf die tatsächlich trainierte KI ** besteht eine hohe Wahrscheinlichkeit, dass das Bild einer Frau zu 95% oder mehr von Mr. Bill Gates oder Mr. Earon Mask ** stammt, was bedeutet, dass die diesmal trainierten Daten ausschließlich männliche Gesichter sind. Wenn also das Gesicht einer Frau übergeben wird, kann es nicht gut beurteilt werden, aber vorerst habe ich vermutet, dass dies das Ergebnis sein würde, da die Wahrscheinlichkeit jedes Etiketts zu 100% kombiniert und ausgegeben werden muss. schwer.

Ich war jedoch ziemlich überrascht über die Genauigkeit des Tiefenlernens, da ** Zuckerberg, Ilone Mask und Bill Gates, die Gesichtsdaten trainierten, fast ohne Entfernen identifiziert werden können **. Es ist wie "Oh, ich werde dich wirklich w schlagen". (Vielleicht entferne ich manchmal nur die Ilone-Maske?)

Danach war ich beeindruckt von der Bequemlichkeit von TensorFlow, mit der Sie vorerst integrierte Funktionen verwenden können, auch wenn Sie die komplizierten mathematischen Formeln und die differenzielle Integration, die hinter Deep Learning stehen, nicht wirklich verstehen. Wenn ich mehr lerne, wird sich das Spektrum der Dinge, die ich tun kann, erheblich erweitern. Daher möchte ich diese Gelegenheit nutzen, um mein Bestes zu geben, um mit den Maschineninformationen Schritt zu halten. Ich denke, es gab viele Punkte, die ich in meiner ersten tiefen Lernerfahrung nicht erreichen konnte, aber ich möchte mich bei allen bedanken, die es bis zum Ende gelesen haben. (Ich würde es begrüßen, wenn Sie auf die Punkte hinweisen könnten, die falsch interpretiert werden m (_ _) m)

Ich habe 2017 sogar einen Entwicklungs-Roadmovie unter dem Namen ** GW Free Research ** gedreht. Wenn Sie also Zeit haben, schauen Sie bitte mal rein (lacht). Sie können auch die Beurteilungsergebnisse sehen, die anhand der Bilder verschiedener Personen beurteilt werden. Der Entwicklungsfilm stammt von hier.

** "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: KI erstellen, die Zuckerbergs Gesicht durch tiefes Lernen identifiziert ④ (WEB-Konstruktion)

GitHub:https://github.com/AkiyoshiOkano/zuckerberg-detect-ai