Multiplicación de matrices en redes neuronales

Dentro de cada capa de una red neuronal ocurre una multiplicación de matrices. Es la operación que combina todas las entradas con todos los pesos de golpe y produce el resultado que pasa a la siguiente capa. Entender esa operación, sus reglas de dimensiones y su coste es entender de verdad cómo calcula una red. Esta guía la explica desde cero, con un ejemplo numérico paso a paso. La misma explicación está disponible en inglés.

Puntos clave

• La multiplicación de matrices de las redes neuronales agrupa los pesos de una capa en una matriz W y calcula la salida como Z = W · X.
• Para multiplicar dos matrices, el número de columnas de la primera debe coincidir con el número de filas de la segunda; el resultado hereda las filas de una y las columnas de la otra.
• Procesar varios ejemplos a la vez (un batch) solo añade columnas a X: la misma matriz de pesos sirve para 1 o para 32 ejemplos sin cambiar nada.
• El coste de multiplicar una matriz m × n por otra n × p es de unas 2 · m · n · p operaciones, y ahí está el 90 % del trabajo de una red.
• Un modelo como GPT-3, con 175.000 millones de parámetros, no es más que muchísimas de estas multiplicaciones encadenadas y ejecutadas en paralelo.

Reglas de la multiplicación de matrices

Multiplicar matrices no es multiplicar elemento a elemento. La regla es distinta y tiene dos partes que conviene fijar antes de seguir.

La primera es la regla de las dimensiones. Si $\mathbf{A} \in \mathbb{R}^{m \times n}$ (m filas, n columnas) y $\mathbf{B} \in \mathbb{R}^{n \times p}$, entonces el producto $\mathbf{A}\mathbf{B}$ existe y tiene forma $m \times p$:

$$\mathbf{A} \in \mathbb{R}^{m \times n},\quad \mathbf{B} \in \mathbb{R}^{n \times p} \;\Longrightarrow\; \mathbf{A}\mathbf{B} \in \mathbb{R}^{m \times p}$$

Las dos dimensiones interiores deben coincidir (la $n$) y desaparecen; las dos exteriores ($m$ y $p$) son las del resultado. Si esas dimensiones interiores no cuadran, la operación no está definida y el programa fallará.

La segunda es cómo se calcula cada número del resultado. El elemento de la fila $i$ y la columna $j$ de $\mathbf{A}\mathbf{B}$ es el producto escalar entre la fila $i$ de $\mathbf{A}$ y la columna $j$ de $\mathbf{B}$:

$$(\mathbf{A}\mathbf{B}){ij} = \sum{k=1}^{n} A{ik}\,B{kj}$$

Se emparejan término a término, se multiplican y se suman. Ese producto escalar es la misma operación que estudiamos en el producto escalar y la neurona. Por eso una matriz por un vector no es más que un producto escalar repetido, uno por cada fila.

Una advertencia importante: el orden importa. En general $\mathbf{A}\mathbf{B}$ no es igual a $\mathbf{B}\mathbf{A}$, y muchas veces uno de los dos productos ni siquiera existe porque las dimensiones no encajan.

Por qué una capa es una multiplicación de matrices

Imagina una capa con 3 entradas y 2 neuronas de salida. Cada neurona tiene su propio conjunto de 3 pesos, uno por entrada. Si escribimos los pesos de la primera neurona en una fila y los de la segunda en otra, obtenemos una matriz W de forma 2 × 3. Las entradas forman un vector x de forma 3 × 1.

La salida de la capa antes de la activación es z = Wx + b, donde b es el vector de sesgos. La multiplicación Wx produce un vector de forma 2 × 1: cada componente es el producto escalar entre una fila de pesos y las entradas, es decir, exactamente lo que calcula una neurona. Sumar el sesgo y aplicar la función de activación a = f(z) completa la capa.

Este es el punto clave: en lugar de programar cada neurona por separado con un bucle, una sola multiplicación de matrices calcula todas las neuronas de la capa a la vez. Como las tarjetas gráficas están diseñadas justo para multiplicar matrices grandes muy deprisa, este planteamiento es el que hace viable el aprendizaje profundo. Todo el recorrido matemático que hay detrás está en las matemáticas detrás de las redes neuronales.

Como resumen Goodfellow, Bengio y Courville en su libro Deep Learning, «una buena comprensión del álgebra lineal es esencial para entender y trabajar con muchos algoritmos de aprendizaje automático, en especial los de aprendizaje profundo».

Batches: procesar muchos ejemplos a la vez

Rara vez se pasa un solo ejemplo por la red. Lo habitual es procesar un grupo (un batch) de varios ejemplos juntos, porque así se aprovecha mejor el hardware. La multiplicación de matrices absorbe ese cambio sin ningún esfuerzo.

