Inicialización de Pesos

❓ ¿Por qué importa la inicialización?

Antes de que el entrenamiento comience, los pesos de una red neuronal deben tener algún valor inicial. Esta decisión, aparentemente trivial, tiene consecuencias profundas en si la red podrá aprender y con qué velocidad lo hará.

La inicialización de pesos es un problema que se agravó enormemente con la llegada del deep learning. En redes poco profundas (1-2 capas ocultas), una inicialización aleatoria genérica suele funcionar razonablemente bien. Pero a medida que las redes se hacen más profundas — 10, 50, 100 o incluso 1000 capas — las señales que se propagan a través de la red (tanto en el forward como en el backward pass) pasan por multiplicaciones sucesivas. Si esas multiplicaciones no están cuidadosamente calibradas, la señal se amplifica hasta el infinito o se desvanece hasta cero, haciendo el entrenamiento imposible. Este fenómeno está íntimamente relacionado con los problemas de vanishing y exploding gradients que estudiaremos en el submódulo de Estabilidad del Entrenamiento.

Recuerda que durante el forward pass, cada capa computa:

Si los pesos \mathbf{W} no se eligen cuidadosamente, las activaciones \mathbf{a}^{(l)} pueden colapsar a cero, saturarse, o explotar — todo antes de dar un solo paso de optimización.

🚫 Inicialización a cero (y a constante)

Todo ceros: W = 0

Parece intuitivo empezar con todos los pesos a cero. Pero es la peor elección posible:

Todas las neuronas de una capa producen exactamente la misma salida (solo depende del bias, que suele inicializarse a cero también). Esto significa:

• Todas las neuronas reciben el mismo gradiente durante backpropagation.
• Todas se actualizan de la misma forma.
• Tras cualquier número de épocas, todas siguen siendo idénticas.

Todo unos: W = 1

Igual de problemático. Todas las neuronas computan lo mismo, y además las activaciones crecen descontroladamente al pasar por las capas (cada capa multiplica por la suma de todas las entradas), causando saturación en funciones como sigmoid/tanh y activaciones enormes con ReLU.

Cualquier constante: W = c

El mismo problema de simetría aplica a cualquier valor constante. El problema no es el valor específico, es que todos los pesos son iguales.

🎲 Inicialización aleatoria naïf

La primera idea es inicializar los pesos con valores aleatorios de una distribución normal o uniforme. Pero, ¿con qué varianza?

Varianza demasiado grande

Si usamos W \sim \mathcal{N}(0, 1) (varianza = 1), las pre-activaciones z = \mathbf{W}\mathbf{a} tienen varianza:

Con n_{\text{in}} = 256 neuronas, la varianza de las pre-activaciones es 256 veces mayor que la de las activaciones de la capa anterior. En una red con 10 capas de 256 neuronas, las pre-activaciones de la última capa tendrían varianza 256^{10} \approx 10^{24}. Las activaciones saturan inmediatamente (sigmoid/tanh) o explotan (ReLU).

Varianza demasiado pequeña

Si usamos W \sim \mathcal{N}(0, 0.001), las activaciones se comprimen hacia cero progresivamente. Después de pocas capas, todas las activaciones son prácticamente cero y los gradientes se desvanecen.

Ejemplo: propagación de la varianza

Para entender el problema formalmente, consideremos una capa lineal (sin activación) con n_{\text{in}} entradas:

Esto asume que los pesos y las activaciones son independientes con media cero (razonable para sigmoid centrada y tanh). La varianza se multiplica por n_\text{in} \cdot \sigma_w^2 en cada capa. Para que se mantenga estable, necesitamos:

📐 Inicialización Xavier / Glorot

En 2010, Xavier Glorot y Yoshua Bengio publicaron "Understanding the difficulty of training deep feedforward neural networks" (AISTATS 2010), donde formalizaron el problema de la propagación de la varianza y propusieron una solución elegante.

Motivación: preservar la varianza en ambos sentidos

Vimos que para mantener la varianza de las activaciones estable en el forward pass, necesitamos:

Pero durante el backward pass, los gradientes se propagan en dirección opuesta, y la condición análoga para preservar la varianza de los gradientes es:

