[PYTHON] 765 Ich habe versucht, die drei Berufsfamilien durch CNN zu identifizieren (mit Chainer 2.0.0).

Während der Deep-Learning-Lernsitzung im Labor entschied ich mich, etwas auszuprobieren, und versuchte, die ursprünglichen drei Familien von Imus durch CNN zu identifizieren.

Das Ergebnis ist so

(Ich habe dieses Bild von http://idolmaster.jp/images/event/9th/goods/img_goods37.jpg ausgeliehen. Wenn es ein Problem gibt, werde ich es löschen.)

Ich habe darüber nachgedacht und es hat ungefähr 10 Stunden gedauert. Ich bin dem von verschiedenen Personen veröffentlichten Code dankbar.

Umgebung

・ MacOS X El Capitan ・ Python 3.5.2 ・ OpenCV 3.1.0 ・ Anaconda3-4.2.0 ・ Chainer 2.0.0 ・ PIL Eine solche

Wenn Sie OpenCV in conda und Chainer oder etwas in setzen, ist es einfach.

Datensatz

Google-Bild mit Python3 herunterladen Ich habe mir den Code dieser Person ausgeliehen und ungefähr 100 Bilder von jeder der drei Personen gesammelt.

Ich habe auch andere Bilder für andere Zwecke gesammelt.

"100 Blatt? Wenig!" Sie könnten denken, aber diesmal hat es funktioniert. Liegt es daran, dass die Funktionen leicht zu verstehen sind?

Schneiden Sie das Gesicht aus

Schätzen Sie mit OpenCV (Eigenface, Fisherface, LBPH), wer das Gesicht hat Basierend auf diesem Code habe ich ihn ausgeschnitten und gespeichert.

Die Größe beträgt 32x32.

Die Änderung lautet lbpcascade_animeface.xml für die Erkennung von Anime-Gesichtern durch OpenCV. Die in verteilte "lbpcascade_animeface.xml" wird für den Feature-Mengen-Detektor verwendet und die Farbe kann gespeichert werden.

kao.py

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

import cv2, os
import numpy as np
from PIL import Image

#Das Originalbild
train_path = 'Pfad des Originalbildordners'

#Anime Face Feature Classifier
cascadePath = "lbpcascade_animeface.xml"
faceCascade = cv2.CascadeClassifier(cascadePath)

#Holen Sie sich das Bild in den angegebenen Pfad
def get_images_and_labels(path):
    #Array zum Speichern von Bildern
    images = []
    #Array zum Speichern von Beschriftungen
    labels = []
    #Array zum Speichern von Dateinamen
    files = []
    i = 0
    for f in os.listdir(path):
        #Bildpfad
        image_path = os.path.join(path, f)
        #Bild laden
        image_pil = Image.open(image_path)
        #In einem Array von NumPy gespeichert
        image = np.array(image_pil, 'uint8')
        #Erkennen Sie das Gesicht mit dem Anime Face Feature Classifier
        faces = faceCascade.detectMultiScale(image)
        #Verarbeitung des erkannten Gesichtsbildes
        for (x, y, w, h) in faces:
            #Ändern Sie die Größe des Gesichts auf 32 x 32
            roi = cv2.resize(image[y: y + h, x: x + w], (32, 32), interpolation=cv2.INTER_LINEAR)
            #Speichern Sie Bilder in einem Array
            images.append(roi)
            #Speichern Sie Dateinamen in einem Array
            files.append(f)
            save_path = './Ordnerpfad exportieren/' + str(i) + '.jpg'
            #Wenn Sie es so speichern, wie es ist, wird es bläulich (nicht RGB)
            cv2.imwrite(save_path, roi[:, :, ::-1].copy())
            print(i)

            i+=1

    return images

images = get_images_and_labels(train_path)

#Verarbeitung beenden
cv2.destroyAllWindows()

Es funktionierte ohne Auffüllen der Daten.

Lernen

Python: Benutze Chainer, um Kamonogatari-Charaktere zu erkennen! ~ Part5 Mehrwertklassifizierung nach Hauptzeichen (gilt für unbekannte Daten) ~ Basierend auf diesem Artikel habe ich es neu geschrieben, um es mit Chainer 2.0.0 auszuführen.

Der Punkt ist

    train = tuple_dataset.TupleDataset(X_train, y_train)
    test = tuple_dataset.TupleDataset(X_test, y_test)

    train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
    test_iter = chainer.iterators.SerialIterator(test, args.batchsize,
                                                 repeat=False, shuffle=False)

    # Set up a trainer
    updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
    trainer = training.Trainer(updater, (args.epoch, 'epoch'), out="output")

    # Evaluate the model with the test dataset for each epoch
    trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))

Durch Ersetzen des "Lernens und Testens" des ursprünglichen Codes werden Trainer und Updater ausgeführt. später

model = L.Classifier(clf_bake())

Ich habe die Ebene in L.Convolution2D geändert und def forward durch def call ersetzt.

Das Modell sieht in der Visualisierung so aus

Lernergebnis

Ich habe 30 Epochen auf der CPU gedreht. Selbst wenn Sie keine GPU verwenden, ist es schnell, wenn es sich um 4 Schichten handelt.

loss

accuracy

Obwohl es ungefähr 100 Datensätze gibt, sind 85% der Werte / Genauigkeit ziemlich erstaunlich. Ich war überrascht, als ich es zum ersten Mal drehte.

CNN ist unglaublich!

Unbekannte Datenschätzung

Die meisten von ihnen verwenden auch python: chainer, um Kamonogatari-Zeichen zu erkennen! ~ Teil 5 Mehrwertige Klassifizierung nach Hauptfiguren (gilt für unbekannte Daten) ~ basiert auf dem Artikel.

Der Punkt ist, das Modell zu laden

model = L.Classifier(clf_bake())

chainer.serializers.load_npz("output/model_snapshot_500", model) 

Mit Classifier wie

Der Rückgabewert der Erkennungsfunktion

def recognition(image, faces):

(Unterlassung)

return model.predictor(face_images) , image

Ist zu sein.

Impressionen

Es macht Spaß, weil Sie die Ergebnisse sofort sehen können. Es macht Spaß, einen eigenen Datensatz vorzubereiten und auszuprobieren.

Versuchen wir diesmal mehr Klassen.