MLP, activaciones y pérdidas

El problema

Tienes cuatro flores con dos medidas del pétalo en centímetros y su especie codificada como entero:

Una red recién creada recibe las dos medidas y devuelve tres números por flor. Para M-1 devuelve -0.207, -0.034 y 0.159. Dos son negativos y la suma no es 1, así que no son probabilidades. Antes de ajustar los pesos de la red necesitas una pérdida: un solo número que compare esos tres valores con la especie 0.

Capas y módulos

nn.Linear(entradas, salidas) es una capa que calcula, para cada salida, una combinación lineal de las entradas más un sesgo. Guarda sus pesos en weight y sus sesgos en bias. Ambos son parámetros: tensores que la capa crea con valores aleatorios.

Pregunta. Con nn.Linear(2, 3) y las cuatro flores, escribe la forma de capa.weight, la de capa.bias y la de salida. Decide también si capa.weight tiene requires_grad en True.

import torch
from torch import nn

X = torch.tensor([[1.4, 0.2], [4.7, 1.4], [6.0, 2.5], [4.5, 1.5]])
y = torch.tensor([0, 1, 2, 1])

torch.manual_seed(0)
capa = nn.Linear(2, 3)
salida = capa(X)

print(capa.weight.shape)
print(capa.bias.shape)
print(salida.shape)
print(capa.weight.requires_grad)

torch.Size([3, 2])
torch.Size([3])
torch.Size([4, 3])
True

La capa aplica la misma cuenta a cada fila de X.

Pregunta. ¿Qué forma tiene X @ capa.weight.T? ¿Coincide capa(X) con X @ capa.weight.T + capa.bias?

nn.Sequential encadena módulos: la salida de uno es la entrada del siguiente. nn.ReLU() es un módulo sin parámetros que se coloca entre dos capas lineales. Capas lineales alternadas con activaciones forman un perceptrón multicapa (MLP). Las capas intermedias se llaman ocultas.

Pregunta. ¿Cuántos parámetros tiene red en total? Cuenta pesos y sesgos de las dos capas lineales. Escribe también la forma de red(X).

torch.manual_seed(0)
red = nn.Sequential(nn.Linear(2, 8), nn.ReLU(), nn.Linear(8, 3))

print(red)
print(sum(p.numel() for p in red.parameters()))
print(red(X).shape)

Sequential(
  (0): Linear(in_features=2, out_features=8, bias=True)
  (1): ReLU()
  (2): Linear(in_features=8, out_features=3, bias=True)
)
51
torch.Size([4, 3])

Cuando el cálculo no es una cadena simple, se escribe una clase que hereda de nn.Module. En __init__ se crean las capas como atributos, y así el módulo registra sus parámetros. En forward se escribe el cálculo. modelo(X) llama a forward; no se llama a forward directamente.

Pregunta. Clasificador crea las mismas capas en el mismo orden que red, con la misma semilla. ¿Serán iguales las salidas de modelo y red?

class Clasificador(nn.Module):
    def __init__(self, entradas, ocultas, clases):
        super().__init__()
        self.oculta = nn.Linear(entradas, ocultas)
        self.activacion = nn.ReLU()
        self.final = nn.Linear(ocultas, clases)

    def forward(self, x):
        return self.final(self.activacion(self.oculta(x)))


torch.manual_seed(0)
modelo = Clasificador(2, 8, 3)

print([nombre for nombre, _ in modelo.named_parameters()])
print(torch.allclose(modelo(X), red(X)))

['oculta.weight', 'oculta.bias', 'final.weight', 'final.bias']
True

Funciones de activación

Una activación se aplica a cada valor por separado y no cambia la forma. Las tres más comunes son ReLU, max(0, z); la sigmoide, 1 / (1 + e^(−z)); y tanh, la tangente hiperbólica. Cada una tiene su módulo: nn.ReLU(), nn.Sigmoid() y nn.Tanh(). Su derivada decide cuánto gradiente pasa hacia las capas anteriores en backpropagation.

