ThinIceDancer

[SuSu_酥酥👅 @NFT_Chen]

🤯逆天了！Qwen 3.8 27B注意力层被彻底击穿了！10M超长上下文下，Prefill注意力快72.4倍、Decode快42.5倍！端到端首token延迟砍到约1/9！

闲置GPU的朋友注意了：把这个新方法丢给Claude/Codex，让它直接移植到Qwen 27B上！注意力算法“移植”已经被验证可行。

惊人之处：
🔹10M token（约1000万）超长上下文下，传统稀疏注意力有98%时间都在“找该看哪些token”，真正算注意力反而没那么贵

🔹新方法Latent Sparse Attention (LSA)：先把Key按“意思相近”聚类成层级结构，Query只看聚类中心，再挑最相关的几个桶去算。从“全扫”变成“树搜索”

🔹实测（Qwen-3.8-27B）：单层注意力Prefill快72.4倍，Decode快42.5倍！端到端首token延迟也能降到约1/9

🔹精度几乎不掉，甚至在RULER等长上下文任务上还略好一点

🔹只需要短蒸馏训练Indexer（基座模型冻结），就能套到现成模型上。Native训练版本也能跟上全注意力精度，还更快

🔹对GPU紧缺党意义巨大：超长上下文（百万级）不再需要堆满H100/H200才能跑，单卡/少量卡也能玩得起真正长上下文Agent

适配步骤：
1️⃣git clone 仓库后用 uv sync 安装（Python 3.12）

2️⃣官方已放出Qwen3.8-27B的蒸馏权重（d-lsa-weights-v1 release），直接下载即可

3️⃣用他们的SGLang fork镜像启动服务，挂载仓库+权重

4️⃣启动时加 --json-model-override-args '{"lsa": {"projections": "/maps/qwen38_27b.pt", "query_heads": "all"}}'（记得加 --disable-prefill-cuda-graph）

5️⃣想自己训练的话，跑 lsa distill targets → lsa distill train → export 即可（基座冻结，只训Indexer）

代码已开源，论文也在，谁有空闲卡先冲一波？

论文：https://t.co/UiHr9uIJkX

GitHub：https://t.co/8WHdT6UQxb

#Qwen #LSA #LongContext #AI #GPU #LocalLLM #注意力优化 #Qwen38 #阿里巴巴

[Dongxi 东锡 NLP @dongxi_nlp]

Weight-Space Programming 再次证明了：

这两年最有趣paper是 persona vectors，建议大家人工读上5遍。

所有的 Weight-Space Programming， emergent misalignment 换汤不换药。

[山景城小路 @Zen_with_AI]

Meta 重磅论文， 循环 loop Transformer，推荐给想在参数量、训练算力和推理速度之间做取舍的朋友。正文 10 页.

一句话概括：循环是一组互相牵制的设计选择，作者在同一套从零训练的设置里，把"循环哪里、循环几次、各轮要不要不同、生成时怎么并行"做了详细的对比实验。

下面我按论文的思路带您看。

先说循环是什么。循环就是把同一组权重反复用几遍，网络变深，存的参数不增加。代价是每多一轮就多算一轮。所以论文问的是：参数、训练算力、自回归推理，这三种约束各自偏爱什么设计？

实验设置是 dense decoder-only，从零训练，70M 到 1B 共六个规模，每个参数配 10 到 160 个训练 token（TPP），循环次数 L 最多 32。主指标是 DCLM 验证集的 bits per byte（BPB，越低越好）。

先给骨架：

哪里循环->循环几次->各轮特化->并行解码
（全栈还是中间块->何时饱和->每轮一个小 LoRA->重新注入当前 token）

哪里循环。论文比了七种设计。全栈循环（整个网络转 L 圈）在固定参数量下质量最好，模型越大、TPP 越高越明显，300M 和 500M 上最稳。中间块循环（前后各约三分之一的层只跑一次，只转中间）在训练 FLOPs 有限时回报更高。把 attention 和 MLP 分开各自循环的做法，L 变大后掉得最厉害。

