AI Phase 03 — LLM / Foundation Models(Day 21–30)

100-Day AI Knowledge Challenge

AI Phase 03 — LLM / Foundation Models(Day 21–30)

這 10 天要搞懂 pretrained model 到底是什麼、怎麼從 base model 變成可以用的 instruction / reasoning model,以及怎麼讀一張 model card。核心 mental model 是 Pretraining → Base Model → Post-training → Instruction / Reasoning Model → Inference1。Day 27 要親手跑一次 fine-tuning,Day 30 要逐欄解讀一張真實的 model card,並比較兩個 model 在同一需求下的 trade-off。

主線是 Hugging Face LLM Course:Chapter 1 補觀念、Chapter 2 看 tokenizer 與 model 的 API、Chapter 3 是 fine-tuning(本 Phase 的底線是做到 Chapter 3);Chapter 11 補 SFT 與 chat template。Transformers 文件與 Hugging Face Hub 的 Model Cards 文件是搭配2。

token、context window、sampling、temperature、inference 這幾個主題已在 Backend 課程 Day 81 完整講過(Backend Day 81),這個 Phase 不重寫,只在 Day 21 與 Day 24 引用,新角度放在 pretraining → post-training 的流程與 model card3。

這個 Phase 的三項驗收各落在哪一天4:「跑過一次 fine-tuning,能說明 base model 和 fine-tuned model 的差異」是 Day 27(fine-tune 前後兩次 evaluate() 的輸出),Day 21、25 補概念,Day 28 用手寫 loop 重做;「挑一個真實 model card 逐欄寫出解讀」是 Day 30 的兩欄比較表,Day 25 先練習讀 Model Overview;「能比較兩個 model 在同一需求下的 trade-off」是 Day 30 的選型說明。

實作程式碼用 PyTorch + Hugging Face transformers、datasets、evaluate。Day 27 的 fine-tuning 在 CPU 上很慢,教材預設只用一小部分資料;有 GPU(或 Colab)時可以拿掉子集限制。

Day 21 — Pretraining → Base → Post-training:一個 LLM 是怎麼來的

今天要回答的問題

一個可以聊天的 LLM,跟「剛 pretrain 完的 model」差在哪裡?中間經過哪幾個階段?

主教材(Core)

  • Hugging Face LLM Course Chapter 1 — How do Transformers work?(Transformers are language models / Transformers are big models / Transfer Learning 三節),預估 25 分鐘
  • 實作,預估 60 分鐘

搭配(Companion,選讀)

讀的時候抓這幾個重點

  • 這部分已在 Backend Day 81 講過 token、context window、sampling 與 inference,今天的新角度是:這個 model 的能力是在哪個階段長出來的。
  • Pretraining 是從隨機初始化的 weight 開始、用超大量資料訓練。 頁面的說法是不帶任何先備知識、通常要花數週。它的目標是「預測下一個 token」(causal language modeling)或「預測被遮住的 token」(masked language modeling),不是「回答問題」。
  • Fine-tuning(transfer learning)是在 pretrained model 之上再訓練。 資料量、時間和算力都遠小於 pretraining,而且通常比從頭訓練效果好。今天的 mental model 就是把 Base Model → Post-training 這一段對應到這一節。
  • Base model 只會「接著寫」,不會「回答」。 它被訓練成續寫文字,你問它問題,它可能接著寫出更多問題。這是最容易誤會的地方:model 不聽話不是壞掉,是它還沒經過 post-training。

實作

用小型 base model 親眼看「續寫」而不是「回答」(distilgpt2 是 pretraining 後的 causal LM,沒有 instruction tuning):

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

name = "distilgpt2"
tok = AutoTokenizer.from_pretrained(name)
model = AutoModelForCausalLM.from_pretrained(name)

prompt = "Question: What is the capital of France?\nAnswer:"
ids = tok(prompt, return_tensors="pt")

with torch.no_grad():
    logits = model(**ids).logits[0, -1]          # 最後一個位置的 logits
probs = torch.softmax(logits, dim=-1)
top = torch.topk(probs, 5)
for p, i in zip(top.values, top.indices):
    print(repr(tok.decode(i)), round(p.item(), 4))

out = model.generate(**ids, max_new_tokens=30, do_sample=False,
                     pad_token_id=tok.eos_token_id)
print(tok.decode(out[0]))

預期:印出下一個 token 的前 5 名與機率;generate 的結果是接在 prompt 後面續寫,不保證答對,也可能繼續出現 Question: 之類的格式。實際輸出以你機器上的結果為準。

接著在 notes.md 畫一條橫線 Pretraining → Base → Post-training → Instruction / Reasoning → Inference,在每個箭頭上寫一句「這一步改變了什麼」。

