RandAugment pentru clasificarea imaginilor cu Keras/TensorFlow

Mărirea datelor a servit, de mult timp, ca mijloc de înlocuire a unui set de date „static” cu variante transformate, întărind invarianța Rețele neuronale convoluționale (CNN), și de obicei conduc la robustețe la intrare.

În timp ce creșterea datelor în forma în care am folosit-o codifică a lipsă de cunoștințe despre varianța translațională, care este importantă pentru detectarea obiectelor, segmentarea semantică și a instanțelor etc. – invarianta acesta oferă este adesea favorabil pentru modelele de clasificare și, prin urmare, augmentarea este mai frecvent și mai agresiv aplicată modelelor de clasificare.

Tipuri de amplificare

Mărirea a început să fie foarte simplă – rotații mici, răsturnări orizontale și verticale, fluctuații de contrast sau luminozitate etc. În ultimii ani, au fost concepute metode mai elaborate, inclusiv Elimina (abandon spațial introducând pătrate negre aleatoriu în imaginile de intrare) și MixUp (amestecarea unor părți ale imaginilor și actualizarea proporțiilor etichetelor) și combinarea lor - CutMix. Metodele mai noi de mărire țin cont de etichete, iar metode precum CutMix modifică proporțiile etichetelor pentru a fi egale cu proporțiile imaginii preluate de părțile fiecărei clase care sunt amestecate.

Cu o listă tot mai mare de posibile creșteri, unii au început să le aplice aleatoriu (sau cel puțin un subset dintre ele), cu ideea că un set aleatoriu de creșteri va spori robustețea modelelor și va înlocui setul original cu un set mult mai mare. spațiul imaginilor de intrare. Aici e locul RandAugment dă cu piciorul!

KerasCV și RandAugment

KerasCV este un pachet separat, dar încă un plus oficial la Keras, dezvoltat de echipa Keras. Aceasta înseamnă că primește aceeași cantitate de lustruire și intuitivitate ca pachetul principal, dar se integrează și cu modelele Keras obișnuite și cu straturile lor. Singura diferență pe care o vei observa este să apelezi keras_cv.layers... în loc de keras.layers....

KerasCV este încă în dezvoltare la momentul scrierii și include deja 27 de noi straturi de preprocesare, RandAugment, CutMix, și MixUp fiind unii dintre ei. Să aruncăm o privire la cum arată să aplici RandAugment la imagini și cum putem antrena un clasificator cu și fără mărire aleatorie.

Mai întâi, instalați keras_cv:

$ pip install keras_cv

Acum, să importăm TensorFlow, Keras și KerasCV, împreună cu seturile de date TensorFlow pentru acces ușor la Imagenette:

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

Să încărcăm o imagine și să o afișăm în forma sa originală:

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)

Acum, să aplicăm RandAugment la acesta, de mai multe ori și aruncați o privire la rezultate:

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

Stratul are a magnitude argument, care este implicit 0.5 și poate fi modificată pentru a crește sau a reduce efectul de augmentare:

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

Când este setată la o valoare scăzută, cum ar fi 0.1 – veți vedea o creștere mult mai puțin agresivă:

Fiind un strat – poate fi folosit în cadrul modelelor sau în tf.data conducte în timp ce creați seturi de date. Asta face RandAugment destul de flexibil! Argumente suplimentare sunt augmentations_per_image și rate argumente, care lucrează împreună.

Pentru 0...augmentations_per_image, stratul adaugă un strat de preprocesare aleatoriu la conductă pentru a fi aplicat unei imagini. În cazul implicit 3 – trei operațiuni diferite sunt adăugate la conductă. Apoi, un număr aleatoriu este eșantionat pentru fiecare creștere din conductă – și dacă este mai mic decât rate (implicit la aproximativ 0.9) – se aplică mărirea.

În esență – există o probabilitate de 90% ca fiecare creștere (aleatorie) din conductă să fie aplicată imaginii.

Acest lucru înseamnă în mod natural că nu trebuie aplicate toate măririle, mai ales dacă coborâți rate. De asemenea, puteți personaliza ce operațiuni sunt permise prin a RandomAugmentationPipeline strat, care RandAugment este cazul special al. Un ghid separat despre RandomAugmentationPipeline va fi publicat în curând.

Antrenarea unui clasificator cu și fără RandAugment

Pentru a simplifica aspectul de pregătire/încărcare a datelor și pentru a se concentra asupra RandAugment, să folosim tfds pentru a încărca o porțiune din Imageette:

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

Am încărcat doar o parte din datele de antrenament, pentru a ușura supraadaptarea setului de date în mai puține epoci (făcând experimentul nostru să ruleze mai rapid, de fapt). Deoarece imaginile din Imagenette sunt de dimensiuni diferite, să creăm un preprocess() funcție care le redimensionează pentru a mapa setul de date cu, precum și un augment() funcție care mărește imaginile în 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']

Acum, am codificat etichetele. Nu trebuia neapărat, dar pentru măriri de genul CutMix că modificați etichetele și proporțiile acestora, va trebui. Deoarece s-ar putea să doriți să le aplicați la fel de bine și RandAugment funcționează foarte bine cu ele pentru a crea clasificatoare robuste – să lăsăm codificarea one-fierbinte. În plus, RandAugment preia un dicționar cu imagini și etichete exact din acest motiv – unele îmbunătățiri pe care le puteți adăuga vor schimba de fapt etichetele, deci sunt obligatorii. Puteți extrage imaginile augmentate și etichetele din outputs dicționar cu ușurință, deci acesta este un pas suplimentar, dar simplu, de făcut în timpul creșterii.

Să mapam seturile de date existente returnate de la tfds cu preprocess() funcția, grupați-le și creșteți numai setul de antrenament:

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)

