LD-FPG-main/chebnet_multi.py

################################################################################
# %% Imports
################################################################################
import os
import sys
import json
import yaml
import argparse
import logging
import h5py
import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
import math
import time
from typing import Dict, List, Optional, Tuple, Any

from torch_geometric.data import Data
from torch_geometric.loader import DataLoader
from torch_geometric.nn import ChebConv, global_mean_pool
from torch_cluster import knn_graph
from sklearn.model_selection import train_test_split
from sklearn.neighbors import NearestNeighbors # New dependency

################################################################################
# (A) Argument Parsing
################################################################################
parser = argparse.ArgumentParser(
    description="Protein Reconstruction: HNO + Single Decoder + Optional Dihedral Loss (Multi-System Version)"
)
parser.add_argument("--config", type=str, required=True, help="Path to YAML configuration file.")
parser.add_argument("--debug", action="store_true", help="Enable debug logging.")
args = parser.parse_args()

################################################################################
# (B) Pre-Logging Config Load
################################################################################
LOG_FILE_DEFAULT = "logfile_multi_system.log"
log_file_path = LOG_FILE_DEFAULT
try:
    with open(args.config, "r") as f:
        temp_config = yaml.safe_load(f)
        log_file_path = temp_config.get("log_file", LOG_FILE_DEFAULT)
except Exception as e:
    print(f"[Warning] Could not pre-load log file path from config ({args.config}): {e}. Using default: {LOG_FILE_DEFAULT}")

################################################################################
# (C) Logging Setup
################################################################################
logger = logging.getLogger("ProteinReconstruction")
logger.setLevel(logging.DEBUG if args.debug else logging.INFO)

if not logger.handlers:
    formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
    try:
        fh = logging.FileHandler(log_file_path, mode="w")
        fh.setLevel(logging.DEBUG if args.debug else logging.INFO)
        fh.setFormatter(formatter)
        logger.addHandler(fh)
    except IOError as e:
        print(f"Warning: Could not write to log file {log_file_path}: {e}. Logging to console only.")
    ch = logging.StreamHandler(sys.stdout)
    ch.setLevel(logging.DEBUG if args.debug else logging.INFO)
    ch.setFormatter(formatter)
    logger.addHandler(ch)

logger.info(f"Logger initialized. Log file: {log_file_path}")
if args.debug: logger.debug("Debug mode is ON.")

################################################################################
# (D) Device Setup (Global)
################################################################################
device_name = "cpu"
if torch.cuda.is_available():
    try:
        cuda_device_index = temp_config.get("cuda_device", 0) if 'temp_config' in locals() else 0
        device_name = f"cuda:{cuda_device_index}"
        torch.cuda.get_device_name(cuda_device_index)
    except Exception:
        logger.warning(f"Could not validate CUDA device {cuda_device_index}. Defaulting to cuda:0 if available, else CPU.")
        if torch.cuda.is_available(): device_name = "cuda:0"
global_device = torch.device(device_name)
logger.info(f"Initial device check: {global_device}")


################################################################################
# (E) Utility Functions
################################################################################

# --- PDB Parsing ---
def parse_pdb(filename: str, logger: logging.Logger) -> Tuple[Dict, List, Dict]:
    """Parses ATOM records from a PDB, returning atom info and C-alpha indices."""
    backbone_atoms = {"N", "CA", "C", "O", "OXT"}
    atoms_in_order = []; ca_indices = {}; processed_atom_indices = set()
    try:
        with open(filename, 'r') as pdb_file:
            for line in pdb_file:
                if not line.startswith("ATOM  "): continue
                alt_loc = line[16].strip()
                if alt_loc not in ['', 'A']: continue

                atom_serial = int(line[6:11])
                if atom_serial in processed_atom_indices: continue
                processed_atom_indices.add(atom_serial)

                atom_name = line[12:16].strip()
                res_name = line[17:20].strip()
                chain_id = line[21].strip()
                res_seq = int(line[22:26])
                orig_res_id = f"{chain_id}:{res_name}:{res_seq}"
                category = "backbone" if atom_name in backbone_atoms else "sidechain"

                atoms_in_order.append((orig_res_id, atom_serial, category, atom_name))
                if atom_name == 'CA': ca_indices[res_seq] = atom_serial

    except FileNotFoundError: logger.error(f"PDB not found: {filename}"); return {}, [], {}
    logger.info(f"Parsed {len(atoms_in_order)} ATOM records from {filename}, found {len(ca_indices)} C-alphas.")
    return {}, atoms_in_order, ca_indices