過關標準

  • 能回答:pretraining 與 fine-tuning 差在哪(資料量、起點、目標各一句)?
  • 能回答:為什麼 base model 不會「回答問題」?
  • 產出:上面程式碼的輸出(前 5 名 token 與續寫結果),加上 notes.md 裡那條帶註解的橫線
  1. 依 AI 課程線總綱(curriculum/ai/00-master-curriculum.md)第 8 節「Phase 03 — LLM / Foundation Models」的目標與核心 mental model
  2. 依 AI 課程線總綱第 8 節的主課程與搭配
  3. 依 AI 課程線總綱第 4 節跟 Backend 課程的重疊對照表(Phase 03 ↔ Backend Day 81)與第 8 節「跟 Backend 課程重疊」
  4. 依 AI 課程線總綱第 8 節「驗收」三項

Day 22 — Encoder / Decoder / Seq2Seq:架構決定能做什麼

今天要回答的問題

BERT、GPT、T5 這幾種 model 的架構差在哪?為什麼今天的 LLM 幾乎都是 decoder-only?

主教材(Core)

  • Hugging Face LLM Course Chapter 1 — Transformer Architectures(Encoder models / Decoder models / Sequence-to-sequence models / Choosing the right architecture / The evolution of LLMs),預估 30 分鐘
  • 實作,預估 50 分鐘

搭配(Companion,選讀)

讀的時候抓這幾個重點

  • Encoder 的 attention 可以看雙向,decoder 只能看左邊。 頁面的分類是:encoder(如 BERT)適合分類、NER、抽取式問答;decoder(如 Llama、Gemma)適合生成;encoder-decoder(如 BART、T5)適合翻譯與摘要。
  • Decoder-only 在今天的 LLM 是主流。 頁面在 The evolution of LLMs 說多數現代 LLM 是 decoder,並且通常是「pretraining 之後再做 instruction tuning」,這正是 Day 21 那條 mental model 的前半段。
  • Architecture 與 checkpoint 是兩件事。 Chapter 1 的 How do Transformers work? 最後一節 Architectures vs. checkpoints 區分了「骨架」與「訓練好的 weight」。同一個架構可以有很多 checkpoint。
  • 標準 attention 的成本隨序列長度二次成長。 頁面的 Attention mechanisms 一節介紹了降低成本的做法(如 local attention),今天只要知道「長 context 有代價」,細節留到 Phase 05。

實作

只下載 config(不下載 weight),並排比較三個 model 的骨架:

from transformers import AutoConfig

for name in ["bert-base-uncased", "distilgpt2", "t5-small"]:
    cfg = AutoConfig.from_pretrained(name)
    print(name,
          "| model_type:", cfg.model_type,
          "| encoder_decoder:", cfg.is_encoder_decoder,
          "| layers:", getattr(cfg, "num_hidden_layers", None),
          "| hidden:", getattr(cfg, "hidden_size", None),
          "| heads:", getattr(cfg, "num_attention_heads", None),
          "| vocab:", getattr(cfg, "vocab_size", None))

預期:每個 model 印出一行,is_encoder_decoder 只有 t5-small 是 True。Transformers 文件說所有 config class 都有 hidden_size、num_attention_heads、num_hidden_layers、vocab_size(文字模型),若某個欄位在你的版本回傳 None,把它記在 notes.md,不要自己補數字。

把結果整理成一張表放進 notes.md:列是三個 model,欄是「架構類型 / 層數 / hidden size / vocab / 適合的任務」。

過關標準

  • 能回答:encoder、decoder、encoder-decoder 各適合哪類任務?為什麼生成任務用 decoder?
  • 能回答:architecture 與 checkpoint 的差別是什麼?
  • 產出:上面程式碼的輸出,加上 notes.md 裡填完的三列比較表

Deep Dive(選讀)

  • 讀 Transformers 文件的 Configuration,看 PreTrainedConfig 的共同屬性與 from_pretrained 不載入 weight 的說明(Deep Dive 層級)

Day 23 — Behind the pipeline:tokenizer → model → head → postprocessing

今天要回答的問題

pipeline("...") 一行背後做了哪三步?model 吐出來的 logits 怎麼變成人看得懂的結果?

主教材(Core)

  • Hugging Face LLM Course Chapter 2 — Behind the pipeline(Preprocessing with a tokenizer / Going through the model / Model heads / Postprocessing the output),預估 30 分鐘
  • Chapter 2 — Models(Creating a Transformer / Loading and saving),預估 20 分鐘
  • 實作,預估 50 分鐘

搭配(Companion,選讀)

  • Transformers 文件 — Models,看 PreTrainedModel 負責載入、下載、儲存 model 的說明

讀的時候抓這幾個重點

  • Pipeline = preprocessing + model + postprocessing。 頁面把 sentiment-analysis pipeline 拆成這三步。理解這個拆法,之後讀任何 inference 程式碼都能對得上。
  • Model 本體輸出的是 hidden states,不是答案。 AutoModel 回傳形狀為 (batch size, sequence length, hidden size) 的向量;要得到分類結果,還要接一個 task-specific head(頁面用 AutoModelForSequenceClassification)。
  • Logits 是未正規化的分數,要過 softmax 才是機率。 頁面的 Postprocessing 一節還示範用 id2label 把位置對回標籤名稱。
  • save_pretrained() 存兩個東西:config.json(架構)與 weight 檔。 兩者都要才能重新載入。這是 Day 22「architecture vs. checkpoint」的實際檔案層面。

