RandAugment for bildeklassifisering med Keras/TensorFlow

Dataforsterkning har i lang tid fungert som et middel til å erstatte et "statisk" datasett med transformerte varianter, noe som forsterker invariansen av Konvolusjonelle nevrale nettverk (CNN), og fører vanligvis til robusthet til input.

Mens dataforstørrelse i den formen vi har brukt, koder den for en mangel kunnskap om translasjonsvarians, som er viktig for objektdeteksjon, semantikk og instanssegmentering osv. – invarians det gir er ofte gunstig for klassifiseringsmodeller, og dermed blir utvidelse mer vanlig og mer aggressivt brukt på klassifiseringsmodeller.

Typer forsterkning

Augmentering begynte å være veldig enkelt – små rotasjoner, horisontale og vertikale vendinger, kontrast- eller lysstyrkefluktuasjoner osv. De siste årene har det blitt utviklet mer forseggjorte metoder, bl.a. Skjære ut (romlig frafall som introduserer svarte firkanter tilfeldig i inngangsbildene) og Blande (blanding av deler av bilder og oppdatering av etikettproporsjoner), og deres kombinasjon – CutMix. De nyere utvidelsesmetodene tar faktisk hensyn til etiketter, og metoder som CutMix endrer etikettproporsjonene til å være lik proporsjonene av bildet tatt opp av deler av hver klasse som blandes sammen.

Med en voksende liste over mulige utvidelser, har noen begynt å bruke dem tilfeldig (eller i det minste en delmengde av dem), med ideen om at et tilfeldig sett med utvidelser vil styrke robustheten til modellene, og erstatte det originale settet med et mye større plass med inndatabilder. Dette er hvor RandAugment slår inn!

KerasCV og RandAugment

KerasCV er en egen pakke, men fortsatt et offisielt tillegg til Keras, utviklet av Keras-teamet. Dette betyr at den får samme mengde polering og intuitivitet som hovedpakken, men den integreres også uten problemer med vanlige Keras-modeller og deres lag. Den eneste forskjellen du noen gang vil legge merke til er å ringe keras_cv.layers... istedenfor keras.layers....

KerasCV er fortsatt under utvikling i skrivende stund, og inkluderer allerede 27 nye forbehandlingslag, RandAugment, CutMixog MixUp være noen av dem. La oss ta en titt på hvordan det ser ut å søke RandAugment til bilder, og hvordan vi kan trene en klassifiserer med og uten tilfeldig forsterkning.

Installer først keras_cv:

$ pip install keras_cv

La oss nå importere TensorFlow, Keras og KerasCV, sammen med TensorFlow-datasett for enkel tilgang til Imagenette:

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

La oss laste inn et bilde og vise det i sin opprinnelige 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)

Nå, la oss søke RandAugment til den, flere ganger og ta en titt på resultatene:

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 er standard 0.5 og kan endres for å øke eller redusere effekten av forsterkning:

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 satt til en lav verdi som f.eks 0.1 – du vil se mye mindre aggressiv forsterkning:

Å være et lag – det kan brukes i modeller eller i tf.data rørledninger mens du oppretter datasett. Dette gjør RandAugment ganske fleksibel! Ytterligere argumenter er augmentations_per_image og rate argumenter som fungerer sammen.

Til 0...augmentations_per_image, legger laget til et tilfeldig forbehandlingslag til rørledningen som skal brukes på et bilde. I tilfelle av standard 3 – tre ulike operasjoner legges til rørledningen. Deretter blir et tilfeldig antall samplet for hver utvidelse i rørledningen – og hvis det er lavere enn rate (standard til rundt 0.9) – utvidelsen brukes.

I hovedsak – det er 90 % sannsynlighet for at hver (tilfeldig) utvidelse i rørledningen blir brukt på bildet.

Dette betyr naturligvis at ikke alle utvidelser må brukes, spesielt hvis du senker rate. Du kan også tilpasse hvilke operasjoner som er tillatt gjennom en RandomAugmentationPipeline lag, som RandAugment er det spesielle tilfellet av. En egen veiledning på RandomAugmentationPipeline vil bli publisert snart.

Trening av en klassifiserer med og uten RandAugment

For å forenkle dataforberedelse/lastingsaspektet og fokusere på RandAugment, la oss bruke tfds for å laste inn en del av 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 bare lastet inn en del av treningsdataene for å gjøre det lettere å overtilpasse datasettet i færre epoker (få eksperimentet vårt til å kjøre raskere, faktisk). Siden bildene i Imagenette er av forskjellige størrelser, la oss lage en preprocess() funksjon som endrer størrelsen på dem for å kartlegge datasettet med, samt en augment() funksjon som forsterker bilder 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']

Nå – vi one-hot-kodet etikettene. Vi trengte ikke nødvendigvis, men for utvidelser som CutMix som tukler med etiketter og deres proporsjoner, må du. Siden du kanskje vil bruke dem også RandAugment fungerer veldig bra med dem for å lage robuste klassifiseringer – la oss la den ene-hot-kodingen være inne. I tillegg, RandAugment tar inn en ordbok med bilder og etiketter akkurat på grunn av dette – noen utvidelser som du kan legge til vil faktisk endre etikettene, så de er obligatoriske. Du kan trekke ut de utvidede bildene og etikettene fra outputs ordbok enkelt, så dette er et ekstra, men likevel enkelt, trinn å ta under utvidelse.

