app.py

import gradio as gr
import pandas as pd
import torch
from transformers import BertTokenizer, BertForSequenceClassification, TrainingArguments, Trainer
from peft import LoraConfig, AdaLoraConfig, get_peft_model, TaskType
from datasets import Dataset
from sklearn.metrics import accuracy_score, precision_recall_fscore_support, confusion_matrix
from torch import nn
import os
from datetime import datetime

os.environ["TOKENIZERS_PARALLELISM"] = "false"

# 全域變數
trained_models = {}
model_counter = 0
baseline_results = {}
baseline_model_cache = {}

def calculate_improvement(baseline_val, finetuned_val):
    """安全計算改善率"""
    if baseline_val == 0:
        if finetuned_val > 0:
            return float('inf')
        else:
            return 0.0
    return (finetuned_val - baseline_val) / baseline_val * 100

def format_improve(val):
    """格式化改善率"""
    if val == float('inf'):
        return "N/A (baseline=0)"
    return f"{val:+.1f}%"

def compute_metrics(pred):
    try:
        labels = pred.label_ids
        preds = pred.predictions.argmax(-1)
        precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average='binary', pos_label=1, zero_division=0)
        acc = accuracy_score(labels, preds)
        cm = confusion_matrix(labels, preds)
        if cm.shape == (2, 2):
            tn, fp, fn, tp = cm.ravel()
        else:
            tn = fp = fn = tp = 0
        sensitivity = tp / (tp + fn) if (tp + fn) > 0 else 0
        specificity = tn / (tn + fp) if (tn + fp) > 0 else 0
        return {
            'accuracy': acc, 'f1': f1, 'precision': precision, 'recall': recall,
            'sensitivity': sensitivity, 'specificity': specificity,
            'tp': int(tp), 'tn': int(tn), 'fp': int(fp), 'fn': int(fn)
        }
    except Exception as e:
        print(f"Error in compute_metrics: {e}")
        return {
            'accuracy': 0, 'f1': 0, 'precision': 0, 'recall': 0, 
            'sensitivity': 0, 'specificity': 0, 'tp': 0, 'tn': 0, 'fp': 0, 'fn': 0
        }

class WeightedTrainer(Trainer):
    def __init__(self, *args, class_weights=None, **kwargs):
        super().__init__(*args, **kwargs)
        self.class_weights = class_weights
    
    def compute_loss(self, model, inputs, return_outputs=False, num_items_in_batch=None):
        labels = inputs.pop("labels")
        outputs = model(**inputs)
        loss_fct = nn.CrossEntropyLoss(weight=self.class_weights)
        loss = loss_fct(outputs.logits.view(-1, 2), labels.view(-1))
        return (loss, outputs) if return_outputs else loss

def evaluate_baseline(model, tokenizer, test_dataset, device):
    """評估未微調的基準模型"""
    model.eval()
    all_preds = []
    all_labels = []
    
    from torch.utils.data import DataLoader
    
    def collate_fn(batch):
        return {
            'input_ids': torch.stack([torch.tensor(item['input_ids']) for item in batch]),
            'attention_mask': torch.stack([torch.tensor(item['attention_mask']) for item in batch]),
            'labels': torch.tensor([item['label'] for item in batch])
        }
    
    dataloader = DataLoader(test_dataset, batch_size=16, collate_fn=collate_fn)
    
    with torch.no_grad():
        for batch in dataloader:
            labels = batch.pop('labels')
            inputs = {k: v.to(device) for k, v in batch.items()}
            outputs = model(**inputs)
            preds = torch.argmax(outputs.logits, dim=-1)
            all_preds.extend(preds.cpu().numpy())
            all_labels.extend(labels.numpy())
    
    precision, recall, f1, _ = precision_recall_fscore_support(all_labels, all_preds, average='binary', pos_label=1, zero_division=0)
    acc = accuracy_score(all_labels, all_preds)
    cm = confusion_matrix(all_labels, all_preds)
    if cm.shape == (2, 2):
        tn, fp, fn, tp = cm.ravel()
    else:
        tn = fp = fn = tp = 0
    sensitivity = tp / (tp + fn) if (tp + fn) > 0 else 0
    specificity = tn / (tn + fp) if (tn + fp) > 0 else 0
    
    return {
        'accuracy': acc, 'f1': f1, 'precision': precision, 'recall': recall,
        'sensitivity': sensitivity, 'specificity': specificity,
        'tp': int(tp), 'tn': int(tn), 'fp': int(fp), 'fn': int(fn)
    }

