【案例】Qwen 微调实战 · 任务定义与数据工程

[
  {
    "instruction": "请提取以下内容中的摘要信息",
    "input": "保持身体健康的五个方法：\n\n1. 每天至少饮用8杯水，促进新陈代谢\n2. 每周进行150分钟中等强度运动，如快走或游泳\n3. 保证7-9小时高质量睡眠，避免熬夜\n4. 饮食中增加蔬菜水果比例，减少油炸食品\n5. 定期体检，监测血压、血糖等指标",
    "output": "多喝水、规律运动、充足睡眠、均衡饮食、定期体检"
  },
  {
    "instruction": "请提取以下内容中的摘要信息",
    "input": "提高学习效率的三个技巧：\n\n1. 使用番茄工作法，每25分钟专注后休息5分钟\n2. 建立思维导图整理知识框架\n3. 睡前复习重点内容加强记忆",
    "output": "番茄工作法、思维导图、睡前复习"
  },
  {
    "instruction": "请提取以下内容中的摘要信息",
    "input": "旅行必备物品清单：\n1. 护照/身份证原件及复印件\n2. 便携充电宝和转换插头\n3. 常用药品（退烧药、创可贴）\n4. 轻便折叠雨伞\n5. 分装洗漱用品",
    "output": "证件、充电设备、药品、雨具、洗漱包"
  },
  {
    "instruction": "请提取以下内容中的摘要信息",
    "input": "职场沟通四大原则：\n① 明确沟通目标\n② 使用金字塔表达结构\n③ 注意非语言信号（眼神/姿态）\n④ 及时确认信息理解度",
    "output": "目标明确、结构化表达、非语言交流、信息确认"
  },
  {
    "instruction": "请提取以下内容中的摘要信息",
    "input": "TODO 把待处理的原文贴到这里。要求：\n1. 保留原文的换行与编号，不要压成一行\n2. 每条内容是动宾短语，带细节描述\n3. 长度控制在 cutoff_len 之内，中文按 1 字 ≈ 1 token 估",
    "output": "TODO、顿号分隔的核心短语、必须 100% 覆盖 input 条目、不加原文没有的信息"
  }
]

import json

INSTRUCTION = "请提取以下内容中的摘要信息"   # 全数据集固定这一句

raw = [
    ("提高学习效率的三个技巧：\n1. 番茄工作法\n2. 思维导图\n3. 睡前复习",
     ["番茄工作法", "思维导图", "睡前复习"]),
]

samples = []
for text, phrases in raw:
    if not (20 <= len(text) <= 900):       # 长度过滤，挡住会被截断的样本
        continue
    samples.append({
        "instruction": INSTRUCTION,
        "input": text.strip(),              # 原文，保留换行与编号
        "output": "、".join(phrases),       # 顿号分隔，不是逗号
    })

with open("qwen_dataset.json", "w", encoding="utf-8") as f:
    json.dump(samples, f, ensure_ascii=False, indent=2)   # 必须关掉 ASCII 转义

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""build_dataset.py —— 把原始文本构造成 instruction / input / output 三字段指令微调数据集。

输入：一份 JSON Lines 原始语料，每行至少包含正文字段（默认 `text`），
      可选地包含已标注好的关键短语字段（默认 `phrases`，列表或顿号分隔字符串）。
输出：LLaMA-Factory 可直接注册的 JSON 数组文件（一个 list，元素是三字段字典）。

运行（不需要 GPU，纯标准库）：
    python3 build_dataset.py --raw raw.jsonl --out qwen_dataset.json
    python3 build_dataset.py --raw raw.jsonl --out qwen_dataset.json --demo

