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
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érdidaForma 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
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

# Suavizado de etiquetas, alivia el sobreajuste; se usa a menudo en competiciones de clasificación de imágenes
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

criterion = nn.BCELoss()

# 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

criterion = nn.BCEWithLogitsLoss()

# 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

# pos_weight: peso de muestras positivas; cuanto mayor es el valor, más atención a las muestras positivas
# 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

criterion = nn.NLLLoss()

# 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 usarCrossEntropyLoss。


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

criterion = nn.MSELoss()

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

criterion = nn.L1Loss()

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

criterion = nn.SmoothL1Loss()

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
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

# delta controla el punto de conmutación entre MSE y L1
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

criterion = nn.KLDivLoss(reduction='batchmean')

# 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

temperature = 4.0  # Coeficiente de temperatura, cuanto mayor, más suave

# 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

criterion = nn.MarginRankingLoss(margin=0.5)

# 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

criterion = nn.TripletMarginLoss(margin=1.0)

# 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

criterion = nn.CTCLoss(blank=0)  # Índice de la etiqueta blank

# 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

predictions = torch.tensor([1.0, 2.0, 3.0, 4.0])
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

# Dar mayor peso a las muestras con mayor error (idea de focal loss)
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

# Supongamos 3 clases: la clase 0 tiene 1000, la clase 1 tiene 100, la clase 2 tiene 50
# 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

# ignore_index: ignora esa etiqueta al calcular la pérdida
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
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
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 tareaFunción de pérdida recomendadaNotas
Clasificación múltipleCrossEntropyLossLa 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 binariaBCEWithLogitsLossMás estable que BCELoss
Clasificación multi-etiquetaBCEWithLogitsLossCada etiqueta se evalúa de forma independiente
Detección de objetos (cabeza de clasificación)CrossEntropyLoss / Focal LossUsar Focal cuando hay desequilibrio entre muestras positivas y negativas
Detección de objetos (cabeza de regresión)SmoothL1Loss / GIoULossPráctica estándar
Regresión normalMSELossPrimera opción cuando no hay valores atípicos
Regresión con valores atípicosHuberLoss / SmoothL1LossRegresión robusta
Segmentación de imágenesCrossEntropyLoss + DiceLossMejor usar en combinación
Reconocimiento de vozCTCLossAlineación de secuencias
Aprendizaje métrico / reconocimiento facialTripletMarginLossAprender distancias en el espacio de características
Destilación de conocimientoKLDivLossAprender la distribución de etiquetas suaves

Errores comunes y precauciones

Ejemplo

# Error: se aplicó Softmax manualmente antes de CrossEntropyLoss
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
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}")
Otras extensiones