""" Training engine for Spatial GNN cell-type annotation. Key differences from base TrainerEngine: - Operates on full graph (not mini-batches) per donor subgraph - Uses subgraph sampling: each batch is a donor's cells + their KNN graph - Model forward: (recon, logits, z) with edge_index argument """ import os import time import numpy as np import torch import torch.nn.functional as F from tqdm import tqdm from sklearn.metrics import precision_recall_fscore_support, roc_auc_score class SpatialGNNTrainerEngine: 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): return torch.log1p(x) def compute_loss(self, X, y_c, y_sc, y_st, confidence, edge_index): X = self._normalize(X) recon, logits, z = self.model(X, edge_index) logit_c, logit_sc, logit_st = logits loss_recon = F.mse_loss(recon, X) loss_c = F.cross_entropy(logit_c, y_c) loss_sc = F.cross_entropy(logit_sc, y_sc) loss_st = (F.cross_entropy(logit_st, y_st, reduction='none') * confidence).mean() total_loss = loss_recon + loss_c + loss_sc + loss_st metrics = { 'total': total_loss.item(), '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, metrics, logits_dict, z def _run_subgraphs(self, subgraphs, train=True): """Process donor subgraphs. Each subgraph is a dict with tensors + edge_index.""" if train: self.model.train() else: self.model.eval() agg = {'total': 0.0, 'recon': 0.0, 'class': 0.0, 'subclass': 0.0, 'supertype': 0.0} n_batches = 0 for sg in subgraphs: X = sg['X'].to(self.device) y_c = sg['y_class'].to(self.device) y_sc = sg['y_subclass'].to(self.device) y_st = sg['y_supertype'].to(self.device) conf = sg['confidence'].to(self.device) ei = sg['edge_index'].to(self.device) if train: self.optimizer.zero_grad() loss, metrics, _, _ = self.compute_loss(X, y_c, y_sc, y_st, conf, ei) loss.backward() torch.nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=5.0) self.optimizer.step() else: with torch.no_grad(): _, metrics, _, _ = self.compute_loss(X, y_c, y_sc, y_st, conf, ei) for k in agg: agg[k] += metrics[k] n_batches += 1 return {k: v / max(n_batches, 1) for k, v in agg.items()} def train(self, train_subgraphs, val_subgraphs): os.makedirs(self.args.save_dir, exist_ok=True) best_path = os.path.join(self.args.save_dir, "best_model.pth") patience_counter = 0 best_val_metrics = None for epoch in range(1, self.args.max_epochs + 1): t0 = time.time() train_m = self._run_subgraphs(train_subgraphs, train=True) val_m = self._run_subgraphs(val_subgraphs, train=False) self.scheduler.step() self.logger.info( f"Epoch [{epoch:03d}/{self.args.max_epochs:03d}] | " f"Time: {time.time()-t0:.1f}s | LR: {self.scheduler.get_last_lr()[0]:.2e}" ) self.logger.info( f" [Train] Total: {train_m['total']:.4f} | Recon: {train_m['recon']:.4f} | " f"Class: {train_m['class']:.4f} | Subclass: {train_m['subclass']:.4f} | " f"Supertype: {train_m['supertype']:.4f}" ) self.logger.info( f" [Val] Total: {val_m['total']:.4f} | Recon: {val_m['recon']:.4f} | " f"Class: {val_m['class']:.4f} | Subclass: {val_m['subclass']:.4f} | " f"Supertype: {val_m['supertype']:.4f}" ) if best_val_metrics is not None: self.logger.info( f" [Best] Total: {self.best_val_loss:.4f} | Recon: {best_val_metrics['recon']:.4f} | " f"Class: {best_val_metrics['class']:.4f} | Subclass: {best_val_metrics['subclass']:.4f} | " f"Supertype: {best_val_metrics['supertype']:.4f}" ) if val_m['total'] < self.best_val_loss: self.best_val_loss = val_m['total'] best_val_metrics = val_m patience_counter = 0 torch.save(self.model.state_dict(), best_path) self.logger.info("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_subgraphs): self.logger.info("\nLoading best model for test-set evaluation...") best_path = os.path.join(self.args.save_dir, "best_model.pth") self.model.load_state_dict(torch.load(best_path, map_location=self.device)) self.model.eval() all_y_true = {'class': [], 'subclass': [], 'supertype': []} all_y_pred = {'class': [], 'subclass': [], 'supertype': []} all_y_prob = {'class': [], 'subclass': [], 'supertype': []} all_z, all_spatial, all_batch, all_st, all_cps = [], [], [], [], [] agg = {'total': 0.0, 'recon': 0.0, 'class': 0.0, 'subclass': 0.0, 'supertype': 0.0} n_batches = 0 for sg in test_subgraphs: X = sg['X'].to(self.device) y_c = sg['y_class'].to(self.device) y_sc = sg['y_subclass'].to(self.device) y_st = sg['y_supertype'].to(self.device) conf = sg['confidence'].to(self.device) ei = sg['edge_index'].to(self.device) _, metrics, logits_dict, z = self.compute_loss(X, y_c, y_sc, y_st, conf, ei) for k in agg: agg[k] += metrics[k] n_batches += 1 all_z.append(z.cpu()) all_spatial.append(sg['spatial']) all_batch.append(sg['batch_id']) all_st.append(sg['y_supertype']) all_cps.append(sg['cps']) for task_key, logit_key in [('class', 'class'), ('subclass', 'subclass'), ('supertype', 'supertype')]: all_y_true[task_key].append(sg[f'y_{task_key}'].numpy()) all_y_pred[task_key].append(logits_dict[task_key].argmax(dim=-1).cpu().numpy()) all_y_prob[task_key].append(F.softmax(logits_dict[task_key], dim=-1).cpu().numpy()) test_m = {k: v / max(n_batches, 1) for k, v in agg.items()} self.logger.info( f" [Test] Total: {test_m['total']:.4f} | Recon: {test_m['recon']:.4f} | " f"Class: {test_m['class']:.4f} | Subclass: {test_m['subclass']:.4f} | " f"Supertype: {test_m['supertype']:.4f}" ) final_true = {k: np.concatenate(v) for k, v in all_y_true.items()} final_pred = {k: np.concatenate(v) for k, v in all_y_pred.items()} final_prob = {k: np.concatenate(v, axis=0) for k, v in all_y_prob.items()} self._log_classification_metrics(final_true, final_pred) self._log_auc_roc_metrics(final_true, final_prob, { 'class': self.args.output_num[0], 'subclass': self.args.output_num[1], 'supertype': self.args.output_num[2], }) res = { 'latent': torch.cat(all_z).numpy(), 'spatial': torch.cat(all_spatial).numpy(), 'batch': torch.cat(all_batch).numpy(), 'supertype': torch.cat(all_st).numpy(), 'cps': torch.cat(all_cps).numpy(), } 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 def _log_classification_metrics(self, y_true_dict, y_pred_dict, prefix="Test"): self.logger.info(f"========== {prefix} Classification Metrics ==========") for task in ['class', 'subclass', 'supertype']: y_true, y_pred = y_true_dict[task], y_pred_dict[task] 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_p, per_r, _, support = precision_recall_fscore_support(y_true, y_pred, average=None, zero_division=0) self.logger.info(f"[{task.upper()}] Macro - P: {macro_p:.4f} | R: {macro_r:.4f} | F1: {macro_f1:.4f}") self.logger.info(f"[{task.upper()}] Micro - P: {micro_p:.4f} | R: {micro_r:.4f} | F1: {micro_f1:.4f}") logs = [f"C{i}(S={support[i]}): P={per_p[i]:.4f}/R={per_r[i]:.4f}" for i in range(len(per_p)) if support[i] > 0 or per_p[i] > 0] self.logger.info(f"[{task.upper()}] Per-class: {' | '.join(logs)}") self.logger.info("-" * 50) def _log_auc_roc_metrics(self, y_true_dict, y_prob_dict, num_classes_dict, prefix="Test"): self.logger.info(f"========== {prefix} AUC-ROC Metrics ==========") for task in ['class', 'subclass', 'supertype']: y_true, y_prob = y_true_dict[task], y_prob_dict[task] num_c = num_classes_dict[task] y_onehot = np.zeros_like(y_prob) y_onehot[np.arange(len(y_true)), y_true] = 1 micro_auc = roc_auc_score(y_onehot.ravel(), y_prob.ravel()) valid_aucs = [] for c in range(num_c): binary = (y_true == c).astype(int) if len(np.unique(binary)) == 2: valid_aucs.append(roc_auc_score(binary, y_prob[:, c])) macro_auc = np.mean(valid_aucs) if valid_aucs else 0.0 self.logger.info(f"[{task.upper()}] AUC-ROC - Macro: {macro_auc:.4f} | Micro: {micro_auc:.4f} | (Valid: {len(valid_aucs)}/{num_c})") self.logger.info("-" * 50)