RandAugment pour la classification d'images avec Keras/TensorFlow

L'augmentation des données a longtemps servi à remplacer un jeu de données « statique » par des variantes transformées, renforçant l'invariance de Réseaux de neurones convolutifs (CNN), et conduisant généralement à la robustesse à l'entrée.

Bien que l'augmentation des données sous la forme que nous utilisons encode un Défaut de connaissances sur la variance traductionnelle, ce qui est important pour la détection d'objets, la segmentation sémantique et d'instance, etc. invariance il fournit est souvent favorable aux modèles de classification, et par conséquent, l'augmentation est plus couramment et plus agressivement appliquée aux modèles de classification.

Types d'augmentation

L'augmentation a commencé à être très simple - petites rotations, retournements horizontaux et verticaux, fluctuations de contraste ou de luminosité, etc. Ces dernières années, des méthodes plus élaborées ont été conçues, notamment Coupé (décrochage spatial introduisant aléatoirement des carrés noirs dans les images d'entrée) et Mélanger (mélange de parties d'images et mise à jour des proportions d'étiquettes), et leur combinaison - CoupeMix. Les nouvelles méthodes d'augmentation tiennent compte des étiquettes, et des méthodes comme CutMix modifient les proportions des étiquettes pour qu'elles soient égales aux proportions de l'image occupée par les parties de chaque classe mélangées.

Avec une liste croissante d'augmentations possibles, certains ont commencé à les appliquer de manière aléatoire (ou au moins un sous-ensemble d'entre eux), avec l'idée qu'un ensemble aléatoire d'augmentations renforcera la robustesse des modèles et remplacera l'ensemble d'origine par un beaucoup plus grand. l'espace des images d'entrée. C'est ici que RandAugment coups de pied dans!

KerasCV et RandAugment

KerasCV est un package séparé, mais toujours un ajout officiel à Keras, développé par l'équipe Keras. Cela signifie qu'il obtient la même quantité de finition et d'intuitivité que le package principal, mais qu'il s'intègre également sans problème avec les modèles Keras réguliers et leurs couches. La seule différence que vous remarquerez est l'appel keras_cv.layers... au lieu de keras.layers....

KerasCV est toujours en développement au moment de l'écriture et comprend déjà 27 nouvelles couches de prétraitement, RandAugment, CutMixet MixUp étant certains d'entre eux. Voyons à quoi cela ressemble d'appliquer RandAugment aux images, et comment nous pouvons former un classifieur avec et sans augmentation aléatoire.

D'abord, installez keras_cv:

$ pip install keras_cv

Maintenant, importons TensorFlow, Keras et KerasCV, ainsi que les ensembles de données TensorFlow pour un accès facile à Imagenette :

import tensorflow as tf
from tensorflow import keras
import keras_cv
import tensorflow_datasets as tfds

Chargeons une image et affichons-la dans sa forme originale :

import matplotlib.pyplot as plt
import cv2

cat_img = cv2.cvtColor(cv2.imread('cat.jpg'), cv2.COLOR_BGR2RGB)
cat_img = cv2.resize(cat_img, (224, 224))
plt.imshow(cat_img)

Maintenant, appliquons RandAugment à lui, plusieurs fois et jetez un oeil aux résultats:

fig = plt.figure(figsize=(10,10))
for i in range(16):
    ax = fig.add_subplot(4,4,i+1)
    aug_img = keras_cv.layers.RandAugment(value_range=(0, 255))(cat_img)
    
    ax.imshow(aug_img.numpy().astype('int'))

La couche a un magnitude argument, qui par défaut est 0.5 et peut être modifié pour augmenter ou diminuer l'effet de l'augmentation :

fig = plt.figure(figsize=(10,10))
for i in range(16):
    ax = fig.add_subplot(4,4,i+1)
    aug_img = keras_cv.layers.RandAugment(value_range=(0, 255), magnitude=0.1)(cat_img)
    ax.imshow(aug_img.numpy().astype('int'))

Lorsqu'il est réglé sur une valeur faible telle que 0.1 – vous verrez une augmentation beaucoup moins agressive :

Être une couche - il peut être utilisé dans des modèles ou dans tf.data pipelines lors de la création d'ensembles de données. Cela fait RandAugment assez souple ! Les arguments supplémentaires sont les augmentations_per_image ainsi que rate arguments qui fonctionnent ensemble.

Pour 0...augmentations_per_image, la couche ajoute une couche de prétraitement aléatoire au pipeline à appliquer à une image. En cas de défaut 3 – trois opérations différentes sont ajoutées au pipeline. Ensuite, un nombre aléatoire est échantillonné pour chaque augmentation dans le pipeline - et s'il est inférieur à rate (par défaut à environ 0.9) – l'augmentation est appliquée.

Essentiellement - il y a une probabilité de 90% que chaque augmentation (aléatoire) du pipeline soit appliquée à l'image.

Cela signifie naturellement que toutes les augmentations ne doivent pas être appliquées, surtout si vous abaissez le rate. Vous pouvez également personnaliser les opérations autorisées via un RandomAugmentationPipeline couche, qui RandAugment est le cas particulier de. Un guide séparé sur RandomAugmentationPipeline sera publié prochainement.

