机器学习算法

线性回归 (Linear Regression)

核心思想 (Core Idea):
- 假设输入特征 (X) 和连续的输出目标 (y) 之间存在线性关系。
- 目标是找到一个（或一组）最佳的权重 (weights/coefficients) 和偏置 (bias/intercept)，使得通过这些参数构建的线性方程能够最好地拟合数据点。
- “最好地拟合”通常指最小化预测值与真实值之间的均方误差 (Mean Squared Error, MSE)。
数学表示 (Mathematical Representation):
- 对于单个特征： ŷ = w * x + b
- 对于多个特征 (向量化表示): ŷ = Xw + b 或者 ŷ = w₀ + w₁x₁ + w₂x₂ + ... + wₚxₚ (其中 w₀ 是偏置 b)
  - ŷ (y-hat): 模型的预测值。
  - X: 输入特征矩阵 (每行是一个样本，每列是一个特征)。
  - x (或 x₁, x₂, ...): 单个输入特征的值。
  - w: 权重向量 (或单个权重)。
  - b: 偏置项 (或截距 w₀)。
- 输出直接是预测的连续值。
求解方式 (Solution Method / Optimization):
- 损失函数 (Loss Function): 均方误差 (MSE) L(w, b) = (1/N) * Σ(yᵢ - ŷᵢ)² = (1/N) * Σ(yᵢ - (Xᵢw + b))² 其中 N 是样本数量。
- 优化算法:
  - 正规方程 (Normal Equation): 一种解析解，可以直接计算出最优的 w (如果将 b 合并到 w 中，并在 X 中添加一列全为1的特征)。 w = (XᵀX)⁻¹ Xᵀy 优点: 一步到位，无需选择学习率。 缺点: XᵀX 的求逆操作计算量大 (O(n³)，n为特征数)，当特征数量巨大时不可行；如果 XᵀX 不可逆（如特征间高度相关），则无法使用。
  - 梯度下降 (Gradient Descent): 一种迭代优化算法。通过计算损失函数对参数 w 和 b 的梯度，并沿着梯度的反方向更新参数，逐步减小损失。 w := w - α * ∂L/∂w b := b - α * ∂L/∂b 其中 α 是学习率。 变种: 批量梯度下降 (BGD), 随机梯度下降 (SGD), 小批量梯度下降 (Mini-batch GD)。
目的/用途 (Purpose / Use Cases):
- 预测一个连续的数值型输出。
- 示例：
  - 根据房屋面积、位置等预测房价。
  - 根据广告投入预测产品销量。
  - 根据历史数据预测未来气温。
  - 分析特征对连续目标变量的影响程度。

PyTorch 实现 (PyTorch Implementation):

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# 1. 准备数据 (示例)
# 假设我们有100个样本，每个样本有3个特征
X_numpy = np.random.rand(100, 3).astype(np.float32)
# 真实关系: y = 2*x1 + 3*x2 - 1.5*x3 + 5 + noise
w_true = np.array([[2], [3], [-1.5]], dtype=np.float32)
b_true = np.array([5], dtype=np.float32)
y_numpy = X_numpy @ w_true + b_true + np.random.randn(100, 1).astype(np.float32) * 0.1 # 加入一些噪声

X_tensor = torch.from_numpy(X_numpy)
y_tensor = torch.from_numpy(y_numpy)

# 2. 定义模型
# nn.Linear(input_features, output_features)
# 对于线性回归，输出特征数为1
input_features = X_tensor.shape[1]
output_features = 1
model = nn.Linear(input_features, output_features)

# 3. 定义损失函数
criterion = nn.MSELoss()

# 4. 定义优化器
optimizer = optim.SGD(model.parameters(), lr=0.01) # 使用随机梯度下降

# 5. 训练模型
num_epochs = 200
for epoch in range(num_epochs):
    # 前向传播
    outputs = model(X_tensor)

    # 计算损失
    loss = criterion(outputs, y_tensor)

    # 反向传播和优化
    optimizer.zero_grad() # 清空之前的梯度
    loss.backward()       # 计算当前梯度
    optimizer.step()      # 更新权重

    if (epoch+1) % 20 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