def train_bert_model(csv_file, base_model, method, num_epochs, batch_size, learning_rate, 
                     weight_decay, dropout, lora_r, lora_alpha, lora_dropout, 
                     weight_mult, best_metric):
    global trained_models, model_counter, baseline_results
    
    model_mapping = {
        "BERT-base": "bert-base-uncased",
    }
    
    model_name = model_mapping.get(base_model, "bert-base-uncased")
    
    try:
        if csv_file is None:
            return "❌ 請上傳 CSV", "", "", ""
        
        df = pd.read_csv(csv_file.name)
        if 'Text' not in df.columns or 'label' not in df.columns:
            return "❌ 需要 Text 和 label 欄位", "", "", ""
        
        df_clean = pd.DataFrame({
            'text': df['Text'].astype(str), 
            'label': df['label'].astype(int)
        }).dropna()
        
        n0 = int(sum(df_clean['label'] == 0))
        n1 = int(sum(df_clean['label'] == 1))
        if n1 == 0:
            return "❌ 無死亡樣本", "", "", ""
        
        ratio = n0 / n1
        w0, w1 = 1.0, ratio * weight_mult
        
        info = f"📊 資料: {len(df_clean)} 筆\n存活: {n0} | 死亡: {n1}\n比例: {ratio:.2f}:1\n權重: {w0:.2f} / {w1:.2f}\n模型: {base_model}\n方法: {method.upper()}"
        
        tokenizer = BertTokenizer.from_pretrained(model_name)
        dataset = Dataset.from_pandas(df_clean[['text', 'label']])
        
        def preprocess(ex):
            return tokenizer(ex['text'], truncation=True, padding='max_length', max_length=128)
        
        tokenized = dataset.map(preprocess, batched=True, remove_columns=['text'])
        split = tokenized.train_test_split(test_size=0.2, seed=42)
        
        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        info += f"\n裝置: {'GPU ✅' if torch.cuda.is_available() else 'CPU ⚠️'}"
        
        # 評估基準模型（未微調）
        info += "\n\n🔍 評估基準模型（未微調）..."
        baseline_model = BertForSequenceClassification.from_pretrained(model_name, num_labels=2)
        baseline_model = baseline_model.to(device)
        
        baseline_perf = evaluate_baseline(baseline_model, tokenizer, split['test'], device)
        baseline_key = f"{base_model}_baseline"
        baseline_results[baseline_key] = baseline_perf
        
        info += f"\n基準 F1: {baseline_perf['f1']:.4f}"
        info += f"\n基準 Accuracy: {baseline_perf['accuracy']:.4f}"
        
        # 清理基準模型以釋放記憶體
        del baseline_model
        torch.cuda.empty_cache() if torch.cuda.is_available() else None
        
        # 開始微調
        info += f"\n\n🔧 套用 {method.upper()} 微調..."
        model = BertForSequenceClassification.from_pretrained(
            model_name, num_labels=2,
            hidden_dropout_prob=dropout,
            attention_probs_dropout_prob=dropout
        )
        
        peft_applied = False
        if method == "lora":
            config = LoraConfig(
                task_type=TaskType.SEQ_CLS, 
                r=int(lora_r), 
                lora_alpha=int(lora_alpha),
                lora_dropout=lora_dropout, 
                target_modules=["query", "value"], 
                bias="none"
            )
            model = get_peft_model(model, config)
            peft_applied = True
            info += f"\n✅ LoRA 已套用（r={int(lora_r)}, alpha={int(lora_alpha)}）"
        elif method == "adalora":
            config = AdaLoraConfig(
                task_type=TaskType.SEQ_CLS, 
                r=int(lora_r), 
                lora_alpha=int(lora_alpha),
                lora_dropout=lora_dropout, 
                target_modules=["query", "value"],
                init_r=12, tinit=200, tfinal=1000, deltaT=10
            )
            model = get_peft_model(model, config)
            peft_applied = True
            info += f"\n✅ AdaLoRA 已套用（r={int(lora_r)}, alpha={int(lora_alpha)}）"
        
        if not peft_applied:
            info += f"\n⚠️ 警告：{method} 方法未被識別，使用 Full Fine-tuning"
        
        model = model.to(device)
        
        total = sum(p.numel() for p in model.parameters())
        trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
        info += f"\n\n💾 參數量\n總參數: {total:,}\n可訓練: {trainable:,}\n比例: {trainable/total*100:.2f}%"
        
        weights = torch.tensor([w0, w1], dtype=torch.float).to(device)
        
        args = TrainingArguments(
            output_dir='./results', 
            num_train_epochs=int(num_epochs),
            per_device_train_batch_size=int(batch_size), 
            per_device_eval_batch_size=int(batch_size)*2,
            learning_rate=float(learning_rate), 
            weight_decay=float(weight_decay),
            evaluation_strategy="epoch", 
            save_strategy="epoch",
            load_best_model_at_end=True, 
            metric_for_best_model=best_metric,
            report_to="none", 
            logging_steps=50,
            save_total_limit=2
        )
        
        trainer = WeightedTrainer(
            model=model, 
            args=args, 
            train_dataset=split['train'],
            eval_dataset=split['test'], 
            compute_metrics=compute_metrics,
            class_weights=weights
        )
        
        info += "\n\n⏳ 開始訓練..."
        trainer.train()
        results = trainer.evaluate()
        
        # 生成帶時間戳的模型 ID
        model_counter += 1
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        model_id = f"{base_model}_{method}_{timestamp}"
        trained_models[model_id] = {
            'model': model, 
            'tokenizer': tokenizer, 
            'results': results,
            'baseline': baseline_perf,
            'config': {
                'type': base_model, 
                'model_name': model_name, 
                'method': method, 
                'metric': best_metric
            },
            'timestamp': timestamp
        }
        
        # 計算改善
        f1_improve = calculate_improvement(baseline_perf['f1'], results['eval_f1'])
        acc_improve = calculate_improvement(baseline_perf['accuracy'], results['eval_accuracy'])
        prec_improve = calculate_improvement(baseline_perf['precision'], results['eval_precision'])
        rec_improve = calculate_improvement(baseline_perf['recall'], results['eval_recall'])
        sens_improve = calculate_improvement(baseline_perf['sensitivity'], results['eval_sensitivity'])
        spec_improve = calculate_improvement(baseline_perf['specificity'], results['eval_specificity'])
        
        # 純 BERT 輸出
        baseline_output = f"🔬 純 BERT（未微調）\n\n"
        baseline_output += f"📈 表現\n"
        baseline_output += f"F1: {baseline_perf['f1']:.4f}\n"
        baseline_output += f"Accuracy: {baseline_perf['accuracy']:.4f}\n"
        baseline_output += f"Precision: {baseline_perf['precision']:.4f}\n"
        baseline_output += f"Recall: {baseline_perf['recall']:.4f}\n"
        baseline_output += f"Sensitivity: {baseline_perf['sensitivity']:.4f}\n"
        baseline_output += f"Specificity: {baseline_perf['specificity']:.4f}\n\n"
        baseline_output += f"混淆矩陣\n"
        baseline_output += f"TP: {baseline_perf['tp']} | TN: {baseline_perf['tn']}\n"
        baseline_output += f"FP: {baseline_perf['fp']} | FN: {baseline_perf['fn']}"
        
        # 微調 BERT 輸出
        finetuned_output = f"✅ 微調 BERT\n模型: {model_id}\n\n"
        finetuned_output += f"📈 表現\n"
        finetuned_output += f"F1: {results['eval_f1']:.4f}\n"
        finetuned_output += f"Accuracy: {results['eval_accuracy']:.4f}\n"
        finetuned_output += f"Precision: {results['eval_precision']:.4f}\n"
        finetuned_output += f"Recall: {results['eval_recall']:.4f}\n"
        finetuned_output += f"Sensitivity: {results['eval_sensitivity']:.4f}\n"
        finetuned_output += f"Specificity: {results['eval_specificity']:.4f}\n\n"
        finetuned_output += f"混淆矩陣\n"
        finetuned_output += f"TP: {results['eval_tp']} | TN: {results['eval_tn']}\n"
        finetuned_output += f"FP: {results['eval_fp']} | FN: {results['eval_fn']}"
        
        # 比較結果輸出
        comparison_output = f"📊 純 BERT vs 微調 BERT 比較\n\n"
        comparison_output += f"指標改善：\n"
        comparison_output += f"F1: {baseline_perf['f1']:.4f} → {results['eval_f1']:.4f} ({format_improve(f1_improve)})\n"
        comparison_output += f"Accuracy: {baseline_perf['accuracy']:.4f} → {results['eval_accuracy']:.4f} ({format_improve(acc_improve)})\n"
        comparison_output += f"Precision: {baseline_perf['precision']:.4f} → {results['eval_precision']:.4f} ({format_improve(prec_improve)})\n"
        comparison_output += f"Recall: {baseline_perf['recall']:.4f} → {results['eval_recall']:.4f} ({format_improve(rec_improve)})\n"
        comparison_output += f"Sensitivity: {baseline_perf['sensitivity']:.4f} → {results['eval_sensitivity']:.4f} ({format_improve(sens_improve)})\n"
        comparison_output += f"Specificity: {baseline_perf['specificity']:.4f} → {results['eval_specificity']:.4f} ({format_improve(spec_improve)})\n\n"
        comparison_output += f"混淆矩陣變化：\n"
        comparison_output += f"TP: {baseline_perf['tp']} → {results['eval_tp']} ({results['eval_tp'] - baseline_perf['tp']:+d})\n"
        comparison_output += f"TN: {baseline_perf['tn']} → {results['eval_tn']} ({results['eval_tn'] - baseline_perf['tn']:+d})\n"
        comparison_output += f"FP: {baseline_perf['fp']} → {results['eval_fp']} ({results['eval_fp'] - baseline_perf['fp']:+d})\n"
        comparison_output += f"FN: {baseline_perf['fn']} → {results['eval_fn']} ({results['eval_fn'] - baseline_perf['fn']:+d})"
        
        info += "\n\n✅ 訓練完成！"
        
        return info, baseline_output, finetuned_output, comparison_output
        
    except Exception as e:
        import traceback
        error_msg = f"❌ 錯誤: {str(e)}\n\n{traceback.format_exc()}"
        return error_msg, "", "", ""

