import pandas as pd import json import typing as T import numpy as np import torch import massspecgym.utils as utils from pathlib import Path from torch.utils.data.dataset import Dataset from torch.utils.data.dataloader import default_collate import dgl from collections import defaultdict from massspecgym.data.transforms import SpecTransform, MolTransform, MolToInChIKey from massspecgym.data.datasets import MassSpecDataset import flare.utils.data as data_utils from torch.nn.utils.rnn import pad_sequence from massspecgym.models.base import Stage import pickle import math import itertools from rdkit.Chem import AllChem from rdkit import Chem from rdkit.Chem.Scaffolds import MurckoScaffold from magma.run_magma import run_magma import matchms def _canonicalize_smiles(smiles): if not isinstance(smiles, str): return None mol = Chem.MolFromSmiles(smiles) if mol is None: return None return Chem.MolToSmiles(mol, canonical=True) def _murcko_scaffold_smiles(smiles): if not isinstance(smiles, str): return None mol = Chem.MolFromSmiles(smiles) if mol is None: return None try: scaffold = MurckoScaffold.GetScaffoldForMol(mol) except Exception: return None if scaffold is None or scaffold.GetNumAtoms() == 0: return None return Chem.MolToSmiles(scaffold, canonical=True) def _resolve_contrast_target(smiles, contrast_target="smiles", fallback="drop"): canonical = _canonicalize_smiles(smiles) if contrast_target == "smiles": return canonical if contrast_target != "scaffold": raise ValueError(f"Unsupported contrast_target: {contrast_target}") scaffold = _murcko_scaffold_smiles(smiles) if scaffold: return scaffold if fallback == "molecule": return canonical if fallback == "drop": return None raise ValueError(f"Unsupported scaffold_fallback: {fallback}") def _safe_transform_mol(mol_transform, smiles): try: return mol_transform(smiles) except Exception: return None class JESTR1_MassSpecDataset(MassSpecDataset): def __init__( self, spectra_view: str, fp_dir_pth: str = None, cons_spec_dir_pth: str = None, NL_spec_dir_pth: str = None, contrast_target: str = "smiles", scaffold_fallback: str = "drop", **kwargs ): super().__init__(**kwargs) self.use_fp = False self.use_cons_spec = False self.use_NL_spec = False self.spectra_view = spectra_view self.contrast_target = contrast_target self.scaffold_fallback = scaffold_fallback self._prepare_contrast_targets() # load fingerprints self._load_fp(fp_dir_pth) # load consensus self._load_cons_spec(cons_spec_dir_pth) # load NL specs self._load_NL_spec(NL_spec_dir_pth) def _load_fp(self, fp_dir_pth): if fp_dir_pth is not None: self.use_fp = True if fp_dir_pth: with open(fp_dir_pth, 'rb') as f: self.smiles_to_fp = pickle.load(f) else: self.smiles_to_fp = {} def _load_cons_spec(self, cons_spec_dir_pth): if cons_spec_dir_pth is not None: self.use_cons_spec = True with open(cons_spec_dir_pth, 'rb') as f: cons_specs = pickle.load(f) # Convert spectra to matchms spectra matchMS_preparer = data_utils.PrepMatchMS(self.spectra_view) spectra = cons_specs.apply(matchMS_preparer.prepare,axis=1) self.cons_specs = dict(zip(cons_specs['smiles'].tolist(), spectra)) def _load_NL_spec(self, NL_spec_dir_pth): if NL_spec_dir_pth is not None: self.use_NL_spec = True with open(NL_spec_dir_pth, 'rb') as f: NL_specs = pickle.load(f) # Convert spectra to matchms spectra matchMS_preparer = data_utils.PrepMatchMS(self.spectra_view) self.NL_specs = NL_specs.apply(matchMS_preparer.prepare,axis=1) def _prepare_contrast_targets(self): self.metadata["canonical_smiles"] = self.metadata["smiles"].apply(_canonicalize_smiles) self.metadata["contrast_target_smiles"] = self.metadata["smiles"].apply( lambda s: _resolve_contrast_target( s, contrast_target=self.contrast_target, fallback=self.scaffold_fallback, ) ) before = len(self.metadata) valid_mask = self.metadata["contrast_target_smiles"].notna() self.metadata = self.metadata[valid_mask].reset_index(drop=True) self.spectra = self.spectra[valid_mask].reset_index(drop=True) dropped = before - len(self.metadata) if dropped: print( f"Dropped {dropped} rows without valid {self.contrast_target} target " f"(fallback={self.scaffold_fallback})." ) def __getitem__(self, i, transform_spec: bool = True, transform_mol: bool = True): spec = self.spectra[i] metadata = self.metadata.iloc[i] mol = ( metadata["contrast_target_smiles"] if "contrast_target_smiles" in metadata else metadata["smiles"] if "smiles" in metadata else metadata["identifier"] ) # Apply all transformations to the spectrum item = {} if transform_spec and self.spec_transform: if isinstance(self.spec_transform, dict): for key, transform in self.spec_transform.items(): item[key] = transform(spec) if transform is not None else spec else: item["spec"] = self.spec_transform(spec) if self.return_mol_freq: item["mol_freq"] = metadata["mol_freq"] if self.return_identifier: item["identifier"] = metadata["identifier"] if self.use_fp and self.smiles_to_fp: item['fp'] = torch.Tensor(self.smiles_to_fp[mol].ToList()) if self.use_cons_spec: item['cons_spec'] = self.spec_transform[self.spectra_view](self.cons_specs[mol]) if self.use_NL_spec: item['NL_spec'] = self.spec_transform[self.spectra_view](self.NL_specs[i]) # Apply all transformations to the molecule if transform_mol and self.mol_transform: if isinstance(self.mol_transform, dict): for key, transform in self.mol_transform.items(): item[key] = transform(mol) if transform is not None else mol else: item["mol"] = self.mol_transform(mol) else: item["mol"] = mol return item class MassSpecDataset_PeakFormulas(JESTR1_MassSpecDataset): def __init__( self, spectra_view: str, spec_transform: T.Optional[T.Union[SpecTransform, T.Dict[str, SpecTransform]]], mol_transform: T.Optional[T.Union[MolTransform, T.Dict[str, MolTransform]]], pth: T.Optional[Path], subformula_dir_pth: str, fp_dir_pth: str = None, NL_spec_dir_pth: str = None, cons_spec_dir_pth: str = None, return_mol_freq: bool = False, return_identifier: bool = True, dtype: T.Type = torch.float32, formula_source = 'default', contrast_target: str = "smiles", scaffold_fallback: str = "drop", stage: Stage = Stage.TRAIN ): """ Args: """ self.pth = pth self.spec_transform = spec_transform self.mol_transform = mol_transform self.return_mol_freq = return_mol_freq self.pred_fp = False self.use_fp = False self.use_cons_spec = False self.use_NL_spec = False self.spectra_view = spectra_view self.formula_source = formula_source self.subformula_dir_pth = subformula_dir_pth self.contrast_target = contrast_target self.scaffold_fallback = scaffold_fallback if isinstance(self.pth, str): self.pth = Path(self.pth) self.spectra_view = spectra_view print("Data path: ", self.pth) self.metadata = pd.read_csv(self.pth, sep="\t") # load subformulas id_to_spec = self._load_id_to_spec(stage) # load fingerprints self._load_fp(fp_dir_pth) # load consensus spectra self._load_cons_spec(cons_spec_dir_pth) # load NL specs self._load_NL_spec(NL_spec_dir_pth) self.metadata = self.metadata[self.metadata['identifier'].isin(id_to_spec)] formula_df = pd.DataFrame.from_dict(id_to_spec, orient='index').reset_index().rename(columns={'index': 'identifier'}) self.metadata = self.metadata.merge(formula_df, on='identifier') self.metadata["canonical_smiles"] = self.metadata["smiles"].apply(_canonicalize_smiles) self.metadata["contrast_target_smiles"] = self.metadata["smiles"].apply( lambda s: _resolve_contrast_target( s, contrast_target=self.contrast_target, fallback=self.scaffold_fallback, ) ) before = len(self.metadata) self.metadata = self.metadata[self.metadata["contrast_target_smiles"].notna()].reset_index(drop=True) dropped = before - len(self.metadata) if dropped: print( f"Dropped {dropped} rows without valid {self.contrast_target} target " f"(fallback={self.scaffold_fallback})." ) # create matchms spectra matchMS_preparer = data_utils.PrepMatchMS(spectra_view=spectra_view) self.spectra = self.metadata.apply(matchMS_preparer.prepare,axis=1) if self.return_mol_freq: if "inchikey" not in self.metadata.columns: self.metadata["inchikey"] = self.metadata["smiles"].apply(utils.smiles_to_inchi_key) self.metadata["mol_freq"] = self.metadata.groupby("inchikey")["inchikey"].transform("count") self.return_identifier = return_identifier self.dtype = dtype def __getitem__(self, i, transform_spec: bool = True, transform_mol: bool = True): item = super().__getitem__(i, transform_spec, transform_mol = False) mol = item['mol'] #smiles # transform mol if transform_mol: if isinstance(self.mol_transform, dict): for key, transform in self.mol_transform.items(): item[key] = transform(mol) if transform is not None else mol else: item["mol"] = self.mol_transform(mol) return item def _load_id_to_spec(self, stage): # if stage == Stage.TRAIN: # self.metadata = self.metadata[self.metadata['fold'] != Stage.TEST.value] # else: # self.metadata = self.metadata[self.metadata['fold'] == Stage.TEST.value] all_spec_ids = self.metadata['identifier'].tolist() self.subformulaLoader = data_utils.Subformula_Loader(spectra_view=self.spectra_view, dir_path=self.subformula_dir_pth, formula_source=self.formula_source) form_list = self.metadata['formula'].tolist() prec_mz_list = self.metadata['precursor_mz'].tolist() id_to_spec = self.subformulaLoader(all_spec_ids, form_list, prec_mz_list) # create subformula spectra if no subformula is available tmp_ids = [spec_id for spec_id in all_spec_ids if spec_id not in id_to_spec] tmp_df = self.metadata[self.metadata['identifier'].isin(tmp_ids)] tmp_df['spec'] = tmp_df.apply(lambda row: data_utils.make_tmp_subformula_spectra(row), axis=1) id_to_spec.update(dict(zip(tmp_df['identifier'].tolist(), tmp_df['spec'].tolist()))) return id_to_spec class ContrastiveDataset(Dataset): def __init__( self, spec_mol_data, contrast_key: str = "contrast_target_smiles", ): super().__init__() indices = spec_mol_data.indices self.spec_mol_data = spec_mol_data self.contrast_key = contrast_key grouped = spec_mol_data.dataset.metadata.loc[indices].groupby(self.contrast_key).indices self.target_to_specmol_ids = grouped self.target_to_spec_counter = defaultdict(int) self.targets = list(self.target_to_specmol_ids.keys()) def __len__(self) -> int: return len(self.targets) def __getitem__(self, i:int) -> dict: mol = self.targets[i] # select spectrum (iterate through list of spectra) specmol_ids = self.target_to_specmol_ids[mol] counter = self.target_to_spec_counter[mol] specmol_id = specmol_ids[counter % len(specmol_ids)] item = self.spec_mol_data.__getitem__(specmol_id) self.target_to_spec_counter[mol] = counter+1 # item['smiles'] = mol # item['spec_id'] = specmol_id return item @staticmethod def collate_fn(batch: T.Iterable[dict], spec_enc: str, spectra_view: str, stage=None, batch_mol: bool = True) -> dict: mol_key = 'cand' if stage == Stage.TEST else 'mol' batch = [item for item in batch if item is not None and (not batch_mol or item.get(mol_key) is not None)] if len(batch) == 0: raise ValueError(f"Empty batch after filtering invalid {mol_key} items during {stage}.") non_standard_collate = ['mol', 'cand', 'aug_cands', 'cons_spec', 'aug_cands_fp', 'NL_spec'] require_pad = False if 'Formula' in spectra_view or 'Tokens' in spectra_view: require_pad = True padding_value=-5 if spec_enc in ('Transformer_Formula', 'Formula_BinnedSpec', 'Transformer_MzInt') else 0 non_standard_collate.append(spectra_view) else: non_standard_collate.remove('cons_spec') non_standard_collate.remove('NL_spec') collated_batch = {} # standard collate for k in batch[0].keys(): if k not in non_standard_collate: try: collated_batch[k] = default_collate([item[k] for item in batch]) except: print(f"Error in collating key {k}") raise # batch graphs if batch_mol: batch_mol = [] batch_mol_nodes= [] for item in batch: batch_mol.append(item[mol_key]) batch_mol_nodes.append(item[mol_key].num_nodes()) collated_batch[mol_key] = dgl.batch(batch_mol) collated_batch['mol_n_nodes'] = batch_mol_nodes # pad peaks/formulas if require_pad: peaks = [] n_peaks = [] for item in batch: peaks.append(item[spectra_view]) n_peaks.append(len(item[spectra_view])) collated_batch[spectra_view] = pad_sequence(peaks, batch_first=True, padding_value=padding_value) collated_batch['n_peaks'] = n_peaks if 'cons_spec' in batch[0]: peaks = [] n_peaks = [] for item in batch: peaks.append(item['cons_spec']) n_peaks.append(len(item['cons_spec'])) collated_batch['cons_spec'] = pad_sequence(peaks, batch_first=True, padding_value=padding_value) collated_batch['cons_n_peaks'] = n_peaks if 'NL_spec' in batch[0]: peaks = [] n_peaks = [] for item in batch: peaks.append(item['NL_spec']) n_peaks.append(len(item['NL_spec'])) collated_batch['NL_spec'] = pad_sequence(peaks, batch_first=True, padding_value=padding_value) collated_batch['NL_n_peaks'] = n_peaks return collated_batch class ExpandedRetrievalDataset: '''Used for testing only Assumes 'fold' column defines the split''' def __init__(self, use_formulas: bool = True, mol_label_transform: MolTransform = MolToInChIKey(), candidates_pth: T.Optional[T.Union[Path, str]] = None, fp_size: int = None, fp_radius: int = None, use_magma = False, contrast_target: str = "smiles", scaffold_fallback: str = "drop", split: str = "test", **kwargs): self.use_magma = use_magma self.contrast_target = contrast_target self.scaffold_fallback = scaffold_fallback self._candidate_validity_cache = {} self.invalid_candidate_count = 0 self.split = split self.instance = MassSpecDataset_PeakFormulas(**kwargs, return_mol_freq=False, stage = Stage.TEST) if use_formulas else JESTR1_MassSpecDataset(**kwargs, return_mol_freq=False) if self.use_fp: self.fpgen = AllChem.GetMorganGenerator(radius=fp_radius,fpSize=fp_size) self.candidates_pth = candidates_pth self.mol_label_transform = mol_label_transform # Read candidates_pth from json to dict: SMILES -> respective candidate SMILES with open(self.candidates_pth, "r") as file: candidates = json.load(file) # Fast path: MassSpecGym candidates JSON uses canonical SMILES for values. # Skip per-candidate canonicalization (~6.5M calls) but keep key canonicalization # (32K calls) so they match the canonicalized TSV query_smiles below. self.candidates = {} for s, cand in candidates.items(): canonical_query = _canonicalize_smiles(s) or s clean_cands = [] seen_cands = set() for c in cand: if not isinstance(c, str) or '.' in c: continue target_c = _resolve_contrast_target( c, contrast_target=self.contrast_target, fallback=self.scaffold_fallback, ) if target_c and target_c not in seen_cands: clean_cands.append(target_c) seen_cands.add(target_c) self.candidates[canonical_query] = clean_cands self.spec_cand = [] #(spec index, cand_smiles, true_label) # use for external dataset where target smiles is not known # self.candidates should be a dict of identifier to candidates if 'smiles' not in self.metadata.columns: if not isinstance(self.metadata.iloc[0]['identifier'], str): self.metadata['smiles'] = self.metadata['identifier'].apply(str) else: self.metadata['smiles'] = self.metadata['identifier'] self.metadata['query_smiles'] = self.metadata['smiles'].apply(lambda s: _canonicalize_smiles(s) or s) self.metadata['query_target_smiles'] = self.metadata['smiles'].apply( lambda s: _resolve_contrast_target( s, contrast_target=self.contrast_target, fallback=self.scaffold_fallback, ) ) # keep datapoints where there are candidates self.metadata = self.metadata[ self.metadata['query_target_smiles'].notna() & self.metadata['query_smiles'].isin(self.candidates.keys()) ] test_query_smiles = self.metadata[self.metadata['fold'] == self.split]['query_smiles'].tolist() test_target_smiles = self.metadata[self.metadata['fold'] == self.split]['query_target_smiles'].tolist() test_ms_id = self.metadata[self.metadata['fold'] == self.split]['identifier'].tolist() self.spec_id_to_index = dict(zip(self.metadata['identifier'], self.metadata.index)) for spec_id, query_smiles, target_smiles in zip(test_ms_id, test_query_smiles, test_target_smiles): candidates = self.candidates[query_smiles] valid_candidates = [] valid_labels = [] for cand in candidates: is_valid = self._candidate_validity_cache.get(cand) if is_valid is None: is_valid = _safe_transform_mol(self.mol_transform, cand) is not None self._candidate_validity_cache[cand] = is_valid if not is_valid: self.invalid_candidate_count += 1 continue valid_candidates.append(cand) valid_labels.append(cand == target_smiles) # mol_label = self.mol_label_transform(s) # labels = [self.mol_label_transform(c) == mol_label for c in candidates] candidates = valid_candidates labels = valid_labels if len(candidates) == 0: print(f"Skipping {spec_id}; empty candidate set") continue if not any(labels): # print(f"Target smiles not in candidate set") pass self.spec_cand.extend([(self.spec_id_to_index[spec_id], candidates[j], k) for j, k in enumerate(labels)]) def __getattr__(self, name): return self.instance.__getattribute__(name) def __len__(self): return len(self.spec_cand) def __getitem__(self, i): spec_i = self.spec_cand[i][0] cand_smiles = self.spec_cand[i][1] label = self.spec_cand[i][2] if self.use_magma: item = self.instance.__getitem__(spec_i, transform_mol=False, transform_spec=False) mzs = np.array([float(x) for x in self.metadata.iloc[spec_i]['mzs'].split(',')]) intensities = np.array([float(x) for x in self.metadata.iloc[spec_i]['intensities'].split(',')]) adduct = self.metadata.iloc[spec_i]['adduct'] precursor_mz = self.metadata.iloc[spec_i]['precursor_mz'] formula = self.metadata.iloc[spec_i]['formula'] spec_data = run_magma(i, mzs, intensities, cand_smiles, adduct) spec = self.subformulaLoader.load_magma_data(spec_data, formula, precursor_mz) spec = matchms.Spectrum( mz = np.array(spec['formula_mzs']), intensities = np.array(spec['formula_intensities']), metadata = {'precursor_mz': precursor_mz, 'formulas': np.array(spec['formulas'])}) if isinstance(self.spec_transform, dict): for key, transform in self.spec_transform.items(): item[key] = transform(spec) if transform is not None else spec else: item["spec"] = self.spec_transform(spec) else: item = self.instance.__getitem__(spec_i, transform_mol=False) item['cand'] = _safe_transform_mol(self.mol_transform, cand_smiles) if item['cand'] is None: return None item['cand_smiles'] = cand_smiles item['label'] = label if self.use_fp: item['fp'] = torch.Tensor(self.fpgen.GetFingerprint(Chem.MolFromSmiles(cand_smiles)).ToList()) return item class MassSpecDataset_Candidates: def __init__(self, use_formulas: bool, aug_cands_dir_pth: str, aug_cands_size: int, **kwargs): self.aug_cands_size = aug_cands_size self.instance = MassSpecDataset_PeakFormulas(**kwargs, return_mol_freq=False) if use_formulas else JESTR1_MassSpecDataset(**kwargs, return_mol_freq=False) with open(aug_cands_dir_pth, 'rb') as f: aug_cands = pickle.load(f) if self.use_fp: self.fpgen = AllChem.GetMorganGenerator(radius=5,fpSize=1024) self.aug_cands = {} targets = np.array(list(aug_cands.keys())) for smiles, cands in aug_cands.items(): # sort candidates by tanimoto similarity cands.sort(key=lambda x: x[1], reverse=True) cands = [c for c in cands if '.' not in c] # assert(len(cands) >0) if len(cands) <=1: # if no candidates, shuffle from target list np.random.shuffle(targets) cands = targets self.aug_cands[smiles] = itertools.cycle(cands) def __getattr__(self, name): return self.instance.__getattribute__(name) def __getitem__(self, i): item = self.instance.__getitem__(i,transform_mol=False) aug_cands = [next(self.aug_cands[item['mol']]) for _ in range(self.aug_cands_size)] item['aug_cands_fp'] = [self.fpgen.GetFingerprint(Chem.MolFromSmiles(c)).ToList() for c in aug_cands] item["aug_cands"] = [self.mol_transform(c) for c in aug_cands] item["mol"] = self.mol_transform(item["mol"]) return item