Estas dos condiciones son incompatibles cuando n_\text{in} \neq n_\text{out}. Glorot y Bengio propusieron un compromiso: usar la media armónica de ambas:

Derivación paso a paso

Distribuciones

La inicialización Xavier puede implementarse con dos distribuciones:

¿Cuándo usar Xavier?

Análisis gráfico

La derivación de Xavier asume que la función de activación es lineal en la zona donde opera. Para tanh, esto es cierto cuando las pre-activaciones son pequeñas (la zona lineal alrededor de cero). Justamente, una buena inicialización mantiene las pre-activaciones en esta zona:

🔥 Inicialización He / Kaiming

En 2015, Kaiming He, Xiangyu Zhang, Shaoqing Ren y Jian Sun publicaron "Delving Deep into Rectifiers" (arXiv:1502.01852), extendiendo el análisis de Xavier para activaciones ReLU. Hoy, He (Kaiming) es la inicialización estándar para redes con ReLU y sus variantes.

¿Por qué Xavier falla con ReLU?

ReLU elimina todas las activaciones negativas: \text{ReLU}(z) = \max(0, z). Esto significa que, en promedio, la mitad de las neuronas producen cero. Si partimos del análisis de Xavier:

El factor \frac{1}{2} proviene de que ReLU pone a cero exactamente la mitad de las entradas (asumiendo entrada simétrica alrededor de cero). Esto significa que con Xavier, la varianza se divide por 2 en cada capa:

Derivación de He

Fórmula de He

La diferencia con Xavier es simplemente el factor 2 en el numerador (Xavier tiene \frac{2}{n_\text{in}+n_\text{out}}, y cuando n_\text{in} = n_\text{out} esto se reduce a \frac{1}{n_\text{in}} — exactamente la mitad de He). Este factor compensa las neuronas muertas de ReLU.

Aunque la diferencia parezca un simple factor de 2, su impacto en la práctica es enorme. Con Xavier y ReLU, la varianza de las activaciones se divide por 2 en cada capa. En una red con 20 capas, las activaciones de la última capa tendrían una varianza 2^{20} \approx 10^6 veces menor que las de la primera. Los gradientes sufrirían el mismo decaimiento en dirección contraria, haciendo que las capas iniciales fueran esencialmente «inentrenables». La inicialización He corrige este desequilibrio y es la razón por la que redes profundas con ReLU pueden entrenarse de forma efectiva.

fan_in vs. fan_out

Al igual que Xavier, He puede derivarse para el forward (usando n_\text{in}) o para el backward (usando n_\text{out}):

Distribuciones

Variantes para Leaky ReLU

Para Leaky ReLU con pendiente negativa \alpha, la fracción de varianza preservada no es \frac{1}{2} sino:

Con \alpha = 0 (ReLU estándar), se recupera \frac{2}{n_\text{in}}. Con \alpha = 1 (lineal), se obtiene \frac{1}{n_\text{in}}, que es Xavier.

¿Cuándo usar He?

⚖️ Xavier vs. He: resumen comparativo

🧬 Inicialización LeCun

Antes de Xavier y He, Yann LeCun propuso en 1998 (Efficient BackProp — LeCun et al., 1998) una inicialización basada únicamente en n_\text{in}:

Es idéntica a Xavier cuando n_\text{in} = n_\text{out}, y puede verse como un caso especial de He con un factor \frac{1}{2}. Actualmente se recomienda para redes con activaciones SELU (Self-Normalizing Neural Networks, Klambauer et al., 2017), donde las propiedades auto-normalizantes de SELU requieren pesos con esta varianza específica.

📏 Inicialización ortogonal

La inicialización ortogonal (Saxe et al., 2014 — arXiv:1312.6120) inicializa la matriz de pesos como una matriz ortogonal (o semi-ortogonal si no es cuadrada). Esto se logra generando una matriz aleatoria y aplicando descomposición QR o SVD:

donde g es un factor de ganancia que depende de la activación.

¿Por qué funciona?

Una matriz ortogonal \mathbf{W} satisface \mathbf{W}^T \mathbf{W} = \mathbf{I}. Esto significa que:

