第零章：学习路线图

学习目标

  • 了解AI学习的完整知识体系与各模块之间的关系
  • 明确自己的学习起点和目标方向
  • 掌握后续学习所需的前置知识要求
  • 建立合理的学习计划和时间安排
  • 准备好学习所需的工具和环境

前置要求

  • 基本的计算机操作能力
  • 高中数学基础（代数、函数、基础几何）
  • 对AI领域的好奇心和学习热情
  • 愿意投入时间进行动手实践

学习路线图

以下是AI学习的完整路线图，共分为6大模块，建议按照顺序逐步学习。每个模块都有明确的学习目标和预期成果。

模块 章节内容 预计时间 重要程度 预期成果
模块一 第零章：学习路线图 0.5 周 ★★ 明确学习方向，搭建环境
模块二 第一章：Python编程基础 2 周 ★★★ 熟练使用Python进行数据处理
模块三 第二章：数学基础 2 周 ★★★ 理解AI背后的数学原理
模块四 第三章：机器学习基础 3 周 ★★★ 掌握经典ML算法与Scikit-learn
模块五 第四章：深度学习基础 3 周 ★★★ 理解神经网络与PyTorch
模块六 第五章：工程实践与工具 2 周 ★★ 完成端到端ML项目

预计学习时间

总时长
约 12-16 周
每周投入
10-15 小时
总计
120-240 小时

所需工具清单

工具 用途 获取方式 费用
Python 3.10+ 编程语言 python.org 免费
VS Code 代码编辑器 code.visualstudio.com 免费
Jupyter Notebook 交互式编程环境 pip install jupyter 免费
NumPy 数值计算 pip install numpy 免费
Matplotlib 数据可视化 pip install matplotlib 免费
Git 版本控制 git-scm.com 免费
学习建议

建议使用 Anaconda 发行版，它已经预装了 Python、Jupyter Notebook、NumPy、Matplotlib 等常用工具，可以省去大量环境配置时间。安装命令：conda install numpy matplotlib jupyter

第一章：Python编程基础

学习目标

  • 掌握Python基本语法：变量、数据类型、运算符
  • 理解控制流：条件判断（if/else）、循环（for/while）
  • 学会使用NumPy进行高效的数组与矩阵运算
  • 能够使用Matplotlib创建基本的数据可视化图表
  • 为后续机器学习编程打下坚实基础

前置要求

  • 已安装Python 3.10或更高版本
  • 了解基本的编程概念（如变量、函数）
  • 能够使用终端/命令行执行基本命令

Python 环境安装

推荐安装方式

推荐使用 Anaconda 进行安装，它包含了Python解释器和大量科学计算库。访问 anaconda.com/download 下载对应系统的安装包。

Bash - 环境检查与安装 
# 检查Python版本
python --version
# 输出: Python 3.10.x 或更高

# 使用pip安装所需库
pip install numpy matplotlib jupyter

# 或者使用conda（如果安装了Anaconda）
conda install numpy matplotlib jupyter

# 启动Jupyter Notebook
jupyter notebook
验证安装

在终端输入 python -c "import numpy; import matplotlib; print('安装成功！')"，如果没有报错，说明环境安装成功。

基础语法

变量与数据类型

Python是动态类型语言，变量不需要提前声明类型。以下是常用的数据类型。

Python - 变量与数据类型 
# ========== 变量与数据类型 ==========

# 整数 (int)
a = 10
b = -3
print(type(a))  # <class 'int'>

# 浮点数 (float)
pi = 3.14159
learning_rate = 0.001
print(type(pi))  # <class 'float'>

# 字符串 (str)
model_name = "ResNet-50"
description = '深度学习模型'
print(type(model_name))  # <class 'str'>

# 布尔值 (bool)
is_training = True
use_gpu = False
print(type(is_training))  # <class 'bool'>

# 列表 (list) - AI中常用于存储数据集、特征等
layers = ['conv', 'relu', 'pool', 'fc']
losses = [0.9, 0.7, 0.5, 0.3, 0.2]

# 字典 (dict) - AI中常用于存储超参数
hyperparams = {
    'learning_rate': 0.001,
    'batch_size': 32,
    'epochs': 100,
    'optimizer': 'adam'
}

# 元组 (tuple) - 不可变序列
image_shape = (224, 224, 3)  # 高度, 宽度, 通道数

print(f"模型: {model_name}, 学习率: {hyperparams['learning_rate']}")
print(f"图像尺寸: {image_shape[0]}x{image_shape[1]}")

