数学与编程基础

「数学是AI的语言,Python是AI的工具。掌握这两样,你就拥有了和AI对话的能力。」

阶段目标

这个阶段的目标很明确:

  1. 数学:掌握理解深度学习所需的数学基础——够用就行,不追求数学家水平
  2. 编程:掌握 Python 数据科学栈,能处理数据、实现算法

学完这个阶段,你将能够:

  • 读懂深度学习代码中的数学操作
  • 理解梯度下降背后的原理
  • 用 Python 实现基础的机器学习算法
  • 处理和分析真实数据

::: tip 💡 学习策略 不要先学完所有数学再学编程,也不要先学完编程再学数学。 两者交叉学习效果最好:学一点数学 → 用 Python 验证 → 再学更多数学。理论+实践交替进行。 :::


第一部分:数学基础

为什么 AI 需要数学?

数据 → 数学表示 → 数学运算 → AI模型 → 输出结果

具体来说:
  图片  →  数字矩阵  →  矩阵运算  →  神经网络  →  "这是一只猫"
  文本  →  词向量    →  向量运算  →  Transformer →  翻译结果

AI 的本质是用数学方法处理数据。你需要理解三块数学:

数学分支 在AI中的作用 类比
线性代数 表示和操作数据 AI 的"语言"
概率统计 处理不确定性 AI 的"判断力"
微积分 优化模型参数 AI 的"学习方式"

1. 线性代数

线性代数是 AI 最核心的数学基础。深度学习中几乎所有的计算都是矩阵运算。

1.1 标量、向量、矩阵、张量

标量(Scalar):一个数字
  例:x = 3.14

向量(Vector):一列数字
  例:v = [1, 2, 3]  (3维向量)

矩阵(Matrix):一个数字表格
  例:M = [[1, 2],
           [3, 4]]  (2×2矩阵)

张量(Tensor):多维数字数组
  例:一张彩色图片是 3维张量(高×宽×3个颜色通道)
  例:一批图片是 4维张量(批次×高×宽×3)

::: tip 💡 为什么叫"Tensor"? PyTorch 中的核心数据结构叫 Tensor(张量),就是这个概念。深度学习的计算本质上就是张量运算。 :::

1.2 向量运算

import numpy as np

# 向量加法
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a + b)  # [5, 7, 9]

# 向量点积(内积)—— AI中最常用的运算
print(np.dot(a, b))  # 1*4 + 2*5 + 3*6 = 32

# 向量的长度(范数)
print(np.linalg.norm(a))  # sqrt(1+4+9) ≈ 3.74

点积的直觉理解:两个向量的"相似度"。点积越大,方向越接近。这在 AI 中用于衡量相似性。

1.3 矩阵运算

A = np.array([[1, 2],
              [3, 4]])
B = np.array([[5, 6],
              [7, 8]])

# 矩阵加法
print(A + B)
# [[ 6,  8],
#  [10, 12]]

# 矩阵乘法 —— 最核心的运算
print(np.matmul(A, B))  # 或 A @ B
# [[1*5+2*7, 1*6+2*8],
#  [3*5+4*7, 3*6+4*8]]
# = [[19, 22],
#    [43, 50]]

# 矩阵转置
print(A.T)
# [[1, 3],
#  [2, 4]]

1.4 为什么矩阵乘法对 AI 如此重要?

神经网络的每一层计算:
  输出 = 激活函数(权重矩阵 × 输入向量 + 偏置)

具体来说:
  输入 x:一个向量(比如100维)
  权重 W:一个矩阵(比如 256×100)
  输出 y = W × x:一个新向量(256维)

一层神经网络 = 一次矩阵乘法 + 一次激活函数
多层神经网络 = 多次矩阵乘法的叠加

::: tip 💡 关键洞察 神经网络的"前向传播"本质上就是一连串的矩阵乘法。 理解了矩阵乘法,你就理解了神经网络最基本的计算过程。 :::

1.5 线性代数核心概念速查表

