import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib.gridspec import GridSpec
sns.set_style("whitegrid")
# 设置中文字体和样式
plt.rcParams['font.sans-serif'] = ['SimHei', 'DejaVu Sans']
plt.rcParams['axes.unicode_minus'] = False
def comprehensive_svd_analysis():
    """
    完整的SVD分析：分开生成多张对比图片
    """
    print("=== SVD模型压缩完整分析 ===")
    print("分开生成多维度可视化对比...")
    
    # 1. 生成模拟数据
    np.random.seed(123)
    m, n = 500, 300  # 用户-物品嵌入矩阵
    rank_true = 30   # 真实内在秩
    
    # 生成低秩核心矩阵 + 噪声
    U_core = np.random.randn(m, rank_true)
    V_core = np.random.randn(rank_true, n)
    core_matrix = U_core @ V_core
    noise = 0.1 * np.random.randn(m, n)
    original_matrix = core_matrix + noise
    
    # 2. SVD分解
    U, s, Vt = np.linalg.svd(original_matrix, full_matrices=False)
    total_energy = np.sum(s ** 2)
    cumulative_energy = np.cumsum(s ** 2) / total_energy
    
    # 3. 关键参数计算
    max_compression_rank = (m * n) // (m + n)
    original_params = m * n
    
    # 4. 测试多个k值
    test_ks = [10, 20, 32, 45, 60, 78, 100, 112, 140, 187]
    k_results = []
    
    for k in test_ks:
        if k > len(s): continue
            
        compressed_params = m * k + k * n
        compression_ratio = 1 - compressed_params / original_params
        energy_preserved = cumulative_energy[k-1]
        speedup_ratio = original_params / compressed_params
        
        # 重构验证
        approx_matrix = U[:, :k] @ np.diag(s[:k]) @ Vt[:k, :]
        approximation_error = np.linalg.norm(original_matrix - approx_matrix) / np.linalg.norm(original_matrix)
        quality = 1 - approximation_error
         # 质量评估
        if approximation_error > 0.5:
            quality_level = "很差"
            scenario = "极度压缩，精度要求极低"
        elif approximation_error > 0.3:
            quality_level = "一般" 
            scenario = "高压缩，适度精度损失"
        elif approximation_error > 0.2:
            quality_level = "良好"
            scenario = "平衡压缩，通用场景"
        elif approximation_error > 0.1:
            quality_level = "优秀"
            scenario = "适度压缩，高质量要求"
        else:
            quality_level = "极好"
            scenario = "近无损，关键任务"
        k_results.append({
            'k': k,
            'compressed_params': compressed_params,
            'compression_ratio': compression_ratio,
            'energy_preserved': energy_preserved,
            'speedup_ratio': speedup_ratio,
            'approximation_error': approximation_error,
            'quality_level': quality_level
        })
    # 输出数值总结
    print_summary_table(k_results, original_params, max_compression_rank)
    
    # 5. 分开创建可视化图表
    # create_singular_value_plot(m, n, s, cumulative_energy, max_compression_rank)
    # create_tradeoff_plot(k_results)
    # create_radar_plot(k_results)
    # create_parameter_efficiency_plot(k_results, original_params)
    # create_marginal_gain_plot(s, cumulative_energy)
    # create_decision_dashboard(k_results, m, n, original_params, max_compression_rank)
    # plot_speedup_vs_error_tradeoff(k_results) # 绘制权衡图
    return k_results
