Ricerca nel sito web

Ottimizzazione automatica degli iperparametri con Keras Tuner


Introduzione

Gli iperparametri sono configurazioni che determinano la struttura dei modelli di machine learning e ne controllano i processi di apprendimento. Non devono essere confusi con i parametri del modello (come il bias) i cui valori ottimali vengono determinati durante l’addestramento.

Gli iperparametri sono configurazioni regolabili impostate e ottimizzate manualmente per ottimizzare le prestazioni del modello. Sono parametri di primo livello i cui valori concorrono a determinare i pesi dei parametri del modello. I due tipi principali di iperparametri sono gli iperparametri del modello (come il numero e le unità degli strati) che determinano la struttura del modello e gli iperparametri dell'algoritmo (come l'algoritmo di ottimizzazione e il tasso di apprendimento), che influenzano e controllano il processo di apprendimento.

Alcuni iperparametri standard per l'addestramento delle reti neurali includono:

  1. Numero di livelli nascosti

  2. Numero di unità per i livelli nascosti

  3. Il tasso di abbandono: è possibile utilizzare un singolo modello per simulare un gran numero di architetture di rete diverse eliminando casualmente i nodi durante l'addestramento

  4. Funzione di attivazione (Relu, Sigmoid, Tanh): definisce l'output di quel nodo dato un input o un insieme di input

  5. Algoritmo di ottimizzazione (discesa del gradiente stocastico, Adam Optimizer, RMSprop, ecc.) - strumenti per aggiornare i parametri del modello e minimizzare il valore della funzione di perdita, come valutato sul set di addestramento.

  6. Funzione di perdita: una misura della bontà del modello in termini di previsione del risultato atteso

  7. Tasso di apprendimento: controlla quanto modificare il modello in risposta all'errore stimato ogni volta che i pesi del modello vengono aggiornati

  8. Numero di iterazioni di addestramento (epoche): il numero di volte in cui l'algoritmo di apprendimento funzionerà attraverso l'intero set di dati di addestramento.

  9. Dimensione batch: questo iperparametro di discesa del gradiente che controlla il numero di campioni di addestramento su cui lavorare prima che i parametri interni del modello vengano aggiornati.

Quando si creano modelli di machine learning, gli iperparametri vengono impostati per guidare il processo di training. A seconda delle prestazioni del modello dopo l'addestramento iniziale, questi valori vengono modificati ripetutamente per migliorare il modello, finché non viene scelta una combinazione di valori che produce i risultati migliori. Il processo di regolazione degli iperparametri per ottenere il giusto insieme di valori che ottimizza le prestazioni dei modelli di machine learning è noto come ottimizzazione degli iperparametri.

L'ottimizzazione degli iperparametri potrebbe essere complessa nel deep learning. Ciò è dovuto principalmente alle diverse configurazioni che devono essere impostate correttamente, alle numerose prove di riaggiustamento di questi valori per migliorare le prestazioni e agli scarsi risultati che derivano dall'impostazione di valori non ottimali per gli iperparametri. In pratica, questi valori vengono solitamente impostati e ottimizzati sulla base di alcune inferenze come i principi generali per problemi specifici (ad esempio utilizzando la funzione di attivazione softmax per la classificazione multiclasse), l'esperienza precedente derivante dalla costruzione di modelli (ad esempio riducendo progressivamente le unità degli strati nascosti di un fattore 2), conoscenza del dominio e dimensione dei dati di input (costruendo reti più semplici per set di dati più piccoli).

Anche con questa comprensione, è ancora difficile trovare valori perfetti per questi iperparametri. I professionisti spesso determinano i migliori iperparametri utilizzando un approccio per tentativi ed errori. Ciò viene fatto inizializzando i valori in base alla loro comprensione del problema, quindi regolando istintivamente i valori su diverse prove di allenamento in base alle prestazioni del modello prima di scegliere i valori finali con le migliori prestazioni per il modello.

La regolazione manuale degli iperparametri in questo modo è spesso laboriosa, dispendiosa in termini di tempo, non ottimale e inefficiente per la gestione delle risorse di elaborazione. Un approccio alternativo consiste nell'utilizzare algoritmi di ricerca iperparametrici scalabili come l'ottimizzazione bayesiana, la ricerca casuale e l'iperbanda. Keras Tuner è un framework Keras scalabile che fornisce questi algoritmi integrati per l'ottimizzazione degli iperparametri dei modelli di deep learning. Fornisce inoltre un algoritmo per l'ottimizzazione dei modelli Scikit-Learn.