# 6. 查看学习到的参数
print("\n学习到的权重和偏置:")
for name, param in model.named_parameters():
    if param.requires_grad:
        if name == 'weight':
            print(f'Weights (w): {param.data.numpy().flatten()}')
        elif name == 'bias':
            print(f'Bias (b): {param.data.numpy().flatten()}')

# 7. 进行预测 (可选)
# new_data = torch.tensor([[0.5, 0.2, 0.8]], dtype=torch.float32)
# predicted_value = model(new_data)
# print(f"Prediction for new data: {predicted_value.item()}")

逻辑回归 (Logistic Regression)

核心思想 (Core Idea):
- 虽然名字带“回归”，但它主要用于二分类问题 (也可以扩展到多分类)。
- 目标是预测一个样本属于某个类别的概率。
- 它首先像线性回归一样计算输入特征的线性组合 (z = Xw + b)。
- 然后，这个线性组合的结果 (z) 会通过一个 Sigmoid (或 Logistic) 函数，将其映射到 (0, 1) 区间，这个输出值可以解释为样本属于正类 (通常标记为1) 的概率。
- 决策边界是线性的。
数学表示 (Mathematical Representation):
- 线性部分: z = Xw + b (同线性回归)
- Sigmoid 函数 (σ): σ(z) = 1 / (1 + e^(-z))
- 预测概率 (ŷ 为样本属于类别1的概率 P(y=1|X)): ŷ = P(y=1|X) = σ(z) = σ(Xw + b) = 1 / (1 + e^-(Xw + b))
- 输出是一个 (0, 1) 之间的概率值。 通常会设定一个阈值 (如0.5)，如果 ŷ > 0.5 则预测为类别1，否则为类别0。
- 另一种表示形式 (对数几率 Log-odds 或 Logit): log( P(y=1|X) / (1 - P(y=1|X)) ) = log( ŷ / (1-ŷ) ) = Xw + b 这表明逻辑回归假设特征的线性组合等于对数几率。
求解方式 (Solution Method / Optimization):
- 损失函数 (Loss Function): 对数损失 (Log Loss) 或二元交叉熵 (Binary Cross-Entropy, BCE) L(w, b) = -(1/N) * Σ [yᵢ * log(ŷᵢ) + (1 - yᵢ) * log(1 - ŷᵢ)] 其中 yᵢ 是真实标签 (0或1)，ŷᵢ 是模型预测样本 i 属于类别1的概率。这个损失函数衡量了预测概率分布与真实标签分布之间的差异。
- 优化算法:
  - 没有简单的解析解 (不像线性回归的MSE有正规方程)。
  - 梯度下降 (Gradient Descent): 同样是主流方法。计算BCE损失函数对参数 w 和 b 的梯度，并迭代更新。 w := w - α * ∂L/∂w b := b - α * ∂L/∂b 变种: SGD, Mini-batch GD, Adam, etc.
目的/用途 (Purpose / Use Cases):
- 预测一个离散的、分类的输出，最常见的是二分类。
- 输出结果是概率，可以根据业务需求调整分类阈值。
- 示例：
  - 判断一封邮件是否为垃圾邮件 (是/否)。
  - 预测一个客户是否会流失 (会/不会)。
  - 根据医学指标判断肿瘤是良性还是恶性。
  - （通过One-vs-Rest或Softmax回归扩展）进行多分类，如数字识别。

PyTorch 实现 (PyTorch Implementation):

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# 1. 准备数据 (示例)
# 假设我们有100个样本，每个样本有2个特征，目标是二分类 (0 或 1)
X_numpy = np.random.rand(100, 2).astype(np.float32)
# 设定一个简单的决策边界: 如果 x1 + x2 > 1 则为类别1，否则为类别0 (加入一些噪声)
y_numpy = (X_numpy[:, 0] + X_numpy[:, 1] > 1).astype(np.float32).reshape(-1, 1)
# 模拟一些噪声，随机翻转10%的标签
noise_indices = np.random.choice(len(y_numpy), size=int(0.1 * len(y_numpy)), replace=False)
y_numpy[noise_indices] = 1 - y_numpy[noise_indices]


