构建AI智能体：从SVD的理论到LoRA的实践：大模型低秩微调的内在逻辑

A = [ 3, 0 ]
    [ 0, 2 ]

U = [ 1, 0 ]
    [ 0, 1 ]
    
Σ = [ 3, 0 ]   # 奇异值是3和2
    [ 0, 2 ]

Vᵀ = [ 1, 0 ]
     [ 0, 1 ]

[ 3, 0 ]   [ 1, 0 ]   [ 3×1+0×0, 3×0+0×1 ]   [ 3, 0 ]
[ 0, 2 ] × [ 0, 1 ] = [ 0×1+2×0, 0×0+2×1 ] = [ 0, 2 ]

[ 1, 0 ]   [ 3, 0 ]   [ 1×3+0×0, 1×0+0×2 ]   [ 3, 0 ]
[ 0, 1 ] × [ 0, 2 ] = [ 0×3+1×0, 0×0+1×2 ] = [ 0, 2 ]

import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
import os

# 设置中文字体，防止乱码
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用黑体显示中文
plt.rcParams['axes.unicode_minus'] = False    # 正常显示负号

print("=== SVD图像压缩演示 ===\n")

# 1. 读取图像并转换为灰度图
print("1. 读取图像...")
image_path = "svd_demo_image.jpg" # 请准备一张图片，或者我们将创建一个示例图

# 如果没有图片，我们创建一个简单的测试图案
try:
    img = Image.open(image_path).convert('L') # 转换为灰度图
    print(f"   已从 '{image_path}' 加载图像。")
except:
    print("   未找到图片，创建一个示例图案...")
    # 创建一个200x200的测试图像：一个简单的渐变和形状
    x, y = np.ogrid[0:200, 0:200]
    img_array = (x/200 * 255).astype(np.uint8) # 垂直渐变
    # 在中间加一个亮块
    img_array[50:150, 50:150] = 255
    # 在右上角加一个暗块
    img_array[20:80, 120:180] = 50
    img = Image.fromarray(img_array)
    print("   示例图案创建完成。")

# 将图像转换为numpy数组
img_array = np.array(img)
m, n = img_array.shape
print(f"   图像尺寸: {m} x {n} = {m*n} 像素")
print(f"   原始数据需要存储 {m * n} 个数值\n")

# 2. 对图像矩阵进行奇异值分解
print("2. 进行奇异值分解(SVD)...")
U, S, Vt = np.linalg.svd(img_array.astype(float), full_matrices=False)
print(f"   分解完成！共得到 {len(S)} 个奇异值")
print(f"   前5个奇异值: {S[:5]}") # 显示最大的5个奇异值
print(f"   最后5个奇异值: {S[-5:]}") # 显示最小的5个奇异值
print("   可以看到奇异值从大到小排列，且衰减很快！\n")

# 3. 使用不同数量的奇异值重建图像
print("3. 使用不同数量的奇异值重建图像...")

# 选择几个不同的k值（保留的奇异值数量）
k_values = [1, 5, 20, 50, 100, min(m, n)]  # 最后一个使用全部奇异值

# 计算每个k值对应的压缩率
storage_original = m * n
compression_ratios = []

print("   压缩效果对比:")
print("   K值  | 存储量 | 压缩率 | 数据保留比例")
print("   ----|--------|--------|------------")

for k in k_values:
    storage_compressed = k * (m + n + 1)
    compression_ratio = storage_compressed / storage_original
    data_retained = np.sum(S[:k]) / np.sum(S)  # 保留的能量比例
    
    compression_ratios.append(compression_ratio)
    print(f"   {k:4d} | {storage_compressed:6d} | {compression_ratio:5.3f} | {data_retained:7.3%}")

print()

# 4. 可视化结果
print("4. 生成对比图...")

# 创建子图
fig, axes = plt.subplots(2, 3, figsize=(15, 8.5))
axes = axes.ravel()

# 绘制原图和不同压缩级别的结果
for i, k in enumerate(k_values):
    # 使用前k个奇异值重建图像
    reconstructed = U[:, :k] @ np.diag(S[:k]) @ Vt[:k, :]
    
    # 确保像素值在0-255之间
    reconstructed = np.clip(reconstructed, 0, 255).astype(np.uint8)
    
    # 显示图像
    axes[i].imshow(reconstructed, cmap='gray')
    
    if k == min(m, n):
        title = f'原图 (K={k})'
        compression_text = "无损"
    else:
        compression_ratio = compression_ratios[i]
        data_retained = np.sum(S[:k]) / np.sum(S)
        title = f'K={k}\n压缩率: {compression_ratio:.1%}\n能量保留: {data_retained:.1%}'
        compression_text = f"{compression_ratio:.1%}"
    
    axes[i].set_title(title, fontsize=12)
    axes[i].axis('off')
    
    print(f"   K={k:3d}: 压缩率 {compression_text}, 能量保留 {data_retained:.2%}")