In questo articolo impareremo come utilizzare varie funzioni del Keras Tuner per eseguire una ricerca automatica degli iperparametri ottimali. Il compito è utilizzare Keras Tuner per ottenere iperparametri ottimali per costruire un modello che classifichi accuratamente le immagini del set di dati CIFAR-10.

1. Configurazione

L'utilizzo di Keras Tuner richiede l'installazione dei pacchetti Tensorflow e Keras Tuner e l'importazione delle librerie richieste per la creazione del nostro modello. KerasTuner richiede Python 3.6+ e TensorFlow 2.0+. Questi sono preinstallati sulle macchine per gradienti.

# install required packages
pip install tensorflow
pip install keras_tuner
# import required packages
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import Input, Model
from tensorflow.keras.layers import Dense, Flatten, Convolution2D, BatchNormalization
from tensorflow.keras.layers import ReLU, MaxPool2D, AvgPool2D, GlobalAvgPool2D
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.utils import plot_model
import keras_tuner as kt
from sklearn.model_selection import train_test_split

2. Caricare e preparare il set di dati

Caricheremo il set di dati CIFAR-10 che contiene 50.000 immagini di addestramento e 10.000 immagini di test di 10 classi di oggetti. Puoi leggere ulteriori informazioni sul set di dati qui. Normalizziamo anche i valori dei pixel dell'immagine per avere una distribuzione dei dati simile e semplificare l'addestramento.

Una versione del set di dati preelaborata è precaricata nel modulo del set di dati Keras per un facile accesso e utilizzo.

2.1 Caricare il set di dati e normalizzare i valori dei pixel dell'immagine