控制流

条件判断和循环是编程的基础，在AI中常用于数据预处理、训练循环等场景。

Python - 控制流 
# ========== 条件判断 ==========
accuracy = 0.92

if accuracy >= 0.9:
    print("模型表现优秀！")
elif accuracy >= 0.7:
    print("模型表现良好，仍有提升空间")
else:
    print("模型需要进一步调优")

# ========== for 循环 - 训练循环模拟 ==========
epochs = 5
losses = []

for epoch in range(epochs):
    loss = 1.0 / (epoch + 1)  # 模拟损失递减
    losses.append(loss)
    print(f"Epoch {epoch + 1}/{epochs}, Loss: {loss:.4f}")

# ========== while 循环 - 早停机制模拟 ==========
patience = 3
best_loss = float('inf')
no_improve = 0
current_loss = 0.8

while no_improve < patience:
    if current_loss < best_loss:
        best_loss = current_loss
        no_improve = 0
        print(f"损失改善: {best_loss:.4f}")
    else:
        no_improve += 1
        print(f"未改善 ({no_improve}/{patience})")
    current_loss *= 0.95  # 模拟损失变化

print(f"训练结束，最佳损失: {best_loss:.4f}")

# ========== 列表推导式 - 数据预处理常用 ==========
raw_data = [1.2, 3.4, 5.6, 7.8, 9.0]
normalized = [(x - min(raw_data)) / (max(raw_data) - min(raw_data))
              for x in raw_data]
print(f"归一化结果: {normalized}")
Python小贴士

在AI编程中，列表推导式和字典推导式非常常用，它们比传统循环更简洁高效。此外，enumerate() 和 zip() 也是数据处理中的常用函数。

NumPy 基础

NumPy是Python科学计算的核心库，提供了高效的多维数组对象和丰富的数学函数。在AI中，NumPy是几乎所有数据处理和数值计算的基础。

数组创建

Python - NumPy 数组创建 
import numpy as np

# ========== 数组创建 ==========
# 从列表创建
a = np.array([1, 2, 3, 4, 5])
print(f"一维数组: {a}, 形状: {a.shape}")

# 创建全零数组（常用于初始化权重）
zeros = np.zeros((3, 4))
print(f"全零数组 (3x4):\n{zeros}")

# 创建全一数组
ones = np.ones((2, 3))
print(f"全一数组 (2x3):\n{ones}")

# 创建单位矩阵（线性代数中常用）
identity = np.eye(3)
print(f"单位矩阵 (3x3):\n{identity}")

# 创建随机数组（常用于初始化神经网络权重）
np.random.seed(42)  # 设置随机种子，保证可复现
random_arr = np.random.randn(3, 3)  # 标准正态分布
print(f"随机数组 (3x3):\n{random_arr}")

# 等间隔数组
x = np.linspace(0, 10, 5)  # [0, 2.5, 5, 7.5, 10]
print(f"等间隔数组: {x}")

# 等差数组
y = np.arange(0, 10, 2)  # [0, 2, 4, 6, 8]
print(f"等差数组: {y}")

矩阵运算

Python - NumPy 矩阵运算 
import numpy as np

# ========== 矩阵运算 ==========
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 矩阵加法
C = A + B
print(f"矩阵加法:\n{C}")

# 矩阵乘法（点积）- AI中最常用的运算
D = A @ B  # 等价于 np.dot(A, B)
print(f"矩阵乘法 A @ B:\n{D}")

# 逐元素乘法（Hadamard积）
E = A * B
print(f"逐元素乘法 A * B:\n{E}")

# 转置
print(f"A的转置:\n{A.T}")

# 矩阵的逆
A_inv = np.linalg.inv(A)
print(f"A的逆矩阵:\n{A_inv}")

# 矩阵的行列式
det = np.linalg.det(A)
print(f"A的行列式: {det:.2f}")

# ========== 广播机制 ==========
# AI中非常重要的特性
x = np.array([[1], [2], [3]])  # 形状 (3, 1)
y = np.array([10, 20, 30])     # 形状 (3,)
result = x + y                 # 广播为 (3, 3)
print(f"广播结果:\n{result}")

# ========== 常用统计运算 ==========
data = np.array([1.2, 3.4, 5.6, 7.8, 9.0])
print(f"均值: {np.mean(data):.2f}")
print(f"标准差: {np.std(data):.2f}")
print(f"最大值: {np.max(data)}, 最小值: {np.min(data)}")
print(f"求和: {np.sum(data)}")
print(f"排序: {np.sort(data)}")
注意

