01

Transformer 基础

Q1：介绍一下 Transformer

Transformer 主要分为两个部分：

  • Encoder：处理输入序列，输出上下文表示。内部是多层 Encoder Layer，每层包括 Multi-Head Self-Attention + Feed Forward + Layer Norm + Residual Connections。
  • Decoder：处理目标序列，输出预测。内部是多层 Decoder Layer，每层包括 Masked Multi-Head Self-Attention（自注意力，防止看到未来）+ Multi-Head Encoder-Decoder Attention（交叉注意力）+ Feed Forward + Layer Norm + Residual Connections。

额外组件：

  • Embedding：词嵌入 + 位置编码（Positional Encoding）

  • Output Layer：线性层

SHEN LAN

Q2. Embedding 是什么，它在什么位置？

文本先由 tokenizer 将文本拆分成 token，然后根据词表（vocab）将 token 映射为整数 input_ids。模型维护一个可学习的 embedding 矩阵，通过查表得到 token 向量。位置在模型最前端，紧跟 tokenizer 之后、Transformer block 之前。

SHEN LAN

Q3. 为什么要位置编码？好处是什么？

因为 Transformer 不采用 RNN 的结构，而是使用全局信息，不能利用单词的顺序信息，使用位置编码保存单词在序列中的相对或绝对位置。

SHEN LAN

Q4. Tokenizer 怎么做的？

利用特定算法（如 BPE 或 WordPiece）将连续的文本切分成一个个更小的单元，即 Token。这些 Token 可以是完整的单词、词根、词缀甚至单个字符。然后在一个预先构建好的”词汇表”中查找每个 Token，并将其映射为一个唯一的数字编号（Token ID）。最终，一段文本就被转换成一串由 Token ID 组成的序列，成为模型真正的输入。

SHEN LAN

Q5. 手撕 Multi-Head Attention

import torch
import torch.nn as nn
import torch.nn.functional as F
class MultiHeadAttention(nn.Module):
def __init__(self, hidden_size, num_heads):
super().__init__()
self.num_heads = num_heads
self.head_dim = hidden_size // num_heads
self.q_linear = nn.Linear(hidden_size, hidden_size)
self.k_linear = nn.Linear(hidden_size, hidden_size)
self.v_linear = nn.Linear(hidden_size, hidden_size)
self.o_linear = nn.Linear(hidden_size, hidden_size)
def forward(self, hidden_state, causal_mask=None,
past_key_value=None, use_cache=False):
batch_size = hidden_state.size(0)
query = self.q_linear(hidden_state)
key   = self.k_linear(hidden_state)
value = self.v_linear(hidden_state)
# 多头拆分
query = query.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
key   = key.view(batch_size,   -1, self.num_heads, self.head_dim).transpose(1, 2)
value = value.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
# 拼接 KV cache
if past_key_value is not None:
past_key, past_value = past_key_value
key   = torch.cat([past_key,   key],   dim=2)
value = torch.cat([past_value, value], dim=2)
new_past_key_value = (key, value) if use_cache else None
# 注意力打分
attention_scores = torch.matmul(query, key.transpose(-1, -2)) \
/ torch.sqrt(torch.tensor(self.head_dim, dtype=torch.float32))
if causal_mask is not None:
attention_scores += causal_mask * -1e9
attention_probs = F.softmax(attention_scores, dim=-1)
output = torch.matmul(attention_probs, value)
# 合并多头
output = output.transpose(1, 2).contiguous() \
.view(batch_size, -1, self.num_heads * self.head_dim)
output = self.o_linear(output)
return (output, new_past_key_value) if use_cache else output

SHEN LAN

Q6. Multi-Head Attention 和 Single-Head Attention 的区别？Multi-Head 有什么好处？

Multi-Head 把 hidden_size 拆成多个并行的子空间，每个 head 学习不同的关注模式（如语法、语义、位置等），再拼接回去。

好处：

  • 多角度建模：每个头关注不同的子空间特征
  • 表达能力更强：相比单头能捕获更丰富的依赖
  • 并行性好：多头之间天然并行

