Productos matriz-vector para IA: dos perspectivas de un cálculo de capa densa

Tres valores de características entran en una capa densa y salen dos puntuaciones. El código de la capa puede ocupar una sola línea:

scores = weights @ features

Ese @ oculta dos sumas ponderadas completas. También oculta una segunda interpretación igualmente correcta: cada característica de entrada escala una columna de la matriz de pesos, y las columnas escaladas se suman para obtener el mismo vector de salida. Conocer ambas perspectivas convierte un operador compacto en algo que se puede calcular y depurar.

Al terminar esta lección, podrás calcular un producto matriz-vector por filas y por columnas, explicar por qué ambos métodos coinciden, implementarlos en NumPy y detectar formas incompatibles o un producto elemento a elemento accidental.

Resultado de aprendizaje: Calcular un producto matriz-vector por filas y por columnas.

La lección 17: Combinaciones lineales para IA mostró cómo se suman vectores escalados. La lección 18: Matrices para IA organizó una regla de salida por fila y una característica de entrada por columna. La multiplicación matriz-vector une esas ideas. El sitio complementario oficial de Mathematics for Machine Learning desarrolla los productos matriciales compatibles y la perspectiva de combinación de columnas en la sección 2.2 del libro. El ejemplo de clasificación, el cálculo, el código, el gráfico interactivo y las evaluaciones que siguen son originales.

La dimensión compartida establece la regla del cálculo

Sea $W\in\mathbb{R}^{m\times n}$ una matriz real con $m$ filas y $n$ columnas. Sea $\boldsymbol{x}\in\mathbb{R}^{n}$ un vector con $n$ coordenadas. El producto $W\boldsymbol{x}$ está definido porque el número de columnas de la matriz coincide con el número de coordenadas del vector:

$$\underbrace{W}_{m\times n} \underbrace{\boldsymbol{x}}_{n\times1} = \underbrace{\boldsymbol{y}}_{m\times1}.$$

Los dos valores $n$ coincidentes describen el trabajo que se realiza dentro del producto. El valor $m$ restante determina la longitud de la salida.

Esto no permite cancelar las dimensiones coincidentes como si fueran números ordinarios. Las dimensiones registran la correspondencia: $x_j$ debe emparejarse con la columna $j$, lo que sitúa el peso $w_{ij}$ y la entrada $x_j$ en el mismo término.

Una entrada produce dos puntuaciones, fila por fila

Supongamos que una pequeña capa de clasificación utiliza tres características de entrada estandarizadas:

• $x_1=2$: la coincidencia temática está dos unidades de escala por encima de su valor de referencia;
• $x_2=1$: la actualidad está una unidad de escala por encima de su valor de referencia; y
• $x_3=-1$: la calidad de la fuente está una unidad de escala por debajo de su valor de referencia.

El vector de características y la matriz de pesos de dos filas son

$$\boldsymbol{x}= \begin{bmatrix}2\\1\\-1\end{bmatrix}, \qquad W= \begin{bmatrix} 0.8 & -0.4 & 0.2\\ 0.1 & 0.6 & -0.5 \end{bmatrix}.$$

Las dimensiones anticipan una respuesta de dos coordenadas:

$$(2\times3)(3\times1)\longrightarrow(2\times1).$$

La entrada negativa $x_3=-1$ hace que el peso negativo $w_{23}=-0.5$ aporte un $0.5$ positivo a $y_2$. El signo de un peso por sí solo no determina si su contribución aumenta o reduce una salida; el signo de la entrada también importa.

Explora el cálculo

Vista por filasVista por columnas

Usa las teclas de flecha en el control deslizante. El paso 3 muestra el producto completo.

Términos incluidos

3 de 3

Cada fila de salida incluye los primeros 3 términos.

Matriz de pesos W

0,8-0,40,20,10,6-0,5

×

Entrada x

21-1

=

Salida acumulada actual

11,3

Fila 1: 1,6 + (-0,4) + (-0,2) = 1

Fila 2: 0,2 + 0,6 + 0,5 = 1,3

Tabla numérica alternativa: cada columna escalada y sus contribuciones a las dos coordenadas de salida.

