Un guide pour entraîner des modèles de classification d'images à l'aide de TensorFlow

Traducteur | Chen Jun

Critique | Sun Shujuan

Comme nous le savons tous, les humains apprennent à identifier et à étiqueter les choses qu'ils voient dès leur plus jeune âge. De nos jours, grâce à l’itération continue des algorithmes d’apprentissage automatique et d’apprentissage profond, les ordinateurs sont capables de classer les images capturées à grande échelle avec une très grande précision. Actuellement, les scénarios d'application de ces algorithmes avancés comprennent : l'interprétation des images de scanner pulmonaire pour déterminer si elles sont saines, la reconnaissance faciale via des appareils mobiles et la distinction de différents types d'objets de consommation pour les détaillants.

Ci-dessous, je discuterai avec vous d'une application de vision par ordinateur - classification d'images, et montrerai progressivement comment utiliser TensorFlow pour entraîner un modèle sur un petit ensemble de données d'image.

1. Ensemble de données et cible

Dans cet exemple, nous utiliserons l'ensemble de données MNIST d'images de chiffres de 0 à 9. Sa forme est celle indiquée dans la figure ci-dessous :

Le but de l'entraînement de ce modèle est de classer les images sous leurs étiquettes respectives, c'est-à-dire : leurs numéros correspondants dans la figure ci-dessus. En règle générale, une architecture de réseau neuronal profond fournit une entrée, une sortie, deux couches cachées (couches cachées) et une couche d'abandon pour entraîner le modèle. CNN ou Convolutional Neural Network est le premier choix pour identifier des images plus grandes. Il peut capturer des informations pertinentes tout en réduisant la quantité d'entrée.

2. Préparation

Tout d'abord, importons toutes les données pertinentes via TensorFlow, to_categorical (utilisé pour convertir les valeurs de classe numériques​​en d'autres catégories), Sequential, Flatten, Dense et Dropout pour créer la base de code de l'architecture de réseau neuronal. . Certaines des bibliothèques de codes mentionnées ici peuvent vous être légèrement inconnues. Je vais les expliquer en détail ci-dessous.

3. Hyperparamètres

• Je vais choisir le bon ensemble d'hyperparamètres à travers les aspects suivants :
• 
  
• Tout d'abord, définissons quelques hyperparamètres comme point de départ. Plus tard, vous pourrez l'ajuster pour répondre à différents besoins. Ici, j'ai choisi 128 comme taille de lot la plus petite. En fait, la taille du lot peut prendre n'importe quelle valeur, mais une puissance de 2 améliore souvent l'efficacité de la mémoire, elle devrait donc être le premier choix. Il convient de noter que la principale raison derrière le choix d'une taille de lot appropriée est qu'une taille de lot trop petite rendra la convergence trop lourde, tandis qu'une taille de lot trop grande risque de ne pas tenir dans la mémoire de votre ordinateur.
• Gardons le nombre d'époques (chaque échantillon de l'ensemble d'entraînement participe à un entraînement) à 50 pour obtenir un entraînement rapide du modèle. Plus la valeur de l’époque est faible, plus elle est adaptée aux ensembles de données petits et simples.
• Ensuite, vous devez ajouter des calques cachés. Ici, j'ai réservé 128 neurones pour chaque couche cachée. Bien entendu, vous pouvez également tester avec 64 et 32 ​​neurones. Pour cet exemple, je ne recommanderais pas d'utiliser des valeurs plus élevées pour un ensemble de données simple comme MINST.
• Vous pouvez essayer différents taux d'apprentissage, tels que 0,01, 0,05 et 0,1. Dans ce cas, je le garde à 0,01.
• Pour les autres hyperparamètres, j'ai choisi les étapes de désintégration et le taux de désintégration comme étant respectivement de 2000 et 0,9. Et au fur et à mesure que la formation progresse, ils peuvent être utilisés pour réduire le taux d’apprentissage.
• Ici, je choisis Adamax comme optimiseur. Bien entendu, vous pouvez également choisir d’autres optimiseurs comme Adam, RMSProp, SGD, etc.

import tensorflow as tf
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense, Dropout
params = {
'dropout': 0.25,
'batch-size': 128,
'epochs': 50,
'layer-1-size': 128,
'layer-2-size': 128,
'initial-lr': 0.01,
'decay-steps': 2000,
'decay-rate': 0.9,
'optimizer': 'adamax'
}
mnist = tf.keras.datasets.mnist
num_class = 10
# split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# reshape and normalize the data
x_train = x_train.reshape(60000, 784).astype("float32")/255
x_test = x_test.reshape(10000, 784).astype("float32")/255
# convert class vectors to binary class matrices
y_train = to_categorical(y_train, num_class)
y_test = to_categorical(y_test, num_class)

