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.
・ 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.
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?
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.
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é
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.
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!
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.
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.
Recommended Posts