SHEN LAN

Q7. Transformer 里的 Attention 和 Feed Forward 各自的作用？

  • Attention：在 token 之间做信息交互，捕获序列依赖关系（”谁关注谁”）。
  • Feed Forward (FFN)：对每个 token 独立做非线性变换，提升模型表达能力，承担”知识存储”的作用。

SHEN LAN

Q8. 大模型怎么处理梯度消失和梯度爆炸？

  • 残差连接（Residual Connection）：保证梯度可以直通传到浅层
  • LayerNorm/RMSNorm：稳定每层的激活值分布
  • 更稳定的初始化：如 Xavier、Kaiming
  • 梯度裁剪（Gradient Clipping）：防止梯度爆炸
  • 学习率 warmup + decay：避免训练初期发散
  • 混合精度训练+Loss scaling：解决FP16下梯度下溢出问题

SHEN LAN

02

大模型推理流程

Q9. 大模型输入文本后怎么得到输出？/ Transformer 推理流程

  1. 文本输入，tokenizer 将文本切分成更小的单元，根据预先准备的词表映射成唯一的token id
  2. 通过Embedding和位置编码，将token id转化为带有位置信息的向量序列
  3. 进入Prefill阶段，模型并行计算输入序列的上下文信息并构建KV Cache
  4. Decode阶段，模型基于已生成的上文和缓存信息，预测下一个token的概率分布，选出概率最高的词后将其追加回输入序列，并更新缓存
  5. 如此反复迭代，直到生成结束符或达到长度限制

SHEN LAN

Q10. 第一个token是怎么来的？

第一个生成的 token 来自 Prefill 阶段：用户输入经过 tokenizer + embedding 后整段并行送入模型，最后一层输出对应”输入末尾位置”的 hidden state，经过 LM Head（线性层）→ logits → 采样策略（greedy / top-k / top-p）→ 得到第一个生成的 token。

SHEN LAN

Q11. 介绍一下PD分离（Prefill-Decode 分离）

Prefill 和 Decode 两个阶段的特性差异极大：

  • Prefill：长序列并行计算，Compute-Bound，能打满 GPU 算力
  • Decode：每次只算一个 token，Memory-Bound，瓶颈是 KV cache 和参数读写带宽

混合在一起会互相干扰：长prefill卡住短decode，导致延迟抖动。PD分离把两个阶段调度到不同的实例（甚至不同硬件），各自批处理，从而提升整体吞吐和SLA。

SHEN LAN

03

Attention 与 KV Cache

Q12. KV Cache 原理？

利用”空间换时间“的策略，解决自回归生成过程中的重复计算问题。

在 Transformer 生成文本时，每次生成新 token 都需要关注之前的所有 token；如果没有缓存，模型必须不断重复计算历史序列的 Key 和 Value 向量，导致计算复杂度呈平方级增长。

KV Cache 通过在显存中保存已计算过的历史 Key 和 Value 状态，使得模型在生成下一个token时，只需计算当前token的Query和新的Key/Value，并直接复用缓存中的历史数据。

这一机制将推理的计算复杂度从 O(n²) 降低到 O(n)，是大模型实现低延迟流式输出的关键。

SHEN LAN

Q13. KV Cache 还有哪些其他优化手段？

  • PagedAttention（vLLM）：把KV cache分块管理，避免显存碎片
  • Continuous Batching：动态拼batch MQA/GQA：多个Query head共享K/V，减少cache体积
  • 量化 KV cache：把KV从FP16量化到INT8/INT4
  • KV cache压缩/驱逐：H2O、StreamingLLM 等丢掉不重要的 token
  • Prefix Caching：相同前缀的请求复用 KV

SHEN LAN

04

Flash Attention

Q14. Flash Attention 原理（目标+方法）

  • 目标：解决 Memory-Bound 问题，避免 attention 矩阵从 HBM 的反复读写

  • 方法：

  • 通过分块计算（tiling），融合多个操作，减少中间结果缓存

  • 反向传播时，重新计算（recomputation）中间结果而非保存

