<?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>Reasoning on Tarragon</title><link>https://tarrragon.github.io/blog/tags/reasoning/</link><description>Recent content in Reasoning on Tarragon</description><generator>Hugo -- gohugo.io</generator><language>zh-TW</language><copyright>Tarragon (CC BY 4.0)</copyright><lastBuildDate>Tue, 12 May 2026 00:00:00 +0000</lastBuildDate><atom:link href="https://tarrragon.github.io/blog/tags/reasoning/index.xml" rel="self" type="application/rss+xml"/><item><title>Chain-of-Thought（CoT）</title><link>https://tarrragon.github.io/blog/llm/knowledge-cards/chain-of-thought/</link><pubDate>Tue, 12 May 2026 00:00:00 +0000</pubDate><guid>https://tarrragon.github.io/blog/llm/knowledge-cards/chain-of-thought/</guid><description>&lt;p>Chain-of-Thought（CoT、思維鏈、Wei et al., 2022）的核心概念是「&lt;strong>讓 LLM 先輸出一連串中間推理步驟、再給最終答案&lt;/strong>」、不是直接從問題跳到結論。CoT 是 reasoning model 的基礎機制；prompting 形式（few-shot 提示）跟訓練形式（reasoning RLHF / RL）兩條路都圍繞它演化。&lt;/p>
&lt;h2 id="概念位置">概念位置&lt;/h2>
&lt;p>CoT 的兩種觸發方式：&lt;/p>





&lt;div class="highlight">&lt;pre tabindex="0" class="chroma">&lt;code class="language-text" data-lang="text">&lt;span class="line">&lt;span class="ln">1&lt;/span>&lt;span class="cl">直接回答：
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">2&lt;/span>&lt;span class="cl"> Q: 23 × 47 = ?
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">3&lt;/span>&lt;span class="cl"> A: 1081
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">4&lt;/span>&lt;span class="cl">
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">5&lt;/span>&lt;span class="cl">Chain-of-Thought：
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">6&lt;/span>&lt;span class="cl"> Q: 23 × 47 = ?
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">7&lt;/span>&lt;span class="cl"> A: 先算 20 × 47 = 940、再算 3 × 47 = 141、加起來 940 + 141 = 1081。
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">8&lt;/span>&lt;span class="cl"> 答案：1081&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>&lt;p>CoT 在 LLM 演化中的兩個階段：&lt;/p>
&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>階段&lt;/th>
 &lt;th>觸發方式&lt;/th>
 &lt;th>代表模型 / 技術&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>Prompting CoT&lt;/td>
 &lt;td>Few-shot 提示「請逐步思考」或「let&amp;rsquo;s think step by step」&lt;/td>
 &lt;td>GPT-3、PaLM、早期 instruct 模型&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Training CoT&lt;/td>
 &lt;td>訓練資料含大量 reasoning trace、模型學會「自然」用 CoT&lt;/td>
 &lt;td>GPT-4、Claude 3.5、Gemini Pro&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Reasoning RL&lt;/td>
 &lt;td>RL 階段獎勵「正確答案的長 reasoning trace」、模型學會用更長 CoT&lt;/td>
 &lt;td>DeepSeek-R1、o1 / o3、Qwen-QwQ、Claude 3.7 Sonnet thinking&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table>
&lt;p>第三階段的特性：模型自己決定「該想多久」（&lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/test-time-compute/" data-link-title="Test-Time Compute" data-link-desc="推論時動態增加計算量換取答案品質的 paradigm、reasoning model 跟 best-of-N 的共同基底">test-time compute&lt;/a> 動態擴展）、推理 trace 可達數千 token、最終答案才是少數 token。&lt;/p>
&lt;h2 id="設計責任">設計責任&lt;/h2>
&lt;p>讀 prompt engineering / paper 看到「CoT」「step by step」「reasoning trace」「thinking」等就是這個機制。寫 code 場景的判讀：&lt;/p>
&lt;ol>
&lt;li>&lt;strong>複雜推理任務開 CoT 通常有幫助&lt;/strong>（math、debug、algorithm design）— 即使是 instruct model 也能透過 prompting 觸發&lt;/li>
&lt;li>&lt;strong>簡單任務 CoT 浪費 token&lt;/strong>（autocomplete、單行查詢、純查表）&lt;/li>
&lt;li>&lt;strong>Reasoning model 的 CoT 是內建行為&lt;/strong>、不需要用 prompt 觸發、但 reasoning trace 會消耗大量 &lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/token/" data-link-title="Token" data-link-desc="LLM 處理文字時的最小單位：介於字元與單字之間">token&lt;/a>（推論時間、context、API 成本都翻倍）&lt;/li>
&lt;li>&lt;strong>本地跑 reasoning model&lt;/strong>：DeepSeek-R1 distill 系列、Qwen-QwQ 等可本地跑、但需要較大 &lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/context-window/" data-link-title="Context Window" data-link-desc="模型一次能處理的最大 token 數量：prompt 加生成的總和上限">context window&lt;/a> 容納 reasoning trace&lt;/li>
&lt;/ol></description><content:encoded><![CDATA[<p>Chain-of-Thought（CoT、思維鏈、Wei et al., 2022）的核心概念是「<strong>讓 LLM 先輸出一連串中間推理步驟、再給最終答案</strong>」、不是直接從問題跳到結論。CoT 是 reasoning model 的基礎機制；prompting 形式（few-shot 提示）跟訓練形式（reasoning RLHF / RL）兩條路都圍繞它演化。</p>
<h2 id="概念位置">概念位置</h2>
<p>CoT 的兩種觸發方式：</p>





<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="ln">1</span><span class="cl">直接回答：
</span></span><span class="line"><span class="ln">2</span><span class="cl">  Q: 23 × 47 = ?
</span></span><span class="line"><span class="ln">3</span><span class="cl">  A: 1081
</span></span><span class="line"><span class="ln">4</span><span class="cl">
</span></span><span class="line"><span class="ln">5</span><span class="cl">Chain-of-Thought：
</span></span><span class="line"><span class="ln">6</span><span class="cl">  Q: 23 × 47 = ?
</span></span><span class="line"><span class="ln">7</span><span class="cl">  A: 先算 20 × 47 = 940、再算 3 × 47 = 141、加起來 940 + 141 = 1081。
</span></span><span class="line"><span class="ln">8</span><span class="cl">     答案：1081</span></span></code></pre></div><p>CoT 在 LLM 演化中的兩個階段：</p>
<table>
  <thead>
      <tr>
          <th>階段</th>
          <th>觸發方式</th>
          <th>代表模型 / 技術</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Prompting CoT</td>
          <td>Few-shot 提示「請逐步思考」或「let&rsquo;s think step by step」</td>
          <td>GPT-3、PaLM、早期 instruct 模型</td>
      </tr>
      <tr>
          <td>Training CoT</td>
          <td>訓練資料含大量 reasoning trace、模型學會「自然」用 CoT</td>
          <td>GPT-4、Claude 3.5、Gemini Pro</td>
      </tr>
      <tr>
          <td>Reasoning RL</td>
          <td>RL 階段獎勵「正確答案的長 reasoning trace」、模型學會用更長 CoT</td>
          <td>DeepSeek-R1、o1 / o3、Qwen-QwQ、Claude 3.7 Sonnet thinking</td>
      </tr>
  </tbody>
</table>
<p>第三階段的特性：模型自己決定「該想多久」（<a href="/blog/llm/knowledge-cards/test-time-compute/" data-link-title="Test-Time Compute" data-link-desc="推論時動態增加計算量換取答案品質的 paradigm、reasoning model 跟 best-of-N 的共同基底">test-time compute</a> 動態擴展）、推理 trace 可達數千 token、最終答案才是少數 token。</p>
<h2 id="設計責任">設計責任</h2>
<p>讀 prompt engineering / paper 看到「CoT」「step by step」「reasoning trace」「thinking」等就是這個機制。寫 code 場景的判讀：</p>
<ol>
<li><strong>複雜推理任務開 CoT 通常有幫助</strong>（math、debug、algorithm design）— 即使是 instruct model 也能透過 prompting 觸發</li>
<li><strong>簡單任務 CoT 浪費 token</strong>（autocomplete、單行查詢、純查表）</li>
<li><strong>Reasoning model 的 CoT 是內建行為</strong>、不需要用 prompt 觸發、但 reasoning trace 會消耗大量 <a href="/blog/llm/knowledge-cards/token/" data-link-title="Token" data-link-desc="LLM 處理文字時的最小單位：介於字元與單字之間">token</a>（推論時間、context、API 成本都翻倍）</li>
<li><strong>本地跑 reasoning model</strong>：DeepSeek-R1 distill 系列、Qwen-QwQ 等可本地跑、但需要較大 <a href="/blog/llm/knowledge-cards/context-window/" data-link-title="Context Window" data-link-desc="模型一次能處理的最大 token 數量：prompt 加生成的總和上限">context window</a> 容納 reasoning trace</li>
</ol>
]]></content:encoded></item><item><title>Reasoning Model</title><link>https://tarrragon.github.io/blog/llm/knowledge-cards/reasoning-model/</link><pubDate>Tue, 12 May 2026 00:00:00 +0000</pubDate><guid>https://tarrragon.github.io/blog/llm/knowledge-cards/reasoning-model/</guid><description>&lt;p>Reasoning model 的核心概念是「&lt;strong>透過後訓練（多半是 RL）讓模型自然在回答前產出長 &lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/chain-of-thought/" data-link-title="Chain-of-Thought（CoT）" data-link-desc="讓 LLM 先輸出推理步驟再給最終答案的 prompting / 訓練方式、reasoning model 的基礎機制">chain-of-thought&lt;/a> reasoning trace 的 LLM 變體&lt;/strong>」。代表是 OpenAI o1 / o3、DeepSeek-R1、Qwen-QwQ、Claude 3.7 Sonnet thinking 等。Reasoning model 是 2024-2026 LLM 的最大 paradigm shift、把 &lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/test-time-compute/" data-link-title="Test-Time Compute" data-link-desc="推論時動態增加計算量換取答案品質的 paradigm、reasoning model 跟 best-of-N 的共同基底">test-time compute&lt;/a> 變成可訓練、可 scale 的維度。&lt;/p>
&lt;h2 id="概念位置">概念位置&lt;/h2>
&lt;p>Reasoning model 跟一般 instruction-tuned model 的差異：&lt;/p>
&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>維度&lt;/th>
 &lt;th>Instruction-tuned model（如 Gemma 4 instruct）&lt;/th>
 &lt;th>Reasoning model（如 DeepSeek-R1）&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>訓練後階段&lt;/td>
 &lt;td>SFT + RLHF / DPO&lt;/td>
 &lt;td>SFT + RLHF + &lt;strong>reasoning RL&lt;/strong>&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>推論行為&lt;/td>
 &lt;td>直接答（或短 CoT）&lt;/td>
 &lt;td>先生 reasoning trace（數百到數千 token）再答&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>適合任務&lt;/td>
 &lt;td>對話、寫作、簡單 coding、查詢&lt;/td>
 &lt;td>math、debug、algorithm、複雜 reasoning&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Token 消耗&lt;/td>
 &lt;td>直接生答案 token&lt;/td>
 &lt;td>reasoning trace 通常 5-50× 於最終答案&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>推論成本&lt;/td>
 &lt;td>1×&lt;/td>
 &lt;td>5-20×（依任務難度）&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Context 需求&lt;/td>
 &lt;td>一般&lt;/td>
 &lt;td>較大（要容納 reasoning trace）&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table>
&lt;p>主流 reasoning model 比較（2026/5）：&lt;/p>
&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>模型&lt;/th>
 &lt;th>開源 / 商業&lt;/th>
 &lt;th>推理 trace 格式&lt;/th>
 &lt;th>本地跑可行性&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>OpenAI o1 / o3&lt;/td>
 &lt;td>商業 API&lt;/td>
 &lt;td>對使用者隱藏&lt;/td>
 &lt;td>不可&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>DeepSeek-R1（full）&lt;/td>
 &lt;td>開源&lt;/td>
 &lt;td>&lt;code>&amp;lt;think&amp;gt;...&amp;lt;/think&amp;gt;&lt;/code> 標記&lt;/td>
 &lt;td>671B 太大、本地不實際&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>DeepSeek-R1 distill&lt;/td>
 &lt;td>開源&lt;/td>
 &lt;td>同上&lt;/td>
 &lt;td>7B / 14B / 32B distill 可在 24-48GB Mac 跑&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Qwen-QwQ&lt;/td>
 &lt;td>開源&lt;/td>
 &lt;td>純文字 reasoning（無特殊 token）&lt;/td>
 &lt;td>32B 可在 64GB+ Mac 跑&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Claude 3.7 Sonnet thinking&lt;/td>
 &lt;td>商業 API&lt;/td>
 &lt;td>extended thinking field&lt;/td>
 &lt;td>不可&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Gemini 2.5 Flash thinking&lt;/td>
 &lt;td>商業 API&lt;/td>
 &lt;td>thinking field&lt;/td>
 &lt;td>不可&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table>
&lt;h2 id="設計責任">設計責任&lt;/h2>
&lt;p>讀 model card / paper 看到「reasoning」「thinking」「test-time compute」「R1-style」就是這個 family。寫 code 場景的判讀：&lt;/p>
&lt;ol>
&lt;li>&lt;strong>本地用 distill 版本是合理起點&lt;/strong>：DeepSeek-R1-Distill-Qwen-32B、QwQ-32B 等是「正常 32B 模型 + reasoning 後訓練」的產物、跑得起來&lt;/li>
&lt;li>&lt;strong>適合的任務&lt;/strong>：debug 複雜 bug、算 algorithm complexity、設計 multi-step refactor、解 leetcode hard&lt;/li>
&lt;li>&lt;strong>不適合的任務&lt;/strong>：autocomplete（reasoning trace 拉長 TTFT、體感變慢）、簡單 docstring 補完、純文字翻譯&lt;/li>
&lt;li>&lt;strong>混用策略&lt;/strong>：日常用 &lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/instruction-tuned/" data-link-title="Instruction-Tuned Model" data-link-desc="經過指令微調的模型：會跟著 prompt 走、回答使用者問題">instruction-tuned model&lt;/a>（如 Gemma 4 31B、Qwen3-Coder）+ 複雜任務切到本地 reasoning model（如 QwQ-32B）+ 真正困難任務切雲端 o1 / R1 full&lt;/li>
&lt;li>&lt;strong>記憶體預算&lt;/strong>：reasoning model 本身大小跟對應 instruct model 相當、但要預留更大 &lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/kv-cache/" data-link-title="KV Cache" data-link-desc="已處理 token 的 attention 中間結果暫存：避免重算、加速後續生成">KV cache&lt;/a> 給長 reasoning trace（context 通常開 32K+）&lt;/li>
&lt;/ol></description><content:encoded><![CDATA[<p>Reasoning model 的核心概念是「<strong>透過後訓練（多半是 RL）讓模型自然在回答前產出長 <a href="/blog/llm/knowledge-cards/chain-of-thought/" data-link-title="Chain-of-Thought（CoT）" data-link-desc="讓 LLM 先輸出推理步驟再給最終答案的 prompting / 訓練方式、reasoning model 的基礎機制">chain-of-thought</a> reasoning trace 的 LLM 變體</strong>」。代表是 OpenAI o1 / o3、DeepSeek-R1、Qwen-QwQ、Claude 3.7 Sonnet thinking 等。Reasoning model 是 2024-2026 LLM 的最大 paradigm shift、把 <a href="/blog/llm/knowledge-cards/test-time-compute/" data-link-title="Test-Time Compute" data-link-desc="推論時動態增加計算量換取答案品質的 paradigm、reasoning model 跟 best-of-N 的共同基底">test-time compute</a> 變成可訓練、可 scale 的維度。</p>
<h2 id="概念位置">概念位置</h2>
<p>Reasoning model 跟一般 instruction-tuned model 的差異：</p>
<table>
  <thead>
      <tr>
          <th>維度</th>
          <th>Instruction-tuned model（如 Gemma 4 instruct）</th>
          <th>Reasoning model（如 DeepSeek-R1）</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>訓練後階段</td>
          <td>SFT + RLHF / DPO</td>
          <td>SFT + RLHF + <strong>reasoning RL</strong></td>
      </tr>
      <tr>
          <td>推論行為</td>
          <td>直接答（或短 CoT）</td>
          <td>先生 reasoning trace（數百到數千 token）再答</td>
      </tr>
      <tr>
          <td>適合任務</td>
          <td>對話、寫作、簡單 coding、查詢</td>
          <td>math、debug、algorithm、複雜 reasoning</td>
      </tr>
      <tr>
          <td>Token 消耗</td>
          <td>直接生答案 token</td>
          <td>reasoning trace 通常 5-50× 於最終答案</td>
      </tr>
      <tr>
          <td>推論成本</td>
          <td>1×</td>
          <td>5-20×（依任務難度）</td>
      </tr>
      <tr>
          <td>Context 需求</td>
          <td>一般</td>
          <td>較大（要容納 reasoning trace）</td>
      </tr>
  </tbody>
</table>
<p>主流 reasoning model 比較（2026/5）：</p>
<table>
  <thead>
      <tr>
          <th>模型</th>
          <th>開源 / 商業</th>
          <th>推理 trace 格式</th>
          <th>本地跑可行性</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>OpenAI o1 / o3</td>
          <td>商業 API</td>
          <td>對使用者隱藏</td>
          <td>不可</td>
      </tr>
      <tr>
          <td>DeepSeek-R1（full）</td>
          <td>開源</td>
          <td><code>&lt;think&gt;...&lt;/think&gt;</code> 標記</td>
          <td>671B 太大、本地不實際</td>
      </tr>
      <tr>
          <td>DeepSeek-R1 distill</td>
          <td>開源</td>
          <td>同上</td>
          <td>7B / 14B / 32B distill 可在 24-48GB Mac 跑</td>
      </tr>
      <tr>
          <td>Qwen-QwQ</td>
          <td>開源</td>
          <td>純文字 reasoning（無特殊 token）</td>
          <td>32B 可在 64GB+ Mac 跑</td>
      </tr>
      <tr>
          <td>Claude 3.7 Sonnet thinking</td>
          <td>商業 API</td>
          <td>extended thinking field</td>
          <td>不可</td>
      </tr>
      <tr>
          <td>Gemini 2.5 Flash thinking</td>
          <td>商業 API</td>
          <td>thinking field</td>
          <td>不可</td>
      </tr>
  </tbody>
</table>
<h2 id="設計責任">設計責任</h2>
<p>讀 model card / paper 看到「reasoning」「thinking」「test-time compute」「R1-style」就是這個 family。寫 code 場景的判讀：</p>
<ol>
<li><strong>本地用 distill 版本是合理起點</strong>：DeepSeek-R1-Distill-Qwen-32B、QwQ-32B 等是「正常 32B 模型 + reasoning 後訓練」的產物、跑得起來</li>
<li><strong>適合的任務</strong>：debug 複雜 bug、算 algorithm complexity、設計 multi-step refactor、解 leetcode hard</li>
<li><strong>不適合的任務</strong>：autocomplete（reasoning trace 拉長 TTFT、體感變慢）、簡單 docstring 補完、純文字翻譯</li>
<li><strong>混用策略</strong>：日常用 <a href="/blog/llm/knowledge-cards/instruction-tuned/" data-link-title="Instruction-Tuned Model" data-link-desc="經過指令微調的模型：會跟著 prompt 走、回答使用者問題">instruction-tuned model</a>（如 Gemma 4 31B、Qwen3-Coder）+ 複雜任務切到本地 reasoning model（如 QwQ-32B）+ 真正困難任務切雲端 o1 / R1 full</li>
<li><strong>記憶體預算</strong>：reasoning model 本身大小跟對應 instruct model 相當、但要預留更大 <a href="/blog/llm/knowledge-cards/kv-cache/" data-link-title="KV Cache" data-link-desc="已處理 token 的 attention 中間結果暫存：避免重算、加速後續生成">KV cache</a> 給長 reasoning trace（context 通常開 32K+）</li>
</ol>
]]></content:encoded></item><item><title>Test-Time Compute</title><link>https://tarrragon.github.io/blog/llm/knowledge-cards/test-time-compute/</link><pubDate>Tue, 12 May 2026 00:00:00 +0000</pubDate><guid>https://tarrragon.github.io/blog/llm/knowledge-cards/test-time-compute/</guid><description>&lt;p>Test-time compute（推論時計算）的核心概念是「&lt;strong>在推論階段花更多計算量、換取更高品質的答案&lt;/strong>」、不是只在訓練時投入算力。是 2024-2026 LLM 的 paradigm shift：GPT-3 → GPT-4 主要靠「更大模型 + 更多訓練資料」；o1 / DeepSeek-R1 → 主要靠「同模型、推論時想更久」。&lt;/p>
&lt;h2 id="概念位置">概念位置&lt;/h2>
&lt;p>LLM 算力分配的兩條軸：&lt;/p>





