AI 与机器学习入门学习笔记

从线性回归到 Transformer，系统理解机器学习与深度学习核心概念。每节配原理讲解、公式推导和代码示例。

1 · 机器学习概述

1.1 什么是机器学习

机器学习是让计算机从数据中自动学习规律，而不是人工编写规则。

Tom Mitchell 的经典定义：

如果某计算机程序在任务 T 上的性能 P 随经验 E 而提高，则称该程序从 E 中学习。

例如垃圾邮件过滤：

任务 T：判断邮件是否为垃圾邮件
经验 E：大量已标注的邮件
性能 P：分类准确率

1.2 三大范式

范式	数据	目标
监督学习	有标签	学习输入到输出的映射
无监督学习	无标签	发现数据内在结构
强化学习	奖励信号	学习最优决策序列

1.3 完整流程

问题定义
  ↓
数据收集
  ↓
数据清洗与预处理（缺失值、异常值、归一化）
  ↓
特征工程
  ↓
模型选择
  ↓
训练模型
  ↓
模型评估
  ↓
调参与优化
  ↓
部署与监控

1.4 数据集划分

训练集：模型学习参数
验证集：调超参数、早停
测试集：最终评估，只能用一次

为什么测试集只能用一次？

因为反复用测试集调参会泄露信息，导致对泛化能力的估计过于乐观。

K 折交叉验证：

把数据分成 K 份
每次用 K-1 份训练，1 份验证
最后取平均
适合数据量不大的场景

2 · 线性模型

2.1 线性回归

线性回归假设输出是输入特征的线性组合：

y = w₁x₁ + w₂x₂ + ... + wₙxₙ + b

向量形式：

ŷ = wᵀx + b

损失函数（MSE）：

L = (1/m) Σ(yᵢ - ŷᵢ)²

目标：找到 w 和 b，使得 L 最小。

Python 示例：

import numpy as np
from sklearn.linear_model import LinearRegression

X = np.array([[1], [2], [3], [4], [5]])
y = np.array([2.1, 4.0, 6.1, 7.9, 10.2])

model = LinearRegression()
model.fit(X, y)
print(f"w={model.coef_[0]:.2f}, b={model.intercept_:.2f}")

2.2 正则化

防止过拟合，在损失函数中加入惩罚项。

L1 正则（Lasso）：

L = MSE + λ Σ|wᵢ|

容易产生稀疏解，可用于特征选择

L2 正则（Ridge）：

L = MSE + λ Σwᵢ²

让权重变小，但不至于为零

Elastic Net：

L = MSE + λ₁ Σ|wᵢ| + λ₂ Σwᵢ²

2.3 逻辑回归

虽然叫"回归"，但用于分类。

Sigmoid 函数：

σ(z) = 1 / (1 + e^{-z})

输出概率：

P(y=1|x) = σ(wᵀx + b)

损失函数（交叉熵）：

L = -(1/m) Σ [yᵢ log(ŷᵢ) + (1-yᵢ) log(1-ŷᵢ)]

多分类用 Softmax：

P(y=i|x) = e^{zᵢ} / Σ e^{zⱼ}

2.4 梯度下降

梯度下降是训练大多数机器学习模型的基础。

核心思想：沿着损失函数梯度的反方向更新参数。

w := w - α · ∂L/∂w
b := b - α · ∂L/∂b

α 是学习率。

批量梯度下降（BGD）：

每次用全部样本计算梯度
稳定但慢

随机梯度下降（SGD）：

每次用一个样本
快但震荡

小批量梯度下降（Mini-batch）：

每次用一批样本（如 32、64、128）
实际最常用

学习率调度：

固定学习率
衰减：训练后期减小学习率
Warmup：训练初期逐渐增大

优化器：

Momentum：累积动量，加速收敛
AdaGrad：自适应学习率
RMSProp：解决 AdaGrad 学习率衰减过快
Adam：Momentum + RMSProp，最常用

from sklearn.linear_model import SGDClassifier

model = SGDClassifier(loss='log_loss', learning_rate='constant', eta0=0.01)
model.fit(X_train, y_train)

3 · 树模型与集成学习

3.1 决策树

决策树通过递归划分特征空间来做预测。

分裂准则：

信息增益（ID3）：选择使信息增益最大的特征
信息增益比（C4.5）：用信息增益除以特征自身的熵
基尼系数（CART）：

Gini = 1 - Σ pᵢ²

剪枝：

预剪枝：限制树深度、叶子最小样本数
后剪枝：生成完整树后再剪去不重要的分支

Python 示例：

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier(max_depth=5, min_samples_leaf=10)
model.fit(X_train, y_train)

3.2 随机森林

随机森林 = 多棵决策树 + Bagging。

Bagging（Bootstrap Aggregating）：

从原始数据中有放回地采样，生成多个子数据集
每个子数据集训练一棵树
最终投票或取平均

