Datasets:

introvoyz045
/

ODesign

License:
Dataset card Files Files and versions
xet
Community
ODesign / data /src /model /modules /invfold /evaluation_tools /tools.py
introvoyz045
Migrated from GitHub
13e95c8 verified 19 days ago
Raw History Blame Contribute Delete
50.9 kB
import sys
import os
sys.path.append(os.path.dirname(os.path.dirname(__file__)))  
from ..src.datasets.featurizer import UniTokenizer, Featurize
import os.path as osp
import gzip
import numpy as np
import torch
from typing import Optional, Dict, Any, List, Tuple, Union, Sequence
from evaluation_tools.design_interface import MInterface
# from model_interface import MInterface
from sklearn.metrics import f1_score
import math
from .inference_utils import (   
    _parse_structure_path,          
    build_cif_id_maps,              
    extract_chain_seq_and_backbone, 
)
from collections import Counter
import re
import torch.nn.functional as F
from collections import defaultdict, OrderedDict

def id_to_char_global(i: int, kind: str, tok) -> str:

    if 0 <= i < 20:
        return tok.alphabet_protein[i]
    if 20 <= i < 25:
        base = tok.nuc5[i-20]  # A,C,G,T,U
        if kind == 'dna' and base == 'U': base = 'T'
        if kind == 'rna' and base == 'T': base = 'U'
        return base
    return 'X'

def diagnose_vocab_distribution(probs_cpu: torch.Tensor, kind: str, tok) -> None:
    """
    probs_cpu: [L, V] on CPU after softmax
    kind: 'dna' | 'rna' | 'protein'
    """
    L, V = probs_cpu.shape
    if kind == 'dna':
        allow = torch.tensor(tok.dna_ids)   # [20,21,22,23]
    elif kind == 'rna':
        allow = torch.tensor(tok.rna_ids)   # [20,21,22,24]
    else:
        allow = torch.arange(0, min(20, V)) 

    allow = allow[allow < V]
    if allow.numel() == 0:
        allow = torch.arange(0, V)

    mass_allowed = probs_cpu[:, allow].sum(dim=1)           # [L]
    mass_protein = probs_cpu[:, :min(20, V)].sum(dim=1)     # [L]
    top1 = probs_cpu.max(dim=-1).values                     # [L]
    ent = -(probs_cpu.clamp_min(1e-12).log() * probs_cpu).sum(dim=-1) / math.log(2.0)  # bits

    argmax_ids = probs_cpu.argmax(dim=-1)                   # [L]
    outside_frac = float((~torch.isin(argmax_ids, allow)).float().mean().item())

    cnt = Counter(int(i) for i in argmax_ids.tolist())
    allow_hist = {id_to_char_global(int(i), kind, tok): cnt.get(int(i), 0) for i in allow.tolist()}

    mass_per_token = probs_cpu.sum(dim=0) / L
    mass_dict = {id_to_char_global(i, kind, tok): float(mass_per_token[i].item()) for i in range(min(V, 25))}

    print("\n[Diag/Vocab]")
    print(f"- Allowed mass (mean/min): {float(mass_allowed.mean()):.4f} / {float(mass_allowed.min()):.4f}")
    print(f"- Protein mass leak (mean): {float(mass_protein.mean()):.4f}")
    print(f"- Argmax outside allowed: {outside_frac*100:.2f}%")
    print(f"- Top1 prob mean±std: {float(top1.mean()):.4f} ± {float(top1.std()):.4f}")
    print(f"- Entropy bits mean±std: {float(ent.mean()):.3f} ± {float(ent.std()):.3f}")
    print(f"- Argmax histogram in allowed: {allow_hist}")


def gzip_open(filename, *args, **kwargs):
    if args and "t" in args[0]:
        args = (args[0].replace("t", ""), ) + args[1:]
    if isinstance(filename, str):
        return gzip.open(filename, *args, **kwargs)
    else:
        return gzip.GzipFile(filename, *args, **kwargs)


def save_fasta(seqs, names, pred_fasta_path='pred.fasta'):
    with open(pred_fasta_path, 'w') as f:
        for seq, name in zip(seqs, names):
            f.write(f">{name}\n{seq}\n")

def reload_model(data_name, checkpoint_path, configs, device: str | None = None):
    
    if device is None:
        if torch.cuda.is_available():
            device = "cuda:0"
        else:
            device = "cpu"
    dev = torch.device(device)

    model = MInterface.load_from_checkpoint(
        dataset=data_name,
        checkpoint_path=checkpoint_path,
        configs=configs,
        map_location=dev,
    ).to(dev).eval()

    try:
        any_param = next(model.parameters())
        print(f"[reload_model] device={dev} first_param_on={any_param.device}")
    except StopIteration:
        print(f"[reload_model] device={dev} (no params?)")
    return model, dev

# ---------------- mmCIF ----------------

try:
    from Bio.PDB import StructureBuilder, Structure, Model, Chain, Residue, Atom
    from Bio.PDB.MMCIFParser import MMCIFParser
    from Bio.PDB.mmcifio import MMCIFIO
except Exception as _e:
    MMCIFParser = None
    MMCIFIO = None

# ------------------ basic mapping ------------------
from biotite.structure import AtomArray

AA3_TO_1 = {
    "ALA": "A", "ARG": "R", "ASN": "N", "ASP": "D",
    "CYS": "C", "GLN": "Q", "GLU": "E", "GLY": "G",
    "HIS": "H", "ILE": "I", "LEU": "L", "LYS": "K",
    "MET": "M", "PHE": "F", "PRO": "P", "SER": "S",
    "THR": "T", "TRP": "W", "TYR": "Y", "VAL": "V",
}

_AA1_TO_AA3 = {
    'A': 'ALA', 'C': 'CYS', 'D': 'ASP', 'E': 'GLU', 'F': 'PHE',
    'G': 'GLY', 'H': 'HIS', 'I': 'ILE', 'K': 'LYS', 'L': 'LEU',
    'M': 'MET', 'N': 'ASN', 'P': 'PRO', 'Q': 'GLN', 'R': 'ARG',
    'S': 'SER', 'T': 'THR', 'V': 'VAL', 'W': 'TRP', 'Y': 'TYR',
}


NA3_TO_1 = {
    # DNA
    "DA": "A", "DT": "T", "DG": "G", "DC": "C",
    "DAD": "A", "DTY": "T", "DGU": "G", "DCY": "C",
    # RNA 
    "A": "A", "U": "U", "G": "G", "C": "C",
    "RA": "A", "RU": "U", "RG": "G", "RC": "C",
    # 
    "ADE": "A", "GUA": "G", "CYT": "C", "URA": "U",
}


