RandAugment til billedklassificering med Keras/TensorFlow

Dataforøgelse har i lang tid tjent som et middel til at erstatte et "statisk" datasæt med transformerede varianter, hvilket forstærker invariansen af Convolutional Neural Networks (CNN'er), og fører normalt til robusthed til input.

Mens dataforøgelse i den form, som vi har brugt det, koder for en manglende viden om translationel varians, som er vigtig for objektdetektion, semantisk og instanssegmentering osv. – invarians det giver, er ofte gunstigt for klassifikationsmodeller, og derfor er augmentation mere almindeligt og mere aggressivt anvendt på klassifikationsmodeller.

Typer af Augmentation

Augmentation begyndte at være meget simpelt – små rotationer, vandrette og lodrette vendinger, kontrast- eller lysstyrkeudsving osv. I de senere år er der blevet udtænkt mere omfattende metoder, bl.a. Skåret ud (rumligt udfald, der introducerer sorte firkanter tilfældigt i inputbillederne) og Bland op (blanding af dele af billeder og opdatering af etiketproportioner) og deres kombination – CutMix. De nyere forstærkningsmetoder tager faktisk højde for etiketter, og metoder som CutMix ændrer etiketproportionerne til at være lig med proportionerne af billedet, der optages af dele af hver klasse, der blandes sammen.

Med en voksende liste over mulige forstørrelser er nogle begyndt at anvende dem tilfældigt (eller i det mindste en delmængde af dem) med tanken om, at et tilfældigt sæt forstørrelser vil styrke modellernes robusthed og erstatte det originale sæt med et meget større sæt. plads til inputbilleder. Det er her RandAugment slår ind!

KerasCV og RandAugment

KerasCV er en separat pakke, men stadig en officiel tilføjelse til Keras, udviklet af Keras-teamet. Det betyder, at den får den samme mængde polering og intuitivitet som hovedpakken, men den integreres også uden problemer med almindelige Keras-modeller og deres lag. Den eneste forskel, du nogensinde vil bemærke, er at ringe keras_cv.layers... i stedet for keras.layers....

KerasCV er stadig under udvikling i skrivende stund og inkluderer allerede 27 nye forbehandlingslag, RandAugment, CutMixog MixUp være nogle af dem. Lad os tage et kig på, hvordan det ser ud at anvende RandAugment til billeder, og hvordan vi kan træne en klassifikator med og uden tilfældig forstærkning.

Installer først keras_cv:

$ pip install keras_cv

Lad os nu importere TensorFlow, Keras og KerasCV sammen med TensorFlow-datasæt for nem adgang til Imagenette:

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

Lad os indlæse et billede og vise det i dets originale form:

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)

Lad os nu ansøge RandAugment til det, flere gange, og tag et kig på resultaterne:

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

Laget har en magnitude argument, som som standard er 0.5 og kan ændres for at øge eller mindske effekten af ​​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'))

Når den er sat til en lav værdi som f.eks 0.1 – du vil se meget mindre aggressiv forstærkning:

At være et lag – det kan bruges i modeller eller i tf.data pipelines, mens du opretter datasæt. Dette gør RandAugment ret fleksibelt! Yderligere argumenter er augmentations_per_image , rate argumenter, som virker sammen.

Til 0...augmentations_per_image, tilføjer laget et tilfældigt forbehandlingslag til pipelinen, der skal påføres et billede. I tilfælde af standard 3 – tre forskellige operationer føjes til rørledningen. Derefter udtages et tilfældigt tal for hver forøgelse i pipelinen – og hvis det er lavere end rate (standard til omkring 0.9) – forøgelsen anvendes.

I bund og grund – der er 90 % sandsynlighed for, at hver (tilfældig) forøgelse i pipelinen bliver anvendt på billedet.

Det betyder naturligvis, at ikke alle forstørrelser skal anvendes, især hvis du sænker rate. Du kan også tilpasse, hvilke operationer der er tilladt gennem en RandomAugmentationPipeline lag, hvilket RandAugment er det særlige tilfælde af. En særskilt vejledning vedr RandomAugmentationPipeline vil snart blive offentliggjort.

Træning af en Classifier med og uden RandAugment

For at forenkle dataforberedelse/indlæsningsaspektet og fokusere på RandAugment, lad os bruge tfds for at indlæse i en del af 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)) 

Vi har kun indlæst en del af træningsdataene for at gøre det nemmere at overfitte datasættet i færre epoker (få vores eksperiment til at køre hurtigere, faktisk). Da billederne i Imagenette er af forskellige størrelser, lad os oprette en preprocess() funktion, der ændrer størrelsen på dem til at kortlægge datasættet med, samt en augment() funktion, der forstærker billeder i en 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 – vi one-hot-kodede etiketterne. Det behøvede vi ikke nødvendigvis, men til forstørrelser som f.eks CutMix at tukle med etiketter og deres proportioner, bliver du nødt til. Da du måske ønsker at anvende dem også RandAugment fungerer rigtig godt sammen med dem til at skabe robuste klassificeringer – lad os lade den ene-hot-kodning være i. Derudover, RandAugment tager i en ordbog med billeder og etiketter netop på grund af dette – nogle forstørrelser, som du kan tilføje, vil faktisk ændre etiketterne, så de er obligatoriske. Du kan udtrække de udvidede billeder og etiketter fra outputs ordbog nemt, så dette er et ekstra, men alligevel enkelt, skridt at tage under forstørrelse.