循环几次。L 不超过 16 时，各设计整体都比不循环好，但边际收益递减，到很大的 L 会饱和、反转，甚至训练不稳。这点在 70M 和 100M 上看得最清楚，因为只有它们扫到了 L=32。TPP 高的时候增益更稳，TPP 低的跑法更早饱和。

各轮特化。每一轮用同一套权重，会不会限制了越循环越深的收益？作者给每一轮加一个很小的低秩适配器，W(l) = W + (alpha/r) * B(l) A(l)，主权重仍然共享。其中 Loop Matrix（每轮对一组共享的 LoRA 做加权混合）效果最好。L=2 时收益很小，L=4 和 8 才明显。在 300M 上参数只多 1.1% 到 4.3%，而把深度加倍要多 51.4%。但在相近训练 FLOPs 下，加倍深度的模型 BPB 更低。所以特化是省参数的办法，省不了算力。

并行解码。普通循环生成每个 token 都要一轮接一轮，延迟随 L 线性增长。PLT（Parallel Loop Transformer）让第 l 轮的输入用当前 token 的 embedding，加上上一个 token 在第 l-1 轮的隐状态。这些状态解码时已经有了，L 轮可以放进一个 batch 同时算。

作者复现后发现，原版 PLT 在他们的设置里保不住循环的收益：L 不超过 2 时只接近不循环的基线，L 变大还可能更差。拆开看有两个原因。一是移位本身。二是当前 token 的 embedding 和上一个 token 的隐状态，RMS 量级差得很大，直接相加会让大的那个压住小的。

修法的方法是：两路各自做 RMSNorm，再用门控混合：b = g * e_hat + (1-g) * h_hat（逐维相乘）。固定 50/50 就够用，rank-8 的线性门略好，参数不到 0.015%。如果去掉当前 token 的 embedding，移位版比不循环还差，有的直接发散。作者的推测是，没有它，每一轮只能靠上一个 token 的隐状态去猜当前 token，错误会沿着位置累积。

结果：1B 上 L=2 时，改进后的并行版在每个显示的训练预算下，BPB 都低于全栈循环。L=4 时仍有竞争力，但和不移位版本的差距变大。另外，在过训练区间，两循环、TPP 80 的模型比不循环、TPP 160 的模型，用更少的训练 FLOPs 就能达到同样的 BPB。L=4 的每 FLOP 收益则更弱。

这篇论文的局限：

规模。32 轮只在 70M 和 100M 上跑过，200M 到 500M 只到 L=8，1B 只到 L=4。所以"饱和或反转"出现在大模型的什么位置，论文没有直接测。

解码速度。PLT 的目的是降低生成延迟，但小路在正文里没有看到实测的解码延迟，比较的都是质量。

下游任务。
八个推理和问答任务的平均，循环能保住或提升，TPP 160 时八个里有六个优于不循环。但 MMLU 和 MMLU-Pro 接近随机，作者明确说不能据此说循环在这个规模上提升了 MMLU 类表现。

另外，实验只做了 dense 模型，MoE 没有评估。
如果您手上有训练代码，论文给的选择可以对着约束来读：参数受限、算力充裕，用全栈循环；训练算力受限，用中间块循环；要快生成，用 PLT，再加上两路 RMSNorm 和保留当前 token 的 embedding。小路想留一个问题：L=4 时并行版和不移位版的差距已经在变大，再往上到 8 轮、16 轮，这条路还能保住多少收益？论文没有回答。

简单总结一下就是：循环要先问哪种资源最紧。参数紧用全栈，算力紧用中间块，轮数多了加小 LoRA，要并行生成就必须保住当前 token 的 embedding 并分别归一化。小路最认同的是它没有宣布一个通用最优解，而是把设计和约束一一对上。保留的是规模，1B 以上和 MoE 上会怎样，还是未知。

https://t.co/j8bTRFw9to

[Avi Chawla @_avichawla]

A tricky LLM interview question:

You're serving a reasoning model on vLLM, and long traces keep pushing it out of GPU memory.

You add KV cache compression and evict 90% of the cached tokens.

