🏠 总目录📚 本教程 17 · 版本与血缘 ← →
📑 本页目录(点开跳转)

17 · 数据版本与血缘

怎样重现三个月前用过的那份数据?

一句话 旧数据和当时的规则都还在,才能先核对输入指纹,再按版本重跑。

读完会做:重放旧版并核对回填

先修:分区、去重、按日求和

事故、成本与收益数字是教学情景;阈值和经验估计需用自己的证据核验。


🎯 一句话

模型的复现依赖代码、数据、参数和环境四项;任何一项缺失,结果都可能变。先从训练所用的数据检查。


🔍 一、先花五分钟做个自测

随便挑一个三个月前上线的模型,回答这六个问题。

逐项核对

代码、参数、环境和数据都要能回溯。这里先找出当时用的数据,核对它还在、内容也一致。

  • ① 训练用的是哪张表、哪个分区/快照?

  • ② 那份数据现在还在吗?内容和当时【逐行相同】吗? ⭐ 大多数人卡在这一条

  • ③ 是哪段 SQL 产出的?那段 SQL 从那天起改过吗?

  • ④ 过滤掉了哪些行?(去重规则、时间窗、黑名单)

  • ⑤ 当时的行数是多少?现在重跑是多少?

  • ⑥ 现在重跑一遍,能得到【指标相同】的模型吗?


📦 二、四种版本化方案:成本、粒度、适用规模

以 200 GB、日变化 5% 的宽表为例。日变化率是每天变化的字节数除以表总字节数。以下成本按 365 日、十进制 TB 估算;分区方案另列只保留 90 天增量的情景。

方案 怎么做 一年存储 回溯粒度 适用规模 ⚠️ 主要痛点
全量快照 每次训练前整表拷一份,路径带日期 以 200 GB、日变化 5%(变化 10 GB ÷ 200 GB)为例:200 GB × 365 ≈ 73 TB 完美 表 < 10 GB,或"只在正式发版时存" 贵得离谱,通常撑不过三个月就被清理
时间戳分区 按 dt= 分区,只写当天增量,永不覆盖 若只保留 90 日增量,200 GB 基底 + 90 × 10 GB = 1.1 TB;全年增量加基底约 3.85 TB 分区级 ⭐ 绝大多数团队的默认答案 💀 回填(backfill)会静默改写历史分区
内容寻址哈希 按内容块算 hash 存对象存储,重复块只存一次 200 GB 基底 + 364 × 10 GB 变化量 ≈ 3.8 TB(按块充分复用) 文件/块级 大表 + 需要严格回溯(金融、医疗) 需要一层元数据服务,运维有成本
DVC 类工具 本质是内容寻址 + git 里只存指针文件 同上 文件级 ⭐ 中小团队、实验型项目 大文件性能一般;团队得真的会用 git
日变化率先考虑什么
低于 2%内容寻址,变化率低且块边界稳定时复用更多。
2%–20%先试时间戳分区并定期做全量快照,例如每月 1 号。
高于 20%先排查口径变化,再评估实际需要的存储。

先保留旧版。分区不覆盖,训练清单记上游分区和指纹。比例阈值和收益是本课经验示意;按账本例子看新版本怎样保住旧结果。


🔑 三、指纹:用一行字符串锁住一份数据

保留版本之后,用指纹核对同一规范下的输入内容。

把 (A,1)、(B,2) 换成 (A,2)、(B,1),各列值相同,同行配对已经改变。逐列 XOR 还会抵消成对重复值。总指纹排序完整行、保留重复次数;per_column 只辅助定位列值。

import hashlib
import json
import math
import numpy as np
import pandas as pd


def logical_fingerprint(df: pd.DataFrame, float_dp: int = 6) -> dict:
    """小表演示:按列名规范化整行,排序后保留每一行(含重复行)。"""
    if not df.columns.is_unique or any(type(c) is not str for c in df.columns):
        raise ValueError("列名必须是唯一字符串")
    if type(float_dp) is not int or not 0 <= float_dp <= 15:
        raise ValueError("float_dp 必须是 0 到 15 的整数")
    cols = sorted(df.columns)

    def normalize(value):
        if isinstance(value, np.generic):
            value = value.item()  # NumPy 数值标量转成 Python 标量
        if value is None or value is pd.NA:
            return ["null"]
        if isinstance(value, float):
            if math.isnan(value):
                return ["null"]
            if not math.isfinite(value):
                raise ValueError("不支持无限值")
            value = round(value, float_dp)
            return ["float", format(0.0 if value == 0 else value, f".{float_dp}f")]
        if type(value) in (str, bool, int):
            return [type(value).__name__, value]
        raise TypeError("示例只支持字符串、布尔、整数、有限浮点和空值")

    def encode(value):
        return json.dumps(value, ensure_ascii=False, separators=(",", ":"))

    def digest(value):
        return hashlib.sha256(encode(value).encode("utf-8")).hexdigest()

    rows = [[normalize(v) for v in row]
            for row in df[cols].itertuples(index=False, name=None)]
    payload = {"columns": cols, "n_rows": len(df), "float_dp": float_dp,
               "rows": sorted(encode(row) for row in rows)}  # 不转 set,不丢重复次数
    return {
        "fingerprint": digest(payload),  # 清单保存完整 SHA-256;展示时可以截短
        "n_rows": len(df), "n_cols": len(cols),
        "per_column": {c: digest(sorted(encode(row[i]) for row in rows))
                       for i, c in enumerate(cols)},  # 仅定位列值变化,不能证明行配对
    }


