L’augmentation des données consiste à appliquer diverses transformations aux données d’apprentissage. Elle permet d’augmenter la diversité de l’ensemble de données et d’éviter l’ajustement excessif. L’ajustement excessif se produit principalement lorsque vous disposez d’un nombre limité de données pour former votre modèle.
Ici, vous apprendrez à utiliser le module d’augmentation des données de TensorFlow pour diversifier votre ensemble de données. Cela permet d’éviter l’overfitting en générant de nouveaux points de données légèrement différents des données d’origine.
L’échantillon de données que vous utiliserez
Vous allez utiliser l’ensemble de données sur les chats et les chiens de Kaggle. Cet ensemble de données contient environ 3 000 images de chats et de chiens. Ces images sont réparties entre les ensembles d’entraînement, de test et de validation.
L’étiquette 1.0 représente un chien tandis que l’étiquette 0.0 représente un chat.
Le code source complet mettant en œuvre les techniques d’augmentation des données et celui qui ne le fait pas sont disponibles dans un dépôt GitHub.
Installation et importation de TensorFlow
Pour continuer, vous devez avoir une connaissance de base de Python. Vous devez également avoir des connaissances de base sur l’apprentissage automatique. Si vous avez besoin d’une remise à niveau, vous pouvez envisager de suivre quelques tutoriels sur l’apprentissage automatique.
Ouvrez Google Colab. Changez le type d’exécution en GPU. Ensuite, exécutez la commande magique suivante sur la première cellule de code pour installer TensorFlow dans votre environnement.
!pip install tensorflow
Importez TensorFlow et ses modules et classes pertinents.
import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
L’outil tensorflow.keras.preprocessing.image vous permettra d’effectuer une augmentation des données sur votre jeu de données.
Création d’instances de la classe ImageDataGenerator
Créer une instance de la classe ImageDataGenerator pour les données d’apprentissage. Vous utiliserez cet objet pour le prétraitement des données d’entraînement. Il génère des lots de données d’images augmentées en temps réel pendant l’apprentissage du modèle.
Pour classer une image comme étant un chat ou un chien, vous pouvez utiliser les techniques de retournement, de largeur aléatoire, de hauteur aléatoire, de luminosité aléatoire et d’agrandissement des données. Ces techniques génèrent de nouvelles données qui contiennent des variations des données originales représentant des scénarios du monde réel.
# define the image data generator for training
train_datagen = ImageDataGenerator(rescale=1./255,
horizontal_flip=True,
width_shift_range=0.2,
height_shift_range=0.2,
brightness_range=[0.2,1.0],
zoom_range=0.2)
Créez une autre instance de la classe ImageDataGenerator pour les données de test. Vous aurez besoin de la classe rescale . Il normalise les valeurs des pixels des images de test pour qu’elles correspondent au format utilisé lors de l’apprentissage.
# define the image data generator for testing
test_datagen = ImageDataGenerator(rescale=1./255)
Créer une instance finale de la classe ImageDataGenerator pour les données de validation. Rééchelonnez les données de validation de la même manière que les données de test.
# define the image data generator for validation
validation_datagen = ImageDataGenerator(rescale=1./255)
Il n’est pas nécessaire d’appliquer les autres techniques d’augmentation aux données de test et de validation. En effet, le modèle n’utilise les données de test et de validation qu’à des fins d’évaluation. Elles doivent refléter la distribution originale des données.
Chargement des données
Créer un DirectoryIterator du répertoire d’apprentissage. Il générera des lots d’images augmentées. Indiquez ensuite le répertoire dans lequel sont stockées les données d’apprentissage. Redimensionnez les images à une taille fixe de 64×64 pixels. Indiquez le nombre d’images que chaque lot utilisera. Enfin, indiquez le type d’étiquette à utiliser. binaire (c.-à-d., chat ou chien).
# defining the training directory
train_data = train_datagen.flow_from_directory(directory=r'/content/drive/MyDrive/cats_and_dogs_filtered/train',
target_size=(64, 64),
batch_size=32,
class_mode='binary')
Créer un autre DirectoryIterator du répertoire de test. Réglez les paramètres aux mêmes valeurs que celles des données d’apprentissage.
# defining the testing directory
test_data = test_datagen.flow_from_directory(directory='/content/drive/MyDrive/cats_and_dogs_filtered/test',
target_size=(64, 64),
batch_size=32,
class_mode='binary')
Créer un objet final DirectoryIterator du répertoire de validation. Les paramètres restent les mêmes que ceux des données d’entraînement et de test.
# defining the validation directory
validation_data = validation_datagen.flow_from_directory(directory='/content/drive/MyDrive/cats_and_dogs_filtered/validation',
target_size=(64, 64),
batch_size=32,
class_mode='binary')
Les itérateurs de répertoire n’augmentent pas les ensembles de données de validation et de test.
Définir votre modèle
Définissez l’architecture de votre réseau neuronal. Utilisez un réseau neuronal convolutif (CNN). Les CNN sont conçus pour reconnaître des modèles et des caractéristiques dans les images.
model = Sequential()
# convolutional layer with 32 filters of size 3x3
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(64, 64, 3)))
# max pooling layer with pool size 2x2
model.add(MaxPooling2D(pool_size=(2, 2)))
# convolutional layer with 64 filters of size 3x3
model.add(Conv2D(64, (3, 3), activation='relu'))
# max pooling layer with pool size 2x2
model.add(MaxPooling2D(pool_size=(2, 2)))
# flatten the output from the convolutional and pooling layers
model.add(Flatten())
# fully connected layer with 128 units and ReLU activation
model.add(Dense(128, activation='relu'))
# randomly drop out 50% of the units to prevent overfitting
model.add(Dropout(0.5))
# output layer with sigmoid activation (binary classification)
model.add(Dense(1, activation='sigmoid'))
Compilez le modèle en utilisant la méthode binaire l’entropie croisée fonction de perte. Les problèmes de classification binaire l’utilisent couramment. Pour l’optimiseur, utilisez la fonction de perte Optimiseur Adam. Il s’agit d’un algorithme d’optimisation du taux d’apprentissage adaptatif. Enfin, évaluez le modèle en termes de précision.
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
Imprimer un résumé de l’architecture du modèle sur la console.
model.summary()
La capture d’écran suivante montre la visualisation de l’architecture du modèle.
Cela vous donne un aperçu de la conception de votre modèle.
Entraînement du modèle
Entraînez le modèle à l’aide de la fonction fit() méthode. Définir le nombre d’étapes par époque comme étant le nombre d’échantillons d’apprentissage divisé par la valeur de taille_du_lot. Définissez également les données de validation et le nombre d’étapes de validation.
# Train the model on the training data
history = model.fit(train_data,
steps_per_epoch=train_data.n // train_data.batch_size,
epochs=50,
validation_data=validation_data,
validation_steps=validation_data.n // validation_data.batch_size)
L’outil ImageDataGenerator La classe ImageDataGenerator applique l’augmentation des données aux données d’apprentissage en temps réel. Cela ralentit le processus d’apprentissage du modèle.
Évaluation de votre modèle
Evaluez la performance de votre modèle sur les données de test à l’aide de la fonction evaluate() . Imprimez également la perte et la précision du test sur la console.
test_loss, test_acc = model.evaluate(test_data,
steps=test_data.n // test_data.batch_size)
print(f'Test loss: {test_loss}')
print(f'Test accuracy: {test_acc}')
La capture d’écran suivante montre les performances du modèle.
Le modèle fonctionne raisonnablement bien sur des données jamais vues.
Lorsque vous exécutez un code qui ne met pas en œuvre les techniques d’augmentation des données, la précision d’apprentissage du modèle est de 1, ce qui signifie qu’il s’adapte trop. Le modèle est également peu performant sur des données qu’il n’a jamais vues auparavant. Cela s’explique par le fait qu’il apprend les particularités de l’ensemble de données.
Quand l’augmentation des données n’est-elle pas utile ?
- Lorsque l’ensemble de données est déjà diversifié et volumineux: L’augmentation des données accroît la taille et la diversité d’un ensemble de données. Si l’ensemble de données est déjà important et diversifié, l’augmentation des données ne sera pas utile.
- Lorsque l’ensemble de données est trop petit: L’augmentation des données ne peut pas créer de nouvelles caractéristiques qui ne sont pas présentes dans l’ensemble de données original. Elle ne peut donc pas compenser le fait qu’un petit ensemble de données ne contient pas la plupart des caractéristiques que le modèle doit apprendre.
- Lorsque le type d’augmentation des données n’est pas approprié: Par exemple, la rotation des images peut ne pas être utile lorsque l’orientation des objets est importante.
De quoi TensorFlow est-il capable ?
TensorFlow est une bibliothèque diversifiée et puissante. Elle est capable de former des modèles complexes d’apprentissage profond et peut fonctionner sur une gamme d’appareils allant des smartphones aux grappes de serveurs. Elle a contribué à alimenter les dispositifs informatiques de pointe qui utilisent l’apprentissage automatique.