def _to_numpy_coords(coord_tensor: torch.Tensor) -> np.ndarray:
    if isinstance(coord_tensor, torch.Tensor):
        return coord_tensor.detach().cpu().numpy().astype(np.float32)
    return np.asarray(coord_tensor, dtype=np.float32)


def _na1_to_compid(base: str, kind: str) -> str:
    b = base.upper()
    if kind == 'rna':
        if b in ('A','U','G','C'):
            return b
        return None
    else:
        mapping = {'A':'DA', 'T':'DT', 'G':'DG', 'C':'DC'}
        return mapping.get(b, None)


def _ensure_biopython():
    if MMCIFParser is None or MMCIFIO is None:
        raise RuntimeError("Biopython (Bio.PDB) not available. Please install biopython.")

def _load_structure_from_cif(cif_path: str):
    _ensure_biopython()
    parser = MMCIFParser(QUIET=True)
    struct_id = os.path.basename(cif_path)
    return parser.get_structure(struct_id, cif_path)

def _copy_single_chain(structure, chain_id: str):

    from Bio.PDB import Structure
    new_s = Structure.Structure("subset")
    model0 = list(structure.get_models())[0]

    from Bio.PDB import Model, Chain, Residue, Atom
    new_m = Model.Model(0)


    for ch in model0:
        if ch.id == chain_id:
            new_ch = Chain.Chain(chain_id)
            for res in ch:
                
                new_res = Residue.Residue(res.id, res.resname, res.segid)
                for atom in res:
                    new_atom = Atom.Atom(
                        atom.get_name(), atom.get_coord(), atom.get_bfactor(),
                        atom.get_occupancy(), atom.get_altloc(), atom.get_fullname(),
                        atom.get_serial_number(), element=atom.element
                    )
                    new_res.add(new_atom)
                new_ch.add(new_res)
            new_m.add(new_ch)
            break
    new_s.add(new_m)
    return new_s

def _mutate_chain_sequence_inplace(structure, chain_id: str, new_seq: str, kind: str) -> Tuple[int,int]:
    new_seq = (new_seq or "").upper()
    if not new_seq:
        return (0, 0)

    model0 = list(structure.get_models())[0]
    chain = None
    for ch in model0:
        if ch.id == chain_id:
            chain = ch
            break
    if chain is None:
        return (0, 0)


    candidates = []
    for res in chain:
        hetflag, resseq, icode = res.id
        if hetflag.strip() != "":
            continue
        candidates.append(res)

    L = min(len(candidates), len(new_seq))
    applied = 0
    for i in range(L):
        res = candidates[i]
        target = new_seq[i]
        if kind == 'protein':
            aa3 = _AA1_TO_AA3.get(target, None)
            if aa3:
                res.resname = aa3
                applied += 1
        else:
            comp = _na1_to_compid(target, kind)
            if comp:
                res.resname = comp
                applied += 1
    return (applied, L)


def save_single_chain_cif(cif_src_path: str, chain_auth_id: str, out_path: str) -> None:

    _ensure_biopython()
    struct = _load_structure_from_cif(cif_src_path)
    sub_s = _copy_single_chain(struct, chain_auth_id)  
    io = MMCIFIO()
    io.set_structure(sub_s)
    os.makedirs(os.path.dirname(out_path), exist_ok=True)
    io.save(out_path)

def save_sequence_replaced_cif(cif_src_path: str,
                               chain_auth_id: str,
                               new_seq: str,
                               kind: str,
                               out_path: str) -> Tuple[int,int]:
    _ensure_biopython()

    full_struct = _load_structure_from_cif(cif_src_path)
    sub_struct = _copy_single_chain(full_struct, chain_auth_id)


    applied, aligned = _mutate_chain_sequence_inplace(
        sub_struct, chain_auth_id, new_seq, kind
    )


    io = MMCIFIO()
    io.set_structure(sub_struct)
    os.makedirs(os.path.dirname(out_path), exist_ok=True)
    io.save(out_path)
    return (applied, aligned)


_CHAIN_AUTH_RE = re.compile(r"_auth([A-Za-z0-9]+)")

def parse_auth_from_title(title: str, fallback: Optional[str] = None) -> Optional[str]:
    m = _CHAIN_AUTH_RE.search(title or "")
    if m:
        return m.group(1)
    return fallback

def _decide_kind(one_seq: str, prefer: str) -> str:

    one = (one_seq or "").upper()
    if 'T' in one: return 'dna'
    if 'U' in one: return 'rna'
    return prefer



# ---------------- Inference & Metrics ----------------
def allowed_indices(kind: str, V: int) -> torch.Tensor:
    kind = str(kind).lower()
    if kind == 'dna':
        cand = torch.tensor([20, 21, 22, 23], dtype=torch.long)  # A,C,G,T
    elif kind == 'rna':
        cand = torch.tensor([20, 21, 22, 24], dtype=torch.long)  # A,C,G,U
    elif kind == 'protein':
        cand = torch.arange(0, min(20, V), dtype=torch.long)
    else:
        cand = torch.arange(0, V, dtype=torch.long)
    return cand[cand < V]

def beam_search_logp(logp_mat, allow_idx, beam_w, len_norm=True, alpha=0.6,
                     diversity_groups=1, gamma=0.0):
    L_, V_ = logp_mat.shape
    K_ = allow_idx.numel()
    G = max(1, int(diversity_groups))
    group_size = (beam_w + G - 1) // G
    groups = [[([], 0.0)] for _ in range(G)]
    for t in range(L_):
        chosen_per_group = []
        for g in range(G):
            beams = groups[g]
            row = logp_mat[t, allow_idx].clone()  # [K_]
            if gamma > 0 and len(chosen_per_group) > 0:
                used = torch.zeros(K_)
                for prev in chosen_per_group:
                    used[prev] += 1
                row = row - gamma * used
            cand = []
            for seq, s in beams:
                for k in range(K_):
                    cand.append((seq + [int(allow_idx[k])], s + float(row[k])))
            cand.sort(key=lambda x: x[1], reverse=True)
            groups[g] = cand[:group_size]
            top_tokens = []
            for ids, _ in groups[g]:
                pos = (allow_idx == ids[-1]).nonzero(as_tuple=False)
                top_tokens.append(int(pos[0, 0]) if pos.numel() > 0 else 0)
            chosen_per_group.append(top_tokens)
    beams_all = [item for grp in groups for item in grp]
    if len_norm:
        beams_all = [(ids, s / max(1, len(ids))) for ids, s in beams_all]
    elif alpha > 0:
        def lp_len(m): return ((5 + m) ** alpha) / ((5 + 1) ** alpha)
        beams_all = [(ids, s / lp_len(len(ids))) for ids, s in beams_all]
    beams_all.sort(key=lambda x: x[1], reverse=True)
    return beams_all[:beam_w]

