Ich habe eine App erstellt, um herauszufinden, wie die Mitglieder der Strohhut-Piraten aussehen

Dieses Mal habe ich eine Anwendung erstellt, die die Bilderkennung des maschinellen Lernens verwendet. Wie der Titel schon sagt, können Sie herausfinden, wie sehr Ihr Gesicht dem ähnelt, der Mitglied der Strohhut-Piraten in einem Stück ist.

Klicken Sie hier für Git Hub ↓↓↓ https://github.com/Sho-cmyk/shiny-winner

Schauen Sie sich zunächst das ausgefüllte Formular an. 図1.png Wenn Sie die Aufnahmetaste drücken, Es zeigt, wie sehr Ihr Gesicht für ein Mitglied der Strohhut-Piraten aussieht. Die beiden obersten ähnlichen Zeichen werden angezeigt. ャ.JPG Ich fand, dass es zu 38% Jinbei und zu 20% Luffy ähnlich war.

Wenn Sie an der App interessiert sind, versuchen Sie es bitte über diese URL. ↓↓↓ https://one-piece-camera.herokuapp.com/

Schritte zum Erstellen einer App

Als nächstes werde ich das Verfahren zum Erstellen einer App vorstellen. Das Verfahren ist grob wie folgt unterteilt.

Dateistruktur (Kolben)
1. Sammle Bilder zum Lernen
Bildvorverarbeitung
1. Lernen
Schätzen
Ordnen Sie den Ausgabebildschirm mit html / css / js an
Dateistruktur in Flask

flask_app
├ one-piece_cnn_aug.h5 ---Gewicht sparen
├ static　---Speicherort der statischen Datei
│ ├ image
│ └ webcam.js
│ └ stylesheet.css
├ templates　---Vorlage
│ └ index.html
│ └ photoclick.html
│ └ photoclick_copy.html
├ main.py ---App-Ausführungsskript (App-Eingang)
├ requirements.txt 
└ runtime.txt
└ Profile
└ README.md

1. Sammle Bilder zum Lernen Ich benutze die Bildersuche von Yahoo, um Bilder von jedem Mitglied der Strohhut-Piraten zu kratzen. Ich habe jeweils 200 Blatt abgekratzt. Informationen zur detaillierten Schabemethode finden Sie im Folgenden. Zitat: https://www.youtube.com/watch?v=BrCaYYJtC4w
Bildvorverarbeitung Ich werde nur die Bilder belassen, die als nächstes verwendet werden können. Ich werde die Fotos löschen, die der Zielcharakter nicht von selbst bewegt hat.

Das Bild ist jetzt in Trainingsdaten und Testdaten unterteilt. Die Trainingsdaten werden mit ImageDataGenerator aufgeblasen.

`generatedata.py`


from PIL import Image
import os,glob
import numpy as np
from sklearn.model_selection import train_test_split
from keras.preprocessing.image import ImageDataGenerator

classes=["Usop","Sanji","Jinbei","Zoro","Hubschrauber","Nami","Bibi","Frankie","Bach","Ruffy","Robin"]
num_classes=len(classes)
image_size=50
num_testdata=30

#Bilder laden
X_train=[]
X_test=[]
Y_train=[]
Y_test=[]

for index,classlabel in enumerate(classes):
    photos_dir="./"+classlabel
    files=glob.glob(photos_dir+"/*.jpg ")
    for i,file in enumerate(files):
        if i >=200:break
        image= Image.open(file)
        image=image.convert("RGB")
        image=image.resize((image_size,image_size))
        data=np.asarray(image)
        X_train.append(data) #Am Ende der Liste hinzufügen
        Y_train.append(index) #Fügen Sie ein Etikett hinzu
#Standardisierung
datagen=ImageDataGenerator(samplewise_center=True,samplewise_std_normalization=True)


g=datagen.flow(X_train,Y_train,shuffle=False)
X_batch,y_batch=g.next()

#0 unter Beibehaltung des Verhältnisses der RGB-Werte-In der Nähe von 255 für eine einfache Anzeige
X_batch *=127.0/max(abs(X_batch.min()),X_batch.max())
X_batch +=127.0
X_batch =X_batch.astype('unit8')

#Legen Sie es in ein Array und teilen Sie es in Test- und Trainingsdaten auf
X_train=np.array(X_train)
X_test=np.array(X_test)
y_train=np.array(Y_train)
y_test=np.array(Y_test)

