El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

El ajuste de hiperparámetros es una parte crucial del proceso de entrenamiento de modelos de aprendizaje automático. Los hiperparámetros son parámetros cuyo valor se establece antes del proceso de aprendizaje y no se actualizan durante el entrenamiento. Ejemplos de hiperparámetros incluyen la tasa de aprendizaje, el número de capas en una red neuronal, el número de neuronas por capa, entre otros.

En esta sección, aprenderemos cómo ajustar los hiperparámetros de nuestros modelos de TensorFlow para mejorar su rendimiento.

Contenido

¿Qué son los Hiperparámetros?
Métodos de Ajuste de Hiperparámetros
Uso de Keras Tuner
Ejemplo Práctico
Ejercicios Prácticos

¿Qué son los Hiperparámetros?

Los hiperparámetros son parámetros que se configuran antes de que comience el proceso de entrenamiento del modelo. A diferencia de los parámetros del modelo, que se aprenden durante el entrenamiento, los hiperparámetros se establecen manualmente y pueden tener un impacto significativo en el rendimiento del modelo.

Ejemplos de Hiperparámetros

Tasa de aprendizaje: Controla la velocidad a la que el modelo se actualiza durante el entrenamiento.
Número de épocas: El número de veces que el algoritmo de aprendizaje pasa por el conjunto de datos completo.
Tamaño del lote: El número de muestras que se procesan antes de actualizar los parámetros del modelo.
Número de capas y neuronas: La arquitectura de la red neuronal.

Métodos de Ajuste de Hiperparámetros

Existen varios métodos para ajustar los hiperparámetros:

Búsqueda en Rejilla (Grid Search)

Consiste en definir un conjunto de valores posibles para cada hiperparámetro y evaluar todas las combinaciones posibles. Es exhaustivo pero puede ser computacionalmente costoso.

Búsqueda Aleatoria (Random Search)

En lugar de evaluar todas las combinaciones posibles, se seleccionan combinaciones aleatorias de hiperparámetros. Es menos exhaustivo pero puede ser más eficiente.

Optimización Bayesiana

Utiliza modelos probabilísticos para seleccionar los hiperparámetros de manera más eficiente. Es más avanzado y puede ser más efectivo que los métodos anteriores.

Uso de Keras Tuner

Keras Tuner es una biblioteca de TensorFlow que facilita el ajuste de hiperparámetros. Proporciona una interfaz sencilla para definir y buscar los mejores hiperparámetros para tu modelo.

Instalación de Keras Tuner

pip install keras-tuner

Definición de un Modelo con Hiperparámetros

import tensorflow as tf
from tensorflow import keras
from keras_tuner import RandomSearch

def build_model(hp):
    model = keras.Sequential()
    model.add(keras.layers.Flatten(input_shape=(28, 28)))
    
    # Número de capas ocultas
    for i in range(hp.Int('num_layers', 1, 3)):
        model.add(keras.layers.Dense(units=hp.Int('units_' + str(i),
                                                  min_value=32,
                                                  max_value=512,
                                                  step=32),
                                     activation='relu'))
    
    model.add(keras.layers.Dense(10, activation='softmax'))
    
    model.compile(optimizer=keras.optimizers.Adam(
                      hp.Choice('learning_rate', [1e-2, 1e-3, 1e-4])),
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])
    
    return model

Búsqueda de Hiperparámetros

tuner = RandomSearch(
    build_model,
    objective='val_accuracy',
    max_trials=5,
    executions_per_trial=3,
    directory='my_dir',
    project_name='intro_to_kt')

tuner.search(x_train, y_train, epochs=10, validation_data=(x_val, y_val))

Resultados de la Búsqueda

best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]
print(f"Mejor número de capas: {best_hps.get('num_layers')}")
print(f"Mejor número de unidades: {best_hps.get('units_0')}")
print(f"Mejor tasa de aprendizaje: {best_hps.get('learning_rate')}")

Ejemplo Práctico

Vamos a ajustar los hiperparámetros de un modelo simple de clasificación de dígitos utilizando el conjunto de datos MNIST.

Código Completo

import tensorflow as tf
from tensorflow import keras
from keras_tuner import RandomSearch

# Cargar el conjunto de datos MNIST
(x_train, y_train), (x_val, y_val) = keras.datasets.mnist.load_data()
x_train, x_val = x_train / 255.0, x_val / 255.0

def build_model(hp):
    model = keras.Sequential()
    model.add(keras.layers.Flatten(input_shape=(28, 28)))
    
    for i in range(hp.Int('num_layers', 1, 3)):
        model.add(keras.layers.Dense(units=hp.Int('units_' + str(i),
                                                  min_value=32,
                                                  max_value=512,
                                                  step=32),
                                     activation='relu'))
    
    model.add(keras.layers.Dense(10, activation='softmax'))
    
    model.compile(optimizer=keras.optimizers.Adam(
                      hp.Choice('learning_rate', [1e-2, 1e-3, 1e-4])),
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])
    
    return model

tuner = RandomSearch(
    build_model,
    objective='val_accuracy',
    max_trials=5,
    executions_per_trial=3,
    directory='my_dir',
    project_name='intro_to_kt')

tuner.search(x_train, y_train, epochs=10, validation_data=(x_val, y_val))

best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]
print(f"Mejor número de capas: {best_hps.get('num_layers')}")
print(f"Mejor número de unidades: {best_hps.get('units_0')}")
print(f"Mejor tasa de aprendizaje: {best_hps.get('learning_rate')}")

Ejercicios Prácticos

Ejercicio 1: Ajuste de Hiperparámetros para un Modelo de Clasificación de Imágenes

