Las matrices representan aplicaciones lineales

Un modelo expone una proyección lineal, pero oculta su matriz de pesos. ¿Es posible revelar toda la transformación con unas pocas entradas elegidas con cuidado? Sí: introduce los vectores de la base de coordenadas y registra sus salidas. Esas respuestas son exactamente las columnas de la matriz, y la linealidad nos indica cómo combinarlas para obtener el resultado de cualquier otra entrada.

Al terminar, podrás obtener una matriz a partir de las respuestas de una aplicación a la base, reconstruir una salida desde sus coordenadas y reconocer cómo se relaciona la disposición de pesos de una biblioteca con la convención de vectores columna.

Resultado de aprendizaje: Obtener la matriz de una aplicación a partir de los vectores de la base transformados.

La lección 19 mostró cómo una matriz multiplica una entrada calculando sumas ponderadas de sus columnas. La lección 34 estableció que una aplicación lineal conserva las combinaciones. La sección 2.7 del libro oficial Mathematics for Machine Learning conecta estas ideas: una vez elegida una base, la aplicación queda determinada por su acción sobre ella. La derivación, el ejemplo de proyección, el recurso visual y las preguntas siguientes son originales.

Cada columna de la matriz registra una respuesta de la base

En $\mathbb{R}^n$, los vectores de la base estándar son $e_1=(1,0,\ldots,0)$, $e_2=(0,1,\ldots,0),$ y así sucesivamente. Cualquier entrada $x=(x_1,\ldots,x_n)$ puede construirse a partir de ellos:

$$x=x_1e_1+x_2e_2+\cdots+x_ne_n.$$

Sea $T:\mathbb{R}^n\to\mathbb{R}^m$ una aplicación lineal. Como conserva las sumas y la multiplicación por escalares, debe enviar esa entrada a

$$T(x)=x_1T(e_1)+x_2T(e_2)+\cdots+x_nT(e_n).$$

Las salidas $T(e_j)$ son vectores de $\mathbb{R}^m$. Coloca cada una en una columna para formar una matriz $m\times n$:

Esta construcción funciona en cualquier dimensión finita: $n$ coordenadas de entrada dan lugar a $n$ columnas, mientras que cada respuesta tiene $m$ coordenadas de salida y, por tanto, aporta $m$ filas. La misma idea sirve con cualquier base ordenada de entrada $B=(b_1,\ldots,b_n)$ y base de salida $C=(c_1,\ldots,c_m)$. Escribe la respuesta a cada vector de la base de entrada en coordenadas de salida:

$$T(b_j)=a_{1j}c_1+\cdots+a_{mj}c_m.$$

Los coeficientes forman la columna $j$ de la matriz de transformación $A_{C\leftarrow B}$:

$$A_{C\leftarrow B}=\begin{bmatrix}[T(b_1)]_C&\cdots&[T(b_n)]_C\end{bmatrix}.$$

Si $[x]_B$ es el vector de coordenadas de $x$ en la base $B$, entonces $[T(x)]_C=A_{C\leftarrow B}[x]_B$. Por tanto, la matriz depende de los sistemas de coordenadas elegidos, aunque la aplicación subyacente $T$ no cambia.

• T(e₁) = (2, 1) — columna 1
• T(e₂) = (1, 1) — columna 2

Por tanto, A es2  11  1. Cualquier entradax = (x₁,x₂) maps tox₁(2, 1) + x₂(1, 1).

El recurso visual usa $T(e_1)=(2,1)$ y $T(e_2)=(1,1)$. Cada flecha de entrada se convierte en una columna, y el cuadrado unidad pasa a ser un paralelogramo generado por esas dos columnas. La transformación en formato de texto es $A=\begin{bmatrix}2&1\\1&1\end{bmatrix}$, así que la conclusión sigue siendo clara sin movimiento ni color.

Recupera la regla a partir de dos respuestas

Supongamos que una aplicación lineal envía los dos vectores de la base estándar a

El orden importa: si se invierten las respuestas, también se invierten las columnas y cambia la aplicación representada. Las filas responden a otra pregunta: cada una indica cómo una coordenada de salida combina todas las coordenadas de entrada.

