Upload 6 files

README.md

@@ -1,5 +1,5 @@
 ---
-title: Pokemon Speed Bayesian Analysis System
+title: BayePyMC
 emoji: 🔬
 colorFrom: blue
 colorTo: indigo
@@ -9,253 +9,323 @@ app_file: app.py
 pinned: false
 ---
 
-# ⚡ Pokemon Speed Bayesian Analysis System
+# 貝氏階層模型分析系統 - 寶可夢速度對勝率影響
 
-A comprehensive web-based system for analyzing the impact of speed on Pokemon win rates using Bayesian hierarchical meta-analysis, powered by AI assistant.
+## 📋 系統簡介
 
-## ✨ Features
+這是一個基於 Streamlit 和 PyMC 的貝氏階層模型分析系統，專為分析寶可夢速度對不同屬性勝率的影響而設計，結合 AI 助手提供深入的統計解釋和對戰策略建議。
 
-### 🔬 **Bayesian Hierarchical Modeling**
-- PyMC-based MCMC sampling
-- Hierarchical structure to borrow strength across Pokemon types
-- Type-specific and overall effect estimation
+## 🎯 主要功能
 
-### 📊 **Interactive Visualizations**
-- **Trace Plots**: Check MCMC convergence
-- **Posterior Distributions**: Visualize parameter uncertainty with HDI
-- **Forest Plots**: Compare effects across Pokemon types
-- **Win Rate Comparisons**: See actual win rate differences
-- **Heterogeneity Analysis**: Understand between-type variation
+### 1. 貝氏階層模型分析
+- ✅ MCMC 抽樣（Markov Chain Monte Carlo）
+- ✅ 階層結構（跨屬性資訊借用）
+- ✅ 完整的不確定性量化
+- ✅ 後驗分佈估計
+- ✅ 收斂診斷
 
-### 🤖 **AI-Powered Assistant**
-- GPT-4 integration for result interpretation
-- Natural language Q&A about analysis results
-- Automatic summary generation
-- Statistical concept explanations
-- Type-specific insights
+### 2. 完整視覺化（4 個圖表 + 1 個文字摘要）
+- 🔀 **DAG 圖**：模型結構視覺化
+- 📉 **Trace Plot**：MCMC 收斂診斷圖
+- 🎯 **Posterior Plot**：後驗分佈圖
+- 🌲 **Forest Plot**：各屬性效應圖
+- 📋 **文字摘要**：統計結果表格
 
-### 📥 **Export Capabilities**
-- JSON format for full results
-- CSV format for type-specific data
-- Downloadable reports
+### 3. AI 智能助手
+- 💬 自然語言對話（雙語支援）
+- 📖 統計概念解釋（貝氏、階層模型）
+- 🎮 對戰策略建議
+- 🔍 結果深度分析
+- 📚 參數詳細說明
 
-## 🚀 Quick Start
-
-### Installation
+## 📦 安裝步驟
 
+### 1. 安裝 Python 依賴套件
 ```bash
-# Install dependencies
-pip install -r requirements.txt
-
-# Run the application
-streamlit run app.py
+pip install -r bayesian_requirements.txt
 ```
 
-### Usage
-
-1. **Configure Settings** (Sidebar)
-   - Enter your OpenAI API Key for AI features
-   - Upload your data CSV or use example data
-   - Adjust MCMC parameters if needed
+### 2. 安裝 Graphviz（系統級套件，用於生成 DAG 圖）
 
-2. **Run Analysis** (Data & Analysis tab)
-   - Click "🚀 Run Analysis"
-   - Wait for MCMC sampling to complete (2-5 minutes)
-   - View results and convergence diagnostics
-
-3. **Explore Visualizations** (Visualizations tab)
-   - Trace plots for convergence checking
-   - Posterior distributions with HDI
-   - Forest plots for type comparisons
-   - Win rate comparisons
-
-4. **Ask Questions** (AI Assistant tab)
-   - Use quick question buttons
-   - Chat with AI about results
-   - Get concept explanations
-   - Request improvement suggestions
+**Windows (使用 Chocolatey):**
+```bash
+choco install graphviz
+```
 
-5. **Export Results** (Export Results tab)
-   - Download as JSON or CSV
-   - Review export preview
+**Mac:**
+```bash
+brew install graphviz
+```
 
-## 📁 Data Format
+**Ubuntu/Debian:**
+```bash
+sudo apt-get install graphviz
+```
 
-Your CSV file should contain the following columns:
+### 3. 準備資料
+將寶可夢速度分析資料 CSV 檔放在同一目錄下，檔名為 `pokemon_speed_meta_results.csv`
 
-| Column | Description |
-|--------|-------------|
-| `Trial_Type` | Pokemon type name (e.g., "Fire", "Water") |
-| `rc` | Control group (slow) win count |
-| `nc` | Control group total battles |
-| `rt` | Treatment group (fast) win count |
-| `nt` | Treatment group total battles |
+**資料格式要求：**
 
-**Example:**
+| 欄位 | 說明 | 範例 |
+|------|------|------|
+| `Trial_Type` | 寶可夢屬性 | Water, Fire, Grass |
+| `rc` | 控制組（速度慢）勝場數 | 45 |
+| `nc` | 控制組總場數 | 100 |
+| `rt` | 實驗組（速度快）勝場數 | 60 |
+| `nt` | 實驗組總場數 | 100 |
 
+**範例資料：**
 ```csv
 Trial_Type,rc,nc,rt,nt
-Fire,45,100,58,100
-Water,52,110,63,105
-Electric,48,95,61,98
+Water,45,100,60,100
+Fire,38,100,55,100
+Grass,42,100,58,100
+Electric,50,100,65,100
 ```
 
-## 🔬 Statistical Model
+### 4. 設定 Google Gemini API Key
+- 在系統左側邊欄輸入您的 Google Gemini API Key
+- API Key 用於 AI 助手功能
+- 取得 API Key：https://ai.google.dev/
 
-### Hierarchical Structure
-
-```
-Overall Effect (d, τ)
-    ↓
-Type-Specific Effects (δᵢ, μᵢ)
-    ↓
-Observed Win Rates (rc, rt)
+### 5. 執行程式
+```bash
+streamlit run bayesian_app.py
 ```
 
-### Key Parameters
+## 🔧 檔案結構
 
-- **d**: Overall log odds ratio of speed effect
-- **OR (Odds Ratio)**: exp(d) - multiplicative effect on odds
-- **σ (sigma)**: Between-type heterogeneity
-- **δᵢ (delta)**: Type-specific speed effects
-- **μᵢ (mu)**: Type-specific baseline win rates
-
-### Priors
-
-```python
-d ~ Normal(0, 10)           # Overall effect
-τ ~ Gamma(0.001, 0.001)     # Precision
-σ = 1/√τ                     # Heterogeneity
-μᵢ ~ Normal(0, 10)          # Baseline rates
-δᵢ ~ Normal(d, σ)           # Type effects
+```
+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  # 資料檔（需自行準備）
 ```
 
-## 📊 Interpreting Results
-
-### Log Odds Ratio (d)
-- **d > 0**: Speed increases win probability
-- **d < 0**: Speed decreases win probability
-- **d ≈ 0**: No effect
-
-### Odds Ratio (OR)
-- **OR = 1.5**: Faster Pokemon have 1.5x the odds of winning
-- **OR = 2.0**: Faster Pokemon have 2x the odds (twice as likely)
-
-### 95% HDI (Highest Density Interval)
-- Bayesian credible interval
-- 95% probability the true value falls within this range
-- **HDI excludes 0**: Effect is "statistically credible"
-
-### Convergence Diagnostics
-
-**R-hat (Gelman-Rubin)**
-- ✅ < 1.01: Excellent convergence
-- ⚠️ 1.01-1.05: Acceptable but check
-- ❌ > 1.05: Poor convergence, resample
-
-**ESS (Effective Sample Size)**
-- ✅ > 400: Good
-- ⚠️ 100-400: Marginal
-- ❌ < 100: Insufficient, increase samples
-
-## 🤖 AI Assistant Features
-
-### Quick Actions
-- **Generate Summary**: Comprehensive analysis overview
-- **Explain Results**: Simple interpretation
-- **Suggest Improvements**: Data and model enhancements
-
-### Concept Explanations
-- Log Odds Ratio
-- Odds Ratio
-- HDI (Highest Density Interval)
-- Heterogeneity
-- Hierarchical Model
-- Convergence Diagnostics
-
-### Custom Questions
-Ask anything about your analysis:
-- "Which Pokemon type benefits most from speed?"
-- "Is the heterogeneity high in my analysis?"
-- "Should I trust these results based on R-hat?"
-- "What does an odds ratio of 1.6 mean practically?"
-
-## 🛠️ Technical Stack
-
-- **Backend**: Python 3.8+
-- **Bayesian Inference**: PyMC 5.x
-- **Diagnostics**: ArviZ
-- **Visualization**: Plotly
-- **Web Framework**: Streamlit
-- **AI**: OpenAI GPT-4o-mini
-
-## ⚙️ Configuration
-
-### MCMC Parameters
-
-**Samples** (default: 2000)
-- More samples = more accurate but slower
-- Recommended: 2000-5000 for production
-
-**Tuning** (default: 1000)
-- Warm-up iterations discarded
-- Recommended: 500-1500
-
-**Target Accept** (default: 0.95)
-- Higher = more accurate but slower
-- Recommended: 0.90-0.98
-
-## 🔍 Example Analysis
-
-Using the example dataset (18 Pokemon types):
-
-**Typical Results:**
-- **Overall Effect (d)**: ~0.35 (95% HDI: [0.18, 0.52])
-- **Odds Ratio**: ~1.42 (faster Pokemon have 42% higher odds)
-- **Heterogeneity (σ)**: ~0.15 (low, effects are consistent across types)
-- **Win Rate Increase**: ~7% on average
-
-**Interpretation:**
-> Across all Pokemon types, faster Pokemon have approximately 1.4x the odds of winning compared to slower Pokemon. This translates to an average win rate increase of about 7 percentage points. The effect is relatively consistent across types (low heterogeneity).
-
-## ⚠️ Limitations
+## 📊 使用方式
+
+### 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
 