VRAM usage doesn't move, and the GPU still runs out of memory.

Why?

(answer below)

Evicting 90% of the KV cache can free close to zero bytes on a paged server.

During decoding, every new token appends its key and value vectors at every layer. vLLM holds all of them until the request finishes.

For reasoning models with long chains of thought, this cache is the main memory cost.

A Qwen3-32B with 4-bit weights on a 24GB GPU needs KV for every token of a 32K-token trace, and it hits OOM around 24K tokens.

Attention over long contexts is sparse, so you can keep the high-importance tokens and drop the rest with little accuracy loss.

That reduces the number of cached tokens but it doesn't necessarily reduce allocated memory.

vLLM manages the cache with PagedAttention. It splits GPU memory into fixed physical blocks of 16 token slots each.

The allocator reclaims a block only when all 16 slots are empty.

Importance-based eviction keeps tokens scattered across the full sequence, so the retained tokens are spread over nearly every block.

Evict 14K of 16K tokens across 1,000 blocks, and almost every block still holds at least one token.

So the allocator reclaims close to nothing.

You could write new tokens into the empty slots. If token 16,001 goes into the slot token 40 held, the block now reads positions 38, 16,001, 41.

The cache is no longer in position order. Attention still gives the correct result, but each slot now needs a stored position index, and every kernel has to read it.

An in-order layout doesn't need that metadata.

So the cache shrinks 90% logically and 0% physically. Many compression papers miss this because they benchmark on pre-allocated contiguous tensors instead of a paged server.

The second problem is the eviction signal.

Most eviction methods rank tokens by their attention scores.

FlashAttention never materializes those scores. It computes attention tile by tile in on-chip SRAM and discards each score tile after use, which is where its speed comes from.

To get the scores, you have to fall back to eager attention and build the full score matrix in HBM, which removes the speedup FlashAttention provides.

NVIDIA's TriAttention handles both problems.

It ranks tokens without attention scores. It uses the geometry of the query and key vectors before RoPE is applied, where they form stable clusters.

Every 128 decoded tokens, it runs a compaction pass. Retained tokens move forward to fill the evicted slots, so trailing blocks empty out completely and return to the allocator, and the cache stays in position order.

On long reasoning traces, it matches full-attention accuracy with 2.5x faster decoding and 10.7x less KV memory.

For KV cache compression on a real server, the metric to track is blocks freed, not tokens evicted.

NVIDIA's write-up: https://t.co/ZwXv7VezVu

I also wrote a first-principles breakdown of the KV cache. It covers why the model caches keys and values, why the cache grows with every token, and how generation speed compares with and without caching.

Read it below.

[neural nets. @cneuralnetwork]

pytorch interview speedrun.
5 questions. no googling.

1. what does model.eval() actually change?
2. why call optimizer .zero_grad()?
3. detach() vs no_grad()?
4. why does CrossEntropyLoss expect logits?
5. what happens if you forget loss.backward()?

how many can you answer correctly?
answers in replies.

[山景城小路 @Zen_with_AI]

最近Google ML 题目

1. SVM 训练时间复杂度
回答 SVM 训练的时间复杂度。

2. 实现 MHA 类
实现一个多头注意力（MHA）类，并回答 SOTA 模型相关的 modeling 问题。

3. 违规 / 冒犯内容检测系统设计
设计一个检测违规 / 冒犯内容的系统。

4. YouTube 推荐系统设计
设计 YouTube 推荐系统。

5. RNN 模型预测吞吐优化
优化 RNN 模型的预测吞吐。

6. Loss 选择与数据问题
回答 loss 选择、数据采集、bias 与反馈回路、模型损坏处理相关问题。

[Enea Monzio Compagnoni @EneaMC]

Cool! We derived an AdamW batch-size scaling rule in Lemma 3.13 of https://t.co/zeTw8E1KtQ

B → B × k

𝗟𝗥 → 𝗟𝗥 × sqrt(𝗸)
𝗪𝗗 → 𝗪𝗗 × sqrt(𝗸)

βᵢ → 1 − sqrt(k) × (1 − βᵢ)

