大模型应用：大模型权重敏感性分析：L1/L2 范数、梯度贡献深入解读.39

import numpy as np

def compute_l1_norm(matrix):
    """
    计算矩阵的 L1 范数
    
    参数：
    matrix: numpy.ndarray, 输入矩阵
    
    返回：
    float: 矩阵的 L1 范数值
    """
    return np.sum(np.abs(matrix))

# 示例
W = np.array([[1, -2, 3],
              [-4, 5, -6],
              [7, -8, 9]])

l1_norm = compute_l1_norm(W)
print(f"权重矩阵 W 的 L1 范数为: {l1_norm}")

import numpy as np

def compute_l2_norm(matrix):
    """
    计算矩阵的 L2 范数（Frobenius 范数）
    
    参数：
    matrix: numpy.ndarray, 输入矩阵
    
    返回：
    float: 矩阵的 L2 范数值
    """
    return np.linalg.norm(matrix, ord='fro')  # 或 np.sqrt(np.sum(matrix**2))

def compute_l2_norm_squared(matrix):
    """
    计算矩阵 L2 范数的平方
    """
    return np.sum(matrix**2)

# 示例
W = np.array([[1, -2, 3],
              [-4, 5, -6],
              [7, -8, 9]])

l2_norm = compute_l2_norm(W)
l2_norm_sq = compute_l2_norm_squared(W)

print(f"权重矩阵 W 的 L2 范数为: {l2_norm:.4f}")
print(f"权重矩阵 W 的 L2 范数平方为: {l2_norm_sq}")

import numpy as np
import torch

def compute_gradient_norms_example():
    """
    梯度范数计算示例：L1范数与L2范数
    """
    print("=" * 70)
    print("梯度范数计算示例：L1范数 vs L2范数")
    print("=" * 70)
    
    # ===================== 示例1：简单人工梯度向量 =====================
    print("\n1. 简单人工梯度向量示例")
    print("-" * 40)
    
    # 创建一个简单的梯度向量
    gradient_vec = np.array([1.2, -0.5, 3.1, -2.0, 0.0, 0.3])
    n_weights = len(gradient_vec)
    
    print(f"梯度向量 ∇w: {gradient_vec}")
    print(f"梯度维度: {n_weights}")
    
    # 计算 L1 范数
    l1_norm = np.sum(np.abs(gradient_vec))
    print(f"\nL1 范数计算:")
    print(f"  ||∇w||₁ = |1.2| + |-0.5| + |3.1| + |-2.0| + |0.0| + |0.3|")
    print(f"           = {abs(1.2)} + {abs(-0.5)} + {abs(3.1)} + {abs(-2.0)} + {abs(0.0)} + {abs(0.3)}")
    print(f"           = {l1_norm:.4f}")
    
    # 计算 L2 范数
    l2_norm = np.linalg.norm(gradient_vec)
    l2_norm_squared = np.sum(gradient_vec ** 2)
    print(f"\nL2 范数计算:")
    print(f"  ||∇w||₂² = (1.2)² + (-0.5)² + (3.1)² + (-2.0)² + (0.0)² + (0.3)²")
    print(f"           = {1.2**2:.4f} + {(-0.5)**2:.4f} + {3.1**2:.4f} + {(-2.0)**2:.4f} + {0.0**2:.4f} + {0.3**2:.4f}")
    print(f"           = {l2_norm_squared:.4f}")
    print(f"  ||∇w||₂ = √{l2_norm_squared:.4f} = {l2_norm:.4f}")
    
    # ===================== 示例2：实际神经网络梯度 =====================
    print("\n\n2. 实际神经网络梯度示例")
    print("-" * 40)
    
    # 模拟一个简单的神经网络层
    # 假设我们有一个全连接层，输入维度5，输出维度3
    input_dim = 5
    output_dim = 3
    batch_size = 4
    
    # 随机生成权重矩阵和梯度矩阵
    np.random.seed(42)
    weight_matrix = np.random.randn(output_dim, input_dim) * 0.1
    gradient_matrix = np.random.randn(output_dim, input_dim) * 0.5
    
    print(f"权重矩阵 W 形状: {weight_matrix.shape} ({output_dim}×{input_dim})")
    print(f"梯度矩阵 ∇W 形状: {gradient_matrix.shape} ({output_dim}×{input_dim})")
    
    # 计算整个梯度矩阵的 L1 和 L2 范数
    gradient_l1 = np.sum(np.abs(gradient_matrix))
    gradient_l2 = np.linalg.norm(gradient_matrix)
    
    print(f"\n梯度矩阵的范数:")
    print(f"  L1范数 (||∇W||₁): {gradient_l1:.6f}")
    print(f"  L2范数 (||∇W||₂): {gradient_l2:.6f}")
    print(f"  L2范数平方 (||∇W||₂²): {gradient_l2**2:.6f}")
    
    # ===================== 示例3：比较不同分布的梯度 =====================
    print("\n\n3. 不同梯度分布对比")
    print("-" * 40)
    
    # 情况1：均匀小梯度
    small_gradients = np.random.randn(10) * 0.1
    
    # 情况2：包含几个大梯度的混合分布
    mixed_gradients = np.random.randn(10) * 0.1
    mixed_gradients[0] = 2.5  # 一个大梯度
    mixed_gradients[5] = -1.8  # 另一个大梯度
    
    # 情况3：梯度爆炸情况
    exploding_gradients = np.random.randn(10) * 5.0
    
    gradients_list = [
        ("均匀小梯度", small_gradients),
        ("混合梯度（含大值）", mixed_gradients),
        ("梯度爆炸", exploding_gradients)
    ]
    
    print(f"{'梯度类型':<20} {'L1范数':<15} {'L2范数':<15} {'L2/L1比值':<15}")
    print("-" * 65)
    
    for name, grad in gradients_list:
        l1 = np.sum(np.abs(grad))
        l2 = np.linalg.norm(grad)
        ratio = l2 / l1 if l1 > 0 else 0
        print(f"{name:<20} {l1:<15.4f} {l2:<15.4f} {ratio:<15.4f}")
    
    return gradient_vec, l1_norm, l2_norm

