import matplotlib.pyplot as plt
import numpy as np
# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用黑体
plt.rcParams['axes.unicode_minus'] = False   # 正常显示负号
# 假设真实的数据关系：y = 2.1 * x
x = np.array([50, 80, 120])  # 房子大小
y_true = np.array([105, 168, 252])  # 真实售价 (50*2.1, 80*2.1, 120*2.1)
# 让权重w在1.5到2.5之间变化，计算每个w对应的总损失
w_values = np.linspace(1.5, 2.5, 100) # 生成100个候选的w值
total_losses = [] # 记录每个w的总损失
for w in w_values:
    y_pred = w * x  # 模型的预测
    loss = np.mean((y_pred - y_true) ** 2)  # 计算均方误差损失
    total_losses.append(loss)
# 找到损失最小的点
min_index = np.argmin(total_losses)
min_w = w_values[min_index]
min_loss = total_losses[min_index]
# 绘制图像
plt.figure(figsize=(10, 6))
plt.plot(w_values, total_losses, linewidth=2, label='总损失函数曲线')
plt.axvline(x=2.1, color='green', linestyle='--', label='真实权重 w=2.1')
plt.plot(min_w, min_loss, 'ro', markersize=8, label=f'最小损失点 (w≈{min_w:.2f})')
plt.xlabel('模型的权重 (w)')
plt.ylabel('总损失 (Loss)')
plt.title('损失函数可视化：寻找最优秀的模型权重')
plt.legend()
plt.grid(True)
plt.show()

import matplotlib.pyplot as plt
import numpy as np
# 防止中文乱码
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
# 使用您提供的实际数据
y_pred = np.array([100, 160, 240])  # 预测值 (万元)
y_true = np.array([100, 160, 250])  # 真实值 (万元)
# 计算每个样本的误差
errors = y_pred - y_true
print("每个样本的误差:", errors)
# 计算MSE和MAE损失
mse_per_sample = errors ** 2
mae_per_sample = np.abs(errors)
mse_total = np.mean(mse_per_sample)
mae_total = np.mean(mae_per_sample)
print("\n各样本MSE损失:", mse_per_sample)
print("各样本MAE损失:", mae_per_sample)
print(f"\n总MSE损失: {mse_total:.2f}")
print(f"总MAE损失: {mae_total:.2f}")
# 可视化对比
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))
# 子图1：各样本损失对比
samples = ['50平米', '80平米', '120平米']
x_pos = np.arange(len(samples))
ax1.bar(x_pos - 0.2, mse_per_sample, 0.4, label='MSE损失', color='red', alpha=0.7)
ax1.bar(x_pos + 0.2, mae_per_sample, 0.4, label='MAE损失', color='blue', alpha=0.7)
ax1.set_xlabel('样本')
ax1.set_ylabel('损失值')
ax1.set_title('各样本损失值对比')
ax1.set_xticks(x_pos)
ax1.set_xticklabels(samples)
ax1.legend()
ax1.grid(True, alpha=0.3)
# 在柱状图上显示数值
for i, (mse_val, mae_val) in enumerate(zip(mse_per_sample, mae_per_sample)):
    ax1.text(i - 0.2, mse_val + 5, f'{mse_val:.0f}', ha='center', va='bottom')
    ax1.text(i + 0.2, mae_val + 5, f'{mae_val:.0f}', ha='center', va='bottom')
# 子图2：损失函数曲线对比（理论曲线）
theory_errors = np.linspace(-150, 150, 300)  # 扩大范围以包含实际误差
theory_mse = theory_errors ** 2
theory_mae = np.abs(theory_errors)
ax2.plot(theory_errors, theory_mse, 'r-', label='MSE损失曲线', linewidth=2)
ax2.plot(theory_errors, theory_mae, 'b-', label='MAE损失曲线', linewidth=2)
# 标记实际数据点
actual_errors = errors
actual_mse = mse_per_sample
actual_mae = mae_per_sample
colors = ['green', 'orange', 'purple']
for i, (err, mse_val, mae_val) in enumerate(zip(actual_errors, actual_mse, actual_mae)):
    ax2.plot(err, mse_val, 'o', color=colors[i], markersize=8, 
             label=f'样本{i+1} MSE (误差={err})')
    ax2.plot(err, mae_val, 's', color=colors[i], markersize=8, 
             label=f'样本{i+1} MAE (误差={err})')