-1. **Computational Time**: MCMC can take several minutes
-2. **API Costs**: AI features require OpenAI API credits
-3. **Data Requirements**: Need sufficient sample sizes per type
-4. **Causality**: Analysis shows association, not causation
-5. **Assumptions**: Binary outcomes, independent battles
+# 如果未安裝，請依照上述安裝步驟安裝
+```
 
-## 📚 References
+### Q2: MCMC 抽樣太慢
+**A**: 可以降低抽樣數或調整參數
+- 減少 Samples（但會降低精確度）
+- 增加 Chains（利用多核心）
+- 降低 Target Accept（但可能影響收斂）
 
-### Statistical Methods
-- Gelman, A. et al. (2013). *Bayesian Data Analysis*
-- Kruschke, J. (2014). *Doing Bayesian Data Analysis*
+### Q3: Trace Plot 顯示未收斂
+**A**: 嘗試以下方法
+- 增加 Tuning samples
+- 增加 Samples
+- 提高 Target Accept
+- 檢查資料是否有問題
 
-### Software
-- [PyMC Documentation](https://www.pymc.io/)
-- [ArviZ Documentation](https://arviz-devs.github.io/)
-- [Streamlit Documentation](https://docs.streamlit.io/)
+### Q4: AI 助手無法使用
+**A**: 請檢查
+- API Key 是否正確
+- ���否已執行分析
+- 網路連線是否正常
 
-## 🤝 Contributing
+## 📧 聯絡資訊
 
-Suggestions and improvements welcome! Consider:
-- Adding more visualization types
-- Implementing model comparison (DIC, WAIC)
-- Supporting multiple outcome types
-- Adding more AI assistant features
+如有問題或建議，歡迎聯繫開發團隊。
 
-## 📄 License
+## 📄 授權
 
-MIT License - feel free to use and modify
+本專案僅供學術研究和教學使用。
 
-## 🙏 Acknowledgments
+---
 
-- **PyMC Team** for excellent Bayesian modeling tools
-- **OpenAI** for GPT-4 API
-- **Streamlit** for the web framework
-- **Pokemon Community** for inspiring this analysis
+**Powered by PyMC, ArviZ & Google Gemini** 🚀
 
----
+## 🎓 延伸閱讀
 
-**Made with ⚡ for Pokemon trainers who love statistics**
+- [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)

app.py

@@ -1,657 +1,621 @@
-"""
-Pokemon Speed Bayesian Analysis System with LLM Assistant
-A comprehensive web application for analyzing speed effects on win rates
-"""
-
 import streamlit as st
 import pandas as pd
-import numpy as np
-from datetime import datetime
-import io
-import json
-
-# 導入自定義模組
-from bayesian_core import BayesianSpeedAnalyzer
-from llm_assistant import LLMAssistant
-from utils import (
-    plot_trace, plot_posterior, plot_forest,
-    plot_win_rate_comparison, plot_heterogeneity,
-    create_results_table, create_type_results_table
-)
+import uuid
+from datetime import datetime, timedelta
+import atexit
+import os
+import base64
 
-# ===== 頁面配置 =====
+# 頁面配置
 st.set_page_config(
-    page_title="Pokemon Speed Analysis",
+    page_title="Bayesian Hierarchical Model - Pokémon Speed Analysis",
     page_icon="⚡",
     layout="wide",
     initial_sidebar_state="expanded"
 )
 
-# ===== 自定義 CSS =====
+# 自定義 CSS
 st.markdown("""
 <style>
-    .main-header {
-        font-size: 2.5rem;
-        font-weight: bold;
-        color: #2d6ca2;
-        text-align: center;
-        margin-bottom: 1rem;
+    .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;
     }
-    .sub-header {
-        font-size: 1.2rem;
-        color: #666;
-        text-align: center;
-        margin-bottom: 2rem;
+    .stButton > button {
+        width: 100%;
+        border-radius: 20px;
+        font-weight: 600;
+        transition: all 0.3s ease;
     }
-    .metric-card {
-        background-color: #f0f2f6;
-        padding: 1rem;
-        border-radius: 0.5rem;
-        border-left: 4px solid #2d6ca2;
+    .stButton > button:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 8px rgba(0,0,0,0.2);
     }
-    .stAlert {
-        margin-top: 1rem;
+    .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;
+    }
+    .info-box {
+        background-color: #d1ecf1;
+        border: 1px solid #bee5eb;
+        border-radius: 5px;
+        padding: 10px;
+        margin: 10px 0;
     }
 </style>
 """, unsafe_allow_html=True)
 
-# ===== Session State 初始化 =====
-if 'analyzer' not in st.session_state:
-    st.session_state.analyzer = None
-if 'results' not in st.session_state:
-    st.session_state.results = None
-if 'trace' not in st.session_state:
-    st.session_state.trace = None
-if 'llm_assistant' not in st.session_state:
-    st.session_state.llm_assistant = None
+# 導入自定義模組
+from bayesian_core import BayesianHierarchicalAnalyzer
+from bayesian_llm_assistant import BayesianLLMAssistant
+
+# 清理函數
+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 'data' not in st.session_state:
-    st.session_state.data = None
+if 'analyzer' not in st.session_state:
+    st.session_state.analyzer = None
+
+# 標題
+st.title("⚡ Bayesian Hierarchical Model Analysis")
+st.markdown("### 寶可夢速度對勝率影響的階層貝氏分析")
+st.markdown("---")
 
-# ===== 側邊欄 =====
+# Sidebar
 with st.sidebar:
-    st.markdown("### ⚙️ Configuration")
+    st.header("⚙️ 配置設定")
     
-    # OpenAI API Key
+    # Google Gemini API Key
     api_key = st.text_input(
-        "OpenAI API Key",
+        "Google Gemini API Key",
         type="password",
-        help="Required for AI Assistant features"
+        help="輸入您的 Google Gemini API Key 以使用 AI 助手"
     )
     
     if api_key:
-        st.success("✅ API Key provided")
-        # 初始化 LLM Assistant
-        if st.session_state.llm_assistant is None:
-            session_id = f"pokemon_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
-            st.session_state.llm_assistant = LLMAssistant(api_key, session_id)
-    else:
-        st.warning("⚠️ Enter API Key to enable AI features")
+        st.session_state.api_key = api_key
+        st.success("✅ API Key 已載入")
     
     st.markdown("---")
     
-    # 資料上傳
-    st.markdown("### 📁 Data Upload")
-    
-    uploaded_file = st.file_uploader(
-        "Upload CSV file",
-        type=['csv'],
-        help="CSV should contain: Trial_Type, rc, nc, rt, nt"
-    )
-    
-    # 使用範例資料
-    use_example = st.checkbox("Use example data", value=True)
+    # 清理按鈕
+    if st.button("🧹 清理過期資料"):
+        cleanup_old_sessions()
+        st.success("✅ 清理完成")
+        st.rerun()
     
     st.markdown("---")
     
-    # 分析參數
-    st.markdown("### 🔧 Analysis Parameters")
-    
-    n_samples = st.slider(
-        "MCMC Samples",
-        min_value=500,
-        max_value=5000,
-        value=2000,
-        step=500,
-        help="Number of posterior samples to draw"
+    # 資料來源選擇
+    st.subheader("📊 資料來源")
+    data_source = st.radio(
+        "選擇資料來源：",
+        ["使用預設資料集", "上傳您的資料"]
     )
     
-    n_tune = st.slider(
-        "Tuning Steps",
-        min_value=500,
-        max_value=3000,
-        value=1000,
-        step=500,
-        help="Number of warm-up iterations"
-    )
-    
-    target_accept = st.slider(
-        "Target Accept Rate",
-        min_value=0.80,
-        max_value=0.99,
-        value=0.95,
-        step=0.01,
-        help="MCMC acceptance rate (higher = more accurate but slower)"
-    )
+    uploaded_file = None
+    if data_source == "上傳您的資料":
+        uploaded_file = st.file_uploader(
+            "上傳 CSV 檔案",
+            type=['csv'],
+            help="上傳寶可夢速度分析資料"
+        )
+        
+        with st.expander("📖 資料格式說明"):
+            st.markdown("""
+            **必要欄位格式：**
+            - `Trial_Type`: 寶可夢屬性（如 Water, Fire, Grass）
+            - `rc`: 控制組（速度慢）的勝場數
+            - `nc`: 控制組的總場數
+            - `rt`: 實驗組（速度快）的勝場數
+            - `nt`: 實驗組的總場數
+            
+            **範例：**
+            ```
+            Trial_Type, rc, nc, rt, nt
+            Water,      45, 100, 60, 100
+            Fire,       38, 100, 55, 100
+            Grass,      42, 100, 58, 100
+            ```
+            """)
     
     st.markdown("---")
     
-    # 關於
-    with st.expander("ℹ️ About"):
-        st.markdown("""
-        **Pokemon Speed Bayesian Analysis**
+    # MCMC 抽樣參數設定
+    st.subheader("🎲 MCMC 抽樣參數")
+    
+    with st.expander("⚙️ 進階設定"):
+        n_samples = st.slider(
+            "抽樣數 (Samples)",
+            min_value=500,
+            max_value=5000,
+            value=2000,
+            step=500,
+            help="更多樣本 = 更準確，但更慢"
+        )
         
-        A hierarchical Bayesian meta-analysis system to evaluate 
-        whether faster Pokemon have higher win rates across different types.
+        n_tune = st.slider(
+            "調整期樣本 (Tuning)",
+            min_value=500,
+            max_value=2000,
+            value=1000,
+            step=100,
+            help="調整期用於優化抽樣器"
+        )
         
-        **Features:**
-        - Bayesian hierarchical modeling
-        - MCMC convergence diagnostics
-        - Interactive visualizations
-        - AI-powered result interpretation
+        n_chains = st.selectbox(
+            "鏈數 (Chains)",
+            options=[1, 2, 4],
+            index=0,
+            help="多條鏈可以檢測收斂問題"
+        )
         
-        **Powered by:**
-        - PyMC (Bayesian inference)
-        - ArviZ (diagnostics)
-        - GPT-4 (AI assistant)
-        - Streamlit (web interface)
+        target_accept = st.slider(
+            "目標接受率",
+            min_value=0.80,
+            max_value=0.99,
+            value=0.95,
+            step=0.01,
+            help="更高的接受率 = 更準確，但更慢"
+        )
+    
+    st.markdown("---")
+    
+    # 關於系統
+    with st.expander("ℹ️ 關於此系統"):
+        st.markdown("""
+        **貝氏階層模型分析系統**
+        
+        本系統使用貝氏階層模型來分析速度對不同屬性寶可夢勝率的影響。
+        
+        **主要功能：**
+        - 🔬 貝氏推論與 MCMC 抽樣
+        - 📊 階層模型（跨屬性資訊借用）
+        - 📈 完整視覺化（4 個圖表）
+        - 💬 AI 助手解釋
+        - 🎮 對戰策略建議
+        
+        **模型優勢：**
+        - 量化不確定性
+        - 處理小樣本
+        - 估計屬性間異質性
+        - 穩健的統計推論
         """)
 
-# ===== 主標題 =====
-st.markdown('<div class="main-header">⚡ Pokemon Speed Bayesian Analysis System</div>', unsafe_allow_html=True)
-st.markdown('<div class="sub-header">Hierarchical Bayesian Meta-Analysis with AI Assistant</div>', unsafe_allow_html=True)
+# 主要內容區 - 雙 Tab
+tab1, tab2 = st.tabs(["📊 貝氏分析", "💬 AI 助手"])
 
-# ===== 資料載入 =====
-def load_data():
-    """載入或生成資料"""
+# Tab 1: 貝氏分析
+with tab1:
+    st.header("📊 貝氏階層模型分析")
     
-    if uploaded_file is not None:
-        try:
+    # 載入資料
+    if data_source == "使用預設資料集":
+        # 檢查預設資料是否存在
+        default_data_path = "pokemon_speed_meta_results.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)
-            
-            # 驗證必要欄位
-            required_cols = ['Trial_Type', 'rc', 'nc', 'rt', 'nt']
-            missing_cols = [col for col in required_cols if col not in df.columns]
-            
-            if missing_cols:
-                st.error(f"❌ Missing required columns: {', '.join(missing_cols)}")
-                return None
-            
-            st.success(f"✅ Loaded {len(df)} Pokemon types from uploaded file")
-            return df
-            
-        except Exception as e:
-            st.error(f"❌ Error loading file: {str(e)}")
-            return None
+            st.success(f"✅ 已載入資料（{len(df)} 個屬性）")
+        else:
+            df = None
+            st.info("📁 請在左側上傳 CSV 檔案")
     
-    elif use_example:
-        # 生成範例資料 (18種屬性)
-        types = [
-            'Normal', 'Fire', 'Water', 'Electric', 'Grass', 'Ice',
-            'Fighting', 'Poison', 'Ground', 'Flying', 'Psychic', 'Bug',
-            'Rock', 'Ghost', 'Dragon', 'Dark', 'Steel', 'Fairy'
-        ]
-        
-        np.random.seed(42)
-        
-        data = []
-        for ptype in types:
-            # 模擬數據：快速寶可夢通常有更高勝率
-            base_win_rate = 0.50
-            speed_effect = np.random.normal(0.08, 0.03)  # 平均 8% 提升，變異 3%
-            
-            nc = np.random.randint(80, 120)  # 控制組樣本數
-            nt = np.random.randint(80, 120)  # 實驗組樣本數
-            
-            pc = np.clip(base_win_rate + np.random.normal(0, 0.05), 0.3, 0.7)
-            pt = np.clip(pc + speed_effect, 0.3, 0.7)
-            
-            rc = int(nc * pc)
-            rt = int(nt * pt)
-            
-            data.append({
-                'Trial_Type': ptype,
-                'rc': rc,
-                'nc': nc,
-                'rt': rt,
-                'nt': nt
-            })
-        
-        df = pd.DataFrame(data)
-        st.info("ℹ️ Using example data (18 Pokemon types)")
-        return df
-    
-    return None
-
-# 載入資料
-if st.session_state.data is None:
-    st.session_state.data = load_data()
-
-# ===== 分頁 =====
-tab1, tab2, tab3, tab4 = st.tabs([
-    "📊 Data & Analysis",
-    "📈 Visualizations",
-    "🤖 AI Assistant",
-    "📥 Export Results"
-])
-
-# ===== Tab 1: 資料與分析 =====
-with tab1:
-    if st.session_state.data is not None:
-        st.markdown("### 📋 Data Preview")
-        
-        # 顯示資料
-        col1, col2 = st.columns([2, 1])
-        
-        with col1:
-            st.dataframe(st.session_state.data, use_container_width=True)
-        
-        with col2:
-            st.markdown("**Data Summary**")
-            st.metric("Total Types", len(st.session_state.data))
-            st.metric("Total Battles (Control)", st.session_state.data['nc'].sum())
-            st.metric("Total Battles (Treatment)", st.session_state.data['nt'].sum())
+    if df is not None:
+        # 顯示資料預覽
+        with st.expander("👀 資料預覽"):
+            st.dataframe(df, use_container_width=True)
         
         st.markdown("---")
         
         # 執行分析按鈕
-        col1, col2, col3 = st.columns([1, 1, 2])
-        
-        with col1:
-            if st.button("🚀 Run Analysis", type="primary", use_container_width=True):
-                with st.spinner("Running Bayesian MCMC sampling... This may take a few minutes."):
-                    try:
-                        # 創建分析器
-                        analyzer = BayesianSpeedAnalyzer(st.session_state.data)
-                        
-                        # 建立模型
-                        analyzer.build_model()
-                        
-                        # 執行 MCMC
-                        progress_bar = st.progress(0)
-                        status_text = st.empty()
-                        
-                        status_text.text("Building model...")
-                        progress_bar.progress(20)
-                        
-                        status_text.text(f"Sampling {n_samples} iterations...")
-                        trace = analyzer.run_analysis(
-                            samples=n_samples,
-                            tune=n_tune,
-                            target_accept=target_accept
-                        )
-                        progress_bar.progress(80)
-                        
-                        status_text.text("Generating results...")
-                        
-                        # 儲存結果
-                        st.session_state.analyzer = analyzer
-                        st.session_state.trace = trace
-                        st.session_state.results = analyzer.results
-                        
-                        progress_bar.progress(100)
-                        status_text.empty()
-                        progress_bar.empty()
-                        
-                        st.success("✅ Analysis completed successfully!")
-                        st.rerun()
-                        
-                    except Exception as e:
-                        st.error(f"❌ Analysis failed: {str(e)}")
+        col1, col2, col3 = st.columns([2, 1, 2])
         
         with col2:
-            if st.session_state.results is not None:
-                if st.button("🔄 Reset Analysis", use_container_width=True):
-                    st.session_state.analyzer = None
-                    st.session_state.results = None
-                    st.session_state.trace = None
-                    st.rerun()
+            analyze_button = st.button("🔬 開始貝氏分析", type="primary", use_container_width=True)
         
-        # 顯示結果
-        if st.session_state.results is not None:
-            st.markdown("---")
-            st.markdown("### 📊 Analysis Results")
+        # 執行分析
+        if analyze_button:
+            # 初始化分析器
+            if st.session_state.analyzer is None:
+                st.session_state.analyzer = BayesianHierarchicalAnalyzer(st.session_state.session_id)
             
-            # 關鍵指標
-            stats = st.session_state.results['statistics']
+            try:
+                st.session_state.analyzer.load_data(df)
+                
+                # 進度條
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+                
+                def update_progress(message, percent):
+                    status_text.text(message)
+                    progress_bar.progress(percent / 100)
+                
+                # 執行分析
+                with st.spinner("正在執行貝氏分析..."):
+                    results = st.session_state.analyzer.run_analysis(
+                        n_samples=n_samples,
+                        n_tune=n_tune,
+                        n_chains=n_chains,
+                        target_accept=target_accept,
+                        progress_callback=update_progress
+                    )
+                    st.session_state.analysis_results = results
+                
+                progress_bar.empty()
+                status_text.empty()
+                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
             
-            col1, col2, col3, col4 = st.columns(4)
+            st.markdown("---")
+            st.markdown("## 📈 分析結果")
             
-            with col1:
-                st.markdown('<div class="metric-card">', unsafe_allow_html=True)
-                st.metric(
-                    "Log Odds Ratio (d)",
-                    f"{stats['d_mean']:.3f}",
-                    delta=f"HDI: [{stats['d_hdi_lower']:.3f}, {stats['d_hdi_upper']:.3f}]"
-                )
-                st.markdown('</div>', unsafe_allow_html=True)
+            # 建立 4 個子 Tab
+            result_tabs = st.tabs(["📊 概覽", "📉 Trace Plot", "🎯 Posterior", "🌲 Forest Plot"])
             
-            with col2:
-                st.markdown('<div class="metric-card">', unsafe_allow_html=True)
-                st.metric(
-                    "Odds Ratio (OR)",
-                    f"{stats['or_mean']:.3f}",
-                    delta=f"HDI: [{stats['or_hdi_lower']:.3f}, {stats['or_hdi_upper']:.3f}]"
+            # Tab: 概覽
+            with result_tabs[0]:
+                st.markdown("### 🎯 關鍵指標")
+                
+                # 顯示關鍵指標
+                col1, col2, col3 = st.columns(3)
+                
+                with col1:
+                    st.metric(
+                        label="整體效應 (d)",
+                        value=f"{results['d_mean']:.4f}",
+                        delta=f"HDI: [{results['d_hdi_lower']:.3f}, {results['d_hdi_upper']:.3f}]"
+                    )
+                
+                with col2:
+                    st.metric(
+                        label="屬性間變異 (sigma)",
+                        value=f"{results['sigma_mean']:.4f}",
+                        delta=f"SD: {results['sigma_sd']:.4f}"
+                    )
+                
+                with col3:
+                    st.metric(
+                        label="速度勝算比 (OR)",
+                        value=f"{results['or_speed_mean']:.3f}",
+                        delta=f"HDI: [{results['or_speed_hdi_lower']:.3f}, {results['or_speed_hdi_upper']:.3f}]"
+                    )
+                
+                st.markdown("---")
+                
+                # 顯著性判斷
+                if results['is_significant']:
+                    st.markdown("""
+                    <div class="success-box">
+                    <h4>✅ 結果顯著</h4>
+                    <p>速度對勝率有<strong>顯著影響</strong>（95% HDI 不包含 0）</p>
+                    </div>
+                    """, unsafe_allow_html=True)
+                else:
+                    st.markdown("""
+                    <div class="warning-box">
+                    <h4>⚠️ 結果不顯著</h4>
+                    <p>速度對勝率<strong>無顯著影響</strong>（95% HDI 包含 0）</p>
+                    </div>
+                    """, unsafe_allow_html=True)
+                
+                st.markdown("---")
+                
+                # 文字摘要
+                st.markdown("### 📋 統計摘要")
+                st.text_area(
+                    "Summary Statistics",
+                    results['summary_text'],
+                    height=300
                 )
-                st.markdown('</div>', unsafe_allow_html=True)
-            
-            with col3:
-                st.markdown('<div class="metric-card">', unsafe_allow_html=True)
-                st.metric(
-                    "Heterogeneity (σ)",
-                    f"{stats['sigma_mean']:.3f}",
-                    delta="Between-type variation"
+                
+                # 下載摘要
+                st.download_button(
+                    label="📥 下載統計摘要 (.txt)",
+                    data=results['summary_text'],
+                    file_name=f"bayesian_summary_{results['timestamp'][:10]}.txt",
+                    mime="text/plain"
                 )
-                st.markdown('</div>', unsafe_allow_html=True)
-            
-            with col4:
-                st.markdown('<div class="metric-card">', unsafe_allow_html=True)
-                st.metric(
-                    "Avg Win Rate Increase",
-                    f"{stats['win_rate_increase'].mean():.1f}%",
-                    delta="Percentage points"
+                
+                st.markdown("---")
+                
+                # 各屬性詳細結果
+                st.markdown("### 🎮 各屬性詳細結果")
+                
+                delta_df = pd.DataFrame(results['delta_results'])
+                delta_df['Significant'] = delta_df['is_significant'].apply(lambda x: '★' if x else '')
+                delta_df = delta_df[['trial_type', 'delta_mean', 'delta_sd', 'delta_hdi_lower', 'delta_hdi_upper', 'Significant']]
+                delta_df.columns = ['屬性', 'Delta 平均', 'Delta 標準差', 'HDI 下界', 'HDI 上界', '顯著']
+                
+                st.dataframe(
+                    delta_df.style.format({
+                        'Delta 平均': '{:.4f}',
+                        'Delta 標準差': '{:.4f}',
+                        'HDI 下界': '{:.4f}',
+                        'HDI 上界': '{:.4f}'
+                    }),
+                    use_container_width=True
                 )
-                st.markdown('</div>', unsafe_allow_html=True)
-            
-            # 解釋
-            st.markdown("### 💡 Interpretation")
-            interpretation = st.session_state.analyzer.interpret_results()
-            st.markdown(interpretation)
-            
-            # 詳細結果表
-            st.markdown("### 📋 Detailed Results")
             
-            col1, col2 = st.columns(2)
-            
-            with col1:
-                st.markdown("**Overall Effect Summary**")
-                fig_summary = create_results_table(st.session_state.results['summary'])
-                st.plotly_chart(fig_summary, use_container_width=True)
-            
-            with col2:
-                st.markdown("**Type-Specific Results**")
-                trial_results = st.session_state.analyzer.get_trial_specific_results()
-                fig_trial = create_type_results_table(trial_results)
-                st.plotly_chart(fig_trial, use_container_width=True)
+            # Tab: Trace Plot
+            with result_tabs[1]:
+                st.markdown("### 📉 Trace Plot - 收斂診斷")
+                
+                st.markdown("""
+                <div class="info-box">
+                <h4>📖 如何解讀 Trace Plot��</h4>
+                <ul>
+                <li><strong>左欄</strong>：MCMC 抽樣軌跡（應該像「毛毛蟲」，平穩無趨勢）</li>
+                <li><strong>右欄</strong>：後驗分佈密度圖</li>
+                <li><strong>良好收斂</strong>：軌跡圖混合良好，無明顯趨勢或週期</li>
+                <li><strong>問題跡象</strong>：軌跡圖有趨勢、卡住、或未混合</li>
+                </ul>
+                </div>
+                """, unsafe_allow_html=True)
+                
+                if results['trace_plot']:
+                    st.image(f"data:image/png;base64,{results['trace_plot']}", use_column_width=True)
+                else:
+                    st.warning("⚠️ Trace Plot 未生成")
             
-            # 收斂診斷
-            st.markdown("### 🔍 Convergence Diagnostics")
-            diagnostics = st.session_state.analyzer.get_convergence_diagnostics()
+            # Tab: Posterior Plot
+            with result_tabs[2]:
+                st.markdown("### 🎯 Posterior Distributions - 後驗分佈")
+                
+                st.markdown("""
+                <div class="info-box">
+                <h4>📖 如何解讀 Posterior Plot：</h4>
+                <ul>
+                <li><strong>d</strong>：整體平均效應（log odds ratio）</li>
+                <li><strong>sigma</strong>：屬性間變異（越大表示屬性間差異越大）</li>
+                <li><strong>or_speed</strong>：速度勝算比（exp(d)）</li>
+                <li><strong>95% HDI</strong>：最高密度區間（類似信賴區間）</li>
+                <li><strong>顯著性</strong>：HDI 不包含 0（d）或 1（or_speed）即為顯著</li>
+                </ul>
+                </div>
+                """, unsafe_allow_html=True)
+                
+                if results['posterior_plot']:
+                    st.image(f"data:image/png;base64,{results['posterior_plot']}", use_column_width=True)
+                else:
+                    st.warning("⚠️ Posterior Plot 未生成")
             
-            if diagnostics:
-                col1, col2 = st.columns(2)
+            # Tab: Forest Plot
+            with result_tabs[3]:
+                st.markdown("### 🌲 Forest Plot - 各屬性效應")
                 
-                with col1:
-                    st.markdown("**R-hat (Convergence)**")
-                    st.write("✅ Good: < 1.01, ⚠️ Check: 1.01-1.05, ❌ Poor: > 1.05")
-                    for param, value in diagnostics['r_hat'].items():
-                        status = "✅" if value < 1.01 else "⚠️" if value < 1.05 else "❌"
-                        st.write(f"{status} {param}: {value:.4f}")
+                st.markdown("""
+                <div class="info-box">
+                <h4>📖 如何解讀 Forest Plot：</h4>
+                <ul>
+                <li><strong>點</strong>：各屬性的平均效應（delta）</li>
+                <li><strong>橫線</strong>：95% 信賴區間</li>
+                <li><strong>紅虛線</strong>：無效應參考線（delta = 0）</li>
+                <li><strong>星號 ★</strong>：該屬性效應顯著</li>
+                <li><strong>右側</strong>：速度快有利於該屬性</li>
+                <li><strong>左側</strong>：速度慢有利於該屬性（罕見）</li>
+                </ul>
+                </div>
+                """, unsafe_allow_html=True)
                 
-                with col2:
-                    st.markdown("**ESS (Effective Sample Size)**")
-                    st.write("✅ Good: > 400, ⚠️ Check: 100-400, ❌ Poor: < 100")
-                    for param, value in diagnostics['ess_bulk'].items():
-                        status = "✅" if value > 400 else "⚠️" if value > 100 else "❌"
-                        st.write(f"{status} {param}: {value:.0f}")
-    
-    else:
-        st.warning("⚠️ Please upload data or enable example data in the sidebar")
+                if results['forest_plot']:
+                    st.image(f"data:image/png;base64,{results['forest_plot']}", use_column_width=True)
+                else:
+                    st.warning("⚠️ Forest Plot 未生成")
+                
+                st.markdown("---")
+                
+                # 顯著屬性總結
+                significant_types = [dr for dr in results['delta_results'] if dr['is_significant']]
+                
+                if significant_types:
+                    st.markdown(f"### ⭐ 顯著屬性總結 ({len(significant_types)}/{results['n_trials']})")
+                    
+                    for dr in significant_types:
+                        if dr['delta_mean'] > 0:
+                            st.success(f"**{dr['trial_type']}**: 速度快有顯著優勢 (Delta = {dr['delta_mean']:.3f})")
+                        else:
+                            st.warning(f"**{dr['trial_type']}**: 速度慢有顯著優勢 (Delta = {dr['delta_mean']:.3f})")
+                else:
+                    st.info("沒有屬性顯示顯著的速度效應")
 
-# ===== Tab 2: 視覺化 =====
+# Tab 2: AI 助手
 with tab2:
-    if st.session_state.trace is not None and st.session_state.results is not None:
-        st.markdown("### 📈 Visualization Gallery")
-        
-        # Trace Plot
-        with st.expander("🔍 Trace Plot (Convergence Check)", expanded=True):
-            st.markdown("""
-            **How to read:** 
-            - Left: Sampling trace should look like a "hairy caterpillar" (stationary)
-            - Right: Posterior distribution shape
-            """)
-            fig_trace = plot_trace(st.session_state.trace, var_names=['d', 'sigma'])
-            st.plotly_chart(fig_trace, use_container_width=True)
-        
-        # Posterior Plot
-        with st.expander("📊 Posterior Distributions", expanded=True):
-            st.markdown("""
-            **How to read:** 
-            - Shaded area: 95% Highest Density Interval (credible interval)
-            - Red line: Posterior mean
-            """)
-            fig_posterior = plot_posterior(st.session_state.trace)
-            st.plotly_chart(fig_posterior, use_container_width=True)
-        
-        # Forest Plot
-        with st.expander("🌲 Forest Plot (Type-Specific Effects)", expanded=True):
-            st.markdown("""
-            **How to read:** 
-            - Each row = one Pokemon type
-            - Point = mean effect, line = 95% credible interval
-            - Red dashed line = no effect (δ=0)
-            - Right of line = speed helps, left = speed hurts
-            """)
-            fig_forest = plot_forest(
-                st.session_state.trace,
-                st.session_state.results['trial_labels']
-            )
-            st.plotly_chart(fig_forest, use_container_width=True)
-        
-        # Win Rate Comparison
-        with st.expander("🏆 Win Rate Comparison", expanded=True):
-            stats = st.session_state.results['statistics']
-            fig_winrate = plot_win_rate_comparison(
-                st.session_state.results['trial_labels'],
-                stats['pc_mean'],
-                stats['pt_mean']
-            )
-            st.plotly_chart(fig_winrate, use_container_width=True)
-        
-        # Heterogeneity
-        with st.expander("📉 Heterogeneity Analysis"):
-            st.markdown("""
-            **Sigma (σ):** Measures variation in speed effects across types
-            - Low (< 0.2): Effects are similar across types
-            - Moderate (0.2-0.5): Some type-specific differences
-            - High (> 0.5): Large differences between types
-            """)
-            fig_hetero = plot_heterogeneity(st.session_state.trace)
-            st.plotly_chart(fig_hetero, use_container_width=True)
+    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:
-        st.info("ℹ️ Run analysis first to view visualizations")
-
-# ===== Tab 3: AI 助手 =====
-with tab3:
-    st.markdown("### 🤖 AI Assistant")
-    
-    if not api_key:
-        st.warning("⚠️ Please enter your OpenAI API Key in the sidebar to use AI features")
-    
-    elif st.session_state.llm_assistant is not None:
-        # 快捷問題按鈕
-        st.markdown("**Quick Questions:**")
+        # 初始化 LLM 助手
+        if 'llm_assistant' not in st.session_state:
+            st.session_state.llm_assistant = BayesianLLMAssistant(
+                api_key=st.session_state.api_key,
+                session_id=st.session_state.session_id
+            )
         
-        col1, col2, col3 = st.columns(3)
+        # 聊天容器
+        chat_container = st.container()
         
-        with col1:
-            if st.button("📝 Generate Summary", use_container_width=True):
-                if st.session_state.results:
-                    with st.spinner("Generating summary..."):
-                        response = st.session_state.llm_assistant.generate_summary(
-                            st.session_state.results
-                        )
-                        st.session_state.chat_history.append({
-                            'role': 'assistant',
-                            'content': response
-                        })
-                else:
-                    st.warning("Run analysis first")
+        with chat_container:
+            for message in st.session_state.chat_history:
+                with st.chat_message(message["role"]):
+                    st.markdown(message["content"])
         
-        with col2:
-            if st.button("📊 Explain Results", use_container_width=True):
-                if st.session_state.results:
-                    with st.spinner("Explaining..."):
+        # 使用者輸入
+        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:
                         response = st.session_state.llm_assistant.get_response(
-                            "Please explain the key findings from this analysis in simple terms.",
-                            st.session_state.results
-                        )
-                        st.session_state.chat_history.append({
-                            'role': 'assistant',
-                            'content': response
-                        })
-                else:
-                    st.warning("Run analysis first")
-        
-        with col3:
-            if st.button("💡 Suggest Improvements", use_container_width=True):
-                if st.session_state.results:
-                    with st.spinner("Thinking..."):
-                        response = st.session_state.llm_assistant.suggest_improvements(
-                            st.session_state.results
+                            user_message=prompt,
+                            analysis_results=st.session_state.analysis_results
                         )
-                        st.session_state.chat_history.append({
-                            'role': 'assistant',
-                            'content': response
-                        })
-                else:
-                    st.warning("Run analysis first")
-        
-        # 概念解釋按鈕
-        st.markdown("**Explain Concepts:**")
+                        st.markdown(response)
+                    except Exception as e:
+                        error_msg = f"❌ 錯誤: {str(e)}\n\n請檢查 API key 或重新表達問題。"
+                        st.error(error_msg)
+                        response = error_msg
+            
+            # 添加助手回應
+            st.session_state.chat_history.append({
+                "role": "assistant",
+                "content": response
+            })
         
-        col1, col2, col3, col4 = st.columns(4)
+        st.markdown("---")
         
-        concepts = [
-            ('Log Odds Ratio', 'log_odds_ratio'),
-            ('Odds Ratio', 'odds_ratio'),
-            ('HDI', 'hdi'),
-            ('Heterogeneity', 'heterogeneity')
+        # 快速問題按鈕
+        st.subheader("💡 快速問題")
+        
+        quick_questions = [
+            "📊 給我分析總結",
+            "🎯 解釋 d 參數",
+            "🔍 解釋 sigma",
+            "📖 什麼是貝氏統計？",
+            "🏗️ 什麼是階層模型？",
+            "📉 如何看 Trace Plot？",
+            "🎮 比較各屬性",
+            "⚔️ 對戰策略建議"
         ]
         
-        for i, (label, concept_key) in enumerate(concepts):
-            with [col1, col2, col3, col4][i]:
-                if st.button(label, use_container_width=True):
-                    with st.spinner(f"Explaining {label}..."):
-                        response = st.session_state.llm_assistant.explain_concept(
-                            concept_key,
-                            st.session_state.results
-                        )
-                        st.session_state.chat_history.append({
-                            'role': 'assistant',
-                            'content': response
-                        })
+        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}", use_container_width=True):
+                # 根據問題選擇對應的方法
+                if "總結" in question:
+                    response = st.session_state.llm_assistant.generate_summary(
+                        st.session_state.analysis_results
+                    )
+                elif "d 參數" in question:
+                    response = st.session_state.llm_assistant.explain_metric(
+                        'd',
+                        st.session_state.analysis_results
+                    )
+                elif "sigma" in question:
+                    response = st.session_state.llm_assistant.explain_metric(
+                        'sigma',
+                        st.session_state.analysis_results
+                    )
+                elif "貝氏統計" in question:
+                    response = st.session_state.llm_assistant.explain_bayesian_concepts()
+                elif "階層模型" in question:
+                    response = st.session_state.llm_assistant.explain_hierarchical_model()
+                elif "Trace Plot" in question:
+                    response = st.session_state.llm_assistant.explain_convergence()
+                elif "比較" in question:
+                    response = st.session_state.llm_assistant.compare_types(
+                        st.session_state.analysis_results
+                    )
+                elif "策略" in question:
+                    response = st.session_state.llm_assistant.battle_strategy_advice(
+                        st.session_state.analysis_results
+                    )
+                else:
+                    response = 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
+                })
+                
+                st.rerun()
         
+        # 重置對話按鈕
         st.markdown("---")
-        
-        # 聊天介面
-        st.markdown("**Chat with AI Assistant:**")
-        
-        # 顯示歷史訊息
-        for msg in st.session_state.chat_history:
-            if msg['role'] == 'user':
-                st.markdown(f"**You:** {msg['content']}")
-            else:
-                st.markdown(f"**AI:** {msg['content']}")
-                st.markdown("---")
-        
-        # 輸入框
-        user_input = st.text_area(
-            "Ask a question about the analysis:",
-            height=100,
-            placeholder="e.g., Which Pokemon type benefits most from speed?"
-        )
-        
-        col1, col2 = st.columns([1, 5])
-        
-        with col1:
-            if st.button("Send", type="primary"):
-                if user_input:
-                    # 添加用戶訊息
-                    st.session_state.chat_history.append({
-                        'role': 'user',
-                        'content': user_input
-                    })
-                    
-                    # 獲取 AI 回應
-                    with st.spinner("Thinking..."):
-                        response = st.session_state.llm_assistant.get_response(
-                            user_input,
-                            st.session_state.results
-                        )
-                        st.session_state.chat_history.append({
-                            'role': 'assistant',
-                            'content': response
-                        })
-                    
-                    st.rerun()
-        
-        with col2:
-            if st.button("Clear Chat"):
-                st.session_state.chat_history = []
-                st.session_state.llm_assistant.reset_conversation()
-                st.rerun()
+        if st.button("🔄 重置對話"):
+            st.session_state.llm_assistant.reset_conversation()
+            st.session_state.chat_history = []
+            st.success("✅ 對話已重置")
+            st.rerun()
 
-# ===== Tab 4: 匯出結果 =====
-with tab4:
-    st.markdown("### 📥 Export Results")
-    
-    if st.session_state.results is not None:
-        # 準備匯出資料
-        export_data = {
-            'timestamp': st.session_state.results['timestamp'],
-            'overall_statistics': {
-                'd_mean': float(st.session_state.results['statistics']['d_mean']),
-                'd_hdi': [
-                    float(st.session_state.results['statistics']['d_hdi_lower']),
-                    float(st.session_state.results['statistics']['d_hdi_upper'])
-                ],
-                'or_mean': float(st.session_state.results['statistics']['or_mean']),
-                'or_hdi': [
-                    float(st.session_state.results['statistics']['or_hdi_lower']),
-                    float(st.session_state.results['statistics']['or_hdi_upper'])
-                ],
-                'sigma_mean': float(st.session_state.results['statistics']['sigma_mean'])
-            },
-            'type_results': st.session_state.analyzer.get_trial_specific_results().to_dict('records')
-        }
-        
-        # JSON 下載
-        st.markdown("**Download as JSON:**")
-        json_str = json.dumps(export_data, indent=2)
-        st.download_button(
-            label="📄 Download JSON",
-            data=json_str,
-            file_name=f"pokemon_speed_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
-            mime="application/json"
-        )
-        
-        # CSV 下載
-        st.markdown("**Download Type Results as CSV:**")
-        csv_buffer = io.StringIO()
-        st.session_state.analyzer.get_trial_specific_results().to_csv(csv_buffer, index=False)
-        st.download_button(
-            label="📊 Download CSV",
-            data=csv_buffer.getvalue(),
-            file_name=f"pokemon_type_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
-            mime="text/csv"
-        )
-        
-        # 顯示摘要
+# DAG 圖（如果有的話，放在側邊欄底部）
+if st.session_state.analysis_results and st.session_state.analysis_results.get('dag_plot'):
+    with st.sidebar:
         st.markdown("---")
-        st.markdown("### 📋 Export Preview")
-        st.json(export_data)
-    
-    else:
-        st.info("ℹ️ Run analysis first to export results")
+        with st.expander("🔀 DAG 模型結構圖"):
+            st.image(f"data:image/png;base64,{st.session_state.analysis_results['dag_plot']}")
 
-# ===== Footer =====
+# Footer
 st.markdown("---")
-st.markdown("""
-<div style='text-align: center; color: #666; font-size: 0.9rem;'>
-    <p>Pokemon Speed Bayesian Analysis System | Powered by PyMC, ArviZ, GPT-4, and Streamlit</p>
-    <p>⚡ Analyzing the impact of speed on win rates across Pokemon types ⚡</p>
-</div>
-""", unsafe_allow_html=True)
+st.markdown(
+    f"""
+    <div style='text-align: center'>
+        <p>⚡ Bayesian Hierarchical Model for Pokémon Speed Analysis | Built with PyMC & Streamlit</p>
+        <p>Session ID: {st.session_state.session_id[:8]} | Powered by Google Gemini</p>
+    </div>
+    """,
+    unsafe_allow_html=True
+)

bayesian_core.py

@@ -1,264 +1,311 @@
-"""
-Bayesian Meta-Analysis Core for Pokemon Speed Analysis
-Using PyMC for hierarchical Bayesian modeling
-"""
-
+import os
 import pymc as pm
 import numpy as np
 import pandas as pd
 import arviz as az
+import matplotlib.pyplot as plt
+import io
+import base64
 from datetime import datetime
+import threading
 
-
-class BayesianSpeedAnalyzer:
+class BayesianHierarchicalAnalyzer:
     """
-    貝葉斯階層式分析器
-    分析速度對不同屬性寶可夢勝率的影響
+    貝氏階層模型分析器
+    用於分析寶可夢速度對勝率的影響（按屬性分層）
     """
-
-    def __init__(self, data):
+    
+    # 類別級的鎖，用於執行緒安全
+    _lock = threading.Lock()
+    
+    # 儲存各 session 的分析結果
+    _session_results = {}
+    
+    def __init__(self, session_id):
         """
         初始化分析器
-
+        
         Args:
-            data: DataFrame 包含欄位:
-                - Trial_Type: 屬性名稱
-                - rc: 控制組勝場數
-                - nc: 控制組總場數
-                - rt: 實驗組勝場數
-                - nt: 實驗組總場數
+            session_id: 唯一的 session 識別碼
         """
-        self.data = data
-        self.trial_labels = data['Trial_Type'].values
-        self.num_trials = len(data)
+        self.session_id = session_id
+        self.df = None
         self.model = None
         self.trace = None
-        self.results = None
-
-    def build_model(self):
-        """建立貝葉斯階層式模型"""
+    
+    def load_data(self, csv_path_or_df):
+        """
+        載入資料
         
-        with pm.Model() as model:
-            # ===== 先驗分佈 (Priors) =====
-            # d: 整體速度效應 (log odds ratio)
-            d = pm.Normal('d', mu=0, sigma=10)
-            
-            # tau: 精度參數 (控制屬性間變異)
-            tau = pm.Gamma('tau', alpha=0.001, beta=0.001)
-            
-            # sigma: 標準差 (由 tau 導出)
-            sigma = pm.Deterministic('sigma', 1 / pm.math.sqrt(tau))
-
-            # ===== 各屬性特定參數 =====
-            # mu: 各屬性基準勝率 (logit scale)
-            mu = pm.Normal('mu', mu=0, sigma=10, shape=self.num_trials)
-            
-            # delta: 各屬性的速度效應
-            delta = pm.Normal(
-                'delta',
-                mu=d,
-                sigma=1 / pm.math.sqrt(tau),
-                shape=self.num_trials
-            )
-
-            # ===== 轉換與似然函數 =====
-            # pc: 控制組(慢速)勝率
-            pc = pm.Deterministic('pc', pm.math.invlogit(mu))
-            
-            # pt: 實驗組(快速)勝率
-            pt = pm.Deterministic('pt', pm.math.invlogit(mu + delta))
-
-            # 觀測資料的似然函數
-            rc_obs = pm.Binomial(
-                'rc_obs',
-                n=self.data['nc'].values,
-                p=pc,
-                observed=self.data['rc'].values
-            )
-            
-            rt_obs = pm.Binomial(
-                'rt_obs',
-                n=self.data['nt'].values,
-                p=pt,
-                observed=self.data['rt'].values
-            )
-
-            # ===== 導出統計量 =====
-            # 預測新屬性的效應
-            delta_new = pm.Normal('delta_new', mu=d, sigma=1 / pm.math.sqrt(tau))
-            
-            # 勝率比 (Odds Ratio)
-            or_speed = pm.Deterministic('or_speed', pm.math.exp(d))
-
-        self.model = model
-        return model
-
-    def run_analysis(self, samples=2000, tune=1000, chains=1, target_accept=0.95, progress_callback=None):
+        Args:
+            csv_path_or_df: CSV 檔案路徑或 DataFrame
         """
-        執行 MCMC 抽樣
-
+        if isinstance(csv_path_or_df, str):
+            self.df = pd.read_csv(csv_path_or_df)
+        else:
+            self.df = csv_path_or_df.copy()
+        
+        # 驗證必要欄位
+        required_cols = ['Trial_Type', 'rc', 'nc', 'rt', 'nt']
+        missing_cols = [col for col in required_cols if col not in self.df.columns]
+        
+        if missing_cols:
+            raise ValueError(f"資料缺少必要欄位: {missing_cols}")
+    
+    def run_analysis(self, n_samples=2000, n_tune=1000, n_chains=1, target_accept=0.95, progress_callback=None):
+        """
+        執行貝氏階層模型分析
+        
         Args:
-            samples: 抽樣次數
-            tune: 暖身迭代次數
-            chains: 鏈數量
+            n_samples: MCMC 抽樣數
+            n_tune: 調整期樣本數
+            n_chains: 鏈數
             target_accept: 目標接受率
-            progress_callback: 進度回調函數 (可選)
-
+            progress_callback: 進度回調函數
+            
         Returns:
-            trace: InferenceData 物件
+            dict: 包含所有分析結果的字典
         """
-        if self.model is None:
-            self.build_model()
-
-        with self.model:
-            self.trace = pm.sample(
-                samples,
-                tune=tune,
-                chains=chains,
-                target_accept=target_accept,
-                return_inferencedata=True,
-                progressbar=False  # Streamlit 中關閉進度條
-            )
-
-        # 生成分析結果
-        self._generate_results()
+        with self._lock:
+            try:
+                if self.df is None:
+                    raise ValueError("請先載入資料")
+                
+                if progress_callback:
+                    progress_callback("建立貝氏模型...", 10)
+                
+                # 準備資料
+                trial_labels = self.df['Trial_Type'].values
+                Num = len(self.df)
+                
+                # 建立貝氏模型
+                with pm.Model() as model:
+                    # 先驗分佈
+                    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)
+                    
+                    # 轉換與似然函數
+                    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, 
+                        return_inferencedata=True,
+                        progressbar=False
+                    )
+                
+                self.model = model
+                self.trace = trace
+                
+                if progress_callback:
+                    progress_callback("生成統計摘要...", 60)
+                
+                # 生成文字摘要
+                summary = az.summary(trace, var_names=['d', 'sigma', 'or_speed'], hdi_prob=0.95)
+                summary_text = self._format_summary(summary)
+                
+                if progress_callback:
+                    progress_callback("生成視覺化圖表...", 70)
+                
+                # 生成圖表
+                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)
+                
+                # 整理結果
+                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_samples': n_samples,
+                        'n_tune': n_tune,
+                        'n_chains': n_chains,
+                        'target_accept': target_accept
+                    }
+                }
+                
+                # 添加各屬性的詳細結果
+                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 圖"""
+        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()
         
-        return self.trace
-
-    def _generate_results(self):
-        """生成分析結果摘要"""
+        # 轉換為 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()
         
-        # 主要參數摘要
-        summary = az.summary(
-            self.trace,
-            var_names=['d', 'sigma', 'or_speed'],
-            hdi_prob=0.95
-        )
-
-        # 各屬性效應摘要
-        delta_summary = az.summary(
-            self.trace,
-            var_names=['delta'],
-            hdi_prob=0.95
-        )
-        delta_summary['Trial_Type'] = self.trial_labels
-
-        # 提取關鍵統計量
-        d_mean = summary.loc['d', 'mean']
-        d_hdi_lower = summary.loc['d', 'hdi_2.5%']
-        d_hdi_upper = summary.loc['d', 'hdi_97.5%']
+        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)
         
-        or_mean = summary.loc['or_speed', 'mean']
-        or_hdi_lower = summary.loc['or_speed', 'hdi_2.5%']
-        or_hdi_upper = summary.loc['or_speed', 'hdi_97.5%']
+        # 轉換為 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()
         
-        sigma_mean = summary.loc['sigma', 'mean']
-
-        # 計算各屬性勝率變化
-        delta_values = self.trace.posterior['delta'].values.reshape(-1, self.num_trials)
-        mu_values = self.trace.posterior['mu'].values.reshape(-1, self.num_trials)
+        return img_base64
+    
+    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
         
-        pc_mean = 1 / (1 + np.exp(-mu_values.mean(axis=0)))  # 控制組平均勝率
-        pt_mean = 1 / (1 + np.exp(-(mu_values.mean(axis=0) + delta_values.mean(axis=0))))  # 實驗組平均勝率
+        fig, ax = plt.subplots(figsize=(12, max(10, Num * 0.4)))
+        y_pos = np.arange(Num)
         
-        win_rate_increase = (pt_mean - pc_mean) * 100  # 勝率提升百分點
-
-        self.results = {
-            'summary': summary,
-            'delta_summary': delta_summary,
-            'statistics': {
-                'd_mean': d_mean,
-                'd_hdi_lower': d_hdi_lower,
-                'd_hdi_upper': d_hdi_upper,
-                'or_mean': or_mean,
-                'or_hdi_lower': or_hdi_lower,
-                'or_hdi_upper': or_hdi_upper,
-                'sigma_mean': sigma_mean,
-                'pc_mean': pc_mean,
-                'pt_mean': pt_mean,
-                'win_rate_increase': win_rate_increase
-            },
-            'trial_labels': self.trial_labels,
-            'num_trials': self.num_trials,
-            'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-        }
-
-    def get_convergence_diagnostics(self):
-        """獲取收斂診斷指標"""
+        # 繪製信賴區間
+        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)
         
-        if self.trace is None:
-            return None
-
-        summary = az.summary(self.trace, var_names=['d', 'sigma', 'or_speed'])
+        # 標註顯著的屬性
+        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')
         
-        diagnostics = {
-            'r_hat': {
-                'd': summary.loc['d', 'r_hat'] if 'r_hat' in summary.columns else 1.0,
-                'sigma': summary.loc['sigma', 'r_hat'] if 'r_hat' in summary.columns else 1.0,
-                'or_speed': summary.loc['or_speed', 'r_hat'] if 'r_hat' in summary.columns else 1.0
-            },
-            'ess_bulk': {
-                'd': summary.loc['d', 'ess_bulk'] if 'ess_bulk' in summary.columns else 2000,
-                'sigma': summary.loc['sigma', 'ess_bulk'] if 'ess_bulk' in summary.columns else 2000,
-                'or_speed': summary.loc['or_speed', 'ess_bulk'] if 'ess_bulk' in summary.columns else 2000
-            }
-        }
-
-        return diagnostics
-
-    def interpret_results(self):
-        """解釋分析結果"""
+        # 設定軸
+        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)
         
-        if self.results is None:
-            return "尚未執行分析"
-
-        stats = self.results['statistics']
+        plt.tight_layout()
         
-        # 判斷速度效應顯著性
-        if stats['d_hdi_lower'] > 0:
-            significance = "顯著正向"
-            direction = "速度快明顯提升勝率"
-        elif stats['d_hdi_upper'] < 0:
-            significance = "顯著負向"
-            direction = "速度快反而降低勝率"
-        else:
-            significance = "不顯著"
-            direction = "速度效應不明確"
-
-        interpretation = f"""
-### 🎯 整體結論
-
-**速度效應**: {significance} ({direction})
-
-- **對數勝率比 (d)**: {stats['d_mean']:.3f} (95% HDI: [{stats['d_hdi_lower']:.3f}, {stats['d_hdi_upper']:.3f}])
-- **勝率比 (OR)**: {stats['or_mean']:.3f} (95% HDI: [{stats['or_hdi_lower']:.3f}, {stats['or_hdi_upper']:.3f}])
-- **異質性 (σ)**: {stats['sigma_mean']:.3f}
-
-### 📊 實際意義
-
-速度快的寶可夢勝率約為速度慢的 **{stats['or_mean']:.2f} 倍**。
-
-平均而言，速度快可使勝率提升約 **{stats['win_rate_increase'].mean():.1f} 個百分點**。
-"""
+        # 轉換為 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 interpretation
-
-    def get_trial_specific_results(self):
-        """獲取各屬性的詳細結果"""
+        return img_base64
+    
+    def _format_summary(self, summary):
+        """格式化摘要表格為文字"""
+        text = "="*70 + "\n"
+        text += "貝氏階層模型分析結果摘要\n"
+        text += "Bayesian Hierarchical Model Analysis Summary\n"
+        text += "="*70 + "\n\n"
         
-        if self.results is None:
-            return None
-
-        stats = self.results['statistics']
+        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"
         
-        trial_results = []
-        for i, trial in enumerate(self.trial_labels):
-            trial_results.append({
-                'Trial_Type': trial,
-                'Control_Win_Rate': f"{stats['pc_mean'][i]:.1%}",
-                'Treatment_Win_Rate': f"{stats['pt_mean'][i]:.1%}",
-                'Win_Rate_Increase': f"{stats['win_rate_increase'][i]:+.1f}%",
-                'Effect_Size': self.results['delta_summary'].iloc[i]['mean']
-            })
-
-        return pd.DataFrame(trial_results)
+        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
+    
+    @classmethod
+    def get_session_results(cls, session_id):
+        """獲取特定 session 的結果"""
+        return cls._session_results.get(session_id)
+    
+    @classmethod
+    def clear_session_results(cls, session_id):
+        """清除特定 session 的結果"""
+        if session_id in cls._session_results:
+            del cls._session_results[session_id]

bayesian_llm_assistant.py

@@ -0,0 +1,362 @@
+import google.generativeai as genai
+
+class BayesianLLMAssistant:
+    """
+    貝氏階層模型 LLM 問答助手
+    協助用戶理解貝氏分析結果
+    """
+    
+    def __init__(self, api_key, session_id):
+        """
+        初始化 LLM 助手
+        
+        Args:
+            api_key: Google Gemini API key
+            session_id: 唯一的 session 識別碼
+        """
+        genai.configure(api_key=api_key)
+        self.model = genai.GenerativeModel('gemini-2.0-flash-exp')
+        self.session_id = session_id
+        self.conversation_history = []
+        
+        # 系統提示詞（雙語版）
+        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:**
+- Always respond in the SAME language as the user's question
+- If user asks in Traditional Chinese (繁體中文), respond in Traditional Chinese
+- 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.
+你的角色是幫助使用者理解貝氏階層模型的結果，分析速度如何影響不同屬性寶可夢的勝率。
+
+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. 用簡單易懂的方式解釋貝氏概念（先驗、後驗、可信區間）
+2. 詮釋階層模型及其優勢（資訊借用、收縮效應）
+3. 解釋參數的意義（d、delta、sigma、tau）
+4. 討論後驗分佈和 HDI（最高密度區間）
+5. 幫助使用者理解收斂診斷（trace plot、R-hat）
+6. 解釋貝氏與頻率論方法的差異
+7. 根據後驗估計提供對戰策略見解
+8. 討論不確定性量化和實際顯著性
+
+Key concepts to explain when relevant:
+重要概念解釋（當相關時）：
+
+**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) | 考慮例外情況（戲法空間、先制招式）
+
+Always be clear, educational, and engaging. Use examples when helpful.
+Format responses with proper markdown for better readability.
+
+請務必清晰、具教育性、引人入勝。適時使用範例說明。使用適當的 Markdown 格式以提升可讀性。"""
+    
+    def get_response(self, user_message, analysis_results=None):
+        """
+        獲取 AI 回應
+        
+        Args:
+            user_message: 用戶訊息
+            analysis_results: 分析結果字典（可選）
+            
+        Returns:
+            str: AI 回應
+        """
+        # 準備上下文資訊
+        context = ""
+        if analysis_results:
+            context = self._prepare_context(analysis_results)
+        
+        # 添加用戶訊息到歷史
+        self.conversation_history.append({
+            "role": "user",
+            "content": user_message
+        })
+        
+        try:
+            # 構建完整的提示詞
+            full_prompt = self.system_prompt
+            
+            if context:
+                full_prompt += f"\n\n## Current Analysis Context:\n{context}"
+            
+            # 構建對話歷史文字
+            conversation_text = "\n\n## Conversation History:\n"
+            for msg in self.conversation_history[:-1]:
+                role = "User" if msg["role"] == "user" else "Assistant"
+                conversation_text += f"\n{role}: {msg['content']}\n"
+            
+            # 組合最終提示詞
+            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,
+                )
+            )
+            
+            assistant_message = response.text
+            
+            # 添加助手回應到歷史
+            self.conversation_history.append({
+                "role": "assistant",
+                "content": assistant_message
+            })
+            
+            return assistant_message
+            
+        except Exception as e:
+            return f"❌ Error: {str(e)}\n\nPlease check your API key and try again."
+    
+    def _prepare_context(self, results):
+        """準備分析結果的上下文資訊"""
+        
+        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 | 速度慢的寶可夢有更高的勝率"
+        
+        # 判斷顯著性
+        if results['is_significant']:
+            significance = "YES - The effect is significant | 是 - 效應顯著"
+        else:
+            significance = "NO - The effect is not significant | 否 - 效應不顯著"
+        
+        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} 倍"
+}
+
+### Type-Specific Effects | 屬性特定效應
+
+"""
+        
+        # 添加各屬性的詳細結果
+        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
+"""
+        
+        return context
+    
+    def generate_summary(self, analysis_results):
+        """自動生成分析結果總結"""
+        
+        summary_prompt = """請根據提供的貝氏階層模型分析結果生成一份完整的總結報告，包含：
+
+1. **分析目的**：這個模型在研究什麼？
+2. **整體發現**：
+   - 速度對勝率的整體影響（d 參數）
+   - 是否具有統計顯著性？
+   - 勝算比告訴我們什麼？
+3. **屬性間差異**：
+   - sigma 參數顯示什麼？
+   - 哪些屬性對速度特別敏感？
+   - 哪些屬性例外？
+4. **對戰意涵**：這對實戰有什麼啟示？
+5. **建議**：訓練師該如何運用這些資訊？
+
+請用清楚的繁體中文 Markdown 格式撰寫，包含適當的章節標題。"""
+        
+        return self.get_response(summary_prompt, analysis_results)
+    
+    def explain_bayesian_concepts(self):
+        """解釋貝氏統計基本概念"""
+        
+        explain_prompt = """請用簡單的方式解釋貝氏統計，特別是在這個寶可夢速度分析的情境下。
+
+請涵蓋：
+1. 什麼是貝氏統計？與傳統統計有何不同？
+2. 什麼是先驗、似然、後驗？
+3. 什麼是 HDI（最高密度區間）？與信賴區間有何不同？
+4. 為什麼用貝氏方法分析這個問題？
+5. 如何解讀後驗分佈？
+
+請用寶可夢的實際例子讓說明更具體易懂，全程使用繁體中文。"""
+        
+        return self.get_response(explain_prompt, None)
+    
+    def explain_hierarchical_model(self):
+        """解釋階層模型的概念"""
+        
+        explain_prompt = """請解釋什麼是階層模型（Hierarchical Model），以及為什麼用它來分析不同屬性的寶可夢。
+
+請涵蓋：
+1. 什麼是階層結構？
+2. 什麼是「資訊借用」（borrowing strength）？
+3. 什麼是「收縮效應」（shrinkage）？為什麼這很重要？
+4. 在這個分析中，階層模型如何幫助我們？
+5. d、delta、sigma 參數分別代表什麼？
+
+請用具體的寶可夢例子說明，使用繁體中文。"""
+        
+        return self.get_response(explain_prompt, None)
+    
+    def explain_convergence(self):
+        """解釋收斂診斷"""
+        
+        explain_prompt = """請解釋如何判斷 MCMC 抽樣是否收斂，以及 Trace Plot 該如何解讀。
+
+請涵蓋：
+1. 什麼是 MCMC 抽樣？
+2. 什麼是收斂？為什麼重要？
+3. Trace Plot 該如何解讀？
+4. 什麼是「毛毛蟲圖」？
+5. 如果沒有收斂會怎樣？
+
+請用簡單的語言解釋，使用繁體中文。"""
+        
+        return self.get_response(explain_prompt, None)
+    
+    def compare_types(self, analysis_results):
+        """比較不同屬性"""
+        
+        compare_prompt = """根據各屬性的 delta 值，請分析哪些寶可夢屬性對速度最敏感，哪些最不敏感。
+
+請提供：
+1. 速度效應最大的前 5 個屬性
+2. 速度效應最小的前 5 個屬性
+3. 可能的原因（從對戰機制角度）
+4. 組隊建議
+
+請用繁體中文回答。"""
+        
+        return self.get_response(compare_prompt, analysis_results)
+    
+    def battle_strategy_advice(self, analysis_results):
+        """提供對戰策略建議"""
+        
+        strategy_prompt = """根據這個貝氏階層模型的分析結果，請為寶可夢訓練師提供實際的對戰策略建議。
+
+請考慮：
+1. 在組建隊伍時應該多重視速度？
+2. 哪些屬性的寶可夢特別需要速度？
+3. 哪些屬性可以犧牲速度換取其他能力？
+4. 有什麼例外情況（如戲法空間隊伍）？
+5. 對競技對戰的影響？
+
+請具體且可操作，使用繁體中文回答。"""
+        
+        return self.get_response(strategy_prompt, analysis_results)
+    
+    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)
+        
+        explain_prompt = f"""請在這次貝氏階層模型分析的脈絡下，解釋以下指標：
+
+指標：{metric_display}
+
+請包含：
+1. 這個指標一般來說測量什麼？
+2. 在本次分析中得到的數值是多少？
+3. 如何從寶可夢對戰的角度詮釋這個數值？
+4. 這告訴我們速度的重要性如何？
+5. 有什麼需要注意的限制或注意事項？
+
+請用繁體中文回答。"""
+        
+        return self.get_response(explain_prompt, analysis_results)
+    
+    def reset_conversation(self):
+        """重置對話歷史"""
+        self.conversation_history = []

bayesian_requirements.txt

@@ -0,0 +1,8 @@
+streamlit==1.31.0
+pandas==2.1.4
+numpy==1.26.3
+pymc==5.10.0
+arviz==0.17.0
+matplotlib==3.8.2
+google-generativeai>=0.3.0
+graphviz

pokemon_speed_meta_results.csv

@@ -0,0 +1,19 @@
+Trial_Type,rt,nt,rc,nc
+Bug,2229,3142,800,3660
+Dark,1559,2083,369,931
+Drago,1264,1715,298,889
+Elect,1935,2499,373,1174
+Fairy,310,432,309,1320
+Fight,800,1134,402,1458
+Fire,2547,3530,487,1535
+Flyin,102,107,39,110
+Ghost,639,937,331,1259
+Grass,1591,2196,1418,4598
+Groun,1100,1529,529,1574
+Ice,826,1288,354,1296
+Norma,4258,5748,1107,3989
+Poiso,997,1571,431,1411
+Psych,2002,2747,334,1926
+Rock,864,1255,998,3392
+Steel,609,804,428,1584
+Water,3601,5492,1814,5793