feat：write 5 laws's data into sqlite.

db/reader.py

@@ -0,0 +1,199 @@
+# db/reader.py
+"""
+数据库查询模块
+- 排行榜查询
+- 模型详情查询
+- 断点续传状态查询
+"""
+
+import sqlite3
+import pandas as pd
+from db.schema import get_connection, init_db
+
+
+# ─────────────────────────────────────────────
+# 排行榜
+# ─────────────────────────────────────────────
+
+def get_leaderboard(
+    conn:          sqlite3.Connection,
+    prefix_filter: str  = None,   # 只看某个组件，None=全部
+    layer_type:    str  = "standard",
+    limit:         int  = 50,
+) -> pd.DataFrame:
+    """
+    排行榜查询
+    按 wang_score 降序排列
+    """
+    sql = """
+        SELECT
+            s.model_id,
+            s.prefix,
+            s.layer_type,
+            s.wang_score,
+            s.median_pearson_QK,
+            s.median_ssr_QK,
+            s.mean_ssr_QK,
+            s.median_cosU_QK,
+            s.median_cosU_QV,
+            s.median_cosV_QK,
+            s.median_cond_Q,
+            s.n_layers,
+            s.n_records,
+            s.updated_at,
+            -- 组件信息
+            c.head_dim_min,
+            c.head_dim_max,
+            c.has_kv_shared,
+            c.has_global,
+            c.d_model
+        FROM model_summary s
+        LEFT JOIN components c
+            ON s.model_id = c.model_id AND s.prefix = c.prefix
+        WHERE s.layer_type = ?
+    """
+    params = [layer_type]
+
+    if prefix_filter:
+        sql += " AND s.prefix LIKE ?"
+        params.append(f"%{prefix_filter}%")
+
+    sql += " ORDER BY s.wang_score DESC LIMIT ?"
+    params.append(limit)
+
+    cur = conn.cursor()
+    cur.execute(sql, params)
+    rows = cur.fetchall()
+
+    if not rows:
+        return pd.DataFrame()
+
+    cols = [d[0] for d in cur.description]
+    return pd.DataFrame([dict(zip(cols, row)) for row in rows])
+
+
+# ─────────────────────────────────────────────
+# 模型详情
+# ─────────────────────────────────────────────
+
+def get_model_summary(
+    conn:     sqlite3.Connection,
+    model_id: str,
+) -> pd.DataFrame:
+    """获取某模型所有组件的汇总统计"""
+    cur = conn.cursor()
+    cur.execute(
+        """
+        SELECT * FROM model_summary
+        WHERE model_id = ?
+        ORDER BY prefix, layer_type
+        """,
+        (model_id,)
+    )
+    rows = cur.fetchall()
+    if not rows:
+        return pd.DataFrame()
+    cols = [d[0] for d in cur.description]
+    return pd.DataFrame([dict(zip(cols, row)) for row in rows])
+
+
+def get_layer_metrics(
+    conn:       sqlite3.Connection,
+    model_id:   str,
+    prefix:     str = None,
+    layer_type: str = None,
+    start_layer:int = None,
+    end_layer:  int = None,
+) -> pd.DataFrame:
+    """
+    查询逐头原始数据
+    支持按 prefix / layer_type / 层号范围过滤
+    """
+    sql    = "SELECT * FROM layer_head_metrics WHERE model_id = ?"
+    params = [model_id]
+
+    if prefix:
+        sql += " AND prefix = ?"
+        params.append(prefix)
+    if layer_type:
+        sql += " AND layer_type = ?"
+        params.append(layer_type)
+    if start_layer is not None:
+        sql += " AND layer >= ?"
+        params.append(start_layer)
+    if end_layer is not None:
+        sql += " AND layer <= ?"
+        params.append(end_layer)
+
+    sql += " ORDER BY prefix, layer, kv_head, q_head"
+
+    cur = conn.cursor()
+    cur.execute(sql, params)
+    rows = cur.fetchall()
+
+    if not rows:
+        return pd.DataFrame()
+    cols = [d[0] for d in cur.description]
+    return pd.DataFrame([dict(zip(cols, row)) for row in rows])
+
+
+def get_analyzed_models(conn: sqlite3.Connection) -> pd.DataFrame:
+    """获取所有已分析模型列表"""
+    cur = conn.cursor()
+    cur.execute(
+        """
+        SELECT
+            m.model_id,
+            m.model_type,
+            m.analyzed_at,
+            m.analyze_sec,
+            COUNT(DISTINCT c.prefix) as n_components,
+            SUM(c.n_layers) as total_layers
+        FROM models m
+        LEFT JOIN components c ON m.model_id = c.model_id
+        GROUP BY m.model_id
+        ORDER BY m.analyzed_at DESC
+        """
+    )
+    rows = cur.fetchall()
+    if not rows:
+        return pd.DataFrame()
+    cols = [d[0] for d in cur.description]
+    return pd.DataFrame([dict(zip(cols, row)) for row in rows])
+
+
+# ─────────────────────────────────────────────
+# 断点续传状态
+# ─────────────────────────────────────────────
+
+def get_resume_status(
+    conn:     sqlite3.Connection,
+    model_id: str,
+    prefix:   str,
+) -> dict:
+    """
+    查询某 (model_id, prefix) 的断点续传状态
+    返回已完成的层号集合和统计信息
+    """
+    cur = conn.cursor()
+
+    # 已完成的层
+    cur.execute(
+        """
+        SELECT DISTINCT layer, COUNT(*) as n_heads
+        FROM layer_head_metrics
+        WHERE model_id = ? AND prefix = ?
+        GROUP BY layer
+        ORDER BY layer
+        """,
+        (model_id, prefix)
+    )
+    rows = cur.fetchall()
+
+    done_layers = {r[0]: r[1] for r in rows}
+
+    return {
+        "done_layers":  set(done_layers.keys()),
+        "layer_detail": done_layers,   # layer → n_heads
+        "total_done":   len(done_layers),
+    }

