qwen3 0.6b sft教程 - ba的博客

laoba

Announcement

Welcome to my blog! This is a sample announcement.

写在前面#

最近想自己微调一个小模型玩玩，选了 Qwen3-0.6B，主要是因为穷（划掉）。试了好几个平台，最后发现 Modal 的 P100 还挺好用的，不过余额烧得也挺快。后来发现 Kaggle 有免费的 P100 可以用，就是要验证手机号，稍微麻烦点，但白嫖真香。

折腾了一晚上总算是跑通了，踩了不少坑，写个教程记录下，也给后来人省点时间。

1. 环境准备#

先检查下 GPU#

这步别忘了，不然跑起来发现是 CPU 那就哭了：

1
import torch
2
print("torch.cuda.is_available():", torch.cuda.is_available())
3
print("cuda device count:", torch.cuda.device_count())
4
!nvidia-smi

如果输出 False，那就赶紧去 Kaggle 设置里开启 GPU，或者检查下 Modal 的配置。

装依赖#

这里有个坑，transformers 版本很重要。我一开始用的最新版结果各种报错，后来降到 4.44.2 就好了：

1
pip install --no-cache-dir --force-reinstall --no-deps \
2
  "protobuf==3.20.3" \
3
  "transformers==4.44.2" \
4
  "accelerate==0.33.0"

--force-reinstall 是为了确保版本对，别偷懒省略这个参数。

2. 数据准备#

去哪找数据？#

说实话，找合适的数据集挺费劲的。我的建议是直接去 HuggingFace 搜 “sft” 或者 “chinese sft”，能找到一大堆。

我用的是这个思维链数据集，质量还不错：

1
from datasets import load_dataset
2

3
ds = load_dataset("Jackrong/Chinese-Qwen3-235B-Thinking-2507-Distill-100k")

下载的时候可能会比较慢，耐心等等。Kaggle 上下载速度还行，Modal 有时候会快一些。

数据长什么样？#

这个数据集挺有意思的，有三个字段：

Input: 用户的问题
CoT_content: AI 的”内心独白”（思考过程）
Answer_content: 最后给用户看的回答

就是那种让模型学会”先思考再回答”的套路，挺酷的。

3. 开始微调#

加载模型#

1
import os
2
import torch
3
from transformers import AutoModelForCausalLM, AutoTokenizer
4

5
# 这个配置能避免显存碎片化，建议加上
6
if torch.cuda.is_available():
7
    os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
8

9
model_name = "Qwen/Qwen3-0.6B"
10
device = "cuda" if torch.cuda.is_available() else "cpu"
11

12
tokenizer = AutoTokenizer.from_pretrained(model_name)
13
model = AutoModelForCausalLM.from_pretrained(
14
    model_name,
15
    torch_dtype=torch.float16 if device == "cuda" else torch.float32,
16
).to(device)
17
model.train()

第一次下载模型会比较慢，大概 1GB 多，可以去泡杯咖啡。

数据预处理（重点！）#

这部分是最容易出错的，我当时在这卡了好久：

1
from transformers import DataCollatorForLanguageModeling
2

3
# 先取一小部分数据试试，别一上来就全量
4
train_size = 1000
5
raw_train = ds["train"].shuffle(seed=42).select(range(train_size))
6

7
def preprocess_function(example):
8
    """
9
    把数据转成 Qwen3 能懂的格式
10
    """
11
    user_input = example["Input"]
12
    cot = example["CoT_content"]
13
    answer = example["Answer_content"]
14

15
    # 关键在这里，用 <think> 标签包裹思考过程
16
    assistant_content = f"<think>{cot}</think>{answer}"
17

18
    messages = [
19
        {"role": "user", "content": user_input},
20
        {"role": "assistant", "content": assistant_content},
21
    ]
22

23
    # 应用聊天模板，记得开启 thinking
24
    text = tokenizer.apply_chat_template(
25
        messages,
26
        tokenize=False,
27
        add_generation_prompt=False,
28
        enable_thinking=True,  # 这个很重要！
29
    )
30

31
    tokenized = tokenizer(
32
        text,
33
        truncation=True,
34
        max_length=1024,  # 根据你的数据调整
35
    )
36
    tokenized["labels"] = tokenized["input_ids"].copy()
37
    return tokenized
38

39
# 处理数据
40
tokenized_train = ds["train"].map(
41
    preprocess_function,
42
    remove_columns=ds["train"].column_names,
43
)
44

45
data_collator = DataCollatorForLanguageModeling(
46
    tokenizer=tokenizer,
47
    mlm=False,
48
)

配置训练参数#

这里的参数我调了好几次才找到比较合适的：

1
from transformers import Trainer, TrainingArguments
2

3
training_args = TrainingArguments(
4
    output_dir="qwen3-0.6b-finetuned",
5
    per_device_train_batch_size=1,  # P100 显存有限，只能设 1
6
    gradient_accumulation_steps=4,   # 累积 4 步相当于 batch_size=4
7
    learning_rate=2e-5,              # 不要太大，容易炸
8
    num_train_epochs=1,              # 一个 epoch 就够了
9
    fp16=True,                       # 混合精度，省显存
10
    gradient_checkpointing=True,     # 这个也很重要，再省点显存
11
    logging_steps=10,                # 每 10 步打印一次 loss
12
    save_steps=50000,                # 我不想频繁保存
13
    save_total_limit=2,
14
    report_to="none",                # 不用 wandb 之类的
15
)
16

