损失函数大全：从 MSE 到 Focal Loss

import numpy as np

# 损失函数：预测与真实之间的桥梁
def visualize_loss_landscape():
    """可视化损失函数的优化地形"""
    def quadratic_loss(w):
        return (w - 3) ** 2 + 2

    def rosenbrock(x, y):
        return (1 - x)  2 + 100 * (y - x  2) ** 2

    # 单变量损失函数（如 MSE 在单层线性模型中）
    w_range = np.linspace(-5, 10, 100)
    losses = [quadratic_loss(w) for w in w_range]
    min_w = w_range[np.argmin(losses)]
    print(f"最小损失点: w = {min_w:.2f}")

    # 多变量损失函数（更复杂的优化地形）
    x = np.linspace(-2, 2, 50)
    y = np.linspace(-1, 3, 50)
    X, Y = np.meshgrid(x, y)
    Z = rosenbrock(X, Y)
    print(f"Rosenbrock 最小值在 (1, 1)，值为 0")

visualize_loss_landscape()

import torch
import torch.nn as nn

# PyTorch 中的损失函数层次结构
print("=== PyTorch 损失函数分类 ===")

# 回归损失
regression_losses = ["MSELoss", "L1Loss", "SmoothL1Loss", "HuberLoss"]
print(f"回归: {regression_losses}")

# 分类损失
classification_losses = ["CrossEntropyLoss", "BCELoss", "BCEWithLogitsLoss", "NLLLoss"]
print(f"分类: {classification_losses}")

# 高级损失
advanced_losses = ["FocalLoss (torchvision)", "TripletMarginLoss", "ContrastiveLoss", "CTCLoss"]
print(f"高级: {advanced_losses}")

# 损失函数 vs 评估指标的区别
# 损失函数：必须可微，用于梯度反向传播
# 评估指标：可以不可微，用于衡量模型好坏
model = nn.Linear(10, 2)
x = torch.randn(5, 10)
y = torch.tensor([0, 1, 0, 1, 0])

loss_fn = nn.CrossEntropyLoss()  # 可微 → 用于训练
output = model(x)
loss = loss_fn(output, y)
loss.backward()  # 梯度可以反向传播

import numpy as np

def mse_loss(y_true, y_pred):
    """均方误差：对大误差敏感"""
    return np.mean((y_true - y_pred) ** 2)

def mae_loss(y_true, y_pred):
    """平均绝对误差：对异常值鲁棒"""
    return np.mean(np.abs(y_true - y_pred))

def huber_loss(y_true, y_pred, delta=1.0):
    """Huber Loss：MSE 和 MAE 的平滑折中"""
    error = y_true - y_pred
    is_small = np.abs(error) <= delta
    return np.mean(
        np.where(is_small, 0.5 * error  2, delta * np.abs(error) - 0.5 * delta  2)
    )

def smooth_l1_loss(y_true, y_pred, beta=1.0):
    """Smooth L1 Loss：Faster R-CNN 默认回归损失"""
    error = y_true - y_pred
    abs_error = np.abs(error)
    return np.mean(
        np.where(abs_error < beta,
                 0.5 * error ** 2 / beta,
                 abs_error - 0.5 * beta)
    )

# 对比实验：存在异常值时各损失的表现
y_true = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
y_pred_normal = np.array([1.1, 2.1, 3.1, 4.1, 5.1])
y_pred_outlier = np.array([1.1, 2.1, 3.1, 4.1, 50.0])  # 第5个是异常值

print(f"正常预测 - MSE: {mse_loss(y_true, y_pred_normal):.4f}, MAE: {mae_loss(y_true, y_pred_normal):.4f}")
print(f"异常预测 - MSE: {mse_loss(y_true, y_pred_outlier):.4f}, MAE: {mae_loss(y_true, y_pred_outlier):.4f}")
# MSE 从 0.01 暴增到 810.9，MAE 从 0.1 仅增至 9.08

import torch
import torch.nn as nn

# PyTorch 中的回归损失
y_true = torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0])
y_pred = torch.tensor([1.5, 2.5, 3.5, 4.5, 5.5])

# MSE Loss
mse = nn.MSELoss()
print(f"MSE: {mse(y_pred, y_true):.4f}")  # 0.2500

