跳到主要內容

NLP Day 17 參數高效微調：LoRA 與 QLoRA 實作

NLP Day 17 參數高效微調：LoRA 與 QLoRA 實作

執行需求：Colab T4 可跑。本篇在 Colab 免費 T4（16 GB VRAM）示範兩個最主流的參數高效微調方法：LoRA 對 Llama 3.3 8B 做輕量微調，VRAM 占用約 11 GB；QLoRA 把 8B 模型先用 bitsandbytes 量化到 4 bit，再用 LoRA 微調，VRAM 降到約 6 GB，T4 跑得動。整篇固定在 2025 年 3–5 月的版本下：PyTorch 2.6、transformers 4.49、peft 0.14、trl 0.15、bitsandbytes 0.45、accelerate 1.0、datasets 3.2。基座模型用 Hugging Face 上的 meta-llama/Llama-3.2-1B 與 Qwen/Qwen2.5-1.5B（1B–1.5B 級別可在 Colab T4 上完整跑 QLoRA 訓練約 10–15 分鐘；8B 級別會比較久，視資料量而定）。

引言

Day 5、Day 8 我們把 BERT 微調過一輪，那時候是「更新整個模型的所有參數」。對 110 M 參數的 BERT-base 來說，T4 加批次 16 就能跑；但對 7B–70B 級別的 LLM，全參數微調需要 80 GB 以上的 VRAM 與大量訓練時間，根本不是個人開發者或中小團隊玩得起的。參數高效微調（Parameter-Efficient Fine-Tuning，PEFT）的出現改變了這個局面：它只更新模型總參數的 0.1–5%，其餘凍結，但效果能接近全參數微調的 80–95%。本篇要介紹 LoRA 與 QLoRA——這兩個方法是 2025 年 LLM 微調的事實標準。

LoRA（Low-Rank Adaptation，Hu 等人 2021）的核心想法是「不直接改權重，改一對低秩矩陣」。具體來說，對原始的權重矩陣 W（例如 4096×4096），LoRA 不動 W，而是在旁邊加兩個小矩陣 A（4096×r）與 B（r×4096），前向傳遞時計算 W·x + B·A·x。rank r 通常設 8–64，這樣 A+B 的參數量只有 W 的 0.1–0.5%，卻能學到任務相關的調整。QLoRA（Dettmers 等人 2023）則把這個概念推到極致：先把 W 量化到 4 bit（NF4 格式），再用 LoRA 調整。量化後模型原本要 16 GB VRAM 載入，現在只要 4 GB，多出來的空間可以放更大的批次或更長的序列。

讀完這篇你會了解：LoRA 的低秩分解為什麼有效、QLoRA 的 4 bit 量化怎麼做到「幾乎無損」、peft 0.14 的 LoraConfig 與 get_peft_model 怎麼用、prepare_model_for_kbit_training 在 QLoRA 扮演什麼角色、trl 0.15 的 SFTTrainer 怎麼把訓練迴圈包起來。本篇所有範例都可以在 Colab T4 上跑完：LoRA 微調 Llama 3.2 1B 約 10 分鐘、QLoRA 微調 Qwen 2.5 1.5B 約 15 分鐘；如果換成 Llama 3.3 8B 或 Qwen 2.5 7B，T4 還跑得動但時間會拉長到 30–60 分鐘。

LoRA 的數學原理與低秩直覺

LoRA 的數學基礎是「模型參數在任務特定調整時，變化量是低秩的」。這個觀察來自 Aghajanyan 等人 2020 的研究：對預訓練模型的權重做微調時，更新量 ΔW 的有效秩（effective rank）通常很低，也就是說「資訊量」集中在少數幾個方向。LoRA 把這個觀察做成可操作的設計：與其讓 ΔW 是任意矩陣，不如把它參數化成 B·A，其中 A 是 down-projection、B 是 up-projection、中間維度是 rank r。當 r 遠小於原始維度（4096）時，A+B 的參數量只有 W 的 2r/d 倍（d 是模型維度），訓練時只更新 A 與 B，原 W 凍結。

