external/SEA-AD/MJM/src/engines/trainer.py

import os
import time
import torch
import torch.nn.functional as F
import numpy as np
from tqdm import tqdm
import numpy as np
from sklearn.metrics import precision_recall_fscore_support, roc_auc_score


class TrainerEngine:
    def __init__(self, model, optimizer, scheduler, device, logger, args):
        self.model = model
        self.optimizer = optimizer
        self.scheduler = scheduler
        self.device = device
        self.logger = logger
        self.args = args
        self.best_val_loss = float('inf')

    def _normalize(self, x, is_norm=True, method='log1p'):
        if is_norm:
            if method == 'log1p':
                return torch.log1p(x)
            else:
                raise ValueError(f"Unsupported normalization: {method}")
        else:
            if method == 'log1p':
                return torch.exp(x)-1
            else:
                raise ValueError(f"Unsupported normalization: {method}")



    def log_classification_metrics(self, y_true_dict, y_pred_dict, prefix="Test"):
        """
        计算并记录三个层级分类任务的 Precision, Recall, Macro/Micro F1 以及单类指标。
        
        Args:
            y_true_dict: dict, 包含 'class', 'subclass', 'supertype' 的真实标签 Numpy 数组
            y_pred_dict: dict, 包含 'class', 'subclass', 'supertype' 的预测标签 Numpy 数组
            prefix: str, 日志前缀，例如 'Val' 或 'Test'
        """
        self.logger.info(f"========== {prefix} Classification Metrics ==========")
        
        tasks = ['class', 'subclass', 'supertype']
        
        for task in tasks:
            y_true = y_true_dict[task]
            y_pred = y_pred_dict[task]
            
            # 计算 Macro 和 Micro 级别的总体指标
            # zero_division=0 极其重要，防止某些罕见细胞在当前 batch/epoch 没出现时报错
            macro_p, macro_r, macro_f1, _ = precision_recall_fscore_support(
                y_true, y_pred, average='macro', zero_division=0
            )
            micro_p, micro_r, micro_f1, _ = precision_recall_fscore_support(
                y_true, y_pred, average='micro', zero_division=0
            )
            
            # 计算 Per-class (单类) 级别的指标
            per_class_p, per_class_r, per_class_f1, support = precision_recall_fscore_support(
                y_true, y_pred, average=None, zero_division=0
            )
            
            # 1. 记录总体指标 (Macro / Micro)
            self.logger.info(f"[{task.upper()}] Macro  - Precision: {macro_p:.4f} | Recall: {macro_r:.4f} | F1: {macro_f1:.4f}")
            self.logger.info(f"[{task.upper()}] Micro  - Precision: {micro_p:.4f} | Recall: {micro_r:.4f} | F1: {micro_f1:.4f}")
            
            # 2. 紧凑记录单类指标 (Per-class)
            # 为了防止日志过长，只打印 Support > 0 (真实存在的类) 或有预测值的类
            per_class_logs = []
            for i in range(len(per_class_p)):
                # 过滤掉既没有真实样本，又没有被预测为该类的“空类”
                if support[i] > 0 or per_class_p[i] > 0:
                    per_class_logs.append(f"C{i}(S={support[i]}): P={per_class_p[i]:.4f}/R={per_class_r[i]:.4f}")
            
            # 将单类指标合并为一行长字符串记录（或者按固定数量换行）
            per_class_str = " | ".join(per_class_logs)
            self.logger.info(f"[{task.upper()}] Per-class P/R: {per_class_str}")
            self.logger.info("-" * 50)



    def log_auc_roc_metrics(self, y_true_dict, y_prob_dict, num_classes_dict, prefix="Test"):
        """
        鲁棒的多分类 AUC-ROC 计算模块。
        
        Args:
            y_true_dict: dict, 包含真实标签的 1D Numpy 数组
            y_prob_dict: dict, 包含经过 Softmax 的预测概率的 2D Numpy 数组 [N, C]
            num_classes_dict: dict, 各个任务的类别总数，例如 {'class': 3, 'subclass': 24, 'supertype': 137}
            prefix: str, 日志前缀
        """
        self.logger.info(f"========== {prefix} AUC-ROC Metrics ==========")
        
        tasks = ['class', 'subclass', 'supertype']
        
        for task in tasks:
            y_true = y_true_dict[task]
            y_prob = y_prob_dict[task]
            num_c = num_classes_dict[task]
            
            # 1. 计算 Micro AUC (全局看作一个巨大的二分类任务)
            # 将 y_true 转为 one-hot 格式，方便与概率矩阵直接计算
            y_true_onehot = np.zeros_like(y_prob)
            y_true_onehot[np.arange(len(y_true)), y_true] = 1
            
            # Micro AUC: 展平所有维度直接算
            micro_auc = roc_auc_score(y_true_onehot.ravel(), y_prob.ravel())
            
            # 2. 鲁棒地计算 Macro AUC (One-vs-Rest)
            # 针对长尾分布：只对存在正样本且存在负样本的类进行计算，防止 sklearn 报错
            valid_auc_scores = []
            for c in range(num_c):
                y_true_binary = (y_true == c).astype(int)
                
                # 只有当该类同时存在 0 和 1 的时候（即既有正样本也有负样本），才能算 AUC
                if len(np.unique(y_true_binary)) == 2:
                    auc = roc_auc_score(y_true_binary, y_prob[:, c])
                    valid_auc_scores.append(auc)
                    
            # 取有效类的均值作为 Macro AUC
            macro_auc = np.mean(valid_auc_scores) if len(valid_auc_scores) > 0 else 0.0
            
            # 3. 记录日志
            self.logger.info(f"[{task.upper()}] AUC-ROC - Macro: {macro_auc:.4f} | Micro: {micro_auc:.4f} | (Valid classes: {len(valid_auc_scores)}/{num_c})")
            
            self.logger.info("-" * 50)



    def compute_loss(self, batch_data):
        X = batch_data['X'].to(self.device)
        # batch_id = batch_data['batch_id'].to(self.device)
        y_c = batch_data['y_class'].to(self.device)
        y_sc = batch_data['y_subclass'].to(self.device)
        y_st = batch_data['y_supertype'].to(self.device)
        confidence = batch_data['confidence'].to(self.device)

        # recon_X, logits, z = self.model(X, batch_id)
        X = self._normalize(X)  # log(1+x) 处理输入特征的数值范围
        recon_X, logits, z = self.model(X)

        logit_c, logit_sc, logit_st = logits

        loss_recon = F.mse_loss(recon_X, X)
        loss_c = F.cross_entropy(logit_c, y_c)
        loss_sc = F.cross_entropy(logit_sc, y_sc)
        
        # 带有 Confidence 的样本级加权 Loss
        loss_st_unweighted = F.cross_entropy(logit_st, y_st, reduction='none')
        loss_st = (loss_st_unweighted * confidence).mean()

        # total_loss = 1.0 * loss_recon + 0.5 * loss_c + 1.0 * loss_sc + 2.0 * loss_st
        total_loss = 1.0 * loss_recon + 1.0 * loss_c + 1.0 * loss_sc + 1.0 * loss_st
        
        metrics = {'total': total_loss, 'recon': loss_recon.item(), 'class': loss_c.item(), 'subclass': loss_sc.item(), 'supertype': loss_st.item()}
        logits_dict = {'class': logit_c, 'subclass': logit_sc, 'supertype': logit_st}
        return total_loss, loss_recon, metrics, logits_dict, z

    def train_epoch(self, dataloader):
        self.model.train()
        epoch_metrics = {'total': 0.0, 'recon': 0.0, 'class': 0.0, 'subclass': 0.0, 'supertype': 0.0}
        
        for batch_data in tqdm(dataloader, desc="Training"):
            self.optimizer.zero_grad()
            loss, _, metrics, _, _ = self.compute_loss(batch_data)
            loss.backward()
            torch.nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=5.0)
            self.optimizer.step()
            
            for k in epoch_metrics: epoch_metrics[k] += metrics[k]
            
        return {k: v / len(dataloader) for k, v in epoch_metrics.items()}

    @torch.no_grad()
    def eval_epoch(self, dataloader):
        self.model.eval()
        epoch_metrics = {'total': 0.0, 'recon': 0.0, 'class': 0.0, 'subclass': 0.0, 'supertype': 0.0}

        for batch_data in tqdm(dataloader, desc="Evaluating"):
            _, _, metrics, _, _ = self.compute_loss(batch_data)
            for k in epoch_metrics: epoch_metrics[k] += metrics[k]

        return {k: v / len(dataloader) for k, v in epoch_metrics.items()}

    def train(self, train_loader, val_loader):
        os.makedirs(self.args.save_dir, exist_ok=True)
        best_model_path = os.path.join(self.args.save_dir, "best_model.pth")
        patience_counter = 0

        for epoch in range(1, self.args.max_epochs + 1):
            start_time = time.time()
            train_metrics = self.train_epoch(train_loader)
            val_metrics = self.eval_epoch(val_loader)
            self.scheduler.step()
            
            self.logger.info(f"Epoch [{epoch:03d}/{self.args.max_epochs:03d}] | Time: {time.time()-start_time:.1f}s | LR: {self.scheduler.get_last_lr()[0]:.2e}")
            self.logger.info(f"  [Train] Total: {train_metrics['total']:.4f} | Recon: {train_metrics['recon']:.4f} | Class: {train_metrics['class']:.4f} | Subclass: {train_metrics['subclass']:.4f} | Supertype: {train_metrics['supertype']:.4f}")
            self.logger.info(f"  [Val]   Total: {val_metrics['total']:.4f} | Recon: {val_metrics['recon']:.4f} | Class: {val_metrics['class']:.4f} | Subclass: {val_metrics['subclass']:.4f} | Supertype: {val_metrics['supertype']:.4f}")
            if epoch > 1:
                self.logger.info(f"  [Best Val] Total: {self.best_val_loss:.4f} | Recon: {best_val_metrics['recon']:.4f} | Class: {best_val_metrics['class']:.4f} | Subclass: {best_val_metrics['subclass']:.4f} | Supertype: {best_val_metrics['supertype']:.4f}")
            if val_metrics['total'] < self.best_val_loss:
                self.best_val_loss = val_metrics['total']
                best_val_metrics = val_metrics
                patience_counter = 0
                torch.save(self.model.state_dict(), best_model_path)
                self.logger.info(f"Best model saved!")
            else:
                patience_counter += 1
                if patience_counter >= self.args.patience:
                    self.logger.info("Early stopping triggered!")
                    break

    @torch.no_grad()
    def test(self, test_loader):
        self.logger.info("\nLoading best model for Test set evaluation...")
        best_model_path = os.path.join(self.args.save_dir, "best_model.pth")
        self.model.load_state_dict(torch.load(best_model_path, map_location=self.device))
        self.model.eval()
        
        res = {'latent': [], 'spatial': [], 'batch': [], 'supertype': [], 'cps': []}
        epoch_metrics = {'total': 0.0, 'recon': 0.0, 'class': 0.0, 'subclass': 0.0, 'supertype': 0.0}
        # 用于收集全 Epoch 的真实标签和预测结果
        all_y_true = {'class': [], 'subclass': [], 'supertype': []}
        all_y_pred = {'class': [], 'subclass': [], 'supertype': []}
        # 🌟 新增：用于收集预测概率 [N, C] 的容器
        all_y_prob = {'class': [], 'subclass': [], 'supertype': []}
        for batch_data in test_loader:
            _, _, metrics, logits_dict, z = self.compute_loss(batch_data)
            res['latent'].append(z.cpu())
            res['spatial'].append(batch_data['spatial'].cpu())
            res['batch'].append(batch_data['batch_id'].cpu())
            res['supertype'].append(batch_data['y_supertype'].cpu())
            res['cps'].append(batch_data['cps'].cpu())
            for k in epoch_metrics: epoch_metrics[k] += metrics[k]

            # 2. 提取真实的标签并转为 CPU Numpy
            all_y_true['class'].append(batch_data['y_class'].cpu().numpy())
            all_y_true['subclass'].append(batch_data['y_subclass'].cpu().numpy())
            all_y_true['supertype'].append(batch_data['y_supertype'].cpu().numpy())
            
            # 🌟 新增：对 logits 进行 Softmax 转为概率，并收集 [Batch, Num_Classes]
            all_y_prob['class'].append(F.softmax(logits_dict['class'], dim=-1).cpu().numpy())
            all_y_prob['subclass'].append(F.softmax(logits_dict['subclass'], dim=-1).cpu().numpy())
            all_y_prob['supertype'].append(F.softmax(logits_dict['supertype'], dim=-1).cpu().numpy())

            # 3. 从 logits 中提取预测类别 (argmax)，并转为 CPU Numpy
            # 假设 compute_loss 返回了 logit_c, logit_sc, logit_st 组成的 logits_dict
            # 这里为了演示，我假设你的 logits 已经拿到了
            logit_c = logits_dict['class']
            logit_sc = logits_dict['subclass']
            logit_st = logits_dict['supertype']
        
            all_y_pred['class'].append(logit_c.argmax(dim=-1).cpu().numpy())
            all_y_pred['subclass'].append(logit_sc.argmax(dim=-1).cpu().numpy())
            all_y_pred['supertype'].append(logit_st.argmax(dim=-1).cpu().numpy())

        test_metrics =  {k: v / len(test_loader) for k, v in epoch_metrics.items()}            
        self.logger.info(f"  [Test] Total: {test_metrics['total']:.4f} | Recon: {test_metrics['recon']:.4f} | Class: {test_metrics['class']:.4f} | Subclass: {test_metrics['subclass']:.4f} | Supertype: {test_metrics['supertype']:.4f}")
        # 将 List of Numpy arrays 拼接成一个完整的大一维 Array
        final_y_true = {k: np.concatenate(v) for k, v in all_y_true.items()}
        final_y_pred = {k: np.concatenate(v) for k, v in all_y_pred.items()}
        
        # 🌟 调用我们刚才写的日志函数计算并打印 P, R, F1
        self.log_classification_metrics(final_y_true, final_y_pred, prefix='test')

        # 🌟 新增：拼接概率矩阵 (沿着样本维度 dim=0 拼接)
        final_y_prob = {k: np.concatenate(v, axis=0) for k, v in all_y_prob.items()}
        num_classes_dict = {
            'class':     self.args.output_num[0],
            'subclass':  self.args.output_num[1],
            'supertype': self.args.output_num[2],
        }
        self.log_auc_roc_metrics(final_y_true, final_y_prob, num_classes_dict, prefix='Test')


        res = {k: torch.cat(v, dim=0).numpy() for k, v in res.items()}
        out_path = os.path.join(self.args.save_dir, 'test_features.npz')
        np.savez_compressed(out_path, **res)
        self.logger.info(f"Features saved to: {out_path}")


        return res