Resolviendo un problema de regresión

¿Cómo abordar la regresión con redes neuronales en Keras y Python?

El proceso de regresión en redes neuronales es crucial para predecir valores continuos —un desafío distinto al de la clasificación. En esta lección, exploramos cómo aplicar técnicas de regresión usando Keras y Python, fundamentándonos en un dataset que representa características de casas junto con sus precios en miles de dólares. Este tutorial proporciona las herramientas esenciales y el conocimiento para que puedas aplicar estos conceptos a tus propios datos.

¿Qué pasos iniciales debemos seguir en el notebook?

Iniciar un proyecto de regresión en un notebook requiere establecer un entorno de trabajo adecuado. Primero, importamos las bibliotecas necesarias como pandas y numpy, seguidas de las partes específicas de Keras: modelos, capas y optimizadores.

import pandas as pd
import numpy as np
from keras.datasets import boston_housing
from keras import models, layers, optimizers

Luego, cargamos los datos utilizando el conjunto de datos de Boston Housing disponible en Keras, y los dividimos en conjuntos de entrenamiento y prueba:

(train_data, train_labels), (test_data, test_labels) = boston_housing.load_data()

¿Cómo normalizamos nuestros datos?

La normalización es crucial para garantizar que las variables con rangos diferentes no dominen el sistema. Aplicamos un proceso estadístico básico, restando la media y dividiendo por la desviación estándar de los datos de entrenamiento:

mean = train_data.mean(axis=0)
train_data -= mean
std = train_data.std(axis=0)
train_data /= std

test_data -= mean
test_data /= std

Este paso asegura que todos los datos estén en el mismo rango, lo que facilita el procesamiento por parte de la red neuronal.

¿Cómo construimos el modelo de red neuronal?

La construcción del modelo empieza definiendo un modelo secuencial y añadiendo capas densas con activación ReLU. La capa final, al tratarse de una regresión, no utiliza activación, para predecir un valor continuo.

def build_model(learning_rate=0.001, input_data_shape=(train_data.shape[1],)):
    model = models.Sequential()
    model.add(layers.Dense(64, activation='relu', input_shape=input_data_shape))
    model.add(layers.Dense(64, activation='relu'))
    model.add(layers.Dense(1))  # No activation to predict continuous value
    
    model.compile(optimizer=optimizers.RMSprop(learning_rate),
                  loss='mse',
                  metrics=['mae'])
    return model

¿Cómo implementar la validación cruzada?

Implementamos la validación cruzada K-Fold para evaluar el modelo de manera más robusta, rotando los sets de validación a lo largo del set de entrenamiento.

k = 4
num_val_samples = len(train_data) // k
num_epochs = 80
all_mae_histories = []

for i in range(k):
    print(f'Processing fold #{i}')
    val_data = train_data[i * num_val_samples: (i + 1) * num_val_samples]
    val_targets = train_labels[i * num_val_samples: (i + 1) * num_val_samples]

    partial_train_data = np.concatenate(
        [train_data[:i * num_val_samples],
         train_data[(i + 1) * num_val_samples:]], axis=0)
    partial_train_targets = np.concatenate(
        [train_labels[:i * num_val_samples],
         train_labels[(i + 1) * num_val_samples:]], axis=0)

    model = build_model()
    history = model.fit(partial_train_data, partial_train_targets,
                        validation_data=(val_data, val_targets),
                        epochs=num_epochs, batch_size=1, verbose=0)
    mae_history = history.history['val_mae']
    all_mae_histories.append(mae_history)

Esta práctica de validación cruzada es un estándar en machine learning, permitiendo que el modelo se entrene y valide sobre distintos subconjuntos del conjunto de datos.

Con estos fundamentos, estás en camino de construir modelos que predigan con precisión valores continuos. ¡Continúa explorando y experimentando para mejorar tus habilidades en redes neuronales!