add sephirot_gen.py

sephirot_gen.py

@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+"""sephirot_gen.py v2 — 十六质点世界修复合成数据引擎(全量重建版)
+枚举空间 N = 16×64×32×4×27×27×5×5 = 2,388,787,200(与论文一致)
+核心:Feistel 双射 + 同置换游走(cycle-walking)→ 索引空间均匀洗牌
+     每行由索引确定性重建(断点安全、可验证)
+用法:
+  python sephirot_gen.py --smoke          # 100万行快速验证
+  python sephirot_gen.py --full           # 全量23亿,16 workers
+  python sephirot_gen.py --verify 50000   # 抽样重生成一致性校验
+"""
+import os, sys, json, gzip, time, math, hashlib, random, multiprocessing as mp
+
+BASE   = os.path.dirname(os.path.abspath(__file__))
+SEEDS  = os.path.join(BASE, "seeds.json")
+DATA   = os.path.join(BASE, "data")
+WORKERS = 16
+SHARD_ROWS = 2_000_000           # 每分片行数
+DIMS = [16, 64, 32, 4, 27, 27, 5, 5]
+N = math.prod(DIMS)              # 2,388,787,200
+
+with open(SEEDS, encoding="utf-8") as f:
+    S = json.load(f)
+SECTOR = S["sector"]; REGION = S["region"]
+INSTR = S["instrument"]; FRAME = S["frame"]
+LEXK = S["sephirot_keys"]; LEX = S["sephirot_lex"]
+TOP = S["top_terms"]
+
+MASTER_KEY = int.from_bytes(hashlib.sha256(
+    b"worldfix-v2|corpus=61562415|sephirot=16").digest()[:8], "big")
+
+STANCES = ["预防", "缓解", "修复", "再生"]
+INTENS  = ["微调", "常规", "强化", "集中", "极限"]
+HORIZON = ["即时", "季度", "年度", "五年", "世代"]
+
+def feistel(x: int) -> int:
+    """4轮 Feistel on 2^32(L=R=16bit),固定网络→双射"""
+    l, r = (x >> 16) & 0xFFFF, x & 0xFFFF
+    for rnd in range(4):
+        f = ((r * 2654435761 + MASTER_KEY + rnd * 0x9E3779B9) ^ (r << 7)) & 0xFFFF
+        l, r = r, (l ^ f) & 0xFFFF
+    return (l << 16) | r
+
+def shuffle_index(i: int) -> int:
+    """同置换游走:i<N 映射到 [0,N) 的双射(修正版:单一定义网络)"""
+    x = i
+    while True:
+        x = feistel(x)
+        if x < N:
+            return x
+
+def decode(idx: int):
+    """混合基解码 → 8字段"""
+    out = []
+    for d in reversed(DIMS):
+        out.append(idx % d)
+        idx //= d
+    return tuple(reversed(out))   # s, sec, reg, st, ins, frm, it, hz
+
+VERD = ("ALLOW", "REPAIR", "FALLBACK")
+
+def make_row(order: int):
+    """order=原始序号 → 确定性生成一行(任何进程任何时候结果一致)"""
+    idx = shuffle_index(order)
+    s, sec, reg, st, ins, frm, it, hz = decode(idx)
+    rng = random.Random(idx ^ MASTER_KEY)
+    k = LEXK[s % 16]
+    lex = LEX[k]
+    actor = lex[rng.randrange(len(lex))]
+    term1 = TOP[(idx * 31 + order) % len(TOP)]
+    term2 = INSTR[ins]
+    term3 = FRAME[frm]
+    rx = (f"[{k}] 面向{REGION[reg]}的{SECTOR[sec]}问题,以「{actor}」为核心姿态,"
+          f"采用{term2}与{term3},在{HORIZON[hz]}视野内以{INTENS[it]}强度推进"
+          f"{STANCES[st]}型干预;配套十六质点审计回路与有界回滚预算(≤3)。")
+    # 治理模拟块
+    roll = rng.random()
+    if roll < 0.86:   v, kk = "ALLOW", 0
+    elif roll < 0.97: v, kk = "REPAIR", 1 + rng.randrange(3)
+    else:             v, kk = "FALLBACK", 3
+    aid = f"{(idx * 2654435761) & 0xFFFFFFFFFFFF:012x}"
+    return (f'{{"i":{order},"h":{idx},"s":{s},"sec":{sec},"reg":{reg},"st":{st},'
+            f'"ins":{ins},"frm":{frm},"it":{it},"hz":{hz},'
+            f'"key":"{k}","sector":"{SECTOR[sec]}","region":"{REGION[reg]}",'
+            f'"stance":"{STANCES[st]}","instrument":"{term2}","frame":"{term3}",'
+            f'"intensity":"{INTENS[it]}","horizon":"{HORIZON[hz]}",'
+            f'"prescription":"{rx}","verdict":"{v}","strikes":{kk},"audit":"{aid}"}}')
+
+# ──────────────────────── worker ────────────────────────
+def worker(wid: int, lo: int, hi: int):
+    wdir = os.path.join(DATA, f"w{wid:02d}")
+    os.makedirs(wdir, exist_ok=True)
+    mani = os.path.join(wdir, "manifest.json")
+    pos = lo
+    if os.path.exists(mani):
+        try:
+            p = int(json.load(open(mani))["pos"])
+            if lo <= p <= hi:          # 越界/损坏清单不可信,静默丢弃
+                pos = max(pos, p)
+        except Exception:
+            pass
+    # 清理尾部未登记分片
+    for fn in os.listdir(wdir):
+        m = fn.endswith(".jsonl.gz") and fn.split("_")[2:]
+        if fn.endswith(".part"):
+            os.remove(os.path.join(wdir, fn))
+    t0 = time.time(); cnt_since = 0
+    while pos < hi:
+        end = min(pos + SHARD_ROWS, hi)
+        tmp = os.path.join(wdir, f"s{pos:012d}.jsonl.gz.part")
+        fin = os.path.join(wdir, f"s{pos:012d}.jsonl.gz")
+        with gzip.open(tmp, "wb", compresslevel=1) as gz:
+            buf = []
+            ap = buf.append
+            for o in range(pos, end):
+                ap(make_row(o))
+                if len(buf) >= 20000:
+                    gz.write(("\n".join(buf) + "\n").encode())
+                    buf.clear()
+            if buf:
+                gz.write(("\n".join(buf) + "\n").encode())
+        os.replace(tmp, fin)
+        pos = end
+        json.dump({"pos": pos, "hi": hi}, open(mani, "w"))
+        cnt_since += SHARD_ROWS
+        el = time.time() - t0
+        # 日志写文件(避免stdout管道背压死锁)
+        with open(os.path.join(wdir, "gen.log"), "a", encoding="utf-8") as lf:
+            lf.write(f"[w{wid:02d}] {pos-lo}/{hi-lo} ({(pos-lo)/(hi-lo)*100:.2f}%) "
+                     f"{cnt_since/max(el,1e-9):,.0f} r/s  t+{el:.0f}s\n")
+    json.dump({"pos": pos, "hi": hi, "done": True}, open(mani, "w"))  # 收尾覆写,清掉陈旧/越界清单
+
+def full():
+    os.makedirs(DATA, exist_ok=True)
+    chunk = N // WORKERS
+    jobs = [(w, w * chunk, (w + 1) * chunk if w < WORKERS - 1 else N)
+            for w in range(WORKERS)]
+    t0 = time.time()
+    with mp.Pool(WORKERS) as pool:
+        pool.starmap(worker, jobs)
+    print(f"FULL DONE {N:,} rows in {(time.time()-t0)/60:.1f} min")
+
+def smoke(total=1_000_000):
+    os.makedirs(DATA, exist_ok=True)
+    chunk = total // WORKERS
+    jobs = [(w, w * chunk, (w + 1) * chunk if w < WORKERS - 1 else total)
+            for w in range(WORKERS)]
+    t0 = time.time()
+    with mp.Pool(WORKERS) as pool:
+        pool.starmap(worker, jobs)
+    print(f"SMOKE DONE {total:,} rows in {time.time()-t0:.1f}s")
+
+def verify(n=50000):
+    import itertools
+    bad = 0
+    rng = random.Random(7)
+    samples = [rng.randrange(N) for _ in range(min(n, 5000))] + list(range(10))
+    for o in samples:
+        r1 = make_row(o)
+        # 重算两次一致性
+        if r1 != make_row(o):
+            bad += 1
+    # 双射性抽查:前100万索引无碰撞
+    seen = set()
+    dup = 0
+    for o in range(1_000_000):
+        h = shuffle_index(o)
+        if h in seen:
+            dup += 1
+        seen.add(h)
+    print(f"verify: 一致性坏行={bad}/{len(samples)}  百万抽样碰撞={dup}")
+    print("VERIFY PASS" if bad == 0 and dup == 0 else "VERIFY FAIL")
+    # 字段范围校验
+    o = 123456789
+    s, sec, reg, st, ins, frm, it, hz = decode(shuffle_index(o))
+    assert 0 <= s < 16 and 0 <= sec < 64 and 0 <= reg < 32 and 0 <= st < 4 \
+       and 0 <= ins < 27 and 0 <= frm < 27 and 0 <= it < 5 and 0 <= hz < 5
+    print("decode ranges OK; N =", f"{N:,}")
+
+if __name__ == "__main__":
+    a = sys.argv[1] if len(sys.argv) > 1 else "--verify"
+    if a == "--full":
+        full()
+    elif a == "--smoke":
+        smoke(int(sys.argv[2]) if len(sys.argv) > 2 else 1_000_000)
+    elif a == "--verify":
+        verify(int(sys.argv[2]) if len(sys.argv) > 2 else 50000)
+    else:
+        print(__doc__)