La oss kartlegge eksisterende datasett returnert fra tfds med preprocess() funksjon, batch dem og forsterk bare treningssettet:

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)

La oss trene et nettverk! keras_cv.models har noen innebygde nettverk, lik keras.applications. Selv om listen fortsatt er kort – vil den utvide seg over tid og ta over keras.applications. API-en er veldig lik, så porteringskoden vil være ganske enkel for de fleste utøvere:

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 bruke strømmen 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 modell som egentlig ikke gjør det superbra:

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

La oss nå trene det samme nettverksoppsettet på det utvidede datasettet. Hver batch er individuelt utvidet, så hver gang samme gruppe bilder (i neste epoke) kommer – vil de ha forskjellige utvidelser:

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

Mye bedre! Mens du fortsatt ønsker å bruke andre utvidelser, for eksempel CutMix og MixUp, sammen med andre treningsteknikker for å maksimere nettverkets nøyaktighet – bare RandAugment betydelig hjulpet og kan sammenlignes med en lengre utvidelsesrørledning.

Hvis du sammenligner treningskurvene, inkludert treningen og valideringskurver – det blir først klart hvor mye RandAugment hjelper:

I den ikke-utvidede rørledningen overpasser nettverket (treningsnøyaktigheten når taket) og valideringsnøyaktigheten forblir lav. I den utvidede rørledningen er treningsnøyaktigheten forblir lavere enn valideringsnøyaktigheten fra start til slutt.

Med et høyere treningstap er nettverket mye mer bevisst på feilene det fortsatt gjør, og flere oppdateringer kan gjøres for å gjøre det invariant i forhold til transformasjonene. Førstnevnte ser ikke noe behov for å oppdatere, mens sistnevnte gjør det og hever taket av potensial.

konklusjonen

KerasCV er en egen pakke, men fortsatt et offisielt tillegg til Keras, utviklet av Keras-teamet, med sikte på å bringe bransjestyrke CV til Keras-prosjektene dine. KerasCV er fortsatt under utvikling i skrivende stund, og inkluderer allerede 27 nye forbehandlingslag, RandAugment, CutMixog MixUp være noen av dem.

I denne korte veiledningen har vi tatt en titt på hvordan du kan bruke RandAugment å bruke et antall tilfeldige transformasjoner fra en gitt liste over anvendte transformasjoner, og hvor enkelt det er å inkludere i en hvilken som helst Keras treningspipeline.

Gå videre – praktisk dyp læring for datasyn

Din nysgjerrige natur gjør at du ønsker å gå lenger? Vi anbefaler å sjekke ut vår Kurs: "Praktisk dyplæring for datasyn med Python".

Et annet datasynskurs?

Vi kommer ikke til å klassifisere MNIST-sifre eller MNIST-mote. De tjente sin del for lenge siden. For mange læringsressurser fokuserer på grunnleggende datasett og grunnleggende arkitekturer før de lar avanserte svartboksarkitekturer bære byrden av ytelse.

Vi ønsker å fokusere på avmystifisering, praktisk, forståelse, intuisjon og ekte prosjekter. Vil lære hvordan du kan gjøre en forskjell? Vi tar deg med på en tur fra måten hjernen vår behandler bilder på til å skrive en dyplæringsklassifiser for brystkreft til dyplæringsnettverk som "hallusinerer", lærer deg prinsippene og teorien gjennom praktisk arbeid, og utstyrer deg med kunnskap og verktøy for å bli en ekspert på å bruke dyp læring for å løse datasyn.

Hva er inni?

• De første prinsippene for visjon og hvordan datamaskiner kan læres å "se"
• Ulike oppgaver og anvendelser av datasyn
• Verktøyene i bransjen som vil gjøre arbeidet ditt enklere
• Finne, lage og bruke datasett for datasyn
• Teorien og anvendelsen av konvolusjonelle nevrale nettverk
• Håndtering av domeneskift, samtidig forekomst og andre skjevheter i datasett
• Overfør Læring og bruk av andres treningstid og beregningsressurser til din fordel
• Bygge og trene en toppmoderne brystkreftklassifiser
• Hvordan bruke en sunn dose skepsis til mainstream ideer og forstå implikasjonene av vidt vedtatte teknikker
• Visualisere et ConvNets "konseptrom" ved hjelp av t-SNE og PCA
• Kasusstudier av hvordan bedrifter bruker datasynsteknikker for å oppnå bedre resultater
• Riktig modellevaluering, latent romvisualisering og identifisering av modellens oppmerksomhet
• Utføre domeneforskning, behandle egne datasett og etablere modelltester
• Nyskapende arkitekturer, utviklingen av ideer, hva som gjør dem unike og hvordan de implementeres
• KerasCV – et WIP-bibliotek for å lage toppmoderne rørledninger og modeller
• Hvordan analysere og lese artikler og implementere dem selv
• Velge modeller avhengig av din applikasjon
• Opprette en ende-til-ende maskinlæringspipeline
• Landskap og intuisjon på objektdeteksjon med raskere R-CNN, RetinaNets, SSD og YOLO
• Forekomst og semantisk segmentering
• Objektgjenkjenning i sanntid med YOLOv5
• Trening av YOLOv5-objektdetektorer
• Arbeide med transformatorer ved å bruke KerasNLP (bransjesterkt WIP-bibliotek)
• Integrering av transformatorer med ConvNets for å generere bildetekster
• Deepdream
• Deep Learning-modelloptimalisering for datasyn