def labels_4class(seq_or_ids, kind: str, tok) -> List[int]:
    kind = str(kind).lower()
    if isinstance(seq_or_ids, (list, tuple)) and len(seq_or_ids) > 0 and isinstance(seq_or_ids[0], int):
        ids = list(seq_or_ids)
    else:
        ids = tok.encode(str(seq_or_ids), kind=kind)
    if kind == 'protein':
        return [t if 0 <= t < 20 else 19 for t in ids]
    elif kind in ('dna', 'rna'):
        A, C, G = tok.nuc_to_id['A'], tok.nuc_to_id['C'], tok.nuc_to_id['G']
        if kind == 'dna':
            T = tok.nuc_to_id['T']
            id2cls = {A:0, C:1, G:2, T:3}
        else:
            U = tok.nuc_to_id['U']
            id2cls = {A:0, C:1, G:2, U:3}
        return [id2cls.get(t, 0) for t in ids]
    else:
        raise ValueError(f"Unknown kind: {kind}")

def _move_to(x, device):
    if isinstance(x, dict):
        return {k: _move_to(v, device) for k, v in x.items()}
    if isinstance(x, (list, tuple)):
        t = type(x)
        return t(_move_to(v, device) for v in x)
    if isinstance(x, torch.Tensor):
        return x.to(device, non_blocking=True)
    return x

# ==== helpers for ligand ====

def ligand_allowed_indices(tok, V: int,
                           allow_rare: bool = True,
                           allow_unk: bool = False,
                           allow_mask: bool = False) -> torch.Tensor:
    allowed = []
    inv = getattr(tok, "id_to_token", None)
    if inv is not None:
        for i, token in enumerate(inv):
            if i >= V: break
            if token == getattr(tok, "MASK_TOKEN", "*") and not allow_mask:
                continue
            if token == getattr(tok, "UNK_TOKEN", "UNK") and not allow_unk:
                continue
            if token == getattr(tok, "RARE_TOKEN", "RARE") and not allow_rare:
                continue
            allowed.append(i)
    else:
        allowed = list(range(min(V, getattr(tok, "vocab_size", V))))
    if not allowed:
        allowed = list(range(min(V, getattr(tok, "vocab_size", V))))
    return torch.tensor(allowed, dtype=torch.long)

def decode_ligand_ids(ids, tok, sep: str = " ") -> str:
    inv = getattr(tok, "id_to_token", None)
    if inv is None:
        return sep.join(str(i) for i in ids)
    out = []
    for i in ids:
        if 0 <= i < len(inv):
            out.append(inv[i])
        else:
            out.append(getattr(tok, "UNK_TOKEN", "UNK"))
    return sep.join(out)



