task_evaluator.py

"""
任务评估器（TaskEvaluator）- 纯真实训练版本

负责执行具体的模型训练和评估，返回性能指标。
支持LDA/MDA/LMI三种任务类型，强制使用CUDA进行训练。
移除了所有模拟训练代码，只保留真实训练实现。
"""

import os
import sys
import argparse
import tempfile
import shutil
import subprocess
import json
import numpy as np
import torch
from typing import Dict, Any, List, Optional, Tuple
from datetime import datetime
import logging
import time

# 导入现有的模块
from autodl_core import OptimizationResult
from parms_setting import settings
from utils import set_global_seed

# 增强训练日志支持
try:
    from enhanced_training_logger import create_enhanced_logger
    ENHANCED_LOGGING_AVAILABLE = True
except ImportError:
    ENHANCED_LOGGING_AVAILABLE = False


class TaskEvaluator:
    """
    任务评估器 - 纯真实训练版本
    
    执行具体的模型训练和评估，返回性能指标。
    只支持真实训练，不包含任何模拟训练逻辑。
    """
    
    def __init__(self, task_type: str = "LDA", data_config: Optional[Dict[str, Any]] = None, 
                 force_cuda: bool = True):
        """
        初始化任务评估器
        
        Args:
            task_type: 任务类型，支持 'LDA', 'MDA', 'LMI'
            data_config: 数据配置，包含数据路径等信息
            force_cuda: 是否强制使用CUDA，默认True
        """
        if task_type not in ['LDA', 'MDA', 'LMI']:
            raise ValueError(f"不支持的任务类型: {task_type}，支持的类型: ['LDA', 'MDA', 'LMI']")
        
        self.task_type = task_type
        self.data_config = data_config or {}
        self.force_cuda = force_cuda
        
        # 设置日志（需要在设备设置之前初始化）
        self.logger = logging.getLogger(f"TaskEvaluator_{task_type}")
        if not self.logger.handlers:
            handler = logging.StreamHandler()
            formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
            handler.setFormatter(formatter)
            self.logger.addHandler(handler)
            self.logger.setLevel(logging.INFO)
        
        # 强制设置设备为CUDA（如果可用）
        if force_cuda:
            if not torch.cuda.is_available():
                self.logger.warning("[DEVICE] CUDA不可用，但要求强制使用CUDA")
                self.logger.warning("[DEVICE] 这可能是因为：1) 没有NVIDIA GPU 2) 驱动问题 3) PyTorch CPU版本")
                self.logger.warning("[DEVICE] 为了继续运行，将使用CPU模式（仅用于测试）")
                self.device = 'cpu'
                self.force_cuda = False
            else:
                self.device = 'cuda'
                torch.cuda.set_device(0)  # 强制使用第一个GPU
                # 清理GPU内存
                torch.cuda.empty_cache()
        else:
            self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
        
        # 尝试导入真实的训练模块
        try:
            from data_preprocess import load_data, get_fold_data
            from instantiation import Create_model
            self.load_data = load_data
            self.get_fold_data = get_fold_data
            self.Create_model = Create_model
            self.real_training_available = True
            self.logger.info("真实训练模块导入成功")
        except ImportError as e:
            self.logger.error(f"无法导入真实训练模块: {e}")
            self.logger.error("TaskEvaluator需要真实训练模块才能工作")
            raise ImportError(f"真实训练模块导入失败，TaskEvaluator无法初始化: {e}")
        
        self.logger.info(f"[INIT] TaskEvaluator初始化完成 - 任务类型: {task_type}, 计算设备: {self.device}")
        if self.device == 'cuda':
            try:
                gpu_name = torch.cuda.get_device_name(0)
                gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
                self.logger.info(f"[INIT] GPU设备: {gpu_name}")
                self.logger.info(f"[INIT] GPU内存: {gpu_memory:.1f} GB")
            except:
                self.logger.info("[INIT] GPU信息获取失败")
        if self.device == 'cpu':
            self.logger.warning("[DEVICE] 使用CPU模式，训练性能可能较慢")
    
    def evaluate_parameters(self, parameters: Dict[str, Any], n_folds: int = 5) -> Dict[str, float]:
        """
        评估参数组合的性能
        
        Args:
            parameters: 参数字典
            n_folds: 交叉验证折数，默认5
            
        Returns:
            包含性能指标的字典，包括AUROC、AUPRC、F1、精确率、召回率等
        """
        self.logger.info(f"开始评估参数组合: {parameters}")
        
        try:
            # 执行交叉验证
            cv_results = self.run_cross_validation(parameters, n_folds)
            
            # 计算平均指标
            metrics = {
                'AUROC': np.mean(cv_results['auroc']),
                'AUPRC': np.mean(cv_results['auprc']),
                'F1': np.mean(cv_results['f1']),
                'precision': np.mean(cv_results['precision']),
                'recall': np.mean(cv_results['recall']),
                'loss': np.mean(cv_results['loss']),
                'AUROC_std': np.std(cv_results['auroc']),
                'AUPRC_std': np.std(cv_results['auprc']),
                'F1_std': np.std(cv_results['f1'])
            }
            
            self.logger.info(f"评估完成，AUROC: {metrics['AUROC']:.4f}±{metrics['AUROC_std']:.4f}")
            return metrics
            
        except Exception as e:
            self.logger.error(f"参数评估失败: {str(e)}")
            # 返回惩罚性的指标值
            return {
                'AUROC': 0.0,
                'AUPRC': 0.0,
                'F1': 0.0,
                'precision': 0.0,
                'recall': 0.0,
                'loss': float('inf'),
                'AUROC_std': 0.0,
                'AUPRC_std': 0.0,
                'F1_std': 0.0,
                'error': str(e)
            }
    
    def run_cross_validation(self, parameters: Dict[str, Any], n_folds: int = 5) -> Dict[str, List[float]]:
        """
        执行真实的交叉验证
        
        Args:
            parameters: 参数字典
            n_folds: 折数
            
        Returns:
            包含各折结果的字典
        """
        self.logger.info(f"开始{n_folds}折真实交叉验证")
        
        # 设置实验参数
        args = self._create_args_from_parameters(parameters)
        
        # 设置随机种子
        set_global_seed(args.seed)
        
        try:
            # 加载数据
            data_o_folds, data_a_folds, train_loaders, test_loaders = self.load_data(args)
            
            # 存储各折结果
            fold_results = {
                'auroc': [],
                'auprc': [],
                'f1': [],
                'precision': [],
                'recall': [],
                'loss': []
            }
            
            # 执行各折训练和评估
            for fold in range(n_folds):
                self.logger.info(f"执行第{fold+1}折真实训练")
                
                try:
                    # 获取当前折的数据
                    data_o = data_o_folds[fold]
                    data_a = data_a_folds[fold]
                    train_loader = train_loaders[fold]
                    test_loader = test_loaders[fold]
                    
                    # 确保数据在CUDA上
                    data_o = data_o.to(self.device)
                    data_a = data_a.to(self.device)
                    
                    # 创建模型和优化器
                    model, optimizer = self.Create_model(args)
                    model = model.to(self.device)
                    
                    # 执行训练
                    result = self._train_single_fold(model, optimizer, data_o, data_a, 
                                                   train_loader, test_loader, args, fold_idx=fold+1)
                    
                    # 收集结果
                    fold_results['auroc'].append(result['auroc'])
                    fold_results['auprc'].append(result['auprc'])
                    fold_results['f1'].append(result['f1'])
                    fold_results['precision'].append(result['precision'])
                    fold_results['recall'].append(result['recall'])
                    fold_results['loss'].append(result['loss'])
                    
                    self.logger.info(f"第{fold+1}折完成，AUROC: {result['auroc']:.4f}")
                    
                    # 清理GPU内存
                    del model, optimizer
                    torch.cuda.empty_cache()
                    
                except Exception as e:
                    self.logger.error(f"第{fold+1}折训练失败: {str(e)}")
                    # 添加惩罚性结果
                    fold_results['auroc'].append(0.0)
                    fold_results['auprc'].append(0.0)
                    fold_results['f1'].append(0.0)
                    fold_results['precision'].append(0.0)
                    fold_results['recall'].append(0.0)
                    fold_results['loss'].append(float('inf'))
            
            return fold_results
            
        except Exception as e:
            self.logger.error(f"数据加载失败: {str(e)}")
            raise RuntimeError(f"真实训练执行失败: {str(e)}")
    
    def _train_single_fold(self, model, optimizer, data_o, data_a, train_loader, test_loader, args, fold_idx):
        """
        训练单个折的模型
        
        使用内置的完整训练实现，包含所有必要的损失函数和优化逻辑
        """
        self.logger.info(f"[TRAINING] 开始完整训练实现 - 设备: {self.device}")
        
        # 使用内置的完整训练实现
        return self._simplified_training(model, optimizer, data_o, data_a, 
                                       train_loader, test_loader, args)
    
    def _simplified_training(self, model, optimizer, data_o, data_a, train_loader, test_loader, args):
        """
        完整的训练实现
        
        包含所有核心训练逻辑：
        - BCE损失（主要分类损失）
        - 对比学习损失（MoCo/BYOL）
        - 节点对抗损失
        - 完整的前向和反向传播
        - 性能指标计算
        """
        import torch.nn as nn
        from sklearn.metrics import roc_auc_score, average_precision_score, f1_score, precision_score, recall_score, confusion_matrix
        
        # 设置损失函数
        loss_fct = nn.BCELoss()
        sigmoid = nn.Sigmoid()
        ce_loss = nn.CrossEntropyLoss()
        node_loss = nn.BCEWithLogitsLoss()
        
        # 强制设置epoch为50
        epochs = 50
        batch_size = getattr(args, 'batch', 25)
        learning_rate = optimizer.param_groups[0]['lr']
        loss_ratio1 = getattr(args, 'loss_ratio1', 1.0)
        loss_ratio2 = getattr(args, 'loss_ratio2', 0.5)
        loss_ratio3 = getattr(args, 'loss_ratio3', 0.5)
        
        # 详细的训练开始信息
        self.logger.info("[TRAINING] ========== 完整模型训练开始 ==========")
        self.logger.info(f"[CONFIG] 训练轮数: {epochs}")
        self.logger.info(f"[CONFIG] 计算设备: {self.device}")
        self.logger.info(f"[CONFIG] 批处理大小: {batch_size}")
        self.logger.info(f"[CONFIG] 学习率: {learning_rate:.8f}")
        self.logger.info(f"[CONFIG] 损失函数权重配置:")
        self.logger.info(f"[CONFIG]   - BCE损失权重: {loss_ratio1:.4f}")
        self.logger.info(f"[CONFIG]   - 对比学习损失权重: {loss_ratio2:.4f}")
        self.logger.info(f"[CONFIG]   - 节点对抗损失权重: {loss_ratio3:.4f}")
        self.logger.info(f"[CONFIG] 训练数据批次数量: {len(train_loader)}")
        self.logger.info(f"[CONFIG] 测试数据批次数量: {len(test_loader)}")
        
        # 模型参数统计
        total_params = sum(p.numel() for p in model.parameters())
        trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
        self.logger.info(f"[MODEL] 模型总参数数量: {total_params:,}")
        self.logger.info(f"[MODEL] 可训练参数数量: {trainable_params:,}")
        self.logger.info(f"[MODEL] 参数占用内存: {total_params * 4 / 1024 / 1024:.2f} MB (假设float32)")
        
        # GPU内存信息
        if torch.cuda.is_available() and self.device == 'cuda':
            gpu_memory_total = torch.cuda.get_device_properties(0).total_memory / 1024**3
            gpu_memory_allocated = torch.cuda.memory_allocated(0) / 1024**3
            gpu_memory_cached = torch.cuda.memory_reserved(0) / 1024**3
            self.logger.info(f"[GPU] GPU总内存: {gpu_memory_total:.2f} GB")
            self.logger.info(f"[GPU] 已分配内存: {gpu_memory_allocated:.2f} GB")
            self.logger.info(f"[GPU] 缓存内存: {gpu_memory_cached:.2f} GB")
        
        self.logger.info("=" * 80)
        
        # 为节点级别的对抗损失创建标签
        n_nodes = int(data_o.x.size(0))
        lbl_1 = torch.ones(1, n_nodes, device=self.device)
        lbl_2 = torch.zeros(1, n_nodes, device=self.device)
        lbl2 = torch.cat((lbl_1, lbl_2), 1)
        
        self.logger.info(f"[DATA] 节点数量: {n_nodes}")
        self.logger.info(f"[DATA] 特征维度: {data_o.x.shape[1] if hasattr(data_o, 'x') else 'N/A'}")
        self.logger.info(f"[DATA] 对抗标签形状: {lbl2.shape}")
        
        model.train()
        
        # 训练循环 - 详细版本
        start_time = time.time()
        all_epoch_losses = []
        
        self.logger.info("[TRAINING] 开始训练循环...")
        self.logger.info("=" * 80)
        
        for epoch in range(epochs):
            epoch_start = time.time()
            epoch_loss = 0.0
            batch_count = 0
            
            # 详细的损失统计
            loss_stats = {
                "total": 0.0, 
                "bce": 0.0, 
                "contrast": 0.0, 
                "adversarial": 0.0,
                "total_list": [],
                "bce_list": [],
                "contrast_list": [],
                "adversarial_list": []
            }
            
            # Epoch开始信息
            elapsed_total = time.time() - start_time
            self.logger.info(f"[EPOCH {epoch+1:02d}/{epochs}] 开始训练")
            self.logger.info(f"[EPOCH {epoch+1:02d}/{epochs}] 累计训练时间: {elapsed_total:.2f}秒 ({elapsed_total/60:.2f}分钟)")
            
            for i, (labels, inputs) in enumerate(train_loader):
                batch_start = time.time()
                labels = labels.to(self.device)
                optimizer.zero_grad()
                
                try:
                    # 前向传播
                    output, cla_os, cla_os_a, _, logits, log1 = model(data_o, data_a, inputs)
                    
                    # 计算各种损失
                    log = torch.squeeze(sigmoid(output))
                    loss1 = loss_fct(log, labels.float())  # BCE损失
                    
                    # 对比学习损失
                    if float(loss_ratio2) > 0.0:
                        if isinstance(cla_os, (list, tuple)):
                            losses = [ce_loss(lg, tg) for lg, tg in zip(cla_os, cla_os_a)]
                            loss2 = torch.stack(losses).mean()
                        else:
                            loss2 = ce_loss(cla_os, cla_os_a)
                    else:
                        loss2 = torch.tensor(0.0, device=self.device)
                    
                    # 节点对抗损失
                    loss3 = node_loss(logits, lbl2.float())
                    
                    # 总损失
                    total_loss = (loss_ratio1 * loss1 + loss_ratio2 * loss2 + loss_ratio3 * loss3)
                    
                    # 反向传播
                    total_loss.backward()
                    optimizer.step()
                    
                    # 统计损失
                    batch_total_loss = total_loss.item()
                    batch_bce_loss = loss1.item()
                    batch_contrast_loss = loss2.item()
                    batch_adversarial_loss = loss3.item()
                    
                    epoch_loss += batch_total_loss
                    loss_stats["total"] += batch_total_loss
                    loss_stats["bce"] += batch_bce_loss
                    loss_stats["contrast"] += batch_contrast_loss
                    loss_stats["adversarial"] += batch_adversarial_loss
                    
                    loss_stats["total_list"].append(batch_total_loss)
                    loss_stats["bce_list"].append(batch_bce_loss)
                    loss_stats["contrast_list"].append(batch_contrast_loss)
                    loss_stats["adversarial_list"].append(batch_adversarial_loss)
                    
                    batch_count += 1
                    batch_time = time.time() - batch_start
                    
                    # 详细的批次进度报告（每10个batch）
                    if batch_count % 10 == 0:
                        avg_loss = epoch_loss / batch_count
                        progress_percent = batch_count / len(train_loader) * 100
                        
                        self.logger.info(f"[BATCH] Epoch {epoch+1:02d} | Batch {batch_count:04d}/{len(train_loader):04d} ({progress_percent:5.1f}%)")
                        self.logger.info(f"[BATCH] 当前批次损失: 总计={batch_total_loss:.6f}, BCE={batch_bce_loss:.6f}, 对比={batch_contrast_loss:.6f}, 对抗={batch_adversarial_loss:.6f}")
                        self.logger.info(f"[BATCH] 累计平均损失: {avg_loss:.6f}")
                    
                except Exception as e:
                    self.logger.error(f"[ERROR] Epoch {epoch+1}, Batch {batch_count+1} 训练失败: {str(e)}")
                    continue
            
            # Epoch结束统计
            if batch_count > 0:
                epoch_time = time.time() - epoch_start
                avg_epoch_loss = epoch_loss / batch_count
                all_epoch_losses.append(avg_epoch_loss)
                
                # 计算各部分损失的平均值和标准差
                avg_bce = loss_stats["bce"] / batch_count
                avg_contrast = loss_stats["contrast"] / batch_count
                avg_adversarial = loss_stats["adversarial"] / batch_count
                
                std_total = np.std(loss_stats["total_list"]) if len(loss_stats["total_list"]) > 1 else 0.0
                std_bce = np.std(loss_stats["bce_list"]) if len(loss_stats["bce_list"]) > 1 else 0.0
                std_contrast = np.std(loss_stats["contrast_list"]) if len(loss_stats["contrast_list"]) > 1 else 0.0
                std_adversarial = np.std(loss_stats["adversarial_list"]) if len(loss_stats["adversarial_list"]) > 1 else 0.0
                
                # 详细的epoch总结
                self.logger.info(f"[EPOCH {epoch+1:02d}/{epochs}] ========== 训练轮次完成 ==========")
                self.logger.info(f"[EPOCH {epoch+1:02d}/{epochs}] 训练时间: {epoch_time:.2f}秒")
                self.logger.info(f"[EPOCH {epoch+1:02d}/{epochs}] 处理批次数量: {batch_count}")
                self.logger.info(f"[EPOCH {epoch+1:02d}/{epochs}] 损失统计:")
                self.logger.info(f"[EPOCH {epoch+1:02d}/{epochs}]   总损失: {avg_epoch_loss:.6f} ± {std_total:.6f}")
                self.logger.info(f"[EPOCH {epoch+1:02d}/{epochs}]   BCE损失: {avg_bce:.6f} ± {std_bce:.6f}")
                self.logger.info(f"[EPOCH {epoch+1:02d}/{epochs}]   对比学习损失: {avg_contrast:.6f} ± {std_contrast:.6f}")
                self.logger.info(f"[EPOCH {epoch+1:02d}/{epochs}]   节点对抗损失: {avg_adversarial:.6f} ± {std_adversarial:.6f}")
                
                # 训练进度和时间估算
                if epoch > 0:
                    avg_time_per_epoch = (time.time() - start_time) / (epoch + 1)
                    remaining_epochs = epochs - epoch - 1
                    estimated_remaining_time = avg_time_per_epoch * remaining_epochs
                    
                    self.logger.info(f"[PROGRESS] 训练进度: {((epoch+1)/epochs)*100:.1f}% ({epoch+1}/{epochs})")
                    self.logger.info(f"[PROGRESS] 平均每轮时间: {avg_time_per_epoch:.2f}秒")
                    
                    # 损失趋势分析
                    if len(all_epoch_losses) >= 2:
                        loss_trend = all_epoch_losses[-1] - all_epoch_losses[-2]
                        if loss_trend < 0:
                            self.logger.info(f"[PROGRESS] 损失趋势: 下降 ({loss_trend:.6f})")
                        elif loss_trend > 0:
                            self.logger.info(f"[PROGRESS] 损失趋势: 上升 (+{loss_trend:.6f})")
                        else:
                            self.logger.info(f"[PROGRESS] 损失趋势: 稳定")
                
                self.logger.info("-" * 80)
            
            # 定期清理GPU内存
            if epoch % 5 == 0 and torch.cuda.is_available():
                torch.cuda.empty_cache()
                if self.device == 'cuda':
                    gpu_memory_allocated = torch.cuda.memory_allocated(0) / 1024**3
                    self.logger.info(f"[MEMORY] GPU内存清理后使用量: {gpu_memory_allocated:.3f} GB")
        
        # 训练完成总结
        total_training_time = time.time() - start_time
        self.logger.info("=" * 80)
        self.logger.info("[TRAINING] ========== 训练完成 ==========")
        self.logger.info(f"[SUMMARY] 总训练时间: {total_training_time:.2f}秒 ({total_training_time/60:.2f}分钟)")
        self.logger.info(f"[SUMMARY] 平均每轮时间: {total_training_time/epochs:.2f}秒")
        self.logger.info(f"[SUMMARY] 训练轮数: {epochs}")
        self.logger.info(f"[SUMMARY] 总批次数: {epochs * len(train_loader)}")
        
        # 损失收敛分析
        if len(all_epoch_losses) >= 2:
            initial_loss = all_epoch_losses[0]
            final_loss = all_epoch_losses[-1]
            loss_reduction = initial_loss - final_loss
            loss_reduction_percent = (loss_reduction / initial_loss) * 100 if initial_loss > 0 else 0
            
            self.logger.info(f"[SUMMARY] 初始损失: {initial_loss:.6f}")
            self.logger.info(f"[SUMMARY] 最终损失: {final_loss:.6f}")
            self.logger.info(f"[SUMMARY] 损失降低: {loss_reduction:.6f} ({loss_reduction_percent:.2f}%)")
            
            # 计算损失的标准差，评估训练稳定性
            loss_std = np.std(all_epoch_losses)
            loss_mean = np.mean(all_epoch_losses)
            cv = (loss_std / loss_mean) * 100 if loss_mean > 0 else 0
            self.logger.info(f"[SUMMARY] 损失稳定性: 标准差={loss_std:.6f}, 变异系数={cv:.2f}%")
        
        self.logger.info("[EVALUATION] 开始模型评估...")
        self.logger.info("=" * 80)
        
        # 评估阶段
        eval_start_time = time.time()
        model.eval()
        y_pred = []
        y_true = []
        eval_batch_count = 0
        
        self.logger.info("[EVALUATION] ========== 模型评估开始 ==========")
        self.logger.info(f"[EVALUATION] 评估数据批次数量: {len(test_loader)}")
        self.logger.info(f"[EVALUATION] 模型设置为评估模式")
        
        with torch.no_grad():
            for i, (labels, inputs) in enumerate(test_loader):
                batch_eval_start = time.time()
                labels = labels.to(self.device)
                eval_batch_count += 1
                
                try:
                    output, _, _, _, _, _ = model(data_o, data_a, inputs)
                    outputs = sigmoid(output.squeeze())
                    
                    # 收集预测结果
                    batch_pred = outputs.cpu().numpy().tolist()
                    batch_true = labels.cpu().numpy().tolist()
                    
                    y_pred.extend(batch_pred)
                    y_true.extend(batch_true)
                    
                    batch_eval_time = time.time() - batch_eval_start
                    
                    # 每10个批次报告一次评估进度
                    if eval_batch_count % 10 == 0:
                        progress_percent = eval_batch_count / len(test_loader) * 100
                        self.logger.info(f"[EVALUATION] 评估进度: {eval_batch_count}/{len(test_loader)} ({progress_percent:.1f}%)")
                        self.logger.info(f"[EVALUATION] 当前批次样本数: {len(batch_true)}")
                        self.logger.info(f"[EVALUATION] 累计收集样本数: {len(y_true)}")
                    
                except Exception as e:
                    self.logger.error(f"[ERROR] 评估批次 {eval_batch_count} 失败: {str(e)}")
                    continue
        
        total_eval_time = time.time() - eval_start_time
        self.logger.info(f"[EVALUATION] 评估数据收集完成")
        self.logger.info(f"[EVALUATION] 总评估时间: {total_eval_time:.2f}秒")
        self.logger.info(f"[EVALUATION] 平均每批次评估时间: {total_eval_time/len(test_loader):.4f}秒")
        self.logger.info(f"[EVALUATION] 总样本数量: {len(y_true)}")
        
        # 数据统计分析
        if len(y_true) > 0:
            positive_samples = sum(y_true)
            negative_samples = len(y_true) - positive_samples
            positive_ratio = positive_samples / len(y_true) * 100
            
            self.logger.info(f"[DATA_STATS] 正样本数量: {positive_samples}")
            self.logger.info(f"[DATA_STATS] 负样本数量: {negative_samples}")
            self.logger.info(f"[DATA_STATS] 正样本比例: {positive_ratio:.2f}%")
            self.logger.info(f"[DATA_STATS] 数据平衡性: {'平衡' if 40 <= positive_ratio <= 60 else '不平衡'}")
        
        # 计算指标
        if len(y_true) > 0 and len(y_pred) > 0:
            try:
                metrics_start_time = time.time()
                
                # 计算连续值指标
                auroc = roc_auc_score(y_true, y_pred)
                auprc = average_precision_score(y_true, y_pred)
                
                # 计算二分类指标（使用0.5阈值）
                y_pred_binary = [1 if p >= 0.5 else 0 for p in y_pred]
                f1 = f1_score(y_true, y_pred_binary, zero_division=0)
                precision = precision_score(y_true, y_pred_binary, zero_division=0)
                recall = recall_score(y_true, y_pred_binary, zero_division=0)
                
                # 计算混淆矩阵
                tn, fp, fn, tp = confusion_matrix(y_true, y_pred_binary).ravel()
                
                # 计算额外指标
                accuracy = (tp + tn) / (tp + tn + fp + fn) if (tp + tn + fp + fn) > 0 else 0
                specificity = tn / (tn + fp) if (tn + fp) > 0 else 0
                npv = tn / (tn + fn) if (tn + fn) > 0 else 0  # Negative Predictive Value
                
                # 计算预测值统计
                pred_mean = np.mean(y_pred)
                pred_std = np.std(y_pred)
                pred_min = np.min(y_pred)
                pred_max = np.max(y_pred)
                
                metrics_time = time.time() - metrics_start_time
                
                result = {
                    'auroc': float(auroc),
                    'auprc': float(auprc),
                    'f1': float(f1),
                    'precision': float(precision),
                    'recall': float(recall),
                    'accuracy': float(accuracy),
                    'specificity': float(specificity),
                    'npv': float(npv),
                    'loss': epoch_loss / max(batch_count, 1),
                    'cm': (int(tn), int(fp), int(fn), int(tp))
                }
                
                # 详细的评估结果输出
                self.logger.info("=" * 80)
                self.logger.info("[RESULTS] ========== 最终评估结果 ==========")
                self.logger.info(f"[RESULTS] 指标计算时间: {metrics_time:.4f}秒")
                self.logger.info("")
                self.logger.info("[RESULTS] === 主要性能指标 ===")
                self.logger.info(f"[RESULTS] AUROC (Area Under ROC Curve): {auroc:.6f}")
                self.logger.info(f"[RESULTS] AUPRC (Area Under Precision-Recall Curve): {auprc:.6f}")
                self.logger.info(f"[RESULTS] F1-Score: {f1:.6f}")
                self.logger.info("")
                self.logger.info("[RESULTS] === 分类性能指标 ===")
                self.logger.info(f"[RESULTS] 准确率 (Accuracy): {accuracy:.6f} ({accuracy*100:.2f}%)")
                self.logger.info(f"[RESULTS] 精确率 (Precision): {precision:.6f} ({precision*100:.2f}%)")
                self.logger.info(f"[RESULTS] 召回率 (Recall/Sensitivity): {recall:.6f} ({recall*100:.2f}%)")
                self.logger.info(f"[RESULTS] 特异性 (Specificity): {specificity:.6f} ({specificity*100:.2f}%)")
                self.logger.info(f"[RESULTS] 负预测值 (NPV): {npv:.6f} ({npv*100:.2f}%)")
                self.logger.info("")
                self.logger.info("[RESULTS] === 混淆矩阵分析 ===")
                self.logger.info(f"[RESULTS] 真负例 (True Negatives): {tn}")
                self.logger.info(f"[RESULTS] 假正例 (False Positives): {fp}")
                self.logger.info(f"[RESULTS] 假负例 (False Negatives): {fn}")
                self.logger.info(f"[RESULTS] 真正例 (True Positives): {tp}")
                self.logger.info(f"[RESULTS] 总样本数: {tn + fp + fn + tp}")
                self.logger.info("")
                self.logger.info("[RESULTS] === 预测值统计 ===")
                self.logger.info(f"[RESULTS] 预测值均值: {pred_mean:.6f}")
                self.logger.info(f"[RESULTS] 预测值标准差: {pred_std:.6f}")
                self.logger.info(f"[RESULTS] 预测值范围: [{pred_min:.6f}, {pred_max:.6f}]")
                self.logger.info("")
                self.logger.info("[RESULTS] === 训练损失信息 ===")
                self.logger.info(f"[RESULTS] 最终训练损失: {result['loss']:.6f}")
                
                # 性能评估
                self.logger.info("")
                self.logger.info("[RESULTS] === 模型性能评估 ===")
                if auroc >= 0.9:
                    performance_level = "优秀"
                elif auroc >= 0.8:
                    performance_level = "良好"
                elif auroc >= 0.7:
                    performance_level = "中等"
                else:
                    performance_level = "需要改进"
                
                self.logger.info(f"[RESULTS] 模型性能等级: {performance_level} (基于AUROC)")
                
                # 平衡性分析
                if precision > 0 and recall > 0:
                    f1_harmonic = 2 * (precision * recall) / (precision + recall)
                    balance_score = min(precision, recall) / max(precision, recall)
                    self.logger.info(f"[RESULTS] 精确率-召回率平衡性: {balance_score:.4f} (1.0为完全平衡)")
                
                self.logger.info("=" * 80)
                
                return result
                
            except Exception as e:
                self.logger.error(f"[ERROR] 指标计算失败: {str(e)}")
                import traceback
                self.logger.error(f"[ERROR] 详细错误信息: {traceback.format_exc()}")
                raise RuntimeError(f"评估指标计算失败: {str(e)}")
        
        # 如果没有有效数据，抛出异常
        raise RuntimeError("评估数据不足，无法计算性能指标")
    
    def _create_args_from_parameters(self, parameters: Dict[str, Any]) -> argparse.Namespace:
        """
        将优化参数转换为实验配置
        
        Args:
            parameters: 优化参数字典
            
        Returns:
            实验配置的命名空间对象
        """
        # 创建默认参数对象，避免调用settings()解析命令行参数
        args = argparse.Namespace()
        
        # 设置默认值（从parms_setting.py中提取的默认值）
        args.seed = 0
        args.in_file = "dataset1/LDA.edgelist"
        args.neg_sample = "dataset1/non_LDA.edgelist"
        args.validation_type = "5_cv1"
        args.task_type = "LDA"
        args.feature_type = "normal"
        args.noise_std = 0.01
        args.mask_rate = 0.1
        args.augment_seed = None
        args.augment_mode = "static"
        args.augment = ['random_permute_features', 'attribute_mask', 'noise_then_mask']
        args.lr = 5e-4
        args.dropout = 0.1
        args.weight_decay = 5e-4
        args.batch = 25
        args.epochs = 50
        args.loss_ratio1 = 1.0
        args.loss_ratio2 = 0.5
        args.loss_ratio3 = 0.5
        args.dimensions = 256
        args.hidden1 = 128
        args.hidden2 = 64
        args.decoder1 = 512
        args.gat_heads = 4
        args.gt_heads = 4
        args.fusion_heads = 4
        args.fusion_strategy = 'self_attention'
        args.fusion_weight = 0.5
        args.co_hidden_dim = None
        args.use_co_attention = False
        args.co_attention_type = 'transformer'
        args.attention_config = None
        args.use_multihead = False
        args.transformer_style = True
        args.model_type = 'moco'
        args.moco_type = 'basic'
        args.moco_config = None
        args.moco_K = 4096
        args.moco_m = 0.999
        args.moco_T = 0.2
        args.moco_tau1 = 0.2
        args.moco_tau2 = 0.3
        args.moco_queue = 4096
        args.moco_momentum = 0.999
        args.moco_t = 0.2
        args.proj_dim = None
        args.queue_warmup_steps = 0
        args.enable_view_0 = True
        args.num_views = 3
        args.byol_config = None
        args.byol_predictor_dim = 256
        args.byol_ema_momentum = 0.996
        args.byol_temperature = 0.2
        args.threads = 32
        args.num_workers = -1
        args.prefetch_factor = 4
        args.chunk_size = 0
        args.similarity_threshold = 0.5
        args.save_datasets = False
        args.save_format = 'npy'
        args.save_dir_prefix = 'result/data'
        args.run_name = None
        args.shutdown = False
        args.adv_mode = 'none'
        args.adv_norm = 'linf'
        args.adv_eps = 0.01
        args.adv_alpha = 0.005
        args.adv_steps = 0
        args.adv_rand_init = False
        args.adv_project = True
        args.adv_agg = 'mean'
        args.adv_budget = 'shared'
        args.adv_use_amp = False
        args.adv_on_moco = False
        args.adv_seed = None
        args.adv_clip_min = float("-inf")
        args.adv_clip_max = float("inf")
        args.adv_warmup_end = 3
        args.enable_threshold_scan = True
        args.threshold_min = 0.35
        args.threshold_max = 0.65
        args.threshold_step = 0.01
        args.enable_temp_scaling = True
        args.temp_grid_min = 0.5
        args.temp_grid_max = 3.0
        args.temp_grid_num = 26
        args.kfold_recompute = True
        args.kfold_cache = False
        
        # 强制使用CUDA和设置epoch
        args.cuda = True
        args.epochs = 50  # 强制设置epoch为50
        os.environ["CUDA_VISIBLE_DEVICES"] = "0"
        
        # 设置任务类型
        args.task_type = self.task_type
        
        # 设置数据文件路径
        if self.task_type == "LDA":
            args.in_file = self.data_config.get('pos_file', "dataset1/LDA.edgelist")
            args.neg_sample = self.data_config.get('neg_file', "dataset1/non_LDA.edgelist")
        elif self.task_type == "MDA":
            args.in_file = self.data_config.get('pos_file', "dataset1/MDA.edgelist")
            args.neg_sample = self.data_config.get('neg_file', "dataset1/non_MDA.edgelist")
        elif self.task_type == "LMI":
            args.in_file = self.data_config.get('pos_file', "dataset1/LMI.edgelist")
            args.neg_sample = self.data_config.get('neg_file', "dataset1/non_LMI.edgelist")
        
        # 应用优化参数
        for param_name, param_value in parameters.items():
            # 处理参数别名映射
            if param_name == 'alpha':
                args.loss_ratio1 = float(param_value)
                continue
            elif param_name == 'beta':
                args.loss_ratio2 = float(param_value)
                continue
            elif param_name == 'gamma':
                args.loss_ratio3 = float(param_value)
                continue
            
            # 处理新的MoCo参数的特殊类型转换
            if param_name == 'moco_tau1':
                args.moco_tau1 = float(param_value)
                continue
            elif param_name == 'moco_tau2':
                args.moco_tau2 = float(param_value)
                continue
            elif param_name == 'enable_view_0':
                # 处理字符串到布尔值的转换
                if isinstance(param_value, str):
                    args.enable_view_0 = param_value.lower() in ('true', '1', 'yes', 'on')
                else:
                    args.enable_view_0 = bool(param_value)
                continue
            
            if hasattr(args, param_name):
                # 确保参数类型正确
                original_value = getattr(args, param_name)
                original_type = type(original_value)
                if original_type == bool:
                    setattr(args, param_name, bool(param_value))
                elif original_type == int:
                    setattr(args, param_name, int(param_value))
                elif original_type == float:
                    setattr(args, param_name, float(param_value))
                else:
                    setattr(args, param_name, param_value)
            else:
                self.logger.warning(f"未知参数: {param_name}")
        
        # 设置固定的训练配置
        args.epochs = 50  # 强制设置epoch为50，覆盖任何传入的值
        args.validation_type = "5_cv1"  # 使用5折交叉验证
        
        # 确保损失权重合理
        if hasattr(args, 'alpha'):
            args.loss_ratio1 = args.alpha
        if hasattr(args, 'beta'):
            args.loss_ratio2 = args.beta
        if hasattr(args, 'gamma'):
            args.loss_ratio3 = args.gamma
        
        # 确保至少有一个损失权重大于0
        if args.loss_ratio1 <= 0 and args.loss_ratio2 <= 0 and args.loss_ratio3 <= 0:
            args.loss_ratio1 = 1.0
        
        # 设置随机种子
        if not hasattr(args, 'seed') or args.seed is None:
            args.seed = 42
        
        # 向后兼容性：确保新MoCo参数有默认值
        if not hasattr(args, 'moco_tau1') or args.moco_tau1 is None:
            args.moco_tau1 = 0.2
        if not hasattr(args, 'moco_tau2') or args.moco_tau2 is None:
            args.moco_tau2 = 0.3
        if not hasattr(args, 'enable_view_0') or args.enable_view_0 is None:
            args.enable_view_0 = True
        
        # MoCo参数类型确保
        try:
            args.moco_tau1 = float(args.moco_tau1)
            args.moco_tau2 = float(args.moco_tau2)
            if isinstance(args.enable_view_0, str):
                args.enable_view_0 = args.enable_view_0.lower() in ('true', '1', 'yes', 'on')
            else:
                args.enable_view_0 = bool(args.enable_view_0)
        except (ValueError, TypeError) as e:
            self.logger.warning(f"MoCo参数类型转换失败，使用默认值: {e}")
            args.moco_tau1 = 0.2
            args.moco_tau2 = 0.3
            args.enable_view_0 = True
        
        # MoCo proj_dim 兜底：None 或非法值时跟随 hidden2
        try:
            pd = getattr(args, "proj_dim", None)
            if pd is None or int(pd) <= 0:
                args.proj_dim = args.hidden2
        except Exception:
            args.proj_dim = args.hidden2
        
        return args
    
    def validate_parameters(self, parameters: Dict[str, Any]) -> Tuple[bool, List[str]]:
        """
        验证参数的有效性
        
        Args:
            parameters: 参数字典
            
        Returns:
            (is_valid, error_messages): 验证结果和错误信息
        """
        errors = []
        
        # 检查必需的参数
        required_params = ['dimensions', 'hidden1', 'hidden2', 'lr', 'batch']
        for param in required_params:
            if param not in parameters:
                errors.append(f"缺少必需参数: {param}")
        
        # 检查参数范围
        if 'lr' in parameters:
            lr = float(parameters['lr'])
            if lr <= 0 or lr > 1:
                errors.append(f"学习率超出合理范围: {lr}")
        
        if 'batch' in parameters:
            batch = int(parameters['batch'])
            if batch <= 0 or batch > 128:
                errors.append(f"批大小超出合理范围: {batch}")
        
        if 'dropout' in parameters:
            dropout = float(parameters['dropout'])
            if dropout < 0 or dropout >= 1:
                errors.append(f"Dropout比例超出范围[0,1): {dropout}")
        
        # 检查模型结构约束
        if all(key in parameters for key in ['dimensions', 'hidden1', 'hidden2']):
            dims = int(parameters['dimensions'])
            h1 = int(parameters['hidden1'])
            h2 = int(parameters['hidden2'])
            if not (dims >= h1 >= h2 > 0):
                errors.append(f"隐藏层维度应该递减且大于0: dimensions({dims}) >= hidden1({h1}) >= hidden2({h2}) > 0")
        
        # 检查注意力头数约束
        attention_checks = [
            ('hidden1', 'gat_heads'),
            ('hidden2', 'gt_heads'),
            ('hidden2', 'fusion_heads')
        ]
        
        for hidden_key, heads_key in attention_checks:
            if all(key in parameters for key in [hidden_key, heads_key]):
                hidden_dim = int(parameters[hidden_key])
                heads = int(parameters[heads_key])
                if hidden_dim % heads != 0:
                    errors.append(f"{heads_key}({heads})必须能整除{hidden_key}({hidden_dim})")
        
        return len(errors) == 0, errors
    
    def get_objective_value(self, metrics: Dict[str, float]) -> float:
        """
        从评估指标中提取主要优化目标值
        
        Args:
            metrics: 评估指标字典
            
        Returns:
            主要优化目标值（AUROC）
        """
        return metrics.get('AUROC', 0.0)
    
    def get_multi_objective_values(self, metrics: Dict[str, float], 
                                  objectives: List[str]) -> Dict[str, float]:
        """
        从指标中提取多个目标函数值
        
        Args:
            metrics: 性能指标字典
            objectives: 目标函数名称列表
            
        Returns:
            多目标函数值字典
        """
        objective_values = {}
        
        for obj_name in objectives:
            if obj_name in metrics:
                objective_values[obj_name] = metrics[obj_name]
            else:
                # 尝试映射常见的目标名称
                mapping = {
                    'auroc': 'AUROC',
                    'auprc': 'AUPRC', 
                    'f1': 'F1',
                    'precision': 'precision',
                    'recall': 'recall',
                    'primary': 'AUROC'  # 默认主要目标
                }
                mapped_name = mapping.get(obj_name.lower(), obj_name)
                objective_values[obj_name] = metrics.get(mapped_name, 0.0)
        
        return objective_values
    
    def create_optimization_result(self, parameters: Dict[str, Any], 
                                 metrics: Dict[str, float], 
                                 iteration: int,
                                 evaluation_time: float) -> OptimizationResult:
        """
        创建优化结果对象
        
        Args:
            parameters: 参数字典
            metrics: 评估指标
            iteration: 迭代次数
            evaluation_time: 评估耗时
            
        Returns:
            OptimizationResult对象
        """
        return OptimizationResult(
            parameters=parameters,
            objective_value=self.get_objective_value(metrics),
            metrics=metrics,
            iteration=iteration,
            timestamp=datetime.now(),
            evaluation_time=evaluation_time,
            error_info=metrics.get('error')
        )
    
    def cleanup(self):
        """清理资源"""
        if torch.cuda.is_available():
            torch.cuda.empty_cache()
        self.logger.info("[CLEANUP] TaskEvaluator资源清理完成")


