DAY25 奇异值SVD分解

知识点回顾：

1. 线性代数概念回顾
2. 奇异值推导
3. 奇异值的应用

• 特征降维：对高维数据减小计算量、可视化
• 数据重构：比如重构信号、重构图像（可以实现有损压缩，k 越小压缩率越高，但图像质量损失越大）
• 降噪：通常噪声对应较小的奇异值。通过丢弃这些小奇异值并重构矩阵，可以达到一定程度的降噪效果。
• 推荐系统：在协同过滤算法中，用户-物品评分矩阵通常是稀疏且高维的。SVD（或其变种如 FunkSVD, SVD++）可以用来分解这个矩阵，发现潜在因子（latent factors），从而预测未评分的项。这里其实属于特征降维的部分。

我们今天用最通俗的方式拆解 SVD（奇异值分解），全程不搞复杂公式，结合例子和 Python 实操，你跟着走就行～

第一步：先搞懂「矩阵」是什么（基础铺垫）

你可以把矩阵想象成一张「表格」：

• 行：代表不同的对象（比如学生 A、学生 B）
• 列：代表对象的属性（比如数学成绩、语文成绩）
• 单元格：属性的具体数值

比如下面这个 2 行 2 列的矩阵 A，代表 2 个学生的 2 科成绩：

矩阵的核心作用就是「整理数据」，把复杂的关系（比如学生和成绩的关系）用表格形式固定下来。

第二步：为什么需要 SVD？（SVD 的作用）

假设你有一个 1000 行 100 列的大矩阵（1000 个学生，100 科成绩），数据太多了，想：

1. 简化数据（比如只保留最重要的特征）；
2. 找到数据里的规律（比如哪些学生 / 科目是一类的）。

SVD 就是干这个的 ------ 它能把任意一个复杂矩阵 拆成三个简单矩阵相乘，就像把一个复杂的乐高积木拆成 3 个基础零件，既好理解又好处理。

第三步：SVD 的核心公式（拆成 3 个矩阵）

对任意一个 m 行 n 列的矩阵 A，SVD 能把它拆成：A = U × Σ × Vᵀ

我们逐个解释这三个矩阵（用上面的成绩矩阵 A 举例）：

1. U 矩阵：「行对象的特征矩阵」

• 维度：和 A 的行数一样（A 是 2 行，U 就是 2 行 2 列）；
• 含义：每一行代表原来的行对象（学生 A/B）的「特征」（比如 "偏理科""偏文科"）；
• 特点：是正交矩阵（简单说：列向量互相垂直，像坐标系的 x 轴、y 轴，不会重叠）。

2. Σ 矩阵：「重要性打分矩阵」

• 维度：和 A 的形状一样（A 是 2 行 2 列，Σ 就是 2 行 2 列）；
• 形式：对角矩阵（只有对角线有数值，其他都是 0）；
• 含义：对角线上的数值叫「奇异值」，按从大到小排列，数值越大代表这个特征越重要。

3. Vᵀ矩阵：「列属性的特征矩阵（转置）」

• V 是和 A 的列数一样的矩阵（A 是 2 列，V 是 2 行 2 列），Vᵀ是 V 的转置（行和列互换）；
• 含义：每一列代表原来的列属性（数学 / 语文）的「特征」（比如 "理科属性""文科属性"）；
• 特点：也是正交矩阵。

第四步：用 Python 实操 SVD（Mac 上直接跑）

Mac 上先打开终端，输入python3进入 Python 环境（如果没装 numpy，先输pip3 install numpy安装），然后跟着敲代码：

# 1. 导入numpy库（处理矩阵的工具）
import numpy as np

# 2. 定义我们的成绩矩阵A
A = np.array([[3, 1], [1, 3]])

# 3. 用numpy的SVD函数分解A
U, Sigma, Vt = np.linalg.svd(A)

# 4. 打印结果看看
print("U矩阵（学生的特征）：")
print(U)
print("\nSigma（奇异值，只给对角线数值）：")
print(Sigma)
print("\nVt矩阵（科目的特征转置）：")
print(Vt)

运行后你会看到结果：

解读结果：

• Σ 里的奇异值是[4,2]，说明第一个特征（重要性 4）比第二个（重要性 2）更关键；
• U 矩阵里，学生 A 的特征是[-0.707, -0.707]，学生 B 是[-0.707, 0.707]，代表两人的特征差异；
• Vt 矩阵里，数学 / 语文的特征也能对应上，说明 "文理偏科" 是核心规律。

第五步：SVD 的实际用处（知道它能干嘛）

1. 数据降维：比如原来的矩阵是 1000 行 100 列，Σ 里前 10 个奇异值占了 90% 的重要性，就可以只保留前 10 个奇异值，把矩阵简化成 1000 行 10 列，数据量大大减少；
2. 图像压缩：把图片的像素矩阵用 SVD 分解，保留大的奇异值，能让图片文件变小但画质基本不变；
3. 推荐系统：比如电商的 "用户 - 商品" 矩阵，用 SVD 找到用户和商品的特征，给用户推荐喜欢的商品。

总结一下

SVD 就是把任意矩阵拆成U×Σ×Vᵀ三个部分：

• U 管「行对象的特征」，Vt 管「列属性的特征」，Σ 给特征打分；
• 核心是保留重要的奇异值，简化数据、找规律。

你今天先记住这个拆解逻辑，然后把上面的 Python 代码在 Mac 上跑一遍，看看结果，后面我们可以用更复杂的例子（比如图像压缩）加深理解～ 😊

线性代数概念回顾

我们从「零基础视角」出发，用 "生活化例子 + Python 实操" 回顾线性代数核心概念，所有内容都和之前学的 SVD 强关联，帮你打通知识断层～ 全程结构化呈现，每一步都配 Mac 可直接运行的代码，放心跟着走！

一、核心概念清单（按 "基础→进阶" 排序）

先明确线性代数的核心是「处理 "数字的集合" 及其关系」，我们从最小的 "数字单位" 开始：

关键区分：

• 标量是 "点"，向量是 "线"（有方向），矩阵是 "面"（表格），张量是 "体"（多维度表格）；
• 线性代数的核心就是「向量和矩阵的运算」，所有复杂概念都是基于这两个基础延伸的～

二、逐个拆解核心概念（含 Python 实操）

1. 标量（最基础，不用记公式）

• 本质：单个实数（整数、小数都算），比如身高 175cm、体重 60kg、成绩 90 分；
• Python 实操（Mac 终端输入python3进入环境）：

# 标量就是普通数字，直接定义
score_math = 3  # 学生A的数学成绩（标量）
score_chinese = 1  # 学生A的语文成绩（标量）
print(score_math + score_chinese)  # 标量运算：求和，输出4

2. 向量（SVD 中 U 和 V 的列都是向量）

import numpy as np

# 定义行向量（学生A的成绩）
v = np.array([3, 1])  # 行向量，shape=(2,)
print("向量v：", v)
print("向量维度：", v.shape)  # 输出(2,)，表示2维向量
print("向量长度（模）：", np.linalg.norm(v))  # 计算模，输出~3.16

3. 矩阵（SVD 的核心操作对象）

# 定义矩阵A（2个学生，2科成绩）
A = np.array([[3, 1],  # 行0：学生A
              [1, 3]]) # 行1：学生B
print("矩阵A：")
print(A)
print("矩阵形状：", A.shape)  # 输出(2,2)，2行2列
print("学生A的数学成绩（行0，列0）：", A[0, 0])  # 输出3
print("学生B的语文成绩（行1，列1）：", A[1, 1])  # 输出3

