AIPython

PyTorch 和 Transformer 简单介绍

Posted Cola🌀

前言 🔖

PyTorch 是一个 Python 语言的深度学习工具箱（AI 框架），PyTorch 最初由 Meta Platforms 的人工智能研究团队开发，现在属于Linux 基金会的一部分。PyTorch 以其灵活性和易用性而闻名，特别适合于深度学习研究和开发。

它本身不是大模型，不是 AI，不能直接聊天、不能生成图片。它就相当于一套高级 “工程机械工具箱”：提供张量、矩阵运算、GPU 调度、自动求导全套工具。

AI 工程师拿着这套工具箱，去搭建、训练、运行神经网络（大模型、图像模型）。

类比现实：
PyTorch = 修理厂全套工具（扳手、焊机、变速箱测试台）
大模型 (Qwen、Flux) = 用这套工具组装出来的汽车。
工具本身不会跑，工程师使用工具，造出可以跑的车。

许多深度学习软件都是基于 PyTorch 构建的，包括特斯拉自动驾驶、Uber 的 Pyro、Hugging Face 的 Transformers、 PyTorch Lightning 和 Catalyst。

PyTorch 主要有两大特征：

  • 类似于 NumPy 的张量计算，能在 GPU 或 MPS 等硬件加速器上加速。
  • 基于带自动微分系统的深度神经网络。

　　

PyTorch 核心的几大基础特征 🔖

🔹1. 张量 Tensor —— AI 世界的通用数据容器

普通 Python 只能处理数字、列表。

PyTorch 中的核心数据结构是 张量（Tensor），它是一个多维矩阵，可以在 CPU 或 GPU 上高效地进行计算。张量的操作支持自动求导（Autograd）机制，使得在反向传播过程中自动计算梯度，这对于深度学习中的梯度下降优化算法至关重要。

张量就是多维数字数组，是 PyTorch 的核心。

  • 文字、图片，不能直接喂给神经网络。
  • 文字经过分词器变成数字 ID，图片转成像素数字，全部封装成张量。
  • 张量可以搬家：可以放在 CPU 内存，也可以搬到 GPU（N 卡 CUDA / Mac MPS），利用显卡高速并行计算。
  • 提供了类似 NumPy 的接口，支持元素级运算。
  • 支持自动求导，可以方便地进行梯度计算。
大模型里面亿级别的权重参数，全部存储为张量。.safetensors文件，本质就是把大量张量序列化保存到磁盘。

　　

🔹2. 自动求导 Autograd（训练 AI 的灵魂）

这是 AI 框架最硬核的能力。训练模型的时候：

  • 输入张量走网络计算，得到输出；
  • 对比标准答案，算出误差 loss；
  • loss.backward()自动反向求导，自动算出每一个权重该往哪个方向修改；
  • 优化器自动更新 safetensors 里面亿万权重数值。
如果没有自动求导，人类需要手写成千上万行微积分，几乎不可能训练出大模型。

⚠️区分两种模式

推理模式：只前向计算（ComfyUI 生图、大模型对话），不需要反向求导。
训练 / 微调模式：前向 + 反向求导，更新权重，产出新的 safetensors。

　　

🔹3. GPU 加速

PyTorch 完全支持在 GPU 上运行，以加速深度学习模型的训练。通过简单的 .to(device) 方法，用户可以将模型和张量转移到 GPU 上进行计算。PyTorch 支持多 GPU 训练，能够利用 NVIDIA CUDA 技术显著提高计算效率。

GPU 支持：

  • 自动选择 GPU 或 CPU。
  • 支持通过 CUDA 加速运算。
  • 支持多 GPU 并行计算（DataParallel 或 torch.distributed）。

　　

🔹4.模型定义与训练

PyTorch 提供了 torch.nn 模块，允许用户通过继承 nn.Module 类来定义神经网络模型。使用 forward 函数指定前向传播，自动反向传播（通过 autograd）和梯度计算也由 PyTorch 内部处理。