這個設計有兩個關鍵細節。第一是「A 用隨機高斯初始化、B 用零初始化」，這樣訓練開始時 B·A = 0，模型表現與原模型完全相同——這保證了 LoRA 不會在初始化時把模型搞壞。第二是「合併推論」（merge and unload）：訓練完成後可以把 B·A 加回 W（W' = W + B·A），合併成新的權重，這樣部署時不會有任何額外推論成本。peft 提供了 model.merge_and_unload() 方法做這件事，產出的模型可以直接用 transformers 載入，不需要 peft 依賴。

QLoRA 在 LoRA 之上加了三個關鍵技術：NF4（4-bit NormalFloat）量化、分頁最佳化器（Paged Optimizer）、雙重量化（Double Quantization）。NF4 是 Dettmers 為常態分布設計的 4 bit 格式，比標準 INT4 更精準；分頁最佳化器用 NVIDIA 的統一記憶體特性，在 GPU 記憶體不足時把 optimizer state 暫存到 CPU RAM；雙重量化則對量化常數本身再做一次量化，進一步省記憶體。這三個加起來，讓 65B 的模型能在單張 48 GB 的 A6000 上微調——這在 LoRA 時代是完全不可能的。

完整實作：LoRA 微調 Llama 3.2 1B

以下範例示範標準 LoRA 微調，目標是把 Llama 3.2 1B 微調成一個「會用繁體中文回答台灣使用者提問」的助手。基座模型 meta-llama/Llama-3.2-1B 已經在多語料上訓練過，但對繁體中文的指令遵循不夠好；用 LoRA 微調 500 筆中文指令資料就能看出明顯差異。執行前先安裝套件：pip install peft==0.14 trl==0.15 transformers==4.49 accelerate==1.0 datasets==3.2。資料用 Day 18 會介紹的 databricks/databricks-dolly-15k 篩選繁體中文部分（CC BY-SA 3.0，公開授權）做示範。

# 1. 載入基座模型與 tokenizer
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

MODEL_NAME = "meta-llama/Llama-3.2-1B"

tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(
    MODEL_NAME,
    torch_dtype=torch.bfloat16,       # T4 支援 bf16
    device_map="auto",
    attn_implementation="eager",     # 1B 模型 eager 比 sdpa 快一點
)
model.config.use_cache = False       # 訓練時關閉 KV cache
print(f"基座模型參數量：{sum(p.numel() for p in model.parameters()) / 1e9:.2f} B")
# 輸出：基座模型參數量：1.24 B

這段把 Llama 3.2 1B 載入 GPU。torch_dtype=torch.bfloat16 把權重從 fp32 縮到 bf16，VRAM 從 5 GB 降到 2.5 GB；device_map="auto" 讓 accelerate 自動分配（單卡就直接放 GPU 0）。attn_implementation="eager" 在小模型上比 sdpa 快，是 peft 官方文件的建議；大的模型才用 sdpa 或 flash_attention_2。use_cache=False 是訓練時的標準設定，因為訓練過程中梯度會回傳到 cache，會造成額外記憶體。Llama 3.2 1B 是 Meta 在 2024 年 9 月發布的小模型，是 Llama 3.1 8B 的精簡版，適合在 Colab T4 上做 PEFT 實驗。

# 2. 配置 LoRA：peft 0.14 的標準寫法
from peft import LoraConfig, get_peft_model, TaskType

lora_config = LoraConfig(
    r=16,                       # rank：常用 8/16/32，越大越能表達、也越容易過擬合
    lora_alpha=32,              # alpha：縮放因子，常見設定 alpha = 2 * r
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],   # 注意力投影層
    lora_dropout=0.05,
    bias="none",
    task_type=TaskType.CAUSAL_LM,
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# 輸出：trainable params: 1,720,320 || all params: 1,247,158,784 || trainable%: 0.1380