def print_summary_table(k_results, original_params, max_k):
    """
    输出详细的数值总结表格
    """
    print("\n" + "="*80)
    print("📊 SVD压缩分析数值总结")
    print("="*80)
    print(f"{'k值':<6} {'参数数量':<12} {'压缩率':<10} {'能量保留':<10} {'计算加速':<10} {'近似误差':<10} {'推荐度'}")
    print("-"*80)
    
    for result in k_results:
        k = result['k']
        # 计算推荐度星级
        if result['compression_ratio'] > 0.6 and result['energy_preserved'] > 0.85:
            stars = "★★★★★"
        elif result['compression_ratio'] > 0.4 and result['energy_preserved'] > 0.8:
            stars = "★★★★"
        elif result['compression_ratio'] > 0.2 and result['energy_preserved'] > 0.75:
            stars = "★★★"
        else:
            stars = "★★"
            
        # 标记临界点
        if k == max_k:
            status = "临界点"
        elif k > max_k:
            status = "膨胀"
        else:
            status = ""
            
        print(f"{k:<6} {result['compressed_params']:<12,} {result['compression_ratio']:+.2%}   "
              f"{result['energy_preserved']:>8.2%}   {result['speedup_ratio']:>7.2f}x   "
              f"{result['approximation_error']:>8.2%}   {stars} {status}")

def create_singular_value_plot(m, n, s, cumulative_energy, max_k):
    """图1: 奇异值分布与信息密度分析"""
    plt.figure(figsize=(10, 6))
    
    x_range = range(1, len(s) + 1)
    
    # 主坐标轴：奇异值分布
    ax1 = plt.gca()
    line1 = ax1.semilogy(x_range, s, 'b-', linewidth=2, alpha=0.8, label='奇异值大小')
    ax1.set_xlabel('奇异值索引 (按重要性降序排列)')
    ax1.set_ylabel('奇异值大小 (对数尺度)', color='blue')
    ax1.tick_params(axis='y', labelcolor='blue')
    
    # 次坐标轴：累积能量
    ax1_twin = ax1.twinx()
    line2 = ax1_twin.plot(x_range, cumulative_energy, 'r-', linewidth=2, alpha=0.8, label='累积能量比例')
    ax1_twin.set_ylabel('累积能量比例', color='red')
    ax1_twin.tick_params(axis='y', labelcolor='red')
    ax1_twin.set_ylim(0, 1)
    
    # 标记关键区域
    regions = [
        (1, 30, '高信息密度区', 'lightgreen', 0.3),
        (31, 80, '中信息密度区', 'lightyellow', 0.3),
        (81, 200, '低信息密度区', 'lightcoral', 0.2),
        (201, len(s), '噪声区域', 'lightgray', 0.1)
    ]
    
    for start, end, label, color, alpha in regions:
        if start <= len(s):
            ax1.axvspan(start, end, alpha=alpha, color=color, label=label)
    
    # 标记关键k值
    key_ks = [10, 32, 60, 100, max_k]
    colors = ['green', 'blue', 'red', 'orange', 'purple']
    labels = ['k=10\n40%能量', 'k=32\n70%能量', 'k=60\n87%能量', 'k=100\n93%能量', f'k={max_k}\n临界点']
    
    for k_val, color, label in zip(key_ks, colors, labels):
        if k_val < len(s):
            ax1.axvline(x=k_val, color=color, linestyle='--', linewidth=2, alpha=0.8)
            ax1.text(k_val, s[k_val-1], f' {label}', rotation=90, verticalalignment='bottom', 
                    fontsize=8, color=color, fontweight='bold')
    
    plt.title('图1: 奇异值分布与信息密度分析\n(信息快速衰减，前60个奇异值包含87%能量)', 
              fontsize=12, fontweight='bold', pad=20)
    
    # 合并图例
    lines1, labels1 = ax1.get_legend_handles_labels()
    lines2, labels2 = ax1_twin.get_legend_handles_labels()
    ax1.legend(lines1 + lines2, labels1 + labels2, loc='upper right', fontsize=8)
    
    ax1.grid(True, alpha=0.3)
    plt.tight_layout()
    plt.savefig('svd_singular_value_analysis.png', dpi=300, bbox_inches='tight')
    plt.show()

