PyTorch función de pérdida
La función de pérdida (Loss Function) mide la diferencia entre los valores predichos por el modelo y los valores reales; es la guía central del entrenamiento de redes neuronales: el optimizador actualiza los parámetros del modelo minimizando la función de pérdida.
PyTorch entorch.nnel módulo incluye más de una docena de funciones de pérdida de uso común, que cubren los principales tipos de tareas como clasificación, regresión y ranking.
1. Fundamentos de la función de pérdida
Uso básico
Todas las funciones de pérdida de PyTorch sonnn.Modulesubclases de, y su forma de uso es uniforme:
Ejemplo
import torch.nn as nn
# 1. Instanciar la función de pérdida
criterion = nn.CrossEntropyLoss()
# 2. Calcular la pérdida (primero las predicciones, luego los valores reales)
loss = criterion(predictions, targets)
# 3. Retropropagación
loss.backward()
Convención de forma de los valores predichos
Las distintas funciones de pérdida tienen requisitos diferentes sobre la forma de las entradas; este es uno de los errores más comunes entre los principiantes:
| Función de pérdida | Forma del valor predicho (input) | Forma de la etiqueta (target) |
|---|---|---|
CrossEntropyLoss | (N, C)logits originales | (N,)índice de clase entero |
BCELoss | (N,)probabilidades después de Sigmoid | (N,)números flotantes 0/1 |
BCEWithLogitsLoss | (N,)logits originales | (N,)números flotantes 0/1 |
MSELoss | (N,)cualquier número real | (N,)cualquier número real |
NLLLoss | (N, C)probabilidades después de log_softmax | (N,)índice de clase entero |
N = batch size,C= número de clases
2. Funciones de pérdida para tareas de clasificación
2.1 CrossEntropyLoss (pérdida de entropía cruzada)
La función de pérdida de clasificación multiclase más utilizada,internamente ejecuta automáticamente Softmax + logaritmo + signo negativo, no es necesario aplicar Softmax manualmente a la salida del modelo.
Fórmula matemática:
Loss = -sum(y_c * log(p_c))
donde p_c = exp(x_c) / sum_j exp(x_j) es la salida de Softmax.
Ejemplo
import torch.nn as nn
criterion = nn.CrossEntropyLoss()
# Salida del modelo: logits originales, shape (batch_size, num_classes)
# ¡No es necesario aplicar Softmax previamente!
predictions = torch.tensor([
[2.0, 0.5, 0.3], # Muestra 1, más probablemente clase 0
[0.1, 3.0, 0.2], # Muestra 2, más probablemente clase 1
[0.2, 0.1, 4.0], # Muestra 3, más probablemente clase 2
])
# Etiquetas: índices de clase enteros, shape (batch_size,)
targets = torch.tensor([0, 1, 2])
loss = criterion(predictions, targets)
print(f"Loss: {loss.item():.4f}") # Loss: 0.1763
Soporta etiquetas suaves (Label Smoothing):
Ejemplo
criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
# También permite pasar directamente etiquetas suaves (distribución de probabilidad)
soft_targets = torch.tensor([
[0.9, 0.05, 0.05],
[0.05, 0.9, 0.05],
])
predictions = torch.randn(2, 3)
loss = criterion(predictions, soft_targets)
Escenarios de aplicación:Todas las tareas de clasificación multiclase: clasificación de múltiples clases (gato/perro/pájaro), clasificación de imágenes, clasificación de texto, etc.
2.2 BCELoss (pérdida de entropía cruzada binaria)
Especialmente diseñada paraclasificación binariaoclasificación multi-etiquetatareas. La entrada debe ser el resultado de aplicarSigmoidprocesamiento, con valores de probabilidad (0~1).
Fórmula matemática:
Loss = -[y * log(p) + (1-y) * log(1-p)]
Ejemplo
# La salida del modelo primero debe pasar por Sigmoid, con rango (0, 1)
raw_output = torch.tensor([2.0, -1.0, 0.5, -3.0])
predictions = torch.sigmoid(raw_output) # [0.88, 0.27, 0.62, 0.05]
# Etiquetas: flotante 0.0 o 1.0
targets = torch.tensor([1.0, 0.0, 1.0, 0.0])
loss = criterion(predictions, targets)
print(f"Loss: {loss.item():.4f}") # Loss: 0.2824
# Clasificación multi-etiqueta (cada muestra puede pertenecer a varias clases)
# predictions shape: (batch_size, num_labels)
predictions_ml = torch.sigmoid(torch.randn(4, 5))
targets_ml = torch.randint(0, 2, (4, 5)).float()
loss_ml = criterion(predictions_ml, targets_ml)
BCELossSe requiere que la entrada esté en el rango (0, 1); pasar logits originales puede causar inestabilidad numérica e incluso NaN. Se recomienda usar la siguienteBCEWithLogitsLoss。
2.3 BCEWithLogitsLoss
BCELossversión mejorada de,que internamente ejecuta Sigmoid automáticamente, numéricamente más estable, se recomienda usarla preferentemente.
Ejemplo
# Pasar los logits originales directamente, sin Sigmoid manual
predictions = torch.tensor([2.0, -1.0, 0.5, -3.0])
targets = torch.tensor([1.0, 0.0, 1.0, 0.0])
loss = criterion(predictions, targets)
print(f"Loss: {loss.item():.4f}")
# Equivalente a (pero con mejor estabilidad numérica):
# loss = BCELoss(Sigmoid(predictions), targets)
Con pesos de muestras positivas (manejo de desequilibrio de clases):
Ejemplo
# Por ejemplo, si las muestras negativas son 10 veces las positivas, establezca pos_weight=10
pos_weight = torch.tensor([10.0])
criterion = nn.BCEWithLogitsLoss(pos_weight=pos_weight)
Escenarios de aplicación:Clasificación binaria (detección de spam), clasificación multi-etiqueta (etiquetado de artículos con múltiples etiquetas), detección de objetos (distinción fondo/primer plano).
2.4 NLLLoss (pérdida de log-verosimilitud negativa)
Requiere aplicar manualmente a la salida del modelolog_softmax, lo que ofrece mayor flexibilidad.CrossEntropyLoss = LogSoftmax + NLLLoss。
Ejemplo
# Primero debe aplicar log_softmax manualmente
raw_output = torch.randn(4, 3) # (batch, num_classes)
log_probs = torch.log_softmax(raw_output, dim=1)
targets = torch.tensor([0, 2, 1, 0])
loss = criterion(log_probs, targets)
Escenarios de uso:Cuando sea necesario usar probabilidades logarítmicas en pasos intermedios (como CTC, Beam Search); en otros casos, prefiera usar
CrossEntropyLoss。
3. Funciones de pérdida para tareas de regresión
3.1 MSELoss (error cuadrático medio)
La pérdida de regresión más clásica; paraes muy sensible a errores grandes(porque el cuadrado amplifica el efecto de los errores grandes).
Fórmula matemática:
MSELoss = (1/N) * sum((y_i - y_hat_i)^2)
Ejemplo
predictions = torch.tensor([2.5, 0.5, 2.0, 8.0])
targets = torch.tensor([3.0, -0.5, 2.0, 7.0])
loss = criterion(predictions, targets)
print(f"MSE Loss: {loss.item():.4f}") # MSE Loss: 0.3750
# Verificación manual
manual = ((predictions - targets) ** 2).mean()
print(f"Cálculo manual: {manual.item():.4f}") # 0.3750
Escenarios de aplicación:Regresión de valores continuos como predicción de precios de vivienda, predicción de temperatura; funciona bien cuando no hay valores atípicos evidentes en los datos.
3.2 L1Loss (error absoluto medio)
SobreMás robusto frente a valores atípicos (outliers), porque usa valor absoluto en lugar de cuadrado, por lo que los errores grandes no se amplifican excesivamente.
Fórmula matemática:
L1Loss = (1/N) * sum(|y_i - y_hat_i|)
Ejemplo
predictions = torch.tensor([2.5, 0.5, 2.0, 8.0])
targets = torch.tensor([3.0, -0.5, 2.0, 7.0])
loss = criterion(predictions, targets)
print(f"L1 Loss: {loss.item():.4f}") # L1 Loss: 0.5000
3.3 SmoothL1Loss (pérdida de Huber)
Combina las ventajas de MSE y L1: cuando el error es pequeño usa MSE (suave, gradiente estable); cuando el error es grande usa L1 (resistente a valores atípicos). Es la pérdida estándar en la detección de objetos (Faster R-CNN).
Fórmula matemática:
SmoothL1(x) = 0.5*x^2 if |x| < 1, else |x| - 0.5
Ejemplo
predictions = torch.tensor([2.5, 0.5, 2.0, 8.0])
targets = torch.tensor([3.0, -0.5, 2.0, 7.0])
loss = criterion(predictions, targets)
print(f"SmoothL1 Loss: {loss.item():.4f}")
Comparación de las tres pérdidas de regresión:
Ejemplo
import torch.nn as nn
predictions = torch.tensor([0.0, 1.0, 5.0, 10.0]) # Simular errores de diferentes magnitudes
targets = torch.zeros(4)
for name, fn in [("MSELoss", nn.MSELoss(reduction='none')),
("L1Loss", nn.L1Loss(reduction='none')),
("SmoothL1",nn.SmoothL1Loss(reduction='none'))]:
losses = fn(predictions, targets)
print(f"{name:12s}: {[f'{l:.2f}' for l in losses.tolist()]}")
输出示例: MSELoss : ['0.00', '1.00', '25.00', '100.00'] # 大误差被平方放大 L1Loss : ['0.00', '1.00', '5.00', '10.00'] # 线性增长 SmoothL1 : ['0.00', '0.50', '4.50', '9.50'] # 中间值
Escenarios de aplicación:Regresión de bounding boxes en detección de objetos, estimación de profundidad, y tareas de regresión donde coexisten errores pequeños y valores atípicos.
4. Funciones de pérdida avanzadas
4.1 HuberLoss
SmoothL1Lossversión general de, permite personalizar el umbral de conmutacióndelta(por defecto 1.0).
Ejemplo
criterion = nn.HuberLoss(delta=1.5)
predictions = torch.randn(10)
targets = torch.randn(10)
loss = criterion(predictions, targets)
4.2 KLDivLoss (divergencia KL)
Mide la diferencia entre dos distribuciones de probabilidad, se utiliza comúnmente endestilación de conocimientoyautoencoders variacionales (VAE)。
Fórmula matemática:
KL(P || Q) = sum(P(i) * log(P(i) / Q(i)))
Ejemplo
# input debe ser log-probabilidad (probabilidad logarítmica), target es probabilidad normal
log_predictions = torch.log_softmax(torch.randn(4, 5), dim=1)
targets = torch.softmax(torch.randn(4, 5), dim=1)
loss = criterion(log_predictions, targets)
print(f"KL Div Loss: {loss.item():.4f}")
Uso típico en destilación de conocimiento:
Ejemplo
# Salida del modelo profesor (teacher)
teacher_logits = torch.randn(32, 10)
# Salida del modelo estudiante (student)
student_logits = torch.randn(32, 10)
soft_labels = torch.softmax(teacher_logits / temperature, dim=1)
soft_preds = torch.log_softmax(student_logits / temperature, dim=1)
distill_loss = nn.KLDivLoss(reduction='batchmean')(soft_preds, soft_labels)
distill_loss *= temperature ** 2 # Restaurar la magnitud del gradiente
4.3 MarginRankingLoss (pérdida de ranking con margen)
Determina el orden relativo de dos entradas, se utiliza comúnmente enaprendizaje por rankingyaprendizaje de similitud。
Ejemplo
# x1 debería estar más cerca de target que x2 (y=1 indica que x1 > x2)
x1 = torch.tensor([0.8, 0.3, 0.6])
x2 = torch.tensor([0.2, 0.7, 0.5])
y = torch.tensor([1.0, -1.0, 1.0]) # 1: x1>x2, -1: x1<x2
loss = criterion(x1, x2, y)
4.4 TripletMarginLoss (pérdida de tripletes)
Se usa para aprendizaje métrico, se requiere que la distancia deanchor (ancla)ya positive (misma clase)sea menor que la distancia anegative (clase diferente).
Ejemplo
# La dimensión de cada vector es embedding_dim
anchor = torch.randn(32, 128) # Muestra ancla
positive = torch.randn(32, 128) # Muestra de la misma clase
negative = torch.randn(32, 128) # Muestra de clase diferente
loss = criterion(anchor, positive, negative)
# Objetivo: dist(anchor, positive) + margin < dist(anchor, negative)
Escenarios aplicables:Reconocimiento facial, recuperación de imágenes, Few-Shot Learning.
4.5 CTCLoss (pérdida de etiquetado de secuencias)
Se usa paratareas de secuencia donde la entrada y la salida no coinciden en longitud,como reconocimiento de voz (secuencia acústica -> secuencia de texto), reconocimiento de escritura manual.
Ejemplo
# log_probs: (T, N, C) T=paso temporal, N=batch, C=número de clases
T, N, C = 50, 4, 20
log_probs = torch.log_softmax(torch.randn(T, N, C), dim=2)
targets = torch.randint(1, C, (N * 10,)) # Secuencia objetivo concatenada
input_lengths = torch.full((N,), T, dtype=torch.long)
target_lengths = torch.full((N,), 10, dtype=torch.long)
loss = criterion(log_probs, targets, input_lengths, target_lengths)
5. Explicación detallada del parámetro reduction
Todas las funciones de pérdida admiten elreductionparámetro, que controla cómo se agregan las pérdidas de las muestras:
Ejemplo
targets = torch.tensor([1.5, 2.5, 2.0, 5.0])
# Error de muestras individuales: [0.25, 0.25, 1.00, 1.00]
# mean (por defecto): calcula el promedio de todas las muestras
loss_mean = nn.MSELoss(reduction='mean')(predictions, targets)
print(f"mean: {loss_mean.item():.4f}") # 0.6250
# sum: suma todas las muestras
loss_sum = nn.MSELoss(reduction='sum')(predictions, targets)
print(f"sum: {loss_sum.item():.4f}") # 2.5000
# none: devuelve la pérdida independiente de cada muestra (se usa a menudo para ponderación)
loss_none = nn.MSELoss(reduction='none')(predictions, targets)
print(f"none: {loss_none.tolist()}") # [0.25, 0.25, 1.0, 1.0]
reduction='none'Su aplicación práctica: ponderar diferentes muestras:
Ejemplo
per_sample_loss = nn.MSELoss(reduction='none')(predictions, targets)
weights = torch.tensor([1.0, 1.0, 2.0, 2.0]) # Configurar pesos manualmente
weighted_loss = (per_sample_loss * weights).mean()
6. Pesos de clase y pesos de muestra
Pesos de clase (manejo de desequilibrio de clases)
Cuando algunas clases tienen muy pocas muestras en el conjunto de datos, se puede dar mayor peso a las clases minoritarias:
Ejemplo
# Pesos inversamente proporcionales a la frecuencia
class_counts = torch.tensor([1000.0, 100.0, 50.0])
weights = 1.0 / class_counts
weights = weights / weights.sum() * len(weights) # Normalización
criterion = nn.CrossEntropyLoss(weight=weights)
Ignorar etiquetas específicas
En tareas como la segmentación semántica, a menudo es necesario ignorar los píxeles de borde (etiqueta 255):
Ejemplo
criterion = nn.CrossEntropyLoss(ignore_index=255)
# Escenario de segmentación semántica
predictions = torch.randn(2, 21, 256, 256) # (N, C, H, W)
targets = torch.randint(0, 22, (2, 256, 256))
targets[targets == 21] = 255 # Los bordes están etiquetados como 255
loss = criterion(predictions, targets)
7. Funciones de pérdida personalizadas
Cuando las funciones de pérdida integradas no satisfacen las necesidades, se pueden personalizar de dos maneras:
Opción 1: funcional (simple)
Ejemplo
import torch.nn.functional as F
def focal_loss(predictions, targets, gamma=2.0, alpha=0.25):
"""
Focal Loss: resuelve el grave desequilibrio entre muestras positivas y negativas en la detección de objetos
Reduce el peso de las muestras fáciles de clasificar para que el modelo se centre en las muestras difíciles
"""
ce_loss = F.cross_entropy(predictions, targets, reduction='none')
pt = torch.exp(-ce_loss) # Probabilidad de la predicción correcta
focal_weight = alpha * (1 - pt) ** gamma # Las muestras difíciles tienen mayor peso
return (focal_weight * ce_loss).mean()
# Uso
predictions = torch.randn(8, 10)
targets = torch.randint(0, 10, (8,))
loss = focal_loss(predictions, targets)
Opción 2: heredar de nn.Module (recomendado)
Ejemplo
import torch.nn as nn
class DiceLoss(nn.Module):
"""
Dice Loss: se usa comúnmente en segmentación de imágenes, optimiza directamente el coeficiente Dice
Es más robusto que CrossEntropy ante el desequilibrio de clases (como la segmentación de objetos pequeños)
"""
def __init__(self, smooth=1.0):
super().__init__()
self.smooth = smooth
def forward(self, predictions, targets):
# predictions: (N, C, H, W) -> probabilidades después de sigmoid
# targets: (N, C, H, W) -> etiquetas codificadas one-hot
predictions = torch.sigmoid(predictions)
# Aplanar a (N, -1)
pred_flat = predictions.view(predictions.size(0), -1)
target_flat = targets.view(targets.size(0), -1).float()
intersection = (pred_flat * target_flat).sum(dim=1)
dice = (2.0 * intersection + self.smooth) / (
pred_flat.sum(dim=1) + target_flat.sum(dim=1) + self.smooth
)
return 1 - dice.mean()
class CombinedLoss(nn.Module):
"""
Pérdida combinada: CrossEntropy + Dice, que tiene en cuenta tanto la clasificación a nivel de píxel como la superposición de regiones
Combinación común en segmentación de imágenes
"""
def __init__(self, ce_weight=0.5, dice_weight=0.5):
super().__init__()
self.ce_weight = ce_weight
self.dice_weight = dice_weight
self.ce = nn.CrossEntropyLoss()
self.dice = DiceLoss()
def forward(self, predictions, targets):
return (self.ce_weight * self.ce(predictions, targets) +
self.dice_weight * self.dice(predictions, targets))
# Uso
criterion = CombinedLoss(ce_weight=0.4, dice_weight=0.6)
8. Guía para elegir la función de pérdida
Selección según el tipo de tarea
| Tipo de tarea | Función de pérdida recomendada | Notas |
|---|---|---|
| Clasificación múltiple | CrossEntropyLoss | La más general, prioritaria |
| Clasificación múltiple (desequilibrio de clases) | CrossEntropyLoss(weight=...) | Ponderar las clases minoritarias |
| Clasificación múltiple (etiquetas con mucho ruido) | CrossEntropyLoss(label_smoothing=0.1) | Evita el sobreajuste |
| Clasificación binaria | BCEWithLogitsLoss | Más estable que BCELoss |
| Clasificación multi-etiqueta | BCEWithLogitsLoss | Cada etiqueta se evalúa de forma independiente |
| Detección de objetos (cabeza de clasificación) | CrossEntropyLoss / Focal Loss | Usar Focal cuando hay desequilibrio entre muestras positivas y negativas |
| Detección de objetos (cabeza de regresión) | SmoothL1Loss / GIoULoss | Práctica estándar |
| Regresión normal | MSELoss | Primera opción cuando no hay valores atípicos |
| Regresión con valores atípicos | HuberLoss / SmoothL1Loss | Regresión robusta |
| Segmentación de imágenes | CrossEntropyLoss + DiceLoss | Mejor usar en combinación |
| Reconocimiento de voz | CTCLoss | Alineación de secuencias |
| Aprendizaje métrico / reconocimiento facial | TripletMarginLoss | Aprender distancias en el espacio de características |
| Destilación de conocimiento | KLDivLoss | Aprender la distribución de etiquetas suaves |
Errores comunes y precauciones
Ejemplo
output = torch.softmax(model(x), dim=1) # Softmax redundante
loss = nn.CrossEntropyLoss()(output, targets) # Internamente lo aplicará de nuevo
# Correcto: pasar los logits directamente
output = model(x) # Logits originales
loss = nn.CrossEntropyLoss()(output, targets)
# Error: BCELoss recibe valores crudos sin sigmoid
loss = nn.BCELoss()(model(x), targets) # Puede salirse de [0,1], numéricamente inestable
# Correcto: usar BCEWithLogitsLoss
loss = nn.BCEWithLogitsLoss()(model(x), targets)
# Error: tipo de etiqueta no coincide (entero vs flotante)
targets = torch.tensor([1, 0, 1]) # Tipo int
loss = nn.BCEWithLogitsLoss()(preds, targets) # ¡Error!
# Correcto: BCEWithLogitsLoss requiere etiquetas float
targets = torch.tensor([1.0, 0.0, 1.0]) # Tipo float
loss = nn.BCEWithLogitsLoss()(preds, targets) # Correcto
# Error: la loss no usa .item(), lo que hace que el grafo computacional se acumule y la memoria de video se desborde
total_loss += loss # La loss es un tensor y mantiene el grafo computacional
# Correcto: usar .item() para obtener el escalar
total_loss += loss.item()
Ejemplo completo de entrenamiento
Ejemplo
import torch.nn as nn
import torch.optim as optim
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Modelo y función de pérdida y optimizador
model = MyModel().to(device)
criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
optimizer = optim.Adam(model.parameters(), lr=1e-3)
for epoch in range(num_epochs):
model.train()
total_loss, correct = 0.0, 0
for inputs, labels in train_loader:
inputs = inputs.to(device)
labels = labels.to(device)
optimizer.zero_grad()
outputs = model(inputs) # Logits originales
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
total_loss += loss.item() * inputs.size(0) # .item() para obtener el escalar
correct += (outputs.argmax(1) == labels).sum().item()
avg_loss = total_loss / len(train_loader.dataset)
accuracy = correct / len(train_loader.dataset)
print(f"Epoch {epoch+1} | Loss: {avg_loss:.4f} | Acc: {accuracy:.4f}")