SHEN LAN

Q15. Flash Attention 不同版本之间有什么区别？

  • FA1：分块 + online softmax
  • FA2：改变了循环的嵌套顺序，先处理Q（外层），KV（内层），结束后统一归一化；减少非矩阵乘法计算，更好利用Tensor Core；如果一个Block 处于矩阵上三角部分（causal mask），不进行attention计算
  • FA3：针对Hopper架构，利用TMA和WGMMA，让Softmax和GEMM重叠执行，用Tensor Core的计算时间掩盖SFU（exp）的低吞吐
  • FA4：针对Blackwell架构，高速online softmax（如果最大值在一定范围就不更新）；高效的exp，使用多项式拟合仿真指数操作，接近矩阵运算

SHEN LAN

Q16. 应用Flash Attention时，如果mask是随机/不规则的怎么处理？

Flash Attention的高效来自于“整块跳过”——causal mask下右上三角的 block完全不算。如果mask是随机的：

  • Block-sparse 化：按 block 粒度判断是否全 0，全 0 的 block 直接跳过；非全 0 的 block 内部按元素应用 mask
  • 传 mask 索引：把”哪些 (Q-block, KV-block) 对需要计算”的列表传进 kernel（FlexAttention / FlashAttention 的 block-sparse 接口就是这种思路）
  • 在 kernel 里把 mask 加到 scores 上（scores += mask * -inf），让 softmax 自动屏蔽
  • 极不规则时，partial-block 的开销可能让收益打折，需要权衡

SHEN LAN

Q17. Flash Attention 比较复杂，哪部分比较困难？

主要难点：

  • online softmax 的数值稳定性（max 的累积更新）
  • 分块大小的选择：要兼顾 SRAM 容量、寄存器压力、warp 调度
  • 反向传播的重计算逻辑与前向对齐
  • 多 batch / 多 head / 不同 head_dim 的边界处理

SHEN LAN

Q18. 了解过其他 Attention 类的加速手段（论文）吗？

  • Multi-Query Attention (MQA) / Grouped-Query Attention (GQA)：减少 KV head 数量
  • Sliding Window Attention（Mistral）
  • Linear Attention / Performer / Linformer：把复杂度降到 O(n)
  • PagedAttention（vLLM）
  • RingAttention：跨GPU切分长序列
  • FlexAttention：用编译器自动生成融合 kernel

SHEN LAN

05

量化

Q19. 量化的原理？

量化是指将连续取值离散化成有限取值的过程。模型量化即将权重、激活值等从高精度转化成低精度的操作过程（如 FP32 → INT8）。

SHEN LAN

Q20. 量化的好处（目的）？

  • 更小的模型尺寸：以 8bit 量化为例，与 32bit 浮点数相比，模型体积降低为原来的1⁄4
  • 更低的功耗：移动 8bit 数据比移动 32bit 浮点型数据效率高 4 倍
  • 更快的计算速度：大多数处理器都支持 8bit 数据的更快处理；二值量化更有优势

SHEN LAN

Q21. 量化的分类？

  • 按量化阶段：量化感知训练（QAT）、训练后量化（PTQ）

  • 按量化对象：仅权重量化（weight-only）、权重和激活都量化（weight + activation）

  • 按量化类型：对称量化、非对称量化

  • 按实现方法：

  • PTQ：直接转换训练好的模型

  • QAT：训练时模拟量化过程

  • 混合精度量化：关键层保持高精度

SHEN LAN

Q22. 模型在运行时哪部分是动态量化、哪部分是静态量化？

  • 静态量化（权重）：权重在部署前就已确定，离线量化好，运行时直接使用
  • 动态量化（激活值）：激活随输入变化，运行时根据当前 batch 实时统计 min/max 来量化（也有提前用校准集统计好的“静态激活量化”）

SHEN LAN

Q23. 为什么有的只量化weight，有的activation和weight都量化？