Lad os kortlægge de eksisterende datasæt, der returneres fra tfds med preprocess() funktion, batch dem og forstærk kun træningssættet:

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)

Lad os træne et netværk! keras_cv.models har nogle indbyggede netværk, svarende til keras.applications. Selvom listen stadig er kort – vil den udvide sig med tiden og tage over keras.applications. API'et er meget ens, så portering af kode vil være ret let for de fleste praktiserende læger:

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)

Alternativt kan du bruge den nuværende 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)

Dette resulterer i en model, der ikke rigtig klarer sig super godt:

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

Lad os nu træne den samme netværksopsætning på det udvidede datasæt. Hver batch er individuelt udvidet, så hver gang den samme batch billeder (i den næste epoke) kommer rundt – vil de have forskellige forstørrelser:

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

Meget bedre! Mens du stadig ønsker at anvende andre forstørrelser, som f.eks CutMix , MixUp, sammen med andre træningsteknikker for at maksimere netværkets nøjagtighed – bare RandAugment markant hjulpet og kan sammenlignes med en længere forstærkningspipeline.

Hvis man sammenligner træningskurverne, inklusive træningen , valideringskurver – det bliver først tydeligt hvor meget RandAugment hjælper:

I den ikke-augmenterede pipeline passer netværket over (træningsnøjagtigheden rammer loftet), og valideringsnøjagtigheden forbliver lav. I den udvidede pipeline er træningsnøjagtigheden forbliver lavere end valideringsnøjagtigheden fra start til slut.

Med et højere træningstab er netværket meget mere bevidst om de fejl, det stadig laver, og der kan foretages flere opdateringer for at gøre det uforanderligt i forhold til transformationerne. Førstnævnte ser ingen grund til at opdatere, mens sidstnævnte gør og hæver loftet over potentialet.

Konklusion

KerasCV er en separat pakke, men stadig en officiel tilføjelse til Keras, udviklet af Keras-teamet, med det formål at bringe branchestærkt CV til dine Keras-projekter. KerasCV er stadig under udvikling i skrivende stund og inkluderer allerede 27 nye forbehandlingslag, RandAugment, CutMixog MixUp være nogle af dem.

I denne korte guide har vi taget et kig på, hvordan du kan bruge RandAugment at anvende et antal tilfældige transformationer fra en given liste over anvendte transformationer, og hvor let det er at inkludere i enhver Keras træningspipeline.

Gå videre – Praktisk dyb læring til computersyn

Din nysgerrige natur giver dig lyst til at gå længere? Vi anbefaler at tjekke vores Kursus: "Praktisk dyb læring til computersyn med Python".

Endnu et kursus i computersyn?

Vi laver ikke klassificering af MNIST-cifre eller MNIST-mode. De tjente deres del for længe siden. For mange læringsressourcer fokuserer på grundlæggende datasæt og grundlæggende arkitekturer, før de lader avancerede black-box-arkitekturer bære byrden af ​​ydeevne.

Vi ønsker at fokusere på afmystificering, praktisk, forståelse, intuition , rigtige projekter. Vil gerne lære hvordan kan du gøre en forskel? Vi tager dig med på en tur fra den måde, vores hjerner behandler billeder på, til at skrive en deep learning-klassificerer for brystkræft i forskningsklasse til deep learning-netværk, der "hallucinerer", lærer dig principperne og teorien gennem praktisk arbejde, og udstyrer dig med knowhow og værktøjer til at blive ekspert i at anvende dyb læring til at løse computervision.

Hvad er der indenfor?

• De første principper for vision og hvordan computere kan læres at "se"
• Forskellige opgaver og anvendelser af computersyn
• Branchens værktøjer, der vil gøre dit arbejde lettere
• Finde, skabe og bruge datasæt til computervision
• Teorien og anvendelsen af ​​​​konvolutionelle neurale netværk
• Håndtering af domæneskift, samtidige forekomster og andre skævheder i datasæt
• Overfør Læring og udnyttelse af andres træningstid og beregningsressourcer til din fordel
• Opbygning og træning af en avanceret brystkræftklassificering
• Hvordan man anvender en sund dosis skepsis til mainstream ideer og forstår implikationerne af vidt anvendte teknikker
• Visualisering af et ConvNets "konceptrum" ved hjælp af t-SNE og PCA
• Casestudier af, hvordan virksomheder bruger computervisionsteknikker til at opnå bedre resultater
• Korrekt modelevaluering, latent rumvisualisering og identifikation af modellens opmærksomhed
• Udførelse af domæneforskning, bearbejdning af dine egne datasæt og etablering af modeltest
• Banebrydende arkitekturer, udviklingen af ​​ideer, hvad der gør dem unikke, og hvordan man implementerer dem
• KerasCV – et WIP-bibliotek til at skabe state of the art pipelines og modeller
• Hvordan man analyserer og læser papirer og implementerer dem selv
• Valg af modeller afhængigt af din applikation
• Oprettelse af en end-to-end machine learning pipeline
• Landskab og intuition på objektdetektion med hurtigere R-CNN'er, RetinaNets, SSD'er og YOLO
• Forekomst og semantisk segmentering
• Objektgenkendelse i realtid med YOLOv5
• Træning af YOLOv5 objektdetektorer
• Arbejde med transformere ved hjælp af KerasNLP (industristærkt WIP-bibliotek)
• Integrering af transformere med ConvNets for at generere billedtekster
• Deepdream
• Deep Learning model optimering til computer vision