CNN avec keras Essayez avec l'image que vous avez prise

J'essaierai diverses choses avec les images que j'ai récupérées de CNN avec des keras

Ici, Python2.7.Cela se fait en 6. De plus, nous utilisons principalement les packages suivants.
Keras (2.0.4)
tensorflow (1.1.0)

introduction


J'ai défié CNN avec des keras. Comme il n'est pas intéressant d'utiliser uniquement le jeu de données d'exemple, j'ai classé les images que j'ai récupérées par CNN.

Ici, nous supposons que la partie théorique de CNN est connue dans une certaine mesure, et nous nous concentrons sur la partie traitement. L'environnement d'analyse utilise EC2 d'AWS.

De plus, à propos de l'image, il est exécuté après avoir découpé la partie nécessaire. (Je l'ai fait avec OpenCV)

À propos de l'environnement d'analyse


Je voulais créer un environnement pour que TensorFlow puisse fonctionner sur GPU, mais c'est difficile pour les débutants ... J'ai une AMI (Bitfusion Ubuntu 14 TensorFlow) dont l'environnement a déjà été construit sur AWS, donc je l'utilise. Les packages nécessaires sont déjà inclus.

https://aws.amazon.com/marketplace/pp/B01EYKBEQ0

L'AMI ci-dessus inclut également Python3, donc je pense qu'il peut également être utilisé là-bas. (Cela coûte de l'argent, veuillez donc vérifier ce point. La taille EBS par défaut est de 100 Go, alors soyez prudent là aussi.)

Importer les packages requis



# coding:utf-8

import keras
from keras.utils import np_utils
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation, Flatten
from keras.preprocessing.image import array_to_img, img_to_array, list_pictures, load_img
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

Veuillez vous référer à la page d'accueil de keras pour le contenu. Le prétraitement peut être effectué facilement en utilisant keras.preprocessing.

Importation d'images et conversion en matrices Création de jeux de données


temp_img = load_img('./test/test1.jpg', target_size=(64,64))

Vous pouvez maintenant charger l'image. Vous pouvez également spécifier la taille de lecture avec target_size. Puisqu'une image de taille fixe est entrée dans le modèle, si la taille de l'image n'est pas alignée dans le prétraitement, alignez-la ici.

Convertissez-le en matrice et entrez-le dans le modèle. Vous pouvez convertir une image en matrice avec:

temp_img_array  = img_to_array(temp_img)

En regardant la forme par forme, c'est (64, 64, 3). Je pense que cela signifie que nous avons des informations sur la couleur (RVB) de chaque pixel pour une image 64x64.

Maintenant, utilisez-les pour créer un ensemble de données. Ici, on suppose que l'image de la cible A (par exemple, un chat) dans le dossier test1 et une autre cible B (par exemple, un chien) se trouvent dans le dossier test2.

#Lire les images dans le dossier de manière séquentielle
#La catégorie commence à 0

X = []
Y = []

#Image de la cible A
for picture in list_pictures('./test1/'):
    img = img_to_array(load_img(picture, target_size=(64,64)))
    X.append(img)
    
    Y.append(0)
    

#Image de la cible B
for picture in list_pictures('./test2/'):
    img = img_to_array(load_img(picture, target_size=(64,64)))
    X.append(img)
    
    Y.append(1)
    

#Convertir en tableau
X = np.asarray(X)
Y = np.asarray(Y)

Les informations d'image sont entrées dans X et les informations de classe sont données à Y. Ensuite, normalisez les valeurs de pixel et convertissez les données de classe (cela semble être appelé expression One-Hot).


#Convertir les valeurs de pixel de 0 à 1
X = X.astype('float32')
X = X / 255.0

#Convertir le format de classe
Y = np_utils.to_categorical(Y, 2)

#Données d'entraînement et données de test
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=111)

Construire un modèle


Maintenant que nous avons un jeu de données, construisons un modèle. En ce qui concerne le modèle, je pense qu'il y a plusieurs exemples si vous le recherchez, alors je le construis en référence à ceux-ci.


#Construire CNN
model = Sequential()

