数学与编程基础
「数学是AI的语言，Python是AI的工具。掌握这两样，你就拥有了和AI对话的能力。」
阶段目标
这个阶段的目标很明确：
- 数学：掌握理解深度学习所需的数学基础——够用就行，不追求数学家水平
- 编程：掌握 Python 数据科学栈，能处理数据、实现算法
学完这个阶段，你将能够：
- 读懂深度学习代码中的数学操作
- 理解梯度下降背后的原理
- 用 Python 实现基础的机器学习算法
- 处理和分析真实数据
💡 学习策略
不要先学完所有数学再学编程，也不要先学完编程再学数学。 两者交叉学习效果最好：学一点数学 → 用 Python 验证 → 再学更多数学。理论+实践交替进行。
第一部分：数学基础
为什么 AI 需要数学？
text
数据 → 数学表示 → 数学运算 → AI模型 → 输出结果
具体来说：
图片 → 数字矩阵 → 矩阵运算 → 神经网络 → "这是一只猫"
文本 → 词向量 → 向量运算 → Transformer → 翻译结果AI 的本质是用数学方法处理数据。你需要理解三块数学：
| 数学分支 | 在AI中的作用 | 类比 |
|---|---|---|
| 线性代数 | 表示和操作数据 | AI 的"语言" |
| 概率统计 | 处理不确定性 | AI 的"判断力" |
| 微积分 | 优化模型参数 | AI 的"学习方式" |
1. 线性代数
线性代数是 AI 最核心的数学基础。深度学习中几乎所有的计算都是矩阵运算。
1.1 标量、向量、矩阵、张量
text
标量（Scalar）：一个数字
例：x = 3.14
向量（Vector）：一列数字
例：v = [1, 2, 3] （3维向量）
矩阵（Matrix）：一个数字表格
例：M = [[1, 2],
[3, 4]] （2×2矩阵）
张量（Tensor）：多维数字数组
例：一张彩色图片是 3维张量（高×宽×3个颜色通道）
例：一批图片是 4维张量（批次×高×宽×3）💡 为什么叫"Tensor"？
PyTorch 中的核心数据结构叫 Tensor（张量），就是这个概念。深度学习的计算本质上就是张量运算。
1.2 向量运算
python
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 矩阵运算
python
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 如此重要？
text
神经网络的每一层计算：
输出 = 激活函数(权重矩阵 × 输入向量 + 偏置)
具体来说：
输入 x：一个向量（比如100维）
权重 W：一个矩阵（比如 256×100）
输出 y = W × x：一个新向量（256维）
一层神经网络 = 一次矩阵乘法 + 一次激活函数
多层神经网络 = 多次矩阵乘法的叠加💡 关键洞察
神经网络的"前向传播"本质上就是一连串的矩阵乘法。 理解了矩阵乘法，你就理解了神经网络最基本的计算过程。
1.5 线性代数核心概念速查表
| 概念 | 说明 | AI 中的用途 |
|---|---|---|
| 向量 | 一列数字 | 表示数据特征、模型参数 |
| 矩阵 | 数字表格 | 表示权重、批量数据 |
| 张量 | 多维数组 | 深度学习的通用数据结构 |
| 矩阵乘法 | 两个矩阵相乘 | 神经网络层的计算 |
| 转置 | 行列互换 | 计算梯度、调整维度 |
| 点积 | 向量对应元素乘积之和 | 计算相似度、注意力 |
| 范数 | 向量的"长度" | 正则化、衡量模型复杂度 |
2. 概率统计
AI 处理的是不确定的世界。概率统计帮助我们量化不确定性、做出合理判断。
2.1 基本概念
概率：某件事发生的可能性，范围 0 到 1。
text
P(下雨) = 0.3 → 30% 的概率下雨
P(不下雨) = 0.7 → 70% 的概率不下雨随机变量：取值不确定的变量。
text
X = 明天的天气 → 可能是"晴"、"阴"、"雨"
Y = 骰子的点数 → 可能是 1, 2, 3, 4, 5, 62.2 概率分布
分布描述随机变量取各种值的可能性。
| 分布 | 说明 | AI 中的例子 |
|---|---|---|
| 均匀分布 | 所有值概率相等 | 随机初始化模型参数 |
| 正态分布 | 钟形曲线，中间多两头少 | 权重初始化、噪声建模 |
| 伯努利分布 | 0或1，抛硬币 | 二分类模型的输出 |
python
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 贝叶斯定理
贝叶斯定理是概率统计中最重要的公式之一。
text
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%的患病概率！💡 为什么这在 AI 中重要？
很多 AI 问题本质上就是在观测到数据后，更新对世界的认知。贝叶斯定理就是这种"更新认知"的数学基础。虽然现代深度学习不直接用贝叶斯公式，但其思想渗透在 AI 的方方面面。
2.4 期望与方差
text
期望（Expectation）：随机变量的"平均值"
类比：如果你重复无数次实验，结果的平均趋势
方差（Variance）：随机变量偏离期望的程度
类比：结果的"波动大小"
标准差（Standard Deviation）：方差的平方根python
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 导数
导数描述函数在某点的变化率。
text
函数 f(x) = x²
导数 f'(x) = 2x
含义：在 x=3 处，f 的变化量约为 x 变化量的 2×3=6 倍python
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 偏导数与梯度
当函数有多个变量时，需要偏导数。
text
函数 f(x, y) = x² + y²
对 x 的偏导数：∂f/∂x = 2x （把 y 当常数）
对 y 的偏导数：∂f/∂y = 2y （把 x 当常数）
梯度 = (∂f/∂x, ∂f/∂y) = (2x, 2y)梯度（Gradient）：所有偏导数组成的向量，指向函数值上升最快的方向。
text
梯度上升：沿着梯度方向走 → 函数值增大
梯度下降：沿着梯度反方向走 → 函数值减小 ← 这是AI训练的核心！3.3 梯度下降
梯度下降是 AI 训练最核心的优化算法。
text
目标：找到让损失函数最小的参数值
算法：
1. 随机初始化参数
2. 计算当前参数下的梯度
3. 沿着梯度反方向更新参数：参数 = 参数 - 学习率 × 梯度
4. 重复步骤 2-3，直到收敛
类比：蒙着眼睛下山
你看不到全貌，但能感知脚下的坡度（梯度）
每次朝着最陡的下坡方向走一步
最终走到谷底（最优解）python
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}") # 趋近于 03.4 链式法则与反向传播
链式法则是微积分中处理复合函数求导的规则，它是反向传播的数学基础。
text
复合函数：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为什么这对深度学习至关重要？
text
神经网络就是嵌套的复合函数：
输入 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
这就是"反向传播"——从损失开始，反向逐层计算梯度。💡 一句话总结
反向传播 = 链式法则在神经网络上的应用。 PyTorch 的"自动求导"（autograd）就是自动帮你做链式法则的计算。
3.5 微积分核心概念速查表
| 概念 | 说明 | AI 中的用途 |
|---|---|---|
| 导数 | 函数变化率 | 衡量参数对损失的影响 |
| 偏导数 | 多变量函数的变化率 | 计算每个参数的梯度 |
| 梯度 | 所有偏导数组成的向量 | 指示优化方向 |
| 梯度下降 | 沿梯度反方向更新参数 | 训练模型的核心算法 |
| 链式法则 | 复合函数求导 | 反向传播的数学基础 |
| 学习率 | 每次更新的步长 | 控制训练速度和稳定性 |
第二部分：编程基础
Python：AI 时代的通用语言
Python 是 AI 领域的绝对主流语言。原因很简单：
text
为什么是 Python？
1. 语法简洁 → 专注算法逻辑，不纠结语法
2. 生态丰富 → NumPy/Pandas/PyTorch... 无所不包
3. 社区庞大 → 遇到问题总能找到答案
4. AI 框架首选 → 几乎所有主流框架都支持 PythonPython 入门学习路径
如果你已经会 Python，可以跳过这一节。
基础语法（1-2 周）
需要掌握的核心概念：
python
# 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 或类似设计。
核心概念
python
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 最强大也最容易困惑的特性。
text
规则：当两个数组形状不同时，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] 被广播到矩阵的每一行python
# 广播示例
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 的数据都加上同一个偏置向量⚠️ 注意
广播机制非常方便，但也容易隐藏 bug。当你遇到维度不匹配的错误时，首先要检查的就是广播是否符合预期。
索引与切片
python
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的元素数组操作常用函数
python
# 改变形状
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 等格式的数据。
核心数据结构
python
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数据读取与保存
python
# 读取 CSV
df = pd.read_csv('data.csv')
# 读取 Excel
df = pd.read_excel('data.xlsx')
# 保存
df.to_csv('output.csv', index=False)数据探索
python
# 查看前几行
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())数据清洗
python
# 处理缺失值
df.fillna(0, inplace=True) # 用 0 填充
df.dropna(inplace=True) # 删除有缺失的行
# 去重
df.drop_duplicates(inplace=True)
# 类型转换
df['age'] = df['age'].astype(float)💡 实际应用
在实际 AI 项目中，数据清洗和预处理占工作量的 60-80%。熟练使用 Pandas 能极大提高你的工作效率。
Matplotlib：数据可视化
可视化是理解数据的重要手段。Matplotlib 是 Python 最基础的可视化库。
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()💡 进阶推荐
Matplotlib 是基础，如果你想要更美观的图表，可以学习：
- Seaborn：基于 Matplotlib，统计图表更美观
- Plotly：交互式图表
- TensorBoard / Weights & Biases：训练过程可视化（后面阶段会用到）
第三部分：实战项目
用 Python 从零实现线性回归
这是你第一个完整的 AI 项目。不用任何框架，纯 NumPy 实现线性回归——同时检验你的数学和编程基础。
问题定义
text
给定一组数据点 (x, y)，找到一条直线 y = w·x + b
使得这条直线尽可能"拟合"这些数据点
这就是线性回归：最简单的机器学习算法完整代码
python
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()运行结果分析
text
真实参数: 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 （这是噪声导致的不可消除的残差）🎉 恭喜！
如果你运行成功了这个项目，说明你已经掌握了：
- ✅ 梯度下降的核心原理
- ✅ 损失函数的概念
- ✅ NumPy 的基本操作
- ✅ Matplotlib 可视化
这就是机器学习的核心流程：定义模型 → 计算损失 → 计算梯度 → 更新参数。深度学习只是在更复杂的模型上重复这个过程。
阶段总结
知识点清单
完成本阶段后，确认你掌握了：
数学：
- [ ] 向量、矩阵、张量的概念和运算
- [ ] 矩阵乘法为什么对 AI 重要
- [ ] 概率分布、期望、方差
- [ ] 导数、偏导数、梯度的概念
- [ ] 梯度下降算法的原理
- [ ] 链式法则与反向传播的关系
编程：
- [ ] Python 基础语法
- [ ] NumPy 数组操作和广播
- [ ] Pandas 数据读写和处理
- [ ] Matplotlib 基本绘图
- [ ] 能用 NumPy 实现梯度下降
推荐进阶资源
| 资源 | 类型 | 说明 |
|---|---|---|
| 《线性代数应该这样学》 | 书 | 线性代数直觉理解 |
| 3Blue1Brown 线性代数本质 | 视频 | 可视化数学概念，强烈推荐 |
| 《统计学习方法》李航 | 书 | 机器学习数学基础 |
| 《Python数据科学手册》 | 书 | NumPy/Pandas/Matplotlib 详解 |
| Kaggle Learn | 在线 | 免费交互式 Python/ML 课程 |
下一步
🚀 下一阶段
👉 阶段三：深度学习入门 —— 开始学习神经网络和 PyTorch
「数学和编程是地基，地基打得越牢，楼盖得越高。但你不需要把地基打到地心——够用就行，随时可以回来补。」