Upload 9 files

README.md

@@ -1,331 +1,34 @@
 ---
-title: BayePyMC
-emoji: 🔬
+title: Bayesian Hierarchical Model Analysis
+emoji: 🎲
 colorFrom: blue
 colorTo: indigo
 sdk: streamlit
 sdk_version: 1.31.0
-app_file: app.py
+app_file: app_bayesian.py
 pinned: false
+python_version: "3.11"
 ---
 
-# 貝氏階層模型分析系統 - 寶可夢速度對勝率影響
+# 🎲 貝氏階層模型分析系統
 
-## 📋 系統簡介
+寶可夢速度對勝率影響的貝氏階層分析
 
-這是一個基於 Streamlit 和 PyMC 的貝氏階層模型分析系統，專為分析寶可夢速度對不同屬性勝率的影響而設計，結合 AI 助手提供深入的統計解釋和對戰策略建議。
+## 功能特色
 
-## 🎯 主要功能
+- 🎲 貝氏階層模型分析
+- 📊 4 種視覺化圖表
+- 💬 AI 助手（Google Gemini）
+- 📈 完整統計報告
 
-### 1. 貝氏階層模型分析
-- ✅ MCMC 抽樣（Markov Chain Monte Carlo）
-- ✅ 階層結構（跨屬性資訊借用）
-- ✅ 完整的不確定性量化
-- ✅ 後驗分佈估計
-- ✅ 收斂診斷
+## 使用方式
 
-### 2. 完整視覺化（4 個圖表 + 1 個文字摘要）
-- 🔀 **DAG 圖**：模型結構視覺化
-- 📉 **Trace Plot**：MCMC 收斂診斷圖
-- 🎯 **Posterior Plot**：後驗分佈圖
-- 🌲 **Forest Plot**：各屬性效應圖
-- 📋 **文字摘要**：統計結果表格
+1. 上傳資料或使用範例資料
+2. 設定 MCMC 參數
+3. 輸入 Google Gemini API Key
+4. 開始分析
 
-### 3. AI 智能助手
-- 💬 自然語言對話（雙語支援）
-- 📖 統計概念解釋（貝氏、階層模型）
-- 🎮 對戰策略建議
-- 🔍 結果深度分析
-- 📚 參數詳細說明
+## 系統需求
 