• Todos sus valores singulares son 1.
• Preserva exactamente la norma de los vectores que multiplica: \|\mathbf{W}\mathbf{x}\| = \|\mathbf{x}\|.
• Los gradientes tampoco se amplifican ni se reducen.

Tabla de ganancias

🔬 LSUV: inicialización data-driven

Layer-Sequential Unit-Variance (Mishkin & Matas, 2016 — arXiv:1511.06422) es un método que no se basa en fórmulas teóricas sino en datos reales. El proceso:

1. Inicializar cada capa con matrices ortogonales.
2. Para cada capa (secuencialmente), pasar un mini-batch por la red.
3. Medir la varianza de la salida de esa capa.
4. Re-escalar los pesos dividiendo por \sqrt{\text{Var}_\text{observada}}.
5. Repetir hasta que la varianza sea ≈ 1.

🔧 Fixup y otras inicializaciones para redes residuales

Las redes residuales (ResNets) presentan un desafío particular: la conexión residual y = x + F(x) acumula varianza con cada bloque. Con L bloques:

Fixup (Zhang et al., 2019 — arXiv:1901.09321) propone escalar la última capa de cada bloque residual por \frac{1}{\sqrt{L}} o inicializarla a cero, de modo que al inicio del entrenamiento la red se comporta como la identidad:

Otras técnicas para ResNets incluyen:

• Zero-init residual: inicializar la última BatchNorm de cada bloque con \gamma = 0, efecto similar a Fixup.
• ReZero (Bachlechner et al., 2021): usar un escalar aprendible \alpha inicializado a 0 en cada conexión residual.

🌌 Inicialización sparse

La inicialización sparse (Martens, 2010) fija la mayoría de los pesos a cero y solo inicializa un número fijo de conexiones por neurona (típicamente 15). Los pesos no-cero se inicializan con varianza adecuada. Esto:

• Garantiza que cada neurona recibe un número fijo de señales de entrada, independientemente del ancho de la capa.
• Evita la dependencia de la varianza con n_\text{in}.
• Se ha usado principalmente en redes tipo DBN y autoencoders.

📊 Tabla comparativa completa

Resumen de todas las inicializaciones discutidas:

🔶 Inicializaciones en PyTorch

PyTorch proporciona todas las inicializaciones a través de torch.nn.init. Por defecto, las capas Linear y Conv2d usan Kaiming Uniform.

import torch
import torch.nn as nn

# Xavier Normal
nn.init.xavier_normal_(layer.weight)

# Xavier Uniform
nn.init.xavier_uniform_(layer.weight)

# En un modelo completo
class MLP(nn.Module):
    def __init__(self, in_features, hidden, out_features):
        super().__init__()
        self.fc1 = nn.Linear(in_features, hidden)
        self.fc2 = nn.Linear(hidden, hidden)
        self.fc3 = nn.Linear(hidden, out_features)

        # Aplicar Xavier a todas las capas
        for m in self.modules():
            if isinstance(m, nn.Linear):
                nn.init.xavier_normal_(m.weight)
                nn.init.zeros_(m.bias)

    def forward(self, x):
        x = torch.tanh(self.fc1(x))  # tanh — ideal para Xavier
        x = torch.tanh(self.fc2(x))
        return self.fc3(x)

import torch.nn as nn

# Kaiming Normal (fan_in, ReLU)
nn.init.kaiming_normal_(layer.weight, mode='fan_in', nonlinearity='relu')

# Kaiming Uniform (fan_in, ReLU)
nn.init.kaiming_uniform_(layer.weight, mode='fan_in', nonlinearity='relu')

# Para Leaky ReLU
nn.init.kaiming_normal_(layer.weight, mode='fan_in',
                        nonlinearity='leaky_relu')  # usa a=0.01