a = pd.DataFrame({"id": ["A", "B"], "price": [1, 2]})
b = pd.DataFrame({"id": ["A", "B"], "price": [2, 1]})
print("换了同行配对,总指纹相同吗:",
      logical_fingerprint(a)["fingerprint"] == logical_fingerprint(b)["fingerprint"])  # False
print("各列值仍相同吗:",
      logical_fingerprint(a)["per_column"] == logical_fingerprint(b)["per_column"])  # True

⚠️ 这是小表的内容指纹,会把整表放入内存排序;先合并待比较的分片再计算。示例只接收唯一字符串列名,以及字符串、布尔、整数、浮点与空值:None / pd.NA / NaN 统一为空,浮点先按 float_dp 舍入、固定小数位并合并正负零;整数与浮点仍区分。时间戳请先统一 UTC 并转成约定字符串,嵌套对象和无限值会拒绝;dtype、时区和规范化规则版本另记清单,不能用这个摘要代替 schema 校验。

哪些细节要统一?

坑 现象 解法
浮点精度 同样的数据,两台机器算出不同指纹 ⭐ 先 round 到固定小数位再 hash
列顺序 SELECT * 在 schema 变更后顺序变了 按列名排序后再 hash
时区 同一个时间戳存成 naive / aware 两种 给无时区值(naive)声明源时区,再统一转 UTC。schema、类型、时区和规范化版本另记
行顺序 分布式任务每次产出顺序不同 ⭐ 规范化整行后排序,保留重复行次数
小表与类型示例整表进内存排序合并待比较的分片;None / pd.NA / NaN 同为空,固定小数位、合并正负零、区分整浮型;列名为唯一字符串,float_dp 取 0–15 的整数。嵌套对象与无限值拒绝,时间戳先转为约定字符串。

🧾 四、血缘要记什么

清单记录输入和当时的处理条件,好让别人能照着重跑。

必须记 为什么
上游表 + 分区/快照 ID 最基本的一条
每个上游的指纹 ⭐ 💀 只记表名是不够的 —— 分区名没变但内容变了,就是最常见的死法
产出这份数据的 SQL / 代码的 commit 逻辑本身也会变
参数(时间窗、阈值、采样率、随机种子) ⭐ 随机种子是最常被漏掉的一个
过滤条件 ⭐ "去掉了哪些行"往往写在 SQL 里,但没人会去读三个月前的 SQL
数据截止时间(不是任务运行时间)⭐ 💀 任务重跑了三次,运行时间不同但数据截止时间相同 —— 混淆这两个会直接导致误判
行数 / 各列空值率 便宜的健康检查,指纹对不上时先看这两个
触发方式与执行人 排查"这份数据是谁在什么情况下造出来的"

把运行清单(run manifest)和产出物放在同一目录,文件名用 _MANIFEST.json。示例摘要已缩短,实际保存完整指纹。

{
  "run_id": "train_credit_v37_20240131_0412",
  "produced_at_utc": "2024-01-31T04:12:38Z",
  "data_cutoff_utc": "2024-01-31T00:00:00Z",
  "code": {"repo": "risk-models", "commit": "9f2c1ab", "entry": "jobs/build_train.py"},
  "params": {"window_days": 180, "neg_sample_rate": 0.15, "seed": 20240131},
  "filters": ["status != 'test'", "apply_time < data_cutoff", "dedup by (uid, apply_date)"],
  "inputs": [
    {"table": "dw.user_profile_wide", "partition": "dt=2024-01-31",
     "fingerprint": "3a91f0c7d2be4155", "n_rows": 8421339},
    {"table": "dw.repay_label", "partition": "dt=2024-01-31",
     "fingerprint": "77c0be14aa39d802", "n_rows": 3110284}
  ],
  "output": {"path": "s3://ds/train/credit_v37/", "fingerprint": "b5e2149c8f0a7731",
             "n_rows": 3110284, "n_cols": 214}
}