實作

不用 pipeline,手動走一遍三步(checkpoint 與 Chapter 2「Behind the pipeline」頁面程式碼使用的相同,2026-10-16 查證;若之後載入失敗,到頁面確認當前使用的 checkpoint 名稱,並記在 notes.md):

import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification

name = "distilbert-base-uncased-finetuned-sst-2-english"
tok = AutoTokenizer.from_pretrained(name)
model = AutoModelForSequenceClassification.from_pretrained(name)

texts = ["I loved this course.", "This was a waste of time."]
inputs = tok(texts, padding=True, truncation=True, return_tensors="pt")
print(inputs.keys())
print(inputs["input_ids"].shape)

with torch.no_grad():
    logits = model(**inputs).logits
print(logits.shape, logits)

probs = torch.softmax(logits, dim=-1)
for t, p in zip(texts, probs):
    label = model.config.id2label[int(p.argmax())]
    print(t, "->", label, round(p.max().item(), 4))

預期:input_ids 的 shape 是 (2, 序列長度);logits 的 shape 是 (2, 2);兩句各印出一個 label 與機率,數值以你機器上的結果為準。

接著 model.save_pretrained("./tmp-model") 並列出資料夾內的檔案,在 notes.md 寫下裡面有哪些檔案、哪個是架構、哪個是 weight。

過關標準

  • 能回答:pipeline 的三步各做什麼?logits 與機率的差別?
  • 能回答:為什麼要有 head?AutoModel 與 AutoModelForSequenceClassification 的輸出差在哪?
  • 產出:上面程式碼的輸出,加上 save_pretrained 產生的檔案清單與每個檔案的用途一行說明

Day 24 — Tokenizer 與 batching:padding、attention mask、generate 的陷阱

今天要回答的問題

不同 tokenizer 為什麼切法不同?多句一起處理時,padding 與 attention mask 在做什麼?

主教材(Core)

  • Hugging Face LLM Course Chapter 2 — Tokenizers(Word-based / Character-based / Subword tokenization / Encoding / Decoding),預估 25 分鐘
  • Chapter 2 — Handling multiple sequences(Padding the inputs / Attention masks / Longer sequences),預估 20 分鐘
  • 實作,預估 50 分鐘

搭配(Companion,選讀)

  • Chapter 2 — Putting it all together(Special tokens),看 tokenizer 加的特殊 token
  • Transformers 文件 — Text generation(Pitfalls:Output length、Padding side、Prompt format)

讀的時候抓這幾個重點

  • 這部分的 token 與 context window 概念已在 Backend Day 81 講過,今天的新角度是:tokenizer 是 model 的一部分,不能換,以及 batching 時的 padding 細節。
  • Subword tokenization 是目前的主流折衷。 頁面說 word-based 的 vocab 太大且有 unknown token 問題,character-based 的每個 token 資訊太少,subword 讓常見字保持完整、罕見字拆成有意義的片段。Day 11 你自己寫的字元級 tokenizer 就是其中一個極端。
  • Tokenizer 與 vocabulary 必須跟 pretraining 時一致。 頁面強調換掉 tokenizer,model 看到的 id 就對不上它學過的意思。
  • Padding 不加 attention mask,結果會變。 頁面示範:padded 後的輸出跟單句獨立跑的輸出不同,因為 attention 也會看 padding token;加上 mask 後才還原。
  • 生成 model 要從左邊 padding。 Transformers 的 Text generation 文件說,LLM 不是被訓練成從 padding token 繼續生成,所以 padding_side 要設成 left。這是 encoder 分類與 decoder 生成在實務上的一個差異。

實作

from transformers import AutoTokenizer

text = "Tokenization is unbelievably important."
for name in ["bert-base-uncased", "gpt2"]:
    tok = AutoTokenizer.from_pretrained(name)
    toks = tok.tokenize(text)
    print(name, len(toks), toks)

# padding 與 attention mask(gpt2 沒有 pad token,借用 eos)
gtok = AutoTokenizer.from_pretrained("gpt2", padding_side="left")
gtok.pad_token = gtok.eos_token
batch = gtok(["1, 2, 3", "A, B, C, D, E"], padding=True, return_tensors="pt")
print(batch["input_ids"])
print(batch["attention_mask"])

預期:兩個 tokenizer 對同一句話切出不同數量的 token(BERT 的 WordPiece 與 GPT-2 的 byte-level BPE,具體切法以輸出為準);attention_mask 在較短那句的左側是 0。

在 notes.md 回答:如果把 padding_side 改成 right,attention_mask 會長怎樣?為什麼生成任務不能這樣做?(可以真的改了再跑一次確認。)