X_tensor = torch.from_numpy(X_numpy)
y_tensor = torch.from_numpy(y_numpy) # 标签是0或1

# 2. 定义模型
# nn.Linear(input_features, output_features)
# 对于二分类逻辑回归，输出特征数为1 (这个输出是logit，即sigmoid函数的输入z)
input_features = X_tensor.shape[1]
output_features = 1 # 输出一个logit
model = nn.Linear(input_features, output_features)
# Sigmoid激活函数可以放在模型定义中，或在计算损失时由损失函数处理

# 3. 定义损失函数
# BCEWithLogitsLoss 结合了 Sigmoid 层和 BCE Loss，更数值稳定
# 它期望的输入是未经sigmoid的原始分数(logits)和目标标签(0或1)
criterion = nn.BCEWithLogitsLoss()
# 如果手动应用sigmoid:
# model = nn.Sequential(nn.Linear(input_features, output_features), nn.Sigmoid())
# criterion = nn.BCELoss() # 此时用BCELoss，输入是概率，标签是0或1

# 4. 定义优化器
optimizer = optim.SGD(model.parameters(), lr=0.1)

# 5. 训练模型
num_epochs = 500
for epoch in range(num_epochs):
    # 前向传播，得到logits
    logits = model(X_tensor)

    # 计算损失
    # BCEWithLogitsLoss的target需要和input有相同的dtype，通常是float
    loss = criterion(logits, y_tensor)

    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if (epoch+1) % 50 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

# 6. 查看学习到的参数
print("\n学习到的权重和偏置:")
for name, param in model.named_parameters():
    if param.requires_grad:
        if name == 'weight':
            print(f'Weights (w): {param.data.numpy().flatten()}')
        elif name == 'bias':
            print(f'Bias (b): {param.data.numpy().flatten()}')

# 7. 进行预测 (可选)
with torch.no_grad(): # 在预测阶段不计算梯度
    new_data = torch.tensor([[0.2, 0.3], [0.8, 0.7]], dtype=torch.float32)
    logits_new = model(new_data)
    probabilities = torch.sigmoid(logits_new) # 手动应用sigmoid得到概率
    predictions = (probabilities > 0.5).float() # 应用阈值得到类别
    print(f"\nNew data: {new_data.numpy()}")
    print(f"Logits: {logits_new.numpy().flatten()}")
    print(f"Probabilities: {probabilities.numpy().flatten()}")
    print(f"Predictions (threshold 0.5): {predictions.numpy().flatten()}")

好的，我们来把对支持向量机 (SVM)、决策树 (Decision Trees) 和随机森林 (Random Forest) 的通俗易懂的例子和它们的核心技术点结合起来介绍。

支持向量机 (Support Vector Machine, SVM)

通俗例子： 想象你面前有一堆混在一起的黑豆和白豆，你需要画一条线，把它们尽可能完美地分开。

简单情况（线性可分）： 如果黑豆和白豆泾渭分明，你可以很容易地在它们之间画一条直线。SVM 的目标是找到那条**“最安全”的线，这条线位于黑豆和白豆之间的“街道”的正中央**，并且这条“街道”要尽可能宽。那些离“街道”边缘最近的豆子就是**“支持向量”**，它们“支撑”着这条街道的边界。
复杂情况（线性不可分 - 核技巧）： 如果黑豆和白豆混在一起像太极图，一条直线分不开。SVM 的核技巧就像你把豆子倒在一块有弹性的桌布上，猛地一拍桌布底部，豆子飞到空中。在空中的某个瞬间，你发现它们在某个平面上被分开了！核函数就是帮助我们完成这个“升维打击”并找到分隔面的巧妙方法，而无需真的去计算豆子在空中的具体位置。