Pregunta. Para z = −3, −1, 0, 1, 3, decide qué función tiene derivada cero en los negativos, cuál da valores entre 0 y 1, y cuál tiene la derivada más grande en z = 0.

sin_activacion tiene las mismas capas lineales que red, pero sin ReLU entre ellas. Indexar un nn.Sequential devuelve sus capas en orden: sin_activacion[0] es la primera capa lineal, y W1 y b1 son sus pesos y sesgos; W2 y b2 son los de la segunda.

sin_activacion = nn.Sequential(nn.Linear(2, 8), nn.Linear(8, 3))
W1, b1 = sin_activacion[0].weight, sin_activacion[0].bias
W2, b2 = sin_activacion[1].weight, sin_activacion[1].bias

Pregunta. Se combinan los pesos de sin_activacion en una matriz W = W2 @ W1 y un sesgo b = W2 @ b1 + b2. ¿Qué forma tiene W? ¿X @ W.T + b reproduce la salida de sin_activacion?

Logits y probabilidades

La última capa de modelo no lleva activación. Sus salidas se llaman logits: puntajes reales sin límite, uno por clase. torch.softmax(logits, dim=1) los convierte en probabilidades: aplica la exponencial a cada logit y divide entre la suma de su fila.

Pregunta. ¿Qué clase elige el modelo para cada flor si toma el logit más grande? ¿Cambia la elección si toma la probabilidad más grande?

with torch.no_grad():
    logits = modelo(X)
probabilidades = torch.softmax(logits, dim=1)

print(logits.round(decimals=3))
print(probabilidades.round(decimals=3))
print(probabilidades.sum(dim=1).round(decimals=3))
print(logits.argmax(dim=1), probabilidades.argmax(dim=1))

tensor([[-0.2070, -0.0340,  0.1590],
        [-0.3860, -0.3750,  0.0480],
        [-0.6340, -0.6930, -0.1740],
        [-0.4150, -0.4100,  0.0210]])
tensor([[0.2750, 0.3270, 0.3970],
        [0.2810, 0.2840, 0.4340],
        [0.2840, 0.2670, 0.4490],
        [0.2820, 0.2830, 0.4350]])
tensor([1., 1., 1., 1.])
tensor([2, 2, 2, 2]) tensor([2, 2, 2, 2])

Con dos clases basta un logit por muestra. La sigmoide lo convierte en la probabilidad de la clase positiva.

Pregunta. ¿Qué probabilidad corresponde a un logit 0? ¿Coincide sigmoid(2) con la segunda probabilidad de softmax([0, 2])?

Funciones de pérdida

nn.CrossEntropyLoss recibe logits de forma (N, C) y etiquetas enteras de forma (N,), con valores de 0 a C − 1. Internamente aplica log_softmax. Para cada muestra toma menos el logaritmo de la probabilidad de su clase correcta y devuelve el promedio.

Pregunta. Las probabilidades de la clase correcta están entre 0.27 y 0.45. ¿Cerca de qué número quedará la pérdida? Escribe también el dtype y la forma de y.

criterio = nn.CrossEntropyLoss()
logits = modelo(X)
perdida = criterio(logits, y)
perdida_a_mano = -torch.log_softmax(logits, dim=1)[torch.arange(4), y].mean()

print(y.dtype, y.shape)
print(round(perdida.item(), 3), round(perdida_a_mano.item(), 3))
print(perdida.requires_grad)

torch.int64 torch.Size([4])
1.152 1.152
True

La pérdida ya aplica log_softmax. Los logits seguros corresponden a una red que acierta en las cuatro flores con un margen de 5.

Pregunta. ¿Qué pérdida dan los logits seguros? ¿Qué pérdida da el mismo acierto si antes se aplica softmax?

seguros = torch.tensor(
    [[5.0, 0.0, 0.0], [0.0, 5.0, 0.0], [0.0, 0.0, 5.0], [0.0, 5.0, 0.0]]
)

print(round(criterio(seguros, y).item(), 3))
print(round(criterio(torch.softmax(seguros, dim=1), y).item(), 3))