過關標準

  • 能回答:subword tokenization 解決了 word-based 與 character-based 各自的什麼問題?
  • 能回答:attention mask 的 1 與 0 各代表什麼?不加 mask 會怎樣?
  • 產出:上面程式碼的輸出,加上兩個 tokenizer 的 token 數與切法對照(各一行)

Day 25 — Base vs Instruct:chat template 與 model 的「型號」

今天要回答的問題

同一個 model 家族常同時有 Base 與 Instruct(或 post-trained)版本,差在哪?為什麼 prompt 一定要套 chat template?

主教材(Core)

  • Hugging Face LLM Course Chapter 11 — Chat Templates(Base Models vs Instruct Models / Common Template Formats / Best Practices),預估 25 分鐘
  • Hugging Face Hub — Qwen/Qwen3-8B-Base 與 Qwen/Qwen3-8B 兩張 model card(只看 Model Overview 一節),預估 25 分鐘
  • 實作,預估 50 分鐘

搭配(Companion,選讀)

  • Chapter 11 的上一頁 Supervised Fine-Tuning(頁面列出 Chat Templates / Supervised Fine-Tuning / LoRA / Evaluation 四個小節),先看章節地圖,Day 29 會回頭用

讀的時候抓這幾個重點

  • Base model 只被訓練去預測下一個 token;instruct model 另外被 fine-tune 成會遵循指令、能多輪對話。 這是 Chat Templates 頁面「Base Models vs Instruct Models」一節的核心,也是 Day 21 mental model 的後半段。
  • Chat template 是 instruct model 的「語法」。 頁面說 ChatML 這類格式用 system / user / assistant 角色標記每則訊息,而且不同 model 家族的格式不同,用錯會讓效果下降;正確的格式在 tokenizer 設定裡,用 apply_chat_template 產生。
  • Model card 的 Model Overview 會寫它是哪個階段。 查證當天(2026-10-16)Qwen3-8B-Base 的卡片寫 Training Stage 為 Pretraining;Qwen3-8B 的卡片寫 pretraining 與 post-training 兩個階段。這就是「看到 model 名稱後綴要先問它是哪個階段」的實例。
  • 同一家族的兩個 checkpoint,架構相同、weight 不同。 兩張卡片的層數與 attention head 數相同,差的是後者多經過 post-training。這呼應 Day 22 的 architecture vs. checkpoint。

實作

只下載 tokenizer(很小),看 instruct model 把對話變成什麼字串:

from transformers import AutoTokenizer

tok = AutoTokenizer.from_pretrained("Qwen/Qwen3-8B")
messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What is a base model?"},
]
text = tok.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
print(text)
print(len(tok(text)["input_ids"]))

預期:印出一段含角色標記與特殊 token 的字串,結尾是在等 assistant 開口的位置;最後一行是這段文字的 token 數。具體標記字串以輸出為準。

再用 Day 21 的 distilgpt2 tokenizer 嘗試 apply_chat_template(它沒有 chat template,預期會報錯或要求設定);把錯誤訊息貼進 notes.md,並說明這跟「base model 沒有 chat template」有什麼關係。

過關標準

  • 能回答:Base 與 Instruct 的訓練目標差在哪?為什麼 instruct model 需要 chat template?
  • 能回答:看到一個陌生 model 名稱時,要去 model card 的哪一節確認它是哪個階段?
  • 產出:上面程式碼的輸出,加上一張兩列的對照表(Qwen3-8B-Base vs Qwen3-8B:階段 / 參數量 / 層數 / context / license,欄位值抄自卡片並註明查證日期)

Day 26 — Fine-tuning 的第一步:Datasets 與資料前處理

今天要回答的問題

要 fine-tune 一個 pretrained model,資料要先處理成什麼樣子?dynamic padding 為什麼比一開始就 pad 好?

主教材(Core)

  • Hugging Face LLM Course Chapter 3 — Introduction,預估 5 分鐘
  • Chapter 3 — Processing the data(Loading a dataset from the Hub / Preprocessing a dataset / Dynamic padding),預估 35 分鐘
  • 實作,預估 60 分鐘

搭配(Companion,選讀)

  • 🤗 Datasets 文件 huggingface.co/docs/datasets(Chapter 3 Introduction 頁面指向的文件;首頁分 Tutorials / How-to guides / Conceptual guides / Reference 四類),只在遇到不熟的 API 時查

讀的時候抓這幾個重點

  • Chapter 3 的目標是把 pretrained BERT fine-tune 成文字分類 model。 資料集是 GLUE 的 MRPC(判斷兩句話是不是同義),這是 sentence-pair 任務:tokenizer 一次吃兩句,並用 token_type_ids 標記哪些 token 屬於第一句、哪些屬於第二句。
  • Dataset.map(..., batched=True) 是前處理的標準做法。 結果以 Arrow 檔存在磁碟上,記憶體用量低。
  • Padding 延後到組 batch 時才做(dynamic padding)。 用 DataCollatorWithPadding 讓每個 batch 只 pad 到該 batch 內最長的長度,減少浪費的運算。頁面也提到 TPU 偏好固定 shape,是例外情況。
  • 進入 model 前要移除非 tensor 欄位。 文字欄位與 idx 這類欄位模型用不到,需要移掉;標籤欄位要叫 labels(Day 28 自己寫 training loop 時會碰到)。

