Las aplicaciones lineales conservan las combinaciones que necesitan los modelos de IA

Una red neuronal transforma repetidamente una representación en otra. Para entender qué hace una capa, conviene plantear dos preguntas: ¿qué tipos de vectores pueden entrar y cuáles pueden salir? Una aplicación lineal responde a ambas y conserva la forma en que se combinan los vectores. Así podemos razonar sobre los pesos de una matriz como transformaciones entre espacios e identificar exactamente dónde introduce la red un comportamiento no lineal.

Al terminar, podrás comprobar si una aplicación es lineal, indicar sus espacios de entrada y salida, y distinguir la transformación matricial de una capa neuronal de su función de activación.

Objetivo de aprendizaje: Comprobar la linealidad y describir los espacios de entrada y salida de una aplicación.

Esta lección se apoya en las reglas de los espacios vectoriales de la Lección 027. La sección 2.7 de Mathematics for Machine Learning introduce las aplicaciones lineales cuando las combinaciones de vectores empiezan a conectar las coordenadas con las matrices. Los cálculos, el ejemplo de una capa neuronal, el recurso visual y las actividades de esta lección son originales.

Una transformación debe respetar cómo se combinan sus entradas

Los vectores se pueden sumar y escalar. Para dos espacios vectoriales reales $V$ y $W$ , una aplicación $T:V\to W$ es lineal cuando respeta ambas operaciones:

Aquí $u,v\in V$ y $a,b\in\mathbb{R}$ . El resultado pertenece a $W$ , y los coeficientes de la derecha escalan las salidas correspondientes.

Puedes comprobar esta regla combinada o dividirla en dos condiciones:

T(u+v)=T(u)+T(v), \qquad T(au)=aT(u).

La primera indica que sumar dos entradas antes de transformarlas da el mismo resultado que transformar cada una y después sumarlas. La segunda indica que escalar una entrada antes de transformarla equivale a escalar su salida por el mismo factor. Ambas deben cumplirse para todas las entradas válidas y todos los escalares reales, incluidos los negativos.

Una aplicación lineal transforma una suma en la suma de sus imágenesPara T(x₁, x₂) = (2x₁ + x₂, −x₁ + x₂), la imagen de e₁ + e₂ es la suma de las imágenes de e₁ y e₂.

Espacio de entrada ℝ²

e₁ = (1, 0)
e₂ = (0, 1)
e₁ + e₂ = (1, 1)

Espacio de salida ℝ²

T(e₁) = (2, −1)
T(e₂) = (1, 1)
T(e₁ + e₂) = (3, 0)

Comprobación de la combinación: T(e₁ + e₂) = T(e₁) + T(e₂)

Las tres flechas muestran un caso concreto de suma. Aquí, $T(e_1+e_2)=(3,0)$ , y $T(e_1)+T(e_2)=(2,-1)+(1,1)=(3,0)$ . El recurso visual ofrece una interpretación geométrica; la fórmula expresa la propiedad general, que debe cumplirse para todos los vectores y escalares, no solo para estos dos vectores de la base.

Una matriz indica qué espacios conecta la aplicación

Sea $A$ una matriz de tamaño $m\times n$ , es decir, con $m$ filas y $n$ columnas. Multiplica un vector columna de $n$ coordenadas y produce un vector columna de $m$ coordenadas:

T: \mathbb{R}^n\to\mathbb{R}^m, \qquad T(x)=Ax.

El dominio es el conjunto de entradas admitidas por la aplicación; el codominio es el espacio de salida al que promete llegar. Para esta regla matricial, las entradas pertenecen a $\mathbb{R}^n$ y las salidas a $\mathbb{R}^m$ . Las dimensiones no tienen por qué coincidir: una aplicación puede ampliar un vector para obtener más coordenadas o comprimirlo para obtener menos.

La multiplicación de matrices es lineal porque distribuye sobre la suma y la multiplicación por escalares. Para cualesquiera vectores $u,v$ de longitud $n$ y escalares $a,b$ ,

T(au+bv)=A(au+bv)=aAu+bAv=aT(u)+bT(v).

Veamos un pequeño ejemplo numérico:

Transforma una suma y compárala con la suma de las imágenes

A=\begin{bmatrix}2&1\\-1&1\end{bmatrix},\qquad u=\begin{bmatrix}1\\0\end{bmatrix},\qquad v=\begin{bmatrix}0\\1\end{bmatrix}.

Primero, multiplica la matriz por cada entrada para obtener su imagen:

T(u)=\begin{bmatrix}2\\-1\end{bmatrix},\qquad T(v)=\begin{bmatrix}1\\1\end{bmatrix}.

Después suma las entradas y transforma el resultado:

T(u+v)=A\begin{bmatrix}1\\1\end{bmatrix} =\begin{bmatrix}3\\0\end{bmatrix} =\begin{bmatrix}2\\-1\end{bmatrix}+\begin{bmatrix}1\\1\end{bmatrix} =T(u)+T(v).

El escalado funciona igual. Para $a=-2$ ,

T(-2u)=A\begin{bmatrix}-2\\0\end{bmatrix} =\begin{bmatrix}-4\\2\end{bmatrix} =-2T(u).

Los valores negativos importan: una comprobación que solo use factores positivos no establece la regla completa de linealidad.

Un sesgo desplaza el origen; una activación cambia la regla