def renumber_atoms_and_residues(atoms_in_order: List[Tuple[str, int, str, str]], ca_serial_indices: Dict) -> Tuple[Dict, Dict, Dict, List[int]]:
    """Renumbers residues and atoms, and maps original C-alpha serials to new indices."""
    new_res_dict, orig_atom_map = {}, {}
    next_new_res_id, next_new_atom_index = 0, 0
    orig_res_map = {}
    
    # Preserve original residue order
    seen_res_order = {}
    res_order_counter = 0
    for r_id, _, _, _ in atoms_in_order:
        if r_id not in seen_res_order:
            seen_res_order[r_id] = res_order_counter
            res_order_counter += 1

    sortable = [(seen_res_order[r_id], serial, r_id, cat, name) for r_id, serial, cat, name in atoms_in_order]
    sortable.sort()

    for _, serial, r_id, cat, name in sortable:
        if r_id not in orig_res_map:
            orig_res_map[r_id] = next_new_res_id
            new_res_dict[next_new_res_id] = {"backbone": [], "sidechain": []}
            next_new_res_id += 1
        
        new_res_id = orig_res_map[r_id]
        new_res_dict[new_res_id][cat].append(next_new_atom_index)
        orig_atom_map[serial] = next_new_atom_index
        next_new_atom_index += 1

    # Map original CA serial numbers to the new, renumbered 0-based indices
    new_ca_indices = [orig_atom_map[ca_serial] for res_seq, ca_serial in sorted(ca_serial_indices.items()) if ca_serial in orig_atom_map]
    
    logger.info(f"Renumbered {next_new_res_id} residues & {next_new_atom_index} atoms. Mapped {len(new_ca_indices)} C-alpha indices.")
    return new_res_dict, orig_atom_map, {}, new_ca_indices


def get_global_indices(renumbered_dict: Dict) -> Tuple[torch.Tensor, torch.Tensor]:
    """Extracts sorted global lists of backbone and sidechain atom indices as tensors."""
    bb_idx, sc_idx = [], []
    for res_id in sorted(renumbered_dict.keys()):
        bb_idx.extend(renumbered_dict[res_id]["backbone"])
        sc_idx.extend(renumbered_dict[res_id]["sidechain"])
    return torch.tensor(bb_idx, dtype=torch.long), torch.tensor(sc_idx, dtype=torch.long)

# --- JSON Loading ---
# This function is unchanged and should work fine.
def load_heavy_atom_coords_from_json(json_file: str, logger: logging.Logger) -> Tuple[List[torch.Tensor], int]:
    logger.info(f"Loading coordinates from JSON: {json_file}")
    try:
        with open(json_file, "r") as f: data = json.load(f)
    except (FileNotFoundError, json.JSONDecodeError) as e:
        logger.error(f"Error reading JSON {json_file}: {e}"); return [], -1
    
    try:
        keys_int = sorted([int(k) for k in data.keys()])
        keys_str = [str(k) for k in keys_int]
        if not keys_str: logger.error("No residue data in JSON."); return [], -1
        
        frame_data = data[keys_str[0]]["heavy_atom_coords_per_frame"]
        n_frames = len(frame_data)
        if n_frames == 0: logger.warning("JSON contains 0 frames."); return [], 0

        coords_frames, n_atoms_check = [], -1
        for frame_idx in range(n_frames):
            frame_coords_np = []
            current_atoms = 0
            for res_key in keys_str:
                coords = np.array(data[res_key]["heavy_atom_coords_per_frame"][frame_idx], dtype=np.float32)
                if coords.ndim != 2 or coords.shape[1] != 3: raise ValueError("Bad coordinate shape")
                frame_coords_np.append(coords)
                current_atoms += coords.shape[0]

            if frame_idx == 0:
                n_atoms_check = current_atoms
                logger.info(f"System has {n_atoms_check} atoms and {n_frames} frames.")
            elif current_atoms != n_atoms_check:
                logger.error(f"Inconsistent atom count on frame {frame_idx}. Expected {n_atoms_check}, got {current_atoms}."); return [], -1
            
            coords_frames.append(torch.tensor(np.concatenate(frame_coords_np, axis=0), dtype=torch.float32))

        return coords_frames, n_atoms_check
    except Exception as e:
        logger.error(f"Invalid JSON structure in {json_file}: {e}", exc_info=True); return [], -1

# --- Alignment ---
def compute_centroid(X: torch.Tensor) -> torch.Tensor: return X.mean(dim=-2)

