feat(db+ui): add modality dimension & migrate legacy data

Introduce `modality` (language/vision/audio) as a first-class dimension
alongside the existing `layer_type` (standard/global), fixing misleading
total_layers display for multi-modal models (Gemma-4 series).

---

1. `total_layers` mixed audio+vision+language into one number —
meaningless for multi-modal models like gemma-4-31b-it.
2. Layer-type dropdown showed "standard/global" (structural concept)
where users expected "language/vision/audio" (modality concept).
3. These two concepts (structure vs modality) were conflated in one field.

---

- Add `modality TEXT DEFAULT 'language'` to `layer_head_metrics`
- Add `modality TEXT DEFAULT 'language'` to `components`
- Add `_migrate_add_modality()`: idempotent ALTER TABLE migration
- Runs on every `init_db()` startup
- Detects missing column via `PRAGMA table_info()`
- Backfills legacy rows via keyword matching on `prefix`
- vision: LIKE '%vision%' OR '%visual%' OR '%image%'
- audio: LIKE '%audio%' OR '%speech%' OR '%acoustic%'
- language: DEFAULT (covers pure-text models e.g. LLaMA, Qwen)
- Add indexes: `idx_metrics_modality`, `idx_components_modality`

- Add `infer_modality(prefix: str) -> str`
- Keyword match on lowercased prefix, no model-name hard-coding
- Default → 'language' (covers "model." prefix of LLaMA/Qwen)
- `write_layer_records()`: fill `modality` column on every insert
- `upsert_component()`: fill `modality` column on every insert

- `get_analyzed_models()`:
- Remove `total_layers`
- Add `language_layers`, `vision_layers`, `audio_layers`
via CASE WHEN aggregation (auto-includes standard+global)
- Add `get_model_components()`:
- Returns raw components rows for a model (Plan B detail view)
- `get_layer_metrics()`:
- Add `modality` filter parameter (independent of `layer_type`)
- Both filters composable: e.g. modality='language' + layer_type='global'
- `get_leaderboard()`:
- Replace `prefix_filter` text param with `modality` dropdown param
- Default modality='language' (leaderboard targets text reasoning)

---

- Model list (Plan A): show language/vision/audio layer counts separately
- vision/audio show "" when 0 (cleaner display)
- Model detail (Plan B): add `components_table` showing raw prefix rows
- Expandable detail alongside summary stats
- Raw data query: split single dropdown into two independent dropdowns
- Modality: [all | language | vision | audio]
- Layer Type: [all | standard | global]
- info text explains each option in EN + 中文

- Replace `prefix_filter` Textbox with `modality` Dropdown
- Choices: [language | vision | audio | all]
- Default: 'language' (standard use case)
- Add `modality` column to leaderboard display table

---

- `total_layers` removed: language_layers = SUM(n_layers) per modality,
naturally includes all layer_types under same prefix
- `layer_type` (standard/global) retained: orthogonal structural dimension
- Future unknown layer types → default to 'language' (no schema change needed)
- `model_summary` table unchanged: leaderboard filters via components JOIN

---

- Zero breaking changes to core/ and tab_analyze.py
- Migration is idempotent: safe to deploy on existing DB
- New DB: modality column present from creation, migration is no-op

db/reader.py

@@ -2,7 +2,8 @@
 """
 数据库查询模块
 - 排行榜查询
-- 模型详情查询
+- 模型详情查询（方案A：按modality聚合 + 方案B：原始components行）
+- 逐头原始数据查询
 - 断点续传状态查询
 """
 
@@ -17,13 +18,13 @@ from db.schema import get_connection, init_db
 
 def get_leaderboard(
     conn:          sqlite3.Connection,
-    prefix_filter: str  = None,   # 只看某个组件，None=全部
+    modality:      str  = "language",   # language/vision/audio/all
     layer_type:    str  = "standard",
-    limit:         int  = 50,
+    limit:         int  = 100,
 ) -> pd.DataFrame:
     """
-    排行榜查询
-    按 wang_score 降序排列
+    排行榜查询，按 wang_score 降序。
+    modality 过滤通过 components 表的 prefix 关联实现。
     """
     sql = """
         SELECT
@@ -41,7 +42,7 @@ def get_leaderboard(
             s.n_layers,
             s.n_records,
             s.updated_at,
-            -- 组件信息
+            c.modality,
             c.head_dim_min,
             c.head_dim_max,
             c.has_kv_shared,
@@ -54,9 +55,9 @@ def get_leaderboard(
     """
     params = [layer_type]
 
-    if prefix_filter:
-        sql += " AND s.prefix LIKE ?"
-        params.append(f"%{prefix_filter}%")
+    if modality != "all":
+        sql += " AND c.modality = ?"
+        params.append(modality)
 
     sql += " ORDER BY s.wang_score DESC LIMIT ?"
     params.append(limit)
@@ -64,18 +65,80 @@ def get_leaderboard(
     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])
+
+
+# ─────────────────────────────────────────────
+# 模型列表（方案A：按modality聚合）
+# ─────────────────────────────────────────────
 
+def get_analyzed_models(conn: sqlite3.Connection) -> pd.DataFrame:
+    """
+    模型列表，按 modality 聚合层数。
+    language_layers = SUM(n_layers) WHERE modality='language'
+    自动包含 standard + global 层（同一 prefix 下）。
+    """
+    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(CASE WHEN c.modality = 'language'
+                THEN c.n_layers ELSE 0 END) AS language_layers,
+            SUM(CASE WHEN c.modality = 'vision'
+                THEN c.n_layers ELSE 0 END) AS vision_layers,
+            SUM(CASE WHEN c.modality = 'audio'
+                THEN c.n_layers ELSE 0 END) AS audio_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])
 
 
 # ─────────────────────────────────────────────