只量化权重：

  • 权重被量化为 INT8，减少存储和带宽占用 激活保持 FP32/FP16，避免量化带来的精度损失
  • 计算时：INT8 权重会被反量化回 FP32/FP16，再与浮点输入运算

权重 + 激活都量化：

  • 权重和激活都量化为 INT8，计算完全在 INT8 进行
  • 计算时：输入先量化到 INT8，再与 INT8 权重进行纯整数计算

结论：只量化权重只减少模型大小，推理速度不会有明显提升；权重 + 激活量化能极大提升推理速度，但模型精度会有所下降。

SHEN LAN

Q24. 量化踩过的坑？

精度陷阱：做分组量化时直接用 max/min 校准，但某些分组中会有个别离群值，导致整个分组的范围被拉得很宽，最终效果较差。

解决思路：截尾（如 percentile 校准）、SmoothQuant、AWQ、对离群通道单独处理。

SHEN LAN

Q25. 模型蒸馏、模型剪枝、量化的区别？

维度 量化 剪枝 蒸馏
操作对象 数值精度 结构（权重/通道/层） 训练目标
是否改变模型结构 否 是 否（小模型独立）
是否需要训练 不一定（PTQ 不需要） 一般需要fine-tune 必须训练student
主要收益 显存+算力 参数量+FLOPs 用小模型逼近大模型

最重要的区别是：蒸馏改的是训练范式（让小模型学大模型），剪枝改的是网络拓扑（去掉不重要的连接），量化只改数值表示。

SHEN LAN

Q26. 如何对训练后的模型做量化？（Flow Matching 改了网络结构，原训练精度 BF16）

优先选择 PTQ（Post-Training Quantization）：

  1. 采集一批校准数据
  2. 用模型跑前向，统计每一层的 activation 分布
  3. 对 weight 和 activation 做量化映射：BF16 → INT8

如果 PTQ 掉点严重，用 QAT（Quantization-Aware Training）：

  • Flow Matching 天生对数值敏感，PTQ 容易崩
  • 在网络里插入伪量化节点
  • 用极小学习率微调 1~3 个 epoch
  • 保持原有 Flow Matching 损失函数不变

可能遇到的问题：激活值离群点、不同分支量化范围不一致、扩散步数累积误差。

SHEN LAN

Q27. 如果 INT8 掉点严重怎么办？

  • 切换到 QAT
  • 使用混合精度：敏感层（如最后输出层、首层）保留 BF16
  • 使用更细粒度的 per-channel / per-group 量化
  • 离群点处理：SmoothQuant（把激活的离群值迁移到权重）、AWQ
  • 检查校准集是否覆盖真实分布

SHEN LAN

Q28. 为什么用 INT4？

  • 更高压缩比：相比 INT8 再缩 1/2，4B 模型可在端侧 4GB 显存运行
  • 带宽更友好：Decode 阶段是 Memory-Bound，权重读取量减半直接提速
  • 精度可控：通过分组量化（K-Quant、AWQ、GPTQ）能把精度损失压到很小

劣势：纯整数 INT4 GEMM 硬件支持有限（目前主流是 W4A16，权重 INT4 但激活 FP16），所以加速主要来自带宽减少而非算力翻倍。

SHEN LAN

Q29. INT4 量化怎么降低时延和显存？

  • 显存：模型权重直接缩到 1/4（FP16 vs INT4）
  • 时延：Decode Memory-Bound 场景下，从 HBM 读权重的字节数减少 → 端到端延迟下降；解包的 ALU 开销远小于带宽节省的收益

SHEN LAN

Q30. 了解过 FP8 量化吗？

FP8 有 E4M3 和 E5M2 两种格式：

  • E4M3：4位指数+3位尾数，动态范围小但精度高，常用于forward/weight

  • E5M2：5位指数+2位尾数，动态范围大，常用于 backward / gradient

H100 / Blackwell 原生支持 FP8 Tensor Core。相比 INT8，FP8 的浮点性质让它对激活的离群值更友好，几乎不需要复杂的校准。

