RandAugment voor beeldclassificatie met Keras/TensorFlow

Gegevensvergroting heeft lange tijd gediend als een middel om een ​​"statische" dataset te vervangen door getransformeerde varianten, waardoor de onveranderlijkheid van Convolutionele neurale netwerken (CNN's), en leidt meestal tot robuustheid van de invoer.

Hoewel gegevensvergroting in de vorm die we hebben gebruikt, codeert a gebrek van kennis over translationele variantie, die belangrijk is voor objectdetectie, semantische en instantiesegmentatie, enz. - de onveranderlijkheid het zorgt ervoor dat het vaak gunstig is voor classificatiemodellen, en dus wordt augmentatie vaker en agressiever toegepast op classificatiemodellen.

Soorten augmentatie

Augmentatie begon heel eenvoudig te worden - kleine rotaties, horizontale en verticale schommelingen, contrast- of helderheidsfluctuaties, enz. In de afgelopen jaren zijn meer uitgebreide methoden bedacht, waaronder Uitknippen (ruimtelijke drop-out die willekeurig zwarte vierkanten introduceert in de invoerafbeeldingen) en Door elkaar halen (delen van afbeeldingen door elkaar halen en labelverhoudingen bijwerken), en hun combinatie - SnijMix. De nieuwere augmentatiemethoden houden feitelijk rekening met labels, en methoden zoals CutMix veranderen de labelverhoudingen zodat deze gelijk zijn aan de verhoudingen van de afbeelding die worden ingenomen door delen van elke klasse die worden verwisseld.

Met een groeiende lijst van mogelijke augmentaties, zijn sommigen begonnen deze willekeurig toe te passen (of in ieder geval een deel ervan), met het idee dat een willekeurige set augmentaties de robuustheid van modellen zal versterken en de originele set zal vervangen door een veel grotere ruimte van invoerbeelden. Dit is waar RandAugment begint te werken!

KerasCV en RandAugment

KerasCV is een apart pakket, maar nog steeds een officiële toevoeging aan Keras, ontwikkeld door het Keras-team. Dit betekent dat het dezelfde hoeveelheid glans en intuïtiviteit krijgt als het hoofdpakket, maar het integreert ook naadloos met reguliere Keras-modellen en hun lagen. Het enige verschil dat je ooit zult merken, is bellen keras_cv.layers... in plaats van keras.layers....

KerasCV is op het moment van schrijven nog in ontwikkeling en bevat al 27 nieuwe voorbewerkingslagen, RandAugment, CutMix en MixUp sommigen van hen zijn. Laten we eens kijken hoe het eruit ziet om te solliciteren RandAugment naar afbeeldingen, en hoe we een classifier kunnen trainen met en zonder willekeurige augmentatie.

Installeer eerst keras_cv:

$ pip install keras_cv

Laten we nu TensorFlow, Keras en KerasCV importeren, samen met de TensorFlow-datasets voor gemakkelijke toegang tot Imagenette:

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

Laten we een afbeelding laden en deze in zijn oorspronkelijke vorm weergeven:

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)

Laten we nu solliciteren RandAugment meerdere keren en bekijk de resultaten:

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

De laag heeft een magnitude argument, dat standaard is 0.5 en kan worden gewijzigd om het effect van augmentatie te vergroten of te verkleinen:

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

Indien ingesteld op een lage waarde zoals: 0.1 - je zult veel minder agressieve augmentatie zien:

Omdat het een laag is, kan het worden gebruikt in modellen of in tf.data pijplijnen tijdens het maken van datasets. Dit maakt RandAugment lekker flexibel! Bijkomende argumenten zijn de augmentations_per_image en rate argumenten die samenwerken.

Voor 0...augmentations_per_image, voegt de laag een willekeurige voorbewerkingslaag toe aan de pijplijn die op een afbeelding moet worden toegepast. In het geval van de standaard 3 – er worden drie verschillende operaties aan de pijplijn toegevoegd. Vervolgens wordt een willekeurig getal bemonsterd voor elke augmentatie in de pijplijn - en als het lager is dan rate (standaard ingesteld op rond) 0.9) – de vergroting wordt toegepast.