# L1 Loss (MAE)
l1 = nn.L1Loss()
print(f"L1: {l1(y_pred, y_true):.4f}")  # 0.5000

# Smooth L1 Loss
smooth_l1 = nn.SmoothL1Loss(beta=1.0)
print(f"SmoothL1: {smooth_l1(y_pred, y_true):.4f}")

# Huber Loss (PyTorch 1.10+)
huber = nn.HuberLoss(delta=1.0)
print(f"Huber: {huber(y_pred, y_true):.4f}")

# reduction 选项
mse_sum = nn.MSELoss(reduction='sum')
mse_none = nn.MSELoss(reduction='none')
print(f"sum: {mse_sum(y_pred, y_true):.4f}")       # 1.2500
print(f"none: {mse_none(y_pred, y_true)}")           # 每个样本独立损失

import numpy as np

def binary_cross_entropy(y_true, y_pred, eps=1e-15):
    """二分类交叉熵（BCE）从零实现"""
    y_pred = np.clip(y_pred, eps, 1 - eps)  # 防止 log(0)
    return -np.mean(
        y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred)
    )

def categorical_cross_entropy(y_true, y_pred, eps=1e-15):
    """多分类交叉熵从零实现"""
    y_pred = np.clip(y_pred, eps, 1 - eps)
    return -np.mean(np.sum(y_true * np.log(y_pred), axis=1))

def softmax(logits):
    """Softmax 函数：将 logit 转为概率"""
    exp_logits = np.exp(logits - np.max(logits, axis=1, keepdims=True))  # 数值稳定
    return exp_logits / np.sum(exp_logits, axis=1, keepdims=True)

# 二分类示例
y_true_binary = np.array([1, 0, 1, 1, 0])
y_pred_binary = np.array([0.9, 0.1, 0.8, 0.3, 0.4])
bce = binary_cross_entropy(y_true_binary, y_pred_binary)
print(f"BCE: {bce:.4f}")

# 多分类示例
logits = np.array([[2.0, 1.0, 0.1],   # 预测偏向类别 0
                   [0.5, 3.0, 0.2]])   # 预测偏向类别 1
probs = softmax(logits)
y_true_multi = np.array([[1, 0, 0],    # one-hot
                         [0, 1, 0]])
cce = categorical_cross_entropy(y_true_multi, probs)
print(f"CrossEntropy: {cce:.4f}")

import torch
import torch.nn as nn

# 二分类：BCEWithLogitsLoss（推荐）
logits_binary = torch.tensor([2.0, -1.0, 1.5, -0.5, 3.0])
labels_binary = torch.tensor([1.0, 0.0, 1.0, 0.0, 1.0])

# ❌ 不推荐：分开做 Sigmoid + BCE
bce_manual = nn.BCELoss()
probs = torch.sigmoid(logits_binary)
loss_manual = bce_manual(probs, labels_binary)

# ✅ 推荐：BCEWithLogitsLoss（数值稳定）
bce_auto = nn.BCEWithLogitsLoss()
loss_auto = bce_auto(logits_binary, labels_binary)
print(f"Manual BCE: {loss_manual:.4f}")  # 0.2271
print(f"Auto BCE:   {loss_auto:.4f}")    # 0.2271（相同结果）

# 多分类：CrossEntropyLoss
logits_multi = torch.tensor([[2.0, 1.0, 0.1],   # 3 个类别的 logit
                             [0.5, 3.0, 0.2]])
labels_multi = torch.tensor([0, 1])              # 类别索引

# ❌ 不推荐：手动 Softmax + NLLLoss
# ✅ 推荐：直接使用 CrossEntropyLoss（内部自动 Softmax）
ce_loss = nn.CrossEntropyLoss()
loss_multi = ce_loss(logits_multi, labels_multi)
print(f"CrossEntropy: {loss_multi:.4f}")

import numpy as np