SHEN LAN

Q31. 量化后的权重怎么参与计算？

以 llama.cpp Q4_K_M 为例：

从块中解包 4-bit 权重，用 scale + min 反量化回 FP16，得到 FP16 权重矩阵，和 FP16 激活做矩阵乘法（当场解包，当场丢弃）。

w_fp16 = q4 * (scale * d) - (minv * dmin)

其中：

  • d：全局 scale（FP16，整个 256 维超块共用）
  • dmin：全局 min（FP16，整个 256 维超块共用）
  • scale：子块局部 scale（6-bit，32 维子块用）
  • minv：子块局部 min（6-bit，32 维子块用）

SHEN LAN

Q32. 如何评估量化损失是可以接受的？精度损失大时如何定位？

评估指标：

  • 语言模型：PPL（Perplexity）、下游任务准确率（MMLU、CEVAL 等）
  • 视觉模型：FID、PSNR、mAP

定位方法：

  • 逐层替换法：每次只量化一层，跑评测，找出敏感层
  • 激活分布对比：FP 和量化版本对比每层输出的余弦相似度 / KL 散度
  • 离群值检测：看哪些通道激活值跨度过大

SHEN LAN

06

GPU / CUDA 优化

Q33. MatMul 怎么优化的？计算瓶颈在哪里？

瓶颈：访存（从 GMEM 读取矩阵）和算力。

常见优化手段：

  • 分块 (Tiling)：按 M、N、K 分块加载到 SMEM
  • 寄存器分块 (Warp Tiling)：每个线程持有更大的输出 tile
  • double buffering：计算和访存 overlap
  • Tensor Core 利用：用 wmma / mma 指令
  • 避免 bank conflict：合理 padding SMEM 布局
  • vectorized load：float4 一次加载 16 字节

SHEN LAN

Q34. 矩阵乘有根据 N、M、K 分块吗？

是。三个维度都要分：

  • M、N 方向：决定每个 block 算输出的哪一块
  • K 方向：累加方向，决定每次从 GMEM 读多少进 SMEM

典型的 BLOCK 大小：BM=128, BN=128, BK=8/16/32（依架构而定）。

SHEN LAN

Q35. Bank Conflict 是什么？

同一个 warp 里的不同线程从同一个 bank 里取数据就会造成 bank conflict，内存读取效率偏低（被串行化）。

GPU SMEM 通常分为 32 个 bank，每个 bank 4 字节。解决方法：调整数据布局加 padding（如 [N+1] 而非 [N]），或者 swizzle。

SHEN LAN

Q36. GPU 的两种瓶颈是什么？

  • Compute-Bound：算力打满（如大矩阵乘 prefill）
  • Memory-Bound：访存打满（如 decode 阶段读权重、KV cache）

SHEN LAN

Q37. GPU 运行的时候是如何将数据从 CPU 搬到 GPU 的？

通过 PCIe 总线进行的跨域传输。

流程：

  1. Host 上分配 pinned memory（避免 swap）
  2. cudaMemcpyAsync 把数据 DMA 拷贝到 GPU 显存
  3. 配合 CUDA Stream 实现拷贝与计算 overlap
  4. 现代架构有 NVLink / GPUDirect 可以绕过 CPU

SHEN LAN

Q38. 如何理解 CPU 和 GPU 的内存层次？

CPU：设计目标是最小化单线程延迟——通过 L1/L2 应对局部性，L3 解决多核数据共享与内存墙问题。深层 cache 是核心。

GPU：专注吞吐量优化——凭借海量线程隐藏延迟，显存带宽优势和大规模寄存器资源使其无需深度缓存层级。层级是 Register → SMEM/L1 → L2 → HBM。

二者差异本质是在延迟敏感与吞吐优先之间的架构权衡。

SHEN LAN

Q39. 如何优化 RMSNorm 算子？解决什么瓶颈？

RMSNorm 是 Memory-Bound（计算量小，但要读整个 hidden state）。

