[PYTHON] J'ai essayé de faire un diagnostic de visage AI pour les golfeuses professionnelles ②
1.Tout d'abord
À la dernière fois, nous avions collecté des images, acquis des parties du visage et des données gonflées, qui font partie du prétraitement des données.
Cette fois, j'ai en fait créé un modèle et vérifié la précision. ・ Modèle construit par moi-même ・ Apprentissage par transfert (VGG16) J'écrirai sur ces deux.
2. Création d'un fichier séparé pour les données d'entraînement et les données de test
preparation.py
from PIL import Image
import os, glob
import numpy as np
from PIL import ImageFile
import cv2
from keras.utils.np_utils import to_categorical
# IOError:le fichier image est tronqué pour éviter
ImageFile.LOAD_TRUNCATED_IMAGES = True
#Création de données d'entraînement
#Créez une liste vide pour chacun
img_shibuno = []
img_koiwai = []
img_hara = []
img_lists = [img_shibuno, img_koiwai, img_hara]
#Obtenez le chemin sous le visage
in_dir = './face/*'
in_file = glob.glob(in_dir)
#Chaque dossier (player)Effectuer le traitement pour chaque
for num in range(len(in_file)):
#Obtenez le chemin de chaque image dans le fichier du lecteur
in_file_name = glob.glob(in_file[num]+'/*')
#Traitez chaque image
for i in range(len(in_file_name)):
#Ouvrir l'image
img = Image.open(in_file_name[i])
img = img.convert("RGB")
#Ajuster la taille
img = img.resize((64,64))
#Convertir en ndarray
data = np.asarray(img)
# img_Ajouter aux listes
img_lists[num].append(data)
#Combinez des listes avec des images
X_train = np.array(img_shibuno+img_koiwai+img_hara)
#0 chacun~Entrez une valeur jusqu'à 2
y_train = np.array([0]*len(img_shibuno) + [1]*len(img_koiwai) + [2]*len(img_hara))
#Créer des données de test
#Créez une liste vide pour chacun
img_shibuno = []
img_koiwai = []
img_hara = []
img_lists = [img_shibuno, img_koiwai, img_hara]
in_dir = './valid/*'
in_file = glob.glob(in_dir)
for num in range(len(in_file)):
#Obtenez le chemin de chaque image dans le fichier du lecteur
in_file_name = glob.glob(in_file[num]+'/*')
#Traitez chaque image
for i in range(len(in_file_name)):
#Ouvrir l'image
img = Image.open(in_file_name[i])
img = img.convert("RGB")
#Ajuster la taille
img = img.resize((64,64))
#Convertir en ndarray
data = np.asarray(img)
# img_Ajouter aux listes
img_lists[num].append(data)
#Combinez des listes avec des images
X_test = np.array(img_shibuno+img_koiwai+img_hara)
#0 chacun~Entrez une valeur jusqu'à 2
y_test = np.array([0]*len(img_shibuno) + [1]*len(img_koiwai) + [2]*len(img_hara))
# one-hot-Vecteur de processus
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
#Enregistrer les données de formation et de validation dans un fichier
xy = (X_train, X_test, y_train, y_test)
np.save('./golfer.npy', xy)
Ceci termine le prétraitement des données. Ensuite, évaluez le modèle
3. Création et évaluation de modèles
Créez votre propre modèle et le modèle d'apprentissage par transfert (vgg16) respectivement
- Les codes suivants sont écrits séparément à des fins d'explication, mais veuillez les combiner en un seul.
3-1. Module d'importation
from keras.models import Model, Sequential
from keras.layers import Conv2D, MaxPooling2D
from keras.layers import Activation, Dropout, Flatten, Dense, Input
from keras.applications.vgg16 import VGG16
from keras.utils import np_utils
import keras
from keras import optimizers, models, layers
import numpy as np
import matplotlib.pyplot as plt
classes = ['shibuno', 'koiwai', 'hara']
num_classes = len(classes)
image_size = 64
3-2. Fonction de lecture des données
def load_data():
X_train, X_test, y_train, y_test = np.load('./golfer.npy', allow_pickle=True)
#Définissez chaque valeur de pixel des données d'entrée sur 0-Normaliser dans la plage de 1
X_train = X_train / 255
X_test = X_test / 255
return X_train, y_train, X_test, y_test
3-3. Fonctions pour entraîner le modèle
__ * Veuillez décrire un seul des ① et ② ci-dessous. __
① Modèle créé par vous-même
def train(X_train, y_train, X_test, y_test):
model = Sequential()
#X est(296, 64, 64, 3): X.shepe[1:]alors(64, 64, 3)
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.1))
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.45))
model.add(Dense(3))
model.add(Activation('softmax'))
model.summary()
#Algorithme d'optimisation RMSprop
opt = keras.optimizers.rmsprop(lr=0.00005, decay=1e-6)
model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy'])
return model
Visualisez le modèle créé
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input_1 (InputLayer) (None, 64, 64, 3) 0
_________________________________________________________________
block1_conv1 (Conv2D) (None, 64, 64, 64) 1792
_________________________________________________________________
block1_conv2 (Conv2D) (None, 64, 64, 64) 36928
_________________________________________________________________
block1_pool (MaxPooling2D) (None, 32, 32, 64) 0
_________________________________________________________________
block2_conv1 (Conv2D) (None, 32, 32, 128) 73856
_________________________________________________________________
block2_conv2 (Conv2D) (None, 32, 32, 128) 147584
_________________________________________________________________
block2_pool (MaxPooling2D) (None, 16, 16, 128) 0
_________________________________________________________________
block3_conv1 (Conv2D) (None, 16, 16, 256) 295168
_________________________________________________________________
block3_conv2 (Conv2D) (None, 16, 16, 256) 590080
_________________________________________________________________
block3_conv3 (Conv2D) (None, 16, 16, 256) 590080
_________________________________________________________________
block3_pool (MaxPooling2D) (None, 8, 8, 256) 0
_________________________________________________________________
block4_conv1 (Conv2D) (None, 8, 8, 512) 1180160
_________________________________________________________________
block4_conv2 (Conv2D) (None, 8, 8, 512) 2359808
_________________________________________________________________
block4_conv3 (Conv2D) (None, 8, 8, 512) 2359808
_________________________________________________________________
block4_pool (MaxPooling2D) (None, 4, 4, 512) 0
_________________________________________________________________
block5_conv1 (Conv2D) (None, 4, 4, 512) 2359808
_________________________________________________________________
block5_conv2 (Conv2D) (None, 4, 4, 512) 2359808
_________________________________________________________________
block5_conv3 (Conv2D) (None, 4, 4, 512) 2359808
_________________________________________________________________
block5_pool (MaxPooling2D) (None, 2, 2, 512) 0
_________________________________________________________________
flatten_1 (Flatten) (None, 2048) 0
_________________________________________________________________
dense_1 (Dense) (None, 256) 524544
_________________________________________________________________
dropout_1 (Dropout) (None, 256) 0
_________________________________________________________________
dense_2 (Dense) (None, 3) 771
=================================================================
② Apprentissage par transfert
def train(X, y, X_test, y_test):
input_tensor = Input(shape=(64, 64, 3))
vgg16 = VGG16(include_top=False, weights='imagenet', input_tensor=input_tensor)
#Je crée un modèle de la partie d'extraction de quantité de caractéristiques
top_model = vgg16.output
top_model = Flatten(input_shape=vgg16.output_shape[1:])(top_model)
top_model = Dense(256, activation='sigmoid')(top_model)
top_model = Dropout(0.5)(top_model)
top_model = Dense(3, activation='softmax')(top_model)
#vgg16 et top_Veuillez concaténer les modèles
model = Model(inputs=vgg16.input, outputs=top_model)
#Complétez les instructions suivantes et fixez les poids jusqu'à la 15e couche
for layer in model.layers[:15]:
layer.trainable = False
#Vérifiez la structure du modèle avant l'entraînement
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.SGD(lr=1e-4, momentum=0.9),
metrics=['accuracy'])
return model
Visualisez le modèle créé
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input_1 (InputLayer) (None, 64, 64, 3) 0
_________________________________________________________________
block1_conv1 (Conv2D) (None, 64, 64, 64) 1792
_________________________________________________________________
block1_conv2 (Conv2D) (None, 64, 64, 64) 36928
_________________________________________________________________
block1_pool (MaxPooling2D) (None, 32, 32, 64) 0
_________________________________________________________________
block2_conv1 (Conv2D) (None, 32, 32, 128) 73856
_________________________________________________________________
block2_conv2 (Conv2D) (None, 32, 32, 128) 147584
_________________________________________________________________
block2_pool (MaxPooling2D) (None, 16, 16, 128) 0
_________________________________________________________________
block3_conv1 (Conv2D) (None, 16, 16, 256) 295168
_________________________________________________________________
block3_conv2 (Conv2D) (None, 16, 16, 256) 590080
_________________________________________________________________
block3_conv3 (Conv2D) (None, 16, 16, 256) 590080
_________________________________________________________________
block3_pool (MaxPooling2D) (None, 8, 8, 256) 0
_________________________________________________________________
block4_conv1 (Conv2D) (None, 8, 8, 512) 1180160
_________________________________________________________________
block4_conv2 (Conv2D) (None, 8, 8, 512) 2359808
_________________________________________________________________
block4_conv3 (Conv2D) (None, 8, 8, 512) 2359808
_________________________________________________________________
block4_pool (MaxPooling2D) (None, 4, 4, 512) 0
_________________________________________________________________
block5_conv1 (Conv2D) (None, 4, 4, 512) 2359808
_________________________________________________________________
block5_conv2 (Conv2D) (None, 4, 4, 512) 2359808
_________________________________________________________________
block5_conv3 (Conv2D) (None, 4, 4, 512) 2359808
_________________________________________________________________
block5_pool (MaxPooling2D) (None, 2, 2, 512) 0
_________________________________________________________________
flatten_1 (Flatten) (None, 2048) 0
_________________________________________________________________
dense_1 (Dense) (None, 256) 524544
_________________________________________________________________
dropout_1 (Dropout) (None, 256) 0
_________________________________________________________________
dense_2 (Dense) (None, 6) 1542
=================================================================
3-4. Fonction graphique du taux de réponse correct et de la fonction de perte
def compare_TV(history):
#Définir les paramètres
#Taux de réponse correct de la classification pour les données d'entraînement
acc = history.history['accuracy']
#Taux de réponse correct de la classification pour les données de validation
val_acc = history.history['val_accuracy']
#Valeur de la fonction de perte pour les données d'entraînement
loss = history.history['loss']
val_loss = history.history['val_loss']
#Valeur de la fonction de perte pour les données de validation
epochs = range(len(acc))
# 1)Graphique du taux de réponse correct
plt.plot(epochs, acc, 'bo' ,label = 'training acc')
plt.plot(epochs, val_acc, 'b' , label= 'validation acc')
plt.title('Training and Validation acc')
plt.legend()
plt.figure()
# 2)Graphique de la fonction de perte
plt.plot(epochs, loss, 'bo' ,label = 'training loss')
plt.plot(epochs, val_loss, 'b' , label= 'validation loss')
plt.title('Training and Validation loss')
plt.legend()
plt.show()
3-5. Fonctions qui lisent des données et forment des modèles
def main():
#Lire les données
X_train, y_train, X_test, y_test = load_data()
#Apprentissage de modèle
model = train(X_train, y_train, X_test, y_test)
history = model.fit(X_train, y_train, batch_size=32, epochs=70, verbose=1, validation_data=(X_test, y_test))
#Évaluation et affichage du système de généralisation
score = model.evaluate(X_test, y_test, batch_size=32, verbose=0)
print('validation loss:{0[0]}\nvalidation accuracy:{0[1]}'.format(score))
compare_TV(history)
model.save('./golfer.h5')
Enfin, écrivez la fonction main () et exécutez-la.
#Cela entraîne le modèle et génère un modèle entraîné
main()
4. Résultat d'apprentissage
Vérifiez le taux de précision et la fonction de perte du résultat d'apprentissage sur le graphique
① Modèle créé par vous-même
__ Taux de réponse correcte: 0,93__
② Apprentissage par transfert
__ Taux de réponse correcte: 0,95__
Comme l'apprentissage par transfert était légèrement meilleur, nous adopterons le modèle d'apprentissage par transfert.
Le modèle a été créé. La prochaine fois, j'écrirai une application et la publierai sur heroku.
référence
J'ai essayé de classer Nogizaka46 par apprentissage automatique
Recommended Posts