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,選讀)
- Chapter 1 — Deep dive into Text Generation Inference with LLMs(The Two-Phase Inference Process、Sampling Strategies),預估 20 分鐘;跟 Backend 課程對照用
讀的時候抓這幾個重點
- 這部分已在 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裡那條帶註解的橫線
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,選讀)
- Chapter 1 — How 🤗 Transformers solve tasks,看同一個架構家族怎麼接上不同任務的 head;預估 20 分鐘
讀的時候抓這幾個重點
- 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 A | Model 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 層級)