Contribución de columna	Contribución a y₁	Contribución a y₂	Columna escalada
x₁w₁ (x₁ = 2)	1,6	0,2	2 × [0,8, 0,1]ᵀ = [1,6, 0,2]ᵀ
x₂w₂ (x₂ = 1)	-0,4	0,6	1 × [-0,4, 0,6]ᵀ = [-0,4, 0,6]ᵀ
x₃w₃ (x₃ = −1)	-0,2	0,5	-1 × [0,2, -0,5]ᵀ = [-0,2, 0,5]ᵀ
Total	1	1,3	[1, 1,3]ᵀ

La tabla completa permanece visible en la lección renderizada por el servidor, por lo que los seis productos escalares y sus dos totales siguen disponibles sin JavaScript ni movimiento.

El simulador comienza con el cálculo completo por filas ya representado. Su vista por columnas no introduce otro producto: reagrupa las mismas seis multiplicaciones escalares en tres contribuciones vectoriales. La tabla conserva todos los valores exactos incluso antes de que se active la interacción o cuando se reduce el movimiento.

Las columnas muestran qué aporta cada entrada

Escribe las columnas de $W$ como vectores $\boldsymbol{w}_1,\boldsymbol{w}_2,\boldsymbol{w}_3\in\mathbb{R}^{2}$:

$$\boldsymbol{w}_1= \begin{bmatrix}0.8\\0.1\end{bmatrix}, \qquad \boldsymbol{w}_2= \begin{bmatrix}-0.4\\0.6\end{bmatrix}, \qquad \boldsymbol{w}_3= \begin{bmatrix}0.2\\-0.5\end{bmatrix}.$$

Las coordenadas de entrada se convierten en coeficientes de esas columnas:

$$W\boldsymbol{x} =x_1\boldsymbol{w}_1+x_2\boldsymbol{w}_2+x_3\boldsymbol{w}_3.$$

Para el mismo ejemplo,

$$\begin{aligned} W\boldsymbol{x} &=2\begin{bmatrix}0.8\\0.1\end{bmatrix} +1\begin{bmatrix}-0.4\\0.6\end{bmatrix} -1\begin{bmatrix}0.2\\-0.5\end{bmatrix}\\[4pt] &=\begin{bmatrix}1.6\\0.2\end{bmatrix} +\begin{bmatrix}-0.4\\0.6\end{bmatrix} +\begin{bmatrix}-0.2\\0.5\end{bmatrix}\\[4pt] &=\begin{bmatrix}1.0\\1.3\end{bmatrix}. \end{aligned}$$

La vista por filas responde: «¿Cómo se calcula la salida $i$?». La vista por columnas responde: «¿Qué aporta la entrada $j$ a cada salida?». Al depurar una capa densa, suelen hacer falta ambas preguntas.

Por qué las dos perspectivas deben coincidir

La igualdad se demuestra coordenada por coordenada. La coordenada $i$ de la combinación de columnas es

$$\left(x_1\boldsymbol{w}_1+\cdots+x_n\boldsymbol{w}_n\right)_i =x_1w_{i1}+\cdots+x_nw_{in} =\sum_{j=1}^{n}w_{ij}x_j.$$

Esa última suma es exactamente la definición por filas de $(W\boldsymbol{x})_i$. Como coinciden las $m$ coordenadas, los vectores resultantes son iguales. El argumento solo utiliza multiplicaciones y sumas ordinarias de un número finito de valores reales; no hay ninguna suposición nueva oculta entre los dos diagramas.

NumPy puede mostrar la operación abreviada

La documentación actual de matmul de NumPy define @ como multiplicación de matrices y describe el resultado habitual al multiplicar un array bidimensional por uno unidimensional. La operación compacta debe venir después de comprobar la forma:

import numpy as np

weights = np.array([
    [0.8, -0.4,  0.2],
    [0.1,  0.6, -0.5],
], dtype=float)
features = np.array([2.0, 1.0, -1.0])

if weights.shape[1] != features.shape[0]:
    raise ValueError("each matrix row needs one weight per input feature")

direct = weights @ features
by_rows = np.array([
    sum(weight * value for weight, value in zip(row, features))
    for row in weights
])
by_columns = sum(
    (features[j] * weights[:, j] for j in range(weights.shape[1])),
    start=np.zeros(weights.shape[0]),
)