#X_train,X_test,y_train,y_test=train_test_split(X,Y)
xy=(X_train,X_test,y_train,y_test)
np.save("./one-piece_aug.npy",xy)#Code speichern

1. Lernen Das Trainingsmodell verwendet CNN. Der Code ist unten.

`one-piece_cnn_aug.py`


from keras.models import Sequential
from keras.layers import Conv2D,MaxPooling2D
from keras.layers import Activation,Dropout,Flatten,Dense
from keras.utils import np_utils
import keras
import numpy as np
from tensorflow.keras.optimizers import RMSprop

classes=["Usop","Sanji","Jinbei","Zoro","Hubschrauber","Nami","Bibi","Frankie","Bach","Ruffy","Robin"]
num_classes=len(classes)
image_size=50
#Definieren Sie die Hauptfunktion, die das Training durchführt
def main():
    X_train,X_test,y_train,y_test=np.load("./one-piece.npy",allow_pickle=True) #Lesen Sie Daten aus einer Textdatei
    X_train=X_train.astype("float")/256 #Normalisieren und konvergieren Sie RGB-Werte auf 0 zu 1, um das Lernen neuronaler Netze zu erleichtern
    X_test=X_test.astype("float")/256 #Ebenfalls
    y_train=np_utils.to_categorical(y_train,num_classes) #one-hot-vector:Der richtige Antwortwert ist 1 und die anderen sind 0. Das erste Argument ist die Bezeichnung, die Sie in einen Vektor konvertieren möchten, und das zweite Argument ist die Bezeichnung, die Sie in einen Vektor konvertieren möchten.
    y_test=np_utils.to_categorical(y_test,num_classes) #Ebenfalls

    model=model_train(X_train,y_train) #Lerne
    model_eval(model,X_test,y_test) #Machen Sie eine Bewertung

#Definieren Sie ein Modell für CNN
def model_train(X,y):
    model=Sequential() #Erstellen Sie ein sequentielles Modell, das die einzelnen Schichten des neuronalen Netzwerks der Reihe nach verbindet
    #Merkmalsmenge extrahieren
    model.add(Conv2D(32,(3,3),padding='same',input_shape=X.shape[1:])) #32 Schichten Faltschicht 3x3
    model.add(Activation('relu')) #Aktivierungsfunktion relu,Negativ → 0, positiv → wie es ist
    model.add(Conv2D(32,(3,3))) #2. Faltschicht
    model.add(Activation('relu')) #Aktivierungsfunktion relu
    model.add(MaxPooling2D(pool_size=(2,2))) #Die Pooling-Ebene hebt die Funktionen hervor und nimmt sie heraus
    model.add(Dropout(0.25)) #Verwerfen Sie 25% der Daten, um die Datenverzerrung zu verringern

    model.add(Conv2D(64,(3,3),padding='same')) #Als nächstes kommen 64 Kernel-Layer
    model.add(Activation('relu')) #Relu Aktivierungsfunktion
    model.add(Conv2D(64,(3,3))) #Auch eine Faltschicht
    model.add(Activation('relu')) #Relu Aktivierungsfunktion
    model.add(MaxPooling2D(pool_size=(2,2))) #Max Pooling

    #Vollständig mitmachen. Klassifizieren Sie anhand von Merkmalen
    model.add(Flatten()) #Ordnen Sie zuerst die Daten in einer Reihe an
    model.add(Dense(512)) #Vollständig mitmachen
    model.add(Activation('relu')) #Relu Aktivierungsfunktion
    model.add(Dropout(0.5)) #Die Hälfte wegwerfen
    model.add(Dense(11)) #11 Ausgangsschichtknoten
    model.add(Activation('softmax')) #Verwenden Sie die Softmax-Funktion, die bis zu 1 summiert

    opt=RMSprop(lr=0.0001,decay=1e-6) #Definition der Optimierungsmethode. Aktualisieren Sie den Algorithmus während des Trainings.

    model.compile(loss='categorical_crossentropy',
                    optimizer=opt,metrics=['accuracy']) #Bewertungsfunktion. Verlust:Der Fehler zwischen der richtigen Antwort und dem geschätzten Wert in der Verlustfunktion. opt:Optimierungsmethode. Metriken:Bewertungswert

    model.fit(X,y,batch_size=32,epochs=100) #Parameteroptimierung. Stapel_size:Die Anzahl der gleichzeitig verwendeten Daten. Epoche: Anzahl der Lektionen.
#Modell speichern
    model.save('./one-piece_cnn.h5')

    return model