清单跟产出走。平台迁移后,仍可从产出位置找到使用的分区、指纹和规则。下面看清单怎样支撑版本重放。

同一份账本,重放 V1 与 V2

D 日的支付报表是 150 元。隔天又收到一条 100 元支付消息和一笔发生在 D 日的迟到退款。要解释旧报表和新报表,必须同时问:钱是哪天发生的?当时已收到哪些事件?

D = 1 月 2 日(2026 年)。用事件日确定报表日期,到达日记录消息什么时候送到。本例每批成功提交一次就给一个递增版本,V1、V2 就是批次 1、2 提交后的视图。金额以整数元计。先把原始正金额变成带符号金额:支付记正,退款记负。可回顾事件时间与处理时间。

两批原始输入,金额单位为元
到达批次事件键事件日到达日类型与原始金额
1pay-100DD支付 100
1pay-050DD支付 50
1pay-040D−1D−1支付 40
2pay-100DD+1支付 100(重投)
2refund-030DD+1退款 30(迟到)

账本按事件 ID 识别一笔事实。业务载荷是事件日、类型、带符号金额;到达日和批次是接收信息。同 ID 同载荷时沿用原行及首次版本 first_version。同 ID 异载荷属于冲突,本批新增的所有行跟着事务一起回滚。更正实际发生的业务应另发新事件,保留原事实。这里的先修是唯一性与对账。

要重放 V1,只取首次版本不晚于 1 的行;要重放 V2,就取不晚于 2 的行。再按事件日分组,求带符号金额之和,并数参与的账本行。相关用法见按键分组。

同一份追加账本的两版报表
报表日V1V2
D100 + 50 = 150 元,2 条100 + 50 − 30 = 120 元,3 条
D−140 元,1 条40 元,1 条
重投pay-100 首次版本为 1同 ID 的事件日、类型、带符号金额相同,仍为 1;首次到达日也保留。批次和到达日不参与比较
回放条件只读已提交版本;取 first_version ≤ V 的行,再按事件日(非到达日)求和与计数。提交版本递增,保留历史输入、规则和版本元数据。超出保留期且缺原输入时,旧版不可重放。冻结 V1 报表和输入指纹后再追加,V1 重跑的指纹与报表均保持相同。回填按契约生成新版本。

清单随报表记下输入版本与整行指纹、事件日规则(生产中也要记录时区)、金额与去重口径、代码修订、核对结果以及保留期。旧版清单和凭证固定;新报表按新版本重算。如果需要的输入或规则已丢失,日期、摘要和新报表只能帮助诊断。指纹的含义见整行指纹。

依据:Delta Lake 时间旅行与留存、SQLite 事务、OpenLineage 数据集版本。

三道检查各抓什么?

预期独立从另存的原始夹具计算:先按事件键取首次事实,再用事件日与符号约定手算或用独立程序求和。这样,被测的账本或 SQL 出错时,预期不会跟着变化。表内的向右箭头表示同键同版本下「预期 → 实际」。

三类检查,给出实际观察的失败行
检查层次键/版本注入故障时的预期 → 实际
转换单测refund-030 / V2退款符号反转:−30 → +30 元。
装载到报表对账D / pay-100 / V2汇总原始消息漏去重:120 元、3 条 → 220 元、4 条(100 + 50 + 100 − 30)。
装载冲突回滚pay-100 / 尝试提交 V3同 ID 本应 +100 元,冲突载荷是 +101 元,本批拒绝。已插入的 before-conflict 回滚后也查不到,V3 未提交。随后把原 V2 整批重投到 V3,旧行和首次版本相同,报表仍是 120 元、40 元。
回填回归D、D+1 / refund-030 / V2误按到达日归并:D 日 120 元、3 条 → 150 元、2 条;D+1 本应无行 → −30 元、1 条。
回填回归D / pay-100 / V1故意改写旧输入 +100 → +101 元;V1 整行指纹随之改变,旧报表 150 元、2 条 → 151 元、2 条。

转换单测用固定输入检查单步逻辑,数据测试在装载后检查事件唯一性与汇总是否对得上,回填回归用冻结的旧版本结果检查历史有没有受影响。依据:dbt 单元测试、dbt 数据测试。

工程验证:运行 SQLite 示例

SQLite 本地模拟。Delta 回溯依赖历史日志和文件;dbt 的单测与数据测试按不同范围执行。