print("direct:", direct)
print("by rows:", by_rows)
print("by columns:", by_columns)
print("all equal:", np.allclose(direct, by_rows)
      and np.allclose(direct, by_columns))

Salida verificada:

direct: [1.  1.3]
by rows: [1.  1.3]
by columns: [1.  1.3]
all equal: True

Las versiones explícitas sirven para enseñar y depurar. Para el trabajo numérico habitual, weights @ features expresa directamente la operación de álgebra lineal deseada y permite que NumPy utilice su implementación optimizada.

La forma de la salida merece atención. weights tiene forma (2, 3), mientras que features tiene forma (3,). NumPy trata ese segundo operando unidimensional como el vector de un producto matriz-vector y devuelve una forma (2,), no (2, 1). Los valores coinciden con la notación de vector columna; la representación de software simplemente omite un eje de tamaño uno.

Una capa densa suma su sesgo después del producto

El producto matriz-vector es la parte lineal de una capa densa. Una capa con sesgo utiliza la regla afín

$$\boldsymbol{z}=W\boldsymbol{x}+\boldsymbol{b}, \qquad \boldsymbol{b}\in\mathbb{R}^{m}.$$

Si $\boldsymbol{b}=[0.2,-0.1]^{\mathsf T}$ en el ejemplo, entonces

$$\boldsymbol{z} =\begin{bmatrix}1.0\\1.3\end{bmatrix} +\begin{bmatrix}0.2\\-0.1\end{bmatrix} =\begin{bmatrix}1.2\\1.2\end{bmatrix}.$$

Una función de activación, si el modelo la utiliza, se aplica después de ese resultado afín. No forma parte de la definición de $W\boldsymbol{x}$.

La documentación actual de torch.nn.Linear almacena los pesos con forma (out_features, in_features), la misma disposición de una fila por salida utilizada aquí. PyTorch suele aceptar entradas con las características en el último eje y presenta su regla como $\boldsymbol{x}A^{\mathsf T}+\boldsymbol{b}$. Para una entrada representada como fila, esa es la forma equivalente por transposición de la ecuación de vector columna $W\boldsymbol{x}+\boldsymbol{b}$; no crea un conjunto diferente de pesos.

Dos signos de multiplicación pueden producir dos objetos distintos

El error más peligroso aquí puede ejecutarse sin provocar una excepción. NumPy documenta multiply y * como multiplicación elemento a elemento con difusión de formas. Por tanto, este código

print(weights * features)

no calcula la salida de dos coordenadas de la capa. El vector de longitud tres se difunde por ambas filas y produce

[[ 1.6 -0.4 -0.2]
 [ 0.2  0.6  0.5]]

con forma (2, 3). Esas seis celdas son las contribuciones antes de sumar cada fila. Llamar a sum(axis=1) completaría este cálculo concreto, pero @ expresa directamente la contracción prevista. La guía de inicio de NumPy establece la misma distinción: * opera elemento a elemento con arrays, mientras que @ realiza un producto matricial.

Una entrada incompatible falla por otra razón:

bad_features = np.array([2.0, 1.0])
weights @ bad_features

La matriz tiene tres columnas, pero el vector solo tiene dos coordenadas. El contrato documentado de matmul en NumPy rechaza esa falta de coincidencia en la dimensión interna. Añadir un tercer número arbitrario para eliminar el error sería peor que el propio error; primero hay que identificar la característica ausente y el significado de su coordenada.

El siguiente producto conserva la misma regla de correspondencia

Un producto matriz-vector condensa varias fórmulas de salida sin borrar su estructura. La lectura por filas muestra una suma ponderada por salida. La lectura por columnas muestra una contribución al vector de salida por entrada. La compatibilidad de formas garantiza que ambas lecturas emparejen el mismo $w_{ij}$ con el mismo $x_j$.

La lección 20 colocará varios vectores de entrada junto a la misma matriz de pesos. La operación pasará a ser una multiplicación matriz-matriz, pero se mantiene la regla central: hacer coincidir la dimensión interna y luego decidir qué ejes externos conserva el resultado. La página del curso Math for AI mantiene esa secuencia de prerrequisitos.