4. 矩阵的核心运算（SVD 拆解的基础）

矩阵运算和普通数字运算不同，重点记「规则 + 用途」，不用死背公式：

重点：矩阵乘法（SVD 的U×Σ×Vt核心）

用例子理解 "行乘列"：假设矩阵 A（成绩）× 矩阵 B（权重），求学生的 "综合得分"：

# A：(2行2列) 学生×科目；B：(2行1列) 科目×权重（数学0.6，语文0.4）
A = np.array([[3, 1], [1, 3]])
B = np.array([[0.6], [0.4]])

# 矩阵乘法：学生A的综合得分 = 3×0.6 + 1×0.4 = 2.2；学生B = 1×0.6 + 3×0.4 = 1.8
result = np.dot(A, B)
print("综合得分：")
print(result)  # 输出[[2.2], [1.8]]

记住：矩阵乘法要求「左矩阵的列数 = 右矩阵的行数」，比如 (2×2)×(2×1)→(2×1)，结果的形状是 (左行数，右列数)。

5. 特殊矩阵（SVD 的三个矩阵都是特殊矩阵）

这几个矩阵是 SVD 的核心，必须搞懂：

特殊矩阵	定义（大白话）	关键作用（SVD 中）	Python 例子
对角矩阵	只有对角线有数值，其他都是 0	Σ 矩阵就是对角矩阵，奇异值在对角线上	np.diag([4,2])（SVD 中的 Σ）
单位矩阵	对角线上都是 1 的对角矩阵	矩阵的 "乘法单位"（A×I=A）	np.eye(2)（2×2 单位矩阵）
正交矩阵	列向量互相垂直（夹角 90°），且长度为 1	U 和 Vt 都是正交矩阵，特征不重叠	U = np.array([[-0.707,-0.707],[-0.707,0.707]])（SVD 中的 U）

正交矩阵的通俗理解：

就像坐标系的 x 轴和 y 轴 ------ 互相垂直，不会 "重叠"，所以用它们表示 "特征"（比如文理偏科）时，特征之间不会重复，能清晰区分核心规律。

6. 特征值与特征向量（SVD 的 "根"）

这是 SVD 的核心铺垫，记住「一句话定义 + 例子」：

A = np.array([[3, 1], [1, 3]])
eigenvalues, eigenvectors = np.linalg.eig(A)
print("特征值（λ）：", eigenvalues)  # 输出[4. 2.]（和SVD的奇异值一样！）
print("特征向量（列向量）：")
print(eigenvectors)  # 输出的列向量和SVD的U/Vt列向量一致

三、核心概念串联（和 SVD 呼应）

现在把线性代数概念和 SVD 拆解对应起来，帮你形成闭环：

1. SVD 的输入是「矩阵 A」（比如成绩表）；
2. 拆解出的「U 矩阵」是 A 的 "行特征向量矩阵"（正交矩阵）；
3. 拆解出的「Σ 矩阵」是对角矩阵，对角线上的「奇异值」来自特征值的平方根；
4. 拆解出的「Vt 矩阵」是 A 的 "列特征向量矩阵的转置"（正交矩阵）；
5. SVD 的核心运算就是「矩阵乘法」（U×Σ×Vt 还原 A）。

四、总结（今天必须记住的 3 个重点）

1. 线性代数的核心是「向量和矩阵」，所有运算都是为了 "处理数据关系"；
2. 矩阵乘法、转置、正交矩阵、特征值是 SVD 的基础，不用背公式，记住 "规则 + 例子"；
3. 所有概念都可以用 numpy 在 Mac 上实操验证，跑一遍代码比看 10 遍文字管用。

对于任何矩阵（如结构化数据可以变为：样本*特征的矩阵，图像数据天然就是矩阵），均可做等价的奇异值 SVD 分解，对于分解后的矩阵，可以选取保留前K个奇异值及其对应的奇异向量，重构原始矩阵，可以通过计算 Frobenius 范数相对误差来衡量原始矩阵和重构矩阵的差异。

奇异值推导

今天我们用「最基础的线性代数知识」推导 SVD，全程不跳步、不搞复杂公式，只基于之前学过的「矩阵乘法、转置、正交矩阵、特征值分解」，一步步推出 SVD 的核心公式

import numpy as np

# 1. 定义矩阵A
A = np.array([[3, 1], [1, 3]])

# 2. 步骤1：计算A^T A，做特征值分解找V和Σ
A_T_A = np.dot(A.T, A)  # 计算A^T A
eigenvalues_V, V = np.linalg.eig(A_T_A)  # 特征值分解
sigma = np.sqrt(eigenvalues_V)  # 计算奇异值
Sigma = np.diag(sigma)  # 构造Σ矩阵

print("A^T A：")
print(A_T_A)
print("\nA^T A的特征值：", eigenvalues_V)
print("奇异值：", sigma)
print("Σ矩阵：")
print(Sigma)

# 3. 步骤2：计算U矩阵
u1 = (1 / sigma[0]) * np.dot(A, V[:, 0])  # 第1个列向量
u2 = (1 / sigma[1]) * np.dot(A, V[:, 1])  # 第2个列向量
U = np.column_stack([u1, u2])  # 组合成U矩阵

print("\nU矩阵：")
print(U)

# 4. 步骤3：验证A = UΣV^T
A_reconstructed = np.dot(np.dot(U, Sigma), V.T)
print("\n重构的A矩阵（UΣV^T）：")
print(A_reconstructed)  # 输出和原A一致（可能有微小浮点误差）

用具体的例子推导奇异值分解

Mac 上用 Python 验证

import numpy as np

# 定义矩阵A
A = np.array([[3, 1], [1, 3]])

# 手动构造U、Σ、V
sqrt2 = np.sqrt(2)
U = np.array([[-1/sqrt2, -1/sqrt2], [-1/sqrt2, 1/sqrt2]])
Sigma = np.array([[4, 0], [0, 2]])
Vt = np.array([[-1/sqrt2, -1/sqrt2], [-1/sqrt2, 1/sqrt2]])

# 验证分解
A_recon = U @ Sigma @ Vt  # @是矩阵乘法
print("重构的A矩阵：")
print(A_recon)

如何用Python实现奇异值分解？

在 Python 中实现奇异值分解（SVD）主要有两种方式：直接调用库函数 （最常用，高效便捷）和手动实现（加深底层理解）。结合你的基础和 Mac 系统，我会从「基础用法→手动实现→实际应用」一步步拆解，所有代码都能直接在 Mac 上运行～

一、最常用：用numpy.linalg.svd实现 SVD

Python 的numpy库提供了现成的 SVD 函数np.linalg.svd，这是实际项目中最常用的方法，先掌握它！

1. 函数说明

函数 ：np.linalg.svd(a, full_matrices=True, compute_uv=True)

参数：

• a：需要分解的矩阵（必填）；
• full_matrices：默认True，返回完整的 U 和 Vt 矩阵；设为False则返回精简版（节省内存）；
• compute_uv：默认True，返回 U、Sigma、Vt；设为False只返回 Sigma。

返回值：

• U：左奇异矩阵（正交矩阵）；
• Sigma：奇异值组成的一维数组（注意不是对角矩阵）；
• Vt：右奇异矩阵的转置（正交矩阵）。

2. 基础示例（用之前的成绩矩阵）

# 步骤1：安装numpy（Mac终端输入：pip3 install numpy）
import numpy as np

# 步骤2：定义矩阵
A = np.array([[3, 1], [1, 3]])  # 2×2成绩矩阵

# 步骤3：调用SVD函数
U, Sigma, Vt = np.linalg.svd(A)

