API avanzado de TensorFlow - Keras

Keras es una API de redes neuronales de alto nivel escrita en Python, que puede ejecutarse con TensorFlow, CNTK o Theano como backend. Su filosofía de diseño es ser fácil de usar, modular y fácilmente extensible.

Características principales de Keras

  1. Simple y fácil de usar: proporciona una interfaz intuitiva y consistente, adecuada para el prototipado rápido
  2. Modular: las capas de redes neuronales, funciones de pérdida, optimizadores, etc., son módulos conectables
  3. Fácilmente extensible: se pueden agregar nuevos módulos fácilmente para expresar nuevas ideas de investigación
  4. Soporta múltiples backends: puede ejecutarse sin problemas en TensorFlow, CNTK o Theano

Conceptos fundamentales de Keras

1. Modelo (Model)

La estructura de datos central de Keras es el modelo, que es la forma de organizar las capas de una red neuronal. Keras proporciona dos tipos principales de modelos:

  • Modelo Sequential: apilamiento lineal de capas
  • Functional API: construye un grafo acíclico dirigido para modelos complejos

2. Capa (Layer)

Las capas son los bloques de construcción básicos de Keras. Cada capa recibe datos de entrada, realiza algún cálculo y produce un resultado. Keras proporciona múltiples capas predefinidas:

  • Capas principales: Dense, Activation, Dropout, etc.
  • Capas convolucionales: Conv2D, MaxPooling2D, etc.
  • Capas recurrentes: LSTM, GRU, etc.
  • Otras: Embedding, BatchNormalization, etc.

3. Función de activación (Activation Function)

La función de activación determina la salida de una neurona. Las comunes incluyen:

  • ReLU (Rectified Linear Unit)
  • Sigmoid
  • Tanh
  • Softmax (problemas de clasificación múltiple)

Flujo de trabajo básico de Keras

1. Definir el modelo

Ejemplo

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

model = Sequential([
    Dense(64, activation='relu', input_shape=(784,)),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')
])

2. Compilar el modelo

Ejemplo

model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

3. Entrenar el modelo

Ejemplo

model.fit(x_train, y_train,
          epochs=5,
          batch_size=32)

4. Evaluar el modelo

Ejemplo

loss_and_metrics = model.evaluate(x_test, y_test, batch_size=128)

5. Realizar predicciones

Ejemplo

classes = model.predict(x_test, batch_size=128)

Explicación detallada de las capas comunes de Keras

1. Capa densa Dense (totalmente conectada)

Ejemplo

Dense(units,
      activation=None,
      use_bias=True,
      kernel_initializer='glorot_uniform',
      bias_initializer='zeros')
  • units: entero positivo, dimensión del espacio de salida
  • activation: función de activación
  • use_bias: si se utiliza el vector de sesgo (bias)
  • kernel_initializer: inicializador de la matriz de pesos
  • bias_initializer: inicializador del vector de sesgo

2. Capa convolucional 2D Conv2D

Ejemplo

Conv2D(filters,
       kernel_size,
       strides=(1, 1),
       padding='valid',
       activation=None)
  • filters: número de núcleos de convolución (filtros)
  • kernel_size: tamaño del núcleo de convolución
  • strides: paso de convolución (stride)
  • padding: modo de relleno ('valid' o 'same')

3. Capa de red de memoria a largo plazo LSTM

Ejemplo

LSTM(units,
     activation='tanh',
     recurrent_activation='hard_sigmoid',
     return_sequences=False)
  • units: entero positivo, dimensión del espacio de salida
  • activation: función de activación
  • recurrent_activation: función de activación del paso recurrente
  • return_sequences: si se devuelve la secuencia completa

Guardado y carga de modelos en Keras

1. Guardar el modelo completo

Ejemplo

model.save('my_model.h5')  # Guardar arquitectura, pesos y configuración de entrenamiento

2. Guardar solo la arquitectura

Ejemplo

json_string = model.to_json()  # Guardar como JSON
yaml_string = model.to_yaml()  # Guardar como YAML

3. Guardar solo los pesos

Ejemplo

model.save_weights('my_model_weights.h5')

4. Cargar el modelo

Ejemplo

from tensorflow.keras.models import load_model

model = load_model('my_model.h5')  # Cargar el modelo completo

Funciones de devolución de llamada (callbacks) en Keras

