第零阶段：数学预备知识（初学者必读）

如果你高中数学还记得，可以快速浏览本节。如果已经忘了，请认真阅读——后面所有内容都建立在这些基础之上。

0.1 函数与映射 — 理解"模型"的本质

什么是函数？ 函数就是一个"规则"，给它一个输入，它返回一个输出。

$$f:X\to Y,y=f(x)$$

深度学习中的模型本质上就是一个复杂的函数：输入一张图片（像素矩阵），输出一个分类标签。

# 最简单的函数
def f(x):
    return 2 * x + 1

# 神经网络也是函数，只是更复杂
# model(image) → "猫" or "狗"

常见函数类型

函数类型	公式	图形	在 AI 中的用途
线性函数	$y=kx+b$	直线	线性回归、全连接层
二次函数	$y=a{x}^2+bx+c$	抛物线	损失函数的局部形状
指数函数	$y=e^x$	快速增长	Softmax、概率计算
对数函数	$y=\ln (x)$	缓慢增长	交叉熵损失、信息量
三角函数	$y=\sin (x)$	波形	位置编码

复合函数 — 深度网络的数学本质

深度网络就是多个简单函数的嵌套组合：

$$\text{output}=f_3(f_2(f_1(\text{input})))$$

# 三层网络 = 三个函数嵌套
def layer1(x): return relu(W1 @ x + b1)
def layer2(x): return relu(W2 @ x + b2)
def layer3(x): return softmax(W3 @ x + b3)

# 前向传播 = 函数复合
output = layer3(layer2(layer1(input)))

0.2 导数与梯度 — 理解"学习"的本质

导数的直觉

导数 = 变化率 = 斜率。它告诉你：如果输入变化一点点，输出会变化多少？

$$f^{\prime }(x)=\underset{\mathrm{\Delta }x\to 0}{lim}\frac{f(x+\mathrm{\Delta }x)-f(x)}{\mathrm{\Delta }x}$$

直觉理解：

• 导数 > 0：函数在上升（往右走会变大）
• 导数 < 0：函数在下降（往右走会变小）
• 导数 = 0：函数在极值点（山顶或谷底）

# 数值求导（最直观的理解）
def numerical_derivative(f, x, h=1e-7):
    """导数 ≈ (f(x+h) - f(x)) / h"""
    return (f(x + h) - f(x)) / h

# 示例
import math
f = lambda x: x**2  # f(x) = x²
print(numerical_derivative(f, 3))  # ≈ 6.0 (因为 f'(x) = 2x)

常用导数公式

函数 $f(x)$	导数 $f^{\prime }(x)$	记忆技巧
$x^n$	$n{x}^{n-1}$	指数下来乘，指数减一
$e^x$	$e^x$	自己的导数是自己
$\ln (x)$	$1/x$	对数的导数是倒数
$\sin (x)$	$\cos (x)$	sin → cos
$\cos (x)$	$-\sin (x)$	cos → -sin

链式法则 — 反向传播的数学基础

如果 $y=f(g(x))$，那么：

$$\frac{dy}{dx}=\frac{dy}{dg}\cdot \frac{dg}{dx}$$

这就是反向传播的全部数学原理！ 深度网络的每一层都是一个函数，链式法则让我们能从输出一层层往回算梯度。

# 链式法则示例
# y = (2x + 1)^3
# 令 u = 2x + 1, y = u^3
# dy/dx = dy/du * du/dx = 3u^2 * 2 = 6(2x+1)^2

# 在神经网络中：
# loss = CrossEntropy(Softmax(W3 @ ReLU(W2 @ ReLU(W1 @ x))))
# 反向传播就是从外到内逐层应用链式法则

梯度 — 多变量的导数

当函数有多个输入时，对每个输入分别求导，组成一个向量就是梯度：

$$\mathrm{\nabla }f=[\frac{\partial f}{\partial x_1},\frac{\partial f}{\partial x_2},\dots ,\frac{\partial f}{\partial x_n}]$$

梯度的方向 = 函数增长最快的方向。所以"梯度下降"就是沿着梯度的反方向走，让损失函数变小。

import torch

# PyTorch 自动求梯度
x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)
y = (x ** 2).sum()  # y = x1² + x2² + x3²
y.backward()        # 自动计算梯度
print(x.grad)       # tensor([2., 4., 6.]) 即 [2x1, 2x2, 2x3]

0.3 求和符号与连乘符号

在 AI 论文中你会频繁看到 $\sum$ 和 $\prod$：

$$\sum _{i=1}^n{x}_i=x_1+x_2+\cdots +x_n$$$$\prod _{i=1}^n{x}_i=x_1\times x_2\times \cdots \times x_n$$

import numpy as np

x = np.array([1, 2, 3, 4, 5])

# 求和 Σ
total = np.sum(x)      # 15
mean = np.mean(x)      # 3.0 = Σx_i / n

# 连乘 Π
product = np.prod(x)   # 120

# 在概率中：联合概率 = 各独立事件概率的乘积
# P(A,B,C) = P(A) × P(B) × P(C)  (独立时)

0.4 指数与对数 — 概率计算的基础

为什么 AI 中到处都是 $e$ 和 $\ln$？

• $e^x$ (指数)：将任意实数映射到正数，用于 Softmax
• $\ln (x)$ (对数)：将乘法变成加法，数值更稳定

$$e^x>0\mathrm{\forall }x\in \mathbb{R}$$$$\ln (ab)=\ln (a)+\ln (b)\text{（乘法变加法，防止数值下溢）}$$

import numpy as np

# Softmax 用 exp 将任意数变成正数，再归一化为概率
def softmax(x):
    exp_x = np.exp(x - np.max(x))  # 减最大值防溢出
    return exp_x / exp_x.sum()

logits = np.array([2.0, 1.0, 0.1])
probs = softmax(logits)
print(probs)  # [0.659, 0.242, 0.099] 概率之和 = 1

# 交叉熵损失用 log
# loss = -Σ y_i * log(p_i)
# 为什么用 log？因为概率相乘容易下溢，取 log 变成相加

0.5 集合与概率基础

概率的直觉

概念	公式	直觉
概率	$P(A)\in [0,1]$	事件发生的可能性
条件概率	$P(A	B) = P(A \cap B) / P(B)$
贝叶斯定理	$P(A	B) = P(B
期望	$E[X]=\sum x_i\cdot P(x_i)$	平均值（加权平均）
方差	$\text{Var}(X)=E[(X-\mu {)}^2]$	数据的分散程度

import numpy as np

# 期望 = 加权平均
values = np.array([1, 2, 3, 4, 5, 6])  # 骰子
probs = np.array([1/6] * 6)             # 等概率
expectation = np.sum(values * probs)     # 3.5

# 方差 = 偏离均值的平方的期望
variance = np.sum((values - expectation)**2 * probs)  # 2.917

# 正态分布（高斯分布）— AI 中最常见的分布
# 初始化权重、噪声、VAE 的隐空间都用正态分布
samples = np.random.normal(mean=0, std=1, size=1000)

贝叶斯定理 — 机器学习的哲学基础

$$P(\text{模型}|\text{数据})=\frac{P(\text{数据}|\text{模型})\cdot P(\text{模型})}{P(\text{数据})}$$

• 后验 $P(\text{模型}|\text{数据})$：看到数据后，对模型的信念
• 似然 $P(\text{数据}|\text{模型})$：模型能多好地解释数据
• 先验 $P(\text{模型})$：没看到数据前，对模型的信念

---

🧭 学习导航

← 返回总览 | 下一阶段：math-programming →