保存下面整段为 replay.py,运行 python replay.py。用 Python 标准库在内存创建一个 SQLite 账本,并另存一份原始输入与 V1 凭证到临时目录。实际发布时,要将凭证和所引用的输入固定保存到产出目录或受保留期管理的位置。SQLite 模拟的是追加、事务和版本过滤。Delta Lake 的时间旅行依赖实际日志与数据文件留存,它的 txnAppId/txnVersion 识别提交级重试,事件 ID 比较则处理这里的业务重投。这个例子无需部署 Delta 或 dbt。依据:Delta Lake 幂等写入、Python SQLite 事务控制。

  1. append_batch 用写事务比较载荷,只插新键。冲突抛错时,先前插入的事件与批次记录一并撤回。
  2. replay 用 first_version <= V 筛出当时可见的事件,再按日期求金额和行数。
  3. oracle 读取另存夹具独立求预期。每行检查都会打印键、版本、预期和实际;FAIL (injected) 表示故意注入的错误已被断言抓住。
SQLite 完整验证脚本
import json
import sqlite3
from hashlib import sha256
from contextlib import closing
from pathlib import Path
from tempfile import TemporaryDirectory

D0, D, D2 = "2026-01-01", "2026-01-02", "2026-01-03"
# 每条输入:事件 ID、事件日、类型、无符号金额(整数元)、到达日。
RAW_INPUT = """{
  "1": [
    ["pay-100", "2026-01-02", "pay", 100, "2026-01-02"],
    ["pay-050", "2026-01-02", "pay", 50, "2026-01-02"],
    ["pay-040", "2026-01-01", "pay", 40, "2026-01-01"]
  ],
  "2": [
    ["pay-100", "2026-01-02", "pay", 100, "2026-01-03"],
    ["refund-030", "2026-01-02", "refund", 30, "2026-01-03"]
  ]
}"""


def signed_amount(kind, amount):
    return -amount if kind == "refund" else amount


def append_batch(db, version, rows):
    db.execute("BEGIN IMMEDIATE")
    try:
        latest = db.execute("SELECT coalesce(max(version), 0) FROM batches").fetchone()[0]
        if version <= latest:
            raise ValueError(f"version={version} must exceed {latest}")
        db.execute("INSERT INTO batches VALUES (?)", (version,))
        inserted = []
        for event_id, day, kind, amount, arrival in rows:
            payload = (day, kind, signed_amount(kind, amount))
            old = db.execute(
                "SELECT event_day, kind, amount FROM ledger WHERE event_id = ?",
                (event_id,),
            ).fetchone()
            if old is None:
                db.execute("INSERT INTO ledger VALUES (?, ?, ?, ?, ?, ?)",
                           (event_id, *payload, arrival, version))
                inserted.append(event_id)
            elif old != payload:
                raise ValueError((event_id, version, old, payload, tuple(inserted)))
        db.execute("COMMIT")
    except Exception:
        db.execute("ROLLBACK")
        raise


def replay(db, version, by_arrival=False):
    if db.execute("SELECT 1 FROM batches WHERE version = ?", (version,)).fetchone() is None:
        raise ValueError(f"V{version} 未提交")
    # 只允许在下列两个预先定义的列名里选择。
    day = "arrival_day" if by_arrival else "event_day"
    return dict((key, (amount, count)) for key, amount, count in db.execute(f"""
        SELECT {day}, SUM(amount), COUNT(*)
        FROM ledger WHERE first_version <= ?
        GROUP BY {day}
    """, (version,)))


def fingerprint(rows):
    # 这是一套固定字段、固定顺序、只有字符串和整数的夹具。
    payload = json.dumps(sorted(rows), separators=(",", ":")).encode("utf-8")
    return sha256(payload).hexdigest()


def snapshot(db, version):
    rows = db.execute("SELECT * FROM ledger WHERE first_version <= ?", (version,))
    return fingerprint(rows)


def oracle(frozen, version):
    # 只读另存原始数据,用 Python 按事件 ID 选首次出现,再分组。
    # 这里不调用装载、符号转换或重放函数。
    unique = {}
    for batch in range(1, version + 1):
        for key, day, kind, unsigned, _arrival in frozen[str(batch)]:
            unique.setdefault(key, (day, unsigned * {"pay": 1, "refund": -1}[kind]))
    groups = {}
    for day, amount in unique.values():
        groups.setdefault(day, []).append(amount)
    return {day: (sum(amounts), len(amounts)) for day, amounts in groups.items()}


def check(label, key, version, expected, actual):
    row = f"{label} key={key} V{version} expected={expected} actual={actual}"
    if actual != expected:
        raise AssertionError(row)
    print(f"PASS {row}")


def expect_failure(label, key, version, expected, actual):
    try:
        check(label, key, version, expected, actual)
    except AssertionError as error:
        print(f"FAIL (injected) {error}")
    else:
        raise AssertionError(f"故障未被检出:{label}")


