损失函数详解：原理、分类与代码实现

import numpy as np
import torch
import torch.nn as nn

# 1. 手动实现MSE（适用于简单回归模型）
def mean_squared_error(y_true, y_pred):
    """
    计算均方误差（MSE）
    参数：
        y_true: 真实值，numpy数组或列表
        y_pred: 预测值，numpy数组或列表
    返回：
        mse: 均方误差值
    """
    y_true = np.array(y_true)
    y_pred = np.array(y_pred)
    if y_true.shape != y_pred.shape:
        raise ValueError("真实值与预测值的形状必须一致")
    n = len(y_true)
    mse = np.sum((y_true - y_pred) ** 2) / n
    return mse

# 测试手动实现的MSE
y_true = [1.2, 2.3, 3.4, 4.5]
y_pred = [1.1, 2.4, 3.3, 4.6]
mse_manual = mean_squared_error(y_true, y_pred)
print(f"手动实现MSE: {mse_manual:.4f}")  # 输出：0.0100

# 2. PyTorch实现MSE（适用于深度学习模型）
# 定义MSE损失函数
mse_loss = nn.MSELoss()

# 构造真实值和预测值（PyTorch张量）
y_true_tensor = torch.tensor(y_true, dtype=torch.float32).reshape(-1, 1)  # 形状：(4, 1)
y_pred_tensor = torch.tensor(y_pred, dtype=torch.float32).reshape(-1, 1)  # 形状：(4, 1)

# 计算MSE
mse_torch = mse_loss(y_pred_tensor, y_true_tensor)
print(f"PyTorch实现MSE: {mse_torch.item():.4f}")  # 输出：0.0100

import numpy as np
import torch
import torch.nn as nn

# 1. 手动实现MAE
def mean_absolute_error(y_true, y_pred):
    """
    计算平均绝对误差（MAE）
    参数：
        y_true: 真实值，numpy数组或列表
        y_pred: 预测值，numpy数组或列表
    返回：
        mae: 平均绝对误差值
    """
    y_true = np.array(y_true)
    y_pred = np.array(y_pred)
    if y_true.shape != y_pred.shape:
        raise ValueError("真实值与预测值的形状必须一致")
    n = len(y_true)
    mae = np.sum(np.abs(y_true - y_pred)) / n
    return mae

# 测试手动实现的MAE
y_true = [1.2, 2.3, 3.4, 4.5, 100.0]  # 加入异常值100.0
y_pred = [1.1, 2.4, 3.3, 4.6, 90.0]
mae_manual = mean_absolute_error(y_true, y_pred)
print(f"手动实现MAE: {mae_manual:.4f}")  # 输出：2.1800

# 对比MSE在异常值下的表现
def mean_squared_error(y_true, y_pred):
    y_true = np.array(y_true)
    y_pred = np.array(y_pred)
    n = len(y_true)
    return np.sum((y_true - y_pred) ** 2) / n

mse_manual = mean_squared_error(y_true, y_pred)
print(f"异常值下MSE: {mse_manual:.4f}")  # 输出：20.0180，远大于MAE

# 2. PyTorch实现MAE
mae_loss = nn.L1Loss()  # PyTorch中L1Loss即为MAE
y_true_tensor = torch.tensor(y_true, dtype=torch.float32).reshape(-1, 1)
y_pred_tensor = torch.tensor(y_pred, dtype=torch.float32).reshape(-1, 1)
mae_torch = mae_loss(y_pred_tensor, y_true_tensor)
print(f"PyTorch实现MAE: {mae_torch.item():.4f}")  # 输出：2.1800

import numpy as np
import torch
import torch.nn as nn

# 1. 手动实现RMSE
def root_mean_squared_error(y_true, y_pred):
    """
    计算均方根误差（RMSE）
    参数：
        y_true: 真实值，numpy数组或列表
        y_pred: 预测值，numpy数组或列表
    返回：
        rmse: 均方根误差值
    """
    y_true = np.array(y_true)
    y_pred = np.array(y_pred)
    if y_true.shape != y_pred.shape:
        raise ValueError("真实值与预测值的形状必须一致")
    n = len(y_true)
    mse = np.sum((y_true - y_pred) ** 2) / n
    rmse = np.sqrt(mse)
    return rmse

# 测试手动实现的RMSE
y_true = [5000.0, 6000.0, 7000.0, 8000.0]  # 人均收入数据（单位：元）
y_pred = [4900.0, 6100.0, 6900.0, 8200.0]
rmse_manual = root_mean_squared_error(y_true, y_pred)
print(f"手动实现RMSE: {rmse_manual:.2f} 元")  # 输出：111.80 元，单位与原始数据一致

