Keras: primera red neuronal

Keras es una API de redes neuronales de alto nivel, escrita en Python, que puede ejecutarse sobre TensorFlow, CNTK o Theano. Su desarrollo se centra en apoyar la experimentación rápida, permitiendo pasar de una idea a un resultado rápidamente con un mínimo de código.

Características principales de Keras

Amigable para el usuario: Keras tiene una interfaz simple y consistente
Modular: Los distintos componentes de una red neuronal (capas, optimizadores, esquemas de inicialización, etc.) son módulos combinables.
Fácil extensibilidad: Se pueden agregar fácilmente nuevos módulos para expresar nuevas ideas de investigación.
Soporte de múltiples backends: Se puede cambiar sin problemas entre TensorFlow, Theano y CNTK como backend de cálculo.

Instalación de Keras

Antes de comenzar, necesitamos instalar Keras y su motor backend (aquí usamos TensorFlow):

pip install tensorflow keras

Nota: Keras 2.4.0 y versiones posteriores ya están integradas en TensorFlow, se puede usar directamente a través detensorflow.kerasusar

Construyendo la primera red neuronal

Comencemos con una simple red neuronal totalmente conectada para resolver el clásico problema de reconocimiento de dígitos manuscritos MNIST.

1. Importar las bibliotecas necesarias

Ejemplo

import numpy as np
from tensorflow import keras
from tensorflow.keras import layers

2. Preparar los datos

El conjunto de datos MNIST contiene 60,000 imágenes de entrenamiento y 10,000 imágenes de prueba, cada una es una imagen en escala de grises de un dígito manuscrito de 28x28 píxeles.

Ejemplo

# Cargar datos
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# Preprocesar los datos
x_train = x_train.reshape(60000, 784).astype("float32") / 255
x_test = x_test.reshape(10000, 784).astype("float32") / 255

# Convertir las etiquetas a codificación one-hot
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

3. Construir el modelo

Construiremos una red totalmente conectada simple, que contiene una capa de entrada, una capa oculta y una capa de salida.

Ejemplo

model = keras.Sequential([
layers.Dense(512, activation="relu", input_shape=(784,)),
layers.Dense(10, activation="softmax")
])

Análisis de la estructura del modelo

Ejemplo

graph TD
A[Capa de entrada 784 neuronas] --> B[Capa oculta 512 neuronas, activación ReLU]
B --> C[Capa de salida 10 neuronas, activación Softmax]

4. Compilar el modelo

Antes de entrenar el modelo, necesitamos configurar el proceso de aprendizaje:

Ejemplo

model.compile(
optimizer="rmsprop",
loss="categorical_crossentropy",
metrics=["accuracy"]
)

Explicación de los parámetros de compilación

Parámetro	Descripción	Valores comunes
optimizer	Optimizador, se usa para actualizar los pesos	"rmsprop", "adam", "sgd"
loss	Función de pérdida, mide la diferencia entre las predicciones del modelo y los valores reales	"categorical_crossentropy" (clasificación), "mse" (regresión)
metrics	Métrica de evaluación, se usa para monitorear el entrenamiento	["accuracy"]

5. Entrenar el modelo

Ahora podemos comenzar a entrenar el modelo:

Ejemplo

history = model.fit(
x_train, y_train,
batch_size=128,
epochs=10,
validation_split=0.2
)

Explicación de los parámetros de entrenamiento

Parámetro	Descripción	Valor sugerido
batch_size	Número de muestras utilizadas en cada actualización de gradiente	32-256
epochs	Número de épocas de entrenamiento	Ajustar según la complejidad de los datos
validation_split	Proporción de datos de entrenamiento utilizada como conjunto de validación	0.1-0.3

6. Evaluar el modelo

Después del entrenamiento, podemos evaluar el rendimiento del modelo en el conjunto de prueba:

Ejemplo

test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Precisión de prueba: {test_acc:.4f}")

Ejemplo de código completo

Ejemplo

import numpy as np
from tensorflow import keras
from tensorflow.keras import layers

# 1. Cargar los datos
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# 2. Preprocesamiento
x_train = x_train.reshape(60000, 784).astype("float32") / 255
x_test = x_test.reshape(10000, 784).astype("float32") / 255
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

# 3. Construir el modelo
model = keras.Sequential([
layers.Dense(512, activation="relu", input_shape=(784,)),
layers.Dense(10, activation="softmax")
])

# 4. Compilar el modelo
model.compile(
optimizer="rmsprop",
loss="categorical_crossentropy",
metrics=["accuracy"]
)

# 5. Entrenar el modelo
history = model.fit(
x_train, y_train,
batch_size=128,
epochs=10,
validation_split=0.2
)

# 6. Evaluar el modelo
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Precisión de prueba: {test_acc:.4f}")

Sugerencias para mejorar el modelo

1. Agregar capa Dropout: Para evitar el sobreajuste

Ejemplo

model.add(layers.Dropout(0.5))

2. Usar un optimizador más avanzado: Por ejemplo, Adam

Ejemplo

model.compile(optimizer="adam", ...)

3. Agregar capas ocultas: Construir una red más profunda

Ejemplo

model.add(layers.Dense(256, activation="relu"))

4. Usar capas convolucionales: Más eficaz para datos de imágenes

Ejemplo

model.add(layers.Conv2D(32, (3, 3), activation="relu"))

Preguntas frecuentes

Q1: ¿Por qué la precisión de mi modelo es tan baja?

Comprobar si el preprocesamiento de datos es correcto
Intentar ajustar la tasa de aprendizaje
Aumentar la capacidad de la red (más capas o más neuronas)

Q2: ¿Qué hago si la pérdida (loss) no disminuye durante el entrenamiento?

Verificar si hay problemas con los datos
Probar diferentes optimizadores
Ajustar la tasa de aprendizaje (generalmente reducirla)

Q3: ¿Cómo guardar y cargar un modelo entrenado?

Ejemplo

# Guardar el modelo
model.save("mnist_model.h5")

# Cargar el modelo
loaded_model = keras.models.load_model("mnist_model.h5")

Otras extensiones