{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "88a064af",
   "metadata": {},
   "source": [
    "Given a spectrum and candidates, can we use the peak-to-node scores to extract key substructures?\n",
    "\n",
    "- for each spectrum, look at top K candidates\n",
    "- compute peak-to-node score matrix\n",
    "- run DFS prioritizing node with high score to any peak, with predefined threshold T\n",
    "- how often are they substructures?\n",
    "- Find two examples where substructures extracted make up the target structure\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c60529bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pickle\n",
    "\n",
    "import torch\n",
    "import numpy as np\n",
    "import plotly.graph_objects as go\n",
    "from plotly.subplots import make_subplots\n",
    "from rdkit import Chem\n",
    "from rdkit.Chem import rdDepictor\n",
    "from rdkit.Chem.Draw import rdMolDraw2D\n",
    "import pickle\n",
    "import copy\n",
    "from rdkit.Chem import Draw"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "515da6c7",
   "metadata": {},
   "source": [
    "# Load data and model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7207164b",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "de653fea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data path:  /r/hassounlab/spectra_data/msgym/MassSpecGym.tsv\n",
      "Processing formula spectra\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 231104/231104 [00:16<00:00, 14307.79it/s]\n",
      "/data/yzhouc01/FILIP-MS/flare/data/datasets.py:221: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  tmp_df['spec'] = tmp_df.apply(lambda row: data_utils.make_tmp_subformula_spectra(row), axis=1)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded Model from checkpoint\n"
     ]
    }
   ],
   "source": [
    "# model and dataset\n",
    "import sys\n",
    "sys.path.insert(0, \"/data/yzhouc01/MassSpecGym\")\n",
    "sys.path.insert(0, \"/data/yzhouc01/FILIP-MS\")\n",
    "\n",
    "from rdkit import RDLogger\n",
    "import pytorch_lightning as pl\n",
    "from pytorch_lightning import Trainer\n",
    "from massspecgym.models.base import Stage\n",
    "import os\n",
    "\n",
    "from flare.utils.data import get_spec_featurizer, get_mol_featurizer, get_ms_dataset\n",
    "from flare.utils.models import get_model\n",
    "\n",
    "from flare.definitions import TEST_RESULTS_DIR\n",
    "import yaml\n",
    "from functools import partial\n",
    "# Suppress RDKit warnings and errors\n",
    "lg = RDLogger.logger()\n",
    "lg.setLevel(RDLogger.CRITICAL)\n",
    "\n",
    "# Load model and data\n",
    "\n",
    "param_pth = '/data/yzhouc01/FILIP-MS/experiments/20250913_optimized_filip-model/lightning_logs/version_0/hparams.yaml'\n",
    "with open(param_pth) as f:\n",
    "    params = yaml.load(f, Loader=yaml.FullLoader)\n",
    "\n",
    "spec_featurizer = get_spec_featurizer(params['spectra_view'], params)\n",
    "mol_featurizer = get_mol_featurizer(params['molecule_view'], params)\n",
    "dataset = get_ms_dataset(params['spectra_view'], params['molecule_view'], spec_featurizer, mol_featurizer, params)\n",
    "\n",
    "\n",
    "# load model\n",
    "import torch \n",
    "checkpoint_pth = \"/data/yzhouc01/FILIP-MS/experiments/20250913_optimized_filip-model/epoch=1993-train_loss=0.10.ckpt\"\n",
    "params['checkpoint_pth'] = checkpoint_pth\n",
    "model = get_model(params['model'], params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "267e2d12",
   "metadata": {},
   "outputs": [],
   "source": [
    "# annotation result\n",
    "with open(\"/data/yzhouc01/FILIP-MS/experiments/20250913_optimized_filip-model/result_MassSpecGym_retrieval_candidates_formula.pkl\", 'rb') as f:\n",
    "    result = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1b82ba3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_target(candidates, labels):\n",
    "    return np.array(candidates)[labels][0]\n",
    "\n",
    "def sorted_candidates(candidates, scores):\n",
    "    return np.array(candidates)[np.argsort(scores)[::-1]].tolist()\n",
    "\n",
    "def get_n_heavy_atoms(smiles):\n",
    "    mol = Chem.MolFromSmiles(smiles)\n",
    "    return mol.GetNumHeavyAtoms()\n",
    "\n",
    "def get_sorted_scores(scores):\n",
    "    return np.array(scores)[np.argsort(scores)[::-1]].tolist()\n",
    "\n",
    "result['target'] = result.apply(lambda x: get_target(x['candidates'], x['labels']), axis=1)\n",
    "\n",
    "result['sorted_candidates'] = result.apply(lambda x: sorted_candidates(x['candidates'], x['scores']), axis=1)\n",
    "\n",
    "result['n_heavy_atoms'] = result['target'].apply(get_n_heavy_atoms)\n",
    "\n",
    "result['sorted_scores'] = result['scores'].apply(get_sorted_scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "40e1b7e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>identifier</th>\n",
       "      <th>candidates</th>\n",
       "      <th>scores</th>\n",
       "      <th>labels</th>\n",
       "      <th>rank</th>\n",
       "      <th>target</th>\n",
       "      <th>sorted_candidates</th>\n",
       "      <th>n_heavy_atoms</th>\n",
       "      <th>sorted_scores</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>MassSpecGymID0000201</td>\n",
       "      <td>[CC(C)[C@@H]1C(=O)N([C@H](C(=O)O[C@@H](C(=O)N(...</td>\n",
       "      <td>[0.17369578778743744, 0.12611594796180725, 0.2...</td>\n",
       "      <td>[True, False, False, False, False, False, Fals...</td>\n",
       "      <td>17</td>\n",
       "      <td>CC(C)[C@@H]1C(=O)N([C@H](C(=O)O[C@@H](C(=O)N([...</td>\n",
       "      <td>[COCCCN1C(=O)COc2ccc(N(C(=O)[C@H]3CN(C(=O)OC(C...</td>\n",
       "      <td>57</td>\n",
       "      <td>[0.2598780691623688, 0.2579679787158966, 0.249...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>MassSpecGymID0000202</td>\n",
       "      <td>[CC(C)[C@@H]1C(=O)N([C@H](C(=O)O[C@@H](C(=O)N(...</td>\n",
       "      <td>[0.05142267048358917, 0.07289629429578781, 0.1...</td>\n",
       "      <td>[True, False, False, False, False, False, Fals...</td>\n",
       "      <td>24</td>\n",
       "      <td>CC(C)[C@@H]1C(=O)N([C@H](C(=O)O[C@@H](C(=O)N([...</td>\n",
       "      <td>[COC(=O)/C(C)=C\\CC1(O)C(=O)C2CC(C(C)C)C13Oc1c(...</td>\n",
       "      <td>57</td>\n",
       "      <td>[0.2371954619884491, 0.21642719209194183, 0.20...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>MassSpecGymID0000203</td>\n",
       "      <td>[CC(C)[C@@H]1C(=O)N([C@H](C(=O)O[C@@H](C(=O)N(...</td>\n",
       "      <td>[0.09354929625988007, 0.0947718694806099, 0.10...</td>\n",
       "      <td>[True, False, False, False, False, False, Fals...</td>\n",
       "      <td>23</td>\n",
       "      <td>CC(C)[C@@H]1C(=O)N([C@H](C(=O)O[C@@H](C(=O)N([...</td>\n",
       "      <td>[C=CCOC12Oc3ccc(OC(=O)NCC)cc3C3C(CCCCO)C(CCCCO...</td>\n",
       "      <td>57</td>\n",
       "      <td>[0.2382681667804718, 0.22565233707427979, 0.21...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             identifier                                         candidates  \\\n",
       "0  MassSpecGymID0000201  [CC(C)[C@@H]1C(=O)N([C@H](C(=O)O[C@@H](C(=O)N(...   \n",
       "1  MassSpecGymID0000202  [CC(C)[C@@H]1C(=O)N([C@H](C(=O)O[C@@H](C(=O)N(...   \n",
       "2  MassSpecGymID0000203  [CC(C)[C@@H]1C(=O)N([C@H](C(=O)O[C@@H](C(=O)N(...   \n",
       "\n",
       "                                              scores  \\\n",
       "0  [0.17369578778743744, 0.12611594796180725, 0.2...   \n",
       "1  [0.05142267048358917, 0.07289629429578781, 0.1...   \n",
       "2  [0.09354929625988007, 0.0947718694806099, 0.10...   \n",
       "\n",
       "                                              labels  rank  \\\n",
       "0  [True, False, False, False, False, False, Fals...    17   \n",
       "1  [True, False, False, False, False, False, Fals...    24   \n",
       "2  [True, False, False, False, False, False, Fals...    23   \n",
       "\n",
       "                                              target  \\\n",
       "0  CC(C)[C@@H]1C(=O)N([C@H](C(=O)O[C@@H](C(=O)N([...   \n",
       "1  CC(C)[C@@H]1C(=O)N([C@H](C(=O)O[C@@H](C(=O)N([...   \n",
       "2  CC(C)[C@@H]1C(=O)N([C@H](C(=O)O[C@@H](C(=O)N([...   \n",
       "\n",
       "                                   sorted_candidates  n_heavy_atoms  \\\n",
       "0  [COCCCN1C(=O)COc2ccc(N(C(=O)[C@H]3CN(C(=O)OC(C...             57   \n",
       "1  [COC(=O)/C(C)=C\\CC1(O)C(=O)C2CC(C(C)C)C13Oc1c(...             57   \n",
       "2  [C=CCOC12Oc3ccc(OC(=O)NCC)cc3C3C(CCCCO)C(CCCCO...             57   \n",
       "\n",
       "                                       sorted_scores  \n",
       "0  [0.2598780691623688, 0.2579679787158966, 0.249...  \n",
       "1  [0.2371954619884491, 0.21642719209194183, 0.20...  \n",
       "2  [0.2382681667804718, 0.22565233707427979, 0.21...  "
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "id": "aa94a86e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn.functional as F\n",
    "\n",
    "# Similarity matrix\n",
    "def get_similarity_matrix(spec_enc, mol_enc):\n",
    "    spec_enc =  F.normalize(spec_enc, p=2, dim=-1)\n",
    "    mol_enc = F.normalize(mol_enc, p=2, dim=-1)\n",
    "    \n",
    "    similarity = torch.matmul(spec_enc, mol_enc.T).detach().cpu().numpy()\n",
    "    sim_norm = (similarity - similarity.min()) / (similarity.max() - similarity.min() + 1e-8)\n",
    "    \n",
    "    return sim_norm\n",
    "\n",
    "def get_embeds(ms_id, cand_smiles, model=model):\n",
    "\n",
    "    i = dataset.metadata[dataset.metadata['identifier'] == ms_id].index[0]\n",
    "    cand_mol= mol_featurizer(cand_smiles)\n",
    "\n",
    "    # Embeddings\n",
    "    model = model.to(torch.device('cpu'))\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        input = copy.deepcopy(dataset[i])\n",
    "        input['mol'] = cand_mol\n",
    "        \n",
    "        spec_enc, mol_enc = model.forward(input, stage='test')\n",
    "\n",
    "    return spec_enc, mol_enc\n",
    "\n",
    "\n",
    "def smiles_to_adjacency(smiles):\n",
    "    \"\"\"\n",
    "    Convert SMILES -> adjacency dict {atom_idx: [neighbor_idx]} and RDKit Mol.\n",
    "    \"\"\"\n",
    "    mol = Chem.MolFromSmiles(smiles)\n",
    "    if mol is None:\n",
    "        raise ValueError(f\"Invalid SMILES: {smiles!r}\")\n",
    "    adjacency = {i: [] for i in range(mol.GetNumAtoms())}\n",
    "    for b in mol.GetBonds():\n",
    "        a1 = b.GetBeginAtomIdx()\n",
    "        a2 = b.GetEndAtomIdx()\n",
    "        adjacency[a1].append(a2)\n",
    "        adjacency[a2].append(a1)\n",
    "    return adjacency, mol\n",
    "\n",
    "\n",
    "def substructure_from_indices(smiles, indices):\n",
    "    \"\"\"\n",
    "    Extract substructure as a valid Mol from atom indices.\n",
    "    Works for disconnected fragments.\n",
    "    \"\"\"\n",
    "    mol = Chem.MolFromSmiles(smiles)\n",
    "    if mol is None:\n",
    "        raise ValueError(f\"Invalid SMILES: {smiles}\")\n",
    "    \n",
    "    indices = sorted(set(indices))\n",
    "    if not indices:\n",
    "        return None, None\n",
    "\n",
    "    # Remove all atoms NOT in the fragment\n",
    "    rw = Chem.RWMol(mol)\n",
    "    remove = sorted(set(range(mol.GetNumAtoms())) - set(indices), reverse=True)\n",
    "    for idx in remove:\n",
    "        rw.RemoveAtom(idx)\n",
    "\n",
    "    submol = rw.GetMol()\n",
    "    # Chem.SanitizeMol(submol)  # ensures valid valence, kekulization, etc.\n",
    "    # display(submol)\n",
    "    \n",
    "    subsmiles = Chem.MolToSmiles(submol, canonical=True)\n",
    "    return submol, subsmiles\n",
    "\n",
    "\n",
    "from collections import deque\n",
    "\n",
    "def dfs_with_scores(start, adjacency, visited, relevant_nodes, node_scores):\n",
    "    stack = [start]\n",
    "    component = []\n",
    "    while stack:\n",
    "        node = stack.pop()\n",
    "        if node not in visited and node in relevant_nodes:\n",
    "            visited.add(node)\n",
    "            component.append(node)\n",
    "            # sort neighbors by score (high → low)\n",
    "            neighbors = sorted(adjacency[node], key=lambda n: node_scores[n], reverse=True)\n",
    "            stack.extend(neighbors)\n",
    "    return component\n",
    "\n",
    "def extract_substructures(score_matrix, adjacency, threshold):\n",
    "    \"\"\"\n",
    "    score_matrix: np.array, shape (num_peaks, num_nodes)\n",
    "    adjacency: dict {node: [neighbors]} representing molecular graph\n",
    "    threshold: float\n",
    "    \n",
    "    Returns: list of substructures (list of node indices)\n",
    "    \"\"\"\n",
    "    # Step 1: Overall node scores (max across peaks)\n",
    "    # node_scores = score_matrix.max(axis=0)\n",
    "    node_scores = score_matrix.max(axis=0)\n",
    "\n",
    "\n",
    "    # Step 2: Relevant nodes (any score ≥ threshold)\n",
    "    relevant_nodes = {j for j in range(score_matrix.shape[1]) \n",
    "                      if (score_matrix[:, j] >= threshold).any()}\n",
    "\n",
    "    # Step 3: DFS traversal\n",
    "    visited = set()\n",
    "    substructures = []\n",
    "\n",
    "    # sort relevant nodes by score for consistent traversal order\n",
    "    sorted_nodes = sorted(relevant_nodes, key=lambda n: node_scores[n], reverse=True)\n",
    "\n",
    "    for node in sorted_nodes:\n",
    "        if node not in visited:\n",
    "            comp = dfs_with_scores(node, adjacency, visited, relevant_nodes, node_scores)\n",
    "            substructures.append(comp)\n",
    "\n",
    "    return substructures\n",
    "\n",
    "\n",
    "\n",
    "def bfs_with_scores(start, adjacency, visited, relevant_nodes, node_scores):\n",
    "    \"\"\"\n",
    "    BFS traversal prioritizing neighbors by node score (high → low).\n",
    "    \"\"\"\n",
    "    queue = deque([start])\n",
    "    component = []\n",
    "    \n",
    "    while queue:\n",
    "        node = queue.popleft()\n",
    "        if node not in visited and node in relevant_nodes:\n",
    "            visited.add(node)\n",
    "            component.append(node)\n",
    "            # sort neighbors by score (high → low)\n",
    "            neighbors = sorted(adjacency[node], key=lambda n: node_scores[n], reverse=True)\n",
    "            for nb in neighbors:\n",
    "                if nb not in visited and nb in relevant_nodes:\n",
    "                    queue.append(nb)\n",
    "    return component\n",
    "\n",
    "\n",
    "def extract_substructures_bfs(score_matrix, adjacency, threshold):\n",
    "    \"\"\"\n",
    "    Extract relevant substructures using BFS.\n",
    "    \n",
    "    Args:\n",
    "        score_matrix (np.ndarray): shape (num_peaks, num_nodes)\n",
    "        adjacency (dict): {node: [neighbors]} molecular graph\n",
    "        threshold (float): relevance threshold\n",
    "    \n",
    "    Returns:\n",
    "        list[list[int]]: list of substructures (atom index lists)\n",
    "    \"\"\"\n",
    "    # 1. Compute overall node scores\n",
    "    node_scores = score_matrix.max(axis=0)\n",
    "\n",
    "    # 2. Identify relevant nodes\n",
    "    relevant_nodes = {j for j in range(score_matrix.shape[1])\n",
    "                      if (score_matrix[:, j] >= threshold).any()}\n",
    "\n",
    "    # 3. BFS over relevant nodes\n",
    "    visited = set()\n",
    "    substructures = []\n",
    "\n",
    "    # Start with highest-scoring nodes\n",
    "    sorted_nodes = sorted(relevant_nodes, key=lambda n: node_scores[n], reverse=True)\n",
    "\n",
    "    for node in sorted_nodes:\n",
    "        if node not in visited:\n",
    "            comp = bfs_with_scores(node, adjacency, visited, relevant_nodes, node_scores)\n",
    "            substructures.append(comp)\n",
    "\n",
    "    return substructures\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "id": "486be19a",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def main(ms_id, target_smiles, cand_smiles_list, cand_scores_list, walk_algo='dfs', threshold=0.5, peak_threshold=0.3):\n",
    "\n",
    "    display(Chem.MolFromSmiles(target_smiles))\n",
    "    mols = []\n",
    "    legends = []\n",
    "    for i, cand_smiles in enumerate(cand_smiles_list):\n",
    "\n",
    "        # 1 Get embeddings\n",
    "        spec_enc, mol_enc = get_embeds(ms_id, cand_smiles)\n",
    "\n",
    "        # 2 compute score matrix\n",
    "        score_matrix = get_similarity_matrix(spec_enc, mol_enc) # (num_peaks, num_nodes)\n",
    "\n",
    "        # 2.5 eliminate some peaks??\n",
    "        score_matrix = score_matrix[np.all(score_matrix > peak_threshold, axis=1)]\n",
    "\n",
    "        # 3 traverse and extract\n",
    "        adjacency, mol = smiles_to_adjacency(cand_smiles)\n",
    "\n",
    "        mols.append(mol)\n",
    "        legends.append(f\"Cand@{i+1}({cand_scores_list[i]:.3})\")\n",
    "\n",
    "        if walk_algo == 'dfs':\n",
    "            substructures_indecies = extract_substructures(score_matrix, adjacency, threshold)\n",
    "        elif walk_algo == 'bfs':\n",
    "            substructures_indecies = extract_substructures_bfs(score_matrix, adjacency, threshold)\n",
    "        else:\n",
    "            raise Exception(\"Walk algorithm not supported\")\n",
    "\n",
    "        j=0\n",
    "        for j, indecies in enumerate(substructures_indecies[:2]):\n",
    "            submol, sub_smiles = substructure_from_indices(cand_smiles, indecies)\n",
    "            mols.append(submol)\n",
    "            legends.append(f\"submol_{i+1}{j}\")\n",
    "\n",
    "        while j<1:\n",
    "            mols.append(None)\n",
    "            legends.append('')\n",
    "            j+=1\n",
    "\n",
    "        if (i == 2) or (i==5):\n",
    "            # Display candidate submols\n",
    "            img = Draw.MolsToGridImage(mols, molsPerRow=3, subImgSize=(200,200), legends=legends)\n",
    "            display(img)\n",
    "\n",
    "            mols = []\n",
    "            legends = []\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "id": "59992b0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MassSpecGymID0076675, t=0.75, rank=144\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<rdkit.Chem.rdchem.Mol at 0x7f2ac2b30a50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ms_id = result[(result['n_heavy_atoms']<=25)& (result['rank']>20)].sample(1).iloc[0]['identifier']\n",
    "ms_id = \"MassSpecGymID0076675\"\n",
    "row = result[result['identifier'] == ms_id].iloc[0]\n",
    "target_smiles = row['target']\n",
    "cand_smiles_list = row['sorted_candidates'][0:6]\n",
    "cand_scores_list = row['sorted_scores'][0:6]\n",
    "\n",
    "threshold=0.75\n",
    "print(f'{ms_id}, t={threshold}, rank={row[\"rank\"]}')\n",
    "main(ms_id, target_smiles, cand_smiles_list,cand_scores_list, walk_algo='dfs', threshold=threshold, peak_threshold=0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16480e3c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "spec",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}