在NumPy中，* 是逐元素乘法，@ 或 np.dot() 才是矩阵乘法。在AI编程中，矩阵乘法（@）远比逐元素乘法更常用，务必区分清楚。

Matplotlib 基础

Matplotlib是Python最常用的数据可视化库。在AI中，我们用它来可视化训练过程、数据分布、模型性能等。

折线图 - 训练损失可视化

Python - Matplotlib 折线图 
import matplotlib.pyplot as plt
import numpy as np

# 设置中文字体（避免中文显示为方块）
plt.rcParams['font.sans-serif'] = ['SimHei', 'Arial Unicode MS']
plt.rcParams['axes.unicode_minus'] = False

# ========== 折线图：模拟训练过程 ==========
epochs = np.arange(1, 101)
train_loss = 2.0 * np.exp(-0.03 * epochs) + np.random.randn(100) * 0.05
val_loss = 2.2 * np.exp(-0.025 * epochs) + np.random.randn(100) * 0.08

plt.figure(figsize=(10, 6))
plt.plot(epochs, train_loss, 'b-', label='训练损失', linewidth=2)
plt.plot(epochs, val_loss, 'r--', label='验证损失', linewidth=2)
plt.xlabel('Epoch', fontsize=14)
plt.ylabel('Loss', fontsize=14)
plt.title('模型训练过程', fontsize=16)
plt.legend(fontsize=12)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('training_curve.png', dpi=150)
plt.show()

散点图 - 数据分布可视化

Python - Matplotlib 散点图 
import matplotlib.pyplot as plt
import numpy as np

plt.rcParams['font.sans-serif'] = ['SimHei', 'Arial Unicode MS']
plt.rcParams['axes.unicode_minus'] = False

# ========== 散点图：两类数据分布 ==========
np.random.seed(42)

# 类别A：以(2, 3)为中心
class_a = np.random.randn(50, 2) * 0.8 + np.array([2, 3])

# 类别B：以(6, 7)为中心
class_b = np.random.randn(50, 2) * 0.8 + np.array([6, 7])

plt.figure(figsize=(8, 6))
plt.scatter(class_a[:, 0], class_a[:, 1],
            c='#4299e1', label='类别 A', alpha=0.7, s=80, edgecolors='white')
plt.scatter(class_b[:, 0], class_b[:, 1],
            c='#e53e3e', label='类别 B', alpha=0.7, s=80, edgecolors='white')
plt.xlabel('特征 1', fontsize=14)
plt.ylabel('特征 2', fontsize=14)
plt.title('二分类数据分布', fontsize=16)
plt.legend(fontsize=12)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('scatter_plot.png', dpi=150)
plt.show()

练习题

[1] 使用NumPy创建一个 5x5 的随机矩阵，计算其转置、逆矩阵和行列式，并验证 \( A \times A^{-1} \) 是否接近单位矩阵。
[2] 给定两组数据 x = [1, 2, 3, 4, 5] 和 y = [2.1, 3.9, 6.2, 7.8, 10.1]，使用Matplotlib绘制散点图，并观察它们之间的关系。
[3] 编写一个函数 normalize(data)，接收一个NumPy数组，返回Z-score标准化后的结果（公式：\( z = \frac{x - \mu}{\sigma} \)），其中 \(\mu\) 为均值，\(\sigma\) 为标准差。

章节小结

  • Python是AI开发的首选语言，其简洁的语法和丰富的库生态是最大优势
  • NumPy的ndarray是AI数值计算的核心数据结构，掌握数组操作和广播机制至关重要
  • 矩阵乘法（@）是AI计算的基本操作，务必与逐元素乘法（*）区分
  • Matplotlib是数据可视化的基础工具，在分析数据和展示模型性能时不可或缺
  • 设置随机种子（np.random.seed()）可以保证实验的可复现性

第二章：数学基础

学习目标

  • 掌握线性代数核心概念：向量、矩阵、矩阵乘法及其几何意义
  • 理解微积分基本概念：导数、偏导数、链式法则、梯度
  • 熟悉概率统计基础：概率分布、期望、方差、贝叶斯定理
  • 了解信息论基本概念：熵、交叉熵及其在AI中的应用
  • 理解每个数学概念在AI中的具体应用场景

前置要求

  • 高中数学基础（函数、方程、基本概率）
  • 了解Python和NumPy基本操作（第一章内容）
  • 对抽象数学概念有一定的接受能力