设计上只做三件事：规范化字段、按长度过滤、落盘并打印统计。
标注质量本身不是脚本能保证的，它只保证"格式是对的、长度是可训的"。
"""

import argparse
import json
import os
import random
import re
import sys
from collections import Counter

# ---------------------------------------------------------------------------
# 1. 固定指令：同一个任务只用同一句祈使句
# ---------------------------------------------------------------------------
# 指令固定不变，模型才能建立稳定的任务映射；换着花样写指令会让映射变松散。
INSTRUCTION = "请提取以下内容中的摘要信息"

# output 里多个短语之间的分隔符，全站统一为中文顿号
SEP = "、"

# 长度过滤阈值（按字符计，粗略对应 token 的 0.6~1.0 倍，中文偏 1.0）
MIN_INPUT_CHARS = 20
MAX_INPUT_CHARS = 900        # 与训练配置里的 cutoff_len: 1024 留出余量
MIN_OUTPUT_PHRASES = 2
MAX_OUTPUT_PHRASES = 12


# ---------------------------------------------------------------------------
# 2. 字段规范化
# ---------------------------------------------------------------------------
def normalize_input(text):
    """把正文规整成干净的多行文本。

    做三件事：统一换行、压掉连续空行、去掉首尾空白。
    不改写正文内容本身 —— input 就是"待处理的原文"，改了它标注就对不上了。
    """
    if not isinstance(text, str):
        return ""
    text = text.replace("\r\n", "\n").replace("\r", "\n")
    text = re.sub(r"\n{3,}", "\n\n", text)
    text = re.sub(r"[ \t]+\n", "\n", text)
    return text.strip()


def normalize_output(phrases):
    """把关键短语规整成顿号分隔的一行字符串。

    接受三种输入形态：列表、顿号/逗号分隔的字符串、None。
    顺带去重并保持原顺序 —— 重复短语会让模型学到"可以啰嗦"。
    """
    if phrases is None:
        return ""
    if isinstance(phrases, str):
        parts = re.split(r"[、,，;；]", phrases)
    elif isinstance(phrases, (list, tuple)):
        parts = list(phrases)
    else:
        return ""

    seen, kept = set(), []
    for p in parts:
        p = str(p).strip().strip("。.,，、")
        if p and p not in seen:
            seen.add(p)
            kept.append(p)
    return SEP.join(kept)


# ---------------------------------------------------------------------------
# 3. 单条样本的构造与过滤
# ---------------------------------------------------------------------------
def build_sample(record, text_key="text", phrase_key="phrases"):
    """把一条原始记录变成三字段样本；不合格返回 (None, 原因)。"""
    raw_input = normalize_input(record.get(text_key))
    raw_output = normalize_output(record.get(phrase_key))

    if not raw_input:
        return None, "input 为空"
    if not raw_output:
        return None, "output 为空（未标注）"

    n = len(raw_input)
    if n < MIN_INPUT_CHARS:
        return None, "input 过短"
    if n > MAX_INPUT_CHARS:
        return None, "input 过长"

    phrases = raw_output.split(SEP)
    if len(phrases) < MIN_OUTPUT_PHRASES:
        return None, "短语数过少"
    if len(phrases) > MAX_OUTPUT_PHRASES:
        return None, "短语数过多"

    sample = {
        "instruction": INSTRUCTION,
        "input": raw_input,
        "output": raw_output,
    }
    return sample, None


# ---------------------------------------------------------------------------
# 4. 读入 / 写出
# ---------------------------------------------------------------------------
def read_jsonl(path):
    """逐行读 JSON Lines；坏行跳过并计数，不让一行脏数据毁掉整个构建。"""
    rows, bad = [], 0
    with open(path, "r", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            try:
                rows.append(json.loads(line))
            except json.JSONDecodeError:
                bad += 1
    if bad:
        print("[warn] 跳过无法解析的行：%d 行" % bad, file=sys.stderr)
    return rows


def demo_records():
    """内置样例，方便没有原始语料时先把流程跑通一遍。"""
    return [
        {
            "text": "保持身体健康的五个方法：\n"
                    "1. 每天至少饮用8杯水，促进新陈代谢\n"
                    "2. 每周进行150分钟中等强度运动，如快走或游泳\n"
                    "3. 保证7-9小时高质量睡眠，避免熬夜\n"
                    "4. 饮食中增加蔬菜水果比例，减少油炸食品\n"
                    "5. 定期体检，监测血压、血糖等指标",
            "phrases": ["多喝水", "规律运动", "充足睡眠", "均衡饮食", "定期体检"],
        },
        {
            "text": "提高学习效率的三个技巧：\n"
                    "1. 使用番茄工作法，每25分钟专注后休息5分钟\n"
                    "2. 建立思维导图整理知识框架\n"
                    "3. 睡前复习重点内容加强记忆",
            "phrases": "番茄工作法、思维导图、睡前复习",
        },
        {
            "text": "旅行必备物品清单：\n"
                    "1. 护照/身份证原件及复印件\n"
                    "2. 便携充电宝和转换插头\n"
                    "3. 常用药品（退烧药、创可贴）\n"
                    "4. 轻便折叠雨伞\n"
                    "5. 分装洗漱用品",
            "phrases": ["证件", "充电设备", "药品", "雨具", "洗漱包"],
        },
        {
            "text": "职场沟通四大原则：\n"
                    "① 明确沟通目标\n"
                    "② 使用金字塔表达结构\n"
                    "③ 注意非语言信号（眼神/姿态）\n"
                    "④ 及时确认信息理解度",
            "phrases": ["目标明确", "结构化表达", "非语言交流", "信息确认"],
        },
        {
            "text": "太短",   # 故意留一条会被长度过滤掉的
            "phrases": ["甲", "乙"],
        },
    ]


def summarize(samples):
    """打印一份可以贴进日志的统计，用来判断数据能不能开训。"""
    if not samples:
        print("没有产出任何样本。")
        return

    in_lens = sorted(len(s["input"]) for s in samples)
    out_cnt = sorted(len(s["output"].split(SEP)) for s in samples)

    def pct(arr, p):
        return arr[min(len(arr) - 1, int(len(arr) * p))]

    print("\n样本总数：%d" % len(samples))
    print("input  长度  min/中位/p95/max = %d / %d / %d / %d"
          % (in_lens[0], pct(in_lens, 0.5), pct(in_lens, 0.95), in_lens[-1]))
    print("output 短语数 min/中位/p95/max = %d / %d / %d / %d"
          % (out_cnt[0], pct(out_cnt, 0.5), pct(out_cnt, 0.95), out_cnt[-1]))

    dist = Counter(out_cnt)
    print("短语数分布：" + "  ".join("%d个:%d条" % (k, dist[k]) for k in sorted(dist)))

    inst = Counter(s["instruction"] for s in samples)
    print("instruction 种类数：%d（应为 1，多于 1 说明任务映射被写散了）" % len(inst))


def main():
    ap = argparse.ArgumentParser(description="构造 instruction/input/output 三字段微调数据集")
    ap.add_argument("--raw", help="原始语料 JSON Lines 路径")
    ap.add_argument("--out", default="qwen_dataset.json", help="输出的数据集 JSON 路径")
    ap.add_argument("--text-key", default="text", help="原始记录里正文字段名")
    ap.add_argument("--phrase-key", default="phrases", help="原始记录里关键短语字段名")
    ap.add_argument("--shuffle", action="store_true", help="落盘前打乱顺序")
    ap.add_argument("--seed", type=int, default=42, help="打乱用的随机种子")
    ap.add_argument("--demo", action="store_true", help="不读文件，用内置样例跑一遍")
    args = ap.parse_args()

    if args.demo:
        records = demo_records()
    elif args.raw:
        records = read_jsonl(args.raw)
    else:
        ap.error("要么给 --raw，要么加 --demo")
        return

    samples, rejects = [], Counter()
    for rec in records:
        sample, why = build_sample(rec, args.text_key, args.phrase_key)
        if sample is None:
            rejects[why] += 1
        else:
            samples.append(sample)

    if args.shuffle:
        random.Random(args.seed).shuffle(samples)

    out_dir = os.path.dirname(os.path.abspath(args.out))
    if out_dir:
        os.makedirs(out_dir, exist_ok=True)
    with open(args.out, "w", encoding="utf-8") as f:
        json.dump(samples, f, ensure_ascii=False, indent=2)

    print("已写出：%s" % args.out)
    if rejects:
        print("被过滤：" + "  ".join("%s=%d" % (k, v) for k, v in rejects.items()))
    summarize(samples)


if __name__ == "__main__":
    main()

$ python3 build_dataset.py --demo --out qwen_dataset.json
已写出：qwen_dataset.json
被过滤：input 过短=1

样本总数：4
input  长度  min/中位/p95/max = 59 / 76 / 120 / 120
output 短语数 min/中位/p95/max = 3 / 5 / 5 / 5
短语数分布：3个:1条  4个:1条  5个:2条
instruction 种类数：1（应为 1，多于 1 说明任务映射被写散了）

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""check_dataset.py —— 开训之前把数据集体检一遍。

检查四件事，每一件都对应一个真实会翻车的点：
  A. 字段完整性     —— 缺字段 / 字段类型不对 / instruction 不统一
  B. output 覆盖率  —— input 里列了几条，output 就该给几个短语（条目级覆盖）
  C. 长度分布       —— input 会不会被 cutoff_len 截断
  D. 重复与泄漏     —— 完全重复的样本、input 相同 output 不同的冲突标注

运行（纯标准库，不需要 GPU）：
    python3 check_dataset.py qwen_dataset.json
    python3 check_dataset.py qwen_dataset.json --cutoff 1024 --strict
退出码：0 = 通过；1 = 有致命问题（--strict 下警告也算不通过）。
"""

