RandAugment för bildklassificering med Keras/TensorFlow

Dataökning har under lång tid fungerat som ett sätt att ersätta en "statisk" datauppsättning med transformerade varianter, vilket stärker invariansen av Convolutional Neural Networks (CNN), och leder vanligtvis till robusthet för indata.

Medan dataökning i den form vi har använt det kodar en Bristen kunskap om translationell varians, vilket är viktigt för objektdetektering, semantisk och instanssegmentering etc. – invarians det ger är ofta gynnsamt för klassificeringsmodeller, och sålunda är förstärkning vanligare och mer aggressivt tillämpad på klassificeringsmodeller.

Typer av förstärkning

Augmentation började vara väldigt enkelt – små rotationer, horisontella och vertikala vändningar, kontrast- eller ljusstyrkefluktuationer etc. På senare år har mer genomarbetade metoder utarbetats, bl.a. Skära ut (spatialt bortfall som introducerar svarta rutor slumpmässigt i ingångsbilderna) och Blanda (blandning av delar av bilder och uppdatering av etikettproportioner) och deras kombination – CutMix. De nyare förstärkningsmetoderna står faktiskt för etiketter, och metoder som CutMix ändrar etikettproportionerna till att vara lika med proportionerna av bilden som tas upp av delar av varje klass som blandas ihop.

Med en växande lista över möjliga förstärkningar har vissa börjat tillämpa dem slumpmässigt (eller åtminstone någon delmängd av dem), med tanken att en slumpmässig uppsättning förstärkningar kommer att stärka modellernas robusthet och ersätta originaluppsättningen med en mycket större utrymme för ingående bilder. Det är här RandAugment slår in!

KerasCV och RandAugment

KerasCV är ett separat paket, men fortfarande ett officiellt tillägg till Keras, utvecklat av Keras-teamet. Detta innebär att den får samma mängd polering och intuitivitet som huvudpaketet, men den integreras också skenbart med vanliga Keras-modeller och deras lager. Den enda skillnaden du någonsin kommer att märka är att ringa keras_cv.layers... istället för keras.layers....

KerasCV är fortfarande under utveckling när det skrivs och inkluderar redan 27 nya förbearbetningslager, RandAugment, CutMixoch MixUp vara några av dem. Låt oss ta en titt på hur det ser ut att ansöka RandAugment till bilder, och hur vi kan träna en klassificerare med och utan slumpmässig förstärkning.

Installera först keras_cv:

$ pip install keras_cv

Låt oss nu importera TensorFlow, Keras och KerasCV, tillsammans med TensorFlow-datauppsättningar för enkel åtkomst till Imagenette:

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

Låt oss ladda in en bild och visa den i dess ursprungliga 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)

Nu, låt oss ansöka RandAugment till den, flera gånger och ta en titt på resultatet:

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

Skiktet har en magnitude argument, som är standard 0.5 och kan ändras för att öka eller minska effekten av 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 inställt på ett lågt värde som t.ex 0.1 – du kommer att se mycket mindre aggressiv förstärkning:

Att vara ett lager – det kan användas inom modeller eller i tf.data pipelines när du skapar datauppsättningar. Detta gör RandAugment ganska smidigt! Ytterligare argument är augmentations_per_image och rate argument som samverkar.

För 0...augmentations_per_image, lägger lagret till ett slumpmässigt förbearbetningslager till pipelinen som ska appliceras på en bild. När det gäller standard 3 – tre olika operationer läggs till pipelinen. Sedan samplas ett slumpmässigt antal för varje förstärkning i pipeline – och om det är lägre än rate (standard till runt 0.9) – förstärkningen tillämpas.

I huvudsak – det är 90 % sannolikhet att varje (slumpmässig) förstärkning i pipelinen kommer att tillämpas på bilden.

Detta innebär naturligtvis att inte alla förstärkningar måste tillämpas, speciellt om du sänker rate. Du kan också anpassa vilka operationer som är tillåtna genom en RandomAugmentationPipeline lager, vilket RandAugment är specialfallet av. En separat guide på RandomAugmentationPipeline kommer att publiceras snart.

Att träna en klassificerare med och utan RandAugment

För att förenkla dataförberedelse/laddningsaspekten och fokusera på RandAugment, låt oss använda tfds för att ladda i 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 bara laddat in en del av träningsdatan för att göra det enklare att överanpassa datamängden under färre epoker (så att vårt experiment går snabbare, faktiskt). Eftersom bilderna i Imagenette är av olika storlekar, låt oss skapa en preprocess() funktion som ändrar storlek på dem för att mappa datamängden med, samt en augment() funktion som utökar 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']

Nu – vi one-hot-kodade etiketterna. Vi behövde inte nödvändigtvis, men för förstärkningar som CutMix att manipulera etiketter och deras proportioner, du måste. Eftersom du kanske vill tillämpa dem också RandAugment fungerar riktigt bra med dem för att skapa robusta klassificerare – låt oss lämna den enkla kodningen i. Dessutom, RandAugment tar in en ordbok med bilder och etiketter precis på grund av detta – vissa tillägg som du kan lägga till kommer faktiskt att ändra etiketterna, så de är obligatoriska. Du kan extrahera de utökade bilderna och etiketterna från outputs ordbok enkelt, så detta är ett extra, men ändå enkelt, steg att ta under förstärkningen.