优化手段：

  • 算子融合：和前后的 residual / linear 融合，减少 HBM 往返
  • vectorized load：float4 加载
  • warp-level reduction：用 __shfl_xor_sync 做归约，避免 SMEM 同步
  • block-level 时：先 warp reduce，再 SMEM 跨 warp 聚合
  • 单步算 sum(x²)，避免 mean/var 两遍扫数据

SHEN LAN

Q40. 你会用 ncu 优化性能，会关注哪些指标？

  • SM Occupancy：占用率
  • Memory Throughput / DRAM Throughput：访存带宽利用率
  • Compute (SM) Throughput：算力利用率
  • L1/L2 Cache Hit Rate
  • Warp Stall Reasons：哪种原因导致 stall（long scoreboard / barrier / mio_throttle…）
  • Achieved vs Theoretical Bandwidth
  • Roofline 分析：判断 kernel 是 Compute-Bound 还是 Memory-Bound

根据指标判断：

  • DRAM 吃满 → Memory-Bound，优化访存（融合、量化、tiling）
  • SM 利用率高但算力低 → 指令组合不好，考虑 Tensor Core
  • 占用率低 → 调整 block 大小、寄存器使用

SHEN LAN

Q41. Latency Bound 问题、Occupancy 相关问题？

  • Latency Bound：指 kernel 因为指令依赖（long scoreboard、barrier）等待，没法发射新指令。可以增加并行（提高 Occupancy）来掩盖
  • Occupancy 不一定越高越好：寄存器多/SMEM 多 → 占用率降低，但单线程效率高，往往整体更快

SHEN LAN

Q42. Ada 升级到 Blackwell 架构，软硬件层面有哪些变化？

硬件层面：

  • 第二代 Transformer Engine，原生支持 FP4 / FP6
  • 更大的 NVLink 带宽（NVL72 拓扑）
  • 更高的 HBM 带宽和容量
  • 第五代 Tensor Core

软件层面：

  • CUDA 12.x 新增 FP4 数据类型支持
  • cuBLAS / cuDNN 适配新 mma 指令
  • FA4 利用新硬件特性

SHEN LAN

Q43. 嵌入式平台/资源受限平台部署小模型vsGPU大模型推理的区别？

可复用：

  • 量化（INT8/INT4）思路
  • 算子融合
  • KV cache 优化
  • 整体的推理流水线设计

需要注意的差异：

  • 嵌入式更受限于内存带宽和功耗，不是算力
  • CPU/NPU 没有 SIMT，需要用 SIMD（NEON）/ NPU 专用指令
  • 内存分配粒度更小，不要频繁 malloc
  • 算子要重写适配（NPU 通常只支持白名单算子）
  • 数据搬运优化更关键：减少 CPU↔NPU 拷贝、用 zero-copy 内存

SHEN LAN

Q44. 你是用什么方法解决数据搬运和提高速度的？

  • 内存池 / KV Cache 池：预分配，避免运行时频繁 malloc
  • Pinned memory + 异步拷贝
  • Stream 并行：拷贝、计算 overlap
  • 算子融合：减少 kernel launch 和中间结果落盘
  • 量化：减少要搬运的数据量

SHEN LAN

Q45. PyTorch 显存管理是怎么做的？

PyTorch 用 caching allocator：

  • 第一次申请向 CUDA 要大块（按 2MB / 20MB 分级）
  • 释放时不还给 CUDA driver，而是放回内部 free list
  • 下次申请优先从 free list 复用，按 size 匹配
  • 这样避免频繁 cudaMalloc/cudaFree 的高开销
  • 副作用：nvidia-smi 看到的显存比实际占用高

SHEN LAN

Q46. 有做过 PyTorch 自定义算子吗？

典型路径：写CUDA kernel → C++ wrapper → TORCH_LIBRARY 注册 → Python端torch.ops.mylib.myop调用；或者用 torch.utils.cpp_extension.load_inline

SHEN LAN

Q47. 之前有做过建模类型的工作吗？分层看激活值的优化？