0.013
0.56

Para una pregunta de sí o no, como «¿la flor es de especie 2?», la red devuelve un logit por muestra, con forma (N, 1). nn.BCEWithLogitsLoss aplica la sigmoide internamente y compara con objetivos decimales 0.0 o 1.0 de la misma forma. Con reduction="none" devuelve la pérdida de cada muestra sin promediar.

Pregunta. Escribe el objetivo de cada flor y su forma. ¿Qué flor aporta más a la pérdida?

logits_binarios = torch.tensor([[-2.0], [0.5], [3.0], [-1.0]])
objetivo = (y == 2).float().unsqueeze(1)

p = torch.sigmoid(logits_binarios)
bce_a_mano = -(objetivo * torch.log(p) + (1 - objetivo) * torch.log(1 - p)).mean()
por_muestra = nn.BCEWithLogitsLoss(reduction="none")(logits_binarios, objetivo)

print(objetivo.squeeze(1), objetivo.shape)
print(por_muestra.squeeze(1).round(decimals=3))
print(round(nn.BCEWithLogitsLoss()(logits_binarios, objetivo).item(), 3))
print(round(bce_a_mano.item(), 3))

tensor([0., 0., 1., 0.]) torch.Size([4, 1])
tensor([0.1270, 0.9740, 0.0490, 0.3130])
0.366
0.366

Para predecir un número, como el ancho a partir del largo, la red devuelve un valor por muestra. nn.MSELoss promedia los cuadrados de las diferencias. X[:, 1:2] selecciona la columna del ancho y conserva los dos ejes.

Pregunta. Calcula a mano la pérdida con estas cuatro predicciones y los anchos de la tabla.

prediccion = torch.tensor([[0.5], [1.5], [2.0], [1.5]])
ancho = X[:, 1:2]

print(ancho.shape)
print(round(nn.MSELoss()(prediccion, ancho).item(), 4))

torch.Size([4, 1])
0.0875

Errores de forma

La primera capa de red es nn.Linear(2, 8). Multiplica el último eje de la entrada por weight.T, de forma (2, 8).

Pregunta. red espera dos características. ¿Qué pasa si recibe tres? ¿Qué forma de salida da una sola flor escrita como vector (2,)?

try:
    red(torch.ones(4, 3))
except RuntimeError as error:
    print(error)

una_flor = torch.tensor([1.4, 0.2])
print(red(una_flor).shape)
print(red(una_flor.unsqueeze(0)).shape)

mat1 and mat2 shapes cannot be multiplied (4x3 and 2x8)
torch.Size([3])
torch.Size([1, 3])

CrossEntropyLoss también revisa las etiquetas.

Pregunta. ¿Qué pasa si las etiquetas llegan como decimales? ¿Y como columna de forma (4, 1)?

for etiquetas in [y.float(), y.unsqueeze(1)]:
    try:
        criterio(logits, etiquetas)
    except RuntimeError as error:
        print(etiquetas.dtype, tuple(etiquetas.shape), "->", error)

torch.float32 (4,) -> expected scalar type Long but found Float
torch.int64 (4, 1) -> 0D or 1D target tensor expected, multi-target not supported

X[:, 1] selecciona la misma columna que X[:, 1:2], pero con forma (4,) en lugar de (4, 1).

Pregunta. Si X[:, 1] se usa como objetivo con prediccion de forma (4, 1), ¿qué forma tiene la resta? ¿La pérdida sigue siendo 0.0875?

import warnings

with warnings.catch_warnings(record=True) as avisos:
    warnings.simplefilter("always")
    perdida_mal = nn.MSELoss()(prediccion, X[:, 1])

print((prediccion - X[:, 1]).shape)
print(round(perdida_mal.item(), 4))
print(avisos[0].message)