神经网络模块（torch.nn）：

  • 提供了常用的层（如线性层、卷积层、池化层等）。
  • 支持定义复杂的神经网络架构（包括多输入、多输出的网络）。
  • 兼容与优化器（如 torch.optim）一起使用。

　　

🔹5.生态系统与社区支持

PyTorch 作为一个开源项目，拥有一个庞大的社区和生态系统。它不仅在学术界得到了广泛的应用，也在工业界，特别是在计算机视觉、自然语言处理等领域中得到了广泛部署。PyTorch 还提供了许多与深度学习相关的工具和库，如：

  • torchvision：用于计算机视觉任务的数据集和模型。
  • torchtext：用于自然语言处理任务的数据集和预处理工具。
  • torchaudio：用于音频处理的工具包。
  • PyTorch Lightning：一种简化 PyTorch 代码的高层库，专注于研究和实验的快速迭代。

　　

🔹6.PyTorch 特性

  • 动态计算图（Dynamic Computation Graphs）： PyTorch 的计算图是动态的，这意味着它们在运行时构建，并且可以随时改变。这为实验和调试提供了极大的灵活性，因为开发者可以逐行执行代码，查看中间结果。
  • 自动微分（Automatic Differentiation）： PyTorch 的自动微分系统允许开发者轻松地计算梯度，这对于训练深度学习模型至关重要。它通过反向传播算法自动计算出损失函数对模型参数的梯度。
  • 张量计算（Tensor Computation）： PyTorch 提供了类似于 NumPy 的张量操作，这些操作可以在 CPU 和 GPU 上执行，从而加速计算过程。张量是 PyTorch 中的基本数据结构，用于存储和操作数据。
  • 丰富的 API： PyTorch 提供了大量的预定义层、损失函数和优化算法，这些都是构建深度学习模型的常用组件。
  • 多语言支持： PyTorch 虽然以 Python 为主要接口，但也提供了 C++ 接口，允许更底层的集成和控制。

　　

与其他框架的对比 🔖

PyTorch 由于其灵活性、易用性和社区支持，已经成为很多深度学习研究者和开发者的首选框架。

🔹TensorFlow vs PyTorch

  • PyTorch 的动态计算图使得它更加灵活，适合快速实验和研究；而 TensorFlow 的静态计算图在生产环境中更具优化空间。
  • PyTorch 在调试时更加方便，TensorFlow 则在部署上更加成熟，支持更广泛的硬件和平台。
  • 近年来，TensorFlow 也引入了动态图（如 TensorFlow 2.x），使得两者在功能上趋于接近。
  • 其他深度学习框架，如 Keras、Caffe 等也有一定应用，但 PyTorch 由于其灵活性、易用性和社区支持，已经成为很多深度学习研究者和开发者的首选框架。
特性TensorFlowPyTorch
开发公司GoogleFacebook (FAIR)
计算图类型静态计算图（定义后再执行）动态计算图（定义即执行）
灵活性低（计算图在编译时构建，不易修改）高（计算图在执行时动态创建，易于修改和调试）
调试较难（需要使用 tf.debugging 或外部工具调试）容易（可以直接在 Python 中进行调试）
易用性低（较复杂，API 较多，学习曲线较陡峭）高（API 简洁，语法更加接近 Python，容易上手）
部署强（支持广泛的硬件，如 TensorFlow Lite、TensorFlow.js）较弱（部署工具和平台相对较少，虽然有 TensorFlow 支持）
社区支持很强（成熟且庞大的社区，广泛的教程和文档）很强（社区活跃，特别是在学术界，快速发展的生态）
模型训练支持分布式训练，支持多种设备（如 CPU、GPU、TPU）支持分布式训练，支持多 GPU、CPU 和 TPU
API 层级高级 API：Keras；低级 API：TensorFlow Core高级 API：TorchVision、TorchText 等；低级 API：Torch
性能高（优化方面成熟，适合生产环境）高（适合研究和原型开发，生产性能也在提升）
自动求导通过 tf.GradientTape 实现动态求导（较复杂）通过 autograd 动态求导（更简洁和直观）
调优与可扩展性强（支持在多平台上运行，如 TensorFlow Serving 等）较弱（虽然在学术和实验环境中表现优越，但生产环境支持相对较少）
框架灵活性较低（TensorFlow 2.x 引入了动态图特性，但仍不完全灵活）高（动态图带来更高的灵活性）
支持多种语言支持多种语言（Python, C++, Java, JavaScript, etc.）主要支持 Python（但也有 C++ API）
兼容性与迁移TensorFlow 2.x 与旧版本兼容性较好与 TensorFlow 兼容性差，迁移较难

　　