def create_tradeoff_plot(k_results):
    """图2: 压缩率 vs 质量权衡分析"""
    plt.figure(figsize=(10, 6))
    
    compression_ratios = [r['compression_ratio'] for r in k_results]
    energy_preserved = [r['energy_preserved'] for r in k_results]
    k_values = [r['k'] for r in k_results]
    
    # 创建散点图，颜色表示k值大小
    scatter = plt.scatter(compression_ratios, energy_preserved, 
                         c=k_values, cmap='viridis', s=100, alpha=0.8, 
                         edgecolors='black', linewidth=0.5)
    
    # 标记关键决策点
    key_points = {
        10: ('k=10', 'darkgreen', 200),
        32: ('k=32', 'blue', 200),
        60: ('k=60\n(推荐)', 'red', 300),
        100: ('k=100', 'orange', 200),
        187: ('k=187\n(临界)', 'purple', 200)
    }
    
    for i, k_val in enumerate(k_values):
        if k_val in key_points:
            label, color, size = key_points[k_val]
            plt.scatter(compression_ratios[i], energy_preserved[i],
                       c=color, s=size, marker='*', edgecolors='black', 
                       linewidth=2, label=label)
            
            # 添加详细标注
            plt.annotate(f'压缩:{compression_ratios[i]:.1%}\n能量:{energy_preserved[i]:.1%}', 
                        (compression_ratios[i], energy_preserved[i]),
                        xytext=(10, 10), textcoords='offset points',
                        bbox=dict(boxstyle='round,pad=0.3', facecolor='yellow', alpha=0.7),
                        fontsize=8)
    
    # 分区标识
    plt.axvline(x=0, color='black', linestyle='-', linewidth=2, alpha=0.7)
    plt.text(0.05, 0.15, '✅ 压缩区域\n(参数减少)', transform=plt.gca().transAxes, 
             bbox=dict(boxstyle="round,pad=0.3", facecolor="lightgreen", alpha=0.8),
             ha='center', fontsize=10, fontweight='bold')
    plt.text(0.65, 0.15, '❌ 膨胀区域\n(参数增加)', transform=plt.gca().transAxes,
             bbox=dict(boxstyle="round,pad=0.3", facecolor="lightcoral", alpha=0.8),
             ha='center', fontsize=10, fontweight='bold')
    
    plt.colorbar(scatter, label='秩 (k)')
    plt.xlabel('压缩率\n(正值=压缩, 负值=膨胀)')
    plt.ylabel('能量保留率\n(质量指标)')
    plt.title('图2: 压缩率 vs 质量权衡分析\n(Pareto前沿与关键决策点)', 
              fontsize=12, fontweight='bold')
    plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
    plt.grid(True, alpha=0.3)
    plt.tight_layout()
    plt.savefig('svd_tradeoff_analysis.png', dpi=300, bbox_inches='tight')
    plt.show()

def create_radar_plot(k_results):
    """图3: 多维度性能雷达图"""
    plt.figure(figsize=(8, 8))
    ax = plt.subplot(111, polar=True)
    
    # 选择几个关键k值进行雷达图对比
    radar_ks = [10, 32, 60, 100]
    radar_labels = ['压缩率', '能量保留', '计算加速', '近似质量']
    
    for k_val in radar_ks:
        # 找到对应的结果
        result = next((r for r in k_results if r['k'] == k_val), None)
        if result:
            # 归一化指标
            metrics = [
                max(result['compression_ratio'], 0),  # 压缩率（只取正值）
                result['energy_preserved'],           # 能量保留
                min(np.log(result['speedup_ratio']), 2) / 2,  # 计算加速（对数缩放）
                1 - result['approximation_error']     # 近似质量
            ]
            
            # 闭合雷达图
            metrics += metrics[:1]
            angles = np.linspace(0, 2*np.pi, len(radar_labels), endpoint=False).tolist()
            angles += angles[:1]
            
            color = {'10': 'green', '32': 'blue', '60': 'red', '100': 'orange'}[str(k_val)]
            ax.plot(angles, metrics, 'o-', linewidth=2, label=f'k={k_val}', color=color)
            ax.fill(angles, metrics, alpha=0.1, color=color)
    
    ax.set_xticks(angles[:-1])
    ax.set_xticklabels(radar_labels)
    ax.set_ylim(0, 1)
    ax.set_title('图3: 多维度性能雷达图\n(k=60在各维度表现均衡)', 
                 fontsize=12, fontweight='bold', pad=20)
    ax.legend(loc='upper right', bbox_to_anchor=(1.3, 1.0))
    plt.tight_layout()
    plt.savefig('svd_radar_analysis.png', dpi=300, bbox_inches='tight')
    plt.show()