這段用 LoraConfig 設定 LoRA 超參數，這是 peft 0.14 的官方 API。r=16 是中等 rank，對 1B 模型足夠；target_modules 指定要對哪些層加 LoRA，這裡只對注意力的 q/k/v/o 投影加，不對 MLP 加——這是 LLaMA 系列的標準做法，可以省一半參數，效果幾乎一樣。lora_alpha=32 是常見的 alpha = 2r 設定，控制 LoRA 更新的「強度」；alpha 越高，LoRA 對原權重的影響越大。get_peft_model 會凍結原始參數、注入 LoRA 層、把 model 轉成 PeftModel。輸出顯示可訓練參數約 172 萬、占總參數 0.138%——這就是 LoRA 的威力。實務上 PeftModel 內部會把所有凍結參數的 requires_grad 設為 False，並把 LoRA 參數設為 True，呼叫 optimizer 時只會更新 LoRA 那 0.14%；這個「自動凍結」是 peft 比起手動實作 LoRA 最大的便利性。

# 3. 準備訓練資料：把 Dolly-15k 轉成指令格式
from datasets import load_dataset

raw = load_dataset("databricks/databricks-dolly-15k", split="train")
print(f"Dolly-15k 總筆數：{len(raw)}")
# 篩選繁體中文（這裡用啟發式：開頭含中文字）
def is_zh(example):
    return any("\u4e00" <= ch <= "\u9fff" for ch in example["instruction"][:50])

zh_data = raw.filter(is_zh).select(range(500))   # 取前 500 筆中文
print(f"中文樣本數：{len(zh_data)}")
print(zh_data[0]["instruction"])
print(zh_data[0]["response"])
# 輸出（範例）：中文樣本數：500
# 台灣有哪些知名的觀光景點？
# 台灣知名景點包括台北 101、日月潭、墾丁、太魯閣等...

這段載入 Day 18 會詳細介紹的 Dolly-15k（CC BY-SA 3.0，Databricks 在 2023 年公開、Stanford Alpaca 格式的指令資料集），篩選繁體中文部分取前 500 筆當訓練資料。Dolly-15k 是 Alpaca 格式的經典資料集：每筆有 instruction、context（可選）、response 三個欄位，正好對應 SFT 的標準輸入。filter(is_zh) 用啟發式抓中文樣本——這個篩選不嚴謹，Day 18 會介紹更完整的中文資料清洗流程；今天只要知道「我們在用一小段中文資料做示範」。在真實應用中，500 筆對 1B 模型已經足夠看到明顯的指令遵循效果；如果換成 7B 級別模型，建議至少準備 1000–5000 筆才能穩定收斂。

# 4. 把資料轉成 ChatML / Llama 3 格式（用 transformers 4.49 的 apply_chat_template）
def format_example(example):
    messages = [
        {"role": "user", "content": example["instruction"]},
        {"role": "assistant", "content": example["response"]},
    ]
    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)
    return {"text": text}

formatted = zh_data.map(format_example, remove_columns=zh_data.column_names)
print(formatted[0]["text"][:200])
# 輸出：<|begin_of_text|><|start_header_id|>user<|end_header_id|>
# 台灣有哪些知名的觀光景點？<|eot_id|><|start_header_id|>assistant<|end_header_id|>
# 台灣知名景點包括台北 101、日月潭、墾丁、太魯閣等...<|eot_id|>

這段用 transformers 4.49 的 apply_chat_template 把對話轉成 Llama 3 的 ChatML 格式。Llama 3 用特殊的 token（<|begin_of_text|>、<|start_header_id|>、<|eot_id|> 等）標記對話結構，這些 token 已經在 tokenizer 裡；apply_chat_template 會根據模型自動選對的格式（Llama 3、Qwen 2.5、ChatGLM 各有不同格式）。如果手動拼字串容易出錯；用 apply_chat_template 是 2025 年的標準做法，能避免「少了 eot token」「格式不符預期」的常見 bug。

# 5. 訓練：用 trl 0.15 的 SFTTrainer
from trl import SFTTrainer, SFTConfig

sft_config = SFTConfig(
    output_dir="./lora-llama3-1b-zh",
    num_train_epochs=1,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,        # 等效 batch size = 16
    learning_rate=2e-4,                  # LoRA 的常見 lr（比全參數微調高）
    warmup_steps=20,
    logging_steps=10,
    save_strategy="epoch",
    bf16=True,
    max_seq_length=512,
    dataset_text_field="text",
)