Entraîner un classificateur avec et sans RandAugment

Pour simplifier l'aspect préparation/chargement des données et se concentrer sur RandAugment, utilisons tfds charger dans une portion d'Imagenette :

(train, valid_set, test_set), info = tfds.load("imagenette", 
                                           split=["train[:70%]", "validation", "train[70%:]"],
                                           as_supervised=True, with_info=True)

class_names = info.features["label"].names
n_classes = info.features["label"].num_classes
print(f'Class names: {class_names}') 
print('Num of classes:', n_classes) 

print("Train set size:", len(train)) 
print("Test set size:", len(test_set)) 
print("Valid set size:", len(valid_set)) 

Nous n'avons chargé qu'une partie des données d'apprentissage, pour faciliter le surajustement de l'ensemble de données en moins d'époques (ce qui rend notre expérience plus rapide, en fait). Puisque les images dans Imagenette sont de tailles différentes, créons un preprocess() fonction qui les redimensionne pour mapper l'ensemble de données avec, ainsi qu'un augment() fonction qui augmente les images dans un tf.data.Dataset:

def preprocess(images, labels):
  return tf.image.resize(images, (224, 224)), tf.one_hot(labels, 10)
  
def augment(images, labels):
  inputs = {"images": images, "labels": labels}
  outputs = keras_cv.layers.RandAugment(value_range=(0, 255))(inputs)
  return outputs['images'], outputs['labels']

Maintenant, nous avons encodé les étiquettes à chaud. Nous n'étions pas obligés de le faire, mais pour des augmentations comme CutMix qui falsifient les étiquettes et leurs proportions, vous devrez le faire. Étant donné que vous voudrez peut-être les appliquer ainsi que RandAugment fonctionne très bien avec eux pour créer des classificateurs robustes - laissons l'encodage à chaud. De plus, RandAugment prend un dictionnaire avec des images et des étiquettes exactement à cause de cela - certaines augmentations que vous pouvez ajouter modifieront en fait les étiquettes, elles sont donc obligatoires. Vous pouvez extraire les images augmentées et les étiquettes de la outputs dictionnaire facilement, il s'agit donc d'une étape supplémentaire, mais simple, à suivre lors de l'augmentation.

Cartographions les ensembles de données existants renvoyés par tfds les preprocess() fonction, regroupez-les et augmentez uniquement l'ensemble d'apprentissage :

valid_set = valid_set.map(preprocess).batch(32).prefetch(tf.data.AUTOTUNE)
train_set = train.map(preprocess).batch(32).prefetch(tf.data.AUTOTUNE)
train_set_aug = train.map(preprocess).map(augment_data, 
                                          num_parallel_calls=tf.data.AUTOTUNE).batch(32).prefetch(tf.data.AUTOTUNE)

Formons un réseau ! keras_cv.models possède des réseaux intégrés, similaires à keras.applications. Bien que la liste soit encore courte, elle s'allongera avec le temps et prendra le relais keras.applications. L'API est très similaire, donc le code de portage sera assez facile pour la plupart des praticiens :

effnet = keras_cv.models.EfficientNetV2B0(include_rescaling=True, include_top=True, classes=10)
          
effnet.compile(
    loss='categorical_crossentropy',
    optimizer='adam',
    metrics=['accuracy']
)

history = effnet.fit(train_set, epochs=25, validation_data = valid_set)

Alternativement, vous pouvez utiliser le courant keras.applications:

effnet = keras.applications.EfficientNetV2B0(weights=None, classes=10)

effnet.compile(
  loss='categorical_crossentropy',
  optimizer='adam',
  metrics=['accuracy']
)

history1 = effnet.fit(train_set, epochs=50, validation_data=valid_set)

Il en résulte un modèle qui ne fonctionne pas vraiment très bien :

Epoch 1/50
208/208 [==============================] - 60s 238ms/step - loss: 2.7742 - accuracy: 0.2313 - val_loss: 3.2200 - val_accuracy: 0.3085
...
Epoch 50/50
208/208 [==============================] - 48s 229ms/step - loss: 0.0272 - accuracy: 0.9925 - val_loss: 2.0638 - val_accuracy: 0.6887