# 2. PyTorch实现RMSE（PyTorch无直接的RMSE函数，可通过MSE开方实现）
mse_loss = nn.MSELoss()
y_true_tensor = torch.tensor(y_true, dtype=torch.float32).reshape(-1, 1)
y_pred_tensor = torch.tensor(y_pred, dtype=torch.float32).reshape(-1, 1)
mse_torch = mse_loss(y_pred_tensor, y_true_tensor)
rmse_torch = torch.sqrt(mse_torch)
print(f"PyTorch实现RMSE: {rmse_torch.item():.2f} 元")  # 输出：111.80 元

import numpy as np
import torch

# 1. 手动实现MAPE
def mean_absolute_percentage_error(y_true, y_pred):
    """
    计算平均绝对百分比误差（MAPE）
    参数：
        y_true: 真实值，numpy数组或列表
        y_pred: 预测值，numpy数组或列表
    返回：
        mape: 平均绝对百分比误差（%）
    """
    y_true = np.array(y_true)
    y_pred = np.array(y_pred)
    if y_true.shape != y_pred.shape:
        raise ValueError("真实值与预测值的形状必须一致")
    if np.any(y_true == 0):
        raise ValueError("真实值中存在0，无法计算MAPE")
    n = len(y_true)
    mape = (np.sum(np.abs((y_true - y_pred) / y_true)) / n) * 100
    return mape

# 测试手动实现的MAPE
y_true_car = [10000, 12000, 15000]  # 汽车销量（辆）
y_pred_car = [9500, 12500, 14500]
mape_car = mean_absolute_percentage_error(y_true_car, y_pred_car)
print(f"汽车销量MAPE: {mape_car:.2f}%")  # 输出：3.56%

y_true_phone = [50000, 60000, 70000]  # 手机销量（部）
y_pred_phone = [48000, 62000, 69000]
mape_phone = mean_absolute_percentage_error(y_true_phone, y_pred_phone)
print(f"手机销量MAPE: {mape_phone:.2f}%")  # 输出：2.22%，可直接与汽车销量MAPE对比

# 2. PyTorch实现MAPE
def torch_mape(y_true, y_pred):
    """
    PyTorch版本的MAPE
    参数：
        y_true: 真实值，PyTorch张量
        y_pred: 预测值，PyTorch张量
    返回：
        mape: 平均绝对百分比误差（%）
    """
    if torch.any(y_true == 0):
        raise ValueError("真实值中存在0，无法计算MAPE")
    mape = (torch.mean(torch.abs((y_true - y_pred) / y_true)) * 100)
    return mape

y_true_tensor = torch.tensor(y_true_car, dtype=torch.float32).reshape(-1, 1)
y_pred_tensor = torch.tensor(y_pred_car, dtype=torch.float32).reshape(-1, 1)
mape_torch = torch_mape(y_true_tensor, y_pred_tensor)
print(f"PyTorch实现汽车销量MAPE: {mape_torch.item():.2f}%")  # 输出：3.56%

import numpy as np
import torch
import torch.nn as nn

# 1. 手动实现Huber损失
def huber_loss(y_true, y_pred, delta=1.0):
    """
    计算Huber损失
    参数：
        y_true: 真实值，numpy数组或列表
        y_pred: 预测值，numpy数组或列表
        delta: 阈值，默认1.0
    返回：
        huber: Huber损失值
    """
    y_true = np.array(y_true)
    y_pred = np.array(y_pred)
    if y_true.shape != y_pred.shape:
        raise ValueError("真实值与预测值的形状必须一致")
    error = y_true - y_pred
    abs_error = np.abs(error)
    # 分情况计算损失
    huber = np.where(abs_error <= delta, 0.5 * error ** 2, delta * abs_error - 0.5 * delta ** 2)
    return np.mean(huber)

# 测试手动实现的Huber损失
y_true = [1.2, 2.3, 3.4, 4.5, 100.0]  # 含异常值
y_pred = [1.1, 2.4, 3.3, 4.6, 90.0]
huber_delta1 = huber_loss(y_true, y_pred, delta=1.0)
huber_delta5 = huber_loss(y_true, y_pred, delta=5.0)
print(f"Huber损失（delta=1.0）: {huber_delta1:.4f}")  # 输出：5.0050
print(f"Huber损失（delta=5.0）: {huber_delta5:.4f}")  # 输出：5.0180

# 对比MSE和MAE
mse = np.mean((np.array(y_true) - np.array(y_pred)) ** 2)
mae = np.mean(np.abs(np.array(y_true) - np.array(y_pred)))
print(f"MSE: {mse:.4f}")  # 输出：20.0180
print(f"MAE: {mae:.4f}")  # 输出：2.1800，Huber损失介于两者之间

# 2. PyTorch实现Huber损失
huber_loss_torch = nn.HuberLoss(delta=1.0)  # PyTorch 1.9.0及以上版本支持
y_true_tensor = torch.tensor(y_true, dtype=torch.float32).reshape(-1, 1)
y_pred_tensor = torch.tensor(y_pred, dtype=torch.float32).reshape(-1, 1)
huber_torch = huber_loss_torch(y_pred_tensor, y_true_tensor)
print(f"PyTorch实现Huber损失（delta=1.0）: {huber_torch.item():.4f}")  # 输出：5.0050