17
trainer = Trainer(
18
    model=model,
19
    args=training_args,
20
    train_dataset=tokenized_train,
21
    data_collator=data_collator,
22
)

开始训练！#

1
# 深呼吸，开始
2
trainer.train()
3

4
# 保存模型
5
trainer.save_model("qwen3-0.6b-finetuned")
6
tokenizer.save_pretrained("qwen3-0.6b-finetuned")

1000 条数据大概要跑 20-30 分钟，可以去刷刷手机。记得看着点，别让 Kaggle 断连了。

4. 部署成 API（可选）#

训练完了想测试效果，可以起个简单的 API 服务：

装依赖#

1
pip install -U fastapi uvicorn[standard] nest_asyncio

写个简单的服务#

1
import torch
2
from fastapi import FastAPI
3
from pydantic import BaseModel
4
from transformers import AutoTokenizer, AutoModelForCausalLM
5

6
device = "cuda" if torch.cuda.is_available() else "cpu"
7

8
# 加载刚训练好的模型
9
tokenizer = AutoTokenizer.from_pretrained("qwen3-0.6b-finetuned")
10
model = AutoModelForCausalLM.from_pretrained(
11
    "qwen3-0.6b-finetuned",
12
    torch_dtype=torch.bfloat16 if device == "cuda" else torch.float32,
13
)
14
model.to(device)
15
model.eval()
16

17
app = FastAPI()
18

19
class GenerateRequest(BaseModel):
20
    prompt: str
21
    max_new_tokens: int = 128
22
    temperature: float = 0.7
23
    top_p: float = 0.9
24

25
@app.post("/generate")
26
async def generate(req: GenerateRequest):
27
    messages = [{"role": "user", "content": req.prompt}]
28
    text = tokenizer.apply_chat_template(
29
        messages,
30
        tokenize=False,
31
        add_generation_prompt=True,
32
    )
33

34
    inputs = tokenizer(text, return_tensors="pt").to(device)
35

36
    with torch.no_grad():
37
        output_ids = model.generate(
38
            **inputs,
39
            max_new_tokens=req.max_new_tokens,
40
            do_sample=True,
41
            temperature=req.temperature,
42
            top_p=req.top_p,
43
            pad_token_id=tokenizer.eos_token_id,
44
        )
45

46
    gen_ids = output_ids[0][inputs["input_ids"].shape[-1]:]
47
    output_text = tokenizer.decode(gen_ids, skip_special_tokens=True)
48
    return {"output": output_text}

启动服务#

1
import nest_asyncio
2
import uvicorn
3

4
nest_asyncio.apply()
5
uvicorn.run(app, host="0.0.0.0", port=8000)

然后就可以用 curl 或者 Postman 测试了。

5. 如果显存不够…#

我知道很多人跟我一样都是穷学生，只能用免费的 GPU。如果上面的方法还是爆显存，试试 QLoRA：

1
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
2
from transformers import BitsAndBytesConfig
3

4
# 4-bit 量化，超级省显存
5
bnb_config = BitsAndBytesConfig(
6
    load_in_4bit=True,
7
    bnb_4bit_quant_type="nf4",
8
    bnb_4bit_use_double_quant=True,
9
    bnb_4bit_compute_dtype=torch.bfloat16,
10
)
11

12
model = AutoModelForCausalLM.from_pretrained(
13
    model_name,
14
    quantization_config=bnb_config,
15
    device_map="auto",
16
)
17

18
model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)
19

20
lora_config = LoraConfig(
21
    r=16,
22
    lora_alpha=32,
23
    lora_dropout=0.05,
24
    bias="none",
25
    task_type="CAUSAL_LM",
26
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
27
                    "gate_proj", "up_proj", "down_proj"],
28
)
29

30
model = get_peft_model(model, lora_config)

用这个方法，理论上 6GB 显存都能跑。

我踩过的坑#

transformers 版本问题：最新版有时候会出奇怪的 bug，建议用稳定版
忘记设置 enable_thinking=True：导致模型学不到思维链，白训练了
batch_size 设太大：直接 OOM，老老实实用 1 吧
学习率太高：模型直接崩了，loss 变成 NaN
Kaggle 自动断连：记得时不时动动鼠标或者刷新页面

一些建议#

刚开始先用小数据集（100-500 条）快速迭代，确认流程没问题
定期看看 loss，如果不降了就可以提前停止
保存好中间的 checkpoint，万一训练崩了还能恢复
训练完记得在验证集上测试，别过拟合了

总结#

整个流程其实不复杂，主要就是：

准备好数据
正确处理成模型能吃的格式
调好参数开始训练
祈祷别 OOM

0.6B 这个模型虽然小，但用几千条高质量数据微调后，在特定领域表现还是挺不错的。关键是快，本地跑都行，不用一直盯着云平台的余额。

有问题欢迎在评论区问，我看到了会回复的。祝大家微调顺利，少踩坑！

qwen3 0.6b sft教程

https://mizuki.mysqil.com/posts/qwen3-sft教程/

Author

laoba

Published at

2026-01-23

License

CC BY-NC-SA 4.0

Some information may be outdated

去年中期反思

美しいミズキ

写在前面#

1. 环境准备#

先检查下 GPU#

装依赖#

2. 数据准备#

去哪找数据？#

数据长什么样？#

3. 开始微调#

加载模型#

数据预处理（重点！）#

配置训练参数#

开始训练！#

4. 部署成 API（可选）#

装依赖#

写个简单的服务#

启动服务#

5. 如果显存不够…#

我踩过的坑#

一些建议#

总结#