def create_parameter_efficiency_plot(k_results, original_params):
    """图4: 参数数量与计算效率对比"""
    plt.figure(figsize=(10, 6))
    
    k_values = [r['k'] for r in k_results]
    param_counts = [r['compressed_params'] for r in k_results]
    speedup_ratios = [r['speedup_ratio'] for r in k_results]
    
    x = range(len(k_values))
    width = 0.35
    
    # 双Y轴柱状图
    ax = plt.gca()
    bars1 = ax.bar([i - width/2 for i in x], param_counts, width,
                   label='参数数量', color='skyblue', alpha=0.8, edgecolor='black')
    ax.set_ylabel('参数数量', color='skyblue', fontweight='bold')
    ax.tick_params(axis='y', labelcolor='skyblue')
    
    ax_twin = ax.twinx()
    bars2 = ax_twin.bar([i + width/2 for i in x], speedup_ratios, width,
                        label='计算加速比', color='lightcoral', alpha=0.8, edgecolor='black')
    ax_twin.set_ylabel('计算加速比', color='lightcoral', fontweight='bold')
    ax_twin.tick_params(axis='y', labelcolor='lightcoral')
    
    # 设置x轴标签
    ax.set_xticks(x)
    ax.set_xticklabels([f'k={k}' for k in k_values], rotation=45)
    
    # 突出显示推荐点k=60
    k60_idx = k_values.index(60)
    bars1[k60_idx].set_color('red')
    bars2[k60_idx].set_color('red')
    bars1[k60_idx].set_alpha(1.0)
    bars2[k60_idx].set_alpha(1.0)
    
    # 添加参考线
    ax.axhline(y=original_params, color='gray', linestyle=':', alpha=0.7, 
               label=f'原始参数({original_params:,})')
    ax_twin.axhline(y=1, color='darkred', linestyle=':', alpha=0.7, 
                    label='无加速基准')
    
    plt.title('图4: 参数数量与计算效率对比\n(k=60: 68%压缩 + 3.12倍加速)', 
              fontsize=12, fontweight='bold')
    ax.legend(loc='upper left')
    ax_twin.legend(loc='upper right')
    ax.grid(True, alpha=0.3, axis='y')
    plt.tight_layout()
    plt.savefig('svd_parameter_efficiency.png', dpi=300, bbox_inches='tight')
    plt.show()

def create_marginal_gain_plot(s, cumulative_energy):
    """图5: 边际收益分析"""
    plt.figure(figsize=(10, 6))
    
    # 计算边际能量增益
    marginal_gains = []
    for i in range(1, len(s)):
        gain = cumulative_energy[i] - cumulative_energy[i-1]
        marginal_gains.append(gain)
    
    # 绘制边际增益曲线
    plt.semilogy(range(1, len(marginal_gains) + 1), marginal_gains, 
                'g-', alpha=0.7, linewidth=1, label='边际能量增益')
    
    # 标记关键点
    key_points_margin = [10, 32, 60, 100, 187]
    for k_val in key_points_margin:
        if k_val < len(marginal_gains):
            gain = marginal_gains[k_val-1]
            plt.axvline(x=k_val, color='red' if k_val == 60 else 'gray', 
                       linestyle='--', alpha=0.7)
            plt.scatter(k_val, gain, color='red' if k_val == 60 else 'blue', 
                       s=50, zorder=5)
            plt.text(k_val, gain*1.5, f' k={k_val}\n{gain:.3%}', 
                    fontsize=8, ha='center')
    
    # 添加收益阈值线
    threshold = 0.002  # 0.2%的边际增益阈值
    plt.axhline(y=threshold, color='orange', linestyle=':', 
                label=f'收益阈值 ({threshold:.1%})', alpha=0.7)
    
    plt.xlabel('秩 (k)')
    plt.ylabel('边际能量增益 (对数尺度)')
    plt.title('图5: 边际收益分析\n(k=60后增益显著下降)', 
              fontsize=12, fontweight='bold')
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.tight_layout()
    plt.savefig('svd_marginal_gain_analysis.png', dpi=300, bbox_inches='tight')
    plt.show()