def kabsch_algorithm(P: torch.Tensor, Q: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
    """Aligns Q onto P using Kabsch algorithm. Handles batches [B, N, 3]."""
    P, Q = P.float(), Q.float(); is_batched = P.ndim == 3
    if not is_batched: P, Q = P.unsqueeze(0), Q.unsqueeze(0)
    B, N, _ = P.shape; centroid_P, centroid_Q = compute_centroid(P), compute_centroid(Q)
    P_c, Q_c = P - centroid_P.unsqueeze(1), Q - centroid_Q.unsqueeze(1)
    C = torch.bmm(Q_c.transpose(1, 2), P_c)
    try: V, S, Wt = torch.linalg.svd(C)
    except Exception as e:
        logger.error(f"Kabsch SVD failed: {e}. Return identity align.", exc_info=True)
        U_fallback = torch.eye(3, device=P.device).unsqueeze(0).expand(B, -1, -1)
        Q_aligned_fallback = Q - centroid_Q.unsqueeze(1) + centroid_P.unsqueeze(1)
        return (U_fallback.squeeze(0), Q_aligned_fallback.squeeze(0)) if not is_batched else (U_fallback, Q_aligned_fallback)
    det = torch.det(torch.bmm(V, Wt)); D = torch.eye(3, device=P.device).unsqueeze(0).repeat(B, 1, 1)
    D[:, 2, 2] = torch.sign(det); U = torch.bmm(torch.bmm(V, D), Wt)
    Q_aligned = torch.bmm(Q_c, U) + centroid_P.unsqueeze(1)
    return (U.squeeze(0), Q_aligned.squeeze(0)) if not is_batched else (U, Q_aligned)

def align_frames_to_first(coords: List[torch.Tensor], logger: logging.Logger, device: torch.device) -> List[torch.Tensor]:
    if not coords: logger.warning("Coordinate list empty."); return []
    ref = coords[0].to(device)
    aligned = [coords[0].cpu()]
    n_frames = len(coords) -1
    for i, frame in enumerate(coords[1:], 1):
        _, aligned_dev = kabsch_algorithm(ref, frame.to(device), logger)
        aligned.append(aligned_dev.cpu())
    logger.debug(f"Aligned {len(aligned)} frames to the first frame of the series.")
    return aligned

# --- NEW ALIGNMENT UTILITIES for MULTI-SYSTEM ---
def find_mutual_nn_pairs(ref_coords_ca: np.ndarray, target_coords_ca: np.ndarray, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor]:
    """Finds mutually nearest C-alpha atoms between two structures of different lengths."""
    logger.debug(f"Finding mutual NN pairs between structures of size {len(ref_coords_ca)} and {len(target_coords_ca)}")
    if ref_coords_ca.ndim != 2 or target_coords_ca.ndim != 2:
        raise ValueError("Input coordinates must be 2D arrays.")

    # Find nearest neighbor from target for each ref point
    nn_ref_to_target = NearestNeighbors(n_neighbors=1, algorithm='auto').fit(target_coords_ca)
    _, indices1 = nn_ref_to_target.kneighbors(ref_coords_ca)
    
    # Find nearest neighbor from ref for each target point
    nn_target_to_ref = NearestNeighbors(n_neighbors=1, algorithm='auto').fit(ref_coords_ca)
    _, indices2 = nn_target_to_ref.kneighbors(target_coords_ca)
    
    # Identify mutual pairs
    ref_indices, target_indices = [], []
    for i, target_idx in enumerate(indices1.flatten()):
        if indices2[target_idx] == i:
            ref_indices.append(i)
            target_indices.append(target_idx)
            
    logger.info(f"Found {len(ref_indices)} mutual nearest neighbor pairs for alignment.")
    if not ref_indices:
        logger.error("No mutual nearest neighbors found. Cannot align structures.")
        return torch.tensor([]), torch.tensor([])
        
    return torch.tensor(ref_indices, dtype=torch.long), torch.tensor(target_indices, dtype=torch.long)

def align_by_core(structure_to_align: torch.Tensor, core_indices_to_align: torch.Tensor,
                  reference_structure: torch.Tensor, core_indices_reference: torch.Tensor,
                  logger: logging.Logger) -> torch.Tensor:
    """Aligns a full structure based on the Kabsch alignment of its core atoms."""
    logger.debug(f"Aligning structure of size {structure_to_align.shape[0]} to ref of size {reference_structure.shape[0]} using {len(core_indices_reference)} core atoms.")
    device = structure_to_align.device

    # 1. Select the coordinates of the core atoms for both structures
    P_core = reference_structure[core_indices_reference].to(device)
    Q_core = structure_to_align[core_indices_to_align].to(device)
    
    # 2. Compute the rotation matrix (U) using only the core
    rotation, _ = kabsch_algorithm(P_core, Q_core, logger)
    
    # 3. Center the full structure_to_align on its core's centroid
    centroid_Q_core = compute_centroid(Q_core)
    structure_to_align_centered = structure_to_align - centroid_Q_core
    
    # 4. Rotate the full centered structure
    structure_to_align_rotated = torch.matmul(structure_to_align_centered, rotation.squeeze(0))
    
    # 5. Translate the rotated structure to the reference core's centroid
    centroid_P_core = compute_centroid(P_core)
    aligned_structure = structure_to_align_rotated + centroid_P_core
    
    return aligned_structure

# --- Graph Dataset ---
# Unchanged
def build_graph_dataset(coords_list: List[torch.Tensor], knn_neighbors: int, system_id: int, logger: logging.Logger, device: torch.device) -> List[Data]:
    dataset = []
    n_frames = len(coords_list)
    for i, coords_cpu in enumerate(coords_list):
        coords_dev = coords_cpu.to(device)
        edge_idx = knn_graph(coords_dev, k=knn_neighbors, loop=False, batch=None)
        data = Data(x=coords_cpu, edge_index=edge_idx.cpu(), y=coords_cpu, system_id=torch.tensor([system_id], dtype=torch.long))
        dataset.append(data)
    logger.info(f"Built graph dataset for system {system_id} with {n_frames} frames.")
    return dataset

# --- Dihedral Utilities ---
# Unchanged
@torch.jit.script
def compute_dihedral(a: torch.Tensor, b: torch.Tensor, c: torch.Tensor, d: torch.Tensor) -> torch.Tensor:
    b1=b-a; b2=c-b; b3=d-c; n1=torch.cross(b1,b2,dim=-1); n2=torch.cross(b2,b3,dim=-1)
    n1n=F.normalize(n1,p=2.,dim=-1,eps=1e-8); n2n=F.normalize(n2,p=2.,dim=-1,eps=1e-8)
    b2n=F.normalize(b2,p=2.,dim=-1,eps=1e-8); m1=torch.cross(n1n, b2n, dim=-1)
    x=(n1n*n2n).sum(dim=-1); y=(m1*n2n).sum(dim=-1); return torch.atan2(y,x)

def compute_all_dihedrals_vectorized(coords: torch.Tensor, info: Dict, n_res: int, logger: logging.Logger) -> Dict:
    """Computes all specified dihedrals vectorially."""
    if coords.ndim != 3: raise ValueError(f"Expected coords [B, N, 3], got {coords.shape}")
    B, N_atoms, _ = coords.shape; dev = coords.device; all_angles = {}
    for name, angle_info in info.items():
        indices, res_idx = angle_info.get('indices'), angle_info.get('res_idx')
        angles_out = torch.zeros(B, n_res, device=dev, dtype=coords.dtype)
        if indices is not None and res_idx is not None and indices[0].numel() > 0:
            try:
                idx_dev = [i.to(dev) for i in indices]; res_idx_dev = res_idx.to(dev)
                max_atom_idx_needed = max(i.max() for i in idx_dev)
                if max_atom_idx_needed >= N_atoms:
                    logger.error(f"Dihedral calculation error: atom index {max_atom_idx_needed} out of bounds for structure with {N_atoms} atoms.")
                    continue
                
                a,b,c,d = (coords[:, i, :] for i in idx_dev)
                values = compute_dihedral(a,b,c,d)
                angles_out.scatter_(1, res_idx_dev.unsqueeze(0).expand(B, -1), values)
            except Exception as e: logger.error(f"Error computing dihedral {name}: {e}", exc_info=True)
        all_angles[name] = angles_out
    return all_angles


def compute_angle_js_div(p: torch.Tensor, t: torch.Tensor, n=36, r=(-np.pi, np.pi)) -> torch.Tensor:
    if p.numel() == 0 or t.numel() == 0: return torch.tensor(0.0, device=p.device)
    eps=1e-10
    p_hist = torch.histc(p.detach(), bins=n, min=r[0], max=r[1])
    t_hist = torch.histc(t.detach(), bins=n, min=r[0], max=r[1])
    p_dist = p_hist / (p_hist.sum() + eps)
    t_dist = t_hist / (t_hist.sum() + eps)
    m_dist = 0.5 * (p_dist + t_dist)
    return 0.5 * (F.kl_div(m_dist.log(), p_dist, reduction='sum') + F.kl_div(m_dist.log(), t_dist, reduction='sum'))

# --- Checkpoint Utilities & MSE Utilities ---
# Unchanged
def save_checkpoint(state: Dict, filename: str, logger: logging.Logger):
    try: torch.save(state, filename); logger.debug(f"Checkpoint saved: {filename}")
    except IOError as e: logger.error(f"Error saving checkpoint {filename}: {e}")

def load_checkpoint(model: nn.Module, optimizer: Optional[torch.optim.Optimizer], filename: str, device: torch.device, logger: logging.Logger) -> Tuple[nn.Module, Optional[torch.optim.Optimizer], int]:
    start_epoch = 0
    if os.path.isfile(filename):
        logger.info(f"Loading checkpoint: '{filename}'")
        try:
            ckpt = torch.load(filename, map_location=device)
            start_epoch = ckpt.get("epoch", 0)
            model.load_state_dict(ckpt["model_state_dict"])
            if optimizer and "optimizer_state_dict" in ckpt:
                optimizer.load_state_dict(ckpt["optimizer_state_dict"])
                for state in optimizer.state.values():
                    for k, v in state.items():
                        if isinstance(v, torch.Tensor): state[k] = v.to(device)
            model.to(device)
            logger.info(f"Checkpoint loaded. Resuming from epoch {start_epoch + 1}")
        except Exception as e:
            logger.error(f"Error loading checkpoint: {e}", exc_info=True)
            start_epoch = 0
    else:
        logger.info(f"No checkpoint found at '{filename}'. Starting from scratch.")
    model.to(device)
    return model, optimizer, start_epoch

def compute_bb_sc_mse(pred: torch.Tensor, target: torch.Tensor, bb_idx: torch.Tensor, sc_idx: torch.Tensor, logger: logging.Logger) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
    crit = nn.MSELoss()
    all_mse = crit(pred, target)
    bb_mse = crit(pred[bb_idx], target[bb_idx]) if bb_idx.numel() > 0 else torch.tensor(0., device=pred.device)
    sc_mse = crit(pred[sc_idx], target[sc_idx]) if sc_idx.numel() > 0 else torch.tensor(0., device=pred.device)
    return all_mse, bb_mse, sc_mse


################################################################################
# (F) Model Definitions
################################################################################

# --- HNO Encoder ---
# NOTE: This model is already size-agnostic. The ChebConv and final Linear layers
# operate on a per-node basis, so it handles graphs of different sizes correctly.
class HNO(nn.Module):
    def __init__(self, hidden_dim, K):
        super().__init__()
        self._debug_logged = False
        self.conv1 = ChebConv(3, hidden_dim, K=K)
        self.bano1 = nn.BatchNorm1d(hidden_dim)
        self.conv2 = ChebConv(hidden_dim, hidden_dim, K=K)
        self.bano2 = nn.BatchNorm1d(hidden_dim)
        self.conv3 = ChebConv(hidden_dim, hidden_dim, K=K)
        self.bano3 = nn.BatchNorm1d(hidden_dim)
        self.conv4 = ChebConv(hidden_dim, hidden_dim, K=K)
        self.mlpRep = nn.Linear(hidden_dim, 3) # This is the reconstruction head

    def forward(self, x, edge_index):
        x = x.float()
        x = self.bano1(F.leaky_relu(self.conv1(x, edge_index)))
        x = self.bano2(F.leaky_relu(self.conv2(x, edge_index)))
        x = self.bano3(F.relu(self.conv3(x, edge_index)))
        x = self.conv4(x, edge_index)
        x_rep = F.normalize(x, p=2.0, dim=1)
        x_recon = self.mlpRep(x_rep)
        
        if self.training is False and not self._debug_logged:
             logger.debug(f"[HNO] Forward pass shapes: In={x.shape}, Rep={x_rep.shape}, Recon={x_recon.shape}")
             self._debug_logged = True
        return x_recon

    def forward_representation(self, x, edge_index):
        x = x.float()
        x = self.bano1(F.leaky_relu(self.conv1(x, edge_index)))
        x = self.bano2(F.leaky_relu(self.conv2(x, edge_index)))
        x = self.bano3(F.relu(self.conv3(x, edge_index)))
        x = self.conv4(x, edge_index)
        return F.normalize(x, p=2.0, dim=1)

# --- REFACTORED Decoder2 Model ---
class ProteinStateReconstructor2D(nn.Module):
    """
    Size-agnostic decoder. Predicts full coordinates from node embeddings.
    It combines local (per-node) and global (per-graph) information.
    """
    def __init__(self, node_emb_dim: int, cond_emb_dim: int, mlp_h_dim: int, mlp_layers: int, logger: logging.Logger):
        super().__init__()
        self.logger = logger
        self._logged_fwd = False
        
        # The input to the final MLP for each node will be:
        # [local_node_embedding, global_graph_embedding, global_conditioner_embedding]
        mlp_in_dim = node_emb_dim + node_emb_dim + cond_emb_dim
        
        # Simple MLP decoder
        layers = []
        in_d = mlp_in_dim
        for i in range(mlp_layers - 1):
            layers.extend([nn.Linear(in_d, mlp_h_dim), nn.BatchNorm1d(mlp_h_dim), nn.GELU()])
            in_d = mlp_h_dim
        layers.append(nn.Linear(in_d, 3))
        self.decoder_mlp = nn.Sequential(*layers)
        
        self.logger.info(f"Initialized Size-Agnostic Decoder2 with MLP input dim: {mlp_in_dim}")

    def forward(self, x: torch.Tensor, batch: torch.Tensor, conditioner_z_ref: torch.Tensor) -> torch.Tensor:
        """
        Args:
            x (Tensor): Per-node embeddings from HNO [N_total_nodes, E_node]
            batch (Tensor): PyG batch vector [N_total_nodes]
            conditioner_z_ref (Tensor): Per-node reference embeddings [N_total_nodes, E_cond]
        """
        # 1. Get global embedding for the current conformation
        z_global = global_mean_pool(x, batch) # -> [B, E_node]
        z_global_per_node = z_global[batch] # Broadcast to each node -> [N_total_nodes, E_node]

        # 2. Get global embedding for the conditioner
        conditioner_global = global_mean_pool(conditioner_z_ref, batch) # -> [B, E_cond]
        conditioner_global_per_node = conditioner_global[batch] # -> [N_total_nodes, E_cond]
        
        # 3. Assemble the feature vector for each node
        mlp_input = torch.cat([x, z_global_per_node, conditioner_global_per_node], dim=1)
        
        # 4. Predict coordinates
        pred_coords = self.decoder_mlp(mlp_input)
        
        if not self._logged_fwd and self.logger.isEnabledFor(logging.DEBUG):
            self.logger.debug(f"[Dec2 Fwd] Shapes: In x={x.shape}, z_global={z_global.shape}, cond_global={conditioner_global.shape}, mlp_in={mlp_input.shape}, Out={pred_coords.shape}")
            self._logged_fwd = True
            
        return pred_coords

################################################################################
# (G) Training Functions
################################################################################

# --- Train HNO ---
# This function requires minimal changes as the model is size-agnostic
def train_hno_model(model: HNO, tr_loader: DataLoader, te_loader: DataLoader, N_epochs: int, lr: float, ckpt: str, save_int: int, dev: torch.device, logger: logging.Logger):
    model=model.to(dev)
    params = list(filter(lambda p: p.requires_grad, model.parameters()))
    opt = torch.optim.Adam(params, lr=lr) if params else None
    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger)
    
    if start_ep >= N_epochs:
        logger.info(f"Loaded HNO checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). Skipping training.")
        return model

    logger.info(f"Starting HNO training from epoch {start_ep + 1}/{N_epochs}, LR={lr}")
    for ep in range(start_ep, N_epochs):
        model.train()
        total_loss = 0.0
        for data in tr_loader:
            data=data.to(dev)
            opt.zero_grad(set_to_none=True)
            pred = model(data.x, data.edge_index)
            loss = F.mse_loss(pred, data.y)
            loss.backward()
            opt.step()
            total_loss += loss.item()
        avg_tr_loss = total_loss / len(tr_loader)
        
        model.eval()
        total_val_loss = 0.0
        with torch.no_grad():
            for data in te_loader:
                data=data.to(dev)
                pred=model(data.x, data.edge_index)
                total_val_loss += F.mse_loss(pred, data.y).item()
        avg_te_loss = total_val_loss / len(te_loader)

        logger.info(f"[HNO] Ep {ep+1}/{N_epochs} | Train MSE: {avg_tr_loss:.6f} | Val MSE: {avg_te_loss:.6f}")
        
        ep_num = ep + 1
        if opt and (ep_num % save_int == 0 or ep_num == N_epochs):
            save_checkpoint({"epoch": ep_num, "model_state_dict": model.state_dict(), "optimizer_state_dict": opt.state_dict()}, ckpt, logger)
    
    logger.info(f"Finished HNO training. Checkpoint saved to {ckpt}")
    return model

