No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Aprende Inglés, Programación, AI, Ciberseguridad y mucho más.

Antes: $249

Currency
$209
Suscríbete

Termina en:

5 Días
9 Hrs
11 Min
28 Seg

Entrenamiento de nuestro modelo de clasificación optimizado

21/25
Recursos

Aportes 4

Preguntas 7

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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") 
Epoch 1/20
384/391 ━━━━━━━━━━━━━━━━━━━━ 0s 99ms/step - accuracy: 0.1996 - loss: 2.1047
391/391 ━━━━━━━━━━━━━━━━━━━━ 46s 105ms/step - accuracy: 0.2010 - loss: 2.1013 - val_accuracy: 0.3720 - val_loss: 1.6851
Epoch 2/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.3685 - loss: 1.6976 - val_accuracy: 0.4526 - val_loss: 1.5051
Epoch 3/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.4288 - loss: 1.5673 - val_accuracy: 0.4945 - val_loss: 1.4209
Epoch 4/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 37s 93ms/step - accuracy: 0.4615 - loss: 1.4908 - val_accuracy: 0.5006 - val_loss: 1.3773
Epoch 5/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.4906 - loss: 1.4152 - val_accuracy: 0.5245 - val_loss: 1.3175
Epoch 6/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 92ms/step - accuracy: 0.5102 - loss: 1.3676 - val_accuracy: 0.5637 - val_loss: 1.2155
Epoch 7/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5174 - loss: 1.3467 - val_accuracy: 0.5705 - val_loss: 1.1890
Epoch 8/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5394 - loss: 1.2960 - val_accuracy: 0.5858 - val_loss: 1.1732
Epoch 9/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 37s 92ms/step - accuracy: 0.5484 - loss: 1.2656 - val_accuracy: 0.5985 - val_loss: 1.1295
Epoch 10/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5630 - loss: 1.2347 - val_accuracy: 0.5931 - val_loss: 1.1346
Epoch 11/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5690 - loss: 1.2147 - val_accuracy: 0.6115 - val_loss: 1.0975
Epoch 12/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 90ms/step - accuracy: 0.5773 - loss: 1.1939 - val_accuracy: 0.6341 - val_loss: 1.0285
Epoch 13/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 90ms/step - accuracy: 0.5855 - loss: 1.1819 - val_accuracy: 0.6211 - val_loss: 1.0559
Epoch 14/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5829 - loss: 1.1710 - val_accuracy: 0.6284 - val_loss: 1.0315
Epoch 15/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.5975 - loss: 1.1436 - val_accuracy: 0.6196 - val_loss: 1.0725
Epoch 16/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 90ms/step - accuracy: 0.6034 - loss: 1.1338 - val_accuracy: 0.6098 - val_loss: 1.1229
Epoch 17/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 37s 93ms/step - accuracy: 0.6082 - loss: 1.1112 - val_accuracy: 0.6426 - val_loss: 1.0291
Epoch 18/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.6121 - loss: 1.1037 - val_accuracy: 0.6594 - val_loss: 0.9613
Epoch 19/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 91ms/step - accuracy: 0.6172 - loss: 1.0911 - val_accuracy: 0.6101 - val_loss: 1.1146
Epoch 20/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 36s 90ms/step - accuracy: 0.6174 - loss: 1.0960 - val_accuracy: 0.6443 - val_loss: 0.9951
313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.6421 - loss: 1.0004
[0.9950822591781616, 0.6442999839782715]