&lt;div class="highlight">&lt;pre tabindex="0" class="chroma">&lt;code class="language-text" data-lang="text">&lt;span class="line">&lt;span class="ln"> 1&lt;/span>&lt;span class="cl">Training compute（訓練算力）：
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln"> 2&lt;/span>&lt;span class="cl"> pre-training 大量 GPU-hour → 模型參數
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln"> 3&lt;/span>&lt;span class="cl"> 一次性投入、後續推論不變
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln"> 4&lt;/span>&lt;span class="cl"> → GPT-3 → 4 的主要 paradigm
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln"> 5&lt;/span>&lt;span class="cl">
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln"> 6&lt;/span>&lt;span class="cl">Test-time compute（推論算力）：
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln"> 7&lt;/span>&lt;span class="cl"> 每次推論時、視任務難度動態增加算力
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln"> 8&lt;/span>&lt;span class="cl"> 難題想 30 秒（生 5000 token reasoning trace）
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln"> 9&lt;/span>&lt;span class="cl"> 簡單問題 1 秒結束（直接答）
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">10&lt;/span>&lt;span class="cl"> → o1 / R1 / Claude thinking 的新 paradigm&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>&lt;p>Test-time compute 的常見實作形式：&lt;/p>
&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>形式&lt;/th>
 &lt;th>機制&lt;/th>
 &lt;th>代表&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>&lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/chain-of-thought/" data-link-title="Chain-of-Thought（CoT）" data-link-desc="讓 LLM 先輸出推理步驟再給最終答案的 prompting / 訓練方式、reasoning model 的基礎機制">Chain-of-thought&lt;/a> 內建&lt;/td>
 &lt;td>模型訓練成「自然」用長 reasoning trace、直接生 thinking + answer&lt;/td>
 &lt;td>o1、DeepSeek-R1、Qwen-QwQ、Claude thinking&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Best-of-N sampling&lt;/td>
 &lt;td>同 prompt 跑 N 次、reward model 選最好的&lt;/td>
 &lt;td>OpenAI early experiments、verifier-based&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Tree search&lt;/td>
 &lt;td>結構化探索多條 reasoning path&lt;/td>
 &lt;td>AlphaCode、tree of thoughts&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Self-consistency&lt;/td>
 &lt;td>多次 sample reasoning、投票選最常見答案&lt;/td>
 &lt;td>早期 CoT prompting 技巧&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Tool use + verification&lt;/td>
 &lt;td>模型呼叫 calculator / interpreter 驗證自己&lt;/td>
 &lt;td>Coding agent、math 解題 agent&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table>
&lt;p>DeepSeek-R1 paper 顯示「reasoning trace 長度跟 benchmark 表現正相關、可透過 RL 拉長」— 把 test-time compute 變成可訓練、可 scale 的維度。&lt;/p>
&lt;h2 id="設計責任">設計責任&lt;/h2>
&lt;p>讀 paper / benchmark 看到「pass@1 vs pass@10」「budget tokens」「thinking time」等就跟 test-time compute 相關。寫 code 場景的判讀：&lt;/p>
&lt;ol>
&lt;li>&lt;strong>Reasoning model 算成本翻倍&lt;/strong>：同一個 prompt、reasoning model 生 5000 token thinking + 500 token answer、傳統 model 直接生 500 token answer、推論成本差 ~10 倍&lt;/li>
&lt;li>&lt;strong>本地跑 reasoning model 的痛點&lt;/strong>：需要長 &lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/context-window/" data-link-title="Context Window" data-link-desc="模型一次能處理的最大 token 數量：prompt 加生成的總和上限">context window&lt;/a> 容納 thinking trace、生成時間長&lt;/li>
&lt;li>&lt;strong>適用任務挑選&lt;/strong>：複雜 reasoning（math、debug、long horizon planning）值得花 test-time compute；簡單任務（autocomplete、查詢）不值得&lt;/li>
&lt;li>&lt;strong>混用策略&lt;/strong>：日常用 instruct model、困難任務切到 reasoning model、是個人 dev 常見模式&lt;/li>
&lt;/ol></description><content:encoded><![CDATA[<p>Test-time compute（推論時計算）的核心概念是「<strong>在推論階段花更多計算量、換取更高品質的答案</strong>」、不是只在訓練時投入算力。是 2024-2026 LLM 的 paradigm shift：GPT-3 → GPT-4 主要靠「更大模型 + 更多訓練資料」；o1 / DeepSeek-R1 → 主要靠「同模型、推論時想更久」。</p>
<h2 id="概念位置">概念位置</h2>
<p>LLM 算力分配的兩條軸：</p>





<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="ln"> 1</span><span class="cl">Training compute（訓練算力）：
</span></span><span class="line"><span class="ln"> 2</span><span class="cl">  pre-training 大量 GPU-hour → 模型參數
</span></span><span class="line"><span class="ln"> 3</span><span class="cl">  一次性投入、後續推論不變
</span></span><span class="line"><span class="ln"> 4</span><span class="cl">  → GPT-3 → 4 的主要 paradigm
</span></span><span class="line"><span class="ln"> 5</span><span class="cl">
</span></span><span class="line"><span class="ln"> 6</span><span class="cl">Test-time compute（推論算力）：
</span></span><span class="line"><span class="ln"> 7</span><span class="cl">  每次推論時、視任務難度動態增加算力
</span></span><span class="line"><span class="ln"> 8</span><span class="cl">  難題想 30 秒（生 5000 token reasoning trace）
</span></span><span class="line"><span class="ln"> 9</span><span class="cl">  簡單問題 1 秒結束（直接答）
</span></span><span class="line"><span class="ln">10</span><span class="cl">  → o1 / R1 / Claude thinking 的新 paradigm</span></span></code></pre></div><p>Test-time compute 的常見實作形式：</p>
<table>
  <thead>
      <tr>
          <th>形式</th>
          <th>機制</th>
          <th>代表</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td><a href="/blog/llm/knowledge-cards/chain-of-thought/" data-link-title="Chain-of-Thought（CoT）" data-link-desc="讓 LLM 先輸出推理步驟再給最終答案的 prompting / 訓練方式、reasoning model 的基礎機制">Chain-of-thought</a> 內建</td>
          <td>模型訓練成「自然」用長 reasoning trace、直接生 thinking + answer</td>
          <td>o1、DeepSeek-R1、Qwen-QwQ、Claude thinking</td>
      </tr>
      <tr>
          <td>Best-of-N sampling</td>
          <td>同 prompt 跑 N 次、reward model 選最好的</td>
          <td>OpenAI early experiments、verifier-based</td>
      </tr>
      <tr>
          <td>Tree search</td>
          <td>結構化探索多條 reasoning path</td>
          <td>AlphaCode、tree of thoughts</td>
      </tr>
      <tr>
          <td>Self-consistency</td>
          <td>多次 sample reasoning、投票選最常見答案</td>
          <td>早期 CoT prompting 技巧</td>
      </tr>
      <tr>
          <td>Tool use + verification</td>
          <td>模型呼叫 calculator / interpreter 驗證自己</td>
          <td>Coding agent、math 解題 agent</td>
      </tr>
  </tbody>
</table>
<p>DeepSeek-R1 paper 顯示「reasoning trace 長度跟 benchmark 表現正相關、可透過 RL 拉長」— 把 test-time compute 變成可訓練、可 scale 的維度。</p>
<h2 id="設計責任">設計責任</h2>
<p>讀 paper / benchmark 看到「pass@1 vs pass@10」「budget tokens」「thinking time」等就跟 test-time compute 相關。寫 code 場景的判讀：</p>
<ol>
<li><strong>Reasoning model 算成本翻倍</strong>：同一個 prompt、reasoning model 生 5000 token thinking + 500 token answer、傳統 model 直接生 500 token answer、推論成本差 ~10 倍</li>
<li><strong>本地跑 reasoning model 的痛點</strong>：需要長 <a href="/blog/llm/knowledge-cards/context-window/" data-link-title="Context Window" data-link-desc="模型一次能處理的最大 token 數量：prompt 加生成的總和上限">context window</a> 容納 thinking trace、生成時間長</li>
<li><strong>適用任務挑選</strong>：複雜 reasoning（math、debug、long horizon planning）值得花 test-time compute；簡單任務（autocomplete、查詢）不值得</li>
<li><strong>混用策略</strong>：日常用 instruct model、困難任務切到 reasoning model、是個人 dev 常見模式</li>
</ol>
]]></content:encoded></item><item><title>3.8 Reasoning models：test-time compute paradigm</title><link>https://tarrragon.github.io/blog/llm/03-theoretical-foundations/reasoning-models/</link><pubDate>Tue, 12 May 2026 00:00:00 +0000</pubDate><guid>https://tarrragon.github.io/blog/llm/03-theoretical-foundations/reasoning-models/</guid><description>&lt;p>&lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/reasoning-model/" data-link-title="Reasoning Model" data-link-desc="訓練成自然輸出長 reasoning trace 的 LLM 變體、o1 / DeepSeek-R1 / Claude thinking 為代表">Reasoning model&lt;/a> 把「LLM 該想多久」從固定的 forward pass 數變成&lt;strong>可訓練、可在推論時動態擴展&lt;/strong>的維度。OpenAI o1（2024 年底）跟 DeepSeek-R1（2025 年初）是這條路線的兩個里程碑、後續 Qwen-QwQ、Claude thinking、Gemini thinking 等都跟上。本章把 reasoning model 的訓練原理、推論行為、本地可跑選項、適用 / 不適用任務拆成可操作的判讀。&lt;/p>
&lt;p>本章不重複 &lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/chain-of-thought/" data-link-title="Chain-of-Thought（CoT）" data-link-desc="讓 LLM 先輸出推理步驟再給最終答案的 prompting / 訓練方式、reasoning model 的基礎機制">chain-of-thought&lt;/a> 跟 &lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/test-time-compute/" data-link-title="Test-Time Compute" data-link-desc="推論時動態增加計算量換取答案品質的 paradigm、reasoning model 跟 best-of-N 的共同基底">test-time compute&lt;/a> 卡片的定義、聚焦「reasoning model 怎麼運作、怎麼跟本地工作流結合」。&lt;/p>
&lt;h2 id="本章目標">本章目標&lt;/h2>
&lt;p>讀完本章後、你應該能：&lt;/p>
&lt;ol>
&lt;li>解釋「reasoning model」相對 instruct model 的訓練差異。&lt;/li>
&lt;li>看到 &lt;code>&amp;lt;think&amp;gt;...&amp;lt;/think&amp;gt;&lt;/code> 標記或「extended thinking」field 時、知道是 reasoning trace、怎麼解讀。&lt;/li>
&lt;li>判斷一個任務該用 reasoning model 還是 instruct model。&lt;/li>
&lt;li>對自己的硬體預算估算「能不能本地跑 reasoning model」、選哪個。&lt;/li>
&lt;/ol>
&lt;h2 id="paradigm-shift從-scaling-pretrain-到-scaling-test-time">Paradigm shift：從 scaling pretrain 到 scaling test-time&lt;/h2>
&lt;p>LLM 能力提升的兩條歷史路徑：&lt;/p>





&lt;div class="highlight">&lt;pre tabindex="0" class="chroma">&lt;code class="language-text" data-lang="text">&lt;span class="line">&lt;span class="ln">1&lt;/span>&lt;span class="cl">2020-2023 時期：scale pretrain compute
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">2&lt;/span>&lt;span class="cl"> GPT-3 → GPT-4：模型大 5-10×、訓練 compute 大 50-100×
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">3&lt;/span>&lt;span class="cl"> 策略：更多參數 + 更多訓練 token = 更好的 base model
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">4&lt;/span>&lt;span class="cl">
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">5&lt;/span>&lt;span class="cl">2024-2026 時期：scale test-time compute
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">6&lt;/span>&lt;span class="cl"> GPT-4 → o1：模型大小接近、但推論時花 5-50× 算力
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">7&lt;/span>&lt;span class="cl"> 策略：base model 不變、訓練「推理能力」+ 推論時動態擴展 reasoning trace&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>&lt;p>兩條路線&lt;strong>不對立&lt;/strong>、是疊加：reasoning model 本身仍跑在大 base model 上、reasoning RL 是再加一層後訓練。Cost trade-off 對比的 framing 跟對使用者錢包的影響、見 &lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/test-time-compute/" data-link-title="Test-Time Compute" data-link-desc="推論時動態增加計算量換取答案品質的 paradigm、reasoning model 跟 best-of-N 的共同基底">test-time compute 卡片&lt;/a>。本章接下來聚焦「reasoning model 的訓練流程」跟「本地選型」、不重複 paradigm 層的對比。&lt;/p>
&lt;p>關鍵理解：reasoning model 不是「更聰明的 GPT-4」、是「同等聰明 base model + 學會把算力花在 reasoning 上」。底層 base model 依然是 Transformer、所有前面章節（attention、FFN、sampling）原理不變。&lt;/p>
&lt;h2 id="reasoning-model-的訓練流程">Reasoning model 的訓練流程&lt;/h2>
&lt;p>DeepSeek-R1 是第一個公開細節的開源 reasoning model、其 paper 揭示的訓練流程具有代表性：&lt;/p>





