Formation personnalisée de modèles d'apprentissage profond à l'aide de techniques d'apprentissage par transfert

​Traducteur | Zhu Xianzhong

Reviewer | Sun Shujuan

L'apprentissage par transfert est un type d'apprentissage automatique. Il s'agit d'une méthode appliquée aux réseaux de neurones qui ont été formés ou pré-entraînés, et à ces réseaux de neurones pré-entraînés. le méta-réseau est formé à l’aide de millions de points de données.

L'utilisation la plus connue de cette technologie actuellement est la formation de réseaux de neurones profonds, car cette méthode montre de bonnes performances lorsqu'elle utilise moins de données pour former des réseaux de neurones profonds. En fait, cette technique est également utile dans le domaine de la science des données, car la plupart des données du monde réel ne contiennent généralement pas des millions de points de données pour former un modèle d'apprentissage profond robuste.

Actuellement, il existe déjà de nombreux modèles entraînés à l'aide de millions de points de données, et ces modèles peuvent être utilisés pour entraîner des réseaux neuronaux complexes d'apprentissage en profondeur avec une précision maximale.

Dans ce didacticiel, vous apprendrez le processus complet d'utilisation de la technologie d'apprentissage par transfert pour former un réseau neuronal profond.

Implémentation de l'apprentissage par transfert à l'aide du programme Keras

Avant de construire ou de former un réseau neuronal profond, vous devez déterminer quelles options sont disponibles pour l'apprentissage par transfert et quelle option doit être utilisée pour former un réseau neuronal profond complexe pour votre projet.

L'application Keras est un modèle d'apprentissage profond avancé qui fournit des poids pré-entraînés qui peuvent être utilisés pour la prédiction, l'extraction de fonctionnalités et le réglage fin. Il existe de nombreux modèles prêts à l'emploi intégrés dans la bibliothèque Keras, parmi les modèles populaires figurent :

•  Modèles, qui peuvent être utilisés avec des poids pré-entraînés. Pour un contenu plus spécifique sur ces modèles, veuillez vous référer au site officiel de Keras.
• Dans cet article, vous découvrirez l'application du
​modèle MobileNet​
• ​dans l'apprentissage par transfert.
• Formation d'un modèle d'apprentissage profond

Dans cette section, vous apprendrez comment créer un modèle d'apprentissage profond personnalisé pour la reconnaissance d'images en quelques étapes seulement, sans avoir à écrire une série de réseaux de neurones convolutifs (CNN), vous il vous suffit d'affiner le modèle pré-entraîné pour entraîner votre modèle sur l'ensemble de données d'entraînement.

Dans cet article, nous construisons un modèle d'apprentissage profond qui sera capable de reconnaître des images de chiffres du langage gestuel. Ensuite, commençons à créer ce modèle d’apprentissage profond personnalisé.

Obtenez l'ensemble de données

Pour démarrer le processus de création d'un modèle d'apprentissage en profondeur, vous devez d'abord préparer vos données, vous pouvez facilement choisir la bonne parmi des millions d'ensembles de données en visitant un site Web appelé Kaggle . Bien entendu, il existe de nombreux autres sites Web qui fournissent des ensembles de données disponibles pour créer des modèles d’apprentissage profond ou d’apprentissage automatique.

Mais l'ensemble de données que nous utiliserons dans cet article est extrait du

Ensemble de données sur les chiffres de la langue des signes américaine

​ fourni par le site Web Kaggle.

Prétraitement des données

Après avoir téléchargé l'ensemble de données et l'avoir enregistré sur le stockage local, il est maintenant temps d'effectuer un prétraitement sur l'ensemble de données, comme la préparation des données, la division des données en répertoire de train, répertoire valide et test répertoires, définition de leurs chemins et création de lots à des fins de formation, etc.

Préparez les données

Lorsque vous téléchargez l'ensemble de données, il contient un répertoire de données de 0 à 9, avec trois sous-dossiers correspondant à l'image d'entrée, l'image de sortie et un dossier nommé CSV.

Ensuite, supprimez les images de sortie et les dossiers CSV de chaque répertoire, déplacez le contenu du dossier des images d'entrée vers le répertoire principal, puis supprimez le dossier des images d'entrée.

Chaque répertoire maître de l'ensemble de données contient désormais 500 images, et vous pouvez choisir de toutes les conserver. Mais à des fins de démonstration, seules 200 images de chaque répertoire sont utilisées dans cet article.