概念 说明 AI 中的用途
向量 一列数字 表示数据特征、模型参数
矩阵 数字表格 表示权重、批量数据
张量 多维数组 深度学习的通用数据结构
矩阵乘法 两个矩阵相乘 神经网络层的计算
转置 行列互换 计算梯度、调整维度
点积 向量对应元素乘积之和 计算相似度、注意力
范数 向量的"长度" 正则化、衡量模型复杂度

2. 概率统计

AI 处理的是不确定的世界。概率统计帮助我们量化不确定性、做出合理判断。

2.1 基本概念

概率:某件事发生的可能性,范围 0 到 1。

P(下雨) = 0.3  → 30% 的概率下雨
P(不下雨) = 0.7 → 70% 的概率不下雨

随机变量:取值不确定的变量。

X = 明天的天气 → 可能是"晴"、"阴"、"雨"
Y = 骰子的点数 → 可能是 1, 2, 3, 4, 5, 6

2.2 概率分布

分布描述随机变量取各种值的可能性。

分布 说明 AI 中的例子
均匀分布 所有值概率相等 随机初始化模型参数
正态分布 钟形曲线,中间多两头少 权重初始化、噪声建模
伯努利分布 0或1,抛硬币 二分类模型的输出
import numpy as np
import matplotlib.pyplot as plt

# 正态分布
data = np.random.normal(loc=0, scale=1, size=10000)  # 均值0,标准差1
plt.hist(data, bins=50)
plt.title("正态分布")
plt.show()

2.3 贝叶斯定理

贝叶斯定理是概率统计中最重要的公式之一。

P(A|B) = P(B|A) × P(A) / P(B)

含义:在B发生的前提下,A发生的概率

举例:
  A = 患病
  B = 检测阳性

  P(患病|检测阳性) = P(检测阳性|患病) × P(患病) / P(检测阳性)
                   = 0.99 × 0.001 / 0.02   (P(检测阳性)=0.02 为假设值,含假阳性等其他来源)
                   = 0.0495 ≈ 5%

  即使检测准确率99%,因为患病率很低,阳性结果也只意味着5%的患病概率!

::: tip 💡 为什么这在 AI 中重要? 很多 AI 问题本质上就是在观测到数据后,更新对世界的认知。贝叶斯定理就是这种"更新认知"的数学基础。虽然现代深度学习不直接用贝叶斯公式,但其思想渗透在 AI 的方方面面。 :::

2.4 期望与方差

期望(Expectation):随机变量的"平均值"
  类比:如果你重复无数次实验,结果的平均趋势

方差(Variance):随机变量偏离期望的程度
  类比:结果的"波动大小"

标准差(Standard Deviation):方差的平方根
data = np.random.normal(0, 1, 100000)

print(f"期望(均值): {np.mean(data):.4f}")      # ≈ 0
print(f"方差: {np.var(data):.4f}")                # ≈ 1
print(f"标准差: {np.std(data):.4f}")              # ≈ 1

在 AI 中,期望和方差用于:

  • 损失函数:最小化预测误差的期望
  • Batch Normalization:标准化数据分布,加速训练
  • 评估模型:用方差衡量预测的稳定性

2.5 概率统计核心概念速查表

概念 说明 AI 中的用途
概率 事件发生的可能性 模型输出预测概率
分布 随机变量的取值规律 数据建模、参数初始化
贝叶斯定理 更新概率认知 分类、不确定性建模
期望 平均值 损失函数定义
方差/标准差 波动程度 评估稳定性、正则化
条件概率 在某条件下发生的概率 序列预测、注意力机制

3. 微积分

微积分是 AI "学习"的数学基础。训练模型的过程就是用微积分找最优解。

3.1 导数

导数描述函数在某点的变化率。

函数 f(x) = x²
导数 f'(x) = 2x

含义:在 x=3 处,f 的变化量约为 x 变化量的 2×3=6 倍
import numpy as np

# 数值导数
def numerical_derivative(f, x, h=1e-5):
    return (f(x + h) - f(x - h)) / (2 * h)

f = lambda x: x ** 2
print(numerical_derivative(f, 3))  # ≈ 6.0

直觉理解:导数告诉你"往哪个方向走,函数值会增加/减少"。

3.2 偏导数与梯度

当函数有多个变量时,需要偏导数。

