RandAugment per la classificazione delle immagini con Keras/TensorFlow

L'aumento dei dati è servito da molto tempo come mezzo per sostituire un set di dati "statico" con varianti trasformate, rafforzando l'invarianza di Reti neurali convoluzionali (CNN), e di solito porta alla robustezza dell'input.

Mentre l'aumento dei dati nella forma che abbiamo utilizzato, codifica a mancanza di conoscenza sulla varianza traslazionale, che è importante per il rilevamento di oggetti, la segmentazione semantica e di istanza, ecc. – il invarianza fornisce spesso è favorevole per i modelli di classificazione e, quindi, l'aumento è applicato più comunemente e in modo più aggressivo ai modelli di classificazione.

Tipi di potenziamento

L'aumento ha iniziato ad essere molto semplice: piccole rotazioni, capovolgimenti orizzontali e verticali, fluttuazioni di contrasto o luminosità, ecc. Negli ultimi anni sono stati ideati metodi più elaborati, tra cui Ritagliare (dropout spaziale che introduce casualmente quadrati neri nelle immagini di input) e Mischiare (mescolare parti di immagini e aggiornare le proporzioni dell'etichetta) e la loro combinazione – Taglia Mix. I metodi di potenziamento più recenti tengono conto effettivamente delle etichette e metodi come CutMix modificano le proporzioni dell'etichetta in modo che siano uguali alle proporzioni dell'immagine occupata da parti di ciascuna classe confuse.

Con un elenco crescente di possibili potenziamenti, alcuni hanno iniziato ad applicarli casualmente (o almeno alcuni sottoinsiemi di essi), con l'idea che un insieme casuale di potenziamenti rafforzerà la robustezza dei modelli e sostituirà il set originale con un insieme molto più grande spazio delle immagini in ingresso. Qui è dove RandAugment butta dentro!

KerasCV e RandAugment

Keras CV è un pacchetto separato, ma è ancora un'aggiunta ufficiale a Keras, sviluppato dal team Keras. Ciò significa che ottiene la stessa quantità di lucidità e intuitività del pacchetto principale, ma si integra anche in modo apparente con i normali modelli Keras e i loro livelli. L'unica differenza che noterai mai è chiamare keras_cv.layers... invece di keras.layers....

KerasCV è ancora in fase di sviluppo al momento della scrittura e include già 27 nuovi livelli di preelaborazione, RandAugment, CutMixe MixUp essere alcuni di loro. Diamo un'occhiata a come si presenta l'applicazione RandAugment alle immagini e come possiamo addestrare un classificatore con e senza aumento casuale.

Innanzitutto, installa keras_cv:

$ pip install keras_cv

Ora importiamo TensorFlow, Keras e KerasCV, insieme ai set di dati TensorFlow per un facile accesso a Imagenette:

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

Carichiamo un'immagine e la visualizziamo nella sua forma originale:

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)

Ora, applichiamo RandAugment ad esso, più volte e dai un'occhiata ai risultati:

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

Lo strato ha a magnitude argomento, che per impostazione predefinita è 0.5 e può essere modificato per aumentare o diminuire l'effetto dell'aumento:

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

Quando è impostato su un valore basso come 0.1 – vedrai un aumento molto meno aggressivo:

Essendo un livello, può essere utilizzato all'interno di modelli o in tf.data pipeline durante la creazione di set di dati. Questo fa RandAugment abbastanza flessibile! Ulteriori argomenti sono il augmentations_per_image ed rate argomentazioni, che funzionano insieme.

Nel 0...augmentations_per_image, il livello aggiunge un livello di preelaborazione casuale alla pipeline da applicare a un'immagine. In caso di inadempimento 3 – alla pipeline vengono aggiunte tre diverse operazioni. Quindi, viene campionato un numero casuale per ogni potenziamento nella pipeline e se è inferiore a rate (predefinito intorno 0.9) – si applica l'aumento.

In sostanza, c'è una probabilità del 90% che ogni aumento (casuale) nella pipeline venga applicato all'immagine.

Ciò significa naturalmente che non tutti gli aumenti devono essere applicati, soprattutto se si abbassa il rate. Puoi anche personalizzare quali operazioni sono consentite tramite a RandomAugmentationPipeline strato, che RandAugment è il caso speciale di. Una guida separata su RandomAugmentationPipeline sarà pubblicato a breve.

Addestrare un classificatore con e senza RandAugment

Per semplificare l'aspetto della preparazione/caricamento dei dati e concentrarsi su RandAugment, usiamo tfds per caricare in una porzione di 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)) 

Abbiamo caricato solo una parte dei dati di addestramento, per semplificare l'overfit del set di dati in meno epoche (rendendo il nostro esperimento più veloce, in effetti). Poiché le immagini in Imagenette sono di dimensioni diverse, creiamo un file preprocess() funzione che li ridimensiona per mappare il set di dati, oltre a un augment() funzione che aumenta le immagini 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']

Ora, abbiamo codificato le etichette. Non dovevamo necessariamente, ma per potenziamenti come CutMix che manomettere le etichette e le loro proporzioni, dovrai farlo. Dal momento che potresti voler applicare anche quelli RandAugment funziona molto bene con loro per creare classificatori robusti: lasciamo la codifica one-hot. Inoltre, RandAugment accetta un dizionario con immagini ed etichette proprio per questo motivo: alcuni miglioramenti che puoi aggiungere cambieranno effettivamente le etichette, quindi sono obbligatorie. Puoi estrarre le immagini e le etichette aumentate dal file outputs dizionario facilmente, quindi questo è un passaggio extra, ma semplice, da compiere durante l'aumento.

