Ici, Python2.7.Cela se fait en 6. De plus, nous utilisons principalement les packages suivants.
Keras (2.0.4)
tensorflow (1.1.0)
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)
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.)
# 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.
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)
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'])
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