model.add(Conv2D(32, (3, 3), padding='same',
                 input_shape=X_train.shape[1:]))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(2))       #2 cours
model.add(Activation('softmax'))

#compiler
model.compile(loss='categorical_crossentropy',
              optimizer='SGD',
              metrics=['accuracy'])

#Courir. Set sans sortie(verbose=0)。
history = model.fit(X_train, y_train, batch_size=5, epochs=200,
                   validation_data = (X_test, y_test), verbose = 0)

Vous pouvez vérifier l'histoire de l'apprentissage dans l'histoire. Ce qui suit trace la précision des données d'entraînement et des données de test.


plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.title('model accuracy')
plt.xlabel('epoch')
plt.ylabel('accuracy')
plt.legend(['acc', 'val_acc'], loc='lower right')
plt.show()

Appliquez-le aux données de validation et appliquez-le réellement pour créer une matrice de confusion.


#Appliquer aux données de test
predict_classes = model.predict_classes(X_test)

#fusionner. Restaurer vos données
mg_df = pd.DataFrame({'predict': predict_classes, 'class': np.argmax(y_test, axis=1)})

# confusion matrix
pd.crosstab(mg_df['class'], mg_df['predict'])

Résumé


Le Deep Learning avait un seuil élevé, mais je pensais que ce serait plus facile à écrire si j'utilisais des keras. En outre, il est facile d'utiliser l'environnement d'analyse qui a déjà été construit.

J'étudierai désormais le raffinement du modèle. Puisque je suis un débutant, il peut y avoir des erreurs, mais j'apprécierais que vous puissiez signaler quoi que ce soit. Jusqu'à la fin Merci d'avoir lu.

Recommended Posts

CNN avec keras Essayez avec l'image que vous avez prise
Essayez de brouiller l'image avec opencv2
Défiez la classification des images avec TensorFlow2 + Keras CNN 1 ~ Bougez pour le moment ~
Essayez de résoudre le problème du fizzbuzz avec Keras
Reconnaissance d'image avec keras
Identifiez le nom de l'image de la fleur avec des keras (flux tenseur)
POSTER l'image avec json et la recevoir avec flask
Essayez de normaliser Coupez l'image avec scikit-image (bien qu'elle se fâche en chemin)
Essayez d'exécuter CNN avec ChainerRL
Créez facilement des CNN avec Keras
Reconnaissance d'image avec Keras + OpenCV
Essayez d'extraire les caractéristiques des données de capteur avec CNN
N'écrivez pas Python si vous voulez l'accélérer avec Python
Jusqu'à ce que vous essayiez l'API Google Cloud Vision (détection d'images dangereuses)
Décrypter le code QR avec CNN
Débutant RNN (LSTM) | Essayer avec Keras
Essayez d'imaginer les données d'élévation du National Land Research Institute avec Python
Affichage de l'image prise avec l'ISIGHT intégré
Essayez d'implémenter XOR avec l'API fonctionnelle Keras
Essayez l'algorithme Variational-Quantum-Eigensolver (VQE) avec Blueqat
Essayez d'utiliser l'appareil photo avec OpenCV de Python
[Python] Arrondissez avec juste l'opérateur
Faites un clic droit sur l'image → Réalisez "Compresser avec TinyPNG"
J'ai essayé de jouer avec l'image avec Pillow
Essayez facilement la génération automatique d'images avec DCGAN-tensor flow
Essayez de réécrire le fichier avec la commande less
Essayez de générer une image avec aliénation
Essayez Fine Tuning (apprentissage par transfert), qui est le courant dominant avec des images avec keras, avec apprentissage des données
Méthode d'extraction de zone à l'aide de l'automate cellulaire Essayez l'extraction de zone de l'image avec growcut (Python)
Jusqu'à ce que vous essayiez de laisser DNN apprendre la vérité de l'image en utilisant Colab
Si vous les gars dans la cuisine de portée pouvez le faire avec une marge ~ ♪
Essayez d'utiliser le processeur à 4 cœurs du Raspberry Pi 2 avec Parallel Python