#Machen Sie das Modell nutzbar
def model_eval(model,X,y):
    scores=model.evaluate(X,y,verbose=1) #verbose:Fortschritt anzeigen,Setzen Sie das Lernergebnis in Punktzahl
    print('Test Loss:',scores[0]) #Verlust
    print('Test Accuracy:',scores[1]) #Richtigkeit

#Lassen Sie dieses Programm von anderen Dateien aufrufen
if __name__=="__main__":
    main()

Die Lernergebnisse sind wie folgt.

Epoch 100/100
7888/7888 [==============================] - 64s 8ms/step - loss: 0.0200 - acc: 0.9962
330/330 [==============================] - 1s 4ms/step

Schätzen

`main.py`


import PIL
import io
import base64
import re
from io import StringIO
from PIL import Image
import os
from flask import Flask, request, redirect, url_for, render_template, flash,jsonify
from werkzeug.utils import secure_filename
from keras.models import Sequential, load_model
from keras.preprocessing import image
import tensorflow as tf
import numpy as np
from datetime import datetime

classes=["Usop","Sanji","Jinbei","Zoro","Hubschrauber","Nami","Bibi","Frankie","Bach","Ruffy","Robin"]
classes_img=["static/img/usoppu.jpg ","static/img/sanji.jpg ","static/img/jinbe.jpg ","static/img/zoro.jpg ","static/img/chopper.jpg ","static/img/nami.jpg ","static/img/bibi.jpg ","static/img/franky.jpg ","static/img/bruck.jpg ","static/img/rufi.jpg ","static/img/robin.jpg "]
num_classes=len(classes)
image_size=50

UPLOAD_FOLDER = "./static/image/"
ALLOWED_EXTENSIONS = set(['png', 'jpg', 'jpeg', 'gif'])

app = Flask(__name__)

def allowed_file(filename):
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS

model = load_model('./one-piece_cnn_aug.h5')#Laden Sie das trainierte Modell

graph = tf.get_default_graph()


app = Flask(__name__)

@app.route('/', methods=['GET', 'POST'])
def upload_file():

    global graph
    with graph.as_default():
        if request.method == 'POST':

                myfile= request.form['snapShot'].split(',')
                imgdata = base64.b64decode(myfile[1])
                image = Image.open(io.BytesIO(imgdata))

                #sparen
                basename = datetime.now().strftime("%Y%m%d-%H%M%S")
                image.save(os.path.join(UPLOAD_FOLDER, basename+".png "))
                filepath = os.path.join(UPLOAD_FOLDER, basename+".png ")


                image=image.convert('RGB')
                image=image.resize((image_size,image_size))
                data=np.asarray(image)
                X=[]
                X.append(data)
                X=np.array(X).astype('float32')
                X /=256

                result=model.predict([X])[0]
                result_proba = model.predict_proba(X, verbose=1)[0]
                    
                percentage=(result_proba*100).astype(float)
                array_sort =sorted(list(zip(percentage,classes,classes_img)),reverse=True)
                percentage,array_class,array_img = zip(*array_sort)
                
                
                pred_answer1="Etikette:"+str(array_class[0])+ ",Wahrscheinlichkeit:"+str(percentage[0])+"%"
                pred_answer2="Etikette:"+str(array_class[1])+ ",Wahrscheinlichkeit:"+str(percentage[1])+"%"
                pred_answer3="Etikette:"+str(array_class[2])+ ",Wahrscheinlichkeit:"+str(percentage[2])+"%"
                
                img_src1=array_img[0]
                img_src2=array_img[1]
                img_src3=array_img[2]


                basename = datetime.now().strftime("%Y%m%d-%H%M%S")
                filepath3 = UPLOAD_FOLDER + basename+".png "


                return render_template("index.html",answer1=pred_answer1,img_data1=img_src1,answer2=pred_answer2,img_data2=img_src2,answer3=pred_answer3,img_data3=img_src3)

        return render_template("index.html",answer="")

        

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

Fünf. Ordnen Sie den Ausgabebildschirm an Alles was Sie tun müssen, ist den Ausgabebildschirm mit html / css / js anzuordnen.

[PYTHON] Ich habe eine App erstellt, um herauszufinden, wie die Mitglieder der Strohhut-Piraten aussehen

Ich habe eine App erstellt, um herauszufinden, wie die Mitglieder der Strohhut-Piraten aussehen

Schritte zum Erstellen einer App

generatedata.py

one-piece_cnn_aug.py

main.py

`generatedata.py`

`one-piece_cnn_aug.py`

`main.py`