Entrenamiento de nuestro modelo de clasificación optimizado

El optimizador, es el encargado de generar pesos cada vez mejores: su importancia es crucial. Su funcionamiento esencial se basa en calcular el gradiente de la función de coste (derivada parcial) por cada peso (parametro/dimension) de la red.

El conjunto de métodos iterativos de reducción de la función de error (búsqueda de un mínimo local), son conocidos cómo los método de optimización basados en el gradiente descendente.

principales optimizadores disponibles en keras

Stochastic Gradient Descent (SGD)
SGD hace algo tan simple cómo limitar el cálculo de la derivada a tan solo una observación (por batch).

Adaptive Gradient Algorithm (AdaGrad)
El algoritmo AdaGrad introduce una variación muy interesante en el concepto de factor de entrenamiento: en vez de considerar un valor uniforme para todos los pesos, se mantiene un factor de entrenamiento específico para cada uno de ellos. Sería inviable calcular este valor de forma específica así que, partiendo del factor de entrenamiento inicial, AdaGrad lo escala y adapta para cada dimensión con respecto al gradiente acumulado en cada iteración.

Adadelta
Adadelta es una variación de AdaGrad en la que en vez de calcular el escalado del factor de entrenamiento de cada dimensión teniendo en cuenta el gradiente acumulado desde el principio de la ejecución, se restringe a una ventana de tamaño fijo de los últimos n gradientes.

RMSprop (Root Mean Square Propagation)
RMSProp es un algoritmo similar. También mantiene un factor de entrenamiento diferente para cada dimensión, pero en este caso el escalado del factor de entrenamiento se realiza dividiéndolo por la media del declive exponencial del cuadrado de los gradientes (glup!)

Adam (Adaptive moment estimation)

El algoritmo Adam combina las bondades de AdaGrad y RMSProp. Se mantiene un factor de entrenamiento por parámetro y además de calcular RMSProp, cada factor de entrenamiento también se ve afectado por la media del momentum del gradiente

NOTA IMPORTANTE
Como se acaba de comprobar, los algoritmos mas recientes como Adam, están construidos en base a sus predecesores, por tanto podremos esperar que su rendimiento sea superior.
Desde mi punto de vista y salvando SGD, es complicado tener una visión intuitiva del comportamiento de cada uno de los optimizadores; por ello es útil visualizar su rendimiento en diferentes funciones de coste.

En conclusión hemos observado de una forma empírica cómo quizás el algoritmo Adam presenta un comportamiento adecuado en diferentes problemas, por tanto puede ser un buen candidato para empezar a probar en nuestros modelos

Toda esta información fue obtenida del blog de Luis Velasco, aca les dejo el link:

Antes de correr el entrenamiento ponganse cómodos y abran Netflix porque tarda alrededor de 1 hora entrenar el modelo.

Como nota interesante, una vez que has terminado el entrenamiento y se ha generado tu best model nada te prohibe, abrirlo y seguirlo entrenando un par de iteraciones más.

Adjunto mi código para que se den una idea:

 # Checkpoint Callback
    checkpoint_cb = ModelCheckpoint("models/best_model.h5", verbose=1, save_best_only=True, monitor="val_acc")

    if not exists("models/best_model.h5"):
        print("Entrenando por primera vez")
        print("*" * 64)
        print("Creando arquitectura")
        md = architecture(base_filtros=32, w_regularized=1e-4, shape=x_train[0].shape, num_classes=num_clases)
        print("*" * 64)
        print("Empezando a entrenar")
        md.compile(optimizer=Adam(), loss="categorical_crossentropy", metrics=["acc"])
        history = md.fit(datagen.flow(x_train, y_train, batch_size=128),
                         callbacks=[checkpoint_cb],
                         steps_per_epoch=x_train.shape[0] // 128,
                         epochs=50,
                         verbose=2,
                         validation_data=(x_valid, y_valid))
        plot_results(history, "acc", "resultado_tuneado.png")

    else:
        print("Abriendo modelo y continuando entrenamiento")
        md = load_model("models/best_model.h5")
        history = md.fit(datagen.flow(x_train, y_train, batch_size=128),
                         callbacks=[checkpoint_cb],
                         steps_per_epoch=x_train.shape[0] // 128,
                         epochs=20,
                         verbose=2,
                         validation_data=(x_valid, y_valid))

        plot_results(history, "acc", "resultado_tuneado_2.png")