线性代数

线性代数是AI的数学基石。神经网络的前向传播本质上是矩阵乘法，反向传播需要计算梯度，这些操作都建立在线性代数之上。

向量 (Vector)

向量是具有大小和方向的量。在AI中，向量用于表示数据点、特征、词嵌入等。

\[ \mathbf{x} = \begin{bmatrix} x_1 \\ x_2 \\ \vdots \\ x_n \end{bmatrix} \in \mathbb{R}^n \]
n维列向量，表示一个具有n个特征的数据点

数值示例：假设一个学生的成绩用向量表示：

\[ \mathbf{s} = \begin{bmatrix} 90 \\ 85 \\ 78 \\ 92 \end{bmatrix} \]
分别对应：数学、英语、物理、化学成绩

向量运算：

\[ \mathbf{a} \cdot \mathbf{b} = \sum_{i=1}^{n} a_i b_i = a_1 b_1 + a_2 b_2 + \cdots + a_n b_n \]
点积（内积）：衡量两个向量的相似度
AI中哪里用到：词向量（Word Embedding）将词语映射为高维向量；特征向量表示数据样本；注意力机制中的Query、Key、Value都是向量。

矩阵 (Matrix)

矩阵是按照矩形排列的数字阵列。在AI中，矩阵用于表示数据集、权重矩阵、变换等。

\[ A = \begin{bmatrix} a_{11} & a_{12} & \cdots & a_{1n} \\ a_{21} & a_{22} & \cdots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} & a_{m2} & \cdots & a_{mn} \end{bmatrix} \in \mathbb{R}^{m \times n} \]
m行n列的矩阵

数值示例：一个3个样本、4个特征的数据集：

\[ X = \begin{bmatrix} 1.0 & 2.3 & 0.5 & 3.1 \\ 0.8 & 1.9 & 0.7 & 2.8 \\ 1.2 & 2.1 & 0.3 & 3.5 \end{bmatrix} \]
3行（样本）x 4列（特征）
AI中哪里用到：数据集通常组织为矩阵形式（样本数 x 特征数）；神经网络每一层的权重都是一个矩阵；图像可以看作像素矩阵。

矩阵乘法 (Matrix Multiplication)

矩阵乘法是神经网络前向传播的核心运算。

\[ C = A \times B, \quad c_{ij} = \sum_{k=1}^{K} a_{ik} \cdot b_{kj} \]
A(m x K) 乘以 B(K x n) 得到 C(m x n)

数值示例：

\[ \begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix} \times \begin{bmatrix} 5 & 6 \\ 7 & 8 \end{bmatrix} = \begin{bmatrix} 1 \times 5 + 2 \times 7 & 1 \times 6 + 2 \times 8 \\ 3 \times 5 + 4 \times 7 & 3 \times 6 + 4 \times 8 \end{bmatrix} = \begin{bmatrix} 19 & 22 \\ 43 & 50 \end{bmatrix} \]
逐步计算矩阵乘法
AI中哪里用到：神经网络层的计算 \( \mathbf{h} = \sigma(W\mathbf{x} + \mathbf{b}) \)，其中 \( W \) 是权重矩阵，\( \mathbf{x} \) 是输入向量，\( \mathbf{b} \) 是偏置向量，\( \sigma \) 是激活函数。整个深度网络就是一系列矩阵乘法的组合。

微积分

微积分是理解AI优化过程的关键。神经网络的训练本质上就是通过微积分中的梯度下降来最小化损失函数。

导数 (Derivative)

导数描述函数在某一点处的变化率，即"瞬时速度"。