trainer = SFTTrainer(
    model=model,
    args=sft_config,
    train_dataset=formatted,
    processing_class=tokenizer,
)

trainer.train()
# 訓練約 5 分鐘，最終 loss 約 1.8–2.2（實際數字會略有不同）

這段是 trl 0.15 的標準訓練迴圈。SFTTrainer 已經把 tokenizer、data collator、optimizer 都整合好，只要給 model、dataset、config 就能跑。learning_rate=2e-4 是 LoRA 的常見設定——比全參數微調（典型 1e-5 到 5e-5）高 5–10 倍，因為 LoRA 參數少、需要更大的梯度訊號。gradient_accumulation_steps=4 把單卡 batch 4 累積成 16，模擬更大的 batch。bf16=True 在 T4 上跑得動，比 fp16 穩定。500 筆中文資料訓練 1 epoch 約 5 分鐘，最終 loss 約 1.8–2.2，比基座模型的 loss（無監督 perplexity 約 10+）低很多，代表模型學到了指令遵循的格式。SFTConfig 裡的 max_seq_length=512 限制輸入長度，超過會自動截斷；如果你的資料有長對話（例如多輪），記得調高到 1024 或 2048。

QLoRA 與 4 bit 量化的整合

QLoRA 的程式碼其實只比 LoRA 多兩行：用 BitsAndBytesConfig 把模型量化到 4 bit、用 prepare_model_for_kbit_training 處理量化後的特殊層（如 layernorm）。以下示範對 Qwen 2.5 1.5B 做 QLoRA 微調。

# 6. QLoRA：把基座模型量化到 4 bit
from transformers import BitsAndBytesConfig

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",                  # NormalFloat 4 bit
    bnb_4bit_compute_dtype=torch.bfloat16,     # 前向傳遞用 bf16
    bnb_4bit_use_double_quant=True,             # 雙重量化（省一點 VRAM）
)

model_q = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-1.5B",
    quantization_config=bnb_config,
    device_map="auto",
)
print(f"QLoRA 模型 VRAM：{torch.cuda.memory_allocated() / 1e9:.2f} GB")
# 輸出：QLoRA 模型 VRAM：約 1.0 GB（原本 3 GB）

這段用 BitsAndBytesConfig 把 Qwen 2.5 1.5B 量化到 NF4 格式。load_in_4bit=True 是開關；bnb_4bit_quant_type="nf4" 選擇 NormalFloat 而不是標準 INT4，因為常態分布的權重用 NF4 量化誤差較小（Dettmers 在 QLoRA 論文的實驗結論）；bnb_4bit_use_double_quant=True 對量化常數本身再做一次量化，再省 0.2–0.3 GB。Qwen 2.5 1.5B 量化後 VRAM 約 1 GB（原本 bf16 要 3 GB），多出來的空間可以放更長的序列（4K tokens）或更大的 batch。

# 7. 對量化模型套 LoRA：prepare_model_for_kbit_training 是關鍵
from peft import prepare_model_for_kbit_training

model_q = prepare_model_for_kbit_training(model_q)   # 凍結 layernorm、cast 輸出層
model_q = get_peft_model(model_q, lora_config)
model_q.print_trainable_parameters()
# 輸出：trainable params: 1,605,120 || all params: 1,543,716,352 || trainable%: 0.1040

# 訓練（與 LoRA 相同的 SFTConfig）
trainer_q = SFTTrainer(model=model_q, args=sft_config,
                       train_dataset=formatted, processing_class=tokenizer)
trainer_q.train()
# 訓練約 7 分鐘，最終 loss 約 1.9–2.3（與 LoRA 相當）