import argparse
import json
import re
import sys
from collections import Counter, defaultdict

SEP = "、"
REQUIRED_KEYS = ("instruction", "input", "output")


# ---------------------------------------------------------------------------
# A. 字段完整性
# ---------------------------------------------------------------------------
def check_fields(data):
    errors, warns = [], []

    if not isinstance(data, list):
        errors.append("顶层结构不是 list —— LLaMA-Factory 的 alpaca 风格数据集要求一个 JSON 数组")
        return errors, warns

    for i, item in enumerate(data):
        if not isinstance(item, dict):
            errors.append("第 %d 条不是对象" % i)
            continue
        for k in REQUIRED_KEYS:
            if k not in item:
                errors.append("第 %d 条缺字段 %s" % (i, k))
            elif not isinstance(item[k], str):
                errors.append("第 %d 条字段 %s 不是字符串（是 %s）" % (i, k, type(item[k]).__name__))
        if isinstance(item.get("input"), str) and not item["input"].strip():
            warns.append("第 %d 条 input 为空串" % i)
        if isinstance(item.get("output"), str) and not item["output"].strip():
            errors.append("第 %d 条 output 为空串 —— 空标注会直接教坏模型" % i)

    insts = Counter(x.get("instruction") for x in data if isinstance(x, dict))
    if len(insts) > 1:
        warns.append("instruction 有 %d 种写法，建议同一任务只用一句固定祈使句：%s"
                     % (len(insts), list(insts)[:3]))
    return errors, warns