def focal_loss(y_true, y_pred, gamma=2.0, alpha=0.25, eps=1e-15):
    """Focal Loss 从零实现"""
    y_pred = np.clip(y_pred, eps, 1 - eps)

    # p_t: 模型对真实类别的预测概率
    p_t = np.where(y_true == 1, y_pred, 1 - y_pred)

    # α_t: 类别平衡因子
    alpha_t = np.where(y_true == 1, alpha, 1 - alpha)

    # Focal Loss = -α_t · (1 - p_t)^γ · log(p_t)
    focal_weight = alpha_t * (1 - p_t) ** gamma
    loss = -focal_weight * np.log(p_t)

    return np.mean(loss)

# 对比：标准交叉熵 vs Focal Loss
y_true = np.array([1, 1, 0, 0, 0, 0, 0, 0, 0, 0])  # 2正8负
y_pred_easy = np.array([0.95, 0.93, 0.05, 0.03, 0.02, 0.04, 0.01, 0.06, 0.02, 0.03])
y_pred_hard = np.array([0.55, 0.45, 0.40, 0.60, 0.50, 0.35, 0.70, 0.30, 0.45, 0.55])

# 易分样本：标准 CE 仍有显著贡献，但 Focal Loss 大幅压缩
ce_easy = -np.mean(y_true * np.log(y_pred_easy + 1e-15) + (1-y_true) * np.log(1-y_pred_easy + 1e-15))
fl_easy = focal_loss(y_true, y_pred_easy)

ce_hard = -np.mean(y_true * np.log(y_pred_hard + 1e-15) + (1-y_true) * np.log(1-y_pred_hard + 1e-15))
fl_hard = focal_loss(y_true, y_pred_hard)

print(f"易分样本 - CE: {ce_easy:.4f}, FL: {fl_easy:.4f}")  # FL 大幅降低
print(f"难分样本 - CE: {ce_hard:.4f}, FL: {fl_hard:.4f}")  # FL 压缩较少
print(f"易/难 比例: CE {ce_easy/ce_hard:.2f}, FL {fl_easy/fl_hard:.2f}")  # FL 比例更低 = 更聚焦难样本

import torch
import torch.nn as nn

class FocalLoss(nn.Module):
    """PyTorch 实现的 Focal Loss"""
    def __init__(self, alpha=0.25, gamma=2.0, reduction='mean'):
        super().__init__()
        self.alpha = alpha
        self.gamma = gamma
        self.reduction = reduction

    def forward(self, logits, targets):
        # BCEWithLogits 风格：输入 logit
        bce_loss = nn.functional.binary_cross_entropy_with_logits(
            logits, targets, reduction='none')
        pt = torch.exp(-bce_loss)  # p_t

        # Focal weight
        focal_weight = (1 - pt) ** self.gamma
        alpha_weight = torch.where(targets == 1,
                                   torch.tensor(self.alpha),
                                   torch.tensor(1 - self.alpha))

        loss = alpha_weight * focal_weight * bce_loss

        if self.reduction == 'mean':
            return loss.mean()
        elif self.reduction == 'sum':
            return loss.sum()
        return loss

# 使用示例
focal = FocalLoss(alpha=0.25, gamma=2.0)
logits = torch.tensor([2.0, -1.0, 0.5, -0.3, 1.5])
targets = torch.tensor([1.0, 0.0, 1.0, 0.0, 1.0])
loss = focal(logits, targets)
print(f"Focal Loss: {loss:.4f}")

import numpy as np

def contrastive_loss(d, y, margin=1.0):
    """Contrastive Loss：成对样本"""
    # y=1: 相似样本，拉近
    # y=0: 不相似样本，推开到 margin 外
    return np.mean(
        y * (d  2) + (1 - y) * (np.maximum(0, margin - d)  2)
    )

def triplet_loss(anchor, positive, negative, margin=1.0):
    """Triplet Loss：三元组样本"""
    d_pos = np.sqrt(np.sum((anchor - positive) ** 2, axis=1))
    d_neg = np.sqrt(np.sum((anchor - negative) ** 2, axis=1))

    # 损失 = max(0, d_pos - d_neg + margin)
    basic_loss = d_pos - d_neg + margin
    return np.mean(np.maximum(basic_loss, 0))

# 对比实验
anchor = np.array([[0.1, 0.2, 0.3]])
positive = np.array([[0.15, 0.25, 0.35]])  # 很近
negative_easy = np.array([[5.0, 6.0, 7.0]])  # 很远（简单负样本）
negative_hard = np.array([[0.2, 0.3, 0.4]])  # 较近（困难负样本）

