Comment améliorer votre modèle d'apprentissage automatique avec l'augmentation des données de TensorFlow

L'augmentation des données est le processus d'application de diverses transformations aux données d'apprentissage. Cela permet d'augmenter la diversité de l'ensemble de données et d'éviter le surajustement. Le surajustement se produit principalement lorsque vous disposez de données limitées pour entraîner votre modèle.

Ici, vous apprendrez à utiliser le module d'augmentation de données de TensorFlow pour diversifier votre ensemble de données. Cela empêchera le surajustement en générant de nouveaux points de données légèrement différents des données d'origine.

L'exemple de jeu de données que vous utiliserez

Vous utiliserez l'ensemble de données chats et chiens de Kagglé. Cet ensemble de données contient environ 3 000 images de chats et de chiens. Ces images sont divisées en ensembles de formation, 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 implémentant les techniques d'augmentation de données et celui qui ne le fait pas sont disponibles dans un Référentiel GitHub.

Installation et importation de TensorFlow

Pour suivre, vous devriez avoir un compréhension de base de Python. Vous devez également avoir des connaissances de base en apprentissage automatique. Si vous avez besoin d'un rappel, vous voudrez peut-être envisager de suivre quelques tutoriels sur l'apprentissage automatique.

Ouvrir Colab Google. Modifiez 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 installer tensorflow

Importez TensorFlow et ses modules et classes pertinents.

importer flux tenseur comme tf
depuis tensorflow.keras.preprocessing.image importer Générateur de données d'image
depuis tensorflow.keras.models importer Séquentiel
depuis tensorflow.keras.layers importer Conv2D, MaxPooling2D, Aplatir, Dense, Abandonner

Le tensorflow.keras.preprocessing.image vous permettra d'effectuer une augmentation de données sur votre jeu de données.

Création d'instances de la classe ImageDataGenerator

Créer une instance de Générateur de données d'image classe pour les données du train. Vous utiliserez cet objet pour le prétraitement des données d'entraînement. Il générera des lots de données d'images augmentées en temps réel pendant la formation du modèle.

Dans la tâche de classer si une image est un chat ou un chien, vous pouvez utiliser les techniques d'augmentation des données de retournement, de largeur aléatoire, de hauteur aléatoire, de luminosité aléatoire et de zoom. Ces techniques généreront de nouvelles données qui contiennent des variations des données originales représentant des scénarios du monde réel.

# définir le générateur de données d'image pour la formation
train_datagen = ImageDataGenerator (rescale=1./255,
 retournement_horizontal=Vrai,
 width_shift_range=0.2,
 height_shift_range=0.2,
 plage_luminosité=[0.2,1.0],
 zoom_range=0.2)

Créez une autre instance de Générateur de données d'image classe pour les données de test. Vous aurez besoin du remettre à l'échelle paramètre. Il normalisera les valeurs de pixel des images de test pour correspondre au format utilisé pendant la formation.

# définir le générateur de données d'image pour les tests
test_datagen = ImageDataGenerator (rescale=1./255)

Créer une instance finale du Générateur de données d'image classe pour les données de validation. Remettez à l'échelle les données de validation de la même manière que les données de test.

# définir le générateur de données d'image pour la validation
validation_datagen = ImageDataGenerator (rescale=1./255)

Vous n'avez pas besoin d'appliquer les autres techniques d'augmentation aux données de test et de validation. En effet, le modèle utilise les données de test et de validation uniquement à des fins d'évaluation. Ils doivent refléter la distribution originale des données.

Chargement de vos données