&lt;div class="highlight">&lt;pre tabindex="0" class="chroma">&lt;code class="language-text" data-lang="text">&lt;span class="line">&lt;span class="ln"> 1&lt;/span>&lt;span class="cl">Stage 1: Cold-start SFT
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln"> 2&lt;/span>&lt;span class="cl"> 用幾千份「高品質 long reasoning trace」資料 fine-tune base model
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln"> 3&lt;/span>&lt;span class="cl"> 目標：讓模型學會「該怎麼想」的 format
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln"> 4&lt;/span>&lt;span class="cl">
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln"> 5&lt;/span>&lt;span class="cl">Stage 2: Reasoning-focused RL
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln"> 6&lt;/span>&lt;span class="cl"> Reward：最終答案正確（math / code / logic 等可機械驗證的任務）
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln"> 7&lt;/span>&lt;span class="cl"> Policy：把 reasoning trace 越拉越長、越能正確、reward 越高
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln"> 8&lt;/span>&lt;span class="cl"> 約束：保留語言流暢度（不能 reasoning trace 變成亂碼）
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln"> 9&lt;/span>&lt;span class="cl"> → 模型自發學會「困難問題想更久」
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">10&lt;/span>&lt;span class="cl">
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">11&lt;/span>&lt;span class="cl">Stage 3: SFT on reasoning + non-reasoning data
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">12&lt;/span>&lt;span class="cl"> 把 reasoning RL 學到的能力跟一般 instruct 能力 mix
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">13&lt;/span>&lt;span class="cl"> 避免「只會 reasoning、不會聊天」
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">14&lt;/span>&lt;span class="cl">
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">15&lt;/span>&lt;span class="cl">Stage 4: Final RLHF / DPO（可選）
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="ln">16&lt;/span>&lt;span class="cl"> 跟 instruct model 同樣的 alignment 階段、refine helpfulness&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>&lt;p>關鍵特性：&lt;/p></description><content:encoded><![CDATA[<p><a href="/blog/llm/knowledge-cards/reasoning-model/" data-link-title="Reasoning Model" data-link-desc="訓練成自然輸出長 reasoning trace 的 LLM 變體、o1 / DeepSeek-R1 / Claude thinking 為代表">Reasoning model</a> 把「LLM 該想多久」從固定的 forward pass 數變成<strong>可訓練、可在推論時動態擴展</strong>的維度。OpenAI o1（2024 年底）跟 DeepSeek-R1（2025 年初）是這條路線的兩個里程碑、後續 Qwen-QwQ、Claude thinking、Gemini thinking 等都跟上。本章把 reasoning model 的訓練原理、推論行為、本地可跑選項、適用 / 不適用任務拆成可操作的判讀。</p>
<p>本章不重複 <a href="/blog/llm/knowledge-cards/chain-of-thought/" data-link-title="Chain-of-Thought（CoT）" data-link-desc="讓 LLM 先輸出推理步驟再給最終答案的 prompting / 訓練方式、reasoning model 的基礎機制">chain-of-thought</a> 跟 <a href="/blog/llm/knowledge-cards/test-time-compute/" data-link-title="Test-Time Compute" data-link-desc="推論時動態增加計算量換取答案品質的 paradigm、reasoning model 跟 best-of-N 的共同基底">test-time compute</a> 卡片的定義、聚焦「reasoning model 怎麼運作、怎麼跟本地工作流結合」。</p>
<h2 id="本章目標">本章目標</h2>
<p>讀完本章後、你應該能：</p>
<ol>
<li>解釋「reasoning model」相對 instruct model 的訓練差異。</li>
<li>看到 <code>&lt;think&gt;...&lt;/think&gt;</code> 標記或「extended thinking」field 時、知道是 reasoning trace、怎麼解讀。</li>
<li>判斷一個任務該用 reasoning model 還是 instruct model。</li>
<li>對自己的硬體預算估算「能不能本地跑 reasoning model」、選哪個。</li>
</ol>
<h2 id="paradigm-shift從-scaling-pretrain-到-scaling-test-time">Paradigm shift：從 scaling pretrain 到 scaling test-time</h2>
<p>LLM 能力提升的兩條歷史路徑：</p>





<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="ln">1</span><span class="cl">2020-2023 時期：scale pretrain compute
</span></span><span class="line"><span class="ln">2</span><span class="cl">  GPT-3 → GPT-4：模型大 5-10×、訓練 compute 大 50-100×
</span></span><span class="line"><span class="ln">3</span><span class="cl">  策略：更多參數 + 更多訓練 token = 更好的 base model
</span></span><span class="line"><span class="ln">4</span><span class="cl">
</span></span><span class="line"><span class="ln">5</span><span class="cl">2024-2026 時期：scale test-time compute
</span></span><span class="line"><span class="ln">6</span><span class="cl">  GPT-4 → o1：模型大小接近、但推論時花 5-50× 算力
</span></span><span class="line"><span class="ln">7</span><span class="cl">  策略：base model 不變、訓練「推理能力」+ 推論時動態擴展 reasoning trace</span></span></code></pre></div><p>兩條路線<strong>不對立</strong>、是疊加：reasoning model 本身仍跑在大 base model 上、reasoning RL 是再加一層後訓練。Cost trade-off 對比的 framing 跟對使用者錢包的影響、見 <a href="/blog/llm/knowledge-cards/test-time-compute/" data-link-title="Test-Time Compute" data-link-desc="推論時動態增加計算量換取答案品質的 paradigm、reasoning model 跟 best-of-N 的共同基底">test-time compute 卡片</a>。本章接下來聚焦「reasoning model 的訓練流程」跟「本地選型」、不重複 paradigm 層的對比。</p>
<p>關鍵理解：reasoning model 不是「更聰明的 GPT-4」、是「同等聰明 base model + 學會把算力花在 reasoning 上」。底層 base model 依然是 Transformer、所有前面章節（attention、FFN、sampling）原理不變。</p>
<h2 id="reasoning-model-的訓練流程">Reasoning model 的訓練流程</h2>
<p>DeepSeek-R1 是第一個公開細節的開源 reasoning model、其 paper 揭示的訓練流程具有代表性：</p>





<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="ln"> 1</span><span class="cl">Stage 1: Cold-start SFT
</span></span><span class="line"><span class="ln"> 2</span><span class="cl">  用幾千份「高品質 long reasoning trace」資料 fine-tune base model
</span></span><span class="line"><span class="ln"> 3</span><span class="cl">  目標：讓模型學會「該怎麼想」的 format
</span></span><span class="line"><span class="ln"> 4</span><span class="cl">
</span></span><span class="line"><span class="ln"> 5</span><span class="cl">Stage 2: Reasoning-focused RL
</span></span><span class="line"><span class="ln"> 6</span><span class="cl">  Reward：最終答案正確（math / code / logic 等可機械驗證的任務）
</span></span><span class="line"><span class="ln"> 7</span><span class="cl">  Policy：把 reasoning trace 越拉越長、越能正確、reward 越高
</span></span><span class="line"><span class="ln"> 8</span><span class="cl">  約束：保留語言流暢度（不能 reasoning trace 變成亂碼）
</span></span><span class="line"><span class="ln"> 9</span><span class="cl">  → 模型自發學會「困難問題想更久」
</span></span><span class="line"><span class="ln">10</span><span class="cl">
</span></span><span class="line"><span class="ln">11</span><span class="cl">Stage 3: SFT on reasoning + non-reasoning data
</span></span><span class="line"><span class="ln">12</span><span class="cl">  把 reasoning RL 學到的能力跟一般 instruct 能力 mix
</span></span><span class="line"><span class="ln">13</span><span class="cl">  避免「只會 reasoning、不會聊天」
</span></span><span class="line"><span class="ln">14</span><span class="cl">
</span></span><span class="line"><span class="ln">15</span><span class="cl">Stage 4: Final RLHF / DPO（可選）
</span></span><span class="line"><span class="ln">16</span><span class="cl">  跟 instruct model 同樣的 alignment 階段、refine helpfulness</span></span></code></pre></div><p>關鍵特性：</p>
<ol>
<li><strong>Stage 2 的 reward 機械可驗證</strong>：math 答案、code unit test、logic 答案 — 不需要 human preference、所以可大量擴展訓練資料</li>
<li><strong>Reasoning trace 是「emerge」出來的</strong>：訓練不直接告訴模型「該怎麼想」、只給「答案對不對」、模型自己摸索出最佳 reasoning strategy</li>
<li><strong>跨任務 transfer 有限</strong>：reasoning model 在訓練分佈內任務（math、coding）強、跨到開放域對話、提升較小</li>
</ol>
<p><a href="/blog/llm/knowledge-cards/reasoning-model/" data-link-title="Reasoning Model" data-link-desc="訓練成自然輸出長 reasoning trace 的 LLM 變體、o1 / DeepSeek-R1 / Claude thinking 為代表">DeepSeek-R1 distill 系列</a> 是另一條路：用 R1 full 模型產生 reasoning trace、再 SFT 一個小 base model（如 Qwen2.5-32B）— 讓較小模型也有 reasoning 能力、但跳過昂貴的 RL 階段。</p>
<h2 id="reasoning-trace-的格式">Reasoning trace 的格式</h2>
<p>主流 reasoning model 在推論時輸出 reasoning trace 的格式：</p>





<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="ln"> 1</span><span class="cl">DeepSeek-R1 / Qwen-QwQ：用特殊 token 標記
</span></span><span class="line"><span class="ln"> 2</span><span class="cl">  &lt;think&gt;
</span></span><span class="line"><span class="ln"> 3</span><span class="cl">  讓我先列出已知條件...先試 case 1...結果矛盾、改試 case 2...
</span></span><span class="line"><span class="ln"> 4</span><span class="cl">  &lt;/think&gt;
</span></span><span class="line"><span class="ln"> 5</span><span class="cl">  最終答案：X
</span></span><span class="line"><span class="ln"> 6</span><span class="cl">
</span></span><span class="line"><span class="ln"> 7</span><span class="cl">OpenAI o1：對使用者隱藏
</span></span><span class="line"><span class="ln"> 8</span><span class="cl">  API 只回最終答案、但計費 reasoning token
</span></span><span class="line"><span class="ln"> 9</span><span class="cl">  使用者看不到 reasoning trace 內容
</span></span><span class="line"><span class="ln">10</span><span class="cl">
</span></span><span class="line"><span class="ln">11</span><span class="cl">Claude 3.7 thinking：extended thinking field
</span></span><span class="line"><span class="ln">12</span><span class="cl">  API response 含 `extended_thinking` 跟 `text` 兩個 field
</span></span><span class="line"><span class="ln">13</span><span class="cl">  IDE / chat 介面通常折疊顯示 thinking 內容</span></span></code></pre></div><p>實作層的關鍵考量：</p>
<ol>
<li><strong>Tokenizer 對 reasoning token 的處理</strong>：<code>&lt;think&gt;</code> 等特殊 token 在 vocab 中被保留、tokenizer 識別後不切碎</li>
<li><strong>Context budget 分配</strong>：reasoning trace 通常 1000-10000 token、要預留 <a href="/blog/llm/knowledge-cards/context-window/" data-link-title="Context Window" data-link-desc="模型一次能處理的最大 token 數量：prompt 加生成的總和上限">context window</a> 容量</li>
<li><strong>Streaming 行為</strong>：reasoning trace streaming 時、使用者看到「模型在想」、TTFT 變短但「first useful output」變長</li>
<li><strong>Stop sequence</strong>：sampling 階段 <code>&lt;/think&gt;</code> 或對應結束 token 是 reasoning trace 的 terminator</li>
</ol>
<h2 id="本地可跑的-reasoning-model">本地可跑的 reasoning model</h2>
<p>2026/5 時、本地寫 code 工作流可考慮的 reasoning model：</p>
<table>
  <thead>
      <tr>
          <th>模型</th>
          <th>大小</th>
          <th>Q4 量化後記憶體</th>
          <th>適合硬體</th>
          <th>reasoning trace 平均 token</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>DeepSeek-R1-Distill-Qwen-7B</td>
          <td>7B</td>
          <td>~4 GB</td>
          <td>16GB+ Mac / 16GB+ VRAM</td>
          <td>500-2000</td>
      </tr>
      <tr>
          <td>DeepSeek-R1-Distill-Qwen-14B</td>
          <td>14B</td>
          <td>~8 GB</td>
          <td>24GB+ Mac / 16GB+ VRAM</td>
          <td>1000-3000</td>
      </tr>
      <tr>
          <td>DeepSeek-R1-Distill-Qwen-32B</td>
          <td>32B</td>
          <td>~18 GB</td>
          <td>32GB+ Mac / 24GB+ VRAM</td>
          <td>1500-5000</td>
      </tr>
      <tr>
          <td>QwQ-32B</td>
          <td>32B</td>
          <td>~18 GB</td>
          <td>32GB+ Mac / 24GB+ VRAM</td>
          <td>2000-8000</td>
      </tr>
      <tr>
          <td>DeepSeek-R1（full）</td>
          <td>671B（MoE）</td>
          <td>~140 GB</td>
          <td>不實際本地跑</td>
          <td>5000-30000</td>
      </tr>
  </tbody>
</table>
<blockquote>
<p><strong>事實查核註</strong>：模型大小、量化體積、reasoning trace 長度是 2026/5 主流版本的常見數量級；具體數字隨量化等級、context 配置、任務類型而變、引用前以對應 model card 跟自己 <code>llama-bench</code> 跑為準。</p></blockquote>
<p>選型判讀（個人 dev 場景）：</p>
<ol>
<li><strong>24GB Mac（M4 Pro）</strong>：可跑 14B distill、或 32B distill Q4 緊張、context 開小</li>
<li><strong>32GB Mac（M4 Pro 升級）</strong>：跑 32B distill 舒服、context 32K+ 可開</li>
<li><strong>48GB+ Mac（M4 Max）</strong>：跑 32B distill 寬鬆、可考慮 QwQ-32B 配 64K context</li>
<li><strong>16GB+ VRAM PC</strong>：跑 14B distill；32B distill 屬 dense 架構（不是 MoE）、要用 dense CPU offload（部分層放 RAM、靠 PCIe 走、tok/s 受 PCIe 頻寬限制）、跟 <a href="/blog/llm/knowledge-cards/moe-cpu-offload/" data-link-title="MoE CPU 卸載" data-link-desc="把 Mixture-of-Experts 模型不活躍的專家層權重放在系統 RAM、用到再走 PCIe 拉回 GPU、讓有限 VRAM 跑得了更大模型">MoE CPU offload</a> 是不同的戰術</li>
<li><strong>24GB+ VRAM PC（5090）</strong>：跑 32B distill 寬鬆</li>
</ol>
<h2 id="適合-reasoning-model-的任務">適合 reasoning model 的任務</h2>
<p>Reasoning model 的優勢任務有明確 pattern：</p>
<table>
  <thead>
      <tr>
          <th>任務類型</th>
          <th>為什麼適合</th>
          <th>案例</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>複雜 algorithm design</td>
          <td>需要多步推理 + 探索多個解法</td>
          <td>Leetcode hard、設計 sliding window 解法</td>
      </tr>
      <tr>
          <td>棘手 debug</td>
          <td>需要排除多種可能、追蹤跨檔案邏輯</td>
          <td>「為什麼這個 race condition 偶爾出現」</td>
      </tr>
      <tr>
          <td>Math / 量化分析</td>
          <td>機械可驗證、模型訓練分佈內</td>
          <td>估算系統 capacity、複雜利率計算</td>
      </tr>
      <tr>
          <td>Multi-step refactor 規劃</td>
          <td>需要看到整體影響、分階段</td>
          <td>「把這個 service 拆成 3 個 microservice 的步驟」</td>
      </tr>
      <tr>
          <td>系統設計取捨</td>
          <td>多 dimension 比較、需要展開論證</td>
          <td>「DB 該選 Postgres 還是 Cassandra」</td>
      </tr>
      <tr>
          <td>解 obscure error</td>
          <td>需要 reason about 多個可能根因</td>
          <td>「kernel panic 訊息 X 可能來源」</td>
      </tr>
  </tbody>
</table>
<p>不適合用 reasoning model 的任務（用 instruct model 即可）：</p>
<table>
  <thead>
      <tr>
          <th>任務類型</th>
          <th>為什麼不適合</th>
          <th>改用</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>Autocomplete</td>
          <td>reasoning trace 拉長 TTFT、體感變慢</td>
          <td>Instruct 小模型（如 Qwen3-Coder-7B）</td>
      </tr>
      <tr>
          <td>簡單 docstring / comment</td>
          <td>過度推理、浪費 token</td>
          <td>Instruct model</td>
      </tr>
      <tr>
          <td>純翻譯 / 風格改寫</td>
          <td>不需要 reasoning</td>
          <td>Instruct model</td>
      </tr>
      <tr>
          <td>高頻短查詢</td>
          <td>每次 reasoning overhead 累積</td>
          <td>Instruct model + KV cache</td>
      </tr>
      <tr>
          <td>已知答案的查表</td>
          <td>reasoning 反而引入錯誤</td>
          <td>Instruct model</td>
      </tr>
      <tr>
          <td>探索性 brainstorming</td>
          <td>不需要「正確答案」、reasoning 反而限制創意</td>
          <td>Instruct model + 高 temperature</td>
      </tr>
  </tbody>
</table>
<p>判讀反射：先問「這任務有沒有客觀正確答案 + 是否需要多步推理」、兩者都 yes 才用 reasoning model。</p>
<h2 id="reasoning-model--tool-use">Reasoning model + tool use</h2>
<p>Reasoning model 跟 <a href="/blog/llm/knowledge-cards/tool-use/" data-link-title="Tool Use" data-link-desc="LLM 透過結構化呼叫外部工具（讀檔、查資料庫、發 API request）來擴展能力的設計、function calling 跟 MCP 是常見實作">tool use</a> 結合是 2026 新趨勢、典型形態：</p>





<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="ln">1</span><span class="cl">模型在 reasoning trace 中發現「需要驗證一個事實」
</span></span><span class="line"><span class="ln">2</span><span class="cl">  ↓
</span></span><span class="line"><span class="ln">3</span><span class="cl">呼叫 tool（calculator / web search / code interpreter）
</span></span><span class="line"><span class="ln">4</span><span class="cl">  ↓
</span></span><span class="line"><span class="ln">5</span><span class="cl">拿到結果、繼續 reasoning
</span></span><span class="line"><span class="ln">6</span><span class="cl">  ↓
</span></span><span class="line"><span class="ln">7</span><span class="cl">最終答案</span></span></code></pre></div><p>代表場景：</p>
<ol>
<li><strong>Coding agent + reasoning</strong>：reasoning 階段規劃 refactor 步驟、tool use 階段執行 file edit、reasoning 階段檢查結果</li>
<li><strong>Math / data analysis</strong>：reasoning 階段拆問題、code interpreter 跑 calculation、reasoning 階段解讀</li>
<li><strong>Web 研究</strong>：reasoning 階段列出該查的事實、web search、reasoning 階段彙整</li>
</ol>
<p>挑戰：</p>
<ol>
<li><strong>Reasoning trace + tool result 都進 context</strong>：context 用量爆炸快、需要 long context 模型（見 <a href="/blog/llm/04-applications/long-context-engineering/" data-link-title="4.11 Long context engineering" data-link-desc="128K / 1M context 模型怎麼用：claimed vs effective context、lost-in-the-middle、context 設計策略、Long context vs RAG 取捨">4.11 Long context engineering</a>）</li>
<li><strong>Tool use 訓練跟 reasoning 訓練是兩件事</strong>：本地 distill 模型 tool use 能力 = 對應 base model 的 tool use 能力、不一定強</li>
<li><strong>Error recovery</strong>：reasoning 階段假設錯了、tool 回 error、模型要會 backtrack（<a href="/blog/llm/knowledge-cards/agent-loop/" data-link-title="Agent Loop" data-link-desc="LLM agent 自我循環的工作流：LLM 規劃下一步、執行 tool、看結果、再規劃下一步、直到任務完成或停止條件觸發">agent loop</a> 失敗模式）</li>
</ol>
<p>實務上、本地 reasoning + agent 是「值得試、但仍處早期」階段；雲端 R1 / o3 / Claude thinking + Claude Code / Cursor 是現階段更穩的組合。</p>
<h2 id="跟-instruct-model-共存的混用策略">跟 instruct model 共存的混用策略</h2>
<p>寫 code 場景的合理混用配置：</p>





<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-text" data-lang="text"><span class="line"><span class="ln"> 1</span><span class="cl">Default model（Continue.dev primary）：instruct model
</span></span><span class="line"><span class="ln"> 2</span><span class="cl">  Qwen3-Coder-30B-Instruct / Gemma 4 31B Instruct
</span></span><span class="line"><span class="ln"> 3</span><span class="cl">  日常 autocomplete、解釋、簡單 refactor
</span></span><span class="line"><span class="ln"> 4</span><span class="cl">
</span></span><span class="line"><span class="ln"> 5</span><span class="cl">Reasoning model（Continue.dev secondary、手動切）：local reasoning
</span></span><span class="line"><span class="ln"> 6</span><span class="cl">  DeepSeek-R1-Distill-Qwen-32B / QwQ-32B
</span></span><span class="line"><span class="ln"> 7</span><span class="cl">  困難 bug、algorithm、複雜 refactor 規劃
</span></span><span class="line"><span class="ln"> 8</span><span class="cl">
</span></span><span class="line"><span class="ln"> 9</span><span class="cl">Cloud fallback（手動切）：雲端旗艦
</span></span><span class="line"><span class="ln">10</span><span class="cl">  Claude 3.7 Sonnet thinking / GPT-5 / o3
</span></span><span class="line"><span class="ln">11</span><span class="cl">  本地 reasoning 卡住、或極困難任務</span></span></code></pre></div><p>Continue.dev 的 multi-model config 可同時設多個、UI 下拉切換、不用重啟 server。安全 / 隱私面：reasoning trace 可能含敏感推理過程、跨雲端 / 本地邊界判讀同 <a href="/blog/llm/06-security/cross-cloud-local-data-boundary/" data-link-title="6.4 跨雲端 / 本地的資料邊界" data-link-desc="個人 dev 場景下混用雲端 LLM 跟本地 LLM 時的 prompt 洩漏點：Continue.dev 多 provider 設定、隱私資料流、按敏感度分流的判讀">6.4</a>。</p>
<h2 id="何時過時--何時不過時">何時過時 / 何時不過時</h2>
<p><strong>不會過時的部分</strong>：</p>
<ul>
<li>Test-time compute 作為一個獨立 scaling 維度的概念</li>
<li>Reasoning trace 結構（pre-answer reasoning + answer）</li>
<li>「適合 reasoning vs instruct」的判讀框架</li>
<li>「機械可驗證的 reward + RL」是 reasoning training 的核心</li>
<li>Reasoning model + tool use 的設計取捨</li>
</ul>
<p><strong>會變的部分</strong>：</p>
<ul>
<li>具體 reasoning model（R1 → R2 → &hellip;、o1 → o3 → &hellip;、會持續迭代）</li>
<li>Reasoning trace 的具體格式（<code>&lt;think&gt;</code>、extended thinking field、未來可能標準化）</li>
<li>本地可跑的模型選項（distill 系列會持續更新）</li>
<li>Reasoning 跟 agent 結合的最佳實踐（仍在演化）</li>
<li>是否會出現 reasoning paradigm 的下一個替代（如 neurosymbolic、multi-agent reasoning）</li>
</ul>
<p>新 reasoning model 出來時、回到本章的 framing：訓練流程是否同 R1 pattern、reasoning trace 怎麼產出、本地能否跑、適用任務是否同樣 pattern — 多數新模型仍會 fit 進這個框架。</p>
<h2 id="下一章">下一章</h2>
<p>下一章：<a href="/blog/llm/03-theoretical-foundations/speculative-decoding-internals/" data-link-title="3.9 Speculative decoding 內部：drafter / 驗證 / 加速上限" data-link-desc="speculative decoding 的演算法細節、drafter 跟 target 怎麼配對、acceptance rate 怎麼決定實際加速、MTP 跟 EAGLE 等變體">3.9 Speculative decoding 內部</a>、看另一個推論時加速的技術細節。</p>
]]></content:encoded></item><item><title>LLM 寫 code 工程實務指南：從心智模型到應用架構</title><link>https://tarrragon.github.io/blog/llm/</link><pubDate>Tue, 12 May 2026 00:00:00 +0000</pubDate><guid>https://tarrragon.github.io/blog/llm/</guid><description>&lt;p>本指南的核心目標是把「LLM 在寫 code 工作流的完整工程地圖」拆成可決策、可實作、可期望管理的工程問題。範圍覆蓋四條讀者旅程：(1) 在自己機器跑本地 LLM 寫 code 的最短可行路徑（Mac 或 PC）、(2) 想懂 LLM 內部運作機制（數學 + 理論基礎）、(3) 想做 LLM 應用開發（RAG / agent / tool use / VLM / benchmarking / 靜態 deployment）、(4) 關心 LLM 工作流的安全議題（本地 dev 視角 + 靜態網站視角）。網路上的 LLM 文章常把推論框架、加速技巧、應用模式、安全議題混為一談；本指南先把這些名詞放回正確的層級、再回答各層的具體取捨。&lt;/p>
&lt;p>本指南預設讀者已經會用過雲端 LLM（ChatGPT、Claude）、熟悉終端機操作、想以工程視角理解 LLM。&lt;strong>寫 code 場景是主要使用例、但模組二 / 三 / 四 / 六多數章節跨場景通用&lt;/strong>：想懂 reasoning model / RAG / embedding model 內部、即使不裝本地 LLM 也能讀。硬體前提分兩條路線：Apple Silicon Mac（M1 ~ M4、統一記憶體）走模組一；Windows / Linux + 獨立 GPU（NVIDIA / AMD、獨立 VRAM + 系統 RAM）走模組五。文章不販賣 LLM 焦慮、也不誇大本地能取代雲端的程度；它的責任是給每條讀者旅程的最短可行路徑、並標出每個階段的取捨。&lt;/p>
&lt;p>模組零（心智模型）是所有讀者旅程的共同前置。模組一跟模組五是「裝本地 LLM」的兩條硬體路線、依平台選一條；想懂底層走模組二跟模組三（跟硬體無關、含 reasoning model / speculative decoding 等推論細節）；想看 LLM 作為系統元件走模組四（12 章涵蓋 RAG、tool use、agent、應用層協議、workflow、production resource、long context、embedding model、benchmarking、vision、靜態 deployment）；本地工作流跑穩想看安全議題走模組六（個人 dev 視角的供應鏈、伺服器綁定、tool use 權限、prompt injection、跨雲端邊界、production routing）。&lt;/p>
&lt;h2 id="教材邊界">教材邊界&lt;/h2>
&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>類型&lt;/th>
 &lt;th>放在本指南&lt;/th>
 &lt;th>不放在本指南&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>心智模型&lt;/td>
 &lt;td>本地 vs 雲端的差異、為何 LLM 生字慢、三層架構（介面 / 伺服器 / 模型）、&lt;a href="https://tarrragon.github.io/blog/llm/00-foundations/openai-compatible-api/" data-link-title="0.3 OpenAI 相容 API" data-link-desc="為什麼幾乎所有本地 LLM 工具不用改就能切到本地：背後是同一套 API 形狀">OpenAI 相容 API&lt;/a>&lt;/td>
 &lt;td>雲端 GPU 租用、AGI 預測&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>術語澄清&lt;/td>
 &lt;td>&lt;a href="https://tarrragon.github.io/blog/llm/00-foundations/mlx-mtp-omlx/" data-link-title="0.4 MLX / MTP / oMLX 的區別" data-link-desc="三個常被混為一談的術語：framework、加速技巧、特化 server，疊加而非互斥">MLX&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/00-foundations/mlx-mtp-omlx/" data-link-title="0.4 MLX / MTP / oMLX 的區別" data-link-desc="三個常被混為一談的術語：framework、加速技巧、特化 server，疊加而非互斥">MTP&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/00-foundations/mlx-mtp-omlx/" data-link-title="0.4 MLX / MTP / oMLX 的區別" data-link-desc="三個常被混為一談的術語：framework、加速技巧、特化 server，疊加而非互斥">oMLX&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/speculative-decoding/" data-link-title="Speculative Decoding" data-link-desc="用小模型猜未來 token、大模型並行驗證的加速技巧">speculative decoding&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/quantization/" data-link-title="Quantization" data-link-desc="用較少 bits 表示模型權重：壓縮記憶體佔用、加快生字速度，代價是少量品質衰減">量化&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/kv-cache/" data-link-title="KV Cache" data-link-desc="已處理 token 的 attention 中間結果暫存：避免重算、加速後續生成">KV cache&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/ttft/" data-link-title="TTFT" data-link-desc="Time To First Token：送出 prompt 到第一個 token 出現的等待時間">TTFT&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/moe-cpu-offload/" data-link-title="MoE CPU 卸載" data-link-desc="把 Mixture-of-Experts 模型不活躍的專家層權重放在系統 RAM、用到再走 PCIe 拉回 GPU、讓有限 VRAM 跑得了更大模型">MoE CPU 卸載&lt;/a>&lt;/td>
 &lt;td>post-training fine-tuning 細節&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Mac 硬體現實&lt;/td>
 &lt;td>&lt;a href="https://tarrragon.github.io/blog/llm/00-foundations/hardware-memory-budget/" data-link-title="0.5 Apple Silicon 記憶體預算" data-link-desc="記憶體決定能跑什麼，Q4 量化下的可運作模型對照與系統保留">記憶體預算與模型大小&lt;/a>、量化選擇、首字延遲、風扇與功耗&lt;/td>
 &lt;td>雲端 GPU 租用、資料中心訓練&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>PC 硬體現實&lt;/td>
 &lt;td>&lt;a href="https://tarrragon.github.io/blog/llm/05-discrete-gpu/vram-ram-budget/" data-link-title="5.0 VRAM &amp;#43; RAM 分層預算" data-link-desc="PC 獨立 GPU 場景的記憶體預算判讀：VRAM 是快的世界、RAM 是大的世界、PCIe 把兩個世界連起來">VRAM + RAM 分層預算&lt;/a>、MoE 專家層 CPU 卸載、KV cache 量化、PCIe 頻寬限制&lt;/td>
 &lt;td>多卡 NVLink、資料中心級分散式推論&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>本地推論伺服器&lt;/td>
 &lt;td>&lt;a href="https://tarrragon.github.io/blog/llm/01-local-llm-services/ollama/" data-link-title="1.0 Ollama：主流推論伺服器" data-link-desc="一行 brew 裝完、ollama run 一鍵跑 Gemma 4 MTP、OpenAI 相容 API on localhost:11434">Ollama&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/01-local-llm-services/lm-studio/" data-link-title="1.1 LM Studio：GUI 探索模型" data-link-desc="GUI 取向的本地推論伺服器：內建模型瀏覽器、speculative decoding 設定面板、適合探索新模型">LM Studio&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/01-local-llm-services/llama-cpp/" data-link-title="1.2 llama.cpp：底層推論引擎" data-link-desc="GGUF 格式、量化、MTP 仍 beta；多數讀者不需要直接接觸，Ollama 已經包好">llama.cpp&lt;/a>（Mac + PC 通用）&lt;/td>
 &lt;td>vLLM、TGI、Triton 等資料中心級 inference server&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>編輯器整合&lt;/td>
 &lt;td>&lt;a href="https://tarrragon.github.io/blog/llm/01-local-llm-services/vscode-continue-integration/" data-link-title="1.3 VS Code &amp;#43; Continue.dev 整合" data-link-desc="安裝 Continue 擴充套件、config.json 設定、Cmd&amp;#43;L 對話 / Cmd&amp;#43;I 行內編輯快捷鍵">Continue.dev + VS Code&lt;/a>、Cursor 對應關係&lt;/td>
 &lt;td>JetBrains 全套整合、Vim / Emacs 進階 plugin&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>模型挑選&lt;/td>
 &lt;td>&lt;a href="https://tarrragon.github.io/blog/llm/01-local-llm-services/model-selection-priority/" data-link-title="1.4 寫 code 場景的模型選型優先順序" data-link-desc="Gemma 4 31B MTP → Qwen3-Coder 30B → Qwen3 14B → gpt-oss 20B 的取捨與適用情境">coding 場景的模型優先順序&lt;/a>、量化等級對體感影響&lt;/td>
 &lt;td>benchmark 跑分方法論的完整推導&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>期望管理&lt;/td>
 &lt;td>&lt;a href="https://tarrragon.github.io/blog/llm/01-local-llm-services/expectation-management/" data-link-title="1.5 期望管理：本地 LLM 的擅長領域與分工" data-link-desc="本地 LLM 是免費的初階 pair programmer：辨識它的擅長領域、跟雲端旗艦做結構性分工">本地 LLM 的擅長領域與分工&lt;/a>、混用雲端的時機&lt;/td>
 &lt;td>LLM 通用能力評估、AGI 預測&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>數學基礎&lt;/td>
 &lt;td>&lt;a href="https://tarrragon.github.io/blog/llm/02-math-foundations/linear-algebra-for-llm/" data-link-title="2.0 線性代數：向量、矩陣、空間" data-link-desc="LLM 內部運算的基底：向量、矩陣、向量空間、內積、norm、矩陣乘法的角色">線性代數&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/02-math-foundations/probability-and-information/" data-link-title="2.1 機率與資訊論" data-link-desc="LLM 輸出的本質是機率分佈：softmax、cross-entropy、KL divergence、perplexity 在訓練與推論中的角色">機率與資訊論&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/02-math-foundations/calculus-and-optimization/" data-link-title="2.2 微積分與最佳化" data-link-desc="從 gradient、chain rule 到 SGD / Adam：LLM 訓練如何更新數十億參數">最佳化&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/02-math-foundations/numerical-precision/" data-link-title="2.3 數值精度與量化的數學依據" data-link-desc="fp32 / bf16 / fp16 / int8 / int4 的差別、量化能省哪些 bits、品質衰減從哪裡來">數值精度&lt;/a> 在 LLM 中的角色&lt;/td>
 &lt;td>完整數學證明、測度論等屬於數學系範圍的主題&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>理論基礎&lt;/td>
 &lt;td>&lt;a href="https://tarrragon.github.io/blog/llm/03-theoretical-foundations/neural-network-basics/" data-link-title="3.0 神經網路基礎" data-link-desc="從單一 neuron 到 multi-layer：weights、activation function、forward / backward pass 的角色">神經網路&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/03-theoretical-foundations/embedding-spaces/" data-link-title="3.1 Embedding 空間" data-link-desc="token 怎麼變成向量、為什麼相似 token 在向量空間中靠近、embedding 是怎麼學出來的">embedding&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/03-theoretical-foundations/attention-mechanism/" data-link-title="3.2 Attention 機制" data-link-desc="Query / Key / Value、scaled dot-product attention、multi-head attention：Transformer 的核心運算">attention&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/03-theoretical-foundations/transformer-architecture/" data-link-title="3.3 Transformer 架構細節" data-link-desc="Decoder-only 結構、Transformer block、positional encoding、layer norm、residual stream">Transformer&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/03-theoretical-foundations/training-pipeline/" data-link-title="3.4 訓練流程：pre-train → SFT → RLHF" data-link-desc="LLM 的三階段訓練：預訓練、指令微調、人類反饋強化學習；各階段目標與最新替代方案">訓練流程&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/03-theoretical-foundations/sampling-and-decoding/" data-link-title="3.5 Sampling 與 Decoding 策略" data-link-desc="Greedy、beam search、top-k、top-p、temperature、min-p：模型輸出後怎麼挑下一個 token">sampling&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/03-theoretical-foundations/tokenization-algorithms/" data-link-title="3.6 Tokenization：BPE、SentencePiece、Tiktoken" data-link-desc="把文字切成 token 的算法：為什麼不同模型切出不同 token 數、tokenizer 選擇對能力的影響">tokenization&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/03-theoretical-foundations/cross-language-tokenization/" data-link-title="3.7 跨語言場景的 tokenizer 與訓練分佈原理" data-link-desc="為什麼模型對不同語言表現不一致：tokenizer &amp;#43; 訓練資料分佈雙因素、語言選擇取捨">跨語言原理&lt;/a>&lt;/td>
 &lt;td>多模態擴展、最新研究細節交給 Stanford CS25&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>應用層原理&lt;/td>
 &lt;td>&lt;a href="https://tarrragon.github.io/blog/llm/04-applications/rag-principles/" data-link-title="4.1 RAG 原理：retrieval &amp;#43; augmentation 模式" data-link-desc="為什麼模型需要外掛知識、語意相似 vs 字面相似、chunking 的本質取捨、retrieval 失敗的根本原因">RAG&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/04-applications/tool-use-principles/" data-link-title="4.3 Tool use 原理：LLM 跟外部世界互動" data-link-desc="Structured output 是 LLM 跨入工程系統的橋、function calling 取捨、為什麼本地小模型 tool use 表現崩潰">Tool use&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/04-applications/agent-architecture/" data-link-title="4.4 Agent 架構原理" data-link-desc="Agent loop 結構、失敗模式、什麼任務適合 vs 不適合、跟人類審查的協作模型">Agent 架構&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/04-applications/application-protocols/" data-link-title="4.6 應用層協議：function calling / structured output / MCP" data-link-desc="三個常被混為一談的概念：模型能力、sampling 約束、server 協議，三者的層級差異與組合方式">應用層協議&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/04-applications/workflow-patterns/" data-link-title="4.7 Workflow 編排模式" data-link-desc="Pipeline / router / parallel / reflection：多 LLM call 組合的四種基本模式與退化條件">Workflow 編排&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/04-applications/production-resource-planning/" data-link-title="4.9 Production 部署的資源評估原理" data-link-desc="從本地單 user 到 production multi-tenant：concurrent users、cost model、observability、SLA、capacity planning 的設計取捨">Production resource&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/04-applications/artifact-management/" data-link-title="4.10 衍生產物管理原理：什麼進 git、什麼不該" data-link-desc="LLM 應用的 source / derived / external 三類產物對應 git / build cache / registry、與 production 部署的 reproducibility / cost / share 取捨">Artifact 管理&lt;/a>&lt;/td>
 &lt;td>具體 framework 教學（LangChain / LlamaIndex）、prompt engineering&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>進階理論&lt;/td>
 &lt;td>&lt;a href="https://tarrragon.github.io/blog/llm/03-theoretical-foundations/reasoning-models/" data-link-title="3.8 Reasoning models：test-time compute paradigm" data-link-desc="Chain-of-thought 從 prompting 技巧演化成訓練 paradigm、reasoning model 的內部運作、本地可跑的選項與適用任務">Reasoning models&lt;/a>（o1 / R1 / QwQ 風格）、&lt;a href="https://tarrragon.github.io/blog/llm/03-theoretical-foundations/speculative-decoding-internals/" data-link-title="3.9 Speculative decoding 內部：drafter / 驗證 / 加速上限" data-link-desc="speculative decoding 的演算法細節、drafter 跟 target 怎麼配對、acceptance rate 怎麼決定實際加速、MTP 跟 EAGLE 等變體">Speculative decoding 內部&lt;/a>（drafter / MTP / EAGLE）&lt;/td>
 &lt;td>完整 paper 推導、最新研究 frontier&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>進階應用&lt;/td>
 &lt;td>&lt;a href="https://tarrragon.github.io/blog/llm/04-applications/long-context-engineering/" data-link-title="4.11 Long context engineering" data-link-desc="128K / 1M context 模型怎麼用：claimed vs effective context、lost-in-the-middle、context 設計策略、Long context vs RAG 取捨">Long context engineering&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/04-applications/embedding-model-internals/" data-link-title="4.12 Embedding model 內部：訓練、選型、in-domain fine-tune" data-link-desc="Embedding model 怎麼訓練（contrastive learning &amp;#43; hard negative mining）、怎麼挑（MTEB / 大小 / domain）、何時該自己 fine-tune">Embedding model 內部&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/04-applications/benchmarking-and-evaluation/" data-link-title="4.14 Benchmarking 與評估方法論" data-link-desc="判讀 model card benchmark 數字、做自己工作流的 in-house benchmark、量測本地推論速度的完整方法論">Benchmarking&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/04-applications/vision-in-coding-workflow/" data-link-title="4.15 Vision in coding workflow：本地 VLM 怎麼接寫 code" data-link-desc="VLM 在 coding 工作流的 use cases、本地 VLM 選型、跟雲端 VLM 的分工、Continue.dev / Ollama 整合現狀">Vision in coding&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/04-applications/static-and-serverless-rag-deployment/" data-link-title="4.16 靜態 / serverless RAG deployment：架構選擇與資安取捨" data-link-desc="沒 backend 的場景怎麼做 RAG：四種 deployment 方案、API key 暴露問題、CORS / abuse / 第三方信任、跟模組六的 routing">靜態 / serverless RAG deployment&lt;/a>&lt;/td>
 &lt;td>完整 LangChain / LlamaIndex 教學&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>Fine-tuning&lt;/td>
 &lt;td>原理（&lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/lora/" data-link-title="LoRA" data-link-desc="Low-Rank Adaptation：凍住原模型權重、只訓兩個小矩陣的 parameter-efficient fine-tuning">LoRA&lt;/a> / &lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/qlora/" data-link-title="QLoRA" data-link-desc="把 base model 量化到 4-bit &amp;#43; LoRA fine-tune 的組合、消費級 GPU 也能 fine-tune 大模型">QLoRA&lt;/a> / &lt;a href="https://tarrragon.github.io/blog/llm/knowledge-cards/catastrophic-forgetting/" data-link-title="Catastrophic Forgetting" data-link-desc="Fine-tune 模型時、新訓練資料覆蓋掉原本學到的能力的現象、LoRA / 資料 mixing 是主要緩解">catastrophic forgetting&lt;/a>）+ &lt;a href="https://tarrragon.github.io/blog/llm/01-local-llm-services/hands-on/local-fine-tuning/" data-link-title="Hands-on：用 QLoRA 在本機 fine-tune coding 模型" data-link-desc="Apple Silicon Mac / PC 獨立 GPU 上跑 QLoRA fine-tune 的完整流程：環境、資料、訓練、evaluation、合併、部署到 Ollama">本機 hands-on&lt;/a>&lt;/td>
 &lt;td>完整資料工程、large-scale distributed fine-tune&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>隱私 / 安全&lt;/td>
 &lt;td>&lt;a href="https://tarrragon.github.io/blog/llm/00-foundations/privacy-data-flow/" data-link-title="0.7 隱私 / 資安的資料流原理" data-link-desc="從「位置」到「資料流」的思考升級：信任邊界、合約模型、零信任原則套用到 LLM 工作流">隱私資料流&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/06-security/" data-link-title="模組六：本地 LLM 的安全與權限" data-link-desc="個人 dev 在自己機器上跑本地 LLM 的安全議題：模型供應鏈、推論伺服器綁定、tool use 副作用、prompt injection 在 IDE、跨雲端 / 本地資料邊界">本地 dev 安全模組&lt;/a>（供應鏈 / 伺服器綁定 / tool use / prompt injection / 跨雲端邊界 / production routing）、&lt;a href="https://tarrragon.github.io/blog/llm/04-applications/static-and-serverless-rag-deployment/" data-link-title="4.16 靜態 / serverless RAG deployment：架構選擇與資安取捨" data-link-desc="沒 backend 的場景怎麼做 RAG：四種 deployment 方案、API key 暴露問題、CORS / abuse / 第三方信任、跟模組六的 routing">靜態網站 RAG 資安&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/01-local-llm-services/troubleshooting/" data-link-title="1.7 排錯方法論：用三層架構做故障定位" data-link-desc="故障定位的分層思考、症狀到層級的對應反射、log 在三層的角色差異、最小可重現的縮減策略">排錯方法論&lt;/a>&lt;/td>
 &lt;td>企業合規逐條檢核、SOC 2 / HIPAA 流程&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>進一步學習&lt;/td>
 &lt;td>&lt;a href="https://tarrragon.github.io/blog/llm/02-math-foundations/going-deeper-math/" data-link-title="2.4 想學更深：推薦公開課程" data-link-desc="MIT、Stanford、Harvard 等公開課程：數學基礎跟 LLM 預備知識的完整學習路線">數學公開課推薦&lt;/a>、&lt;a href="https://tarrragon.github.io/blog/llm/03-theoretical-foundations/going-deeper-theory/" data-link-title="3.11 想學更深：推薦公開課程" data-link-desc="Karpathy、Stanford CS224N / CS25 / CS336、DeepLearning.AI、Hugging Face：LLM 理論深入學習的完整路線">LLM 理論公開課推薦&lt;/a>&lt;/td>
 &lt;td>（交給推薦的課程跟書籍）&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table>
