<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>I1 on 吕炘嵘的博客</title>
    <link>https://blog.lvxinrong.com/tags/i1/</link>
    <description>Recent content in I1 on 吕炘嵘的博客</description>
    <image>
      <title>吕炘嵘的博客</title>
      <url>https://blog.lvxinrong.com/og-default.jpg</url>
      
      <link>https://blog.lvxinrong.com/tags/i1/</link>
    </image>
    <generator>Hugo</generator>
    <language>zh-CN</language>
    <lastBuildDate>Tue, 10 Nov 2026 12:25:26 +0800</lastBuildDate>
    <atom:link href="https://blog.lvxinrong.com/tags/i1/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>手搓 LLM 笔记 18：I1，让语料从文本流向可训练数据</title>
      <link>https://blog.lvxinrong.com/llm/llm-18-i1-data-pipeline/</link>
      <pubDate>Tue, 10 Nov 2026 12:25:26 +0800</pubDate>
      <guid>https://blog.lvxinrong.com/llm/llm-18-i1-data-pipeline/</guid>
      <description>从博客源文档清单、最小清洗和 JSONL，到 uint32 token 文件、np.memmap、训练冒烟、BPB 与 Scaling 测算；重点不是训练大模型，而是把数据如何进入模型这条链路打通。</description>
      <content:encoded><![CDATA[<blockquote>
<p>今天没有训练一个更强的大模型，而是回答另一个更基础的问题：一堆博客文章，怎样变成可以追溯、可以流式读取、可以参与训练和评估的数据？</p>
</blockquote>
<h2 id="一i1-要解决什么">一、I1 要解决什么？</h2>
<p>第一阶段和 I0 的代码已经可以完成模型训练与推理，但数据侧仍然存在一个隐患：所有东西都会被提前装进内存。</p>
<p>旧的 <code>TokenStreamDataset</code> 大致是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">ids</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">for</span> <span class="n">text</span> <span class="ow">in</span> <span class="n">texts</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="n">ids</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="n">tokenizer</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="n">text</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">ids</span><span class="p">)</span> <span class="o">-</span> <span class="n">max_length</span><span class="p">,</span> <span class="n">stride</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">    <span class="bp">self</span><span class="o">.</span><span class="n">input_ids</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">ids</span><span class="p">[</span><span class="n">i</span><span class="p">:</span><span class="n">i</span> <span class="o">+</span> <span class="n">max_length</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">    <span class="bp">self</span><span class="o">.</span><span class="n">target_ids</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">ids</span><span class="p">[</span><span class="n">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">:</span><span class="n">i</span> <span class="o">+</span> <span class="n">max_length</span> <span class="o">+</span> <span class="mi">1</span><span class="p">])</span>
</span></span></code></pre></div><p>这里有三层全量物化：</p>
<ol>
<li>全部文本被读入内存；</li>
<li>全部 token IDs 被放进 Python list；</li>
<li>所有 input/target 窗口又被提前保存成两个 list。</li>
</ol>
<p>在当前个人博客规模下，它并不慢，也不构成明显内存压力。但如果未来语料扩大，这种写法会让内存随语料总量增长。</p>
<p>所以 I1 的目标不是“让今天的数据突然变快”，而是建立一条更可扩展的主干：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">源文档清单
</span></span><span class="line"><span class="cl">→ 最小清洗
</span></span><span class="line"><span class="cl">→ train / held-out 隔离
</span></span><span class="line"><span class="cl">→ JSONL 文档流
</span></span><span class="line"><span class="cl">→ uint32 token 文件
</span></span><span class="line"><span class="cl">→ np.memmap 按需读取
</span></span><span class="line"><span class="cl">→ 训练与 BPB 评估
</span></span></code></pre></div><h2 id="二先盘点42-条文档不都是文章">二、先盘点：42 条文档不都是文章</h2>
<p>第一步没有直接清洗，而是从 <code>lv_blog/content/**/*.md</code> 重新建立文档级清单。</p>
<p><code>train.txt</code> 已经把多篇文章拼成了一个大字符串，无法单独追溯每一篇。新的清单直接读取原始 Markdown，并保留标题、路径、日期、正文大小和 SHA-256。</p>
<p>第一次汇总：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">included_documents = 42
</span></span><span class="line"><span class="cl">excluded:
</span></span><span class="line"><span class="cl">  index  = 9
</span></span><span class="line"><span class="cl">  layout = 3
</span></span><span class="line"><span class="cl">  draft  = 14
</span></span></code></pre></div><p>我一开始觉得数量对不上，因为印象里应该是“接近 40 篇”。继续检查后发现，42 条中还包含：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">content/about.md       → 关于页面
</span></span><span class="line"><span class="cl">content/roadmap.md     → 学习路线图
</span></span><span class="line"><span class="cl">content/llm-backlog.md → 学习回炉待办
</span></span></code></pre></div><p>于是增加了 <code>document_type</code>，得到：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">article  = 39
</span></span><span class="line"><span class="cl">profile  = 1
</span></span><span class="line"><span class="cl">roadmap  = 1
</span></span><span class="line"><span class="cl">backlog  = 1
</span></span><span class="line"><span class="cl">合计     = 42
</span></span></code></pre></div><p>这正好解释了数量差异。</p>
<p>这次盘点让我看到：<strong>数据口径不一致时，先分类和追溯，不要急着删除或强行让数字相等。</strong></p>
<h2 id="三manifest-是数据档案不是训练文本">三、manifest 是数据档案，不是训练文本</h2>
<p>今天生成了几种不同用途的文件，需要分清：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">source inventory / corpus manifest
</span></span><span class="line"><span class="cl">记录文档来源、类型、划分、大小和 hash
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">train.jsonl / heldout.jsonl
</span></span><span class="line"><span class="cl">保存一篇篇清洗后的实际文档内容
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">token store metadata
</span></span><span class="line"><span class="cl">记录 tokenizer、dtype、EOS、文档 offset / length 和 hash
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">memmap Dataset
</span></span><span class="line"><span class="cl">根据二进制 token 文件与训练窗口配置，按需产生样本
</span></span></code></pre></div><p>manifest 不是模型直接读取的正文，而是整批数据的档案。后续要证明两次实验使用的是同一批数据，不能只写“用了博客语料”，还要能对应到具体版本和内容指纹。</p>
<h2 id="四sha-256-在这里做什么">四、SHA-256 在这里做什么？</h2>
<p>SHA-256 在当前管线里只是内容指纹，不是加密，也不会参与模型计算。</p>
<p>它主要有四个用途：</p>
<ol>
<li>检查完全重复的正文；</li>
<li>防止同一篇内容同时进入 train 和 held-out；</li>
<li>判断文件或正文是否发生变化；</li>
<li>让训练、BPB 和评估报告能追溯到具体数据版本。</li>
</ol>
<p>今天还区分了两种 hash：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">source_sha256
</span></span><span class="line"><span class="cl">→ 清洗后正文
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">encoded_sha256
</span></span><span class="line"><span class="cl">→ 实际送入 tokenizer 的“标题 + 正文”
</span></span></code></pre></div><p>这两个值需要分开，因为后续加入标题以后，正文 hash 已经不能代表完整的编码输入。</p>
<h2 id="五清洗只做到够用不做通用平台">五、清洗只做到够用，不做通用平台</h2>
<p>我的博客格式比较固定，部分文章存在图片链接。今天的决定是：不写通用 Markdown 解析器，只覆盖当前真实格式。</p>
<p><code>src/squid/data/markdown.py</code> 只做：</p>
<ul>
<li>普通链接保留显示文字；</li>
<li>图片保留 alt，无 alt 则删除；</li>
<li>合并多余空行；</li>
<li>按代码块分段，代码内部不应用清洗规则。</li>
</ul>
<p>代码块需要单独保护，否则代码里的注释或字符串也可能被误当成 Markdown 链接和图片。</p>
<p><code>tests/test_markdown.py</code> 验收了 5 个场景：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">普通链接保留文字
</span></span><span class="line"><span class="cl">图片保留 alt
</span></span><span class="line"><span class="cl">无 alt 图片删除
</span></span><span class="line"><span class="cl">代码块保持不变
</span></span><span class="line"><span class="cl">多余空行合并
</span></span></code></pre></div><p>结果：<code>5 passed</code>。</p>
<p>这里刻意没有继续做 OCR、通用质量评分、复杂清洗规则或完整 MinHash 管线。当前语料规模小、来源可信，清洗够用地服务主干即可。未来如果有大批量语料，再借助 AI 完成更系统的清洗与划分也来得及。</p>
<h2 id="六第一次接触-jsonl">六、第一次接触 JSONL</h2>
<p>清洗后的文档被写成：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">data/corpus/blog_v1/train.jsonl
</span></span><span class="line"><span class="cl">data/corpus/blog_v1/heldout.jsonl
</span></span></code></pre></div><p>JSONL 是 JSON Lines，一行一个完整 JSON 对象：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-jsonl" data-lang="jsonl"><span class="line"><span class="cl"><span class="p">{</span><span class="nt">&#34;title&#34;</span><span class="p">:</span> <span class="s2">&#34;第一篇&#34;</span><span class="p">,</span> <span class="nt">&#34;text&#34;</span><span class="p">:</span> <span class="s2">&#34;第一篇正文&#34;</span><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span><span class="nt">&#34;title&#34;</span><span class="p">:</span> <span class="s2">&#34;第二篇&#34;</span><span class="p">,</span> <span class="nt">&#34;text&#34;</span><span class="p">:</span> <span class="s2">&#34;第二篇正文&#34;</span><span class="p">}</span>
</span></span></code></pre></div><p>它和 JSON 数组不同，不需要一次性读取整个文件，可以：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">path</span><span class="p">,</span> <span class="n">encoding</span><span class="o">=</span><span class="s2">&#34;utf-8&#34;</span><span class="p">)</span> <span class="k">as</span> <span class="n">file</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">file</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="n">document</span> <span class="o">=</span> <span class="n">json</span><span class="o">.</span><span class="n">loads</span><span class="p">(</span><span class="n">line</span><span class="p">)</span>
</span></span></code></pre></div><p>正文中的换行会被转义为 <code>\n</code>，读取后再还原，因此仍能保持“一行一篇”。</p>
<p>JSONL 不适合用 <code>indent=2</code> 美化，否则一条记录会跨多行。<code>manifest.json</code> 可以美化，文档流则保持一行一条。</p>
<p>最终构建结果：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">train_documents   = 38
</span></span><span class="line"><span class="cl">heldout_documents = 2
</span></span><span class="line"><span class="cl">total_documents   = 40
</span></span></code></pre></div><p>即：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">39 篇文章 + 1 篇 profile = 40 个候选
</span></span><span class="line"><span class="cl">40 - 2 篇固定 held-out = 38 条训练候选
</span></span></code></pre></div><p>原有 held-out 继续隔离，没有因为重新生成语料而混回训练集。</p>
<h2 id="七标题应该进入训练文本">七、标题应该进入训练文本</h2>
<p>最初 <code>write_tokens()</code> 只编码：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">document</span><span class="p">[</span><span class="s2">&#34;text&#34;</span><span class="p">]</span>
</span></span></code></pre></div><p>我随后意识到：标题对我来说很重要，它不是单纯的文件名，也承载文章主题和表达结构。</p>
<p>因此实际编码文本改为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">text</span> <span class="o">=</span> <span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="sa">f</span><span class="s2">&#34;# </span><span class="si">{</span><span class="n">document</span><span class="p">[</span><span class="s1">&#39;title&#39;</span><span class="p">]</span><span class="si">}</span><span class="se">\n\n</span><span class="s2">&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="sa">f</span><span class="s2">&#34;</span><span class="si">{</span><span class="n">document</span><span class="p">[</span><span class="s1">&#39;text&#39;</span><span class="p">]</span><span class="si">}</span><span class="s2">&#34;</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</span></span></code></pre></div><p>也就是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl"># 文章标题
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">清洗后的正文……
</span></span></code></pre></div><p>metadata 中同时记录：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-json" data-lang="json"><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;include_title&#34;</span><span class="p">:</span> <span class="kc">true</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;title_template&#34;</span><span class="p">:</span> <span class="s2">&#34;# {title}\n\n{text}&#34;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>这样以后看到 token 文件，就能明确知道标题有没有参与训练，以及是怎样拼入的。</p>
<h2 id="八为什么-token-文件使用-uint32">八、为什么 token 文件使用 uint32？</h2>
<p>Qwen 的词表大小是 <code>151936</code>，而 <code>uint16</code> 最大只能表示 <code>65535</code>。</p>
<p>因此不能为了节省空间使用 uint16，当前统一使用：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">np</span><span class="o">.</span><span class="n">asarray</span><span class="p">(</span><span class="n">ids</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">np</span><span class="o">.</span><span class="n">uint32</span><span class="p">)</span>
</span></span></code></pre></div><p>每个 token 固定占 4 bytes。</p>
<p><code>build_token_store.py</code> 的主干是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">逐行读取一篇 JSONL
</span></span><span class="line"><span class="cl">→ 拼接标题与正文
</span></span><span class="line"><span class="cl">→ 编码当前文档
</span></span><span class="line"><span class="cl">→ 追加 EOS ID
</span></span><span class="line"><span class="cl">→ 转成 uint32
</span></span><span class="line"><span class="cl">→ 写入二进制文件
</span></span><span class="line"><span class="cl">→ 记录 offset、length 和 hash
</span></span></code></pre></div><p>这里修正过一个属性错误：需要写入的是整数 <code>tokenizer.eos_id</code>，不是字符串 <code>eos_token</code>。</p>
<p>最终生成：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">data/token_store/blog_v1/
</span></span><span class="line"><span class="cl">├── train.uint32.bin
</span></span><span class="line"><span class="cl">├── heldout.uint32.bin
</span></span><span class="line"><span class="cl">└── metadata.json
</span></span></code></pre></div><p>汇总结果：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">train_tokens   = 117890
</span></span><span class="line"><span class="cl">heldout_tokens = 5485
</span></span></code></pre></div><p>metadata 还验证了：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">二进制文件 bytes = token_count × 4
</span></span></code></pre></div><h2 id="九memmap从保存所有窗口改成用时再切">九、memmap：从“保存所有窗口”改成“用时再切”</h2>
<p><code>np.memmap</code> 使用只读映射：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">tokens</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">memmap</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">    <span class="n">token_path</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">dtype</span><span class="o">=</span><span class="s2">&#34;uint32&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="n">mode</span><span class="o">=</span><span class="s2">&#34;r&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl"><span class="p">)</span>
</span></span></code></pre></div><p>第一次读取时，成功从首篇文档还原出：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl"># 关于
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">## 我是谁
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">吕炘嵘，一个写了十一年多代码的人……
</span></span></code></pre></div><p>新的 <code>MemmapTokenDataset</code> 不再提前保存所有窗口，只保存映射、窗口长度、stride 和样本数量：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">start</span> <span class="o">=</span> <span class="n">idx</span> <span class="o">*</span> <span class="bp">self</span><span class="o">.</span><span class="n">stride</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">input_ids</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">tokens</span><span class="p">[</span>
</span></span><span class="line"><span class="cl">    <span class="n">start</span><span class="p">:</span><span class="n">start</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">max_length</span>
</span></span><span class="line"><span class="cl"><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="n">target_ids</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">tokens</span><span class="p">[</span>
</span></span><span class="line"><span class="cl">    <span class="n">start</span> <span class="o">+</span> <span class="mi">1</span><span class="p">:</span><span class="n">start</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">max_length</span> <span class="o">+</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl"><span class="p">]</span>
</span></span></code></pre></div><p>交给模型前再转换成 <code>torch.long</code>，因为 Embedding 索引需要整数张量。</p>
<h3 id="最后一个窗口会不会越界">最后一个窗口会不会越界？</h3>
<p><code>sample_count</code> 使用与旧实现一致的窗口起点范围。设 token 总数为 <code>L</code>、窗口长度为 <code>M</code>，最后一个起点满足：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">start &lt;= L - M - 1
</span></span></code></pre></div><p>因此 target 的切片结束位置最多为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">start + M + 1 &lt;= L
</span></span></code></pre></div><p>刚好不会超出末尾。</p>
<p>NumPy 切片越界时通常会静默返回较短数组，所以测试不能只比较新旧实现，还需要独立检查每个 input/target 的 shape 都是 <code>(128,)</code>。</p>
<h2 id="十先做内容对照再谈内存优化">十、先做内容对照，再谈内存优化</h2>
<p>今天写了两层对照：</p>
<ol>
<li><code>test_token_store_matches_pack_tokens</code>：二进制 token 流与旧 <code>pack_tokens()</code> 逐元素一致，offset、length 和 EOS 也一致；</li>
<li><code>test_memmap_dataset_matches_legacy_dataset</code>：在 stride 64 和 128 下，新旧 Dataset 的选中窗口内容一致。</li>
</ol>
<p>全部通过。</p>
<p>第一次内存对照还暴露了一个实验设计错误：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">旧 Dataset 使用旧 train.txt：69316 tokens → 541 窗口
</span></span><span class="line"><span class="cl">新 Dataset 使用新 token store：117890 tokens → 921 窗口
</span></span></code></pre></div><p>输入不同，内存数字就不能直接比较。</p>
<p>修正为两边都使用同一个 <code>train.uint32.bin</code> 后，得到：</p>
<div class="table-scroll" tabindex="0" role="region" aria-label="表格，可横向滚动">
  <table>
    <thead>
      <tr>
        <th>实现</th>
        <th style="text-align: right">source tokens</th>
        <th style="text-align: right">windows</th>
        <th style="text-align: right">Python 当前分配</th>
        <th style="text-align: right">Python 峰值分配</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>旧 TokenStreamDataset</td>
        <td style="text-align: right">117890</td>
        <td style="text-align: right">921</td>
        <td style="text-align: right">2,004,496 bytes</td>
        <td style="text-align: right">2,004,672 bytes</td>
      </tr>
      <tr>
        <td>MemmapTokenDataset</td>
        <td style="text-align: right">117890</td>
        <td style="text-align: right">921</td>
        <td style="text-align: right">1,766 bytes</td>
        <td style="text-align: right">8,505 bytes</td>
      </tr>
    </tbody>
  </table>