Enfin, la structure de l'ensemble de données sera la suivante :

Structure des dossiers de l'ensemble de données

Diviser l'ensemble de données

Maintenant, commençons par diviser l'ensemble de données en trois sous-répertoires : entraîner, valider et tester.

• Le répertoire des trains contiendra les données d'entraînement qui serviront de données d'entrée à notre modèle pour les modèles d'apprentissage et les irrégularités.
• Le répertoire valide contiendra les données de validation qui seront introduites dans le modèle et seront les premières données invisibles vues par le modèle, ce qui permettra d'obtenir une précision maximale.
• Le répertoire de test contiendra les données de test utilisées pour tester le modèle.

Tout d’abord, importons les bibliothèques qui seront utilisées plus loin dans le code.

# 导入需要的库
import os
import shutil
import random

Vous trouverez ci-dessous le code pour générer le répertoire requis et déplacer les données vers un répertoire spécifique.

#创建三个子目录：train、valid和test，并把数据组织到其下
os.chdir('D:SACHINJupyterHand Sign LanguageHand_Sign_Language_DL_ProjectAmerican-Sign-Language-Digits-Dataset')

#如果目录不存在则创建相应的子目录
if os.path.isdir('train/0/') is False:
os.mkdir('train')
os.mkdir('valid')
os.mkdir('test')

for i in range(0, 10):
#把0-9子目录移动到train子目录下
shutil.move(f'{i}', 'train')
os.mkdir(f'valid/{i}')
os.mkdir(f'test/{i}')

#从valid子目录下取90个样本图像
valid_samples = random.sample(os.listdir(f'train/{i}'), 90)
for j in valid_samples:
#把样本图像从子目录train移动到valid子目录
shutil.move(f'train/{i}/{j}', f'valid/{i}')

#从test子目录下取90个样本图像
test_samples = random.sample(os.listdir(f'train/{i}'), 10)
for k in test_samples:
#把样本图像从子目录train移动到test子目录
shutil.move(f'train/{i}/{k}', f'test/{i}')

os.chdir('../..')

Dans le code ci-dessus, nous modifions d'abord le répertoire correspondant à l'ensemble de données dans le stockage local, puis vérifions si le répertoire train/0 existe déjà, sinon nous créerons respectivement les sous-répertoires train, valid et test ;

Ensuite, nous créons les sous-répertoires 0 à 9, déplaçons toutes les données vers le répertoire train et créons les sous-répertoires 0 à 9 sous les sous-répertoires valid et test.

Nous parcourons ensuite les sous-répertoires 0 à 9 dans le répertoire train et obtenons au hasard 90 données d'image de chaque sous-répertoire et les déplaçons vers le sous-répertoire correspondant dans le répertoire valide.

Il en va de même pour le test du répertoire de test.