随机性来源：

样本随机（Bootstrap）
特征随机：每个节点分裂时只考虑部分特征

from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(n_estimators=100, max_depth=10)
model.fit(X_train, y_train)

3.3 梯度提升树

梯度提升树（GBDT）串行训练：每棵树拟合前一轮的残差。

代表算法：

XGBoost：二阶导数近似 + 正则化
LightGBM：直方图算法 + 叶子优先生长，速度快
CatBoost：原生处理类别特征

import xgboost as xgb

params = {
    'max_depth': 6,
    'eta': 0.1,
    'objective': 'binary:logistic',
    'eval_metric': 'auc'
}
dtrain = xgb.DMatrix(X_train, label=y_train)
model = xgb.train(params, dtrain, num_boost_round=100)

3.4 Bagging vs Boosting

特性	Bagging	Boosting
训练方式	并行	串行
样本权重	均匀	根据错误率调整
目标	降低方差	降低偏差
代表	随机森林	XGBoost、LightGBM
过拟合风险	低	中等（需调参）

4 · 支持向量机（SVM）

4.1 基本思想

SVM 寻找一个超平面，使得两类样本之间的间隔最大。

间隔最大的超平面称为"最优超平面"。

支持向量：离超平面最近的样本点，它们决定了超平面的位置。

4.2 核技巧

当数据线性不可分时，SVM 使用核函数把数据映射到高维空间。

常用核函数：

线性核：K(x, y) = xᵀy
多项式核：K(x, y) = (γ xᵀy + r)^d
RBF 核（高斯核）：K(x, y) = exp(-γ ||x-y||²)

核技巧的神奇之处在于：不需要显式计算高维映射，直接计算核函数即可。

4.3 Python 示例

from sklearn.svm import SVC

model = SVC(kernel='rbf', C=1.0, gamma='scale')
model.fit(X_train, y_train)

5 · 神经网络基础

5.1 感知机

感知机是最简单的神经网络单元。

output = σ(wᵀx + b)

单层感知机只能解决线性可分问题。 1958 年提出的感知机无法解决 XOR 问题，导致第一次 AI 寒冬。

5.2 多层感知机（MLP）

加入隐藏层后，MLP 可以拟合任意连续函数（万能近似定理）。

前向传播：

z = W·x + b
a = activation(z)

激活函数：

$图 1 \xb7 神经网络结构$

Sigmoid：输出 0~1，适合做概率
Tanh：输出 -1~1
ReLU：max(0, x)，计算简单，缓解梯度消失
Leaky ReLU：解决 ReLU 神经元死亡问题
GELU：Transformer 常用

5.3 反向传播

反向传播用链式法则计算梯度，从输出层向输入层传播。

假设损失函数 L，参数 W：

∂L/∂W = ∂L/∂a · ∂a/∂z · ∂z/∂W

Python 示例（PyTorch）：

import torch
import torch.nn as nn

model = nn.Sequential(
    nn.Linear(784, 128),
    nn.ReLU(),
    nn.Linear(128, 10)
)

criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

for epoch in range(10):
    outputs = model(inputs)
    loss = criterion(outputs, labels)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

5.4 过拟合与正则化

过拟合：训练集表现好，测试集表现差。 欠拟合：训练集都表现差。

防止过拟合：

L1/L2 正则化
Dropout：训练时随机丢弃神经元
早停（Early Stopping）：验证集 loss 不再下降时停止训练
数据增强：旋转、翻转、裁剪图像
Batch Normalization：稳定训练，有轻微正则效果

6 · 卷积神经网络（CNN）

6.1 卷积操作

卷积核在输入上滑动，做局部加权求和。

例如 3×3 卷积核：

1 0 -1
1 0 -1
1 0 -1

这个核可以检测垂直边缘。

6.2 CNN 核心组件

卷积层：提取局部特征
池化层：降维，保留主要特征
- Max Pooling：取窗口内最大值
- Average Pooling：取平均值
全连接层：最终分类

6.3 经典架构

网络	特点
LeNet-5	最早的 CNN，手写数字识别
AlexNet	2012 ImageNet 冠军，引入 ReLU + Dropout
VGG	反复堆叠 3×3 卷积
ResNet	残差连接，训练 152+ 层网络
Inception	多尺度并行卷积
MobileNet	深度可分离卷积，移动端友好

6.4 残差连接

ResNet 的核心：

output = F(x) + x

这样即使 F(x) 学习不到东西，网络也能保持恒等映射，缓解深层网络梯度消失问题。

6.5 PyTorch CNN 示例

import torch.nn as nn

class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 64 * 7 * 7)
        x = F.relu(self.fc1(x))
        return self.fc2(x)

7 · 循环神经网络与序列建模

7.1 RNN

RNN 处理序列数据，隐藏状态传递历史信息。