En vez de un vector x de forma 3 × 1, apilamos 32 ejemplos como columnas y formamos una matriz X de forma 3 × 32. La operación sigue siendo la misma, Z = W · X: ahora W es 2 × 3 y X es 3 × 32, así que Z sale 2 × 32. Cada columna de Z es la salida de un ejemplo distinto. La matriz de pesos no cambia; solo crece el número de columnas de la entrada.

Por eso la fórmula de la portada usa mayúsculas, Z = W · X: la X en mayúscula señala que tratamos con un lote de ejemplos, no con uno solo. Un batch de 32 o de 256 ejemplos se calcula con la misma línea de código.

Coste computacional

Multiplicar matrices tiene un precio, y saber cuál ayuda a entender por qué entrenar modelos grandes cuesta tanto. Multiplicar una matriz m × n por otra n × p requiere del orden de m · n · p multiplicaciones y otras tantas sumas, es decir, unas 2 · m · n · p operaciones en coma flotante.

Un ejemplo con números: una capa que transforma un vector de 1.000 entradas en 1.000 salidas usa una matriz 1000 × 1000, es decir, un millón de pesos. Multiplicarla por un batch de 100 ejemplos cuesta unos 200 millones de operaciones para una sola capa. Multiplica eso por decenas de capas y por millones de pasos de entrenamiento y se entiende por qué se necesitan las GPU.

La documentación de NumPy^[1] explica que su función matmul delega en bibliotecas de álgebra lineal muy optimizadas (BLAS) para que estas operaciones vuelen. La mayor parte del tiempo de cómputo de una red, tanto al entrenar como al predecir, se va en estas multiplicaciones.

Ejemplo paso a paso

Hagamos el cálculo completo de una capa con 3 entradas y 2 salidas. Los pesos son:

W = [ 1   0   2 ]      x = [ 2 ]      b = [  1 ]
    [ 0   3   1 ]          [ 1 ]          [ -2 ]
                          [ 4 ]

z = W·x + b

fila 1:  1·2 + 0·1 + 2·4 = 10   ->  10 + 1  = 11
fila 2:  0·2 + 3·1 + 1·4 =  7   ->   7 - 2  =  5

z = [ 11 ]
    [  5 ]

La primera componente, 11, es el producto escalar de la primera fila de pesos con las entradas más el primer sesgo; la segunda, 5, hace lo mismo con la segunda fila. Al aplicar una activación como ReLU, que deja pasar los positivos, la salida sería a = [11, 5]. Con esos dos números listos, la siguiente capa repetiría exactamente el mismo procedimiento con su propia matriz de pesos.

Preguntas frecuentes

¿Cuál es la diferencia entre multiplicar matrices y multiplicar elemento a elemento?

Multiplicar elemento a elemento (producto de Hadamard) exige que las dos matrices tengan la misma forma y multiplica cada posición con su homóloga. La multiplicación de matrices, en cambio, combina filas con columnas mediante productos escalares y sigue la regla de dimensiones m × n por n × p. En una red neuronal, la operación de la capa es la segunda; el producto elemento a elemento aparece en otras partes, como algunas puertas de las redes recurrentes.

¿Por qué las GPU son tan buenas para las redes neuronales?

Porque una tarjeta gráfica tiene miles de núcleos capaces de hacer muchas multiplicaciones y sumas a la vez, y la multiplicación de matrices es justo eso: miles de productos escalares independientes. Una GPU moderna alcanza decenas de billones de operaciones por segundo, muy por encima de una CPU, y como el 90 % del cálculo de una red son multiplicaciones de matrices, ese paralelismo se traduce en un entrenamiento mucho más rápido.

¿Qué pasa si las dimensiones no coinciden?

La operación no está definida y la biblioteca lanza un error de forma (shape mismatch). Es el fallo más común al construir una red a mano: hay que comprobar que el número de columnas de la matriz de pesos coincide con el número de filas del vector o la matriz de entrada. Llevar la cuenta de las formas m × n en cada capa evita la mayoría de estos problemas.

Conclusión

La multiplicación de matrices es el motor silencioso de cualquier red neuronal: una sola operación, Z = W · X, calcula toda una capa, se adapta sin esfuerzo a lotes de ejemplos y concentra casi todo el coste de cómputo. Dominar sus reglas de dimensiones y su significado geométrico convierte el resto del aprendizaje profundo en un terreno mucho más firme. El siguiente paso natural es repasar el producto escalar y la neurona y luego ver cómo se encadenan las capas en las matemáticas detrás de las redes neuronales.

Fuentes

1. NumPy
2. Mathematics for Machine Learning (Deisenroth, Faisal y Ong)
3. Deep Learning (Goodfellow, Bengio y Courville)
4. Multiplicación de matrices (Wikipedia)

Ruta: Fundamentos matemáticos de las redes neuronales