Multiplicación matricial

La operación que conecta capas completas en redes neuronales

La multiplicación matricial es una operación entre matrices (o matriz y vector) que permite transformar datos de un espacio a otro. Es una de las operaciones más importantes en redes neuronales, ya que cada capa de una red se basa en esta operación.

Si el producto escalar describe una neurona, la multiplicación matricial describe una capa completa de neuronas trabajando en paralelo.

Definición corta

La multiplicación matricial combina una matriz y un vector (o dos matrices) para producir una nueva estructura mediante productos escalares entre filas y columnas.

Definición detallada

Dada una matriz $W$ W de tamaño $m \times n$ m×n y un vector $x$ x de tamaño $n$ n: $z = W \cdot x$ z=W⋅x

El resultado es un vector de tamaño $m$ m.

Cada elemento de $z$ z se calcula como el producto escalar entre:

una fila de $W$ W
el vector $x$ x

Ejemplo básico

$W = \begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix} , \quad x = \begin{bmatrix} 5 \\ 6 \end{bmatrix}$ W=[1324],x=[56]

Resultado: $z = \begin{bmatrix} 1×5 + 2×6 \\ 3×5 + 4×6 \end{bmatrix} = \begin{bmatrix} 17 \\ 39 \end{bmatrix}$ z=[1×5+2×63×5+4×6]=[1739]

Intuición

Cada fila de la matriz representa una neurona.

👉 Entonces:

fila 1 → neurona 1
fila 2 → neurona 2

Cada neurona calcula: $z_i = w_i \cdot x$ zi=wi⋅x

👉 La multiplicación matricial es simplemente muchos productos escalares al mismo tiempo.

Interpretación geométrica

La multiplicación matricial representa una transformación lineal del espacio.

Puede:

Rotar
Escalar
Proyectar
Cambiar de base

👉 En redes neuronales:

Cada capa transforma el espacio de representación de los datos

Compatibilidad de dimensiones

Para multiplicar: $(m \times n) \cdot (n \times p)$ (m×n)⋅(n×p)

👉 El resultado es: $(m \times p)$ (m×p)

Ejemplo

$W$ W: (3 × 2)
$x$ x: (2 × 1)

👉 Resultado: (3 × 1)

Multiplicación matricial en redes neuronales

La operación clave de una capa: $z = W \cdot x + b$ z=W⋅x+b

👉 Donde:

$x$ x = vector de entrada
$W$ W = matriz de pesos
$b$ b = bias

🔹 Interpretación

Cada fila de $W$ W = una neurona
Cada columna de $W$ W = una conexión de entrada

🔹 Capas profundas

$x \rightarrow W_1 \rightarrow W_2 \rightarrow W_3$ x→W1→W2→W3

👉 Cada capa aplica una nueva transformación.

Multiplicación matriz-matriz

Permite encadenar transformaciones: $Z = W_2 \cdot W_1$ Z=W2⋅W1

👉 Usado en:

Redes profundas
Transformers
Modelos complejos

Batch processing

En deep learning, procesamos múltiples muestras: $X = [batch\_size \times features]$ X=[batch_size×features] $Z = X \cdot W^T$ Z=X⋅WT

👉 Permite computación eficiente en GPU.

Ejemplo en Python (manual)

			
# Multiplicación matriz-vector manual
W = [
    [1, 2],
    [3, 4]
]
x = [5, 6]
z = [
    W[0][0]*x[0] + W[0][1]*x[1],
    W[1][0]*x[0] + W[1][1]*x[1]
]
print("Resultado:", z)

		

Ejemplo en NumPy

			
import numpy as np
W = np.array([
    [1, 2],
    [3, 4]
])
x = np.array([5, 6])
z = np.dot(W, x)
print("Resultado:", z)

		

Ejemplo en PyTorch

			
import torch
W = torch.tensor([
    [1.0, 2.0],
    [3.0, 4.0]
])
x = torch.tensor([5.0, 6.0])
z = torch.matmul(W, x)
print("Resultado:", z)

		

Ejemplo con batch (PyTorch)

			
import torch
# Batch de 2 muestras
X = torch.tensor([
    [1.0, 2.0],
    [3.0, 4.0]
])
# Pesos
W = torch.tensor([
    [0.5, -0.3],
    [0.8, 0.2]
])
b = torch.tensor([0.1, 0.2])
# Forward
Z = torch.matmul(X, W.T) + b
print("Salida:\n", Z)

		

Ejemplo con gradientes

			
import torch
X = torch.tensor([
    [1.0, 2.0],
    [3.0, 4.0]
], requires_grad=True)
W = torch.tensor([
    [0.5, -0.3],
    [0.8, 0.2]
], requires_grad=True)
b = torch.tensor([0.1, 0.2], requires_grad=True)
Z = torch.matmul(X, W.T) + b
loss = torch.sum((Z - 1.0) ** 2)
loss.backward()
print("Loss:", loss.item())
print("Grad W:\n", W.grad)
print("Grad X:\n", X.grad)

		

Qué muestra este ejemplo

X → batch de datos
W → matriz de pesos
Z → salida de la capa
Gradientes → cómo ajustar cada parámetro

👉 Esto es exactamente una capa real de red neuronal.

Errores comunes

Dimensiones incompatibles

Error más frecuente en deep learning.

Confundir orden de multiplicación

$W \cdot x \neq x \cdot W$

Ignorar el bias

La transformación completa incluye $+ b$ +b

Ejemplo conceptual de una capa

Entrada: $X = \begin{bmatrix} x_1 \\ x_2 \end{bmatrix}$

Pesos: $W = \begin{bmatrix} w_{11} & w_{12} \\ w_{21} & w_{22} \end{bmatrix}$

Salida: $Z = W \cdot X$

👉 Genera múltiples neuronas simultáneamente.

Interpretación profunda

La multiplicación matricial permite:

paralelizar neuronas
escalar modelos
transformar representaciones
construir arquitecturas profundas

👉 Es el motor computacional del deep learning.

Conclusión

La multiplicación matricial es la operación que permite a las redes neuronales escalar desde una sola neurona hasta millones de ellas trabajando en paralelo.

Es el puente entre:

datos
pesos
transformaciones
aprendizaje

👉 Sin esta operación, no existiría el deep learning moderno.

Related Concepts

Producto escalar
Vector
Matriz
Tensor
Capa neuronal
Activación
Gradiente