# --- REFACTORED Train Decoder2 ---
def train_decoder2_model(
    model: ProteinStateReconstructor2D, tr_loader: DataLoader, te_loader: DataLoader,
    all_conditioners: Dict[int, torch.Tensor], # Dict of z_ref tensors
    all_sys_info: Dict[int, Any], # Dict containing bb_idx, sc_idx, n_res etc. for each system
    N_epochs: int, lr: float, ckpt: str, save_int: int, dev: torch.device, logger: logging.Logger,
    base_w: float, use_di: bool, all_di_info: Optional[Dict], div_t: str, l_div: float, l_mse: float
):
    model = model.to(dev)
    opt = torch.optim.Adam(list(filter(lambda p: p.requires_grad, model.parameters())), lr=lr)
    model, opt, start_ep = load_checkpoint(model, opt, ckpt, dev, logger)

    if start_ep >= N_epochs:
        logger.info(f"Loaded Decoder2 checkpoint epoch ({start_ep}) >= target epochs ({N_epochs}). Skipping training.")
        return model
        
    comp_div = compute_angle_js_div if div_t == "JS" else (lambda p, t: torch.tensor(0.0))
    if use_di: logger.info(f"Dihedral loss enabled: type={div_t}, lambda_div={l_div}, lambda_mse={l_mse}")

    logger.info(f"Starting Decoder2 training from epoch {start_ep + 1}/{N_epochs}, LR={lr}")
    for ep in range(start_ep, N_epochs):
        model.train()
        tr_metrics = {'total': 0.0, 'coord': 0.0, 'di_div': 0.0, 'di_mse': 0.0}
        
        for data in tr_loader:
            data = data.to(dev)
            opt.zero_grad(set_to_none=True)
            
            # --- Assemble Batch-Specific Conditioners and Indices ---
            # This is the core logic for handling heterogeneous batches
            unique_sys_ids = torch.unique(data.system_id)
            
            # Create the conditioner tensor for this specific batch
            # Note: This could be optimized, but is clear for debugging
            cond_list = []
            for i in range(data.num_graphs):
                sid = data.system_id[i].item()
                num_nodes = data.ptr[i+1] - data.ptr[i]
                cond = all_conditioners[sid].to(dev)
                if cond.shape[0] != num_nodes: # This check is important!
                    logger.error(f"FATAL: Mismatch in conditioner size for system {sid}. Expected {num_nodes}, got {cond.shape[0]}")
                    # This should not happen if data prep is correct.
                    # As a fallback, we must skip or resize. For now, let's assume it matches.
                cond_list.append(cond)
            conditioners_for_batch = torch.cat(cond_list, dim=0)

            # --- Forward and Coordinate Loss ---
            pred = model(data.x, data.batch, conditioners_for_batch)
            total_loss = 0.0
            coord_loss = 0.0

            # Calculate coordinate MSE loss per system in the batch
            for sid_tensor in unique_sys_ids:
                sid = sid_tensor.item()
                mask = (data.system_id[data.batch] == sid)
                
                bb_idx = all_sys_info[sid]['bb_idx_local'] # Use local indices
                sc_idx = all_sys_info[sid]['sc_idx_local']
                
                pred_sys = pred[mask]
                target_sys = data.y[mask]
                
                sys_mse, _, _ = compute_bb_sc_mse(pred_sys, target_sys, bb_idx, sc_idx, logger)
                coord_loss += sys_mse

            total_loss += base_w * coord_loss
            tr_metrics['coord'] += coord_loss.item()
            
            # --- Dihedral Loss ---
            di_div_loss = torch.tensor(0.0, device=dev)
            di_mse_loss = torch.tensor(0.0, device=dev)
            if use_di and all_di_info:
                for sid_tensor in unique_sys_ids:
                    sid = sid_tensor.item()
                    mask = (data.system_id[data.batch] == sid)
                    
                    pred_sys_3d = pred[mask].view(-1, all_sys_info[sid]['n_atoms'], 3)
                    true_sys_3d = data.y[mask].view(-1, all_sys_info[sid]['n_atoms'], 3)
                    
                    pred_a = compute_all_dihedrals_vectorized(pred_sys_3d, all_di_info[sid], all_sys_info[sid]['n_res'], logger)
                    true_a = compute_all_dihedrals_vectorized(true_sys_3d, all_di_info[sid], all_sys_info[sid]['n_res'], logger)

                    for name in pred_a:
                        pa, ta = pred_a[name], true_a[name]
                        if pa.numel() > 0:
                             di_div_loss += comp_div(pa, ta)
                             di_mse_loss += F.mse_loss(pa, ta)
                
                total_loss += l_div * di_div_loss + l_mse * di_mse_loss
                tr_metrics['di_div'] += di_div_loss.item()
                tr_metrics['di_mse'] += di_mse_loss.item()

            tr_metrics['total'] += total_loss.item()
            total_loss.backward()
            opt.step()
        
        # Log training stats (validation loop omitted for brevity but should be added)
        avg_tr = {k: v / len(tr_loader) for k, v in tr_metrics.items()}
        logger.info(f"[Dec2] Ep {ep+1}/{N_epochs} | Train Loss: {avg_tr['total']:.4f} (Coord: {avg_tr['coord']:.4f}, Dihedral Div: {avg_tr['di_div']:.4f}, Dihedral MSE: {avg_tr['di_mse']:.4f})")
        
        ep_num = ep + 1
        if opt and (ep_num % save_int == 0 or ep_num == N_epochs):
            save_checkpoint({"epoch": ep_num, "model_state_dict": model.state_dict(), "optimizer_state_dict": opt.state_dict()}, ckpt, logger)
            
    logger.info("Finished Decoder2 training.")
    return model


