一、环境搭建
Anaconda+VSC+PyTorch。VSC我已经有了，只需安装插件，这就不详说了。
| 组件 | 推荐版本/类型 | 必装/选装 | 核心作用 |
|---|---|---|---|
| Anaconda | 2025.03 或更高 (Python 3.12+) | 必装 | 包管理器 + 虚拟环境隔离 |
| Visual Studio Code | 最新稳定版 (v1.90+) | 已装 | 代码编辑器 |
| VSC 插件 - Python | 最新版 (ms-python.python) | 必装 | 语法高亮、调试、环境识别 |
| VSC 插件 - Pylance | 最新版 (ms-python.vscode-pylance) | 必装 | 类型检查与智能提示（依赖Python插件） |
| PyTorch | 2.5.1 或 2.6.0 (稳定版) | 必装 | 深度学习框架 |
1.Anaconda：
++https://repo.anaconda.com/archive/Anaconda3-2025.12-1-Windows-x86_64.exe++
Anaconda 是一个Python/R 数据科学发行版 ，简单说它是一个打包好的 Python 环境 + 大量预装的数据科学工具包。
2.PyTorch：
**深度学习框架，**做深度学习 / AI 项目的。
-
用于构建和训练神经网络
-
由 Meta（Facebook）开发
-
广泛应用于：计算机视觉、NLP、强化学习等
用 Anaconda，安装 PyTorch 特别方便
-
如果你是 NVIDIA 显卡用户（GPU 版） ：
conda会自动检测你的驱动并匹配兼容的 CUDA 版本。bashconda install pytorch torchvision torchaudio -c conda-forge -
如果你没有 NVIDIA 显卡（CPU 版）：
bashconda install pytorch torchvision torchaudio cpuonly -c conda-forge
bash
// 创建专属环境
conda create -n pytorch_env python=3.12
conda activate pytorch_env3.VSC
在vsc中开发，运行时，记得切pytorch_env
二、PyTorch基础
1.基本操作
1.1 数学运算
（1）创建张量
| 方法 | 说明 | 示例 |
|---|---|---|
torch.tensor(data) |
从 Python 数据创建 | torch.tensor([1, 2, 3]) |
torch.zeros(shape) |
全0张量 | torch.zeros(2, 3) |
torch.ones(shape) |
全1张量 | torch.ones(2, 3) |
torch.rand(shape) |
均匀分布 [0,1) | torch.rand(2, 3) |
torch.randn(shape) |
标准正态分布 | torch.randn(2, 3) |
torch.randint(low, high, shape) |
随机整数 [low, high) | torch.randint(1, 10, (2, 3)) |
torch.arange(start, end, step) |
等差数列 | torch.arange(0, 10, 2) |
torch.linspace(start, end, steps) |
等间隔数列 | torch.linspace(0, 1, 5) |
torch.eye(n) |
单位矩阵 | torch.eye(3) |
torch.empty(shape) |
未初始化内存（垃圾值） | torch.empty(2, 3) |
python
import torch
# 1.创建张量。创建张量，可以里理解为声明变量、张量与python普通变量的区别：张量可以在GPU运行，速度翻倍，能用来计算梯度，可以直接批量计算。
#随机int,生成一个 2行3列 的张量,每个元素是在 [1, 10) 范围内的随机整数（即 1 到 9）,manual_seed(42) 保证每次运行结果一样
torch.manual_seed(42)
a=torch.randint(1,10,(2,3),dtype=torch.int8)
print(a)
# 随机0-1均匀分布:生成一个 2行3列 的张量,每个元素是在 [0, 1) 区间内的随机浮点数（均匀分布）,manual_seed(42) 保证每次运行结果一样
torch.manual_seed(42)
b=torch.rand((2,3),dtype=torch.float16)
print(b)
# 把张量 b（float16 类型）转换为 NumPy 数组
b.numpy()
print(b.numpy())
# 创建一个标量张量（0维张量），数值是 1，数据类型是 int16
c=torch.tensor(1,dtype=torch.int16)
# 创建一个标量张量，数值是 1.0，数据类型是 float32
d=torch.tensor(1.0,dtype=torch.float32)
# 专门用于标量张量（只有一个元素的张量），把它转换成 Python 原生数值类型
d.item()
print(d.item())
# 多元素用 tolist()
y = torch.tensor([1, 2, 3])
print(y.tolist()) # [1, 2, 3]
# 从 Python 列表创建张量
e = torch.tensor([1, 2, 3, 4])
# 查看形状、数据类型
print(e.shape) # torch.Size([4])
print(e.dtype) # torch.int64（默认）
# 改变形状
f = e.reshape(2, 2)
print(f) # tensor([[1, 2], [3, 4]])张量属性
| 属性 | 说明 | 示例 |
|---|---|---|
.shape |
张量形状（元组） | t.shape → torch.Size([2, 3]) |
.size() |
同 .shape |
t.size() → torch.Size([2, 3]) |
.dtype |
数据类型 | t.dtype → torch.float32 |
.device |
所在设备（CPU/GPU） | t.device → device(type='cpu') |
.ndim |
维度数量 | t.ndim → 2 |
.numel() |
元素总数 | t.numel() → 6 |
.requires_grad |
是否需要梯度 | t.requires_grad → True/False |
张量数据类型
| 类型 | 用途 | 内存占用 |
|---|---|---|
torch.float32 |
深度学习默认 （绝大多数场景），深度学习标准 | 4字节 |
torch.float16 |
省显存、加速（混合精度训练），GPU 加速，省显存 | 2字节 |
torch.int64 |
索引、标签 | 8字节 |
torch.int32 |
节省内存的整数 | 4字节 |
torch.int8 |
极省内存（量化模型） | 1字节 |
torch.bool |
条件判断、掩码 | 1字节 |
精度规则
类型提升（低精度 → 高精度）
int16 + float32 → float32 # 自动提升
int8 + int32 → int32 # 自动提升PyTorch 在处理不同类型张量的运算时，会遵循类型提升规则：
低精度类型会自动提升为高精度类型，避免数据丢失。
（2）对比普通变量与张量
| 对比维度 | 普通 Python 变量 | PyTorch 张量 |
|---|---|---|
| 本质 | Python 对象的引用（指向内存中的整数、字符串、列表等） | 一个连续内存块，存储大量同类型数值（类似数组） |
| 能装什么 | 任意类型（int, float, str, list, dict, 自定义对象...） | 只能是数值（int, float，且所有元素类型必须一致） |
| 计算方式 | 解释器逐行执行，循环慢 | 向量化运算（底层 C++/CUDA 实现，极快） |
| 硬件支持 | 只能 CPU | ✅ CPU + GPU（.to('cuda')） |
| 自动求导 | ❌ 不支持 | ✅ 支持（requires_grad=True） |
| 存储结构 | 分散在堆内存中，元素可能不连续 | 连续内存块（访问效率高） |
| 典型用途 | 逻辑控制、字符串处理、数据结构存储 | 数值计算、深度学习、科学计算 |
（3）使用场景
| 场景 | 用谁 | 为什么 |
|---|---|---|
| 存放图片、音频、文本向量 | 张量 | 数据量大，需要 GPU 加速和批量运算 |
| 神经网络权重和偏置 | 张量 | 需要自动求导来更新 |
| 记录训练日志（loss、acc） | 普通变量 | 就是单个数字，不需要张量的超能力 |
| 字符串处理、文件路径 | 普通变量 | 张量不支持字符串 |
简单的数学计算（a+b） |
都可以，少量数据用普通变量即可 | 杀鸡不用牛刀 |
| 大量数据排序、统计 | 张量（或 NumPy） | 向量化操作快得多 |
（4）代数运算
| 运算 | 运算符 | 函数 | 是否支持广播 | 说明 |
|---|---|---|---|---|
| 加法 | + |
torch.add(a, b) |
✅ 支持 | 对应元素相加 |
| 减法 | - |
torch.sub(a, b) |
✅ 支持 | 对应元素相减 |
| 乘法（逐元素） | * |
torch.mul(a, b) |
✅ 支持 | 对应元素相乘（哈达玛积） |
| 除法 | / |
torch.div(a, b) |
✅ 支持 | 对应元素相除 |
| 幂运算 | ** |
torch.pow(a, b) |
✅ 支持 | a 的 b 次方 |
| 取负 | - |
torch.neg(a) |
N/A | 取每个元素的相反数 |
| 绝对值 | - | torch.abs(a) |
N/A | 取每个元素的绝对值 |
| 平方根 | - | torch.sqrt(a) |
N/A | 取每个元素的平方根 |
| 指数 | - | torch.exp(a) |
N/A | e 的 a 次方 |
| 自然对数 | - | torch.log(a) |
N/A | ln(a) |
| 取整 | - | torch.floor(a) torch.ceil(a) torch.round(a) |
N/A | 向下/向上/四舍五入取整 |
| 取余 | % |
torch.remainder(a, b) |
✅ 支持 | a 除以 b 的余数 |
大部分逐元素运算（如加减乘除）确实要求形状完全一致，但 PyTorch 有一个"外挂"叫"广播机制（Broadcasting）"，可以在特定条件下让形状不同的张量也能运算
广播：从最后一个维度开始，往前比较两个张量的形状，必须满足以下条件之一：
-
维度大小相等（比如都是 3）
-
其中一个维度大小是 1（可以被拉伸）
-
其中一个张量缺少这个维度（视为 1）
import torch
A = torch.tensor([[1, 2, 3], [4, 5, 6]]) # 形状 (2, 3)
B = torch.tensor([10, 20, 30]) # 形状 (3,)
C = A + B
print(C)[[1+10, 2+20, 3+30], → [[11, 22, 33],
[4+10, 5+20, 6+30]] [14, 25, 36]]
如果两个张量在某个维度上既不相等，也没有 1，就无法广播，直接报错。
（6）向量/矩阵运算
| 运算 | 运算符 | 函数 | 形状要求 | 说明 |
|---|---|---|---|---|
| 向量点积（内积） | - | torch.dot(a, b) |
两者都是 1D，且长度相同 | 对应元素相乘再求和 → 标量 |
| 矩阵乘法（2D） | @ |
torch.mm(a, b) |
a: (m×n), b: (n×p) | 标准矩阵乘法 → (m×p) |
| 批量矩阵乘法（3D+） | @ |
torch.bmm(a, b) |
a: (b×n×m), b: (b×m×p) | 批量矩阵乘法 → (b×n×p) |
| 通用矩阵乘法（任意维度） | @ |
torch.matmul(a, b) |
自动适配 | 最推荐，自动处理各种维度 |
| 向量×矩阵 | @ |
torch.matmul(a, b) |
a: (n,), b: (n, m) | → (m,) |
| 矩阵×向量 | @ |
torch.matmul(a, b) |
a: (m, n), b: (n,) | → (m,) |
| 外积 | - | torch.outer(a, b) |
两者都是 1D | a 和 b 的外积 → (len(a), len(b)) |
| 矩阵转置 | .T |
torch.transpose(a, 0, 1) |
2D | 行列互换 |
| 矩阵求逆 | - | torch.inverse(a) |
方阵 (n×n) | 矩阵的逆 |
| 矩阵行列式 | - | torch.det(a) |
方阵 (n×n) | 计算行列式（标量） |
| 特征值/特征向量 | - | torch.linalg.eig(a) |
方阵 (n×n) | 计算特征值和特征向量 |
1.2 元素选取（重要）
| 方式 | 示例 | 返回类型 | 是否共享 内存 | 修改是否 影响原张量 |
|---|---|---|---|---|
| 整数索引 | a[2, 3] |
标量（或降维张量） | ❌ 复制 | ❌ 不会 |
| 整数张量索引（花式索引） | a[[2, 3], [1, 2]] |
新张量（形状同索引形状） | ❌ 复制 | ❌ 不会 |
| 切片 | a[1:4, 2:5] |
视图（View） | ✅ 共享 | ✅ 会 |
| 切片 + 整数索引（混合） | a[1:4, 2] |
视图（View） | ✅ 共享 | ✅ 会 |
| 切片 + 花式索引（混合） | a[1:4, [1, 2]] |
可能复制（⚠️ 不保证视图） | ❌ 不保证 | ❌ 可能不会 |
clone() |
a[1:4].clone() |
独立副本 | ❌ 不共享 | ❌ 不会 |
索引
python
torch.manual_seed(42)
a=torch.randint(1,10,(4,4),dtype=torch.int8)
# tensor([[7, 6, 8, 5],
# [1, 3, 8, 6],
# [5, 3, 5, 5],
# [9, 1, 1, 5]], dtype=torch.int8)
ix=a[[2,3],[2]] # [2,3]指2行，3行 ，[2]指2列，索引从0开始计
print(ix) #tensor([5, 1], dtype=torch.int8)
ix[1]=8 #当前只有索引 0 和 1
print(a) # a是不变的哈切片
python
# 切片
# a=tensor([[7, 6, 8, 5],
# [1, 3, 8, 6],
# [5, 3, 5, 5],
# [9, 1, 1, 5]], dtype=torch.int8)
slice=a[:2,:3] #取前两行（索引 0 和 1）和前 3 列（索引 0，1，2）
slice[0][2]=12 #修改值
print(a)
#原张量a发生变化了 tensor([[ 7, 6, 12, 5],
# [ 1, 3, 8, 6],
# [ 5, 3, 5, 5],
# [ 9, 1, 1, 5]], dtype=torch.int8)假设张量 a 是：
列0 列1 列2 列3
行0 1 2 3 4
行1 5 6 7 8 ← 前两行（行0，行1）
行2 9 10 11 12
↑ ↑
前3列 第4列不取
(列0,1,2)执行 slice = a[:2, :3] 后，slice 得到的是绿色框里的部分：
slice = [[1, 2, 3], ← 行0，列0-2
[5, 6, 7]] ← 行1，列0-2-
:单独使用 = 全部取 -
:n= 从开头取到第 n-1 个（前 n 个） -
m:n= 从第 m 个取到第 n-1 个 -
m:= 从第 m 个取到最后 -
::k= 步长为 k -
本质上都是m：n：k，上面的写法是省略的写法
m：起始索引（包含）
n：结束索引（不包含）
k：步长（默认为 1）
| 参数 | 步长为正（step > 0） |
步长为负（step < 0） |
|---|---|---|
start 默认值 |
0（开头） |
-1（末尾，即最后一个元素） |
stop 默认值 |
张量长度（末尾之后） | 负的 张量长度 减 1（开头之前） |
| 取值方向 | 从左到右（正向） | 从右到左（反向） |
克隆
python
# 克隆：clone后是新副本
torch.manual_seed(42)
q=torch.rand((2,3),dtype=torch.float16)
# tensor([[0.8823, 0.9150, 0.3828],
# [0.9595, 0.3904, 0.6011]], dtype=torch.float16)
slice1=q[:2,:1].clone()
print(slice1)
# tensor([[0.8823],
# [0.9595]], dtype=torch.float16)
slice1[1][0]=12 #修改值
print(q)
# tensor([[0.8823, 0.9150, 0.3828],
# [0.9595, 0.3904, 0.6011]], dtype=torch.float16)极值
python
# q=tensor([[0.8823, 0.9150, 0.3828],
# [0.9595, 0.3904, 0.6011]], dtype=torch.float16)
print(q.max()) #全局最大值
#tensor(0.9595, dtype=torch.float16)
print(q.min()) #全局最小值
#tensor(0.3828, dtype=torch.float16)
print(q.max(0)) #每列最大值 ，等价q.max(dim=0)
# torch.return_types.max(
# values=tensor([0.9595, 0.9150, 0.6011], dtype=torch.float16),
# indices=tensor([1, 0, 1]))
print(q.min(1)) #行最小值，等价q.max(dim=1)
# values=tensor([0.3828, 0.3904], dtype=torch.float16),
# indices=tensor([2, 1]))张量 q (2行 × 3列):
列0 列1 列2
行0 0.8823 0.9150 0.3828 ← 行0的最小值在列2 (0.3828)
行1 0.9595 0.3904 0.6011 ← 行1的最小值在列1 (0.3904)
↑ ↑ ↑
列0最大 列1最大 列2最大
在行1 在行0 在行1
(0.9595) (0.9150) (0.6011)1.3 元素修改
| 步骤 | 操作类别 | PyTorch函数/方法 | 说明 | 代码示例 |
|---|---|---|---|---|
| 调整shape | 改变形状 | torch.reshape() / tensor.view() |
返回新的形状视图（view要求内存连续） | x = torch.randn(4, 6) y = x.view(3, 8) z = x.reshape(2, 12) |
| 压缩/扩展维度 | torch.squeeze() / torch.unsqueeze() |
删除/增加大小为1的维度 | x = torch.randn(1, 3, 1, 5) y = x.squeeze() # (3,5) z = x.unsqueeze(0) # (1,1,3,1,5) |
|
| 转置（交换维度） | torch.transpose() / tensor.permute() |
交换指定维度 / 按新顺序重排维度 | x = torch.randn(2, 3, 4) y = x.transpose(0, 1) # (3,2,4) z = x.permute(2, 0, 1) # (4,2,3) |
|
| 展平 | torch.flatten() |
将指定维度展平为一维 | x = torch.randn(2, 3, 4) y = x.flatten(start_dim=1) # (2,12) |
|
| 调整 类型 | 数据类型转换 | tensor.to(dtype) / tensor.type() |
改变张量的数据类型 | x = torch.tensor([1, 2]) y = x.to(torch.float32) z = x.type(torch.float64) |
| 设备转换 | tensor.to(device) |
在CPU/GPU之间移动张量 | x = torch.randn(3,4) y = x.to('cuda') z = x.to('cpu') |
|
| 调整 维度 | 增加新维度 | torch.unsqueeze() |
在指定位置插入大小为1的新维度（同上面） | 同上 unsqueeze |
| 删除维度（大小为1） | torch.squeeze() |
删除所有或指定大小为1的维度（同上面） | 同上 squeeze | |
| 维度重排 | torch.permute() / tensor.transpose() |
任意交换维度顺序 / 交换两个维度（同上） | 同上 permute / transpose | |
| 拆分 | 按块拆分 | torch.chunk() |
将张量沿指定维度均匀拆分为多个块 | x = torch.randn(4, 8) chunks = x.chunk(2, dim=1) # 两个 (4,4) |
| 按大小拆分 | torch.split() |
沿指定维度按指定大小或列表拆分 | x = torch.randn(4, 8) splits = x.split([3, 5], dim=1) # (4,3), (4,5) |
|
| 按索引拆分 | torch.index_select() |
按索引选择特定行/列（非严格拆分，但常用） | x = torch.randn(4, 8) indices = torch.tensor([0, 2]) y = x.index_select(0, indices) # (2,8) |
|
| 合并 | 拼接 | torch.cat() |
沿已有维度拼接（不增加维度） | a = torch.randn(2,3) b = torch.randn(2,3) c = torch.cat([a,b], dim=0) # (4,3) |
| 堆叠 | torch.stack() |
沿新维度堆叠（增加维度） | a = torch.randn(2,3) b = torch.randn(2,3) c = torch.stack([a,b], dim=0) # (2,2,3) |
2.自动求导
在训练神经网络时，我们需要不断调整参数（权重和偏置），让模型的预测结果越来越准。
-
怎么调整？ → 使用梯度下降（Gradient Descent）
-
梯度是什么？ → 梯度是损失函数对参数的偏导数，它指出了参数应该"往哪个方向调"能让损失下降得最快。
-
求梯度需要计算导数，神经网络动辄百万、千万级别的参数，手动求导根本不现实。
于是PyTorch提供了**自动求导（Autograd）**机制：你只需要定义好前向计算（输入→输出），PyTorch会自动帮你算出所有参数的梯度。
（1）数学公式理解
（2）训练过程
┌─────────────────────────────────────────────────────┐
│ 训练过程 │
│ │
│ ① 提前准备好样本 ② 随机初始化 ③ 计算误差 │
│ (x, y) + θ 组 → h(x) - y │
│ (固定不变) (动态值) (判断差多少) │
│ ↑ │
│ │ │
│ ⑤ 更新 θ 组 ←──────────④ 梯度下降 │
│ (动态调整) (根据误差方向调整) │
│ │ │
│ ⑥ 重复 ①~⑤ 很多次... │
│ ↓ │
│ ⑦ 最终 θ 组固定下来（收敛），模型训练完成！ │
└─────────────────────────────────────────────────────┘(x, y)（样本值）
-
(x, y)（样本值）就是训练集（Training Set）。
-
作用： 它们是"标准答案"或"老师"。在训练开始前，这些数据已经收集好了（比如过去一年的房价、猫狗的图片标签）。模型最终学得好不好，就是看预测出来的 h(x) 跟这些提前准备好的 y 像不像。
θ 组（参数）
-
θ 组（参数）叫模型的权重（Weights） 或参数（Parameters）。
-
作用： 它们就像是一块橡皮泥 ，或者是收音机上的调频旋钮。
-
一开始，它们是随机的（比如全是0或者随机小数）。
-
在训练过程中，它们会动态地、一步一步地（通过梯度下降）发生变化。
-
最终，它们会固定下来，变成一组最优的值。这时候，模型就"训练好了"。
-
梯度下降
假设损失函数是 J(θ)=θ^2（一个简单的抛物线），我们想找到使 J 最小的 θ。
手动计算过程
| 步骤 | θθ 值 | 梯度 J′(θ)=2θJ′(θ)=2θ | 更新（α=0.1α=0.1） | 新 θθ |
|---|---|---|---|---|
| 初始 | 10.0 | 20.0 | 10−0.1×20=8.0 | 8.0 |
| 第2步 | 8.0 | 16.0 | 8−0.1×16=6.4 | 6.4 |
| 第3步 | 6.4 | 12.8 | 6.4−0.1×12.8=5.12 | 5.12 |
| ... | ... | ... | ... | ... |
| 第N步 | ≈ 0 | ≈ 0 | 趋近0 | ≈ 0 |
代入到"房价预测"场景
假设我们要预测房价：
-
提前准备的样本 (x, y)：
-
x（面积）：80㎡，100㎡，120㎡
-
y（真实房价）：200万，250万，300万
-
-
θ 组（动态调整的参数）：
-
假设模型是
-
一开始：θ0=0,θ1=1,预测 80㎡ 只有 80万（离谱！误差巨大）。
-
训练中：通过梯度下降，θ1 从 1 慢慢变成 2.5，θ0 从 0 慢慢变成 0。
-
最终：θ0=0,θ1=2.5。模型变成 h(x)=2.5x。预测 80㎡ 得出 200万，完美匹配！
-
（3）PyTorch
python
# 自动求导
# 1.第一个参数：1.0（data）:传入 1.0（Python 浮点数）→ 创建一个 0 维标量张量，值为 1.0，dtype 默认是 torch.float32。也可以传列表、嵌套列表来创建向量/矩阵：
# 2.requires_grad=True:表示这个张量是否需要被追踪梯度,只有浮点张量才能设 requires_grad=True
x=torch.tensor(2.0,requires_grad=True)
y=x**2+3*x+1
y.backward()
print("x =", x.item()) # x = 2.0
print("y =", y.item()) # y = 11.0
print("dy/dx =", x.grad.item()) #dy/dx = 7.0
# 向量
x1=torch.tensor([1.0,2.9,3.5],requires_grad=True)
w=torch.tensor([3.0,5.1,4.5],requires_grad=True)
b=torch.tensor([3.0,6.0,3.0],requires_grad=True)
y=w*x1+b
# backward() 要求标量
y.sum().backward()
print("dy/dx =", x1.grad) # dy/dx = tensor([3.0000, 5.1000, 4.5000])
print("dy/dw =", w.grad) # dy/dw = tensor([1.0000, 2.9000, 3.5000])
print("dy/db =", b.grad) # dy/db = tensor([1., 1., 1.])3.其他框架
| 分类 | 工具名称 | 所属公司 / 组织 | 流行程度与现状 |
|---|---|---|---|
| 基本操作层 | PyTorch | Meta (Facebook) | 极流行：AI顶会论文中占比达80%，是当前研究与开发的主流框架。 |
| TensorFlow | 流行：市场占有率约37.5%，是企业级生产部署的重要选择。 | ||
| MXNet | Apache 基金会 | 已淘汰：曾由AWS支持，但官方已停止维护，不建议在新项目中使用。 | |
| 集成、优化层 | Keras | 流行：TensorFlow官方高层API，用户友好，适合快速搭建原型。 | |
| PyTorch Lightning | Grid.ai (社区项目) | 流行：为PyTorch提供轻量级封装，将工程代码与科学逻辑分离，便于大规模训练。 | |
| FastAI | fast.ai (社区项目) | 小众但口碑好：在PyTorch之上构建，以极少的代码实现高质量基线，在教育领域很受欢迎。 | |
| 模型应用层 | Transformers | Hugging Face | 极流行：提供数千个预训练模型的统一接口，GitHub星标超16万，是NLP和基础模型时代的标准。 |
| ModelScope (魔搭) | 阿里巴巴达摩院 | 国内流行：国内最大的开源模型社区之一，提供模型体验、训练、部署一站式服务。 | |
| Paddle系列 (飞桨) | 百度 | 特定领域流行：中国首个自主研发的产业级深度学习平台，在中文NLP、OCR等场景有独特优势。 |
-
做研究或跟踪前沿模型 ，PyTorch + Transformers 是当前最常见的组合。
-
面向企业生产部署 ，TensorFlow/Keras 或 PaddlePaddle 在工程化方面有成熟的工具链。
-
快速验证想法或做教学演示 ，FastAI 和 Keras 的上手成本会低很多。
-
国内中文场景 ，ModelScope 和 Paddle系列 的本土化支持会更有优势。
如果下次有人给你推荐一个新的 AI 框架，你可以用这张图里的四个维度问自己：
-
接口友好吗？ 我大概要花多久才能写个 Demo 出来？
-
定位匹配吗？ 它是适合做研究快速试错，还是适合明天上线给客户用？
-
性能可迭代吗？ 如果未来数据量涨 10 倍，这个框架有现成的优化方案吗？
-
社区有活人吗？ 遇到问题，我能多快找到答案或源码？有人理你吗？