def plot_speedup_vs_error_tradeoff(k_results):
    """绘制计算加速与近似误差的权衡图"""
    
    # 使用之前的结果数据
    k_values = [r['k'] for r in k_results]
    speedups = [r['speedup_ratio'] for r in k_results]
    errors = [r['approximation_error'] for r in k_results]
    quality_levels = [r['quality_level'] for r in k_results]
    
    plt.figure(figsize=(12, 8))
    
    # 创建颜色映射
    colors = {
        '很差': 'red',
        '一般': 'orange', 
        '良好': 'green',
        '优秀': 'blue',
        '极好': 'purple'
    }
    
    # 绘制散点图
    for i, k in enumerate(k_values):
        color = colors[quality_levels[i]]
        plt.scatter(speedups[i], errors[i], c=color, s=150, alpha=0.7, 
                   label=f'k={k}' if k in [10, 60, 187] else "")
        
        # 添加标注
        plt.annotate(f'k={k}\n加速:{speedups[i]:.1f}x\n误差:{errors[i]:.1%}', 
                    (speedups[i], errors[i]),
                    xytext=(10, 10), textcoords='offset points',
                    bbox=dict(boxstyle='round,pad=0.3', facecolor='lightyellow', alpha=0.7),
                    fontsize=9)
    
    plt.xlabel('计算加速比 (倍数)', fontsize=12, fontweight='bold')
    plt.ylabel('近似误差', fontsize=12, fontweight='bold')
    plt.title('计算加速 vs 近似误差 权衡分析\n(追求加速会牺牲精度，需要找到平衡点)', 
              fontsize=14, fontweight='bold', pad=20)
    
    # 添加参考线
    plt.axhline(y=0.3, color='red', linestyle='--', alpha=0.5, label='质量阈值 (30%误差)')
    plt.axvline(x=2.0, color='blue', linestyle='--', alpha=0.5, label='加速阈值 (2倍)')
    
    # 标记推荐区域
    plt.axvspan(2, 4, ymin=0.2, ymax=0.4, alpha=0.2, color='green', 
                label='推荐区域 (2-4倍加速, 20-40%误差)')
    
    plt.grid(True, alpha=0.3)
    plt.legend()
    plt.tight_layout()
    plt.show()

import numpy as np
import matplotlib.pyplot as plt
# 设置随机种子保证可重复性
np.random.seed(123)
# 生成具有低秩特性的用户-物品交互矩阵
# 真实秩约为30，但我们用64维嵌入
rank_true = 30
m, n = 500, 300
# 生成核心低秩矩阵 + 噪声
U_core = np.random.randn(m, rank_true)
V_core = np.random.randn(rank_true, n)
core_matrix = U_core @ V_core
# 添加噪声模拟真实数据
noise = 0.1 * np.random.randn(m, n)
original_matrix = core_matrix + noise
print(f"原始矩阵: {m} × {n} = {m*n:,} 参数")
print(f"矩阵Frobenius范数: {np.linalg.norm(original_matrix):.2f}")
# 执行SVD分解
U, s, Vt = np.linalg.svd(original_matrix, full_matrices=False)
print("SVD分解完成!")
print(f"奇异值数量: {len(s)}")
print(f"前10个奇异值: {s[:10]}")
print(f"奇异值总和: {np.sum(s):.2f}")
# 计算能量分布（奇异值的平方代表能量）
total_energy = np.sum(s ** 2)
cumulative_energy = np.cumsum(s ** 2) / total_energy
energy_contributions = (s ** 2) / total_energy
print(f"总能量: {total_energy:.2f}")
print(f"\n前10个奇异值的能量贡献:")
for i in range(10):
    print(f"  奇异值{i+1}: {s[i]:.2f} → 贡献: {energy_contributions[i]:.3%}")