\[ f'(x) = \frac{df}{dx} = \lim_{h \to 0} \frac{f(x+h) - f(x)}{h} \]
导数的定义

常用导数公式：

\[ \frac{d}{dx}x^n = nx^{n-1}, \quad \frac{d}{dx}e^x = e^x, \quad \frac{d}{dx}\ln(x) = \frac{1}{x}, \quad \frac{d}{dx}\sin(x) = \cos(x) \]
基本函数的导数
AI中哪里用到：导数告诉我们损失函数在某个参数值处的变化方向，是梯度下降法的基础。激活函数的导数决定了反向传播中梯度的流动。

偏导数 (Partial Derivative)

当函数有多个变量时，偏导数是固定其他变量，对某一个变量求导。

\[ f(x, y) = x^2 + 3xy + y^2 \] \[ \frac{\partial f}{\partial x} = 2x + 3y, \quad \frac{\partial f}{\partial y} = 3x + 2y \]
多变量函数的偏导数
AI中哪里用到：损失函数通常有大量参数（可能数百万个），我们需要分别对每个参数求偏导数，以确定每个参数应该如何调整来减小损失。

链式法则 (Chain Rule)

链式法则是微积分中最重要的法则之一，用于求复合函数的导数。

\[ \frac{d}{dx}[f(g(x))] = f'(g(x)) \cdot g'(x) \]
链式法则基本形式

多变量链式法则：

\[ \frac{\partial L}{\partial w} = \frac{\partial L}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial w} \]
多层复合函数的链式求导
AI中哪里用到：反向传播算法（Backpropagation）的核心就是链式法则。神经网络由多层组成，损失函数对第一层参数的梯度需要逐层传递，每一层都通过链式法则将梯度向后传递。这是深度学习能够高效训练的关键。

梯度 (Gradient)

梯度是一个向量，由函数对所有变量的偏导数组成，指向函数值增长最快的方向。

\[ \nabla f = \begin{bmatrix} \frac{\partial f}{\partial x_1} \\ \frac{\partial f}{\partial x_2} \\ \vdots \\ \frac{\partial f}{\partial x_n} \end{bmatrix} \]
梯度向量（n个变量的函数）

梯度下降更新公式：

\[ \theta_{t+1} = \theta_t - \alpha \cdot \nabla_\theta L(\theta_t) \]
梯度下降：沿梯度的反方向更新参数，\(\alpha\) 为学习率
AI中哪里用到：梯度下降是几乎所有机器学习模型的训练方法。SGD、Adam、RMSprop等优化器都是基于梯度下降的变体。理解梯度是理解模型训练过程的关键。

概率统计

概率论为AI提供了处理不确定性的数学框架。从朴素贝叶斯分类器到贝叶斯神经网络，概率统计无处不在。

概率分布 (Probability Distribution)

概率分布描述了随机变量取各个值的可能性。

常见分布：

\[ \text{正态分布: } f(x) = \frac{1}{\sigma\sqrt{2\pi}} e^{-\frac{(x-\mu)^2}{2\sigma^2}} \]
高斯分布，\(\mu\)为均值，\(\sigma\)为标准差
\[ \text{伯努利分布: } P(X=k) = p^k(1-p)^{1-k}, \quad k \in \{0, 1\} \]
二值分布，如抛硬币
\[ \text{Softmax分布: } P(y_i) = \frac{e^{z_i}}{\sum_{j=1}^{K} e^{z_j}} \]
多分类中常用的概率分布
AI中哪里用到：正态分布用于权重初始化和数据假设；Softmax将网络输出转化为概率分布，用于多分类任务（如ImageNet的1000类分类）。

期望与方差 (Expectation & Variance)

期望是随机变量的"平均值"，方差衡量数据的离散程度。

\[ \mathbb{E}[X] = \sum_{i} x_i \cdot P(x_i) \quad \text{(离散)} \] \[ \mathbb{E}[X] = \int_{-\infty}^{\infty} x \cdot f(x) \, dx \quad \text{(连续)} \]
期望（数学期望）
\[ \text{Var}(X) = \mathbb{E}[(X - \mathbb{E}[X])^2] = \mathbb{E}[X^2] - (\mathbb{E}[X])^2 \]
方差：衡量随机变量偏离均值的程度

数值示例：掷骰子的期望和方差：

\[ \mathbb{E}[X] = \frac{1+2+3+4+5+6}{6} = 3.5 \] \[ \text{Var}(X) = \frac{(1-3.5)^2 + (2-3.5)^2 + \cdots + (6-3.5)^2}{6} \approx 2.92 \]
公平骰子的期望和方差
AI中哪里用到：期望用于计算预测值；方差用于衡量模型的不确定性；Batch Normalization利用批次的均值和方差来稳定训练。