loss_easy = triplet_loss(anchor, positive, negative_easy, margin=0.5)
loss_hard = triplet_loss(anchor, positive, negative_hard, margin=0.5)
print(f"简单三元组损失: {loss_easy:.4f}")   # 0.0（已满足条件）
print(f"困难三元组损失: {loss_hard:.4f}")   # > 0（需要学习）

import torch
import torch.nn as nn

# PyTorch 中的对比损失
class ContrastiveModel(nn.Module):
    """简单的编码器：用于提取特征"""
    def __init__(self, input_dim=128, embed_dim=64):
        super().__init__()
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, 256),
            nn.ReLU(),
            nn.Linear(256, embed_dim),
            nn.BatchNorm1d(embed_dim)
        )

    def forward(self, x):
        return nn.functional.normalize(self.encoder(x), dim=1)

# Triplet Margin Loss
triplet_loss = nn.TripletMarginLoss(margin=1.0, p=2)

anchor = torch.randn(32, 64)      # 32 个锚点样本
positive = torch.randn(32, 64)    # 32 个正样本
negative = torch.randn(32, 64)    # 32 个负样本

loss = triplet_loss(anchor, positive, negative)
print(f"Triplet Loss: {loss:.4f}")

# Hard Triplet Mining（关键策略）
def hard_triplet_mining(anchor, positive, negative, margin=1.0):
    """半困难三元组挖掘"""
    d_pos = torch.sum((anchor - positive) ** 2, dim=1)
    d_neg = torch.sum((anchor - negative) ** 2, dim=1)
    loss = torch.clamp(d_pos - d_neg + margin, min=0.0)
    return loss.mean()

import torch
import torch.nn as nn

# 方式一：函数式自定义损失
def quantile_loss(y_pred, y_true, tau=0.5):
    """分位数损失：预测指定分位数而非均值"""
    error = y_true - y_pred
    return torch.mean(torch.max(tau * error, (tau - 1) * error))

def asymmetric_mse(y_pred, y_true, alpha=2.0):
    """非对称 MSE：高估和低估的惩罚不同"""
    error = y_pred - y_true
    # 高估（error > 0）惩罚 α 倍，低估正常惩罚
    weight = torch.where(error > 0,
                         torch.tensor(alpha),
                         torch.tensor(1.0))
    return torch.mean(weight * error ** 2)

# 方式二：类式自定义损失（带可学习参数）
class AdaptiveLoss(nn.Module):
    """自适应损失：uncertainty-weighted loss"""
    def __init__(self, num_tasks=2):
        super().__init__()
        # 可学习的 log-variance 参数
        self.log_vars = nn.Parameter(torch.zeros(num_tasks))

    def forward(self, losses):
        """多任务自适应加权"""
        # 损失 = Σ (loss_i / (2σ_i²) + log(σ_i))
        # 其中 σ_i² = exp(log_var_i)
        weighted = 0
        for i, loss_i in enumerate(losses):
            prec = torch.exp(-self.log_vars[i])  # 1/σ²
            weighted += prec * loss_i + self.log_vars[i]
        return weighted

# 验证梯度
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
y = torch.tensor([1.5, 2.5, 3.5])
loss = quantile_loss(x, y, tau=0.7)
loss.backward()
print(f"分位数损失: {loss:.4f}")
print(f"梯度: {x.grad}")

import torch
import torch.nn as nn

# 实战：结合多种损失的复合损失函数
class CompositeLoss(nn.Module):
    """复合损失：MSE + 正则化 + 边界惩罚"""
    def __init__(self, alpha=0.1, beta=0.05, boundary=5.0):
        super().__init__()
        self.alpha = alpha   # L2 正则权重
        self.beta = beta     # 边界惩罚权重
        self.boundary = boundary  # 预测值边界

    def forward(self, pred, target, model_params=None):
        # 主损失：MSE
        mse_loss = nn.functional.mse_loss(pred, target)

        # L2 正则化
        l2_reg = torch.tensor(0.0)
        if model_params:
            l2_reg = sum(p.pow(2).sum() for p in model_params)

        # 边界惩罚：预测超出边界时惩罚
        boundary_violation = torch.relu(
            torch.abs(pred) - self.boundary
        ).mean()

        total_loss = mse_loss + self.alpha * l2_reg + self.beta * boundary_violation
        return total_loss

