Update app.py

app.py

@@ -8,8 +8,15 @@ from sklearn.metrics import accuracy_score, precision_recall_fscore_support, con
 from torch import nn
 import os
 from datetime import datetime
+import gc
 
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:512"
+
+# 設置較小的預設值以節省記憶體
+torch.backends.cudnn.benchmark = False
+if torch.cuda.is_available():
+    torch.cuda.empty_cache()
 
 # 全域變數
 trained_models = {}
@@ -57,16 +64,71 @@ def compute_metrics(pred):
             'sensitivity': 0, 'specificity': 0, 'tp': 0, 'tn': 0, 'fp': 0, 'fn': 0
         }
 
+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)
+    }
+
 class WeightedTrainer(Trainer):
-    def __init__(self, *args, class_weights=None, **kwargs):
+    def __init__(self, *args, class_weights=None, use_focal_loss=False, **kwargs):
         super().__init__(*args, **kwargs)
         self.class_weights = class_weights
+        self.use_focal_loss = use_focal_loss
     
     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))
+        logits = outputs.logits
+        
+        if self.use_focal_loss:
+            # Focal Loss: 更關注難分類的樣本
+            ce_loss = nn.CrossEntropyLoss(weight=self.class_weights, reduction='none')(
+                logits.view(-1, 2), labels.view(-1)
+            )
+            pt = torch.exp(-ce_loss)
+            focal_loss = ((1 - pt) ** 2 * ce_loss).mean()
+            loss = focal_loss
+        else:
+            loss_fct = nn.CrossEntropyLoss(weight=self.class_weights)
+            loss = loss_fct(logits.view(-1, 2), labels.view(-1))
+        
         return (loss, outputs) if return_outputs else loss
 
 def evaluate_baseline(model, tokenizer, test_dataset, device):
@@ -141,9 +203,14 @@ def train_bert_model(csv_file, base_model, method, num_epochs, batch_size, learn
             return "❌ 無死亡樣本", "", "", ""
         
         ratio = n0 / n1
-        w0, w1 = 1.0, ratio * weight_mult
+        # 動態調整權重計算
+        if ratio > 10:  # 極度不平衡
+            w0, w1 = 1.0, min(ratio * weight_mult, ratio * 0.7)  # 限制最大權重
+        else:
+            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()}"
+        info = f"📊 資料: {len(df_clean)} 筆\n存活: {n0} | 死亡: {n1}\n比例: {ratio:.2f}:1\n"
+        info += f"⚖️ 權重: {w0:.2f} / {w1:.2f}\n模型: {base_model}\n方法: {method.upper()}"
         
         tokenizer = BertTokenizer.from_pretrained(model_name)
         dataset = Dataset.from_pandas(df_clean[['text', 'label']])
@@ -157,8 +224,7 @@ def train_bert_model(csv_file, base_model, method, num_epochs, batch_size, learn
         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)
         