Las funciones de devolución de llamada son funciones invocadas en momentos específicos durante el entrenamiento, utilizadas para:

  • Puntos de control del modelo (checkpoints)
  • Detención temprana
  • Ajuste de la tasa de aprendizaje
  • Registro de logs, etc.

Funciones de devolución de llamada comunes

Ejemplo

from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping

callbacks = [
    ModelCheckpoint(filepath='best_model.h5', monitor='val_loss', save_best_only=True),
    EarlyStopping(monitor='val_loss', patience=3)
]

model.fit(x_train, y_train,
          epochs=10,
          callbacks=callbacks,
          validation_data=(x_val, y_val))

Ejemplo práctico de Keras: reconocimiento de dígitos escritos a mano MNIST

Ejemplo

from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Flatten
from tensorflow.keras.layers import Conv2D, MaxPooling2D
from tensorflow.keras.utils import to_categorical

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

# Preprocesamiento de datos
x_train = x_train.reshape(60000, 28, 28, 1).astype('float32') / 255
x_test = x_test.reshape(10000, 28, 28, 1).astype('float32') / 255
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

# Construir el modelo
model = Sequential([
    Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D(pool_size=(2, 2)),
    Dropout(0.25),
    Flatten(),
    Dense(128, activation='relu'),
    Dropout(0.5),
    Dense(10, activation='softmax')
])

# Compilar el modelo
model.compile(loss='categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

# Entrenar el modelo
model.fit(x_train, y_train,
          batch_size=128,
          epochs=12,
          verbose=1,
          validation_data=(x_test, y_test))

# Evaluar el modelo
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

Técnicas avanzadas de Keras

1. Capas personalizadas

Ejemplo

from tensorflow.keras import backend as K
from tensorflow.keras.layers import Layer

class MyLayer(Layer):
    def __init__(self, output_dim, **kwargs):
        self.output_dim = output_dim
        super(MyLayer, self).__init__(**kwargs)
   
    def build(self, input_shape):
        self.kernel = self.add_weight(name='kernel',
                                     shape=(input_shape[1], self.output_dim),
                                     initializer='uniform',
                                     trainable=True)
        super(MyLayer, self).build(input_shape)
   
    def call(self, x):
        return K.dot(x, self.kernel)
   
    def compute_output_shape(self, input_shape):
        return (input_shape[0], self.output_dim)

2. Funciones de pérdida personalizadas

Ejemplo

from tensorflow.keras import backend as K

def custom_loss(y_true, y_pred):
    return K.mean(K.square(y_pred - y_true), axis=-1)

model.compile(optimizer='adam', loss=custom_loss)

3. Programación de la tasa de aprendizaje (learning rate)

Ejemplo

from tensorflow.keras.callbacks import LearningRateScheduler

def scheduler(epoch, lr):
    if epoch < 10:
        return lr
    else:
        return lr * K.exp(-0.1)

callback = LearningRateScheduler(scheduler)
model.fit(x_train, y_train, epochs=15, callbacks=[callback])

Problemas comunes y soluciones en Keras

1. Problema de sobreajuste

  • Agregar capas Dropout
  • Usar regularización L1/L2
  • Aumentar los datos de entrenamiento
  • Usar aumento de datos

2. Entrenamiento lento

  • Aumentar el tamaño del lote (batch size)
  • Usar un modelo más simple
  • Probar diferentes optimizadores
  • Usar aceleración con GPU

3. Desaparición/explosión del gradiente

  • Usar BatchNormalization
  • Usar una inicialización de pesos adecuada
  • Usar funciones de activación no saturadas como ReLU
  • Usar recorte de gradiente (gradient clipping)

Resumen

Keras, como API de alto nivel de TensorFlow, proporciona una interfaz simple e intuitiva para construir y entrenar modelos de aprendizaje profundo. Con este artículo, deberías haber aprendido:

  1. Los conceptos fundamentales de Keras y su flujo de trabajo básico
  2. El uso de las capas comunes
  3. El guardado y la carga de modelos
  4. El uso de funciones de devolución de llamada
  5. Ejemplos de aplicación en proyectos reales
  6. Técnicas avanzadas y soluciones a problemas comunes

La fortaleza de Keras radica en su flexibilidad y facilidad de uso, lo que hace más eficiente el desarrollo de modelos de aprendizaje profundo. A medida que profundices en la práctica, podrás construir modelos de redes neuronales más complejos para resolver diversos problemas reales.

Otras extensiones