Créer un DirectoryIteratorDirectoryIterator objet du répertoire de formation. Il générera des lots d'images augmentées. Spécifiez ensuite le répertoire qui stocke les données d'apprentissage. Redimensionner les images à une taille fixe de 64x64 pixels. Spécifiez le nombre d'images que chaque lot utilisera. Enfin, précisez le type d'étiquette à binaire (c'est-à-dire chat ou chien).

# définir le répertoire de formation
train_data = train_datagen.flow_from_directory (répertoire=r'/content/drive/MyDrive/cats_and_dogs_filtered/train',
 taille_cible=(64, 64),
 batch_size=32,
 mode_classe='binaire')

Créer un autre DirectoryIteratorDirectoryIterator objet du répertoire testing. Réglez les paramètres sur les mêmes valeurs que celles des données d'entraînement.

# définir le répertoire testing
test_data = test_datagen.flow_from_directory (répertoire='/content/drive/MyDrive/cats_and_dogs_filtered/test',
 taille_cible=(64, 64),
 batch_size=32,
 mode_classe='binaire')

Créer une finale DirectoryIteratorDirectoryIterator objet du répertoire de validation. Les paramètres restent les mêmes que ceux des données d'entraînement et de test.

# définir le répertoire de validation
validation_data = validation_datagen.flow_from_directory (répertoire='/content/drive/MyDrive/cats_and_dogs_filtered/validation',
 taille_cible=(64, 64),
 batch_size=32,
 mode_classe='binaire')

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 de neurones. Utiliser un Réseau neuronal convolutif (CNN). Les CNN sont conçus pour reconnaître les modèles et les caractéristiques des images.

modèle = Séquentiel()
# couche convolutive avec 32 filtres de taille 3x3
model.add (Conv2D(32, (3, 3), activation='relu', input_shape=(64, 64, 3))) 
# couche de pooling max avec taille de pool 2x2
model.add (MaxPooling2D(pool_size=(2, 2))) 
# couche convolutive avec 64 filtres de taille 3x3
model.add (Conv2D(64, (3, 3), activation='relu'))
# couche de pooling max avec taille de pool 2x2 
model.add (MaxPooling2D(pool_size=(2, 2))) 
# aplatir la sortie des couches de convolution et de mise en commun
model.add (Aplatir()) 
# couche entièrement connectée avec 128 unités et activation ReLU
model.add (Dense(128, activation='relu')) 
# abandonner au hasard 50 % des unités pour éviter le surajustement
model.add (Décrochage(0.5)) 
# couche de sortie avec activation sigmoïde (classification binaire)
model.add (Dense(1, activation='sigmoïde'))

Compiler le modèle en utilisant le binaire entropie croisée fonction de perte. Les problèmes de classification binaire l'utilisent couramment. Pour l'optimiseur, utilisez le Adam optimiseur. 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 (perte='binary_crossentropy', optimiseur='Adam', mesures=['précision'])

Imprimez un résumé de l'architecture du modèle sur la console.

modèle. résumé ()

La capture d'écran suivante montre la visualisation de l'architecture du modèle.

Cela vous donne un aperçu de l'apparence de la conception de votre modèle.

Formation de votre modèle

Entraînez le modèle à l'aide de adapter() méthode. Définissez le nombre d'étapes par époque comme étant le nombre d'échantillons d'apprentissage divisé par le taille du lot. Définissez également les données de validation et le nombre d'étapes de validation.

# Entraîner le modèle sur les données d'entraînement
history = model.fit (train_data,
 étapes_per_epoch=train_data.n // train_data.batch_size,
 époques=50,
 validation_data=validation_data,
 validation_steps=validation_data.n // validation_data.batch_size)

Le Générateur de données d'image classe applique l'augmentation de données aux données de formation en temps réel. Cela rend le processus de formation du modèle plus lent.

Évaluation de votre modèle

Évaluez les performances de votre modèle sur les données de test à l'aide de évaluer() méthode. Imprimez également la perte et la précision du test sur la console.

test_loss, test_acc = model.evaluate (test_data,
 étapes=test_data.n // test_data.batch_size)
imprimer(f'Test de perte: {test_loss}')
imprimer(f'Tester la précision: {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 du code qui n'implémente pas les techniques d'augmentation des données, la précision de formation du modèle est de 1. Ce qui signifie qu'il dépasse. Il fonctionne également mal sur des données qu'il n'a jamais vues auparavant. En effet, 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 augmente la taille et la diversité d'un ensemble de données. Si l'ensemble de données est déjà volumineux 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 entités qui ne sont pas présentes dans le jeu de données d'origine. Par conséquent, il ne peut pas compenser un petit ensemble de données dépourvu de la plupart des fonctionnalités dont le modèle a besoin pour apprendre.
• Lorsque le type d'augmentation de données est inapproprié: Par exemple, la rotation des images peut ne pas être utile lorsque l'orientation des objets est importante.

De quoi est capable TensorFlow

TensorFlow est une bibliothèque diversifiée et puissante. Il est capable de former des modèles complexes d'apprentissage en profondeur et peut fonctionner sur une gamme d'appareils allant des smartphones aux clusters de serveurs. Il a aidé à alimenter les appareils informatiques de pointe qui utilisent l'apprentissage automatique.