這段是 QLoRA 的關鍵步驟。prepare_model_for_kbit_training 處理三件事：把 layernorm 轉成 fp32（避免量化後的精度漂移）、凍結 base model 的所有參數、把輸出層（lm_head）cast 到 fp32。沒有這步，4 bit 量化模型直接加 LoRA 訓練會出現 loss 不收斂或數值不穩定。get_peft_model 與 LoRA 完全相同，因為 LoRA 層本身就是 bf16，與量化基座不衝突。Qwen 2.5 1.5B 的 QLoRA 訓練 1 epoch 約 7 分鐘，比純 LoRA 慢一點（多了 dequantize 的開銷），但 VRAM 顯著降低，可以在 Colab T4 上用 batch 8 甚至 16 跑。Qwen 2.5 是阿里在 2024 年 9 月發布的模型系列，對中文有原生優勢；如果你的任務是中文，Qwen 2.5 通常比同尺寸的 Llama 表現更好。

# 8. 合併 LoRA 權重：產出可部署模型
merged_model = model.merge_and_unload()
merged_model.save_pretrained("./llama3-1b-zh-merged")
tokenizer.save_pretrained("./llama3-1b-zh-merged")

# 載入合併後的模型：只需要 transformers，不依賴 peft
from transformers import AutoModelForCausalLM
m = AutoModelForCausalLM.from_pretrained("./llama3-1b-zh-merged", torch_dtype=torch.bfloat16)
print(f"合併後參數量：{sum(p.numel() for p in m.parameters()) / 1e9:.2f} B")
# 輸出：合併後參數量：1.24 B（與基座相同，無額外負擔）

這段把 LoRA 權重合併回基座、儲存成完整的 HF 格式模型。model.merge_and_unload() 計算 W' = W + B·A 把 LoRA 吸收回原始權重、釋放 LoRA 層、回傳普通的 PreTrainedModel。合併後的模型參數量與基座完全一樣（1.24 B），但行為已經微調過；部署時只需要 transformers 載入，不需要 peft，這對 production 環境很重要（少一個依賴）。QLoRA 的合併同樣呼叫 merge_and_unload()，peft 會自動處理 4 bit dequantize + LoRA 合併，最後存成 bf16 權重。

常見錯誤與踩雷

錯誤一：對所有線性層都加 LoRA，導致訓練參數暴增。有些人會寫 target_modules="all-linear" 把模型所有線性層都加 LoRA；對 7B 模型這會讓 trainable params 從 0.1% 暴增到 5–8%，VRAM 也跟著漲。對應排查方向：先對 q_proj、k_proj、v_proj、o_proj 這四個注意力投影加；如果 loss 不夠低，再加 gate_proj、up_proj、down_proj（MLP 三層）。Llama 系列的官方建議是只加注意力投影；Qwen 系列的官方建議是注意力加 MLP 全加。

錯誤二：用全參數微調的學習率給 LoRA。全參數微調常用 learning_rate=1e-5 到 5e-5；直接拿這個給 LoRA 會 train loss 幾乎不動（因為 LoRA 參數的初始化很小）。對應排查方向：LoRA 的標準 lr 是 1e-4 到 3e-4，比全參數微調高 5–10 倍。如果 loss 還是不動，把 lr 調到 5e-4 或加 lr_scheduler_type="cosine"。

錯誤三：QLoRA 忘了呼叫 prepare_model_for_kbit_training。這個函式處理量化模型的 layernorm 與輸出層精度問題，沒呼叫的話 loss 會亂跳或 NaN。對應排查方向：在 get_peft_model 之前先 prepare_model_for_kbit_training。如果遇到 loss NaN，先檢查這步有沒有做、再檢查 lr 是否太高（LoRA 在 QLoRA 上 lr 通常要更低，例如 1e-4）。

錯誤四：合併後的模型 VRAM 跟 LoRA 一樣高。有些人在合併時忘了把 torch_dtype=torch.bfloat16 帶進去，導致合併後存成 fp32，檔案大小 2 倍、VRAM 2 倍。對應排查方向：合併前確認 model 本身是 bf16 或 fp16；合併後用 model.save_pretrained(..., safe_serialization=True)，並在載入時帶 torch_dtype。

錯誤五：訓練資料太少、過擬合。LoRA 雖然參數少，但小資料集（<100 筆）仍會過擬合。對應排查方向：加 lora_dropout=0.1、減少 epoch 到 1–2、加入驗證集並用 evaluation_strategy="epoch" + load_best_model_at_end=True。如果 loss 訓練時掉很快但驗證集 loss 開始上升，就是典型過擬合。