def predict(model_id, text):
    global baseline_model_cache
    
    if not model_id or model_id not in trained_models:
        return "❌ 請選擇模型"
    if not text:
        return "❌ 請輸入文字"
    
    try:
        info = trained_models[model_id]
        model, tokenizer = info['model'], info['tokenizer']
        config = info['config']
        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        
        inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=128)
        inputs_cuda = {k: v.to(device) for k, v in inputs.items()}
        
        # 預測：微調模型
        model.eval()
        with torch.no_grad():
            outputs = model(**inputs_cuda)
            probs_finetuned = torch.nn.functional.softmax(outputs.logits, dim=-1)
            pred_finetuned = torch.argmax(probs_finetuned, dim=-1).item()
        
        result_finetuned = "存活" if pred_finetuned == 0 else "死亡"
        
        # 預測：基準模型（使用快取）
        cache_key = config['model_name']
        if cache_key not in baseline_model_cache:
            baseline_model = BertForSequenceClassification.from_pretrained(config['model_name'], num_labels=2)
            baseline_model = baseline_model.to(device)
            baseline_model.eval()
            baseline_model_cache[cache_key] = baseline_model
        else:
            baseline_model = baseline_model_cache[cache_key]
        
        with torch.no_grad():
            outputs_baseline = baseline_model(**inputs_cuda)
            probs_baseline = torch.nn.functional.softmax(outputs_baseline.logits, dim=-1)
            pred_baseline = torch.argmax(probs_baseline, dim=-1).item()
        
        result_baseline = "存活" if pred_baseline == 0 else "死亡"
        
        # 判斷是否一致
        agreement = "✅ 一致" if pred_finetuned == pred_baseline else "⚠️ 不一致"
        
        output = f"""🔮 預測結果比較

📝 輸入文字: {text[:100]}{'...' if len(text) > 100 else ''}

{'='*50}

🧬 微調模型 ({model_id})
預測: {result_finetuned}
信心: {probs_finetuned[0][pred_finetuned].item():.2%}
機率分布:
  • 存活: {probs_finetuned[0][0].item():.2%}
  • 死亡: {probs_finetuned[0][1].item():.2%}

{'='*50}

🔬 基準模型（未微調 {config['type']}）
預測: {result_baseline}
信心: {probs_baseline[0][pred_baseline].item():.2%}
機率分布:
  • 存活: {probs_baseline[0][0].item():.2%}
  • 死亡: {probs_baseline[0][1].item():.2%}

{'='*50}

📊 結論
兩模型預測: {agreement}
"""
        
        if pred_finetuned != pred_baseline:
            output += f"\n💡 分析: 微調模型預測為【{result_finetuned}】，而基準模型預測為【{result_baseline}】"
            output += f"\n   這顯示了 fine-tuning 對此案例的影響！"
        
        f1_improve = calculate_improvement(info['baseline']['f1'], info['results']['eval_f1'])
        
        output += f"""

📈 模型表現
微調模型 F1: {info['results']['eval_f1']:.4f}
基準模型 F1: {info['baseline']['f1']:.4f}
改善幅度: {format_improve(f1_improve)}
"""
        
        return output
        
    except Exception as e:
        import traceback
        return f"❌ 錯誤: {str(e)}\n\n{traceback.format_exc()}"

