fxtensor-bayesnet 0.9.0__py3-none-any.whl

fxtensor_bayesnet/__init__.py

@@ -0,0 +1,9 @@
+"""設定ファイル駆動の離散ベイジアンネットワーク推論（fxtensor-salmon 使用）。"""
+__version__ = "0.9.0"
+
+from .config import ConfigError, config_hash, dump_config, load_config, topo_order, validate  # noqa: E402
+from .inference import Engine, run  # noqa: E402
+from .network import Net  # noqa: E402
+
+__all__ = ["ConfigError", "Engine", "Net", "config_hash", "dump_config", "load_config",
+           "run", "topo_order", "validate", "__version__"]

fxtensor_bayesnet/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

fxtensor_bayesnet/cli.py

@@ -0,0 +1,148 @@
+"""fxtensor-bayesnet — 設定ファイル駆動の離散ベイジアンネットワーク推論（fxtensor-salmon 使用）
+
+使い方:
+  fxtensor-bayesnet [--config PATH] [options]
+    --config PATH     設定ファイル（既定: カレントディレクトリの config.json）
+    --out-dir DIR     results.json / results.md / model.mmd の出力先（既定: 設定ファイルと同じフォルダ）
+    --history-dir DIR スナップショットの保存先（既定: 設定ファイルと同じフォルダの history/）
+    --no-write        results.json / results.md / model.mmd を書かず、標準出力だけにする
+    --md              標準出力を Markdown にする（既定は JSON）
+    --check           設定の検証だけ行う（エラーなら終了コード 2）
+    --snapshot        設定と結果を <history-dir>/<as_of>/ に保存（既存なら --force が必要）
+    --force           --snapshot の上書きを許可
+    --diff [PATH]     設定（と結果）の前回スナップショットとの差分を表示
+                      PATH 省略時は <history-dir> の as_of より前で最新のもの
+    --format-config   設定ファイルを読みやすい形（核の1行=1行）に整形して書き戻す
+    --plot            図を <out-dir> に出力（network / marginals / updates。--diff と併用で diff）
+                      matplotlib が必要: pip install 'fxtensor-bayesnet[plot]'
+    --plot-format F.. 図の形式 png / svg（複数可。既定: png）
+    --plot-dpi N      PNG の解像度（既定: 150）
+    --lang ja|en      Markdown と図の見出し・凡例の言語（既定: ja。results.json のキーは固定）
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+
+from . import __version__
+from .config import ConfigError, config_hash, dump_config, load_config
+from .history import diff_configs, diff_results, previous_snapshot, snapshot
+from .inference import run
+from .report import render_markdown, render_mermaid
+
+
+def build_parser():
+    ap = argparse.ArgumentParser(prog="fxtensor-bayesnet", description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    ap.add_argument("--config", default="config.json")
+    ap.add_argument("--out-dir", default=None)
+    ap.add_argument("--history-dir", default=None)
+    ap.add_argument("--no-write", action="store_true")
+    ap.add_argument("--md", action="store_true")
+    ap.add_argument("--check", action="store_true")
+    ap.add_argument("--snapshot", action="store_true")
+    ap.add_argument("--force", action="store_true")
+    ap.add_argument("--diff", nargs="?", const="__prev__")
+    ap.add_argument("--format-config", action="store_true")
+    ap.add_argument("--plot", action="store_true")
+    ap.add_argument("--plot-format", nargs="+", choices=["png", "svg"], default=["png"])
+    ap.add_argument("--plot-dpi", type=int, default=150)
+    ap.add_argument("--lang", choices=["ja", "en"], default="ja")
+    return ap
+
+
+def _plot_module():
+    """図のモジュールを読み込み、matplotlib の有無を先に確かめる。"""
+    from . import plot
+    plot._mpl()
+    return plot
+
+
+def main(argv=None):
+    a = build_parser().parse_args(argv)
+    base = os.path.dirname(os.path.abspath(a.config))
+    out_dir = a.out_dir or base
+    history_dir = a.history_dir or os.path.join(base, "history")
+
+    try:
+        cfg = load_config(a.config)
+    except FileNotFoundError:
+        print(f"設定ファイルがありません: {a.config}", file=sys.stderr)
+        return 2
+    except json.JSONDecodeError as e:
+        print(f"JSON の構文エラー: {a.config}: {e}", file=sys.stderr)
+        return 2
+    except ConfigError as e:
+        print(str(e), file=sys.stderr)
+        return 2
+
+    plot = None
+    if a.plot and not a.check:
+        try:
+            plot = _plot_module()
+        except Exception as e:  # PlotError
+            print(str(e), file=sys.stderr)
+            return 3
+
+    if a.format_config:
+        with open(a.config, "w", encoding="utf-8") as f:
+            f.write(dump_config(cfg))
+        print(f"整形しました: {a.config}", file=sys.stderr)
+    if a.check:
+        print(f"設定OK: {a.config}（変数 {len(cfg['variables'])}、核 {len(cfg['kernels'])}、ハッシュ {config_hash(cfg)}）")
+        return 0
+    if a.diff:
+        path = previous_snapshot(history_dir, cfg["as_of"]) if a.diff == "__prev__" else a.diff
+        if not path:
+            print(f"比較対象のスナップショットがありません（{history_dir}/<日付>/config.json）")
+            return 0
+        with open(path, encoding="utf-8") as f:
+            old = json.load(f)
+        print(f"# 設定の差分: {path} → {a.config}")
+        print("\n".join(diff_configs(old, cfg)))
+        rpath = os.path.join(os.path.dirname(path), "results.json")
+        if os.path.exists(rpath):
+            with open(rpath, encoding="utf-8") as f:
+                old_res = json.load(f)
+            new_res = run(cfg)
+            print(f"\n# 結果の差分（0.1pt 以上）: {rpath} → 現在の設定で再計算")
+            print("\n".join(diff_results(old_res, new_res)))
+            if plot:
+                for fmt in a.plot_format:
+                    out = plot.plot_diff(old_res, new_res, cfg, os.path.join(out_dir, f"diff.{fmt}"), a.plot_dpi,
+                                         old_label=old_res.get("基準日"), new_label=cfg["as_of"], lang=a.lang)
+                    if out:
+                        print(f"図を保存: {out}", file=sys.stderr)
+        elif plot:
+            print("前回の results.json がないため変化量の図は描けません", file=sys.stderr)
+        return 0
+
+    res = run(cfg)
+    md = render_markdown(res, cfg, a.lang)
+    if not a.no_write:
+        os.makedirs(out_dir, exist_ok=True)
+        with open(os.path.join(out_dir, "results.json"), "w", encoding="utf-8") as f:
+            json.dump(res, f, ensure_ascii=False, indent=2)
+        with open(os.path.join(out_dir, "results.md"), "w", encoding="utf-8") as f:
+            f.write(md)
+        with open(os.path.join(out_dir, "model.mmd"), "w", encoding="utf-8") as f:
+            f.write(render_mermaid(cfg))
+    if plot:
+        for out in plot.plot_all(res, cfg, out_dir, a.plot_format, a.plot_dpi, lang=a.lang):
+            print(f"図を保存: {out}", file=sys.stderr)
+    if a.snapshot:
+        try:
+            d = snapshot(cfg, res, history_dir, a.force)
+        except FileExistsError as e:
+            print(str(e), file=sys.stderr)
+            return 1
+        print(f"スナップショット保存: {d}", file=sys.stderr)
+    print(md if a.md else json.dumps(res, ensure_ascii=False, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

fxtensor_bayesnet/config.py

@@ -0,0 +1,136 @@
+"""設定ファイルの読み込み・検証・整形・ハッシュ。"""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from itertools import product
+
+import numpy as np
+
+TOL = 1e-6
+
+
+class ConfigError(ValueError):
+    """設定ファイルの内容が不正なときに送出される。"""
+
+
+def load_config(path):
+    """JSON 設定を読み込み、検証してから返す。"""
+    with open(path, encoding="utf-8") as f:
+        cfg = json.load(f)
+    validate(cfg)
+    return cfg
+
+
+def topo_order(cfg):
+    """変数のトポロジカル順（親が先）。循環があれば ConfigError。"""
+    vars_ = list(cfg["variables"])
+    kernels = cfg.get("kernels", {})
+    parents = {v: kernels[v]["parents"] if v in kernels else [] for v in vars_}
+    order, seen, temp = [], set(), set()
+
+    def visit(v):
+        if v in seen:
+            return
+        if v in temp:
+            raise ConfigError(f"循環があります: {v}")
+        temp.add(v)
+        for p in parents[v]:
+            visit(p)
+        temp.discard(v)
+        seen.add(v)
+        order.append(v)
+
+    for v in vars_:
+        visit(v)
+    return order
+
+
+def validate(cfg):
+    """設定を検査する。問題があればすべてまとめて ConfigError で報告する。"""
+    errs = []
+    if "as_of" not in cfg:
+        errs.append("as_of（基準日 YYYY-MM-DD）がありません")
+    V = cfg.get("variables", {})
+    P = cfg.get("priors", {})
+    K = cfg.get("kernels", {})
+    if not V:
+        errs.append("variables が空です")
+    for v, spec in V.items():
+        labs = spec.get("labels", [])
+        if len(labs) < 2 or len(set(labs)) != len(labs):
+            errs.append(f"{v}: labels が不正 {labs}")
+        if (v in P) == (v in K):
+            errs.append(f"{v}: priors（根）か kernels（子）のどちらか一方にだけ定義してください")
+    for v in list(P) + list(K):
+        if v not in V:
+            errs.append(f"{v}: variables に未定義")
+
+    def check_dist(where, p, n):
+        if not isinstance(p, list) or len(p) != n:
+            errs.append(f"{where}: 長さ {n} のリストが必要（{p}）")
+            return
+        a = np.asarray(p, dtype=float)
+        if (a < -TOL).any():
+            errs.append(f"{where}: 負の確率 {p}")
+        if abs(a.sum() - 1) > TOL:
+            errs.append(f"{where}: 和が1でない（和={a.sum():.6f}）{p}")
+
+    for v, spec in P.items():
+        if v in V:
+            check_dist(f"priors.{v}", spec.get("p"), len(V[v]["labels"]))
+    for v, spec in K.items():
+        if v not in V:
+            continue
+        pars = spec.get("parents", [])
+        bad = [p for p in pars if p not in V]
+        if bad:
+            errs.append(f"kernels.{v}: 未定義の親 {bad}")
+            continue
+        cpt = spec.get("cpt", {})
+        want = {"|".join(c) for c in product(*[V[p]["labels"] for p in pars])}
+        have = set(cpt)
+        for k in sorted(want - have):
+            errs.append(f"kernels.{v}: 行が足りない「{k}」")
+        for k in sorted(have - want):
+            errs.append(f"kernels.{v}: 余分な行「{k}」（親のラベルと一致しない）")
+        for k in sorted(want & have):
+            check_dist(f"kernels.{v}[{k}]", cpt[k], len(V[v]["labels"]))
+    for name, ov in cfg.get("scenarios", {}).items():
+        for v, p in ov.items():
+            if v not in P:
+                errs.append(f"scenarios.{name}: {v} は根の変数ではない")
+            else:
+                check_dist(f"scenarios.{name}.{v}", p, len(V[v]["labels"]))
+    for ob in cfg.get("observations", []):
+        if ob.get("var") not in V or ob.get("label") not in V.get(ob.get("var"), {}).get("labels", []):
+            errs.append(f"observations: 不正な観測 {ob}")
+        for f in ob.get("focus", []):
+            if f not in V:
+                errs.append(f"observations: focus {f} が未定義")
+    for o in cfg.get("outputs", []):
+        if o not in V:
+            errs.append(f"outputs: {o} が未定義")
+    if not errs:
+        try:
+            topo_order(cfg)
+        except ConfigError as e:
+            errs.append(str(e))
+    if errs:
+        raise ConfigError("設定エラー:\n  - " + "\n  - ".join(errs))
+
+
+def config_hash(cfg):
+    """設定内容の短いハッシュ（キー順に依存しない）。"""
+    return hashlib.sha256(json.dumps(cfg, ensure_ascii=False, sort_keys=True).encode()).hexdigest()[:12]
+
+
+def dump_config(cfg):
+    """核の1行・ラベル列を1行にまとめた読みやすい JSON（差分が行単位で読める）。"""
+    s = json.dumps(cfg, ensure_ascii=False, indent=2)
+    s = re.sub(r"\[\s*((?:-?[0-9.eE+-]+\s*,\s*)*-?[0-9.eE+-]+)\s*\]",
+               lambda m: "[" + ", ".join(x.strip() for x in m.group(1).split(",")) + "]", s)
+    s = re.sub(r'\[\s*((?:"[^"\n]*"\s*,\s*)*"[^"\n]*")\s*\]',
+               lambda m: "[" + ", ".join(x.strip() for x in re.findall(r'"[^"\n]*"', m.group(1))) + "]", s)
+    return s + "\n"

fxtensor_bayesnet/history.py

@@ -0,0 +1,90 @@
+"""日次スナップショットと差分。"""
+from __future__ import annotations
+
+import json
+import os
+import re
+
+from .config import dump_config
+
+
+def snapshot(cfg, res, history_dir, force=False):
+    d = os.path.join(history_dir, cfg["as_of"])
+    if os.path.exists(d) and not force:
+        raise FileExistsError(f"{d} は既にあります（上書きするなら --force）")
+    os.makedirs(d, exist_ok=True)
+    with open(os.path.join(d, "config.json"), "w", encoding="utf-8") as f:
+        f.write(dump_config(cfg))
+    with open(os.path.join(d, "results.json"), "w", encoding="utf-8") as f:
+        json.dump(res, f, ensure_ascii=False, indent=2)
+    return d
+
+
+def previous_snapshot(history_dir, as_of):
+    """history_dir のうち as_of より前で最新の日付の config.json（なければ None）。"""
+    if not os.path.isdir(history_dir):
+        return None
+    dates = sorted(d for d in os.listdir(history_dir)
+                   if re.fullmatch(r"\d{4}-\d{2}-\d{2}", d) and d < as_of
+                   and os.path.exists(os.path.join(history_dir, d, "config.json")))
+    return os.path.join(history_dir, dates[-1], "config.json") if dates else None
+
+
+def diff_configs(old, new):
+    out = []
+    ov, nv = old.get("variables", {}), new.get("variables", {})
+    for v in sorted(set(ov) | set(nv)):
+        if v not in ov:
+            out.append(f"+ 変数追加 {v}: {nv[v]['labels']}")
+        elif v not in nv:
+            out.append(f"- 変数削除 {v}")
+        elif ov[v]["labels"] != nv[v]["labels"]:
+            out.append(f"~ ラベル変更 {v}: {ov[v]['labels']} → {nv[v]['labels']}")
+    for v in sorted(set(old.get("priors", {})) | set(new.get("priors", {}))):
+        a = old.get("priors", {}).get(v, {}).get("p")
+        b = new.get("priors", {}).get(v, {}).get("p")
+        if a != b:
+            out.append(f"~ 事前分布 {v}: {a} → {b}")
+    ok, nk = old.get("kernels", {}), new.get("kernels", {})
+    for v in sorted(set(ok) | set(nk)):
+        if v not in ok:
+            out.append(f"+ 核追加 {v} | {nk[v]['parents']}")
+            continue
+        if v not in nk:
+            out.append(f"- 核削除 {v}")
+            continue
+        if ok[v]["parents"] != nk[v]["parents"]:
+            out.append(f"~ 経路変更 {v}: 親 {ok[v]['parents']} → {nk[v]['parents']}")
+            continue
+        for row in nk[v]["cpt"]:
+            if ok[v]["cpt"].get(row) != nk[v]["cpt"][row]:
+                out.append(f"~ 核 {v}[{row}]: {ok[v]['cpt'].get(row)} → {nk[v]['cpt'][row]}")
+        if ok[v].get("reason") != nk[v].get("reason"):
+            out.append(f"~ 理由文 {v} を更新")
+    os_, ns = old.get("scenarios", {}), new.get("scenarios", {})
+    for s in sorted(set(os_) | set(ns)):
+        if os_.get(s) != ns.get(s):
+            out.append(f"~ シナリオ {s}: {os_.get(s)} → {ns.get(s)}")
+    if old.get("observations") != new.get("observations"):
+        out.append("~ observations を変更")
+    if old.get("outputs") != new.get("outputs"):
+        out.append(f"~ outputs: {old.get('outputs')} → {new.get('outputs')}")
+    return out or ["（設定の変更なし）"]
+
+
+def diff_results(old, new, threshold_pt=0.1):
+    out = []
+    for sc, r in new.get("シナリオ", {}).items():
+        o = old.get("シナリオ", {}).get(sc)
+        if not o:
+            out.append(f"+ シナリオ {sc}（前回なし）")
+            continue
+        for v, d in r["周辺"].items():
+            od = o["周辺"].get(v)
+            if od is None:
+                out.append(f"+ {sc} / {v}（前回なし）")
+                continue
+            delta = {lab: round((d[lab] - od.get(lab, 0)) * 100, 1) for lab in d}
+            if any(abs(x) >= threshold_pt for x in delta.values()):
+                out.append(f"~ {sc} / {v}: " + ", ".join(f"{lab} {x:+.1f}pt" for lab, x in delta.items()))
+    return out or ["（結果の変化なし）"]

fxtensor_bayesnet/i18n.py

@@ -0,0 +1,74 @@
+"""表示用の文言（Markdown と図）。results.json のキーは言語によらず固定。"""
+from __future__ import annotations
+
+LANGS = ("ja", "en")
+
+TEXT = {
+    "ja": {
+        "result_title": "# 結果（基準日 {as_of}{horizon}）",
+        "horizon_sep": "、",
+        "scenario": "シナリオ",
+        "base": "基本",
+        "bayes_header": "## ベイズ更新（基本）",
+        "obs_header": "### {obs} を観測（観測前の確率 {p:.1f}%）",
+        "ranking": "動きの大きさ順(TV)",
+        "delta": "差",
+        "checks": "検算",
+        "network_title": "ネットワーク構造",
+        "kind_root": "根（事前分布）",
+        "kind_middle": "中間変数",
+        "kind_output": "出力変数",
+        "marginals_title": "周辺分布のシナリオ比較（基準日 {as_of}）",
+        "prior": "事前",
+        "posterior": "事後",
+        "obs_annot": "観測: {obs}（観測前の確率 {p:.1f}%）",
+        "updates_title": "ベイズ更新：注目変数の事前・事後",
+        "change_pt": "変化（pt）",
+        "no_change": "変化なし",
+        "diff_title": "周辺分布の変化：{old} → {new}",
+        "previous": "前回",
+        "current": "今回",
+    },
+    "en": {
+        "result_title": "# Results (as of {as_of}{horizon})",
+        "horizon_sep": ", ",
+        "scenario": "Scenario",
+        "base": "Base",
+        "bayes_header": "## Bayesian updates (base)",
+        "obs_header": "### Observed {obs} (prior probability {p:.1f}%)",
+        "ranking": "Ranking by movement (TV)",
+        "delta": "change",
+        "checks": "Checks",
+        "network_title": "Network structure",
+        "kind_root": "Root (prior)",
+        "kind_middle": "Intermediate",
+        "kind_output": "Output",
+        "marginals_title": "Marginals by scenario (as of {as_of})",
+        "prior": "Prior",
+        "posterior": "Posterior",
+        "obs_annot": "Observed: {obs} (prior probability {p:.1f}%)",
+        "updates_title": "Bayesian update: prior vs posterior of focus variables",
+        "change_pt": "Change (pt)",
+        "no_change": "No change",
+        "diff_title": "Change in marginals: {old} → {new}",
+        "previous": "previous",
+        "current": "current",
+    },
+}
+
+
+def t(lang, key, **kw):
+    if lang not in TEXT:
+        raise ValueError(f"unsupported language: {lang} (choose from {', '.join(LANGS)})")
+    s = TEXT[lang][key]
+    return s.format(**kw) if kw else s
+
+
+def scenario_name(lang, name):
+    """結果内部のシナリオ名「基本」を表示言語に合わせる。"""
+    return t(lang, "base") if name == "基本" else name
+
+
+def obs_name(key):
+    """結果キー「var=label を観測」から「var=label」を取り出す。"""
+    return key.replace(" を観測", "")

fxtensor_bayesnet/inference.py

@@ -0,0 +1,144 @@
+"""推論：シナリオ別の周辺分布、観測によるベイズ更新、要因の逆算、einsum による検算。"""
+from __future__ import annotations
+
+import numpy as np
+from fxtensor_salmon import FXTensor
+
+from .config import config_hash
+from .network import Net, self_test_graph_extend, wiring
+
+MAX_JOINT = 2_000_000      # 同時分布の要素数がこれを超えたら祖先集合ごとの計算に切り替え
+
+
+def as_dict(labels, arr, nd=4):
+    return {lab: round(float(x), nd) for lab, x in zip(labels, arr)}
+
+
+def movement(prior, post, labels):
+    """事前→事後の動き（差・全変動距離・KL）。"""
+    p = np.asarray(prior, float)
+    q = np.array([post[lab] for lab in labels])
+    nz = q > 0
+    return {
+        "差(pt)": {lab: round(float((q[i] - p[i]) * 100), 1) for i, lab in enumerate(labels)},
+        "全変動距離TV": round(float(0.5 * np.abs(q - p).sum()), 4),
+        "KL(事後||事前)[nat]": round(float(np.sum(q[nz] * np.log(q[nz] / np.maximum(p[nz], 1e-300)))), 4),
+    }
+
+
+class Engine:
+    def __init__(self, net, priors, max_joint=MAX_JOINT):
+        self.net, self.priors = net, priors
+        self.mode = "joint" if net.joint_size() <= max_joint else "ancestral"
+        self.check_err = 0.0
+        if self.mode == "joint":
+            self.joint, self.names = net.build_joint(priors)
+            self.labs = [net.labels[v] for v in self.names]
+            perm = [net.order.index(v) for v in self.names]
+            self.check_err = float(np.max(np.abs(
+                np.transpose(self.joint.data, perm) - net.brute_force_joint(priors).transpose(perm)
+            )))
+
+    def marginal(self, v):
+        """周辺分布（joint: ライブラリの配線核で discard / ancestral: 祖先集合の einsum）。"""
+        if self.mode == "joint":
+            return self.joint.composition(wiring(self.labs, [self.names.index(v)])).data
+        return self.net.einsum_query(self.priors, [v])
+
+    def pair(self, a, b):
+        """I → a ⊗ b の同時状態（FXTensor）。"""
+        net = self.net
+        if self.mode == "joint":
+            return self.joint.composition(wiring(self.labs, [self.names.index(a), self.names.index(b)]))
+        return FXTensor([[], [net.labels[a], net.labels[b]]], data=net.einsum_query(self.priors, [a, b]))
+
+    def condition(self, obs, label):
+        """観測 obs=label の下での各変数の事後（(obs, v) の2変数状態を conditionalization(2)）。"""
+        net = self.net
+        ev = float(self.marginal(obs)[net.labels[obs].index(label)])
+        if ev <= 0:
+            raise ValueError(f"観測 {obs}={label} の確率が 0 のため条件付けできません")
+        post = {}
+        for v in net.order:
+            if v == obs:
+                continue
+            cond = self.pair(obs, v).conditionalization(2)            # obs → v
+            post[v] = as_dict(net.labels[v], cond.data[cond.get_label_index(0, label)])
+        return ev, post
+
+    def inversion_roots(self, obs, label):
+        """核 (根の全体)→obs を einsum で作り FXTensor.bayesian_inversion で根の事後を出す（要因の逆算）。"""
+        net = self.net
+        kdata = net.einsum_query(self.priors, [obs], free_roots=True)
+        k = FXTensor([[net.labels[r] for r in net.roots], [net.labels[obs]]], data=kdata)
+        assert k.is_markov()
+        inv = k.bayesian_inversion(net.prior_state(self.priors))
+        row = inv.data[inv.get_label_index(0, label)]
+        out = {}
+        for i, r in enumerate(net.roots):
+            axes = tuple(j for j in range(len(net.roots)) if j != i)
+            out[r] = as_dict(net.labels[r], row.sum(axis=axes) if axes else row)
+        return out
+
+
+def run(cfg, max_joint=MAX_JOINT):
+    """設定を計算して結果の辞書を返す。検算で食い違いがあれば AssertionError。"""
+    self_test_graph_extend()
+    net = Net(cfg)
+    base_pri = {v: cfg["priors"][v]["p"] for v in net.roots}
+    res = {
+        "基準日": cfg["as_of"], "ホライズン": cfg.get("horizon"), "注意": cfg.get("note"),
+        "設定ハッシュ": config_hash(cfg),
+        "事前分布(基本)": {v: as_dict(net.labels[v], base_pri[v]) for v in net.roots},
+        "シナリオ": {}, "ベイズ更新(基本)": {}, "検算": {},
+    }
+    checks = {"計算モード": None, "同時分布の要素数": net.joint_size(),
+              "einsum(全同時)との最大差": 0.0, "einsum(祖先集合・周辺)との最大差": 0.0,
+              "einsum(条件付け)との最大差": 0.0, "bayesian_inversionとconditionalizationの最大差": 0.0}
+    outputs = cfg.get("outputs") or [v for v in net.order if v not in net.roots]
+    for name, ov in {"基本": {}, **cfg.get("scenarios", {})}.items():
+        pri = {**base_pri, **ov}
+        eng = Engine(net, pri, max_joint)
+        checks["計算モード"] = eng.mode
+        checks["einsum(全同時)との最大差"] = max(checks["einsum(全同時)との最大差"], eng.check_err)
+        marg = {}
+        for v in outputs:
+            m = eng.marginal(v)
+            e = net.einsum_query(pri, [v])
+            checks["einsum(祖先集合・周辺)との最大差"] = max(checks["einsum(祖先集合・周辺)との最大差"],
+                                                       float(np.max(np.abs(m - e))))
+            marg[v] = as_dict(net.labels[v], m)
+        res["シナリオ"][name] = {"上書き": ov, "周辺": marg}
+
+    eng = Engine(net, base_pri, max_joint)
+    for ob in cfg.get("observations", []):
+        v, lab = ob["var"], ob["label"]
+        ev, post = eng.condition(v, lab)
+        for w, d in post.items():          # einsum 検算（祖先集合で (obs, w) を直接）
+            pr = net.einsum_query(base_pri, [v, w])
+            ref = pr[net.labels[v].index(lab)] / pr[net.labels[v].index(lab)].sum()
+            checks["einsum(条件付け)との最大差"] = max(checks["einsum(条件付け)との最大差"],
+                                                   float(np.max(np.abs(np.array(list(d.values())) - ref))))
+        inv = eng.inversion_roots(v, lab)
+        for r, d in inv.items():
+            if r != v:
+                checks["bayesian_inversionとconditionalizationの最大差"] = max(
+                    checks["bayesian_inversionとconditionalizationの最大差"],
+                    max(abs(d[lab_] - post[r][lab_]) for lab_ in d))
+        focus = ob.get("focus") or net.roots
+        prior_marg = {w: eng.marginal(w) for w in focus}
+        mv = {w: movement(prior_marg[w], post[w], net.labels[w]) for w in focus if w != v}
+        ranking = sorted(mv, key=lambda w: -mv[w]["全変動距離TV"])
+        res["ベイズ更新(基本)"][f"{v}={lab} を観測"] = {
+            "観測前の確率": round(ev, 4), "事後": post,
+            "注目変数の事前": {w: as_dict(net.labels[w], prior_marg[w]) for w in focus},
+            "注目変数の動き": mv, "動きの大きさ順(TV)": ranking,
+        }
+    for k in list(checks):
+        if isinstance(checks[k], float):
+            checks[k] = float(f"{checks[k]:.3g}")
+    checks["備考"] = "事後は小数4桁に丸めて出力するため、条件付けの差は丸め誤差（<5e-5）程度"
+    res["検算"] = checks
+    assert checks["einsum(全同時)との最大差"] < 1e-12 and checks["einsum(祖先集合・周辺)との最大差"] < 1e-12
+    assert checks["einsum(条件付け)との最大差"] < 1e-4 and checks["bayesian_inversionとconditionalizationの最大差"] < 1e-3
+    return res