-# 模型详情
+# 模型详情（方案B：原始components行）
 # ─────────────────────────────────────────────
 
+def get_model_components(
+    conn:     sqlite3.Connection,
+    model_id: str,
+) -> pd.DataFrame:
+    """
+    返回某模型的原始 components 行（方案B详情展开用）。
+    每行 = 一个 prefix，含 modality/n_layers/head_dim 等。
+    """
+    cur = conn.cursor()
+    cur.execute(
+        """SELECT
+               prefix, modality, n_layers,
+               head_dim_min, head_dim_max,
+               has_kv_shared, has_global, d_model
+           FROM components
+           WHERE model_id = ?
+           ORDER BY modality, prefix""",
+        (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_model_summary(
     conn:     sqlite3.Connection,
     model_id: str,
@@ -83,11 +146,9 @@ def get_model_summary(
     """获取某模型所有组件的汇总统计"""
     cur = conn.cursor()
     cur.execute(
-        """
-        SELECT * FROM model_summary
-        WHERE model_id = ?
-        ORDER BY prefix, layer_type
-        """,
+        """SELECT * FROM model_summary
+           WHERE model_id = ?
+           ORDER BY prefix, layer_type""",
         (model_id,)
     )
     rows = cur.fetchall()
@@ -97,17 +158,22 @@ def get_model_summary(
     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,
+    conn:        sqlite3.Connection,
+    model_id:    str,
+    prefix:      str  = None,
+    modality:    str  = None,   # language/vision/audio
+    layer_type:  str  = None,   # standard/global
+    start_layer: int  = None,
+    end_layer:   int  = None,
 ) -> pd.DataFrame:
     """
-    查询逐头原始数据
-    支持按 prefix / layer_type / 层号范围过滤
+    逐头原始数据查询。
+    modality 和 layer_type 是两个独立维度，可以组合过滤。
     """
     sql    = "SELECT * FROM layer_head_metrics WHERE model_id = ?"
     params = [model_id]
@@ -115,6 +181,9 @@ def get_layer_metrics(
     if prefix:
         sql += " AND prefix = ?"
         params.append(prefix)
+    if modality:
+        sql += " AND modality = ?"
+        params.append(modality)
     if layer_type:
         sql += " AND layer_type = ?"
         params.append(layer_type)
@@ -130,32 +199,6 @@ def get_layer_metrics(
     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]
@@ -171,29 +214,18 @@ def get_resume_status(
     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
-        """,
+        """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
+        "layer_detail": done_layers,
         "total_done":   len(done_layers),
     }

db/schema.py

@@ -8,11 +8,6 @@ import sqlite3
 import os
 from datetime import datetime
 
-# ─────────────────────────────────────────────
-# 数据库路径
-# /data 是 HF Space bucket 挂载点，重启后数据不丢失
-# 本地开发时自动回退到当前目录
-# ─────────────────────────────────────────────
 
 def get_db_path() -> str:
     if os.path.exists("/data"):
@@ -21,9 +16,8 @@ def get_db_path() -> str:
 
 
 def get_connection() -> sqlite3.Connection:
-    """获取数据库连接，启用 WAL 模式提升并发性能"""
     conn = sqlite3.connect(get_db_path(), check_same_thread=False)
-    conn.row_factory = sqlite3.Row      # 支持按列名访问
+    conn.row_factory = sqlite3.Row
     conn.execute("PRAGMA journal_mode=WAL")
     conn.execute("PRAGMA foreign_keys=ON")
     return conn
@@ -36,10 +30,10 @@ def get_connection() -> sqlite3.Connection:
 SQL_CREATE_MODELS = """
 CREATE TABLE IF NOT EXISTS models (
     model_id      TEXT PRIMARY KEY,
-    model_type    TEXT,              -- gemma4 / llama / qwen2 等
+    model_type    TEXT,
     analyzed_at   TIMESTAMP,
-    analyze_sec   REAL,              -- 分析耗时（秒）
-    notes         TEXT               -- 备注
+    analyze_sec   REAL,
+    notes         TEXT
 );
 """
 
@@ -47,13 +41,14 @@ 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,           -- 输入维度
+    prefix        TEXT NOT NULL,
+    modality      TEXT DEFAULT 'language',  -- language/vision/audio
+    n_layers      INTEGER,
+    head_dim_min  INTEGER,
+    head_dim_max  INTEGER,
+    has_kv_shared INTEGER DEFAULT 0,
+    has_global    INTEGER DEFAULT 0,
+    d_model       INTEGER,
     UNIQUE(model_id, prefix),
     FOREIGN KEY(model_id) REFERENCES models(model_id)
 );
@@ -65,48 +60,32 @@ CREATE TABLE IF NOT EXISTS layer_head_metrics (
     model_id      TEXT NOT NULL,
     prefix        TEXT NOT NULL,
     layer         INTEGER NOT NULL,
-    layer_type    TEXT DEFAULT 'standard', -- standard / global
+    layer_type    TEXT DEFAULT 'standard',  -- standard/global
+    modality      TEXT DEFAULT 'language',  -- language/vision/audio
     kv_head       INTEGER NOT NULL,
     q_head        INTEGER NOT NULL,
-    kv_shared     INTEGER DEFAULT 0,  -- 1=K=V共享（理论值），0=独立V
+    kv_shared     INTEGER DEFAULT 0,
     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,
+    -- 第一定律
+    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)
@@ -117,29 +96,23 @@ 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
+    layer_type        TEXT NOT NULL DEFAULT 'all',
     -- 第一定律
-    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_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_cond_Q     REAL, mean_cond_Q     REAL,
     -- 第四定律
-    median_cosU_QK    REAL,
-    median_cosU_QV    REAL,
+    median_cosU_QK    REAL, median_cosU_QV  REAL,
     -- 第五定律
-    median_cosV_QK    REAL,
-    median_cosV_QV    REAL,
-    -- 王氏评分（暂时 = 1 - median_ssr_QK，基于 standard 层）
+    median_cosV_QK    REAL, median_cosV_QV  REAL,
+    -- 王氏评分
     wang_score        REAL,
     -- 统计范围
-    n_layers          INTEGER,  -- 参与统计的层数
-    n_records         INTEGER,  -- 参与统计的记录数
+    n_layers          INTEGER,
+    n_records         INTEGER,
     updated_at        TIMESTAMP,
 
     PRIMARY KEY(model_id, prefix, layer_type),
@@ -147,32 +120,91 @@ CREATE TABLE IF NOT EXISTS model_summary (
 );
 """
 
-# 索引：加速常用查询
 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_metrics_modality
+       ON layer_head_metrics(model_id, modality)""",
     """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)""",
+    """CREATE INDEX IF NOT EXISTS idx_components_modality
+       ON components(model_id, modality)""",
 ]
 
 
 # ─────────────────────────────────────────────
-# 初始化函数
+# 迁移：为旧数据库加 modality 列
+# ─────────────────────────────────────────────
+
+def _migrate_add_modality(conn: sqlite3.Connection):
+    """
+    幂等迁移：给旧表加 modality 列并回填数据。
+    新建数据库时这些列已在建表SQL中，PRAGMA会检测到直接跳过。
+    """
+    cur = conn.cursor()
+
+    # ── layer_head_metrics ────────────────────
+    cur.execute("PRAGMA table_info(layer_head_metrics)")
+    lhm_cols = [row[1] for row in cur.fetchall()]
+
+    if "modality" not in lhm_cols:
+        cur.execute(
+            "ALTER TABLE layer_head_metrics "
+            "ADD COLUMN modality TEXT DEFAULT 'language'"
+        )
+        # 回填 vision
+        cur.execute(
+            """UPDATE layer_head_metrics SET modality = 'vision'
+               WHERE prefix LIKE '%vision%'
+                  OR prefix LIKE '%visual%'
+                  OR prefix LIKE '%image%'"""
+        )
+        # 回填 audio
+        cur.execute(
+            """UPDATE layer_head_metrics SET modality = 'audio'
+               WHERE prefix LIKE '%audio%'
+                  OR prefix LIKE '%speech%'
+                  OR prefix LIKE '%acoustic%'"""
+        )
+        # language 已由 DEFAULT 'language' 覆盖，无需额外更新
+
+    # ── components ────────────────────────────
+    cur.execute("PRAGMA table_info(components)")
+    comp_cols = [row[1] for row in cur.fetchall()]
+
+    if "modality" not in comp_cols:
+        cur.execute(
+            "ALTER TABLE components "
+            "ADD COLUMN modality TEXT DEFAULT 'language'"
+        )
+        cur.execute(
+            """UPDATE components SET modality = 'vision'
+               WHERE prefix LIKE '%vision%'
+                  OR prefix LIKE '%visual%'
+                  OR prefix LIKE '%image%'"""
+        )
+        cur.execute(
+            """UPDATE components SET modality = 'audio'
+               WHERE prefix LIKE '%audio%'
+                  OR prefix LIKE '%speech%'
+                  OR prefix LIKE '%acoustic%'"""
+        )
+
+    conn.commit()
+
+
+# ─────────────────────────────────────────────
+# 初始化
 # ─────────────────────────────────────────────
 
 def init_db() -> sqlite3.Connection:
     """
-    初始化数据库：建表 + 建索引
+    初始化数据库：建表 + 建索引 + 迁移旧数据
     幂等操作，重复调用安全
-    返回数据库连接
     """
     conn = get_connection()
     cur  = conn.cursor()
@@ -186,23 +218,22 @@ def init_db() -> sqlite3.Connection:
         cur.execute(sql)
 
     conn.commit()
+
+    # 旧数据库迁移（新库此函数为空操作）
+    _migrate_add_modality(conn)
+
     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

@@ -4,77 +4,98 @@
 - 写入分析结果到 layer_head_metrics
 - 计算并写入 model_summary
 - 支持断点续传（以 prefix+layer 为粒度）
+- 写入权限验证
 """
 
+import os
 import sqlite3
 import numpy as np
 from datetime import datetime
 from db.schema import get_connection, init_db
-import os
 
 
 # ─────────────────────────────────────────────
-# layer_type 推断
+# 推断函数：layer_type 和 modality
 # ─────────────────────────────────────────────
 
 def infer_layer_type(kv_shared: bool) -> str:
     """
-    从 kv_shared 推断层类型
-    kv_shared=True  → 'global'  （K=V共享，如 Gemma-4-31B 全局层）
+    从结构特征推断层类型
+    kv_shared=True  → 'global'  （K=V共享，如 Gemma 全局层）
     kv_shared=False → 'standard'
-    零 hard coding，纯从结构特征推断
     """
     return "global" if kv_shared else "standard"
 
 
+def infer_modality(prefix: str) -> str:
+    """
+    从组件前缀推断模态
+    纯关键词匹配，不 hard coding 模型名
+    未匹配到任何关键词 → 默认 'language'
+    （覆盖纯语言模型，如 "model." 前缀的 LLaMA/Qwen）
+    """
+    p = prefix.lower()
+    if "vision" in p or "visual" in p or "image" in p:
+        return "vision"
+    if "audio" in p or "speech" in p or "acoustic" in p:
+        return "audio"
+    return "language"
+
+
 # ─────────────────────────────────────────────
-# 断点续传：检查已完成的层
+# 写入权限验证
+# ─────────────────────────────────────────────
+
+def check_write_permission(admin_token: str) -> bool:
+    """
+    验证管理员写入权限。
+    WRITE_TOKEN 存储在 HF Space Secrets（加密，不进入 git repo）。
+    运行时由 HF 注入为环境变量，只在服务端比对，不返回给前端。
+
+    返回：
+      True  = 有写入权限
+      False = 只读模式（分析可以跑，结果不写库）
+    """
+    server_token = os.environ.get("WRITE_TOKEN", "")
+    if not server_token:
+        return False
+    return admin_token.strip() == server_token
+
+
+# ─────────────────────────────────────────────
+# 断点续传
 # ─────────────────────────────────────────────
 
 def get_analyzed_layers(
     conn:     sqlite3.Connection,
     model_id: str,
     prefix:   str,
-) -> set[int]:
-    """
-    返回已完成分析的层号集合
-    用于断点续传：跳过已有数据的层
-    粒度：(model_id, prefix, layer)
-    """
+) -> set:
+    """返回已完成分析的层号集合"""
     cur = conn.cursor()
     cur.execute(
-        """
-        SELECT DISTINCT layer
-        FROM layer_head_metrics
-        WHERE model_id = ? AND prefix = ?
-        """,
+        """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,
+    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 = ?
-        """,
+        """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
+    return cur.fetchone()[0] >= expected_records
 
 
 # ─────────────────────────────────────────────
@@ -87,51 +108,47 @@ def upsert_model(
     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
-        """,
+        """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:          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,
 ):
-    """写入或更新组件信息"""
+    modality = infer_modality(prefix)
     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
-        """,
+        """INSERT INTO components(
+               model_id, prefix, modality, n_layers,
+               head_dim_min, head_dim_max,
+               has_kv_shared, has_global, d_model
+           )
+           VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT(model_id, prefix) DO UPDATE SET
+               modality      = excluded.modality,
+               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,
+            model_id, prefix, modality, n_layers,
             head_dim_min, head_dim_max,
             int(has_kv_shared), int(has_global), d_model
         )
@@ -148,21 +165,20 @@ def write_layer_records(
     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)))