fig.tight_layout()

# 5. 额外分析：奇异值分布
print("\n5. 分析奇异值分布...")

plt.figure(figsize=(12, 4))

# 子图1：奇异值大小分布
plt.subplot(1, 3, 1)
plt.plot(S, 'b-', linewidth=1)
plt.title('奇异值分布')
plt.xlabel('奇异值索引')
plt.ylabel('奇异值大小')
plt.grid(True, alpha=0.3)

# 子图2：前50个奇异值（更清晰）
plt.subplot(1, 3, 2)
plt.plot(S[:50], 'r-', linewidth=2, marker='o', markersize=3)
plt.title('前50个奇异值')
plt.xlabel('奇异值索引')
plt.ylabel('奇异值大小')
plt.grid(True, alpha=0.3)

# 子图3：累积能量比例
plt.subplot(1, 3, 3)
cumulative_energy = np.cumsum(S) / np.sum(S)
plt.plot(cumulative_energy, 'g-', linewidth=2)
plt.title('累积能量比例')
plt.xlabel('奇异值数量 (K)')
plt.ylabel('能量保留比例')
plt.grid(True, alpha=0.3)

# 标记几个关键点
key_points = [1, 5, 10, 20, 50]
for point in key_points:
    if point < len(S):
        plt.plot(point, cumulative_energy[point], 'ro')
        plt.annotate(f'{cumulative_energy[point]:.1%}', 
                    (point, cumulative_energy[point]),
                    textcoords="offset points", 
                    xytext=(0,10), 
                    ha='center')

plt.tight_layout()
# 显示所有图表
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec

# 设置中文字体和样式
plt.rcParams['font.sans-serif'] = ['SimHei', 'Arial']
plt.rcParams['axes.unicode_minus'] = False

print("=== LoRA与SVD关系深度演示 ===\n")

# 1. 模拟大模型权重矩阵的更新变化
np.random.seed(42)
original_dim = 1000  # 原始权重矩阵维度
rank = 10           # 内在的低秩维度

print("1. 模拟大模型权重更新变化...")
print(f"   原始权重矩阵 W 尺寸: {original_dim} x {original_dim} = 1,000,000 参数")

# 创建一个低秩的权重更新矩阵 ΔW (这就是LoRA要近似的)
A_low_rank = np.random.randn(original_dim, rank)  # 低秩矩阵A
B_low_rank = np.random.randn(rank, original_dim)  # 低秩矩阵B  
true_delta_W = A_low_rank @ B_low_rank  # 真实的低秩权重更新

print(f"   真实权重更新 ΔW 的内在秩: {rank}")
print(f"   但传统方法需要更新所有 {original_dim * original_dim:,} 个参数\n")

# 2. 对真实的权重更新进行SVD分析
print("2. 对权重更新矩阵 ΔW 进行SVD分析...")
U, S, Vt = np.linalg.svd(true_delta_W, full_matrices=False)

# 显示前15个奇异值
print("   前15个奇异值:")
for i in range(min(15, len(S))):
    print(f"      σ{i+1}: {S[i]:.4f}")

print(f"   奇异值总和: {np.sum(S):.2f}")

# 计算累积能量比例
cumulative_energy = np.cumsum(S) / np.sum(S)
print(f"\n   能量累积比例:")
for k in [1, 3, 5, 10, 20, 50]:
    if k <= len(S):
        print(f"     前{k}个奇异值保留: {cumulative_energy[k-1]:.2%} 能量")

# 3. 不同秩近似的效果比较
print("\n3. 比较不同秩近似的效果...")
ranks_to_test = [1, 3, 5, 10, 20, 50]
approximation_errors = []

for r in ranks_to_test:
    # 使用前r个奇异值进行低秩近似
    U_r = U[:, :r]
    S_r = S[:r] 
    Vt_r = Vt[:r, :]
    approx_delta_W = U_r @ np.diag(S_r) @ Vt_r
    
    # 计算近似误差
    error = np.linalg.norm(true_delta_W - approx_delta_W) / np.linalg.norm(true_delta_W)
    approximation_errors.append(error)
    
    print(f"   秩 r={r:2d}: 近似误差 {error:.4f}, 参数数量 {r * (2 * original_dim):,}")

# 4. 可视化展示
print("\n4. 生成可视化图表...")

# 创建综合图表
fig = plt.figure(figsize=(20, 12))
gs = GridSpec(3, 3, figure=fig)

# 图1: 奇异值分布和能量累积
ax1 = fig.add_subplot(gs[0, :])
ax1.plot(S[:50], 'bo-', linewidth=2, markersize=4, label='奇异值大小')
ax1.set_ylabel('奇异值 σ', fontsize=12)
ax1.set_xlabel('奇异值索引', fontsize=12)
ax1.set_title('(a) 权重更新矩阵的奇异值分布', fontsize=14, fontweight='bold')
ax1.grid(True, alpha=0.3)
ax1.set_yscale('log')