思路：用hook注入每层激活，统计 min/max/distribution，对比量化前后的差异，定位敏感层

SHEN LAN

07

llama.cpp

Q48. llama.cpp 是不是只是单 batch 的情况？

历史上是单 batch 为主（端侧场景为主），但目前已经支持 batched decoding（llama_batch）和并行序列。不过相比vLLM这类serving框架，它的多batch调度仍然较为简单。

SHEN LAN

Q49. llama.cpp 除了算子优化以外，还有什么方法降低延迟？核心优化能力是什么？

  • K-Quant 系列量化（Q2_K ~ Q8_K，超块 + 子块两级量化）
  • GGUF 格式：mmap 直接加载，减少冷启动时间 CPU + GPU 混合推理（-ngl 控制 offload 层数）
  • 持续 batch 优化
  • prompt cache：相同 prompt 复用 KV 跨平台 backend：Metal / CUDA / SYCL / Vulkan

核心优化能力：极致的端侧量化部署+跨平台兼容+极小依赖（纯 C/C++）。

SHEN LAN

Q50. K-Quant 量化方法是什么？

量化流程（4 步）：

  1. 分块：权重矩阵按行优先展平，每 256 维为一个超块，再拆为 8 个 32 维子块
  2. 算局部参数：对每个 32 维子块，用 make_qkx1_quants（5 次迭代 K-Means）求最优 scale/min，最小化重构误差
  3. 算全局参数：取 8 个子块的最大 scale 作为全局 scale（d = max_scale / 63），最大 min 作为全局 min 尺度（dmin = max_min / 63）
  4. 编码存储：
  • 子块 scale/min 量化为 6-bit，紧凑存入 scales[12]（前 4 个直接存，后 4 个拆高低位）
  • 4-bit 权重按 qs[i] = q[2i] | (q[2i+1] << 4) 打包入 qs[128]

反量化（推理时）：

对每个 32 维子块：

  1. 从 scales 解码 6-bit scale/min，乘全局 d/dmin 得实际 scale/dm
  2. 解包 4-bit 权重（q = (qs[l] & 0xF) 或 (qs[l] >> 4)）
  3. 反量化：x = d * q - dm（FP16 计算）

SHEN LAN

Q51. llama.cpp 里比较精妙的技巧是什么？

  • GGUF + mmap：模型按需加载，启动快、内存可被多进程共享
  • Q-format 的紧凑编码：scale 和量化值的 packing 设计极致省内存
  • 统一的 ggml 张量抽象：跨后端只换 backend op
  • SIMD 内核手工优化：每种量化格式都有 AVX2/AVX-512/NEON/Metal/CUDA 的专门实现
  • graph 重用 + scratch buffer：每步推理复用同一块工作内存

SHEN LAN

08

数据表示

Q52. FLOPS 和 FLOPs 和吞吐量分别是什么？

FLOPS（Floating Point Operations Per Second，每秒浮点运算次数）：

  • 衡量硬件理论峰值计算能力的标准单位
  • 比较不同硬件理论算力天花板的主要指标
  • 常用 TFLOPS、PFLOPS 表示

FLOPs（Floating Point Operations，浮点运算次数）：

  • 衡量一个模型执行一次前向（或前向+反向）所需的总浮点运算量
  • 表示模型的计算复杂度
  • 是估算训练/推理资源和时间的基础

吞吐量（Throughput）：

  • 系统在单位时间内处理的数据量或完成的任务量
  • 训练：tokens/s 或 samples/s
  • 推理：requests/s（QPS）或 tokens/s 衡量实际性能的关键指标

2026年AI行业最大的机会，毫无疑问就在应用层！

字节跳动已有7个团队全速布局Agent

大模型岗位暴增69%，年薪破百万！

腾讯、京东、百度开放招聘技术岗，80%与AI相关……

如今，超过60%的企业都在推进AI产品落地，而真正能交付项目的 大模型应用开发工程师 **，**却极度稀缺！