函数 f(x, y) = x² + y²
  对 x 的偏导数:∂f/∂x = 2x  (把 y 当常数)
  对 y 的偏导数:∂f/∂y = 2y  (把 x 当常数)

梯度 = (∂f/∂x, ∂f/∂y) = (2x, 2y)

梯度(Gradient):所有偏导数组成的向量,指向函数值上升最快的方向。

梯度上升:沿着梯度方向走 → 函数值增大
梯度下降:沿着梯度反方向走 → 函数值减小 ← 这是AI训练的核心!

3.3 梯度下降

梯度下降是 AI 训练最核心的优化算法。

目标:找到让损失函数最小的参数值

算法:
1. 随机初始化参数
2. 计算当前参数下的梯度
3. 沿着梯度反方向更新参数:参数 = 参数 - 学习率 × 梯度
4. 重复步骤 2-3,直到收敛

类比:蒙着眼睛下山
  你看不到全貌,但能感知脚下的坡度(梯度)
  每次朝着最陡的下坡方向走一步
  最终走到谷底(最优解)
import numpy as np

# 梯度下降示例:最小化 f(x) = x²
x = 10.0          # 初始值
lr = 0.1          # 学习率
for i in range(100):
    grad = 2 * x  # f(x) = x² 的导数
    x = x - lr * grad  # 梯度下降
    if i % 20 == 0:
        print(f"第{i}步: x = {x:.6f}")

print(f"最终结果: x = {x:.6f}")  # 趋近于 0

3.4 链式法则与反向传播

链式法则是微积分中处理复合函数求导的规则,它是反向传播的数学基础。

复合函数:y = f(g(x))

链式法则:dy/dx = (dy/dg) × (dg/dx)

举例:
  g = x²
  f = g + 1   →  f(g(x)) = x² + 1
  
  df/dx = (df/dg) × (dg/dx) = 1 × 2x = 2x

为什么这对深度学习至关重要?

神经网络就是嵌套的复合函数:

  输入 x
    → 第1层: h1 = f1(W1·x + b1)
    → 第2层: h2 = f2(W2·h1 + b2)
    → 第3层: 输出 = f3(W3·h2 + b3)
    → 损失: L = loss(输出, 真实标签)

要更新 W1 的参数,需要计算 dL/dW1
根据链式法则:
  dL/dW1 = dL/d输出 × d输出/dh2 × dh2/dh1 × dh1/dW1

这就是"反向传播"——从损失开始,反向逐层计算梯度。

::: tip 💡 一句话总结 反向传播 = 链式法则在神经网络上的应用。 PyTorch 的"自动求导"(autograd)就是自动帮你做链式法则的计算。 :::

3.5 微积分核心概念速查表

概念 说明 AI 中的用途
导数 函数变化率 衡量参数对损失的影响
偏导数 多变量函数的变化率 计算每个参数的梯度
梯度 所有偏导数组成的向量 指示优化方向
梯度下降 沿梯度反方向更新参数 训练模型的核心算法
链式法则 复合函数求导 反向传播的数学基础
学习率 每次更新的步长 控制训练速度和稳定性

第二部分:编程基础

Python:AI 时代的通用语言

Python 是 AI 领域的绝对主流语言。原因很简单:

为什么是 Python?
1. 语法简洁 → 专注算法逻辑,不纠结语法
2. 生态丰富 → NumPy/Pandas/PyTorch... 无所不包
3. 社区庞大 → 遇到问题总能找到答案
4. AI 框架首选 → 几乎所有主流框架都支持 Python

Python 入门学习路径

如果你已经会 Python,可以跳过这一节。

基础语法(1-2 周)

需要掌握的核心概念:

# 1. 变量与数据类型
name = "AI"           # 字符串
year = 2024           # 整数
pi = 3.14159          # 浮点数
is_ai = True          # 布尔值

# 2. 数据结构
my_list = [1, 2, 3]                    # 列表
my_dict = {"name": "Alice", "age": 25} # 字典
my_tuple = (1, 2, 3)                   # 元组
my_set = {1, 2, 3}                     # 集合

# 3. 控制流
if score >= 90:
    grade = "A"
elif score >= 60:
    grade = "B"
else:
    grade = "C"

