Previeni l'overfitting e aumenta la precisione del tuo modello di machine learning implementando i metodi di aumento dei dati di TensorFlow.

L'aumento dei dati è il processo di applicazione di varie trasformazioni ai dati di addestramento. Aiuta ad aumentare la diversità del set di dati e prevenire l'overfitting. L'overfitting si verifica principalmente quando si dispone di dati limitati per addestrare il modello.

Qui imparerai come utilizzare il modulo di aumento dei dati di TensorFlow per diversificare il tuo set di dati. Ciò impedirà l'overfitting generando nuovi punti dati leggermente diversi dai dati originali.

Il set di dati di esempio che utilizzerai

Utilizzerai il set di dati di cani e gatti da Kaggle. Questo set di dati contiene circa 3.000 immagini di cani e gatti. Queste immagini sono suddivise in set di addestramento, test e convalida.

L'etichetta 1.0 rappresenta un cane mentre l'etichetta 0.0 rappresenta un gatto.

Il codice sorgente completo che implementa le tecniche di aumento dei dati e quello che non lo è è disponibile in a Deposito GitHub.

instagram viewer

Installazione e importazione di TensorFlow

Per seguire, dovresti avere a conoscenza di base di Python. Dovresti anche avere una conoscenza di base dell'apprendimento automatico. Se hai bisogno di un ripasso, potresti prendere in considerazione l'idea di seguirne alcuni tutorial sull'apprendimento automatico.

Aprire Google Colab. Cambia il tipo di runtime in GPU. Quindi, esegui il seguente comando magico sulla prima cella di codice per installare TensorFlow nel tuo ambiente.

!pip installa tensorflow

Importa TensorFlow e i relativi moduli e classi.

importare tensorflow COME tf
da tensorflow.keras.preprocessing.image importare ImageDataGenerator
da tensorflow.keras.models importare Sequenziale
da tensorflow.keras.layers importare Conv2D, MaxPooling2D, Flatten, Dense, Dropout

IL tensorflow.keras.preprocessing.image ti consentirà di eseguire l'aumento dei dati sul tuo set di dati.

Creazione di istanze della classe ImageDataGenerator

Crea un'istanza di ImageDataGenerator classe per i dati del treno. Utilizzerai questo oggetto per la pre-elaborazione dei dati di addestramento. Genererà batch di dati immagine aumentati in tempo reale durante l'addestramento del modello.

Nel compito di classificare se un'immagine è un gatto o un cane, è possibile utilizzare le tecniche di aumento dei dati di capovolgimento, larghezza casuale, altezza casuale, luminosità casuale e zoom. Queste tecniche genereranno nuovi dati che contengono variazioni dei dati originali che rappresentano scenari del mondo reale.

# definire il generatore di dati immagine per l'addestramento
train_datagen = ImageDataGenerator (rescale=1./255,
 capovolgimento_orizzontale=VERO,
 width_shift_range=0.2,
 height_shift_range=0.2,
 intervallo_luminosità=[0.2,1.0],
 zoom_range=0.2)

Crea un'altra istanza di ImageDataGenerator classe per i dati di test. Avrai bisogno del riscalare parametro. Normalizzerà i valori dei pixel delle immagini di prova in modo che corrispondano al formato utilizzato durante l'addestramento.

# definisce il generatore di dati immagine per il test
test_datagen = ImageDataGenerator (rescale=1./255)

Creare un'ultima istanza di ImageDataGenerator classe per i dati di convalida. Ridimensionare i dati di convalida allo stesso modo dei dati di test.

# definisce il generatore di dati immagine per la validazione
validation_datagen = ImageDataGenerator (rescale=1./255)

Non è necessario applicare le altre tecniche di aumento ai dati di test e convalida. Questo perché il modello utilizza i dati di test e convalida solo a scopo di valutazione. Dovrebbero riflettere la distribuzione originale dei dati.

Caricamento dei dati

Creare un DirectoryIterator oggetto dalla directory di formazione. Genererà lotti di immagini aumentate. Quindi specificare la directory in cui sono archiviati i dati di addestramento. Ridimensiona le immagini a una dimensione fissa di 64x64 pixel. Specificare il numero di immagini che ogni batch utilizzerà. Infine, specificare il tipo di etichetta da utilizzare binario (cioè, gatto o cane).

# definizione della directory di addestramento
train_data = train_datagen.flow_from_directory (directory=r'/content/drive/MyDrive/cats_and_dogs_filtered/train',
 dimensione_obiettivo=(64, 64),
 batch_size=32,
 class_mode='binario')

Creane un altro DirectoryIterator oggetto dalla directory testing. Impostare i parametri sugli stessi valori di quelli dei dati di addestramento.

# definizione della directory di test
test_data = test_datagen.flow_from_directory (directory='/content/drive/MyDrive/cats_and_dogs_filtered/test',
 dimensione_obiettivo=(64, 64),
 batch_size=32,
 class_mode='binario')