In wezen is er een kans van 90% dat elke (willekeurige) vergroting in de pijplijn wordt toegepast op de afbeelding.

Dit betekent natuurlijk dat niet alle augmentaties toegepast hoeven te worden, zeker niet als je de rate. U kunt ook aanpassen welke bewerkingen zijn toegestaan ​​via a RandomAugmentationPipeline laag, die RandAugment is het speciale geval van. Een aparte gids over RandomAugmentationPipeline wordt binnenkort gepubliceerd.

Een classifier trainen met en zonder RandAugment

Om het aspect gegevensvoorbereiding/laden te vereenvoudigen en erop te focussen: RandAugment, laten we gebruiken tfds om een ​​deel van Imagenette in te laden:

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

We hebben slechts een deel van de trainingsgegevens geladen om het gemakkelijker te maken om de gegevensset in minder tijdvakken te overfitten (waardoor ons experiment in feite sneller wordt uitgevoerd). Aangezien de afbeeldingen in Imagenette verschillende formaten hebben, maken we een preprocess() functie die de grootte ervan aanpast om de dataset in kaart te brengen, evenals een augment() functie die afbeeldingen vergroot in a 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']

Nu - we hebben de labels one-hot gecodeerd. We hoefden niet per se, maar voor augmentaties zoals CutMix dat knoeien met labels en hun verhoudingen, je zult moeten. Omdat je die misschien net zo goed wilt toepassen als RandAugment werkt heel goed met hen om robuuste classificaties te maken - laten we de one-hot codering erin laten. Bovendien, RandAugment neemt juist daarom een ​​woordenboek met afbeeldingen en labels in beslag - sommige augmentaties die u kunt toevoegen, zullen de labels daadwerkelijk veranderen, dus ze zijn verplicht. U kunt de vergrote afbeeldingen en labels extraheren uit de outputs woordenboek gemakkelijk, dus dit is een extra, maar eenvoudige stap die u tijdens augmentatie moet nemen.

Laten we de bestaande datasets in kaart brengen die zijn geretourneerd uit tfds met de preprocess() functie, batch ze en vergroot alleen de trainingsset:

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)

Laten we een netwerk trainen! keras_cv.models heeft een aantal ingebouwde netwerken, vergelijkbaar met: keras.applications. Hoewel de lijst nog steeds kort is, zal deze in de loop van de tijd uitbreiden en het overnemen keras.applications. De API lijkt erg op elkaar, dus het overzetten van code zal voor de meeste beoefenaars vrij eenvoudig zijn:

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)

Als alternatief kunt u de huidige 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)

Dit resulteert in een model dat het niet echt super goed doet:

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

Laten we nu dezelfde netwerkconfiguratie trainen op de uitgebreide dataset. Elke batch wordt individueel uitgebreid, dus wanneer dezelfde batch afbeeldingen (in het volgende tijdperk) rondkomt, hebben ze verschillende augmentaties:

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

Veel beter! Terwijl u nog steeds andere verbeteringen wilt toepassen, zoals: CutMix en MixUp, naast andere trainingstechnieken om de nauwkeurigheid van het netwerk te maximaliseren - gewoon RandAugment aanzienlijk geholpen en kan vergelijkbaar zijn met een langere augmentatiepijplijn.

Als je de trainingscurves vergelijkt, inclusief de training en validatiecurves - het wordt pas duidelijk hoeveel RandAugment helpt:

In de niet-verbeterde pijplijn overfits het netwerk (trainingsnauwkeurigheid bereikt plafond) en blijft de validatienauwkeurigheid laag. In de uitgebreide pijplijn, de trainingsnauwkeurigheid blijft van begin tot eind lager dan de validatienauwkeurigheid.