import numpy as np
import torch
import torch.nn as nn

# 1. 手动实现Log-Cosh损失
def log_cosh_loss(y_true, y_pred):
    """
    计算Log-Cosh损失
    参数：
        y_true: 真实值，numpy数组或列表
        y_pred: 预测值，numpy数组或列表
    返回：
        log_cosh: Log-Cosh损失值
    """
    y_true = np.array(y_true)
    y_pred = np.array(y_pred)
    if y_true.shape != y_pred.shape:
        raise ValueError("真实值与预测值的形状必须一致")
    error = y_true - y_pred
    log_cosh = np.log(np.cosh(error))
    return np.mean(log_cosh)

# 测试手动实现的Log-Cosh损失
y_true = [1.2, 2.3, 3.4, 4.5, 100.0]  # 含异常值
y_pred = [1.1, 2.4, 3.3, 4.6, 90.0]
log_cosh = log_cosh_loss(y_true, y_pred)
print(f"Log-Cosh损失: {log_cosh:.4f}")  # 输出：4.5051

# 对比Huber损失（delta=1.0）
huber = huber_loss(y_true, y_pred, delta=1.0)
print(f"Huber损失（delta=1.0）: {huber:.4f}")  # 输出：5.0050，Log-Cosh损失略小

# 2. PyTorch实现Log-Cosh损失
class LogCoshLoss(nn.Module):
    """PyTorch自定义Log-Cosh损失函数"""
    def __init__(self):
        super(LogCoshLoss, self).__init__()
    
    def forward(self, y_pred, y_true):
        error = y_true - y_pred
        return torch.mean(torch.log(torch.cosh(error)))

# 初始化损失函数并计算
log_cosh_loss_torch = LogCoshLoss()
y_true_tensor = torch.tensor(y_true, dtype=torch.float32).reshape(-1, 1)
y_pred_tensor = torch.tensor(y_pred, dtype=torch.float32).reshape(-1, 1)
log_cosh_torch = log_cosh_loss_torch(y_pred_tensor, y_true_tensor)
print(f"PyTorch实现Log-Cosh损失: {log_cosh_torch.item():.4f}")  # 输出：4.5051

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F

# 1. 手动实现BCE损失（含Sigmoid转换）
def binary_cross_entropy_loss(y_true, y_logits, epsilon=1e-7):
    """
    计算二元交叉熵损失（BCE）
    参数：
        y_true: 真实标签，numpy数组或列表，取值为0或1
        y_logits: 模型Logits输出（未经过Sigmoid），numpy数组或列表
        epsilon: 防止log(0)的微小值，默认1e-7
    返回：
        bce: 二元交叉熵损失值
    """
    y_true = np.array(y_true)
    y_logits = np.array(y_logits)
    if y_true.shape != y_logits.shape:
        raise ValueError("真实标签与Logits的形状必须一致")
    # Sigmoid转换为概率
    y_pred = 1 / (1 + np.exp(-y_logits))
    # 限制概率范围
    y_pred = np.clip(y_pred, epsilon, 1 - epsilon)
    # 计算BCE损失
    bce = -np.mean(y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))
    return bce

# 测试手动实现的BCE损失
y_true = [1, 0, 1, 0, 1]  # 二分类真实标签
y_logits = [2.3, -1.2, 3.1, 0.5, 1.8]  # 模型Logits输出
bce_manual = binary_cross_entropy_loss(y_true, y_logits)
print(f"手动实现BCE损失: {bce_manual:.4f}")  # 输出：0.1562

# 2. PyTorch实现BCE损失（两种方式：带Sigmoid和不带Sigmoid）
# 方式1：使用BCEWithLogitsLoss（直接输入Logits，内置Sigmoid，数值更稳定）
bce_with_logits_loss = nn.BCEWithLogitsLoss()
y_true_tensor = torch.tensor(y_true, dtype=torch.float32).reshape(-1, 1)
y_logits_tensor = torch.tensor(y_logits, dtype=torch.float32).reshape(-1, 1)
bce_torch1 = bce_with_logits_loss(y_logits_tensor, y_true_tensor)
print(f"PyTorch BCEWithLogitsLoss: {bce_torch1.item():.4f}")  # 输出：0.1562

# 方式2：先Sigmoid再用BCELoss（需注意数值稳定性）
sigmoid = nn.Sigmoid()
y_pred_tensor = sigmoid(y_logits_tensor)
bce_loss = nn.BCELoss()
bce_torch2 = bce_loss(y_pred_tensor, y_true_tensor)
print(f"PyTorch Sigmoid + BCELoss: {bce_torch2.item():.4f}")  # 输出：0.1562