En el código de aprendizaje automático, «capa lineal» es una abreviación habitual. En matemáticas, los detalles determinan si la operación es lineal. Para lotes organizados por filas, PyTorch torch.nn.Linear calcula $xA^\mathsf{T}+b$ e incluye el sesgo $b$ de forma predeterminada. Si el sesgo no es cero, la regla es afín: conserva las combinaciones cuyos coeficientes suman uno, pero por lo general no conserva sumas ni escalados arbitrarios. La documentación de PyTorch la denomina transformación afín y permite desactivar el sesgo con bias=False (documentación de torch.nn.Linear). Aun así, conserva una combinación ponderada cuando los pesos suman uno:

F(\lambda u+(1-\lambda)v) =\lambda Au+(1-\lambda)Av+b =\lambda(Au+b)+(1-\lambda)(Av+b).

La última igualdad se cumple porque $\lambda b+(1-\lambda)b=b$ . La suma vectorial ordinaria usa los coeficientes $1$ y $1$ , cuya suma no es uno, así que el sesgo no se cancela en $F(u+v)$ .

El vector cero permite hacer un diagnóstico rápido. Toda aplicación lineal debe enviar el cero al cero, porque $T(0)=T(0\cdot x)=0\cdot T(x)=0$ . Para la regla afín $F(x)=Ax+b$ ,

F(0)=A0+b=b.

Si $b\ne0$ , entonces $F$ no puede ser lineal. El sesgo no hace que la capa sea incorrecta; permite que el modelo desplace la salida incluso cuando la entrada es cero.

Las redes neuronales añaden otra operación después de la transformación de pesos. Un patrón habitual es $h=\operatorname{ReLU}(Ax+b)$ , donde ReLU sustituye cada coordenada negativa por cero. Es una operación no lineal. Por ejemplo, sea $r(t)=\max(0,t)$ . Entonces $r(-1+1)=r(0)=0$ , mientras que $r(-1)+r(1)=0+1=1$ . La prueba de suma falla. La documentación de PyTorch define torch.nn.ReLU como esta operación de máximo elemento a elemento (documentación de ReLU).

Esta diferencia explica por qué las redes combinan estos pasos. Si dos capas fueran únicamente aplicaciones lineales, su composición seguiría siendo una sola aplicación lineal: $B(Ax)=(BA)x$ . Añadir capas cambiaría la matriz, pero no crearía una regla no lineal entre entrada y salida. Una activación impide esa reducción y permite que la red represente relaciones más variadas. La matriz de pesos mezcla las características de entrada; la activación cambia la regla que se aplica a las coordenadas resultantes.

Examina la transformación con código

Puedes comprobar los mismos cálculos con NumPy. Los vectores columna hacen que la convención de matriz a la izquierda coincida con la derivación anterior:

import numpy as np

A = np.array([[2, 1],
              [-1, 1]])
u = np.array([1, 0])
v = np.array([0, 1])

def T(x):
    return A @ x
print(T(u + v))              # [3 0]
print(T(u) + T(v))           # [3 0]
print(T(-2 * u))             # [-4  2]
print(-2 * T(u))             # [-4  2]

En PyTorch, los vectores de un lote suelen almacenarse como filas, por lo que la matriz de pesos de la biblioteca aparece transpuesta en la fórmula mostrada. La dimensión del lote se mantiene, mientras que la última dimensión, la de características, pasa de in_features a out_features:

import torch
from torch import nn

x = torch.tensor([[1.0, 0.0], [0.0, 1.0]])  # shape: (2 examples, 2 features)
linear_part = nn.Linear(2, 3, bias=False)
activation = nn.ReLU()

pre_activation = linear_part(x)  # shape: (2, 3); a linear map
hidden = activation(pre_activation)  # shape: (2, 3); nonlinear elementwise step

En este caso, la aplicación lineal transforma cada vector de características de $\mathbb{R}^2$ en uno de $\mathbb{R}^3$ . Este ejemplo omite el sesgo, de modo que la primera operación sí es lineal. Con el sesgo predeterminado, PyTorch describe esa operación como afín. La activación conserva la forma de la salida, pero no supera la prueba de combinación de vectores. Que las formas coincidan no permite saber si una operación es lineal; lo determina la regla algebraica.

Una aplicación lineal aún puede perder información

La linealidad no significa que una aplicación sea reversible, conserve longitudes o resulte útil para todas las tareas posteriores. La matriz nula transforma cualquier entrada en el vector cero y aun así satisface las dos reglas de linealidad. Una aplicación lineal de $\mathbb{R}^3$ a $\mathbb{R}^2$ no puede ser inyectiva: necesariamente desaparece al menos una dirección de la información de entrada. Para determinar si se conserva la información, se necesitan otros conceptos, como la independencia lineal, el rango y la invertibilidad.

Al inspeccionar un bloque neuronal, escribe el espacio anterior y posterior a cada operación y después comprueba la regla que aplica. La multiplicación matricial transforma las combinaciones de forma predecible; un sesgo desplaza el origen; una activación cambia cómo se comportan las combinaciones. Esa es la distinción que conviene llevar a la siguiente lección, donde las aplicaciones lineales adquieren representaciones matriciales concretas.

Comprueba lo que has entendido

Pregunta 1

¿Qué dos propiedades debe satisfacer una aplicación para ser lineal? ¿Qué queda sin comprobar con una prueba de suma de vectores?