Summaries

Nel Machine Learning, ci sono due tipi di parametri:

1. Parametri (Weights): I pesi e bias della rete, appresi automaticamente durante il training (backpropagation).
2. Iperparametri: Le variabili che decidiamo noi prima del training e che controllano la struttura della rete e l'algoritmo di apprendimento.
   • Modello: Numero di layer, numero di neuroni, tipo di attivazione (ReLU vs Tanh).
   • Algoritmo: Learning rate, batch size, optimizer (Adam vs SGD), tasso di dropout.

Trovare la combinazione giusta è un'arte oscura. Il processo di ricerca automatica si chiama Hyperparameter Tuning (Hypertuning).

1. Ottimizzazione con TensorBoard (HParams)

TensorBoard offre un plugin chiamato HParams per visualizzare i risultati di vari esperimenti. Possiamo definire intervalli discreti o continui per ogni iperparametro e lanciare un ciclo di training per ogni combinazione.

from tensorboard.plugins.hparams import api as hp

# Definizione dello spazio di ricerca
HP_NUM_UNITS = hp.HParam('num_units', hp.Discrete([16, 32, 64]))
HP_DROPOUT = hp.HParam('dropout', hp.RealInterval(0.1, 0.3))
HP_OPTIMIZER = hp.HParam('optimizer', hp.Discrete(['adam', 'sgd']))

# Funzione che addestra un modello con una data configurazione
def train_test_model(hparams):
    model = keras.Sequential([
        layers.Dense(hparams[HP_NUM_UNITS], activation='relu'),
        layers.Dropout(hparams[HP_DROPOUT]),
        layers.Dense(10, activation='softmax')
    ])
    # ... compile e fit ...
    return accuracy

Nella dashboard HPARAMS di TensorBoard, vedremo un grafico a coordinate parallele che mostra come ogni scelta ha influenzato l'accuratezza finale.

2. Keras Tuner

Scrivere cicli for manuali per testare parametri diventa presto ingestibile. Keras Tuner è la libreria ufficiale per automatizzare questo processo.

Definizione dell'Ipermodello

Invece di un modello statico, definiamo una funzione che costruisce modelli parametrici.

import keras_tuner as kt

def model_builder(hp):
    model = keras.Sequential()

    # hp.Int definisce un intero da cercare in un range
    hp_units = hp.Int('units', min_value=32, max_value=512, step=32)
    model.add(layers.Dense(units=hp_units, activation='relu'))

    # hp.Choice sceglie tra valori discreti
    hp_learning_rate = hp.Choice('learning_rate', values=[1e-2, 1e-3, 1e-4])

    model.compile(optimizer=keras.optimizers.Adam(learning_rate=hp_learning_rate),
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])
    return model

Strategie di Ricerca (Tuners)

Keras Tuner offre diversi algoritmi per esplorare lo spazio delle combinazioni:

1. Random Search

Sceglie combinazioni di iperparametri in modo completamente casuale.

• Pro: È sorprendentemente efficace. Spesso i parametri importanti sono pochi, e il campionamento casuale ha buone probabilità di trovarli.
• Contro: Può sprecare tempo su combinazioni palesemente scarse.

2. Bayesian Optimization

Usa la statistica Bayesiana per costruire un modello probabilistico della funzione obiettivo.

• Come funziona: Guarda i risultati degli esperimenti passati per decidere quale combinazione provare dopo. Cerca di bilanciare esplorazione (provare zone ignote) e sfruttamento (affinare zone promettenti).
• Pro: Molto efficiente in termini di numero di prove.

3. Hyperband (Consigliato)

È una variante ottimizzata della Random Search basata sul principio dell'Early Stopping.

• Il Problema: Addestrare un modello fino alla fine (es. 100 epoche) per scoprire che fa schifo è uno spreco di risorse.
• La Soluzione Hyperband:
  1. Genera molte configurazioni casuali.
  2. Addestra tutte per poche epoche (es. 2).
  3. Scarta la metà peggiore.
  4. Addestra le sopravvissute per altre epoche.
  5. Ripeti finché non ne resta una.
• Pro: Permette di testare centinaia di configurazioni velocemente, concentrando le risorse computazionali solo su quelle che promettono bene.

tuner = kt.Hyperband(model_builder,
                     objective='val_accuracy',
                     max_epochs=10,
                     factor=3,
                     directory='my_dir',
                     project_name='intro_to_kt')

# Avvia la ricerca (simile a model.fit)
tuner.search(img_train, label_train, epochs=50, validation_split=0.2)

# Recupera i migliori iperparametri
best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]
print(f"Miglior numero di unità: {best_hps.get('units')}")