def compare():
    if not trained_models:
        return "❌ 尚未訓練模型"
    
    text = "# 📊 模型比較\n\n"
    text += "## 微調模型表現\n\n"
    text += "| 模型 | 基礎 | 方法 | F1 | Acc | Prec | Recall | Sens | Spec |\n"
    text += "|------|------|------|-----|-----|------|--------|------|------|\n"
    
    for mid, info in trained_models.items():
        r = info['results']
        c = info['config']
        text += f"| {mid} | {c['type']} | {c['method'].upper()} | {r['eval_f1']:.4f} | {r['eval_accuracy']:.4f} | "
        text += f"{r['eval_precision']:.4f} | {r['eval_recall']:.4f} | "
        text += f"{r['eval_sensitivity']:.4f} | {r['eval_specificity']:.4f} |\n"
    
    text += "\n## 基準模型表現（未微調）\n\n"
    text += "| 模型 | F1 | Acc | Prec | Recall | Sens | Spec |\n"
    text += "|------|-----|-----|------|--------|------|------|\n"
    
    for mid, info in trained_models.items():
        b = info['baseline']
        c = info['config']
        text += f"| {c['type']}-baseline | {b['f1']:.4f} | {b['accuracy']:.4f} | "
        text += f"{b['precision']:.4f} | {b['recall']:.4f} | "
        text += f"{b['sensitivity']:.4f} | {b['specificity']:.4f} |\n"
    
    text += "\n## 🏆 最佳模型\n\n"
    for metric in ['f1', 'accuracy', 'precision', 'recall', 'sensitivity', 'specificity']:
        best = max(trained_models.items(), key=lambda x: x[1]['results'][f'eval_{metric}'])
        baseline_val = best[1]['baseline'][metric]
        finetuned_val = best[1]['results'][f'eval_{metric}']
        improvement = calculate_improvement(baseline_val, finetuned_val)
        
        text += f"**{metric.upper()}**: {best[0]} ({finetuned_val:.4f}, 改善 {format_improve(improvement)})\n\n"
    
    return text