Crea una finale DirectoryIterator oggetto dalla directory di convalida. I parametri rimangono gli stessi di quelli dei dati di addestramento e test.

# definizione della directory di convalida
validation_data = validation_datagen.flow_from_directory (directory='/content/drive/MyDrive/cats_and_dogs_filtered/convalida',
 dimensione_obiettivo=(64, 64),
 batch_size=32,
 class_mode='binario')

Gli iteratori di directory non aumentano i set di dati di convalida e test.

Definire il tuo modello

Definisci l'architettura della tua rete neurale. Usare un Rete neurale convoluzionale (CNN). Le CNN sono progettate per riconoscere modelli e caratteristiche nelle immagini.

modello = Sequenziale()
# strato convoluzionale con 32 filtri di dimensione 3x3
modello.add (Conv2D(32, (3, 3), attivazione='rilu', input_shape=(64, 64, 3))) 


# strato di pooling massimo con dimensioni del pool 2x2
model.add (MaxPooling2D(pool_size=(2, 2))) 


# strato convoluzionale con 64 filtri di dimensione 3x3
modello.add (Conv2D(64, (3, 3), attivazione='rilu'))


# strato di pooling massimo con dimensioni del pool 2x2 
model.add (MaxPooling2D(pool_size=(2, 2))) 


# appiattisce l'output dai livelli convoluzionale e di raggruppamento
model.add (Appiattisci()) 


# layer completamente connesso con 128 unità e attivazione ReLU
model.add (Dense(128, attivazione='rilu')) 


# Elimina casualmente il 50% delle unità per evitare l'overfitting
model.add (Eliminazione(0.5)) 
# livello di output con attivazione sigmoidea (classificazione binaria)
model.add (Dense(1, attivazione='sigmoideo'))

Compilare il modello utilizzando il binario entropia incrociata funzione di perdita. I problemi di classificazione binaria usano comunemente It. Per l'ottimizzatore, utilizzare il Ottimizzatore Adam. È un algoritmo di ottimizzazione del tasso di apprendimento adattivo. Infine, valutare il modello in termini di accuratezza.

modello.compile (perdita='binary_crossentropy', ottimizzatore='Adamo', metriche=['precisione'])

Stampa un riepilogo dell'architettura del modello sulla console.

modello.summary()

Lo screenshot seguente mostra la visualizzazione dell'architettura del modello.

Questo ti dà una panoramica di come appare il design del tuo modello.

Allenare il tuo modello

Addestrare il modello utilizzando il adatto() metodo. Impostare il numero di passaggi per epoca in modo che sia il numero di campioni di addestramento diviso per dimensione del lotto. Inoltre, impostare i dati di convalida e il numero di passaggi di convalida.

# Addestra il modello sui dati di addestramento
storia = model.fit (train_data,
 steps_per_epoch=train_data.n // train_data.batch_size,
 epoche=50,
 validation_data=validation_data,
 validation_steps=validation_data.n // validation_data.batch_size)

IL ImageDataGenerator la classe applica l'aumento dei dati ai dati di addestramento in tempo reale. Ciò rallenta il processo di addestramento del modello.

Valutazione del tuo modello

Valuta le prestazioni del tuo modello sui dati di test utilizzando il file valutare() metodo. Inoltre, stampa la perdita e l'accuratezza del test sulla console.

test_loss, test_acc = model.evaluate (test_data,
 steps=test_data.n // test_data.batch_size)
stampa(f'Test perdita: {prova_perdita}')
stampa(f'Accuratezza del test: {test_acc}')

Lo screenshot seguente mostra le prestazioni del modello.

Il modello funziona ragionevolmente bene su dati mai visti.

Quando si esegue codice che non implementa le tecniche di aumento dei dati, l'accuratezza dell'addestramento del modello è 1. Il che significa che si adatta troppo. Funziona male anche su dati che non ha mai visto prima. Questo perché apprende le peculiarità del set di dati.

Quando il Data Augmentation non è utile?

  • Quando il set di dati è già vario e ampio: l'aumento dei dati aumenta le dimensioni e la diversità di un set di dati. Se il set di dati è già ampio e diversificato, l'aumento dei dati non sarà utile.
  • Quando il set di dati è troppo piccolo: l'aumento dei dati non può creare nuove funzionalità che non sono presenti nel set di dati originale. Pertanto, non può compensare un piccolo set di dati privo della maggior parte delle funzionalità che il modello richiede per apprendere.
  • Quando il tipo di aumento dei dati non è appropriato: Ad esempio, la rotazione delle immagini potrebbe non essere utile quando l'orientamento degli oggetti è importante.

Di cosa è capace TensorFlow

TensorFlow è una libreria diversificata e potente. È in grado di addestrare complessi modelli di deep learning e può essere eseguito su una vasta gamma di dispositivi, dagli smartphone ai cluster di server. Ha aiutato a potenziare i dispositivi di edge computing che utilizzano l'apprendimento automatico.