def parse_invfold(
    atom_array: AtomArray,
    pred_output,
    design_modality: str,           # 'protein' / 'rna' / 'dna' / 'ligand'
    sample_name: str,
) -> List[List[Dict[str, Any]]]:
    prefer = design_modality.strip().lower()
    assert prefer in ("protein", "rna", "dna", "ligand")

    coord_tensor_all = pred_output.coordinate
    assert coord_tensor_all.ndim == 3, f"expect coordinate [N_struct, N_atom, 3], got {coord_tensor_all.shape}"
    n_struct, n_atom = coord_tensor_all.shape[0], coord_tensor_all.shape[1]

    atom_names = np.asarray(atom_array.atom_name).astype(str)
    chain_ids_atom = np.asarray(atom_array.chain_id).astype(str)
    res_ids_atom = np.asarray(atom_array.res_id)

    if hasattr(atom_array, "cano_seq_resname"):
        res3 = np.asarray(atom_array.cano_seq_resname).astype(str)
    else:
        res3 = np.asarray(atom_array.res_name).astype(str)

    if hasattr(atom_array, "condition_token_mask"):
        cond_mask_atom = np.asarray(atom_array.condition_token_mask).astype(bool)
    else:
        cond_mask_atom = np.zeros(n_atom, dtype=bool)

    if hasattr(atom_array, "hetero"):
        hetero_atom = np.asarray(atom_array.hetero).astype(bool)
    else:
        hetero_atom = np.zeros(n_atom, dtype=bool)

    if hasattr(atom_array, "element"):
        elem_atom = np.asarray(atom_array.element).astype(str)
    else:
        elem_atom = np.array([name[:1] if len(name) > 0 else "X" for name in atom_names], dtype=str)

    if n_atom != len(atom_array):
        raise ValueError(f"coordinate.shape[1]={n_atom} does not match {len(atom_array)}")

    # residue -> atom indices
    residue_atoms: dict[tuple[str, int], list[int]] = defaultdict(list)
    for idx, (ch, rid) in enumerate(zip(chain_ids_atom, res_ids_atom)):
        residue_atoms[(ch, int(rid))].append(idx)

    sorted_keys = sorted(residue_atoms.keys(), key=lambda x: (x[0], x[1]))
    chains: "OrderedDict[str, list[tuple[str, int]]]" = OrderedDict()
    for ch, rid in sorted_keys:
        chains.setdefault(ch, []).append((ch, rid))

    # element -> int mapping compatible with LigandMPNN data_utils
    try:
        from src.model.modules.invfold.proteinmpnn.data_utils import element_list as _MPNN_ELEMENT_LIST
        _ELEMENT_TO_INT = {str(e).upper(): i + 1 for i, e in enumerate(_MPNN_ELEMENT_LIST)}
    except Exception:
        _COMMON_ELEMENTS = [
            "H", "C", "N", "O", "F", "P", "S", "CL", "BR", "I",
            "NA", "K", "MG", "CA", "MN", "FE", "CO", "NI", "CU", "ZN",
            "SE", "B", "SI",
        ]
        _ELEMENT_TO_INT = {e: i + 1 for i, e in enumerate(_COMMON_ELEMENTS)}

    def _normalize_element_symbol(e: str) -> str:
        e = str(e).strip().upper()
        if len(e) == 0:
            return "X"
        # common cases already look like C, N, O, ZN, CL ...
        return e

    def _is_protein_like_residue(atom_idx_list: list[int]) -> bool:
        names = {atom_names[i].upper() for i in atom_idx_list}
        # protein-like if it has the peptide backbone N-CA-C
        return ("N" in names) and ("CA" in names) and ("C" in names)

    samples_all: List[List[Dict[str, Any]]] = []

    for struct_idx in range(n_struct):
        coord_tensor = coord_tensor_all[struct_idx]   # [N_atom, 3]
        coords_np = _to_numpy_coords(coord_tensor)

        def get_coord_for_atom(atom_idx_list: list[int], target_name: str) -> np.ndarray:
            t = target_name.upper()
            for idx in atom_idx_list:
                if atom_names[idx].upper() == t:
                    return coords_np[idx]
            return np.full((3,), np.nan, dtype=np.float32)

        def get_na_base_n_coord(atom_idx_list: list[int]) -> np.ndarray:
            for idx in atom_idx_list:
                if atom_names[idx].upper() == "N9":
                    return coords_np[idx]
            for idx in atom_idx_list:
                if atom_names[idx].upper() == "N1":
                    return coords_np[idx]
            for idx in atom_idx_list:
                if atom_names[idx].upper().startswith("N"):
                    return coords_np[idx]
            return np.full((3,), np.nan, dtype=np.float32)

        struct_samples: List[Dict[str, Any]] = []

        # ---------- ligand-only ----------
        if prefer == "ligand":
            for ch, res_keys in chains.items():
                for (ch_id, rid) in res_keys:
                    atom_idx_list = residue_atoms[(ch_id, rid)]

                    is_het_res = np.all(hetero_atom[atom_idx_list])
                    if not is_het_res:
                        continue

                    # ligand: 保持旧逻辑，全 conditioned 的 ligand residue 不参与设计
                    res_cond = cond_mask_atom[atom_idx_list]
                    if np.all(res_cond):
                        continue

                    elems = [elem_atom[i].upper() for i in atom_idx_list]
                    norm_elems = [e if e else "UNK" for e in elems]
                    lig_xyz = coords_np[atom_idx_list]
                    if lig_xyz.shape[0] == 0:
                        continue

                    L = lig_xyz.shape[0]
                    lig_seq_str = " ".join(norm_elems)

                    res_ids = np.arange(L, dtype=int)
                    chain_ids = np.array([str(ch_id)] * L, dtype=str)
                    res_atom_indices = [np.asarray([atom_idx_list[i]], dtype=int) for i in range(L)]

                    sample = {
                        "title": f"{sample_name}_s{struct_idx}_LIG_chain{ch_id}_res{int(rid)}",
                        "type": "ligand",
                        "seq": lig_seq_str,
                        "ligand": {
                            "elements": norm_elems,
                            "coords": lig_xyz.tolist(),
                            "chain_mask": [[1.0] * L],
                            "chain_encoding": [[1.0] * L],
                        },
                        "res_ids": res_ids,
                        "chain_ids": chain_ids,
                        "res_atom_indices": res_atom_indices,
                        "design_mask": np.ones(L, dtype=bool),
                    }
                    struct_samples.append(sample)

            samples_all.append(struct_samples)
            continue

        # ---------- build whole-structure MPNN context for protein design ----------
        mpnn_input_dict = None
        global_index_of_residue: dict[tuple[str, int], int] = {}
        has_ligand_context = False
        mpnn_model_type = "protein_mpnn"

        if prefer == "protein":
            global_seq_chars: list[str] = []
            global_R_idx: list[int] = []
            global_chain_letters: list[str] = []
            global_chain_labels: list[int] = []
            global_N_list, global_CA_list, global_C_list, global_O_list = [], [], [], []

            protein_atom_mask = np.zeros(n_atom, dtype=bool)

            protein_chain_order: list[str] = []
            for ch, res_keys in chains.items():
                chain_has_protein = False
                for (ch_id, rid) in res_keys:
                    atom_idx_list = residue_atoms[(ch_id, rid)]
                    if _is_protein_like_residue(atom_idx_list):
                        chain_has_protein = True
                        break
                if chain_has_protein:
                    protein_chain_order.append(str(ch))

            chain_to_label = {ch: i for i, ch in enumerate(protein_chain_order)}

            for ch, res_keys in chains.items():
                for (ch_id, rid) in res_keys:
                    atom_idx_list = residue_atoms[(ch_id, rid)]
                    if not _is_protein_like_residue(atom_idx_list):
                        continue

                    name3 = res3[atom_idx_list[0]].upper()
                    aa = AA3_TO_1.get(name3, "X")

                    global_index_of_residue[(str(ch_id), int(rid))] = len(global_seq_chars)
                    global_seq_chars.append(aa)
                    global_R_idx.append(int(rid))
                    global_chain_letters.append(str(ch_id))
                    global_chain_labels.append(int(chain_to_label[str(ch_id)]))

                    N_xyz = get_coord_for_atom(atom_idx_list, "N")
                    CA_xyz = get_coord_for_atom(atom_idx_list, "CA")
                    C_xyz = get_coord_for_atom(atom_idx_list, "C")
                    O_xyz = get_coord_for_atom(atom_idx_list, "O")

                    global_N_list.append(N_xyz)
                    global_CA_list.append(CA_xyz)
                    global_C_list.append(C_xyz)
                    global_O_list.append(O_xyz)

                    protein_atom_mask[np.asarray(atom_idx_list, dtype=int)] = True

            if len(global_seq_chars) > 0:
                X_all = np.stack(
                    [
                        np.stack(global_N_list, axis=0),
                        np.stack(global_CA_list, axis=0),
                        np.stack(global_C_list, axis=0),
                        np.stack(global_O_list, axis=0),
                    ],
                    axis=1,
                ).astype(np.float32)   # [L_all, 4, 3]

                mask_all = np.isfinite(X_all).all(axis=(1, 2)).astype(np.int32)

                aa_to_id = {
                    "A": 0, "C": 1, "D": 2, "E": 3, "F": 4,
                    "G": 5, "H": 6, "I": 7, "K": 8, "L": 9,
                    "M": 10, "N": 11, "P": 12, "Q": 13, "R": 14,
                    "S": 15, "T": 16, "V": 17, "W": 18, "Y": 19,
                    "X": 20,
                }
                S_all = np.asarray([aa_to_id.get(a, 20) for a in global_seq_chars], dtype=np.int32)
                R_idx_all = np.asarray(global_R_idx, dtype=np.int32)
                chain_labels_all = np.asarray(global_chain_labels, dtype=np.int32)
                chain_letters_all = np.asarray(global_chain_letters, dtype=str)

                water_names = {"HOH", "WAT", "H2O", "DOD"}
                non_water_mask = ~np.isin(np.char.upper(res3.astype(str)), list(water_names))
                context_atom_mask = (~protein_atom_mask) & non_water_mask

                Y = coords_np[context_atom_mask].astype(np.float32)
                Y_elem = np.asarray([_normalize_element_symbol(e) for e in elem_atom[context_atom_mask]], dtype=str)
                Y_t = np.asarray([_ELEMENT_TO_INT.get(e, 0) for e in Y_elem], dtype=np.int32)
                Y_m = ((Y_t != 1) & (Y_t != 0)).astype(np.int32)  # remove H and unknown

                if Y.shape[0] > 0:
                    keep = Y_m.astype(bool)
                    Y = Y[keep]
                    Y_t = Y_t[keep]
                    Y_m = Y_m[keep]

                if Y.shape[0] == 0:
                    Y = np.zeros((1, 3), dtype=np.float32)
                    Y_t = np.zeros((1,), dtype=np.int32)
                    Y_m = np.zeros((1,), dtype=np.int32)

                has_ligand_context = bool(np.sum(Y_m) > 0)
                mpnn_model_type = "ligand_mpnn" if has_ligand_context else "protein_mpnn"

                mpnn_input_dict = {
                    "X": X_all,                              # [L_all, 4, 3]
                    "mask": mask_all,                        # [L_all]
                    "R_idx": R_idx_all,                      # [L_all]
                    "chain_labels": chain_labels_all,        # [L_all]
                    "chain_letters": chain_letters_all,      # [L_all]
                    "S": S_all,                              # [L_all]
                    "Y": Y,                                  # [N_ctx, 3]
                    "Y_t": Y_t,                              # [N_ctx]
                    "Y_m": Y_m,                              # [N_ctx]
                }

        # ---------- protein / rna / dna ----------
        for ch, res_keys in chains.items():
            seq_chars: list[str] = []
            design_mask: list[bool] = []
            res_id_list: list[int] = []
            chain_id_list: list[str] = []

            if prefer == "protein":
                # 只对 protein-like residues 建样本；ligand / ion / NA chain 会被跳过
                local_entries: list[tuple[str, int, list[int]]] = []
                for (ch_id, rid) in res_keys:
                    atom_idx_list = residue_atoms[(ch_id, rid)]
                    if _is_protein_like_residue(atom_idx_list):
                        local_entries.append((str(ch_id), int(rid), atom_idx_list))

                if len(local_entries) == 0:
                    continue

                N_list, CA_list, C_list, O_list = [], [], [], []
                res_atom_indices_list: list[list[int]] = []
                target_global_indices: list[int] = []

                for (ch_id, rid, atom_idx_list) in local_entries:
                    res_cond = cond_mask_atom[atom_idx_list]
                    designable = (not np.all(res_cond))

                    name3 = res3[atom_idx_list[0]].upper()
                    aa = AA3_TO_1.get(name3, "X")
                    seq_chars.append(aa)

                    N_list.append(get_coord_for_atom(atom_idx_list, "N"))
                    CA_list.append(get_coord_for_atom(atom_idx_list, "CA"))
                    C_list.append(get_coord_for_atom(atom_idx_list, "C"))
                    O_list.append(get_coord_for_atom(atom_idx_list, "O"))

                    design_mask.append(bool(designable))
                    res_id_list.append(int(rid))
                    chain_id_list.append(str(ch_id))
                    res_atom_indices_list.append(atom_idx_list)
                    target_global_indices.append(global_index_of_residue[(str(ch_id), int(rid))])

                L = len(seq_chars)
                if L == 0:
                    continue

                sample = {
                    "title": f"{sample_name}_s{struct_idx}_chain{ch}",
                    "type": "protein",
                    "seq": "".join(seq_chars),

                    # local target-chain backbone
                    "N": np.stack(N_list, axis=0).astype(np.float32),
                    "CA": np.stack(CA_list, axis=0).astype(np.float32),
                    "C": np.stack(C_list, axis=0).astype(np.float32),
                    "O": np.stack(O_list, axis=0).astype(np.float32),

                    # keep old fields for downstream merge/writeback
                    "chain_mask": np.ones(L, dtype=np.float32),
                    "chain_encoding": np.ones(L, dtype=np.float32),
                    "design_mask": np.asarray(design_mask, dtype=bool),
                    "res_ids": np.asarray(res_id_list, dtype=int),
                    "chain_ids": np.asarray(chain_id_list),
                    "res_atom_indices": [np.asarray(idxs, dtype=int) for idxs in res_atom_indices_list],

                    # new fields for MPNN family routing / whole-structure context
                    "target_global_indices": np.asarray(target_global_indices, dtype=np.int64),
                    "has_ligand_context": bool(has_ligand_context),
                    "mpnn_model_type": mpnn_model_type,
                    "mpnn_input_dict": mpnn_input_dict,
                }
                struct_samples.append(sample)

            else:
                P_list, O5_list, C5_list, C4_list, C3_list, O3_list, N_list_na = [], [], [], [], [], [], []
                res_atom_indices_list: list[list[int]] = []

                for (ch_id, rid) in res_keys:
                    atom_idx_list = residue_atoms[(ch_id, rid)]
                    res_cond = cond_mask_atom[atom_idx_list]
                    designable = (not np.all(res_cond))

                    name3 = res3[atom_idx_list[0]].upper()
                    base = NA3_TO_1.get(name3, "N")

                    if prefer == "dna":
                        ch1 = base.upper()
                        if ch1 == "U":
                            ch1 = "T"
                        if ch1 not in ("A", "T", "G", "C", "N"):
                            ch1 = "N"
                    else:
                        ch1 = base.upper()
                        if ch1 == "T":
                            ch1 = "U"
                        if ch1 not in ("A", "U", "G", "C", "N"):
                            ch1 = "N"

                    seq_chars.append(ch1)

                    P_list.append(get_coord_for_atom(atom_idx_list, "P"))
                    O5_list.append(get_coord_for_atom(atom_idx_list, "O5'"))
                    C5_list.append(get_coord_for_atom(atom_idx_list, "C5'"))
                    C4_list.append(get_coord_for_atom(atom_idx_list, "C4'"))
                    C3_list.append(get_coord_for_atom(atom_idx_list, "C3'"))
                    O3_list.append(get_coord_for_atom(atom_idx_list, "O3'"))
                    N_list_na.append(get_na_base_n_coord(atom_idx_list))

                    design_mask.append(bool(designable))
                    res_id_list.append(int(rid))
                    chain_id_list.append(str(ch_id))
                    res_atom_indices_list.append(atom_idx_list)

                L = len(seq_chars)
                if L == 0:
                    continue

                kind = "dna" if prefer == "dna" else "rna"
                sample = {
                    "title": f"{sample_name}_s{struct_idx}_{kind}_chain{ch}",
                    "type": kind,
                    "seq": "".join(seq_chars),
                    "P": np.stack(P_list, axis=0).astype(np.float32),
                    "O5": np.stack(O5_list, axis=0).astype(np.float32),
                    "C5": np.stack(C5_list, axis=0).astype(np.float32),
                    "C4": np.stack(C4_list, axis=0).astype(np.float32),
                    "C3": np.stack(C3_list, axis=0).astype(np.float32),
                    "O3": np.stack(O3_list, axis=0).astype(np.float32),
                    "N": np.stack(N_list_na, axis=0).astype(np.float32),
                    "chain_mask": np.ones(L, dtype=np.float32),
                    "chain_encoding": np.ones(L, dtype=np.float32),
                    "design_mask": np.asarray(design_mask, dtype=bool),
                    "res_ids": np.asarray(res_id_list, dtype=int),
                    "chain_ids": np.asarray(chain_id_list),
                    "res_atom_indices": [np.asarray(idxs, dtype=int) for idxs in res_atom_indices_list],
                }
                struct_samples.append(sample)

        samples_all.append(struct_samples)

    return samples_all

    