db/schema.py

@@ -0,0 +1,208 @@
+# db/schema.py
+"""
+数据库表结构定义与初始化
+SQLite 存储在 /data/wang_laws.db（HF Space bucket 持久化）
+"""
+
+import sqlite3
+import os
+from datetime import datetime
+
+# ─────────────────────────────────────────────
+# 数据库路径
+# /data 是 HF Space bucket 挂载点，重启后数据不丢失
+# 本地开发时自动回退到当前目录
+# ─────────────────────────────────────────────
+
+def get_db_path() -> str:
+    if os.path.exists("/data"):
+        return "/data/wang_laws.db"
+    return "wang_laws.db"
+
+
+def get_connection() -> sqlite3.Connection:
+    """获取数据库连接，启用 WAL 模式提升并发性能"""
+    conn = sqlite3.connect(get_db_path(), check_same_thread=False)
+    conn.row_factory = sqlite3.Row      # 支持按列名访问
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA foreign_keys=ON")
+    return conn
+
+
+# ─────────────────────────────────────────────
+# 建表 SQL
+# ─────────────────────────────────────────────
+
+SQL_CREATE_MODELS = """
+CREATE TABLE IF NOT EXISTS models (
+    model_id      TEXT PRIMARY KEY,
+    model_type    TEXT,              -- gemma4 / llama / qwen2 等
+    analyzed_at   TIMESTAMP,
+    analyze_sec   REAL,              -- 分析耗时（秒）
+    notes         TEXT               -- 备注
+);
+"""
+
+SQL_CREATE_COMPONENTS = """
+CREATE TABLE IF NOT EXISTS components (
+    id            INTEGER PRIMARY KEY AUTOINCREMENT,
+    model_id      TEXT NOT NULL,
+    prefix        TEXT NOT NULL,     -- 如 model.language_model.
+    n_layers      INTEGER,           -- 该组件完整层数
+    head_dim_min  INTEGER,           -- 最小 head_dim（异构层用）
+    head_dim_max  INTEGER,           -- 最大 head_dim
+    has_kv_shared INTEGER DEFAULT 0, -- 是否有 K=V 共享层（全局层）
+    has_global    INTEGER DEFAULT 0, -- 是否有 global 层
+    d_model       INTEGER,           -- 输入维度
+    UNIQUE(model_id, prefix),
+    FOREIGN KEY(model_id) REFERENCES models(model_id)
+);
+"""
+
+SQL_CREATE_LAYER_HEAD_METRICS = """
+CREATE TABLE IF NOT EXISTS layer_head_metrics (
+    id            INTEGER PRIMARY KEY AUTOINCREMENT,
+    model_id      TEXT NOT NULL,
+    prefix        TEXT NOT NULL,
+    layer         INTEGER NOT NULL,
+    layer_type    TEXT DEFAULT 'standard', -- standard / global
+    kv_head       INTEGER NOT NULL,
+    q_head        INTEGER NOT NULL,
+    kv_shared     INTEGER DEFAULT 0,  -- 1=K=V共享（理论值），0=独立V
+    head_dim      INTEGER,
+    d_model       INTEGER,
+    n_q_heads     INTEGER,
+    n_kv_heads    INTEGER,
+    -- 第一定律：谱线性对齐
+    pearson_QK    REAL,
+    spearman_QK   REAL,
+    pearson_QV    REAL,
+    pearson_KV    REAL,
+    -- 第二定律：谱形状残差
+    ssr_QK        REAL,
+    ssr_QV        REAL,
+    ssr_KV        REAL,
+    -- 第三定律：条件数
+    sigma_max_Q   REAL,
+    sigma_min_Q   REAL,
+    cond_Q        REAL,
+    sigma_max_K   REAL,
+    sigma_min_K   REAL,
+    cond_K        REAL,
+    sigma_max_V   REAL,
+    sigma_min_V   REAL,
+    cond_V        REAL,
+    -- 第四定律：左奇异向量对齐（输出子空间）
+    cosU_QK       REAL,
+    cosU_QV       REAL,
+    cosU_KV       REAL,
+    -- 第五定律：右奇异向量对齐（输入子空间）
+    cosV_QK       REAL,
+    cosV_QV       REAL,
+    cosV_KV       REAL,
+    -- 尺度因子 + 最小二乘残差
+    alpha_QK      REAL,
+    alpha_res_QK  REAL,
+    alpha_QV      REAL,
+    alpha_res_QV  REAL,
+    alpha_KV      REAL,
+    alpha_res_KV  REAL,
+
+    UNIQUE(model_id, prefix, layer, kv_head, q_head),
+    FOREIGN KEY(model_id) REFERENCES models(model_id)
+);
+"""
+
+SQL_CREATE_MODEL_SUMMARY = """
+CREATE TABLE IF NOT EXISTS model_summary (
+    model_id          TEXT NOT NULL,
+    prefix            TEXT NOT NULL,
+    layer_type        TEXT NOT NULL DEFAULT 'all', -- all / standard / global
+    -- 第一定律
+    median_pearson_QK REAL,
+    mean_pearson_QK   REAL,
+    -- 第二定律（王氏评分核心）
+    median_ssr_QK     REAL,
+    mean_ssr_QK       REAL,
+    median_ssr_QV     REAL,
+    mean_ssr_QV       REAL,
+    -- 第三定律
+    median_cond_Q     REAL,
+    mean_cond_Q       REAL,
+    -- 第四定律
+    median_cosU_QK    REAL,
+    median_cosU_QV    REAL,
+    -- 第五定律
+    median_cosV_QK    REAL,
+    median_cosV_QV    REAL,
+    -- 王氏评分（暂时 = 1 - median_ssr_QK，基于 standard 层）
+    wang_score        REAL,
+    -- 统计范围
+    n_layers          INTEGER,  -- 参与统计的层数
+    n_records         INTEGER,  -- 参与统计的记录数
+    updated_at        TIMESTAMP,
+
+    PRIMARY KEY(model_id, prefix, layer_type),
+    FOREIGN KEY(model_id) REFERENCES models(model_id)
+);
+"""
+
+# 索引：加速常用查询
+SQL_CREATE_INDEXES = [
+    # 按模型+组件查询层数据
+    """CREATE INDEX IF NOT EXISTS idx_metrics_model_prefix
+       ON layer_head_metrics(model_id, prefix)""",
+    # 按层号范围查询
+    """CREATE INDEX IF NOT EXISTS idx_metrics_layer
+       ON layer_head_metrics(model_id, prefix, layer)""",
+    # 排行榜查询
+    """CREATE INDEX IF NOT EXISTS idx_summary_wang_score
+       ON model_summary(wang_score DESC)""",
+    # 断点续传：快速判断某层是否已分析
+    """CREATE INDEX IF NOT EXISTS idx_metrics_resume
+       ON layer_head_metrics(model_id, prefix, layer, kv_head, q_head)""",
+]
+
+
+# ─────────────────────────────────────────────
+# 初始化函数
+# ─────────────────────────────────────────────
+
+def init_db() -> sqlite3.Connection:
+    """
+    初始化数据库：建表 + 建索引
+    幂等操作，重复调用安全
+    返回数据库连接
+    """
+    conn = get_connection()
+    cur  = conn.cursor()
+
+    cur.execute(SQL_CREATE_MODELS)
+    cur.execute(SQL_CREATE_COMPONENTS)
+    cur.execute(SQL_CREATE_LAYER_HEAD_METRICS)
+    cur.execute(SQL_CREATE_MODEL_SUMMARY)
+
+    for sql in SQL_CREATE_INDEXES:
+        cur.execute(sql)
+
+    conn.commit()
+    return conn
+
+
+def get_db_stats(conn: sqlite3.Connection) -> dict:
+    """获取数据库统计信息"""
+    cur = conn.cursor()
+    stats = {}
+
+    for table in ["models", "components", "layer_head_metrics", "model_summary"]:
+        cur.execute(f"SELECT COUNT(*) FROM {table}")
+        stats[table] = cur.fetchone()[0]
+
+    # 数据库文件大小
+    db_path = get_db_path()
+    if os.path.exists(db_path):
+        stats["db_size_mb"] = round(os.path.getsize(db_path) / 1024 / 1024, 2)
+    else:
+        stats["db_size_mb"] = 0
+
+    return stats