for i in range(5):
    print(i)

# 4. 函数
def compute_loss(predictions, labels):
    """计算均方误差损失"""
    return ((predictions - labels) ** 2).mean()

# 5. 类(面向对象)
class NeuralLayer:
    def __init__(self, in_features, out_features):
        self.weight = np.random.randn(out_features, in_features)
        self.bias = np.zeros(out_features)
    
    def forward(self, x):
        return np.matmul(x, self.weight.T) + self.bias

推荐学习资源

资源 说明
Python 官方教程 最权威的入门教程
《Python编程:从入门到实践》 适合零基础
廖雪峰 Python 教程 中文,简洁实用
B站 Python 入门视频 视频学习更直观

NumPy:数值计算基石

NumPy 是 Python 科学计算的基石,几乎所有 AI 框架的底层都基于 NumPy 或类似设计。

核心概念

import numpy as np

# 1. 创建数组
a = np.array([1, 2, 3, 4, 5])           # 一维数组
b = np.array([[1, 2], [3, 4]])           # 二维数组
c = np.zeros((3, 4))                     # 全零矩阵
d = np.random.randn(2, 3)               # 随机矩阵(正态分布)

# 2. 数组属性
print(a.shape)    # (5,)  形状
print(b.ndim)     # 2     维度
print(b.size)     # 4     元素总数
print(b.dtype)    # int64 数据类型

# 3. 数组运算(逐元素)
x = np.array([1, 2, 3])
y = np.array([4, 5, 6])
print(x + y)    # [5, 7, 9]
print(x * y)    # [4, 10, 18]  逐元素乘法
print(x ** 2)   # [1, 4, 9]

广播机制(Broadcasting)

广播是 NumPy 最强大也最容易困惑的特性。

规则:当两个数组形状不同时,NumPy 会自动"扩展"较小的数组

例1:数组 + 标量
  [1, 2, 3] + 10  →  [11, 12, 13]
  标量 10 被"广播"到每个元素

例2:矩阵 + 向量
  [[1, 2, 3],     [10, 20, 30]     [[11, 22, 33],
   [4, 5, 6]]  +               →    [14, 25, 36]]
   
  向量 [10, 20, 30] 被广播到矩阵的每一行
# 广播示例
matrix = np.array([[1, 2, 3],
                    [4, 5, 6]])
vector = np.array([10, 20, 30])

print(matrix + vector)
# [[11, 22, 33],
#  [14, 25, 36]]

# 这在深度学习中非常常见:
# 比如给一个 batch 的数据都加上同一个偏置向量

::: warning ⚠️ 注意 广播机制非常方便,但也容易隐藏 bug。当你遇到维度不匹配的错误时,首先要检查的就是广播是否符合预期。 :::

索引与切片

a = np.array([[1, 2, 3, 4],
              [5, 6, 7, 8],
              [9, 10, 11, 12]])

# 基本索引
print(a[0])        # [1, 2, 3, 4]  第一行
print(a[0, 1])     # 2  第一行第二列

# 切片
print(a[:, 0])     # [1, 5, 9]  所有行的第一列
print(a[0:2, 1:3]) # [[2, 3], [6, 7]]  前两行,第2-3列

# 布尔索引
mask = a > 5
print(a[mask])     # [6, 7, 8, 9, 10, 11, 12]  所有大于5的元素

数组操作常用函数

# 改变形状
a = np.arange(12)
print(a.reshape(3, 4))   # 变成 3×4 矩阵

# 拼接
x = np.array([[1, 2], [3, 4]])
y = np.array([[5, 6]])
print(np.concatenate([x, y], axis=0))  # 按行拼接

# 统计
print(a.sum())       # 总和
print(a.mean())      # 均值
print(a.max())       # 最大值
print(a.std())       # 标准差

Pandas:数据处理利器

Pandas 是处理表格数据的最佳工具。在 AI 工作中,你经常需要处理 CSV、Excel 等格式的数据。

核心数据结构

import pandas as pd

# DataFrame —— 类似Excel表格
data = {
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'score': [90, 85, 78]
}
df = pd.DataFrame(data)
print(df)
#       name  age  score
# 0    Alice   25     90
# 1      Bob   30     85
# 2  Charlie   35     78