# load the CIFAR-10 dataset from keras
(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()
Normalize the image pixel values
img_train = x_train.astype('float32') / 255.0
img_test = x_test.astype('float32') / 255.0
split the train data into train and validation sets
x_train, y_train, x_val, y_val = train_test_split(x_train, y_train,                                                             test_size=0.25)

3. Costruire un ipermodello

Ora che abbiamo la configurazione e preparato i nostri dati di input, possiamo costruire il nostro modello per l'hypertuning. Questo viene fatto utilizzando Keras Tuner per definire un modello di ricerca (noto come ipermodello) che viene poi passato a un tuner per l'hypertuning.

Gli ipermodelli vengono definiti creando una funzione di creazione di modelli personalizzata, utilizzando i modelli integrati o creando sottoclassi la classe Tuner per casi d'uso avanzati. Utilizzeremo i primi due approcci per creare modelli di ricerca per l'ottimizzazione automatica dei nostri iperparametri.

3.a. Utilizzo di un modello personalizzato

Per utilizzare un modello personalizzato, definiremo una funzione di costruzione del modello definendo i livelli di cui abbiamo bisogno, personalizzeremo lo spazio di ricerca per trovare i parametri migliori e definiremo un valore predefinito per gli iperparametri quando non li stiamo ottimizzando.

3.a.1 Definire una funzione di costruzione del modello

La funzione accetta un parametro (hp) che istanzia l'oggetto Hyperparameter di Keras Tuner e viene utilizzato per definire lo spazio di ricerca per i valori degli iperparametri. Inoltre compileremo e restituiremo l'ipermodello per l'uso. Utilizzeremo il modello del modello funzionale Keras per costruire il nostro modello.

# function to build an hypermodeltakes an argument from which to sample hyperparameters
def build_model(hp):
​
  inputs = Input(shape = (32, 32, 3)) #input layer
  x = inputs
​
  # iterate a number of conv blocks from min_value to max_value
  # tune the number of filters
  # choose an optimal value from min_value to max_value
  for i in range(hp.Int('conv_blocks',min_value = 3, max_value = 5, default=3)): # Int specifies the dtype of the values
    filters = hp.Int('filters_' + str(i),min_value = 32,max_value = 256, step=32)
​
    for _ in range(2):
      # define the conv, BatchNorm and activation layers for each block
      x = Convolution2D(filters, kernel_size=(3, 3), padding= 'same')(x)
      x = BatchNormalization()(x)
      x = ReLU()(x)
​
    # choose an optimal pooling type
    if hp.Choice('pooling_' + str(i), ['avg', 'max']) == 'max': # hp.Choice chooses from a list of values
        x = MaxPool2D()(x)
    else:
        x = AvgPool2D()(x)
​
  x = GlobalAvgPool2D()(x) # apply GlobalAvG Pooling
​
  # Tune the number of units in the  Dense layer
  # Choose an optimal value between min_value to max_value
  x = Dense(hp.Int('Dense units',min_value = 30, max_value = 100, step=10, default=50), activation='relu')(x)
  outputs = Dense(10, activation= 'softmax')(x) # output layer

  # define the model
  model = Model(inputs, outputs)
​
  # Tune the learning rate for the optimizer
  # Choose an optimal value frommin_value to max_value
  model.compile(optimizer= Adam(hp.Float('learning_rate', min_value = 1e-4, max_value =1e-2, sampling='log')),
                loss= 'sparse_categorical_crossentropy', metrics = ['accuracy'])
  return model
Comprensione del codice

Riga 3: Definiamo una funzione di costruzione del modello (build_model) e passiamo un parametro (hp) che istanzia l'oggetto Hyperparameter del pacchetto Keras Tuner , questo viene utilizzato per definire lo spazio di ricerca per i valori degli iperparametri.

Riga 5-6: definiamo il nostro livello di input e lo passiamo a una variabile (x)

Riga 11: definiamo uno spazio di ricerca per il numero di blocchi di convoluzione per il nostro modello. Usiamo la funzione hp.Int per creare uno spazio di ricerca di iperparametri interi. Questo crea uno spazio di ricerca da min_value + 1 a max value. Questo cercherà in uno spazio di 4 e 5 blocchi di convoluzione il valore ottimale che massimizza la precisione.

Riga 12: definiamo uno spazio di ricerca per il numero di filtri per ogni strato convoluzionale in un blocco. Un incremento di 32 aumenta le unità di filtro di 32 per i successivi strati di convoluzione.

Riga 14-24: definiamo un insieme di tre layer per ogni blocco. Ciascun sottolivello applica all'input la convoluzione, la normalizzazione batch e l'attivazione ReLU. La funzione hp.Choice per il livello di pooling sceglie casualmente uno dei pool forniti da applicare all'input. Passiamo quindi lo spazio di ricerca del filtro predefinito al livello di convoluzione.

Riga 26: Applichiamo il pooling medio globale e uno strato denso con uno spazio di ricerca da min_value a max_value e un step di 10. Definiamo anche il livello di output con un'attivazione softmax.

Riga 34-40: Infine definiamo il modello utilizzando i livelli di input e output, compiliamo il modello e restituiamo l'ipermodello costruito.

Per compilare il modello definiamo uno spazio di ricerca del tasso di apprendimento con la funzione hp.Float che crea uno spazio di ricerca da 0,0001 a 0,002 per selezionare il tasso di apprendimento ottimale.

3.a.2 Inizializzazione dell'algoritmo di ricerca (sintonizzatore)

Dopo aver costruito l'ipermodello, ora possiamo inizializzare il nostro algoritmo di ricerca.         Dovremo scegliere tra gli algoritmi di ricerca integrati, come Ottimizzazione bayesiana, Hyperband e Ricerca casuale, per i modelli classici di machine learning.

Per il nostro esempio utilizzeremo l'algoritmo di ricerca Hyperband. La funzione di sintonizzazione accetta parametri come l'ipermodello, una metrica oggettiva per valutare il modello, i max_epochs per l'addestramento, il numero di hyperband_iterations per ciascun modello e una directory per il salvataggio dei log di addestramento (che possono essere visualizzati con Tensorboard) e il project_name.

# initialize tuner to run the model.using the Hyperband search algorithm
tuner = kt.Hyperband(
    hypermodel = build_model,
    objective='val_accuracy',
    max_epochs=30,
    hyperband_iterations=2,
    directory="Keras_tuner_dir",
    project_name="Keras_tuner_Demo")

3.b. Utilizzo di modelli integrati

Keras Tuner attualmente fornisce due modelli integrati sintonizzabili, i modelli HyperResnet e HyperXception che cercano attraverso diverse combinazioni rispettivamente per le architetture Resnet e Xception.                                                   La definizione del sintonizzatore utilizzando i modelli integrati è simile all'utilizzo della funzione di creazione del modello.

# Initialize a random search tunerusing the Resnet architectureand the Random Search algorithm
tuner = kt.tuners.RandomSearch(
  kt.applications.HyperResNet(input_shape=(32, 32, 3), classes=10),
  objective='val_accuracy',
  max_trials=30)

4. Eseguire la ricerca degli iperparametri ottimali

Possiamo quindi utilizzare il nostro sintonizzatore per cercare gli iperparametri ottimali per il modello all'interno dello spazio di ricerca definito. Il metodo è simile all'adattamento di un modello utilizzando Keras.

# Run the search
tuner.search(x_train, y_train,
             validation_data= (x_test,y_test),
             epochs=30,
             callbacks=[tf.keras.callbacks.EarlyStopping(patience=2)])

5. Ottenere e visualizzare gli iperparametri e il modello ottimali

I migliori iperparametri per il modello all'interno dello spazio di ricerca definito possono essere ottenuti utilizzando il metodo get_best_hyperparameters dell'istanza del sintonizzatore e il modello migliore utilizzando il metodo get_best_models.

# Get the optimal hyperparameters
best_hps= tuner.get_best_hyperparameters(1)[0]
get the best model
best_model = tuner.get_best_models(1)[0]

Possiamo anche visualizzare i migliori iperparametri. Nel nostro esempio, possiamo ottenere questo risultato in questo modo:

nblocks = best_hps.get('conv_blocks')
print(f'Number of conv blocks: {nblocks}')
for hyparam in [f'filters_{i}' for i in range(nblocks)] + [f'pooling_{i}' for i in range(nblocks)] + ['Dense units'] + ['learning_rate']:
    print(f'{hyparam}: {best_hps.get(hyparam)}')

Vengono visualizzati i valori ottimali per il numero di blocchi di convoluzione, i filtri e le unità per i livelli di convoluzione e densi, le scelte del livello di pooling e la velocità di apprendimento.

Possiamo anche visualizzare il riepilogo e la struttura del modello ottimale utilizzando le apposite funzioni di Keras.

# display model structure
plot_model(best_model, 'best_model.png', show_shapes=True)
show model summary
best_model.summary()

6. Formazione del modello

Infine, costruiremo un modello utilizzando gli iperparametri ottimali prima di chiamare la funzione fit per addestrare il modello.

# Build the model with the optimal hyperparameterstrain the model.
model = tuner.hypermodel.build(best_hps)
model.fit(x_train, y_train,
          validation_data= (x_val,y_val),
          epochs= 25,
           callbacks=[tf.keras.callbacks.EarlyStopping(patience=5)])

Qui alleno il modello per 50 epoche e aggiungo un callback EarlyStopping per interrompere l'addestramento quando il modello non migliora più.

6. Valutare il modello

Possiamo valutare il modello sul set di test. Valuteremo il modello utilizzando la perdita e il punteggio di accuratezza del modello. Puoi provare altre metriche, se applicabili.

# evaluate the result
eval_result = model.evaluate(x_test, y_test)
print(f"test loss: {eval_result[0]}, test accuracy: {eval_result[1]}")

Riepilogo

Gli iperparametri sono determinanti chiave per le prestazioni dei modelli di machine learning e ottimizzarli con un approccio per tentativi ed errori è inefficiente. Keras Tuner applica algoritmi di ricerca per trovare automaticamente i migliori iperparametri in uno spazio di ricerca definito.

In questo articolo abbiamo utilizzato Keras Tuner per determinare i migliori iperparametri per un'attività di classificazione multiclasse. Siamo stati in grado di definire uno spazio di ricerca in un ipermodello utilizzando il nostro modello personalizzato e i modelli integrati prima di sfruttare gli algoritmi di ricerca forniti per cercare automaticamente diversi valori e combinazioni per trovare una combinazione ottimale di iperparametri per il nostro modello.

Puoi consultare la guida Keras Tuner per guide sulla visualizzazione del processo di ottimizzazione su Tensorboard, sulla distribuzione del processo di hypertuning, sulla personalizzazione dello spazio di ricerca e sulla sottoclasse della classe Tuner per casi d'uso avanzati.

Articoli correlati: