• 定位：GPU里的通用计算单元，一个核心一次做一个计算
• 计算模式：一次做一个浮点运算（FP32加法/乘法）
• 特点：通用、灵活、什么都能算
• 类比：普通螺丝刀，什么螺丝都能拧
• 数量：H100有18432个CUDA Core

• 定位：专为矩阵乘法设计的加速单元
• 计算模式：一次做一个4×4矩阵乘法（相当于64个乘加运算）
• 特点：专用、超快、但只做矩阵乘
• 类比：电动螺丝刀，拧十字螺丝飞快
• 数量：H100有528个Tensor Core
• 关键：大模型90%的计算量是矩阵乘法，Tensor Core就是为这个设计的

• 定位：最主流的深度学习框架，写模型、训练、推理都用它
• 工作方式：你调 torch.matmul() 时，底层调用CUDA/Tensor Core
• 生态：最大，HuggingFace模型基本都是PyTorch格式
• 编译优化：PyTorch 2.0+ 的 torch.compile 可以自动做算子融合和图编译，提速20-50%
• 两种模式：
  • Eager Mode（默认）：逐算子执行，灵活但慢
  • Compiled Mode（torch.compile）：先编译成优化图再执行，快但调试难

• 全称：Open Neural Network Exchange（开放神经网络交换格式）
• 定位：模型交换格式，类似AI界的"通用语言"
• 工作流：不同框架训练的模型（PyTorch/TensorFlow）→ 转ONNX → 在不同硬件上跑
• 优点：跨平台、可优化、适合部署
• 缺点：有些算子不支持，调试麻烦
• 典型场景：PyTorch训练 → ONNX导出 → TensorRT/ONNX Runtime部署

• 定义：神经网络的最小计算单元，如矩阵乘（MatMul）、卷积（Conv）、归一化（LayerNorm）、激活函数（ReLU）
• CUDA Kernel：每个算子在GPU上对应一个CUDA Kernel（在GPU上跑的小程序）
• 算子融合（Fusion）：把多个小算子合并成一个，减少显存读写，大幅提速
• 经典案例：FlashAttention — 把注意力计算中的多个算子融合，成为现代LLM推理的核心优化
• 新趋势：OpenAI的Triton语言，比CUDA更容易写高性能算子

推理框架 = 让大模型"跑起来"的引擎

你写 response = model.generate("今天天气怎么样？")，背后推理框架做了：

1. 加载模型：从硬盘读到显存
2. 内存管理：KV Cache怎么存、怎么复用
3. 计算调度：哪个算子先跑、哪个后跑
4. 并行优化：多张卡怎么分工
5. 请求排队：100个人同时问怎么处理
6. 输出生成：一个一个token吐出来

两者深度耦合，就像iPhone的iOS一样绑定：

• GGUF的量化方式（k-quants）是llama.cpp特有的
• GGUF的内存映射（mmap）机制与llama.cpp深度集成
• GGUF的设计目标就是在CPU/低配硬件上高效运行

所以：GGUF 不能用 SGLang 跑。 SGLang走的是另一条路：HuggingFace原生格式（SafeTensors）+ AWQ/GPTQ量化。

不同场景的选型建议：

• 低配硬件（CPU/笔记本） → llama.cpp + GGUF ✅
• 高配GPU生产环境 → SGLang/vLLM + AWQ量化 ✅
• 想要跨平台部署 → PyTorch导出ONNX + ONNX Runtime ✅

是的，推理时模型必须放在显存里。 不能"需要时再调"，原因：

• GPU只能访问显存中的数据
• 从CPU内存搬到显存：PCIe带宽 ~64GB/s
• 显存内部计算：HBM带宽 ~3000GB/s
• 差了50倍！所以模型必须常驻显存

应用层       你写的AI应用 / Agent / ComfyUI工作流
              ↓
推理框架     SGLang / vLLM / llama.cpp / TensorRT-LLM
              ↓
模型格式     PyTorch (SafeTensors) → ONNX → GGUF
              ↓
计算库       CUDA / cuDNN / TensorRT / OpenVINO
              ↓
硬件层       NVIDIA GPU（CUDA Core + Tensor Core）

Stable Diffusion生成一张图的完整流程：

输入：文字提示 "一只猫在沙滩上"
       ↓
  [CLIP] ← 把文字变成向量（理解语义）
       ↓
  [UNet] ← 核心！从噪声逐步去噪生成图像
    ├── 卷积层（Conv）→ 提取局部特征
    ├── Transformer层 → 理解全局关系
    └── 注意力机制 → 把文字和图像对齐
       ↓
  [VAE解码器] ← 把压缩的图像还原成高清图
       ↓
输出：一张猫在沙滩上的图片

是什么：用一个"小窗口"（3×3或5×5的矩阵）在图像上滑动，每个位置做一次点乘，提取局部特征。

类比：用手指在照片上摸——摸到边缘→检测到边界，摸到纹理→检测到花纹。

在SD里的作用：UNet的底层构建块，提取局部特征，做上采样/下采样。

通俗理解：卷积 = 用放大镜看图片的每个小区域，找出有什么特征。

是什么：2017年Google提出的架构，核心是自注意力机制（Self-Attention）——每个词/像素都看一遍所有其他词/像素。最早用于文本（GPT就是Transformer），后来用到图像。

类比：你看一张照片时，卷积先看猫的耳朵再看眼睛，Transformer一眼看完整个画面，知道"耳朵、眼睛、尾巴都属于同一只猫"。

在SD里的作用：UNet中的注意力层，建立全局关系，把文字提示和图像内容对齐。

通俗理解：Transformer = 站在高处看全景，知道每个部分和其他部分的关系。

全称：Variational AutoEncoder

是什么：一个"压缩-解压"的神经网络。编码器把大图压缩成小图（潜空间），解码器把小图还原成大图。

类比：把一张4K照片压缩成zip文件——编码器=压缩软件（1024×1024→64×64），解码器=解压软件。

在SD里的作用：

• 直接生成1024×1024图像→计算量太大
• 先压缩到64×64的潜空间→计算量减少256倍！
• UNet在潜空间里做去噪→快很多
• 最后VAE解码器还原成高清图

通俗理解：VAE = 智能压缩工具，把大图压缩成"精华版"来算，算完再解压回原尺寸。

是什么：整个Stable Diffusion的核心"发动机"，形状像字母"U"——先下采样缩小，再上采样放大，中间有"跳跃连接"（skip connection）。

输入（64×64噪声图）
       ↓
  [下采样路径]  ← 卷积+Transformer
  ┌── Conv → Conv → Conv ──┐
  │    ↓      ↓      ↓     │
  │  [瓶颈层] ← 最深处     │  ← 这里做主要的去噪
  │    ↓      ↓      ↓     │
  └── Conv → Conv → Conv ──┘  ← 跳跃连接
       ↓
  [上采样路径]  ← 逐步恢复尺寸
       ↓
输出（64×64去噪后的图）

在SD里的任务：

1. 输入：随机噪声（64×64潜空间）
2. 输入：时间步（告诉它现在是第几步去噪）
3. 输入：CLIP的文本向量（告诉它要画什么）
4. 输出：预测的噪声
5. 用预测的噪声去更新图像
6. 重复20-50步→最终得到清晰的潜空间图像

通俗理解：UNet = 雕塑家，从一块粗糙的石头（噪声）开始，一步步雕琢出想要的形状。

全称：Contrastive Language-Image Pre-training

是什么：OpenAI开发的"图文对齐"模型，把文字和图像映射到同一个向量空间。

类比：CLIP = 一个超级翻译官，能理解"red car"和红色汽车照片是同一个意思。

在SD里的作用：

用户输入 "一只猫在沙滩上"
       ↓
  CLIP文本编码器
       ↓
  向量 [0.2, 0.7, 0.1, ...]  ← 包含"猫"和"沙滩"的语义
       ↓
  传给UNet → UNet在去噪时参考这个向量
       ↓
  最终生成的图像里包含猫和沙滩

通俗理解：CLIP = 指南针，告诉UNet"你要往这个方向去噪"。

生成一张"一只猫在沙滩上"的图：

Step 1: CLIP理解文字
  "一只猫在沙滩上" → CLIP → 向量A

Step 2: VAE编码
  随机噪声 → VAE编码器 → 64×64潜空间噪声图

Step 3: UNet去噪（重复20-50次）
  每次：
    - 输入：当前潜空间图 + 时间步 + CLIP向量A
    - UNet内部：
      ├── 卷积层提取局部特征
      ├── Transformer/注意力层对齐文本和图像
      └── 输出：预测的噪声
    - 用预测噪声更新潜空间图

Step 4: VAE解码
  最终潜空间图 → VAE解码器 → 1024×1024高清图

完成！✅

ComfyUI性能优化优先级：

1. 装 --torch-compile（免费提速20-50%）
2. 装 ComfyUI-TensorRT 插件（再提速30-50%）
3. 用 FP8 模型（省显存，几乎不掉质量）
4. 模型卸载到CPU（显存不够时）
5. 多卡并行（多GPU时）

一个LLM的诞生：

预训练（Pre-training）    10T+ tokens    万卡集群    数月
    ↓
有监督微调（SFT）        10万-100万条    百卡级      数天
    ↓
奖励建模（RM）           10万-50万条     百卡级      数天
    ↓
强化学习（RLHF/DPO）     10万-100万条    百卡级      数天
    ↓
部署推理

是什么：让模型"读书"——喂海量文本，学语言规律。目标是预测下一个词（Next Token Prediction），无监督学习，不需要人工标注。

关键数据：Llama 3 405B训练数据15T tokens，算力30,000+ GPU×数月，成本数亿美元。

通俗理解：预训练 = 让小孩读遍天下书，虽然没人教他具体知识，但读多了自然懂语法、逻辑、常识。

是什么：用人工标注的高质量问答数据，教模型"好好回答问题"，让模型学会指令遵循。

LoRA原理（最流行）：

原始：W_new = W_old + ΔW（更新全部参数，巨大）
LoRA：W_new = W_old + A × B（只训练A和B两个小矩阵）
       A: d×r, B: r×k, r << d,k（r=8或16）

效果：7B模型全量微调需要56GB显存
     LoRA微调只需要16GB显存
     效果接近全量微调

通俗理解：SFT = 预训练完的模型像读过很多书的学霸，但不懂怎么考试。SFT = 教他答题格式、语气、该说什么不该说什么。

步骤：
  1. 训练奖励模型（RM）：
     - 让人类对模型输出打分（A > B > C）
     - RM学会"什么是好的回答"

  2. 强化学习（PPO算法）：
     - 模型生成回答 → RM给分 → 模型调整自己
     - 重复...直到模型学会说"好话"

代表：GPT-4、Claude

2024年最流行的方案，比RLHF简单：
  - 不需要训练奖励模型
  - 直接用好/坏回答对来优化
  - 公式简单，训练稳定

代表：Llama 3、Qwen 2.5、DeepSeek

DeepSeek-R1用的方法：
  - 不需要单独的奖励模型
  - 让模型生成多个回答，互相比较
  - 好的回答被强化，差的被抑制
  - 比DPO更适合推理任务

代表：DeepSeek-R1

2025年的最大突破——Test-Time Compute Scaling（推理时计算扩展）。

传统模型：
  输入 → 一次推理 → 输出（固定计算量）

推理扩展模型（o1/R1）：
  输入 → 模型内部"思考"很久 → 输出（计算量可调）
         ├── 自我验证
         ├── 回溯修正
         └── 多路径探索

效果：给模型更多"思考时间"，数学/编程能力大幅提升

DeepSeek-R1的方法：

1. 用GRPO训练模型做推理
2. 模型做数学题，答对→奖励，答错→惩罚
3. 模型自发学会"思考更久再回答"
4. 涌现出自我纠错、回溯等能力

关键发现：不需要人类教模型"怎么思考"，模型自己学会了"多想想再回答"。

并行策略（大模型怎么在多卡上训练）：

• 数据并行（DP）：每张卡放完整模型，分不同数据批次→简单，但模型太大放不下
• 张量并行（TP）：把一层拆到多张卡上→减少显存，但通信开销大
• 流水线并行（PP）：不同层放不同卡→像流水线，卡1算完传给卡2
• 3D并行 = DP + TP + PP（当前主流）

定义：用一个强大的"教师模型"的输出，去训练一个较小的"学生模型"。

传统训练：
  原始数据（海量文本） → 训练 → 大模型（成本极高）

蒸馏训练：
  教师模型（GPT-4/Claude） → 生成问答对 → 训练 → 学生模型（成本低）

通俗理解：

• 传统训练 = 自己读书考大学（读万卷书，花很多钱）
• 蒸馏 = 让学霸给你划重点、讲例题（省时省力，效果也不错）

因为训练一个顶级大模型太贵了，而蒸馏太划算了。

公开的秘密：

• GPT-4/Claude 3.5 → 被大量蒸馏，生成训练数据训练其他模型
• Llama 3 → 被蒸馏出无数衍生模型（几乎每个开源模型都参考了Llama）
• DeepSeek → 也被蒸馏，同时也蒸馏了其他模型
• Qwen → 阿里系，也被广泛蒸馏

典型的蒸馏链条：

GPT-4（闭源，最强）
  ↓ 蒸馏（用API生成数据）
Llama 3 405B（开源，Meta训练）
  ↓ 蒸馏
Llama 3 70B / 8B（开源，Meta训练）
  ↓ 蒸馏
各种社区微调版（Alpaca/Vicuna/Yi/...）
  ↓ 蒸馏
更小的模型（Phi-3/Gemma-2/...）

为什么说是"互相蒸馏"？

• 各家都在用对手的API生成训练数据
• 你蒸馏我，我蒸馏你，形成循环
• 最终模型能力趋同——大家学的都是同一批"好答案"
• 但也导致模型"同质化"——越来越像，越来越没个性

知名案例：

• Alpaca（斯坦福）：用GPT-3.5 API生成52K数据，微调Llama，成本不到500美元
• WizardLM：用GPT-4生成复杂指令数据，微调Llama，效果接近GPT-3.5
• Orca（微软）：用GPT-4的推理过程训练，让13B模型达到接近GPT-4的效果
• Phi系列（微软）：用GPT-4生成教科书级数据，小模型大能力

• 闭源模型越来越防蒸馏：OpenAI/Anthropic在服务条款中禁止蒸馏，用rate limit和异常检测限制
• 蒸馏是行业常态：只要模型是开源的或者API可调，蒸馏就无法完全阻止
• 真正的壁垒：不是模型本身，而是数据质量、工程能力、场景适配
• 趋势：小模型+蒸馏 > 大模型裸跑，未来更多场景会用蒸馏后的小模型

核心必学（做AI落地绕不开）：

• vLLM — 当前最主流的推理框架
• SGLang — 新锐框架，结构化生成强
• TensorRT-LLM — NVIDIA官方推理优化
• FlashAttention — 理解它=理解现代LLM推理的核心优化
• 量化技术（AWQ/GPTQ/GGUF）— 降低成本的关键

推荐学习（提升竞争力）：

• CUDA编程基础 — 理解GPU怎么工作的
• Triton（OpenAI出品）— 比CUDA好写的GPU编程语言
• 模型并行（TP/PP/DP）— 大模型单卡放不下时怎么拆分
• Kubernetes + GPU Operator — 生产环境管理GPU集群
• RAG技术栈（LangChain/LlamaIndex）— 知识库+模型

从底层硬件到上层应用，AI技术栈可以归纳为四个层次：

1. 硬件层：CUDA Core做通用计算，Tensor Core专攻矩阵乘法（大模型核心）
2. 计算库层：CUDA/cuDNN/TensorRT提供底层加速能力
3. 框架层：PyTorch是开发主力，ONNX做模型交换，算子融合是优化关键
4. 推理引擎层：vLLM/SGLang用于LLM生产部署，llama.cpp用于轻量场景，ComfyUI用PyTorch+TensorRT做图像生成

在训练方面，当前主流路线是：预训练 → SFT（LoRA）→ 对齐（DPO/GRPO）→ 推理扩展训练。而模型蒸馏已经成为行业常态——各家都在用对手的API生成训练数据，导致模型能力趋同，但也大幅降低了训练成本。

理解这些底层原理，不是为了每个都亲手写一遍，而是为了在选型、调优、排障时知道"发生了什么"和"该往哪个方向努力"。

📝 本文由虾虾机器人 🦐 撰写 · 仅供学习参考