Entrenar Modelo de sesion2_composed

[fbientrigo]

Mediante un entrenamiento de hiperparametros, conseguir un modelo que sea capaz de crear imagenes realistas de materia oscura.

Quest

Subir los archivos de checkpoint.pkl, optimizer_result.pkl y pesos del modelo entrenado junto a sus hiperparametros.

[fbientrigo]

Desde el 19 de agosto a las 10PM hasta el 21 de agosto a las 5pm @JimenezDValencia realizó una optimizacion de training que se almacena en 04_local_training/sesion2_composed/results_2_dani/

Esta sesion de training es la 2da, y es la más grande hasta ahora

Updates

Nuevas funciones de perdida

Del fichero utils/model.py dentro del session2?composed:

dice_loss_callable = tf.keras.losses.Dice(
    reduction='sum_over_batch_size', name='dice'
)

mape_callable = tf.keras.losses.MeanAbsolutePercentageError(
    reduction='sum_over_batch_size',
    name='mean_absolute_percentage_error'
)

def combined_loss(weight_kl=0.1, weight_dice = 32768, weight_mape = 1):
    #  32768 es igual al MAE maximo asumiendo ranogs (-1,1) con 128x128 pixeles
    def loss(y_true, y_pred):
        mae_loss = tf.keras.losses.mae(y_true, y_pred)
        kl_loss = tf.keras.losses.kld(y_true, y_pred)
        dice_loss = dice_loss_callable(y_true, y_pred)
        mape_loss = mape_callable(y_true, y_pred)
        return mae_loss + weight_kl * kl_loss + weight_dice * dice_loss + weight_mape * mape_loss
    return loss

Además de tener funciones de activación fijas con un modelo con un upsampling doble

def create_model(learning_rate=1e-4, 
                 h_kernel_size=3, 
                 hidden_filters=64,
                 out_kernel_size=3,
                 beta_1=0.9,
                 beta_2=0.999,
                 epsilon=1e-7,
                 decay_steps=10000,
                 decay_rate=0.96):
    """
    Modelo que agranda las dimensiones espaciales hasta 256x256 y luego las reduce a 128x128.
    """
    model = tf.keras.models.Sequential([
        tf.keras.layers.Input(shape=(128, 128, 3)),
        tf.keras.layers.Conv2D(32, (3, 3), activation="sigmoid", padding='same'),
        tf.keras.layers.BatchNormalization(),
        tf.keras.layers.UpSampling2D(size=(2, 2)),
        tf.keras.layers.Conv2D(hidden_filters, (h_kernel_size, h_kernel_size), activation="sigmoid", padding='same'),
        tf.keras.layers.BatchNormalization(),
        tf.keras.layers.Conv2D(2 * hidden_filters, (h_kernel_size, h_kernel_size), activation="sigmoid", padding='same'),
        tf.keras.layers.BatchNormalization(),
        tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
        tf.keras.layers.Conv2D(64, (3, 3), activation="tanh", padding='same'),
        tf.keras.layers.BatchNormalization(),
        tf.keras.layers.Conv2D(1, (out_kernel_size, out_kernel_size), activation="tanh", padding='same')
    ])

    lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
      initial_learning_rate=learning_rate,
      decay_steps=decay_steps,
      decay_rate=decay_rate,
      staircase=True)

    optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule, 
                                         beta_1=beta_1, 
                                         beta_2=beta_2, 
                                         epsilon=epsilon)

    model.compile(optimizer=optimizer, loss=combined_loss(1))

    return model

Resultados

El espacio de busqueda dentro de optimize.py

dimensions = [
            Real(low=1e-6, high=1e-2, prior='log-uniform', name='learning_rate'),
            Integer(low=2, high=7, name='h_kernel_size'),
            Integer(low=16, high=128, name='hidden_filters'),
            Integer(low=2, high=7, name='out_kernel_size'),
            Real(low=0.0, high=0.99, name='beta_1'),
            Real(low=0.0, high=0.999, name='beta_2'),
            Real(low=1e-8, high=1e-4, prior='log-uniform', name='epsilon'),
            Integer(low=1000, high=50000, name='decay_steps'),
            Real(low=0.8, high=0.99, name='decay_rate'),
            Integer(low=5, high=25, name='epochs')
        ]

default_parameters = [1e-4, 3, 64, 3, 
    0.9, 0.99, 1e-7, 10000, 0.96, 10]

Sin embargo, solo sobrevivió el checkpoint, así que se debe dar un ultimo training para crear el res.pkl, pero lo importante ahora es evaluar visualmente el modelo

El primer best model

podemos observar algo similar en forma, pero no presenta los peaks caracteristicos ni sus posiciones

El segundo best model

Se observa un problema claro, y parece estar relacionado a las funciones de perdida en donde un valor altamente positivo se beneficia demasiado

[fbientrigo]

Se considera el final de esta iteración de modelos, que directamente estiman los pixeles, debido a que tienden a overfit rápidamente, a estados en donde el modelo deja de aprender.

Podría probarse otras herramientas más potentes, pero no se tiene acceso a un hardware para entrenar efectivamente un modelo de difusión o un autoencoder.

Que se aprendió

Debido a como se mide el error, la red pasa a aprender a estimar ruido que le permite reducir en promedio el error Sin embargo esto es poco efectivo para el hecho que deseamos que la red pueda estimar peaks, se probarón distintas formas de organizar las funciones de error, de la misma forma agregar modelos de gaussian mixtures, pero el error no se calculaba comparando coeficientes si no pixeles de la imagen, lo que indicó que no permitia una backpropagation eficiente, pues este modelo volvía a estimar como generar un background

la idea de generar el background por separado Aqui surge la idea de generar un background mediante un algoritmo PCA y luego generar los peaks con Gaussian Mixtures