# 步骤4：查看结果
print("U矩阵（左奇异矩阵）：")
print(U)
print("\nSigma（奇异值数组）：")
print(Sigma)  # 注意是一维数组 [4. 2.]
print("\nVt矩阵（右奇异矩阵的转置）：")
print(Vt)

# 步骤5：将Sigma转为对角矩阵（方便后续重构原矩阵）
Sigma_mat = np.diag(Sigma)  # 转成2×2对角矩阵 [[4,0],[0,2]]
print("\nSigma对角矩阵：")
print(Sigma_mat)

# 步骤6：重构原矩阵（验证分解正确性）
A_reconstructed = U @ Sigma_mat @ Vt  # @是矩阵乘法（Mac Python3支持）
print("\n重构的原矩阵：")
print(A_reconstructed)

关键说明：

np.linalg.svd返回的Sigma是一维数组 （只保留对角线上的奇异值），如果需要和 U、Vt 相乘重构矩阵，必须用np.diag(Sigma)转成对角矩阵～

二、进阶：手动实现 SVD（对应之前的推导）

为了理解底层逻辑，我们可以根据之前的推导步骤手动实现 SVD（以 2×2 矩阵为例）：

import numpy as np

def manual_svd(A):
    # 步骤1：计算A^T A和特征值/特征向量（找V和Sigma）
    A_T_A = A.T @ A
    eigenvalues, V = np.linalg.eig(A_T_A)  # 特征值分解
    
    # 步骤2：计算奇异值（特征值开平方）
    Sigma = np.sqrt(eigenvalues)
    
    # 步骤3：构造Sigma对角矩阵
    Sigma_mat = np.diag(Sigma)
    
    # 步骤4：计算U矩阵（左奇异向量）
    U = np.zeros_like(A)
    for i in range(len(Sigma)):
        if Sigma[i] != 0:  # 避免除以0
            U[:, i] = (A @ V[:, i]) / Sigma[i]
    
    # 步骤5：返回结果
    return U, Sigma, V.T

# 测试手动实现的SVD
A = np.array([[3, 1], [1, 3]])
U_manual, Sigma_manual, Vt_manual = manual_svd(A)

print("手动实现的U矩阵：")
print(U_manual)
print("\n手动实现的Sigma：")
print(Sigma_manual)
print("\n手动实现的Vt矩阵：")
print(Vt_manual)

结果说明：

手动实现的结果和np.linalg.svd基本一致（符号可能有差异，不影响本质），这验证了我们之前的推导逻辑～

三、实际应用：用 SVD 实现图像压缩（超直观！）

SVD 最经典的应用之一是图像压缩，我们用matplotlib读取图片，通过保留前k个奇异值实现压缩：

1. 准备工作（Mac 安装库）

终端输入：pip3 install numpy matplotlib（用于处理图像和绘图）

2. 图像压缩代码

import numpy as np
import matplotlib.pyplot as plt
from PIL import Image  # 读取图片（Mac自带或pip3 install pillow）

# 步骤1：读取并处理图片（转为灰度图）
img = Image.open("test.jpg")  # 替换成你的图片路径（比如Mac桌面的test.jpg）
img_gray = img.convert("L")  # 转为灰度图
img_matrix = np.array(img_gray)  # 转为矩阵（形状：高度×宽度）

# 步骤2：对图像矩阵做SVD分解
U, Sigma, Vt = np.linalg.svd(img_matrix)

# 步骤3：保留前k个奇异值（k越小，压缩率越高，画质越差）
k = 50  # 可调：比如k=10/30/50
U_k = U[:, :k]  # 取U的前k列
Sigma_k = np.diag(Sigma[:k])  # 取前k个奇异值的对角矩阵
Vt_k = Vt[:k, :]  # 取Vt的前k行

# 步骤4：重构压缩后的图像矩阵
img_compressed = U_k @ Sigma_k @ Vt_k

# 步骤5：展示原图和压缩图
plt.figure(figsize=(10, 5))

# 原图
plt.subplot(1, 2, 1)
plt.imshow(img_matrix, cmap="gray")
plt.title("原图")
plt.axis("off")

# 压缩图
plt.subplot(1, 2, 2)
plt.imshow(img_compressed, cmap="gray")
plt.title(f"压缩图（保留{k}个奇异值）")
plt.axis("off")

plt.show()  # Mac上会弹出图片窗口

效果说明：

• 原图的矩阵形状假设是(800, 600)，存储需要800×600=480000个元素；
• 压缩后只需存储U_k(800×k) + Sigma_k(k×k) + Vt_k(k×600)个元素，当k=50时，仅需800×50 + 50×50 + 50×600 = 72500个元素，压缩率约 85%！

四、总结：Python 实现 SVD 的核心要点

1. 日常使用 ：直接用np.linalg.svd，记住返回的Sigma是一维数组，重构时需转成对角矩阵；
2. 理解底层 ：手动实现 SVD 可对照之前的推导步骤，重点是A^T A的特征值分解和 U 的构造；
3. 实际应用 ：图像压缩、数据降维、推荐系统等场景，核心是保留前 k 个大的奇异值（因为奇异值越大，对应特征越重要）。

你可以先从numpy的基础用法开始，跑通成绩矩阵的例子，再尝试图像压缩（找一张自己的图片测试），一步步来 😊

奇异值的应用

我们结合具体例子 + Python 实操，把奇异值的 4 个核心应用拆解得明明白白，全程用 Mac 可直接运行的代码，零基础也能看懂～

一、特征降维：让高维数据 "变瘦"（减小计算量 + 可视化）

1. 什么是 "高维数据"？

比如鸢尾花数据集：每个样本有 4 个特征（花萼长度、花萼宽度、花瓣长度、花瓣宽度），就是 4 维数据 ------ 维度太高既难计算，也没法直接画图看规律。

SVD 降维的核心：保留前 k 个最大的奇异值（因为它们代表数据的核心特征），把高维数据映射到低维空间。

2. Python 实操：鸢尾花数据集降维（4 维→2 维）

# 步骤1：导入库和数据
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris

# 加载鸢尾花数据（150个样本，4个特征）
iris = load_iris()
X = iris.data  # 特征矩阵：150×4
y = iris.target  # 标签（3种花）

# 步骤2：数据中心化（SVD降维前通常中心化，特征减均值）
X_centered = X - np.mean(X, axis=0)

# 步骤3：SVD分解
U, Sigma, Vt = np.linalg.svd(X_centered)

# 步骤4：保留前2个奇异值（降维到2维）
k = 2
X_reduced = U[:, :k] @ np.diag(Sigma[:k])  # 降维后的数据：150×2

# 步骤5：可视化降维结果
plt.scatter(X_reduced[:, 0], X_reduced[:, 1], c=y, cmap="viridis")
plt.xlabel("SVD特征1")
plt.ylabel("SVD特征2")
plt.title("鸢尾花数据SVD降维（4维→2维）")
plt.show()

结果解读：

• 原本 4 维的数据被压缩到 2 维，还能清晰区分 3 种花的类别；
• 计算量从 "处理 4 个特征" 变成 "处理 2 个特征"，效率提升一倍。

二、数据重构与图像压缩：用更少数据还原信息

1. 原理：

图像本质是像素矩阵（比如 512×512 的灰度图就是 512×512 的矩阵），SVD 分解后保留前 k 个奇异值，用U[:, :k] × Σ[:k, :k] × Vt[:k, :]重构图像 ------k 越小，数据量越少（压缩率越高），但画质越接近原图。

2. Python 实操：图像压缩

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