-## 📦 安裝步驟
-
-### 1. 安裝 Python 依賴套件
-```bash
-pip install -r bayesian_requirements.txt
-```
-
-### 2. 安裝 Graphviz（系統級套件，用於生成 DAG 圖）
-
-**Windows (使用 Chocolatey):**
-```bash
-choco install graphviz
-```
-
-**Mac:**
-```bash
-brew install graphviz
-```
-
-**Ubuntu/Debian:**
-```bash
-sudo apt-get install graphviz
-```
-
-### 3. 準備資料
-將寶可夢速度分析資料 CSV 檔放在同一目錄下，檔名為 `pokemon_speed_meta_results.csv`
-
-**資料格式要求：**
-
-| 欄位 | 說明 | 範例 |
-|------|------|------|
-| `Trial_Type` | 寶可夢屬性 | Water, Fire, Grass |
-| `rc` | 控制組（速度慢）勝場數 | 45 |
-| `nc` | 控制組總場數 | 100 |
-| `rt` | 實驗組（速度快）勝場數 | 60 |
-| `nt` | 實驗組總場數 | 100 |
-
-**範例資料：**
-```csv
-Trial_Type,rc,nc,rt,nt
-Water,45,100,60,100
-Fire,38,100,55,100
-Grass,42,100,58,100
-Electric,50,100,65,100
-```
-
-### 4. 設定 Google Gemini API Key
-- 在系統左側邊欄輸入您的 Google Gemini API Key
-- API Key 用於 AI 助手功能
-- 取得 API Key：https://ai.google.dev/
-
-### 5. 執行程式
-```bash
-streamlit run bayesian_app.py
-```
-
-## 🔧 檔案結構
-
-```
-bayesian_hierarchical_model/
-├── bayesian_app.py              # Streamlit 主程式
-├── bayesian_core.py             # 貝氏階層模型核心邏輯
-├── bayesian_llm_assistant.py    # AI 對話助手
-├── bayesian_requirements.txt    # 依賴套件
-├── README.md                    # 說明文件
-└── pokemon_speed_meta_results.csv  # 資料檔（需自行準備）
-```
-
-## 📊 使用方式
-
-### Step 1: 載入資料
-1. 選擇「使用預設資料集」或「上傳您的資料」
-2. 如果上傳，請確保 CSV 格式正確（需包含必要欄位）
-
-### Step 2: 設定抽樣參數（可選）
-1. 展開「進階設定」調整 MCMC 參數
-2. **建議設定**：
-   - Samples: 2000（更多 = 更準確但更慢）
-   - Tuning: 1000
-   - Chains: 1（多條鏈可檢測收斂問題）
-   - Target Accept: 0.95
-
-### Step 3: 執行分析
-1. 點擊「開始貝氏分析」按鈕
-2. 等待分析完成（通常需要 2-5 分鐘）
-3. 查看結果的四個子頁面：
-   - **📊 概覽**：關鍵指標、摘要、各屬性詳細結果
-   - **📉 Trace Plot**：收斂診斷
-   - **🎯 Posterior**：後驗分佈
-   - **🌲 Forest Plot**：各屬性效應比較
-
-### Step 4: 使用 AI 助手
-1. 切換到「AI 助手」頁面
-2. 在聊天框輸入問題，或點擊快速問題按鈕
-3. AI 會根據分析結果提供解釋和建議
-
-## 💡 統計指標說明
-
-### 關鍵參數
-
-| 參數 | 說明 | 解讀 |
-|------|------|------|
-| **d** | 整體平均效應（log OR） | 所有屬性的平均速度效應 |
-| **sigma** | 屬性間變異 | 不同屬性對速度反應的差異程度 |
-| **or_speed** | 速度勝算比（exp(d)） | 速度快的寶可夢獲勝機率倍數 |
-| **delta[i]** | 第 i 個屬性的效應 | 該屬性的速度效應（相對於整體） |
-
-### 判斷準則
-
-**顯著性：**
-- 95% HDI 不包含 0 → 效應顯著
-- 95% HDI 包含 0 → 效應不顯著
-
-**勝算比解讀：**
-- OR > 1：速度快有利
-- OR = 1：無差異
-- OR < 1：速度慢有利（罕見）
-
-**收斂診斷：**
-- Trace plot 應該像「毛毛蟲」（平穩、混合良好）
-- 不應有明顯趨勢或週期性
-
-## 🎮 應用場景
-
-### 1. 屬性特定分析
-判斷哪些屬性的寶可夢特別受益於速度（如電系、飛行系）
-
-### 2. 組隊策略制定
-根據統計結果選擇是否優先速度特訓
-
-### 3. 對戰機制理解
-理解速度在不同對戰情境中的重要性
-
-### 4. 教學用途
-學習貝氏階層模型的原理和應用
-
-## 📈 視覺化圖表說明
-
-### 1️⃣ DAG 圖（模型結構）
-- **作用**：展示變數之間的依賴關係
-- **元素**：
-  - 圓形/橢圓：隨機變數
-  - 矩形：觀測資料
-  - 菱形：推導變數
-  - 箭頭：依賴關係
-
-### 2️⃣ Trace Plot（收斂診斷）
-- **左欄**：MCMC 抽樣軌跡
-- **右欄**：後驗分佈密度
-- **良好收斂**：軌跡像「毛毛蟲」，平穩無趨勢
-- **問題跡象**：有趨勢、卡住、未混合
-
-### 3️⃣ Posterior Plot（後驗分佈）
-- 顯示 d、sigma、or_speed 的後驗分佈
-- 自動標註 95% HDI
-- 顯示平均值
-
-### 4️⃣ Forest Plot（各屬性效應）
-- **最重要的圖！**
-- Y 軸：各屬性
-- X 軸：delta（log OR）
-- 點：平均效應
-- 線：95% 信賴區間
-- 星號：顯著效應
-- 紅虛線：無效應參考線
-
-## ⚙️ 技術架構
-
-### 核心技術
-- **Streamlit**: Web 應用框架
-- **PyMC**: 貝氏推論引擎
-- **ArviZ**: 貝氏分析視覺化
-- **NumPy/Pandas**: 數值運算與資料處理
-- **Matplotlib**: 圖表繪製
-- **Google Gemini**: AI 助手
-
-### 統計方法
-- **Hierarchical Bayesian Model**: 階層貝氏模型
-- **MCMC Sampling**: 馬可夫鏈蒙地卡羅抽樣
-- **Logit Link Function**: Logit 連結函數
-- **Partial Pooling**: 部分池化（資訊借用）
-
-### 特色設計
-- ✅ Session 隔離（多用戶支援）
-- ✅ 執行緒安全
-- ✅ 自動清理過期資料
-- ✅ 響應式 UI 設計
-- ✅ 進度條回饋
-- ✅ 完整錯誤處理
-
-## 🔒 隱私與安全
-
-- 所有分析在本地執行
-- Session 資料獨立儲存
-- 超過 1 小時自動清理
-- API Key 不會被儲存
-
-## 📝 範例問題（給 AI 助手）
-
-### 基本概念
-- "什麼是貝氏統計？"
-- "什麼是階層模型？"
-- "什麼是先驗、後驗、似然？"
-- "HDI 和信賴區間有什麼不同？"
-
-### 結果解讀
-- "d 參數是什麼意思？"
-- "sigma 大表示什麼？"
-- "如何判斷速度效應是否顯著？"
-- "為什麼有些屬性顯著，有些不顯著？"
-
-### 收斂診斷
-- "如何看 Trace Plot？"
-- "什麼是毛毛蟲圖？"
-- "我的模型收斂了嗎？"
-
-### 實戰應用
-- "給我分析總結"
-- "哪些屬性最受益於速度？"
-- "我該如何組建隊伍？"
-- "這對對戰策略有什麼啟示？"
-
-## 🆚 與 McNemar 系統的比較
-
-| 特性 | McNemar 系統 | 貝氏階層模型 |
-|------|--------------|--------------|
-| 方法 | 頻率論統計 | 貝氏推論 |
-| 資料 | 配對資料（勝vs敗） | 獨立兩組（快vs慢） |
-| 分析單位 | 單一特徵 | 多屬性同時分析 |
-| 輸出 | p 值、OR | 後驗分佈、HDI |
-| 階層性 | 無 | 有（跨屬性借用資訊） |
-| 不確定性 | 點估計 + CI | 完整後驗分佈 |
-| 小樣本 | 可能不穩定 | 穩健（借用資訊） |
-
-## 🚀 未來功能規劃
-
-- [ ] 多特徵聯合分析（速度 + 攻擊 + HP）
-- [ ] 模型比較（DIC, WAIC）
-- [ ] 預測新屬性的效應
-- [ ] 互動式後驗預測檢查
-- [ ] 匯出完整 PDF 報告
-- [ ] 批次分析多個資料集
-
-## 🐛 常見問題排解
-
-### Q1: DAG 圖無法生成
-**A**: 請確保已安裝系統級的 Graphviz
-```bash
-# 檢查是否安裝
-dot -V
-
-# 如果未安裝，請依照上述安裝步驟安裝
-```
-
-### Q2: MCMC 抽樣太慢
-**A**: 可以降低抽樣數或調整參數
-- 減少 Samples（但會降低精確度）
-- 增加 Chains（利用多核心）
-- 降低 Target Accept（但可能影響收斂）
-
-### Q3: Trace Plot 顯示未收斂
-**A**: 嘗試以下方法
-- 增加 Tuning samples
-- 增加 Samples
-- 提高 Target Accept
-- 檢查資料是否有問題
-
-### Q4: AI 助手無法使用
-**A**: 請檢查
-- API Key 是否正確
-- 是否已執行分析
-- 網路連線是否正常
-
-## 📧 聯絡資訊
-
-如有問題或建議，歡迎聯繫開發團隊。
-
-## 📄 授權
-
-本專案僅供學術研究和教學使用。
-
----
-
-**Powered by PyMC, ArviZ & Google Gemini** 🚀
-
-## 🎓 延伸閱讀
-
-- [PyMC 官方文件](https://www.pymc.io/)
-- [ArviZ 官方文件](https://arviz-devs.github.io/arviz/)
-- [Bayesian Data Analysis (Gelman et al.)](http://www.stat.columbia.edu/~gelman/book/)
-- [Hierarchical Models 教學](https://www.pymc.io/projects/examples/en/latest/case_studies/hierarchical_partial_pooling.html)
+- Python 3.11
+- Google Gemini API Key

app_bayesian.py

@@ -0,0 +1,709 @@
+import streamlit as st
+import pandas as pd
+import uuid
+from datetime import datetime, timedelta
+import atexit
+import os
+import sys
+
+# 頁面配置
+st.set_page_config(
+    page_title="Bayesian Hierarchical Model - Pokémon Speed Analysis",
+    page_icon="🎲",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# 自定義 CSS
+st.markdown("""
+<style>
+    .streamlit-expanderHeader {
+        background-color: #e8f1f8;
+        border: 1px solid #b0cfe8;
+        border-radius: 5px;
+        font-weight: 600;
+        color: #1b4f72;
+    }
+    .streamlit-expanderHeader:hover {
+        background-color: #d0e7f8;
+    }
+    .stMetric {
+        background-color: #f8fbff;
+        padding: 10px;
+        border-radius: 5px;
+        border: 1px solid #d0e4f5;
+    }
+    .stButton > button {
+        width: 100%;
+        border-radius: 20px;
+        font-weight: 600;
+        transition: all 0.3s ease;
+    }
+    .stButton > button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 8px rgba(0,0,0,0.2);
+    }
+    .success-box {
+        background-color: #d4edda;
+        border: 1px solid #c3e6cb;
+        border-radius: 5px;
+        padding: 10px;
+        margin: 10px 0;
+    }
+    .warning-box {
+        background-color: #fff3cd;
+        border: 1px solid #ffeaa7;
+        border-radius: 5px;
+        padding: 10px;
+        margin: 10px 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# 導入自定義模組
+from bayesian_core import BayesianHierarchicalAnalyzer
+# 注意：如果要啟用 DAG 動態生成功能，請將下行改為：
+# from bayesian_llm_assistant_enhanced import BayesianLLMAssistant
+from bayesian_llm_assistant import BayesianLLMAssistant
+from bayesian_utils import (
+    plot_trace,
+    plot_posterior,
+    plot_forest,
+    plot_model_dag,
+    create_summary_table,
+    create_trial_results_table,
+    export_results_to_text,
+    plot_odds_ratio_comparison
+)
+
+# 清理函數
+def cleanup_old_sessions():
+    """清理超過 1 小時的 session"""
+    current_time = datetime.now()
+    for session_id in list(BayesianHierarchicalAnalyzer._session_results.keys()):
+        result = BayesianHierarchicalAnalyzer._session_results.get(session_id)
+        if result:
+            result_time = datetime.fromisoformat(result['timestamp'])
+            if current_time - result_time > timedelta(hours=1):
+                BayesianHierarchicalAnalyzer.clear_session_results(session_id)
+
+# 註冊清理函數
+atexit.register(cleanup_old_sessions)
+
+# 初始化 session state
+if 'session_id' not in st.session_state:
+    st.session_state.session_id = str(uuid.uuid4())
+if 'analysis_results' not in st.session_state:
+    st.session_state.analysis_results = None
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
+if 'analyzer' not in st.session_state:
+    st.session_state.analyzer = None
+if 'trace_img' not in st.session_state:
+    st.session_state.trace_img = None
+if 'posterior_img' not in st.session_state:
+    st.session_state.posterior_img = None
+if 'forest_img' not in st.session_state:
+    st.session_state.forest_img = None
+if 'dag_img' not in st.session_state:
+    st.session_state.dag_img = None
+
+# 標題
+st.title("🎲 Bayesian Hierarchical Model Analysis")
+st.markdown("### 火系 vs 水系寶可夢配對勝率的貝氏階層分析")
+st.markdown("---")
+
+# Sidebar
+with st.sidebar:
+    st.header("⚙️ 配置設定")
+    
+    # API 選擇
+    api_choice = st.radio(
+        "選擇 LLM API",
+        options=["Google Gemini", "Anthropic Claude"],
+        index=0,
+        help="選擇要使用的 AI 助手"
+    )
+    
+    # API Key 輸入
+    if api_choice == "Google Gemini":
+        api_key = st.text_input(
+            "Google Gemini API Key",
+            type="password",
+            help="輸入您的 Google Gemini API Key"
+        )
+    else:  # Claude
+        api_key = st.text_input(
+            "Anthropic Claude API Key",
+            type="password",
+            help="輸入您的 Anthropic API Key (https://console.anthropic.com)"
+        )
+    
+    if api_key:
+        st.session_state.api_key = api_key
+        st.session_state.api_choice = api_choice  # 新增：儲存 API 選擇
+        st.success(f"✅ {api_choice} API Key 已載入")
+    
+    st.markdown("---")
+    
+    # MCMC 參數設定
+    st.subheader("🔬 MCMC 參數")
+    
+    n_samples = st.number_input(
+        "抽樣數 (Samples)",
+        min_value=500,
+        max_value=10000,
+        value=2000,
+        step=500,
+        help="每條鏈的抽樣數量"
+    )
+    
+    n_tune = st.number_input(
+        "調整期 (Tune)",
+        min_value=200,
+        max_value=5000,
+        value=1000,
+        step=200,
+        help="調整期的樣本數"
+    )
+    
+    n_chains = st.selectbox(
+        "鏈數 (Chains)",
+        options=[1, 2, 4],
+        index=1,
+        help="平行運行的鏈數"
+    )
+    
+    target_accept = st.slider(
+        "目標接��率",
+        min_value=0.80,
+        max_value=0.99,
+        value=0.95,
+        step=0.01,
+        help="NUTS 採樣器的目標接受率"
+    )
+    
+    st.markdown("---")
+    
+    # 清理按鈕
+    if st.button("🧹 清理過期資料"):
+        cleanup_old_sessions()
+        st.success("✅ 清理完成")
+        st.rerun()
+    
+    st.markdown("---")
+    
+    # 資料來源選擇
+    st.subheader("📊 資料來源")
+    data_source = st.radio(
+        "選擇資料來源：",
+        ["使用預設資料集", "上傳您的資料"]
+    )
+    
+    uploaded_file = None
+    if data_source == "上傳您的資料":
+        uploaded_file = st.file_uploader(
+            "上傳 CSV 檔案",
+            type=['csv'],
+            help="上傳寶可夢速度對戰資料"
+        )
+        
+        with st.expander("📖 資料格式說明"):
+            st.markdown("""
+            **必要欄位格式：**
+            - `Trial_Type`: 配對名稱（例如：Pair_1, Pair_2）
+            - `rt`: 火系（治療組）的勝場數
+            - `nt`: 火系的總場數
+            - `rc`: 水系（對照組）的勝場數
+            - `nc`: 水系的總場數
+            
+            **範例：**
+            ```
+            Trial_Type,rt,nt,rc,nc
+            Pair_1,122,133,22,145
+            Pair_2,85,132,17,135
+            Pair_3,52,129,41,134
+            ```
+            """)   
+            
+    st.markdown("---")
+    
+    
+    # 關於系統
+    with st.expander("ℹ️ 關於此系統"):
+        st.markdown("""
+        **貝氏階層模型分析系統**
+        
+        本系統使用貝氏階層模型來分析速度對寶可夢勝率的影響，
+        並考慮不同屬性之間的異質性。
+        
+        **主要功能：**
+        - 🎲 貝氏推論與後驗分佈
+        - 📊 階層模型（借用資訊）
+        - 📈 4 種視覺化圖表
+        - 💬 AI 助手解釋
+        - 🎮 屬性對抗策略建議
+
+        **適用場景：**
+        - 分析火系對水系的配對勝率
+        - 理解不同配對間的異質性
+        - 評估屬性優劣勢
+        """)
+
+# 主要內容區 - 雙 Tab
+tab1, tab2 = st.tabs(["📊 貝氏分析", "💬 AI 助手"])
+
+# Tab 1: 貝氏分析
+with tab1:
+    st.header("📊 貝氏階層模型分析")
+    
+    # 載入資料
+    if data_source == "使用預設資料集":
+        # 檢查預設資料是否存在
+        default_data_path = "fire_water_converted.csv"
+        if os.path.exists(default_data_path):
+            df = pd.read_csv(default_data_path)
+            st.success(f"✅ 已載入預設資料集（{len(df)} 組配對）")
+        else:
+            st.warning("⚠️ 找不到預設資料集，請上傳您的資料")
+            df = None
+    else:
+        if uploaded_file is not None:
+            df = pd.read_csv(uploaded_file)
+            st.success(f"✅ 已載入資料（{len(df)} 組配對）")
+        else:
+            df = None
+            st.info("📁 請在左側上傳 CSV 檔案")
+    
+    if df is not None:
+        # 顯示資料預覽
+        with st.expander("👀 資料預覽"):
+            st.dataframe(df, use_container_width=True)
+        
+        st.markdown("---")
+        
+        # 分析按鈕
+        col1, col2, col3 = st.columns([1, 2, 1])
+        
+        with col2:
+            analyze_button = st.button(
+                "🔬 開始貝氏分析",
+                type="primary",
+                use_container_width=True
+            )
+        
+        # 執行分析
+        if analyze_button:
+            with st.spinner(f"正在執行貝氏分析... (抽樣 {n_samples} × {n_chains} 條鏈)"):
+                try:
+                    # 初始化分析器
+                    if st.session_state.analyzer is None:
+                        st.session_state.analyzer = BayesianHierarchicalAnalyzer(st.session_state.session_id)
+                    
+                    # 載入資料
+                    st.session_state.analyzer.load_data(df)
+                    
+                    # 執行分析
+                    results = st.session_state.analyzer.run_analysis(
+                        n_samples=n_samples,
+                        n_tune=n_tune,
+                        n_chains=n_chains,
+                        target_accept=target_accept
+                    )
+                    
+                    st.session_state.analysis_results = results
+                    
+                    # 生成圖表
+                    with st.spinner("生成視覺化圖表..."):
+                        st.session_state.trace_img = plot_trace(st.session_state.analyzer.trace)
+                        st.session_state.posterior_img = plot_posterior(st.session_state.analyzer.trace)
+                        st.session_state.forest_img = plot_forest(
+                            st.session_state.analyzer.trace,
+                            results['trial_labels']
+                        )
+                        st.session_state.dag_img = plot_model_dag(st.session_state.analyzer)
+                    
+                    st.success("✅ 分析完成！")
+                    st.balloons()
+                    
+                except Exception as e:
+                    st.error(f"❌ 分析失敗: {str(e)}")
+        
+        # 顯示結果
+        if st.session_state.analysis_results is not None:
+            results = st.session_state.analysis_results
+            
+            st.markdown("---")
+            st.subheader("📊 分析結果")
+            
+            # 創建 4 個子頁面
+            result_tabs = st.tabs([
+                "📊 概覽",
+                "📈 Trace & Posterior",
+                "🌲 Forest Plot",
+                "🔍 DAG 模型圖",
+                "📋 詳細報告"
+            ])
+            
+            # Tab: 概覽
+            with result_tabs[0]:
+                st.markdown("### 🎯 整體效應摘要")
+                
+                overall = results['overall']
+                interp = results['interpretation']
+                
+                # 關鍵指標
+                col1, col2, col3 = st.columns(3)
+                
+                with col1:
+                    st.metric(
+                        "d (整體效應)",
+                        f"{overall['d_mean']:.4f}",
+                        delta=f"HDI: [{overall['d_hdi_low']:.3f}, {overall['d_hdi_high']:.3f}]"
+                    )
+                
+                with col2:
+                    st.metric(
+                        "勝算比 (OR)",
+                        f"{overall['or_mean']:.3f}",
+                        delta=f"HDI: [{overall['or_hdi_low']:.3f}, {overall['or_hdi_high']:.3f}]"
+                    )
+                
+                with col3:
+                    st.metric(
+                        "sigma (異質性)",
+                        f"{overall['sigma_mean']:.4f}",
+                        delta=f"HDI: [{overall['sigma_hdi_low']:.3f}, {overall['sigma_hdi_high']:.3f}]"
+                    )
+                
+                st.markdown("---")
+                
+                # 結果解釋
+                st.markdown("### 📖 結果解釋")
+                
+                st.info(f"""
+                **整體效應**: {interp['overall_effect']}
+                
+                **顯著性**: {interp['overall_significance']}
+                
+                **效果大小**: {interp['effect_size']}
+                
+                **異質性**: {interp['heterogeneity']}
+                """)
+                
+                st.markdown("---")
+                
+                # 收斂診斷
+                st.markdown("### 🔍 模型收斂診斷")
+                
+                diag = results['diagnostics']
+                
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.markdown("**R-hat 診斷** (應 < 1.1):")
+                    if diag['rhat_d']:
+                        st.metric("R-hat (d)", f"{diag['rhat_d']:.4f}", 
+                                 delta="✓ 良好" if diag['rhat_d'] < 1.1 else "✗ 需改善")
+                    if diag['rhat_sigma']:
+                        st.metric("R-hat (sigma)", f"{diag['rhat_sigma']:.4f}",
+                                 delta="✓ 良好" if diag['rhat_sigma'] < 1.1 else "✗ 需改善")
+                
+                with col2:
+                    st.markdown("**有效樣本數 (ESS)**:")
+                    if diag['ess_d']:
+                        st.metric("ESS (d)", f"{int(diag['ess_d'])}")
+                    if diag['ess_sigma']:
+                        st.metric("ESS (sigma)", f"{int(diag['ess_sigma'])}")
+                
+                if diag['converged']:
+                    st.success("✅ 模型已收斂，結果可信")
+                else:
+                    st.warning("⚠️ 模型可能未完全收斂，建議增加抽樣數或鏈數")
+                
+                st.markdown("---")
+                
+                # 摘要表格
+                st.markdown("### 📊 統計摘要表")
+                summary_df = create_summary_table(results)
+                st.dataframe(summary_df, use_container_width=True)
+                
+                st.markdown("---")
+                
+                # 各屬性結果
+                st.markdown("### 🎮 各屬性詳細結果")
+                trial_df = create_trial_results_table(results)
+                st.dataframe(trial_df, use_container_width=True)
+                
+                st.markdown("---")
+                
+                # 勝算比比較圖
+                st.markdown("### 📊 各屬性速度效應比較")
+                or_fig = plot_odds_ratio_comparison(results)
+                st.plotly_chart(or_fig, use_container_width=True)
+            
+            # Tab: Trace & Posterior
+            with result_tabs[1]:
+                st.markdown("### 📈 Trace Plot（收斂診斷）")
+                st.markdown("""
+                **Trace Plot 用途**：
+                - 檢查 MCMC 抽樣是否收斂
+                - 左圖：抽樣軌跡（應該像「毛毛蟲」）
+                - 右圖：後驗分佈密度
+                """)
+                
+                if st.session_state.trace_img:
+                    st.image(st.session_state.trace_img, use_column_width=True)
+                else:
+                    st.info("請先執行分析以生成 Trace Plot")
+                
+                st.markdown("---")
+                
+                st.markdown("### 📊 Posterior Plot（後驗分佈）")
+                st.markdown("""
+                **Posterior Plot 用途**：
+                - 顯示參數的後驗分佈
+                - 包含 95% HDI（最高密度區間）
+                - 顯示平均值
+                """)
+                
+                if st.session_state.posterior_img:
+                    st.image(st.session_state.posterior_img, use_column_width=True)
+                else:
+                    st.info("請先執行分析以生成 Posterior Plot")
+            
+            # Tab: Forest Plot
+            with result_tabs[2]:
+                st.markdown("### 🌲 Forest Plot（各屬性效應）")
+                st.markdown("""
+                **Forest Plot 用途**：
+                - 顯示每個屬性的速度效應（delta）
+                - 點：平均效應
+                - 線：95% HDI
+                - ★ 標記：顯著正效應（HDI 不包含 0）
+                - ☆ 標記：顯著負效應
+                """)
+                
+                if st.session_state.forest_img:
+                    st.image(st.session_state.forest_img, use_column_width=True)
+                else:
+                    st.info("請先執行分析以生成 Forest Plot")
+            
+            # Tab: DAG 模型圖
+            with result_tabs[3]:
+                st.markdown("### 🔍 模型結構圖 (DAG)")
+                st.markdown("""
+                **DAG（有向無環圖）用途**：
+                - 視覺化模型的階層結構
+                - 顯示變數之間的依賴關係
+                - 圓形/橢圓：隨機變數
+                - 矩形：觀測資料
+                - 菱形：推導變數
+                """)
+                
+                if st.session_state.dag_img:
+                    st.image(st.session_state.dag_img, use_column_width=True)
+                else:
+                    st.warning("⚠️ 無法生成 DAG 圖（可能需要安裝 Graphviz）")
+                    st.markdown("""
+                    **安裝 Graphviz:**
+                    - Windows: `choco install graphviz`
+                    - Mac: `brew install graphviz`
+                    - Ubuntu: `sudo apt-get install graphviz`
+                    """)
+            
+            # Tab: 詳細報告
+            with result_tabs[4]:
+                st.markdown("### 📋 完整分析報告")
+                
+                # 生成文字報告
+                text_report = export_results_to_text(results)
+                
+                st.text_area(
+                    "報告內容",
+                    text_report,
+                    height=500
+                )
+                
+                # 下載按鈕
+                st.download_button(
+                    label="📥 下載完整報告 (.txt)",
+                    data=text_report,
+                    file_name=f"bayesian_report_{results['timestamp'][:10]}.txt",
+                    mime="text/plain"
+                )
+
+# Tab 2: AI 助手
+with tab2:
+    st.header("💬 AI 分析助手")
+    
+    if not st.session_state.get('api_key'):
+        st.warning("⚠️ 請在左側輸入您的 Google Gemini API Key 以使用 AI 助手")
+    elif st.session_state.analysis_results is None:
+        st.info("ℹ️ 請先在「貝氏分析」頁面執行分析")
+    else:
+        # 初始化 LLM 助手
+        if 'llm_assistant' not in st.session_state:
+            api_choice = st.session_state.get('api_choice', 'Google Gemini')
+            st.session_state.llm_assistant = BayesianLLMAssistant(
+                api_key=st.session_state.api_key,
+                session_id=st.session_state.session_id,
+                api_provider=api_choice  # 新增：傳遞 API 選擇
+            )
+        
+        # 聊天容器
+        chat_container = st.container()
+                        
+        with chat_container:
+            for message in st.session_state.chat_history:
+                with st.chat_message(message["role"]):
+                    st.markdown(message["content"])
+                    # 如果訊息包含 DAG 圖，顯示圖片
+                    if message.get("has_dag", False) and message.get("dag_image") is not None:
+                        st.image(message["dag_image"], caption="🎨 生成的 DAG 圖", use_column_width=True)                        
+                        
+        
+        # 使用者輸入
+        if prompt := st.chat_input("詢問關於分析結果的任何問題..."):
+            # 添加使用者訊息
+            st.session_state.chat_history.append({
+                "role": "user",
+                "content": prompt
+            })
+            
+            with st.chat_message("user"):
+                st.markdown(prompt)
+            
+            # AI 回應
+            with st.chat_message("assistant"):
+                with st.spinner("思考中..."):
+                    try:
+                        # 修改：接收回應和可能的 DAG 圖片
+                        response, dag_image = st.session_state.llm_assistant.get_response(
+                            user_message=prompt,
+                            analysis_results=st.session_state.analysis_results
+                        )
+                        st.markdown(response)
+                        
+                        # 如果有生成 DAG 圖，顯示它
+                        if dag_image is not None:
+                            st.image(dag_image, caption="🎨 AI 生成的 DAG 圖", use_column_width=True)
+                            st.success("✨ DAG 圖已生成！你可以繼續詢問圖表相關問題。")
+                        
+                    except Exception as e:
+                        error_msg = f"❌ 錯誤: {str(e)}\n\n請檢查 API key 或重新表達問題。"
+                        st.error(error_msg)
+                        response = error_msg
+                        dag_image = None
+            
+            # 添加助手回應（包含 DAG 標記）
+            st.session_state.chat_history.append({
+                "role": "assistant",
+                "content": response,
+                "has_dag": dag_image is not None,
+                "dag_image": dag_image  # 新增：保存圖片
+            })
+        
+        st.markdown("---")
+        
+        # 快速問題按鈕
+        st.subheader("💡 快速問題")
+        
+        # 添加使用提示
+        st.info("💡 提示：你可以要求助手「畫一個 DAG 圖」來視覺化模型結構！")
+        
+        quick_questions = [
+            "📊 給我這次分析的總結",
+            "🎯 解釋 d 和勝算比",
+            "🔍 解釋 sigma（異質性）",
+            "❓ 什麼是階層模型？",
+            "🎨 畫一個模型結構圖",  # 新增 DAG 生成按鈕
+            "🆚 貝氏 vs 頻率論",
+            "⚔️ 對戰策略建議",
+            "🎮 比較不同屬性"
+        ]
+        
+        cols = st.columns(4)
+        for idx, question in enumerate(quick_questions):
+            col_idx = idx % 4
+            if cols[col_idx].button(question, key=f"quick_{idx}"):
+                # 根據問題選擇對應的方法
+                if "總結" in question:
+                    response = st.session_state.llm_assistant.generate_summary(
+                        st.session_state.analysis_results
+                    )
+                    dag_image = None  # 這些方法不返回圖片
+                elif "d 和勝算比" in question:
+                    response = st.session_state.llm_assistant.explain_metric(
+                        'd',
+                        st.session_state.analysis_results
+                    )
+                    dag_image = None
+                elif "sigma" in question or "異質性" in question:
+                    response = st.session_state.llm_assistant.explain_metric(
+                        'sigma',
+                        st.session_state.analysis_results
+                    )
+                    dag_image = None
+                elif "階層模型" in question:
+                    response = st.session_state.llm_assistant.explain_hierarchical_model()
+                    dag_image = None
+                elif "畫一個" in question or "結構圖" in question:
+                    # DAG 生成請求
+                    response, dag_image = st.session_state.llm_assistant.get_response(
+                        "請畫一個貝氏階層模型的 DAG 圖，並用繁體中文解釋每個節點的意義",
+                        st.session_state.analysis_results
+                    )
+                elif "貝氏" in question and "頻率論" in question:
+                    response = st.session_state.llm_assistant.explain_bayesian_vs_frequentist()
+                    dag_image = None
+                elif "策略" in question:
+                    response = st.session_state.llm_assistant.battle_strategy_advice(
+                        st.session_state.analysis_results
+                    )
+                    dag_image = None
+                elif "比較" in question:
+                    response = st.session_state.llm_assistant.compare_types(
+                        st.session_state.analysis_results
+                    )
+                    dag_image = None
+                else:
+                    response, dag_image = st.session_state.llm_assistant.get_response(
+                        question,
+                        st.session_state.analysis_results
+                    )
+                
+                # 添加到聊天歷史
+                st.session_state.chat_history.append({
+                    "role": "user",
+                    "content": question
+                })
+                
+                st.session_state.chat_history.append({
+                    "role": "assistant",
+                    "content": response,
+                    "has_dag": dag_image is not None if 'dag_image' in locals() else False,
+                    "dag_image": dag_image if 'dag_image' in locals() else None
+                })
+                
+                st.rerun()
+        
+        # 重置對話按鈕
+        st.markdown("---")
+        if st.button("🔄 重置對話"):
+            st.session_state.llm_assistant.reset_conversation()
+            st.session_state.chat_history = []
+            st.success("✅ 對話已重置")
+            st.rerun()
+
+# Footer
+st.markdown("---")
+st.markdown(
+    f"""
+    <div style='text-align: center'>
+        <p>🎲 Bayesian Hierarchical Model Analysis for Pokémon Speed | Built with Streamlit & PyMC</p>
+        <p>Session ID: {st.session_state.session_id[:8]} | Powered by Google Gemini 2.0 Flash</p>
+    </div>
+    """,
+    unsafe_allow_html=True
+)

bayesian_core.py

@@ -1,18 +1,16 @@
-import os
-import pymc as pm
-import numpy as np
 import pandas as pd
+import numpy as np
+import pymc as pm
 import arviz as az
-import matplotlib.pyplot as plt
-import io
-import base64
-from datetime import datetime
 import threading
+from datetime import datetime
+import warnings
+warnings.filterwarnings('ignore')
 
 class BayesianHierarchicalAnalyzer:
     """
     貝氏階層模型分析器
-    用於分析寶可夢速度對勝率的影響（按屬性分層）
+    用於分析寶可夢速度對勝率的影響（跨屬性）
     """
     
     # 類別級的鎖，用於執行緒安全
@@ -39,6 +37,13 @@ class BayesianHierarchicalAnalyzer:
         
         Args:
             csv_path_or_df: CSV 檔案路徑或 DataFrame
+            
+        Expected columns:
+            - Trial_Type: 屬性名稱 (e.g., Water, Fire, Grass)
+            - rc: 控制組（速度慢）的勝場數
+            - nc: 控制組的總場數
+            - rt: 實驗組（速度快）的勝場數
+            - nt: 實驗組的總場數
         """
         if isinstance(csv_path_or_df, str):
             self.df = pd.read_csv(csv_path_or_df)
@@ -51,8 +56,29 @@ class BayesianHierarchicalAnalyzer:
         
         if missing_cols:
             raise ValueError(f"資料缺少必要欄位: {missing_cols}")
+        
+        return True
     
-    def run_analysis(self, n_samples=2000, n_tune=1000, n_chains=1, target_accept=0.95, progress_callback=None):
+    def validate_data(self):
+        """驗證資料有效性"""
+        if self.df is None:
+            raise ValueError("請先載入資料")
+        
+        # 檢查數值欄位
+        for col in ['rc', 'nc', 'rt', 'nt']:
+            if not pd.api.types.is_numeric_dtype(self.df[col]):
+                raise ValueError(f"欄位 {col} 必須是數值類型")
+        
+        # 檢查邏輯約束
+        if (self.df['rc'] > self.df['nc']).any():
+            raise ValueError("rc (勝場數) 不能大於 nc (總場數)")
+        
+        if (self.df['rt'] > self.df['nt']).any():
+            raise ValueError("rt (勝場數) 不能大於 nt (總場數)")
+        
+        return True
+    
+    def run_analysis(self, n_samples=2000, n_tune=1000, n_chains=2, target_accept=0.95):
         """
         執行貝氏階層模型分析
         
@@ -61,243 +87,218 @@ class BayesianHierarchicalAnalyzer:
             n_tune: 調整期樣本數
             n_chains: 鏈數
             target_accept: 目標接受率
-            progress_callback: 進度回調函數
             
         Returns:
             dict: 包含所有分析結果的字典
         """
         with self._lock:
             try:
-                if self.df is None:
-                    raise ValueError("請先載入資料")
-                
-                if progress_callback:
-                    progress_callback("建立貝氏模型...", 10)
+                self.validate_data()
                 
                 # 準備資料
                 trial_labels = self.df['Trial_Type'].values
-                Num = len(self.df)
+                num_trials = len(self.df)
                 
-                # 建立貝氏模型
-                with pm.Model() as model:
-                    # 先驗分佈
+                # 建立模型
+                with pm.Model() as self.model:
+                    # --- 先驗分佈 (Priors) ---
                     d = pm.Normal('d', mu=0, sigma=10)
                     tau = pm.Gamma('tau', alpha=0.001, beta=0.001)
                     sigma = pm.Deterministic('sigma', 1 / pm.math.sqrt(tau))
                     
-                    # 各屬性特定效應
-                    mu = pm.Normal('mu', mu=0, sigma=10, shape=Num)
-                    delta = pm.Normal('delta', mu=d, sigma=1 / pm.math.sqrt(tau), shape=Num)
+                    # --- 各屬性特定效應 (Trial-specific effects) ---
+                    mu = pm.Normal('mu', mu=0, sigma=10, shape=num_trials)
+                    delta = pm.Normal('delta', mu=d, sigma=1 / pm.math.sqrt(tau), shape=num_trials)
                     
-                    # 轉換與似然函數
+                    # --- 轉換與似然函數 (Logit Link & Likelihood) ---
                     pc = pm.Deterministic('pc', pm.math.invlogit(mu))
                     pt = pm.Deterministic('pt', pm.math.invlogit(mu + delta))
+                    
                     rc_obs = pm.Binomial('rc_obs', n=self.df['nc'].values, p=pc, observed=self.df['rc'].values)
                     rt_obs = pm.Binomial('rt_obs', n=self.df['nt'].values, p=pt, observed=self.df['rt'].values)
                     
-                    # 其他統計量
+                    # --- 其他統計量 ---
                     delta_new = pm.Normal('delta_new', mu=d, sigma=1 / pm.math.sqrt(tau))
                     or_speed = pm.Deterministic('or_speed', pm.math.exp(d))
                     
-                    # 生成 DAG 圖
-                    if progress_callback:
-                        progress_callback("生成 DAG 模型圖...", 20)
-                    
-                    try:
-                        dag_img = self._generate_dag(model)
-                    except Exception as e:
-                        print(f"DAG 生成失敗: {e}")
-                        dag_img = None
-                    
                     # 執行 MCMC 抽樣
-                    if progress_callback:
-                        progress_callback("執行貝氏抽樣（這可能需要幾分鐘）...", 30)
-                    
-                    trace = pm.sample(
-                        n_samples, 
-                        tune=n_tune, 
-                        chains=n_chains, 
-                        target_accept=target_accept, 
+                    self.trace = pm.sample(
+                        draws=n_samples,
+                        tune=n_tune,
+                        chains=n_chains,
+                        target_accept=target_accept,
                         return_inferencedata=True,
-                        progressbar=False
+                        progressbar=False, # 在 Streamlit 中關閉進度條
+                        discard_tuned_samples=False  # 👈 加這行!保留 tune 樣本
                     )
                 
-                self.model = model
-                self.trace = trace
+                # 生成摘要統計
+                summary = az.summary(self.trace, var_names=['d', 'sigma', 'or_speed'], hdi_prob=0.95)
                 
-                if progress_callback:
-                    progress_callback("生成統計摘要...", 60)
+                # 計算各屬性的 delta 統計量
+                delta_posterior = self.trace.posterior['delta'].values.reshape(-1, num_trials)
+                delta_mean = delta_posterior.mean(axis=0)
+                delta_std = delta_posterior.std(axis=0)
+                delta_hdi = az.hdi(self.trace, var_names=['delta'], hdi_prob=0.95)['delta'].values
                 
-                # 生成文字摘要
-                summary = az.summary(trace, var_names=['d', 'sigma', 'or_speed'], hdi_prob=0.95)
-                summary_text = self._format_summary(summary)
+                # 判斷顯著性（HDI 不包含 0）
+                delta_significant = (delta_hdi[:, 0] > 0) | (delta_hdi[:, 1] < 0)
                 
-                if progress_callback:
-                    progress_callback("生成視覺化圖表...", 70)
+                # 計算控制組和實驗組的勝率
+                pc_posterior = self.trace.posterior['pc'].values.reshape(-1, num_trials)
+                pt_posterior = self.trace.posterior['pt'].values.reshape(-1, num_trials)
                 
-                # 生成圖表
-                trace_plot = self._generate_trace_plot(trace)
-                posterior_plot = self._generate_posterior_plot(trace)
-                forest_plot = self._generate_forest_plot(trace, trial_labels, Num)
-                
-                if progress_callback:
-                    progress_callback("整理結果...", 90)
+                pc_mean = pc_posterior.mean(axis=0)
+                pt_mean = pt_posterior.mean(axis=0)
                 
                 # 整理結果
                 results = {
-                    'trial_labels': trial_labels.tolist(),
-                    'n_trials': Num,
-                    'summary_table': summary.to_dict(),
-                    'summary_text': summary_text,
-                    'd_mean': float(summary.loc['d', 'mean']),
-                    'd_sd': float(summary.loc['d', 'sd']),
-                    'd_hdi_lower': float(summary.loc['d', 'hdi_2.5%']),
-                    'd_hdi_upper': float(summary.loc['d', 'hdi_97.5%']),
-                    'sigma_mean': float(summary.loc['sigma', 'mean']),
-                    'sigma_sd': float(summary.loc['sigma', 'sd']),
-                    'or_speed_mean': float(summary.loc['or_speed', 'mean']),
-                    'or_speed_sd': float(summary.loc['or_speed', 'sd']),
-                    'or_speed_hdi_lower': float(summary.loc['or_speed', 'hdi_2.5%']),
-                    'or_speed_hdi_upper': float(summary.loc['or_speed', 'hdi_97.5%']),
-                    'is_significant': summary.loc['d', 'hdi_2.5%'] > 0 or summary.loc['d', 'hdi_97.5%'] < 0,
-                    'dag_plot': dag_img,
-                    'trace_plot': trace_plot,
-                    'posterior_plot': posterior_plot,
-                    'forest_plot': forest_plot,
                     'timestamp': datetime.now().isoformat(),
-                    'sampling_params': {
+                    'n_trials': num_trials,
+                    'trial_labels': trial_labels.tolist(),
+                    
+                    # 整體效應
+                    'overall': {
+                        'd_mean': float(summary.loc['d', 'mean']),
+                        'd_sd': float(summary.loc['d', 'sd']),
+                        'd_hdi_low': float(summary.loc['d', 'hdi_2.5%']),
+                        'd_hdi_high': float(summary.loc['d', 'hdi_97.5%']),
+                        
+                        'sigma_mean': float(summary.loc['sigma', 'mean']),
+                        'sigma_sd': float(summary.loc['sigma', 'sd']),
+                        'sigma_hdi_low': float(summary.loc['sigma', 'hdi_2.5%']),
+                        'sigma_hdi_high': float(summary.loc['sigma', 'hdi_97.5%']),
+                        
+                        'or_mean': float(summary.loc['or_speed', 'mean']),
+                        'or_sd': float(summary.loc['or_speed', 'sd']),
+                        'or_hdi_low': float(summary.loc['or_speed', 'hdi_2.5%']),
+                        'or_hdi_high': float(summary.loc['or_speed', 'hdi_97.5%']),
+                    },
+                    
+                    # 各屬性的效應
+                    'by_trial': {
+                        'delta_mean': delta_mean.tolist(),
+                        'delta_std': delta_std.tolist(),
+                        'delta_hdi_low': delta_hdi[:, 0].tolist(),
+                        'delta_hdi_high': delta_hdi[:, 1].tolist(),
+                        'delta_significant': delta_significant.tolist(),
+                        'pc_mean': pc_mean.tolist(),
+                        'pt_mean': pt_mean.tolist(),
+                    },
+                    
+                    # 原始資料
+                    'data': self.df.to_dict('records'),
+                    
+                    # 模型參數
+                    'model_params': {
                         'n_samples': n_samples,
                         'n_tune': n_tune,
                         'n_chains': n_chains,
                         'target_accept': target_accept
-                    }
+                    },
+                    
+                    # 收斂診斷
+                    'diagnostics': self._compute_diagnostics(summary),
+                    
+                    # 解釋
+                    'interpretation': self._interpret_results(
+                        summary.loc['or_speed', 'mean'],
+                        summary.loc['or_speed', 'hdi_2.5%'],
+                        summary.loc['or_speed', 'hdi_97.5%'],
+                        summary.loc['sigma', 'mean']
+                    )
                 }
                 
-                # 添加各屬性的詳細結果
-                delta_summary = az.summary(trace, var_names=['delta'], hdi_prob=0.95)
-                results['delta_results'] = []
-                for i, trial_type in enumerate(trial_labels):
-                    results['delta_results'].append({
-                        'trial_type': trial_type,
-                        'delta_mean': float(delta_summary.iloc[i]['mean']),
-                        'delta_sd': float(delta_summary.iloc[i]['sd']),
-                        'delta_hdi_lower': float(delta_summary.iloc[i]['hdi_2.5%']),
-                        'delta_hdi_upper': float(delta_summary.iloc[i]['hdi_97.5%']),
-                        'is_significant': delta_summary.iloc[i]['hdi_2.5%'] > 0 or delta_summary.iloc[i]['hdi_97.5%'] < 0
-                    })
-                
                 # 儲存到 session results
                 self._session_results[self.session_id] = results
                 
-                if progress_callback:
-                    progress_callback("分析完成！", 100)
-                
                 return results
                 
             except Exception as e:
                 raise Exception(f"分析失敗: {str(e)}")
     
-    def _generate_dag(self, model):
-        """生成 DAG 圖"""
+    def _compute_diagnostics(self, summary):
+        """計算收斂診斷指標"""
         try:
-            gv = pm.model_to_graphviz(model)
-            # 轉換為 PNG 圖片的 base64
-            png_data = gv.pipe(format='png')
-            return base64.b64encode(png_data).decode()
-        except Exception as e:
-            print(f"DAG 生成失敗: {e}")
-            return None
-    
-    def _generate_trace_plot(self, trace):
-        """生成 Trace Plot"""
-        fig, axes = plt.subplots(2, 2, figsize=(14, 8))
-        az.plot_trace(trace, var_names=['d', 'sigma'], axes=axes)
-        plt.tight_layout()
-        
-        # 轉換為 base64
-        buf = io.BytesIO()
-        plt.savefig(buf, format='png', dpi=150, bbox_inches='tight')
-        buf.seek(0)
-        img_base64 = base64.b64encode(buf.read()).decode()
-        plt.close()
-        
-        return img_base64
-    
-    def _generate_posterior_plot(self, trace):
-        """生成 Posterior Plot"""
-        az.plot_posterior(trace, var_names=['d', 'sigma', 'or_speed'], hdi_prob=0.95)
-        
-        # 轉換為 base64
-        buf = io.BytesIO()
-        plt.savefig(buf, format='png', dpi=150, bbox_inches='tight')
-        buf.seek(0)
-        img_base64 = base64.b64encode(buf.read()).decode()
-        plt.close()
-        
-        return img_base64
+            # R-hat (應該接近 1.0)
+            rhat_d = float(summary.loc['d', 'r_hat']) if 'r_hat' in summary.columns else None
+            rhat_sigma = float(summary.loc['sigma', 'r_hat']) if 'r_hat' in summary.columns else None
+            
+            # ESS (有效樣本數)
+            ess_d = float(summary.loc['d', 'ess_bulk']) if 'ess_bulk' in summary.columns else None
+            ess_sigma = float(summary.loc['sigma', 'ess_bulk']) if 'ess_bulk' in summary.columns else None
+            
+            return {
+                'rhat_d': rhat_d,
+                'rhat_sigma': rhat_sigma,
+                'ess_d': ess_d,
+                'ess_sigma': ess_sigma,
+                'converged': (rhat_d is None or rhat_d < 1.1) and (rhat_sigma is None or rhat_sigma < 1.1)
+            }
+        except:
+            return {
+                'converged': None,
+                'rhat_d': None,
+                'rhat_sigma': None,
+                'ess_d': None,
+                'ess_sigma': None
+            }
     
-    def _generate_forest_plot(self, trace, trial_labels, Num):
-        """生成 Forest Plot"""
-        delta_posterior = trace.posterior['delta'].values.reshape(-1, Num)
-        delta_mean = delta_posterior.mean(axis=0)
-        delta_hdi = az.hdi(trace, var_names=['delta'], hdi_prob=0.95)['delta'].values
-        
-        fig, ax = plt.subplots(figsize=(12, max(10, Num * 0.4)))
-        y_pos = np.arange(Num)
-        
-        # 繪製信賴區間
-        ax.hlines(y_pos, delta_hdi[:, 0], delta_hdi[:, 1], color='steelblue', linewidth=3)
-        # 繪製平均值
-        ax.scatter(delta_mean, y_pos, color='darkblue', s=120, zorder=3, edgecolors='white', linewidth=1.5)
-        
-        # 標註顯著的屬性
-        for i, (mean, hdi) in enumerate(zip(delta_mean, delta_hdi)):
-            if hdi[0] > 0:  # 顯著正效應
-                ax.text(mean + 0.05, i, '★', fontsize=15, ha='left', color='gold', va='center')
-        
-        # 設定軸
-        ax.set_yticks(y_pos)
-        ax.set_yticklabels(trial_labels, fontsize=11)
-        ax.invert_yaxis()
-        ax.axvline(0, color='red', linestyle='--', linewidth=2, label='No Effect (δ=0)')
-        ax.set_xlabel('Delta (Log Odds Ratio)', fontsize=13)
-        ax.set_title('Effect of Speed on Win Rate by Type', fontsize=15, fontweight='bold', pad=20)
-        ax.legend(loc='lower right')
-        ax.grid(axis='x', alpha=0.3)
-        
-        plt.tight_layout()
-        
-        # 轉換為 base64
-        buf = io.BytesIO()
-        plt.savefig(buf, format='png', dpi=150, bbox_inches='tight')
-        buf.seek(0)
-        img_base64 = base64.b64encode(buf.read()).decode()
-        plt.close()
+    def _interpret_results(self, or_mean, or_low, or_high, sigma_mean):
+        """解釋分析結果"""
+        # 整體效應顯著性       
+        if or_low > 1:
+            overall_effect = "火系寶可夢相對於水系顯著更容易獲勝"
+            overall_significance = "顯著正效應"
+        elif or_high < 1:
+            overall_effect = "水系寶可夢相對於火系顯著更容易獲勝"
+            overall_significance = "顯著負效應"
+        else:
+            overall_effect = "火系與水系勝率無顯著差異"
+            overall_significance = "不顯著"        
+
+        # 效果大小           
+        if or_mean > 2:
+            effect_size = "大效果 (OR > 2) - 火系有明顯優勢"
+        elif or_mean > 1.5:
+            effect_size = "中等效果 (OR > 1.5) - 火系有一定優勢"
+        elif or_mean > 1:
+            effect_size = "小效果 (OR > 1) - 火系略有優勢"
+        elif or_mean == 1:
+            effect_size = "無差異 (OR = 1) - 火系與水系勢均力敵"
+        elif or_mean > 0.67:
+            effect_size = "小效果 (OR < 1) - 水系略有優勢"
+        elif or_mean > 0.5:
+            effect_size = "中等效果 (OR < 0.67) - 水系有一定優勢"
+        else:
+            effect_size = "大效果 (OR < 0.5) - 水系有明顯優勢"          
+                    
         
-        return img_base64
+        # 異質性評估
+        if sigma_mean > 0.5:
+            heterogeneity = "高異質性 - 不同配對的勝率差異很大"
+        elif sigma_mean > 0.3:
+            heterogeneity = "中等異質性 - 不同配對的勝率有一定差異"
+        else:
+            heterogeneity = "低異質性 - 不同配對的勝率相對一致"        
+              
+        return {
+            'overall_effect': overall_effect,
+            'overall_significance': overall_significance,
+            'effect_size': effect_size,
+            'heterogeneity': heterogeneity
+        }
     
-    def _format_summary(self, summary):
-        """格式化摘要表格為文字"""
-        text = "="*70 + "\n"
-        text += "貝氏階層模型分析結果摘要\n"
-        text += "Bayesian Hierarchical Model Analysis Summary\n"
-        text += "="*70 + "\n\n"
-        
-        for var in ['d', 'sigma', 'or_speed']:
-            row = summary.loc[var]
-            text += f"{var:12} | "
-            text += f"Mean: {row['mean']:7.4f} | "
-            text += f"SD: {row['sd']:7.4f} | "
-            text += f"95% HDI: [{row['hdi_2.5%']:7.4f}, {row['hdi_97.5%']:7.4f}]\n"
+    def get_model_graph(self):
+        """生成模型 DAG 圖（返回 graphviz 物件）"""
+        if self.model is None:
+            raise ValueError("請先執行分析")
         
-        text += "\n" + "="*70 + "\n"
-        text += "參數說明 (Parameter Descriptions):\n"
-        text += "  d        : 整體平均效應 (Overall mean effect)\n"
-        text += "  sigma    : 屬性間變異 (Between-type variability)\n"
-        text += "  or_speed : 速度勝算比 (Speed odds ratio = exp(d))\n"
-        text += "="*70 + "\n"
-        
-        return text
+        try:
+            gv = pm.model_to_graphviz(self.model)
+            return gv
+        except Exception as e:
+            raise Exception(f"無法生成 DAG 圖: {str(e)}")
     
     @classmethod
     def get_session_results(cls, session_id):

bayesian_llm_assistant.py

@@ -1,25 +1,45 @@
 import google.generativeai as genai
+import json
+import re
+import graphviz
+import io
+from PIL import Image
 
 class BayesianLLMAssistant:
     """
-    貝氏階層模型 LLM 問答助手
-    協助用戶理解貝氏分析結果
+    貝氏階層模型 LLM 問答助手（支援動態 DAG 生成）
+    協助用戶理解貝氏分析結果，並可根據描述生成客製化 DAG 圖
     """
-    
-    def __init__(self, api_key, session_id):
+
+    def __init__(self, api_key, session_id, api_provider="Google Gemini"):
         """
         初始化 LLM 助手
         
         Args:
-            api_key: Google Gemini API key
+            api_key: API key (Gemini 或 Claude)
             session_id: 唯一的 session 識別碼
+            api_provider: API 提供商 ("Google Gemini" 或 "Anthropic Claude")
         """
-        genai.configure(api_key=api_key)
-        self.model = genai.GenerativeModel('gemini-2.0-flash-exp')
+        self.api_provider = api_provider
         self.session_id = session_id
         self.conversation_history = []
         
-        # 系統提示詞（雙語版）
+        if api_provider == "Google Gemini":
+            import google.generativeai as genai
+            genai.configure(api_key=api_key)
+            self.model = genai.GenerativeModel('gemini-2.0-flash-exp')
+            self.client = None
+        else:  # Anthropic Claude
+            import anthropic
+            self.client = anthropic.Anthropic(api_key=api_key)
+            self.model_name = "claude-sonnet-4-5-20250929"
+            self.model = None
+
+        
+        # 系統提示詞（加入 DAG 生成能力）
+        # 完整修改後的 system_prompt
+        # 替換 bayesian_llm_assistant.py 第 40-181 行
+
         self.system_prompt = """You are an expert Bayesian statistician specializing in hierarchical models and meta-analysis, particularly in the context of Pokémon battle statistics.
 
 **IMPORTANT - Language Instruction:**
@@ -28,65 +48,137 @@ class BayesianLLMAssistant:
 - If user asks in English, respond in English
 - Maintain language consistency throughout the conversation
 
-你是一位精通貝氏統計和階層模型的專家，特別專注於寶可夢速度對戰分析。
-
-Your role is to help users understand Bayesian hierarchical model results for analyzing how Speed affects win rates across different Pokémon types.
-你的角色是幫助使用者理解貝氏階層模型的結果，分析速度如何影響不同屬性寶可夢的勝率。
+你是一位精通貝氏階層模型和統合分析的統計專家，特別專注於寶可夢對戰統計分析。
+
+Your role is to help users understand Bayesian hierarchical model results analyzing 
+win rate comparisons between Fire-type and Water-type Pokémon across different matchup pairs.
+你的角色是幫助使用者理解貝氏階層模型分析結果，
+了解火系與水系寶可夢在不同配對組合下的勝率比較。
+
+**NEW CAPABILITY: DAG Diagram Generation | 新能力：DAG 圖生成**
+When users ask you to draw, create, or visualize a DAG (Directed Acyclic Graph) or model structure, you can generate Graphviz DOT code.
+當用戶要求你繪製、創建或視覺化 DAG（有向無環圖）或模型結構時，你可以生成 Graphviz DOT 代碼。
+
+**How to generate DAG code:**
+1. Detect requests like: "draw a DAG", "show me the model structure", "visualize the relationships", "畫一個 DAG 圖", "顯示模型結構"
+2. Generate Graphviz DOT code wrapped in special tags:
+   ```graphviz
+   digraph G {
+       // Your DOT code here
+   }
+   ```
+3. The system will automatically render it as an image
+
+**IMPORTANT - Font and Label Instructions for DAG:**
+- NEVER use Chinese characters in node labels
+- Use ONLY English labels, or use English + romanized Chinese
+- DO NOT set fontname in the graph
+- Example of good labels: "d (overall effect)" or "delta[i] (pair-specific)"
+- Example of bad labels: "整體效應" or any Chinese text
+
+**重要 - DAG 圖的字型和標籤指示：**
+- 絕對不要在節點標籤中使用中文字
+- 只使用英文標籤，或使用「英文 + 拼音」
+- 不要設定 fontname
+- 好的標籤範例："d (overall effect)" 或 "delta[i] (pair-specific)"
+- 不好的標籤範例："整體效應" 或任何中文
+
+**Example DAG code for Bayesian hierarchical model:**
+```graphviz
+digraph BayesianModel {
+    rankdir=TB;
+    node [shape=ellipse, style=filled, fillcolor=lightblue];
+    
+    // Priors
+    d [label="d\n(Fire vs Water overall)", fillcolor=lightyellow];
+    tau [label="tau\n(precision)", fillcolor=lightyellow];
+    sigma [label="sigma = 1/√tau", shape=diamond, fillcolor=lightgray];
+    
+    // Hierarchy
+    d -> delta [label="mean"];
+    tau -> delta [label="precision"];
+    sigma -> delta [style=dashed];
+    
+    delta [label="delta[i]\n(pair-specific)", fillcolor=lightgreen];
+    mu [label="mu[i]\n(baseline)", fillcolor=lightyellow];
+    
+    // Likelihood
+    delta -> pt [label="effect"];
+    mu -> pc;
+    mu -> pt;
+    
+    pc [label="pc[i]\n(Water win rate)", shape=diamond, fillcolor=lightgray];
+    pt [label="pt[i]\n(Fire win rate)", shape=diamond, fillcolor=lightgray];
+    
+    pc -> rc_obs [label="probability"];
+    pt -> rt_obs [label="probability"];
+    
+    rc_obs [label="rc_obs[i]\n(Water wins)", shape=box, fillcolor=lightcoral];
+    rt_obs [label="rt_obs[i]\n(Fire wins)", shape=box, fillcolor=lightcoral];
+}
+```
 
 You should:
-1. Explain Bayesian concepts in simple, accessible terms (prior, posterior, credible intervals)
-2. Interpret hierarchical modeling and why it's useful (borrowing strength, shrinkage)
-3. Explain what parameters mean (d, delta, sigma, tau)
-4. Discuss posterior distributions and HDI (Highest Density Interval)
-5. Help users understand convergence diagnostics (trace plots, R-hat)
-6. Explain the difference between Bayesian and frequentist approaches
-7. Provide battle strategy insights based on posterior estimates
-8. Discuss uncertainty quantification and practical significance
+1. Explain Bayesian concepts in simple, accessible terms
+2. Interpret posterior distributions, HDI (Highest Density Interval), and credible intervals
+3. Explain hierarchical structure and why it's useful
+4. Help users understand heterogeneity (sigma) between different matchup pairs
+5. Discuss the practical significance of Fire vs Water type advantages
+6. Provide insights about which matchup pairs favor Fire-types the most
+7. Suggest team building strategies based on the statistical findings
+8. Clarify differences between Bayesian and frequentist approaches
+9. Explain MCMC diagnostics (R-hat, ESS) when relevant
+10. **Generate custom DAG diagrams based on user descriptions**
 
 你應該：
-1. 用簡單易懂的方式解釋貝氏概念（先驗、後驗、可信區間）
-2. 詮釋階層模型及其優勢（資訊借用、收縮效應）
-3. 解釋參數的意義（d、delta、sigma、tau）
-4. 討論後驗分佈和 HDI（最高密度區間）
-5. 幫助使用者理解收斂診斷（trace plot、R-hat）
-6. 解釋貝氏與頻率論方法的差異
-7. 根據後驗估計提供對戰策略見解
-8. 討論不確定性量化和實際顯著性
+1. 用簡單易懂的方式解釋貝氏概念
+2. 詮釋後驗分佈、HDI（最高密度區間）和可信區間
+3. 解釋階層結構及其優勢
+4. 幫助使用者理解不同配對間的異質性（sigma）
+5. 討論火系與水系屬性優劣勢的實際意義
+6. 提供哪些配對組合中火系最具優勢的見解
+7. 根據統計發現提出組隊策略建議
+8. 說明貝氏方法與頻率論方法的差異
+9. 適時解釋 MCMC 診斷指標（R-hat、ESS）
+10. **根據用戶描述生成客製化 DAG 圖**
 
 Key concepts to explain when relevant:
-重要概念解釋（當相關時）：
+- **Bayesian Hierarchical Model**: Borrows strength across matchup pairs, shrinkage effect
+- **Prior & Posterior**: How data updates beliefs
+- **HDI (Highest Density Interval)**: 95% most credible values
+- **d (overall effect)**: Average log odds ratio of Fire vs Water across all pairs
+- **sigma (between-pair variation)**: How much different matchup pairs vary in Fire advantage
+- **delta (pair-specific effects)**: Each matchup pair's individual Fire advantage/disadvantage
+- **Odds Ratio**: exp(d) - how much more likely Fire-types are to win compared to Water-types
+- **MCMC**: Markov Chain Monte Carlo sampling method
+- **Convergence**: R-hat < 1.1, good ESS (effective sample size)
+- **DAG (Directed Acyclic Graph)**: Visual representation of model structure
 
-**Bayesian Framework | 貝氏框架:**
-- **Prior**: Initial belief before seeing data | 先驗：觀察資料前的初始信念
-- **Likelihood**: Probability of data given parameters | 似然：給定參數下資料的機率
-- **Posterior**: Updated belief after seeing data | 後驗：觀察資料後更新的信念
-- **HDI**: 95% highest density interval (Bayesian CI) | HDI：95% 最高密度區間（貝氏信賴區間）
-
-**Hierarchical Model Parameters | 階層模型參數:**
-- **d**: Overall mean effect across all types | d：所有屬性的整體平均效應
-- **delta[i]**: Type-specific effect for type i | delta[i]：第 i 個屬性的特定效應
-- **sigma**: Between-type variability | sigma：屬性間的變異性
-- **tau**: Precision parameter (1/sigma²) | tau：精確度參數（1/sigma²）
-- **or_speed**: Odds ratio = exp(d) | or_speed：勝算比 = exp(d)
-
-**Model Advantages | 模型優勢:**
-- Borrows information across types (partial pooling) | 跨屬性資訊借用（部分池化）
-- Quantifies uncertainty properly | 正確量化不確定性
-- Shrinks unreliable estimates toward overall mean | 將不可靠估計收縮至整體平均
-- Handles small sample sizes better | 更好處理小樣本
-
-**Interpretation Guidelines | 解讀指引:**
-- HDI not crossing 0 → significant effect | HDI 不跨越 0 → 效應顯著
-- or_speed > 1 → faster Pokémon more likely to win | or_speed > 1 → 速度快的更容易獲勝
-- Large sigma → high variability between types | sigma 大 → 屬���間差異大
-- Trace plots should look like "hairy caterpillar" | Trace 圖應該像「毛毛蟲」
-
-When discussing Pokémon battles:
-討論寶可夢對戰時：
-- Explain why Speed matters (turn order, priority moves) | 解釋速度的重要性（回合順序、先制技能）
-- Connect type-specific effects to battle mechanics | 將屬性特定效應連結到對戰機制
-- Discuss practical implications for team building | 討論組隊的實際意涵
-- Consider exceptions (Trick Room, priority moves) | 考慮例外情況（戲法空間、先制招式）
+重要概念解釋（當相關時）：
+- **貝氏階層模型**：跨配對借用資訊，收縮效應
+- **先驗與後驗**：資料如何更新信念
+- **HDI（最高密度區間）**：95% 最可信的數值範圍
+- **d（整體效應）**：火系相對於水系的平均對數勝算比（跨所有配對）
+- **sigma（配對間變異）**：不同配對組合的火系優勢差異程度
+- **delta（配對特定效應）**：每組配對的個別火系優勢/劣勢
+- **勝算比**：exp(d) - 火系相對於水系獲勝的可能性倍數
+- **MCMC**：馬可夫鏈蒙地卡羅抽樣方法
+- **收斂性**：R-hat < 1.1，良好的 ESS（有效樣本數）
+- **DAG（有向無環圖）**：模型結構的視覺化表示
+
+When discussing Pokémon type matchups:
+- Connect statistical findings to type advantage mechanics (Water typically beats Fire in core games)
+- Explain why Fire vs Water matchups show certain patterns
+- Discuss individual matchup variations and their causes (e.g., specific Pokémon abilities, stats)
+- Identify which Fire/Water Pokémon pairs show unusual results (Fire winning despite type disadvantage)
+- Consider team building and type coverage implications
+
+討論寶可夢屬性對抗時：
+- 將統計發現連結到屬性相剋機制（水系通常剋火系）
+- 解釋火系對水系的對戰模式為何呈現特定趨勢
+- 討論個別配對的變異及其可能原因（例如特殊能力、數值差異）
+- 識別哪些火/水系配對顯示異常結果（火系儘管屬性不利仍獲勝）
+- 考慮組隊和屬性覆蓋的影響
 
 Always be clear, educational, and engaging. Use examples when helpful.
 Format responses with proper markdown for better readability.
@@ -95,14 +187,14 @@ Format responses with proper markdown for better readability.
     
     def get_response(self, user_message, analysis_results=None):
         """
-        獲取 AI 回應
+        獲取 AI 回應（支援 DAG 生成）
         
         Args:
             user_message: 用戶訊息
             analysis_results: 分析結果字典（可選）
             
         Returns:
-            str: AI 回應
+            tuple: (回應文字, DAG 圖片或 None)
         """
         # 準備上下文資訊
         context = ""
@@ -131,16 +223,32 @@ Format responses with proper markdown for better readability.
             # 組合最終提示詞
             final_prompt = full_prompt + conversation_text + f"\nUser: {user_message}\n\nAssistant:"
             
-            # 調用 Gemini API
-            response = self.model.generate_content(
-                final_prompt,
-                generation_config=genai.types.GenerationConfig(
-                    temperature=1.0,
-                    max_output_tokens=4000,
+            
+            # 調用對應的 API
+            if self.api_provider == "Google Gemini":
+                response = self.model.generate_content(
+                    final_prompt,
+                    generation_config=genai.types.GenerationConfig(
+                        temperature=0.7,
+                        max_output_tokens=4000,
+                    )
+                )
+                assistant_message = response.text
+                
+            else:  # Anthropic Claude
+                response = self.client.messages.create(
+                    model=self.model_name,
+                    max_tokens=4000,
+                    temperature=0.7,
+                    system=self.system_prompt,
+                    messages=[
+                        {"role": "user", "content": final_prompt}
+                    ]
                 )
-            )
+                assistant_message = response.content[0].text            
             
-            assistant_message = response.text
+            # 檢查是否包含 Graphviz 代碼
+            dag_image = self._extract_and_render_dag(assistant_message)
             
             # 添加助手回應到歷史
             self.conversation_history.append({
@@ -148,10 +256,55 @@ Format responses with proper markdown for better readability.
                 "content": assistant_message
             })
             
-            return assistant_message
+            return assistant_message, dag_image
+            
+        except Exception as e:
+            error_msg = f"❌ Error: {str(e)}\n\nPlease check your API key and try again."
+            return error_msg, None
+    
+
+            
+    def _extract_and_render_dag(self, text):
+        """
+        從文字中提取 Graphviz 代碼並渲染成圖片
+        
+        Args:
+            text: 包含可能的 Graphviz 代碼的文字
+            
+        Returns:
+            PIL Image 或 None
+        """
+        # 方法 1: 嘗試提取 ```graphviz ... ``` 格式
+        pattern1 = r'```graphviz\s*\n(.*?)\n```'
+        matches = re.findall(pattern1, text, re.DOTALL)
+        
+        if matches:
+            dot_code = matches[0]
+        else:
+            # 方法 2: 嘗試提取 digraph ... } 格式（沒有 markdown 包裹）
+            #pattern2 = r'(digraph\s+\w+\s*\{.*?\n\})'
+            pattern2 = r'(digraph\s+\w+\s*\{.*\})'
+            matches = re.findall(pattern2, text, re.DOTALL)
+            
+            if not matches:
+                return None
+            
+            dot_code = matches[0]
+        
+        try:
+            # 使用 Graphviz 渲染
+            graph = graphviz.Source(dot_code)
+            png_bytes = graph.pipe(format='png')
+            
+            # 轉換為 PIL Image
+            img = Image.open(io.BytesIO(png_bytes))
+            
+            return img
             
         except Exception as e:
-            return f"❌ Error: {str(e)}\n\nPlease check your API key and try again."
+            print(f"Failed to render DAG: {e}")
+            return None           
+           
     
     def _prepare_context(self, results):
         """準備分析結果的上下文資訊"""
@@ -159,203 +312,232 @@ Format responses with proper markdown for better readability.
         if not results:
             return "目前尚無分析結果。No analysis results available yet."
         
-        # 判斷效應方向
-        if results['d_mean'] > 0:
-            effect_direction = "faster Pokémon have HIGHER win rates | 速度快的寶可夢有更高的勝率"
-        else:
-            effect_direction = "slower Pokémon have HIGHER win rates | 速度慢的寶可夢有更高的勝率"
+        overall = results['overall']
+        interp = results['interpretation']
+        diag = results['diagnostics']
         
-        # 判斷顯著性
-        if results['is_significant']:
-            significance = "YES - The effect is significant | 是 - 效應顯著"
-        else:
-            significance = "NO - The effect is not significant | 否 - 效應不顯著"
+        # 找出顯著的屬性
+        sig_types = [
+            results['trial_labels'][i] 
+            for i, sig in enumerate(results['by_trial']['delta_significant']) 
+            if sig
+        ]
         
         context = f"""
 ## Current Bayesian Hierarchical Model Analysis | 目前的貝氏階層模型分析
 
-### Dataset Information | 資料集資訊
-- Number of Pokémon Types Analyzed | 分析的屬性數量: {results['n_trials']}
-- Types | 屬性: {', '.join(results['trial_labels'])}
-
-### Overall Effect (All Types Combined) | 整體效應（所有屬性合併）
-
-**d (Overall Mean Effect | 整體平均效應):**
-- Mean | 平均值: {results['d_mean']:.4f}
-- SD | 標準差: {results['d_sd']:.4f}
-- 95% HDI | 95% 最高密度區間: [{results['d_hdi_lower']:.4f}, {results['d_hdi_upper']:.4f}]
-- **Interpretation | 解讀**: {effect_direction}
-- **Is Significant? | 是否顯著?**: {significance}
-
-**sigma (Between-Type Variability | 屬性間變異):**
-- Mean | 平均值: {results['sigma_mean']:.4f}
-- SD | 標準差: {results['sigma_sd']:.4f}
-- **Interpretation | 解讀**: {"High variability between types | 屬性間差異大" if results['sigma_mean'] > 0.5 else "Moderate variability between types | 屬性間差異中等" if results['sigma_mean'] > 0.2 else "Low variability between types | 屬性間差異小"}
-
-**or_speed (Speed Odds Ratio | 速度勝算比):**
-- Mean | 平均值: {results['or_speed_mean']:.4f}
-- SD | 標準差: {results['or_speed_sd']:.4f}
-- 95% HDI | 95% 最高密度區間: [{results['or_speed_hdi_lower']:.4f}, {results['or_speed_hdi_upper']:.4f}]
-- **Interpretation | 解讀**: {
-    f"Faster Pokémon are {results['or_speed_mean']:.2f} times more likely to win | 速度快的寶可夢獲勝機率是慢的 {results['or_speed_mean']:.2f} 倍"
-    if results['or_speed_mean'] > 1
-    else f"Slower Pokémon are {1/results['or_speed_mean']:.2f} times more likely to win | 速度慢的寶可夢獲勝機率是快的 {1/results['or_speed_mean']:.2f} 倍"
+### Overall Effect | 整體效應
+- **d (Log Odds Ratio) | d（對數勝算比）**: 
+  - Mean | 平均: {overall['d_mean']:.4f}
+  - SD | 標準差: {overall['d_sd']:.4f}
+  - 95% HDI: [{overall['d_hdi_low']:.4f}, {overall['d_hdi_high']:.4f}]
+
+- **sigma (Between-type Variation) | sigma（屬性間變異）**: 
+  - Mean | 平均: {overall['sigma_mean']:.4f}
+  - SD | 標準差: {overall['sigma_sd']:.4f}
+  - 95% HDI: [{overall['sigma_hdi_low']:.4f}, {overall['sigma_hdi_high']:.4f}]
+
+- **Odds Ratio | 勝算比**: 
+  - Mean | 平均: {overall['or_mean']:.4f}
+  - SD | 標準差: {overall['or_sd']:.4f}
+  - 95% HDI: [{overall['or_hdi_low']:.4f}, {overall['or_hdi_high']:.4f}]
+
+### Model Diagnostics | 模型診斷
+- **R-hat (d)**: {f"{diag['rhat_d']:.4f}" if diag['rhat_d'] is not None else 'N/A'} {'✓' if diag['rhat_d'] and diag['rhat_d'] < 1.1 else '✗'}
+- **R-hat (sigma)**: {f"{diag['rhat_sigma']:.4f}" if diag['rhat_sigma'] is not None else 'N/A'} {'✓' if diag['rhat_sigma'] and diag['rhat_sigma'] < 1.1 else '✗'}
+- **ESS (d)**: {int(diag['ess_d']) if diag['ess_d'] is not None else 'N/A'}
+- **ESS (sigma)**: {int(diag['ess_sigma']) if diag['ess_sigma'] is not None else 'N/A'}
+- **Convergence | 收斂狀態**: {'✓ Converged 已收斂' if diag['converged'] else '✗ Not Converged 未收斂'}
+
+### Interpretation | 結果解釋
+- **Overall Effect | 整體效應**: {interp['overall_effect']}
+- **Significance | 顯著性**: {interp['overall_significance']}
+- **Effect Size | 效果大小**: {interp['effect_size']}
+- **Heterogeneity | 異質性**: {interp['heterogeneity']}
+
+### Significant Types | 顯著的屬性
+{len(sig_types)} out of {results['n_trials']} types show significant speed effects:
+{len(sig_types)} 個屬性（共 {results['n_trials']} 個）顯示顯著的速度效應：
+{', '.join(sig_types) if sig_types else 'None 無'}
+
+### Number of Types Analyzed | 分析的屬性數量
+{results['n_trials']} types in total 共 {results['n_trials']} 個屬性
+
+### Key Finding | 關鍵發現
+{
+    f"On average, Fire-type Pokémon are {overall['or_mean']:.2f} times more likely to win compared to Water-type (95% HDI: [{overall['or_hdi_low']:.2f}, {overall['or_hdi_high']:.2f}]). 平均而言，火系寶可夢獲勝的可能性是水系的 {overall['or_mean']:.2f} 倍 （95% HDI: [{overall['or_hdi_low']:.2f}, {overall['or_hdi_high']:.2f}]）。"
+
+    if overall['or_mean'] > 1
+    else f"Interestingly, the data suggests no clear speed advantage or even a slight disadvantage. 有趣的是，資料顯示速度並無明顯優勢，甚至可能略有劣勢。"
 }
 
-### Type-Specific Effects | 屬性特定效應
-
+The variation between types (sigma = {overall['sigma_mean']:.3f}) indicates {interp['heterogeneity'].lower()}.
+屬性間的變異（sigma = {overall['sigma_mean']:.3f}）表示{interp['heterogeneity'].lower()}。
 """
+        return context
+    
+    def draw_custom_dag(self, description):
+        """
+        根據用戶描述生成客製化 DAG 圖
         
-        # 添加各屬性的詳細結果
-        for delta_result in results['delta_results']:
-            significant_marker = "★" if delta_result['is_significant'] else " "
-            context += f"\n**{delta_result['trial_type']} {significant_marker}:**\n"
-            context += f"  - Delta Mean | 平均效應: {delta_result['delta_mean']:.4f}\n"
-            context += f"  - 95% HDI: [{delta_result['delta_hdi_lower']:.4f}, {delta_result['delta_hdi_upper']:.4f}]\n"
-            context += f"  - Significant? | 顯著?: {'Yes 是' if delta_result['is_significant'] else 'No 否'}\n"
-        
-        context += f"""
-### Model Fitting Information | 模型擬合資訊
-- Samples | 樣本數: {results['sampling_params']['n_samples']}
-- Tuning samples | 調整樣本數: {results['sampling_params']['n_tune']}
-- Chains | 鏈數: {results['sampling_params']['n_chains']}
-- Target accept rate | 目標接受率: {results['sampling_params']['target_accept']}
-
-### Key Insights | 關鍵洞察
-1. **Overall Pattern | 整體模式**: {effect_direction}
-2. **Heterogeneity | 異質性**: {"Different types show different responses to speed" if results['sigma_mean'] > 0.3 else "Types respond similarly to speed"}
-3. **Significant Types | 顯著屬性**: {sum(1 for dr in results['delta_results'] if dr['is_significant'])} out of {results['n_trials']} types show significant speed effects
-"""
+        Args:
+            description: 用戶對 DAG 的描述
+            
+        Returns:
+            tuple: (解釋文字, DAG 圖片或 None)
+        """
+        prompt = f"""Based on the following description, generate a Graphviz DOT code for a DAG diagram:
+
+User description: {description}
+
+Please:
+1. Create a clear and informative DAG
+2. Use appropriate node shapes (ellipse for random variables, box for observed data, diamond for deterministic nodes)
+3. Use different colors to distinguish node types
+4. **CRITICAL: Use ONLY English labels - NO Chinese characters in node labels**
+5. Add labels to explain what each node represents (in English)
+6. Wrap your DOT code in ```graphviz ``` tags
+7. Provide a brief explanation in Traditional Chinese about what the diagram shows
+
+根據以下描述，生成 Graphviz DOT 代碼的 DAG 圖：
+
+用戶描述：{description}
+
+請：
+1. 創建清晰且有資訊性的 DAG
+2. 使用適當的節點形狀（橢圓代表隨機變數，矩形代表觀測資料，菱形代表確定性節點）
+3. 使用不同顏色區分節點類型
+4. **重要：節點標籤必須使用英文，不能使用中文**
+5. 添加標籤說明每個節點代表什麼（用英文）
+6. 將 DOT 代碼包在 ```graphviz ``` 標籤中
+7. 用繁體中文簡要說明圖表顯示什麼"""
         
-        return context
+        return self.get_response(prompt, None)
     
+    # 保留原有的所有方法...
     def generate_summary(self, analysis_results):
         """自動生成分析結果總結"""
         
         summary_prompt = """請根據提供的貝氏階層模型分析結果生成一份完整的總結報告，包含：
 
-1. **分析目的**：這個模型在研究什麼？
+1. **模型目的**：簡述這個階層模型在分析什麼
 2. **整體發現**：
-   - 速度對勝率的整體影響（d 參數）
-   - 是否具有統計顯著性？
-   - 勝算比告訴我們什麼？
+   - 速度對勝率有什麼整體影響？
+   - d 和勝算比告訴我們什麼？
+   - HDI 的意義是什麼？
 3. **屬性間差異**：
-   - sigma 參數顯示什麼？
-   - 哪些屬性對速度特別敏感？
-   - 哪些屬性例外？
-4. **對戰意涵**：這對實戰有什麼啟示？
-5. **建議**：訓練師該如何運用這些資訊？
+   - sigma 告訴我們什麼？
+   - 哪些屬性特別受速度影響？
+4. **模型品質**：
+   - 模型收斂得好嗎？（R-hat、ESS）
+   - 結果可信嗎？
+5. **實戰啟示**：
+   - 訓練師如何運用這些資訊？
+   - 哪些屬性應該優先考慮速度？
 
 請用清楚的繁體中文 Markdown 格式撰寫，包含適當的章節標題。"""
         
-        return self.get_response(summary_prompt, analysis_results)
+        text, _ = self.get_response(summary_prompt, analysis_results)
+        return text
     
-    def explain_bayesian_concepts(self):
-        """解釋貝氏統計基本概念"""
+    def explain_metric(self, metric_name, analysis_results):
+        """解釋特定指標"""
         
-        explain_prompt = """請用簡單的方式解釋貝氏統計，特別是在這個寶可夢速度分析的情境下。
-
-請涵蓋：
-1. 什麼是貝氏統計？與傳統統計有何不同？
-2. 什麼是先驗、似然、後驗？
-3. 什麼是 HDI（最高密度區間）？與信賴區間有何不同？
-4. 為什麼用貝氏方法分析這個問題？
-5. 如何解讀後驗分佈？
-
-請用寶可夢的實際例子讓說明更具體易懂，全程使用繁體中文。"""
+        metric_explanations = {
+            'd': 'd (整體對數勝算比)',
+            'sigma': 'sigma (屬性間變異)',
+            'or_speed': 'Odds Ratio (勝算比)',
+            'hdi': '95% HDI (最高密度區間)',
+            'delta': 'delta (屬性特定效應)',
+            'rhat': 'R-hat (收斂診斷)',
+            'ess': 'ESS (有效樣本數)'
+        }
         
-        return self.get_response(explain_prompt, None)
-    
-    def explain_hierarchical_model(self):
-        """解釋階層模型的概念"""
+        metric_display = metric_explanations.get(metric_name, metric_name)
         
-        explain_prompt = """請解釋什麼是階層模型（Hierarchical Model），以及為什麼用它來分析不同屬性的寶可夢。
+        explain_prompt = f"""請在這次貝氏階層模型分析的脈絡下，解釋以下指標：
 
-請涵蓋：
-1. 什麼是階層結構？
-2. 什麼是「資訊借用」（borrowing strength）？
-3. 什麼是「收縮效應」（shrinkage）？為什麼這很重要？
-4. 在這個分析中，階層模型如何幫助我們？
-5. d、delta、sigma 參數分別代表什麼？
+指標：{metric_display}
+
+請包含：
+1. 這個指標在貝氏統計中測量什麼？
+2. 在本次分析中得到的數值是多少？
+3. 如何從寶可夢對戰的角度詮釋這個數值？
+4. 與頻率論統計的對應指標有何不同？
+5. 有什麼需要注意的限制或注意事項？
 
-請用具體的寶可夢例子說明，使用繁體中文。"""
+請用繁體中文回答。"""
         
-        return self.get_response(explain_prompt, None)
+        text, _ = self.get_response(explain_prompt, analysis_results)
+        return text
     
-    def explain_convergence(self):
-        """解釋收斂診斷"""
+    def explain_bayesian_vs_frequentist(self):
+        """解釋貝氏與頻率論的差異"""
         
-        explain_prompt = """請解釋如何判斷 MCMC 抽樣是否收斂，以及 Trace Plot 該如何解讀。
+        explain_prompt = """請用簡單的方式解釋貝氏統計和頻率論統計的差異，特別是在寶可夢對戰分析的情境下。
 
 請涵蓋：
-1. 什麼是 MCMC 抽樣？
-2. 什麼是收斂？為什麼重要？
-3. Trace Plot 該如何解讀？
-4. 什麼是「毛毛蟲圖」？
-5. 如果沒有收斂會怎樣？
+1. 兩者的根本哲學差異是什麼？
+2. p 值 vs HDI（可信區間）有什麼不同？
+3. 為什麼我們用階層模型來分析多個屬性？
+4. 貝氏方法的優勢和限制是什麼？
+5. 什麼時候該用貝氏、什麼時候該用頻率論？
 
-請用簡單的語言解釋，使用繁體中文。"""
+請用寶可夢的實際例子讓說明更具體易懂，全程使用繁體中文。"""
         
-        return self.get_response(explain_prompt, None)
+        text, _ = self.get_response(explain_prompt, None)
+        return text
     
-    def compare_types(self, analysis_results):
-        """比較不同屬性"""
+    def explain_hierarchical_model(self):
+        """解釋階層模型的概念"""
         
-        compare_prompt = """根據各屬性的 delta 值，請分析哪些寶可夢屬性對速度最敏感，哪些最不敏感。
+        explain_prompt = """請用簡單的方式解釋貝氏階層模型，特別是在寶可夢屬性分析的情境下。
 
-請提供：
-1. 速度效應最大的前 5 個屬性
-2. 速度效應最小的前 5 個屬性
-3. 可能的原因（從對戰機制角度）
-4. 組隊建議
+請涵蓋：
+1. 什麼是階層模型？為什麼要用階層結構？
+2. 「借用資訊」(borrowing strength) 是什麼意思？
+3. 收縮效應 (shrinkage) 如何運作？
+4. 為什麼階層模型適合分析多個屬性？
+5. d、sigma、delta 之間的關係是什麼？
 
-請用繁體中文回答。"""
+請用寶可夢的實際例子讓說明更具體易懂，全程使用繁體中文。"""
         
-        return self.get_response(compare_prompt, analysis_results)
+        text, _ = self.get_response(explain_prompt, None)
+        return text
     
     def battle_strategy_advice(self, analysis_results):
         """提供對戰策略建議"""
         
-        strategy_prompt = """根據這個貝氏階層模型的分析結果，請為寶可夢訓練師提供實際的對戰策略建議。
+        strategy_prompt = """根據貝氏階層模型的分析結果，請為寶可夢訓練師提供實際的對戰策略建議。
 
 請考慮：
-1. 在組建隊伍時應該多重視速度？
-2. 哪些屬性的寶可夢特別需要速度？
-3. 哪些屬性可以犧牲速度換取其他能力？
-4. 有什麼例外情況（如戲法空間隊伍）？
-5. 對競技對戰的影響？
+1. 整體而言，速度對勝率的影響有多大？
+2. 哪些屬性特別受益於速度？哪些不受影響？
+3. 訓練師在組建隊伍時應該如何權衡速度？
+4. 有沒有屬性可以忽略速度、專注其他數值？
+5. 對競技對戰有什麼啟示？
 
 請具體且可操作，使用繁體中文回答。"""
         
-        return self.get_response(strategy_prompt, analysis_results)
+        text, _ = self.get_response(strategy_prompt, analysis_results)
+        return text
     
-    def explain_metric(self, metric_name, analysis_results):
-        """解釋特定指標"""
-        
-        metric_explanations = {
-            'd': 'Overall Mean Effect (d) | 整體平均效應',
-            'sigma': 'Between-Type Variability (sigma) | 屬性間變異',
-            'or_speed': 'Speed Odds Ratio (or_speed) | 速度勝算比',
-            'delta': 'Type-Specific Effects (delta) | 屬性特定效應',
-            'hdi': '95% HDI (Highest Density Interval) | 95% 最高密度區間'
-        }
-        
-        metric_display = metric_explanations.get(metric_name, metric_name)
+    def compare_types(self, analysis_results):
+        """比較不同屬性"""
         
-        explain_prompt = f"""請在這次貝氏階層模型分析的脈絡下，解釋以下指標：
+        compare_prompt = """請比較分析結果中不同屬性對速度的反應差異。
 
-指標：{metric_display}
-
-請包含：
-1. 這個指標一般來說測量什麼？
-2. 在本次分析中得到的數值是多少？
-3. 如何從寶可夢對戰的角度詮釋這個數值？
-4. 這告訴我們速度的重要性如何？
-5. 有什麼需要注意的限制或注意事項？
+請說明：
+1. 哪些屬性對速度最敏感？為什麼？
+2. 哪些屬性對速度不敏感？可能的原因是什麼？
+3. 屬性間的異質性（sigma）告訴我們什麼？
+4. 有沒有令人意外的發現？
+5. 這些差異對組隊策略有什麼啟示？
 
 請用繁體中文回答。"""
         
-        return self.get_response(explain_prompt, analysis_results)
+        text, _ = self.get_response(compare_prompt, analysis_results)
+        return text
     
     def reset_conversation(self):
         """重置對話歷史"""

bayesian_utils.py

@@ -0,0 +1,425 @@
+import plotly.graph_objects as go
+import plotly.express as px
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib
+matplotlib.use('Agg')  # 使用非互動式後端
+import arviz as az
+import io
+import base64
+from PIL import Image
+
+def plot_trace(trace, var_names=['d', 'sigma']):
+    """
+    繪製 Trace Plot（MCMC 收斂診斷）
+    包含完整的 warmup + posterior
+    
+    Args:
+        trace: ArviZ InferenceData 物件
+        var_names: 要繪製的變數名稱
+        
+    Returns:
+        PIL Image
+    """
+    fig, axes = plt.subplots(len(var_names), 2, figsize=(14, 4 * len(var_names)))
+    if len(var_names) == 1:
+        axes = axes.reshape(1, -1)
+    
+    # 檢查是否有 warmup_posterior
+    has_warmup = hasattr(trace, 'warmup_posterior') and trace.warmup_posterior is not None
+    
+    for idx, var_name in enumerate(var_names):
+        # 左圖: KDE 密度圖（只用 posterior, 不用 warmup）
+        post_data = trace.posterior[var_name].values
+        for chain_idx in range(post_data.shape[0]):
+            from scipy import stats
+            data = post_data[chain_idx].flatten()
+            density = stats.gaussian_kde(data)
+            xs = np.linspace(data.min(), data.max(), 200)
+            axes[idx, 0].plot(xs, density(xs), alpha=0.8, label=f'Chain {chain_idx+1}')
+        axes[idx, 0].set_xlabel(var_name, fontsize=12)
+        axes[idx, 0].set_ylabel('Density', fontsize=12)
+        axes[idx, 0].set_title(f'{var_name}', fontsize=13, fontweight='bold')
+        if idx == 0:
+            axes[idx, 0].legend()
+        
+        # 右圖: Trace 圖（完整 warmup + posterior）
+        if has_warmup:
+            # 有 warmup: 合併繪製
+            warmup_data = trace.warmup_posterior[var_name].values
+            post_data = trace.posterior[var_name].values
+            
+            n_warmup = warmup_data.shape[1]
+            n_post = post_data.shape[1]
+            
+            # 定義顏色,讓每條鏈用固定顏色
+            colors = plt.cm.tab10.colors  # 使用 matplotlib 的顏色循環
+            
+            for chain_idx in range(warmup_data.shape[0]):
+                chain_color = colors[chain_idx % len(colors)]  # 每條鏈一個固定顏色
+                
+                # 繪 warmup 部分
+                x_warmup = np.arange(n_warmup)
+                axes[idx, 1].plot(x_warmup, warmup_data[chain_idx].flatten(), 
+                                color=chain_color,  # 👈 指定顏色
+                                alpha=0.7, linewidth=0.5,
+                                label=f'Chain {chain_idx+1}' if idx == 0 else '')
+                
+                # 繪 posterior 部分 (用同樣的顏色!)
+                x_post = np.arange(n_warmup, n_warmup + n_post)
+                axes[idx, 1].plot(x_post, post_data[chain_idx].flatten(), 
+                                color=chain_color,  # 👈 同一個顏色
+                                alpha=0.7, linewidth=0.5)
+            
+            # 加 Tune 結束的紅線
+            axes[idx, 1].axvline(x=n_warmup, color='red', linestyle='--', 
+                               linewidth=2, alpha=0.7, 
+                               label='Tune結束' if idx == 0 else '')
+                               
+                               
+                               
+                               
+        else:
+            # 沒有 warmup: 只用 posterior
+            post_data = trace.posterior[var_name].values
+            for chain_idx in range(post_data.shape[0]):
+                axes[idx, 1].plot(post_data[chain_idx].flatten(), 
+                                alpha=0.7, linewidth=0.5,
+                                label=f'Chain {chain_idx+1}' if idx == 0 else '')
+        
+        axes[idx, 1].set_xlabel('Iteration', fontsize=12)
+        axes[idx, 1].set_ylabel(var_name, fontsize=12)
+        axes[idx, 1].set_title(f'{var_name} trace', fontsize=13, fontweight='bold')
+        if idx == 0:
+            axes[idx, 1].legend(loc='upper right', fontsize=9)
+        axes[idx, 1].grid(alpha=0.3)
+    
+    plt.tight_layout()
+    
+    # 轉換為圖片
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png', dpi=300, bbox_inches='tight')
+    buf.seek(0)
+    img = Image.open(buf)
+    plt.close()
+    
+    return img
+
+
+# ============================================
+# 替換說明:
+# 在 bayesian_utils.py 中,把第 13-51 行的整個 plot_trace 函數
+# 替換成上面這個版本
+# ============================================
+
+def plot_posterior(trace, var_names=['d', 'sigma', 'or_speed'], hdi_prob=0.95):
+    """
+    繪製後驗分佈圖
+    
+    Args:
+        trace: ArviZ InferenceData 物件
+        var_names: 要繪製的變數名稱
+        hdi_prob: HDI 機率
+        
+    Returns:
+        PIL Image
+    """
+    fig = az.plot_posterior(trace, var_names=var_names, hdi_prob=hdi_prob, figsize=(14, 5))
+    plt.tight_layout()
+    
+    # 轉換為圖片
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png', dpi=300, bbox_inches='tight')
+    buf.seek(0)
+    img = Image.open(buf)
+    plt.close()
+    
+    return img
+
+def plot_forest(trace, trial_labels, title='Effect of Speed on Win Rate by Type'):
+    """
+    繪製 Forest Plot（各屬性效應）
+    
+    Args:
+        trace: ArviZ InferenceData 物件
+        trial_labels: 屬性標籤列表
+        title: 圖表標題
+        
+    Returns:
+        PIL Image
+    """
+    num_trials = len(trial_labels)
+    
+    # 計算統計量
+    delta_posterior = trace.posterior['delta'].values.reshape(-1, num_trials)
+    delta_mean = delta_posterior.mean(axis=0)
+    delta_hdi = az.hdi(trace, var_names=['delta'], hdi_prob=0.95)['delta'].values
+    
+    # 建立圖表
+    fig, ax = plt.subplots(figsize=(12, max(10, num_trials * 0.4)))
+    y_pos = np.arange(num_trials)
+    
+    # 繪製信賴區間（橫線）
+    ax.hlines(y_pos, delta_hdi[:, 0], delta_hdi[:, 1], color='steelblue', linewidth=3, label='95% HDI')
+    
+    # 繪製平均值（點）
+    ax.scatter(delta_mean, y_pos, color='darkblue', s=120, zorder=3, 
+               edgecolors='white', linewidth=1.5, label='Mean')
+    
+    # 標註顯著的點
+    for i, (mean, hdi) in enumerate(zip(delta_mean, delta_hdi)):
+        if hdi[0] > 0:  # 顯著正效應
+            ax.text(mean, i, ' ★', fontsize=15, ha='left', va='center', color='gold')
+        elif hdi[1] < 0:  # 顯著負效應
+            ax.text(mean, i, ' ☆', fontsize=15, ha='left', va='center', color='red')
+    
+    # 設定軸
+    ax.set_yticks(y_pos)
+    ax.set_yticklabels(trial_labels, fontsize=11)
+    ax.invert_yaxis()
+    ax.axvline(0, color='red', linestyle='--', linewidth=2, label='No Effect (δ=0)')
+    ax.set_xlabel('Delta (Log Odds Ratio)', fontsize=13)
+    ax.set_title(title, fontsize=15, fontweight='bold', pad=20)
+    ax.legend(loc='lower right')
+    ax.grid(axis='x', alpha=0.3)
+    
+    plt.tight_layout()
+    
+    # 轉換為圖片
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png', dpi=300, bbox_inches='tight')
+    buf.seek(0)
+    img = Image.open(buf)
+    plt.close()
+    
+    return img
+
+def plot_model_dag(analyzer):
+    """
+    繪製模型 DAG 圖
+    
+    Args:
+        analyzer: BayesianHierarchicalAnalyzer 物件
+        
+    Returns:
+        PIL Image 或 None
+    """
+    try:
+        gv = analyzer.get_model_graph()
+        
+        # 轉換為 PNG
+        png_bytes = gv.pipe(format='png')
+        
+        # 轉換為 PIL Image
+        img = Image.open(io.BytesIO(png_bytes))
+        
+        return img
+    except Exception as e:
+        print(f"無法生成 DAG 圖: {e}")
+        return None
+
+def create_summary_table(results):
+    """
+    創建結果摘要表格
+    
+    Args:
+        results: 分析結果字典
+        
+    Returns:
+        pandas DataFrame
+    """
+    overall = results['overall']
+    
+    summary_data = {
+        '參數': ['d (整體效應)', 'sigma (屬性間變異)', 'or_speed (勝算比)'],
+        '平均值': [
+            f"{overall['d_mean']:.4f}",
+            f"{overall['sigma_mean']:.4f}",
+            f"{overall['or_mean']:.4f}"
+        ],
+        '標準差': [
+            f"{overall['d_sd']:.4f}",
+            f"{overall['sigma_sd']:.4f}",
+            f"{overall['or_sd']:.4f}"
+        ],
+        '95% HDI 下界': [
+            f"{overall['d_hdi_low']:.4f}",
+            f"{overall['sigma_hdi_low']:.4f}",
+            f"{overall['or_hdi_low']:.4f}"
+        ],
+        '95% HDI 上界': [
+            f"{overall['d_hdi_high']:.4f}",
+            f"{overall['sigma_hdi_high']:.4f}",
+            f"{overall['or_hdi_high']:.4f}"
+        ]
+    }
+    
+    return pd.DataFrame(summary_data)
+
+def create_trial_results_table(results):
+    """
+    創建各屬性結果表格
+    
+    Args:
+        results: 分析結果字典
+        
+    Returns:
+        pandas DataFrame
+    """
+    trial_labels = results['trial_labels']
+    by_trial = results['by_trial']
+    data = results['data']
+    
+    trial_data = {
+        '屬性': trial_labels,
+        'Delta (平均)': [f"{x:.4f}" for x in by_trial['delta_mean']],
+        'Delta (標準差)': [f"{x:.4f}" for x in by_trial['delta_std']],
+        '95% HDI 下界': [f"{x:.4f}" for x in by_trial['delta_hdi_low']],
+        '95% HDI 上界': [f"{x:.4f}" for x in by_trial['delta_hdi_high']],
+        '顯著性': ['★ 顯著' if sig else '不顯著' for sig in by_trial['delta_significant']],
+        '控制組勝率': [f"{x:.2%}" for x in by_trial['pc_mean']],
+        '實驗組勝率': [f"{x:.2%}" for x in by_trial['pt_mean']],
+        '控制組 (勝/總)': [f"{d['rc']}/{d['nc']}" for d in data],
+        '實驗組 (勝/總)': [f"{d['rt']}/{d['nt']}" for d in data]
+    }
+    
+    return pd.DataFrame(trial_data)
+
+def export_results_to_text(results):
+    """
+    匯出結果為純文字格式
+    
+    Args:
+        results: 分析結果字典
+        
+    Returns:
+        str: 格式化的文字報告
+    """
+    overall = results['overall']
+    interp = results['interpretation']
+    diag = results['diagnostics']
+    
+    report = f"""
+==============================================
+貝氏階層模型分析報告
+==============================================
+
+分析時間: {results['timestamp']}
+屬性數量: {results['n_trials']}
+
+----------------------------------------------
+1. 整體效應摘要
+----------------------------------------------
+d (整體效應 - Log OR):
+  - 平均值: {overall['d_mean']:.4f}
+  - 標準差: {overall['d_sd']:.4f}
+  - 95% HDI: [{overall['d_hdi_low']:.4f}, {overall['d_hdi_high']:.4f}]
+
+sigma (屬性間變異):
+  - 平均值: {overall['sigma_mean']:.4f}
+  - 標準差: {overall['sigma_sd']:.4f}
+  - 95% HDI: [{overall['sigma_hdi_low']:.4f}, {overall['sigma_hdi_high']:.4f}]
+
+or_speed (勝算比):
+  - 平均值: {overall['or_mean']:.4f}
+  - 標準差: {overall['or_sd']:.4f}
+  - 95% HDI: [{overall['or_hdi_low']:.4f}, {overall['or_hdi_high']:.4f}]
+
+----------------------------------------------
+2. 模型收斂診斷
+----------------------------------------------
+R-hat (d): {f"{diag['rhat_d']:.4f}" if diag['rhat_d'] is not None else 'N/A'}
+R-hat (sigma): {f"{diag['rhat_sigma']:.4f}" if diag['rhat_sigma'] is not None else 'N/A'}
+ESS (d): {int(diag['ess_d']) if diag['ess_d'] is not None else 'N/A'}
+ESS (sigma): {int(diag['ess_sigma']) if diag['ess_sigma'] is not None else 'N/A'}
+收斂狀態: {'✓ 已收斂' if diag['converged'] else '✗ 未收斂'}
+
+----------------------------------------------
+3. 結果解釋
+----------------------------------------------
+整體效應: {interp['overall_effect']}
+顯著性: {interp['overall_significance']}
+效果大小: {interp['effect_size']}
+異質性: {interp['heterogeneity']}
+
+----------------------------------------------
+4. 各屬性詳細結果
+----------------------------------------------
+"""
+    
+    # 添加各屬性的詳細資訊
+    trial_labels = results['trial_labels']
+    by_trial = results['by_trial']
+    
+    for i, label in enumerate(trial_labels):
+        sig_marker = "★" if by_trial['delta_significant'][i] else " "
+        report += f"""
+{sig_marker} {label}:
+  Delta (平均): {by_trial['delta_mean'][i]:.4f}
+  95% HDI: [{by_trial['delta_hdi_low'][i]:.4f}, {by_trial['delta_hdi_high'][i]:.4f}]
+  控制組勝率: {by_trial['pc_mean'][i]:.2%}
+  實驗組勝率: {by_trial['pt_mean'][i]:.2%}
+  勝率差異: {(by_trial['pt_mean'][i] - by_trial['pc_mean'][i]):.2%}
+"""
+    
+    report += """
+==============================================
+"""
+    
+    return report
+
+def plot_odds_ratio_comparison(results):
+    """
+    繪製各屬性的勝算比比較圖（Plotly 版本）
+    
+    Args:
+        results: 分析結果字典
+        
+    Returns:
+        plotly figure
+    """
+    trial_labels = results['trial_labels']
+    delta_mean = results['by_trial']['delta_mean']
+    
+    # 轉換為勝算比
+    or_values = [np.exp(d) for d in delta_mean]
+    
+    # 排序
+    sorted_indices = np.argsort(or_values)[::-1]
+    sorted_labels = [trial_labels[i] for i in sorted_indices]
+    sorted_or = [or_values[i] for i in sorted_indices]
+    sorted_sig = [results['by_trial']['delta_significant'][i] for i in sorted_indices]
+    
+    # 顏色標記
+    colors = ['#2ecc71' if sig else '#95a5a6' for sig in sorted_sig]
+    
+    fig = go.Figure()
+    
+    fig.add_trace(go.Bar(
+        x=sorted_or,
+        y=sorted_labels,
+        orientation='h',
+        marker=dict(
+            color=colors,
+            line=dict(color='white', width=1)
+        ),
+        text=[f'{or_val:.2f}' for or_val in sorted_or],
+        textposition='outside',
+        hovertemplate='%{y}<br>OR: %{x:.3f}<extra></extra>'
+    ))
+    
+    # 參考線 (OR = 1)
+    fig.add_vline(x=1, line_dash="dash", line_color="red", line_width=2)
+    
+    fig.update_layout(
+        title='各屬性速度效應（勝算比）',
+        xaxis_title='Odds Ratio',
+        yaxis_title='',
+        width=800,
+        height=max(400, len(trial_labels) * 25),
+        template='plotly_white',
+        showlegend=False
+    )
+    
+    return fig

fire_water_converted.csv

@@ -0,0 +1,47 @@
+Trial_Type,rt,nt,rc,nc
+Pair_1,122,133,22,145
+Pair_2,85,132,17,135
+Pair_3,52,129,41,134
+Pair_4,69,126,76,132
+Pair_5,50,125,98,132
+Pair_6,103,122,67,131
+Pair_7,37,122,18,127
+Pair_8,90,119,60,127
+Pair_9,81,119,25,125
+Pair_10,107,117,105,125
+Pair_11,102,116,55,123
+Pair_12,56,116,37,123
+Pair_13,91,115,65,122
+Pair_14,65,115,74,122
+Pair_15,78,114,56,122
+Pair_16,97,112,75,121
+Pair_17,76,112,33,121
+Pair_18,94,112,27,121
+Pair_19,102,112,61,121
+Pair_20,59,111,59,121
+Pair_21,91,111,97,121
+Pair_22,41,110,52,120
+Pair_23,9,109,56,120
+Pair_24,38,109,66,119
+Pair_25,31,108,66,119
+Pair_26,80,108,32,119
+Pair_27,52,107,83,119
+Pair_28,69,107,44,119
+Pair_29,51,106,72,119
+Pair_30,85,106,104,119
+Pair_31,74,106,65,118
+Pair_32,30,105,109,118
+Pair_33,59,104,77,118
+Pair_34,4,104,42,117
+Pair_35,19,104,76,117
+Pair_36,81,103,103,117
+Pair_37,50,102,31,117
+Pair_38,65,102,54,116
+Pair_39,53,101,20,116
+Pair_40,89,101,41,116
+Pair_41,24,101,66,116
+Pair_42,75,98,67,115
+Pair_43,44,97,27,114
+Pair_44,52,96,39,114
+Pair_45,83,92,76,114
+Pair_46,69,89,105,114

requirements.txt

@@ -1,10 +1,11 @@
-streamlit==1.31.0
-pandas==2.1.4
-numpy==1.26.3
-pymc==5.10.4
-pytensor==2.18.6
-arviz==0.17.1
-matplotlib==3.8.2
-scipy==1.11.4
+streamlit>=1.31.0
+numpy<2.0,>=1.24.0
+pandas>=2.1.0
+plotly>=5.18.0
+pymc>=5.10.0
+arviz>=0.17.0
+matplotlib>=3.8.0
 google-generativeai>=0.3.0
-graphviz
+pillow>=10.0.0
+graphviz>=0.20.0
+anthropic>=0.18.0

runtime.txt

@@ -1 +1 @@
-python-3.11
+python-3.11