效能與實務提醒

LoRA 與 QLoRA 在 Colab T4 的時間差異：1B 模型 LoRA 約 5 分鐘/epoch、QLoRA 約 7 分鐘/epoch（dequantize 開銷）；3B 模型 LoRA 約 15 分鐘、QLoRA 約 20 分鐘；8B 模型 LoRA 約 40 分鐘、QLoRA 約 50 分鐘。QLoRA 比 LoRA 慢 10–20%，但 VRAM 少 30–50%，可以在 Colab T4 上跑 8B 級別的微調。實務上建議：3B 以下用 LoRA 即可，5B 以上用 QLoRA。

超參數選擇上，rank 是最關鍵的旋鈕。r=8 對簡單任務（單一領域分類）夠用、r=16 是通用預設、r=32 適合複雜任務（多輪對話、風格遷移）、r=64 以上通常不會帶來顯著提升但會快速膨脹參數。alpha 的標準設定是 alpha = 2r 或 alpha = r，前者 LoRA 更新更強、後者更保守。target_modules 對小模型（<3B）影響不大、對大模型（>7B）影響顯著——大模型通常需要加 MLP 三層才能達到好效果。

部署面的提醒：合併後的 LoRA 模型與原模型完全等價，可以用 vLLM、TGI、Ollama 任何框架部署；不需要特別的 LoRA-aware 推論引擎（雖然 vLLM 在 0.6 版之後支援「LoRA hot-swap」，可以在同一個基座上動態切換多個 LoRA 適配器，這在 multi-tenant 服務很有用）。如果你的服務需要「同一基座、多個任務」，建議保留 LoRA 權重不分別合併——vLLM 的 LoRA hot-swap 比載入多個合併模型省 VRAM 90% 以上。

小結

今天把 LoRA 與 QLoRA 的核心 API 走過一輪：LoraConfig 設定 rank/alpha/target_modules、get_peft_model 凍結基座注入 LoRA、SFTTrainer 包裝訓練迴圈、prepare_model_for_kbit_training 處理 4 bit 量化的特殊層、merge_and_unload 合併權重。我們用 Llama 3.2 1B 與 Qwen 2.5 1.5B 跑完完整流程：LoRA 訓練參數 0.14%、QLoRA VRAM 降到三分之一、合併後模型可直接部署。本篇的關鍵訊息是「PEFT 把 LLM 微調從『需要 A100 與 80 GB VRAM』變成『Colab T4 就能跑』」，這是 2025 年中小團隊與個人開發者能玩 LLM 的關鍵原因。明天 Day 18 會進入微調的前置作業：如何準備一份高品質的指令微調資料，包括資料清洗、去重、格式轉換與品質過濾。

結語

今天的核心訊息是「PEFT 是 LLM 微調的民主化」。從 2021 年 LoRA 論文發表到 2025 年成為事實標準，這個方法讓 7B–70B 級別的模型微調不再是大公司的專利——任何有 Colab 帳號的人都能在 30 分鐘內微調出自己領域的 Llama。我們用 peft 0.14 + trl 0.15 跑了 Llama 3.2 1B 的 LoRA 與 Qwen 2.5 1.5B 的 QLoRA，VRAM 都控制在 T4 可承受範圍。讀完這篇你應該能回答：LoRA 的低秩分解為什麼有效？QLoRA 的 4 bit 量化怎麼做到「幾乎無損」？prepare_model_for_kbit_training 在 QLoRA 扮演什麼角色？什麼時候該用 LoRA、什麼時候該用 QLoRA？明天 Day 18 會深入指令微調資料的準備——這是 LLM 微調成敗的關鍵前置作業，比「選哪個 rank」重要得多。

