Datasets:
File size: 10,050 Bytes
d847043 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 | """把问答对拼成训练用的 data/train.jsonl。
python scripts/build_sft.py
- 读 data/pairs/*.jsonl(已经整理好的老数据,base.jsonl 就是之前那 7297 条)
和 data/new/*.jsonl(teacher.py / teacher_hard.py 新出的、verify.py 复核过的)
- 测试库的题一律不要;SQL 在建表语句上跑不通的(表名、列名不存在)丢掉
- 按 (库, 问题) 去重,问题过短的丢掉
- 用 prompt.py 里的格式包装成 messages
- 顺手统计一下查询类型分布,看看数据偏不偏
"""
import argparse
import hashlib
import json
import random
import re
import sqlite3
from collections import Counter, defaultdict
from pathlib import Path
from prompt import build
# 包里脚本在 scripts/,schemas/ data/ 在上一级;GitHub 仓库是平铺的,两种都认
ROOT = Path(__file__).resolve().parent
if not (ROOT / "schemas").is_dir():
ROOT = ROOT.parent
TEST_DBS = {"library", "gym", "hard_retail", "transit"}
OLD_SQLITE_UNSUPPORTED = re.compile(r"(?i)\b(?:right|full)\s+(?:outer\s+)?join\b")
NO_VALUES_SHARE = 0.2 # 这么多样本不带「部分字段的取值」,模型在没给取值时也得会用
# 分类字段的判断:名字、日期、联系方式这类列不算;日期、通配、数字这类字面量不算
NOT_CATEGORY_COL = re.compile(r"date|time|_at$|birth|since|name|title|phone|mobile|email|address|sku|code|_no$|_id$")
NOT_CATEGORY_LIT = re.compile(r"^(\d{4}(-\d\d){0,2}( [\d:]+)?|.*%.*|now|[+-]?\d+ \w+|start of \w+|-?\d+(\.\d+)?|)$", re.I)
NOT_ALIAS = {"on", "where", "join", "left", "right", "inner", "outer", "full", "cross", "natural",
"group", "order", "limit", "having", "union", "using", "as"}
def schema_path(db: str) -> Path:
for p in (ROOT / "schemas").rglob(f"{db}.sql"):
return p
raise FileNotFoundError(db)
def table_columns(ddl: str) -> dict[str, list[str]]:
"""{表: [列, ...]},都转小写,按建表顺序。"""
conn = sqlite3.connect(":memory:")
conn.executescript(ddl)
return {t.lower(): [c[1].lower() for c in conn.execute(f'pragma table_info("{t}")')]
for (t,) in conn.execute("select name from sqlite_master where type='table' order by rowid")}
def category_literals(sql: str, cols: dict[str, list[str]]):
"""找出 SQL 里「分类列 = '值'」「分类列 IN ('值', ...)」,返回 [(表, 列, 值)]。别名按 FROM/JOIN 解析。"""
alias = {}
for t, a in re.findall(r"(?i)\b(?:from|join)\s+(\w+)(?:\s+(?:as\s+)?(\w+))?", sql):
if t.lower() in cols:
alias[t.lower()] = t.lower()
if a and a.lower() not in NOT_ALIAS:
alias[a.lower()] = t.lower()
pairs = re.findall(r"(?:(\w+)\.)?(\w+)\s*(?:=|!=|<>)\s*'([^']*)'", sql)
for a, col, body in re.findall(r"(?i)(?:(\w+)\.)?(\w+)\s+(?:not\s+)?in\s*\(([^()]*)\)", sql):
pairs += [(a, col, lit) for lit in re.findall(r"'([^']*)'", body)]
out = []
for a, col, lit in pairs:
col = col.lower()
if NOT_CATEGORY_COL.search(col) or NOT_CATEGORY_LIT.match(lit):
continue
if a:
t = alias.get(a.lower())
else:
owners = {t for t in alias.values() if col in cols[t]}
t = owners.pop() if len(owners) == 1 else None
if t and col in cols[t]:
out.append((t, col, lit))
return out
def style(lit: str) -> str:
"""值的写法:中文 / 全小写 / 全大写 / 首字母大写。真实库里一列只会用一种写法。"""
if re.search(r"[一-鿿]", lit):
return "zh"
if lit.islower():
return "lower"
if lit.isupper():
return "upper"
return "title"
class ValueHints:
"""训练样本的「部分字段的取值」。训练库没有真实数据,取值只能从训练 SQL 的字面量里攒;
同一列的写法混着用(有的写 'active'、有的写 'Active'、有的写 '已批准'),所以每条样本只列和它
标准答案同一种写法的值,等于每条样本看到的是一个「这列只用一种写法」的库。值太少的借同名列的凑数。"""
def __init__(self, rows: list[dict], cols_of: dict[str, dict[str, list[str]]]):
self.cols_of = cols_of
self.seen = defaultdict(Counter) # (db, 表, 列) -> 值的出现次数
for r in rows:
for t, c, lit in category_literals(r["sql"], cols_of[r["db"]]):
self.seen[(r["db"], t, c)][lit] += 1
# 凑数用:先借同一个库里同名列的值(account.status 借 loan.status),不够再借别的库的
self.same_db = defaultdict(Counter) # (库, 列名, 写法) -> 值
self.by_name = defaultdict(Counter) # (列名, 写法) -> 值
for (db, _t, c), cnt in self.seen.items():
for lit, n in cnt.items():
self.same_db[(db, c, style(lit))][lit] += n
self.by_name[(c, style(lit))][lit] += n
def for_row(self, r: dict) -> dict[str, list[str]] | None:
rng = random.Random(hashlib.md5(f"{r['db']}|{r['question']}".encode()).hexdigest())
if rng.random() < NO_VALUES_SHARE:
return None
used = {(t, c): style(lit) for t, c, lit in category_literals(r["sql"], self.cols_of[r["db"]])}
out = {}
for t, cols in self.cols_of[r["db"]].items():
for c in cols:
cnt = self.seen.get((r["db"], t, c))
if not cnt or len(cnt) > 20: # 没出现过,或者值太散不像分类字段
continue
# 标准答案用到这列就跟它的写法;没用到就用这列最常见的写法
by_style = Counter()
for lit, n in cnt.items():
by_style[style(lit)] += n
want = used.get((t, c)) or by_style.most_common(1)[0][0]
vals = {lit for lit in cnt if style(lit) == want}
for pool, cap in ((self.same_db[(r["db"], c, want)], 5), (self.by_name[(c, want)], 3)):
for lit, _ in pool.most_common():
if len(vals) >= cap:
break
vals.add(lit)
if vals:
out[f"{t}.{c}"] = sorted(vals)
return out or None
def sql_kind(sql: str) -> str:
s = sql.lower()
for key, pat in (
("CTE", r"^\s*with\b"),
("窗口函数", r"\bover\s*\("),
("子查询", r"\(\s*select\b"),
("多表连接", r"\bjoin\b"),
("分组", r"\bgroup by\b"),
("排序", r"\border by\b"),
("取前几", r"\blimit\b"),
("聚合", r"\b(count|sum|avg|max|min)\s*\("),
):
if re.search(pat, s):
return key
return "简单筛选"
def main() -> None:
ap = argparse.ArgumentParser()
ap.add_argument("--out", default="data/train.jsonl")
# 消融用(run_paper.sh):--skip 去掉文件名匹配的几份数据,--add 换上别的问答对文件
ap.add_argument("--skip", default="", help="正则,匹配文件名(不带 .jsonl)的不读,比如 '_r2_para$'")
ap.add_argument("--add", nargs="*", default=[], help="额外读的问答对 jsonl")
args = ap.parse_args()
files = sorted((ROOT / "data" / "pairs").glob("*.jsonl")) + sorted((ROOT / "data" / "new").glob("*.jsonl"))
files = [p for p in files if not (args.skip and re.search(args.skip, p.stem))] + [ROOT / a for a in args.add]
rows: list[dict] = []
for p in files:
for line in p.read_text(encoding="utf-8").splitlines():
if not line.strip():
continue
r = json.loads(line)
if len(r.get("question", "")) < 4 or not r.get("sql") or r["db"] in TEST_DBS:
continue
rows.append(r)
# 库重新生成过而题没跟着重出,就会有引用不存在的表/列的 SQL,以前混进去过 36 条
empty_dbs: dict[str, sqlite3.Connection] = {}
broken = 0
seen = set()
keep = []
for r in rows:
key = (r["db"], re.sub(r"\s+", "", r["question"]))
if key in seen:
continue
if r["db"] not in empty_dbs:
empty_dbs[r["db"]] = sqlite3.connect(":memory:")
empty_dbs[r["db"]].executescript(schema_path(r["db"]).read_text(encoding="utf-8"))
empty_dbs[r["db"]].execute("PRAGMA query_only = ON")
# RIGHT / FULL JOIN 要 SQLite 3.39+:Mac 上能跑,RunPod 镜像的 Python 带的是 3.37,评测和别人的环境都可能更老
if OLD_SQLITE_UNSUPPORTED.search(r["sql"]):
broken += 1
continue
try:
empty_dbs[r["db"]].execute(r["sql"].rstrip(";")).fetchall()
except sqlite3.Error:
broken += 1
continue
seen.add(key)
keep.append(r)
ddls = {db: schema_path(db).read_text(encoding="utf-8") for db in {r["db"] for r in keep}}
hints = ValueHints(keep, {db: table_columns(ddl) for db, ddl in ddls.items()})
with_values = 0
out = ROOT / args.out
out.parent.mkdir(parents=True, exist_ok=True)
with out.open("w", encoding="utf-8") as f:
for r in keep:
values = hints.for_row(r)
with_values += values is not None
msgs = build(ddls[r["db"]], r["question"], values)
msgs.append({"role": "assistant", "content": r["sql"].rstrip(";") + ";"})
f.write(json.dumps({"messages": msgs, "db": r["db"]}, ensure_ascii=False) + "\n")
kinds = Counter(sql_kind(r["sql"]) for r in keep)
dbs = Counter(r["db"] for r in keep)
print(f"写好了 {len(keep)} 条 → {out}(原始 {len(rows)} 条,跑不通 {broken},去重 {len(rows)-len(keep)-broken})")
print(f"带「部分字段的取值」的 {with_values} 条({with_values / len(keep):.0%})")
print("库分布:", dict(sorted(dbs.items(), key=lambda x: -x[1])))
print("类型分布:", dict(kinds.most_common()))
if __name__ == "__main__":
main()
|