结合技术点：

核心思想：
- 在特征空间中找到一个能够将不同类别的数据点最大程度地分开的决策边界（超平面）。
- “最大程度地分开”指的是这个超平面与两边最近的数据点（即支持向量）之间的间隔 (margin) 最大化。
数学表示 (简化版 SVC):
- 决策边界: w · x + b = 0
- 间隔: 2 / ||w||
- 优化目标 (软间隔): 最小化 (1/2) * ||w||² + C * Σξᵢ (其中 C 是正则化参数，ξᵢ 是松弛变量，允许一些点被错分或在间隔内)。
- 核技巧: 使用核函数 K(xᵢ, xⱼ) (如RBF核、多项式核) 隐式地将数据映射到更高维空间，使其线性可分。
求解方式： 这是一个凸二次规划问题，常用序列最小最优化 (SMO) 算法求解。
目的/用途：
- 主要用于分类 (SVC)，也可用于回归 (SVR)。
- 在高维空间中表现良好，尤其当特征维度大于样本数时。
- 文本分类、图像识别（早期）、生物信息学等。

一句话总结例子与技术： SVM 就像找一条最宽的“街道”（最大化间隔 2/||w||）来分隔两类物体（如黑豆白豆），如果直接分不开，就用“核技巧”（如拍桌布）把它们“扔到高维空间”再找分隔面（超平面 w · x + b = 0）。

决策树 (Decision Tree)

通俗例子： 你在玩一个**“猜动物”的游戏**，或者像一个经验丰富的医生诊断病情。

你会问一系列问题，每个问题都有几个固定的答案（例如“是”或“否”）。
第一个问题（根节点）： “这个动物会飞吗？”
根据回答进入下一个分支： 如果“会飞”，下一个问题可能是：“它是鸟类吗？”
就这样一步步问下去，直到最后能确定是什么动物（叶节点）。整个提问和回答的过程画出来就像一棵倒过来的树。

结合技术点：

核心思想：
- 构建一个树状结构模型，每个内部节点代表对一个特征的“测试”，每个分支代表测试的一个结果，每个叶节点代表一个类别标签（分类树）或一个连续值（回归树）。
- 通过一系列的 if-then-else 规则进行决策。
数学表示 (概念性):
- 不是单一数学方程，而是规则集。
- 分裂标准：
  - 分类树：基尼不纯度 (Gini Impurity) 或 信息增益 (Information Gain - 基于熵)，选择能使子节点“更纯净”的分裂。
  - 回归树：均方误差 (Mean Squared Error, MSE)，选择能使子节点预测值方差最小的分裂。
求解方式 (训练过程)：
- 采用贪心算法，自顶向下递归地选择最佳分裂特征和分割点来构建树。
- 通常需要剪枝 (Pruning)（预剪枝或后剪枝）来防止过拟合。
目的/用途：
- 分类和回归任务。
- 模型具有很好的可解释性，决策路径清晰可见。
- 特征重要性评估。

一句话总结例子与技术： 决策树就像玩“猜动物”游戏，通过一系列“if-then-else”判断（基于基尼不纯度或信息增益等分裂标准选择最佳问题）逐步缩小范围，最终得到结论。

随机森林 (Random Forest)

通俗例子： 你生病了，不放心只听一个医生的诊断，于是你决定咨询一大群医生（比如100位），组成一个专家会诊团。

“随机”之一 (数据随机性 - 每个医生看的病历略有不同)： 给每位医生看的病历资料都是从你总的病历中随机抽取的一部分（有放回抽样，即Bootstrap采样）。
“随机”之二 (特征随机性 - 每个医生提问的侧重点不同)： 每位医生在诊断（构建自己的“问题树”）时，在思考每一个问题（如“是病毒感染还是细菌感染？”）时，只从一部分随机选出的病症（特征）中去挑选最有区分度的那个来提问。
集体决策 (投票)： 每一位医生（每一棵决策树）都给出一个诊断结果。最后，大家投票决定最终结果（分类）或取平均值（回归）。