This was subsequently validated empirically in an ICLR 2026 paper:

https://t.co/JFC7D9LDzF

[Jintao Zhang 张晋涛 @aiandcloud]

好了，我当时要说的就是这个了。

SGLang PD 分离部署下，一个被中止的请求的 prompt 片段可能出现其他被会话里，进而导致数据泄露的情况。

https://t.co/oL0KJ8Alft

[Rosinality @rosinality]

https://t.co/dl5pmfuPdi

Fixing numerical precision problem in softmax.

[山景城小路 @Zen_with_AI]

小路带你看大厂架构｜Meta GEM：把推荐系统做成 LLM

GEM（Generative Ads Model）是 Meta 的广告推荐 foundation model，号称业界最大。2026 这一代的关键变化：从 Facebook、Instagram、Reels 各自独立优化，收敛成一个中央大模型，所有站点的点击和转化联合预测。效果：转化 +18.9%，CTR +12%。

架构 Kunlun 是 LLM 范式往推荐的移植：推荐特征异构、分布漂移，Transformer 的 scaling law 在这儿不 work。Kunlun 用 block attention 把序列复杂度从平方降到线性，GDPA 把多种 attention-like 算子统一进一个 kernel（forward 快 2 倍），MoE 式 cross interaction 处理特征交叉，CompSkip 按需跳过组件省 43% FLOPs。模型复杂度涨 2.5 倍，出现 LLM 式的"越大越灵"。

训练侧：5D 并行加低精度定制 kernel，总 FLOPs 涨 4 倍，MFU 做到 20–25%（端到端效率翻倍）。推荐负载和 LLM 算力画像完全不同，能到这个利用率不容易。

推理侧玩的是"转移"而非"直服"：LoopFM 把中央大脑的表征压缩成结构化表示传给下游，Solaris 则投机预计算——在广告请求进来前，先把可能用到的 user-ad embedding 算好，实时链路只取结果，延迟零增加。

推荐系统也在吃 scaling law 这碗饭了。

https://t.co/77qwBxDJDs

[Feiteng @FeitengLi]

vLLM 开始支持双向 KV 传输，针对多轮 Agent 在 prefill/decode 分离部署中反复计算历史上下文的问题：上一轮 decode 节点算出的 KV，下一轮可以传回 prefill 节点继续复用。

在 AWS P5en + EFA、一个 prefill 节点配一个 decode 节点的测试中，GLM-5-FP8 在约 20K 输入长度下，首 token 延迟从 2,334 ms 降到 702 ms。但这个对照关闭了 prefill 端的前缀缓存，用来模拟缓存失效或请求换节点。

短上下文里，搬运和协调的开销可能比重算更大。

官方介绍：https://t.co/giFZGqJXGv

[Suraj Sharma @suraj_sharma14]

As an AI Infrastructure Engineer, you must build these projects.

1.) High-Throughput Serving Engine Tuning
Build: Deploy vLLM or SGLang, tuning chunked prefill, continuous batching and max-num-seqs for a specific GPU architecture.

Why: Default configs waste 60% of VRAM. Squeezing the hardware is the baseline job.

2.) KV-Cache Prefix Routing Proxy
Build: A load balancer that hashes incoming system prompts and routes requests to the specific replica holding that KV-cache block in memory.

Why: Reused context is free speed. This alone can slash Time-To-First-Token (TTFT) by 80%.

3.) Custom Fused Triton Kernel
Build: Write a fused RMSNorm or RoPE (Rotary Position Embedding) kernel in Triton and benchmark it against the native PyTorch implementation.

Why: Python overhead and memory reads kill inference. Fused kernels save milliseconds that compound at scale.

4.) Speculative Decoding Pipeline
Build: A serving setup where a local 2B "draft" model generates tokens in parallel and a 70B "target" model verifies them in a single forward pass.

Why: 2x decode speed at zero quality loss is the closest thing to a free lunch in inference.

5.) Disaggregated Prefill/Decode Cluster
Build: Separate GPU pools where compute-heavy prefills and memory-bound decodes are routed to different hardware optimized for each phase.