</div>
<p>这才是同输入对照。</p>
<p>减少的是“提前物化所有窗口”的 Python 分配，不是宣称操作系统映射页面完全不占内存。<code>tracemalloc</code> 也无法覆盖所有底层和 OS 内存。</p>
<p>两边的构建时间分别是约 <code>2.50 ms</code> 与 <code>8.25 ms</code>，单次毫秒级结果不能用来证明 memmap 更慢或更快。当前优化的目标是可扩展性，不是这几毫秒。</p>
<h2 id="十一让-memmap-数据真正进入训练">十一、让 memmap 数据真正进入训练</h2>
<p>随后用一个小型 <code>GPTModelV3</code> 做了 5 步训练冒烟：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">emb_dim = 64
</span></span><span class="line"><span class="cl">ffn_dim = 256
</span></span><span class="line"><span class="cl">n_layers = 2
</span></span><span class="line"><span class="cl">n_heads = 4
</span></span><span class="line"><span class="cl">n_kv_heads = 2
</span></span><span class="line"><span class="cl">context_length = 128
</span></span><span class="line"><span class="cl">vocab_size = 151936
</span></span></code></pre></div><p>没有加载 Qwen 权重，不追求模型质量，只验证：</p>
<ul>
<li>memmap 样本能进入模型；</li>
<li>loss 是有限值；</li>
<li>backward 与 optimizer 能执行；</li>
<li>checkpoint 能保存与重载；</li>
<li>重载前后同一批输入的 logits 完全一致。</li>
</ul>
<p>实测 loss：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">12.1019 → 12.1559 → 12.0544 → 12.1084 → 12.0915
</span></span></code></pre></div><p>没有断言 loss 必须下降，因为 5 步随机批次训练不能支持这种要求。</p>
<p>作为数量级参照，词表均匀分布时交叉熵约为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">ln(151936) ≈ 11.93
</span></span></code></pre></div><p>所以这里的 loss 只能说明训练链路可运行，不能说明模型已经学会博客内容。</p>
<h2 id="十二bpb把-loss-归一到原始文本字节">十二、BPB：把 loss 归一到原始文本字节</h2>
<p>BPB 是 Bits Per Byte，表示平均每个原始 UTF-8 字节对应多少 bits 的预测/编码成本。同一份评估文本、同一口径下，通常越低越好。</p>
<p>它需要模型 loss 参与，不是 tokenizer 单独能计算的指标：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">BPB = 总交叉熵 nats / ln(2) / 总评估 UTF-8 bytes
</span></span></code></pre></div><p>今天的 held-out 冒烟报告：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">evaluated_tokens      = 5376
</span></span><span class="line"><span class="cl">evaluated_utf8_bytes  = 18932
</span></span><span class="line"><span class="cl">mean_loss             = 12.081579798743839
</span></span><span class="line"><span class="cl">BPB                   = 4.949496596618363
</span></span></code></pre></div><p>计算时按 target 数累计交叉熵，避免最后一个较小 batch 被赋予与完整 batch 相同的平均权重；EOS 不折算成自然文本字节。</p>
<p>这个数值只验证 BPB 计算链路，不代表 Qwen，也不代表个人 midtrain 效果。换数据集或评估口径后，不能直接拿 BPB 比较。</p>
<h2 id="十三parametersnumel-与-scaling-测算">十三、parameters、numel 与 Scaling 测算</h2>
<p><code>parameter.numel()</code> 是 number of elements，计算参数张量中有多少个元素。</p>
<p>例如：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">形状 (10, 64) 的权重
</span></span><span class="line"><span class="cl">numel = 10 × 64 = 640
</span></span></code></pre></div><p><code>model.parameters()</code> 会遍历模型中注册的 Parameter，包括 Linear、Embedding、RMSNorm 等模块内部的底层可学习张量；mask 和 inv_freq 这类 buffer 不属于 Parameter。</p>
<p>当前冒烟模型实际参数量：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">19,571,264
</span></span></code></pre></div><p>其中：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">tok_emb.weight  = 9,723,904
</span></span><span class="line"><span class="cl">out_head.weight = 9,723,904
</span></span></code></pre></div><p>两块合计 <code>19,447,808</code>，约占整个模型的 <strong>99.37%</strong>。</p>
<p>因为当前冒烟配置是 <code>tie_word_embeddings=False</code>，输入与输出是两套独立权重。如果改为共享，总参数约为 <code>9,847,360</code>，几乎减半。</p>
<p>这也重新解释了 Weight Tying：不是两个模块变成一个，而是 <code>out_head.weight</code> 与 <code>tok_emb.weight</code> 指向同一个底层 Parameter。</p>
<h3 id="chinchilla一个从零预训练的参考基线">Chinchilla：一个从零预训练的参考基线</h3>
<p>Chinchilla 是 DeepMind 在 2022 年提出的模型及训练研究，论文是 <a href="https://arxiv.org/abs/2203.15556">《Training Compute-Optimal Large Language Models》</a>。</p>
<p>它研究的核心问题是：</p>
<blockquote>
<p>在训练算力有限的情况下，参数量和训练 token 数应该怎样搭配？</p>
</blockquote>
<p>当时很多模型倾向于不断扩大参数量，但训练数据量没有同步增加。Chinchilla 指出：很多大模型其实处于训练不足的状态，不能只堆参数，还要同步增加数据。</p>
<p>Chinchilla 使用大约 70B 参数和 1.4T tokens，两者之比约为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">1.4T tokens / 70B 参数 ≈ 20 tokens / 参数
</span></span></code></pre></div><p>因此，“约 20 tokens/参数”后来常被用作从零预训练的一个粗略参考。它不是严格的物理定律，也不是所有模型都必须满足的门槛。</p>
<h3 id="为什么它叫计算最优参考">为什么它叫“计算最优”参考？</h3>
<p>常见的 Transformer 训练计算量可以粗略理解为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">训练计算量 ≈ 6 × 参数量 × 训练 token 数
</span></span></code></pre></div><p>在算力固定时，参数变大和 token 变多会争夺同一份计算预算：</p>
<ul>
<li>参数很大、数据太少，模型可能训练不足；</li>
<li>数据很多、模型太小，也可能无法充分利用数据中的规律；</li>
<li>Chinchilla 研究的是怎样在这两者之间取得更合理的配比。</li>
</ul>
<p>它不是在讨论“一个参数必须分到 20 个 token 才能训练”，而是在讨论<strong>从零预训练时，怎样让算力配置更接近计算最优</strong>。</p>
<h3 id="用当前模型做一次数量级估算">用当前模型做一次数量级估算</h3>
<p>今天用“约 20 tokens / 参数”做了参考计算：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">当前冒烟模型参数量：19,571,264
</span></span><span class="line"><span class="cl">当前训练语料：117,890 tokens
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">参考 token 量：19,571,264 × 20 = 391,425,280
</span></span><span class="line"><span class="cl">当前语料覆盖率：117,890 / 391,425,280 ≈ 0.000301 ≈ 0.0301%
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">Qwen 0.5B 名义参考 token 量：10,000,000,000
</span></span><span class="line"><span class="cl">当前语料覆盖率：约 0.00118%
</span></span></code></pre></div><p>这说明：按这个经验参考粗略估算，当前博客语料远低于从零计算最优预训练的参考量级。</p>
<p>但它不能推出：</p>
<ul>
<li>当前模型完全不能训练；</li>
<li>小语料训练没有任何效果；</li>
<li>所有模型都必须严格训练到 20 tokens/参数；</li>
<li>个人 midtrain 没有意义。</li>
</ul>
<p>语料少时模型仍可能学到模式，只是更容易重复、记忆或过拟合。现代模型也会因为推理成本、数据质量和训练目标不同，采用不同的实际配比。</p>
<h3 id="计算时还要统一两个口径">计算时还要统一两个口径</h3>
<p><strong>第一，训练总 token 数不等于去重后的语料 token 数</strong>。多轮 epoch 会重复处理同一批语料，不能把“训练时处理的总 token 数”和“唯一语料 token 数”混为一谈。</p>
<p><strong>第二，参数统计口径必须一致</strong>。今天使用的是总参数量，而当前冒烟模型约 99% 参数集中在输入/输出词表矩阵中。这个计算适合建立数量级直觉，不等于完整复现 Chinchilla 论文的 Scaling 实验。</p>
<p>个人 midtrain 是从已有底座继续训练，不是从零学习语言。Chinchilla 在这里的价值是提供一个<strong>参数、数据和算力配比的参考基线</strong>，而不是成为个人语料训练的硬性准入条件。</p>
<h2 id="十四今天记录的后续选修实验">十四、今天记录的后续选修实验</h2>
<p>实验名称：</p>
<blockquote>
<p><strong>在 GPTModel 的多头注意力机制计算中引入门阀装置对比。</strong></p>
</blockquote>
<p>初步想法是在 attention 合头之后、<code>out_proj</code> 之前增加按 token、按特征通道的 sigmoid 门控。</p>
<p>Attention 本身已经通过 softmax 权重决定“从哪些 token 读取信息”；新增门控可以进一步决定“这些 attention 输出在哪些通道上通过多少”。两者作用对象不同，不必然重复。</p>
<p>这个实验当前只记录想法，尚未开始，不阻塞 I1。若承接 Qwen 权重，需要单独处理新增参数与初始化，不能直接 strict 加载原权重。</p>
<h2 id="十五今天的边界与真实完成方式">十五、今天的边界与真实完成方式</h2>
<p>今天完成的是数据管线和指标闭环：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">清单 → 最小清洗 → 划分 → JSONL → uint32 → memmap
</span></span><span class="line"><span class="cl">→ 训练冒烟 → checkpoint → BPB → Scaling 参考测算
</span></span></code></pre></div><p>没有完成或没有展开：</p>
<ul>
<li>个人中文 midtrain；</li>
<li>通用大数据清洗平台；</li>
<li>MinHash 近似去重实现；</li>
<li>大模型训练；</li>
<li>分布式、MoE 和 DeepInfer 部署；</li>
<li>对任意语料规模与任意模型质量的证明。</li>
</ul>
<p>今天的部分工程脚本由 Kimi 提供完整代码，我负责运行、阅读、提问和验收；这部分不写成“全部亲手实现”。核心概念仍需通过复盘和后续默写来确认是否真正掌握。</p>
<h2 id="十六阅读后的四个回答">十六、阅读后的四个回答</h2>
<p>这一节的主体回答由我在阅读草稿后手敲，Kimi 只做了少量结构整理，并修正了 DataLoader 中 shuffle 的一处表述。</p>
<h3 id="1-今天哪些概念只是暂时听懂还需要重新复述">1. 今天哪些概念只是暂时听懂，还需要重新复述？</h3>
<p>概念上的内容基本都能理解。说到底，今天做的事情就是<strong>按需加载</strong>。</p>
<p>之前训练数据比较小，可以全部加载到内存中；当训练语料规模上升后，就需要实现流式加载。<code>np.memmap</code> 的核心作用是在磁盘文件与内存访问之间建立映射关系，只把当前需要的部分交给内存使用，而不是提前把整个文件和全部训练窗口都转成 Python 对象。</p>
<p>所以今天的主干不是“把语料做得多大”，而是“语料变大以后，数据访问方式是否需要改变”。</p>
<h3 id="2-哪些代码需要我重新手写一遍">2. 哪些代码需要我重新手写一遍？</h3>
<p>我理解目前的代码暂时不需要专门考虑重写和回炉。本质上它仍然属于数据处理部分，我需要先理解原理和本质，后续在实际调整和使用过程中还会继续学习。</p>
<p>这不等于宣称每段代码都能脱稿默写，而是当前没有必要为了默写再单独开一轮重复劳动。</p>
<h3 id="3-数据管线和模型训练之间还有哪些关系没有真正打通">3. 数据管线和模型训练之间，还有哪些关系没有真正打通？</h3>
<p>我目前的理解是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">原始文档
</span></span><span class="line"><span class="cl">→ 清洗与 train / held-out 划分
</span></span><span class="line"><span class="cl">→ token store
</span></span><span class="line"><span class="cl">→ Dataset
</span></span><span class="line"><span class="cl">→ input / target 的 +1 错位处理
</span></span><span class="line"><span class="cl">→ DataLoader
</span></span><span class="line"><span class="cl">→ 模型 forward 与 loss
</span></span></code></pre></div><p>其中：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"><span class="line"><span class="cl"><span class="n">input_ids</span> <span class="o">=</span> <span class="n">tokens</span><span class="p">[</span><span class="n">start</span><span class="p">:</span><span class="n">start</span> <span class="o">+</span> <span class="n">max_length</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="n">target_ids</span> <span class="o">=</span> <span class="n">tokens</span><span class="p">[</span><span class="n">start</span> <span class="o">+</span> <span class="mi">1</span><span class="p">:</span><span class="n">start</span> <span class="o">+</span> <span class="n">max_length</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]</span>
</span></span></code></pre></div><p>target 仍然是在同一 token 流上向后错开一位，让模型学习预测下一个 token。</p>
<p>DataLoader 本身不知道 train、val、test 的区别，是我们根据用途设置 shuffle：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="cl">train：通常 shuffle=True，让训练样本顺序随机化
</span></span><span class="line"><span class="cl">val：shuffle=False，保证验证顺序与结果可复现
</span></span><span class="line"><span class="cl">test：shuffle=False，保证最终测试顺序与结果可复现
</span></span></code></pre></div><p>另外，val 用于调参和选择，test 用于最终评估；held-out 是“被隔离、不参与训练”的总称，不能把所有 held-out 都自动当成同一个用途。</p>
<h3 id="4-哪些疑问值得单独回炉而不是继续往后赶">4. 哪些疑问值得单独回炉，而不是继续往后赶？</h3>
<p>目前没有感觉需要单独回炉的内容。今天的疑问已经在 JSONL、SHA-256、标题拼接、uint32、memmap、窗口边界、BPB、parameters 和 Scaling 测算的过程中逐项解决。</p>
<p>如果后面实际训练或调整数据管线时暴露出新的理解缺口，再针对那个具体问题回炉，不为了回炉而回炉。</p>
]]></content:encoded>
    </item>
  </channel>
</rss>