结合技术点：

核心思想：
- 一种集成学习 (Ensemble Learning) 方法，属于 Bagging (Bootstrap Aggregating) 的扩展。
- 通过构建多棵决策树并在它们的预测结果上进行**多数投票（分类）或平均（回归）**来做出最终决策。
- 核心在于引入随机性（行抽样和列抽样）来确保各个基学习器（决策树）之间的差异性，从而减少整体模型的方差并提高泛化能力。
数学表示 (概念性):
- 分类: ŷ_rf = mode {T₁(x), T₂(x), ..., T_K(x)}
- 回归: ŷ_rf = (1/K) * Σ Tᵢ(x)
求解方式 (训练过程)：
1. 对每棵树进行Bootstrap采样得到训练子集。
2. 训练每棵决策树时，在每个节点分裂时，从所有特征中随机选择一个子集，然后在这个子集中选择最佳分裂特征。
3. 通常让决策树生长到最大深度，不进行剪枝（集成效应能抵抗过拟合）。
目的/用途：
- 高性能的分类和回归。
- 特征重要性评估。
- 鲁棒性强，不易过拟合。

一句话总结例子与技术： 随机森林就像组织一个“专家会诊团”（多棵决策树），每个“医生”（决策树）看的“病历”（Bootstrap抽样的数据）和“关注的症状”（随机选择的特征子集）都略有不同，最后集体“投票”（或取平均）得出诊断结果，以提高准确性和稳定性。

好的，我们继续按照之前的标准来介绍 K-近邻 (KNN)、K-均值 (K-Means) 和主成分分析 (PCA)。

K-近邻 (K-Nearest Neighbors, KNN)

通俗例子： 想象你要判断一个新搬来的邻居是喜欢安静还是喜欢热闹。

找K个最近的邻居： 你会看看离他家最近的 K 户邻居（比如 K=5）。
看邻居的特点： 你发现这5户邻居里，有4户非常安静，1户比较热闹。
做判断： 你大概率会认为这个新邻居也喜欢安静，因为他的“朋友圈”（最近的邻居）大部分是安静的。

KNN 就是这样，根据一个新样本点周围 K 个已知类别邻居的“多数意见”来决定这个新样本点的类别。如果是回归问题，就取 K 个邻居的平均值。

结合技术点：

核心思想 (Core Idea):
- “物以类聚，人以群分”。一个样本的类别由其在特征空间中最接近的 K 个邻居的类别决定。
- 这是一种基于实例的学习 (Instance-based learning) 或懒惰学习 (Lazy learning) 方法，因为它不从训练数据中学习一个明确的判别函数，而是将所有训练实例存储起来，直到需要预测时才进行计算。
数学表示 (Mathematical Representation):
- 没有显式的模型训练过程来学习参数 w 和 b。
- 关键在于距离度量，常用的有：
  - 欧氏距离 (Euclidean Distance): d(x, y) = √Σ(xᵢ - yᵢ)² (最常用)
  - 曼哈顿距离 (Manhattan Distance): d(x, y) = Σ|xᵢ - yᵢ|
  - 闵可夫斯基距离 (Minkowski Distance): d(x, y) = (Σ|xᵢ - yᵢ|ᵖ)^(1/p) (欧氏是p=2, 曼哈顿是p=1)
- 决策规则:
  - 分类: 新样本的类别是其 K 个最近邻中出现次数最多的类别（多数投票）。
  - 回归: 新样本的预测值是其 K 个最近邻的目标值的平均值或加权平均值。
求解方式 / "训练"与预测过程 ("Solution Method" / "Training" & Prediction):
- "训练"阶段: 非常简单，仅仅是存储所有训练数据点及其标签。没有模型参数需要学习。
- 预测阶段 (对于一个新样本):
  1. 计算新样本与训练集中所有样本之间的距离。
  2. 找出距离最近的 K 个训练样本（即K个近邻）。
  3. 根据这 K 个近邻的标签进行多数投票（分类）或计算平均值（回归）作为新样本的预测结果。