Låt oss kartlägga de befintliga datamängder som returneras från tfds med preprocess() funktion, batch dem och utöka endast träningsuppsättningen:

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)

Låt oss träna ett nätverk! keras_cv.models har några inbyggda nätverk, liknande keras.applications. Även om listan fortfarande är kort – kommer den att utökas med tiden och ta över keras.applications. API:t är väldigt lika, så portering av kod kommer att vara ganska lätt för de flesta utövare:

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 använda 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)

Detta resulterar i en modell som inte riktigt går 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

Låt oss nu träna samma nätverksinställningar på den utökade datamängden. Varje batch utökas individuellt, så varje gång samma serie bilder (i nästa epok) dyker upp – kommer de att ha olika förstoringar:

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

Mycket bättre! Medan du fortfarande vill använda andra förstärkningar, som t.ex CutMix och MixUp, tillsammans med andra träningstekniker för att maximera nätverkets noggrannhet – bara RandAugment avsevärt hjälpt och kan jämföras med en längre förstärkningspipeline.

Om man jämför träningskurvorna inklusive träningen och valideringskurvor – det blir bara tydligt hur mycket RandAugment hjälper:

I den icke-augmenterade pipelinen överpassar nätverket (träningsnoggrannheten når taket) och valideringsnoggrannheten förblir låg. I den utökade pipeline, den träningsnoggrannheten förblir lägre än valideringsnoggrannheten från början till slut.

Med en högre träningsförlust är nätverket mycket mer medvetet om de misstag det fortfarande gör, och fler uppdateringar kan göras för att göra det oföränderligt för transformationerna. Den förra ser inget behov av att uppdatera, medan den senare gör det och höjer taket för potential.

Slutsats

KerasCV är ett separat paket, men fortfarande ett officiellt tillägg till Keras, utvecklat av Keras-teamet, som syftar till att ge branschstarka CV till dina Keras-projekt. KerasCV är fortfarande under utveckling när det skrivs och inkluderar redan 27 nya förbearbetningslager, RandAugment, CutMixoch MixUp vara några av dem.

I den här korta guiden har vi tagit en titt på hur du kan använda RandAugment att tillämpa ett antal slumpmässiga transformationer från en given lista med tillämpade transformationer, och hur lätt det är att inkludera i någon Keras träningspipeline.

Going Further – Praktisk djupinlärning för datorseende

Din nyfikna natur gör att du vill gå längre? Vi rekommenderar att du kollar in vår Kurs: "Praktisk djupinlärning för datorseende med Python".

Ännu en kurs i datorseende?

Vi kommer inte att göra klassificering av MNIST-siffror eller MNIST-mode. De tjänade sin del för länge sedan. Alltför många inlärningsresurser fokuserar på grundläggande datamängder och grundläggande arkitekturer innan de låter avancerade blackbox-arkitekturer bära bördan av prestanda.

Vi vill fokusera på avmystifiering, praktiskhet, förståelse, intuition och riktiga projekt. Vill lära sig hur du kan göra skillnad? Vi tar dig med på en tur från hur våra hjärnor bearbetar bilder till att skriva en klassificerare för djupinlärning för bröstcancer i forskningsklass till nätverk för djupinlärning som "hallucinerar", lär dig principer och teorier genom praktiskt arbete, och utrustar dig med kunskap och verktyg för att bli expert på att tillämpa djupinlärning för att lösa datorseende.

Vad är inuti?

• De första principerna för syn och hur datorer kan läras att "se"
• Olika uppgifter och tillämpningar av datorseende
• Branschens verktyg som gör ditt arbete enklare
• Hitta, skapa och använda datauppsättningar för datorseende
• Teorin och tillämpningen av Convolutional Neural Networks
• Hantera domänskifte, samtidig förekomst och andra fördomar i datamängder
• Överför Lärande och utnyttja andras träningstid och beräkningsresurser till din fördel
• Bygga och träna en toppmodern klassificerare för bröstcancer
• Hur man applicerar en hälsosam dos av skepsis på mainstream idéer och förstår implikationerna av allmänt använda tekniker
• Visualisera ett ConvNets "konceptutrymme" med t-SNE och PCA
• Fallstudier av hur företag använder datorseendetekniker för att uppnå bättre resultat
• Korrekt modellutvärdering, latent rumsvisualisering och identifiering av modellens uppmärksamhet
• Utföra domänforskning, bearbeta dina egna datamängder och upprätta modelltester
• Banbrytande arkitekturer, utvecklingen av idéer, vad som gör dem unika och hur man implementerar dem
• KerasCV – ett WIP-bibliotek för att skapa toppmoderna pipelines och modeller
• Hur man analyserar och läser uppsatser och implementerar dem själv
• Välja modeller beroende på din applikation
• Skapa en komplett maskininlärningspipeline
• Landskap och intuition på objektdetektering med snabbare R-CNN, RetinaNets, SSD och YOLO
• Instans och semantisk segmentering
• Objektigenkänning i realtid med YOLOv5
• Träning av YOLOv5-objektdetektorer
• Arbeta med transformatorer med KerasNLP (industristarkt WIP-bibliotek)
• Integrering av Transformers med ConvNets för att generera bildtexter
• DeepDream
• Deep Learning-modelloptimering för datorseende