Examina una proyección aprendida con NumPy

La misma idea permite inspeccionar una proyección lineal aunque sus pesos no estén disponibles directamente, siempre que acepte las entradas elegidas y sea realmente lineal. Supongamos que las tres entradas de la base producen $(1,2)$, $(-2,1)$ y $(0,3)$. Sus coordenadas son salidas de $\mathbb{R}^2$, por lo que la aplicación recuperada va de tres características de entrada a dos de salida. column_stack de NumPy coloca respuestas unidimensionales en columnas de una matriz (documentación de NumPy):

import numpy as np

responses = [
    np.array([1.0, 2.0]),
    np.array([-2.0, 1.0]),
    np.array([0.0, 3.0]),
]
A = np.column_stack(responses)  # shape (2 outputs, 3 inputs)
x = np.array([2.0, -1.0, 1.0])

print(A)
# [[ 1. -2.  0.]
#  [ 2.  1.  3.]]
print(A @ x)
# [4. 6.]

La salida es $2(1,2)-(-2,1)+(0,3)=(4,6)$. Para un lote de entradas almacenadas como vectores columna, multiplica por $A$ por la izquierda; si los ejemplos se guardan como filas, la misma operación se expresa con la transpuesta a la derecha.

Esta orientación resulta útil al leer los parámetros de una red neuronal. torch.nn.Linear de PyTorch almacena los pesos con forma (out_features, in_features) y aplica un lote orientado por filas como $XW^\mathsf{T}+b$ (documentación de PyTorch). Con bias=False, su tensor de pesos $W$ es la misma matriz $A$ de la ecuación con vectores columna $T(x)=Ax$. Si se activa el sesgo, el módulo aplica $Ax+b$: resta la respuesta a la entrada cero $b$ antes de tratar las salidas de la base como columnas. Si después de la capa se aplica una operación no lineal, como una función de activación, la aplicación total deja de ser lineal; por ello, las respuestas de la base de esa capa por sí solas no determinan su comportamiento para todas las entradas.

Las respuestas de la base solo bastan si la aplicación es lineal

La reconstrucción tiene dos elementos: una base permite expresar cualquier entrada como una suma ponderada, y la linealidad permite que la aplicación conserve esos pesos al pasar por la suma. Juntos explican por qué la matriz reproduce $T$ y por qué no puede existir otra matriz que produzca una salida distinta para alguna entrada y, a la vez, coincida en todas las mismas respuestas de la base.

Si un sistema devuelve $T(e_j)$ para cada vector de la base de entrada, esas respuestas determinan su matriz. Pero probar esas entradas no demuestra que un sistema desconocido sea lineal. Por ejemplo, un sistema no lineal podría coincidir en las mismas respuestas de la base y comportarse de otra forma en $e_1+e_2$. Una combinación reservada para la prueba permite examinar esa suposición: compara $T(e_1+e_2)$ con $T(e_1)+T(e_2)$. La siguiente lección usa matrices para plantear otra pregunta: ¿qué direcciones de entrada desaparecen y a qué salidas puede llegar la aplicación?

Comprueba lo que has aprendido

Question 1

Una aplicación lineal envía e₁ a (4, −1) y e₂ a (2, 3). Escribe su matriz en coordenadas estándar e identifica las dimensiones de entrada y salida.

Show the step-by-step solution

Las dos entradas forman la base estándar de $\mathbb{R}^2$, así que hay dos columnas. Cada salida tiene dos coordenadas, así que hay dos filas. Coloca la primera respuesta en la primera columna y la segunda en la segunda:

$$A=\begin{bmatrix}4&2\\-1&3\end{bmatrix}.$$

Por tanto, la aplicación es $T:\mathbb{R}^2\to\mathbb{R}^2$.

Question 2

Usa la aplicación del ejemplo para calcular T(1, 2) a partir de las respuestas de la base. Muestra cómo las coordenadas determinan la combinación.

Show the step-by-step solution

La entrada se descompone como $(1,2)=1e_1+2e_2$. La linealidad traslada esos coeficientes a las salidas:

$$T(1,2)=T(e_1)+2T(e_2) =(3,1)+2(-1,2) =(3,1)+(-2,4) =(1,5).$$