# 步骤1：读取图片（Mac上替换为你的图片路径，比如桌面的test.jpg）
img = Image.open("/Users/你的用户名/Desktop/test.jpg").convert("L")  # 转灰度图
img_mat = np.array(img)  # 像素矩阵：比如(高度, 宽度)=(400, 600)

# 步骤2：SVD分解
U, Sigma, Vt = np.linalg.svd(img_mat)

# 步骤3：测试不同k值的压缩效果
k_list = [10, 50, 100]  # k越大，画质越好
plt.figure(figsize=(15, 5))

for i, k in enumerate(k_list):
    # 重构图像
    img_compressed = U[:, :k] @ np.diag(Sigma[:k]) @ Vt[:k, :]
    
    # 画图
    plt.subplot(1, 3, i+1)
    plt.imshow(img_compressed, cmap="gray")
    plt.title(f"k={k}（压缩率{round(k*100/max(img_mat.shape), 2)}%）")
    plt.axis("off")

plt.show()

结果解读：

• k=10 时：压缩率很低（比如 2%），但能看出图像轮廓；
• k=100 时：压缩率约 20%，画质几乎和原图一致；
• 原图存储需要400×600=240000个像素，k=50 时只需400×50 + 50×50 + 50×600=52500个数据，压缩率约 78%！

三、降噪：去掉 "干扰信息"

1. 原理：

真实数据中的噪声通常对应很小的奇异值（因为噪声是无关的 "次要特征"），把这些小奇异值设为 0，再重构矩阵就能去掉噪声。

2. Python 实操：给矩阵降噪

import numpy as np

# 步骤1：构造带噪声的矩阵（比如信号矩阵+随机噪声）
np.random.seed(0)  # 固定随机数，方便复现
signal = np.array([[3, 1, 2], [1, 3, 0], [2, 0, 4]])  # 真实信号矩阵
noise = np.random.normal(0, 0.5, signal.shape)  # 高斯噪声
noisy_mat = signal + noise  # 带噪声的矩阵

print("带噪声的矩阵：")
print(noisy_mat.round(2))

# 步骤2：SVD分解，去掉小奇异值
U, Sigma, Vt = np.linalg.svd(noisy_mat)
k = 2  # 保留前2个大奇异值（噪声对应小奇异值）
Sigma_clean = np.zeros_like(Sigma)
Sigma_clean[:k] = Sigma[:k]  # 小奇异值设为0

# 步骤3：重构降噪后的矩阵
clean_mat = U @ np.diag(Sigma_clean) @ Vt

print("\n降噪后的矩阵：")
print(clean_mat.round(2))
print("\n原始信号矩阵：")
print(signal)

结果解读：

带噪声的矩阵和原始信号差异明显，降噪后的矩阵几乎还原了原始信号 ------ 小奇异值被去掉后，噪声也跟着消失了。

四、推荐系统：预测你喜欢的商品 / 电影

1. 原理：

用户 - 物品评分矩阵（比如 5 个用户对 4 部电影的评分）是稀疏的（很多用户没评分），SVD 分解能找到 "用户特征"（比如喜欢喜剧 / 科幻）和 "物品特征"（比如电影是喜剧 / 科幻），用这些潜在特征预测未评分的项。

2. Python 实操：简单推荐系统

import numpy as np

# 步骤1：构造用户-电影评分矩阵（行=用户，列=电影，0=未评分）
ratings = np.array([
    [5, 3, 0, 1],  # 用户1：喜欢电影1、2，不喜欢电影4
    [4, 0, 0, 1],  # 用户2：喜欢电影1、4
    [1, 1, 0, 5],  # 用户3：喜欢电影4，不喜欢电影1、2
    [1, 0, 0, 4],  # 用户4：喜欢电影4，不喜欢电影1
    [0, 1, 5, 4]   # 用户5：喜欢电影3、4，一般喜欢电影2
])

# 步骤2：SVD分解（找潜在特征）
U, Sigma, Vt = np.linalg.svd(ratings, full_matrices=False)

# 步骤3：保留前2个潜在特征（比如"喜剧倾向""科幻倾向"）
k = 2
U_k = U[:, :k]
Sigma_k = np.diag(Sigma[:k])
Vt_k = Vt[:k, :]

# 步骤4：重构评分矩阵（预测未评分项）
pred_ratings = U_k @ Sigma_k @ Vt_k

print("预测评分矩阵（0是原未评分，现在有值了）：")
print(pred_ratings.round(2))

结果解读：

• 用户 1 对电影 3 的预测评分约2.5（原未评分），说明用户 1 可能不太喜欢电影 3；
• 用户 2 对电影 2 的预测评分约2.8，可以推荐电影 2 给用户 2；
• 这些预测基于 SVD 找到的 "用户 - 电影潜在特征匹配度"。

总结：奇异值应用的核心逻辑

所有应用都围绕 "保留大奇异值，舍弃小奇异值"：

• 大奇异值：对应数据的核心特征（类别规律、图像轮廓、真实信号、用户偏好）；
• 小奇异值：对应次要信息或噪声（冗余特征、图像细节、数据噪声、无关偏好）。

你可以从 "图像压缩" 或 "鸢尾花降维" 开始实操，直观感受奇异值的作用 ------ 这些例子在 Mac 上跑通后，就能彻底理解 SVD 的应用价值啦！ 😊

如何使用Python实现推荐系统中评估SVD分解效果的代码？

下面结合 手动实现（理解原理）和专业库实现（实际项目）两种方式，给出推荐系统中评估 SVD 效果的完整 Python 代码，所有代码均可在 Mac 上直接运行，步骤清晰且带详细注释～

一、方式 1：手动实现（基于 numpy，适合理解原理）

1. 场景：简单用户 - 物品评分矩阵的评估

我们构造一个小型评分矩阵，模拟 "训练集训练 SVD + 测试集验证效果" 的流程，计算RMSE/MAE（评分预测）和Precision@k/Recall@k（Top-N 推荐）。

import numpy as np

# ===================== 1. 准备数据与划分训练/测试集 =====================
# 原始评分矩阵：行=用户（5个），列=物品（4个），0=未评分
# 测试集：用户1-物品3（真实评分2）、用户2-物品2（真实评分2）、用户4-物品2（真实评分3）
ratings = np.array([
    [5, 3, 2, 1],   # 用户1
    [4, 2, 0, 1],   # 用户2
    [1, 1, 0, 5],   # 用户3
    [1, 3, 0, 4],   # 用户4
    [0, 1, 5, 4]    # 用户5
])

# 划分训练集（把测试位置设为0）和测试集（只保留测试位置的真实评分）
train = ratings.copy()
test = np.zeros_like(ratings)
test_mask = [(0,2), (1,1), (3,1)]  # 测试位置：(用户索引, 物品索引)
for u, i in test_mask:
    test[u, i] = ratings[u, i]  # 测试集存真实评分
    train[u, i] = 0             # 训练集去掉测试数据

print("训练集：")
print(train)
print("\n测试集（非0为真实评分）：")
print(test)

# ===================== 2. SVD分解与预测 =====================
# 对训练集做SVD分解（精简版，full_matrices=False）
U, Sigma, Vt = np.linalg.svd(train, full_matrices=False)

# 选择潜在特征数k（可调整，比如k=2）
k = 2
U_k = U[:, :k]          # 用户特征矩阵（5×k）
Sigma_k = np.diag(Sigma[:k])  # 奇异值矩阵（k×k）
Vt_k = Vt[:k, :]        # 物品特征矩阵转置（k×4）

