Visualización del backward

Introducción

La visualización del backward es una parte crucial en la comprensión de cómo funciona exactamente el backpropagation. Es a través de este proceso que las redes neuronales aprenden a ajustar sus pesos para minimizar el error en las predicciones. Este artículo te guiará a través de un proyecto guiado donde podrás ver paso a paso cómo se propaga el error hacia atrás y cómo se actualizan los pesos en una red neuronal simple.

Explicación principal con ejemplos

Consideremos una red neuronal simple con solo una capa oculta. La estructura general sería:

import numpy as np

# Parámetros de la red
input_layer_size = 2
hidden_layer_size = 3
output_layer_size = 1

# Peso inicialización (aleatoria)
weights_input_hidden = np.random.randn(input_layer_size, hidden_layer_size)
weights_hidden_output = np.random.randn(hidden_layer_size, output_layer_size)

# Datos de entrada y salida esperada
X = np.array([[0.5], [0.9]])
y = np.array([[1]])

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def forward_pass(X, weights_input_hidden, weights_hidden_output):
    hidden_layer_input = np.dot(X, weights_input_hidden)
    hidden_layer_output = sigmoid(hidden_layer_input)

    output_layer_input = np.dot(hidden_layer_output, weights_hidden_output)
    output = sigmoid(output_layer_input)
    
    return hidden_layer_output, output

# Forward pass
hidden_layer_output, y_pred = forward_pass(X, weights_input_hidden, weights_hidden_output)

Después de realizar la forward pass, obtenemos una predicción y_pred que es probablemente diferente a y. A continuación, procedemos con el backward pass para ajustar los pesos.

Backward Pass

def sigmoid_derivative(x):
    return x * (1 - x)

def backward_pass(X, y, hidden_layer_output, y_pred, weights_input_hidden, weights_hidden_output):
    output_error = y_pred - y
    output_delta = output_error * sigmoid_derivative(y_pred)
    
    hidden_error = np.dot(output_delta, weights_hidden_output.T)
    hidden_delta = hidden_error * sigmoid_derivative(hidden_layer_output)

    # Ajuste de pesos
    d_weights_input_hidden = np.dot(X.T, hidden_delta)
    d_weights_hidden_output = np.dot(hidden_layer_output.T, output_delta)

    return d_weights_input_hidden, d_weights_hidden_output

# Backward pass
d_weights_input_hidden, d_weights_hidden_output = backward_pass(X, y, hidden_layer_output, y_pred, weights_input_hidden, weights_hidden_output)

En este código, output_error es la diferencia entre la predicción y el valor real. Este error se propaga hacia atrás a través de las capas ocultas, calculándose los errores y deltas en cada capa.

Errores típicos / trampas

1. Gradientes que explotan: Si los valores de los gradientes crecen exponencialmente durante el backward pass, puede llevar a la divergencia del optimizador. Esto sucede cuando los pesos son demasiado grandes o cuando se usa una función de activación como Tanh con salida en (-1, 1).

1. Gradientes que desaparecen: A menudo ocurre en las redes profundas cuando los gradientes se vuelven tan pequeños que parecen "desaparecer". Esto es un problema particular en el uso de funciones de activación sigmoide y Tanh.

1. Pesos inicializados mal: Pesos iniciales demasiado grandes o pequeños pueden llevar a la divergencia del optimizador. Es importante inicializar los pesos adecuadamente, típicamente con valores aleatorios de distribución normal estándar (mean = 0, std = 1).

Checklist accionable

1. Inicializa los pesos correctamente: Usa una distribución apropiada para inicializar los pesos.
2. Elije la función de activación adecuada: La elección de la función de activación puede afectar drásticamente el rendimiento del modelo.
3. Comprueba la normalización de datos: Asegúrate de que tus datos están correctamente normalizados para mejorar la convergencia.
4. Monitorea los gradientes durante el entrenamiento: Utiliza herramientas de visualización para monitorear si los gradientes crecen o desaparecen.
5. Utiliza optimizadores efectivos: Experimenta con diferentes optimizadores como Adam, RMSprop, etc., para mejorar la convergencia del modelo.

Siguientes pasos

1. Aprende sobre redes neuronales profundas: Explora cómo se aplican estos conceptos a modelos más complejos.
2. Practica con datos reales: Trata de implementar el backpropagation en un conjunto de datos real y observa cómo cambia la convergencia del modelo.
3. Explora técnicas avanzadas de optimización: Aprende sobre regularización, aprendizaje por lotes, etc., para mejorar aún más el rendimiento del modelo.

Última actualización: 2025-12-26