def check_report(version, expected, actual):
    for day in sorted(expected.keys() | actual.keys()):
        check("replay", day, version, expected.get(day), actual.get(day))


def main(original_path):
    # 测试数据源与被测数据库隔离。夹具由 RAW_INPUT 固定,保存后只读。
    original_path.write_text(RAW_INPUT, encoding="utf-8")
    frozen = json.loads(original_path.read_text(encoding="utf-8"))
    batches = json.loads(RAW_INPUT)
    expected_v1, expected_v2 = oracle(frozen, 1), oracle(frozen, 2)
    with closing(sqlite3.connect(":memory:", isolation_level=None)) as db:
        db.executescript("""
            CREATE TABLE batches (version INTEGER PRIMARY KEY);
            CREATE TABLE ledger (
                event_id TEXT NOT NULL PRIMARY KEY,
                event_day TEXT NOT NULL, kind TEXT NOT NULL, amount INTEGER NOT NULL,
                arrival_day TEXT NOT NULL, first_version INTEGER NOT NULL
            );
        """)
        refund = next(row for row in frozen["2"] if row[0] == "refund-030")
        expected_refund = -refund[3]
        actual_refund = signed_amount(refund[2], refund[3])
        check("refund-sign", refund[0], 2, expected_refund, actual_refund)
        def broken_transform(kind, amount):
            return -signed_amount(kind, amount)

        expect_failure("refund-sign", refund[0], 2, expected_refund,
                       broken_transform(refund[2], refund[3]))

        append_batch(db, 1, batches["1"])
        check_report(1, expected_v1, replay(db, 1))
        original_v1 = [(key, day, kind, amount, arrival, 1)
                       for key, day, kind, amount, arrival in frozen["1"]]
        expected_hash = fingerprint(original_v1)  # V1 三行都是正金额支付。
        check("input fingerprint", "ledger", 1, expected_hash, snapshot(db, 1))
        receipt = original_path.with_name("v1-receipt.json")
        receipt.write_text(json.dumps({"version": 1, "rule": "event-day-v1",
                                       "input_sha256": expected_hash,
                                       "report": expected_v1}), encoding="utf-8")
        append_batch(db, 2, batches["2"])
        check_report(2, expected_v2, replay(db, 2))
        released = json.loads(receipt.read_text(encoding="utf-8"))
        old_report = {day: tuple(value) for day, value in released["report"].items()}
        check_report(1, old_report, replay(db, 1))
        check("input fingerprint", "ledger", 1, released["input_sha256"], snapshot(db, 1))

        # V2 重投到达日变了。首次到达日期和首次版本仍来自独立的原始 V1。
        first_arrival = frozen["1"][0][4]
        first_ingest = db.execute(
            "SELECT arrival_day, first_version FROM ledger WHERE event_id = ?",
            ("pay-100",),
        ).fetchone()
        check("retry first ingest", "pay-100", 2, (first_arrival, 1), first_ingest)

        # 错误路径越过去重账本,直接汇总 V1/V2 的原始入站行。
        duplicated = [signed_amount(kind, amount)
                      for batch in batches.values()
                      for _key, day, kind, amount, _arrival in batch if day == D]
        expect_failure("no dedup", f"{D}/pay-100", 2, expected_v2[D],
                       (sum(duplicated), len(duplicated)))

        # 错误回填按到达日分组。比较键的并集,新增的空预期日期也会报警。
        wrong_days = replay(db, 2, by_arrival=True)
        for day in sorted(expected_v2.keys() | wrong_days.keys()):
            expected, actual = expected_v2.get(day), wrong_days.get(day)
            if day == D0:
                check("arrival unaffected", day, 2, expected, actual)
            else:
                expect_failure("arrival grouping", f"{day}/refund-030",
                               2, expected, actual)

        # V3 在插入新事件后遇到冲突,整批回滚。
        bad_batch = [("before-conflict", D, "pay", 10, D2),
                     ("pay-100", D, "pay", 101, D2)]
        all_rows = "SELECT * FROM ledger ORDER BY event_id"
        before = db.execute(all_rows).fetchall()
        try:
            append_batch(db, 3, bad_batch)
        except ValueError as error:
            conflict, version, saved, incoming, staged = error.args[0]
            pay = frozen["1"][0]
            check("conflicting event", conflict, version,
                  (pay[1], pay[2], pay[3]), saved)
            print(f"REJECT key={conflict} V{version} expected={saved} actual={incoming}")
            check("staged before conflict", conflict, version, ("before-conflict",), staged)
        else:
            raise AssertionError("异载荷批次错误提交")
        remaining = db.execute(
            "SELECT event_id FROM ledger WHERE event_id = ?", ("before-conflict",)
        ).fetchone()
        check("rollback new event", "before-conflict", 3, None, remaining)
        check("rollback entire ledger", "all events", 3, before, db.execute(all_rows).fetchall())
        check("rollback version", "batches", 3, [(1,), (2,)],
              db.execute("SELECT version FROM batches ORDER BY version").fetchall())

        # 再把 V2 的原始事件完整投递到下一批,账本和报表保持原样。
        try:
            replay(db, 3)
        except ValueError as error:
            check("uncommitted version", "batches", 3, "V3 未提交", str(error))
        else:
            raise AssertionError("回放误读了未提交的 V3")
        append_batch(db, 3, batches["2"])
        check("whole-batch retry", "all events", 3, before, db.execute(all_rows).fetchall())
        check_report(3, expected_v2, replay(db, 3))

        # 只在演示尾部故意绕开追加纪律,改写旧输入后再次检查历史凭证。
        db.execute("UPDATE ledger SET amount = 101 WHERE event_id = ?", ("pay-100",))
        amount = db.execute(
            "SELECT amount FROM ledger WHERE event_id = ?", ("pay-100",)
        ).fetchone()[0]
        expect_failure("overwritten input", "pay-100", 1, frozen["1"][0][3], amount)
        expect_failure("overwritten fingerprint", "ledger/pay-100", 1,
                       released["input_sha256"], snapshot(db, 1))
        expect_failure("overwritten report", f"{D}/pay-100", 1,
                       old_report[D], replay(db, 1)[D])


