Multiplicación de matrices para implementar la propagación hacia adelante de redes neuronales

Implementa manualmente \(y = Wx + b\), introduce matrices de diferentes formas y observa cómo cambian y coinciden las dimensiones.

Al completar este caso práctico, entenderás:Al entrenar una red neuronal, el error shape mismatch se debe esencialmente a que las dimensiones de la multiplicación de matrices no coinciden.


Introducción desde la vida cotidiana

Centro de clasificación de paquetería

Un lote de paquetes entra por la cinta transportadora (entrada), se desvía mediante clasificadoras a diferentes camiones (capa oculta) y finalmente se entrega a distintas comunidades (salida).

Cada clasificadora es una «neurona»: recibe todos los paquetes y, según sus reglas, decide qué paquetes toman su propio camino. Las reglas de la clasificadora son los «pesos»: asignar más paquetes hacia una dirección y menos hacia otra.

El funcionamiento de todo el centro de clasificación es:Multiplicación de matrices + función de activación + sesgo。


Comprensión intuitiva

Una capa de red neuronal = tres pasos, todo en una línea de código:

\( z = X @ W + b \)

Cada parte tiene un rol bien definido:

X
Datos de entrada
(batch, in)
W
Matriz de pesos
(in, out)
b
Sesgo
(out,)
z
Salida
(batch, out)
Regla de hierro para la coincidencia de dimensiones:¡El número de columnas de A debe ser igual al número de filas de B! \(A_{(m \times n)} \cdot B_{(n \times p)} = C_{(m \times p)}\)

El número de características de entrada (in_features) debe ser igual al número de filas de la matriz de pesos. El número de características de salida (out_features) es igual al número de columnas de la matriz de pesos. El batch_size permanece constante durante todo el proceso.


Definición matemática

Propagación hacia adelante de una sola capa

\[ z_j = \sum_{i=1}^{n} x_i \cdot W_{ij} + b_j \]

Cada salida \(z_j\) es el producto punto del vector de entrada con la columna \(j\)-ésima de la matriz de pesos, más el sesgo.

Dos capas de red en serie

\[ \begin{aligned} h &= \text{ReLU}(X W_1 + b_1) \quad & (m \times 4) \cdot (4 \times 6) &= (m \times 6) \\ o &= \text{Sigmoid}(h W_2 + b_2) \quad & (m \times 6) \cdot (6 \times 2) &= (m \times 2) \end{aligned} \]

Nota: el número de características de salida de la primera capa (6) debe ser igual al número de filas de la matriz de pesos de la segunda capa (6). Esto es lo que se llama «conexión dimensional entre capas».


Práctica con Python

Usa una función genérica dense_layer para demostrar tres escenarios: muestra única, procesamiento por lotes y red de dos capas.

Ejemplos

import numpy as np

def dense_layer(X, W, b, activation=None):
    """
Propagación hacia adelante de una red de una capa totalmente conectada
X: matriz de entrada (batch_size, in_features)
W: matriz de pesos (in_features, out_features)
b: vector de sesgo (out_features,)
    """

    z = X @ W + b   # Multiplicación de matrices + suma por broadcasting
    if activation == "relu":
        return np.maximum(0, z)          # ReLU: los negativos se convierten en 0
    if activation == "sigmoid":
        return 1 / (1 + np.exp(-z))      # Sigmoid: comprime a (0,1)
    return z

print("=" * 55)
print("EJEMPLO Escenario 1: muestra única, 4 dimensiones -> 3 dimensiones")
print("=" * 55)
X = np.array([[1.0, 2.0, 0.5, -1.0]])     # (1, 4)
W = np.random.randn(4, 3) * 0.5            # (4, 3)
b = np.zeros(3)                            # (3,)
y = dense_layer(X, W, b, activation="relu")
print("X.shape:", X.shape, "  W.shape:", W.shape,
      "  ->  y.shape:", y.shape)

print("\n" + "=" * 55)
print("EJEMPLO Escenario 2: lote de 8 muestras, mismos pesos")
print("=" * 55)
X_batch = np.random.randn(8, 4)            # (8, 4)
y_batch = dense_layer(X_batch, W, b, activation="relu")
print("X_batch.shape:", X_batch.shape,
      "  ->  y_batch.shape:", y_batch.shape)
print("El tamaño del lote (8) no cambia; las características pasan de 4 -> 3")

print("\n" + "=" * 55)
print("EJEMPLO Escenario 3: apilar una red de dos capas")
print("=" * 55)
# Primera capa: 4 dimensiones -> 6 dimensiones + ReLU
W1 = np.random.randn(4, 6) * 0.5
b1 = np.zeros(6)
# Segunda capa: 6 dimensiones -> 2 dimensiones + Sigmoid
W2 = np.random.randn(6, 2) * 0.5
b2 = np.zeros(2)

h = dense_layer(X_batch, W1, b1, activation="relu")
out = dense_layer(h, W2, b2, activation="sigmoid")

print(f"Capa de entrada: {X_batch.shape}")
print(f"Capa oculta: {h.shape} (4->6, W1=(4,6))")
print(f"Capa de salida: {out.shape} (6->2, W2=(6,2))")

# Verificación: ¿qué sucede si las dimensiones no coinciden?
print("\n" + "=" * 55)
print("EJEMPLO Escenario 4: la falta de coincidencia de dimensiones genera un error")
print("=" * 55)
try:
    W_wrong = np.random.randn(5, 3) * 0.5  # El número de filas es incorrecto
    dense_layer(X_batch, W_wrong, b)
except ValueError as e:
    print("Motivo del error: X_batch tiene 4 columnas,"
          "W_wrong tiene 5 filas -> no se pueden multiplicar")
    print(f" Lo correcto: el número de filas de W ({W_wrong.shape
          f" debe ser igual al número de columnas de X ({X_batch.shape)
=======================================================
EJEMPLO 场景 1:单样本,4 维 -> 3 维
=======================================================
X.shape: (1, 4)   W.shape: (4, 3)   ->  y.shape: (1, 3)

=======================================================
EJEMPLO 场景 2:8 个样本批量,同权重
=======================================================
X_batch.shape: (8, 4)   ->  y_batch.shape: (8, 3)
批大小 8 不变,特征维度 4 -> 3

=======================================================
EJEMPLO 场景 3:堆叠两层网络
=======================================================
输入层: (8, 4)
隐藏层: (8, 6)  (4->6, W1=(4,6))
输出层: (8, 2)  (6->2, W2=(6,2))

=======================================================
EJEMPLO 场景 4:维度不匹配会报错
=======================================================
报错原因:X_batch 有 4 列,W_wrong 有 5 行 -> 无法相乘
  正确做法:W 的行数 (5) 应等于 X 的列数 (4)

Escenarios de aplicación en IA

Escenario de IAEjemplo de cambio de dimensionesDescripción
Capa totalmente conectada(32, 784) @ (784, 128) = (32, 128)Clasificación MNIST: 28x28=784 píxeles → características de 128 dimensiones
QKV del Transformer(B, L, D) @ (D, D) = (B, L, D)Autoatención: la dimensión de los tokens de entrada y salida no cambia
Búsqueda en tabla de embeddings(B, L) → (B, L, D)Secuencia de ID de palabras → secuencia de vectores de palabras
Cabeza de clasificación(B, 768) @ (768, 10) = (B, 10)Salida de clasificación de la última capa de BERT
Otras extensiones