🔹PyTorch vs NumPy

特性PyTorchNumPy
目标深度学习专用通用科学计算
GPU 支持原生支持 CUDA不直接支持
自动微分内置自动求导需要手动计算梯度
神经网络丰富的神经网络模块需要从零实现
学习成本相对较高相对较低

　　

很多大模型都是 PyTorch 训练出来的吗？🔖

是的，现在几乎所有主流开源大模型：Qwen、Llama、DeepSeek、Z‑Image‑Turbo、Flux，绝大多数都是用 PyTorch 完成训练。

  • 早期部分老模型有用 TensorFlow；
  • 少量实验室用 JAX；
  • 但开源圈子、国内大厂，PyTorch 是绝对主流。
训练的时候：
PyTorch 框架负责：张量管理、矩阵运算、GPU 调度 (CUDA)、自动求导反向传播、更新权重。
训练跑在大量 NVIDIA 显卡集群上。

大模型训练完成之后，产出什么（重点）

训练跑完，不会直接出来一个可以双击运行的程序。输出一堆文件，这就是PyTorch 原生产物：

  1. config.json
    • 模型配置文件：层数、注意力头数、上下文窗口大小、hidden 维度等，记录神经网络 “图纸”。
  2. .safetensors（分片权重文件）
    • 真正的模型参数，亿万浮点数权重。
    • 比如：model‑00001‑of‑00026.safetensors
    • 这就是PyTorch 原生权重，只有一堆数字。
  3. 分词器相关：tokenizer.json、vocab.json
    • 负责文字转数字 token。
  4. 有些还会附带model.py模型代码（网络结构实现）

整套合在一起，才是完整原版模型，只有 safetensors，没有 config，是加载不了模型的。

大量训练数据 → PyTorch框架 + 多块N卡集群训练
        ↓
【产出】config.json + 一堆safetensors权重 + 分词器文件（原生PyTorch产物）

　　

Transformer 是什么？为什么有 PyTorch 还需要 Transformer？🔖

先分清两个角色，这是很多人混淆的关键点：

PyTorch：通用计算工具箱（底层积木，什么深度学习都能做）
Transformer：一种特定神经网络的「算法 / 网络架构」（专门处理序列、文字的一套拼装方案）

通俗比喻：

  • PyTorch = 五金工具箱：里面有螺丝、螺母、扳手、矩阵乘法工具、张量、自动求导。工具箱本身不代表某个机器，你可以用它搭 CNN 图像卷积网络、RNN、Transformer，随便什么网络。
  • Transformer = 一张完整的机器组装图纸：规定怎么把工具箱里的零件拼出一台专门处理文字的机器。

工具箱 (PyTorch) 不能直接产出大模型；你需要按照 Transformer 这张图纸，拿工具箱的零件把机器拼出来。

🔹Transformer 是什么？

Transformer 是 2017 年论文提出的神经网络结构，核心发明是 自注意力机制（Self‑Attention）。专门解决：文字、对话这类序列数据。

  • 以前老网络 RNN：文字要一个字一个顺序串行算，慢，长文本记不住。
  • Transformer 的自注意力：可以同时看整段所有 token，看词语之间的关联。