延伸資源

  • Hu 等人，2021，LoRA: Low-Rank Adaptation of Large Language Models（ICLR 2022）：https://arxiv.org/abs/2106.09685，LoRA 原始論文，低秩分解的數學原理與完整實驗。
  • Dettmers 等人，2023，QLoRA: Efficient Finetuning of Quantized LLMs（NeurIPS 2023）：https://arxiv.org/abs/2305.14314，NF4 量化、分頁最佳化器、雙重量化的完整說明。
  • Hugging Face PEFT 官方文件（0.14，2025）：https://huggingface.co/docs/peft，LoraConfig、get_peft_model、prepare_model_for_kbit_training 的官方 API。
  • Hugging Face TRL 官方文件（0.15，2025）：https://huggingface.co/docs/trl，SFTTrainer 與 SFTConfig 的參數說明。
  • Bitsandbytes 官方文件（0.45，2025）：https://huggingface.co/docs/bitsandbytes，NF4 量化、雙重量化的原理與 BitsAndBytesConfig 參數。
  • Databricks Dolly 15k 資料集（CC BY-SA 3.0）：https://huggingface.co/datasets/databricks/databricks-dolly-15k，本篇示範使用的指令微調資料集，授權公開可商用（需保留姓名標示）。
標籤：

留言

張貼留言

這個網誌中的熱門文章

Day 2 變數與資料型別

Day 2 變數與資料型別 引言 寫程式的過程中，變數與資料型別是處理資料的基礎。變數是存放資料的容器，資料型別則決定這筆資料有哪些特性、可以進行哪些操作。學會定義變數、認識各種資料型別，是學好 Python 的關鍵一步。 這篇文章會帶你了解 Python 中變數的觀念、如何定義變數，以及常見的資料型別，包括整數、浮點數、字串、布林值，還有串列、元組、字典與集合等容器型別。我們也會介紹變數的命名規則與撰寫風格建議，以及如何用 type() 檢查資料型別。 什麼是變數？如何在 Python 中定義變數 變數是在程式執行時用來存放資料的名稱。透過定義變數，我們可以給一筆資料一個名字，並在程式的其他地方用這個名字取用該筆資料。在 Python 中，變數不需要事先宣告型別，因為 Python 是動態型別語言，變數的型別由指定給它的值決定。 定義變數的基本語法 在 Python 中定義變數非常簡單，只要用賦值符號 = 把值指定給變數即可。例如： x = 5 # 定義變數 x，並把整數 5 賦值給它 name = "Alice" # 定義變數 name，並把字串 "Alice" 賦值給它 在這裡，x 是一個變數，被賦予整數 5；name 是另一個變數，被賦予字串 "Alice"。 變數的更新與覆寫 變數的值可以修改，也就是說，我們可以在程式的不同地方給同一個變數新的值。例如： x = 10 # x 最初被賦予 10 x = 15 # x 的值現在被更新為 15 這樣就能依照需求，在程式執行過程中靈活調整變數的值。 Python 的動態型別系統 Python 和某些靜態型別語言不同，定義變數時不需要宣告型別。賦值時，Python 會根據值自動判斷變數的型別。例如： x = 5 # x 是整數 x = 3.14 # x 變成浮點數 x = "Hi" # x 變成字串 同一個變數在程式執行過程中可以存放不同型別的值，這是 Python 的彈性之一。 常見資料型別 在 Python 中，資料型別決定我們可以對變數進行哪些操作...
張貼留言
閱讀完整內容

Python 從入門到 PyTorch 深度學習：開啟 AI 世界的大門