Why: This is the exact architecture frontier labs use to maximize MFU (Model Flops Utilization) in 2026.

6.) FP8 Quantization & Calibration Harness
Build: A pipeline that calibrates a model for FP8 inference, serves it via TensorRT-LLM and measures the exact perplexity drop against throughput gains.

Why: Quantization is the only way to fit frontier models on edge GPUs and protect your cloud margins.

7.) Queue-Based GPU Autoscaler (KEDA)
Build: An autoscaler that spins up spot GPU nodes based on pending token queue depth and gracefully drains them when the queue empties.

Why: Idle H100s burn $3+/hr. FinOps and scheduling are now core infra responsibilities.

8.) Complexity-Routing AI Gateway
Build: A proxy that analyzes prompt entropy and token length to instantly route simple queries to a quantized local 8B model and complex reasoning to a frontier API.

Why: Unit economics decide if your AI product survives the next API price hike.

9.) Multi-Node Tensor Parallelism Setup
Build: Shard a 70B+ parameter model across 4 nodes using NCCL over RDMA/RoCE v2 and profile the exact network bottleneck between GPUs.

Why: Single-node inference is dead for frontier models. You must master the interconnect.

10.) Semantic Cache Layer
Build: A Redis + Vector DB proxy that intercepts requests, checks for >98% embedding similarity, and returns cached outputs without hitting the GPU.

Why: The cheapest and fastest token is the one you never generate.

11.) DCGM Observability & Throttling Dashboard
Build: A Grafana stack tracking GPU temp, SM occupancy, VRAM OOMs and PCIe TX/RX to catch silent hardware throttling.

Why: You cannot fix an SLO violation if your dashboard only shows HTTP 200s while the GPU is melting.

12.) MoE (Mixture of Experts) Load Profiler
Build: An expert-parallel deployment tracking token-to-expert routing to identify and fix expert load imbalance and communication overhead.

Why: Sparse MoE models are the 2026 standard, and naive routing destroys their latency advantage.

13.) Inference Chaos & Fault Tolerance Suite
Build: A harness that injects network partitions, simulated GPU ECC errors, and OOMs to test the cluster's ability to migrate KV-caches and recover.

Why: At scale, hardware fails daily. Your architecture must heal itself.

14.) Checkpointing & Weight Streaming Engine
Build: A system that streams model weights directly from an S3 bucket to GPU VRAM on cold-start, bypassing local disk bottlenecks.

Why: Cold-start latency kills autoscaling. Streaming weights directly to memory is the ultimate optimization.

15.) Public Inference Benchmark Teardown
Build: 3 published deep-dives with Pareto curves (Cost vs TTFT vs Throughput) comparing vLLM vs SGLang vs TensorRT-LLM on your specific hardware.

Why: Public proof of hardware mastery and methodology gets you hired instantly by top AI labs.

Systems that prove you can serve, optimize & scale when silicon meets intelligence.

Bookmark & Repost.

[SuSu_酥酥👅 @NFT_Chen]

💥揭秘！小米 MiMo V2.7-3.0 Pro 的模型推理优化岗，面试直接把底牌摊开了！

面试官来自基础架构 AI Infra，团队负责自研 MiMo 系列（含 MiMo V2.7 Pro）推理优化，日调用量数十亿 token。岗位是推理框架团队，大模型推理优化方向（推理引擎/算子）。

不是背名词，仿真、调度、缓存收益边界和手写实现全问：
1️⃣ TerarkKVCache / HiCache 是什么，多级缓存 offload 到 CPU / 分布式存储 / Disk 的必要性与带宽 trade-off

2️⃣ SGLang radix cache 怎么管，请求如何按 token id 做最长前缀匹配

3️⃣ 多级缓存何时有收益：G2→G1 加载时间 < 命中部分重新 prefill 的时间

4️⃣ 高并发服务权衡什么：吞吐、TTFT/TPOT、释放算力速度

5️⃣ AI Configurator 算子 latency 数据来源（实测 / SOL 理论值 / 插值），MAPE 如何验证到 <10%