目的/用途 (Purpose / Use Cases):
- 分类任务: 邮件过滤（判断是否垃圾邮件）、图像识别（识别手写数字）。
- 回归任务: 预测房价（根据相似房产的价格）。
- 推荐系统（找到与用户兴趣相似的其他用户或物品）。

K-均值 (K-Means Clustering)

通俗例子： 想象你有一大堆五颜六色的糖果，你想把它们分成 K 堆（比如 K=3），让每一堆里的糖果颜色尽可能相似。

随机选K个中心点： 你先随便从糖果堆里抓出3颗糖果，作为初始的3个“颜色中心”。
分配糖果： 把剩下的每一颗糖果都放到离它颜色最近的那个“颜色中心”所代表的堆里。
重新计算中心点： 对于每一堆糖果，计算这堆糖果的“平均颜色”，这个“平均颜色”就成了新的“颜色中心”。
重复： 不断重复第2步和第3步（把糖果分给最近的中心，然后更新中心），直到每次移动糖果后，“颜色中心”的位置基本不再变化为止。

K-Means 就是这样，通过迭代找到 K 个簇的中心，使得每个数据点都属于离它最近的那个中心所代表的簇。

结合技术点：

核心思想 (Core Idea):
- 一种无监督学习的聚类算法。
- 目标是将 N 个数据点划分到预先指定的 K 个簇 (cluster) 中，使得每个数据点都属于离它最近的均值（簇中心或质心, centroid）所对应的簇。
- 通过迭代优化，最小化每个簇内数据点到其质心的距离平方和 (WCSS - Within-Cluster Sum of Squares，也叫惯性 Inertia)。
数学表示 (Mathematical Representation):
- 目标函数 (最小化WCSS): J = Σ_{j=1}^{K} Σ_{xᵢ ∈ Cⱼ} ||xᵢ - μⱼ||²
  - K: 簇的数量。
  - Cⱼ: 第 j 个簇。
  - xᵢ: 第 i 个数据点。
  - μⱼ: 第 j 个簇的质心 (该簇内所有点的均值)。
  - ||xᵢ - μⱼ||²: 数据点 xᵢ 到其所属簇质心 μⱼ 的欧氏距离的平方。
