Entrenamiento del modelo de clasificación binaria

¿Cómo construir un modelo de red neuronal para clasificación binaria?

Comenzar a trabajar con redes neuronales para tareas de clasificación binaria puede marcar una gran diferencia en el manejo efectivo de tus datos. En este caso, aprenderemos a crear un modelo que utilice la función de pérdida binary cross entropy, ideal para este tipo de situaciones.

¿Cómo se crean las capas del modelo?

La construcción comienza con el uso de models.Sequential, una herramienta que te permite agregar capas al modelo. Aquí tienes una guía de los pasos necesarios:

1. Agregar capas densas: Utiliza add(layers.Dense()) para añadir capas densas. Estas son manejadas con estructuras de conjunto de datos.

2. Configuración de la capa: La configuración incluye:

   • 16 neuronas.
   • Función de activación relu.
   • Los datos de entrada con un input shape de 10,000.

3. Capas subsecuentes: Agregar más capas sin necesidad de definir el input, ya que el modelo ya conoce la entrada.

4. Capa de salida: La última capa termina en una sola neurona con una función sigmoide, que es perfecta para clasificaciones binarias.

from keras import models, layers

model = models.Sequential()
model.add(layers.Dense(16, activation='relu', input_shape=(10000,)))
model.add(layers.Dense(16, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))

¿Cómo compilar y entrenar el modelo?

Luego de establecer las capas de nuestro modelo, pasamos a compilar y entrenar el modelo con los siguientes pasos:

1. Compilación del modelo:

   • Optimizador: rmsprop, una variación del descenso de gradiente, ideal para esta tarea.
   • Función de pérdida: binary_crossentropy.
   • Métrica: accuracy.

2. Entrenamiento del modelo:

   • Conjunto de validación: Creación de un conjunto de validación dividiendo los datos originales.
   • Proceso de ajuste (fit): Configurado para realizar cuatro iteraciones y lotes de datos de tamaño 512.

model.compile(optimizer='rmsprop',
              loss='binary_crossentropy',
              metrics=['accuracy'])

history = model.fit(partial_x_train,
                    partial_y_train,
                    epochs=4,
                    batch_size=512,
                    validation_data=(x_val, y_val))

Visualización y evaluación del modelo ¿Qué se analiza?

La evaluación de un modelo es crucial para entender su rendimiento. Utilizamos matplotlib para graficar resultados, lo que permite analizar la pérdida y la precisión a través de las épocas.

1. Visualización de resultados:

   • Pérdida y precisión en el conjunto de entrenamiento.
   • Pérdida y precisión en el conjunto de validación, centrándose en si el modelo muestra overfitting, es decir, si se ajusta demasiado a los datos de entrenamiento y permea en el rendimiento en validación.

2. Evaluación del modelo con el conjunto de prueba:

   • Utilizamos model.evaluate() para calcular la exactitud real en los datos de prueba.

import matplotlib.pyplot as plt

history_dict = history.history

loss_values = history_dict['loss']
val_loss_values = history_dict['val_loss']

epochs = range(1, len(loss_values) + 1)

plt.plot(epochs, loss_values, 'o', label='Training loss')
plt.plot(epochs, val_loss_values, '-', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()

results = model.evaluate(x_test, y_test)
print(f'Exactitud del modelo: {results[1] * 100:.2f}%')

El modelo presentado mostró un accuracy del 87%. Aunque es elevado, detectamos que sufre de overfitting. Resolver este problema puede llevar nuestro modelo a un nivel de desempeño aún mejor. ¡Sigue explorando y ajustando tu modelo, y no dudes en probar técnicas para reducir el overfitting!