@@ -166,12 +232,11 @@ def train_bert_model(csv_file, base_model, method, num_epochs, batch_size, learn
         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
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        gc.collect()
         
         # 開始微調
         info += f"\n\n🔧 套用 {method.upper()} 微調..."
@@ -226,12 +291,12 @@ def train_bert_model(csv_file, base_model, method, num_epochs, batch_size, learn
             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,
+            save_strategy="no",  # 🔧 改為不保存，避免 PEFT 載入問題
+            load_best_model_at_end=False,  # 🔧 關閉，直接用最後一個 epoch
             report_to="none", 
-            logging_steps=50,
-            save_total_limit=2
+            logging_steps=10,
+            warmup_steps=50,
+            logging_first_step=True
         )
         
         trainer = WeightedTrainer(
@@ -240,11 +305,27 @@ def train_bert_model(csv_file, base_model, method, num_epochs, batch_size, learn
             train_dataset=split['train'],
             eval_dataset=split['test'], 
             compute_metrics=compute_metrics,
-            class_weights=weights
+            class_weights=weights,
+            use_focal_loss=(ratio > 10)  # 極度不平衡時使用 Focal Loss
         )
         
+        if ratio > 10:
+            info += "\n\n⚡ 使用 Focal Loss 處理極度不平衡資料"
+        
         info += "\n\n⏳ 開始訓練..."
-        trainer.train()
+        
+        # 訓練前檢查
+        info += f"\n📊 訓練前檢查："
+        info += f"\n  - 訓練樣本: {len(split['train'])}"
+        info += f"\n  - 測試樣本: {len(split['test'])}"
+        info += f"\n  - 批次數/epoch: {len(split['train']) // int(batch_size)}"
+        
+        train_result = trainer.train()
+        
+        # 訓練後資訊
+        info += f"\n\n✅ 訓練完成！"
+        info += f"\n📉 最終 Training Loss: {train_result.training_loss:.4f}"
+        
         results = trainer.evaluate()
         
         # 生成帶時間戳的模型 ID
@@ -255,7 +336,7 @@ def train_bert_model(csv_file, base_model, method, num_epochs, batch_size, learn
             'model': model, 
             'tokenizer': tokenizer, 
             'results': results,
-            'baseline': baseline_perf,
+            'baseline': baseline_perf,  # 保存基準結果供後續使用
             'config': {
                 'type': base_model, 
                 'model_name': model_name, 
@@ -275,7 +356,7 @@ def train_bert_model(csv_file, base_model, method, num_epochs, batch_size, learn
         
         # 純 BERT 輸出
         baseline_output = f"🔬 純 BERT（未微調）\n\n"
-        baseline_output += f"📈 表現\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"
@@ -287,8 +368,9 @@ def train_bert_model(csv_file, base_model, method, num_epochs, batch_size, learn
         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"✅ 微調 BERT\n"
+        finetuned_output += f"模型: {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"
@@ -489,9 +571,12 @@ with gr.Blocks(title="BERT Fine-tuning 教學平台", theme=gr.themes.Soft()) as
         
         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)
+            num_epochs = gr.Number(value=5, label="訓練輪數 (epochs)", minimum=1, maximum=100, precision=0,
+                                  info="建議 5-8 輪")
+            batch_size = gr.Number(value=4, label="批次大小 (batch_size)", minimum=1, maximum=128, precision=0,
+                                  info="記憶體不足時降到 4")
+            learning_rate = gr.Number(value=5e-5, label="學習率 (learning_rate)", minimum=0, maximum=1, format=".0e",
+                                     info="5e-5 是平衡選擇")
         
         gr.Markdown("### ⚙️ 進階參數")
         with gr.Row():
@@ -500,17 +585,17 @@ with gr.Blocks(title="BERT Fine-tuning 教學平台", theme=gr.themes.Soft()) as
         
         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="防止過擬合")
+            lora_r = gr.Number(value=32, label="LoRA Rank (r)", minimum=1, maximum=256, precision=0,
+                             info="提高到 32，增加表達能力")
+            lora_alpha = gr.Number(value=64, label="LoRA Alpha", minimum=1, maximum=512, precision=0,
+                                 info="Alpha = Rank × 2")
+            lora_dropout = gr.Number(value=0.05, label="LoRA Dropout", minimum=0, maximum=1,
+                                   info="降低 dropout，避免欠擬合")
         
         gr.Markdown("### ⚖️ 評估設定")
         with gr.Row():
-            weight_mult = gr.Number(value=2.0, label="類別權重倍數", minimum=0, maximum=10,
-                                   info="推薦 1.5-2.5，過低會忽略少數類")
+            weight_mult = gr.Number(value=1.0, label="類別權重倍數", minimum=0, maximum=5,
+                                   info="⚠️ 資料極度不平衡時建議 0.5-1.5，不要超過 2.0")
             best_metric = gr.Dropdown(
                 choices=["f1", "accuracy", "precision", "recall", "sensitivity", "specificity"],
                 value="f1",
@@ -608,9 +693,12 @@ with gr.Blocks(title="BERT Fine-tuning 教學平台", theme=gr.themes.Soft()) as
         針對不平衡資料（如醫療資料）：
         - **微調方法**: LoRA（快速有效）或 AdaLoRA（追求極致）
         - **LoRA Rank**: 8-16（平衡效果與速度）
-        - **類別權重倍數**: 1.5-2.5（資料不平衡時）
-        - **Learning rate**: 2e-5 到 5e-5
-        - **Epochs**: 3-8（避免過擬合）
+        - **類別權重倍數**: 
+          - ⚠️ **極度不平衡 (>10:1)**: 0.5-1.0（你的情況！）
+          - 中度不平衡 (3-10:1): 1.0-1.5
+          - 輕度不平衡 (<3:1): 1.5-2.5
+        - **Learning rate**: 3e-5 到 5e-5（較高的學習率配合 LoRA）
+        - **Epochs**: 5-10（極度不平衡需要更多輪）
         - **Batch size**: 8-16（依 GPU 記憶體調整）
         
         ### 資料格式
@@ -629,4 +717,9 @@ with gr.Blocks(title="BERT Fine-tuning 教學平台", theme=gr.themes.Soft()) as
         """)
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        max_threads=4  # 限制執行緒數
+    )