6️⃣ PD 分离仿真核心：单进程虚拟时钟与状态机（waiting prefill→prefill→KV transit→decode），P/D worker 按 KV 容量绑定，worker pool/replicas（TP/PP/DP），mix chunk 优先 decode

7️⃣ Cache-aware + load score 路由打分策略，和 Dynamo 的对比

8️⃣ TP/DP/EP 背景与优劣：MoE 中 DP attention、DP×TP=EP、EP 的 all-to-all 通信

9️⃣ 手写公式：MHA 的 KV cache 显存 (2 \times B \times S \times heads \times head_dim \times bytes \times layers)，TP 下如何切分

🔟 手写 C++：LRU Cache（双向链表 + 哈希表）

1️⃣1️⃣ 反问透露：人均至少 8 卡 H200；MiMo 用 SWA 滑动窗口注意力减少 KV 存储与传输，是团队重点方向

想冲 MiMo V2.7-3.0 Pro 的推理 Infra，这套题基本就是准入线了。

#AI面经 #AI面试题 #小米 #AIInfra #大模型推理 #MiMo #MiMoV27Pro #罗福莉

[山景城小路 @Zen_with_AI]

最近OpenAI 面经：

Infection Spread，60 分钟 5 连问

本质是 LeetCode 994 腐烂橘子的豪华版，multi-source BFS 起手。

Part 1 基础传播：每天每个感染格同时感染 4 邻域健康格，求全感染天数，不可能就返回 -1。多源 BFS，一遍 O(R·C)。

Part 2 加免疫墙（2=immune）：永不感染也不传播。BFS 不变，遇到墙跳过；有健康格被墙死了就返回 -1。

Part 3 自愈：感染 D 天后变 immune 不再传播。坑在 off-by-one：第 t 天感染的格，current_day - t >= D 当天先变 immune 再传播，顺序反了就错。

Part 4 阈值+死亡：健康格要有 ≥K 个感染邻居才被感染，变体还有死亡倒计时。纯 BFS 骨架不够了，改同步更新：快照当前格，一次算完再整体替换，in-place 直接改是最大 bug 源。

Part 5 每天烧一行或一列，最小化死亡总数——优化问题，能走到这的人很少。

通关口诀：Part 1-2 纯 BFS，Part 3 起同步更新 + day stamp；干净做完前 3 部分就能拿 strong。

[Suraj Sharma @suraj_sharma14]

If you learn inference infra, you will never be unemployed again.

Stage 1: Systems Foundations
C/C++ or Rust basics, Python performance, Linux, memory hierarchy, CPU vs GPU execution.

Stage 2: GPU Architecture Fundamentals
CUDA cores, tensor cores, VRAM, memory bandwidth, SM occupancy, nvidia-smi profiling.

Stage 3: Transformer Inference Anatomy
Prefill vs decode phases, KV cache growth, attention memory math, arithmetic intensity.

Stage 4: Serving Engines
vLLM, SGLang, TGI: continuous batching, PagedAttention, scheduling, throughput vs latency.

Stage 5: KV Cache Optimization
Prefix caching, chunked prefill, KV quantization, cache offloading, multi-turn reuse.

Stage 6: Quantization and Compression
FP8, INT8, AWQ, GPTQ, sparsity; measuring quality drop against speed gains.

Stage 7: Speculative Decoding and Parallelism
Draft-target models, Medusa heads, tensor vs pipeline parallelism tradeoffs.

Stage 8: Kernel-Level Optimization
Triton kernels, FlashAttention, CUDA graphs, operator fusion, Nsight profiling.

Stage 9: Distributed Inference
Multi-node serving, NVLink and InfiniBand, disaggregated prefill/decode, MoE expert parallelism.

Stage 10: Autoscaling and Economics
Queue-based scaling with KEDA, cold starts, spot GPUs, cost per token, MFU utilization.

Stage 11: Gateway, Routing, and Reliability
AI gateways, fallback chains, rate limits, TTFT and ITL SLOs, observability, chaos testing.

