[PYTHON] [Apprentissage automatique] Créez un modèle d'apprentissage automatique en effectuant un apprentissage par transfert avec votre propre ensemble de données
1.Tout d'abord
Articles précédents ( Scraping , Traitement d'images avec OpenCV ) a présenté comment créer votre propre ensemble de données. Dans cet article, je voudrais vous présenter comment créer un modèle d'apprentissage automatique qui utilise l'ensemble de données créé pour effectuer un apprentissage par transfert et juger les Japonais et les étrangers.
2. Ce que je veux faire cette fois
Préparez l'ensemble de données requis pour créer un modèle d'apprentissage automatique ← Contenu jusqu'à la dernière fois ↓ ---------- Que faire dans cet article à partir d'ici ---------- ↓ Créez un modèle d'apprentissage automatique à l'aide de l'apprentissage par transfert. ↓ Utilisez un modèle d'apprentissage automatique pour déterminer des photos de Japonais et d'étrangers.
3. Qu'est-ce que l'apprentissage par transfert?
En un mot, l'apprentissage par transfert est une méthode d'apprentissage de modèle utilisée pour améliorer les performances des modèles d'apprentissage automatique en peu de temps.
En général, les performances (précision) d'un modèle d'apprentissage automatique sont meilleures si la couche du modèle d'apprentissage automatique est profonde et large.
Cependant, la création d'un modèle d'apprentissage automatique aussi profond et large à partir de zéro nécessite énormément de temps et de données.
Par conséquent, l'apprentissage par transfert consiste à utiliser la partie autre que la couche entièrement connectée du modèle d'apprentissage automatique haute performance existant (VGG16, etc.) comme couche d'extraction de caractéristiques, puis à créer et à former la partie de la couche entièrement connectée par vous-même. ..
Par conséquent, par rapport à la création d'un modèle d'apprentissage automatique à partir de zéro, l'apprentissage par transfert ne nécessite que l'apprentissage de la couche entièrement connectée.Il est donc possible de créer un modèle d'apprentissage automatique avec de bonnes performances en peu de temps.
Source: "Qu'est-ce que l'apprentissage par transfert? Comment réalisez-vous le" transfert d'apprentissage "attendu dans l'apprentissage profond?
4. Code source
Le code source utilisé cette fois est indiqué ci-dessous.
cnn.py
from keras.layers import Dense, Dropout, Flatten, Activation
from keras.layers import Conv2D, MaxPooling2D, Input, BatchNormalization
from keras.models import Sequential, load_model, Model
from keras.applications.vgg16 import VGG16
from keras.optimizers import SGD
from keras.preprocessing import image
import numpy as np
import matplotlib.pyplot as plt
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
epochs = 10
#Tracer la précision et la perte pour chaque époque sur un graphique
def show_graph(history):
# Setting Parameters
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))
# 1) Accracy Plt
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) Loss Plt
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()
#Obtenir des données à partir d'un ensemble de données
(X_train, y_train, X_test, y_test) = np.load('Ensemble de données PATH')
X_train = np.array(X_train)
X_train = X_train.astype('float32')
X_train /= 255
y_train = np.array(y_train)
X_test = np.array(X_test)
X_test = X_test.astype('float32')
X_test /= 255
y_test = np.array(y_test)
datagen = image.ImageDataGenerator(
rotation_range=20,
width_shift_range=0.2,
height_shift_range=0.2
)
datagen.fit(X_train)
input_tensor = Input(shape=(64, 64, 3))
#Lire les données VGG16
vgg16 = VGG16(include_top=False, weights='imagenet', input_tensor=input_tensor)
top_model = Sequential()
top_model.add(Flatten(input_shape=vgg16.output_shape[1:]))
top_model.add(Dense(256, activation='relu'))
top_model.add(BatchNormalization())
top_model.add(Dropout(0.5))
top_model.add(Dense(2, activation='softmax'))
#vgg16 et top_Concaténer des modèles
model = Model(inputs=vgg16.input, outputs=top_model(vgg16.output))
#Fixez les poids jusqu'au 19ème calque en utilisant l'instruction for
for layer in model.layers[:19]:
layer.trainable = False
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=SGD(lr=1e-4, momentum=0.9),
metrics=['accuracy'])
history = model.fit_generator(datagen.flow(X_train, y_train, batch_size=32),
steps_per_epoch=len(X_train)/32, epochs=epochs, validation_data=(X_test, y_test))
#Évaluation de l'exactitude
scores = model.evaluate(X_test, y_test, verbose=1)
print('Test loss:', scores[0])
print('Test accuracy:', scores[1])
Les données acquises à partir de l'ensemble de données cette fois sont des données d'image couleur (64 * 64) et leur étiquette. X_train et X_test sont des données d'image, et y_train et y_test sont des étiquettes. En regardant le contenu de X_train,
print(X_train.shape)
print(X_train[0])
(1547, 64, 64, 3)
[[[ 36 40 50]
[ 40 46 59]
[ 57 64 82]
...
[114 120 124]
[161 155 152]
[141 118 109]]
...
[[203 146 115]
[210 154 123]
[182 128 95]
...
[249 250 248]
[251 243 241]
[228 212 213]]]
Ça ressemble à ça. En d'autres termes, X_train contient 1547 (64 * 64) images couleur. De plus, la valeur stockée dans X_train est un type entier non signé 8 bits compris entre 0 et 255. Je divise cela par 255 pour en faire un nombre compris entre 0 et 1 afin de réduire le coût d'apprentissage.
Si vous vérifiez les données y_train de la même manière,
print(y_train.shape)
print(y_train[0])
(1547, 2)
[0 1]
Vous pouvez voir que le même nombre de vecteurs one-hot que X_train est stocké.
Chargez ensuite le modèle VGG16. Veuillez vous référer à la documentation des applications Keras pour le chargement du modèle VGG16. Cette fois, 3 arguments sont définis. include_top indique s'il faut inclure ou non les trois couches entièrement connectées du côté de la couche de sortie du réseau. Puisque nous faisons l'apprentissage par transfert cette fois, nous n'avons pas besoin de la couche entièrement connectée de VGG16. Par conséquent, il est défini sur False. les poids déterminent le poids de VGG 16. S'il est Aucun, il sera aléatoire, et s'il est "imagenet", il sera appris poids. input_tensor spécifie la taille de l'image d'entrée.
top_model est la partie de la couche entièrement connectée qui colle après VGG16. VGG16 et top_model sont intégrés dans un modèle appelé model. Et cette fois, je veux utiliser le poids de VGG16 tel qu'il est appris dans imagenet, donc j'écris le code suivant.
#Fixez les poids jusqu'au 19ème calque en utilisant l'instruction for
for layer in model.layers[:19]:
layer.trainable = False
5. Utilisez Google Colaboratory
Même si vous dites que vous construisez un modèle d'apprentissage automatique par apprentissage par transfert, si les spécifications de l'ordinateur que vous utilisez sont faibles, le nombre de données ou le nombre d'époques est important, il faudra du temps pour apprendre. Dans un tel cas, créons un modèle d'apprentissage automatique à l'aide de Google Colabratory. Google Colabratory est un environnement de notebook jupyter fourni par Google. Le plus grand avantage de l'utilisation de ce service est qu'il peut être traité à grande vitesse à l'aide de GPU. Je pense que le temps de traitement différera d'environ 10 fois en fonction de la présence ou de l'absence de GPU. Voici donc les étapes à suivre pour exécuter le code source ci-dessus dans Google Colaboratory.
Ouvrez d'abord Google Colaboratory, donnez-lui un nom, puis modifiez les paramètres pour utiliser le GPU.
Pour activer le GPU, cliquez sur le bouton "Modifier-> Paramètres du bloc-notes" juste en dessous du nom de fichier en haut à gauche.
Ensuite, l'écran suivant apparaîtra, alors sélectionnez "GPU".
Le notebook est maintenant prêt pour le GPU.
Tapez ensuite le code suivant pour modifier la version de numpy.
pip install numpy==1.16.1
La raison de l'écriture de ce code est d'éviter les erreurs lors de la lecture de l'ensemble de données dans le code source ci-dessus. Ensuite, téléchargez l'ensemble de données sur votre ordinateur portable. Pour télécharger, associez Google Colaboratory et chargez le fichier téléchargé sur Google Drive. Pour que cela fonctionne, tapez le code suivant.
from google.colab import drive
drive.mount('/content/gdrive')
Lorsque vous saisissez le code, vous verrez une zone dans laquelle vous pouvez saisir l'URL et le code de vérification.
Lorsque vous cliquez sur le lien et que vous vous connectez à Google Drive, le mot de passe d'authentification s'affiche. Copiez-le et saisissez le code d'authentification pour utiliser les données sur Google Drive.
La structure des répertoires sur le notebook est (./gdrive/MyDrive/).
Les fichiers enregistrés dans mon Google Drive y sont enregistrés.
6. À la fin
Cette fois, nous avons créé un modèle d'apprentissage automatique en effectuant un apprentissage par transfert à l'aide de notre propre ensemble de données. Même un amateur peut facilement écrire du code en machine learning, mais cela peut affaiblir la compréhension du code écrit de cette quantité, donc je pense qu'il est important de revenir sur le code que j'ai écrit de cette manière. Je vais. La prochaine fois, j'utiliserai le modèle d'apprentissage automatique créé cette fois pour créer une application Web qui distingue les visages des japonais et des étrangers.
Les références
・ Keras Documentatino-Application ・ Comment utiliser Google Colabratory ・ J'ai essayé d'utiliser l'environnement GPU gratuit de Google Colaboratory ・ Qu'est-ce que l'apprentissage par transfert? Comment réalisez-vous le «transfert d'apprentissage» attendu dans l'apprentissage profond?
Recommended Posts