ax2.set_xlabel('误差 (y_pred - y_true) 万元')
ax2.set_ylabel('损失 (Loss)')
ax2.set_title('损失函数曲线与实际数据点')
ax2.legend()
ax2.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
# 打印详细分析
print("\n" + "="*50)
print("详细分析")
print("="*50)
print("样本详情:")
for i, (size, pred, true, error) in enumerate(zip([50, 80, 120], y_pred, y_true, errors)):
    print(f"  样本{i+1} ({size}平米): 预测={pred}万, 真实={true}万, 误差={error}万")
    
print(f"\n关键观察:")
print(f"  - 样本1和2: 误差为0，MSE和MAE损失都为0")
print(f"  - 样本3: 误差为-10万")
print(f"    * MSE损失: (-10)² = 100")
print(f"    * MAE损失: |-10| = 10")
print(f"  - MSE对较大误差的惩罚更严厉 (100 vs 10)")
print(f"  - 总MSE损失: (0 + 0 + 100)/3 = {mse_total:.2f}")
print(f"  - 总MAE损失: (0 + 0 + 10)/3 = {mae_total:.2f}")

import numpy as np
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
def binary_cross_entropy_demo():
    """二分类交叉熵损失演示"""
    
    # 1. 数学公式实现
    def binary_cross_entropy(y_true, y_pred):
        """手动实现二分类交叉熵损失"""
        return - (y_true * np.log(y_pred) + (1 - y_true) * np.log(1 - y_pred))
    
    # 2. 示例数据
    y_true_positive = 1  # 正样本真实标签
    y_true_negative = 0  # 负样本真实标签
    
    # 模型预测的概率（正类概率）
    predictions = np.linspace(0.01, 0.99, 100)
    
    # 3. 计算损失
    loss_positive = binary_cross_entropy(y_true_positive, predictions)
    loss_negative = binary_cross_entropy(y_true_negative, predictions)
    
    # 4. 可视化
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
    
    # 正样本的损失曲线
    ax1.plot(predictions, loss_positive, 'b-', linewidth=2, label='正样本损失 (y=1)')
    ax1.set_xlabel('模型预测概率 p')
    ax1.set_ylabel('损失值')
    ax1.set_title('二分类交叉熵 - 正样本 (y=1)\nLoss = -log(p)')
    ax1.grid(True, alpha=0.3)
    ax1.legend()
    
    # 标记几个关键点
    key_points = [0.1, 0.5, 0.9]
    for p in key_points:
        loss = -np.log(p)
        ax1.plot(p, loss, 'ro', markersize=8)
        ax1.annotate(f'p={p}\nloss={loss:.2f}', 
                    xy=(p, loss), xytext=(10, 10), 
                    textcoords='offset points', fontsize=9)
    
    # 负样本的损失曲线
    ax2.plot(predictions, loss_negative, 'r-', linewidth=2, label='负样本损失 (y=0)')
    ax2.set_xlabel('模型预测概率 p')
    ax2.set_ylabel('损失值')
    ax2.set_title('二分类交叉熵 - 负样本 (y=0)\nLoss = -log(1-p)')
    ax2.grid(True, alpha=0.3)
    ax2.legend()
    
    # 标记几个关键点
    for p in key_points:
        loss = -np.log(1-p)
        ax2.plot(p, loss, 'bo', markersize=8)
        ax2.annotate(f'p={p}\nloss={loss:.2f}', 
                    xy=(p, loss), xytext=(10, 10), 
                    textcoords='offset points', fontsize=9)
    
    plt.tight_layout()
    plt.show()