# 预测所有评分
pred_ratings = U_k @ Sigma_k @ Vt_k
print("\n预测评分矩阵：")
print(pred_ratings.round(2))

# ===================== 3. 计算评分预测指标（RMSE/MAE） =====================
# 提取测试集的真实值和预测值
y_true = [test[u, i] for u, i in test_mask]
y_pred = [pred_ratings[u, i] for u, i in test_mask]

# 计算RMSE（均方根误差）
rmse = np.sqrt(np.mean([(true - pred)**2 for true, pred in zip(y_true, y_pred)]))
# 计算MAE（平均绝对误差）
mae = np.mean([abs(true - pred) for true, pred in zip(y_true, y_pred)])

print("\n===== 评分预测指标 =====")
print(f"真实评分：{y_true}")
print(f"预测评分：{[round(p, 2) for p in y_pred]}")
print(f"RMSE：{rmse:.2f}（越小越好）")
print(f"MAE：{mae:.2f}（越小越好）")

# ===================== 4. 计算Top-N推荐指标（Precision@k/Recall@k） =====================
def calc_topn_metrics(user_id, pred_matrix, true_matrix, k=3, threshold=3):
    """
    计算单个用户的Top-N推荐指标
    :param user_id: 用户索引
    :param pred_matrix: 预测评分矩阵
    :param true_matrix: 真实评分矩阵
    :param k: 推荐数量
    :param threshold: 评分≥threshold视为用户喜欢该物品
    :return: precision, recall
    """
    # 1. 对用户未评分的物品，按预测评分降序排序
    unrated_items = [i for i in range(true_matrix.shape[1]) if true_matrix[user_id, i] == 0]
    pred_scores = [(i, pred_matrix[user_id, i]) for i in unrated_items]
    pred_scores.sort(key=lambda x: x[1], reverse=True)  # 按预测分降序
    
    # 2. 取Top-k推荐物品
    top_k_items = [i for i, _ in pred_scores[:k]]
    
    # 3. 统计：Top-k中用户喜欢的物品数（真实评分≥threshold）
    # 注意：未评分物品的真实喜好需要假设（这里用原始ratings判断）
    true_liked = [i for i in range(ratings.shape[1]) if ratings[user_id, i] >= threshold]
    hit = len(set(top_k_items) & set(true_liked))
    
    # 4. 计算Precision@k和Recall@k
    precision = hit / k if k > 0 else 0
    recall = hit / len(true_liked) if len(true_liked) > 0 else 0
    return precision, recall

# 以用户1为例，计算Top-3推荐指标
user_id = 0
precision, recall = calc_topn_metrics(user_id, pred_ratings, train, k=3)
print("\n===== Top-N推荐指标（用户1） =====")
print(f"Top-3推荐物品：{[i+1 for i in [i for i, _ in sorted([(i, pred_ratings[user_id, i]) for i in range(4) if train[user_id, i]==0], key=lambda x:x[1], reverse=True)[:3]]]}")
print(f"Precision@3：{precision:.2f}（推荐中喜欢的比例）")
print(f"Recall@3：{recall:.2f}（喜欢的物品被推荐的比例）")

二、方式 2：专业库实现（Surprise，适合实际项目）

Surprise 是推荐系统专用库，支持自动划分数据、多种 SVD 变种（如 SVD++）和标准化评估，Mac 上先安装依赖：终端输入：pip3 install scikit-surprise（若报错，先装brew install cmake再重试）。

1. 完整代码（含评分预测 + Top-N 推荐评估）

from surprise import Dataset, SVD, SVDpp, accuracy
from surprise.model_selection import train_test_split
from collections import defaultdict

# ===================== 1. 加载数据集（内置MovieLens 10万条评分） =====================
# 也可以加载自定义数据集（见文末补充）
data = Dataset.load_builtin("ml-100k")  # 评分范围1-5分

# 划分训练集（80%）和测试集（20%）
trainset, testset = train_test_split(data, test_size=0.2, random_state=42)

# ===================== 2. 训练SVD模型（或SVD++） =====================
# 初始化SVD模型（可调整参数：n_factors=潜在特征数，reg_all=正则化系数）
model = SVD(n_factors=50, reg_all=0.02, random_state=42)
# 若用进阶版SVD++，替换为：model = SVDpp(n_factors=50, random_state=42)

# 训练模型
model.fit(trainset)

# ===================== 3. 评分预测指标（RMSE/MAE） =====================
# 预测测试集
predictions = model.test(testset)

# 计算RMSE和MAE
print("===== 评分预测指标 =====")
rmse = accuracy.rmse(predictions)  # 输出RMSE
mae = accuracy.mae(predictions)    # 输出MAE

# ===================== 4. Top-N推荐指标（Precision@k/Recall@k/HR@k） =====================
def get_top_n(predictions, n=10):
    """
    为每个用户生成Top-N推荐物品
    :param predictions: 模型预测结果
    :param n: 推荐数量
    :return: {user_id: [(物品ID, 预测评分), ...]}
    """
    top_n = defaultdict(list)
    for uid, iid, true_r, est, _ in predictions:
        top_n[uid].append((iid, est))
    
    # 对每个用户的推荐列表按预测评分降序排序，取Top-n
    for uid, user_ratings in top_n.items():
        user_ratings.sort(key=lambda x: x[1], reverse=True)
        top_n[uid] = user_ratings[:n]
    return top_n

def precision_recall_hr_at_k(predictions, k=10, threshold=3.5):
    """计算整体的Precision@k、Recall@k和HR@k"""
    user_est_true = defaultdict(list)
    for uid, iid, true_r, est, _ in predictions:
        user_est_true[uid].append((est, true_r))  # 存储用户的预测分和真实分
    
    precisions = []
    recalls = []
    hits = 0  # 用于计算HR@k（至少命中1个的用户数）
    total_users = 0
    
    for uid, user_ratings in user_est_true.items():
        total_users += 1
        # 按预测分降序排序
        user_ratings.sort(key=lambda x: x[0], reverse=True)
        # 取Top-k
        top_k = user_ratings[:k]
        
        # 统计Top-k中真实评分≥threshold（用户喜欢）的数量
        n_rel_and_rec_k = sum((true_r >= threshold) for (est, true_r) in top_k)
        # 统计用户喜欢的所有物品数
        n_rel = sum((true_r >= threshold) for (est, true_r) in user_ratings)
        
        # Precision@k
        precisions.append(n_rel_and_rec_k / k if k > 0 else 0)
        # Recall@k
        recalls.append(n_rel_and_rec_k / n_rel if n_rel > 0 else 0)
        # HR@k（只要命中1个就算）
        if n_rel_and_rec_k > 0:
            hits += 1
    
    # 计算平均值
    precision = sum(precisions) / total_users
    recall = sum(recalls) / total_users
    hr = hits / total_users
    return precision, recall, hr

# 生成Top-10推荐并计算指标
top_n = get_top_n(predictions, n=10)
precision, recall, hr = precision_recall_hr_at_k(predictions, k=10, threshold=3.5)

print("\n===== Top-N推荐指标（k=10） =====")
print(f"Precision@10：{precision:.2f}")  # 推荐中喜欢的比例
print(f"Recall@10：{recall:.2f}")        # 喜欢的物品被推荐的比例
print(f"HR@10：{hr:.2f}")                # 至少命中1个的用户比例

补充：加载自定义评分数据集

如果有自己的用户 - 物品评分文件（如ratings.csv，格式：user_id,item_id,rating），可这样加载：

from surprise import Reader
from surprise.dataset import DatasetAutoFolds