# 计算理论最大压缩秩
max_compression_rank = (m * n) // (m + n)
print(f"\n理论最大压缩秩计算:")
print(f"  原始参数: {m} × {n} = {m * n:,}")
print(f"  压缩参数: {m} × k + k × {n} = {m + n} × k")
print(f"  压缩条件: {m + n} × k < {m * n}")
print(f"  解得: k < {m * n} / {m + n} = {max_compression_rank}")
# 验证临界点
k_critical = max_compression_rank
params_original = m * n
params_compressed = m * k_critical + k_critical * n
compression_ratio = 1 - params_compressed / params_original
print(f"\n临界点验证 (k={k_critical}):")
print(f"  原始参数: {params_original:,}")
print(f"  压缩参数: {params_compressed:,}") 
print(f"  压缩率: {compression_ratio:+.4%}")
# 分析临界点附近的压缩效果
critical_range = [185, 186, 187, 188, 189, 190]
print("\n临界点附近的压缩效果:")
print("k值 | 压缩参数 | 压缩率 | 状态")
print("-" * 40)
for k_test in critical_range:
    params_comp = m * k_test + k_test * n
    comp_ratio = 1 - params_comp / params_original
    status = "压缩" if comp_ratio > 0 else "膨胀"
    print(f"{k_test:3d} | {params_comp:8,} | {comp_ratio:+.4%} | {status}")
# 定义不同的能量保留目标
energy_targets = [0.7, 0.8, 0.9, 0.95]
print("\n基于能量保留的k值选择:")
print("目标能量 | 所需k值 | 压缩率 | 能量实际值")
print("-" * 50)
k_candidates = {}
for target in energy_targets:
    # 找到第一个达到目标能量的k值
    k_needed = np.argmax(cumulative_energy >= target) + 1
    params_comp = m * k_needed + k_needed * n
    comp_ratio = 1 - params_comp / params_original
    actual_energy = cumulative_energy[k_needed-1]
    
    k_candidates[target] = k_needed
    
    print(f"  {target:.0%}   |    {k_needed:3d}   | {comp_ratio:+.2%} |   {actual_energy:.3%}")
k_70 = k_candidates[0.7]
U_k = U[:, :k_70]
s_k = s[:k_70] 
Vt_k = Vt[:k_70, :]
approx_70 = U_k @ np.diag(s_k) @ Vt_k
error_70 = np.linalg.norm(original_matrix - approx_70) / np.linalg.norm(original_matrix)
params_70 = m * k_70 + k_70 * n
print(f"\nk=32 详细分析 (70%能量目标):")
print(f"  • 参数: {m}×{k_70} + {k_70}×{n} = {params_70:,}")
print(f"  • 压缩率: {1-params_70/params_original:+.2%}")
print(f"  • 能量保留: {cumulative_energy[k_70-1]:.3%}")
print(f"  • 近似误差: {error_70:.3%}")
print(f"  • 计算加速: {params_original/params_70:.2f}×")
k_80 = k_candidates[0.8]
params_80 = m * k_80 + k_80 * n
approx_80 = U[:, :k_80] @ np.diag(s[:k_80]) @ Vt[:k_80, :]
error_80 = np.linalg.norm(original_matrix - approx_80) / np.linalg.norm(original_matrix)
print(f"\nk=45 详细分析 (80%能量目标):")
print(f"  • 参数: {params_80:,}")
print(f"  • 压缩率: {1-params_80/params_original:+.2%}")
print(f"  • 能量保留: {cumulative_energy[k_80-1]:.3%}")
print(f"  • 近似误差: {error_80:.3%}")
print(f"  • 计算加速: {params_original/params_80:.2f}×")
def compute_composite_score(k, m, n, cumulative_energy, original_params, 
                           quality_weight=0.6, efficiency_weight=0.4):
    """
    计算k值的综合评分
    """
    # 基础指标
    compressed_params = m * k + k * n
    compression_ratio = 1 - compressed_params / original_params
    energy_preserved = cumulative_energy[k-1]
    speedup_ratio = original_params / compressed_params
    
    # 质量得分（基于能量保留）
    quality_score = energy_preserved
    
    # 效率得分（综合考虑压缩率和加速比）
    compression_score = max(compression_ratio, 0)  # 只考虑正压缩
    speedup_score = min(np.log(speedup_ratio + 1), 2) / 2  # 对数缩放
    
    efficiency_score = 0.7 * compression_score + 0.3 * speedup_score
    
    # 综合得分
    composite_score = (quality_weight * quality_score + 
                      efficiency_weight * efficiency_score)
    
    return {
        'k': k,
        'compression_ratio': compression_ratio,
        'energy_preserved': energy_preserved,
        'speedup_ratio': speedup_ratio,
        'quality_score': quality_score,
        'efficiency_score': efficiency_score,
        'composite_score': composite_score
    }