實作

from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorWithPadding

raw = load_dataset("glue", "mrpc")
print(raw)
print(raw["train"][0])
print(raw["train"].features["label"])

checkpoint = "bert-base-uncased"
tok = AutoTokenizer.from_pretrained(checkpoint)

def tokenize(ex):
    return tok(ex["sentence1"], ex["sentence2"], truncation=True)

tokenized = raw.map(tokenize, batched=True)
print(tokenized["train"].column_names)

collator = DataCollatorWithPadding(tokenizer=tok)
samples = [tokenized["train"][i] for i in range(8)]
samples = [{k: v for k, v in s.items()
            if k not in ["sentence1", "sentence2", "idx"]} for s in samples]
print([len(s["input_ids"]) for s in samples])
batch = collator(samples)
print({k: v.shape for k, v in batch.items()})

預期:raw 有 train / validation / test 三個 split;label 是把 0 對應到 not_equivalent、1 對應到 equivalent 的 ClassLabel;tokenize 後多出 input_ids、token_type_ids、attention_mask 欄位;batch 裡所有 tensor 的第二維等於這 8 筆中最長的長度。實際的長度與樣本數以輸出為準。

過關標準

  • 能回答:token_type_ids 是做什麼的?為什麼 dynamic padding 比整個資料集統一 pad 好?
  • 能回答:map(batched=True) 為什麼比逐筆處理好?
  • 產出:上面程式碼的輸出,加上一行:這 8 筆樣本的各自長度與 batch 的 shape,說明 padding 補到多長

Day 27 — 第一次 Fine-tuning:用 Trainer API 訓練並評估

今天要回答的問題

把一個 pretrained model fine-tune 到特定任務,需要設定哪些東西?怎麼知道有沒有學到東西?

主教材(Core)

  • Hugging Face LLM Course Chapter 3 — Fine-tuning a model with the Trainer API(Training / Evaluation / Advanced Training Features),預估 30 分鐘
  • 實作(訓練時間不計入;CPU 上用下面的子集設定),預估 70 分鐘

搭配(Companion,選讀)

  • 同一頁的 Advanced Training Features(mixed precision、gradient accumulation、learning rate scheduler),有 GPU 時再試

讀的時候抓這幾個重點

  • TrainingArguments 只有輸出資料夾是必填。 其他設定都有預設值;Trainer 的組成是 model、training arguments、train / validation dataset、data collator 與 tokenizer(頁面的 processing_class)。
  • 載入 AutoModelForSequenceClassification 時的警告是正常的。 頁面解釋:pretrained 的 head 被丟掉,換成隨機初始化的新 head(num_labels=2),所以那個 head 還沒有被訓練過。這就是「base 與 fine-tuned 差在哪」最具體的一個答案。
  • 預設的 train() 只回報 training loss,不代表 model 表現好。 要在 compute_metrics 用 🤗 Evaluate 算 accuracy 與 F1,並把 eval_strategy 設成 "epoch" 才會每個 epoch 評估一次。頁面的範例結果約 85.78% accuracy、F1 約 89.97,數字會因環境而異。
  • 在 CPU 上訓練很慢。 頁面建議用 GPU 或 Colab。教材的子集設定只是為了讓你在 CPU 上也能跑完一輪、看到流程,不是為了追分數。

實作

先建立「fine-tune 前」的基準,再訓練,最後比較。以下是 CPU 友善的子集版本(只用訓練集前 500 筆、1 個 epoch;有 GPU 時把 select 兩行拿掉、num_train_epochs 改成 3):

import numpy as np
import evaluate
from datasets import load_dataset
from transformers import (AutoTokenizer, AutoModelForSequenceClassification,
                          DataCollatorWithPadding, Trainer, TrainingArguments)

raw = load_dataset("glue", "mrpc")
checkpoint = "bert-base-uncased"
tok = AutoTokenizer.from_pretrained(checkpoint)
tokenized = raw.map(lambda ex: tok(ex["sentence1"], ex["sentence2"], truncation=True),
                    batched=True)
train_ds = tokenized["train"].select(range(500))
val_ds = tokenized["validation"]

metric = evaluate.load("glue", "mrpc")
def compute_metrics(eval_pred):
    logits, labels = eval_pred
    return metric.compute(predictions=np.argmax(logits, axis=-1), references=labels)

model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
args = TrainingArguments("mrpc-ft", eval_strategy="epoch", num_train_epochs=1,
                         report_to="none")
trainer = Trainer(model=model, args=args, train_dataset=train_ds,
                  eval_dataset=val_ds, data_collator=DataCollatorWithPadding(tok),
                  processing_class=tok, compute_metrics=compute_metrics)