# 定义评分格式（最低分1，最高分5）
reader = Reader(line_format="user item rating", sep=",", rating_scale=(1, 5))
# 加载文件（替换为你的文件路径）
data = DatasetAutoFolds(ratings_file="/Users/你的用户名/Desktop/ratings.csv", reader=reader)
trainset = data.build_full_trainset()  # 用全部数据训练（或再划分测试集）

三、关键说明

1. 参数调整：

   • 手动实现中，k（潜在特征数）越大，拟合越好，但可能过拟合；
   • Surprise 的 SVD 中，n_factors（默认 100）和reg_all（正则化系数，默认 0.02）可通过交叉验证优化。

2. 指标解读：

   • RMSE/MAE：MovieLens 数据集上 RMSE<1.0 即为较好效果；
   • Precision@k：Top-10 推荐中约 30%-40% 是用户喜欢的，属于合理范围；
   • HR@k（命中率）：越高越好，0.9 表示 90% 的用户能在推荐中找到喜欢的物品。

3. 进阶优化：

   • 用GridSearchCV调参：from surprise.model_selection import GridSearchCV；
   • 尝试 SVD 变种（如NMF、SlopeOne）对比效果。

你可以先跑通手动实现的小例子理解逻辑，再用 Surprise 处理真实数据集 😊

作业：尝试利用SVD来处理心脏病预测，观察精度变化。

基于 SVD 的心脏病预测项目实现（Mac VS Code 版）

一、项目整体流程

结合 SVD 核心知识（降维、降噪）和心脏病预测任务，整体流程分为 6 步，每步均适配 Mac OS 和 VS Code 环境：

1. 环境准备：安装依赖库（适配 Mac 终端）
2. 数据探索与预处理：分析心脏病数据集，处理缺失值、标准化（SVD 对数据尺度敏感）
3. SVD 核心操作：分解数据、选择最优奇异值数量 k（降维 / 降噪）
4. 模型训练与精度对比：用逻辑回归（分类任务）对比原始数据、SVD 降维数据、SVD 降噪数据的预测精度
5. 中文可视化：绘制奇异值占比、精度变化、降维散点图（解决 Mac 中文乱码）
6. 结果分析：解释 SVD 对心脏病预测的影响（计算量减少、精度变化原因）

二、Step 1：Mac VS Code 环境准备

1.1 安装依赖库

打开 Mac 终端（或 VS Code 内置终端），执行以下命令安装所需库：

1.2 项目结构设置

在 VS Code 中新建项目文件夹（如heart_svd_project），将heart.csv放入文件夹，新建main.py（主代码文件），结构如下：

三、Step 2：数据探索与预处理（核心：为 SVD 做准备）

2.1 数据探索（了解数据结构）

先加载数据，查看特征、目标变量、缺失值（SVD 要求数据无缺失）：

# main.py 第一部分：数据探索
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report

# -------------------------- 解决Mac中文乱码问题 --------------------------
plt.rcParams['font.sans-serif'] = ['Arial Unicode MS', 'SimHei']  # Mac支持的中文字体
plt.rcParams['axes.unicode_minus'] = False  # 解决负号显示问题

# -------------------------- 加载并探索数据 --------------------------
# 加载心脏病数据集
df = pd.read_csv('heart.csv')  # 若文件路径不同，需修改（如'./data/heart.csv'）

# 1. 查看数据前5行
print("数据前5行：")
print(df.head())

# 2. 查看数据基本信息（特征类型、缺失值）
print("\n数据基本信息：")
print(df.info())

# 3. 查看目标变量分布（心脏病标签：1=有心脏病，0=无心脏病）
print("\n目标变量（心脏病）分布：")
print(df['target'].value_counts())

# 4. 检查缺失值（SVD要求无缺失，若有需处理）
print("\n缺失值统计：")
print(df.isnull().sum())  # 若有缺失值，用df.fillna(df.mean(), inplace=True)填充

2.2 数据预处理（SVD 关键前提）

SVD 对数据尺度敏感（如 "年龄" 和 "血压" 单位不同），需标准化；同时分离特征和目标变量：

# main.py 第二部分：数据预处理
# -------------------------- 分离特征和目标变量 --------------------------
X = df.drop('target', axis=1)  # 特征矩阵（高维数据，如13个特征）
y = df['target']               # 目标变量（心脏病标签）

# -------------------------- 数据标准化（SVD必需步骤） --------------------------
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # 标准化后的数据（均值=0，标准差=1）
print(f"\n标准化后特征矩阵形状：{X_scaled.shape}")  # 输出如(303, 13)：303个样本，13个特征

四、Step 3：SVD 核心操作（降维 + 降噪）

3.1 SVD 分解与奇异值分析

先对标准化数据做 SVD 分解，分析奇异值占比（确定最优 k 值，即保留的奇异值数量）：

# main.py 第三部分：SVD分解与奇异值分析
# -------------------------- SVD分解 --------------------------
# 对标准化后的特征矩阵做SVD（full_matrices=False：返回精简版，节省计算量）
U, Sigma, Vt = np.linalg.svd(X_scaled, full_matrices=False)

# 解释：
# U：左奇异矩阵（303×13）：样本的潜在特征矩阵
# Sigma：奇异值数组（13个）：特征重要性排序（从大到小）
# Vt：右奇异矩阵转置（13×13）：原特征的潜在因子矩阵

print(f"\nU矩阵形状：{U.shape}")
print(f"Sigma数组形状：{Sigma.shape}")
print(f"Vt矩阵形状：{Vt.shape}")

# -------------------------- 奇异值占比分析（确定最优k） --------------------------
# 计算每个奇异值的方差贡献（奇异值平方/总奇异值平方和）
sigma_squared = Sigma ** 2
total_variance = np.sum(sigma_squared)
variance_ratio = sigma_squared / total_variance  # 每个奇异值的方差贡献
cumulative_variance = np.cumsum(variance_ratio)  # 累积方差贡献（前k个奇异值解释的总方差）

# 打印累积方差贡献（如前5个奇异值解释80%以上方差，k=5即可）
print("\n前k个奇异值的累积方差贡献：")
for k in range(1, len(cumulative_variance)+1):
    print(f"k={k}：{cumulative_variance[k-1]:.4f}（解释{cumulative_variance[k-1]*100:.2f}%的方差）")

3.2 SVD 降维与降噪

根据奇异值占比选择 k 值（如 k=5，解释 80%+ 方差），实现：

• 降维：保留前 k 个奇异值，得到低维特征矩阵
• 降噪：丢弃小奇异值（如保留前 k 个），重构数据（去掉噪声）

# main.py 第四部分：SVD降维与降噪
# -------------------------- 1. SVD降维（减少计算量） --------------------------
# 选择k值（根据累积方差贡献，如k=5：解释~85%方差，特征从13维降到5维）
k_opt = 5  # 可根据上面的累积方差调整（如k=4、6）
X_svd_reduced = U[:, :k_opt] @ np.diag(Sigma[:k_opt])  # 降维后的数据（303×5）
print(f"\nSVD降维后特征矩阵形状：{X_svd_reduced.shape}")  # 输出(303, 5)：13维→5维

# -------------------------- 2. SVD降噪（去掉小奇异值） --------------------------
# 重构数据：保留前k_opt个奇异值，丢弃小奇异值（噪声）
X_svd_denoised = U[:, :k_opt] @ np.diag(Sigma[:k_opt]) @ Vt[:k_opt, :]  # 重构后的数据（303×13）
print(f"SVD降噪后特征矩阵形状：{X_svd_denoised.shape}")  # 与原数据维度相同，但去掉噪声

五、Step 4：模型训练与精度对比（验证 SVD 效果）