# def parse_invfold(
#     atom_array: AtomArray,
#     pred_output,
#     design_modality: str,           # 'protein' / 'rna' / 'dna' / 'ligand'
#     sample_name: str,
# ) -> List[List[Dict[str, Any]]]:
#     prefer = design_modality.strip().lower()
#     assert prefer in ("protein", "rna", "dna", "ligand")

#     coord_tensor_all = pred_output.coordinate
#     assert coord_tensor_all.ndim == 3, f"expect coordinate [N_struct, N_atom, 3], got {coord_tensor_all.shape}"
#     n_struct, n_atom = coord_tensor_all.shape[0], coord_tensor_all.shape[1]

#     atom_names = np.asarray(atom_array.atom_name).astype(str)
#     chain_ids_atom = np.asarray(atom_array.chain_id).astype(str)
#     res_ids_atom = np.asarray(atom_array.res_id)

#     if hasattr(atom_array, "cano_seq_resname"):
#         res3 = np.asarray(atom_array.cano_seq_resname).astype(str)
#     else:
#         res3 = np.asarray(atom_array.res_name).astype(str)

#     if hasattr(atom_array, "condition_token_mask"):
#         cond_mask_atom = np.asarray(atom_array.condition_token_mask).astype(bool)
#     else:
#         cond_mask_atom = np.zeros(n_atom, dtype=bool)