# ---------------------------------------------------------------------------
# B. output 覆盖率
# ---------------------------------------------------------------------------
# input 里一个"条目"的开头长什么样：1. / 2、/ ① / - / • / （3）
ITEM_HEAD = re.compile(
    r"^\s*(?:\d+\s*[\.、）\)]|[（(]\s*\d+\s*[）)]|[①-⑳]|[-*•·])\s*\S"
)


def count_items(input_text):
    """数一数 input 里列了几个条目。

    标注规范要求 output 100% 覆盖 input 条目，所以"条目数"才是覆盖率的分母。
    注意不能用字面包含去判断 output 短语 —— 标注本来就是概括，
    「每天至少饮用8杯水」概括成「多喝水」，字面一个都对不上，那是正确标注。
    识别不出条目（整段散文）时返回 0，此时跳过覆盖率判断。
    """
    return sum(1 for line in input_text.split("\n") if ITEM_HEAD.match(line))


def _charset(s):
    """取中文字符与字母数字，用于"零交集"这一条最保守的编造信号。"""
    return set(re.findall(r"[\u4e00-\u9fff0-9A-Za-z]", s))


def check_coverage(data, sample_limit=20):
    warns, mismatched, orphan = [], [], []
    ratios = []

    for i, item in enumerate(data):
        if not isinstance(item, dict):
            continue
        inp = item.get("input") or ""
        out = item.get("output") or ""
        if not isinstance(inp, str) or not isinstance(out, str) or not out:
            continue

        phrases = [p for p in out.split(SEP) if p.strip()]
        if not phrases:
            continue

        # B-1 条目级覆盖：列了几条就该给几个短语
        n_items = count_items(inp)
        if n_items:
            ratio = min(1.0, len(phrases) / n_items)
            ratios.append(ratio)
            if len(phrases) != n_items and len(mismatched) < sample_limit:
                mismatched.append((i, n_items, len(phrases)))

        # B-2 最保守的编造信号：短语与原文一个字符都不沾
        inp_chars = _charset(inp)
        for p in phrases:
            cs = _charset(p)
            if cs and not (cs & inp_chars) and len(orphan) < sample_limit:
                orphan.append((i, p))

    if ratios:
        avg = sum(ratios) / len(ratios)
        full = sum(1 for r in ratios if r >= 0.999)
        print("条目级覆盖率：平均 %.1f%%，完全覆盖的样本 %d/%d（%.1f%%）"
              % (avg * 100, full, len(ratios), full / len(ratios) * 100))
        if avg < 0.95:
            warns.append("平均条目覆盖率 %.1f%% 偏低，说明有 input 条目在 output 里没被提到" % (avg * 100))
    else:
        print("条目级覆盖率：input 未使用编号/项目符号，跳过该项检查")

    if mismatched:
        warns.append("以下样本的条目数与短语数对不上（前 %d 条）：" % len(mismatched))
        for i, a, b in mismatched:
            warns.append("    第 %d 条 → input %d 条目 / output %d 短语" % (i, a, b))
    if orphan:
        warns.append("以下短语与原文没有任何共同字符，疑似凭空添加（前 %d 条）：" % len(orphan))
        for i, p in orphan:
            warns.append("    第 %d 条 → 「%s」" % (i, p))
    return warns


