<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Know Thyself</title>
    <description>阅读、技术与生活札记</description>
    <link>https://www.hi-bin.com</link>
    <atom:link href="https://www.hi-bin.com/feed.xml" rel="self" type="application/rss+xml" />
    
      <item>
        <title>Vision Encoder：不同训练目标怎样塑造视觉表示？</title>
        <description>
          多模态第二课，同样的图片，为什么会学出不同的特征 - 
          目录多模态第二课视觉编码器是什么三种训练目标取哪一种特征动手比较特征怎样连接语言模型小结与下一课参考文献 　　上一课把图片切成 Patch，再送进 ViT，得到了每个位置的向量。这一课继续问：同样使用 ViT，为什么有的模型擅长分类，有的能用文字找图片，有的能提供有用的局部视觉特征？ 　　想象三位学生看同一张猫的照片：第一位要回答“是什么动物”，第二位要找到与它对应的描述，第三位要把不同裁剪里的视觉内容联系起来。看到的图片相同，要完成的任务却不同，学习时关注的信息也会不同。 ViT 是处理图片的结构，训练目标决定参数怎样被调整；实际表示还受数据、规模和训练细节影响。 1、视觉编码器到底输出什么？ 　　Vision Encoder 可以理解为把图片转换成视觉特征的模块。以 ViT 为例，它通常包含 Patch Embedding、位置机制和多个 Transformer Block；分类头、图文投影头则承担后续任务，读取特征时要区分骨干输出和任务头输出。 1.1 全图向量与 Patch 向量 　　假设有 196 个 Patch，隐藏宽度为 768，视觉编码器可以提供一组 [196,768] 的 Patch 特征，也可以通过 CLS 或池化得到一条 [768] 的全图特征。前者保留与网格位置对应的表示，后者适合描述整张图片；每个 Patch 经过 Attention 后已经包含上下文，不再只表示原来那一小块像素。 表示 像什么 可以怎样使用 全图特征 一张图片的摘要 图片检索、分类 Patch 特征 带位置的局部笔记 密集预测、给 VLM...
        </description>
        <pubDate>Wed, 07 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-07-Vision-Encoder%E4%B8%8D%E5%90%8C%E8%AE%AD%E7%BB%83%E7%9B%AE%E6%A0%87%E6%80%8E%E6%A0%B7%E5%A1%91%E9%80%A0%E8%A7%86%E8%A7%89%E8%A1%A8%E7%A4%BA/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-07-Vision-Encoder%E4%B8%8D%E5%90%8C%E8%AE%AD%E7%BB%83%E7%9B%AE%E6%A0%87%E6%80%8E%E6%A0%B7%E5%A1%91%E9%80%A0%E8%A7%86%E8%A7%89%E8%A1%A8%E7%A4%BA/</guid>
      </item>
    
      <item>
        <title>ViT：图片是怎么变成 Token 的？</title>
        <description>
          多模态第一课，从像素到视觉序列 - 
          目录 多模态第一课 为什么要切块 图片如何变成向量 最小代码实现 连接多模态模型 交互实验与动画 易错点 小结与下一课 参考文献 　　上一门课，我们把一句话沿着 Token ID、Embedding、Transformer 一路送进大模型；现在换一张图片，它没有词表，也没有现成的“单词边界”，怎样才能进入同样的计算框架？ 　　看一张游戏截图时，人一眼就能同时看见角色、掩体和准星，而模型最先拿到的却是一个像素数组，里面没有“敌人”这个标签，只有每个位置上的红、绿、蓝数值。 这一课先记住一条主线：图片切成小块 → 每块投影成向量 → 加上位置 → Transformer 让各块交换信息。 　　读完这一课，你应该能算出一张图片产生多少个视觉 Token，并解释它和文字 Token 的区别。 1、为什么要把图片切成小块？ 1.1 Transformer 需要序列，图片天然是二维的 　　Transformer 接收的基本形式是“一排向量”：文字经过分词与查表后，已经是这样的序列；图片则通常是 $H\times W\times C$ 的数组，其中 $H$ 是高度，$W$ 是宽度，RGB 图片的通道数 $C=3$。 　　最直接的办法是把每个像素当一个 Token，但一张 $224\times224$ 的图片就有 50,176 个位置，而普通全局 Attention 要比较每一对位置，序列一长，计算代价就会迅速增加。...
        </description>
        <pubDate>Wed, 07 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-07-ViT%E5%9B%BE%E7%89%87%E6%98%AF%E6%80%8E%E4%B9%88%E5%8F%98%E6%88%90Token%E7%9A%84/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-07-ViT%E5%9B%BE%E7%89%87%E6%98%AF%E6%80%8E%E4%B9%88%E5%8F%98%E6%88%90Token%E7%9A%84/</guid>
      </item>
    
      <item>
        <title>量化：INT8、INT4 到底损失了什么？</title>
        <description>
          少存几个比特，换来数值近似；质量和速度要另算 - 
          目录第二十课目录1、一个数字2、丢掉什么3、交互实验4、分组与敏感度5、量化了哪些张量6、速度边界7、复习总图 　　一个模型的权重原本可能用 FP16 或 BF16 保存。若改为 INT8、INT4，每个权重占用的比特更少，模型也更容易装进有限的显存。但原来那些细密的数值，必须落到数量有限的“格点”上。 量化首先损失的是数值表示的精细程度；模型回答是否明显变差、推理是否更快，需要另外验证。 同一个权重，在不同位宽下会被近似成什么。点击查看原始 SVG 先看一个数字怎样变形 　　假设某个权重是 0.37，我们暂时只允许保存 $[-1,1]$ 范围内的数。为讲清原理，使用一种简单的对称均匀量化：整数格点从 $-Q$ 到 $Q$，其中 INT8 取 $Q=127$，INT4 取 $Q=7$。这里刻意不用 INT4 可能存在的 $-8$ 档，方便正负范围对称；真实方案可采用不同范围、零点和舍入规则。 \[s=\frac{1}{Q},\qquad q=\operatorname{clip}\!\left(\operatorname{round}\!\left(\frac{x}{s}\right),-Q,Q\right),\qquad \hat{x}=q\,s\] 　　$s$ 是每格的宽度；$q$ 是存下来的整数；$\hat{x}$ 是计算时还原出的近似值。把 $x=0.37$ 代进去： 表示方式 格点宽度 存下的整数 还原的近似值 绝对误差 INT8（示意） $1/127$ 47 约 0.37008 约 0.00008 INT4（示意） $1/7$...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-%E9%87%8F%E5%8C%96INT8-INT4%E5%88%B0%E5%BA%95%E6%8D%9F%E5%A4%B1%E4%BA%86%E4%BB%80%E4%B9%88/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-%E9%87%8F%E5%8C%96INT8-INT4%E5%88%B0%E5%BA%95%E6%8D%9F%E5%A4%B1%E4%BA%86%E4%BB%80%E4%B9%88/</guid>
      </item>
    
      <item>
        <title>训练大模型为什么这么吃显存？</title>
        <description>
          参数、梯度、优化器状态与激活值，到底谁占得最多 - 
          目录第五课目录1、训练与推理2、参数3、梯度与优化器4、激活值5、简化算例6、省显存方法估算清单复习总图 　　第四课中，DataLoader 把形状为 $[B,T]$ 的 Token IDs 送进 GPU。接下来常见的问题是：模型文件明明只有十几 GB，为什么训练时几十 GB 显存仍然不够？ 　　因为 GPU 里放的不只是模型参数。训练还要保存梯度、优化器状态和反向传播需要的激活值。 模型大小只是显存账单的一部分；训练显存更像“四笔账”的总和。 训练显存的四笔账，点击查看原始 SVG 1、先分清训练和推理 　　推理只需要使用已经训练好的参数完成前向计算；训练还要反向传播并修改参数，因此需要保存更多中间数据。 内容 推理 训练 模型参数 ✓ ✓ 激活值 部分、短暂 ✓，供反向传播使用 梯度 — ✓ 优化器状态 — ✓ KV Cache 生成时常用 通常不是主要项 　　因此，同一个模型能在一张卡上推理，不代表也能在这张卡上完整训练。 2、参数本身占多少显存 　　参数显存可以粗略估算为： \[参数量 \times 每个参数的字节数\] 数据类型 每个参数大小 10 亿参数约占 FP32...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-%E8%AE%AD%E7%BB%83%E5%A4%A7%E6%A8%A1%E5%9E%8B%E4%B8%BA%E4%BB%80%E4%B9%88%E8%BF%99%E4%B9%88%E5%90%83%E6%98%BE%E5%AD%98/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-%E8%AE%AD%E7%BB%83%E5%A4%A7%E6%A8%A1%E5%9E%8B%E4%B8%BA%E4%BB%80%E4%B9%88%E8%BF%99%E4%B9%88%E5%90%83%E6%98%BE%E5%AD%98/</guid>
      </item>
    
      <item>
        <title>终期项目：训练、评估并部署一个小型语言模型</title>
        <description>
          把数据、模型、训练、评估和推理服务连成一条可复现链路 - 
          目录第二十四课目录1、先定义可验证目标2、数据与 Tokenizer3、模型与训练4、评估不能只看训练 Loss5、Checkpoint 与恢复6、推理与部署7、最终交付清单易错点复习总图 　　最后一课不再引入新缩写，而是把前 23 课连起来。目标不是训练一个巨型模型，而是完成一个规模可控、能够解释每个选择的小型语言模型项目。 项目完成的标准不是“跑出一段文字”，而是每个阶段都有记录、基线、检查和可复现结果。 第 24 课核心流程，点击查看原始 SVG 1、先定义可验证目标 明确模型规模、数据范围、上下文长度、硬件预算与成功指标。例如：在 TinyStories 类数据上训练一个小型 Decoder-only Transformer，验证 Loss 持续下降，并能生成结构完整的短文本。 先建立小基线，再扩大规模；不要第一次运行就把所有参数拉满。 2、数据与 Tokenizer 记录数据来源、许可、清洗规则、训练/验证切分与去重策略。训练 BPE Tokenizer，保存词表、Merge 和特殊 Token，并用固定样例检查 encode/decode 是否可逆。 3、模型与训练 实现 Embedding、RoPE、Attention、RMSNorm、SwiGLU、Residual、LM Head 与 Causal Mask。先用极小 Batch 过拟合少量样本，确认 Loss 能快速下降，再启动正式训练。 记录随机种子、配置、代码版本、每 Step Loss、学习率、梯度范数、吞吐和显存。 4、评估不能只看训练 Loss 至少报告验证集 Loss 与 Perplexity，并用固定...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-%E7%BB%88%E6%9C%9F%E9%A1%B9%E7%9B%AE%E8%AE%AD%E7%BB%83%E8%AF%84%E4%BC%B0%E5%B9%B6%E9%83%A8%E7%BD%B2%E4%B8%80%E4%B8%AA%E5%B0%8F%E5%9E%8B%E8%AF%AD%E8%A8%80%E6%A8%A1%E5%9E%8B/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-%E7%BB%88%E6%9C%9F%E9%A1%B9%E7%9B%AE%E8%AE%AD%E7%BB%83%E8%AF%84%E4%BC%B0%E5%B9%B6%E9%83%A8%E7%BD%B2%E4%B8%80%E4%B8%AA%E5%B0%8F%E5%9E%8B%E8%AF%AD%E8%A8%80%E6%A8%A1%E5%9E%8B/</guid>
      </item>
    
      <item>
        <title>位置编码：模型如何知道 Token 的顺序？</title>
        <description>
          从“我喜欢苹果”到绝对位置、相对距离、RoPE 与 NoPE - 
          目录第十一课·位置编码1、为什么需要位置线索2、位置的本质3、四种位置方法4、NoPE 的反转5、交互实验6、视频总结7、容易混淆的事8、复习总图 　　“我喜欢苹果”和“苹果喜欢我”使用同样的 Token，只是换了位置，意思就变了。 　　人类读到一句话时，内容和顺序同时到达。Transformer 最先拿到的却只是一排 Token 向量。向量告诉它“这是谁”，却没有天然告诉它“谁在前面”。 先记住一句话：Token Embedding 说明“是什么”，位置机制补充“在哪里、离多远”。 1、Transformer 为什么需要位置线索 　　暂时去掉位置信息和 Causal Mask。Self-Attention 对每个 Token 使用同样的规则生成 Q、K、V，再按相关性对 V 求加权和。如果只把输入重新排列，Q、K、V 也会跟着排列，计算规则本身没有一把固定的尺子。 [我, 喜欢, 苹果] → 对应的输出向量 [苹果, 喜欢, 我] → 同样的向量跟着换位 　　这叫排列等变：输入怎么换序，输出就怎么换序。它适合处理“一组东西”，却不足以表达语言的前后关系。 线索 它回答的问题 例子 Token ID 词表中是谁 “喜欢”是哪个 Token Position ID 在序列的哪里 这是第 12 个 Token Relative...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-%E4%BD%8D%E7%BD%AE%E7%BC%96%E7%A0%81%E6%A8%A1%E5%9E%8B%E5%A6%82%E4%BD%95%E7%9F%A5%E9%81%93Token%E7%9A%84%E9%A1%BA%E5%BA%8F/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-%E4%BD%8D%E7%BD%AE%E7%BC%96%E7%A0%81%E6%A8%A1%E5%9E%8B%E5%A6%82%E4%BD%95%E7%9F%A5%E9%81%93Token%E7%9A%84%E9%A1%BA%E5%BA%8F/</guid>
      </item>
    
      <item>
        <title>从零实现一次完整训练循环</title>
        <description>
          把 Batch、Forward、Loss、Backward 和 Optimizer Step 真正连起来 - 
          目录第八课目录1、循环什么2、准备输入3、Forward4、Loss5、Backward6、更新参数7、完整代码复习总图 　　前七课分别看过数据、模型、显存、多卡和混合精度。它们最后都会汇到同一段代码里：训练循环。 　　训练循环并不神秘。模型先根据一批输入做预测，用 Loss 衡量答案有多错，再通过 Backward 找出每个参数应该往哪边调整，最后由 Optimizer 真正更新参数。下一批数据到来后，重复这一过程。 一次训练迭代就是：取数据 → 清梯度 → Forward → 算 Loss → Backward → 更新参数。 从一批 Token 到一次参数更新，点击查看原始 SVG 1、训练循环到底在循环什么 　　一个 Epoch 表示完整看过一遍训练数据。一个 Step 表示处理一个 Batch，并尝试更新一次参数。 训练过程 ├─ Epoch 1 │ ├─ Batch 1 → Step 1 │ ├─ Batch 2 → Step 2...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-%E4%BB%8E%E9%9B%B6%E5%AE%9E%E7%8E%B0%E4%B8%80%E6%AC%A1%E5%AE%8C%E6%95%B4%E8%AE%AD%E7%BB%83%E5%BE%AA%E7%8E%AF/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-%E4%BB%8E%E9%9B%B6%E5%AE%9E%E7%8E%B0%E4%B8%80%E6%AC%A1%E5%AE%8C%E6%95%B4%E8%AE%AD%E7%BB%83%E5%BE%AA%E7%8E%AF/</guid>
      </item>
    
      <item>
        <title>一张 GPU 放不下模型时，多张 GPU 怎么分工？</title>
        <description>
          数据并行、张量并行、流水线并行与 ZeRO 到底在拆什么 - 
          目录第六课目录1、为什么需要多卡2、数据并行3、张量并行4、流水线并行5、ZeRO / FSDP6、如何组合方式对比复习总图 　　第五课算过：7B 模型采用混合精度 AdamW 训练时，仅参数、梯度和优化器状态就可能接近 112 GB，还没有算激活值。 　　一张 80 GB GPU 放不下，就要让多张 GPU 分担。但“多卡训练”不是一种固定做法，关键要先回答：究竟要拆什么？ 数据并行拆 Batch，张量并行拆一层里的计算，流水线并行拆模型层，ZeRO/FSDP 拆参数、梯度和优化器状态。 四种多 GPU 分工方式，点击查看原始 SVG 1、为什么需要多卡 　　多卡通常解决两类问题：一是单卡放不下，二是单卡算得太慢。 问题 目标 显存容量不足 把模型状态或激活分散到多卡 训练时间太长 让多卡同时处理更多计算 　　多一张 GPU 不等于速度直接翻倍。GPU 之间需要传输数据，通信会占时间；切分不均匀还会让部分 GPU 等待。 2、数据并行：拆 Batch 　　Data Parallel 最直观：每张 GPU 都保存完整模型，但处理不同的样本。 GPU 0：完整模型 + Batch A GPU...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-%E4%B8%80%E5%BC%A0GPU%E6%94%BE%E4%B8%8D%E4%B8%8B%E6%A8%A1%E5%9E%8B%E6%97%B6%E5%A4%9A%E5%BC%A0GPU%E6%80%8E%E4%B9%88%E5%88%86%E5%B7%A5/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-%E4%B8%80%E5%BC%A0GPU%E6%94%BE%E4%B8%8D%E4%B8%8B%E6%A8%A1%E5%9E%8B%E6%97%B6%E5%A4%9A%E5%BC%A0GPU%E6%80%8E%E4%B9%88%E5%88%86%E5%B7%A5/</guid>
      </item>
    
      <item>
        <title>一个 Transformer Block 内部到底有什么？</title>
        <description>
          看懂 Attention、FFN、RMSNorm 与残差连接怎样协作 - 
          目录第九课目录1、基本积木2、完整数据流3、Attention4、FFN5、Residual6、Norm7、形状变化复习总图 　　第一课里，我们把 Transformer 当成一个黑盒：Token 向量进去，带有上下文的信息出来。现在把黑盒打开一层。 　　大语言模型并不是只有一个巨大的 Transformer。它会把结构相同的 Transformer Block 堆叠很多次。每个 Block 都做两件核心工作：让 Token 之间交换信息，再分别加工每个 Token 的表示。 Attention 负责“彼此交流”，FFN 负责“各自加工”；Residual 和 Norm 让这两步能够稳定地重复很多层。 一个 Pre-Norm Transformer Block 的完整数据流，点击查看原始 SVG 1、Block 是模型的基本积木 　　假设输入隐藏状态是： \[x\in\mathbb{R}^{B\times T\times d_{model}}\] 　　一个 Block 接收 x，输出形状相同的新隐藏状态。然后，这个输出会成为下一个 Block 的输入。 Embedding → Block 1 → Block 2 → ... →...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-%E4%B8%80%E4%B8%AATransformer-Block%E5%86%85%E9%83%A8%E5%88%B0%E5%BA%95%E6%9C%89%E4%BB%80%E4%B9%88/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-%E4%B8%80%E4%B8%AATransformer-Block%E5%86%85%E9%83%A8%E5%88%B0%E5%BA%95%E6%9C%89%E4%BB%80%E4%B9%88/</guid>
      </item>
    
      <item>
        <title>Temperature、Top-K、Top-P 怎样改变生成结果？</title>
        <description>
          从同一组候选词出发，看懂“调权重、删候选、再抽样” - 
          目录第十七课目录1、一组候选2、选最大或抽样3、Temperature4、Top-K5、Top-P6、交互实验7、组合与边界8、复习总图 　　我们问模型：“法国的首都是”。模型不会直接说“我决定选巴黎”，而是先给词表里的每个 Token 一个分数，再由解码规则挑出下一个 Token。下面为了方便理解，只展示五个候选；真实词表远不止五个。 Temperature 改变候选之间的相对权重；Top-K 和 Top-P 缩小可选范围；最后一步才是抽样。 同一组候选，三种参数分别在哪一步起作用。点击查看原始 SVG 模型先给出一组候选 　　假设这次预测的概率是下表这样。数字是教学示意，不代表真实模型对这句话的输出。 候选 Token 概率 巴黎 0.55 北京 0.25 伦敦 0.12 东京 0.05 其他 0.03 　　五项加起来等于 1。“巴黎”最可能，但“最可能”与“必定选中”不是同一回事。 先分清：选最大，还是按概率抽 　　Greedy（贪心）每一步都选当前概率最高的 Token。按上表，它会选“巴黎”。Sampling（抽样）像按权重抽签：“巴黎”的签最多，其他候选仍有机会。Top-K、Top-P 和 Temperature 主要是给抽样前的分布定规则。 　　贪心路径并不保证整段话是概率最高或质量最好的；抽样也不保证内容更正确。解码策略影响结果，同一个模型也可能因选词方式不同，写出很不一样的文本。[1] Temperature：先改变概率的形状 　　模型原先给的是 Logits，即尚未归一化的分数。Temperature（温度）用一个正数 $\tau$ 缩放 Logits，再做 Softmax： \[p_i(\tau)=\frac{e^{z_i/\tau}}{\sum_j e^{z_j/\tau}},\qquad \tau&amp;gt;0\] 　　$\tau&amp;lt;1$ 时，原有分数差距被放大，高概率候选更占优势；$\tau&amp;gt;1$ 时，概率更平均，较弱候选更容易被抽到。温度不直接删除任何候选。它也不会把原来的排名颠倒：最高分仍是最高分。 　　接近...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-Temperature-Top-K-Top-P%E6%80%8E%E6%A0%B7%E6%94%B9%E5%8F%98%E7%94%9F%E6%88%90%E7%BB%93%E6%9E%9C/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-Temperature-Top-K-Top-P%E6%80%8E%E6%A0%B7%E6%94%B9%E5%8F%98%E7%94%9F%E6%88%90%E7%BB%93%E6%9E%9C/</guid>
      </item>
    
      <item>
        <title>SFT：怎样把基础模型训练成聊天助手？</title>
        <description>
          用指令与回答示范，改变模型在对话格式下的行为 - 
          目录第二十一课目录1、训练样本长什么样2、Loss 计算在哪些 Token 上3、它仍是下一个 Token 预测4、数据质量比堆数量更重要5、SFT 能做什么、不能做什么6、如何评估易错点复习总图 　　基础模型擅长续写互联网文本，却不一定知道何时回答、遵守什么格式。Supervised Fine-Tuning 用高质量的指令—回答示范继续训练，让模型学会期望的交互方式。 SFT 仍然是 Next Token Prediction，变化的是数据格式与哪些 Token 计入 Loss。 第 21 课核心流程，点击查看原始 SVG 1、训练样本长什么样 一条样本通常包含 system、user、assistant 等角色。Chat Template 会把结构化消息转换成模型实际看到的 Token 序列，并加入角色与结束标记。 训练与推理必须使用匹配的模板，否则模型可能无法识别轮次边界。 2、Loss 计算在哪些 Token 上 常见做法只让 assistant 回答部分计入 Loss，system 与 user Token 作为上下文但标签设为 ignore。这样模型学习“看到指令后如何回答”，而不是学习复述用户输入。 也有全序列训练等变体，选择要与数据和目标一致。 3、它仍是下一个 Token 预测 SFT 没有改变语言模型的基本目标：给定前文，预测下一个...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-SFT%E6%80%8E%E6%A0%B7%E6%8A%8A%E5%9F%BA%E7%A1%80%E6%A8%A1%E5%9E%8B%E8%AE%AD%E7%BB%83%E6%88%90%E8%81%8A%E5%A4%A9%E5%8A%A9%E6%89%8B/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-SFT%E6%80%8E%E6%A0%B7%E6%8A%8A%E5%9F%BA%E7%A1%80%E6%A8%A1%E5%9E%8B%E8%AE%AD%E7%BB%83%E6%88%90%E8%81%8A%E5%A4%A9%E5%8A%A9%E6%89%8B/</guid>
      </item>
    
      <item>
        <title>RoPE 是怎样把位置信息放进 Attention 的？</title>
        <description>
          转动 Q 和 K，让点积看见两个 Token 相隔多远 - 
          目录第十二课目录先记住一句话1、RoPE 改了哪里常见疑问：Embedding 变了吗2、把两维看成一个平面3、关键是角度差4、交互实验5、多种频率6、为什么不旋转 V7、长上下文8、视频讲解复习总图 　　先看两个短语： 我 喜欢 苹果 苹果 喜欢 我 　　Token 没有变。顺序变了，意思也变了。Attention 必须知道每个 Token 在哪里。 　　RoPE 的办法很特别。它不把位置向量加到 Token Embedding 上。它转动 Q 和 K，然后再计算点积。 先记住一句话 RoPE 用绝对位置决定旋转角度，用两个角度的差表示相对距离。 位置编号 → 旋转 Q/K → 计算角度差 → 得到 Attention 分数 1、RoPE 改了哪里 　　Attention 先从每个 Token 生成 Q、K、V。 Hidden State → Q、K、V Q ·...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-RoPE%E6%98%AF%E6%80%8E%E6%A0%B7%E6%8A%8A%E4%BD%8D%E7%BD%AE%E4%BF%A1%E6%81%AF%E6%94%BE%E8%BF%9BAttention%E7%9A%84/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-RoPE%E6%98%AF%E6%80%8E%E6%A0%B7%E6%8A%8A%E4%BD%8D%E7%BD%AE%E4%BF%A1%E6%81%AF%E6%94%BE%E8%BF%9BAttention%E7%9A%84/</guid>
      </item>
    
      <item>
        <title>Residual、LayerNorm 和 RMSNorm 为什么重要？</title>
        <description>
          深层 Transformer 怎样保留信息并让数值保持稳定 - 
          目录第十课目录1、深层网络的困难2、Residual3、Norm 的对象4、LayerNorm5、RMSNorm6、Pre / Post-Norm7、放回 Block复习总图 　　上一课打开 Transformer Block，看到每个子层都有一条残差路径，前面还有一次 RMSNorm。它们看起来不像 Attention 那样“聪明”，却决定了几十层甚至上百层的模型能不能稳定训练。 　　Residual 解决的是信息和梯度如何穿过深层网络，Norm 解决的是每一层接收到的数值尺度是否稳定。两者分工不同，又必须配合使用。 Residual 给信息留一条直路，Norm 把送进子层的数值调到合适尺度。 Residual、LayerNorm、RMSNorm 与 Pre-Norm，点击查看原始 SVG 1、为什么深层网络难训练 　　如果把很多非线性子层首尾相接，每一层都完全改写上一层的输出，会遇到两个直观问题： 原始信息经过很多次变换后更容易丢失。 反向传播要连续穿过每个子层，梯度可能变得过大、过小或不稳定。 　　同时，不同层输出的数值范围可能逐渐漂移。后一层今天接到很大的数，下一步又接到很小的数，学习会变得困难。 　　Residual 和 Norm 就是在改善这两个问题。 2、Residual：给信息留一条直路 　　普通子层直接输出 $F(x)$，残差结构则输出： \[y=x+F(x)\] 　　这里的 $x$ 沿旁路直接到达输出，$F(x)$ 只需要学习“在原表示上补充什么”。如果当前子层暂时学不到有用内容，只要 $F(x)$ 接近 0，信息仍可以近似原样通过。 　　反向传播时也多了一条直接路径： \[\frac{\partial y}{\partial x}=I+\frac{\partial F(x)}{\partial x}\] 　　式子里的 $I$ 来自那条不经过子层的旁路。它不能保证训练永远不会出问题，但能显著改善深层网络中的梯度传播。...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-Residual-LayerNorm%E5%92%8CRMSNorm%E4%B8%BA%E4%BB%80%E4%B9%88%E9%87%8D%E8%A6%81/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-Residual-LayerNorm%E5%92%8CRMSNorm%E4%B8%BA%E4%BB%80%E4%B9%88%E9%87%8D%E8%A6%81/</guid>
      </item>
    
      <item>
        <title>RLHF、DPO 与偏好对齐到底在做什么？</title>
        <description>
          从成对偏好数据到奖励模型、策略优化与直接偏好训练 - 
          目录第二十三课目录1、偏好数据2、经典 RLHF 流程3、Reward Hacking4、DPO 的核心5、RLHF 与 DPO 怎么选6、对齐不等于绝对安全易错点复习总图 　　很多回答没有唯一标准答案。标注者更容易比较 A 与 B 哪个更好，而不是为每个回答写一个绝对分数。偏好对齐就从这种成对选择开始。 SFT 教模型模仿理想答案，偏好训练教模型在两个可行答案中更偏向哪一个。 第 23 课核心流程，点击查看原始 SVG 1、偏好数据 对同一个 Prompt 生成多个回答，由人类或可靠规则选出 chosen 与 rejected。标准应明确，例如有用、诚实、安全、简洁与格式正确。 偏好标签会继承标注者和采样分布的偏差，因此需要一致性检查。 2、经典 RLHF 流程 InstructGPT 风格流程先做 SFT，再用偏好对训练 Reward Model，最后用 PPO 等强化学习算法优化策略，使奖励升高。 训练通常加入相对参考模型的 KL 约束，避免策略为了追求奖励而偏离语言能力太远。 3、Reward Hacking 奖励模型只是人类偏好的近似。策略可能找到能骗取高分却不真正有用的模式，这叫 Reward Hacking。监控长度偏差、套话、格式漏洞与分布外行为很重要。 4、DPO 的核心 DPO 不单独训练显式 Reward...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-RLHF-DPO%E4%B8%8E%E5%81%8F%E5%A5%BD%E5%AF%B9%E9%BD%90%E5%88%B0%E5%BA%95%E5%9C%A8%E5%81%9A%E4%BB%80%E4%B9%88/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-RLHF-DPO%E4%B8%8E%E5%81%8F%E5%A5%BD%E5%AF%B9%E9%BD%90%E5%88%B0%E5%BA%95%E5%9C%A8%E5%81%9A%E4%BB%80%E4%B9%88/</guid>
      </item>
    
      <item>
        <title>Prefill 与 Decode：推理为什么分成两个阶段？</title>
        <description>
          先读完提示词，再一个一个写出回答 - 
          目录第十九课目录1、时间线2、Prefill3、Decode4、交互演示5、性能差异6、延迟指标7、服务调度8、复习总图 　　我们输入“法国的首都是”，模型回答“巴黎。”。这看起来是一件连续的事，计算机却会把它分成两种很不一样的工作：先处理整个提示词，再根据已经生成的内容逐个预测后续 Token。研究 LLM 推理系统时，通常把它们叫作 Prefill 和 Decode。[1] Prefill 负责“读”；Decode 负责“接着写”。它们用的是同一模型，但每次送进模型的 Token 数量不同。 同一请求的时间线。点击查看原始 SVG 一次回答的时间线 　　为便于画图，我们把提示词示意性地切成“法国 / 的 / 首都 / 是”四个位置；这不代表实际 Tokenizer 一定这样切分。模型先对这四个位置运行一次前向计算，并从最后一个位置的输出预测第一个回答 Token“巴黎”。接下来把“巴黎”作为新输入，再预测“。”。如果还要继续，才把“。”送回模型。 时刻 本次送入模型的内容 本轮产生的下一个 Token 阶段 首次前向 四个提示词位置 巴黎 Prefill 下一轮前向 刚生成的“巴黎” 。 Decode 若继续 刚生成的“。” 下一个 Token Decode 　　第一个输出 Token 通常来自 Prefill 的最后位置，不是先把提示词 Prefill...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-Prefill%E4%B8%8EDecode%E6%8E%A8%E7%90%86%E4%B8%BA%E4%BB%80%E4%B9%88%E5%88%86%E6%88%90%E4%B8%A4%E4%B8%AA%E9%98%B6%E6%AE%B5/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-Prefill%E4%B8%8EDecode%E6%8E%A8%E7%90%86%E4%B8%BA%E4%BB%80%E4%B9%88%E5%88%86%E6%88%90%E4%B8%A4%E4%B8%AA%E9%98%B6%E6%AE%B5/</guid>
      </item>
    
      <item>
        <title>MoE：为什么只让每个 Token 找少数专家？</title>
        <description>
          从 FFN、Router 到负载均衡，看懂“参数多、计算少”如何成立 - 
          目录第十五课目录1、为什么要稀疏2、专家是什么3、Router 如何选择4、交互实验5、计算账6、负载均衡7、通信成本8、复习总图 　　上一课说到：FFN 会分别加工每个 Token。普通的稠密模型让所有 Token 使用同一套 FFN。MoE（Mixture of Experts，混合专家）则准备多套 FFN，让一个小型 Router 为每个 Token 选其中少数几套。[1] MoE 想增加可用的参数容量，同时控制每个 Token 实际执行的 FFN 数量。 一个 Token 如何选择并经过专家，点击查看原始 SVG 先看问题：如果每个 Token 都用全部专家 　　假设某层有 8 套 FFN。如果每个 Token 都要使用这 8 套，参数容量是增加了，但这一层的 FFN 计算也会跟着涨。上下文很长或并发很多时，代价会很高。 　　MoE 的想法是：8 套 FFN 都可供选择，但每个 Token 只经过其中 1 套或 2 套。这样，模型拥有的总参数与一次计算中真正用到的激活参数就成了两个不同的数。Switch Transformer...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-MoE%E4%B8%BA%E4%BB%80%E4%B9%88%E5%8F%AA%E6%BF%80%E6%B4%BB%E4%B8%80%E9%83%A8%E5%88%86%E4%B8%93%E5%AE%B6/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-MoE%E4%B8%BA%E4%BB%80%E4%B9%88%E5%8F%AA%E6%BF%80%E6%B4%BB%E4%B8%80%E9%83%A8%E5%88%86%E4%B8%93%E5%AE%B6/</guid>
      </item>
    
      <item>
        <title>MHA、MQA、GQA、MLA：它们到底在省什么？</title>
        <description>
          从每个 Head 一套 KV，到只缓存一份低维潜表示 - 
          目录第十三课目录1、真正的问题2、统一例子3、MHA4、MQA5、GQA6、MLA7、交互实验8、怎样选择9、复习总图 　　MHA、MQA、GQA、MLA 看起来像四个需要背诵的缩写。其实先记住一个问题就够了：生成下一个 Token 时，模型要怎样读取前文的 K 和 V？ 这四种结构都保留多个 Query Head。它们真正不同的地方，是历史 Token 的 K、V 如何保存：每个 Head 各存一份、多人共享一份，还是改存一份低维潜表示。 用 8 个 Query Head 比较四种结构，点击查看原始 SVG 先抓住真正的问题：Decode 时反复搬运 KV 　　在生成阶段，模型一次只生成一个新 Token。这个新 Token 会产生 Query，然后回头和前面所有 Token 的 Key、Value 做注意力计算。 　　前文的 K、V 不必每次重算，所以模型会把它们保存在 KV Cache 中。省下计算以后，另一个问题出现了：上下文越长、并发请求越多，模型每一步要从显存读取的历史 K、V 就越多。此时速度常常受制于显存带宽，而不只是算力。 　　如果先不考虑 MLA，每层、每个 Token 的 KV Cache...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-MHA-MQA-GQA%E5%92%8CMLA%E6%9C%89%E4%BB%80%E4%B9%88%E5%8C%BA%E5%88%AB/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-MHA-MQA-GQA%E5%92%8CMLA%E6%9C%89%E4%BB%80%E4%B9%88%E5%8C%BA%E5%88%AB/</guid>
      </item>
    
      <item>
        <title>LoRA 与 QLoRA：普通显卡怎样微调模型？</title>
        <description>
          冻结基础权重，用低秩增量学习任务变化 - 
          目录第二十二课目录1、低秩增量2、Rank 与 Alpha3、加在哪些层4、QLoRA 多做了什么5、训练后怎样使用6、省显存不等于没有代价易错点复习总图 　　全参数微调要为每个参数保存梯度和优化器状态，显存代价高。LoRA 冻结基础模型，只在部分线性层旁加入两块小矩阵。 LoRA 不直接改写大权重矩阵，而是学习一个低秩增量 ΔW。 第 22 课核心流程，点击查看原始 SVG 1、低秩增量 对原权重 W，LoRA 使用 W+ΔW，其中 ΔW=B·A。若隐藏维很大而秩 r 很小，A、B 的参数量远少于完整 W。 初始化通常让训练开始时 ΔW 接近 0，从基础模型行为平稳出发。 2、Rank 与 Alpha Rank r 决定低秩通道宽度，越大容量与训练参数越多。Alpha 用于缩放 LoRA 更新，常见形式为 alpha/r。二者需要结合任务与目标层调节。 3、加在哪些层 常见目标包括 Attention 的 q_proj、k_proj、v_proj、o_proj，以及 FFN 投影。只训练少数层更省，但可能限制适应能力；覆盖更多层需要更多显存。 4、QLoRA 多做了什么 QLoRA 把冻结的基础模型权重量化为 4-bit，Forward 时按需反量化计算，同时让...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-LoRA%E4%B8%8EQLoRA%E6%99%AE%E9%80%9A%E6%98%BE%E5%8D%A1%E6%80%8E%E6%A0%B7%E5%BE%AE%E8%B0%83%E6%A8%A1%E5%9E%8B/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-LoRA%E4%B8%8EQLoRA%E6%99%AE%E9%80%9A%E6%98%BE%E5%8D%A1%E6%80%8E%E6%A0%B7%E5%BE%AE%E8%B0%83%E6%A8%A1%E5%9E%8B/</guid>
      </item>
    
      <item>
        <title>KV Cache 为什么能加速逐 Token 生成？</title>
        <description>
          旧 Token 的 K、V 不再重算；新 Query 仍要看历史 - 
          目录第十八课目录1、重复计算2、保存什么3、交互演示4、为什么不存 Q5、显存代价6、复用边界7、复习总图 　　模型收到“法国的首都是”，回答出“巴黎”。如果还要继续生成句号，它会再次处理当前上下文。问题是：前面的“法国、的、首都、是”早已算过，为什么每多生成一个 Token，还要把它们的 Key 和 Value 再算一遍？ KV Cache 保存历史 Token 在每一层 Attention 中的 K、V。下一个 Token 到来时，只为它生成新的 Q、K、V，并让新 Q 查询缓存中的历史 K、V。 从 Prefill 到 Decode：旧 K/V 复用，新 K/V 追加。点击查看原始 SVG 一段话为什么会被重复计算 　　自回归生成一次只决定下一个 Token。若每一步都把完整前缀重新送进模型，第 1 次处理 4 个 Token，第 2 次处理 5 个，第 3 次处理 6 个；前面位置的表示和 K/V 又跟着计算。对因果 Attention...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-KV-Cache%E4%B8%BA%E4%BB%80%E4%B9%88%E8%83%BD%E5%8A%A0%E9%80%9F%E9%80%90Token%E7%94%9F%E6%88%90/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-KV-Cache%E4%B8%BA%E4%BB%80%E4%B9%88%E8%83%BD%E5%8A%A0%E9%80%9F%E9%80%90Token%E7%94%9F%E6%88%90/</guid>
      </item>
    
      <item>
        <title>FlashAttention 为什么更快、更省显存？</title>
        <description>
          公式没变，改变的是数据在 GPU 里怎么走 - 
          目录第十六课目录1、问题在哪2、两级存储3、分块计算4、在线 Softmax5、交互演示6、反向传播7、适用边界8、复习总图 　　前面学 Attention 时，我们写下了一个很简洁的公式： \[\operatorname{Attention}(Q,K,V)=\operatorname{softmax}\!\left(\frac{QK^\top}{\sqrt{d_k}}\right)V\] 　　公式只占一行，照着它一步一步计算，却可能在 GPU 上反复搬运一张很大的中间表。FlashAttention 的核心不是改掉这个公式，而是改变计算顺序：尽量在片上算完当前的一小块，不把整张注意力矩阵写回显存。[1] 两种数据流：公式相同，搬运方式不同。点击查看原始 SVG 从一张注意力矩阵说起 　　假设一段输入有 $T$ 个 Token。每个 Query 都要与 Key 比较，分数形成一张 $T\times T$ 的表。朴素实现先算 $QK^\top$，把分数写到 GPU 显存；读出来做 Softmax，再写回；接着又读出来与 $V$ 相乘。 　　如果 $T=4096$，仅一张单头、单样本的 FP16 分数表就有 $4096^2$ 个数，约 32 MiB。这还没算其他中间结果、多个头和批次。关键不只是“放不放得下”：写出、再读回这张表，也要花时间。 显存大，不等于访问快 　　可以把 GPU 的 HBM 想成仓库：容量大，但从中取货有搬运成本。片上 SRAM 像工作台：空间小，取用却快。这个比喻只用于理解存储层级，不代表真实 GPU 只有两层内存。 　　如果每做一步都把整张表送回仓库，计算单元就会等数据。FlashAttention 设计时把这种读写成本也算进去，所以论文称它为...
        </description>
        <pubDate>Sat, 03 Oct 2026 00:00:00 +0800</pubDate>
        <link>https://www.hi-bin.com/2026-10-03-FlashAttention%E4%B8%BA%E4%BB%80%E4%B9%88%E6%9B%B4%E5%BF%AB%E6%9B%B4%E7%9C%81%E6%98%BE%E5%AD%98/</link>
        <guid isPermaLink="true">https://www.hi-bin.com/2026-10-03-FlashAttention%E4%B8%BA%E4%BB%80%E4%B9%88%E6%9B%B4%E5%BF%AB%E6%9B%B4%E7%9C%81%E6%98%BE%E5%AD%98/</guid>
      </item>
    
  </channel>
</rss>