&lt;h2 id="學習路線">學習路線&lt;/h2>
&lt;p>本指南分成七個模組加一組前置卡片（111 張）。讀者依目的選讀、不需要從頭到尾全讀：&lt;/p></description><content:encoded><![CDATA[<p>本指南的核心目標是把「LLM 在寫 code 工作流的完整工程地圖」拆成可決策、可實作、可期望管理的工程問題。範圍覆蓋四條讀者旅程：(1) 在自己機器跑本地 LLM 寫 code 的最短可行路徑（Mac 或 PC）、(2) 想懂 LLM 內部運作機制（數學 + 理論基礎）、(3) 想做 LLM 應用開發（RAG / agent / tool use / VLM / benchmarking / 靜態 deployment）、(4) 關心 LLM 工作流的安全議題（本地 dev 視角 + 靜態網站視角）。網路上的 LLM 文章常把推論框架、加速技巧、應用模式、安全議題混為一談；本指南先把這些名詞放回正確的層級、再回答各層的具體取捨。</p>
<p>本指南預設讀者已經會用過雲端 LLM（ChatGPT、Claude）、熟悉終端機操作、想以工程視角理解 LLM。<strong>寫 code 場景是主要使用例、但模組二 / 三 / 四 / 六多數章節跨場景通用</strong>：想懂 reasoning model / RAG / embedding model 內部、即使不裝本地 LLM 也能讀。硬體前提分兩條路線：Apple Silicon Mac（M1 ~ M4、統一記憶體）走模組一；Windows / Linux + 獨立 GPU（NVIDIA / AMD、獨立 VRAM + 系統 RAM）走模組五。文章不販賣 LLM 焦慮、也不誇大本地能取代雲端的程度；它的責任是給每條讀者旅程的最短可行路徑、並標出每個階段的取捨。</p>
<p>模組零（心智模型）是所有讀者旅程的共同前置。模組一跟模組五是「裝本地 LLM」的兩條硬體路線、依平台選一條；想懂底層走模組二跟模組三（跟硬體無關、含 reasoning model / speculative decoding 等推論細節）；想看 LLM 作為系統元件走模組四（12 章涵蓋 RAG、tool use、agent、應用層協議、workflow、production resource、long context、embedding model、benchmarking、vision、靜態 deployment）；本地工作流跑穩想看安全議題走模組六（個人 dev 視角的供應鏈、伺服器綁定、tool use 權限、prompt injection、跨雲端邊界、production routing）。</p>
<h2 id="教材邊界">教材邊界</h2>
<table>
  <thead>
      <tr>
          <th>類型</th>
          <th>放在本指南</th>
          <th>不放在本指南</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>心智模型</td>
          <td>本地 vs 雲端的差異、為何 LLM 生字慢、三層架構（介面 / 伺服器 / 模型）、<a href="/blog/llm/00-foundations/openai-compatible-api/" data-link-title="0.3 OpenAI 相容 API" data-link-desc="為什麼幾乎所有本地 LLM 工具不用改就能切到本地：背後是同一套 API 形狀">OpenAI 相容 API</a></td>
          <td>雲端 GPU 租用、AGI 預測</td>
      </tr>
      <tr>
          <td>術語澄清</td>
          <td><a href="/blog/llm/00-foundations/mlx-mtp-omlx/" data-link-title="0.4 MLX / MTP / oMLX 的區別" data-link-desc="三個常被混為一談的術語：framework、加速技巧、特化 server，疊加而非互斥">MLX</a>、<a href="/blog/llm/00-foundations/mlx-mtp-omlx/" data-link-title="0.4 MLX / MTP / oMLX 的區別" data-link-desc="三個常被混為一談的術語：framework、加速技巧、特化 server，疊加而非互斥">MTP</a>、<a href="/blog/llm/00-foundations/mlx-mtp-omlx/" data-link-title="0.4 MLX / MTP / oMLX 的區別" data-link-desc="三個常被混為一談的術語：framework、加速技巧、特化 server，疊加而非互斥">oMLX</a>、<a href="/blog/llm/knowledge-cards/speculative-decoding/" data-link-title="Speculative Decoding" data-link-desc="用小模型猜未來 token、大模型並行驗證的加速技巧">speculative decoding</a>、<a href="/blog/llm/knowledge-cards/quantization/" data-link-title="Quantization" data-link-desc="用較少 bits 表示模型權重：壓縮記憶體佔用、加快生字速度，代價是少量品質衰減">量化</a>、<a href="/blog/llm/knowledge-cards/kv-cache/" data-link-title="KV Cache" data-link-desc="已處理 token 的 attention 中間結果暫存：避免重算、加速後續生成">KV cache</a>、<a href="/blog/llm/knowledge-cards/ttft/" data-link-title="TTFT" data-link-desc="Time To First Token：送出 prompt 到第一個 token 出現的等待時間">TTFT</a>、<a href="/blog/llm/knowledge-cards/moe-cpu-offload/" data-link-title="MoE CPU 卸載" data-link-desc="把 Mixture-of-Experts 模型不活躍的專家層權重放在系統 RAM、用到再走 PCIe 拉回 GPU、讓有限 VRAM 跑得了更大模型">MoE CPU 卸載</a></td>
          <td>post-training fine-tuning 細節</td>
      </tr>
      <tr>
          <td>Mac 硬體現實</td>
          <td><a href="/blog/llm/00-foundations/hardware-memory-budget/" data-link-title="0.5 Apple Silicon 記憶體預算" data-link-desc="記憶體決定能跑什麼，Q4 量化下的可運作模型對照與系統保留">記憶體預算與模型大小</a>、量化選擇、首字延遲、風扇與功耗</td>
          <td>雲端 GPU 租用、資料中心訓練</td>
      </tr>
      <tr>
          <td>PC 硬體現實</td>
          <td><a href="/blog/llm/05-discrete-gpu/vram-ram-budget/" data-link-title="5.0 VRAM &#43; RAM 分層預算" data-link-desc="PC 獨立 GPU 場景的記憶體預算判讀：VRAM 是快的世界、RAM 是大的世界、PCIe 把兩個世界連起來">VRAM + RAM 分層預算</a>、MoE 專家層 CPU 卸載、KV cache 量化、PCIe 頻寬限制</td>
          <td>多卡 NVLink、資料中心級分散式推論</td>
      </tr>
      <tr>
          <td>本地推論伺服器</td>
          <td><a href="/blog/llm/01-local-llm-services/ollama/" data-link-title="1.0 Ollama：主流推論伺服器" data-link-desc="一行 brew 裝完、ollama run 一鍵跑 Gemma 4 MTP、OpenAI 相容 API on localhost:11434">Ollama</a>、<a href="/blog/llm/01-local-llm-services/lm-studio/" data-link-title="1.1 LM Studio：GUI 探索模型" data-link-desc="GUI 取向的本地推論伺服器：內建模型瀏覽器、speculative decoding 設定面板、適合探索新模型">LM Studio</a>、<a href="/blog/llm/01-local-llm-services/llama-cpp/" data-link-title="1.2 llama.cpp：底層推論引擎" data-link-desc="GGUF 格式、量化、MTP 仍 beta；多數讀者不需要直接接觸，Ollama 已經包好">llama.cpp</a>（Mac + PC 通用）</td>
          <td>vLLM、TGI、Triton 等資料中心級 inference server</td>
      </tr>
      <tr>
          <td>編輯器整合</td>
          <td><a href="/blog/llm/01-local-llm-services/vscode-continue-integration/" data-link-title="1.3 VS Code &#43; Continue.dev 整合" data-link-desc="安裝 Continue 擴充套件、config.json 設定、Cmd&#43;L 對話 / Cmd&#43;I 行內編輯快捷鍵">Continue.dev + VS Code</a>、Cursor 對應關係</td>
          <td>JetBrains 全套整合、Vim / Emacs 進階 plugin</td>
      </tr>
      <tr>
          <td>模型挑選</td>
          <td><a href="/blog/llm/01-local-llm-services/model-selection-priority/" data-link-title="1.4 寫 code 場景的模型選型優先順序" data-link-desc="Gemma 4 31B MTP → Qwen3-Coder 30B → Qwen3 14B → gpt-oss 20B 的取捨與適用情境">coding 場景的模型優先順序</a>、量化等級對體感影響</td>
          <td>benchmark 跑分方法論的完整推導</td>
      </tr>
      <tr>
          <td>期望管理</td>
          <td><a href="/blog/llm/01-local-llm-services/expectation-management/" data-link-title="1.5 期望管理：本地 LLM 的擅長領域與分工" data-link-desc="本地 LLM 是免費的初階 pair programmer：辨識它的擅長領域、跟雲端旗艦做結構性分工">本地 LLM 的擅長領域與分工</a>、混用雲端的時機</td>
          <td>LLM 通用能力評估、AGI 預測</td>
      </tr>
      <tr>
          <td>數學基礎</td>
          <td><a href="/blog/llm/02-math-foundations/linear-algebra-for-llm/" data-link-title="2.0 線性代數：向量、矩陣、空間" data-link-desc="LLM 內部運算的基底：向量、矩陣、向量空間、內積、norm、矩陣乘法的角色">線性代數</a>、<a href="/blog/llm/02-math-foundations/probability-and-information/" data-link-title="2.1 機率與資訊論" data-link-desc="LLM 輸出的本質是機率分佈：softmax、cross-entropy、KL divergence、perplexity 在訓練與推論中的角色">機率與資訊論</a>、<a href="/blog/llm/02-math-foundations/calculus-and-optimization/" data-link-title="2.2 微積分與最佳化" data-link-desc="從 gradient、chain rule 到 SGD / Adam：LLM 訓練如何更新數十億參數">最佳化</a>、<a href="/blog/llm/02-math-foundations/numerical-precision/" data-link-title="2.3 數值精度與量化的數學依據" data-link-desc="fp32 / bf16 / fp16 / int8 / int4 的差別、量化能省哪些 bits、品質衰減從哪裡來">數值精度</a> 在 LLM 中的角色</td>
          <td>完整數學證明、測度論等屬於數學系範圍的主題</td>
      </tr>
      <tr>
          <td>理論基礎</td>
          <td><a href="/blog/llm/03-theoretical-foundations/neural-network-basics/" data-link-title="3.0 神經網路基礎" data-link-desc="從單一 neuron 到 multi-layer：weights、activation function、forward / backward pass 的角色">神經網路</a>、<a href="/blog/llm/03-theoretical-foundations/embedding-spaces/" data-link-title="3.1 Embedding 空間" data-link-desc="token 怎麼變成向量、為什麼相似 token 在向量空間中靠近、embedding 是怎麼學出來的">embedding</a>、<a href="/blog/llm/03-theoretical-foundations/attention-mechanism/" data-link-title="3.2 Attention 機制" data-link-desc="Query / Key / Value、scaled dot-product attention、multi-head attention：Transformer 的核心運算">attention</a>、<a href="/blog/llm/03-theoretical-foundations/transformer-architecture/" data-link-title="3.3 Transformer 架構細節" data-link-desc="Decoder-only 結構、Transformer block、positional encoding、layer norm、residual stream">Transformer</a>、<a href="/blog/llm/03-theoretical-foundations/training-pipeline/" data-link-title="3.4 訓練流程：pre-train → SFT → RLHF" data-link-desc="LLM 的三階段訓練：預訓練、指令微調、人類反饋強化學習；各階段目標與最新替代方案">訓練流程</a>、<a href="/blog/llm/03-theoretical-foundations/sampling-and-decoding/" data-link-title="3.5 Sampling 與 Decoding 策略" data-link-desc="Greedy、beam search、top-k、top-p、temperature、min-p：模型輸出後怎麼挑下一個 token">sampling</a>、<a href="/blog/llm/03-theoretical-foundations/tokenization-algorithms/" data-link-title="3.6 Tokenization：BPE、SentencePiece、Tiktoken" data-link-desc="把文字切成 token 的算法：為什麼不同模型切出不同 token 數、tokenizer 選擇對能力的影響">tokenization</a>、<a href="/blog/llm/03-theoretical-foundations/cross-language-tokenization/" data-link-title="3.7 跨語言場景的 tokenizer 與訓練分佈原理" data-link-desc="為什麼模型對不同語言表現不一致：tokenizer &#43; 訓練資料分佈雙因素、語言選擇取捨">跨語言原理</a></td>
          <td>多模態擴展、最新研究細節交給 Stanford CS25</td>
      </tr>
      <tr>
          <td>應用層原理</td>
          <td><a href="/blog/llm/04-applications/rag-principles/" data-link-title="4.1 RAG 原理：retrieval &#43; augmentation 模式" data-link-desc="為什麼模型需要外掛知識、語意相似 vs 字面相似、chunking 的本質取捨、retrieval 失敗的根本原因">RAG</a>、<a href="/blog/llm/04-applications/tool-use-principles/" data-link-title="4.3 Tool use 原理：LLM 跟外部世界互動" data-link-desc="Structured output 是 LLM 跨入工程系統的橋、function calling 取捨、為什麼本地小模型 tool use 表現崩潰">Tool use</a>、<a href="/blog/llm/04-applications/agent-architecture/" data-link-title="4.4 Agent 架構原理" data-link-desc="Agent loop 結構、失敗模式、什麼任務適合 vs 不適合、跟人類審查的協作模型">Agent 架構</a>、<a href="/blog/llm/04-applications/application-protocols/" data-link-title="4.6 應用層協議：function calling / structured output / MCP" data-link-desc="三個常被混為一談的概念：模型能力、sampling 約束、server 協議，三者的層級差異與組合方式">應用層協議</a>、<a href="/blog/llm/04-applications/workflow-patterns/" data-link-title="4.7 Workflow 編排模式" data-link-desc="Pipeline / router / parallel / reflection：多 LLM call 組合的四種基本模式與退化條件">Workflow 編排</a>、<a href="/blog/llm/04-applications/production-resource-planning/" data-link-title="4.9 Production 部署的資源評估原理" data-link-desc="從本地單 user 到 production multi-tenant：concurrent users、cost model、observability、SLA、capacity planning 的設計取捨">Production resource</a>、<a href="/blog/llm/04-applications/artifact-management/" data-link-title="4.10 衍生產物管理原理：什麼進 git、什麼不該" data-link-desc="LLM 應用的 source / derived / external 三類產物對應 git / build cache / registry、與 production 部署的 reproducibility / cost / share 取捨">Artifact 管理</a></td>
          <td>具體 framework 教學（LangChain / LlamaIndex）、prompt engineering</td>
      </tr>
      <tr>
          <td>進階理論</td>
          <td><a href="/blog/llm/03-theoretical-foundations/reasoning-models/" data-link-title="3.8 Reasoning models：test-time compute paradigm" data-link-desc="Chain-of-thought 從 prompting 技巧演化成訓練 paradigm、reasoning model 的內部運作、本地可跑的選項與適用任務">Reasoning models</a>（o1 / R1 / QwQ 風格）、<a href="/blog/llm/03-theoretical-foundations/speculative-decoding-internals/" data-link-title="3.9 Speculative decoding 內部：drafter / 驗證 / 加速上限" data-link-desc="speculative decoding 的演算法細節、drafter 跟 target 怎麼配對、acceptance rate 怎麼決定實際加速、MTP 跟 EAGLE 等變體">Speculative decoding 內部</a>（drafter / MTP / EAGLE）</td>
          <td>完整 paper 推導、最新研究 frontier</td>
      </tr>
      <tr>
          <td>進階應用</td>
          <td><a href="/blog/llm/04-applications/long-context-engineering/" data-link-title="4.11 Long context engineering" data-link-desc="128K / 1M context 模型怎麼用：claimed vs effective context、lost-in-the-middle、context 設計策略、Long context vs RAG 取捨">Long context engineering</a>、<a href="/blog/llm/04-applications/embedding-model-internals/" data-link-title="4.12 Embedding model 內部：訓練、選型、in-domain fine-tune" data-link-desc="Embedding model 怎麼訓練（contrastive learning &#43; hard negative mining）、怎麼挑（MTEB / 大小 / domain）、何時該自己 fine-tune">Embedding model 內部</a>、<a href="/blog/llm/04-applications/benchmarking-and-evaluation/" data-link-title="4.14 Benchmarking 與評估方法論" data-link-desc="判讀 model card benchmark 數字、做自己工作流的 in-house benchmark、量測本地推論速度的完整方法論">Benchmarking</a>、<a href="/blog/llm/04-applications/vision-in-coding-workflow/" data-link-title="4.15 Vision in coding workflow：本地 VLM 怎麼接寫 code" data-link-desc="VLM 在 coding 工作流的 use cases、本地 VLM 選型、跟雲端 VLM 的分工、Continue.dev / Ollama 整合現狀">Vision in coding</a>、<a href="/blog/llm/04-applications/static-and-serverless-rag-deployment/" data-link-title="4.16 靜態 / serverless RAG deployment：架構選擇與資安取捨" data-link-desc="沒 backend 的場景怎麼做 RAG：四種 deployment 方案、API key 暴露問題、CORS / abuse / 第三方信任、跟模組六的 routing">靜態 / serverless RAG deployment</a></td>
          <td>完整 LangChain / LlamaIndex 教學</td>
      </tr>
      <tr>
          <td>Fine-tuning</td>
          <td>原理（<a href="/blog/llm/knowledge-cards/lora/" data-link-title="LoRA" data-link-desc="Low-Rank Adaptation：凍住原模型權重、只訓兩個小矩陣的 parameter-efficient fine-tuning">LoRA</a> / <a href="/blog/llm/knowledge-cards/qlora/" data-link-title="QLoRA" data-link-desc="把 base model 量化到 4-bit &#43; LoRA fine-tune 的組合、消費級 GPU 也能 fine-tune 大模型">QLoRA</a> / <a href="/blog/llm/knowledge-cards/catastrophic-forgetting/" data-link-title="Catastrophic Forgetting" data-link-desc="Fine-tune 模型時、新訓練資料覆蓋掉原本學到的能力的現象、LoRA / 資料 mixing 是主要緩解">catastrophic forgetting</a>）+ <a href="/blog/llm/01-local-llm-services/hands-on/local-fine-tuning/" data-link-title="Hands-on：用 QLoRA 在本機 fine-tune coding 模型" data-link-desc="Apple Silicon Mac / PC 獨立 GPU 上跑 QLoRA fine-tune 的完整流程：環境、資料、訓練、evaluation、合併、部署到 Ollama">本機 hands-on</a></td>
          <td>完整資料工程、large-scale distributed fine-tune</td>
      </tr>
      <tr>
          <td>隱私 / 安全</td>
          <td><a href="/blog/llm/00-foundations/privacy-data-flow/" data-link-title="0.7 隱私 / 資安的資料流原理" data-link-desc="從「位置」到「資料流」的思考升級：信任邊界、合約模型、零信任原則套用到 LLM 工作流">隱私資料流</a>、<a href="/blog/llm/06-security/" data-link-title="模組六：本地 LLM 的安全與權限" data-link-desc="個人 dev 在自己機器上跑本地 LLM 的安全議題：模型供應鏈、推論伺服器綁定、tool use 副作用、prompt injection 在 IDE、跨雲端 / 本地資料邊界">本地 dev 安全模組</a>（供應鏈 / 伺服器綁定 / tool use / prompt injection / 跨雲端邊界 / production routing）、<a href="/blog/llm/04-applications/static-and-serverless-rag-deployment/" data-link-title="4.16 靜態 / serverless RAG deployment：架構選擇與資安取捨" data-link-desc="沒 backend 的場景怎麼做 RAG：四種 deployment 方案、API key 暴露問題、CORS / abuse / 第三方信任、跟模組六的 routing">靜態網站 RAG 資安</a>、<a href="/blog/llm/01-local-llm-services/troubleshooting/" data-link-title="1.7 排錯方法論：用三層架構做故障定位" data-link-desc="故障定位的分層思考、症狀到層級的對應反射、log 在三層的角色差異、最小可重現的縮減策略">排錯方法論</a></td>
          <td>企業合規逐條檢核、SOC 2 / HIPAA 流程</td>
      </tr>
      <tr>
          <td>進一步學習</td>
          <td><a href="/blog/llm/02-math-foundations/going-deeper-math/" data-link-title="2.4 想學更深：推薦公開課程" data-link-desc="MIT、Stanford、Harvard 等公開課程：數學基礎跟 LLM 預備知識的完整學習路線">數學公開課推薦</a>、<a href="/blog/llm/03-theoretical-foundations/going-deeper-theory/" data-link-title="3.11 想學更深：推薦公開課程" data-link-desc="Karpathy、Stanford CS224N / CS25 / CS336、DeepLearning.AI、Hugging Face：LLM 理論深入學習的完整路線">LLM 理論公開課推薦</a></td>
          <td>（交給推薦的課程跟書籍）</td>
      </tr>
  </tbody>
</table>
<h2 id="學習路線">學習路線</h2>
<p>本指南分成七個模組加一組前置卡片（111 張）。讀者依目的選讀、不需要從頭到尾全讀：</p>
<ul>
<li><strong>想用 Apple Silicon Mac 裝本地 LLM 寫 code</strong>：讀模組零 + 模組一（最短路徑）</li>
<li><strong>想用 Windows / Linux + 獨立 GPU 裝</strong>：讀模組零 + 模組五</li>
<li><strong>想懂 LLM 內部原理</strong>：模組二（數學） + 模組三（理論、含 reasoning models / speculative decoding）— 跟硬體無關</li>
<li><strong>想做 LLM 應用開發（含 RAG / agent / VLM / 靜態 deployment）</strong>：模組四（12 章、跨工具世代不變的原理）— 跟硬體無關</li>
<li><strong>想懂本地工作流的安全議題</strong>：模組一 / 五跑穩後接模組六（個人 dev 視角）</li>
<li><strong>想選 RAG 的 storage 方案（pickle / vector DB / hosted SaaS）</strong>：直接看 <a href="/blog/llm/04-applications/vector-storage-engineering/" data-link-title="4.22 RAG storage 工程：從 pickle 到 vector database 的選型判讀" data-link-desc="RAG storage backend 選型：規模到哪個階段該從 in-memory 升級到 vector DB、dependency chain 如何收窄選項">4.22 RAG storage 工程</a></li>
<li><strong>想在靜態網站加 RAG / 智能搜尋</strong>：直接看 <a href="/blog/llm/04-applications/static-and-serverless-rag-deployment/" data-link-title="4.16 靜態 / serverless RAG deployment：架構選擇與資安取捨" data-link-desc="沒 backend 的場景怎麼做 RAG：四種 deployment 方案、API key 暴露問題、CORS / abuse / 第三方信任、跟模組六的 routing">4.16 靜態 / serverless RAG deployment</a></li>
<li><strong>想在本機 fine-tune 模型</strong>：模組三 3.4 訓練流程原理 → <a href="/blog/llm/01-local-llm-services/hands-on/local-fine-tuning/" data-link-title="Hands-on：用 QLoRA 在本機 fine-tune coding 模型" data-link-desc="Apple Silicon Mac / PC 獨立 GPU 上跑 QLoRA fine-tune 的完整流程：環境、資料、訓練、evaluation、合併、部署到 Ollama">本機 QLoRA hands-on</a></li>
<li><strong>想跟最新進展接軌</strong>：讀完模組後進推薦的公開課程跟 paper（模組二 2.4 + 模組三 3.10）</li>
</ul>
<h3 id="前置知識卡片"><a href="/blog/llm/knowledge-cards/" data-link-title="Knowledge Cards" data-link-desc="用原子化卡片整理本地 LLM 寫 code 場景所需的概念詞彙">前置知識卡片</a></h3>
<p>用原子化卡片整理 <a href="/blog/llm/knowledge-cards/token/" data-link-title="Token" data-link-desc="LLM 處理文字時的最小單位：介於字元與單字之間">token</a>、<a href="/blog/llm/knowledge-cards/autoregressive/" data-link-title="Autoregressive" data-link-desc="LLM 一次生成一個 token、把已生成內容作為下一次輸入的架構">自回歸</a>、<a href="/blog/llm/knowledge-cards/kv-cache/" data-link-title="KV Cache" data-link-desc="已處理 token 的 attention 中間結果暫存：避免重算、加速後續生成">KV cache</a>、<a href="/blog/llm/knowledge-cards/quantization/" data-link-title="Quantization" data-link-desc="用較少 bits 表示模型權重：壓縮記憶體佔用、加快生字速度，代價是少量品質衰減">量化</a>、<a href="/blog/llm/knowledge-cards/speculative-decoding/" data-link-title="Speculative Decoding" data-link-desc="用小模型猜未來 token、大模型並行驗證的加速技巧">speculative decoding</a>、<a href="/blog/llm/knowledge-cards/mtp/" data-link-title="Multi-Token Prediction (MTP)" data-link-desc="Google 為 Gemma 系列釋出的 speculative decoding 工程化實作">MTP</a>、<a href="/blog/llm/knowledge-cards/mlx/" data-link-title="MLX" data-link-desc="Apple 釋出的 Apple Silicon 數值運算 framework：類似 PyTorch / JAX 的 Mac 對應物">MLX</a>、<a href="/blog/llm/knowledge-cards/inference-server/" data-link-title="Inference Server" data-link-desc="載入模型權重、處理 prompt、產生 token 的常駐 process">推論伺服器</a>、<a href="/blog/llm/knowledge-cards/openai-compatible-api/" data-link-title="OpenAI 相容 API" data-link-desc="本地推論伺服器跟雲端 OpenAI 共用的 API 形狀標準">OpenAI 相容 API</a>、<a href="/blog/llm/knowledge-cards/memory-bandwidth/" data-link-title="Memory Bandwidth" data-link-desc="記憶體每秒能讀寫多少 bytes：決定本地 LLM 生字速度的真正瓶頸">memory bandwidth</a>、<a href="/blog/llm/knowledge-cards/unified-memory/" data-link-title="Unified Memory Architecture" data-link-desc="Apple Silicon 讓 CPU / GPU / NE 共用同一塊記憶體：跑大模型的優勢來源">統一記憶體</a>、<a href="/blog/llm/knowledge-cards/ttft/" data-link-title="TTFT" data-link-desc="Time To First Token：送出 prompt 到第一個 token 出現的等待時間">TTFT</a>、<a href="/blog/llm/knowledge-cards/prefill/" data-link-title="Prefill" data-link-desc="Prompt 首次處理時的計算階段：把整段輸入跑過模型、產生 KV cache">prefill</a>、<a href="/blog/llm/knowledge-cards/context-window/" data-link-title="Context Window" data-link-desc="模型一次能處理的最大 token 數量：prompt 加生成的總和上限">context window</a>、<a href="/blog/llm/knowledge-cards/transformer/" data-link-title="Transformer" data-link-desc="寫 code 用的 LLM 神經網路架構：基於 attention 機制、自回歸生成 token">Transformer</a>、<a href="/blog/llm/knowledge-cards/diffusion/" data-link-title="Diffusion" data-link-desc="產圖用的生成式 AI 架構：跟寫 code 用的 Transformer 是不同路線">Diffusion</a> 等核心概念。章節文章專注情境推導、術語背景交由卡片維持一致。</p>
<h3 id="模組零基礎知識與心智模型"><a href="/blog/llm/00-foundations/" data-link-title="模組零：基礎知識與心智模型" data-link-desc="建立本地 LLM 的心智模型、釐清 MLX / MTP / oMLX 等常被混淆的術語、Apple Silicon 記憶體現實">模組零：基礎知識與心智模型</a></h3>
<p>整理本地 vs 雲端 LLM 的差異、自回歸架構與記憶體頻寬瓶頸、介面 / 伺服器 / 模型三層心智模型、OpenAI 相容 API 為何重要、MLX / MTP / oMLX 三個容易搞混的術語、Apple Silicon Mac 記憶體與模型大小的對應關係、判讀本地 LLM 資訊的五個框架。</p>
<h3 id="模組一本地-llm-服務的安裝與應用"><a href="/blog/llm/01-local-llm-services/" data-link-title="模組一：本地 LLM 服務的安裝與應用" data-link-desc="Ollama、LM Studio、llama.cpp 的安裝與差異、VS Code &#43; Continue.dev 整合、模型選型與期望管理">模組一：本地 LLM 服務的安裝與應用</a></h3>
<p>整理 Ollama、LM Studio、llama.cpp 三個主流推論伺服器的現況差異與安裝路徑、用 Continue.dev 把本地 LLM 接到 VS Code 的完整步驟、寫 code 場景下模型選型的優先順序、本地模型的期望管理、想進一步玩 coding agent、Web UI、產圖時的延伸方向。</p>
<h3 id="模組二llm-的數學基礎"><a href="/blog/llm/02-math-foundations/" data-link-title="模組二：LLM 的數學基礎" data-link-desc="整理 LLM 推論背後需要理解的線性代數、機率與資訊論、最佳化、數值精度等數學概念">模組二：LLM 的數學基礎</a></h3>
<p>整理 LLM 推論背後的數學工具：<a href="/blog/llm/02-math-foundations/linear-algebra-for-llm/" data-link-title="2.0 線性代數：向量、矩陣、空間" data-link-desc="LLM 內部運算的基底：向量、矩陣、向量空間、內積、norm、矩陣乘法的角色">線性代數</a>（向量、矩陣、空間）、<a href="/blog/llm/02-math-foundations/probability-and-information/" data-link-title="2.1 機率與資訊論" data-link-desc="LLM 輸出的本質是機率分佈：softmax、cross-entropy、KL divergence、perplexity 在訓練與推論中的角色">機率與資訊論</a>（softmax、cross-entropy、KL、perplexity）、<a href="/blog/llm/02-math-foundations/calculus-and-optimization/" data-link-title="2.2 微積分與最佳化" data-link-desc="從 gradient、chain rule 到 SGD / Adam：LLM 訓練如何更新數十億參數">微積分與最佳化</a>（gradient、SGD / Adam）、<a href="/blog/llm/02-math-foundations/numerical-precision/" data-link-title="2.3 數值精度與量化的數學依據" data-link-desc="fp32 / bf16 / fp16 / int8 / int4 的差別、量化能省哪些 bits、品質衰減從哪裡來">數值精度</a>（fp32 / bf16 / Q4 / Q8 的取捨）。每章末尾接到<a href="/blog/llm/02-math-foundations/going-deeper-math/" data-link-title="2.4 想學更深：推薦公開課程" data-link-desc="MIT、Stanford、Harvard 等公開課程：數學基礎跟 LLM 預備知識的完整學習路線">公開課推薦</a>。</p>
<h3 id="模組三llm-的理論基礎"><a href="/blog/llm/03-theoretical-foundations/" data-link-title="模組三：LLM 的理論基礎" data-link-desc="從神經網路、embedding、attention、Transformer 架構、訓練到 sampling：LLM 內部運作的完整理論圖像">模組三：LLM 的理論基礎</a></h3>
<p>整理 LLM 內部運作機制、共 11 章：<a href="/blog/llm/03-theoretical-foundations/neural-network-basics/" data-link-title="3.0 神經網路基礎" data-link-desc="從單一 neuron 到 multi-layer：weights、activation function、forward / backward pass 的角色">神經網路基礎</a>、<a href="/blog/llm/03-theoretical-foundations/embedding-spaces/" data-link-title="3.1 Embedding 空間" data-link-desc="token 怎麼變成向量、為什麼相似 token 在向量空間中靠近、embedding 是怎麼學出來的">embedding 空間</a>、<a href="/blog/llm/03-theoretical-foundations/attention-mechanism/" data-link-title="3.2 Attention 機制" data-link-desc="Query / Key / Value、scaled dot-product attention、multi-head attention：Transformer 的核心運算">attention 機制</a>、<a href="/blog/llm/03-theoretical-foundations/transformer-architecture/" data-link-title="3.3 Transformer 架構細節" data-link-desc="Decoder-only 結構、Transformer block、positional encoding、layer norm、residual stream">Transformer 架構</a>、<a href="/blog/llm/03-theoretical-foundations/training-pipeline/" data-link-title="3.4 訓練流程：pre-train → SFT → RLHF" data-link-desc="LLM 的三階段訓練：預訓練、指令微調、人類反饋強化學習；各階段目標與最新替代方案">訓練流程</a>（pre-train → SFT → RLHF / DPO）、<a href="/blog/llm/03-theoretical-foundations/sampling-and-decoding/" data-link-title="3.5 Sampling 與 Decoding 策略" data-link-desc="Greedy、beam search、top-k、top-p、temperature、min-p：模型輸出後怎麼挑下一個 token">sampling 策略</a>、<a href="/blog/llm/03-theoretical-foundations/tokenization-algorithms/" data-link-title="3.6 Tokenization：BPE、SentencePiece、Tiktoken" data-link-desc="把文字切成 token 的算法：為什麼不同模型切出不同 token 數、tokenizer 選擇對能力的影響">tokenization 算法</a>、<a href="/blog/llm/03-theoretical-foundations/cross-language-tokenization/" data-link-title="3.7 跨語言場景的 tokenizer 與訓練分佈原理" data-link-desc="為什麼模型對不同語言表現不一致：tokenizer &#43; 訓練資料分佈雙因素、語言選擇取捨">跨語言場景原理</a>、<a href="/blog/llm/03-theoretical-foundations/reasoning-models/" data-link-title="3.8 Reasoning models：test-time compute paradigm" data-link-desc="Chain-of-thought 從 prompting 技巧演化成訓練 paradigm、reasoning model 的內部運作、本地可跑的選項與適用任務">Reasoning models</a>（o1 / R1 / QwQ 等 test-time compute paradigm）、<a href="/blog/llm/03-theoretical-foundations/speculative-decoding-internals/" data-link-title="3.9 Speculative decoding 內部：drafter / 驗證 / 加速上限" data-link-desc="speculative decoding 的演算法細節、drafter 跟 target 怎麼配對、acceptance rate 怎麼決定實際加速、MTP 跟 EAGLE 等變體">Speculative decoding 內部</a>（drafter / MTP / EAGLE）。每章末尾接到<a href="/blog/llm/03-theoretical-foundations/going-deeper-theory/" data-link-title="3.11 想學更深：推薦公開課程" data-link-desc="Karpathy、Stanford CS224N / CS25 / CS336、DeepLearning.AI、Hugging Face：LLM 理論深入學習的完整路線">公開課推薦</a>（Karpathy、Stanford CS224N / CS25 / CS336、DeepLearning.AI）。</p>
<h3 id="模組四llm-應用層原理"><a href="/blog/llm/04-applications/" data-link-title="模組四：LLM 應用層原理" data-link-desc="Prompt 技術光譜、RAG、tool use、agent、應用層協議、人機協作、multi-agent、workflow 編排、eval 設計：跨工具不變的概念地圖">模組四：LLM 應用層原理</a></h3>
<p>整理 LLM 作為系統元件的設計原理、共 12 章：<a href="/blog/llm/04-applications/rag-principles/" data-link-title="4.1 RAG 原理：retrieval &#43; augmentation 模式" data-link-desc="為什麼模型需要外掛知識、語意相似 vs 字面相似、chunking 的本質取捨、retrieval 失敗的根本原因">RAG</a>、<a href="/blog/llm/04-applications/tool-use-principles/" data-link-title="4.3 Tool use 原理：LLM 跟外部世界互動" data-link-desc="Structured output 是 LLM 跨入工程系統的橋、function calling 取捨、為什麼本地小模型 tool use 表現崩潰">tool use</a>、<a href="/blog/llm/04-applications/agent-architecture/" data-link-title="4.4 Agent 架構原理" data-link-desc="Agent loop 結構、失敗模式、什麼任務適合 vs 不適合、跟人類審查的協作模型">agent 架構</a>、<a href="/blog/llm/04-applications/application-protocols/" data-link-title="4.6 應用層協議：function calling / structured output / MCP" data-link-desc="三個常被混為一談的概念：模型能力、sampling 約束、server 協議，三者的層級差異與組合方式">應用層協議</a>、<a href="/blog/llm/04-applications/workflow-patterns/" data-link-title="4.7 Workflow 編排模式" data-link-desc="Pipeline / router / parallel / reflection：多 LLM call 組合的四種基本模式與退化條件">workflow 編排模式</a>、<a href="/blog/llm/04-applications/production-resource-planning/" data-link-title="4.9 Production 部署的資源評估原理" data-link-desc="從本地單 user 到 production multi-tenant：concurrent users、cost model、observability、SLA、capacity planning 的設計取捨">Production resource planning</a>、<a href="/blog/llm/04-applications/artifact-management/" data-link-title="4.10 衍生產物管理原理：什麼進 git、什麼不該" data-link-desc="LLM 應用的 source / derived / external 三類產物對應 git / build cache / registry、與 production 部署的 reproducibility / cost / share 取捨">衍生產物管理</a>、<a href="/blog/llm/04-applications/long-context-engineering/" data-link-title="4.11 Long context engineering" data-link-desc="128K / 1M context 模型怎麼用：claimed vs effective context、lost-in-the-middle、context 設計策略、Long context vs RAG 取捨">Long context engineering</a>、<a href="/blog/llm/04-applications/embedding-model-internals/" data-link-title="4.12 Embedding model 內部：訓練、選型、in-domain fine-tune" data-link-desc="Embedding model 怎麼訓練（contrastive learning &#43; hard negative mining）、怎麼挑（MTEB / 大小 / domain）、何時該自己 fine-tune">Embedding model 內部</a>、<a href="/blog/llm/04-applications/benchmarking-and-evaluation/" data-link-title="4.14 Benchmarking 與評估方法論" data-link-desc="判讀 model card benchmark 數字、做自己工作流的 in-house benchmark、量測本地推論速度的完整方法論">Benchmarking 方法論</a>、<a href="/blog/llm/04-applications/vision-in-coding-workflow/" data-link-title="4.15 Vision in coding workflow：本地 VLM 怎麼接寫 code" data-link-desc="VLM 在 coding 工作流的 use cases、本地 VLM 選型、跟雲端 VLM 的分工、Continue.dev / Ollama 整合現狀">Vision in coding workflow</a>（本地 VLM 接 IDE）、<a href="/blog/llm/04-applications/static-and-serverless-rag-deployment/" data-link-title="4.16 靜態 / serverless RAG deployment：架構選擇與資安取捨" data-link-desc="沒 backend 的場景怎麼做 RAG：四種 deployment 方案、API key 暴露問題、CORS / abuse / 第三方信任、跟模組六的 routing">靜態 / serverless RAG deployment</a>（沒 backend 場景）。本模組刻意只寫跨工具世代不變的原理、避開 LangChain / LlamaIndex 等具體 framework 教學。</p>
<h3 id="模組五windows--linux--獨立-gpu"><a href="/blog/llm/05-discrete-gpu/" data-link-title="模組五：Windows / Linux &#43; 獨立 GPU" data-link-desc="消費級 PC（Windows / Linux &#43; NVIDIA / AMD 獨立 GPU）跑本地 LLM 的硬體判讀、MoE CPU 卸載、KV cache 量化與 llama.cpp 調參">模組五：Windows / Linux + 獨立 GPU</a></h3>
<p>整理消費級 PC（Windows / Linux + NVIDIA / AMD 獨立 GPU）跑本地 LLM 的硬體判讀模型與工程選項：<a href="/blog/llm/05-discrete-gpu/vram-ram-budget/" data-link-title="5.0 VRAM &#43; RAM 分層預算" data-link-desc="PC 獨立 GPU 場景的記憶體預算判讀：VRAM 是快的世界、RAM 是大的世界、PCIe 把兩個世界連起來">VRAM + RAM 分層預算</a>、MoE 模型的 <a href="/blog/llm/knowledge-cards/moe-cpu-offload/" data-link-title="MoE CPU 卸載" data-link-desc="把 Mixture-of-Experts 模型不活躍的專家層權重放在系統 RAM、用到再走 PCIe 拉回 GPU、讓有限 VRAM 跑得了更大模型">CPU 卸載策略</a>（<code>--n-cpu-moe</code>）、KV cache 量化（K=Q8 / V=Q4）跟 context 長度的權衡、llama.cpp 在 PC 上的調參空間。本模組跟模組一是平行的硬體路線、共用模組零的心智模型跟卡片。</p>
<h3 id="模組六本地-llm-的安全與權限"><a href="/blog/llm/06-security/" data-link-title="模組六：本地 LLM 的安全與權限" data-link-desc="個人 dev 在自己機器上跑本地 LLM 的安全議題：模型供應鏈、推論伺服器綁定、tool use 副作用、prompt injection 在 IDE、跨雲端 / 本地資料邊界">模組六：本地 LLM 的安全與權限</a></h3>
<p>整理個人 dev 在自己機器上跑本地 LLM 的安全議題：<a href="/blog/llm/06-security/model-supply-chain-trust/" data-link-title="6.0 模型供應鏈與信任邊界" data-link-desc="個人 dev 用本地 LLM 時的模型權重來源信任：GGUF 完整性、Hugging Face / Ollama registry 信任、量化版本污染、檔案完整性檢查">模型供應鏈與信任邊界</a>、<a href="/blog/llm/06-security/inference-server-binding/" data-link-title="6.1 推論伺服器的綁定與暴露範圍" data-link-desc="個人 dev 場景下 llama-server / Ollama / LM Studio 的 bind address 判讀：127.0.0.1 vs LAN vs 反代、預設安全、誤開放給內網的後果">推論伺服器的綁定與暴露範圍</a>、<a href="/blog/llm/06-security/tool-use-permission-model/" data-link-title="6.2 tool use 與 MCP server 的權限模型" data-link-desc="個人 dev 場景下 tool use / MCP server 的副作用權限：檔案系統 / shell / 網路存取邊界、第三方 MCP 信任、副作用的可逆性">tool use 與 MCP server 的權限模型</a>、<a href="/blog/llm/06-security/prompt-injection-in-ide/" data-link-title="6.3 IDE 場景的 prompt injection" data-link-desc="個人 dev 場景下 IDE 寫 code 工作流的 prompt injection：codebase 內容、外部文件、剪貼簿作為攻擊面、跟雲端 LLM 場景的差異">IDE 場景的 prompt injection</a>、<a href="/blog/llm/06-security/cross-cloud-local-data-boundary/" data-link-title="6.4 跨雲端 / 本地的資料邊界" data-link-desc="個人 dev 場景下混用雲端 LLM 跟本地 LLM 時的 prompt 洩漏點：Continue.dev 多 provider 設定、隱私資料流、按敏感度分流的判讀">跨雲端 / 本地的資料邊界</a>、<a href="/blog/llm/06-security/routing-to-production-security/" data-link-title="6.5 跨進 production 的 routing 中樞" data-link-desc="個人 dev → 團隊 → production LLM 服務的三層演化、跟 backend/07 對應卡片的 routing 清單">跨進 production 的 routing 中樞</a>。framing 是個人 dev 視角、不是 enterprise 資安管理；production / 多租戶 LLM 服務的特殊資安議題見 <a href="/blog/backend/07-security-data-protection/" data-link-title="模組七：資安與資料保護" data-link-desc="以問題驅動方式擴充資安知識網：先定義服務環節問題，再以案例作為觸發式參考">Backend 模組七 資安與資料保護</a> 的 LLM 相關章節。</p>
<h2 id="模組之間怎麼配合">模組之間怎麼配合</h2>
<table>
  <thead>
      <tr>
          <th>模組</th>
          <th>角度</th>
          <th>跟其他模組的關係</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>模組零</td>
          <td>操作層心智模型</td>
          <td>是模組一跟模組五的共同前置</td>
      </tr>
      <tr>
          <td>模組一</td>
          <td>工具層、Mac 實際安裝</td>
          <td>用模組零的詞彙、跟模組三的理論互補</td>
      </tr>
      <tr>
          <td>模組二</td>
          <td>數學工具</td>
          <td>提供模組三需要的數學詞彙、跟硬體平台無關</td>
      </tr>
      <tr>
          <td>模組三</td>
          <td>理論機制</td>
          <td>用模組二的工具拼出完整 LLM、跟硬體平台無關</td>
      </tr>
      <tr>
          <td>模組四</td>
          <td>應用層原理</td>
          <td>用前面模組建的詞彙、看 LLM 作為系統元件</td>
      </tr>
      <tr>
          <td>模組五</td>
          <td>工具層、PC 獨立 GPU</td>
          <td>跟模組一平行、用模組零的詞彙、處理 VRAM 場景</td>
      </tr>
      <tr>
          <td>模組六</td>
          <td>安全層、個人 dev 視角</td>
          <td>在模組一 / 五的工作流上加安全判讀、cross-link backend/07 通用資安卡片</td>
      </tr>
  </tbody>
</table>
<p>模組二跟模組三可並讀。閱讀模組三遇到陌生數學詞時跳回模組二補完、再回模組三繼續。模組四在前面模組之上、但讀者熟悉 LLM 應用詞彙也可直接從這裡讀起。模組一跟模組五依硬體選一條主路線、共用模組零的心智模型與 <a href="/blog/llm/knowledge-cards/" data-link-title="Knowledge Cards" data-link-desc="用原子化卡片整理本地 LLM 寫 code 場景所需的概念詞彙">knowledge-cards</a>。模組六在模組一 / 五跑穩後接、處理「跑起來後該注意什麼」。</p>
<h2 id="適合的讀者">適合的讀者</h2>
<table>
  <thead>
      <tr>
          <th>背景</th>
          <th>適合程度</th>
          <th>建議起點</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>用過 ChatGPT / Claude、沒碰過本地模型</td>
          <td>直接適合</td>
          <td><a href="/blog/llm/00-foundations/" data-link-title="模組零：基礎知識與心智模型" data-link-desc="建立本地 LLM 的心智模型、釐清 MLX / MTP / oMLX 等常被混淆的術語、Apple Silicon 記憶體現實">模組零</a> 從頭讀</td>
      </tr>
      <tr>
          <td>裝過 Ollama 但被網路上的術語混淆</td>
          <td>直接適合</td>
          <td><a href="/blog/llm/00-foundations/mlx-mtp-omlx/" data-link-title="0.4 MLX / MTP / oMLX 的區別" data-link-desc="三個常被混為一談的術語：framework、加速技巧、特化 server，疊加而非互斥">MLX / MTP / oMLX 區分</a> + <a href="/blog/llm/00-foundations/info-judgment-frames/" data-link-title="0.6 判讀本地 LLM 資訊的五個框架" data-link-desc="本地 LLM 資訊更新快，學會用版本、層級、變數、能力、資料流五個框架評估文章與宣稱">判讀框架</a></td>
      </tr>
      <tr>
          <td>想知道 24GB / 32GB Mac 該選哪個模型</td>
          <td>直接適合</td>
          <td><a href="/blog/llm/00-foundations/hardware-memory-budget/" data-link-title="0.5 Apple Silicon 記憶體預算" data-link-desc="記憶體決定能跑什麼，Q4 量化下的可運作模型對照與系統保留">硬體記憶體預算</a> + <a href="/blog/llm/01-local-llm-services/model-selection-priority/" data-link-title="1.4 寫 code 場景的模型選型優先順序" data-link-desc="Gemma 4 31B MTP → Qwen3-Coder 30B → Qwen3 14B → gpt-oss 20B 的取捨與適用情境">模型選型</a></td>
      </tr>
      <tr>
          <td>想用本地 LLM 完全取代 Claude / GPT-5</td>
          <td>部分適合</td>
          <td><a href="/blog/llm/01-local-llm-services/expectation-management/" data-link-title="1.5 期望管理：本地 LLM 的擅長領域與分工" data-link-desc="本地 LLM 是免費的初階 pair programmer：辨識它的擅長領域、跟雲端旗艦做結構性分工">期望管理</a> 先看完再決定</td>
      </tr>
      <tr>
          <td>想懂 LLM 內部運作機制</td>
          <td>直接適合</td>
          <td><a href="/blog/llm/03-theoretical-foundations/" data-link-title="模組三：LLM 的理論基礎" data-link-desc="從神經網路、embedding、attention、Transformer 架構、訓練到 sampling：LLM 內部運作的完整理論圖像">模組三 理論基礎</a> 從頭讀（含 reasoning models / speculative decoding）</td>
      </tr>
      <tr>
          <td>想懂背後的數學</td>
          <td>直接適合</td>
          <td><a href="/blog/llm/02-math-foundations/" data-link-title="模組二：LLM 的數學基礎" data-link-desc="整理 LLM 推論背後需要理解的線性代數、機率與資訊論、最佳化、數值精度等數學概念">模組二 數學基礎</a> 從頭讀</td>
      </tr>
      <tr>
          <td>想懂 o1 / DeepSeek-R1 等 reasoning model 怎麼運作</td>
          <td>直接適合</td>
          <td><a href="/blog/llm/03-theoretical-foundations/reasoning-models/" data-link-title="3.8 Reasoning models：test-time compute paradigm" data-link-desc="Chain-of-thought 從 prompting 技巧演化成訓練 paradigm、reasoning model 的內部運作、本地可跑的選項與適用任務">3.8 Reasoning models</a> 從頭讀</td>
      </tr>
      <tr>
          <td>想做 LLM 應用開發（RAG / agent / tool use）</td>
          <td>直接適合</td>
          <td><a href="/blog/llm/04-applications/" data-link-title="模組四：LLM 應用層原理" data-link-desc="Prompt 技術光譜、RAG、tool use、agent、應用層協議、人機協作、multi-agent、workflow 編排、eval 設計：跨工具不變的概念地圖">模組四</a> 從 4.0 RAG 依序讀</td>
      </tr>
      <tr>
          <td>想在自家 Hugo / Astro 等靜態網站加 RAG</td>
          <td>直接適合</td>
          <td><a href="/blog/llm/04-applications/static-and-serverless-rag-deployment/" data-link-title="4.16 靜態 / serverless RAG deployment：架構選擇與資安取捨" data-link-desc="沒 backend 的場景怎麼做 RAG：四種 deployment 方案、API key 暴露問題、CORS / abuse / 第三方信任、跟模組六的 routing">4.16 靜態 / serverless RAG deployment</a>（含資安取捨）</td>
      </tr>
      <tr>
          <td>想用 VLM 看截圖 / 設計稿輔助寫 code</td>
          <td>直接適合</td>
          <td><a href="/blog/llm/04-applications/vision-in-coding-workflow/" data-link-title="4.15 Vision in coding workflow：本地 VLM 怎麼接寫 code" data-link-desc="VLM 在 coding 工作流的 use cases、本地 VLM 選型、跟雲端 VLM 的分工、Continue.dev / Ollama 整合現狀">4.15 Vision in coding workflow</a></td>
      </tr>
      <tr>
          <td>想評估 LLM benchmark 數字、做 in-house eval</td>
          <td>直接適合</td>
          <td><a href="/blog/llm/04-applications/benchmarking-and-evaluation/" data-link-title="4.14 Benchmarking 與評估方法論" data-link-desc="判讀 model card benchmark 數字、做自己工作流的 in-house benchmark、量測本地推論速度的完整方法論">4.14 Benchmarking 方法論</a></td>
      </tr>
      <tr>
          <td>想在本機 fine-tune 模型懂自家 codebase 慣例</td>
          <td>直接適合</td>
          <td><a href="/blog/llm/03-theoretical-foundations/training-pipeline/" data-link-title="3.4 訓練流程：pre-train → SFT → RLHF" data-link-desc="LLM 的三階段訓練：預訓練、指令微調、人類反饋強化學習；各階段目標與最新替代方案">3.4 訓練流程</a> 原理 + <a href="/blog/llm/01-local-llm-services/hands-on/local-fine-tuning/" data-link-title="Hands-on：用 QLoRA 在本機 fine-tune coding 模型" data-link-desc="Apple Silicon Mac / PC 獨立 GPU 上跑 QLoRA fine-tune 的完整流程：環境、資料、訓練、evaluation、合併、部署到 Ollama">QLoRA hands-on</a></td>
      </tr>
      <tr>
          <td>想做 large-scale fine-tune / 從頭訓練</td>
          <td>部分適合</td>
          <td>讀完模組三後進入 <a href="/blog/llm/03-theoretical-foundations/going-deeper-theory/" data-link-title="3.11 想學更深：推薦公開課程" data-link-desc="Karpathy、Stanford CS224N / CS25 / CS336、DeepLearning.AI、Hugging Face：LLM 理論深入學習的完整路線">推薦的公開課程</a> 跟 Stanford CS336</td>
      </tr>
      <tr>
          <td>用 Windows / Linux + NVIDIA / AMD 獨立 GPU 跑本地 LLM</td>
          <td>直接適合</td>
          <td><a href="/blog/llm/00-foundations/" data-link-title="模組零：基礎知識與心智模型" data-link-desc="建立本地 LLM 的心智模型、釐清 MLX / MTP / oMLX 等常被混淆的術語、Apple Silicon 記憶體現實">模組零</a> 建心智模型 + <a href="/blog/llm/05-discrete-gpu/" data-link-title="模組五：Windows / Linux &#43; 獨立 GPU" data-link-desc="消費級 PC（Windows / Linux &#43; NVIDIA / AMD 獨立 GPU）跑本地 LLM 的硬體判讀、MoE CPU 卸載、KV cache 量化與 llama.cpp 調參">模組五</a> 處理 VRAM 預算、MoE 卸載、KV cache 量化</td>
      </tr>
      <tr>
          <td>想知道本地 LLM 跑起來後的安全議題</td>
          <td>直接適合</td>
          <td><a href="/blog/llm/06-security/" data-link-title="模組六：本地 LLM 的安全與權限" data-link-desc="個人 dev 在自己機器上跑本地 LLM 的安全議題：模型供應鏈、推論伺服器綁定、tool use 副作用、prompt injection 在 IDE、跨雲端 / 本地資料邊界">模組六</a> 個人 dev 視角的安全與權限</td>
      </tr>
      <tr>
          <td>想把 LLM 部署成 production 服務、處理服務化資安</td>
          <td>部分適合</td>
          <td>個人視角見 <a href="/blog/llm/06-security/" data-link-title="模組六：本地 LLM 的安全與權限" data-link-desc="個人 dev 在自己機器上跑本地 LLM 的安全議題：模型供應鏈、推論伺服器綁定、tool use 副作用、prompt injection 在 IDE、跨雲端 / 本地資料邊界">模組六</a>；production 場景見 <a href="/blog/backend/07-security-data-protection/" data-link-title="模組七：資安與資料保護" data-link-desc="以問題驅動方式擴充資安知識網：先定義服務環節問題，再以案例作為觸發式參考">Backend 模組七 資安</a> 的 LLM 相關章節</td>
      </tr>
      <tr>
          <td>想在資料中心級 GPU（H100 / H200 / B200）部署</td>
          <td>部分適合</td>
          <td>心智模型跟 <a href="/blog/llm/knowledge-cards/" data-link-title="Knowledge Cards" data-link-desc="用原子化卡片整理本地 LLM 寫 code 場景所需的概念詞彙">knowledge-cards</a> 通用；vLLM / TGI / Triton 等資料中心 inference server 另尋專門教材</td>
      </tr>
      <tr>
          <td>想跑 Stable Diffusion / Midjourney 等產圖</td>
          <td>跟主題不同</td>
          <td>產圖是 Diffusion 架構、見 <a href="/blog/llm/knowledge-cards/diffusion/" data-link-title="Diffusion" data-link-desc="產圖用的生成式 AI 架構：跟寫 code 用的 Transformer 是不同路線">Diffusion 卡片</a>、另尋 ComfyUI / Draw Things 教材</td>
      </tr>
  </tbody>
</table>
<h2 id="用語約定">用語約定</h2>
<p>本指南使用的關鍵術語在第一次出現時都附原文。為避免歧義，下列詞彙在本指南內固定指涉：</p>
<ol>
<li><strong>本地 LLM</strong>：跑在使用者自己機器（Mac 或 PC）上的大型語言模型推論、prompt 留在本機。</li>
<li><strong>推論伺服器</strong>（inference server）：負責載入模型權重、處理 prompt、產生 token 的常駐程式、例如 Ollama、LM Studio 內建 server、llama.cpp <code>server</code>。</li>
<li><strong>介面層</strong>：使用者實際打字互動的工具、例如 VS Code + Continue.dev、CLI、Web UI。介面層透過 API 跟推論伺服器溝通。</li>
<li><strong>模型</strong>（model）：權重檔本身、例如 <code>gemma4:31b</code>、<code>qwen3-coder:30b</code>。模型可以在不同推論伺服器之間共用、前提是格式相容。</li>
<li><strong>量化</strong>（quantization）：把模型權重從高精度（如 bf16）壓成低精度（如 Q4）以減少記憶體佔用、代價是少許品質下降。</li>
</ol>
<h2 id="不在本指南內的主題">不在本指南內的主題</h2>
<p>本指南不討論：</p>
<ul>
<li><strong>Speech / audio LLM</strong>：跟核心文字 LLM 是不同方向、本指南不涵蓋。Vision（VLM）原本不放、但因 coding 工作流的 vision use case 進入主流、補上 <a href="/blog/llm/04-applications/vision-in-coding-workflow/" data-link-title="4.15 Vision in coding workflow：本地 VLM 怎麼接寫 code" data-link-desc="VLM 在 coding 工作流的 use cases、本地 VLM 選型、跟雲端 VLM 的分工、Continue.dev / Ollama 整合現狀">4.15 Vision in coding workflow</a>；video LLM 仍不放。</li>
<li><strong>資料中心訓練的工程細節</strong>：data parallelism、ZeRO、tensor parallelism 等屬於專門課程的範圍。</li>
<li><strong>向量資料庫的 vendor 比較</strong>（Pinecone vs Weaviate vs Chroma 等）：vendor 格局半年一變、不適合寫入教材。RAG 的 storage 工程原理（升級判讀、index 生命週期、dependency 約束）見 <a href="/blog/llm/04-applications/vector-storage-engineering/" data-link-title="4.22 RAG storage 工程：從 pickle 到 vector database 的選型判讀" data-link-desc="RAG storage backend 選型：規模到哪個階段該從 in-memory 升級到 vector DB、dependency chain 如何收窄選項">4.22 RAG storage 工程</a>。</li>
<li><strong>Kubernetes / 資料中心級分散式推論</strong>：跟個人機器本地 LLM 方向不同、需另尋專門教材。</li>
<li><strong>多卡 NVLink、tensor parallelism</strong>：消費級 PC 場景通常單卡、本指南不涵蓋多卡分散式推論。</li>
</ul>
<p>若讀完本指南後想往這些方向走：</p>
<ol>
<li><strong>想做 <a href="/blog/llm/knowledge-cards/rag/" data-link-title="RAG" data-link-desc="Retrieval-Augmented Generation：動態外掛知識給 LLM、繞開模型參數記憶的靜態限制">RAG</a> 應用</strong>：先把 Ollama + Continue.dev 跑穩、再讀 <a href="/blog/llm/04-applications/rag-principles/" data-link-title="4.1 RAG 原理：retrieval &#43; augmentation 模式" data-link-desc="為什麼模型需要外掛知識、語意相似 vs 字面相似、chunking 的本質取捨、retrieval 失敗的根本原因">模組四 4.1 RAG 原理</a> 建立設計取捨判讀、或 <a href="/blog/llm/03-theoretical-foundations/going-deeper-theory/" data-link-title="3.11 想學更深：推薦公開課程" data-link-desc="Karpathy、Stanford CS224N / CS25 / CS336、DeepLearning.AI、Hugging Face：LLM 理論深入學習的完整路線">模組三 3.8 推薦</a> 的 DeepLearning.AI short courses。</li>
<li><strong>想跑 coding <a href="/blog/llm/knowledge-cards/agent/" data-link-title="LLM Agent" data-link-desc="把控制流交給 LLM 的應用模式：自主決策、跨多步呼叫工具、人類角色從主導變監督">agent</a></strong>：先讀 <a href="/blog/llm/04-applications/agent-architecture/" data-link-title="4.4 Agent 架構原理" data-link-desc="Agent loop 結構、失敗模式、什麼任務適合 vs 不適合、跟人類審查的協作模型">4.4 Agent 架構原理</a> 建立判讀、再看 <a href="/blog/llm/01-local-llm-services/extension-paths/" data-link-title="1.6 延伸方向：Web UI、coding agent、產圖" data-link-desc="日常路徑跑穩後可以玩的延伸：Open WebUI、aider、ComfyUI；先把基底跑穩再進階">1.6 延伸方向</a> 了解 aider、Cline 等工具的定位差異。</li>
<li><strong>想跑產圖模型</strong>：<a href="/blog/llm/knowledge-cards/diffusion/" data-link-title="Diffusion" data-link-desc="產圖用的生成式 AI 架構：跟寫 code 用的 Transformer 是不同路線">Diffusion</a> 跟 Transformer 是不同架構、請另尋 ComfyUI / Draw Things / Diffusers 教材。</li>
<li><strong>想自己訓練 / fine-tune</strong>：讀完模組三、進入 Karpathy zero-to-hero、Stanford CS336、Hugging Face NLP Course 等<a href="/blog/llm/03-theoretical-foundations/going-deeper-theory/" data-link-title="3.11 想學更深：推薦公開課程" data-link-desc="Karpathy、Stanford CS224N / CS25 / CS336、DeepLearning.AI、Hugging Face：LLM 理論深入學習的完整路線">推薦資源</a>。</li>
</ol>
<hr>
<p><em>文件版本：v0.7.0</em>
<em>最後更新：2026-05-12</em>
<em>系列狀態：七個模組 + 125 張知識卡片。模組零（9 章）/ 一（10 章 + hands-on、含 QLoRA + judge harness）/ 二（5 章）/ 三（12 章、含 reasoning / speculative / constrained decoding）/ 四（17 章、含 long context / embedding / benchmarking / VLM / 靜態 deployment / coding agent harness / prompt caching / agent memory / tracing / LLM-as-judge）/ 五（7 章）/ 六（7 章、含 OWASP 對照）。</em></p>
]]></content:encoded></item></channel></rss>