La misma comprobación con la matriz es $\begin{bmatrix}3&-1\\1&2\end{bmatrix}\begin{bmatrix}1\\2\end{bmatrix} =\begin{bmatrix}1\\5\end{bmatrix}$.

Question 3

Una aplicación de ℝ³ a ℝ² envía e₁ a (1, 0), e₂ a (0, 2) y e₃ a (−1, 1). Construye su matriz y calcula la imagen de (2, −1, 3).

Show the step-by-step solution

Hay tres vectores en la base de entrada, así que coloca sus respuestas en tres columnas:

$$A=\begin{bmatrix}1&0&-1\\0&2&1\end{bmatrix}.$$

Aplica esta matriz a la entrada o combina las respuestas con sus coordenadas:

$$T(2,-1,3)=2(1,0)-1(0,2)+3(-1,1) =(2,0)+(0,-2)+(-3,3)=(-1,1).$$

La salida tiene dos coordenadas, como corresponde a una aplicación con valores en $\mathbb{R}^2$.

Question 4

Las respuestas T(e₁) = (2, 1) y T(e₂) = (−1, 3) se colocan como filas en vez de columnas. ¿Qué matriz resulta y qué hace con (1, 0)?

Show the step-by-step solution

Al colocar las respuestas indicadas como filas, se obtiene $B=\begin{bmatrix}2&1\\-1&3\end{bmatrix}$. Multiplicar por $(1,0)$ selecciona la primera columna, así que $B(1,0)=(2,-1)$. La respuesta real debería ser $T(e_1)=(2,1)$, que es distinta. Colocar las salidas en filas ha cambiado la aplicación; la regla general es poner $T(e_j)$ en la columna $j$.

Question 5

Un módulo de proyección devuelve f(0) = (5, −2), f(e₁) = (7, 1) y f(e₂) = (4, 0). Si es afín, recupera su parte lineal matricial y su vector de sesgo.

Show the step-by-step solution

Para una aplicación afín $f(x)=Ax+b$, la entrada cero da $f(0)=b$, de modo que $b=(5,-2)$. La primera respuesta lineal es la salida de la primera base menos el sesgo: $f(e_1)-b=(7,1)-(5,-2)=(2,3)$. De igual forma, $f(e_2)-b=(4,0)-(5,-2)=(-1,2)$. Coloca esas respuestas corregidas en las columnas:

$$A=\begin{bmatrix}2&-1\\3&2\end{bmatrix},\qquad b=\begin{bmatrix}5\\-2\end{bmatrix}.$$

Question 6

¿Por qué las respuestas a la base estándar determinan T(x) para cualquier x cuando T es lineal? Indica qué suposición permite llegar a esa conclusión.

Show the step-by-step solution

Todo $x=(x_1,\ldots,x_n)$ tiene la descomposición $x=\sum_{j=1}^n x_j e_j$. Por linealidad, $T(x)=T(\sum_j x_j e_j)=\sum_j x_jT(e_j)$. Por tanto, las respuestas de la base registradas aportan todos los términos necesarios para calcular cualquier salida. La conclusión depende de que $T$ conserve las sumas y la multiplicación por escalares; sin linealidad, otras entradas podrían comportarse de forma distinta aunque todas las respuestas de la base coincidieran.

Question 7

Una función de caja negra coincide con una aplicación lineal en todos los vectores de la base estándar. ¿Eso demuestra que es lineal? Da una prueba adicional en dos dimensiones.

Show the step-by-step solution

No. Un conjunto finito de respuestas coincidentes no descarta un comportamiento no lineal en otros puntos. En dos dimensiones, prueba una combinación de entradas como $e_1+e_2$: la linealidad exige $T(e_1+e_2)=T(e_1)+T(e_2)$. Si no coinciden, se descarta la linealidad. Si coinciden, es una prueba útil para esa combinación concreta, pero por sí sola no demuestra que la regla se cumpla para todas las entradas posibles.

Fuentes

1. Mathematics for Machine Learning book PDF, Section 2.7
2. NumPy documentation: numpy.column_stack
3. PyTorch documentation: torch.nn.Linear