4. Créez des ensembles de formation et de test

Étant donné que la bibliothèque TensorFlow comprend également l'ensemble de données MNIST, vous pouvez obtenir la formation (60 000) en appelant datasets.mnist sur l'objet, puis en appelant la méthode load_data(). ) et tester des ensembles de données (10 000 échantillons).

Ensuite, vous devez remodeler et normaliser les images d'entraînement et de test. Parmi eux, la normalisation limitera l’intensité des pixels de l’image entre 0 et 1.

Enfin, nous utilisons la méthode to_categorical que nous avons importée précédemment pour convertir les étiquettes de formation et de test en étiquettes classifiées. Il est très important de transmettre au framework TensorFlow que les étiquettes de sortie (c'est-à-dire : 0 à 9) sont des classes, et non des types numériques.

5. Concevoir l'architecture du réseau neuronal

Maintenant, comprenons comment concevoir l'architecture du réseau neuronal en détail.

Nous convertissons la matrice d'image 2D en vecteurs en ajoutant Flatten pour définir la structure du DNN (Deep Neural Network). Les neurones d'entrée correspondent ici aux nombres dans le vecteur.

Ensuite, j'utilise la méthode Dense() pour ajouter deux couches denses cachées et extraire chaque hyperparamètre du dictionnaire "params" précédemment défini. On peut utiliser "relu" (Rectified Linear Unit) comme fonction d'activation de ces couches. C’est l’une des fonctions d’activation les plus couramment utilisées dans les couches cachées des réseaux neuronaux.

Ensuite, nous ajoutons le calque Dropout en utilisant la méthode Dropout. Il sera utilisé pour éviter le surajustement lors de la formation des réseaux de neurones. Après tout, les modèles de surajustement ont tendance à mémoriser avec précision l’ensemble d’entraînement et ne parviennent pas à généraliser à des ensembles de données invisibles.

输出层是我们网络中的最后一层，它是使用Dense() 方法来定义的。需要注意的是，输出层有10个神经元，这对应于类（数字）的数量。

# Model Definition
# Get parameters from logged hyperparameters
model = Sequential([
Flatten(input_shape=(784, )),
Dense(params('layer-1-size'), activatinotallow='relu'),
Dense(params('layer-2-size'), activatinotallow='relu'),
Dropout(params('dropout')),
Dense(10)
])
lr_schedule =
tf.keras.optimizers.schedules.ExponentialDecay(
initial_learning_rate=experiment.get_parameter('initial-lr'),
decay_steps=experiment.get_parameter('decay-steps'),
decay_rate=experiment.get_parameter('decay-rate')
)
loss_fn = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
model.compile(optimizer='adamax',
loss=loss_fn,
metrics=['accuracy'])
model.fit(x_train, y_train,
batch_size=experiment.get_parameter('batch-size'),
epochs=experiment.get_parameter('epochs'),
validation_data=(x_test, y_test),)
score = model.evaluate(x_test, y_test)
# Log Model
model.save('tf-mnist-comet.h5')

6、训练

至此，我们已经定义好了架构。下面让我们用给定的训练数据，来编译和训练神经网络。

首先，我们以初始学习率、衰减步骤和衰减率作为参数，使用ExponentialDecay（指数衰减学习率）来定义学习率计划。

其次，将损失函数定义为CategoricalCrossentropy（用于多类式分类）。

接着，通过将优化器 (即：adamax)、损失函数、以及各项指标（由于所有类都同等重要、且均匀分布，因此我选择了准确性）作为参数，来编译模型。

然后，我们通过使用x_train、y_train、batch_size、epochs和validation_data去调用一个拟合方法，并拟合出模型。

同时，我们调用模型对象的评估方法，以获得模型在不可见数据集上的表现分数。

最后，您可以使用在模型对象上调用的save方法，保存要在生产环境中部署的模型对象。

7、小结

综上所述，我们讨论了为图像分类任务，训练深度神经网络的一些入门级的知识。您可以将其作为熟悉使用神经网络，进行图像分类的一个起点。据此，您可了解到该如何选择正确的参数集、以及架构背后的思考逻辑。

原文链接：https://www.kdnuggets.com/2022/12/guide-train-image-classification-model-tensorflow.html

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!