Carga el conjunto de datos CIFAR-10.
Define un modelo de red neuronal convolucional.
Utiliza Keras Tuner para ajustar los hiperparámetros del modelo.
Evalúa el modelo con los mejores hiperparámetros encontrados.

Ejercicio 2: Ajuste de Hiperparámetros para un Modelo de Series Temporales

Carga un conjunto de datos de series temporales (por ejemplo, el conjunto de datos de temperaturas diarias).
Define un modelo de red neuronal recurrente.
Utiliza Keras Tuner para ajustar los hiperparámetros del modelo.
Evalúa el modelo con los mejores hiperparámetros encontrados.

Soluciones

Solución al Ejercicio 1

import tensorflow as tf
from tensorflow import keras
from keras_tuner import RandomSearch

# Cargar el conjunto de datos CIFAR-10
(x_train, y_train), (x_val, y_val) = keras.datasets.cifar10.load_data()
x_train, x_val = x_train / 255.0, x_val / 255.0

def build_model(hp):
    model = keras.Sequential()
    model.add(keras.layers.Conv2D(filters=hp.Int('filters', 32, 128, step=32),
                                  kernel_size=hp.Choice('kernel_size', [3, 5]),
                                  activation='relu',
                                  input_shape=(32, 32, 3)))
    model.add(keras.layers.MaxPooling2D(pool_size=2))
    model.add(keras.layers.Flatten())
    model.add(keras.layers.Dense(units=hp.Int('units', 32, 512, step=32),
                                 activation='relu'))
    model.add(keras.layers.Dense(10, activation='softmax'))
    
    model.compile(optimizer=keras.optimizers.Adam(
                      hp.Choice('learning_rate', [1e-2, 1e-3, 1e-4])),
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])
    
    return model

tuner = RandomSearch(
    build_model,
    objective='val_accuracy',
    max_trials=5,
    executions_per_trial=3,
    directory='my_dir',
    project_name='cifar10_tuning')

tuner.search(x_train, y_train, epochs=10, validation_data=(x_val, y_val))

best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]
print(f"Mejor número de filtros: {best_hps.get('filters')}")
print(f"Mejor tamaño de kernel: {best_hps.get('kernel_size')}")
print(f"Mejor número de unidades: {best_hps.get('units')}")
print(f"Mejor tasa de aprendizaje: {best_hps.get('learning_rate')}")

Solución al Ejercicio 2

import tensorflow as tf
from tensorflow import keras
from keras_tuner import RandomSearch
import numpy as np

# Generar datos de ejemplo de series temporales
time = np.arange(0, 100, 0.1)
series = np.sin(time) + 0.1 * np.random.randn(len(time))

# Preparar los datos
def create_dataset(series, window_size):
    dataset = []
    labels = []
    for i in range(len(series) - window_size):
        dataset.append(series[i:i+window_size])
        labels.append(series[i+window_size])
    return np.array(dataset), np.array(labels)

window_size = 20
x_train, y_train = create_dataset(series, window_size)
x_train = x_train[..., np.newaxis]

def build_model(hp):
    model = keras.Sequential()
    model.add(keras.layers.LSTM(units=hp.Int('units', 32, 128, step=32),
                                return_sequences=True,
                                input_shape=(window_size, 1)))
    model.add(keras.layers.LSTM(units=hp.Int('units', 32, 128, step=32)))
    model.add(keras.layers.Dense(1))
    
    model.compile(optimizer=keras.optimizers.Adam(
                      hp.Choice('learning_rate', [1e-2, 1e-3, 1e-4])),
                  loss='mse')
    
    return model

tuner = RandomSearch(
    build_model,
    objective='val_loss',
    max_trials=5,
    executions_per_trial=3,
    directory='my_dir',
    project_name='timeseries_tuning')

tuner.search(x_train, y_train, epochs=10, validation_split=0.2)

best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]
print(f"Mejor número de unidades: {best_hps.get('units')}")
print(f"Mejor tasa de aprendizaje: {best_hps.get('learning_rate')}")

Conclusión

El ajuste de hiperparámetros es una técnica esencial para mejorar el rendimiento de los modelos de aprendizaje automático. En esta sección, hemos aprendido sobre los diferentes métodos de ajuste de hiperparámetros y cómo utilizar Keras Tuner para automatizar este proceso. Con la práctica y la experimentación, podrás encontrar los mejores hiperparámetros para tus modelos y mejorar significativamente su rendimiento.

Ajuste de Hiperparámetros

Contenido

¿Qué son los Hiperparámetros?

Ejemplos de Hiperparámetros

Métodos de Ajuste de Hiperparámetros

Búsqueda en Rejilla (Grid Search)

Búsqueda Aleatoria (Random Search)

Optimización Bayesiana

Uso de Keras Tuner

Instalación de Keras Tuner

Definición de un Modelo con Hiperparámetros

Búsqueda de Hiperparámetros

Resultados de la Búsqueda

Ejemplo Práctico

Código Completo

Ejercicios Prácticos

Ejercicio 1: Ajuste de Hiperparámetros para un Modelo de Clasificación de Imágenes

Ejercicio 2: Ajuste de Hiperparámetros para un Modelo de Series Temporales

Soluciones

Solución al Ejercicio 1

Solución al Ejercicio 2

Conclusión

Curso de TensorFlow

Módulo 1: Introducción a TensorFlow

Módulo 2: Fundamentos de TensorFlow

Módulo 3: Manejo de Datos en TensorFlow

Módulo 4: Construcción de Redes Neuronales

Módulo 5: Redes Neuronales Convolucionales (CNNs)

Módulo 6: Redes Neuronales Recurrentes (RNNs)

Módulo 7: Técnicas Avanzadas de TensorFlow

Módulo 8: TensorFlow para Producción

Módulo 9: TensorFlow Extendido (TFX)

Módulo 10: Temas Especiales