Comprueba lo que has aprendido

Question 1

Sea A de forma 4 × 3 y x de longitud 3. ¿Está definido Ax, cuál es la longitud de su salida y cuántos productos escalares se suman para cada coordenada de salida?

Show the step-by-step solution

La matriz tiene tres columnas y el vector tiene tres coordenadas. Esas dimensiones internas coinciden, así que el producto está definido:

$$(4\times3)(3\times1)\longrightarrow(4\times1).$$

Las cuatro filas restantes determinan cuatro coordenadas de salida. Para cada salida, una fila aporta tres pesos. Cada peso multiplica la coordenada de entrada correspondiente y los tres productos escalares se suman. Por tanto, $A\boldsymbol{x}$ tiene longitud $4$, con tres productos que contribuyen a cada coordenada.

Question 2

Calcula Bv por filas para B = [[2, −1], [0.5, 3]] y v = [4, 2]ᵀ. Muestra las dos sumas ponderadas.

Show the step-by-step solution

Las dos columnas de $B$ coinciden con las dos coordenadas de $\boldsymbol{v}$, así que el producto está definido y tendrá dos salidas.

Para la fila 1,

$$y_1=(2)(4)+(-1)(2)=8-2=6.$$

Para la fila 2,

$$y_2=(0.5)(4)+(3)(2)=2+6=8.$$

Al reunir los resultados de las filas en orden se obtiene

$$B\boldsymbol{v}=\begin{bmatrix}6\\8\end{bmatrix}.$$

Question 3

Vuelve a calcular el producto de la pregunta 2 como una suma ponderada de las columnas de B.

Show the step-by-step solution

Primero, separa las columnas:

$$\boldsymbol{b}_1=\begin{bmatrix}2\\0.5\end{bmatrix}, \qquad \boldsymbol{b}_2=\begin{bmatrix}-1\\3\end{bmatrix}.$$

Las coordenadas de $\boldsymbol{v}=[4,2]^{\mathsf T}$ se convierten en sus coeficientes:

$$\begin{aligned} B\boldsymbol{v} &=4\boldsymbol{b}_1+2\boldsymbol{b}_2\\ &=4\begin{bmatrix}2\\0.5\end{bmatrix} +2\begin{bmatrix}-1\\3\end{bmatrix}\\ &=\begin{bmatrix}8\\2\end{bmatrix} +\begin{bmatrix}-2\\6\end{bmatrix}\\ &=\begin{bmatrix}6\\8\end{bmatrix}. \end{aligned}$$

El resultado coincide con el cálculo por filas porque ambas perspectivas contienen los mismos cuatro productos escalares, agrupados de forma diferente.

Question 4

En el producto de la lección, fija x₂ en cero y conserva x₁ = 2 y x₃ = −1. Utiliza la vista por columnas para calcular el nuevo resultado y explica qué correspondencia se mantiene.

Show the step-by-step solution

La nueva entrada es $[2,0,-1]^{\mathsf T}$. Su segunda coordenada escala la segunda columna a cero, pero la coordenada permanece en la posición 2:

$$\begin{aligned} W\boldsymbol{x} &=2\begin{bmatrix}0.8\\0.1\end{bmatrix} +0\begin{bmatrix}-0.4\\0.6\end{bmatrix} -1\begin{bmatrix}0.2\\-0.5\end{bmatrix}\\ &=\begin{bmatrix}1.6\\0.2\end{bmatrix} +\begin{bmatrix}0\\0\end{bmatrix} +\begin{bmatrix}-0.2\\0.5\end{bmatrix}\\ &=\begin{bmatrix}1.4\\0.7\end{bmatrix}. \end{aligned}$$

La columna 2 sigue correspondiendo a la actualidad y la columna 3 a la calidad de la fuente. Eliminar por completo la coordenada cero acortaría el vector y desalinearía todas las características posteriores.

Question 5

Una persona ejecuta weights * features con formas (2, 3) y (3,). ¿Por qué funciona el código, qué forma devuelve y qué operación falta todavía?

Show the step-by-step solution

