J'ai essayé de m'intéresser à l'analyse faciale des animaux.
"Créez un modèle d'apprentissage automatique qui distingue les" chiens qui rient "et les" chiens en colère "à Keras." https://qiita.com/ariera/items/545d48c961170a784075
#Définir une fonction pour lire une image et la convertir en matrice
from keras.preprocessing.image import load_img, img_to_array
def img_to_traindata(file, img_rows, img_cols, rgb):
if rgb == 0:
img = load_img(file, color_mode = "grayscale", target_size=(img_rows,img_cols)) #Lire avec des niveaux de gris
else:
img = load_img(file, color_mode = "rgb", target_size=(img_rows,img_cols)) #Lire en RVB
x = img_to_array(img)
x = x.astype('float32')
x /= 255
return x
#Données d'entraînement, génération de données de test
import glob, os
img_rows = 224 #La taille de l'image est la taille par défaut de VGG16
img_cols = 224
nb_classes = 2 #2 classes de colère et de rire
img_dirs = ["./dog_angry", "./dog_smile"] #Répertoire contenant des images de chiens en colère et de chiens rieurs
X_train = []
Y_train = []
X_test = []
Y_test = []
for n, img_dir in enumerate(img_dirs):
img_files = glob.glob(img_dir+"/*.jpg ") #Lire tous les fichiers image dans le répertoire
for i, img_file in enumerate(img_files): #annuaire(Type de caractère)Pour tous les fichiers dans
x = img_to_traindata(img_file, img_rows, img_cols, 1) #Lisez chaque fichier image en RVB et convertissez-le en matrice
if i < 8: #Apprentissage des données de la 1ère à la 8ème feuille
X_train.append(x) #Données d'entraînement(contribution)Ajoutez une matrice qui convertit les images en
Y_train.append(n) #Données d'entraînement(production)Classer(Fâché=0, lol=1)Ajouter
else: #Données de test pour la 9e feuille et les suivantes
X_test.append(x) #données de test(contribution)Ajoutez une matrice qui convertit les images en
Y_test.append(n) #données de test(production)Classer(Fâché=0, lol=1)Ajouter
import numpy as np
#Formation et test des données de liste à numpy.Convertir en ndarray
X_train = np.array(X_train, dtype='float')
Y_train = np.array(Y_train, dtype='int')
X_test = np.array(X_test, dtype='float')
Y_test = np.array(Y_test, dtype='int')
#Données catégoriques(vecteur)Conversion en
from keras.utils import np_utils
Y_train = np_utils.to_categorical(Y_train, nb_classes)
Y_test = np_utils.to_categorical(Y_test, nb_classes)
#Enregistrez les données d'entraînement et les données de test créées dans un fichier
np.save('models/X_train_2class_120.npy', X_train)
np.save('models/X_test_2class_120.npy', X_test)
np.save('models/Y_train_2class_120.npy', Y_train)
np.save('models/Y_test_2class_120.npy', Y_test)
#Afficher le type de données créées
print(X_train.shape)
print(Y_train.shape)
print(X_test.shape)
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Conv2D, MaxPooling2D
#【Réglages des paramètres】
batch_size = 20
epochs = 30
input_shape = (img_rows, img_cols, 3)
nb_filters = 32
# size of pooling area for max pooling
pool_size = (2, 2)
# convolution kernel size
kernel_size = (3, 3)
#[Définition du modèle]
model = Sequential()
model.add(Conv2D(nb_filters, kernel_size, #Couche pliante
padding='valid',
activation='relu',
input_shape=input_shape))
model.add(Conv2D(nb_filters, kernel_size, activation='relu')) #Couche pliante
model.add(MaxPooling2D(pool_size=pool_size)) #Couche de regroupement
model.add(Conv2D(nb_filters, kernel_size, activation='relu')) #Couche pliante
model.add(MaxPooling2D(pool_size=pool_size)) #Couche de regroupement
model.add(Dropout(0.25)) #Abandonner(Déconnectez au hasard entre l'entrée et la sortie pour éviter le surapprentissage)
model.add(Flatten()) #Convertir un tableau multidimensionnel en tableau unidimensionnel
model.add(Dense(128, activation='relu')) #Couche entièrement connectée
model.add(Dropout(0.2)) #Abandonner
model.add(Dense(nb_classes, activation='sigmoid')) #Puisqu'il s'agit de 2 classes, la couche entièrement connectée est sigmoïde
#Compiler le modèle
model.compile(loss='binary_crossentropy', #Binaire car c'est 2 classes_crossentropy
optimizer='adam', #Utiliser les valeurs par défaut pour les paramètres de la fonction d'optimisation
metrics=['accuracy'])
#Définissez un rappel pour générer des résultats d'apprentissage pour chaque époque(Enregistrez uniquement lorsque la précision est meilleure que la dernière fois)】
from keras.callbacks import ModelCheckpoint
import os
model_checkpoint = ModelCheckpoint(
filepath=os.path.join('models','model_2class120_{epoch:02d}.h5'),
monitor='val_accuracy',
mode='max',
save_best_only=True,
verbose=1)
print("filepath",os.path.join('models','model_.h5'))
#[Apprentissage]
result = model.fit(X_train, Y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(X_test, Y_test),
callbacks=[model_checkpoint],validation_split=0.1)
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Conv2D, MaxPooling2D
#【Réglages des paramètres】
batch_size = 20
epochs = 30
input_shape = (img_rows, img_cols, 3)
nb_filters = 32
# size of pooling area for max pooling
pool_size = (2, 2)
# convolution kernel size
kernel_size = (3, 3)
#[Définition du modèle]
model = Sequential()
model.add(Conv2D(nb_filters, kernel_size, #Couche pliante
padding='valid',
activation='relu',
input_shape=input_shape))
model.add(Conv2D(nb_filters, kernel_size, activation='relu')) #Couche pliante
model.add(MaxPooling2D(pool_size=pool_size)) #Couche de regroupement
model.add(Conv2D(nb_filters, kernel_size, activation='relu')) #Couche pliante
model.add(MaxPooling2D(pool_size=pool_size)) #Couche de regroupement
model.add(Dropout(0.25)) #Abandonner(Déconnectez au hasard entre l'entrée et la sortie pour éviter le surapprentissage)
model.add(Flatten()) #Convertir un tableau multidimensionnel en tableau unidimensionnel
model.add(Dense(128, activation='relu')) #Couche entièrement connectée
model.add(Dropout(0.2)) #Abandonner
model.add(Dense(nb_classes, activation='sigmoid')) #Puisqu'il s'agit de 2 classes, la couche entièrement connectée est sigmoïde
#Compiler le modèle
model.compile(loss='binary_crossentropy', #Binaire car c'est 2 classes_crossentropy
optimizer='adam', #Utiliser les valeurs par défaut pour les paramètres de la fonction d'optimisation
metrics=['accuracy'])
#Définissez un rappel pour générer des résultats d'apprentissage pour chaque époque(Enregistrez uniquement lorsque la précision est meilleure que la dernière fois)】
from keras.callbacks import ModelCheckpoint
import os
model_checkpoint = ModelCheckpoint(
filepath=os.path.join('models','model_2class120_{epoch:02d}_{val_acc:.3f}.h5'),
monitor='val_acc',
mode='max',
save_best_only=True,
verbose=1)
#[Apprentissage]
result = model.fit(X_train, Y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(X_test, Y_test),
callbacks=[model_checkpoint])
from keras.models import load_model
from keras.preprocessing.image import load_img, img_to_array
import matplotlib.pyplot as plt
model = load_model('models/model_2class120_04.h5')
model.summary()
def img_to_traindata(file, img_rows, img_cols, rgb):
if rgb == 0:
img = load_img(file, color_mode = "grayscale", target_size=(img_rows,img_cols)) #Lire avec des niveaux de gris
else:
img = load_img(file, color_mode = "rgb", target_size=(img_rows,img_cols)) #Lire en RVB
x = img_to_array(img)
x = x.astype('float32')
x /= 255
return x
import numpy as np
img_rows = 224 #La taille de l'image est la taille par défaut de VGG16
img_cols = 224
##Chargement d'image
filename = "dog_smile/n02085936_37.jpg "
x = img_to_traindata(filename, img_rows, img_cols, 1) # img_to_La fonction traindata est définie lors de la génération des données d'entraînement
x = np.expand_dims(x, axis=0)
##Déterminez quelle classe
preds = model.predict(x)
pred_class = np.argmax(preds[0])
print("Résultat de l'identification:", pred_class)
print("probabilité:", preds[0])
from keras import backend as K
import cv2
#Sortez la sortie finale du modèle
model_output = model.output[:, pred_class]
#Retirez la dernière couche de convolution
last_conv_output = model.get_layer('conv2d_3').output #'block5_conv3').output
#Gradient de la sortie finale de la couche de convolution par rapport à la sortie finale du modèle
grads = K.gradients(model_output, last_conv_output)[0]
# model.Lorsque vous entrez l'entrée, le dernier_conv_Définir une fonction qui génère des résultats et des notes
gradient_function = K.function([model.input], [last_conv_output, grads])
#Trouvez le dégradé de l'image chargée
output, grads_val = gradient_function([x])
output, grads_val = output[0], grads_val[0]
#Poids moyens et multiplier par la sortie de couche pour créer une carte thermique
weights = np.mean(grads_val, axis=(0, 1))
heatmap = np.dot(output, weights)
heatmap = cv2.resize(heatmap, (img_rows, img_cols), cv2.INTER_LINEAR)
heatmap = np.maximum(heatmap, 0)
heatmap = heatmap / heatmap.max()
heatmap = cv2.applyColorMap(np.uint8(255 * heatmap), cv2.COLORMAP_JET) #Colorez la carte de chaleur
heatmap = cv2.cvtColor(heatmap, cv2.COLOR_BGR2RGB) #Convertir la couleur en RVB
img = plt.imread(filename, cv2.IMREAD_UNCHANGED)
print(img.shape) # (330, 440, 4)
fig, ax = plt.subplots()
ax.imshow(img)
plt.show()
2020-04-26 21:12:46.904489: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x7fded852e7f0 initialized for platform Host (this does not guarantee that XLA will be used). Devices:
2020-04-26 21:12:46.904528: I tensorflow/compiler/xla/service/service.cc:176] StreamExecutor device (0): Host, Default Version
Model: "sequential_1"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
conv2d_1 (Conv2D) (None, 222, 222, 32) 896
_________________________________________________________________
conv2d_2 (Conv2D) (None, 220, 220, 32) 9248
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 110, 110, 32) 0
_________________________________________________________________
conv2d_3 (Conv2D) (None, 108, 108, 32) 9248
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 54, 54, 32) 0
_________________________________________________________________
dropout_1 (Dropout) (None, 54, 54, 32) 0
_________________________________________________________________
flatten_1 (Flatten) (None, 93312) 0
_________________________________________________________________
dense_1 (Dense) (None, 128) 11944064
_________________________________________________________________
dropout_2 (Dropout) (None, 128) 0
_________________________________________________________________
dense_2 (Dense) (None, 2) 258
=================================================================
Total params: 11,963,714
Trainable params: 11,963,714
Non-trainable params: 0
_________________________________________________________________
Résultat d'identification: 1
probabilité:[0.27252397 0.6845933 ]
(375, 500, 3)
Il est nécessaire de réduire les problèmes pour améliorer la précision.
Recommended Posts