#     hetero_atom = None
#     elem_atom = None
#     if prefer == "ligand":
#         if hasattr(atom_array, "hetero"):
#             hetero_atom = np.asarray(atom_array.hetero).astype(bool)
#         else:
#             hetero_atom = np.ones(n_atom, dtype=bool)
#         if hasattr(atom_array, "element"):
#             elem_atom = np.asarray(atom_array.element).astype(str)
#         else:
#             elem_atom = np.array([name[0] for name in atom_names], dtype=str)

#     if n_atom != len(atom_array):
#         raise ValueError(f"coordinate.shape[1]={n_atom} does not match {len(atom_array)}")

#     # residue -> atom indices
#     residue_atoms: dict[tuple[str, int], list[int]] = defaultdict(list)
#     for idx, (ch, rid) in enumerate(zip(chain_ids_atom, res_ids_atom)):
#         residue_atoms[(ch, int(rid))].append(idx)

#     sorted_keys = sorted(residue_atoms.keys(), key=lambda x: (x[0], x[1]))
#     chains: "OrderedDict[str, list[tuple[str, int]]]" = OrderedDict()
#     for ch, rid in sorted_keys:
#         chains.setdefault(ch, []).append((ch, rid))

#     samples_all: List[List[Dict[str, Any]]] = []

#     for struct_idx in range(n_struct):
#         coord_tensor = coord_tensor_all[struct_idx]   # [N_atom, 3]
#         coords_np = _to_numpy_coords(coord_tensor)

#         def get_coord_for_atom(atom_idx_list: list[int], target_name: str) -> np.ndarray:
#             t = target_name.upper()
#             for idx in atom_idx_list:
#                 if atom_names[idx].upper() == t:
#                     return coords_np[idx]
#             return np.full((3,), np.nan, dtype=np.float32)

#         def get_na_base_n_coord(atom_idx_list: list[int]) -> np.ndarray:
#             for idx in atom_idx_list:
#                 if atom_names[idx].upper() == "N9":
#                     return coords_np[idx]
#             for idx in atom_idx_list:
#                 if atom_names[idx].upper() == "N1":
#                     return coords_np[idx]
#             for idx in atom_idx_list:
#                 if atom_names[idx].upper().startswith("N"):
#                     return coords_np[idx]
#             return np.full((3,), np.nan, dtype=np.float32)

#         struct_samples: List[Dict[str, Any]] = []

#         # ---------- ligand-only ----------
#         if prefer == "ligand":
#             for ch, res_keys in chains.items():
#                 for (ch_id, rid) in res_keys:
#                     atom_idx_list = residue_atoms[(ch_id, rid)]

#                     is_het_res = np.all(hetero_atom[atom_idx_list])
#                     if not is_het_res:
#                         continue

#                     # ligand: 这里仍保持“全 conditioned 的 ligand residue 不参与设计并跳过”的旧逻辑
#                     res_cond = cond_mask_atom[atom_idx_list]
#                     if np.all(res_cond):
#                         continue

#                     elems = [elem_atom[i].upper() for i in atom_idx_list]
#                     norm_elems = [e if e else "UNK" for e in elems]
#                     lig_xyz = coords_np[atom_idx_list]
#                     if lig_xyz.shape[0] == 0:
#                         continue

#                     L = lig_xyz.shape[0]
#                     lig_seq_str = " ".join(norm_elems)

#                     res_ids = np.arange(L, dtype=int)
#                     chain_ids = np.array([str(ch_id)] * L, dtype=str)
#                     res_atom_indices = [np.asarray([atom_idx_list[i]], dtype=int) for i in range(L)]

#                     sample = {
#                         "title": f"{sample_name}_s{struct_idx}_LIG_chain{ch_id}_res{int(rid)}",
#                         "type": "ligand",
#                         "seq": lig_seq_str,
#                         "ligand": {
#                             "elements": norm_elems,
#                             "coords": lig_xyz.tolist(),
#                             "chain_mask": [[1.0] * L],
#                             "chain_encoding": [[1.0] * L],
#                         },
#                         "res_ids": res_ids,
#                         "chain_ids": chain_ids,
#                         "res_atom_indices": res_atom_indices,
#                         "design_mask": np.ones(L, dtype=bool),
#                     }
#                     struct_samples.append(sample)