import numpy as np
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
def categorical_cross_entropy_demo():
    """多分类交叉熵损失演示"""
    
    # 1. 数学公式实现
    def categorical_cross_entropy(y_true, y_pred):
        """手动实现多分类交叉熵损失"""
        return -np.sum(y_true * np.log(y_pred))
    
    # 2. 三分类示例
    classes = ['猫', '狗', '兔子']
    
    # 真实标签：one-hot编码，真实类别是猫
    y_true = np.array([1, 0, 0])
    
    # 3. 不同模型的预测概率
    predictions = {
        '好模型': np.array([0.9, 0.08, 0.02]),
        '一般模型': np.array([0.60, 0.25, 0.15]),
        '差模型': np.array([0.4, 0.3, 0.3]),
        '烂模型': np.array([0.05, 0.25, 0.70])
    }
    
    # 4. 计算各模型的损失
    print("多分类交叉熵损失计算示例")
    print("真实标签: 猫 [1, 0, 0]")
    print("-" * 50)
    
    results = {}
    for name, pred in predictions.items():
        loss = categorical_cross_entropy(y_true, pred)
        results[name] = loss
        print(f"{name}:")
        print(f"  预测概率: {pred}")
        print(f"  损失值: {loss:.4f}")
        print(f"  对真实类别'猫'的预测概率: {pred[0]:.2f}")
        print()
    
    # 5. 可视化不同预测的损失
    plt.figure(figsize=(12, 8))
    
    # 子图1：各模型损失对比
    plt.subplot(2, 2, 1)
    names = list(results.keys())
    losses = list(results.values())
    bars = plt.bar(names, losses, color=['green', 'orange', 'red', 'darkred'])
    plt.ylabel('交叉熵损失')
    plt.title('不同模型预测的损失对比')
    
    # 在柱状图上显示数值
    for bar, loss in zip(bars, losses):
        plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.05,
                f'{loss:.3f}', ha='center', va='bottom')
    
    # 子图2：预测概率分布
    plt.subplot(2, 2, 2)
    x = np.arange(len(classes))
    width = 0.2
    
    for i, (name, pred) in enumerate(predictions.items()):
        plt.bar(x + i*width, pred, width, label=name)
    
    plt.xlabel('类别')
    plt.ylabel('预测概率')
    plt.title('各模型的预测概率分布')
    plt.xticks(x + width*1.5, classes)
    plt.legend()
    plt.ylim(0, 1)
    
    # 子图3：真实类别预测概率与损失的关系
    plt.subplot(2, 2, 3)
    true_class_probs = [pred[0] for pred in predictions.values()]
    plt.scatter(true_class_probs, losses, s=100, c=losses, cmap='Reds_r')
    
    for i, (name, prob, loss) in enumerate(zip(names, true_class_probs, losses)):
        plt.annotate(name, (prob, loss), xytext=(5, 5), 
                    textcoords='offset points', fontsize=9)
    
    plt.xlabel("对真实类别'猫'的预测概率")
    plt.ylabel('交叉熵损失')
    plt.title('真实类别概率 vs 损失')
    plt.grid(True, alpha=0.3)
    
    # 子图4：损失函数曲线（针对真实类别）
    plt.subplot(2, 2, 4)
    p_cat = np.linspace(0.01, 0.99, 100)
    loss_curve = -np.log(p_cat)
    plt.plot(p_cat, loss_curve, 'purple', linewidth=2)
    plt.xlabel("对真实类别'猫'的预测概率")
    plt.ylabel('交叉熵损失')
    plt.title('多分类交叉熵损失曲线\nLoss = -log(p_true_class)')
    plt.grid(True, alpha=0.3)
    
    # 标记示例点
    for name, prob, loss in zip(names, true_class_probs, losses):
        plt.plot(prob, loss, 'o', markersize=8, label=name)
    
    plt.legend()
    
    plt.tight_layout()
    plt.show()

import numpy as np
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
def compare_binary_multiclass():
    """对比二分类和多分类交叉熵"""
    
    plt.figure(figsize=(14, 6))
    
    # 二分类损失曲线
    plt.subplot(1, 2, 1)
    p = np.linspace(0.01, 0.99, 100)
    loss_positive = -np.log(p)
    loss_negative = -np.log(1-p)
    
    plt.plot(p, loss_positive, 'b-', linewidth=2, label='正样本 (y=1): -log(p)')
    plt.plot(p, loss_negative, 'r-', linewidth=2, label='负样本 (y=0): -log(1-p)')
    plt.xlabel('预测概率 p')
    plt.ylabel('损失值')
    plt.title('二分类交叉熵损失\n自动选择计算路径')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    # 多分类损失曲线（针对真实类别）
    plt.subplot(1, 2, 2)
    p_true = np.linspace(0.01, 0.99, 100)
    loss_multiclass = -np.log(p_true)
    
    plt.plot(p_true, loss_multiclass, 'purple', linewidth=2)
    plt.xlabel('对真实类别的预测概率')
    plt.ylabel('损失值')
    plt.title('多分类交叉熵损失\nLoss = -log(p_true_class)')
    plt.grid(True, alpha=0.3)
    
    # 添加说明文本
    plt.figtext(0.1, 0.02, 
                "二分类特点: 根据真实标签自动选择计算 -log(p) 或 -log(1-p)\n"
                "多分类特点: 由于one-hot编码，只计算真实类别的 -log(p_true_class)", 
                fontsize=11, ha='left')
    
    plt.tight_layout(rect=[0, 0.1, 1, 0.99])
    plt.show()
# 运行对比演示
compare_binary_multiclass()