# 测试多个k值
test_ks = [10, 20, 32, 45, 60, 78, 100, 112, 140, 187]
results = []
print("综合评分分析:")
print("k值 | 压缩率 | 能量保留 | 加速比 | 质量分 | 效率分 | 综合分")
print("-" * 75)
for k in test_ks:
    if k > len(s): continue
        
    result = compute_composite_score(k, m, n, cumulative_energy, params_original)
    results.append(result)
    
    print(f"{k:3d} | {result['compression_ratio']:+.2%} | {result['energy_preserved']:7.3%} | "
          f"{result['speedup_ratio']:5.2f}x | {result['quality_score']:6.3f} | "
          f"{result['efficiency_score']:6.3f} | {result['composite_score']:6.3f}")
    
# 找到综合评分最高的k值
best_result = max(results, key=lambda x: x['composite_score'])
best_k = best_result['k']
print(f"\n 最优k值分析:")
print(f"最优选择: k = {best_k}")
print(f"综合评分: {best_result['composite_score']:.3f}")
print(f"压缩率: {best_result['compression_ratio']:+.2%}")
print(f"能量保留: {best_result['energy_preserved']:.3%}")
print(f"计算加速: {best_result['speedup_ratio']:.2f}×")
print(f"参数变化: {params_original:,} → {m*best_k + best_k*n:,}")
# 验证这是否是合理的工程选择
if best_result['compression_ratio'] > 0.5 and best_result['energy_preserved'] > 0.8:
    print(" 工程可行性: 优秀 - 高压缩且质量良好")
elif best_result['compression_ratio'] > 0.3 and best_result['energy_preserved'] > 0.85:
    print(" 工程可行性: 良好 - 平衡的压缩与质量")
else:
    print("  工程可行性: 需要重新评估权衡")
# 创建最终压缩版本
k_final = 32
U_final = U[:, :k_final]
s_final = s[:k_final]
Vt_final = Vt[:k_final, :]
# 构建压缩矩阵
B = U_final @ np.diag(s_final)  # 500 × 60
C = Vt_final                    # 60 × 300
# 重构近似矩阵
approx_final = B @ C
print("最终选择: k = 32")
print("=" * 50)
print("压缩配置:")
print(f"  • 原始: W ({m}×{n}) = {m*n:,} 参数")
print(f"  • 压缩: B ({m}×{k_final}) + C ({k_final}×{n}) = {m*k_final + k_final*n:,} 参数")
print(f"  • 参数减少: {m*n - (m*k_final + k_final*n):,}")
print("\n性能指标:")
print(f"  • 压缩率: {1 - (m*k_final + k_final*n)/(m*n):+.2%}")
print(f"  • 存储节省: {(m*n*4 - (m*k_final + k_final*n)*4)/1024:.1f} KB")
print(f"  • 能量保留: {cumulative_energy[k_final-1]:.3%}")
print(f"  • 近似误差: {np.linalg.norm(original_matrix - approx_final)/np.linalg.norm(original_matrix):.3%}")
print(f"  • 计算加速: {(m*n)/(m*k_final + k_final*n):.2f}×")