Met een hoger trainingsverlies is het netwerk zich veel meer bewust van de fouten die het nog maakt en kunnen er meer updates worden gedaan om het invariant te maken voor de transformaties. De eerste ziet geen noodzaak om te updaten, terwijl de laatste het wel doet en het plafond van het potentieel verhoogt.

Conclusie

KerasCV is een apart pakket, maar nog steeds een officiële toevoeging aan Keras, ontwikkeld door het Keras-team, gericht op het brengen van industrie-sterke CV naar uw Keras-projecten. KerasCV is op het moment van schrijven nog in ontwikkeling en bevat al 27 nieuwe voorbewerkingslagen, RandAugment, CutMix en MixUp sommigen van hen zijn.

In deze korte handleiding hebben we bekeken hoe u kunt gebruiken RandAugment om een ​​aantal willekeurige transformaties uit een gegeven lijst van toegepaste transformaties toe te passen, en hoe gemakkelijk het is om het in een Keras-trainingspijplijn op te nemen.

Verder gaan - Praktisch diep leren voor computervisie

Je leergierige karakter maakt dat je verder wilt gaan? We raden aan om onze Type cursus: "Praktisch diep leren voor computervisie met Python".

Nog een cursus computervisie?

We zullen geen classificatie van MNIST-cijfers of MNIST-mode doen. Ze hebben lang geleden hun deel gediend. Te veel leermiddelen zijn gericht op basisgegevenssets en basisarchitecturen voordat geavanceerde black-box-architecturen de last van de prestaties op zich nemen.

We willen ons concentreren op demystificatie, uitvoerbaarheid, begrip, intuïtie en echte projecten. Willen leren hoe je kan een verschil maken? We nemen je mee op een reis van de manier waarop onze hersenen afbeeldingen verwerken tot het schrijven van een onderzoeksclassificatie voor diep leren voor borstkanker tot diepgaande leernetwerken die 'hallucineren', je de principes en theorie leren door middel van praktisch werk, en je uitrusten met de knowhow en tools om een ​​expert te worden in het toepassen van deep learning om computervisie op te lossen.

Wat zit erin?

• De eerste principes van visie en hoe computers kunnen worden geleerd om te "zien"
• Verschillende taken en toepassingen van computervisie
• De tools van het vak die uw werk gemakkelijker maken
• Datasets zoeken, maken en gebruiken voor computervisie
• De theorie en toepassing van convolutionele neurale netwerken
• Omgaan met domeinverschuiving, gelijktijdig voorkomen en andere vooroordelen in datasets
• Overdragen Leren en de trainingstijd en computerbronnen van anderen gebruiken in uw voordeel
• Het bouwen en trainen van een state-of-the-art classifier voor borstkanker
• Hoe je een gezonde dosis scepsis toepast op mainstream ideeën en de implicaties begrijpt van algemeen aanvaarde technieken?
• De "conceptruimte" van een ConvNet visualiseren met t-SNE en PCA
• Casestudy's van hoe bedrijven computervisietechnieken gebruiken om betere resultaten te behalen
• Correcte modelevaluatie, visualisatie van de latente ruimte en het identificeren van de aandacht van het model
• Domeinonderzoek doen, eigen datasets verwerken en modeltesten opzetten
• Geavanceerde architecturen, de voortgang van ideeën, wat ze uniek maakt en hoe ze te implementeren
• KerasCV – een WIP-bibliotheek voor het maken van ultramoderne pijplijnen en modellen
• Hoe papers te ontleden en te lezen en ze zelf te implementeren?
• Modellen selecteren afhankelijk van uw toepassing
• Een end-to-end machine learning-pijplijn maken
• Landschap en intuïtie bij objectdetectie met snellere R-CNN's, RetinaNets, SSD's en YOLO
• Instantie en semantische segmentatie
• Realtime objectherkenning met YOLOv5
• YOLOv5-objectdetectoren trainen
• Werken met Transformers met KerasNLP (industriële WIP-bibliotheek)
• Transformers integreren met ConvNets om bijschriften van afbeeldingen te genereren
• DeepDream
• Optimalisatie van Deep Learning-modellen voor computervisie