# 运行示例
if __name__ == "__main__":
    compute_gradient_norms_example()

import numpy as np

def gradient_norms_explanation():
    """
    梯度范数的详细解释和逻辑说明
    """
    print("\n" + "=" * 70)
    print("梯度范数的逻辑与数学意义")
    print("=" * 70)
    
    # 创建一个示例梯度向量
    gradient = np.array([1.0, -2.0, 0.5, 3.0, -0.1])
    
    print(f"\n示例梯度向量: {gradient}")
    
    # 计算各种统计量
    abs_grad = np.abs(gradient)
    squared_grad = gradient ** 2
    
    print(f"\n梯度绝对值: {abs_grad}")
    print(f"梯度平方值: {squared_grad}")
    
    # L1范数计算
    l1_norm = np.sum(abs_grad)
    print(f"\n1. 梯度的L1范数（梯度贡献L1）:")
    print(f"   ||∇w||₁ = Σ|∂L/∂wᵢ| = {l1_norm:.4f}")
    print(f"   逻辑解释: 所有梯度绝对值的总和，反映梯度的'总活跃度'")
    print(f"   特点: 对异常值较不敏感，衡量梯度的总体规模")
    
    # L2范数计算
    l2_norm = np.linalg.norm(gradient)
    print(f"\n2. 梯度的L2范数（梯度贡献L2）:")
    print(f"   ||∇w||₂ = √(Σ(∂L/∂wᵢ)²) = {l2_norm:.4f}")
    print(f"   逻辑解释: 梯度平方和的平方根，反映梯度的'能量强度'")
    print(f"   特点: 对大梯度值更加敏感（平方放大了大值的影响）")
    
    # 范数比较
    print(f"\n3. L1范数与L2范数比较:")
    print(f"   L1范数: {l1_norm:.4f}")
    print(f"   L2范数: {l2_norm:.4f}")
    print(f"   比值 L2/L1: {l2_norm/l1_norm:.4f}")
    
    # 可视化说明
    print(f"\n4. 范数差异的直观理解:")
    print(f"   假设有两个梯度向量:")
    print(f"     ∇w₁ = [1, 1, 1, 1]  → L1=4.0, L2=2.0")
    print(f"     ∇w₂ = [2, 0, 0, 0]  → L1=2.0, L2=2.0")
    print(f"   注意: L2范数相同，但L1范数不同!")
    print(f"   这说明L2范数更关注'峰值'，L1范数更关注'总量'")
    
    return l1_norm, l2_norm