贝叶斯定理 (Bayes' Theorem)

贝叶斯定理描述了在获得新证据后如何更新我们的信念。

\[ P(A|B) = \frac{P(B|A) \cdot P(A)}{P(B)} \]
贝叶斯定理：后验概率 = 似然 x 先验概率 / 证据

数值示例：疾病检测

\[ \text{假设：疾病发病率} P(D) = 0.01, \text{检测灵敏度} P(+|D) = 0.99, \text{误报率} P(+|\neg D) = 0.05 \] \[ P(D|+) = \frac{P(+|D) \cdot P(D)}{P(+|D) \cdot P(D) + P(+|\neg D) \cdot P(\neg D)} = \frac{0.99 \times 0.01}{0.99 \times 0.01 + 0.05 \times 0.99} \approx 0.167 \]
即使检测为阳性，实际患病的概率也仅有约16.7%（贝叶斯定理的经典应用）
AI中哪里用到：朴素贝叶斯分类器（垃圾邮件过滤）；贝叶斯优化（超参数调优）；贝叶斯神经网络（量化模型不确定性）；最大后验估计（MAP）。

信息论

信息论为AI提供了衡量"信息量"和"不确定性"的工具，是理解损失函数设计的基础。

熵 (Entropy)

熵衡量一个随机变量的不确定性，熵越大表示不确定性越高。

\[ H(X) = -\sum_{i=1}^{n} p(x_i) \log_2 p(x_i) \]
信息熵（单位：比特）

直观理解：

\[ \text{公平硬币: } H = -(0.5 \log_2 0.5 + 0.5 \log_2 0.5) = 1 \text{ bit} \] \[ \text{作弊硬币(总是正面): } H = -(1 \log_2 1 + 0 \log_2 0) = 0 \text{ bit} \]
越确定的事物，熵越低；越不确定的事物，熵越高
AI中哪里用到：决策树使用信息增益（基于熵）来选择最优分裂特征；信息熵用于衡量数据集的纯度。

交叉熵 (Cross-Entropy)

交叉熵衡量两个概率分布之间的"距离"，是分类任务中最常用的损失函数。

\[ H(p, q) = -\sum_{i=1}^{n} p(x_i) \log q(x_i) \]
交叉熵：p为真实分布，q为预测分布

二分类交叉熵损失：

\[ \mathcal{L} = -\frac{1}{N}\sum_{i=1}^{N} \left[ y_i \log \hat{y}_i + (1 - y_i) \log(1 - \hat{y}_i) \right] \]
Binary Cross-Entropy Loss，\(\hat{y}\)为预测概率，\(y\)为真实标签

多分类交叉熵损失：

\[ \mathcal{L} = -\sum_{i=1}^{C} y_i \log \hat{y}_i \]
Categorical Cross-Entropy Loss，C为类别数
AI中哪里用到：交叉熵是深度学习中最常用的损失函数。几乎所有的分类任务（图像分类、文本分类、机器翻译等）都使用交叉熵作为损失函数。它衡量的是模型预测分布与真实分布之间的差异，模型训练的目标就是最小化这个差异。

数学概念与AI应用对照表

数学概念 AI应用 涉及章节
向量/矩阵 数据表示、权重矩阵、特征提取 全部章节
矩阵乘法 神经网络前向传播 深度学习
导数/梯度 梯度下降、反向传播 机器学习、深度学习
链式法则 反向传播算法 深度学习
概率分布 Softmax输出、数据建模 机器学习、深度学习
贝叶斯定理 朴素贝叶斯、贝叶斯优化 机器学习
交叉熵 分类损失函数 机器学习、深度学习

练习题

[1] 给定矩阵 \( A = \begin{bmatrix} 1 & 2 \\ 3 & 4 \end{bmatrix} \) 和向量 \( \mathbf{x} = \begin{bmatrix} 5 \\ 6 \end{bmatrix} \)，手动计算 \( A\mathbf{x} \)，然后用NumPy验证结果。
[2] 对函数 \( f(x, y) = x^2 y + y^3 \)，分别求 \( \frac{\partial f}{\partial x} \) 和 \( \frac{\partial f}{\partial y} \)，并计算在点 \( (2, 1) \) 处的梯度 \( \nabla f \)。
[3] 一个二分类问题中，真实标签为 \( y = 1 \)，模型预测概率为 \( \hat{y} = 0.8 \)。计算该样本的交叉熵损失 \( \mathcal{L} = -[y \log \hat{y} + (1-y)\log(1-\hat{y})] \)。如果预测概率提高到 \( \hat{y} = 0.95 \)，损失如何变化？

章节小结

  • 线性代数是AI计算的基础，矩阵乘法是神经网络的核心运算
  • 微积分中的梯度和链式法则是反向传播算法的数学基础
  • 概率论为处理不确定性提供了框架，贝叶斯定理在多个AI领域有重要应用
  • 交叉熵是最常用的分类损失函数，理解其含义对模型训练至关重要
  • 不必一开始就精通所有数学，随着后续章节的学习，这些概念会越来越清晰