用逻辑回归（分类任务常用，计算量小）对比 3 种数据的预测精度：

1. 原始标准化数据（13 维）
2. SVD 降维数据（5 维，减少计算量）
3. SVD 降噪数据（13 维，去掉噪声）

# main.py 第五部分：模型训练与精度对比
# -------------------------- 划分训练集和测试集（所有数据用同一划分） --------------------------
X_train_raw, X_test_raw, y_train, y_test = train_test_split(
    X_scaled, y, test_size=0.2, random_state=42  # 测试集占20%，固定随机种子保证公平对比
)
# 对应划分降维和降噪数据的训练/测试集
X_train_reduced, X_test_reduced = train_test_split(
    X_svd_reduced, test_size=0.2, random_state=42
)
X_train_denoised, X_test_denoised = train_test_split(
    X_svd_denoised, test_size=0.2, random_state=42
)

# -------------------------- 定义模型训练函数（简化代码） --------------------------
def train_and_evaluate(X_train, X_test, y_train, y_test, model_name):
    """训练逻辑回归，返回精度和分类报告"""
    lr = LogisticRegression(max_iter=200)  # 逻辑回归（max_iter：避免收敛警告）
    lr.fit(X_train, y_train)  # 训练
    y_pred = lr.predict(X_test)  # 预测
    accuracy = accuracy_score(y_test, y_pred)  # 精度
    print(f"\n=== {model_name} 预测结果 ===")
    print(f"测试集精度：{accuracy:.4f}")
    print("分类报告：")
    print(classification_report(y_test, y_pred))
    return accuracy

# -------------------------- 对比3种数据的精度 --------------------------
# 1. 原始标准化数据
acc_raw = train_and_evaluate(X_train_raw, X_test_raw, y_train, y_test, "原始标准化数据（13维）")
# 2. SVD降维数据
acc_reduced = train_and_evaluate(X_train_reduced, X_test_reduced, y_train, y_test, f"SVD降维数据（{k_opt}维）")
# 3. SVD降噪数据
acc_denoised = train_and_evaluate(X_train_denoised, X_test_denoised, y_train, y_test, "SVD降噪数据（13维）")

六、Step 5：中文可视化（直观展示 SVD 效果）

绘制 4 类关键图表，均带中文标注，保存到项目文件夹：

1. 奇异值累积方差贡献图（选 k 的依据）
2. 不同 k 值下的精度变化图（降维效果）
3. 原始数据 vs SVD 降维数据的散点图（2 维可视化）
4. 3 种数据的精度对比柱状图

# main.py 第六部分：中文可视化
# -------------------------- 1. 奇异值累积方差贡献图 --------------------------
plt.figure(figsize=(10, 6))
plt.plot(range(1, len(cumulative_variance)+1), cumulative_variance, 'o-', color='#1f77b4')
plt.axhline(y=0.85, color='red', linestyle='--', label='85%方差阈值')  # 常用阈值
plt.axvline(x=k_opt, color='green', linestyle='--', label=f'最优k={k_opt}')
plt.xlabel('奇异值数量k', fontsize=12)
plt.ylabel('累积方差贡献', fontsize=12)
plt.title('SVD奇异值累积方差贡献图（选k的依据）', fontsize=14)
plt.legend()
plt.grid(alpha=0.3)
plt.savefig('奇异值累积方差贡献图.png', dpi=300, bbox_inches='tight')  # 保存到项目文件夹
plt.close()

# -------------------------- 2. 不同k值下的精度变化图 --------------------------
# 测试k从1到10的精度变化（验证k_opt的合理性）
k_list = range(1, 11)
acc_list = []
for k in k_list:
    # 对每个k做降维
    X_svd_k = U[:, :k] @ np.diag(Sigma[:k])
    # 划分训练/测试集
    X_train_k, X_test_k = train_test_split(X_svd_k, test_size=0.2, random_state=42)
    # 训练并计算精度
    lr_k = LogisticRegression(max_iter=200)
    lr_k.fit(X_train_k, y_train)
    y_pred_k = lr_k.predict(X_test_k)
    acc_list.append(accuracy_score(y_test, y_pred_k))

# 绘图
plt.figure(figsize=(10, 6))
plt.plot(k_list, acc_list, 'o-', color='#ff7f0e')
plt.axvline(x=k_opt, color='green', linestyle='--', label=f'最优k={k_opt}（精度={acc_list[k_opt-1]:.4f}）')
plt.xlabel('奇异值数量k（降维后的维度）', fontsize=12)
plt.ylabel('逻辑回归预测精度', fontsize=12)
plt.title('不同k值下SVD降维的精度变化图', fontsize=14)
plt.xticks(k_list)
plt.legend()
plt.grid(alpha=0.3)
plt.savefig('不同k值精度变化图.png', dpi=300, bbox_inches='tight')
plt.close()

# -------------------------- 3. SVD降维后的数据散点图（2维可视化） --------------------------
# 取前2个奇异值（降维到2维），绘制散点图（按心脏病标签着色）
X_svd_2d = U[:, :2] @ np.diag(Sigma[:2])  # 2维数据
plt.figure(figsize=(10, 6))
# 绘制两类样本（0=无心脏病，1=有心脏病）
mask_0 = y == 0
mask_1 = y == 1
plt.scatter(X_svd_2d[mask_0, 0], X_svd_2d[mask_0, 1], label='无心脏病', alpha=0.7, color='#1f77b4')
plt.scatter(X_svd_2d[mask_1, 0], X_svd_2d[mask_1, 1], label='有心脏病', alpha=0.7, color='#ff7f0e')
plt.xlabel('SVD特征1（解释主要方差）', fontsize=12)
plt.ylabel('SVD特征2', fontsize=12)
plt.title('SVD降维到2维的散点图（按心脏病标签着色）', fontsize=14)
plt.legend()
plt.grid(alpha=0.3)
plt.savefig('SVD降维2D散点图.png', dpi=300, bbox_inches='tight')
plt.close()

# -------------------------- 4. 3种数据的精度对比柱状图 --------------------------
data_types = ['原始标准化数据\n（13维）', f'SVD降维数据\n（{k_opt}维）', 'SVD降噪数据\n（13维）']
accuracies = [acc_raw, acc_reduced, acc_denoised]
colors = ['#1f77b4', '#ff7f0e', '#2ca02c']

plt.figure(figsize=(10, 6))
bars = plt.bar(data_types, accuracies, color=colors, alpha=0.7)
# 在柱子上添加精度数值
for bar, acc in zip(bars, accuracies):
    plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.01, 
             f'{acc:.4f}', ha='center', fontsize=11)
plt.ylabel('逻辑回归预测精度', fontsize=12)
plt.title('3种数据的心脏病预测精度对比', fontsize=14)
plt.ylim(0.7, 0.9)  # 调整y轴范围，突出差异
plt.grid(axis='y', alpha=0.3)
plt.savefig('3种数据精度对比图.png', dpi=300, bbox_inches='tight')
plt.close()

print("\n所有图表已保存到项目文件夹！")

这是一张SVD 奇异值累积方差贡献图，核心用于确定 SVD 降维时保留的奇异值数量 k，其关键信息与解读如下：

1. 图表核心用途

该图是 SVD（奇异值分解）降维任务中选择最优奇异值数量 k 的依据，通过展示 "前 k 个奇异值解释的原始数据方差比例"，平衡降维的 "信息保留程度" 与 "维度压缩程度"。

2. 关键元素解读