if __name__ == "__main__":
    with TemporaryDirectory() as folder:
        main(Path(folder) / "frozen-input.json")

☠️ 五、只存代码不存数据的两种死法

什么变了怎样保住旧版
上游被覆盖或过期INSERT OVERWRITE 或 90 天保留期都可能令旧数据消失。让产出所用版本的保留期覆盖追溯窗口,确认历史文件也留存。
表名、行数、schema 都相同,内容口径变了检查整行指纹与口径版本。修正历史数据时写新分区或新版本,冻结旧分区与审计记录。

例如“income_verified 算错了,已经修好并回填历史”。变更可能让当前报表更准,原地写回却会破坏旧模型的训练依据。


💀 六、教学事故情景(出处待核实)

某消费信贷模型 v37 在 2 月上线。10 月问询要求解释 3 月 12 日的拒绝决策,并证明没用禁用字段。团队有 git commit、镜像摘要、超参和权重,缺当时的训练快照。

时间 事件
1 月 31 日 用 dw.user_profile_wide 的 dt=2024-01-31 分区训练,该表保留期 90 天
3 月 数据团队修正 income_verified 的口径:从"近 6 个月流水"改成"近 12 个月",并 backfill 了全部历史分区。分区名没变、行数没变、schema 没变
10 月 监管要求复现。原始分区早已过期被清理,只能用当前口径重建一份"等价数据"
复现结果 重跑模型 AUC 0.7412,原始记录 0.7389;Top-10 特征重要性里 3 个换了位次
💀 关键 对那位申请人,重跑模型给出的分数是 0.44,原始记录是 0.31,审批阈值 0.35 —— 重跑出来的模型会批准他
观察情景细节
错过预警90 天保留期短于 24 个月追溯期;回填无新分区和通知;血缘平台只记表名,漏分区指纹和口径版本;重训 AUC 原本就在 0.73–0.75 波动。
整改投入2 名工程师和 1 名合规人员投入 6 周,咨询与法务约 86 万元;下线 5 周回退旧规则,通过率 −11%,少放款约 2.3 亿元,估算利息少 340 万元。
快照支出23 个模型补存共 41 TB,年成本约 12 万元。单模型事前一年约 5000 元;上述咨询和利息损失合计约 426 万元(400 多万元)。
缺失 补上之后
训练数据没有快照 💀 ⭐ 每次正式发版的训练集做一次内容寻址快照(不是每次实验都做)。日变化率 5%,增量存储可控
保留期短于追溯期 ⭐ 建一条硬规则:任何进过生产模型的数据,保留期 ≥ 监管追溯期,并把这条写进数据契约(第 03 章)
backfill 原地改写 💀 禁止原地 backfill。改口径必须写新分区或加版本后缀,旧分区冻结
血缘只记表名 manifest 里必须有每个上游的指纹 + 行数 + 数据截止时间,缺一项不许发版
只看聚合指标 ⭐ ⭐ 复现校验不看 AUC,看个体分数:抽 1000 条样本,比较新旧模型打分,|Δscore| > 0.02 的比例 > 1% 就算复现失败
没有复现演练 每季度随机抽一个线上模型做"复现演练",当作消防演习

