sunnynet-cx 0.3.0__py3-none-win_amd64.whl

sunnynet_cx-0.3.0.data/purelib/sunnynet/__init__.py

@@ -0,0 +1,29 @@
+"""SunnyNet: 原创 CPU 通用序列神经网络架构."""
+import importlib
+
+__version__ = "0.3.0"
+__all__ = ["SunnyConfig", "SunnyNet", "CenteredScaleNorm", "logspace_scan",
+           "poly_sigmoid", "softwedge"]
+
+# 延迟导入 torch: kernels/runtime 子包不依赖它, 顶层 import 会让二者无法单独导入。
+_LAZY = {
+    "SunnyConfig": "sunnynet.model",
+    "SunnyNet": "sunnynet.model",
+    "CenteredScaleNorm": "sunnynet.ops",
+    "logspace_scan": "sunnynet.ops",
+    "poly_sigmoid": "sunnynet.ops",
+    "softwedge": "sunnynet.ops",
+}
+
+
+def __getattr__(name):
+    mod = _LAZY.get(name)
+    if mod is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    val = getattr(importlib.import_module(mod), name)
+    globals()[name] = val
+    return val
+
+
+def __dir__():
+    return sorted(set(__all__) | set(globals()))

sunnynet_cx-0.3.0.data/purelib/sunnynet/_native.py