Maintenant, formons la même configuration réseau sur l'ensemble de données augmenté. Chaque lot est augmenté individuellement, donc chaque fois que le même lot d'images (à l'époque suivante) apparaît, elles auront des augmentations différentes :

effnet = keras.applications.EfficientNetV2B0(weights=None, classes=10)
effnet.compile(
  loss='categorical_crossentropy',
  optimizer='adam',
  metrics=['accuracy']
)

history2 = effnet.fit(train_set_aug, epochs=50, validation_data = valid_set)

Epoch 1/50
208/208 [==============================] - 141s 630ms/step - loss: 2.9966 - accuracy: 0.1314 - val_loss: 2.7398 - val_accuracy: 0.2395
...
Epoch 50/50
208/208 [==============================] - 125s 603ms/step - loss: 0.7313 - accuracy: 0.7583 - val_loss: 0.6101 - val_accuracy: 0.8143

Bien mieux ! Bien que vous souhaitiez toujours appliquer d'autres augmentations, telles que CutMix ainsi que MixUp, ainsi que d'autres techniques de formation pour maximiser la précision du réseau - juste RandAugment considérablement aidé et peut être comparable à un pipeline d'augmentation plus long.

Si vous comparez les courbes d'entraînement, y compris l'entraînement ainsi que courbes de validation - il devient seulement clair combien RandAugment aide:

Dans le pipeline non augmenté, le réseau se suradapte (la précision de la formation atteint le plafond) et la précision de la validation reste faible. Dans le pipeline augmenté, le la précision de la formation reste inférieure à la précision de la validation du début à la fin.

Avec une perte d'entraînement plus élevée, le réseau est beaucoup plus conscient des erreurs qu'il commet encore, et davantage de mises à jour peuvent être effectuées pour le rendre invariant aux transformations. Le premier ne voit pas la nécessité de se mettre à jour, tandis que le second le fait et relève le plafond du potentiel.

Conclusion

KerasCV est un package séparé, mais toujours un ajout officiel à Keras, développé par l'équipe Keras, visant à apporter un CV de qualité industrielle à vos projets Keras. KerasCV est toujours en développement au moment de l'écriture et comprend déjà 27 nouvelles couches de prétraitement, RandAugment, CutMixet MixUp étant certains d'entre eux.

Dans ce petit guide, nous avons examiné comment vous pouvez utiliser RandAugment pour appliquer un certain nombre de transformations aléatoires à partir d'une liste donnée de transformations appliquées, et à quel point il est facile de les inclure dans n'importe quel pipeline de formation Keras.

Aller plus loin - Apprentissage profond pratique pour la vision par ordinateur

Votre nature curieuse vous donne envie d'aller plus loin ? Nous vous recommandons de consulter notre Cours: "Apprentissage profond pratique pour la vision par ordinateur avec Python".

Un autre cours de vision par ordinateur ?

Nous ne ferons pas de classification des chiffres MNIST ou de la mode MNIST. Ils ont fait leur part il y a longtemps. Trop de ressources d'apprentissage se concentrent sur les ensembles de données de base et les architectures de base avant de laisser les architectures de boîte noire avancées assumer le fardeau des performances.

Nous voulons nous concentrer sur démystification, pratique, compréhension, intuition ainsi que de vrais projets. Vouloir apprendre how tu peux faire la différence? Nous vous emmènerons dans un voyage de la façon dont notre cerveau traite les images à l'écriture d'un classificateur d'apprentissage en profondeur de qualité recherche pour le cancer du sein aux réseaux d'apprentissage en profondeur qui "hallucinent", vous enseignant les principes et la théorie par le biais de travaux pratiques, vous équipant du savoir-faire et outils pour devenir un expert dans l'application de l'apprentissage profond pour résoudre la vision par ordinateur.

Qu'est-ce qu'il y a à l'intérieur?

• Les premiers principes de la vision et comment apprendre aux ordinateurs à « voir »
• Différentes tâches et applications de la vision par ordinateur
• Les outils du métier qui faciliteront votre travail
• Trouver, créer et utiliser des ensembles de données pour la vision par ordinateur
• La théorie et l'application des réseaux de neurones convolutifs
• Gestion du changement de domaine, de la cooccurrence et d'autres biais dans les ensembles de données
• Transférer Apprendre et utiliser le temps de formation et les ressources informatiques des autres à votre avantage
• Construire et former un classificateur de pointe du cancer du sein
• Comment appliquer une bonne dose de scepticisme aux idées dominantes et comprendre les implications des techniques largement adoptées
• Visualiser « l'espace conceptuel » d'un ConvNet à l'aide de t-SNE et PCA
• Études de cas sur la façon dont les entreprises utilisent les techniques de vision par ordinateur pour obtenir de meilleurs résultats
• Évaluation appropriée du modèle, visualisation de l'espace latent et identification de l'attention du modèle
• Effectuer des recherches de domaine, traiter vos propres ensembles de données et établir des tests de modèles
• Les architectures de pointe, la progression des idées, ce qui les rend uniques et comment les mettre en œuvre
• KerasCV - une bibliothèque WIP pour créer des pipelines et des modèles de pointe
• Comment analyser et lire des articles et les mettre en œuvre vous-même
• Sélection de modèles en fonction de votre application
• Création d'un pipeline d'apprentissage automatique de bout en bout
• Paysage et intuition sur la détection d'objets avec Faster R-CNN, RetinaNets, SSD et YOLO
• Instance et segmentation sémantique
• Reconnaissance d'objets en temps réel avec YOLOv5
• Formation aux détecteurs d'objets YOLOv5
• Travailler avec des transformateurs à l'aide de KerasNLP (bibliothèque WIP de pointe)
• Intégration de Transformers avec ConvNets pour générer des légendes d'images
• Rêve profond
• Optimisation du modèle de Deep Learning pour la vision par ordinateur