#             samples_all.append(struct_samples)
#             continue

#         # ---------- protein / rna / dna ----------
#         for ch, res_keys in chains.items():
#             seq_chars: list[str] = []
#             design_mask: list[bool] = []
#             res_id_list: list[int] = []
#             chain_id_list: list[str] = []

#             if prefer == "protein":
#                 N_list, CA_list, C_list, O_list = [], [], [], []
#                 res_atom_indices_list: list[list[int]] = []

#                 for (ch_id, rid) in res_keys:
#                     atom_idx_list = residue_atoms[(ch_id, rid)]
#                     res_cond = cond_mask_atom[atom_idx_list]
#                     designable = (not np.all(res_cond))  # 关键：不再 continue；而是标记

#                     name3 = res3[atom_idx_list[0]].upper()
#                     aa = AA3_TO_1.get(name3, "X")
#                     seq_chars.append(aa)

#                     N_list.append(get_coord_for_atom(atom_idx_list, "N"))
#                     CA_list.append(get_coord_for_atom(atom_idx_list, "CA"))
#                     C_list.append(get_coord_for_atom(atom_idx_list, "C"))
#                     O_list.append(get_coord_for_atom(atom_idx_list, "O"))

#                     design_mask.append(bool(designable))
#                     res_id_list.append(int(rid))
#                     chain_id_list.append(str(ch_id))
#                     res_atom_indices_list.append(atom_idx_list)

#                 L = len(seq_chars)
#                 if L == 0:
#                     continue

#                 sample = {
#                     "title": f"{sample_name}_s{struct_idx}_chain{ch}",
#                     "type":  "protein",
#                     "seq":   "".join(seq_chars),
#                     "N":     np.stack(N_list,  axis=0).astype(np.float32),
#                     "CA":    np.stack(CA_list, axis=0).astype(np.float32),
#                     "C":     np.stack(C_list,  axis=0).astype(np.float32),
#                     "O":     np.stack(O_list,  axis=0).astype(np.float32),
#                     "chain_mask":     np.ones(L, dtype=np.float32),
#                     "chain_encoding": np.ones(L, dtype=np.float32),
#                     "design_mask":    np.asarray(design_mask, dtype=bool),   # residue-level 1D bool
#                     "res_ids":        np.asarray(res_id_list, dtype=int),
#                     "chain_ids":      np.asarray(chain_id_list),
#                     "res_atom_indices": [np.asarray(idxs, dtype=int) for idxs in res_atom_indices_list],
#                 }
#                 struct_samples.append(sample)

#             else:
#                 P_list, O5_list, C5_list, C4_list, C3_list, O3_list, N_list_na = [], [], [], [], [], [], []
#                 res_atom_indices_list: list[list[int]] = []

#                 for (ch_id, rid) in res_keys:
#                     atom_idx_list = residue_atoms[(ch_id, rid)]
#                     res_cond = cond_mask_atom[atom_idx_list]
#                     designable = (not np.all(res_cond))  # 关键：不再 continue；而是标记

#                     name3 = res3[atom_idx_list[0]].upper()
#                     base = NA3_TO_1.get(name3, "N")

#                     if prefer == "dna":
#                         ch1 = base.upper()
#                         if ch1 == "U":
#                             ch1 = "T"
#                         if ch1 not in ("A", "T", "G", "C", "N"):
#                             ch1 = "N"
#                     else:
#                         ch1 = base.upper()
#                         if ch1 == "T":
#                             ch1 = "U"
#                         if ch1 not in ("A", "U", "G", "C", "N"):
#                             ch1 = "N"

#                     seq_chars.append(ch1)

#                     P_list.append(get_coord_for_atom(atom_idx_list, "P"))
#                     O5_list.append(get_coord_for_atom(atom_idx_list, "O5'"))
#                     C5_list.append(get_coord_for_atom(atom_idx_list, "C5'"))
#                     C4_list.append(get_coord_for_atom(atom_idx_list, "C4'"))
#                     C3_list.append(get_coord_for_atom(atom_idx_list, "C3'"))
#                     O3_list.append(get_coord_for_atom(atom_idx_list, "O3'"))
#                     N_list_na.append(get_na_base_n_coord(atom_idx_list))

#                     design_mask.append(bool(designable))
#                     res_id_list.append(int(rid))
#                     chain_id_list.append(str(ch_id))
#                     res_atom_indices_list.append(atom_idx_list)

#                 L = len(seq_chars)
#                 if L == 0:
#                     continue

#                 kind = "dna" if prefer == "dna" else "rna"
#                 sample = {
#                     "title": f"{sample_name}_s{struct_idx}_{kind}_chain{ch}",
#                     "type":  kind,
#                     "seq":   "".join(seq_chars),
#                     "P":     np.stack(P_list,  axis=0).astype(np.float32),
#                     "O5":    np.stack(O5_list, axis=0).astype(np.float32),
#                     "C5":    np.stack(C5_list, axis=0).astype(np.float32),
#                     "C4":    np.stack(C4_list, axis=0).astype(np.float32),
#                     "C3":    np.stack(C3_list, axis=0).astype(np.float32),
#                     "O3":    np.stack(O3_list, axis=0).astype(np.float32),
#                     "N":     np.stack(N_list_na, axis=0).astype(np.float32),
#                     "chain_mask":     np.ones(L, dtype=np.float32),
#                     "chain_encoding": np.ones(L, dtype=np.float32),
#                     "design_mask":    np.asarray(design_mask, dtype=bool),   # residue-level 1D bool
#                     "res_ids":        np.asarray(res_id_list, dtype=int),
#                     "chain_ids":      np.asarray(chain_id_list),
#                     "res_atom_indices": [np.asarray(idxs, dtype=int) for idxs in res_atom_indices_list],
#                 }
#                 struct_samples.append(sample)

#         samples_all.append(struct_samples)

#     return samples_all

    