# 运行解释示例
if __name__ == "__main__":
    gradient_norms_explanation()

import numpy as np
import matplotlib.pyplot as plt

# 设置中文字体（避免乱码）
plt.rcParams["font.family"] = ["SimHei"]
plt.rcParams["axes.unicode_minus"] = False  # 解决负号显示问题

class GradientMonitor:
    """
    梯度监控器：实时监控梯度范数，诊断训练问题
    """
    
    def __init__(self, model_name="Untitled Model"):
        self.model_name = model_name
        self.l1_history = []
        self.l2_history = []
        self.max_gradient_history = []
        
    def log_gradients(self, gradients):
        """
        记录梯度并计算范数
        
        参数：
        gradients: dict，包含各层梯度 {layer_name: gradient_tensor}
        """
        total_l1 = 0
        total_l2_squared = 0
        max_grad = 0
        
        print(f"\n[梯度监控] {self.model_name}")
        print("-" * 50)
        
        for layer_name, grad in gradients.items():
            if grad is not None:
                # 转换为numpy数组（如果是PyTorch或TensorFlow张量）
                if hasattr(grad, 'numpy'):
                    grad_np = grad.numpy()
                elif hasattr(grad, 'detach'):
                    grad_np = grad.detach().numpy()
                else:
                    grad_np = np.array(grad)
                
                layer_l1 = np.sum(np.abs(grad_np))
                layer_l2 = np.linalg.norm(grad_np)
                layer_max = np.max(np.abs(grad_np))
                
                total_l1 += layer_l1
                total_l2_squared += layer_l2 ** 2
                max_grad = max(max_grad, layer_max)
                
                print(f"{layer_name:<20} L1:{layer_l1:10.4f} L2:{layer_l2:10.4f} Max:{layer_max:8.4f}")
        
        total_l2 = np.sqrt(total_l2_squared)
        
        # 记录历史
        self.l1_history.append(total_l1)
        self.l2_history.append(total_l2)
        self.max_gradient_history.append(max_grad)
        
        print(f"{'总计':<20} L1:{total_l1:10.4f} L2:{total_l2:10.4f} Max:{max_grad:8.4f}")
        
        # 诊断建议
        self._diagnose(total_l1, total_l2, max_grad)
        
        return total_l1, total_l2
    
    def _diagnose(self, l1_norm, l2_norm, max_grad):
        """根据梯度范数提供诊断建议"""
        print("\n[诊断建议]")
        
        # 梯度爆炸检测
        if max_grad > 10.0:
            print("  ⚠️  检测到梯度爆炸！最大梯度值: {:.4f}".format(max_grad))
            print("     建议: 使用梯度裁剪(gradient clipping)，降低学习率")
        
        # 梯度消失检测
        elif max_grad < 1e-6:
            print("  ⚠️  检测到梯度消失！最大梯度值: {:.8f}".format(max_grad))
            print("     建议: 检查激活函数，尝试使用ReLU，调整初始化方法")
        
        # L1/L2范数比值分析
        if l1_norm > 0:
            ratio = l2_norm / l1_norm
            print(f"  L2/L1比值: {ratio:.4f}")
            
            if ratio > 0.8:
                print("  梯度分布: 相对集中（少数大梯度主导）")
            elif ratio < 0.3:
                print("  梯度分布: 相对分散（许多小梯度贡献）")
            else:
                print("  梯度分布: 中等分散")
        
        # 历史趋势分析
        if len(self.l1_history) > 10:
            recent_l1 = np.mean(self.l1_history[-10:])
            early_l1 = np.mean(self.l1_history[:10])
            
            if recent_l1 < early_l1 * 0.1:
                print("  📉 梯度规模持续下降，可能接近收敛")
            elif recent_l1 > early_l1 * 10:
                print("  📈 梯度规模持续上升，需警惕不稳定")
    
    def plot_history(self):
        """绘制梯度范数历史"""
        try:
            
            fig, axes = plt.subplots(2, 1, figsize=(10, 8))
            
            # L1范数历史
            axes[0].plot(self.l1_history, 'b-', linewidth=2)
            axes[0].set_title(f'{self.model_name} - 梯度L1范数历史')
            axes[0].set_xlabel('迭代步')
            axes[0].set_ylabel('L1范数')
            axes[0].grid(True, alpha=0.3)
            
            # L2范数历史
            axes[1].plot(self.l2_history, 'r-', linewidth=2)
            axes[1].set_title(f'{self.model_name} - 梯度L2范数历史')
            axes[1].set_xlabel('迭代步')
            axes[1].set_ylabel('L2范数')
            axes[1].grid(True, alpha=0.3)
            
            plt.tight_layout()
            plt.show()
            
        except ImportError:
            print("需要matplotlib库来绘制图表")