落地AI应用绝对不是写几个prompt，调几个API就能搞定的，企业真正需要的，是能搞定这三项核心能力的人：

✅RAG：融入外部信息，修正模型输出，给模型装靠谱大脑

✅Agent智能体：让AI自主干活，通过工具调用（Tools）环境交互，多步推理完成复杂任务。比如做智能客服等等……

✅微调：针对特定任务优化，让模型适配业务

目前，脉脉上有超过1000家企业发布大模型相关岗位，人工智能岗平均月薪7.8w！实习生日薪高达4000！远超其他行业收入水平！

技术的稀缺性，才是你「值钱」的关键！

具备AI能力的程序员，比传统开发高出不止一截！有的人早就转行AI方向，拿到百万年薪！👇🏻👇🏻

图片

AI浪潮，正在重构程序员的核心竞争力！现在入场，仍是最佳时机！

我把大模型的学习全流程已经整理📚好了！抓住AI时代风口，轻松解锁职业新可能，希望大家都能把握机遇，实现薪资/职业跃迁～

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】

在这里插入图片描述

⭐️从大模型微调到AI Agent智能体搭建

剖析AI技术的应用场景，用实战经验落地AI技术。从GPT到最火的开源模型，让你从容面对AI技术革新！

大模型微调

  • 掌握主流大模型（如DeepSeek、Qwen等）的微调技术，针对特定场景优化模型性能。

  • 学习如何利用领域数据（如制造、医药、金融等）进行模型定制，提升任务准确性和效率。

RAG应用开发

  • 深入理解检索增强生成（Retrieval-Augmented Generation, RAG）技术，构建高效的知识检索与生成系统。
  • 应用于垂类场景（如法律文档分析、医疗诊断辅助、金融报告生成等），实现精准信息提取与内容生成。

AI Agent智能体搭建

  • 学习如何设计和开发AI Agent，实现多任务协同、自主决策和复杂问题解决。
  • 构建垂类场景下的智能助手（如制造业中的设备故障诊断Agent、金融领域的投资分析Agent等）。

图片

如果你也有以下诉求：

快速链接产品/业务团队，参与前沿项目

构建技术壁垒，从竞争者中脱颖而出

避开35岁裁员危险期，顺利拿下高薪岗

迭代技术水平，延长未来20年的新职业发展！

……

那这节课你一定要来听！

因为，留给普通程序员的时间真的不多了！

立即扫码，即可免费预约

「AI技术原理 + 实战应用 + 职业发展」

「大模型应用开发实战公开课」

👇👇

在这里插入图片描述

👍🏻还有靠谱的内推机会+直聘权益！！

完课后赠送：大模型应用案例集、AI商业落地白皮书

# 人工智能 # transformer # 深度学习 # AI
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

2024科技趋势：AI领跑，云边协同

2024年技术发展将围绕人工智能、云计算、边缘计算等核心领域展开，重点关注技术融合与实际应用场景的落地。技术发展将更强调“价值闭环”，即从技术创新到商业变现的路径缩短，同时跨领域协作（如AI+生物科技）可能催生突破性应用。

avatar AtomGit开源社区

2024技术趋势：AI领跑，开发者必看22

强调技术快速迭代中持续学习的重要性，鼓励读者关注实践与理论结合。（注：可根据实际需求调整子标题深度或增删模块，如加入“行业案例”或“争议性技术讨论”等部分。

avatar AtomGit开源社区

使用Koopman理论识别机器人动力学的非线性系统（Matlab代码实现）

实际中的大多数系统均为非线性系统，而Koopman算子可以描述非线性系统的可观测状态量在高维空间中的线性演化过程，可以将非线性问题转化为线性问题，对于非线性系统的研究有较大的价值。利用Koopman算子理论，可以仅依靠实验数据或系统仿真数据建立非线性系统的线性模型，基于该模型可实现对非线性系统的分析、预测和控制[6]。为了识别杜宾汽车模型的非线性动力学，我们使用Koopman算子理论首先从系统的仿

avatar AtomGit开源社区