# 使用示例
model = nn.Linear(10, 1)
composite = CompositeLoss(alpha=0.1, beta=0.05)
x = torch.randn(32, 10)
y = torch.randn(32, 1)
pred = model(x)
loss = composite(pred, y, list(model.parameters()))
loss.backward()
print(f"Composite Loss: {loss:.4f}")

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset

class LossFunctionSelector:
    """损失函数选择与配置工具"""

    @staticmethod
    def get_loss(task, config=None):
        """根据任务类型返回合适的损失函数"""
        config = config or {}

        if task == "regression":
            if config.get("robust", False):
                return nn.HuberLoss(delta=config.get("delta", 1.0))
            return nn.MSELoss()

        elif task == "binary_classification":
            if config.get("focal", False):
                gamma = config.get("gamma", 2.0)
                alpha = config.get("alpha", 0.25)
                return FocalLoss(gamma=gamma, alpha=alpha)
            return nn.BCEWithLogitsLoss(
                pos_weight=config.get("pos_weight", None))

        elif task == "multi_classification":
            class_weights = config.get("class_weights", None)
            weight = torch.tensor(class_weights) if class_weights else None
            return nn.CrossEntropyLoss(weight=weight)

        elif task == "contrastive":
            return nn.TripletMarginLoss(
                margin=config.get("margin", 1.0), p=2)

        else:
            raise ValueError(f"Unknown task: {task}")

    @staticmethod
    def diagnose_loss_curve(train_losses, val_losses):
        """诊断训练曲线"""
        if not val_losses:
            return "无验证数据，无法诊断"

        train_change = train_losses[-1] - train_losses[0]
        val_change = val_losses[-1] - val_losses[0]
        gap = val_losses[-1] - train_losses[-1]

        if train_change > 0 and val_change > 0:
            return "欠拟合：增大模型容量或降低正则化"
        elif train_change < -0.1 and val_change > 0:
            return "过拟合：添加 Dropout 或早停"
        elif gap > train_losses[-1] * 0.5:
            return "训练-验证差距大：添加正则化"
        return "训练状态正常"

import torch
import torch.nn as nn
import torch.nn.functional as F

# 完整训练流程：损失函数切换示例
def train_with_loss_comparison(model, trainloader, valloader,
                               epochs=50, device='cuda'):
    """对比不同损失函数在同一任务上的表现"""
    losses_config = {
        "MSE": nn.MSELoss(),
        "SmoothL1": nn.SmoothL1Loss(),
        "Huber": nn.HuberLoss(delta=1.0),
    }

    results = {}
    for name, criterion in losses_config.items():
        model_copy = deepcopy(model).to(device)
        optimizer = torch.optim.Adam(model_copy.parameters(), lr=0.001)

        train_hist = []
        val_hist = []

        for epoch in range(epochs):
            # 训练
            model_copy.train()
            epoch_loss = 0
            for X, y in trainloader:
                X, y = X.to(device), y.to(device)
                optimizer.zero_grad()
                pred = model_copy(X).squeeze(-1)
                loss = criterion(pred, y)
                loss.backward()
                optimizer.step()
                epoch_loss += loss.item() * X.size(0)

            train_loss = epoch_loss / len(trainloader.dataset)
            train_hist.append(train_loss)

            # 验证
            model_copy.eval()
            val_loss = 0
            with torch.no_grad():
                for X, y in valloader:
                    pred = model_copy(X.to(device)).squeeze(-1)
                    val_loss += criterion(pred, y.to(device)).item() * X.size(0)

            val_loss /= len(valloader.dataset)
            val_hist.append(val_loss)

        results[name] = {
            "train": train_hist,
            "val": val_hist,
            "final_train": train_hist[-1],
            "final_val": val_hist[-1],
        }
        print(f"{name}: train={train_hist[-1]:.4f}, val={val_hist[-1]:.4f}")

    return results