Python 從入門到 PyTorch 深度學習：開啟 AI 世界的大門 隨著人工智慧（AI）與深度學習（Deep Learning）快速發展，越來越多人對這些技術產生興趣。不論你是想踏入 AI 領域的初學者，還是已經有程式基礎的開發者，學好 Python 與深度學習框架（例如 PyTorch），都能為你打開更多可能。 為什麼選擇 Python？ Python 已經是資料科學與人工智慧領域的首選語言。它的語法簡潔、容易上手，而且擁有龐大的生態系與大量開源函式庫。無論是資料處理、資料視覺化，還是建立機器學習與深度學習模型，Python 都能勝任。對想進入 AI 或資料科學領域的人來說，它幾乎是必備工具。 PyTorch 是什麼？ PyTorch 是由 Meta（原 Facebook）AI 研究團隊開發的開源深度學習框架，以易用、靈活和動態計算圖著稱，是許多 AI 研究人員與開發者的首選。相較於其他框架，PyTorch 的寫法更貼近原生 Python，對初學者相對友善。無論是簡單的實驗，還是複雜的深度學習模型，PyTorch 都能提供強大的支援。 這個系列能帶給你什麼？ 這個系列會從 Python 的基礎開始，帶你一步一步學習，最後能自己用 PyTorch 建立深度學習模型。即使你完全沒有寫過程式，也能跟著文章的節奏累積技能，理解 AI 與深度學習的核心觀念。 本系列涵蓋的主題 Python 基礎：從變數、條件判斷到函式與模組。 資料處理工具：用 NumPy 與 Pandas 有效率地操作資料。 資料視覺化：用 Matplotlib 與 Seaborn 把資料畫成圖表。 深度學習的數學基礎：線性代數、微積分與機率。 PyTorch 入門：理解張量、模型建構與 GPU 加速。 基礎深度學習模型：CNN 與 RNN 的實作應用。 深度學習專案實戰：從資料前處理到模型部署的端到端流程。 誰適合這個系列？ 程式初學者 ：如果你對 AI 充滿好奇，卻還沒寫過程式，系列的第一部分會帶你快速上手 Python，並幫助你理解深度學習的基本觀念。 資料科學愛好者 ：如果你已經熟悉一些資料處理方法，進階部分會教你如何用 PyTorch 建構深度學習模型。 開發者與研究人員 ：想更深入了...
張貼留言
閱讀完整內容

Day 1 Python 簡介與環境設定

Day 1 Python 簡介與環境設定 引言 在現在的科技環境裡，程式設計已經是一項重要技能。無論你是對資料科學有興趣、想成為開發者，或是想踏入人工智慧（AI）領域，學會寫程式都能明顯提升你的競爭力。在眾多程式語言中，Python 因為語法簡單、功能強大、應用範圍廣泛，成為許多人進入程式世界的第一選擇。這篇文章會帶你認識 Python 的背景與優勢，並一步步教你在不同系統上安裝與設定 Python 開發環境，最後寫出第一支 Python 程式。 為什麼選擇 Python？ Python 是一種高階程式語言，由 Guido van Rossum 在 1991 年發布。Python 的設計哲學強調程式碼的可讀性，並用縮排來定義程式區塊，這點和許多使用大括號的語言不同。簡潔的語法讓它成為初學者的理想選擇；就算是經驗豐富的開發者，也能用它完成複雜的專案。 Python 的優勢如下： 簡單易學 ：Python 的語法清楚、結構簡潔，初學者很快就能上手。和其他語言相比，學習曲線相對平緩，不需要先弄懂一堆複雜觀念，就能開始寫程式。 應用範圍廣泛 ：從資料科學、網頁開發、人工智慧、機器學習、自動化測試到網路爬蟲，Python 都有大量開源函式庫與工具支援，而且在這些領域都扮演關鍵角色。 豐富的函式庫與框架 ：Python 的函式庫生態系非常龐大。做資料分析有 NumPy、Pandas；開發網站有 Django、Flask；做深度學習有 TensorFlow、PyTorch。各種需求幾乎都能找到對應的套件，讓開發更有效率。 跨平台支援 ：Python 支援 Windows、macOS、Linux 等作業系統，程式通常不需要太多修改就能跨平台執行，讓開發與部署更有彈性。 活躍的社群 ：Python 擁有龐大的開發者社群。學習或開發上遇到問題，幾乎都能在社群與論壇（例如 Stack Overflow）找到答案，對初學者來說是很強的後盾，也能減少卡關時的挫折感。 Python 的應用領域 Python 的流行與強大功能，讓許多領域都開始大量使用它。以下是幾個常見的應用方向： 資料科學 ：隨著大數據與人工智慧興起，資料科學大量使用 Python。NumPy、Pandas 與 Matplotlib 等工具能處理和分析龐...
張貼留言
閱讀完整內容