# 使用示例
if __name__ == "__main__":
    # 模拟一些梯度数据
    monitor = GradientMonitor("示例模型")
    
    # 模拟5个训练步骤
    for step in range(5):
        gradients = {
            "conv1.weight": np.random.randn(16, 3, 3, 3) * (0.5 if step < 3 else 0.1),
            "conv1.bias": np.random.randn(16) * (0.3 if step < 3 else 0.05),
            "fc.weight": np.random.randn(10, 64) * (0.8 if step < 3 else 0.2),
            "fc.bias": np.random.randn(10) * (0.2 if step < 3 else 0.05),
        }
        
        print(f"\n步骤 {step + 1}:")
        monitor.log_gradients(gradients)
    
    # 绘制历史图表
    monitor.plot_history()

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt

# 设备设置
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
plt.rcParams['font.sans-serif'] = ['SimHei']  # 解决中文显示
plt.rcParams['axes.unicode_minus'] = False    # 解决负号显示

# 1. 构造模拟权重（模拟模型某一层的权重向量/矩阵）
# 模拟权重向量（长度100，符合正态分布）
weight_vector = torch.randn(100).to(device)
# 模拟权重矩阵（10×20，模拟全连接层权重）
weight_matrix = torch.randn(10, 20).to(device)

# 2. 定义范数计算函数（文本公式对应实现）
def calculate_l1_norm(weights):
    """计算L1范数：所有元素绝对值求和"""
    return torch.sum(torch.abs(weights)).item()

def calculate_l2_norm(weights):
    """计算L2范数：所有元素平方和开平方根"""
    return torch.sqrt(torch.sum(torch.square(weights))).item()

# 3. 计算范数值
# 向量范数
vec_l1 = calculate_l1_norm(weight_vector)
vec_l2 = calculate_l2_norm(weight_vector)
# 矩阵范数
mat_l1 = calculate_l1_norm(weight_matrix)
mat_l2 = calculate_l2_norm(weight_matrix)

# 4. 可视化：对比向量/矩阵的L1/L2范数
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))

