Un guide pour entraîner des modèles de classification d'images à l'aide de TensorFlow-IA-php.cn

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 :

Un guide pour entraîner des modèles de classification dimages à laide de TensorFlow

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ériquesen 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)

Copier après la connexion

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')

Copier après la connexion