@@ -0,0 +1,277 @@
+"""预编译共享库的定位与构建.
+
+包内 sunnynet/_prebuilt/<平台标签>/ 存放构建期编好的产物。运行期优先加载它,
+命中就不再要求本机有 C 编译器; 未命中或 CPU 指令集不达标时退回源码编译。
+
+预编译库一律以 -mavx2 -mfma -march=x86-64-v3 编出, 只对 x86-64 且支持 AVX2 的
+机器可用, 故按指令集判定而非仅按平台。
+"""
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import sys
+from pathlib import Path
+
+__all__ = [
+    "PREBUILT", "platform_tag", "cpu_flags", "isa_ok",
+    "locate", "build_prebuilt", "MODULES", "SOURCES", "run_cc",
+]
+
+HERE = Path(__file__).resolve().parent
+PREBUILT = HERE / "_prebuilt"
+
+# 构建期需要产出预编译库的模块; 每个模块需有 _compile(gcc) 与 DLL 属性。
+MODULES = (
+    "sunnynet.runtime",
+    "sunnynet.runtime.model",
+    "sunnynet.runtime.rwkv7_c",
+    "sunnynet.runtime.deltanet_c",
+    "sunnynet.runtime.mamba2_c",
+    "sunnynet.runtime.gla_c",
+    "sunnynet.runtime.hgrn2_c",
+    "sunnynet.runtime.quant",
+    "sunnynet.runtime.abi",
+    "sunnynet.kernels",
+)
+
+# 每个预编译库的输入源码 (相对 HERE)。随包分发, 用于判定产物是否过期。
+SOURCES = {
+    "sunnynet.runtime": ("runtime/recur.c", "runtime/recur.h"),
+    "sunnynet.runtime.model": ("runtime/sunnynet.c", "runtime/sunnynet.h"),
+    "sunnynet.runtime.rwkv7_c": ("runtime/rwkv7.c", "runtime/rwkv7.h",
+                                 "runtime/quant.c"),
+    "sunnynet.runtime.deltanet_c": ("runtime/deltanet.c", "runtime/deltanet.h",
+                                    "runtime/quant.c"),
+    "sunnynet.runtime.mamba2_c": ("runtime/mamba2.c", "runtime/mamba2.h"),
+    "sunnynet.runtime.gla_c": ("runtime/gla.c", "runtime/gla.h",
+                               "runtime/quant.c"),
+    "sunnynet.runtime.hgrn2_c": ("runtime/hgrn2.c", "runtime/hgrn2.h",
+                                 "runtime/quant.c"),
+    "sunnynet.runtime.quant": ("runtime/quant.c", "runtime/quant.h"),
+    "sunnynet.runtime.abi": ("runtime/sn_abi.c", "runtime/sn_abi.h",
+                             "runtime/recur.c", "runtime/rwkv7.c",
+                             "runtime/quant.c"),
+    "sunnynet.kernels": ("kernels/scan_avx2.c", "kernels/core_avx2.c",
+                         "kernels/step_avx2.c"),
+}
+
+
+def _machine() -> str:
+    m = platform.machine().lower()
+    return {"amd64": "x86_64", "arm64": "aarch64"}.get(m, m)
+
+
+def run_cc(cmd: list[str]):
+    """跑编译器。Windows 下 gcc 的诊断按系统代码页输出, 中文路径会撞非 UTF-8 字节;
+    带 text=True 会抛 UnicodeDecodeError 把真实编译错误盖掉, 故收 bytes 再容错解码。
+    返回 (returncode, 合并后的诊断文本)。
+    """
+    import subprocess
+
+    r = subprocess.run(cmd, capture_output=True)
+    msg = (r.stderr or r.stdout or b"").decode("utf-8", errors="replace")
+    return r.returncode, msg
+
+
+def platform_tag() -> str:
+    """对应 _prebuilt 下的子目录名, 如 win-x86_64 / linux-x86_64。"""
+    if sys.platform == "win32":
+        return f"win-{_machine()}"
+    if sys.platform == "darwin":
+        return f"macos-{_machine()}"
+    return f"linux-{_machine()}"
+
+
+def cpu_flags() -> set[str]:
+    """本机 CPU 特性名集合 (小写)。"""
+    if sys.platform != "win32":
+        try:
+            text = Path("/proc/cpuinfo").read_text(encoding="utf-8",
+                                                  errors="replace")
+        except OSError:
+            return set()
+        for line in text.splitlines():
+            low = line.lower()
+            if low.startswith("flags") or low.startswith("features"):
+                return set(line.split(":", 1)[1].split())
+        return set()
+    try:
+        import ctypes
+        import ctypes.wintypes as wt
+
+        k = ctypes.windll.kernel32
+        k.IsProcessorFeaturePresent.argtypes = [wt.DWORD]
+        k.IsProcessorFeaturePresent.restype = wt.BOOL
+        # PF_AVX2_INSTRUCTIONS_AVAILABLE = 40。Windows 无独立的 FMA 查询位,
+        # 但 FMA3 与 AVX2 同期引入 (Haswell), 有 AVX2 即有 FMA。
+        return {"avx2", "fma"} if k.IsProcessorFeaturePresent(40) else set()
+    except Exception:
+        return set()
+
+
+_ISA_CACHE = None
+
+
+def isa_ok() -> bool:
+    """预编译库用 x86-64-v3 编出, 只有 AVX2+FMA 的 x86-64 机器能跑。"""
+    global _ISA_CACHE
+    if _ISA_CACHE is None:
+        if _machine() != "x86_64":
+            _ISA_CACHE = False
+        else:
+            f = cpu_flags()
+            _ISA_CACHE = "avx2" in f and "fma" in f
+    return _ISA_CACHE
+
+
+def find(name: str) -> Path | None:
+    p = PREBUILT / platform_tag() / name
+    return p if p.is_file() else None
+
+
+def _sha256(p: Path) -> str:
+    import hashlib
+
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for blk in iter(lambda: f.read(1 << 16), b""):
+            h.update(blk)
+    return h.hexdigest()
+
+
+def _manifest_path() -> Path:
+    return PREBUILT / platform_tag() / "sources.sha256"
+
+
+def all_sources() -> tuple[str, ...]:
+    return tuple(sorted({s for srcs in SOURCES.values() for s in srcs}))
+
+
+def _read_manifest() -> dict:
+    import json
+
+    p = _manifest_path()
+    if not p.is_file():
+        return {}
+    try:
+        return json.loads(p.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+_STALE_CACHE = {}
+
+
+def prebuilt_stale(shlib_name: str | None = None) -> bool:
+    """包内产物是否与同包源码不一致。
+
+    比对内容哈希而非 mtime: pip 解包会把源码 mtime 刷成解包时刻, 恒新于产物,
+    按时间判会把装好的包一律判成过期。源码没随包分发时无法判定, 按不过期处理。
+
+    shlib_name 为 None 时检查全部库 (需 import 各模块), 否则只查清单里该库的条目
+    ——不 import 任何模块, 少读文件: Windows 实时防护下每次打开约 6 ms。
+    """
+    if shlib_name is None:
+        return any(prebuilt_stale(n) for n in _dll_names())
+    if shlib_name in _STALE_CACHE:
+        return _STALE_CACHE[shlib_name]
+    man = _read_manifest().get(shlib_name) or {}
+    stale = False
+    for rel, want in man.items():
+        p = HERE / rel
+        if p.is_file() and _sha256(p) != want:
+            stale = True
+            break
+    _STALE_CACHE[shlib_name] = stale
+    return stale
+
+
+def _dll_names() -> tuple[str, ...]:
+    out = []
+    for name in MODULES:
+        d = _dll_of(name)
+        if d:
+            out.append(d)
+    return tuple(out)
+
+
+def _dll_of(mod_name: str) -> str | None:
+    import importlib
+
+    try:
+        return importlib.import_module(mod_name).DLL.name
+    except Exception:
+        return None
+
+
+def locate(shlib_name: str) -> Path | None:
+    """预编译库可加载则返回路径, 否则 None (调用方退回源码编译)。
+
+    设 SUNNY_NO_PREBUILT=1 可强制走源码路径, 用于对照验证。
+    开发态下源码改过则判过期, 避免静默加载旧库 (见 prebuilt_stale)。
+    """
+    if os.environ.get("SUNNY_NO_PREBUILT") == "1" or not isa_ok():
+        return None
+    if prebuilt_stale(shlib_name):
+        return None
+    return find(shlib_name)
+
+
+def build_prebuilt(out_dir: str | Path | None = None):
+    """编译全部原生库并复制到 _prebuilt/<平台标签>/。
+
+    同时写出 sources.sha256 清单, 供运行期判定产物是否与源码一致。
+    返回 (产物列表, 错误说明)。当前 C 运行时用 -mavx2 编出, 只有 x86-64 能编;
+    其他架构返回空列表并说明, 由调用方决定是否视为失败。
+
+    编译落在临时目录: 各模块的 _compile 写的是共享的 <pkg>/_build/<dll>, 该文件
+    一旦被本进程 (或别的测试) 加载过, Windows 不允许覆盖写, 编译必失败。
+    """
+    import importlib
+    import json
+    import tempfile
+
+    if _machine() != "x86_64":
+        return [], f"{_machine()} 不是 x86-64, 该架构无预编译产物"
+    if not isa_ok():
+        return [], "构建机不支持 AVX2+FMA, 跳过预编译"
+
+    out = Path(out_dir) if out_dir else PREBUILT / platform_tag()
+    made: list[Path] = []
+    skipped: list[str] = []
+    with tempfile.TemporaryDirectory(prefix="sunnynet-build-") as td:
+        tmp = Path(td)
+        for name in MODULES:
+            mod = importlib.import_module(name)
+            gcc = mod._find_gcc()
+            if gcc is None:
+                return made, f"未找到 C 编译器, 无法生成预编译库 ({name})"
+            dst = tmp / mod.DLL.name
+            cmd = mod._link_cmd(gcc, dst)
+            rc, msg = run_cc(cmd)
+            if rc != 0:
+                return made, f"{name} 编译失败: {msg[-500:]}"
+            out.mkdir(parents=True, exist_ok=True)
+            try:
+                shutil.copy2(dst, out / dst.name)
+            except PermissionError:
+                # 目标 dll 已被本进程加载, Windows 不允许覆盖。编译产物仍是新的,
+                # 单独说明而不整体失败 —— 其余库照常写出。
+                skipped.append(f"{dst.name} (已加载, 未覆盖)")
+                continue
+            made.append(out / dst.name)
+
+    man = {}
+    for name in MODULES:
+        dll = importlib.import_module(name).DLL.name
+        man[dll] = {rel: _sha256(HERE / rel) for rel in SOURCES[name]
+                    if (HERE / rel).is_file()}
+    man_p = out / "sources.sha256"
+    man_p.write_text(json.dumps(man, indent=1, sort_keys=True), encoding="utf-8")
+    made.append(man_p)
+    _STALE_CACHE.clear()      # 产物已刷新, 旧的过期判定失效
+    if skipped:
+        return made, "部分库被占用未覆盖: " + ", ".join(skipped)
+    return made, None

sunnynet_cx-0.3.0.data/purelib/sunnynet/_prebuilt/win-x86_64/sources.sha256

@@ -0,0 +1,50 @@
+{
+ "sunnynet_abi.dll": {
+  "runtime/quant.c": "024f36c5ee82fa97e330e982048422a0fc13a82d3539a957e64299ab82b557dd",
+  "runtime/recur.c": "f9d528a311513322f083e5ae6dbdc60d160fcf6f529360535cb68127e6869529",
+  "runtime/rwkv7.c": "12cf26f74bf6399b6698695647da4ac7da794584827c13646568e8a4bea30bf0",
+  "runtime/sn_abi.c": "761c48ef2649f3d10e470cbf406df019b3512dccc8e7d4fff2c1d1501eaa2d14",
+  "runtime/sn_abi.h": "0a737b7b73c88150246a86d970169bac45300068e735883e4261317dcaa33fba"
+ },
+ "sunnynet_deltanet.dll": {
+  "runtime/deltanet.c": "835fb36b332d35815ec88e95e1a4988fc0d2089ac1f7bac7e2f4c593a1303ed4",
+  "runtime/deltanet.h": "672a3a4606e38ddb1c6c084b0a250d90d33616f78bef9d445ea5a111aee6afde",
+  "runtime/quant.c": "024f36c5ee82fa97e330e982048422a0fc13a82d3539a957e64299ab82b557dd"
+ },
+ "sunnynet_gla.dll": {
+  "runtime/gla.c": "bb823bd1d9e7dafefee791359efbcc4be4d77a3bd2a1442733a6bd7e1827f4aa",
+  "runtime/gla.h": "2889fa80d22d14b3ee82304d3a5edc0bc2fc681afa3112585e2bc817a9abaaab",
+  "runtime/quant.c": "024f36c5ee82fa97e330e982048422a0fc13a82d3539a957e64299ab82b557dd"
+ },
+ "sunnynet_hgrn2.dll": {
+  "runtime/hgrn2.c": "05b6b95e70d347fa2b323e3d725a3d0a0f863cf1edb37387e44a1a38dd712f32",
+  "runtime/hgrn2.h": "cfeddcedd70cc4dca5a948a8cd8dcf0010b59ae5e70114ad80d3bf3f6170bc8c",
+  "runtime/quant.c": "024f36c5ee82fa97e330e982048422a0fc13a82d3539a957e64299ab82b557dd"
+ },
+ "sunnynet_kernels.dll": {
+  "kernels/core_avx2.c": "bd65d3ff52820af3e59436759bb265d06a509ad1d803651227060cc0e471c02b",
+  "kernels/scan_avx2.c": "d994843e167c8cb934be1e42e752ff4a76386508098e35525cd284bc277554d9",
+  "kernels/step_avx2.c": "3bb28f7bd393e2eebc5444cdce2e29544fedd1a21b91cbeff3ee9fb3c3bfc426"
+ },
+ "sunnynet_mamba2.dll": {
+  "runtime/mamba2.c": "6f27ea4f7efafa30fb89f27fa4b2c5c6121b806eeeb5fc885b671c5c46507bbd",
+  "runtime/mamba2.h": "5cbd41e1d78d3390c498f619ab8310c66e9009f317b3b05bbb77541a115dfe0b"
+ },
+ "sunnynet_model.dll": {
+  "runtime/sunnynet.c": "705cbc064f35432f05738c8654fe6a9ddf0df6330c8e5e97e3b209dc6660d64a",
+  "runtime/sunnynet.h": "e391bfc7651bdf650be0886c168a7c357452976a1d74b8b1ffc047e7b1a48fda"
+ },
+ "sunnynet_quant.dll": {
+  "runtime/quant.c": "024f36c5ee82fa97e330e982048422a0fc13a82d3539a957e64299ab82b557dd",
+  "runtime/quant.h": "5cfd9571036c33064d692fc08043addd47b4498f66af46c113c258168e474983"
+ },
+ "sunnynet_runtime.dll": {
+  "runtime/recur.c": "f9d528a311513322f083e5ae6dbdc60d160fcf6f529360535cb68127e6869529",
+  "runtime/recur.h": "10c8d059f5296ecf7a81b816c37f6e2cf4b29e0e3eccddfac61a33c5dbcd51a9"
+ },
+ "sunnynet_rwkv7.dll": {
+  "runtime/quant.c": "024f36c5ee82fa97e330e982048422a0fc13a82d3539a957e64299ab82b557dd",
+  "runtime/rwkv7.c": "12cf26f74bf6399b6698695647da4ac7da794584827c13646568e8a4bea30bf0",
+  "runtime/rwkv7.h": "7a8ca76b7c2f4cc9d6fb927a8072818090042568af26af5a343bdb3af91b9c3f"
+ }
+}

sunnynet_cx-0.3.0.data/purelib/sunnynet/baseline.py

@@ -0,0 +1,193 @@
+"""对照基线: 标准 Transformer 语言模型.
+
+仅用于公平对照 (同参数量 / 同数据 / 同硬件 / 同 token 预算), 不属于 SunnyNet 架构本体.
+手写实现以便精确控制参数量与结构, 不调用 nn.TransformerEncoder.
+"""
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+__all__ = ["BaselineConfig", "TransformerLM", "TransformerState", "solve_baseline_for_params"]
+
+
+@dataclass
+class BaselineConfig:
+    vocab_size: int = 12000
+    d_model: int = 320
+    n_heads: int = 8
+    n_layers: int = 6
+    d_ff: int = 640
+    max_len: int = 2048
+    tie_embeddings: bool = True
+
+
+@dataclass
+class TransformerState:
+    """KV cache: 逐层 (k, v) 均为 (B,H,T_past,d_head), 首步前为 None."""
+
+    kv: list
+    pos: int = 0
+
+
+class CausalSelfAttention(nn.Module):
+    def __init__(self, cfg: BaselineConfig):
+        super().__init__()
+        self.n_heads = cfg.n_heads
+        self.d_head = cfg.d_model // cfg.n_heads
+        self.qkv = nn.Linear(cfg.d_model, 3 * cfg.d_model, bias=True)
+        self.proj = nn.Linear(cfg.d_model, cfg.d_model, bias=True)
+
+    def forward(self, x, mask):
+        B, T, C = x.shape
+        q, k, v = self.qkv(x).split(C, dim=-1)
+        q = q.view(B, T, self.n_heads, self.d_head).transpose(1, 2)
+        k = k.view(B, T, self.n_heads, self.d_head).transpose(1, 2)
+        v = v.view(B, T, self.n_heads, self.d_head).transpose(1, 2)
+        att = (q @ k.transpose(-2, -1)) / math.sqrt(self.d_head)
+        att = att.masked_fill(mask[:, :, :T, :T] == 0, float("-inf"))
+        att = F.softmax(att, dim=-1)
+        y = (att @ v).transpose(1, 2).contiguous().view(B, T, C)
+        return self.proj(y)
+
+    def step(self, x_t, cache):
+        """单步: x_t (B,C), cache=(k,v) 形如 (B,H,T_past,d_head); 返回 (y, cache_new)."""
+        B, C = x_t.shape
+        q, k, v = self.qkv(x_t).split(C, dim=-1)
+        q = q.view(B, 1, self.n_heads, self.d_head).transpose(1, 2)
+        k = k.view(B, 1, self.n_heads, self.d_head).transpose(1, 2)
+        v = v.view(B, 1, self.n_heads, self.d_head).transpose(1, 2)
+        if cache is not None:
+            k = torch.cat([cache[0], k], dim=2)
+            v = torch.cat([cache[1], v], dim=2)
+        att = (q @ k.transpose(-2, -1)) / math.sqrt(self.d_head)
+        att = F.softmax(att, dim=-1)
+        y = (att @ v).transpose(1, 2).contiguous().view(B, 1, C)
+        return self.proj(y)[:, 0], (k, v)
+
+
+class Block(nn.Module):
+    def __init__(self, cfg: BaselineConfig):
+        super().__init__()
+        self.ln1 = nn.LayerNorm(cfg.d_model)
+        self.attn = CausalSelfAttention(cfg)
+        self.ln2 = nn.LayerNorm(cfg.d_model)
+        self.fc1 = nn.Linear(cfg.d_model, cfg.d_ff, bias=True)
+        self.fc2 = nn.Linear(cfg.d_ff, cfg.d_model, bias=True)
+
+    def forward(self, x, mask):
+        x = x + self.attn(self.ln1(x), mask)
+        h = F.gelu(self.fc1(self.ln2(x)))
+        return x + self.fc2(h)
+
+    def step(self, x_t, cache):
+        y, c = self.attn.step(self.ln1(x_t), cache)
+        x_t = x_t + y
+        return x_t + self.fc2(F.gelu(self.fc1(self.ln2(x_t)))), c
+
+
+class TransformerLM(nn.Module):
+    def __init__(self, cfg: BaselineConfig):
+        super().__init__()
+        self.cfg = cfg
+        self.embed = nn.Embedding(cfg.vocab_size, cfg.d_model)
+        self.pos = nn.Embedding(cfg.max_len, cfg.d_model)
+        self.blocks = nn.ModuleList([Block(cfg) for _ in range(cfg.n_layers)])
+        self.ln_f = nn.LayerNorm(cfg.d_model)
+        self.head = nn.Linear(cfg.d_model, cfg.vocab_size, bias=False)
+        if cfg.tie_embeddings:
+            self.head.weight = self.embed.weight
+        mask = torch.tril(torch.ones(cfg.max_len, cfg.max_len)).view(1, 1, cfg.max_len, cfg.max_len)
+        self.register_buffer("mask", mask, persistent=False)
+        self.apply(self._init)
+        for n, p in self.named_parameters():
+            if n.endswith("proj.weight") or n.endswith("fc2.weight"):
+                nn.init.normal_(p, mean=0.0, std=0.02 / math.sqrt(2 * cfg.n_layers))
+
+    def _init(self, m):
+        if isinstance(m, nn.Linear):
+            nn.init.normal_(m.weight, mean=0.0, std=0.02)
+            if m.bias is not None:
+                nn.init.zeros_(m.bias)
+        elif isinstance(m, nn.Embedding):
+            nn.init.normal_(m.weight, mean=0.0, std=0.02)
+
+    def num_params(self, non_embedding: bool = False) -> int:
+        n = sum(p.numel() for p in self.parameters())
+        if non_embedding:
+            n -= self.embed.weight.numel()
+            n -= self.pos.weight.numel()
+            if not self.cfg.tie_embeddings:
+                n -= self.head.weight.numel()
+        return n
+
+    def forward(self, idx, state=None, return_state=False):
+        B, T = idx.shape
+        pos = torch.arange(T, device=idx.device)
+        x = self.embed(idx) + self.pos(pos)[None, :, :]
+        for blk in self.blocks:
+            x = blk(x, self.mask)
+        logits = self.head(self.ln_f(x))
+        if return_state:
+            return logits, None
+        return logits
+
+    @torch.no_grad()
+    def forward_step(self, idx_t, state):
+        """单步自回归 (KV cache): idx_t (B,) -> (logits (B,V), state)."""
+        if state is None:
+            state = TransformerState(kv=[None] * len(self.blocks), pos=0)
+        x = self.embed(idx_t) + self.pos(torch.tensor(state.pos, device=idx_t.device))
+        new_kv = []
+        for blk, c in zip(self.blocks, state.kv):
+            x, cn = blk.step(x, c)
+            new_kv.append(cn)
+        logits = self.head(self.ln_f(x))
+        return logits, TransformerState(kv=new_kv, pos=state.pos + 1)
+
+
+def stack_param_count(d_model: int, d_ff: int, n_layers: int) -> int:
+    """Transformer 计算栈参数量, 不含 token/位置嵌入与 LM head.
+
+    SunnyNet 无位置嵌入, 只有排除位置嵌入两边口径才一致.
+    """
+    per_layer = (d_model * 3 * d_model + 3 * d_model
+                 + d_model * d_model + d_model
+                 + 2 * d_model
+                 + d_model * d_ff + d_ff
+                 + d_ff * d_model + d_model
+                 + 2 * d_model)
+    return n_layers * per_layer + 2 * d_model
+
+
+def solve_baseline_for_params(target_non_embed: int, vocab_size: int,
+                              n_layers: int = 6, n_heads: int = 8,
+                              max_len: int = 2048):
+    """枚举 (d_model, d_ff) 使计算栈参数量最接近目标. 用解析公式, 不实例化模型.
+
+    返回 (cfg, 实际栈参数量, 相对偏差).
+    """
+    best = None
+    for d_model in range(64, 3072, 8):
+        if d_model % n_heads:
+            continue
+        base = (n_layers * (d_model * 3 * d_model + 3 * d_model
+                            + d_model * d_model + d_model + 2 * d_model
+                            + d_model * d_model + d_model + 2 * d_model)
+                + 2 * d_model)
+        if base > target_non_embed * 1.05:
+            break
+        for d_ff in range(d_model, 6 * d_model + 1, 16):
+            n = stack_param_count(d_model, d_ff, n_layers)
+            rel = abs(n - target_non_embed) / max(1, target_non_embed)
+            key = (rel, -min(n, target_non_embed))
+            if best is None or key < best[0]:
+                best = (key, n, rel, BaselineConfig(
+                    vocab_size=vocab_size, d_model=d_model, n_heads=n_heads,
+                    n_layers=n_layers, d_ff=d_ff, max_len=max_len))
+    _, n, rel, cfg = best
+    return cfg, n, rel