El núcleo y la imagen muestran qué pierde y qué alcanza una capa lineal

La proyección de un modelo puede convertir dos vectores de características distintos en una misma representación. Cuando eso ocurre, ninguna capa posterior puede distinguir esas entradas basándose únicamente en dicha representación. Dos conceptos precisan este efecto: el núcleo identifica los cambios de entrada que una aplicación lineal elimina, mientras que la imagen describe las salidas que puede producir.

Al terminar, podrás hallar ambos conjuntos para una matriz pequeña y explicar qué revelan sobre la pérdida de información y las salidas representables.

Objetivo de aprendizaje: Encontrar ejemplos sencillos de espacio nulo e imagen e interpretarlos.

Esta lección conecta el rango de una matriz de la Lección 033 con la representación matricial de una aplicación lineal de la Lección 035. La sección 2.7.3 de Mathematics for Machine Learning presenta la imagen y el núcleo de una aplicación lineal. La proyección, el cálculo, la interpretación en IA, la visualización y las preguntas que siguen son originales.

Una proyección puede eliminar una dirección y restringir las salidas

Considera la aplicación $P: \mathbb{R}^3\to\mathbb{R}^3$ , representada por

Conserva las dos primeras coordenadas y fija la tercera en cero. El núcleo de una aplicación lineal $T:V\to W$ es el conjunto de entradas de $V$ que se transforman en el vector cero de $W$ . Su imagen es el conjunto de salidas de $W$ que la aplicación puede producir a partir de alguna entrada. Estos conjuntos pertenecen a espacios distintos: el núcleo se refiere a las entradas y la imagen, a las salidas.

Aquí, núcleo significa el espacio nulo de una aplicación lineal. En aprendizaje automático, «kernel» también designa funciones que comparan ejemplos en métodos de kernel; es otro concepto.

En $P$ , una entrada llega a cero exactamente cuando $x=0$ e $y=0$ , mientras que $z$ puede ser cualquiera. Por tanto, el núcleo es el eje $z$ :

\ker(P)=\{(0,0,z):z\in\mathbb{R}\} =\operatorname{span}\{(0,0,1)\}.

Todas las salidas tienen la forma $(x,y,0)$ , y cada vector así puede alcanzarse con la entrada $(x,y,0)$ . Por tanto, la imagen es el plano $xy$ :

\operatorname{Im}(P)=\{(x,y,0):x,y\in\mathbb{R}\} =\operatorname{span}\{(1,0,0),(0,1,0)\}.

La figura separa estas dos preguntas. La dirección vertical del núcleo marca la variación de entrada que desaparece; el plano sombreado de la imagen marca las salidas que siguen estando disponibles.

Una aplicación, dos subespacios distintosP(x, y, z) = (x, y, 0): cambiar z desplaza la entrada a lo largo del núcleo, mientras que todas las salidas permanecen en el plano xy.

Espacio de entrada ℝ³

x = (2, 1, 0)
x + k = (2, 1, 2)
k = (0, 0, 2)

Salidas alcanzables: Im(P)

La tercera coordenada de toda salida es 0

P(x) = P(x + k) = (2, 1, 0)

Los vectores del núcleo explican qué entradas se agrupan

Toma $x=(2,1,0)$ y súmale el vector del núcleo $k=(0,0,2)$ . Las entradas son distintas, pero sus imágenes coinciden:

Así que el núcleo no es una lista de entradas que la matriz ignora una por una. Es el conjunto de direcciones por las que puede desplazarse una entrada sin cambiar el resultado. Si el modelo solo recibe el vector proyectado, no puede recuperar en qué punto de esas direcciones comenzó la entrada original.

La imagen limita lo que puede recibir el código posterior

La misma $P$ tiene rango dos porque su imagen posee dos direcciones independientes. Su núcleo también tiene dimensión uno. Estos valores suman la dimensión del espacio de entrada:

\underbrace{\dim(\ker(P))}_{\text{nullity }1} +\underbrace{\dim(\operatorname{Im}(P))}_{\text{rank }2} =\underbrace{\dim(\mathbb{R}^3)}_{3}.

Este es el teorema del rango y la nulidad para una aplicación lineal cuyo espacio de entrada tiene dimensión finita. Relaciona el número de direcciones de salida independientes con el de direcciones de entrada independientes que se reducen a cero. Para una matriz $m\times n$ que actúa sobre vectores columna, la imagen es el espacio generado por sus columnas, el núcleo se obtiene resolviendo $Ax=0$ , y el rango más la nulidad es $n$ , el número de coordenadas de entrada.

Ese último número importa al leer las dimensiones en el código. El operador @ de NumPy realiza multiplicación matricial: una matriz $m\times n$ por un vector de $n$ elementos produce un vector de $m$ elementos. Para esta proyección, el breve cálculo confirma que las salidas coinciden y que la dirección del núcleo desaparece:

import numpy as np

P = np.diag([1, 1, 0])
x = np.array([2, 1, 2])
k = np.array([0, 0, 2])

print(P @ x)        # [2 1 0]
print(P @ (x - k))  # [2 1 0]
print(P @ k)        # [0 0 0]

La misma distinción ayuda a diagnosticar una proyección aprendida

Una matriz de pesos aprendida también transforma un vector de características en otro. torch.nn.Linear de PyTorch aplica una transformación afín, $y=xA^\mathsf{T}+b$ , a entradas organizadas por filas; al establecer bias=False queda solo la aplicación matricial. En notación de vectores columna, la misma operación es $Au+b$ . La aplicación de pesos determina qué diferencias de entrada desaparecen: si $A(u-v)=0$ , ambas entradas producen la misma salida porque el sesgo común se cancela. La imagen de la aplicación de pesos describe las direcciones de salida disponibles a partir de los pesos; con un sesgo, el conjunto completo de salidas es el subespacio trasladado $b+\operatorname{Im}(A)$ (documentación de PyTorch).

El núcleo y la imagen responden a preguntas distintas al depurar. Un núcleo no nulo significa que algunos vectores de características distintos se vuelven indistinguibles en esta capa. Una imagen restringida significa que ciertas combinaciones de características de salida no pueden producirse. Una aplicación de $\mathbb{R}^3$ a $\mathbb{R}^2$ puede tener un núcleo no trivial y, a la vez, alcanzar todos los puntos de su espacio de salida bidimensional. En cambio, una aplicación de $\mathbb{R}^2$ a $\mathbb{R}^3$ puede conservar todas las distinciones entre entradas y hacer que sus salidas queden en un plano. La forma de salida de la matriz, por sí sola, no permite responder a ninguna de estas preguntas: hay que examinar el rango y los subespacios concretos.

El siguiente paso es preguntar qué direcciones son redundantes antes de comprimir una representación. Cuando esa elección se aprende en vez de especificarse, inspeccionar el rango, el núcleo y la imagen de la aplicación de pesos revela qué puede seguir distinguiendo y expresando el modelo posterior.