# ---------------------------------------------------------------------------
# C. 长度分布直方图
# ---------------------------------------------------------------------------
def histogram(values, bins=10, width=46, title="分布"):
    """纯文本直方图，方便直接贴进终端日志。"""
    if not values:
        return
    lo, hi = min(values), max(values)
    if lo == hi:
        print("%s：全部等于 %d" % (title, lo))
        return
    step = (hi - lo) / bins
    counts = [0] * bins
    for v in values:
        idx = min(bins - 1, int((v - lo) / step))
        counts[idx] += 1
    peak = max(counts) or 1
    print("\n%s（共 %d 条）" % (title, len(values)))
    for b in range(bins):
        left = lo + step * b
        right = lo + step * (b + 1)
        bar = "#" * int(counts[b] / peak * width)
        print("  %7.0f ~ %7.0f | %-*s %d" % (left, right, width, bar, counts[b]))


def check_length(data, cutoff):
    """按字符估算长度；中文场景下 1 字符 ≈ 1 token 是个偏保守的估计。"""
    warns = []
    lens = []
    over = 0
    for item in data:
        if not isinstance(item, dict):
            continue
        total = len(item.get("instruction") or "") + len(item.get("input") or "") \
            + len(item.get("output") or "")
        lens.append(total)
        if total > cutoff:
            over += 1
    if lens:
        lens_sorted = sorted(lens)
        p95 = lens_sorted[min(len(lens_sorted) - 1, int(len(lens_sorted) * 0.95))]
        print("\n三字段合计长度：中位 %d，p95 %d，最长 %d（字符）"
              % (lens_sorted[len(lens_sorted) // 2], p95, lens_sorted[-1]))
        histogram(lens, title="长度直方图")
        if over:
            warns.append("有 %d 条（%.1f%%）超过 cutoff_len=%d，训练时尾部会被截断，"
                         "被截掉的正好是 output —— 要么调大 cutoff_len，要么把长样本拆开"
                         % (over, over / len(lens) * 100, cutoff))
    return warns


# ---------------------------------------------------------------------------
# D. 重复与冲突
# ---------------------------------------------------------------------------
def check_duplicate(data):
    warns = []
    whole = Counter()
    by_input = defaultdict(set)
    for item in data:
        if not isinstance(item, dict):
            continue
        key = (item.get("instruction"), item.get("input"), item.get("output"))
        whole[key] += 1
        by_input[item.get("input")].add(item.get("output"))

    dup = sum(c - 1 for c in whole.values() if c > 1)
    if dup:
        warns.append("完全重复的样本 %d 条 —— 重复会让模型对这部分过拟合" % dup)

    conflict = [k for k, v in by_input.items() if len(v) > 1]
    if conflict:
        warns.append("同一 input 对应多个不同 output 的有 %d 组 —— 标注冲突，模型会学得摇摆" % len(conflict))
    return warns


def main():
    ap = argparse.ArgumentParser(description="指令微调数据集体检")
    ap.add_argument("path", help="数据集 JSON 路径")
    ap.add_argument("--cutoff", type=int, default=1024, help="训练配置里的 cutoff_len")
    ap.add_argument("--strict", action="store_true", help="把警告也当作不通过")
    args = ap.parse_args()

    with open(args.path, "r", encoding="utf-8") as f:
        data = json.load(f)

    print("=" * 62)
    print("数据集：%s" % args.path)
    print("=" * 62)

    errors, warns = check_fields(data)
    if not errors:
        warns += check_coverage(data)
        warns += check_length(data, args.cutoff)
        warns += check_duplicate(data)

    print("\n" + "-" * 62)
    if errors:
        print("致命问题 %d 项：" % len(errors))
        for e in errors[:40]:
            print("  [x] " + e)
    if warns:
        print("警告 %d 项：" % len(warns))
        for w in warns[:60]:
            print("  [!] " + w)
    if not errors and not warns:
        print("全部通过，可以开训。")

    bad = bool(errors) or (args.strict and bool(warns))
    sys.exit(1 if bad else 0)


if __name__ == "__main__":
    main()

$ python3 check_dataset.py qwen_dataset.json --cutoff 1024
==============================================================
数据集：qwen_dataset.json
==============================================================
条目级覆盖率：平均 100.0%，完全覆盖的样本 4/4（100.0%）

三字段合计长度：中位 106，p95 156，最长 156（字符）

长度直方图（共 4 条）
       93 ~      99 | ############################################## 2
       99 ~     106 |                                                0
      106 ~     112 | #######################                        1
      ...
      150 ~     156 | #######################                        1

--------------------------------------------------------------
全部通过，可以开训。

 "qwen_dataset": {
    "file_name": "qwen_dataset.json"
  },

{
  "chat-train": {
    "file_name": "train.jsonl"
  }
}

{"instruction": "提出问题1", "input": "", "output": "对应的答案1"}
{"instruction": "提出问题2", "input": "", "output": "对应的答案2"}

[
  {
    "instruction": "请提取以下内容中的摘要信息",
    "input": "保持身体健康的五个方法：\n\n1. 每天至少饮用8杯水，促进新陈代谢\n2. 每周进行150分钟中等强度运动，如快走或游泳\n3. 保证7-9小时高质量睡眠，避免熬夜\n4. 饮食中增加蔬菜水果比例，减少油炸食品\n5. 定期体检，监测血压、血糖等指标",
    "output": "多喝水、规律运动、充足睡眠、均衡饮食、定期体检"
  },
  {
    "instruction": "请提取以下内容中的摘要信息",
    "input": "提高学习效率的三个技巧：\n\n1. 使用番茄工作法，每25分钟专注后休息5分钟\n2. 建立思维导图整理知识框架\n3. 睡前复习重点内容加强记忆",
    "output": "番茄工作法、思维导图、睡前复习"
  },
  {
    "instruction": "请提取以下内容中的摘要信息",
    "input": "旅行必备物品清单：\n1. 护照/身份证原件及复印件\n2. 便携充电宝和转换插头\n3. 常用药品（退烧药、创可贴）\n4. 轻便折叠雨伞\n5. 分装洗漱用品",
    "output": "证件、充电设备、药品、雨具、洗漱包"
  },
  {
    "instruction": "请提取以下内容中的摘要信息",
    "input": "职场沟通四大原则：\n① 明确沟通目标\n② 使用金字塔表达结构\n③ 注意非语言信号（眼神/姿态）\n④ 及时确认信息理解度",
    "output": "目标明确、结构化表达、非语言交流、信息确认"
  },
  {
    "instruction": "请提取以下内容中的摘要信息",
    "input": "TODO 把待处理的原文贴到这里。要求：\n1. 保留原文的换行与编号，不要压成一行\n2. 每条内容是动宾短语，带细节描述\n3. 长度控制在 cutoff_len 之内，中文按 1 字 ≈ 1 token 估",
    "output": "TODO、顿号分隔的核心短语、必须 100% 覆盖 input 条目、不加原文没有的信息"
  }
]

{
  "_说明": [
    "这份文件对应 LLaMA-Factory 的 data/dataset_info.json。",
    "不要整份覆盖官方文件 —— 官方文件里已有上百个内置数据集条目，",
    "把下面 TODO 之后的键值对追加到文件尾部即可（注意前一条要补逗号）。",
    "键名 = 训练 yaml 里 dataset 字段要填的名字；file_name = data/ 目录下的实际文件名。",
    "正式使用时把本段 _说明 删掉，JSON 里留着它不会报错但没意义。"
  ],

  "qwen_dataset": {
    "file_name": "qwen_dataset.json"
  },

  "TODO_你的数据集名": {
    "file_name": "TODO_你的文件名.json",

    "_可选项1": "数据文件放在 data/ 下时只写文件名；放别处则在训练时用 --dataset_dir 指定目录",
    "_可选项2": "字段名与 alpaca 默认不一致时，用 columns 做映射，例如下面这段",

    "columns": {
      "prompt": "instruction",
      "query": "input",
      "response": "output"
    }
  },

  "chat-train": {
    "file_name": "train.jsonl",
    "_说明": "jsonl 形式的写法：每行一个 {instruction, input, output} 对象，file_name 指向 .jsonl 即可"
  }
}