Mappiamo i set di dati esistenti restituiti da tfds con la preprocess() funzione, raggruppali e aumenta solo il set di allenamento:

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)

Formiamo una rete! keras_cv.models ha alcune reti integrate, simili a keras.applications. Mentre l'elenco è ancora breve, si espanderà nel tempo e prenderà il sopravvento keras.applications. L'API è molto simile, quindi il porting del codice sarà abbastanza semplice per la maggior parte dei professionisti:

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)

In alternativa, puoi usare la corrente 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)

Ciò si traduce in un modello che non funziona molto bene:

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

Ora, addestriamo la stessa configurazione di rete sul set di dati aumentato. Ogni batch viene aumentato individualmente, quindi ogni volta che lo stesso batch di immagini (nell'epoca successiva) si presenta, avranno diversi aumenti:

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

Molto meglio! Mentre vorresti ancora applicare altri aumenti, come CutMix ed MixUp, insieme ad altre tecniche di formazione per massimizzare l'accuratezza della rete – just RandAugment ha aiutato in modo significativo e può essere paragonabile a una pipeline di potenziamento più lunga.

Se si confrontano le curve di allenamento, compreso l'allenamento ed curve di convalida: diventa chiaro solo quanto RandAugment aiuta:

Nella pipeline non potenziata, la rete si sovraadatta (l'accuratezza della formazione raggiunge il limite massimo) e l'accuratezza della convalida rimane bassa. Nella pipeline aumentata, il l'accuratezza dell'allenamento rimane inferiore all'accuratezza della convalida dall'inizio alla fine.

Con una perdita di allenamento maggiore, la rete è molto più consapevole degli errori che fa ancora e possono essere apportati più aggiornamenti per renderla invariante alle trasformazioni. Il primo non vede la necessità di aggiornare, mentre il secondo lo fa e alza il tetto del potenziale.

Conclusione

Keras CV è un pacchetto separato, ma è ancora un'aggiunta ufficiale a Keras, sviluppato dal team Keras, volto a portare CV di forza del settore ai tuoi progetti Keras. KerasCV è ancora in fase di sviluppo al momento della scrittura e include già 27 nuovi livelli di preelaborazione, RandAugment, CutMixe MixUp essere alcuni di loro.

In questa breve guida, abbiamo dato un'occhiata a come puoi usare RandAugment per applicare una serie di trasformazioni casuali da un determinato elenco di trasformazioni applicate e quanto sia facile includerle in qualsiasi pipeline di formazione Keras.

Andare oltre - Apprendimento profondo pratico per la visione artificiale

La tua natura curiosa ti fa venire voglia di andare oltre? Ti consigliamo di dare un'occhiata al nostro Portata: "Apprendimento profondo pratico per la visione artificiale con Python".

Un altro corso di visione artificiale?

Non faremo la classificazione delle cifre MNIST o della moda MNIST. Hanno servito la loro parte molto tempo fa. Troppe risorse di apprendimento si stanno concentrando su set di dati di base e architetture di base prima di lasciare che le architetture black-box avanzate si assumano il peso delle prestazioni.

Vogliamo concentrarci demistificazione, praticità, e una comprensione reciproca, intuizione ed progetti reali. Vuoi imparare come Puoi fare la differenza? Ti porteremo in un viaggio dal modo in cui il nostro cervello elabora le immagini alla scrittura di un classificatore di apprendimento profondo per la ricerca per il cancro al seno alle reti di apprendimento profondo che "allucinano", insegnandoti i principi e la teoria attraverso il lavoro pratico, fornendoti il know-how e strumenti per diventare un esperto nell'applicazione del deep learning per risolvere la visione artificiale.

Cosa c'è dentro?

• I primi principi della visione e come si può insegnare ai computer a "vedere"
• Diversi compiti e applicazioni della visione artificiale
• Gli strumenti del mestiere che ti semplificheranno il lavoro
• Trovare, creare e utilizzare set di dati per la visione artificiale
• La teoria e l'applicazione delle reti neurali convoluzionali
• Gestione del cambio di dominio, della co-occorrenza e di altri pregiudizi nei set di dati
• Trasferisci l'apprendimento e utilizza il tempo di formazione e le risorse di calcolo degli altri a tuo vantaggio
• Costruire e formare un classificatore di cancro al seno all'avanguardia
• Come applicare una sana dose di scetticismo alle idee tradizionali e comprendere le implicazioni delle tecniche ampiamente adottate
• Visualizzazione dello "spazio concettuale" di una ConvNet utilizzando t-SNE e PCA
• Casi di studio su come le aziende utilizzano le tecniche di visione artificiale per ottenere risultati migliori
• Valutazione corretta del modello, visualizzazione dello spazio latente e identificazione dell'attenzione del modello
• Esecuzione di ricerche di dominio, elaborazione dei propri set di dati e creazione di test di modello
• Architetture all'avanguardia, la progressione delle idee, cosa le rende uniche e come realizzarle
• KerasCV – una libreria WIP per la creazione di pipeline e modelli all'avanguardia
• Come analizzare e leggere documenti e implementarli da soli
• Selezione dei modelli in base all'applicazione
• Creazione di una pipeline di machine learning end-to-end
• Paesaggio e intuizione sul rilevamento di oggetti con R-CNN, RetinaNet, SSD e YOLO più veloci
• Istanza e segmentazione semantica
• Riconoscimento di oggetti in tempo reale con YOLOv5
• Formazione dei rilevatori di oggetti YOLOv5
• Utilizzo di Transformers tramite KerasNLP (libreria WIP di livello industriale)
• Integrazione di Transformers con ConvNets per generare didascalie di immagini
• Deepdream
• Ottimizzazione del modello di deep learning per la visione artificiale