【Supplément】 module Shutil pour effectuer des opérations avancées sur les fichiers en Python (copier ou déplacer manuellement des fichiers ou des dossiers d'un répertoire à un autre peut être une chose très pénible. Pour des conseils détaillés, veuillez vous référer à l'article https://medium.com /@geekpython/perform-high-level-file-operations-in-python-shutil-module-dfd71b149d32).

Définir les chemins d'accès à chaque répertoire

Après avoir créé les répertoires requis, vous devez maintenant définir les chemins d'accès aux trois sous-répertoires : train, valid et test.

#为三个子目录train、valid和test分别指定路径
train_path = 'D:/SACHIN/Jupyter/Hand Sign Language/Hand_Sign_Language_DL_Project/American-Sign-Language-Digits-Dataset/train'
valid_path = 'D:/SACHIN/Jupyter/Hand Sign Language/Hand_Sign_Language_DL_Project/American-Sign-Language-Digits-Dataset/valid'
test_path = 'D:/SACHIN/Jupyter/Hand Sign Language/Hand_Sign_Language_DL_Project/American-Sign-Language-Digits-Dataset/test'

Prétraitement

Les modèles d'apprentissage en profondeur pré-entraînés nécessitent des données prétraitées, ce qui est très approprié pour la formation. Par conséquent, les données doivent être au format requis par le modèle pré-entraîné.

Avant d'appliquer tout prétraitement, importons TensorFlow et ses utilitaires, qui seront utilisés plus loin dans le code.

#导入TensorFlow及其实用程序
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.layers import Dense, Activation
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.metrics import categorical_crossentropy
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.preprocessing import image
from tensorflow.keras.models import Model
from tensorflow.keras.models import load_model

#创建训练、校验和测试图像的批次，并使用Mobilenet的预处理模型进行预处理
train_batches = ImageDataGenerator(preprocessing_function=tf.keras.applications.mobilenet.preprocess_input).flow_from_directory(
directory=train_path, target_size=(224,224), batch_size=10, shuffle=True)
valid_batches = ImageDataGenerator(preprocessing_function=tf.keras.applications.mobilenet.preprocess_input).flow_from_directory(
directory=valid_path, target_size=(224,224), batch_size=10, shuffle=True)
test_batches = ImageDataGenerator(preprocessing_function=tf.keras.applications.mobilenet.preprocess_input).flow_from_directory(
directory=test_path, target_size=(224,224), batch_size=10, shuffle=False)

Nous avons utilisé ImageDatagenerator, qui prend un paramètre preprocessing_function dans lequel nous prétraitons l'image fournie par le modèle MobileNet.

Ensuite, appelez la fonction flow_from_directory où nous fournissons le chemin d'accès au répertoire et aux dimensions des images à entraîner, puisque le modèle MobileNet est entraîné pour des images de dimensions 224x224.

Ensuite, la taille du lot est définie - définissant le nombre d'images pouvant être traitées en une seule itération, puis nous mélangeons aléatoirement l'ordre de traitement des images. Ici, nous ne mélangeons pas aléatoirement les images des données de test car les données de test ne seront pas utilisées pour la formation.

Après avoir exécuté l'extrait de code ci-dessus dans le notebook Jupyter ou Google Colab, vous verrez les résultats suivants.

La sortie du code ci-dessus

Le scénario d'application général d'ImageDataGenerator consiste à augmenter les données. Ce qui suit est un guide pour effectuer une augmentation de données à l'aide d'ImageDataGenerator dans le framework Keras.

Création du modèle

Avant d'intégrer les données de formation et de validation dans le modèle, le modèle d'apprentissage en profondeur MobileNet doit obtenir une meilleure précision en ajoutant des couches de sortie, en supprimant les couches inutiles et en rendant certaines couches impossibles à entraîner pour un réglage précis.

Le code suivant téléchargera le modèle MobileNet depuis Keras et le stockera dans la variable mobile. Vous devez être connecté à Internet la première fois que vous exécutez l'extrait de code suivant.

mobile = tf.keras.applications.mobilenet.MobileNet()

如果您运行以下代码，那么您将看到模型的摘要信息，在其中你可以看到一系列神经网络层的输出信息。

mobile.summary()

现在，我们将在模型中添加以10为单位的全连接输出层（也称“稠密层”）——因为从0到9将有10个输出。此外，我们从MobileNet模型中删除了最后六个层。

# 删除最后6层并添加一个输出层
x = mobile.layers[-6].output
output = Dense(units=10, activation='softmax')(x)

然后，我们将所有输入和输出层添加到模型中。

model = Model(inputs=mobile.input, outputs=output)

现在，我们将最后23层设置成不可训练的——其实这是一个相对随意的数字。一般来说，这一具体数字是通过多次试验和错误获得的。该代码的唯一目的是通过使某些层不可训练来提高精度。

#我们不会训练最后23层——这里的23是一个相对随意的数字
for layer in mobile.layers[:-23]:
layer.trainable=False

如果您看到了微调模型的摘要输出，那么您将注意到与前面看到的原始摘要相比，不可训练参数和层的数量存在一些差异。

model.summary()

接下来，我们要编译名为Adam的优化器，选择学习率为0.0001，以及损失函数，还有衡量模型的准确性的度量参数。

model.compile(optimizer=Adam(learning_rate=0.0001), loss='categorical_crossentropy', metrics=['accuracy'])

现在是准备好模型并根据训练和验证数据来开始训练的时候了。在下面的代码中，我们提供了训练和验证数据以及训练的总体轮回数。详细信息只是为了显示准确性进度，在这里您可以指定一个数字参数值为0、1或者2。

# 运行共10个轮回（epochs）
model.fit(x=train_batches, validation_data=valid_batches, epochs=10, verbose=2)

如果您运行上面的代码片断，那么您将看到训练数据丢失和准确性的轮回的每一步的输出内容。对于验证数据，您也能够看到这样的输出结果。

显示有精度值的训练轮回步数

存储模型

该模型现在已准备就绪，准确度得分为99%。现在请记住一件事：这个模型可能存在过度拟合，因此有可能对于给定数据集图像以外的图像表现不佳。

#检查模型是否存在；否则，保存模型
if os.path.isfile("D:/SACHIN/Models/Hand-Sign-Digit-Language/digit_model.h5") is False:
model.save("D:/SACHIN/Models/Hand-Sign-Digit-Language/digit_model.h5")

上面的代码将检查是否已经有模型的副本。如果没有，则通过调用save函数在指定的路径中保存模型。

测试模型

至此，模型已经经过训练，可以用于识别图像了。本节将介绍加载模型和编写准备图像、预测结果以及显示和打印预测结果的函数。

在编写任何代码之前，需要导入一些将在代码中进一步使用的必要的库。

import numpy as np
import matplotlib.pyplot as plt
from PIL import Image

加载定制的模型

对图像的预测将使用上面使用迁移学习技术创建的模型进行。因此，我们首先需要加载该模型，以供后面使用。

my_model = load_model("D:/SACHIN/Models/Hand-Sign-Digit-Language/digit_model.h5")

在此，我们通过使用load_model函数，实现从指定路径加载模型，并将其存储在my_model变量中，以便在后面代码中进一步使用。

准备输入图像

在向模型提供任何用于预测或识别的图像之前，我们需要提供模型所需的格式。

def preprocess_img(img_path):
open_img = image.load_img(img_path, target_size=(224, 224))
img_arr = image.img_to_array(open_img)/255.0
img_reshape = img_arr.reshape(1, 224,224,3)
return img_reshape

首先，我们要定义一个获取图像路径的函数preprocess_img，然后使用image实用程序中的load_img函数加载该图像，并将目标大小设置为224x224。然后将该图像转换成一个数组，并将该数组除以255.0，这样就将图像的像素值转换为0和1，然后将图像数组重新调整为形状（224，224，3），最后返回转换形状后的图像。

编写预测函数

def predict_result(predict):
pred = my_model.predict(predict)
return np.argmax(pred[0], axis=-1)

这里，我们定义了一个函数predict_result，它接受predict参数，此参数基本上是一个预处理的图像。然后，我们调用模型的predict函数来预测结果。最后，从预测结果中返回最大值。

显示与预测图像

首先，我们将创建一个函数，它负责获取图像的路径，然后显示图像和预测结果。

#显示和预测图像的函数
def display_and_predict(img_path_input):
display_img = Image.open(img_path_input)
plt.imshow(display_img)
plt.show()
img = preprocess_img(img_path_input)
pred = predict_result(img)
print("Prediction: ", pred)

上面这个函数display_and_predict首先获取图像的路径并使用PIL库中的Image.open函数打开该图像，然后使用matplotlib库来显示图像，然后将图像传递给preprep_img函数以便输出预测结果，最后使用predict_result函数获得结果并最终打印。

img_input = input("Enter the path of an image: ")
display_and_predict(img_input)

如果您运行上面的程序片断并输入数据集中图像的路径，那么您将得到所期望的输出。

预测结果示意图

请注意，到目前为止该模型是使用迁移学习技术成功创建的，而无需编写任何一系列神经网络层相关代码。

现在，这个模型可以用于开发能够进行图像识别的Web应用程序了。文章的最后所附链接处提供了如何将该模型应用到Flask应用程序中的完整实现源码。

结论

本文中我们介绍了使用预先训练的模型或迁移学习技术来制作一个定制的深度学习模型的过程。

到目前为止，您已经了解了创建一个完整的深度学习模型所涉及的每一步。归纳起来看，所使用的总体步骤包括：

• 准备数据集
• 预处理数据
• 创建模型
• 保存自定义模型
• 测试自定义模型

最后，您可以从​​GitHub​​上获取本文示例项目完整的源代码。

译者介绍

朱先忠，51CTO社区编辑，51CTO专家博客、讲师，潍坊一所高校计算机教师，自由编程界老兵一枚。

原文标题：​​Trained A Custom Deep Learning Model Using A Transfer Learning Technique​​​，作者：Sachin Pal​

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!