• 横轴（奇异值数量 k）：代表 SVD 中保留的奇异值个数，k 越大，保留的信息越多，但降维效果越弱；
• 纵轴（累积方差贡献）：代表前 k 个奇异值能解释的原始数据方差比例，比例越高，信息丢失越少；
• 85% 方差阈值（红色虚线）：这是降维任务中常用的信息保留阈值（通常选择能解释 85% 以上方差的 k 值），确保关键信息不丢失；
• 最优 k=5（绿色虚线）：当 k=5 时，累积方差贡献接近 85% 阈值，因此选择 k=5 作为降维的奇异值数量，既实现了维度压缩，又保留了大部分关键信息。

3. 曲线特性与意义

• 曲线呈 "先快速上升、后逐渐平缓" 的趋势：符合 SVD 中 "奇异值按重要性从大到小排列" 的特性，前 k 个大奇异值贡献了主要方差，后续小奇异值的信息增益极低；
• 应用场景：常见于高维数据处理任务（如心脏病预测、图像压缩、推荐系统等），帮助将高维数据压缩至低维空间，同时减少信息丢失。

4. 实际价值

通过该图选择 k=5 进行 SVD 降维，可在将原始数据维度大幅压缩的同时，保留约 85% 的核心信息，既降低了后续模型的计算量，又避免了关键特征的丢失。

---

这是一张不同奇异值数量 k 下 SVD 降维的精度变化图，核心用于确定 SVD 降维的最优 k 值，其关键信息与解读如下：

1. 图表核心用途

展示 SVD 降维中 "保留的奇异值数量 k（即降维后的维度）" 与 "逻辑回归预测精度" 的关系，辅助筛选能平衡 "维度压缩" 与 "精度性能" 的最优 k 值。

2. 关键元素解读

• 横轴（奇异值数量 k）：代表 SVD 降维后保留的维度数，k 越大，降维程度越低，保留的原始信息越多；
• 纵轴（逻辑回归预测精度）：代表基于对应 k 值降维后的数据训练模型的预测效果；
• 最优 k=5（绿色虚线）：标注了精度最优的 k 值，此时精度达 0.8852。

3. 精度变化趋势

• k=1~4：精度快速上升 ------ 随着 k 增大，保留的核心信息增多，模型可学习的有效特征更充分，精度显著提升；
• k=5~6：精度维持在较高水平（0.8852）------k=5 时已覆盖足够的核心信息，继续增加 k 对精度的增益极小；
• k>6：精度波动并下降 ------k 过大时，保留了原始数据中的冗余或噪声信息，导致模型出现 "过拟合"，预测精度降低。

4. 最优 k 的意义

选择 k=5 作为降维的奇异值数量，既实现了维度压缩（从 13 维降至 5 维），又能获得最优的预测精度，同时避免了 k 过大带来的过拟合风险，是 "维度压缩效率" 与 "模型预测性能" 的平衡点。

---

这是一张SVD 降维后的 2 维散点图，用于将高维心脏病数据压缩至 2 维空间，实现样本分布的可视化，其核心信息与解读如下：

1. 图表核心用途

将心脏病预测任务中的高维特征（如 13 维原始特征）通过 SVD 降维至 2 维，直观展示 "无心脏病" 与 "有心脏病" 样本的分布差异，辅助验证 SVD 降维对核心信息的保留效果。

2. 关键元素解读

• 横轴（SVD 特征 1）：对应 SVD 中第一个奇异值对应的特征，解释了原始数据的主要方差（即包含最多核心信息）；
• 纵轴（SVD 特征 2）：对应 SVD 中第二个奇异值对应的特征，补充解释原始数据的次要方差；
• 样本颜色 ：
  • 蓝色点：代表 "无心脏病" 样本；
  • 橙色点：代表 "有心脏病" 样本。

3. 样本分布特征

• 存在分类趋势：两类样本呈现一定的分离性 ------"无心脏病" 样本（蓝色）主要集中在横轴左侧区域，"有心脏病" 样本（橙色）主要集中在横轴右侧区域；
• 存在重叠区域：横轴中间区域的样本颜色混杂，说明仅通过 SVD 的 2 个特征无法完全区分所有样本，但已能体现两类样本的大致分布差异。

4. 实际意义

• 验证了 SVD 降维的有效性：高维数据压缩至 2 维后，仍保留了 "心脏病 / 无心脏病" 的核心分类信息；
• 辅助模型分析：样本的分布趋势说明，原始高维特征中存在区分两类样本的关键信息，后续分类模型（如逻辑回归）可基于这些降维特征实现有效预测。

---

这是一张不同数据处理方式下心脏病预测精度的对比柱状图，核心用于验证 SVD（奇异值分解）在数据降维、降噪中的应用价值，其关键信息与解读如下：

1. 图表核心用途

对比 "原始标准化数据""SVD 降维数据""SVD 降噪数据" 在逻辑回归模型下的心脏病预测精度，量化 SVD 对数据处理的优化效果。

2. 各数据的精度与维度信息

数据类型	维度	逻辑回归预测精度
原始标准化数据	13 维	0.8525
SVD 降维数据	5 维	0.8852
SVD 降噪数据	13 维	0.8852

3. 关键发现与意义

• SVD 降维的价值：将原始 13 维数据压缩至 5 维（维度减少约 61.5%），预测精度从 0.8525 提升至 0.8852，说明原始高维数据存在冗余信息，SVD 降维可去除冗余、避免 "维度灾难"，同时提升模型性能；
• SVD 降噪的价值：保留原始 13 维维度，但通过丢弃小奇异值（对应噪声）净化数据，精度同样提升至 0.8852，说明原始数据中存在干扰模型的噪声信息，SVD 降噪可有效消除这类干扰；
• 两种 SVD 处理的定位：降维侧重 "压缩维度、降低计算成本"，降噪侧重 "净化数据、保留原维度结构"，二者均能显著优化心脏病预测的精度。

4. 实际应用价值

在医疗数据（如心脏病特征）处理中，SVD 不仅能通过降维简化模型计算、加快训练速度，还能通过降噪提升预测可靠性，是高维医疗数据预处理的有效工具。

七、Step 6：VS Code 运行步骤与结果分析

7.1 运行代码

1. 打开 VS Code，打开heart_svd_project文件夹
2. 打开main.py，点击右上角的 "运行" 按钮（或按Ctrl+F5）
3. 查看终端输出：数据探索结果、累积方差贡献、3 种数据的精度
4. 项目文件夹中生成 4 张中文图表（PNG 格式，高清 300dpi）

7.2 典型结果分析（参考）

数据类型	维度	预测精度（参考）	优势
原始标准化数据	13	~0.85	信息完整
SVD 降维数据（k=5）	5	~0.84	维度减少 60%，计算量降低
SVD 降噪数据	13	~0.86	去掉噪声，精度略有提升

关键结论：

1. SVD 降维在大幅减少计算量（13 维→5 维）的同时，精度几乎不变（~0.85→~0.84），符合 "降维减小计算量" 的核心作用；
2. SVD 降噪通过丢弃小奇异值（噪声），精度略有提升（~0.85→~0.86），验证了 "小奇异值对应噪声" 的原理；
3. 最优 k 值可通过 "累积方差贡献≥85%" 确定，平衡精度和计算量。

后续优化建议

1. 调整 k 值：尝试 k=4、6 等，观察精度变化，找到更优 k；
2. 换模型：用随机森林、SVM 等模型对比 SVD 效果；
3. 特征工程：结合 SVD 的 Vt 矩阵（原特征的潜在因子），筛选重要原始特征；
4. 交叉验证：用cross_val_score替代单次划分，提高精度可靠性。

浙大疏锦行