# 子图1：范数值对比柱状图
categories = ['向量L1', '向量L2', '矩阵L1', '矩阵L2']
values = [vec_l1, vec_l2, mat_l1, mat_l2]
ax1.bar(categories, values, color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728'])
ax1.set_title('权重向量/矩阵的L1/L2范数值', fontsize=12)
ax1.set_ylabel('范数值', fontsize=10)
# 标注数值
for i, v in enumerate(values):
    ax1.text(i, v + 0.5, f'{v:.2f}', ha='center', fontsize=9)

# 子图2：权重向量分布+范数标注
ax2.plot(weight_vector.cpu().numpy(), color='#1f77b4', label='权重向量元素')
ax2.axhline(y=0, color='black', linestyle='--', alpha=0.5)
ax2.set_title('权重向量分布（L1={:.2f}, L2={:.2f}）'.format(vec_l1, vec_l2), fontsize=12)
ax2.set_xlabel('元素索引', fontsize=10)
ax2.set_ylabel('权重值', fontsize=10)
ax2.legend()

plt.tight_layout()
plt.savefig('l1_l2_norm_visual.png', dpi=300, bbox_inches='tight')  # 保存图片
plt.show()

# 打印结果
print("===== L1/L2范数计算结果 =====")
print(f"权重向量L1范数（绝对值求和）：{vec_l1:.2f}")
print(f"权重向量L2范数（平方和开根号）：{vec_l2:.2f}")
print(f"权重矩阵L1范数（绝对值求和）：{mat_l1:.2f}")
print(f"权重矩阵L2范数（平方和开根号）：{mat_l2:.2f}")

# 1. 构造简易模型（模拟大模型单层）
class SimpleLayer(nn.Module):
    def __init__(self):
        super().__init__()
        # 定义可训练权重（模拟核心权重）
        self.linear = nn.Linear(10, 1).to(device)  # 输入10维，输出1维

    def forward(self, x):
        return self.linear(x)

# 2. 初始化模型、损失函数、输入数据
model = SimpleLayer()
criterion = nn.MSELoss()  # 均方误差损失（模拟分类/回归任务损失）
# 模拟输入数据（批次大小8，输入维度10）
input_data = torch.randn(8, 10).to(device)
# 模拟真实标签
target = torch.randn(8, 1).to(device)

# 3. 计算梯度（反向传播）
model.train()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
optimizer.zero_grad()  # 清空梯度

# 前向传播
output = model(input_data)
# 计算损失
loss = criterion(output, target)
# 反向传播：计算权重梯度
loss.backward()

# 4. 提取权重和梯度，计算梯度贡献
# 提取线性层权重（shape: [1, 10]）
weights = model.linear.weight.detach().cpu().numpy()[0]
# 提取权重梯度（shape: [1, 10]）
grads = model.linear.weight.grad.detach().cpu().numpy()[0]

# 计算梯度贡献（文本公式实现）
grad_l1 = sum(abs(g) for g in grads)  # 梯度L1贡献：绝对值求和
grad_l2 = np.sqrt(sum(g**2 for g in grads))  # 梯度L2贡献：平方和开根号

# 5. 可视化：权重vs梯度贡献
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))

# 子图1：权重值与梯度值对比
x = np.arange(len(weights))
width = 0.35
ax1.bar(x - width/2, weights, width, label='权重值', color='#1f77b4')
ax1.bar(x + width/2, grads, width, label='梯度值', color='#ff7f0e')
ax1.set_title('权重值与梯度值对比', fontsize=12)
ax1.set_xlabel('权重索引', fontsize=10)
ax1.set_ylabel('数值', fontsize=10)
ax1.legend()
ax1.grid(axis='y', alpha=0.3)

# 子图2：梯度贡献分布（L1/L2）
ax2.bar(['梯度L1贡献', '梯度L2贡献'], [grad_l1, grad_l2], color=['#2ca02c', '#d62728'])
ax2.set_title('梯度贡献值（L1={:.4f}, L2={:.4f}）'.format(grad_l1, grad_l2), fontsize=12)
ax2.set_ylabel('贡献值', fontsize=10)
# 标注数值
for i, v in enumerate([grad_l1, grad_l2]):
    ax2.text(i, v + 0.001, f'{v:.4f}', ha='center', fontsize=9)

plt.tight_layout()
plt.savefig('gradient_contribution_visual.png', dpi=300, bbox_inches='tight')  # 保存图片
plt.show()

# 打印结果
print("\n===== 梯度贡献计算结果 =====")
print(f"梯度L1贡献（梯度绝对值求和）：{grad_l1:.4f}")
print(f"梯度L2贡献（梯度平方和开根号）：{grad_l2:.4f}")
print(f"注：梯度贡献越大，说明该权重对损失的影响越强")