def inference(model, sample_input, design_modality,
              topk: int = 5, temp: float = 1.0, use_beam: bool = False,
              device=None):

    kind = str(design_modality).lower()
    # 1) featurizer/tokenizer
    if kind == 'ligand':
        from src.model.modules.invfold.src.datasets.featurizer_ligand import Featurize_Ligand, LigandTokenizer
        feat = Featurize_Ligand()
        tok = LigandTokenizer()
        batch = feat.featurize([sample_input['ligand']])
    else:
        from src.model.modules.invfold.src.datasets.featurizer import Featurize, UniTokenizer
        feat = Featurize(mixed=True, augmentor=None)
        tok = UniTokenizer()
        batch = feat.featurize([sample_input])

    # 2) featurize
    # batch = feat.featurize([sample_input]['ligand'])
    if batch is None:
        raise RuntimeError("featurize defective??")

    # 3) 设备
    if device is None:
        try:
            device = next(model.model.parameters()).device
        except Exception:
            device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    batch = _move_to(batch, device)

    # 4) forward
    # model.eval()
    model.model.eval()
    with torch.no_grad():
        out = model.model(batch)
        log_probs = out['log_probs']         # [N_all, V]
        logits    = out['logits']            # [N_all, V]
        probs_cpu_all = torch.softmax(logits / temp, dim=-1).detach().cpu()
        logp_cpu_all  = log_probs.detach().cpu()

    if kind == 'ligand':
        mask = batch.get('ligand_mask', None)
        if mask is None:
            mask = batch['chain_mask']
        mask = mask.detach().float().cpu().view(-1)  # [N_all]
        idx = (mask > 0.5).nonzero(as_tuple=False).view(-1)  # [L_lig]
        if idx.numel() == 0:
            return [], [], "", torch.empty(0, logits.shape[-1]), {
                'per_candidate': [], 'top1': {'Accuracy': 0.0, 'Macro_F1': 0.0},
                'best_idx': 0, 'best': {'Accuracy': 0.0, 'Macro_F1': 0.0}
            }

        probs_cpu = probs_cpu_all.index_select(0, idx)  # [L_lig, V]
        logp_cpu  = logp_cpu_all.index_select(0, idx)   # [L_lig, V]
    else:
        probs_cpu = probs_cpu_all
        logp_cpu  = logp_cpu_all

    L, V = probs_cpu.shape
    if kind == 'ligand':
        allow = ligand_allowed_indices(tok, V, allow_rare=True, allow_unk=False, allow_mask=False)
    else:
        allow = allowed_indices(kind, V)
        if allow.numel() == 0:
            allow = torch.arange(0, V, dtype=torch.long)

    pred_seqs, scores = [], []
    if not use_beam:
        sub = probs_cpu[:, allow]                 # [L, |allow|]
        ids_rel = sub.argmax(dim=-1)              # [L]
        ids_glb = allow[ids_rel].tolist()         # [L]
        if kind == 'ligand':
            seq = decode_ligand_ids(ids_glb, tok, sep=" ")
        else:
            seq = tok.decode(ids_glb, kind=kind)
        lp  = float(logp_cpu[torch.arange(L), torch.tensor(ids_glb)].sum())
        pred_seqs = [seq]; scores = [lp]
    else:
        beam_width = max(1, int(topk))
        beams = beam_search_logp(
            logp_cpu, allow, beam_width,
            len_norm=True, alpha=0.6,
            diversity_groups=1, gamma=0.0
        )
        for ids_glb, logp_sum in beams:
            if kind == 'ligand':
                seq = decode_ligand_ids(ids_glb, tok, sep=" ")
            else:
                seq = tok.decode(ids_glb, kind=kind)
            pred_seqs.append(seq)
            scores.append(float(logp_sum))


    if kind == 'ligand':
       
        true_seq = sample_input.get('ligand_seq') \
                   or " ".join(sample_input.get('ligand', {}).get('elements', [])) \
                   or ""
        true_tokens = (true_seq or "").split()
        if pred_seqs:
            L_common = min(len(true_tokens), *(len(s.split()) for s in pred_seqs))
        else:
            L_common = 0
        if L_common == 0:
            metrics = {
                'per_candidate': [{'Accuracy': 0.0, 'Macro_F1': 0.0} for _ in pred_seqs],
                'top1': {'Accuracy': 0.0, 'Macro_F1': 0.0},
                'best_idx': 0,
                'best': {'Accuracy': 0.0, 'Macro_F1': 0.0},
            }
            return pred_seqs, scores, true_seq, probs_cpu, metrics

        true_tokens = true_tokens[:L_common]
        per_cand = []
        for seq in pred_seqs:
            pred_tokens = seq.split()[:L_common]
            acc = sum(1 for a, b in zip(true_tokens, pred_tokens) if a == b) / float(L_common)
            labels = sorted(set(true_tokens) | set(pred_tokens))
            try:
                macro_f1 = float(f1_score(true_tokens, pred_tokens, labels=labels, average='macro'))
            except Exception:
                macro_f1 = 0.0
            per_cand.append({'Accuracy': acc, 'Macro_F1': macro_f1})
        top1 = per_cand[0]
        best_idx = max(range(len(per_cand)), key=lambda i: (per_cand[i]['Accuracy'],
                                                            per_cand[i]['Macro_F1'],
                                                            scores[i]))
        best = per_cand[best_idx]
        metrics = {'per_candidate': per_cand, 'top1': top1, 'best_idx': best_idx, 'best': best}
        return pred_seqs, scores, true_seq, probs_cpu, metrics

    # protein / rna / dna
    true_seq = sample_input['seq'][0] if isinstance(sample_input.get('seq'), list) \
               else sample_input.get('seq', '')
    L_common = min(len(true_seq), *(len(s) for s in pred_seqs)) if pred_seqs else 0
    if L_common == 0:
        metrics = {
            'per_candidate': [{'Accuracy': 0.0, 'Macro_F1': 0.0} for _ in pred_seqs],
            'top1': {'Accuracy': 0.0, 'Macro_F1': 0.0},
            'best_idx': 0,
            'best': {'Accuracy': 0.0, 'Macro_F1': 0.0},
        }
        return pred_seqs, scores, true_seq, probs_cpu, metrics
    true_seq_c = true_seq[:L_common]
    per_cand = []
    for seq in pred_seqs:
        seq_c = seq[:L_common]
        acc = sum(1 for a, b in zip(true_seq_c, seq_c) if a == b) / float(L_common)
        y_true = labels_4class(true_seq_c, kind, tok)
        y_pred = labels_4class(seq_c, kind, tok)
        try:
            macro_f1 = float(f1_score(y_true, y_pred, average='macro'))
        except Exception:
            macro_f1 = 0.0
        per_cand.append({'Accuracy': acc, 'Macro_F1': macro_f1})
    top1 = per_cand[0]
    best_idx = max(range(len(per_cand)), key=lambda i: (per_cand[i]['Accuracy'],
                                                        per_cand[i]['Macro_F1'],
                                                        scores[i]))
    best = per_cand[best_idx]
    metrics = {'per_candidate': per_cand, 'top1': top1, 'best_idx': best_idx, 'best': best}
    return pred_seqs, scores, true_seq, probs_cpu, metrics