El operador * de NumPy realiza multiplicación elemento a elemento. Un array de longitud tres se puede difundir por cada una de las dos filas de la matriz, por lo que la operación funciona y devuelve un array (2, 3) con seis productos.

Para los valores de la lección, esas filas son

$$\begin{bmatrix} 1.6 & -0.4 & -0.2\\ 0.2 & 0.6 & 0.5 \end{bmatrix}.$$

La salida de la capa densa necesita un número por fila. Todavía falta sumar cada fila:

$$\begin{bmatrix} 1.6-0.4-0.2\\ 0.2+0.6+0.5 \end{bmatrix} =\begin{bmatrix}1.0\\1.3\end{bmatrix}.$$

Utilizar weights @ features expresa tanto la multiplicación como la suma necesaria.

Question 6

Para una matriz A compatible, compara A0 con la salida de una capa con sesgo A0 + b. ¿Por qué difieren las respuestas?

Show the step-by-step solution

Cada coordenada del vector cero vale cero. En la vista por columnas, por tanto, cada columna se escala por cero:

$$A\boldsymbol{0} =0\boldsymbol{a}_1+\cdots+0\boldsymbol{a}_n =\boldsymbol{0}.$$

Una capa densa con sesgo realiza una suma vectorial adicional después del producto matricial:

$$A\boldsymbol{0}+\boldsymbol{b} =\boldsymbol{0}+\boldsymbol{b} =\boldsymbol{b}.$$

Las respuestas difieren porque $A\boldsymbol{x}$ es una transformación lineal, mientras que añadir un sesgo no nulo vuelve afín la regla completa. El sesgo no forma parte del producto matriz-vector.

Question 7

Un array de pesos almacenado tiene forma (3, 2), pero la capa prevista tiene tres entradas y dos salidas. ¿Por qué falla W @ x para una entrada de longitud tres y qué debe comprobarse antes de transponer W?

Show the step-by-step solution

Con la convención de una fila por salida, la forma prevista de la matriz es (2, 3): dos filas de salida y tres columnas de entrada. El array observado (3, 2) solo tiene dos columnas. Por eso, su dimensión interna no puede coincidir con una entrada de longitud tres:

$$(3\times2)(3\times1)$$

no está definido porque $2\ne3$.

La transposición produciría la forma (2, 3), pero la forma por sí sola no basta. Antes de hacerlo, comprueba que las filas observadas representan realmente las tres características de entrada, que las columnas observadas representan realmente las dos reglas de salida y que sus órdenes coinciden con los metadatos de las características y salidas. Si el array ya tiene otra organización semántica, transponerlo a ciegas puede conservar significados erróneos.

Question 8

El producto de la lección es [1, 1.3]ᵀ. Una capa densa suma b = [0.2, −0.1]ᵀ y luego aplica ReLU, que sustituye las coordenadas negativas por cero. Calcula el valor previo a la activación y la salida final.

Show the step-by-step solution

Primero, suma el sesgo coordenada por coordenada:

$$\boldsymbol{z} =W\boldsymbol{x}+\boldsymbol{b} =\begin{bmatrix}1.0\\1.3\end{bmatrix} +\begin{bmatrix}0.2\\-0.1\end{bmatrix} =\begin{bmatrix}1.2\\1.2\end{bmatrix}.$$

Este $\boldsymbol{z}$ es el valor previo a la activación. ReLU se aplica a cada coordenada por separado, según $\operatorname{ReLU}(t)=\max(0,t)$. Ambas coordenadas son positivas, así que ninguna cambia:

$$\operatorname{ReLU}(\boldsymbol{z}) =\begin{bmatrix}\max(0,1.2)\\\max(0,1.2)\end{bmatrix} =\begin{bmatrix}1.2\\1.2\end{bmatrix}.$$

El orden importa: calcula el producto matriz-vector, suma el sesgo y solo después aplica la activación.

Fuentes

1. Mathematics for Machine Learning companion website
2. Mathematics for Machine Learning book PDF
3. NumPy documentation: numpy.matmul
4. NumPy documentation: numpy.multiply
5. NumPy quickstart: elementwise and matrix products
6. PyTorch documentation: torch.nn.Linear