print("before:", trainer.evaluate())     # 新 head 是隨機的,預期接近亂猜
trainer.train()
print("after:", trainer.evaluate())

預期:before 的 accuracy 接近亂猜(隨機 head);after 的 accuracy 與 F1 明顯高於 before。具體數字與是否通過警告以你機器上的輸出為準,並把兩個 dict 完整貼進 notes.md。若 TrainingArguments 或 Trainer 的參數名稱在你安裝的 transformers 版本不同(例如 eval_strategy、processing_class),以該版本的文件為準,並把改動記在 notes.md。

過關標準

  • 能回答:base model(加上隨機 head)與 fine-tuned model 的差異是什麼?你的 before / after 數字怎麼證明?
  • 能回答:為什麼載入時會有「部分 weight 是新初始化」的警告?
  • 產出:before 與 after 兩次 evaluate() 的完整輸出,加上一段說明你用了多少資料、幾個 epoch、跑了多久

Day 28 — 自己寫 training loop,並學會看 learning curve

今天要回答的問題

Trainer 替你做了哪些事?看到一條 loss 曲線,怎麼判斷 overfitting 或 underfitting?

主教材(Core)

  • Hugging Face LLM Course Chapter 3 — A full training loop(Prepare for training / The training loop / The evaluation loop),預估 30 分鐘
  • Chapter 3 — Understanding Learning Curves(Interpreting Learning Curve Patterns 與 Key Takeaways),預估 20 分鐘
  • 實作,預估 60 分鐘

搭配(Companion,選讀)

  • Chapter 3 — Fine-tuning, Check! 的 Pro Tips 區塊,當作 Chapter 3 的收尾清單
  • 同章 A full training loop 的 Accelerate 一節,只在你有多 GPU 或想了解分散式時讀

讀的時候抓這幾個重點

  • Training loop 就是五件事的重複:搬資料、forward、backward、optimizer step(加 scheduler)、清梯度。 頁面的順序是 loss.backward() → optimizer.step() → lr_scheduler.step() → optimizer.zero_grad()。Phase 01 手寫的 gradient descent 與這裡是同一件事,只是 model 大很多。
  • Evaluation loop 要 model.eval() 加上 torch.no_grad()。 頁面的 evaluation 一節這樣做,原因是評估時不該更新 weight、也不需要記錄梯度。
  • Learning curve 同時看 loss 與 accuracy。 頁面說 loss 應該先降後平;accuracy 常常是階梯狀,因為預測要跨過決策邊界才會改變。
  • Overfitting 與 underfitting 看 training 與 validation 的關係。 Training loss 下降但 validation loss 上升或不動,是 overfitting;兩者都很高,是 underfitting。頁面各自列出對應的補救方向。

實作

延續 Day 27 的 train_ds、val_ds 與 tok,改用純 PyTorch 迴圈(子集版,1 個 epoch),並把每一步的 loss 記下來:

import torch
from torch.utils.data import DataLoader
from transformers import (AutoModelForSequenceClassification, DataCollatorWithPadding,
                          get_scheduler)

cols = ["sentence1", "sentence2", "idx"]
tr = train_ds.remove_columns(cols).rename_column("label", "labels")
va = val_ds.remove_columns(cols).rename_column("label", "labels")
tr.set_format("torch"); va.set_format("torch")

collator = DataCollatorWithPadding(tok)
train_dl = DataLoader(tr, shuffle=True, batch_size=8, collate_fn=collator)
val_dl = DataLoader(va, batch_size=8, collate_fn=collator)

device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=2).to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=5e-5)
epochs = 1
steps = epochs * len(train_dl)
sched = get_scheduler("linear", optimizer=optimizer, num_warmup_steps=0, num_training_steps=steps)

losses = []
model.train()
for _ in range(epochs):
    for batch in train_dl:
        batch = {k: v.to(device) for k, v in batch.items()}
        loss = model(**batch).loss
        loss.backward()
        optimizer.step(); sched.step(); optimizer.zero_grad()
        losses.append(loss.item())

model.eval()
correct = total = 0
for batch in val_dl:
    batch = {k: v.to(device) for k, v in batch.items()}
    with torch.no_grad():
        pred = model(**batch).logits.argmax(dim=-1)
    correct += (pred == batch["labels"]).sum().item()
    total += len(pred)
print("steps:", len(losses), "first5:", losses[:5], "last5:", losses[-5:])
print("val accuracy:", correct / total)

預期:losses 的長度等於 len(train_dl);前幾步的 loss 通常比最後幾步高(單步 loss 有雜訊,不必每步遞減);val accuracy 的大小接近 Day 27 用 Trainer 子集跑出來的結果,但不必完全相同。若要畫曲線,可以用 matplotlib 畫 losses(需要另外安裝,屬選配)。

在 notes.md 回答:如果訓練了更多 epoch,training loss 一直降、validation accuracy 卻掉下來,你會怎麼判斷、頁面建議做什麼?