hₜ = tanh(Wₕhₜ₋₁ + Wₓxₜ + b)

问题：长序列导致梯度消失/爆炸，难以记住久远信息。

7.2 LSTM

LSTM 通过门控机制控制信息流动。

三个门：

遗忘门：决定丢弃哪些旧信息
输入门：决定加入哪些新信息
输出门：决定输出什么

7.3 GRU

GRU 是 LSTM 的简化版，只有两个门：

更新门
重置门

效果接近 LSTM，但参数量更少。

7.4 应用

文本生成
机器翻译（已被 Transformer 取代）
语音识别
时间序列预测

8 · Transformer 与大模型

8.1 Self-Attention

Self-Attention 让模型在处理一个 token 时，能够关注输入序列中的所有位置。

计算 Query、Key、Value：

Q = XW_Q
K = XW_K
V = XW_V

Attention(Q, K, V) = softmax(QKᵀ / √dₖ) V

除以 √dₖ 是为了防止点积结果过大，导致 softmax 梯度消失。

8.2 Multi-Head Attention

把 Q/K/V 投影到多个子空间，分别做 Attention，再拼接。

MultiHead(Q, K, V) = Concat(head₁, ..., headₕ) W_O

不同 head 可以关注不同的信息：语法、语义、指代等。

8.3 Transformer 架构

Encoder：

Multi-Head Self-Attention
Feed-Forward Network
LayerNorm + 残差连接

Decoder：

Masked Multi-Head Self-Attention
Cross Attention（关注 Encoder 输出）
Feed-Forward Network

8.4 预训练模型

BERT（Encoder-only）：

理解类任务：分类、命名实体识别、问答
训练任务：Masked Language Model + Next Sentence Prediction

GPT（Decoder-only）：

生成类任务：文本生成、代码生成
训练任务：自回归语言建模

T5（Encoder-Decoder）：

翻译、摘要、问答
把所有任务统一成 text-to-text 格式

8.5 大语言模型（LLM）

LLM 通常有数十亿到数千亿参数。

训练流程：

预训练：海量无标注文本，学习语言知识
SFT（监督微调）：用指令数据训练，让模型学会对话
RLHF（人类反馈强化学习）：让模型输出更符合人类偏好

推理优化：

KV Cache：缓存已生成 token 的 Key 和 Value
量化：FP32 → FP16 → INT8 → INT4
vLLM：PagedAttention 提高吞吐

9 · 模型部署与推理

9.1 模型导出

常见格式：

ONNX：跨框架通用格式
TorchScript：PyTorch 原生导出
TensorFlow SavedModel
TensorRT：NVIDIA 专用优化格式

9.2 推理框架

框架	特点
ONNX Runtime	跨平台，CPU/GPU
TensorRT	NVIDIA GPU 极致优化
OpenVINO	Intel 优化
vLLM	LLM 高吞吐
Ollama	本地运行 LLM

9.3 服务化

把模型包装成 HTTP/gRPC 服务：

from fastapi import FastAPI
import onnxruntime as ort

app = FastAPI()
session = ort.InferenceSession("model.onnx")

@app.post("/predict")
def predict(x: list):
    outputs = session.run(None, {"input": x})
    return {"result": outputs[0].tolist()}

9.4 模型优化

量化：INT8 / INT4，降低显存占用
剪枝：移除不重要的权重
知识蒸馏：用大模型教小模型
批处理：合并请求提高 GPU 利用率

本页目录

AI 与机器学习入门学习笔记#

1 · 机器学习概述#

1.1 什么是机器学习#

1.2 三大范式#

1.3 完整流程#

1.4 数据集划分#

2 · 线性模型#

2.1 线性回归#

2.2 正则化#

2.3 逻辑回归#

2.4 梯度下降#

3 · 树模型与集成学习#

3.1 决策树#

3.2 随机森林#

3.3 梯度提升树#

3.4 Bagging vs Boosting#

4 · 支持向量机（SVM）#

4.1 基本思想#

4.2 核技巧#

4.3 Python 示例#

5 · 神经网络基础#

5.1 感知机#

5.2 多层感知机（MLP）#

5.3 反向传播#

5.4 过拟合与正则化#

6 · 卷积神经网络（CNN）#

6.1 卷积操作#

6.2 CNN 核心组件#

6.3 经典架构#

6.4 残差连接#

6.5 PyTorch CNN 示例#

7 · 循环神经网络与序列建模#

7.1 RNN#

7.2 LSTM#

7.3 GRU#

7.4 应用#

8 · Transformer 与大模型#

8.1 Self-Attention#

8.2 Multi-Head Attention#

8.3 Transformer 架构#

8.4 预训练模型#

8.5 大语言模型（LLM）#

9 · 模型部署与推理#

9.1 模型导出#

9.2 推理框架#

9.3 服务化#

9.4 模型优化#