+        modality   = infer_modality(r["prefix"])
         rows.append((
             model_id,
             r["prefix"],
             r["layer"],
             layer_type,
+            modality,
             r["kv_head"],
             r["q_head"],
             int(r.get("kv_shared", False)),
@@ -170,66 +186,41 @@ def write_layer_records(
             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"),
+            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 (
-            ?,?,?,?,?,?,?,?,?,?,?,
-            ?,?,?,?,?,?,?,
-            ?,?,?,?,?,?,?,?,?,
-            ?,?,?,?,?,?,
-            ?,?,?,?,?,?
-        )
-        """,
+        """INSERT OR REPLACE INTO layer_head_metrics(
+               model_id, prefix, layer, layer_type, modality,
+               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()
@@ -240,34 +231,25 @@ def write_layer_records(
 # ─────────────────────────────────────────────
 
 def _calc_summary_row(
-    rows: list[sqlite3.Row],
-    model_id: str,
-    prefix: str,
+    rows:       list,
+    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
+        return np.array(vals, dtype=float) if vals else np.array([])
 
-    def avg(arr):
-        return float(np.mean(arr)) if len(arr) > 0 else None
+    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")
+    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)
+    n_layers   = len(set(r["layer"] for r in rows))
+    n_records  = len(rows)
 
     return {
         "model_id":          model_id,
@@ -298,106 +280,65 @@ def update_model_summary(
     prefix:   str,
 ):
     """
-    重新计算并写入 model_summary
-    对每个 (model_id, prefix) 生成三行：
-      - layer_type='all'
-      - layer_type='standard'
-      - layer_type='global'
-    王氏评分固定用 standard 层计算
+    重新计算并写入 model_summary（all / standard / global 三行）
+    wang_score 统一用 standard 层计算
     """
     cur = conn.cursor()
 
+    # 预取 standard 层的 ssr_QK（wang_score 统一用这个）
+    cur.execute(
+        """SELECT ssr_QK FROM layer_head_metrics
+           WHERE model_id = ? AND prefix = ? AND layer_type = 'standard'""",
+        (model_id, prefix)
+    )
+    std_ssr_rows = cur.fetchall()
+    std_ssr = np.array(
+        [r[0] for r in std_ssr_rows if r[0] is not None], dtype=float
+    )
+    std_wang_score = float(1 - np.median(std_ssr)) if len(std_ssr) > 0 else None
+
     for layer_type in ["all", "standard", "global"]:
-        # 查询对应数据
         if layer_type == "all":
             cur.execute(
-                """
-                SELECT * FROM layer_head_metrics
-                WHERE model_id = ? AND prefix = ?
-                """,
+                "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 = ?
-                """,
+                """SELECT * FROM layer_head_metrics
+                   WHERE model_id=? AND prefix=? AND layer_type=?""",
                 (model_id, prefix, layer_type)
             )
 
-        rows = cur.fetchall()
+        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
+        # wang_score 统一用 standard 层
+        summary["wang_score"] = std_wang_score
 
         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
-            )
-            """,
+            """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()
-
-# 在 db/writer.py 末尾追加
-
-
-
-# ─────────────────────────────────────────────
-# 写入权限验证
-# ─────────────────────────────────────────────
-
-def check_write_permission(admin_token: str) -> bool:
-    """
-    验证管理员写入权限。
-    
-    原理：
-    - WRITE_TOKEN 存储在 HF Space Secrets（加密，不进入 git repo）
-    - 运行时由 HF 注入为环境变量
-    - 只在服务端比对，不返回给前端
-    
-    返回：
-    - True  = 有写入权限
-    - False = 只读模式（分析可以跑，结果不写库）
-    """
-    server_token = os.environ.get("WRITE_TOKEN", "")
-    if not server_token:
-        # 服务端未配置 WRITE_TOKEN → 拒绝所有写入
-        return False
-    return admin_token.strip() == server_token
+    conn.commit()

ui/tab_database.py

@@ -1,9 +1,10 @@
 # ui/tab_database.py
 """
-Tab4：数据库浏览
-- 查看已分析模型列表
-- 查看某模型的逐层原始数据
-- 数据库统计信息
+Tab4: Database Browser
+- Model list (Plan A: aggregated by modality)
+- Model detail (Plan B: raw components rows, expandable)
+- Per-head raw data query (modality + layer_type as two independent filters)
+- DB stats
 """
 
 import gradio as gr
@@ -12,6 +13,7 @@ import pandas as pd
 from db.schema import init_db, get_db_stats
 from db.reader import (
     get_analyzed_models,
+    get_model_components,
     get_model_summary,
     get_layer_metrics,
     get_resume_status,
@@ -19,92 +21,112 @@ from db.reader import (
 
 
 def load_db_stats() -> str:
-    """获取数据库统计信息"""
     conn  = init_db()
     stats = get_db_stats(conn)
     return (
-        f"📊 数据库统计\n"
+        f"Database Statistics\n"
         f"{'─'*40}\n"
-        f"  模型数：     {stats.get('models', 0)}\n"
-        f"  组件数：     {stats.get('components', 0)}\n"
-        f"  层头记录数： {stats.get('layer_head_metrics', 0)}\n"
-        f"  汇总行数：   {stats.get('model_summary', 0)}\n"
-        f"  数据库大小： {stats.get('db_size_mb', 0)} MB\n"
+        f"  Models:            {stats.get('models', 0)}\n"
+        f"  Components:        {stats.get('components', 0)}\n"
+        f"  Layer-head records:{stats.get('layer_head_metrics', 0)}\n"
+        f"  Summary rows:      {stats.get('model_summary', 0)}\n"
+        f"  DB size:           {stats.get('db_size_mb', 0)} MB\n"
     )
 
 
 def load_model_list() -> pd.DataFrame:
-    """加载已分析模型列表"""
+    """
+    方案A：按 modality 聚合层数
+    language_layers 含 standard + global（同一prefix下全部层）
+    vision/audio 为 0 时显示 0
+    """
     conn = init_db()
     df   = get_analyzed_models(conn)
     if df.empty:
-        return pd.DataFrame(
-            columns=["model_id", "model_type", "analyzed_at",
-                     "analyze_sec", "n_components", "total_layers"]
-        )
+        return pd.DataFrame(columns=[
+            "model_id", "model_type", "analyzed_at", "analyze_sec",
+            "n_components", "language_layers", "vision_layers", "audio_layers"
+        ])
+    # vision/audio 为 0 时替换为空字符串，更美观
+    for col in ["vision_layers", "audio_layers"]:
+        df[col] = df[col].apply(lambda x: "" if x == 0 else x)
     return df
 
 
-def load_model_detail(model_id: str) -> tuple[pd.DataFrame, pd.DataFrame, str]:
+def load_model_detail(
+    model_id: str
+) -> tuple[pd.DataFrame, pd.DataFrame, str]:
     """
-    加载模型详情
-    返回 (summary_df, 断点续传状态文本)
+    返回：
+    1. 方案B：原始 components 行（prefix/modality/n_layers/head_dim等）
+    2. model_summary 汇总统计
+    3. 断点续传状态文本
     """
     if not model_id.strip():
-        return pd.DataFrame(), pd.DataFrame(), "请输入模型 ID"
+        return pd.DataFrame(), pd.DataFrame(), "Please enter a model ID."
 
     conn = init_db()
+    mid  = model_id.strip()
+
+    # 方案B：原始 components
+    comp_df    = get_model_components(conn, mid)
 
     # 汇总统计
-    summary_df = get_model_summary(conn, model_id.strip())
+    summary_df = get_model_summary(conn, mid)
 
-    # 断点续传状态（按前缀）
-    status_lines = [f"📍 断点续传状态：{model_id}\n{'─'*50}\n"]
-    if not summary_df.empty:
-        for pfx in summary_df["prefix"].unique():
-            rs = get_resume_status(conn, model_id.strip(), pfx)
+    # 断点续传状态
+    status_lines = [f"Resume Status: {mid}\n{'─'*50}\n"]
+    if not comp_df.empty:
+        for pfx in comp_df["prefix"].tolist():
+            rs = get_resume_status(conn, mid, pfx)
             status_lines.append(
                 f"  [{pfx}]\n"
-                f"    已完成层数：{rs['total_done']}\n"
-                f"    层号：{sorted(rs['done_layers'])}\n"
+                f"    Done layers : {rs['total_done']}\n"
+                f"    Layer index : {sorted(rs['done_layers'])}\n"
             )
     else:
-        status_lines.append("  暂无数据\n")
+        status_lines.append("  No data yet.\n")
 
-    return summary_df, "".join(status_lines)
+    return comp_df, summary_df, "".join(status_lines)
 
 
 def load_layer_data(
-    model_id:    str,
-    prefix:      str,
-    layer_type:  str,
-    start_layer: int,
-    end_layer:   int,
+    model_id:   str,
+    modality:   str,
+    layer_type: str,
+    start_layer:int,
+    end_layer:  int,
 ) -> tuple[pd.DataFrame, str]:
-    """加载逐头原始数据"""
+    """
+    逐头原始数据查询
+    modality 和 layer_type 两个维度独立过滤
+    """
     if not model_id.strip():
-        return pd.DataFrame(), "请输入模型 ID"
+        return pd.DataFrame(), "Please enter a model ID."
 
     conn = init_db()
+    mod  = modality   if modality   != "all" else None
     lt   = layer_type if layer_type != "all" else None
-    pfx  = prefix.strip() or None
 
     df = get_layer_metrics(
         conn,
         model_id    = model_id.strip(),
-        prefix      = pfx,
+        modality    = mod,
         layer_type  = lt,
         start_layer = int(start_layer),
         end_layer   = int(end_layer),
     )
 
     if df.empty:
-        return pd.DataFrame(), f"⚠️ 无数据：model={model_id} prefix={pfx} layer_type={lt}"
+        return pd.DataFrame(), (
+            f"No data found: model={model_id} "
+            f"modality={mod or 'all'} layer_type={lt or 'all'}"
+        )
 
     status = (
-        f"✅ {len(df)} 条记录  "
-        f"| 层 {df['layer'].min()}~{df['layer'].max()}  "
-        f"| prefix={pfx or '全部'}"
+        f"✅ {len(df)} records  "
+        f"| layers {df['layer'].min()}~{df['layer'].max()}  "
+        f"| modality={mod or 'all'}  layer_type={lt or 'all'}"
     )
     return df, status
 
@@ -114,120 +136,149 @@ def load_layer_data(
 # ─────────────────────────────────────────────
 
 def build_tab_database():
-    with gr.Tab("🗄️ 数据库"):
-        gr.Markdown("## 数据库浏览  \n查看已分析模型的原始数据和汇总统计。")
+    with gr.Tab("🗄️ Database"):
+        gr.Markdown(
+            "## Database Browser\n"
+            "View analyzed models, raw per-head data, and resume status.\n\n"
+            "> 查看已分析模型、逐头原始数据及断点续传状态。"
+        )
 
-        # ── 数据库统计 ──────────────────────────
+        # ── DB Stats ────────────────────────────────────────
         with gr.Row():
             stats_text = gr.Textbox(
-                label="数据库统计",
-                value="点击刷新",
+                label="Database Statistics",
+                value="Click Refresh to load.",
                 lines=7,
                 interactive=False,
                 scale=2,
             )
             refresh_stats_btn = gr.Button(
-                "🔄 刷新统计", scale=1, variant="secondary"
+                "🔄 Refresh Stats", scale=1, variant="secondary"
             )
-
-        refresh_stats_btn.click(
-            fn=load_db_stats,
-            outputs=stats_text,
-        )
+        refresh_stats_btn.click(fn=load_db_stats, outputs=stats_text)
 
         gr.Markdown("---")
 
-        # ── 已分析模型列表 ──────────────────────
-        gr.Markdown("### 已分析模型")
-        with gr.Row():
-            refresh_models_btn = gr.Button(
-                "🔄 刷新模型列表", variant="secondary"
-            )
-
+        # ── Model List（方案A）──────────────────────────────
+        gr.Markdown(
+            "### Analyzed Models\n"
+            "Layers are split by modality. "
+            "`language_layers` includes both standard and global layers.\n\n"
+            "> 层数按模态拆分。`language_layers` 含 standard 和 global 层。"
+        )
+        refresh_models_btn = gr.Button(
+            "🔄 Refresh Model List", variant="secondary"
+        )
         models_table = gr.Dataframe(
-            label="已分析模型",
+            label="Analyzed Models",
+            headers=[
+                "model_id", "model_type", "analyzed_at", "analyze_sec",
+                "n_components", "language_layers", "vision_layers", "audio_layers"
+            ],
             interactive=False,
         )
-
-        refresh_models_btn.click(
-            fn=load_model_list,
-            outputs=models_table,
-        )
+        refresh_models_btn.click(fn=load_model_list, outputs=models_table)
 
         gr.Markdown("---")
 
-        # ── 模型详情 ────────────────────────────
-        gr.Markdown("### 模型详情 & 断点续传状态")
+        # ── Model Detail（方案B展开）────────────────────────
+        gr.Markdown(
+            "### Model Detail & Resume Status\n"
+            "Expand raw component rows and check which layers are done.\n\n"
+            "> 查看原始组件信息及断点续传进度。"
+        )
         with gr.Row():
             detail_model_id = gr.Textbox(
-                label="模型 ID",
+                label="Model ID",
                 placeholder="google/gemma-4-e2b",
                 scale=3,
             )
             load_detail_btn = gr.Button(
-                "📋 查看详情", variant="secondary", scale=1
+                "📋 Load Detail", variant="secondary", scale=1
             )
 
         resume_status_text = gr.Textbox(
-            label="断点续传状态",
+            label="Resume Status",
             lines=8,
             interactive=False,
         )
+        # 方案B：原始 components 行
+        components_table = gr.Dataframe(
+            label="Components (raw) — prefix / modality / n_layers / head_dim",
+            headers=[
+                "prefix", "modality", "n_layers",
+                "head_dim_min", "head_dim_max",
+                "has_kv_shared", "has_global", "d_model"
+            ],
+            interactive=False,
+        )
         summary_table = gr.Dataframe(
-            label="模型汇总统计（all/standard/global 三行）",
+            label="Model Summary (all / standard / global)",
             interactive=False,
         )
 
         load_detail_btn.click(
             fn=load_model_detail,
             inputs=[detail_model_id],
-            outputs=[summary_table, resume_status_text],
+            outputs=[components_table, summary_table, resume_status_text],
         )
 
         gr.Markdown("---")
 
-        # ── 逐头原始数据 ────────────────────────
-        gr.Markdown("### 逐头原始数据查询")
+        # ── Raw Data Query ──────────────────────────────────
+        gr.Markdown(
+            "### Per-head Raw Data Query\n"
+            "`Modality` and `Layer Type` are two independent filter dimensions.\n\n"
+            "> Modality（模态）和 Layer Type（层结构类型）是两个独立过滤维度，可组合使用。"
+        )
         with gr.Row():
             raw_model_id = gr.Textbox(
-                label="模型 ID",
+                label="Model ID",
                 placeholder="google/gemma-4-e2b",
                 scale=2,
             )
-            raw_prefix = gr.Textbox(
-                label="组件前缀（留空=全部）",
-                placeholder="model.language_model.",
-                scale=2,
+            raw_modality = gr.Dropdown(
+                label="Modality",
+                choices=["all", "language", "vision", "audio"],
+                value="language",
+                scale=1,
+                info="Filter by component modality | 按模态过滤",
             )
             raw_layer_type = gr.Dropdown(
-                label="层类型",
+                label="Layer Type",
                 choices=["all", "standard", "global"],
                 value="all",
                 scale=1,
+                info=(
+                    "standard = normal layers  |  "
+                    "global = K=V shared layers (e.g. Gemma global)"
+                ),
             )
         with gr.Row():
             raw_start = gr.Number(
-                label="起始层号", value=0, precision=0, scale=1
+                label="Start Layer", value=0,  precision=0, scale=1
             )
             raw_end = gr.Number(
-                label="结束层号", value=10, precision=0, scale=1
+                label="End Layer",   value=10, precision=0, scale=1
             )
             load_raw_btn = gr.Button(
-                "🔍 查询数据", variant="secondary", scale=1
+                "🔍 Query Data", variant="secondary", scale=1
             )
 
         raw_status = gr.Textbox(
-            label="查询状态", lines=1, interactive=False
+            label="Query Status", lines=1, interactive=False
         )
         raw_table = gr.Dataframe(
-            label="逐头原始数据",
+            label="Per-head Raw Data",
             interactive=False,
             wrap=False,
         )
 
         load_raw_btn.click(
             fn=load_layer_data,
-            inputs=[raw_model_id, raw_prefix, raw_layer_type,
-                    raw_start, raw_end],
+            inputs=[
+                raw_model_id, raw_modality, raw_layer_type,
+                raw_start, raw_end
+            ],
             outputs=[raw_table, raw_status],
         )

ui/tab_leaderboard.py

@@ -1,9 +1,9 @@
 # ui/tab_leaderboard.py
 """
-Tab3：王氏评分排行榜
-- 从 model_summary 读取，按 wang_score 降序
-- 支持按组件过滤（language_model / vision_tower / all）
-- 支持按 layer_type 过滤（standard / global / all）
+Tab3: Wang's Five Laws Leaderboard
+- Ranked by wang_score (= 1 − median SSR_QK, standard layers only)
+- Filter by modality (default: language)
+- Filter by layer_type (default: standard)
 """
 
 import gradio as gr
@@ -14,123 +14,104 @@ from db.schema import init_db
 from db.reader import get_leaderboard
 
 
-# ─────────────────────────────────────────────
-# 排行榜列格式化
-# ─────────────────────────────────────────────
-
 def _format_leaderboard(df: pd.DataFrame) -> pd.DataFrame:
-    """格式化排行榜显示列"""
     if df.empty:
         return df
 
-    # 提取可读的模型名（去掉 org 前缀）
     df = df.copy()
     df["model_name"] = df["model_id"].apply(
         lambda x: x.split("/")[-1] if "/" in x else x
     )
-
-    # 王氏评分百分制（便于直觉理解）
     df["wang_score_pct"] = df["wang_score"].apply(
         lambda x: f"{x*100:.3f}" if pd.notna(x) else "N/A"
     )
-
-    # 格式化关键指标
     for col in ["median_pearson_QK", "median_ssr_QK", "mean_ssr_QK"]:
         if col in df.columns:
             df[col] = df[col].apply(
                 lambda x: f"{x:.6f}" if pd.notna(x) else "N/A"
             )
 
-    # 选择展示列
     display_cols = [
-        "model_name",
-        "prefix",
-        "layer_type",
+        "model_name", "modality", "layer_type",
         "wang_score_pct",
-        "median_pearson_QK",
-        "median_ssr_QK",
-        "mean_ssr_QK",
-        "median_cosU_QK",
-        "median_cosU_QV",
-        "median_cosV_QK",
-        "n_layers",
-        "n_records",
-        "model_id",       # 完整 ID 放最后
+        "median_pearson_QK", "median_ssr_QK", "mean_ssr_QK",
+        "median_cosU_QK", "median_cosU_QV", "median_cosV_QK",
+        "n_layers", "n_records", "model_id",
     ]
     existing = [c for c in display_cols if c in df.columns]
     return df[existing]
 
 
 def load_leaderboard(
-    prefix_filter: str,
-    layer_type:    str,
+    modality:   str,
+    layer_type: str,
 ) -> tuple[pd.DataFrame, str]:
-    """
-    加载排行榜数据
-    返回 (DataFrame, 状态文本)
-    """
     conn = init_db()
+    lt   = layer_type if layer_type != "all" else "standard"
+    mod  = modality
 
-    # prefix_filter 空字符串 → None（不过滤）
-    pfx = prefix_filter.strip() or None
-    lt  = layer_type if layer_type != "all" else "standard"
-
-    df = get_leaderboard(conn, prefix_filter=pfx, layer_type=lt, limit=100)
+    df = get_leaderboard(conn, modality=mod, layer_type=lt, limit=100)
 
     if df.empty:
         return pd.DataFrame(), (
-            "📭 排行榜暂无数据\n"
-            "请先在「分析」Tab 分析至少一个模型的完整层。\n"
-            f"（当前过滤：prefix='{pfx}', layer_type='{lt}'）"
+            f"No data yet. Please analyze at least one model first.\n"
+            f"(modality='{mod}', layer_type='{lt}')\n\n"
+            f"暂无数据，请先在「Analyze」Tab 分析至少一个模型。"
         )
 
     formatted = _format_leaderboard(df)
     status = (
-        f"✅ 共 {len(formatted)} 条记录  "
-        f"| layer_type={lt}  "
-        f"| prefix_filter='{pfx or '全部'}'"
+        f"✅ {len(formatted)} entries  "
+        f"| modality={mod}  layer_type={lt}"
     )
     return formatted, status
 
 
-# ─────────────────────────────────────────────
-# Tab3 UI
-# ─────────────────────────────────────────────
-
 def build_tab_leaderboard():
-    with gr.Tab("🏆 排行榜"):
+    with gr.Tab("🏆 Leaderboard"):
         gr.Markdown("""
-        ## 王氏评分排行榜
-        **Wang Score = 1 − median(SSR_QK)**，越高越好（理论极值 = 1）  
-        基于 `standard` 层计算（排除 K=V 共享的全局层干扰）。
+        ## Wang's Five Laws — Model Leaderboard
+
+        **Wang Score = 1 − median(SSR\_QK)**  Higher is better. Theoretical max = 1.  
+        Computed from `standard` layers only (global/KV-shared layers excluded).
+
+        > 王氏评分 = 1 − median(SSR_QK)，越高越好，理论极值=1。
+        > 仅基于 standard 层计算（排除 K=V 共享的全局层干扰）。
         """)
 
         with gr.Row():
-            prefix_input = gr.Textbox(
-                label="组件过滤（含关键词即匹配，留空=全部）",
-                placeholder="language_model",
-                value="",
-                scale=3,
+            modality_input = gr.Dropdown(
+                label="Modality",
+                choices=["language", "vision", "audio", "all"],
+                value="language",
+                scale=1,
+                info="language = text LLM components | 通常选 language",
             )
             layer_type_input = gr.Dropdown(
-                label="层类型",
+                label="Layer Type",
                 choices=["standard", "global", "all"],
                 value="standard",
                 scale=1,
+                info=(
+                    "standard = normal layers  |  "
+                    "global = K=V shared (Gemma global layers)"
+                ),
+            )
+            refresh_btn = gr.Button(
+                "🔄 Refresh Leaderboard", variant="primary", scale=1
             )
-            refresh_btn = gr.Button("🔄 刷新排行榜", variant="primary", scale=1)
 
         status_text = gr.Textbox(
-            label="状态",
-            value="点击「刷新排行榜」加载数据",
+            label="Status",
+            value="Click Refresh to load leaderboard.",
             lines=1,
             interactive=False,
         )
 
         leaderboard_table = gr.Dataframe(
-            label="王氏评分排行榜（按 Wang Score 降序）",
+            label="Wang Score Leaderboard (sorted by Wang Score ↓)",
             headers=[
-                "model_name", "prefix", "layer_type",
+                "model_name", "modality", "layer_type",
                 "wang_score_pct",
                 "median_pearson_QK", "median_ssr_QK", "mean_ssr_QK",
                 "median_cosU_QK", "median_cosU_QV", "median_cosV_QK",
@@ -141,23 +122,20 @@ def build_tab_leaderboard():
         )
 
         gr.Markdown("""
-        ### 指标说明
-        | 指标 | 含义 | 越好 |
-        |------|------|------|
-        | Wang Score | 1 − median(SSR_QK)，综合推理能力评分 | ↑ 高 |
-        | median_pearson_QK | Q/K 奇异值谱 Pearson 相关中位数（第一定律） | ↑ 高 |
-        | median_ssr_QK | Q/K 归一化谱失配中位数（第二定律） | ↓ 低 |
-        | median_cosU_QK | Q/K 输出子空间对齐（第四定律，≈随机正交） | ≈ 1/√d |
-        | median_cosU_QV | Q/V 输出子空间（第四定律，超正交） | ↓ 低 |
-        | median_cosV_QK | Q/K 输入子空间（第五定律，≈随机正交） | ≈ 1/√D |
+        ### Metric Reference | 指标说明
+
+        | Metric | Description | Better |
+        |--------|-------------|--------|
+        | Wang Score | 1 − median(SSR\_QK)，综合推理能力评分 | ↑ Higher |
+        | median\_pearson\_QK | Q/K spectral Pearson correlation (Law 1) | ↑ Higher |
+        | median\_ssr\_QK | Q/K normalized spectral mismatch (Law 2) | ↓ Lower |
+        | median\_cosU\_QK | Q/K output subspace alignment (Law 4, ≈ random orthogonal) | ≈ 1/√d |
+        | median\_cosU\_QV | Q/V output subspace (Law 4, super-orthogonal) | ↓ Lower |
+        | median\_cosV\_QK | Q/K input subspace (Law 5, ≈ random orthogonal) | ≈ 1/√D |
         """)
 
-        # 事件绑定
         refresh_btn.click(
             fn=load_leaderboard,
-            inputs=[prefix_input, layer_type_input],
+            inputs=[modality_input, layer_type_input],
             outputs=[leaderboard_table, status_text],
-        )
-
-        # 启动时自动加载
-        leaderboard_table.change(fn=None)
+        )