# En un modelo CNN
class ConvNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 64, 3, padding=1)
        self.conv2 = nn.Conv2d(64, 128, 3, padding=1)
        self.fc = nn.Linear(128 * 8 * 8, 10)

        # He/Kaiming para capas con ReLU
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out',
                                        nonlinearity='relu')
                if m.bias is not None:
                    nn.init.zeros_(m.bias)
            elif isinstance(m, nn.Linear):
                nn.init.kaiming_normal_(m.weight)
                nn.init.zeros_(m.bias)

    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = torch.relu(self.conv2(x))
        x = x.view(x.size(0), -1)
        return self.fc(x)

import torch.nn as nn

# No existe nn.init.lecun_*, pero es equivalente a:
# Normal: std = 1 / sqrt(fan_in)
fan_in = layer.weight.shape[1]
nn.init.normal_(layer.weight, mean=0, std=(1.0 / fan_in) ** 0.5)

# O manualmente usando kaiming con nonlinearity='linear':
nn.init.kaiming_normal_(layer.weight, mode='fan_in',
                        nonlinearity='linear')

# Modelo con SELU
class SelfNormMLP(nn.Module):
    def __init__(self, in_f, hidden, out_f):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(in_f, hidden),
            nn.SELU(),
            nn.AlphaDropout(0.05),
            nn.Linear(hidden, hidden),
            nn.SELU(),
            nn.AlphaDropout(0.05),
            nn.Linear(hidden, out_f),
        )
        # LeCun init para SELU
        for m in self.modules():
            if isinstance(m, nn.Linear):
                nn.init.kaiming_normal_(m.weight, mode='fan_in',
                                        nonlinearity='linear')
                nn.init.zeros_(m.bias)

    def forward(self, x):
        return self.net(x)

import torch.nn as nn

# Ortogonal con ganancia para ReLU
nn.init.orthogonal_(layer.weight, gain=nn.init.calculate_gain('relu'))

# Ganancias predefinidas
gain_relu  = nn.init.calculate_gain('relu')       # √2
gain_tanh  = nn.init.calculate_gain('tanh')       # 5/3
gain_lrelu = nn.init.calculate_gain('leaky_relu', param=0.2)

# Ejemplo para RNN
class CustomRNN(nn.Module):
    def __init__(self, input_size, hidden_size):
        super().__init__()
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)

        # Ortogonal para recurrencia (crucial en RNNs)
        for name, param in self.rnn.named_parameters():
            if 'weight_hh' in name:
                nn.init.orthogonal_(param)
            elif 'weight_ih' in name:
                nn.init.xavier_uniform_(param)
            elif 'bias' in name:
                nn.init.zeros_(param)

    def forward(self, x):
        return self.rnn(x)

import torch
import torch.nn as nn

def check_activation_stats(model, input_shape=(64, 784)):
    """Registra la media y varianza de activaciones por capa."""
    activations = {}

    def hook_fn(name):
        def hook(module, input, output):
            activations[name] = output.detach()
        return hook

    hooks = []
    for name, layer in model.named_modules():
        if isinstance(layer, (nn.Linear, nn.Conv2d)):
            hooks.append(layer.register_forward_hook(hook_fn(name)))

    # Forward con datos aleatorios
    x = torch.randn(*input_shape)
    with torch.no_grad():
        model(x)

    # Imprimir estadísticas
    for name, act in activations.items():
        print(f"{name:20s} | media={act.mean():.4f} | "
              f"std={act.std():.4f} | "
              f"% ceros={100*(act==0).float().mean():.1f}%")

    # Limpiar hooks
    for h in hooks:
        h.remove()

# Uso:
# model = MLP(784, 256, 10)
# check_activation_stats(model)

🟠 Inicializaciones en TensorFlow / Keras

En TensorFlow/Keras, las inicializaciones se pasan como el argumento kernel_initializer de cada capa. Por defecto, Dense usa Glorot Uniform (Xavier Uniform).

import tensorflow as tf
from tensorflow import keras
from keras import layers

# Glorot/Xavier Normal
init_glorot_n = keras.initializers.GlorotNormal()

# Glorot/Xavier Uniform (DEFAULT para Dense)
init_glorot_u = keras.initializers.GlorotUniform()