AUC 只差 0.0023(0.7412 − 0.7389),该人的分数却从 0.31 升至 0.44,差 0.13 并跨过 0.35。复现检查还要按事先声明的阈值核对个体结果。


🤝 七、和《模型上线之后 17》的分工

模型上线之后 · 17 数据这一关 · 17(本章)
管什么 代码、参数、环境、模型权重、推理链路 ⭐ 数据本身
核心问题 「这个预测是哪个模型版本给出的?」 「这个模型是哪份数据训出来的?」
典型手段 模型注册表、镜像 digest、请求级版本打点 分区不覆盖、内容指纹、run manifest
典型死法 加载了错误的模型版本 💀 上游被覆盖 / 被静默 backfill
谁负责 通常是算法工程 / MLOps 通常是数据工程 —— ⚠️ 所以最容易两边都以为对方管了

谁发版谁在模型卡登记训练数据指纹,对应清单的 inputs[].fingerprint。缺这项时先补证据。


🪜 八、按团队规模分级实施

级别 做什么 成本 什么时候升级到下一级
L0(1–3 人) ⭐ 分区永不覆盖 + 训练脚本把上游分区名打进日志 几乎为零 有第二个人需要复现你的结果时
L1(3–10 人) 加 _MANIFEST.json:分区名 + 指纹 + 行数 + commit + 参数 半天工程量 ⭐ 性价比最高的一级 模型进了生产、有回溯要求时
L2(生产 / 受监管) 正式发版时做内容寻址快照;保留期对齐追溯期;季度复现演练 存储 + 一条流程 数据集数量多到人管不过来时
L3(数十个数据集) 上 DVC / lakeFS / Delta 之类的工具,接血缘平台 一个人长期维护 —

先用 L1 的产出清单解决常见留存与重跑问题,再按生产审计或管理规模升级。半天、80% 和剩余 20% 是课内估算,实际成本与收益需测量。


🔗 这一章连到哪里

去哪 为什么
模型上线之后 17 版本回溯与可复现 ⭐ 成对的另一半:那边管代码/参数/环境/模型权重,这边只管数据。四项缺一不可,是短板效应
模型上线之后 16 重训练 每次重训都在产生一份新的训练数据版本 —— 重训频率越高,manifest 越重要
模型上线之后 19 合规审计与模型卡 ⭐ 案例里监管要的东西。把「上游分区指纹」列进模型卡必填项,就是这两章的接口
AI基础设施 22 数据管线与存储 分区、对象存储、内容寻址的工程实现细节
数据泄漏的七种来源 「数据截止时间 vs 任务运行时间」混淆,在那一章里是一种泄漏,在这一章里是一种不可复现
SQL 查询这一关 06 CTE 与递归查询 ⭐ 成对的另一半:本章 owns「血缘该记什么」,那一章 owns「记下来之后怎么查」——本章第四节那个 inputs 数组就是它第四节那张 edges 表。⚠️ 没有递归 CTE,「这份训练数据的全部上游是谁」在纯 SQL 里根本表达不出来

✅ 检查点

  1. 五分钟自测的六个问题是什么?大多数团队卡在哪一条?
  2. 为什么说"代码都在 git 里"救不了可复现?这四项是什么关系?
  3. 四种版本化方案在「200 GB 表、日变化率 5%」下一年各要多少存储?各自的主要痛点是什么?怎么用日变化率选方案、超过 20% 说明什么?
  4. 逻辑指纹为什么要按列名排序、要规范化浮点、要排序完整行并保留重复次数?per_column 能定位什么、不能证明什么?
  5. 血缘里最容易漏的三项是什么?为什么 manifest 要放在产出物旁边而不是血缘平台里?
  6. 只存代码不存数据的两种死法是什么?为什么说 backfill "长得像修 bug"?纪律是什么?
  7. 信贷那个事故里,重跑的 AUC 和原始差多少?那位申请人的分数差多少?为什么说前者"没差别"而后者"完全不同"?
  8. 那个事故的四条"没被发现"的原因里,哪一条最容易被忽悠过去?代价一共多少、如果当初就存快照要花多少?
  9. 本章和《模型上线之后 17》怎么分工?为什么这个边界特别容易出事、怎么解决?
  10. 分级实施表里,哪一级性价比最高、要多少工程量、能解决多少问题?
  11. 为什么同一份账本既能重放 D 日的 150 元,又能得到 120 元?如果退款只按到达日记,会在哪一天对不上?