db/writer.py

@@ -0,0 +1,375 @@
+# db/writer.py
+"""
+数据库写入模块
+- 写入分析结果到 layer_head_metrics
+- 计算并写入 model_summary
+- 支持断点续传（以 prefix+layer 为粒度）
+"""
+
+import sqlite3
+import numpy as np
+from datetime import datetime
+from db.schema import get_connection, init_db
+
+
+# ─────────────────────────────────────────────
+# layer_type 推断
+# ─────────────────────────────────────────────
+
+def infer_layer_type(kv_shared: bool) -> str:
+    """
+    从 kv_shared 推断层类型
+    kv_shared=True  → 'global'  （K=V共享，如 Gemma-4-31B 全局层）
+    kv_shared=False → 'standard'
+    零 hard coding，纯从结构特征推断
+    """
+    return "global" if kv_shared else "standard"
+
+
+# ─────────────────────────────────────────────
+# 断点续传：检查已完成的层
+# ─────────────────────────────────────────────
+
+def get_analyzed_layers(
+    conn:     sqlite3.Connection,
+    model_id: str,
+    prefix:   str,
+) -> set[int]:
+    """
+    返回已完成分析的层号集合
+    用于断点续传：跳过已有数据的层
+    粒度：(model_id, prefix, layer)
+    """
+    cur = conn.cursor()
+    cur.execute(
+        """
+        SELECT DISTINCT layer
+        FROM layer_head_metrics
+        WHERE model_id = ? AND prefix = ?
+        """,
+        (model_id, prefix)
+    )
+    return {row[0] for row in cur.fetchall()}
+
+
+def is_layer_complete(
+    conn:     sqlite3.Connection,
+    model_id: str,
+    prefix:   str,
+    layer:    int,
+    expected_records: int,
+) -> bool:
+    """
+    检查某层是否已完整写入
+    expected_records = n_q_heads（该层应有的记录数）
+    """
+    cur = conn.cursor()
+    cur.execute(
+        """
+        SELECT COUNT(*)
+        FROM layer_head_metrics
+        WHERE model_id = ? AND prefix = ? AND layer = ?
+        """,
+        (model_id, prefix, layer)
+    )
+    actual = cur.fetchone()[0]
+    return actual >= expected_records
+
+
+# ─────────────────────────────────────────────
+# 写入模型元数据
+# ─────────────────────────────────────────────
+
+def upsert_model(
+    conn:       sqlite3.Connection,
+    model_id:   str,
+    model_type: str = None,
+    notes:      str = None,
+):
+    """写入或更新模型基本信息"""
+    conn.execute(
+        """
+        INSERT INTO models(model_id, model_type, analyzed_at, notes)
+        VALUES(?, ?, ?, ?)
+        ON CONFLICT(model_id) DO UPDATE SET
+            model_type  = excluded.model_type,
+            analyzed_at = excluded.analyzed_at,
+            notes       = excluded.notes
+        """,
+        (model_id, model_type, datetime.utcnow().isoformat(), notes)
+    )
+    conn.commit()
+
+
+def upsert_component(
+    conn:         sqlite3.Connection,
+    model_id:     str,
+    prefix:       str,
+    n_layers:     int,
+    head_dim_min: int,
+    head_dim_max: int,
+    has_kv_shared:bool,
+    has_global:   bool,
+    d_model:      int,
+):
+    """写入或更新组件信息"""
+    conn.execute(
+        """
+        INSERT INTO components(
+            model_id, prefix, n_layers,
+            head_dim_min, head_dim_max,
+            has_kv_shared, has_global, d_model
+        )
+        VALUES(?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(model_id, prefix) DO UPDATE SET
+            n_layers      = excluded.n_layers,
+            head_dim_min  = excluded.head_dim_min,
+            head_dim_max  = excluded.head_dim_max,
+            has_kv_shared = excluded.has_kv_shared,
+            has_global    = excluded.has_global,
+            d_model       = excluded.d_model
+        """,
+        (
+            model_id, prefix, n_layers,
+            head_dim_min, head_dim_max,
+            int(has_kv_shared), int(has_global), d_model
+        )
+    )
+    conn.commit()
+
+
+# ─────────────────────────────────────────────
+# 写入逐头指标
+# ─────────────────────────────────────────────
+
+def write_layer_records(
+    conn:     sqlite3.Connection,
+    model_id: str,
+    records:  list[dict],
+):
+    """
+    批量写入一层的逐头指标
+    使用 INSERT OR REPLACE 实现幂等写入
+    """
+    if not records:
+        return
+
+    rows = []
+    for r in records:
+        layer_type = infer_layer_type(bool(r.get("kv_shared", False)))
+        rows.append((
+            model_id,
+            r["prefix"],
+            r["layer"],
+            layer_type,
+            r["kv_head"],
+            r["q_head"],
+            int(r.get("kv_shared", False)),
+            r.get("head_dim"),
+            r.get("d_model"),
+            r.get("n_q_heads"),
+            r.get("n_kv_heads"),
+            # 第一定律
+            r.get("pearson_QK"),
+            r.get("spearman_QK"),
+            r.get("pearson_QV"),
+            r.get("pearson_KV"),
+            # 第二定律
+            r.get("ssr_QK"),
+            r.get("ssr_QV"),
+            r.get("ssr_KV"),
+            # 第三定律
+            r.get("sigma_max_Q"),
+            r.get("sigma_min_Q"),
+            r.get("cond_Q"),
+            r.get("sigma_max_K"),
+            r.get("sigma_min_K"),
+            r.get("cond_K"),
+            r.get("sigma_max_V"),
+            r.get("sigma_min_V"),
+            r.get("cond_V"),
+            # 第四定律
+            r.get("cosU_QK"),
+            r.get("cosU_QV"),
+            r.get("cosU_KV"),
+            # 第五定律
+            r.get("cosV_QK"),
+            r.get("cosV_QV"),
+            r.get("cosV_KV"),
+            # 尺度因子
+            r.get("alpha_QK"),
+            r.get("alpha_res_QK"),
+            r.get("alpha_QV"),
+            r.get("alpha_res_QV"),
+            r.get("alpha_KV"),
+            r.get("alpha_res_KV"),
+        ))
+
+    conn.executemany(
+        """
+        INSERT OR REPLACE INTO layer_head_metrics(
+            model_id, prefix, layer, layer_type,
+            kv_head, q_head, kv_shared,
+            head_dim, d_model, n_q_heads, n_kv_heads,
+            pearson_QK, spearman_QK, pearson_QV, pearson_KV,
+            ssr_QK, ssr_QV, ssr_KV,
+            sigma_max_Q, sigma_min_Q, cond_Q,
+            sigma_max_K, sigma_min_K, cond_K,
+            sigma_max_V, sigma_min_V, cond_V,
+            cosU_QK, cosU_QV, cosU_KV,
+            cosV_QK, cosV_QV, cosV_KV,
+            alpha_QK, alpha_res_QK,
+            alpha_QV, alpha_res_QV,
+            alpha_KV, alpha_res_KV
+        ) VALUES (
+            ?,?,?,?,?,?,?,?,?,?,?,
+            ?,?,?,?,?,?,?,
+            ?,?,?,?,?,?,?,?,?,
+            ?,?,?,?,?,?,
+            ?,?,?,?,?,?
+        )
+        """,
+        rows
+    )
+    conn.commit()
+
+
+# ─────────────────────────────────────────────
+# 计算并写入 model_summary
+# ─────────────────────────────────────────────
+
+def _calc_summary_row(
+    rows: list[sqlite3.Row],
+    model_id: str,
+    prefix: str,
+    layer_type: str,
+) -> dict | None:
+    """
+    从一组 layer_head_metrics 行计算汇总统计
+    返回 model_summary 的一行
+    """
+    if not rows:
+        return None
+
+    def col(name):
+        vals = [r[name] for r in rows if r[name] is not None]
+        return np.array(vals) if vals else np.array([])
+
+    def med(arr):
+        return float(np.median(arr)) if len(arr) > 0 else None
+
+    def avg(arr):
+        return float(np.mean(arr)) if len(arr) > 0 else None
+
+    ssr_qk = col("ssr_QK")
+    wang_score = float(1 - np.median(ssr_qk)) if len(ssr_qk) > 0 else None
+
+    # 统计层数（去重）
+    n_layers  = len(set(r["layer"] for r in rows))
+    n_records = len(rows)
+
+    return {
+        "model_id":          model_id,
+        "prefix":            prefix,
+        "layer_type":        layer_type,
+        "median_pearson_QK": med(col("pearson_QK")),
+        "mean_pearson_QK":   avg(col("pearson_QK")),
+        "median_ssr_QK":     med(ssr_qk),
+        "mean_ssr_QK":       avg(ssr_qk),
+        "median_ssr_QV":     med(col("ssr_QV")),
+        "mean_ssr_QV":       avg(col("ssr_QV")),
+        "median_cond_Q":     med(col("cond_Q")),
+        "mean_cond_Q":       avg(col("cond_Q")),
+        "median_cosU_QK":    med(col("cosU_QK")),
+        "median_cosU_QV":    med(col("cosU_QV")),
+        "median_cosV_QK":    med(col("cosV_QK")),
+        "median_cosV_QV":    med(col("cosV_QV")),
+        "wang_score":        wang_score,
+        "n_layers":          n_layers,
+        "n_records":         n_records,
+        "updated_at":        datetime.utcnow().isoformat(),
+    }
+
+
+def update_model_summary(
+    conn:     sqlite3.Connection,
+    model_id: str,
+    prefix:   str,
+):
+    """
+    重新计算并写入 model_summary
+    对每个 (model_id, prefix) 生成三行：
+      - layer_type='all'
+      - layer_type='standard'
+      - layer_type='global'
+    王氏评分固定用 standard 层计算
+    """
+    cur = conn.cursor()
+
+    for layer_type in ["all", "standard", "global"]:
+        # 查询对应数据
+        if layer_type == "all":
+            cur.execute(
+                """
+                SELECT * FROM layer_head_metrics
+                WHERE model_id = ? AND prefix = ?
+                """,
+                (model_id, prefix)
+            )
+        else:
+            cur.execute(
+                """
+                SELECT * FROM layer_head_metrics
+                WHERE model_id = ? AND prefix = ? AND layer_type = ?
+                """,
+                (model_id, prefix, layer_type)
+            )
+
+        rows = cur.fetchall()
+        summary = _calc_summary_row(rows, model_id, prefix, layer_type)
+
+        if summary is None:
+            continue
+
+        # 王氏评分统一用 standard 层（如果当前是 all/global，重新取 standard 的 ssr）
+        if layer_type != "standard":
+            cur.execute(
+                """
+                SELECT ssr_QK FROM layer_head_metrics
+                WHERE model_id = ? AND prefix = ? AND layer_type = 'standard'
+                """,
+                (model_id, prefix)
+            )
+            std_rows = cur.fetchall()
+            if std_rows:
+                std_ssr = np.array([r[0] for r in std_rows if r[0] is not None])
+                summary["wang_score"] = float(1 - np.median(std_ssr)) if len(std_ssr) > 0 else None
+
+        conn.execute(
+            """
+            INSERT OR REPLACE INTO model_summary(
+                model_id, prefix, layer_type,
+                median_pearson_QK, mean_pearson_QK,
+                median_ssr_QK, mean_ssr_QK,
+                median_ssr_QV, mean_ssr_QV,
+                median_cond_Q, mean_cond_Q,
+                median_cosU_QK, median_cosU_QV,
+                median_cosV_QK, median_cosV_QV,
+                wang_score,
+                n_layers, n_records, updated_at
+            ) VALUES (
+                :model_id, :prefix, :layer_type,
+                :median_pearson_QK, :mean_pearson_QK,
+                :median_ssr_QK, :mean_ssr_QK,
+                :median_ssr_QV, :mean_ssr_QV,
+                :median_cond_Q, :mean_cond_Q,
+                :median_cosU_QK, :median_cosU_QV,
+                :median_cosV_QK, :median_cosV_QV,
+                :wang_score,
+                :n_layers, :n_records, :updated_at
+            )
+            """,
+            summary
+        )
+
+    conn.commit()