数据读取与保存

# 读取 CSV
df = pd.read_csv('data.csv')

# 读取 Excel
df = pd.read_excel('data.xlsx')

# 保存
df.to_csv('output.csv', index=False)

数据探索

# 查看前几行
print(df.head())

# 查看数据信息
print(df.info())

# 统计描述
print(df.describe())

# 筛选数据
young = df[df['age'] < 30]

# 排序
sorted_df = df.sort_values('score', ascending=False)

# 分组统计
print(df.groupby('age')['score'].mean())

数据清洗

# 处理缺失值
df.fillna(0, inplace=True)          # 用 0 填充
df.dropna(inplace=True)             # 删除有缺失的行

# 去重
df.drop_duplicates(inplace=True)

# 类型转换
df['age'] = df['age'].astype(float)

::: tip 💡 实际应用 在实际 AI 项目中,数据清洗和预处理占工作量的 60-80%。熟练使用 Pandas 能极大提高你的工作效率。 :::


Matplotlib:数据可视化

可视化是理解数据的重要手段。Matplotlib 是 Python 最基础的可视化库。

import matplotlib.pyplot as plt
import numpy as np

# 折线图
x = np.linspace(0, 10, 100)
y = np.sin(x)
plt.figure(figsize=(8, 4))
plt.plot(x, y, label='sin(x)')
plt.xlabel('x')
plt.ylabel('y')
plt.title('正弦函数')
plt.legend()
plt.grid(True)
plt.show()

# 散点图
x = np.random.randn(100)
y = x * 2 + np.random.randn(100) * 0.5
plt.scatter(x, y, alpha=0.5)
plt.xlabel('x')
plt.ylabel('y')
plt.title('散点图')
plt.show()

# 直方图
data = np.random.normal(0, 1, 1000)
plt.hist(data, bins=30, edgecolor='black')
plt.title('数据分布')
plt.show()

# 子图
fig, axes = plt.subplots(1, 2, figsize=(12, 4))
axes[0].plot(x, np.sin(x))
axes[0].set_title('sin(x)')
axes[1].plot(x, np.cos(x))
axes[1].set_title('cos(x)')
plt.show()

::: tip 💡 进阶推荐 Matplotlib 是基础,如果你想要更美观的图表,可以学习:

  • Seaborn:基于 Matplotlib,统计图表更美观
  • Plotly:交互式图表
  • TensorBoard / Weights & Biases:训练过程可视化(后面阶段会用到) :::

第三部分:实战项目

用 Python 从零实现线性回归

这是你第一个完整的 AI 项目。不用任何框架,纯 NumPy 实现线性回归——同时检验你的数学和编程基础。

问题定义

给定一组数据点 (x, y),找到一条直线 y = w·x + b
使得这条直线尽可能"拟合"这些数据点

这就是线性回归:最简单的机器学习算法

完整代码

import numpy as np
import matplotlib.pyplot as plt

# ============================================================
# 第一步:生成模拟数据
# ============================================================
np.random.seed(42)
n_samples = 100

# 真实的关系:y = 3x + 2 + 噪声
X = np.random.uniform(-5, 5, n_samples)
true_w, true_b = 3.0, 2.0
noise = np.random.randn(n_samples) * 2.0
y = true_w * X + true_b + noise

print(f"真实参数: w={true_w}, b={true_b}")
print(f"数据量: {n_samples} 个样本")

# ============================================================
# 第二步:初始化模型参数
# ============================================================
w = np.random.randn()  # 随机初始化权重
b = np.random.randn()  # 随机初始化偏置
print(f"\n初始参数: w={w:.4f}, b={b:.4f}")

# ============================================================
# 第三步:定义损失函数(均方误差 MSE)
# ============================================================
def compute_loss(X, y, w, b):
    """均方误差损失"""
    predictions = w * X + b
    loss = np.mean((predictions - y) ** 2)
    return loss