# 添加能量累积曲线
ax1_twin = ax1.twinx()
ax1_twin.plot(cumulative_energy[:50], 'r-', linewidth=3, label='累积能量比例')
ax1_twin.set_ylabel('累积能量比例', fontsize=12, color='red')
ax1_twin.tick_params(axis='y', labelcolor='red')
ax1_twin.set_ylim(0, 1.1)

# 合并图例
lines1, labels1 = ax1.get_legend_handles_labels()
lines2, labels2 = ax1_twin.get_legend_handles_labels()
ax1.legend(lines1 + lines2, labels1 + labels2, loc='upper right')

# 图2: 不同秩近似的误差比较
ax2 = fig.add_subplot(gs[1, 0])
bars = ax2.bar(range(len(ranks_to_test)), approximation_errors, color='lightcoral')
ax2.set_xlabel('近似秩 r')
ax2.set_ylabel('相对近似误差')
ax2.set_title('(b) 不同秩近似的误差', fontweight='bold')
ax2.set_xticks(range(len(ranks_to_test)))
ax2.set_xticklabels(ranks_to_test)
ax2.grid(True, alpha=0.3)

# 在柱状图上添加数值标签
for bar, error in zip(bars, approximation_errors):
    height = bar.get_height()
    ax2.text(bar.get_x() + bar.get_width()/2., height + 0.01,
             f'{error:.3f}', ha='center', va='bottom')

# 图3: 参数数量对比
ax3 = fig.add_subplot(gs[1, 1])
full_params = original_dim * original_dim
lora_params = [r * (2 * original_dim) for r in ranks_to_test]

x = np.arange(len(ranks_to_test))
width = 0.35

ax3.bar(x - width/2, [full_params] * len(ranks_to_test), width, 
        label=f'全参数微调', alpha=0.7)
ax3.bar(x + width/2, lora_params, width, label='LoRA参数', color='orange')

ax3.set_xlabel('近似秩 r')
ax3.set_ylabel('参数数量')
ax3.set_title('(c) 参数数量对比', fontweight='bold')
ax3.set_xticks(x)
ax3.set_xticklabels(ranks_to_test)
ax3.set_yscale('log')
ax3.legend()
ax3.grid(True, alpha=0.3)

# 图4: 压缩比展示
ax4 = fig.add_subplot(gs[1, 2])
compression_ratios = [lora_param / full_params for lora_param in lora_params]

ax4.plot(ranks_to_test, compression_ratios, 's-', linewidth=3, markersize=8, color='green')
ax4.set_xlabel('近似秩 r')
ax4.set_ylabel('压缩比 (LoRA/全参数)')
ax4.set_title('(d) 参数压缩比例', fontweight='bold')
ax4.set_yscale('log')
ax4.grid(True, alpha=0.3)

# 添加压缩比数值标注
for i, (r, ratio) in enumerate(zip(ranks_to_test, compression_ratios)):
    ax4.annotate(f'{ratio:.1%}', (r, ratio), textcoords="offset points", 
                 xytext=(0,10), ha='center', fontweight='bold')

# 图5: LoRA原理示意图
ax5 = fig.add_subplot(gs[2, :])
# 模拟原始权重更新矩阵的热力图
subset_size = 100  # 显示子集以便可视化
subset_delta_W = true_delta_W[:subset_size, :subset_size]

# 显示原始矩阵
im = ax5.imshow(subset_delta_W, cmap='RdBu_r', aspect='auto')
plt.colorbar(im, ax=ax5, label='权重更新值')

# 添加秩近似说明
ax5.text(0.02, 0.98, '原始权重更新 ΔW (高秩)', transform=ax5.transAxes, 
         fontsize=12, fontweight='bold', verticalalignment='top',
         bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))

# 添加LoRA分解说明
ax5.text(0.02, 0.15, 'LoRA分解: ΔW ≈ A × B\n'
                     f'A: {original_dim}×r\n'
                     f'B: r×{original_dim}\n'
                     f'参数: r×({original_dim}+{original_dim})', 
         transform=ax5.transAxes, fontsize=11, verticalalignment='top',
         bbox=dict(boxstyle='round', facecolor='lightyellow', alpha=0.9))

ax5.set_xlabel('输出维度')
ax5.set_ylabel('输入维度')
ax5.set_title('(e) LoRA原理: 用低秩矩阵近似权重更新', fontweight='bold')

plt.tight_layout()


best_rank = 10  # 基于我们的示例
best_compression = compression_ratios[ranks_to_test.index(best_rank)]
best_error = approximation_errors[ranks_to_test.index(best_rank)]
best_energy = cumulative_energy[best_rank-1]

plt.show()