import gradio as gr import pandas as pd import torch from torch import nn from transformers import ( BertTokenizer, BertForSequenceClassification, TrainingArguments, Trainer ) from datasets import Dataset from sklearn.metrics import ( accuracy_score, precision_recall_fscore_support, roc_auc_score, confusion_matrix ) import numpy as np from datetime import datetime import json import os import gc import random # ==================== 🎲 隨機種子設定 ==================== RANDOM_SEED = 42 def set_seed(seed=42): """ ⭐ 設定所有隨機種子以確保結果完全可重現 ⭐ """ print(f"\n{'='*70}") print(f"🎲 設定隨機種子: {seed}") print(f"{'='*70}") random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) torch.cuda.manual_seed(seed) torch.cuda.manual_seed_all(seed) torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False os.environ['PYTHONHASHSEED'] = str(seed) os.environ['CUBLAS_WORKSPACE_CONFIG'] = ':4096:8' try: torch.use_deterministic_algorithms(True) except: pass print(f"✅ 隨機種子設定完成 - 結果應該完全可重現") print(f" - Python random seed: {seed}") print(f" - NumPy seed: {seed}") print(f" - PyTorch seed: {seed}") print(f" - CUDA deterministic mode: ON") print(f"{'='*70}\n") # 程式啟動時立即設定種子 set_seed(RANDOM_SEED) # PEFT 相關的 import(LoRA 和 AdaLoRA) try: from peft import ( LoraConfig, AdaLoraConfig, get_peft_model, TaskType, PeftModel ) PEFT_AVAILABLE = True except ImportError: PEFT_AVAILABLE = False print("⚠️ PEFT 未安裝,LoRA 和 AdaLoRA 功能將不可用") # 檢查 GPU device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') _MODEL_PATH = None LAST_TOKENIZER = None LAST_TUNING_METHOD = None # ==================== 您的原始函數 - 完全不動 ==================== def evaluate_baseline_bert(eval_dataset, df_clean): """ 評估原始 BERT(完全沒看過資料)的表現 這部分是從您的格子 5 提取的 baseline 比較邏輯 """ print("\n" + "=" * 80) print("評估 Baseline 純 BERT(完全沒看過資料)") print("=" * 80) # 載入純 BERT baseline_tokenizer = BertTokenizer.from_pretrained("bert-base-uncased") baseline_model = BertForSequenceClassification.from_pretrained( "bert-base-uncased", num_labels=2 ).to(device) baseline_model.eval() print(" ⚠️ 這個模型完全沒有使用您的資料訓練") # 重新處理驗證集 baseline_dataset = Dataset.from_pandas(df_clean[['text', 'label']]) def baseline_preprocess(examples): return baseline_tokenizer(examples['text'], truncation=True, padding='max_length', max_length=256) baseline_tokenized = baseline_dataset.map(baseline_preprocess, batched=True) baseline_split = baseline_tokenized.train_test_split(test_size=0.2, seed=42) baseline_eval_dataset = baseline_split['test'] # 建立 Baseline Trainer baseline_trainer_args = TrainingArguments( output_dir='./temp_baseline', per_device_eval_batch_size=32, report_to="none" ) baseline_trainer = Trainer( model=baseline_model, args=baseline_trainer_args, ) # 評估 Baseline print("📄 評估純 BERT...") predictions_output = baseline_trainer.predict(baseline_eval_dataset) all_preds = predictions_output.predictions.argmax(-1) all_labels = predictions_output.label_ids probs = torch.nn.functional.softmax(torch.tensor(predictions_output.predictions), dim=-1)[:, 1].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) try: auc = roc_auc_score(all_labels, probs) except: auc = 0.0 cm = confusion_matrix(all_labels, all_preds) if cm.shape == (2, 2): tn, fp, fn, tp = cm.ravel() sensitivity = tp / (tp + fn) if (tp + fn) > 0 else 0 specificity = tn / (tn + fp) if (tn + fp) > 0 else 0 else: sensitivity = specificity = 0 tn = fp = fn = tp = 0 baseline_results = { 'f1': float(f1), 'accuracy': float(acc), 'precision': float(precision), 'recall': float(recall), 'sensitivity': float(sensitivity), 'specificity': float(specificity), 'auc': float(auc), 'tp': int(tp), 'tn': int(tn), 'fp': int(fp), 'fn': int(fn) } print("✅ Baseline 評估完成") # 清理 del baseline_model del baseline_trainer torch.cuda.empty_cache() gc.collect() return baseline_results def run_original_code_with_tuning( file_path, weight_multiplier, epochs, batch_size, learning_rate, warmup_steps, tuning_method, best_metric, # LoRA 參數 lora_r, lora_alpha, lora_dropout, lora_modules, # AdaLoRA 參數 adalora_init_r, adalora_target_r, adalora_tinit, adalora_tfinal, adalora_delta_t, # 新增:是否為二次微調 is_second_finetuning=False, base_model_path=None ): """ 您的原始程式碼 + 不同微調方法的選項 + Baseline 比較 核心邏輯完全不變,只是在模型初始化部分加入條件判斷 新增參數: - is_second_finetuning: 是否為二次微調 - base_model_path: 第一次微調模型的路徑(僅二次微調時使用) """ # ⭐⭐⭐ 訓練前重新設定隨機種子以確保可重現性 ⭐⭐⭐ print("\n" + "="*80) print("🔄 訓練前重新確認隨機種子...") print("="*80) set_seed(RANDOM_SEED) global LAST_MODEL_PATH, LAST_TOKENIZER, LAST_TUNING_METHOD # ==================== 清空記憶體(訓練前) ==================== torch.cuda.empty_cache() gc.collect() print("🧹 記憶體已清空") # ==================== 您的原始程式碼開始 ==================== # 讀取上傳的檔案 df_original = pd.read_csv(file_path) df_clean = pd.DataFrame({ 'text': df_original['Text'], 'label': df_original['label'] }) df_clean = df_clean.dropna() training_type = "二次微調" if is_second_finetuning else "第一次微調" print("\n" + "=" * 80) print(f"乳癌存活預測 BERT {training_type} - {tuning_method} 方法") print("=" * 80) print(f"開始時間: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}") print(f"訓練類型: {training_type}") print(f"微調方法: {tuning_method}") print(f"最佳化指標: {best_metric}") if is_second_finetuning: print(f"基礎模型: {base_model_path}") print("=" * 80) # 載入 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) probs = torch.nn.functional.softmax(torch.tensor(pred.predictions), dim=-1)[:, 1].numpy() precision, recall, f1, _ = precision_recall_fscore_support( labels, preds, average='binary', pos_label=1, zero_division=0 ) acc = accuracy_score(labels, preds) try: auc = roc_auc_score(labels, probs) except: auc = 0.0 cm = confusion_matrix(labels, preds) if cm.shape == (2, 2): tn, fp, fn, tp = cm.ravel() else: if len(np.unique(preds)) == 1: if preds[0] == 0: tn, fp, fn, tp = sum(labels == 0), 0, sum(labels == 1), 0 else: tn, fp, fn, tp = 0, sum(labels == 0), 0, sum(labels == 1) 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, 'auc': auc, 'sensitivity': sensitivity, 'specificity': specificity, 'tp': int(tp), 'tn': int(tn), 'fp': int(fp), 'fn': int(fn) } # ============================================================================ # 步驟 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): return tokenizer(examples['text'], truncation=True, padding='max_length', max_length=256) tokenized_dataset = dataset.map(preprocess_function, batched=True) train_test_split = tokenized_dataset.train_test_split(test_size=0.2, seed=42) train_dataset = train_test_split['train'] eval_dataset = train_test_split['test'] 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 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) # ============================================================================ # 步驟 4:訓練模型 - 這裡加入二次微調的邏輯 # ============================================================================ print("\n" + "=" * 80) print(f"步驟 4:訓練 {tuning_method} BERT 模型 ({training_type})") print("=" * 80) print(f"\n🔄 初始化模型 ({tuning_method})...") # 【新增】二次微調:載入第一次微調的模型 if is_second_finetuning and base_model_path: print(f"📦 載入第一次微調模型: {base_model_path}") # 讀取第一次模型資訊 with open('./saved_models_list.json', 'r') as f: models_list = json.load(f) base_model_info = None for model_info in models_list: if model_info['model_path'] == base_model_path: base_model_info = model_info break if base_model_info is None: raise ValueError(f"找不到基礎模型資訊: {base_model_path}") base_tuning_method = base_model_info['tuning_method'] print(f" 第一次微調方法: {base_tuning_method}") # 根據第一次的方法載入模型 if base_tuning_method in ["LoRA", "AdaLoRA"] and PEFT_AVAILABLE: # 載入 PEFT 模型 base_bert = BertForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=2) model = PeftModel.from_pretrained(base_bert, base_model_path) print(f" ✅ 已載入 {base_tuning_method} 模型") else: # 載入一般模型 model = BertForSequenceClassification.from_pretrained(base_model_path, num_labels=2) print(f" ✅ 已載入 Full Fine-tuning 模型") model = model.to(device) print(f" ⚠️ 注意:二次微調將使用與第一次相同的方法 ({base_tuning_method})") # 二次微調時強制使用相同方法 tuning_method = base_tuning_method else: # 【原始邏輯】第一次微調:從純 BERT 開始 model = BertForSequenceClassification.from_pretrained( "bert-base-uncased", num_labels=2, problem_type="single_label_classification" ) # 根據選擇的微調方法設定模型 if tuning_method == "Full Fine-tuning": # 您的原始方法 - 完全不動 model = model.to(device) print("✅ 使用完整 Fine-tuning(所有參數可訓練)") trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad) all_params = sum(p.numel() for p in model.parameters()) print(f" 可訓練參數: {trainable_params:,} / {all_params:,} ({100 * trainable_params / all_params:.2f}%)") elif tuning_method == "LoRA" and PEFT_AVAILABLE: # LoRA 設定 target_modules = lora_modules.split(",") if lora_modules else ["query", "value"] target_modules = [m.strip() for m in target_modules] peft_config = LoraConfig( task_type=TaskType.SEQ_CLS, r=int(lora_r), lora_alpha=int(lora_alpha), lora_dropout=float(lora_dropout), target_modules=target_modules ) model = get_peft_model(model, peft_config) model = model.to(device) print("✅ 使用 LoRA 微調") print(f" LoRA rank (r): {lora_r}") print(f" LoRA alpha: {lora_alpha}") print(f" LoRA dropout: {lora_dropout}") print(f" 目標模組: {target_modules}") model.print_trainable_parameters() elif tuning_method == "AdaLoRA" and PEFT_AVAILABLE: # AdaLoRA 設定 target_modules = lora_modules.split(",") if lora_modules else ["query", "value"] target_modules = [m.strip() for m in target_modules] peft_config = AdaLoraConfig( task_type=TaskType.SEQ_CLS, init_r=int(adalora_init_r), target_r=int(adalora_target_r), tinit=int(adalora_tinit), tfinal=int(adalora_tfinal), deltaT=int(adalora_delta_t), lora_alpha=int(lora_alpha), lora_dropout=float(lora_dropout), target_modules=target_modules ) model = get_peft_model(model, peft_config) model = model.to(device) print("✅ 使用 AdaLoRA 微調") print(f" 初始 rank: {adalora_init_r}") print(f" 目標 rank: {adalora_target_r}") print(f" Tinit: {adalora_tinit}, Tfinal: {adalora_tfinal}, DeltaT: {adalora_delta_t}") model.print_trainable_parameters() else: # 預設使用 Full Fine-tuning model = model.to(device) print("⚠️ PEFT 未安裝或方法無效,使用 Full Fine-tuning") # 自訂 Trainer(使用權重) - 您的原始程式碼 class WeightedTrainer(Trainer): def compute_loss(self, model, inputs, return_outputs=False): labels = inputs.pop("labels") outputs = model(**inputs) loss_fct = nn.CrossEntropyLoss(weight=class_weights) loss = loss_fct(outputs.logits.view(-1, 2), labels.view(-1)) return (loss, outputs) if return_outputs else loss # 訓練設定 - 根據選擇的最佳指標調整 metric_map = { "f1": "f1", "accuracy": "accuracy", "precision": "precision", "recall": "recall", "sensitivity": "sensitivity", "specificity": "specificity", "auc": "auc" } training_args = TrainingArguments( output_dir='./results_weight', 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=learning_rate, logging_steps=50, evaluation_strategy="epoch", save_strategy="epoch", load_best_model_at_end=True, metric_for_best_model=metric_map.get(best_metric, "f1"), report_to="none", greater_is_better=True, seed=RANDOM_SEED, # ⭐ 加入隨機種子 data_seed=RANDOM_SEED, # ⭐ 資料載入種子 dataloader_num_workers=0 # ⭐ 單執行緒以確保可重現 ) trainer = WeightedTrainer( model=model, args=training_args, train_dataset=train_dataset, eval_dataset=eval_dataset, compute_metrics=compute_metrics ) print(f"\n🚀 開始訓練({epochs} epochs)...") print(f" 最佳化指標: {best_metric}") print("-" * 80) trainer.train() print("\n✅ 模型訓練完成!") # 評估模型 print("\n📊 評估模型...") results = trainer.evaluate() print(f"\n{training_type} {tuning_method} BERT ({weight_multiplier}x 權重) 表現:") print(f" F1 Score: {results['eval_f1']:.4f}") print(f" Accuracy: {results['eval_accuracy']:.4f}") print(f" Precision: {results['eval_precision']:.4f}") print(f" Recall: {results['eval_recall']:.4f}") print(f" Sensitivity: {results['eval_sensitivity']:.4f}") print(f" Specificity: {results['eval_specificity']:.4f}") print(f" AUC: {results['eval_auc']:.4f}") print(f" 混淆矩陣: Tp={results['eval_tp']}, Tn={results['eval_tn']}, " f"Fp={results['eval_fp']}, Fn={results['eval_fn']}") # ============================================================================ # 步驟 5:Baseline 比較(純 BERT) - 僅第一次微調時執行 # ============================================================================ if not is_second_finetuning: print("\n" + "=" * 80) print("步驟 5:Baseline 比較 - 純 BERT(完全沒看過資料)") print("=" * 80) baseline_results = evaluate_baseline_bert(eval_dataset, df_clean) # ============================================================================ # 步驟 6:比較結果 # ============================================================================ print("\n" + "=" * 80) print(f"📊 【對比結果】純 BERT vs {tuning_method} BERT") print("=" * 80) print("\n📋 詳細比較表:") print("-" * 100) print(f"{'指標':<15} {'純 BERT':<20} {tuning_method:<20} {'改善幅度':<20}") print("-" * 100) metrics_to_compare = [ ('F1 Score', 'f1', 'eval_f1'), ('Accuracy', 'accuracy', 'eval_accuracy'), ('Precision', 'precision', 'eval_precision'), ('Recall', 'recall', 'eval_recall'), ('Sensitivity', 'sensitivity', 'eval_sensitivity'), ('Specificity', 'specificity', 'eval_specificity'), ('AUC', 'auc', 'eval_auc') ] for name, baseline_key, finetuned_key in metrics_to_compare: baseline_val = baseline_results[baseline_key] finetuned_val = results[finetuned_key] improvement = ((finetuned_val - baseline_val) / baseline_val * 100) if baseline_val > 0 else 0 print(f"{name:<15} {baseline_val:<20.4f} {finetuned_val:<20.4f} {improvement:>+18.1f}%") print("-" * 100) else: baseline_results = None # 儲存模型 training_label = "second" if is_second_finetuning else "first" save_dir = f'./breast_cancer_bert_{tuning_method.lower().replace(" ", "_")}_{training_label}_{datetime.now().strftime("%Y%m%d_%H%M%S")}' if tuning_method in ["LoRA", "AdaLoRA"] and PEFT_AVAILABLE: # PEFT 模型儲存方式 model.save_pretrained(save_dir) tokenizer.save_pretrained(save_dir) else: # 一般模型儲存方式 model.save_pretrained(save_dir) tokenizer.save_pretrained(save_dir) # 儲存模型資訊到 JSON 檔案(用於預測頁面選擇) model_info = { 'model_path': save_dir, 'tuning_method': tuning_method, 'training_type': training_type, 'best_metric': best_metric, 'best_metric_value': float(results[f'eval_{metric_map.get(best_metric, "f1")}']), 'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'), 'weight_multiplier': weight_multiplier, 'epochs': epochs, 'is_second_finetuning': is_second_finetuning, 'base_model_path': base_model_path if is_second_finetuning else None } # 讀取現有的模型列表 models_list_file = './saved_models_list.json' if os.path.exists(models_list_file): with open(models_list_file, 'r') as f: models_list = json.load(f) else: models_list = [] # 加入新模型資訊 models_list.append(model_info) # 儲存更新後的列表 with open(models_list_file, 'w') as f: json.dump(models_list, f, indent=2) # 儲存到全域變數供預測使用 LAST_MODEL_PATH = save_dir LAST_TOKENIZER = tokenizer LAST_TUNING_METHOD = tuning_method print(f"\n💾 模型已儲存至: {save_dir}") print("\n" + "=" * 80) print("🎉 訓練完成!") print("=" * 80) print(f"完成時間: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}") # ==================== 清空記憶體(訓練後) ==================== del model del trainer torch.cuda.empty_cache() gc.collect() print("🧹 訓練後記憶體已清空") # 加入所有資訊到結果中 results['tuning_method'] = tuning_method results['training_type'] = training_type results['best_metric'] = best_metric results['best_metric_value'] = results[f'eval_{metric_map.get(best_metric, "f1")}'] results['baseline_results'] = baseline_results results['model_path'] = save_dir results['is_second_finetuning'] = is_second_finetuning return results # ==================== 新增:新數據測試函數 ==================== def test_on_new_data(test_file_path, baseline_model_path, first_model_path, second_model_path): """ 在新測試數據上比較三個模型的表現: 1. 純 BERT (baseline) 2. 第一次微調模型 3. 第二次微調模型 """ print("\n" + "=" * 80) print("📊 新數據測試 - 三模型比較") print("=" * 80) # 載入測試數據 df_test = pd.read_csv(test_file_path) df_clean = pd.DataFrame({ 'text': df_test['Text'], 'label': df_test['label'] }) df_clean = df_clean.dropna() print(f"\n測試數據:") print(f" 總筆數: {len(df_clean)}") print(f" 存活 (0): {sum(df_clean['label']==0)} 筆") print(f" 死亡 (1): {sum(df_clean['label']==1)} 筆") # 準備測試數據 tokenizer = BertTokenizer.from_pretrained("bert-base-uncased") test_dataset = Dataset.from_pandas(df_clean[['text', 'label']]) def preprocess_function(examples): return tokenizer(examples['text'], truncation=True, padding='max_length', max_length=256) test_tokenized = test_dataset.map(preprocess_function, batched=True) # 評估函數 def evaluate_model(model, dataset_name): model.eval() trainer_args = TrainingArguments( output_dir='./temp_test', per_device_eval_batch_size=32, report_to="none" ) trainer = Trainer( model=model, args=trainer_args, ) predictions_output = trainer.predict(test_tokenized) all_preds = predictions_output.predictions.argmax(-1) all_labels = predictions_output.label_ids probs = torch.nn.functional.softmax(torch.tensor(predictions_output.predictions), dim=-1)[:, 1].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) try: auc = roc_auc_score(all_labels, probs) except: auc = 0.0 cm = confusion_matrix(all_labels, all_preds) if cm.shape == (2, 2): tn, fp, fn, tp = cm.ravel() sensitivity = tp / (tp + fn) if (tp + fn) > 0 else 0 specificity = tn / (tn + fp) if (tn + fp) > 0 else 0 else: sensitivity = specificity = 0 tn = fp = fn = tp = 0 results = { 'f1': float(f1), 'accuracy': float(acc), 'precision': float(precision), 'recall': float(recall), 'sensitivity': float(sensitivity), 'specificity': float(specificity), 'auc': float(auc), 'tp': int(tp), 'tn': int(tn), 'fp': int(fp), 'fn': int(fn) } print(f"\n✅ {dataset_name} 評估完成") del trainer torch.cuda.empty_cache() gc.collect() return results all_results = {} # 1. 評估純 BERT if baseline_model_path != "跳過": print("\n" + "-" * 80) print("1️⃣ 評估純 BERT (Baseline)") print("-" * 80) baseline_model = BertForSequenceClassification.from_pretrained( "bert-base-uncased", num_labels=2 ).to(device) all_results['baseline'] = evaluate_model(baseline_model, "純 BERT") del baseline_model torch.cuda.empty_cache() else: all_results['baseline'] = None # 2. 評估第一次微調模型 if first_model_path != "請選擇": print("\n" + "-" * 80) print("2️⃣ 評估第一次微調模型") print("-" * 80) # 讀取模型資訊 with open('./saved_models_list.json', 'r') as f: models_list = json.load(f) first_model_info = None for model_info in models_list: if model_info['model_path'] == first_model_path: first_model_info = model_info break if first_model_info: tuning_method = first_model_info['tuning_method'] if tuning_method in ["LoRA", "AdaLoRA"] and PEFT_AVAILABLE: base_model = BertForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=2) first_model = PeftModel.from_pretrained(base_model, first_model_path) first_model = first_model.to(device) else: first_model = BertForSequenceClassification.from_pretrained(first_model_path).to(device) all_results['first'] = evaluate_model(first_model, "第一次微調模型") del first_model torch.cuda.empty_cache() else: all_results['first'] = None else: all_results['first'] = None # 3. 評估第二次微調模型 if second_model_path != "請選擇": print("\n" + "-" * 80) print("3️⃣ 評估第二次微調模型") print("-" * 80) # 讀取模型資訊 with open('./saved_models_list.json', 'r') as f: models_list = json.load(f) second_model_info = None for model_info in models_list: if model_info['model_path'] == second_model_path: second_model_info = model_info break if second_model_info: tuning_method = second_model_info['tuning_method'] if tuning_method in ["LoRA", "AdaLoRA"] and PEFT_AVAILABLE: base_model = BertForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=2) second_model = PeftModel.from_pretrained(base_model, second_model_path) second_model = second_model.to(device) else: second_model = BertForSequenceClassification.from_pretrained(second_model_path).to(device) all_results['second'] = evaluate_model(second_model, "第二次微調模型") del second_model torch.cuda.empty_cache() else: all_results['second'] = None else: all_results['second'] = None print("\n" + "=" * 80) print("✅ 新數據測試完成") print("=" * 80) return all_results # ==================== 預測函數(保持原樣) ==================== def predict_text(model_choice, text_input): """ 預測功能 - 支持選擇已訓練的模型,並同時顯示未微調和微調的預測結果 """ if not text_input or text_input.strip() == "": return "請輸入文本", "請輸入文本" try: # ==================== 未微調的 BERT 預測 ==================== print("\n使用未微調 BERT 預測...") baseline_tokenizer = BertTokenizer.from_pretrained("bert-base-uncased") baseline_model = BertForSequenceClassification.from_pretrained( "bert-base-uncased", num_labels=2 ).to(device) baseline_model.eval() # Tokenize 輸入(未微調) baseline_inputs = baseline_tokenizer( text_input, truncation=True, padding='max_length', max_length=256, return_tensors='pt' ).to(device) # 預測(未微調) with torch.no_grad(): baseline_outputs = baseline_model(**baseline_inputs) baseline_probs = torch.nn.functional.softmax(baseline_outputs.logits, dim=-1) baseline_pred_class = baseline_probs.argmax(-1).item() baseline_confidence = baseline_probs[0][baseline_pred_class].item() baseline_result = "存活" if baseline_pred_class == 0 else "死亡" baseline_prob_survive = baseline_probs[0][0].item() baseline_prob_death = baseline_probs[0][1].item() baseline_output = f""" # 🔵 未微調 BERT 預測結果 ## 預測類別: **{baseline_result}** ## 信心度: **{baseline_confidence:.1%}** ## 機率分布: - 🟢 **存活機率**: {baseline_prob_survive:.2%} - 🔴 **死亡機率**: {baseline_prob_death:.2%} --- **說明**: 此為原始 BERT 模型,未經任何領域資料訓練 """ # 清空記憶體 del baseline_model del baseline_tokenizer torch.cuda.empty_cache() # ==================== 微調後的 BERT 預測 ==================== if model_choice == "請先訓練模型": finetuned_output = """ # 🟢 微調 BERT 預測結果 ❌ 尚未訓練任何模型,請先在「模型訓練」頁面訓練模型 """ return baseline_output, finetuned_output # 解析選擇的模型路徑 model_path = model_choice.split(" | ")[0].replace("路徑: ", "") # 從 JSON 讀取模型資訊 with open('./saved_models_list.json', 'r') as f: models_list = json.load(f) selected_model_info = None for model_info in models_list: if model_info['model_path'] == model_path: selected_model_info = model_info break if selected_model_info is None: finetuned_output = f""" # 🟢 微調 BERT 預測結果 ❌ 找不到模型:{model_path} """ return baseline_output, finetuned_output print(f"\n使用微調模型: {model_path}") # 載入 tokenizer finetuned_tokenizer = BertTokenizer.from_pretrained(model_path) # 載入模型 tuning_method = selected_model_info['tuning_method'] if tuning_method in ["LoRA", "AdaLoRA"] and PEFT_AVAILABLE: # 載入 PEFT 模型 base_model = BertForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=2) finetuned_model = PeftModel.from_pretrained(base_model, model_path) finetuned_model = finetuned_model.to(device) else: # 載入一般模型 finetuned_model = BertForSequenceClassification.from_pretrained(model_path).to(device) finetuned_model.eval() # Tokenize 輸入(微調) finetuned_inputs = finetuned_tokenizer( text_input, truncation=True, padding='max_length', max_length=256, return_tensors='pt' ).to(device) # 預測(微調) with torch.no_grad(): finetuned_outputs = finetuned_model(**finetuned_inputs) finetuned_probs = torch.nn.functional.softmax(finetuned_outputs.logits, dim=-1) finetuned_pred_class = finetuned_probs.argmax(-1).item() finetuned_confidence = finetuned_probs[0][finetuned_pred_class].item() finetuned_result = "存活" if finetuned_pred_class == 0 else "死亡" finetuned_prob_survive = finetuned_probs[0][0].item() finetuned_prob_death = finetuned_probs[0][1].item() training_type_label = "二次微調" if selected_model_info.get('is_second_finetuning', False) else "第一次微調" finetuned_output = f""" # 🟢 微調 BERT 預測結果 ## 預測類別: **{finetuned_result}** ## 信心度: **{finetuned_confidence:.1%}** ## 機率分布: - 🟢 **存活機率**: {finetuned_prob_survive:.2%} - 🔴 **死亡機率**: {finetuned_prob_death:.2%} --- ### 模型資訊: - **訓練類型**: {training_type_label} - **微調方法**: {selected_model_info['tuning_method']} - **最佳化指標**: {selected_model_info['best_metric']} - **訓練時間**: {selected_model_info['timestamp']} - **模型路徑**: {model_path} --- **注意**: 此預測僅供參考,實際醫療決策應由專業醫師判斷。 """ # 清空記憶體 del finetuned_model del finetuned_tokenizer torch.cuda.empty_cache() return baseline_output, finetuned_output except Exception as e: import traceback error_msg = f"❌ 預測錯誤:{str(e)}\n\n詳細錯誤訊息:\n{traceback.format_exc()}" return error_msg, error_msg def get_available_models(): """ 取得所有已訓練的模型列表 """ models_list_file = './saved_models_list.json' if not os.path.exists(models_list_file): return ["請先訓練模型"] with open(models_list_file, 'r') as f: models_list = json.load(f) if len(models_list) == 0: return ["請先訓練模型"] # 格式化模型選項 model_choices = [] for i, model_info in enumerate(models_list, 1): training_type = model_info.get('training_type', '第一次微調') choice = f"路徑: {model_info['model_path']} | 類型: {training_type} | 方法: {model_info['tuning_method']} | 時間: {model_info['timestamp']}" model_choices.append(choice) return model_choices def get_first_finetuning_models(): """ 取得所有第一次微調的模型(用於二次微調選擇) """ models_list_file = './saved_models_list.json' if not os.path.exists(models_list_file): return ["請先進行第一次微調"] with open(models_list_file, 'r') as f: models_list = json.load(f) # 只返回第一次微調的模型 first_models = [m for m in models_list if not m.get('is_second_finetuning', False)] if len(first_models) == 0: return ["請先進行第一次微調"] model_choices = [] for model_info in first_models: choice = f"{model_info['model_path']}" model_choices.append(choice) return model_choices # ==================== Wrapper 函數 ==================== def train_first_wrapper( file, tuning_method, weight_mult, epochs, batch_size, lr, warmup, best_metric, lora_r, lora_alpha, lora_dropout, lora_modules, adalora_init_r, adalora_target_r, adalora_tinit, adalora_tfinal, adalora_delta_t ): """第一次微調的包裝函數""" if file is None: return "請上傳 CSV 檔案", "", "" try: results = run_original_code_with_tuning( file_path=file.name, weight_multiplier=weight_mult, epochs=int(epochs), batch_size=int(batch_size), learning_rate=lr, warmup_steps=int(warmup), tuning_method=tuning_method, best_metric=best_metric, lora_r=lora_r, lora_alpha=lora_alpha, lora_dropout=lora_dropout, lora_modules=lora_modules, adalora_init_r=adalora_init_r, adalora_target_r=adalora_target_r, adalora_tinit=adalora_tinit, adalora_tfinal=adalora_tfinal, adalora_delta_t=adalora_delta_t, is_second_finetuning=False ) baseline_results = results['baseline_results'] # 格式化輸出 data_info = f""" # 📊 資料資訊 (第一次微調) ## 🔧 訓練配置 - **微調方法**: {results['tuning_method']} - **最佳化指標**: {results['best_metric']} - **最佳指標值**: {results['best_metric_value']:.4f} ## ⚙️ 訓練參數 - **權重倍數**: {weight_mult}x - **訓練輪數**: {epochs} - **批次大小**: {batch_size} - **學習率**: {lr} - **Warmup Steps**: {warmup} ✅ 第一次微調完成!可進行二次微調或預測! """ baseline_output = f""" # 🔵 純 BERT (Baseline) ### 📈 評估指標 | 指標 | 數值 | |------|------| | **F1 Score** | {baseline_results['f1']:.4f} | | **Accuracy** | {baseline_results['accuracy']:.4f} | | **Precision** | {baseline_results['precision']:.4f} | | **Recall** | {baseline_results['recall']:.4f} | | **Sensitivity** | {baseline_results['sensitivity']:.4f} | | **Specificity** | {baseline_results['specificity']:.4f} | | **AUC** | {baseline_results['auc']:.4f} | ### 📈 混淆矩陣 | | 預測:存活 | 預測:死亡 | |---|-----------|-----------| | **實際:存活** | TN={baseline_results['tn']} | FP={baseline_results['fp']} | | **實際:死亡** | FN={baseline_results['fn']} | TP={baseline_results['tp']} | """ finetuned_output = f""" # 🟢 第一次微調 BERT ### 📈 評估指標 | 指標 | 數值 | |------|------| | **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} | | **AUC** | {results['eval_auc']:.4f} | ### 📈 混淆矩陣 | | 預測:存活 | 預測:死亡 | |---|-----------|-----------| | **實際:存活** | TN={results['eval_tn']} | FP={results['eval_fp']} | | **實際:死亡** | FN={results['eval_fn']} | TP={results['eval_tp']} | """ return data_info, baseline_output, finetuned_output except Exception as e: import traceback error_msg = f"❌ 錯誤:{str(e)}\n\n詳細錯誤訊息:\n{traceback.format_exc()}" return error_msg, "", "" def train_second_wrapper( base_model_choice, file, weight_mult, epochs, batch_size, lr, warmup, best_metric ): """二次微調的包裝函數""" if base_model_choice == "請先進行第一次微調": return "請先在「第一次微調」頁面訓練模型", "" if file is None: return "請上傳新的訓練數據 CSV 檔案", "" try: # 解析基礎模型路徑 base_model_path = base_model_choice # 讀取第一次模型資訊 with open('./saved_models_list.json', 'r') as f: models_list = json.load(f) base_model_info = None for model_info in models_list: if model_info['model_path'] == base_model_path: base_model_info = model_info break if base_model_info is None: return "找不到基礎模型資訊", "" # 使用第一次的參數(二次微調不更換方法) tuning_method = base_model_info['tuning_method'] # 獲取第一次的 PEFT 參數 lora_r = 16 lora_alpha = 32 lora_dropout = 0.1 lora_modules = "query,value" adalora_init_r = 12 adalora_target_r = 8 adalora_tinit = 0 adalora_tfinal = 0 adalora_delta_t = 1 results = run_original_code_with_tuning( file_path=file.name, weight_multiplier=weight_mult, epochs=int(epochs), batch_size=int(batch_size), learning_rate=lr, warmup_steps=int(warmup), tuning_method=tuning_method, best_metric=best_metric, lora_r=lora_r, lora_alpha=lora_alpha, lora_dropout=lora_dropout, lora_modules=lora_modules, adalora_init_r=adalora_init_r, adalora_target_r=adalora_target_r, adalora_tinit=adalora_tinit, adalora_tfinal=adalora_tfinal, adalora_delta_t=adalora_delta_t, is_second_finetuning=True, base_model_path=base_model_path ) data_info = f""" # 📊 二次微調結果 ## 🔧 訓練配置 - **基礎模型**: {base_model_path} - **微調方法**: {results['tuning_method']} (繼承自第一次) - **最佳化指標**: {results['best_metric']} - **最佳指標值**: {results['best_metric_value']:.4f} ## ⚙️ 訓練參數 - **權重倍數**: {weight_mult}x - **訓練輪數**: {epochs} - **批次大小**: {batch_size} - **學習率**: {lr} - **Warmup Steps**: {warmup} ✅ 二次微調完成!可進行預測或新數據測試! """ finetuned_output = f""" # 🟢 二次微調 BERT ### 📈 評估指標 | 指標 | 數值 | |------|------| | **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} | | **AUC** | {results['eval_auc']:.4f} | ### 📈 混淆矩陣 | | 預測:存活 | 預測:死亡 | |---|-----------|-----------| | **實際:存活** | TN={results['eval_tn']} | FP={results['eval_fp']} | | **實際:死亡** | FN={results['eval_fn']} | TP={results['eval_tp']} | """ return data_info, finetuned_output except Exception as e: import traceback error_msg = f"❌ 錯誤:{str(e)}\n\n詳細錯誤訊息:\n{traceback.format_exc()}" return error_msg, "" def test_new_data_wrapper(test_file, baseline_choice, first_choice, second_choice): """新數據測試的包裝函數""" if test_file is None: return "請上傳測試數據 CSV 檔案", "", "" try: all_results = test_on_new_data( test_file.name, baseline_choice, first_choice, second_choice ) # 格式化輸出 outputs = [] # 1. 純 BERT if all_results['baseline']: r = all_results['baseline'] baseline_output = f""" # 🔵 純 BERT (Baseline) | 指標 | 數值 | |------|------| | **F1 Score** | {r['f1']:.4f} | | **Accuracy** | {r['accuracy']:.4f} | | **Precision** | {r['precision']:.4f} | | **Recall** | {r['recall']:.4f} | | **Sensitivity** | {r['sensitivity']:.4f} | | **Specificity** | {r['specificity']:.4f} | | **AUC** | {r['auc']:.4f} | ### 混淆矩陣 | | 預測:存活 | 預測:死亡 | |---|-----------|-----------| | **實際:存活** | TN={r['tn']} | FP={r['fp']} | | **實際:死亡** | FN={r['fn']} | TP={r['tp']} | """ else: baseline_output = "未選擇評估純 BERT" outputs.append(baseline_output) # 2. 第一次微調 if all_results['first']: r = all_results['first'] first_output = f""" # 🟢 第一次微調模型 | 指標 | 數值 | |------|------| | **F1 Score** | {r['f1']:.4f} | | **Accuracy** | {r['accuracy']:.4f} | | **Precision** | {r['precision']:.4f} | | **Recall** | {r['recall']:.4f} | | **Sensitivity** | {r['sensitivity']:.4f} | | **Specificity** | {r['specificity']:.4f} | | **AUC** | {r['auc']:.4f} | ### 混淆矩陣 | | 預測:存活 | 預測:死亡 | |---|-----------|-----------| | **實際:存活** | TN={r['tn']} | FP={r['fp']} | | **實際:死亡** | FN={r['fn']} | TP={r['tp']} | """ else: first_output = "未選擇第一次微調模型" outputs.append(first_output) # 3. 第二次微調 if all_results['second']: r = all_results['second'] second_output = f""" # 🟡 第二次微調模型 | 指標 | 數值 | |------|------| | **F1 Score** | {r['f1']:.4f} | | **Accuracy** | {r['accuracy']:.4f} | | **Precision** | {r['precision']:.4f} | | **Recall** | {r['recall']:.4f} | | **Sensitivity** | {r['sensitivity']:.4f} | | **Specificity** | {r['specificity']:.4f} | | **AUC** | {r['auc']:.4f} | ### 混淆矩陣 | | 預測:存活 | 預測:死亡 | |---|-----------|-----------| | **實際:存活** | TN={r['tn']} | FP={r['fp']} | | **實際:死亡** | FN={r['fn']} | TP={r['tp']} | """ else: second_output = "未選擇第二次微調模型" outputs.append(second_output) return outputs[0], outputs[1], outputs[2] except Exception as e: import traceback error_msg = f"❌ 錯誤:{str(e)}\n\n詳細錯誤訊息:\n{traceback.format_exc()}" return error_msg, "", "" # ============================================================================ # Gradio 介面 # ============================================================================ with gr.Blocks(title="BERT 二次微調平台", theme=gr.themes.Soft()) as demo: gr.Markdown(""" # 🥼 BERT乳癌存預測大型微調應用（Fine-tuning) ### 🌟 功能特色: - 🎯 第一次微調:從純 BERT 開始訓練 - 🔄 第二次微調:基於第一次模型用新數據繼續訓練 - 📊 新數據測試:比較三個模型在新數據的表現 - 🔮 預測功能:使用訓練好的模型進行預測 """) # Tab 1: 第一次微調 with gr.Tab("1️⃣ 第一次微調"): with gr.Row(): with gr.Column(scale=1): gr.Markdown("### 📤 資料上傳") file_input_first = gr.File(label="上傳訓練數據 CSV", file_types=[".csv"]) gr.Markdown("### 🔧 微調方法選擇") tuning_method_first = gr.Radio( choices=["Full Fine-tuning", "LoRA", "AdaLoRA"], value="Full Fine-tuning", label="選擇微調方法" ) gr.Markdown("### 🎯 最佳模型選擇") best_metric_first = gr.Dropdown( choices=["f1", "accuracy", "precision", "recall", "sensitivity", "specificity", "auc"], value="f1", label="選擇最佳化指標" ) gr.Markdown("### ⚙️ 訓練參數") weight_slider_first = gr.Slider(0.1, 2.0, value=0.8, step=0.1, label="權重倍數") epochs_input_first = gr.Number(value=3, label="訓練輪數") batch_size_input_first = gr.Number(value=16, label="批次大小") lr_input_first = gr.Number(value=2e-5, label="學習率") warmup_input_first = gr.Number(value=200, label="Warmup Steps") # LoRA 參數 with gr.Column(visible=False) as lora_params_first: gr.Markdown("### 🔷 LoRA 參數") lora_r_first = gr.Slider(4, 64, value=16, step=4, label="LoRA Rank (r)") lora_alpha_first = gr.Slider(8, 128, value=32, step=8, label="LoRA Alpha") lora_dropout_first = gr.Slider(0.0, 0.5, value=0.1, step=0.05, label="LoRA Dropout") lora_modules_first = gr.Textbox(value="query,value", label="目標模組") # AdaLoRA 參數 with gr.Column(visible=False) as adalora_params_first: gr.Markdown("### 🔶 AdaLoRA 參數") adalora_init_r_first = gr.Slider(4, 64, value=12, step=4, label="初始 Rank") adalora_target_r_first = gr.Slider(4, 64, value=8, step=4, label="目標 Rank") adalora_tinit_first = gr.Number(value=0, label="Tinit") adalora_tfinal_first = gr.Number(value=0, label="Tfinal") adalora_delta_t_first = gr.Number(value=1, label="Delta T") train_button_first = gr.Button("🚀 開始第一次微調", variant="primary", size="lg") with gr.Column(scale=2): gr.Markdown("### 📊 第一次微調結果") data_info_output_first = gr.Markdown(value="等待訓練...") with gr.Row(): baseline_output_first = gr.Markdown(value="### 純 BERT\n等待訓練...") finetuned_output_first = gr.Markdown(value="### 第一次微調\n等待訓練...") # Tab 2: 二次微調 with gr.Tab("2️⃣ 二次微調"): with gr.Row(): with gr.Column(scale=1): gr.Markdown("### 🔄 選擇基礎模型") base_model_dropdown = gr.Dropdown( label="選擇第一次微調的模型", choices=["請先進行第一次微調"], value="請先進行第一次微調" ) refresh_base_models = gr.Button("🔄 重新整理模型列表", size="sm") gr.Markdown("### 📤 上傳新訓練數據") file_input_second = gr.File(label="上傳新的訓練數據 CSV", file_types=[".csv"]) gr.Markdown("### ⚙️ 訓練參數") gr.Markdown("⚠️ 微調方法將自動繼承第一次微調的方法") best_metric_second = gr.Dropdown( choices=["f1", "accuracy", "precision", "recall", "sensitivity", "specificity", "auc"], value="f1", label="選擇最佳化指標" ) weight_slider_second = gr.Slider(0.1, 2.0, value=0.8, step=0.1, label="權重倍數") epochs_input_second = gr.Number(value=3, label="訓練輪數", info="建議比第一次少") batch_size_input_second = gr.Number(value=16, label="批次大小") lr_input_second = gr.Number(value=1e-5, label="學習率", info="建議比第一次小") warmup_input_second = gr.Number(value=100, label="Warmup Steps") train_button_second = gr.Button("🚀 開始二次微調", variant="primary", size="lg") with gr.Column(scale=2): gr.Markdown("### 📊 二次微調結果") data_info_output_second = gr.Markdown(value="等待訓練...") finetuned_output_second = gr.Markdown(value="### 二次微調\n等待訓練...") # Tab 3: 新數據測試 with gr.Tab("3️⃣ 新數據測試"): with gr.Row(): with gr.Column(scale=1): gr.Markdown("### 📤 上傳測試數據") test_file_input = gr.File(label="上傳測試數據 CSV", file_types=[".csv"]) gr.Markdown("### 🎯 選擇要比較的模型") gr.Markdown("可選擇 1-3 個模型進行比較") baseline_test_choice = gr.Radio( choices=["評估純 BERT", "跳過"], value="評估純 BERT", label="純 BERT (Baseline)" ) first_model_test_dropdown = gr.Dropdown( label="第一次微調模型", choices=["請選擇"], value="請選擇" ) second_model_test_dropdown = gr.Dropdown( label="第二次微調模型", choices=["請選擇"], value="請選擇" ) refresh_test_models = gr.Button("🔄 重新整理模型列表", size="sm") test_button = gr.Button("📊 開始測試", variant="primary", size="lg") with gr.Column(scale=2): gr.Markdown("### 📊 新數據測試結果 - 三模型比較") with gr.Row(): baseline_test_output = gr.Markdown(value="### 純 BERT\n等待測試...") first_test_output = gr.Markdown(value="### 第一次微調\n等待測試...") second_test_output = gr.Markdown(value="### 二次微調\n等待測試...") # Tab 4: 預測 with gr.Tab("4️⃣ 模型預測"): gr.Markdown(""" ### 使用訓練好的模型進行預測 選擇已訓練的模型,輸入病歷文本進行預測。 """) with gr.Row(): with gr.Column(): model_dropdown = gr.Dropdown( label="選擇模型", choices=["請先訓練模型"], value="請先訓練模型" ) refresh_predict_models = gr.Button("🔄 重新整理模型列表", size="sm") text_input = gr.Textbox( label="輸入病歷文本", placeholder="請輸入患者的病歷描述(英文)...", lines=10 ) predict_button = gr.Button("🔮 開始預測", variant="primary", size="lg") with gr.Column(): gr.Markdown("### 預測結果比較") baseline_prediction_output = gr.Markdown(label="未微調 BERT", value="等待預測...") finetuned_prediction_output = gr.Markdown(label="微調 BERT", value="等待預測...") # Tab 5: 使用說明 with gr.Tab("📖 使用說明"): gr.Markdown(""" ## 🔄 二次微調流程說明 ### 步驟 1: 第一次微調 1. 上傳訓練數據 A (CSV 格式: Text, label) 2. 選擇微調方法 (Full Fine-tuning / LoRA / AdaLoRA) 3. 調整訓練參數 4. 開始訓練 5. 系統會自動比較純 BERT vs 第一次微調的表現 ### 步驟 2: 二次微調 1. 選擇已訓練的第一次微調模型 2. 上傳新的訓練數據 B 3. 調整訓練參數 (建議 epochs 更少, learning rate 更小) 4. 開始訓練 (方法自動繼承第一次) 5. 模型會基於第一次的權重繼續學習 ### 步驟 3: 新數據測試 1. 上傳測試數據 C 2. 選擇要比較的模型 (純 BERT / 第一次 / 第二次) 3. 系統會並排顯示三個模型的表現 ### 步驟 4: 預測 1. 選擇任一已訓練模型 2. 輸入病歷文本 3. 查看預測結果 ## ⚠️ 注意事項 - CSV 格式必須包含 `Text` 和 `label` 欄位 - 第二次微調會自動使用第一次的微調方法 - 建議第二次的學習率比第一次小,避免破壞已學習的知識 - 新數據測試可以同時評估最多 3 個模型 ## 📊 指標說明 - **F1 Score**: 平衡指標,綜合考慮精確率和召回率 - **Accuracy**: 整體準確率 - **Precision**: 預測為死亡中的準確率 - **Recall/Sensitivity**: 實際死亡中被正確識別的比例 - **Specificity**: 實際存活中被正確識別的比例 - **AUC**: ROC 曲線下面積,整體分類能力 """) # ==================== 事件綁定 ==================== # 第一次微調 - 參數面板顯示/隱藏 def update_first_params(method): if method == "LoRA": return gr.update(visible=True), gr.update(visible=False) elif method == "AdaLoRA": return gr.update(visible=True), gr.update(visible=True) else: return gr.update(visible=False), gr.update(visible=False) tuning_method_first.change( fn=update_first_params, inputs=[tuning_method_first], outputs=[lora_params_first, adalora_params_first] ) # 第一次微調按鈕 train_button_first.click( fn=train_first_wrapper, inputs=[ file_input_first, tuning_method_first, weight_slider_first, epochs_input_first, batch_size_input_first, lr_input_first, warmup_input_first, best_metric_first, lora_r_first, lora_alpha_first, lora_dropout_first, lora_modules_first, adalora_init_r_first, adalora_target_r_first, adalora_tinit_first, adalora_tfinal_first, adalora_delta_t_first ], outputs=[data_info_output_first, baseline_output_first, finetuned_output_first] ) # 刷新基礎模型列表 def refresh_base_models_list(): choices = get_first_finetuning_models() return gr.update(choices=choices, value=choices[0]) refresh_base_models.click( fn=refresh_base_models_list, outputs=[base_model_dropdown] ) # 二次微調按鈕 train_button_second.click( fn=train_second_wrapper, inputs=[ base_model_dropdown, file_input_second, weight_slider_second, epochs_input_second, batch_size_input_second, lr_input_second, warmup_input_second, best_metric_second ], outputs=[data_info_output_second, finetuned_output_second] ) # 刷新測試模型列表 def refresh_test_models_list(): all_models = get_available_models() first_models = get_first_finetuning_models() # 篩選第二次微調模型 with open('./saved_models_list.json', 'r') as f: models_list = json.load(f) second_models = [m['model_path'] for m in models_list if m.get('is_second_finetuning', False)] if len(second_models) == 0: second_models = ["請選擇"] return ( gr.update(choices=first_models if first_models[0] != "請先進行第一次微調" else ["請選擇"], value="請選擇"), gr.update(choices=second_models, value="請選擇") ) refresh_test_models.click( fn=refresh_test_models_list, outputs=[first_model_test_dropdown, second_model_test_dropdown] ) # 測試按鈕 test_button.click( fn=test_new_data_wrapper, inputs=[test_file_input, baseline_test_choice, first_model_test_dropdown, second_model_test_dropdown], outputs=[baseline_test_output, first_test_output, second_test_output] ) # 刷新預測模型列表 def refresh_predict_models_list(): choices = get_available_models() return gr.update(choices=choices, value=choices[0]) refresh_predict_models.click( fn=refresh_predict_models_list, outputs=[model_dropdown] ) # 預測按鈕 predict_button.click( fn=predict_text, inputs=[model_dropdown, text_input], outputs=[baseline_prediction_output, finetuned_prediction_output] ) if __name__ == "__main__": demo.launch()