Să antrenăm o rețea! keras_cv.models are unele rețele încorporate, similare cu keras.applications. Deși lista este încă scurtă - se va extinde în timp și va prelua keras.applications. API-ul este foarte asemănător, așa că portarea codului va fi destul de ușoară pentru majoritatea practicanților:

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)

Alternativ, puteți utiliza curentul 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)

Rezultă un model care nu se descurcă foarte bine:

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

Acum, să antrenăm aceeași configurație de rețea pe setul de date augmentat. Fiecare lot este mărit individual, așa că ori de câte ori apare același lot de imagini (în epoca următoare) - vor avea diferite creșteri:

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

Mult mai bine! Deși ați dori totuși să aplicați alte creșteri, cum ar fi CutMix și MixUp, alături de alte tehnici de antrenament pentru a maximiza acuratețea rețelei – doar RandAugment ajutat în mod semnificativ și poate fi comparabil cu o conductă mai lungă de creștere.

Dacă comparați curbele de antrenament, inclusiv antrenamentul și curbe de validare – devine clar doar cât RandAugment ajută:

În conducta neamplificată, rețeaua se supraajustează (precizia antrenamentului atinge plafonul), iar acuratețea validării rămâne scăzută. În conducta augmentată, precizia antrenamentului rămâne mai mică decât acuratețea validării de la început până la sfârșit.

Cu o pierdere de antrenament mai mare, rețeaua este mult mai conștientă de greșelile pe care le face și mai multe actualizări pot fi făcute pentru a o face invariabilă la transformări. Primul nu vede nevoia să se actualizeze, în timp ce cel din urmă face și ridică plafonul potențialului.

Concluzie

KerasCV este un pachet separat, dar totuși o completare oficială la Keras, dezvoltat de echipa Keras, menit să aducă un CV puternic în industrie pentru proiectele dumneavoastră Keras. KerasCV este încă în dezvoltare la momentul scrierii și include deja 27 de noi straturi de preprocesare, RandAugment, CutMix, și MixUp fiind unii dintre ei.

În acest scurt ghid, am aruncat o privire asupra modului în care puteți utiliza RandAugment pentru a aplica un număr de transformări aleatorii dintr-o listă dată de transformări aplicate și cât de ușor este să le includă în orice canal de antrenament Keras.

Mergând mai departe – Învățare profundă practică pentru viziunea computerizată

Natura ta curios te face să vrei să mergi mai departe? Vă recomandăm să verificați Curs: „Învățare profundă practică pentru viziunea computerizată cu Python”.

Un alt curs de Computer Vision?

Nu vom face clasificarea cifrelor MNIST sau a modei MNIST. Și-au servit rolul cu mult timp în urmă. Prea multe resurse de învățare se concentrează pe seturile de date de bază și pe arhitecturile de bază înainte de a lăsa arhitecturile avansate de tip cutie neagră să asume povara performanței.

Vrem să ne concentrăm asupra demistificare, practic, înţelegere, intuiţie și proiecte reale. Vreau sa invat cum poți face o diferență? Vă vom duce într-o plimbare de la modul în care creierul nostru procesează imaginile până la scrierea unui clasificator de învățare profundă de nivel de cercetare pentru cancerul de sân la rețele de învățare profundă care „halucinează”, învățându-vă principiile și teoria prin muncă practică, echipându-vă cu know-how și instrumente pentru a deveni un expert în aplicarea învățării profunde pentru a rezolva viziunea computerizată.

Ce e inauntru?

• Primele principii ale vederii și modul în care computerele pot fi învățate să „vadă”
• Diferite sarcini și aplicații ale vederii computerizate
• Instrumentele meseriei care vă vor ușura munca
• Găsirea, crearea și utilizarea seturilor de date pentru viziune computerizată
• Teoria și aplicarea rețelelor neuronale convoluționale
• Gestionarea deplasării de domeniu, apariției concomitente și a altor părtiniri în seturile de date
• Transfer Învățați și utilizați timpul de instruire și resursele de calcul ale altora în beneficiul dumneavoastră
• Construirea și formarea unui clasificator de ultimă generație pentru cancerul de sân
• Cum să aplicați o doză sănătoasă de scepticism ideilor principale și să înțelegeți implicațiile tehnicilor adoptate pe scară largă
• Vizualizarea unui „spațiu conceptual” al unui ConvNet folosind t-SNE și PCA
• Studii de caz despre modul în care companiile folosesc tehnicile de viziune computerizată pentru a obține rezultate mai bune
• Evaluarea corectă a modelului, vizualizarea spațiului latent și identificarea atenției modelului
• Efectuarea cercetărilor de domeniu, procesarea propriilor seturi de date și stabilirea de teste de model
• Arhitecturi de ultimă oră, progresul ideilor, ce le face unice și cum să le implementăm
• KerasCV – o bibliotecă WIP pentru crearea de conducte și modele de ultimă generație
• Cum să analizați și să citiți lucrările și să le implementați singur
• Selectarea modelelor în funcție de aplicația dvs
• Crearea unui canal de învățare automată de la capăt la capăt
• Peisaj și intuiție în detectarea obiectelor cu R-CNN-uri mai rapide, RetinaNets, SSD-uri și YOLO
• Instanță și segmentare semantică
• Recunoașterea obiectelor în timp real cu YOLOv5
• Instruirea detectoarelor de obiecte YOLOv5
• Lucrul cu Transformers folosind KerasNLP (bibliotecă WIP puternică în industrie)
• Integrarea Transformers cu ConvNets pentru a genera subtitrări ale imaginilor
• Deepdream
• Optimizarea modelului de Deep Learning pentru viziunea computerizată