举例子句子：小明把杯子递给了他
自注意力可以识别出：“他” 指的是小明。
这就是大模型理解上下文的根源。

Transformer 由两大块组成：

  1. 编码器 Encoder：理解输入（翻译模型用）
  2. 解码器 Decoder：生成文字，现在所有大语言模型只用 Decoder 部分。 Qwen、Llama、DeepSeek 全部都是 Decoder‑only Transformer。

它内部的组件：

  • 多头自注意力 Multi‑Head Attention
  • 前向网络 FFN
  • 归一化层 RMSNorm/LayerNorm
  • 位置编码 RoPE，告诉模型文字的先后顺序

这些组件，全部都是用 PyTorch 的 API 写出来的。

Attention 本质就是大量矩阵乘法，矩阵乘法就是 PyTorch 提供的算子。

　　

🔹为什么有 PyTorch，还需要 Transformer？

PyTorch 只是基础工具，它不知道 “怎么理解语言”，PyTorch 会做矩阵乘、张量、求导，但它不懂什么是句子、什么是上下文关系。PyTorch 没有内置 “大模型”。你必须人写代码，把 Attention、FFN 一层层组装起来，这个组装方案就是 Transformer。

  • PyTorch：通用深度学习工具库，提供张量、矩阵运算、GPU 调度、自动求导。本身不懂语言。
  • Transformer：一套神经网络架构（算法图纸），依靠自注意力，擅长处理文字序列，现在大模型的标准方案。
  • PyTorch 用来实现运行 Transformer；二者不是二选一，是图纸 vs 工具的关系。
  • Transformer 这套算法逻辑，不只可以跑在 PyTorch，也可以用 C++(llama‑cpp)、MLX、JAX 实现。
  • config.json里面保存的，就是这个 Transformer 网络的图纸参数。

　　

🔹Transformer 是大模型的核心设计架构

Transformer 是大模型的核心设计架构（神经网络图纸），但 Transformer ≠ 大模型本身。

打个比方：

Transformer = 汽车的设计图纸（规定发动机怎么布局、变速箱结构）
大模型 = 按照这份图纸造出来的一台完整汽车。
  1. 现在几乎所有开源大语言模型 Qwen、Llama、DeepSeek，用的都是 Transformer 的 Decoder‑only（仅解码器）变体。config.json 里面存的：层数、注意力头数、隐藏维度、RoPE 参数，全部就是这份 Transformer 图纸上的参数。
  2. 有了架构图纸（Transformer），还需要两样东西才叫一个可用大模型：
    • 海量训练数据，喂给 PyTorch 去训练；
    • 训练出来的数十亿权重（safetensors），也就是模型学到的知识。
    • 同样一张 Transformer 图纸，用不同数据训练，可以得到完全不一样能力的模型。
  3. Transformer 不是只有大语言模型在用
    • 多模态 Qwen‑VL：主干依旧是 Transformer Decoder，额外加一个图像编码器；
    • Flux / Z‑Image‑Turbo（DiT）：也是基于 Transformer 架构做图像生成。
  4. 重要：架构是算法思想，可以用不同工具实现
    • PyTorch：Python 实现 Transformer，用来训练、微调；
    • llama‑cpp：C++ 手写重写一遍一模一样的 Transformer Decoder 逻辑，读 GGUF 做推理，不再依赖 PyTorch。
    • 架构（Transformer）没变，只是换了一套代码工具去运行它。

Transformer 是当代大模型的标准设计架构（网络结构图纸）；

大模型 = Transformer 架构 + 训练得到的权重知识。

　　

各家大模型都是底层都是 Transformer架构，为什么模型出来差距巨大？🔖

这个问题特别关键：都是 PyTorch，底层都是 Transformer，输入都是 token / 张量，但各家模型出来差距巨大，并不是套同一个模板就完事。