👀 答案
  1. ①用了哪张表哪个分区 ②那份数据现在还在吗、内容逐行相同吗 ③是哪段 SQL 产出的、改过吗 ④过滤掉了哪些行 ⑤行数是多少 ⑥现在重跑能得到指标相同的模型吗。大多数人卡在第 ②条 —— 上游表是 INSERT OVERWRITE 的,或者保留期太短。
  2. 因为 模型 = f(代码, 参数, 环境, 数据),前三项 git/yaml/镜像都解决了,数据那一格是一张每天被覆盖的表。这四项是短板效应,不是加权平均 —— 前三项做到 100 分,有一项不可回溯,总分还是 0。
  3. 全量快照 ≈ 73 TB(贵到撑不过三个月就被清);时间戳分区 ≈ 1.1 TB(💀 痛点是 backfill 会静默改写历史分区);内容寻址 ≈ 3.8 TB(需要一层元数据服务);DVC 类同内容寻址(大文件性能一般,且团队得真的会用 git)。选型看 日变化率 = 每天真正变了的字节 / 全表字节:<2% 内容寻址几乎免费;2%–20% 时间戳分区 + 每月一次全量快照;>20% 说明数据本身在剧烈变化,通常是口径不稳定,先去问"为什么",这不是存储问题。
  4. 排序列名 → 不受列顺序影响;按约定精度规范化浮点 → 忽略约定范围内的小差异;排序完整行且保留重复次数 → 不受行顺序影响,也不丢字段配对与重复数量。per_column 帮你定位列值变化;如果只是同行配对改变,它可以全部不变,所以不能代替总指纹。
  5. 最容易漏的三项:过滤条件(写在 SQL 里但没人会去读三个月前的 SQL)、数据截止时间(不是任务运行时间,任务重跑三次运行时间不同但截止时间相同)、随机种子。manifest 要放产出物旁边(_MANIFEST.json),因为💀 血缘系统的存活率比数据文件低得多 —— 它可能换域名、换负责人或已经下线。
  6. A:上游被覆盖(OVERWRITE 或保留期到期),连"当时是什么"都拿不到;B:上游还在但语义变了(口径改动 + 回填历史),分区名/行数/schema 全没变,没有指纹的话这个问题无法被发现也无法被证明。backfill 长得像修 bug 是因为它的说法是"我们发现算错了,已修好并回填历史" —— 听起来完全正确,但它同时静默改写了所有历史模型的训练数据。纪律:任何 backfill 必须写新分区或新版本号,永不原地改写。
  7. AUC 0.7412 vs 0.7389,差 0.0023;那位申请人的分数 0.31 → 0.44,阈值 0.35,差 0.13,决策直接翻转(重跑出的模型会批准他)。因为重训 AUC 本来就在 0.73–0.75 之间波动,0.0023 小到不会触发任何告警,但足以翻转个体决策 —— 聚合指标的稳定完全掩盖了个体决策的不稳定。所以复现校验要看个体分数:抽 1000 条比对,|Δscore| > 0.02 的比例 > 1% 就算复现失败。
  8. 最容易被忽悠过去的是第 ③条 —— 团队"有"血缘系统,但它只记表名,不记分区指纹和口径版本;💀 有血缘 ≠ 可复现。代价:6 周专项(2 工程师 + 1 合规)、外部咨询法务 ≈ 86 万、模型下线整改 5 周期间通过率 −11%、少放款 2.3 亿、利息损失 ≈ 340 万、23 个模型补快照新增 41 TB。而当初存快照单模型每年约 5000 元 —— 💀 省下的 5000 元最后花掉了 400 多万。
  9. 《模型上线之后 17》管代码、参数、环境、模型权重、推理链路,回答"这个预测是哪个模型版本给的";本章只管数据本身,回答"这个模型是哪份数据训出来的"。容易出事是因为⚠️ 模型侧觉得数据是数仓的事、数据侧觉得训练集是算法自己拉的,两边都以为对方管了。解法:把「上游分区指纹」列进模型卡的必填项,谁发版谁填,填不出来不许发版。
  10. L1 性价比最高:加一个 _MANIFEST.json(分区名 + 指纹 + 行数 + commit + 参数),半天工程量,能解决 80% 的"三个月后重现不出来"问题。L1 是绝大多数团队应该停下来的地方 —— 剩下 20% 才需要 DVC/lakeFS 这类工具,而那 20% 的团队自己知道自己是谁。
  11. 先按 first_version 选择当时已入账的事件,再按事件日求和。V1 是 100 + 50 = 150 元;V2 只新增 D 日的 −30 元退款,得到 120 元。在错误的到达日口径下,D 日仍为 150 元,D+1 多出 −30 元。

本节回顾

留旧版与规则,用整行指纹验输入,按事件日重跑并核对旧结果。下一节看训练和预测怎样在正确时点取到特征。

下一节 · 特征存储

打卡记录保存在你的浏览器里,首页能看到总进度