Stage 12: Portfolio and Benchmarks
Self-hosted cluster, published latency/throughput/cost benchmarks, kernel optimization writeups.

Most people stay stuck watching tutorials.

Builders get hired.

(Bookmark it)

[美研芒格君 @Kay2289123]

分享一份最近收集的 AI Infra 入门阅读清单，建议收藏，慢慢看

AI 已经可以生成很多很好的内容，解释概念、翻译论文、整理资料，都越来越方便。但在这个时代，能静下心来，把一篇好文章认真读完，把没懂的地方再琢磨一遍，我觉得更加难能可贵

这次整理的材料，主要集中在大模型推理这一块。从 KV Cache、显存管理，到请求调度、推理加速，再到怎么判断性能有没有真正变好

做工程的朋友，可以顺着往源码和实验里走。平时看 AI 产业、算力和存储的朋友，也可以先把原理读明白

读文章，挑值得反复读的。
1. 如果只选一篇，我会选 Inside vLLM。
Inside vLLM: Anatomy of a High-Throughput LLM Inference System，作者 Aleksa Gordić
https://t.co/Lc2Sk6Ivuf

把很多零散的概念串进了一个真实系统：一个请求进来，怎么排队，怎么分配 KV Cache，怎么执行，最后又怎么把结果送回来

PagedAttention、continuous batching、chunked prefill、prefix caching、投机解码、P/D 分离、多卡和性能测试，都能在这条线上找到位置。
这篇适合当主线，后面的材料用来补不懂的地方

2. 想弄懂 continuous batching，先看 Anyscale 这篇。
Continuous Batching 博客
https://t.co/7jufAckmsE

llm用户的回答有长有短，有的已经生成完了，有的还在继续。已经空出来的位置，能不能马上接下一个请求？
这篇用静态批处理和连续批处理的对比图，把这个问题讲得很直观。看完你会理解，GPU 的效率，也取决于请求怎么安排

建议重点看图和机制

3. NVIDIA 的两篇，一篇帮你建立全貌，一篇教你怎么看性能。
Mastering LLM Techniques: Inference Optimization
https://t.co/cFASAERBjM

适合先建立基本认识：处理输入的 prefill 和逐步生成输出的 decode 有什么区别，模型权重和 KV Cache 分别占什么空间，量化、批处理、多卡并行又各自解决什么问题

LLM Inference Benchmarking: Fundamental Concepts
https://t.co/yR5bIXxseZ
这一篇我也很推荐。用户等多久才看到第一个 token，后面生成得快不快，整个系统一秒能服务多少请求，是不同的问题。TTFT、ITL、TPOT 这些指标，要连着测试口径一起看

4. 想再往下算一层，读 kipply 的 Transformer Inference Arithmetic
Transformer Inference Arithmetic
这是一篇 2022 年的文章。它带你从计算量、内存容量、带宽和通信开销出发，估算推理为什么快、为什么慢，以及 batch size 改变后会发生什么

硬件和模型的具体例子有年代了, 作为 optional 选读

[孤桜ETH @GYLQ520]

想死磕LLM推理的，这套东西值得盯死。

有老哥搞了一份LLM工程师实战手册time-to-first-token，每天半个小时，磨它10周，总共50堂课。从零垒一套能上生产的完整技术栈：

1️⃣ 先建认知模型，吃透Decode为什么撑爆显存、Prefill为什么吃满算力

2️⃣ 硬啃vLLM源码，PagedAttention和调度器核心逻辑一个不跳

3️⃣ 上Prometheus、Grafana，把TTFT和队列状态盯死

4️⃣ 直接怼1000+并发压测，FP8、INT4量化怎么取舍讲得明明白白

🔗 https://t.co/Cu893x4sMe

[vixhaℓ @TheVixhal]

https://t.co/9CVnLrd9Xy

[ThinIceDancer @DanceOnThinIce]

@UTD_Seth001 I could not find more bold face lier outside of the Argentina team

[ThinIceDancer @DanceOnThinIce]

@Rmadonyfc_ They did it out of blatant lies and cheats. Anyone else bold enough to do that?