打个比方：

大家都用同一套乐高积木（PyTorch 框架、Transformer 基础组件）。
但不同工程师，选的零件数量、拼装方式、训练数据、训练配方、目标不一样，拼出来的成品完全不一样。
积木库是一样的，不等于造出来的车都一样。

大模型差别到底在哪

🔹1、训练用的数据不一样（最大的区别）

同样的网络结构，喂不同数据，模型性格、知识、能力天差地别。

  • Qwen：大量中文互联网、书籍、多语言数据；中文能力强。
  • Llama：英文为主，中文原始版本弱。
  • DeepSeek：大量代码、推理类文本，擅长做题写代码。
训练 = 模型在海量数据里面统计学习语言规律。
数据的质量、语种、题材、清洗过滤方式，直接决定模型懂什么、不懂什么、会不会胡说。
哪怕网络一模一样，换一套数据集，模型就变成另一个 “脑子”。

　　

🔹2、模型结构细节不一样（虽然都是 Transformer）

都叫 Transformer，但可以改很多地方：

  1. 层数、头数、隐藏维度：27B、14B、7B，规模本身就不同。
  2. 变体：MoE 混合专家 / 稠密模型；RMSNorm / LayerNorm；不同的激活函数（SwiGLU 等等）。
  3. 位置编码：RoPE，不同的旋转基数、最大上下文窗口设置。
  4. 多模态：图像编码器选型不一样（Qwen‑VL 和 LLaVA 的视觉模块完全不同）。

这些细节全部写在 config.json，你打开两个不同模型的 config.json 对比，很多参数是不一样的。

　　

🔹3、训练配方不一样（超参）

就算数据、网络完全相同，训练配方不同结果也不同：

  • 学习率多大
  • batch 大小
  • 训练多少万亿 token
  • 优化器（AdamW 各类变种）
  • dropout、权重衰减
  • 预热、调度器策略

就像同样的面粉水，不同温度、发酵时间，烤出来面包口感完全不同。

　　

🔹4、预训练之后，后续微调不一样

预训练是学通用知识；

之后还要做：SFT 监督微调、RLHF/RLAIF 人类对齐。

  • 有的侧重对话友好；
  • 有的侧重推理；
  • 有的偏向编码；
  • 有的做去限制（uncensored）社区二次微调。

很多社区魔改模型（比如Qwen3.6‑27B‑Uncensored）：主干权重来自官方 Qwen，只是做二次微调，就性格大变。

　　

🔹5、分词器 tokenizer 不一样

同样一句中文：不同模型分词器切出来的 token ID 序列不一样。

  • token 粒度不同，会影响长文本、中文理解、符号处理。
  • tokenizer 是独立文件，不是网络权重，但是直接影响输入。

　　

🔹6、对齐目标不同

  • 有的模型目标：安全、保守；
  • 有的模型目标：尽可能输出真实回答，少拒绝；
  • 有的优先数学推理；
  • 有的优先代码。
  • 对齐阶段就塑造了模型的 “性格”。

　　

🔹7.梳理整条链路

原始语料库A（Qwen） / 语料库B（Llama）
        ↓
清洗过滤（每家策略不一样）
        ↓
tokenizer分词，转为张量输入PyTorch
        ↓
Transformer网络（结构细节、规模各家有差异）
        ↓
训练超参配方不同，反复更新safetensors权重
        ↓
预训练基础模型
        ↓
SFT / RLHF微调（各家微调数据集、目标不一样）
        ↓
最终产出 config + safetensors权重

全部都跑在 PyTorch 上，但数据、结构细节、训练配方、微调，每一处都可以拉开差距。

Transformer 只是一套计算骨架，真正的知识全部存在safetensors里面那几十亿个浮点数权重。 训练的本质，就是不断调整这堆数字。 不同数据、不同训练过程，最终收敛得到的那堆浮点数完全不一样。

　　

