Crear la red neural, definir capas, compilar, entrenar, evaluar y predicciones

Ya tenemos todas las configuraciones previas para programar nuestra red, lo siguiente será definir una arquitectura, compilar el modelo y revisar el rendimiento de la red.

Creando el modelo de red neuronal

Definiremos un modelo con la clase Sequential de Keras, esta nos permitirá apilar varias capas una encima de otra para lograr el efecto de aprendizaje profundo.

La primera capa será de entrada, donde recibiremos una imagen de 28x28 píxeles en un solo canal, una vez recibida será aplanada para ser procesada como un array unidimensional. En cambio, las siguientes 2 capas serán capas profundas con 256 y 128 neuronas respectivamente, y tendrán como función de activación la ReLU.

La capa de salida será una capa de 24 neuronas (una por cada posible clase) de activación Softmax que nos retornará un array con las probabilidades de cada letra.

model_base = tf.keras.models.Sequential(
    [tf.keras.layers.Flatten(input_shape = (28, 28, 1)),
    tf.keras.layers.Dense(256, activation = "relu"),
    tf.keras.layers.Dense(128, activation = "relu"),
    tf.keras.layers.Dense(len(classes), activation = "softmax")]
)

Si llamamos el método summary obtendremos un resumen de la arquitectura de la red.

model_base.summary()

Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param 
=================================================================
 flatten_2 (Flatten)         (None, 784)               0         
                                                                 
 dense_5 (Dense)             (None, 256)               200960    
                                                                 
 dense_6 (Dense)             (None, 128)               32896     
                                                                 
 dense_7 (Dense)             (None, 24)                3096      
                                                                 
=================================================================
Total params: 236,952
Trainable params: 236,952
Non-trainable params: 0
_________________________________________________________________

Compilación y entrenamiento del modelo

Compilaremos el modelo definiendo un optimizador, para este caso determinamos adam, un algoritmo que permite actualizar automáticamente el learning rate según el desempeño de la red. Como función de pérdida aplicaremos categorical cross entropy y la métrica de éxito será la precisión.

Entrenaremos el modelo con el image generator de entrenamiento, durante 20 épocas y con los datos de validación.

model_base.compile(optimizer = "adam", loss = "categorical_crossentropy", metrics = ["accuracy"])

history = model_base.fit(
    train_generator,
    epochs = 20,
    validation_data = validation_generator
)

En la época final tendremos una precisión casi total durante el entrenamiento pero un rendimiento diferente sobre los datos de validación.

Epoch 20/20
215/215 [==============================] - 6s 27ms/step - loss: 0.0101 - accuracy: 0.9999 - val_loss: 1.3020 - val_accuracy: 0.7572

Si evaluamos el modelo, nos encontraremos con una precisión del 76%, donde entrenamiento era casi absoluta.

results = model_base.evaluate(test_generator)
57/57 [==============================] - 2s 36ms/step - loss: 1.2101 - accuracy: 0.7616

Análisis del desempeño de la red

Para entender más gráficamente lo que sucedió, crearemos la función de visualización de resultados, que comparará el rendimiento del entrenamiento sobre el rendimiento de validación tanto términos de accuracy como de loss.

def visualizacion_resultados(history):
  epochs = [i for i in range(20)]
  fig, ax = plt.subplots(1, 2)
  train_acc = history.history["accuracy"]
  train_loss = history.history["loss"]
  val_acc = history.history["val_accuracy"]
  val_loss = history.history["val_loss"]
  fig.set_size_inches(16, 9)

  ax[0].plot(epochs, train_acc, "go-", label = "Train accuracy")
  ax[0].plot(epochs, val_acc, "ro-", label = "Validation accuracy")
  ax[0].set_title("Train and Val accuracy")
  ax[0].legend()
  ax[0].set_xlabel("Epochs")
  ax[0].set_ylabel("Accuracy")

  ax[1].plot(epochs, train_loss, "go-", label = "Train Loss")
  ax[1].plot(epochs, val_loss, "ro-", label = "Validation Loss")
  ax[1].set_title("Train and Val loss")
  ax[1].legend()
  ax[1].set_xlabel("Epochs")
  ax[1].set_ylabel("Loss")

  plt.show()

Si corremos la función obtendremos información valiosísima con respecto al comportamiento del modelo.

visualizacion_resultados(history)

Puedes notar una diferencia abrupta tanto en el accuracy como en el loss, en la etapa de entrenamiento la red aprendió óptimamente y redujo la pérdida de manera constante, mientras que en validación sufrió de un rápido estancamiento, esto puede ser señal de overfitting, donde la red calcó los ejemplos y no los patrones.

Contribución creada por Sebastián Franco Gómez.