# ============================================================
# 第四步:定义梯度计算
# ============================================================
def compute_gradients(X, y, w, b):
    """计算损失对 w 和 b 的梯度"""
    n = len(X)
    predictions = w * X + b
    error = predictions - y
    
    # 损失函数 L = (1/n) * Σ (w*x + b - y)²
    # dL/dw = (2/n) * Σ (w*x + b - y) * x
    # dL/db = (2/n) * Σ (w*x + b - y)
    dw = (2 / n) * np.sum(error * X)
    db = (2 / n) * np.sum(error)
    
    return dw, db

# ============================================================
# 第五步:训练循环(梯度下降)
# ============================================================
learning_rate = 0.01
epochs = 100
loss_history = []

print("\n--- 开始训练 ---")
for epoch in range(epochs):
    # 计算梯度
    dw, db = compute_gradients(X, y, w, b)
    
    # 梯度下降更新参数
    w = w - learning_rate * dw
    b = b - learning_rate * db
    
    # 记录损失
    loss = compute_loss(X, y, w, b)
    loss_history.append(loss)
    
    # 每 20 轮打印一次
    if (epoch + 1) % 20 == 0:
        print(f"Epoch {epoch+1:3d} | Loss: {loss:.4f} | w: {w:.4f} | b: {b:.4f}")

# ============================================================
# 第六步:结果展示
# ============================================================
print(f"\n--- 训练结果 ---")
print(f"真实参数: w={true_w}, b={true_b}")
print(f"学到的参数: w={w:.4f}, b={b:.4f}")
print(f"最终损失: {loss_history[-1]:.4f}")

# 可视化
fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# 图1:拟合结果
axes[0].scatter(X, y, alpha=0.5, label='数据点')
x_line = np.linspace(-5, 5, 100)
axes[0].plot(x_line, w * x_line + b, 'r-', linewidth=2, label='拟合直线')
axes[0].plot(x_line, true_w * x_line + true_b, 'g--', linewidth=2, label='真实直线')
axes[0].set_xlabel('X')
axes[0].set_ylabel('y')
axes[0].set_title('线性回归拟合结果')
axes[0].legend()
axes[0].grid(True)

# 图2:损失下降
axes[1].plot(loss_history)
axes[1].set_xlabel('Epoch')
axes[1].set_ylabel('Loss (MSE)')
axes[1].set_title('训练损失下降曲线')
axes[1].grid(True)

plt.tight_layout()
plt.show()

运行结果分析

真实参数: w=3.0, b=2.0
初始参数: w=-0.2347, b=1.5792

Epoch  20 | Loss: 5.8231 | w: 2.5289 | b: 2.1779
Epoch  40 | Loss: 4.2344 | w: 2.7847 | b: 2.1183
Epoch  60 | Loss: 3.9689 | w: 2.8876 | b: 2.0956
Epoch  80 | Loss: 3.9276 | w: 2.9306 | b: 2.0870
Epoch 100 | Loss: 3.9211 | w: 2.9492 | b: 2.0836

最终学到的参数: w≈2.95, b≈2.08 (接近真实值 3.0 和 2.0)
最终损失: 3.92 (这是噪声导致的不可消除的残差)

::: tip 🎉 恭喜! 如果你运行成功了这个项目,说明你已经掌握了:

  • ✅ 梯度下降的核心原理
  • ✅ 损失函数的概念
  • ✅ NumPy 的基本操作
  • ✅ Matplotlib 可视化

这就是机器学习的核心流程:定义模型 → 计算损失 → 计算梯度 → 更新参数。深度学习只是在更复杂的模型上重复这个过程。 :::


阶段总结

知识点清单

完成本阶段后,确认你掌握了:

数学:

编程:

推荐进阶资源

资源 类型 说明
《线性代数应该这样学》 书 线性代数直觉理解
3Blue1Brown 线性代数本质 视频 可视化数学概念,强烈推荐
《统计学习方法》李航 书 机器学习数学基础
《Python数据科学手册》 书 NumPy/Pandas/Matplotlib 详解
Kaggle Learn 在线 免费交互式 Python/ML 课程

下一步

::: tip 🚀 下一阶段 👉 阶段三:深度学习入门 —— 开始学习神经网络和 PyTorch :::

「数学和编程是地基,地基打得越牢,楼盖得越高。但你不需要把地基打到地心——够用就行,随时可以回来补。」