🔹8.举个现实例子

Qwen‑27B 和 Llama3‑27B：

  • 都用 PyTorch 训练
  • 都是 Transformer，输入都是 token 张量 但是：
  1. 训练数据一个侧重中文，一个英文为主
  2. config 网络参数细节有差异
  3. 分词器完全不同
  4. 微调对齐数据集不一样 → 实际对话、写中文、推理能力表现明显不一样。

　　

Mac M 系列 PyTorch MPS 完整小示例 🔖

PyTorch MPS， MPS = Metal Performance Shaders，是苹果给 M 系列芯片（M1/M2/M3/M4/M5）做的GPU 加速后端，对标 N 卡的 CUDA、AMD 的 ROCm。

CUDA → Nvidia 显卡
ROCm → AMD 显卡
MPS → Apple Silicon（M 芯片 Mac）

Metal 是苹果底层 GPU 编程 API；MPS 是构建在 Metal 之上，专门做机器学习矩阵运算的高性能计算库

PyTorch 从 1.12 版本开始官方内置 MPS 后端，可以把张量、神经网络运算交给 Mac 内置 GPU 跑，不再只靠 CPU 慢吞吞计算

新建虚拟环境

python -m venv python-venv

激活虚拟环境

source python-venv/bin/activate

安装torch

python -m pip install torch

运行代码

python demo_torch_mps.py
import torch

# 1. 判断设备：优先MPS，没有就回退CPU
if torch.backends.mps.is_available():
    device = torch.device("mps")
    print("✅ 使用 MPS (Metal GPU)")
else:
    device = torch.device("cpu")
    print("⚠️ MPS不可用，使用 CPU")

# 2. 创建张量，搬运到GPU(MPS)
# 3行，5列的随机数字张量
x = torch.randn(3, 5).to(device)
y = torch.randn(5, 4).to(device)

print("\nx 张量 shape:", x.shape)
print("y 张量 shape:", y.shape)
print("x 的设备:", x.device)

# 3. GPU上做矩阵乘法（AI最核心运算）
z = torch.matmul(x, y)
print("\n矩阵乘法结果z shape:", z.shape)
print(z)

# ----------------------
# 演示：推理(只前向) vs 训练(前向+反向求梯度)
# ----------------------
# 简单神经网络
net = torch.nn.Linear(4, 2).to(device)
out = net(z)

loss = out.sum()
loss.backward()   # 反向传播，训练才会用到！MPS支持反向

print("\n✅ 梯度计算完成，权重存在梯度：")
print(net.weight.grad is not None)  # True代表反向求导正常工作

# 4. 把MPS上的张量拿回到CPU，才能打印/numpy处理
z_cpu = z.to("cpu")
print("\n转回CPU后的张量设备：", z_cpu.device)

运行结果

✅ 使用 MPS (Metal GPU)

x 张量 shape: torch.Size([3, 5])
y 张量 shape: torch.Size([5, 4])
x 的设备: mps:0

矩阵乘法结果z shape: torch.Size([3, 4])
tensor([[-0.1038,  1.3596,  2.0733,  3.7567],
        [ 3.2019, -0.1455, -1.4333,  3.9464],
        [ 2.4885, -2.1966, -0.9626,  1.0828]], device='mps:0')

✅ 梯度计算完成，权重存在梯度：
True

转回CPU后的张量设备： cpu

关键知识点

  • .to(device)：张量搬家，放到 MPS (GPU 统一内存)，后续运算走 Metal 加速。
  • loss.backward()：反向传播，训练才用；ComfyUI 生图只做前向，不需要这行。
  • MPS 上的张量不能直接转 numpy，必须先 .to(“cpu”)。

如果遇到部分算子 MPS 不支持、报错，可以开启降级环境变量：

export PYTORCH_ENABLE_MPS_FALLBACK=1
python demo_torch_mps.py