def create_task_evaluator(task_type: str = "LDA", 
                         data_config: Optional[Dict[str, Any]] = None,
                         force_cuda: bool = True) -> TaskEvaluator:
    """
    创建任务评估器的工厂函数 - 纯真实训练版本
    
    Args:
        task_type: 任务类型
        data_config: 数据配置
        force_cuda: 是否强制使用CUDA，默认True
        
    Returns:
        TaskEvaluator实例（只支持真实训练）
        
    Note:
        此版本移除了所有模拟训练代码，只支持真实训练。
        如果真实训练模块导入失败，将抛出异常。
    """
    return TaskEvaluator(task_type, data_config, force_cuda)


def test_task_evaluator():
    """测试TaskEvaluator的基本功能"""
    print("测试TaskEvaluator（纯真实训练版本）...")
    
    try:
        # 创建评估器（强制CUDA）
        evaluator = TaskEvaluator(task_type="LDA", force_cuda=True)
        
        # 测试参数
        test_params = {
            'dimensions': 256,
            'hidden1': 128,
            'hidden2': 64,
            'decoder1': 512,
            'lr': 0.001,
            'dropout': 0.1,
            'weight_decay': 0.0005,
            'batch': 32,
            'epochs': 50,
            'gat_heads': 4,
            'gt_heads': 4,
            'fusion_heads': 4,
            'alpha': 1.0,
            'beta': 0.5,
            'gamma': 0.5,
            'fusion_strategy': 'self_attention',
            'feature_type': 'normal',
            'moco_type': 'basic'
        }
        
        # 验证参数
        is_valid, errors = evaluator.validate_parameters(test_params)
        print(f"参数验证结果: {is_valid}")
        if errors:
            print(f"验证错误: {errors}")
        
        # 测试参数转换
        args = evaluator._create_args_from_parameters(test_params)
        print(f"参数转换成功，任务类型: {args.task_type}")
        
        print("TaskEvaluator（纯真实训练版本）功能测试通过")
        
    except Exception as e:
        print(f"TaskEvaluator测试失败: {e}")
        import traceback
        traceback.print_exc()
    finally:
        if 'evaluator' in locals():
            evaluator.cleanup()


if __name__ == "__main__":
    test_task_evaluator()