Lors de la session d'étude d'apprentissage en profondeur au laboratoire, j'ai décidé d'essayer quelque chose, alors j'ai essayé d'identifier les trois familles originales d'Imus par CNN.

Le résultat est comme ça

(J'ai emprunté cette image à http://idolmaster.jp/images/event/9th/goods/img_goods37.jpg. S'il y a un problème, je vais la supprimer.)

J'y ai pensé et cela a pris environ 10 heures. Je suis reconnaissant au code publié par diverses personnes.

environnement

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

Si vous mettez OpenCV dans conda et mettez Chainer ou quelque chose dedans, c'est facile.

base de données

Télécharger l'image google avec python3 J'ai emprunté le code de cette personne et collecté environ 100 images de chacune des trois personnes.

J'ai également collecté d'autres images à d'autres fins.

«100 feuilles? Peu! Vous pourriez penser, mais cette fois, cela a fonctionné. Est-ce parce que les fonctionnalités sont faciles à comprendre?

Découpez le visage

Estimer le visage de qui en utilisant OpenCV (Eigenface, Fisherface, LBPH) Sur la base de ce code, je l'ai découpé et sauvegardé.

La taille est 32x32.

Le changement est lbpcascade_animeface.xml pour la détection de visage d'anime par OpenCV Le "lbpcascade_animeface.xml" distribué dans est utilisé pour le détecteur de quantité de caractéristiques et la couleur peut être enregistrée.

`kao.py`


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

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

#L'image originale
train_path = 'Chemin du dossier d'image d'origine'

#Classificateur de caractéristiques de visage d'anime
cascadePath = "lbpcascade_animeface.xml"
faceCascade = cv2.CascadeClassifier(cascadePath)

#Récupère l'image dans le chemin spécifié
def get_images_and_labels(path):
    #Tableau pour stocker des images
    images = []
    #Tableau pour stocker les étiquettes
    labels = []
    #Tableau pour stocker les noms de fichiers
    files = []
    i = 0
    for f in os.listdir(path):
        #Chemin de l'image
        image_path = os.path.join(path, f)
        #Charger l'image
        image_pil = Image.open(image_path)
        #Stocké dans un tableau de NumPy
        image = np.array(image_pil, 'uint8')
        #Détecter le visage avec le classificateur de caractéristiques de visage d'anime
        faces = faceCascade.detectMultiScale(image)
        #Traitement de l'image du visage détecté
        for (x, y, w, h) in faces:
            #Redimensionner le visage à la taille 32x32
            roi = cv2.resize(image[y: y + h, x: x + w], (32, 32), interpolation=cv2.INTER_LINEAR)
            #Stocker des images dans un tableau
            images.append(roi)
            #Stocker les noms de fichiers dans un tableau
            files.append(f)
            save_path = './Exporter le chemin du dossier/' + str(i) + '.jpg'
            #Si vous l'enregistrez tel quel, il sera bleuâtre (pas RVB)
            cv2.imwrite(save_path, roi[:, :, ::-1].copy())
            print(i)

            i+=1

    return images

images = get_images_and_labels(train_path)

#Terminer le traitement
cv2.destroyAllWindows()

Cela a fonctionné sans remplir les données.

Apprentissage

python: utilisez le chainer pour reconnaître les caractères Kamonogatari! ~ Part5 Classification multi-valeurs par caractères majeurs (applicable aux données inconnues) ~ Sur la base de cet article, je l'ai réécrit pour qu'il fonctionne avec chainer 2.0.0.

Le point est

    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))

En remplaçant «l'apprentissage et les tests» du code d'origine, le formateur et le programme de mise à jour s'exécutent. plus tard

model = L.Classifier(clf_bake())

J'ai changé la couche en L.Convolution2D, et remplacé def forward par def call.

Le modèle ressemble à ceci lorsqu'il est visualisé

Résultat d'apprentissage

J'ai eu 30 ans sur le processeur. Même si vous n'utilisez pas de GPU, c'est rapide s'il s'agit d'environ 4 couches. スクリーンショット 2017-07-02 13.45.10.png

loss

accuracy

Même s'il existe environ 100 ensembles de données, 85% de la valeur / précision est assez incroyable. J'ai été surpris quand je l'ai tourné pour la première fois.

CNN est incroyable!

Estimation des données inconnues

La plupart d'entre eux utilisent également python: chainer pour reconnaître les caractères Kamonogatari! ~ Part5 Classification multi-valeurs par caractères principaux (applicable aux données inconnues) ~ est basé sur l'article.

Le but est de charger le modèle

model = L.Classifier(clf_bake())

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

Utilisation du classificateur comme

La valeur de retour de la fonction de reconnaissance

def recognition(image, faces):

(Omission)

return model.predictor(face_images) , image

Est d'être.

Impressions

C'est amusant car vous pouvez voir les résultats immédiatement. C'est amusant de préparer votre propre jeu de données et de l'essayer.

Essayons plus de cours cette fois.

[PYTHON] 765 J'ai essayé d'identifier les trois familles professionnelles par CNN (avec Chainer 2.0.0)