model = keras.Sequential([
    layers.Dense(256, activation='tanh',
                 kernel_initializer='glorot_normal',      # string
                 bias_initializer='zeros'),
    layers.Dense(256, activation='tanh',
                 kernel_initializer=init_glorot_n),        # objeto
    layers.Dense(10, activation='softmax',
                 kernel_initializer='glorot_uniform'),
])

# Nota: Dense() sin kernel_initializer ya usa GlorotUniform
model_default = keras.Sequential([
    layers.Dense(256, activation='tanh'),   # Glorot Uniform implícito
    layers.Dense(10, activation='softmax'),
])

import tensorflow as tf
from tensorflow import keras
from keras import layers

# He Normal
init_he_n = keras.initializers.HeNormal()

# He Uniform
init_he_u = keras.initializers.HeUniform()

# Modelo CNN con He
model = keras.Sequential([
    layers.Conv2D(64, 3, padding='same', activation='relu',
                  kernel_initializer='he_normal'),
    layers.BatchNormalization(),
    layers.Conv2D(128, 3, padding='same', activation='relu',
                  kernel_initializer='he_normal'),
    layers.BatchNormalization(),
    layers.GlobalAveragePooling2D(),
    layers.Dense(10, activation='softmax',
                 kernel_initializer='glorot_uniform'),
])

# Con Leaky ReLU (usar VarianceScaling directamente)
init_leaky = keras.initializers.VarianceScaling(
    scale=2.0,
    mode='fan_in',
    distribution='truncated_normal'
)

model_leaky = keras.Sequential([
    layers.Dense(256, kernel_initializer=init_leaky),
    layers.LeakyReLU(0.2),
    layers.Dense(10, activation='softmax'),
])

from tensorflow import keras
from keras import layers

# LeCun Normal
init_lecun_n = keras.initializers.LecunNormal()

# LeCun Uniform
init_lecun_u = keras.initializers.LecunUniform()

# Modelo SELU auto-normalizante
model = keras.Sequential([
    layers.Dense(256, activation='selu',
                 kernel_initializer='lecun_normal'),
    layers.AlphaDropout(0.05),
    layers.Dense(256, activation='selu',
                 kernel_initializer='lecun_normal'),
    layers.AlphaDropout(0.05),
    layers.Dense(10, activation='softmax'),
])

from tensorflow import keras
from keras import layers

# Ortogonal con ganancia
init_ortho = keras.initializers.Orthogonal(gain=1.0)

# Para RNN
model = keras.Sequential([
    layers.SimpleRNN(128, return_sequences=True,
                     kernel_initializer='glorot_uniform',
                     recurrent_initializer='orthogonal'),   # default!
    layers.SimpleRNN(64,
                     kernel_initializer='glorot_uniform',
                     recurrent_initializer=keras.initializers.Orthogonal(
                         gain=1.0
                     )),
    layers.Dense(10, activation='softmax'),
])

# Nota: las capas RNN de Keras ya usan ortogonal por defecto
# para recurrent_initializer. ¡No necesitas cambiarlo!

from tensorflow import keras

# VarianceScaling es la base de todas las demás:
# GlorotUniform  = VarianceScaling(scale=1, mode='fan_avg', dist='uniform')
# GlorotNormal   = VarianceScaling(scale=1, mode='fan_avg', dist='truncated_normal')
# HeNormal       = VarianceScaling(scale=2, mode='fan_in',  dist='truncated_normal')
# HeUniform      = VarianceScaling(scale=2, mode='fan_in',  dist='uniform')
# LecunNormal    = VarianceScaling(scale=1, mode='fan_in',  dist='truncated_normal')
# LecunUniform   = VarianceScaling(scale=1, mode='fan_in',  dist='uniform')

# Personalizado: He para Leaky ReLU con α=0.2
alpha = 0.2
custom_init = keras.initializers.VarianceScaling(
    scale=2.0 / (1 + alpha**2),   # ≈ 1.923
    mode='fan_in',
    distribution='truncated_normal',
    seed=42
)

# Parámetros:
#   scale:        factor multiplicativo de la varianza
#   mode:         'fan_in', 'fan_out', o 'fan_avg'
#   distribution: 'truncated_normal', 'untruncated_normal', o 'uniform'

📋 Resumen: correspondencias entre frameworks