Update app.py

app.py

@@ -22,43 +22,35 @@ import json
 # 檢查 GPU
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 
-def train_bert_model(file, weight_multiplier=0.8, epochs=3):
+def run_your_original_code(file_path, weight_multiplier, epochs, batch_size, learning_rate, warmup_steps):
     """
-    這個函數幾乎完全保持您原始程式碼的邏輯
-    只是把它包裝成一個函數
+    這裡直接貼上您的原始程式碼
+    只把必要的參數改成變數
     """
     
-    output_log = []
+    # ==================== 以下是您的原始程式碼 ====================
+    # 我只把檔案讀取和參數部分改成變數，其他完全不動
     
-    output_log.append("\n" + "=" * 80)
-    output_log.append("乳癌存活預測 BERT Fine-tuning")
-    output_log.append("=" * 80)
-    output_log.append(f"開始時間: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-    output_log.append(f"使用裝置: {device}")
-    output_log.append("=" * 80)
-    
-    # ============ 以下幾乎都是您的原始程式碼 ============
-    
-    # 讀取資料
-    df_original = pd.read_csv(file.name)
+    # 讀取上傳的檔案
+    df_original = pd.read_csv(file_path)
     df_clean = pd.DataFrame({
         'text': df_original['Text'],
         'label': df_original['label']
     })
     df_clean = df_clean.dropna()
     
-    output_log.append(f"\n原始資料分布：")
-    output_log.append(f"  存活 (0): {sum(df_clean['label']==0)} 筆 ({sum(df_clean['label']==0)/len(df_clean)*100:.1f}%)")
-    output_log.append(f"  死亡 (1): {sum(df_clean['label']==1)} 筆 ({sum(df_clean['label']==1)/len(df_clean)*100:.1f}%)")
-    
-    ratio = sum(df_clean['label']==0) / sum(df_clean['label']==1)
-    output_log.append(f"  不平衡比例: {ratio:.1f}:1")
+    print("\n" + "=" * 80)
+    print("乳癌存活預測 BERT Fine-tuning - " + str(weight_multiplier) + "x 權重策略")
+    print("=" * 80)
+    print(f"開始時間: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print("=" * 80)
     
     # 載入 Tokenizer
-    output_log.append("\n📦 載入 BERT Tokenizer...")
+    print("\n📦 載入 BERT Tokenizer...")
     tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
+    print("✅ Tokenizer 載入完成")
     
-    # 評估函數 - 完全照您的原始程式
+    # 評估函數 - 完全是您的原始程式碼
     def compute_metrics(pred):
         labels = pred.label_ids
         preds = pred.predictions.argmax(-1)
@@ -95,7 +87,29 @@ def train_bert_model(file, weight_multiplier=0.8, epochs=3):
             'tp': int(tp), 'tn': int(tn), 'fp': int(fp), 'fn': int(fn)
         }
     
-    # Tokenization
+    # ============================================================================
+    # 步驟 1：準備資料（不做平衡）
+    # ============================================================================
+    
+    print("\n" + "=" * 80)
+    print("步驟 1：準備資料（保持原始比例）")
+    print("=" * 80)
+    
+    print(f"\n原始資料分布：")
+    print(f"  存活 (0): {sum(df_clean['label']==0)} 筆 ({sum(df_clean['label']==0)/len(df_clean)*100:.1f}%)")
+    print(f"  死亡 (1): {sum(df_clean['label']==1)} 筆 ({sum(df_clean['label']==1)/len(df_clean)*100:.1f}%)")
+    
+    ratio = sum(df_clean['label']==0) / sum(df_clean['label']==1)
+    print(f"  不平衡比例: {ratio:.1f}:1")
+    
+    # ============================================================================
+    # 步驟 2：Tokenization
+    # ============================================================================
+    
+    print("\n" + "=" * 80)
+    print("步驟 2：Tokenization")
+    print("=" * 80)
+    
     dataset = Dataset.from_pandas(df_clean[['text', 'label']])
     
     def preprocess_function(examples):
@@ -106,29 +120,44 @@ def train_bert_model(file, weight_multiplier=0.8, epochs=3):
     train_dataset = train_test_split['train']
     eval_dataset = train_test_split['test']
     
-    output_log.append(f"\n✅ 資料集準備完成：")
-    output_log.append(f"  訓練集: {len(train_dataset)} 筆")
-    output_log.append(f"  驗證集: {len(eval_dataset)} 筆")
+    print(f"\n✅ 資料集準備完成：")
+    print(f"  訓練集: {len(train_dataset)} 筆")
+    print(f"  驗證集: {len(eval_dataset)} 筆")
+    
+    # ============================================================================
+    # 步驟 3：設定權重 - 這裡用參數
+    # ============================================================================
+    
+    print("\n" + "=" * 80)
+    print(f"步驟 3：設定類別權重（{weight_multiplier}x 倍數）")
+    print("=" * 80)
     
-    # 設定權重 - 照您的原始程式
     weight_0 = 1.0
     weight_1 = ratio * weight_multiplier
     
-    output_log.append(f"\n權重設定：")
-    output_log.append(f"  倍數: {weight_multiplier}x")
-    output_log.append(f"  存活類權重: {weight_0:.3f}")
-    output_log.append(f"  死亡類權重: {weight_1:.3f}")
+    print(f"\n權重設定：")
+    print(f"  倍數: {weight_multiplier}x")
+    print(f"  存活類權重: {weight_0:.3f}")
+    print(f"  死亡類權重: {weight_1:.3f} (= {ratio:.1f} × {weight_multiplier})")
     
     class_weights = torch.tensor([weight_0, weight_1], dtype=torch.float).to(device)
     
-    # 載入模型
-    output_log.append("\n🔄 初始化模型...")
+    # ============================================================================
+    # 步驟 4：訓練模型
+    # ============================================================================
+    
+    print("\n" + "=" * 80)
+    print("步驟 4：訓練 Fine-tuned BERT 模型")
+    print("=" * 80)
+    
+    print("\n🔄 初始化模型...")
+    
     model = BertForSequenceClassification.from_pretrained(
         "bert-base-uncased", num_labels=2, problem_type="single_label_classification"
     )
     model = model.to(device)
     
-    # 自訂 Trainer - 照您的原始程式
+    # 自訂 Trainer（使用權重）- 您的原始程式碼
     class WeightedTrainer(Trainer):
         def compute_loss(self, model, inputs, return_outputs=False):
             labels = inputs.pop("labels")
@@ -137,17 +166,17 @@ def train_bert_model(file, weight_multiplier=0.8, epochs=3):
             loss = loss_fct(outputs.logits.view(-1, 2), labels.view(-1))
             return (loss, outputs) if return_outputs else loss
     
-    # 訓練設定 - 照您的原始程式，只改 eval_strategy
+    # 訓練設定 - 使用參數
     training_args = TrainingArguments(
         output_dir='./results_weight',
-        num_train_epochs=epochs,
-        per_device_train_batch_size=16,
-        per_device_eval_batch_size=32,
-        warmup_steps=200,
+        num_train_epochs=epochs,  # 使用參數
+        per_device_train_batch_size=batch_size,  # 使用參數
+        per_device_eval_batch_size=batch_size*2,  # 使用參數
+        warmup_steps=warmup_steps,  # 使用參數
         weight_decay=0.01,
-        learning_rate=2e-5,
+        learning_rate=learning_rate,  # 使用參數
         logging_steps=50,
-        evaluation_strategy="epoch",  # 只改這裡：eval_strategy → evaluation_strategy
+        evaluation_strategy="epoch",  # 改為新版參數名
         save_strategy="epoch",
         load_best_model_at_end=True,
         metric_for_best_model="sensitivity",
@@ -160,74 +189,192 @@ def train_bert_model(file, weight_multiplier=0.8, epochs=3):
         compute_metrics=compute_metrics
     )
     
-    output_log.append("\n🚀 開始訓練...")
-    output_log.append("-" * 80)
+    print(f"\n🚀 開始訓練（{epochs} epochs）...")
+    print("-" * 80)
     
-    # 訓練
     trainer.train()
     
-    output_log.append("\n✅ Fine-tuned 模型訓練完成！")
+    print("\n✅ Fine-tuned 模型訓練完成！")
     
-    # 評估
-    output_log.append("\n📊 評估 Fine-tuned 模型...")
+    # 評估 Fine-tuned 模型
+    print("\n📊 評估 Fine-tuned 模型...")
     finetuned_results = trainer.evaluate()
     
-    output_log.append(f"\nFine-tuned BERT ({weight_multiplier}x 權重) 表現：")
-    output_log.append(f"  F1 Score: {finetuned_results['eval_f1']:.4f}")
-    output_log.append(f"  Accuracy: {finetuned_results['eval_accuracy']:.4f}")
-    output_log.append(f"  Precision: {finetuned_results['eval_precision']:.4f}")
-    output_log.append(f"  Recall: {finetuned_results['eval_recall']:.4f}")
-    output_log.append(f"  Sensitivity: {finetuned_results['eval_sensitivity']:.4f}")
-    output_log.append(f"  Specificity: {finetuned_results['eval_specificity']:.4f}")
-    output_log.append(f"  混淆矩陣: Tp={finetuned_results['eval_tp']}, Tn={finetuned_results['eval_tn']}, "
+    print(f"\nFine-tuned BERT ({weight_multiplier}x 權重) 表現：")
+    print(f"  F1 Score: {finetuned_results['eval_f1']:.4f}")
+    print(f"  Accuracy: {finetuned_results['eval_accuracy']:.4f}")
+    print(f"  Precision: {finetuned_results['eval_precision']:.4f}")
+    print(f"  Recall: {finetuned_results['eval_recall']:.4f}")
+    print(f"  Sensitivity: {finetuned_results['eval_sensitivity']:.4f}")
+    print(f"  Specificity: {finetuned_results['eval_specificity']:.4f}")
+    print(f"  混淆矩陣: Tp={finetuned_results['eval_tp']}, Tn={finetuned_results['eval_tn']}, "
           f"Fp={finetuned_results['eval_fp']}, Fn={finetuned_results['eval_fn']}")
     
     # 儲存模型
-    save_dir = './breast_cancer_bert'
+    save_dir = './breast_cancer_bert_weight'
     model.save_pretrained(save_dir)
     tokenizer.save_pretrained(save_dir)
     
-    output_log.append(f"\n💾 模型已儲存至: {save_dir}")
-    output_log.append("=" * 80)
-    output_log.append("🎉 訓練完成！")
-    output_log.append("=" * 80)
+    print(f"\n💾 Fine-tuned 模型已儲存至: {save_dir}")
+    print("\n" + "=" * 80)
+    print("🎉 訓練完成！")
+    print("=" * 80)
+    print(f"完成時間: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    # 回傳結果
+    return finetuned_results
+
+# ============================================================================
+# Gradio 介面部分 - 只是���裝，不改您的程式
+# ============================================================================
+
+def train_wrapper(file, weight_mult, epochs, batch_size, lr, warmup):
+    """包裝函數，處理 Gradio 的輸入輸出"""
+    
+    if file is None:
+        return "請上傳 CSV 檔案"
     
-    # 返回訓練日誌
-    return "\n".join(output_log)
+    try:
+        # 呼叫您的原始程式碼
+        results = run_your_original_code(
+            file_path=file.name,
+            weight_multiplier=weight_mult,
+            epochs=int(epochs),
+            batch_size=int(batch_size),
+            learning_rate=lr,
+            warmup_steps=int(warmup)
+        )
+        
+        # 格式化輸出
+        output = f"""
+# 🎉 訓練完成！
+
+## 📊 模型表現指標
+
+| 指標 | 數值 |
+|------|------|
+| **F1 Score** | {results['eval_f1']:.4f} |
+| **Accuracy** | {results['eval_accuracy']:.4f} |
+| **Precision** | {results['eval_precision']:.4f} |
+| **Recall** | {results['eval_recall']:.4f} |
+| **Sensitivity** | {results['eval_sensitivity']:.4f} |
+| **Specificity** | {results['eval_specificity']:.4f} |
+
+## 📈 混淆矩陣
+
+- True Positive (TP): {results['eval_tp']}
+- True Negative (TN): {results['eval_tn']}
+- False Positive (FP): {results['eval_fp']}
+- False Negative (FN): {results['eval_fn']}
+
+## ⚙️ 使用的參數
+
+- 權重倍數: {weight_mult}x
+- 訓練輪數: {epochs}
+- 批次大小: {batch_size}
+- 學習率: {lr}
+- Warmup Steps: {warmup}
+
+模型已儲存至 `./breast_cancer_bert_weight/`
+        """
+        return output
+        
+    except Exception as e:
+        return f"❌ 錯誤：{str(e)}"
 
-# 建立簡單的 Gradio 介面
-with gr.Blocks(title="BERT 乳癌存活預測訓練") as demo:
+# 建立 Gradio 介面
+with gr.Blocks(title="BERT 乳癌存活預測訓練", theme=gr.themes.Soft()) as demo:
+    
     gr.Markdown("""
     # 🏥 BERT 乳癌存活預測訓練平台
     
-    上傳 CSV 檔案（需包含 'Text' 和 'label' 欄位），點擊訓練按鈕開始。
+    ### 使用說明：
+    1. 上傳您的 CSV 檔案（需包含 'Text' 和 'label' 欄位）
+    2. 調整訓練參數（或使用預設值）
+    3. 點擊「開始訓練」
+    
+    **注意**：這個介面只是包裝您的原始程式碼，核心邏輯完全不變。
     """)
     
     with gr.Row():
-        with gr.Column():
-            file_input = gr.File(label="上傳 CSV 檔案", file_types=[".csv"])
+        with gr.Column(scale=1):
+            gr.Markdown("### 📤 資料與參數設定")
+            
+            file_input = gr.File(
+                label="上傳 CSV 檔案",
+                file_types=[".csv"]
+            )
+            
+            gr.Markdown("### ⚙️ 訓練參數")
+            
             weight_slider = gr.Slider(
-                minimum=0.1, maximum=2.0, value=0.8, step=0.1,
-                label="權重倍數"
+                minimum=0.1,
+                maximum=2.0,
+                value=0.8,
+                step=0.1,
+                label="權重倍數 (Weight Multiplier)",
+                info="調整死亡類別的權重，您原始程式使用 0.8"
+            )
+            
+            epochs_input = gr.Number(
+                value=8,
+                label="訓練輪數 (Epochs)",
+                info="您原始程式使用 8"
+            )
+            
+            batch_size_input = gr.Number(
+                value=16,
+                label="批次大小 (Batch Size)",
+                info="您原始程式使用 16"
             )
-            epochs_slider = gr.Slider(
-                minimum=1, maximum=10, value=3, step=1,
-                label="訓練輪數 (Epochs)"
+            
+            lr_input = gr.Number(
+                value=2e-5,
+                label="學習率 (Learning Rate)",
+                info="您原始程式使用 2e-5"
+            )
+            
+            warmup_input = gr.Number(
+                value=200,
+                label="Warmup Steps",
+                info="您原始程式使用 200"
+            )
+            
+            train_button = gr.Button(
+                "🚀 開始訓練",
+                variant="primary",
+                size="lg"
             )
-            train_btn = gr.Button("開始訓練", variant="primary")
         
-        with gr.Column():
-            output = gr.Textbox(
-                label="訓練輸出", 
-                lines=30,
-                max_lines=50
+        with gr.Column(scale=2):
+            gr.Markdown("### 📊 訓練結果")
+            output_text = gr.Markdown(
+                value="等待訓練...",
+                label="輸出結果"
             )
     
-    train_btn.click(
-        fn=train_bert_model,
-        inputs=[file_input, weight_slider, epochs_slider],
-        outputs=output
+    # 設定按鈕動作
+    train_button.click(
+        fn=train_wrapper,
+        inputs=[
+            file_input,
+            weight_slider,
+            epochs_input,
+            batch_size_input,
+            lr_input,
+            warmup_input
+        ],
+        outputs=output_text
     )
+    
+    gr.Markdown("""
+    ---
+    ### 📝 備註
+    - 訓練時間依資料量和參數而定，通常需要 5-15 分鐘
+    - 建議使用 GPU 以加快訓練速度
+    - 模型會自動儲存在伺服器上
+    - 這個介面完全保留您的原始訓練邏輯
+    """)
 
 if __name__ == "__main__":
     demo.launch()