過關標準

  • 能回答:Trainer 替你包了哪幾件事?手寫 loop 的每一行對應 Trainer 的哪個行為?
  • 能回答:overfitting 與 underfitting 在 loss 曲線上各長什麼樣?
  • 產出:上面程式碼的輸出(前後各 5 步的 loss 與 val accuracy),加上 notes.md 裡對 overfitting 的書面回答

Day 29 — Post-training:SFT、偏好對齊(RLHF / DPO)、reasoning 與 distillation

今天要回答的問題

一個 pretrained model 變成「聽話的助理」或「會想很久才回答的 reasoning model」,中間用了哪些訓練方法?各自的資料長什麼樣?

主教材(Core)

  • Hugging Face LLM Course Chapter 11 — Supervised Fine-Tuning(章節地圖:Chat Templates / Supervised Fine-Tuning / LoRA / Evaluation),預估 10 分鐘
  • TRL 文件 — DPO Trainer(Overview / Expected dataset type and format / Looking deeper into the DPO method),預估 30 分鐘
  • Hub — Qwen/Qwen3-8B model card 的 Qwen3 Highlights 與「Switching Between Thinking and Non-Thinking Mode」兩節(兩節標題已確認存在),預估 15 分鐘
  • 實作,預估 50 分鐘

搭配(Companion,選讀)

  • Direct Preference Optimization 論文(連結在 DPO Trainer 頁面的 Overview:arXiv 2305.18290),只讀摘要;該論文頁面本任務未開啟,屬依 DPO Trainer 頁面轉引的連結
  • Qwen3 Technical Report(arXiv 2505.09388,由 Qwen3-8B 卡片連出)——本任務未開啟,Deep Dive 層級,想知道 post-training 實際流程時才讀

讀的時候抓這幾個重點

  • SFT 是用「輸入 → 理想輸出」的範例繼續訓練。 這就是 Day 27 的 fine-tuning 換成對話資料:Chapter 11 的章節地圖顯示它建立在 chat template 之上,並接著介紹 LoRA(低成本只訓練一小部分參數的做法)。
  • 偏好對齊的資料是「同一個 prompt 的好答案與壞答案」。 DPO Trainer 頁面說 DPO 需要 preference dataset:每筆包含 prompt、chosen、rejected 三個欄位。
  • DPO 不需要另外訓練 reward model。 頁面的說法是:目標函數直接拉大「chosen 相對於 reference model 的 log-likelihood」與「rejected 相對於 reference model 的 log-likelihood」之間的差距,不需要顯式的 reward model。頁面也提到實務上主要是壓低 rejected 的機率。這是跟 RLHF(先訓練 reward model、再用強化學習最大化它)最容易搞混的地方:DPO 論文摘要是把 RLHF 的問題改寫成一個簡單的分類 loss。
  • Reasoning model 是 post-training 的另一個方向。 Qwen3-8B 卡片有一節標題就叫「Switching Between Thinking and Non-Thinking Mode」,讀這一節看 model 怎麼在兩種模式間切換(本任務只確認了該節標題存在,內文由你今天讀)。「想很久」是 inference 時才看得到的行為,但它要靠 post-training 才有。
  • Distillation(蒸餾)今天只要先有概念。 概念是用較大或較強的 model 產生的輸出,去訓練較小的 model。本 Phase 沒有找到適合的、已開啟查證的單頁教材,所以不列為 Core;Phase 04 與 Phase 05 再回來。

實作

不訓練 model,只用純 Python 手算一次 DPO loss,確認你懂公式在比什麼。公式依 DPO Trainer 頁面的定義:loss = -log σ(β · ((log π(y⁺) − log π_ref(y⁺)) − (log π(y⁻) − log π_ref(y⁻)))),β 的預設值頁面寫 0.1。

import math

def dpo_loss(logp_chosen, logp_rejected, ref_chosen, ref_rejected, beta=0.1):
    margin = (logp_chosen - ref_chosen) - (logp_rejected - ref_rejected)
    return -math.log(1 / (1 + math.exp(-beta * margin)))

# 情境 A:policy 跟 reference 完全一樣(訓練剛開始)
print("A:", dpo_loss(-10.0, -12.0, -10.0, -12.0))
# 情境 B:policy 提高了 chosen、壓低了 rejected
print("B:", dpo_loss(-8.0, -15.0, -10.0, -12.0))
# 情境 C:policy 反過來,壓低了 chosen、提高了 rejected
print("C:", dpo_loss(-12.0, -9.0, -10.0, -12.0))

預期:A 的 loss 等於 log 2(約 0.693,因為 margin 為 0);B 小於 A;C 大於 A。這三個結論可以直接由公式推出,不需要依賴任何機器上的輸出。

接著在 notes.md 手寫一筆 preference 資料(照頁面的 standard 格式,{"prompt": ..., "chosen": ..., "rejected": ...}),並用兩句話說明這筆資料裡 chosen 與 rejected 的差別是人類偏好的哪個面向。