def refresh_model_list():
    return gr.Dropdown(choices=list(trained_models.keys()))

# Gradio UI
with gr.Blocks(title="BERT Fine-tuning 教學平台", theme=gr.themes.Soft()) as demo:
    gr.Markdown("# 🧬 BERT Fine-tuning 教學平台")
    gr.Markdown("### 比較基準模型 vs 微調模型的表現差異")
    
    with gr.Tab("訓練"):
        gr.Markdown("## 步驟 1: 選擇基礎模型")
        
        base_model = gr.Dropdown(
            choices=["BERT-base"],
            value="BERT-base",
            label="基礎模型",
            info="更多模型即將推出"
        )
        
        gr.Markdown("## 步驟 2: 選擇微調方法")
        
        method = gr.Radio(
            choices=["lora", "adalora"],
            value="lora",
            label="微調方法",
            info="兩種都是參數高效方法，推薦從 LoRA 開始"
        )
        
        gr.Markdown("## 步驟 3: 上傳資料")
        csv_file = gr.File(label="CSV 檔案 (需包含 Text 和 label 欄位)", file_types=[".csv"])
        
        gr.Markdown("## 步驟 4: 設定訓練參數")
        
        gr.Markdown("### 🎯 基本訓練參數")
        with gr.Row():
            num_epochs = gr.Number(value=3, label="訓練輪數 (epochs)", minimum=1, maximum=100, precision=0)
            batch_size = gr.Number(value=8, label="批次大小 (batch_size)", minimum=1, maximum=128, precision=0)
            learning_rate = gr.Number(value=2e-5, label="學習率 (learning_rate)", minimum=0, maximum=1)
        
        gr.Markdown("### ⚙️ 進階參數")
        with gr.Row():
            weight_decay = gr.Number(value=0.01, label="權重衰減 (weight_decay)", minimum=0, maximum=1)
            dropout = gr.Number(value=0.1, label="Dropout 機率", minimum=0, maximum=1)
        
        gr.Markdown("### 🔧 LoRA 參數")
        with gr.Row():
            lora_r = gr.Number(value=16, label="LoRA Rank (r)", minimum=1, maximum=256, precision=0,
                             info="推薦 8-16，越大效果越好但越慢")
            lora_alpha = gr.Number(value=32, label="LoRA Alpha", minimum=1, maximum=512, precision=0,
                                 info="通常設為 Rank 的 2 倍")
            lora_dropout = gr.Number(value=0.1, label="LoRA Dropout", minimum=0, maximum=1,
                                   info="防止過擬合")
        
        gr.Markdown("### ⚖️ 評估設定")
        with gr.Row():
            weight_mult = gr.Number(value=2.0, label="類別權重倍數", minimum=0, maximum=10,
                                   info="推薦 1.5-2.5，過低會忽略少數類")
            best_metric = gr.Dropdown(
                choices=["f1", "accuracy", "precision", "recall", "sensitivity", "specificity"],
                value="f1",
                label="最佳模型選擇指標",
                info="訓練時用此指標選擇最佳模型"
            )
        
        train_btn = gr.Button("🚀 開始訓練", variant="primary", size="lg")
        
        gr.Markdown("## 📊 訓練結果")
        
        data_info = gr.Textbox(label="📋 資料資訊", lines=10)
        
        with gr.Row():
            baseline_result = gr.Textbox(label="🔬 純 BERT（未微調）", lines=14)
            finetuned_result = gr.Textbox(label="✅ 微調 BERT", lines=14)
        
        comparison_result = gr.Textbox(label="📊 純 BERT vs 微調 BERT 比較", lines=14)
        
        train_btn.click(
            train_bert_model,
            inputs=[csv_file, base_model, method, num_epochs, batch_size, learning_rate,
                   weight_decay, dropout, lora_r, lora_alpha, lora_dropout,
                   weight_mult, best_metric],
            outputs=[data_info, baseline_result, finetuned_result, comparison_result]
        )
    
    with gr.Tab("預測"):
        gr.Markdown("## 使用訓練好的模型預測")
        
        with gr.Row():
            model_drop = gr.Dropdown(label="選擇模型", choices=list(trained_models.keys()))
            refresh = gr.Button("🔄 刷新")
        
        text_input = gr.Textbox(label="輸入病例描述", lines=4,
                               placeholder="Patient diagnosed with...")
        predict_btn = gr.Button("預測", variant="primary", size="lg")
        pred_output = gr.Textbox(label="預測結果（含基準模型對比）", lines=20)
        
        refresh.click(refresh_model_list, outputs=[model_drop])
        predict_btn.click(predict, inputs=[model_drop, text_input], outputs=[pred_output])
        
        gr.Examples(
            examples=[
                ["Patient with stage II breast cancer, good response to treatment."],
                ["Advanced metastatic cancer, multiple organ involvement."]
            ],
            inputs=text_input
        )
    
    with gr.Tab("比較"):
        gr.Markdown("## 比較所有模型（含基準模型）")
        compare_btn = gr.Button("比較", variant="primary", size="lg")
        compare_output = gr.Markdown()
        compare_btn.click(compare, outputs=[compare_output])
    
    with gr.Tab("說明"):
        gr.Markdown("""
        ## 📖 使用說明
        
        ### 🎯 平台特色
        
        本平台會自動比較：
        - **基準模型**：未經微調的原始 BERT
        - **微調模型**：使用你的資料訓練後的 BERT
        
        這樣可以清楚看到 fine-tuning 帶來的改善！
        
        ### 基礎模型
        
        - **BERT-base**: 標準 BERT，110M 參數 ⭐目前支援
        
        ### 微調方法
        
        - **LoRA**: 低秩適應，參數高效的微調方法 ⭐強烈推薦
          - 只訓練少量參數（通常 <1%）
          - 訓練速度快，效果好
          - 適合大多數情況
        
        - **AdaLoRA**: 自適應 LoRA，動態調整秩
          - 自動找出最重要的參數
          - 可能比 LoRA 效果稍好
          - 訓練時間稍長
        
        ### 評估指標
        
        - **F1**: 平衡指標，推薦用於不平衡資料 ⭐
        - **Accuracy**: 整體準確率
        - **Precision**: 減少假陽性
        - **Recall/Sensitivity**: 減少假陰性
        - **Specificity**: 真陰性率
        
        ### 參數建議
        
        針對不平衡資料（如醫療資料）：
        - **微調方法**: LoRA（快速有效）或 AdaLoRA（追求極致）
        - **LoRA Rank**: 8-16（平衡效果與速度）
        - **類別權重倍數**: 1.5-2.5（資料不平衡時）
        - **Learning rate**: 2e-5 到 5e-5
        - **Epochs**: 3-8（避免過擬合）
        - **Batch size**: 8-16（依 GPU 記憶體調整）
        
        ### 資料格式
        
        CSV 必須包含:
        - `Text`: 病例描述
        - `label`: 0=存活, 1=死亡
        
        ### 🚀 快速開始
        
        1. 上傳包含 `Text` 和 `label` 欄位的 CSV
        2. 使用預設參數（適合大多數情況）
        3. 點擊「開始訓練」
        4. 在「預測」分頁測試模型
        5. 在「比較」分頁查看所有模型表現
        """)

if __name__ == "__main__":
    demo.launch()