torch.Size([4, 4])
0.9625
Using a target size (torch.Size([4])) that is different to the input size (torch.Size([4, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.

Práctica

Traza guiada

Antes de procesar, escribe la forma de traza[0].weight, el número total de parámetros, las formas de oculta y salida_traza, y el intervalo donde caen los valores de oculta.

torch.manual_seed(0)
traza = nn.Sequential(nn.Linear(5, 16), nn.Tanh(), nn.Linear(16, 4))
entrada = torch.randn(10, 5)

oculta = traza[1](traza[0](entrada))
salida_traza = traza(entrada)

Comprueba con print. Si el número de parámetros no coincide, revisa que contaste un sesgo por salida en cada capa lineal.

Clasificador binario

Cambia Clasificador para que responda «¿la flor es de especie 2?» con un solo logit por flor. Antes de procesar, predice la forma de la salida y la del objetivo (y == 2).float().unsqueeze(1). Calcula nn.BCEWithLogitsLoss y comprueba con assert que coincide con la fórmula de «Funciones de pérdida» con tolerancia 1e-6. Si aparece Target size ... must be the same as input size, compara las dos formas.

Regresor propio

Genera 20 flores sintéticas con np.random.default_rng(0): largo uniforme entre 1 y 7, y ancho igual a 0.4 · largo − 0.4 más ruido normal con desviación 0.1. Escribe una subclase de nn.Module que:

1. reciba el largo como tensor float32 de forma (20, 1)
2. use una capa oculta de 4 unidades con nn.Tanh()
3. devuelva un valor por flor
4. calcule nn.MSELoss con un objetivo de forma (20, 1) y compruebe ambas formas con assert
5. repita la pérdida con el objetivo de forma (20,) y registre el aviso y el valor distinto

Reto opcional

Escribe logits de forma (4, 3) que acierten en las cuatro flores y den una CrossEntropyLoss menor que 0.01. Antes de procesar, predice qué logit de cada fila debe ser el mayor y por cuánto. Después aplica softmax antes de la pérdida y calcula a mano el valor al que se acerca cuando la diferencia entre logits crece sin límite.

Errores que revisar

• Si la pérdida de clasificación se estanca muy por encima de 0 aunque la red acierte (con tres clases, cerca de 0.55), revisa si aplicaste softmax antes de CrossEntropyLoss. La pérdida espera logits.
• Si aparece mat1 and mat2 shapes cannot be multiplied (4x3 and 2x8), el número de características de la entrada (3) no coincide con in_features de la primera capa (2).
• Si CrossEntropyLoss lanza expected scalar type Long but found Float o multi-target not supported, convierte las etiquetas con .long() y dales forma (N,) con .squeeze(1).
• Si MSELoss avisa Using a target size ... that is different to the input size, la pérdida comparó todas las parejas por broadcasting. Da al objetivo la misma forma que la predicción.
• Si BCEWithLogitsLoss lanza Target size (torch.Size([4])) must be the same as input size (torch.Size([4, 1])), añade el eje con .unsqueeze(1) y convierte el objetivo a float.

Cierre

Explica qué forma, qué tipo y qué significado tienen la salida de modelo y las etiquetas y cuando se pasan a CrossEntropyLoss, y por qué esa salida no pasa antes por softmax.

Lista de comprobación

• ¿Qué forma tiene weight en nn.Linear(entradas, salidas) y cuántos parámetros aporta la capa?
• ¿Por qué dos capas lineales sin activación equivalen a una sola?
• ¿Qué cambia y qué se conserva al pasar de logits a probabilidades en una misma fila?
• ¿Qué forma y qué dtype espera como objetivo cada una de CrossEntropyLoss, BCEWithLogitsLoss y MSELoss?
• ¿Qué error de forma produce un número equivocado sin lanzar excepción?

Documentación oficial

• Build the Neural Network: subclases de nn.Module, nn.Linear, nn.ReLU, nn.Sequential y nn.Softmax.
• torch.nn: índice de capas, activaciones y funciones de pérdida.
• CrossEntropyLoss: formas de entrada y objetivo, etiquetas enteras y reduction.
• BCEWithLogitsLoss: pérdida binaria que recibe logits.
• MSELoss: error cuadrático medio para regresión.