過關標準

  • 能回答:SFT 與 DPO 的訓練資料格式各是什麼?DPO 與 RLHF 在「需不需要 reward model」上的差別?
  • 能回答:β 變大或變小,對「policy 離 reference model 多遠」有什麼影響?(答案的依據是 DPO Trainer 頁面對 beta 的說明)
  • 產出:三個情境的 loss 數值與一句話解讀,加上你寫的那筆 preference 資料

Deep Dive(選讀)

  • 讀 DPO Trainer 頁面的 Loss Types 表,挑一種(例如 IPO 或 SimPO 對應的 sigmoid_norm)說明它想修正原始 sigmoid loss 的什麼問題(Deep Dive 層級,不計入 2 小時)

Day 30 — 讀 Model Card:逐欄解讀,並比較兩個 model

今天要回答的問題

看到一個 model 名稱,要從 model card 抓哪些資訊,才能決定能不能用、該怎麼用?兩個 model 在同一需求下怎麼取捨?

主教材(Core)

  • Hugging Face LLM Course Chapter 4 — Building a model card(Model description / Intended uses & limitations / Training data / Training procedure / Evaluation results),預估 20 分鐘
  • Hugging Face Hub 文件 — Model Cards(What are Model Cards? / Model card metadata,含 license、base_model、datasets 欄位),預估 20 分鐘
  • 實作與書面比較,預估 70 分鐘

搭配(Companion,選讀)

  • Hub 文件 — Annotated Model Card Template(Model Details / Uses / Bias, Risks, and Limitations / Training Details / Evaluation / Technical Specifications 各節的說明),當作逐欄解讀的檢查清單
  • Chapter 4 — The Hugging Face Hub,知道 Hub 上每個 model 是一個 Git repository

讀的時候抓這幾個重點

  • Model card 是 repo 裡的 README.md,上面有一段 YAML metadata。 Hub 文件說 metadata 決定了 model 怎麼被篩選與分類:license、datasets、base_model、pipeline_tag、library_name 都在這裡。
  • base_model 欄位說明這個 model 是 fine-tune、adapter、quantized 還是 merge。 Hub 文件說這個欄位可以標出衍生關係,使用者可以用它找出某個 base model 的所有衍生 model。這是追溯 Day 21 那條 mental model 的實務工具。
  • 卡片的完整度因發布者而異。 查證當天(2026-10-16)的兩個例子:Qwen3-8B 的卡片有 Model Overview(參數量、層數、attention 型態、context length、license),但沒有獨立的 limitations 一節;Mistral-7B-Instruct-v0.3 的卡片有 Limitations 一節,但沒有明確寫 context length。卡片沒寫的,不能自己補,要到 paper、config 或實測確認。
  • Benchmark 分數只是其中一欄。 總綱的提醒是看到「Qwen xxx 32B」不要只看 benchmark,要同時看 architecture、parameter size、context、license、intended use、limitations、training information 與 quantized variants。

實作

挑兩張真實的 model card,填同一張表。教材預設比較:Qwen/Qwen3-8B 與 mistralai/Mistral-7B-Instruct-v0.3(你也可以換成自己想用的兩個 model,但要在表上註明)。

欄位Model AModel B
發布者 / 版本 / 查證日期
階段(pretrain / post-train / base_model 欄位)
Architecture(類型、層數、attention 型態)
參數量
Context length(卡片有寫才填,沒寫就寫「卡片未載明」)
License
Intended use
Limitations / bias(卡片原文哪一節)
Training information(卡片寫了什麼、沒寫什麼)
Quantized variants(Hub 上的 quantizations 數量或位置)

再用程式碼從 Hub 讀 metadata,對照你填的表(需要網路;ModelCard 在 huggingface_hub,是 transformers 的依賴之一):

from huggingface_hub import ModelCard

for repo in ["Qwen/Qwen3-8B", "mistralai/Mistral-7B-Instruct-v0.3"]:
    card = ModelCard.load(repo)
    print(repo, card.data.to_dict())

預期:印出每個 repo 的 YAML metadata(例如 license、base_model 等欄位,具體有哪些欄位以輸出為準)。把輸出與你手填的表對照,標出「metadata 有、正文沒寫」或「正文有、metadata 沒有」的欄位各一個。

最後寫一段 150–250 字的選型說明:假設需求是「在單張消費級 GPU 上跑、需要工具呼叫、商用」,你選 A 還是 B?依據是表中的哪幾欄、哪些資訊卡片沒寫所以還需要另外確認?

過關標準

  • 能回答:model card 的 metadata 與正文各負責什麼?base_model 能告訴你什麼?
  • 能回答:卡片沒有寫 context length 或 limitations 時,你下一步去哪裡確認?
  • 產出:填完的兩欄比較表(每格標明資訊來自卡片的哪一節或「卡片未載明」)、程式碼輸出與對照標記、150–250 字的選型說明

Deep Dive(選讀)

  • 讀 Hub 文件 Model Cards 頁面的 Evaluation Results 與 Specifying a base model 兩節,了解 Hub 如何把評估結果與衍生關係結構化(Deep Dive 層級)