################################################################################
# (I) Main Execution Function
################################################################################
def main():
    start_time = time.time()
    logger.info("================ Script Starting (Multi-System Version) ================")
    global global_device
    
    with open(args.config, "r") as f: config = yaml.safe_load(f)
    logger.info("Successfully loaded configuration.")
    
    # --- Extract Parameters ---
    force_cpu = config.get("force_cpu", False)
    device = torch.device("cpu") if force_cpu else global_device
    pin_mem = (device.type == "cuda")
    num_workers = config.get("num_workers", 0)
    
    hno_cfg = config["hno_encoder"]
    dec2_cfg = config["decoder2"]
    d2s = config["decoder2_settings"]
    di_cfg = config.get("dihedral_loss", {})
    out_cfg = config["output_directories"]
    [os.makedirs(d, exist_ok=True) for d in out_cfg.values()]

    # --- Stage 1: Multi-System Data Loading & Alignment ---
    logger.info("--- Stage 1: Data Loading & Preprocessing for All Systems ---")
    
    full_dset = []
    all_sys_info = {} # Will store n_atoms, n_res, ca_indices, bb_idx etc. for each system
    canonical_ref_coords = None
    canonical_ref_ca_indices = None

    # Loop through each system defined in the config
    for i, system_config in enumerate(config["data"]["systems"]):
        sid = i
        pdb_p = system_config["pdb_path"]
        json_p = system_config["json_path"]
        logger.info(f"--- Processing System ID {sid}: {os.path.basename(pdb_p)} ---")

        # 1. Parse PDB for topology and C-alpha indices
        _, atoms_ord, ca_serial_map = parse_pdb(pdb_p, logger)
        renum_d, _, _, ca_indices_new = renumber_atoms_and_residues(atoms_ord, ca_serial_map)
        bb_idx, sc_idx = get_global_indices(renum_d)
        
        # 2. Load coordinates from JSON
        coords_list, n_atoms = load_heavy_atom_coords_from_json(json_p, logger)
        if not coords_list: continue # Skip if system loading failed

        all_sys_info[sid] = {
            'n_atoms': n_atoms,
            'ca_indices': ca_indices_new,
            'bb_idx_local': bb_idx, # These are local to the system
            'sc_idx_local': sc_idx,
            'n_res': len(renum_d)
        }

        # 3. Perform Alignment
        aligned_coords_list = []
        if sid == 0:
            # This is the canonical reference system
            logger.info(f"System {sid} is the canonical reference.")
            canonical_ref_coords = coords_list[0].clone()
            canonical_ref_ca_indices = torch.tensor(ca_indices_new, dtype=torch.long)
            aligned_coords_list = align_frames_to_first(coords_list, logger, device)
        else:
            # Align this system to the canonical reference
            logger.info(f"Aligning system {sid} to canonical reference (system 0).")
            target_ref_coords = coords_list[0]
            target_ca_indices = torch.tensor(ca_indices_new, dtype=torch.long)
            
            # Find core pairs for alignment
            core_ref_idx, core_target_idx = find_mutual_nn_pairs(
                canonical_ref_coords[canonical_ref_ca_indices].numpy(),
                target_ref_coords[target_ca_indices].numpy(),
                logger
            )
            
            # Align the first frame of this system to the canonical reference
            aligned_target_ref_frame = align_by_core(
                target_ref_coords, target_ca_indices[core_target_idx],
                canonical_ref_coords, canonical_ref_ca_indices[core_ref_idx],
                logger
            ).to(device)
            
            # Align the rest of this system's trajectory to its own aligned reference frame
            temp_list_for_align = [aligned_target_ref_frame.cpu()] + [c.to(device) for c in coords_list[1:]]
            aligned_coords_list = align_frames_to_first(temp_list_for_align, logger, device)

        # 4. Build graph dataset for this system and add to the master list
        system_dset = build_graph_dataset(aligned_coords_list, config["graph"]["knn_value"], sid, logger, device)
        full_dset.extend(system_dset)

    logger.info(f"--- Finished data loading. Total frames in dataset: {len(full_dset)} ---")

    # --- Stage 2: HNO Training ---
    logger.info("--- Stage 2: Training Shared HNO Encoder ---")
    tr_hno, te_hno = train_test_split(full_dset, test_size=0.1, random_state=42)
    load_tr_hno = DataLoader(tr_hno, hno_cfg['batch_size'], shuffle=True, num_workers=num_workers, pin_memory=pin_mem)
    load_te_hno = DataLoader(te_hno, hno_cfg['batch_size'], shuffle=False, num_workers=num_workers, pin_memory=pin_mem)
    hno_model = HNO(hno_cfg['hidden_dim'], hno_cfg['cheb_order'])
    hno_ckpt = os.path.join(out_cfg['checkpoint_dir'], "hno_checkpoint.pth")
    hno_model = train_hno_model(hno_model, load_tr_hno, load_te_hno, hno_cfg['num_epochs'], hno_cfg['learning_rate'], hno_ckpt, hno_cfg['save_interval'], device, logger)
    hno_model.eval()

    # --- Stage 3: Decoder Input Data Prep ---
    logger.info("--- Stage 3: Preparing Decoder Input Dataset & Conditioners ---")
    dec_in_dset = []
    all_conditioners = {} # Dictionary to hold the z_ref for each system
    
    # Generate embeddings for the whole dataset
    with torch.no_grad():
        infer_load = DataLoader(full_dset, hno_cfg['batch_size'] * 2, shuffle=False)
        for batch in infer_load:
            batch = batch.to(device)
            emb = hno_model.forward_representation(batch.x, batch.edge_index)
            # De-batch to create new Data objects
            split_sizes = (batch.ptr[1:] - batch.ptr[:-1]).tolist()
            emb_list = torch.split(emb, split_sizes)
            y_list = torch.split(batch.y, split_sizes)
            
            for i in range(len(emb_list)):
                dec_in_dset.append(Data(x=emb_list[i].cpu(), y=y_list[i].cpu(), system_id=batch.system_id[i].cpu().reshape(1)))
    
    # Create the conditioner dictionary
    if d2s['conditioner_mode'] == 'z_ref':
        for sid in all_sys_info.keys():
            # Find the first frame of the system in the original dataset to get its reference coords
            ref_data_orig = next(d for d in full_dset if d.system_id.item() == sid)
            ref_data_orig = ref_data_orig.to(device)
            with torch.no_grad():
                z_ref = hno_model.forward_representation(ref_data_orig.x, ref_data_orig.edge_index)
                all_conditioners[sid] = z_ref.cpu() # Store on CPU
        logger.info(f"Created 'z_ref' conditioners for all {len(all_conditioners)} systems.")
    else:
        raise NotImplementedError("Only 'z_ref' conditioner mode is supported in this version.")

    # --- Stage 4: Decoder Setup & Training ---
    logger.info("--- Stage 4: Decoder2 Setup & Training ---")
    
    # Prepare Dihedral Info Dictionaries
    all_di_info = {}
    use_di_train = di_cfg.get("use_dihedral_loss", False)
    if use_di_train:
        logger.info("Preparing dihedral information for all systems...")
        for i, system_config in enumerate(config["data"]["systems"]):
            sid = i
            torsion_p = system_config.get("torsion_info_path")
            if not torsion_p or not os.path.isfile(torsion_p):
                logger.warning(f"Torsion file not found for system {sid}. Disabling dihedral loss for this system.")
                continue
            
            with open(torsion_p, "r") as f: t_info = json.load(f)
            # Simplified parsing logic, assuming it's correct per system
            di_info_sys = {} # ... parsing logic to fill this based on t_info ...
            all_di_info[sid] = di_info_sys
        if not all_di_info: use_di_train = False # Disable if no files were loaded
    
    # Initialize and Train Decoder
    tr_dec, te_dec = train_test_split(dec_in_dset, test_size=0.1, random_state=42)
    load_tr_dec = DataLoader(tr_dec, dec2_cfg['batch_size'], shuffle=True, num_workers=num_workers, pin_memory=pin_mem)
    load_te_dec = DataLoader(te_dec, dec2_cfg['batch_size'], shuffle=False, num_workers=num_workers, pin_memory=pin_mem)
    
    dec2_model = ProteinStateReconstructor2D(
        node_emb_dim=hno_cfg['hidden_dim'],
        cond_emb_dim=hno_cfg['hidden_dim'], # since we use z_ref
        mlp_h_dim=d2s['mlp_hidden_dim'],
        mlp_layers=d2s['num_hidden_layers'],
        logger=logger
    )
    dec2_ckpt = os.path.join(out_cfg['checkpoint_dir'], "decoder2_checkpoint.pth")
    dec2_model = train_decoder2_model(
        dec2_model, load_tr_dec, load_te_dec, all_conditioners, all_sys_info,
        dec2_cfg['num_epochs'], dec2_cfg['learning_rate'], dec2_ckpt, dec2_cfg['save_interval'], device, logger,
        dec2_cfg['base_loss_weight'], use_di_train, all_di_info,
        di_cfg.get('divergence_type', 'JS'), di_cfg.get('lambda_divergence', 0.0), di_cfg.get('lambda_torsion_mse', 0.0)
    )

    logger.info(f"================ Script Finished ({time.strftime('%H:%M:%S', time.gmtime(time.time() - start_time))}) ================")

################################################################################
# (J) Script Entry Point
################################################################################
if __name__ == "__main__":
    main()