求解方式 / 训练过程 (Lloyd's Algorithm):
1. 初始化 (Initialization): 随机选择 K 个数据点作为初始的簇质心 μ₁, μ₂, ..., μK。 (或者使用 K-Means++ 等更智能的初始化方法)
2. 分配步骤 (Assignment Step): 对于每个数据点 xᵢ，计算它到每个质心 μⱼ 的距离，并将其分配给距离最近的质心所代表的簇 Cⱼ。 Cⱼ = {xᵢ : ||xᵢ - μⱼ||² ≤ ||xᵢ - μₗ||² for all l=1,...,K}
3. 更新步骤 (Update Step): 对于每个簇 Cⱼ，重新计算其质心 μⱼ 为该簇内所有数据点的均值。 μⱼ = (1 / |Cⱼ|) * Σ_{xᵢ ∈ Cⱼ} xᵢ
4. 迭代 (Iteration): 重复步骤2和步骤3，直到簇的分配不再发生变化，或者质心的变化小于某个阈值，或者达到最大迭代次数。
目的/用途 (Purpose / Use Cases):
- 客户细分/市场划分: 根据购买行为、人口统计学等将客户分组。
- 文档聚类: 将相似主题的文档分组。
- 图像分割/压缩(向量量化): 将颜色相近的像素点聚类。
- 异常检测: 远离任何簇质心的数据点可能是异常点。
- 作为其他算法的预处理步骤。

主成分分析 (Principal Component Analysis, PCA)

通俗例子： 想象你用一个相机从不同角度给一个复杂的3D物体（比如一辆汽车）拍照。

高维数据： 物体的完整信息是3D的，甚至更多（材质、颜色细节等）。
降维： 你想用一张2D照片来尽可能多地展示这辆汽车的主要特征。
- 如果从汽车正前方或正侧方拍照，这张2D照片能保留很多关于汽车形状的信息。这些方向就是“主成分”方向，它们能最大程度地捕捉物体的“变化”或“信息”。
- 如果从车顶正上方斜着一个很小的角度拍照，照片可能大部分是车顶，很多侧面和前面的细节就丢失了。这个方向捕捉到的信息就少。

PCA 就是找到数据中“最重要”的几个方向（主成分），然后把数据投影到这些方向上，从而用更少的维度来表示原始数据，同时尽量保留原始数据中的主要信息（方差）。

结合技术点：

核心思想 (Core Idea):
- 一种无监督学习的降维技术。
- 目标是找到一组新的正交（互相垂直）坐标轴（称为主成分, Principal Components），使得数据在这些新轴上的投影方差最大化。
- 第一个主成分捕捉数据中最大的方差方向，第二个主成分捕捉与第一个正交方向上最大的剩余方差，以此类推。
- 通过保留方差最大的前 k 个主成分，可以将高维数据投影到低维子空间，同时最大限度地保留原始数据的信息。
数学表示 (Mathematical Representation):
- 目标: 找到一个变换矩阵 W，使得 Y = XW，其中 Y 是降维后的数据，X 是原始数据（通常已中心化）。W 的列是主成分（特征向量）。
- 主成分是原始数据协方差矩阵的特征向量 (eigenvectors)。
- 对应的特征值 (eigenvalues) 表示每个主成分所解释的方差大小。
- 步骤:
  1. 数据标准化/中心化: X_std = (X - mean(X)) / std(X) (或仅中心化 X_centered = X - mean(X)).
  2. 计算协方差矩阵: Cov(X_std) = (1/(n-1)) * X_stdᵀ * X_std.
  3. 对协方差矩阵进行特征值分解，得到特征值 λᵢ 和对应的特征向量 vᵢ。
  4. 将特征值从大到小排序，选择前 k 个最大的特征值对应的特征向量组成投影矩阵 W_k = [v₁, v₂, ..., v_k].
  5. 将原始数据投影到选定的主成分上: X_pca = X_std * W_k.
求解方式 / "训练"过程 ("Solution Method" / "Training"):
- "训练"过程就是上述计算协方差矩阵、进行特征值分解、并确定主成分（投影矩阵 W_k）的过程。
- 一旦 W_k 确定，就可以用它来转换新的数据。
目的/用途 (Purpose / Use Cases):
- 降维: 减少特征数量，简化模型，加速训练，缓解维度灾难。
- 数据可视化: 将高维数据降到2D或3D进行可视化观察。
- 噪声过滤: 较小方差的主成分可能对应噪声，去除它们可以起到去噪作用。
- 特征提取/特征工程: 生成一组新的、不相关的特征，用于后续的机器学习模型。
- 数据压缩。

数学基础

Python 基础

NumPy基础

Pandas基础

Scikit-learn基础

Matplotlib基础

机器学习的四大范式

机器学习算法

数据预处理

评估指标

深度学习基础

Pytorch

卷积神经网络CNN

基于LSTM的文本分类任务

循环神经网络RNN

自然语言处理 (NLP) 基础

Attention注意力机制

Transformer架构 (LLM的基石)

主流预训练模型

一个简单的预训练代码（了解流程即可）

预训练LLM的宏观流程

prompt工程

微调

机器学习算法

线性回归 (Linear Regression)

逻辑回归 (Logistic Regression)

支持向量机 (Support Vector Machine, SVM)

决策树 (Decision Tree)

随机森林 (Random Forest)

K-近邻 (K-Nearest Neighbors, KNN)

K-均值 (K-Means Clustering)

主成分分析 (Principal Component Analysis, PCA)