cal_top_k_accuracy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate Top-k Accuracy (TTA20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rdkit version: 2019.03.2\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import rdkit\n",
    "from rdkit import Chem\n",
    "print('rdkit version:', rdkit.__version__)\n",
    "\n",
    "def clear_map_canonical_smiles(smi):\n",
    "    mol = Chem.MolFromSmiles(smi)\n",
    "    if mol is not None:\n",
    "        mol = Chem.MolFromSmiles(smi)\n",
    "        for atom in mol.GetAtoms():\n",
    "            if atom.HasProp('molAtomMapNumber'):\n",
    "                atom.ClearProp('molAtomMapNumber')\n",
    "        smi = Chem.MolToSmiles(mol, canonical=True)\n",
    "        return Chem.MolToSmiles(Chem.MolFromSmiles(smi))\n",
    "    else:\n",
    "        return smi\n",
    "\n",
    "from e_smiles import get_edit_from_e_smiles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5000\n"
     ]
    }
   ],
   "source": [
    "# Label ReactSeq (50k-test)\n",
    "n_best = 10\n",
    "argtimes = 1\n",
    "product_lis = []\n",
    "true_reactseq_lis = []\n",
    "with open('datasets/50k_ReactSeq/aug20_test/2023_7_13_50k_test_r20_v.txt') as f:\n",
    "    for line in f.readlines():\n",
    "        line = ','.join(line.replace('\\n','').split(',')[2:])\n",
    "        product_lis += [line.split('>>>')[0]] * n_best\n",
    "        true_reactseq_lis.append(line)\n",
    "\n",
    "edit_times_lis = []\n",
    "for i in range(5000):\n",
    "    core_edits,chai_edits,stereo_edits,charge_edits,core_edits_add,lg_map_lis = get_edit_from_e_smiles(true_reactseq_lis[i])\n",
    "    edit_times = len(core_edits) + len(chai_edits) + len(stereo_edits) + len(charge_edits) + len(core_edits_add) + len(lg_map_lis)\n",
    "    edit_times_lis.append(edit_times)\n",
    "\n",
    "# Label SMILES of Reactants (50k-test)\n",
    "DATA = 'test' \n",
    "if DATA == 'val':\n",
    "    raw_df = pd.read_csv(\"datasets/50k_raw/raw_val.csv\")\n",
    "    indexes_to_drop = [2302, 2527, 2950, 4368, 4863, 4890]\n",
    "    df = raw_df.drop(indexes_to_drop)\n",
    "\n",
    "elif DATA == 'test':\n",
    "    raw_df = pd.read_csv(\"datasets/50k_raw/raw_test.csv\")\n",
    "    indexes_to_drop = [822, 1282, 1490, 1558, 2810, 3487, 4958]\n",
    "    df = raw_df.drop(indexes_to_drop)\n",
    "\n",
    "truth = list(map(lambda x: x.split(\">>\")[0], list(df['reactants>reagents>production'])))\n",
    "truth = list(map(clear_map_canonical_smiles, truth))\n",
    "print(len(truth))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predicted E-ReactSeq (50k-test)\n",
    "pred_reactseq_lis_h = []\n",
    "\n",
    "with open('output/tgt_50k_ReactSeq_aug100_train_aug20_test_infer.txt') as f:\n",
    "    for line in f.readlines():\n",
    "        line = line.replace('\\n','').replace(\" \",\"\")\n",
    "        pred_reactseq_lis_h.append(line)\n",
    "\n",
    "reactseq_lis = []\n",
    "for i in range(len(product_lis)):\n",
    "    reactseq_lis.append(product_lis[i] + \">>>\" + pred_reactseq_lis_h[i])\n",
    "\n",
    "\n",
    "# Predicted SMILES of Reactants (50k-test)\n",
    "pred = []\n",
    "with open('output/pred_reactants_50k_ReactSeq_aug100_train_aug20_test_infer.txt') as f:\n",
    "    for line in f.readlines():\n",
    "        line = line.replace('\\n','').replace(\" \",\"\")\n",
    "        pred.append(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate top-k accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "fold = 20\n",
    "num = 5000\n",
    "n = 10\n",
    "\n",
    "score_1 = []\n",
    "for i in range(fold):\n",
    "    for j in range(num):\n",
    "        for k in range(1,n+1):\n",
    "            score_1.append(1/k**2)       # square  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "vote_score_lis = [-1]*len(pred) \n",
    "\n",
    "for j in range(num):\n",
    "    smiles_score_dic = {}\n",
    "    for i in range(fold):\n",
    "        for k in range(n):\n",
    "            idx = i * num * n + j*n + k\n",
    "            smiles = pred[idx]\n",
    "            s = score_1[idx]\n",
    "            if smiles == '':\n",
    "                s = 0\n",
    "            \n",
    "            if smiles not in smiles_score_dic:\n",
    "                smiles_score_dic[smiles] = s\n",
    "            else:\n",
    "                smiles_score_dic[smiles] += s\n",
    "\n",
    "    for i in range(fold):\n",
    "        for k in range(n):\n",
    "            idx = i * num * n + j*n + k\n",
    "            smiles = pred[idx]\n",
    "            vote_score = smiles_score_dic[smiles]\n",
    "            vote_score_lis[i * num * n + j*n + k] = vote_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "pre_smiles_50_lis = []\n",
    "pre_reactseq_50_lis = []\n",
    "\n",
    "for j in range(num):\n",
    "    smiles_g = []\n",
    "    vote_score_g = []\n",
    "    reactseq_g = []\n",
    "    for i in range(fold):\n",
    "        for k in range(n):\n",
    "            idx = i * num * n + j*n + k\n",
    "            smiles_g.append(pred[idx])\n",
    "            vote_score_g.append(vote_score_lis[idx])\n",
    "            reactseq_g.append(reactseq_lis[idx])\n",
    "    #print(smiles_g)\n",
    "    #print(vote_score_g)\n",
    "    #print(reactseq_g)\n",
    "    \n",
    "    zip_a_b_c = zip(smiles_g, reactseq_g, vote_score_g)\n",
    "    sorted_zip = sorted(zip_a_b_c, key=lambda x:x[-1],reverse= True)\n",
    "    smiles_g, reactseq_g, vote_score_g = zip(*sorted_zip)\n",
    "    \n",
    "    pre_smiles_50 = []\n",
    "    pre_reactseq_50 = []\n",
    "    for i,j in zip(smiles_g, reactseq_g):\n",
    "        if i not in pre_smiles_50 and len(pre_smiles_50) < 50:\n",
    "            pre_smiles_50.append(i)\n",
    "            pre_reactseq_50.append(j)\n",
    "\n",
    "    if len(pre_smiles_50) < 50:\n",
    "        pre_smiles_50 = pre_smiles_50 + [''] * (50-len(pre_smiles_50))\n",
    "        pre_reactseq_50 = pre_reactseq_50 + [pre_reactseq_50[-1].split('>>>')[0]+'>>>'] * (50-len(pre_reactseq_50))\n",
    "        \n",
    "    pre_smiles_50_lis.append(pre_smiles_50)\n",
    "    pre_reactseq_50_lis.append(pre_reactseq_50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top-K Pred_Set Prediction: \n",
      "Top-1 Pred accuracy after TTA: 0.589\n",
      "Top-3 Pred accuracy after TTA: 0.805\n",
      "Top-5 Pred accuracy after TTA: 0.864\n",
      "Top-10 Pred accuracy after TTA: 0.914\n"
     ]
    }
   ],
   "source": [
    "# calculate the accuracy of predicted smiles\n",
    "\n",
    "print(\"Top-K Pred_Set Prediction: \")\n",
    "k_lis = []\n",
    "for i in range(num):\n",
    "    rank = 11\n",
    "    for k in range(n):\n",
    "        if pre_smiles_50_lis[i][k] == truth[i]:\n",
    "            rank = k+1\n",
    "            break\n",
    "    k_lis.append(rank)\n",
    "\n",
    "top1 = 0\n",
    "top3 = 0\n",
    "top5 = 0\n",
    "top10 = 0\n",
    "for i in k_lis:\n",
    "    if i <= 1:\n",
    "        top1 += 1\n",
    "    if i <= 3:\n",
    "        top3 += 1\n",
    "    if i <= 5:\n",
    "        top5 += 1\n",
    "    if i <= 10:\n",
    "        top10 += 1\n",
    "        \n",
    "print(f'Top-1 Pred accuracy after TTA: {top1/num:.3f}')\n",
    "print(f'Top-3 Pred accuracy after TTA: {top3/num:.3f}')\n",
    "print(f'Top-5 Pred accuracy after TTA: {top5/num:.3f}')\n",
    "print(f'Top-10 Pred accuracy after TTA: {top10/num:.3f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # To see the wrong cases\n",
    "\n",
    "# print(\"Top-K Pred_Set Prediction: \")\n",
    "# ks = [1, 3, 5, 10] # \n",
    "# pred_k = {k:0 for k in ks}\n",
    "\n",
    "# for i in range(len(truth)):\n",
    "#   for k in ks:\n",
    "#     if truth[i] in pre_smiles_50_lis[i][:k]:\n",
    "#         pred_k[k] += 1\n",
    "#     else:\n",
    "#       if k == 1:\n",
    "#           print(i)\n",
    "#           print(\"label:\")\n",
    "#           print(truth[i])\n",
    "#           print(\"pred\")\n",
    "#           for j in range(n_best):\n",
    "#               print(pre_smiles_50_lis[i][j], end='\\n')\n",
    "#           print()    \n",
    "\n",
    "# for k in ks:\n",
    "#   # print(pred_k[k])\n",
    "#   print ('Top-%d Pred accuracy after TTA: %.3f' % (k, pred_k[k]/len(truth)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate top-k accuracy for each reaction type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_lis = []\n",
    "with open('datasets/50k_ReactSeq/aug20_test/2023_7_13_50k_test_r20_v.txt') as f:\n",
    "    for line in f.readlines():\n",
    "        class_lis.append(line.split(',')[1])\n",
    "class_lis = class_lis[:5000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "class_1 1511\n",
      "0.6036\n",
      "0.8345\n",
      "0.8974\n",
      "0.9437\n",
      "\n",
      "class_2 1190\n",
      "0.6891\n",
      "0.9008\n",
      "0.9437\n",
      "0.9731\n",
      "\n",
      "class_3 566\n",
      "0.447\n",
      "0.659\n",
      "0.7261\n",
      "0.811\n",
      "\n",
      "class_4 91\n",
      "0.5385\n",
      "0.7473\n",
      "0.7912\n",
      "0.8462\n",
      "\n",
      "class_5 68\n",
      "0.6176\n",
      "0.9118\n",
      "0.9412\n",
      "0.9412\n",
      "\n",
      "class_6 824\n",
      "0.5364\n",
      "0.7524\n",
      "0.8143\n",
      "0.8568\n",
      "\n",
      "class_7 462\n",
      "0.6017\n",
      "0.7987\n",
      "0.8701\n",
      "0.9329\n",
      "\n",
      "class_8 82\n",
      "0.7195\n",
      "0.9024\n",
      "0.9268\n",
      "0.9756\n",
      "\n",
      "class_9 183\n",
      "0.3825\n",
      "0.5683\n",
      "0.6721\n",
      "0.8142\n",
      "\n",
      "class_10 23\n",
      "0.7826\n",
      "0.8696\n",
      "0.8696\n",
      "0.913\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for c in range(1,11):\n",
    "    c ='class_' + str(c)\n",
    "    num = 0\n",
    "    top1 = 0\n",
    "    top3 = 0\n",
    "    top5 = 0\n",
    "    top10 = 0\n",
    "    for i, class_ in zip(k_lis,class_lis):\n",
    "        if class_ == c:\n",
    "            num += 1\n",
    "            if i <= 1:\n",
    "                top1 += 1\n",
    "            if i <= 3:\n",
    "                top3 += 1\n",
    "            if i <= 5:\n",
    "                top5 += 1\n",
    "            if i <= 10:\n",
    "                top10 += 1\n",
    "        else:\n",
    "            pass\n",
    "    print(c,num)\n",
    "    print(round(top1/num,4))\n",
    "    print(round(top3/num,4))\n",
    "    print(round(top5/num,4))\n",
    "    print(round(top10/num,4))\n",
    "    print('')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate top-k accuracy for each edit time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "edit_times_lis = []\n",
    "for i in range(5000):\n",
    "    core_edits,chai_edits,stereo_edits,charge_edits,core_edits_add,lg_map_lis = get_edit_from_e_smiles(true_reactseq_lis[i])\n",
    "    edit_times = len(core_edits) + len(chai_edits) + len(stereo_edits) + len(charge_edits) + len(core_edits_add) + len(lg_map_lis)\n",
    "    edit_times_lis.append(edit_times)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 194 0.0388\n",
      "0.5361\n",
      "0.7938\n",
      "0.8866\n",
      "0.9639\n",
      "\n"
     ]
    }
   ],
   "source": [
    "num = 0\n",
    "top1 = 0\n",
    "top3 = 0\n",
    "top5 = 0\n",
    "top10 = 0\n",
    "e = 1\n",
    "for i, edit_time in zip(k_lis,edit_times_lis):\n",
    "    if edit_time == e:\n",
    "        num += 1\n",
    "        if i <= 1:\n",
    "            top1 += 1\n",
    "        if i <= 3:\n",
    "            top3 += 1\n",
    "        if i <= 5:\n",
    "            top5 += 1\n",
    "        if i <= 10:\n",
    "            top10 += 1\n",
    "    else:\n",
    "        pass\n",
    "print(e,num,num/5000)\n",
    "print(round(top1/num,4))\n",
    "print(round(top3/num,4))\n",
    "print(round(top5/num,4))\n",
    "print(round(top10/num,4))\n",
    "print('')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3844 0.7688\n",
      "0.6155\n",
      "0.8356\n",
      "0.891\n",
      "0.9334\n",
      "\n"
     ]
    }
   ],
   "source": [
    "num = 0\n",
    "top1 = 0\n",
    "top3 = 0\n",
    "top5 = 0\n",
    "top10 = 0\n",
    "e = 2\n",
    "for i, edit_time in zip(k_lis,edit_times_lis):\n",
    "    if edit_time == e:\n",
    "        num += 1\n",
    "        if i <= 1:\n",
    "            top1 += 1\n",
    "        if i <= 3:\n",
    "            top3 += 1\n",
    "        if i <= 5:\n",
    "            top5 += 1\n",
    "        if i <= 10:\n",
    "            top10 += 1\n",
    "    else:\n",
    "        pass\n",
    "print(e,num,num/5000)\n",
    "print(round(top1/num,4))\n",
    "print(round(top3/num,4))\n",
    "print(round(top5/num,4))\n",
    "print(round(top10/num,4))\n",
    "print('')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 648 0.1296\n",
      "0.3997\n",
      "0.6265\n",
      "0.7083\n",
      "0.8086\n",
      "\n"
     ]
    }
   ],
   "source": [
    "num = 0\n",
    "top1 = 0\n",
    "top3 = 0\n",
    "top5 = 0\n",
    "top10 = 0\n",
    "e = 3\n",
    "for i, edit_time in zip(k_lis,edit_times_lis):\n",
    "    if edit_time == e:\n",
    "        num += 1\n",
    "        if i <= 1:\n",
    "            top1 += 1\n",
    "        if i <= 3:\n",
    "            top3 += 1\n",
    "        if i <= 5:\n",
    "            top5 += 1\n",
    "        if i <= 10:\n",
    "            top10 += 1\n",
    "    else:\n",
    "        pass\n",
    "print(e,num,num/5000)\n",
    "print(round(top1/num,4))\n",
    "print(round(top3/num,4))\n",
    "print(round(top5/num,4))\n",
    "print(round(top10/num,4))\n",
    "print('')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 238 0.0476\n",
      "0.7353\n",
      "0.8319\n",
      "0.8655\n",
      "0.8908\n",
      "\n"
     ]
    }
   ],
   "source": [
    "num = 0\n",
    "top1 = 0\n",
    "top3 = 0\n",
    "top5 = 0\n",
    "top10 = 0\n",
    "e = 4\n",
    "for i, edit_time in zip(k_lis,edit_times_lis):\n",
    "    if edit_time == e:\n",
    "        num += 1\n",
    "        if i <= 1:\n",
    "            top1 += 1\n",
    "        if i <= 3:\n",
    "            top3 += 1\n",
    "        if i <= 5:\n",
    "            top5 += 1\n",
    "        if i <= 10:\n",
    "            top10 += 1\n",
    "    else:\n",
    "        pass\n",
    "print(e,num,num/5000)\n",
    "print(round(top1/num,4))\n",
    "print(round(top3/num,4))\n",
    "print(round(top5/num,4))\n",
    "print(round(top10/num,4))\n",
    "print('')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 28 0.0056\n",
      "0.5\n",
      "0.6071\n",
      "0.6429\n",
      "0.7143\n",
      "\n"
     ]
    }
   ],
   "source": [
    "num = 0\n",
    "top1 = 0\n",
    "top3 = 0\n",
    "top5 = 0\n",
    "top10 = 0\n",
    "e = 5\n",
    "for i, edit_time in zip(k_lis,edit_times_lis):\n",
    "    if edit_time == e:\n",
    "        num += 1\n",
    "        if i <= 1:\n",
    "            top1 += 1\n",
    "        if i <= 3:\n",
    "            top3 += 1\n",
    "        if i <= 5:\n",
    "            top5 += 1\n",
    "        if i <= 10:\n",
    "            top10 += 1\n",
    "    else:\n",
    "        pass\n",
    "print(e,num,num/5000)\n",
    "print(round(top1/num,4))\n",
    "print(round(top3/num,4))\n",
    "print(round(top5/num,4))\n",
    "print(round(top10/num,4))\n",
    "print('')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 48 0.0096\n",
      "0.5208\n",
      "0.75\n",
      "0.7917\n",
      "0.8333\n",
      "\n"
     ]
    }
   ],
   "source": [
    "num = 0\n",
    "top1 = 0\n",
    "top3 = 0\n",
    "top5 = 0\n",
    "top10 = 0\n",
    "e = 6\n",
    "for i, edit_time in zip(k_lis,edit_times_lis):\n",
    "    if edit_time >= e:\n",
    "        num += 1\n",
    "        if i <= 1:\n",
    "            top1 += 1\n",
    "        if i <= 3:\n",
    "            top3 += 1\n",
    "        if i <= 5:\n",
    "            top5 += 1\n",
    "        if i <= 10:\n",
    "            top10 += 1\n",
    "    else:\n",
    "        pass\n",
    "print(e,num,num/5000)\n",
    "print(round(top1/num,4))\n",
    "print(round(top3/num,4))\n",
    "print(round(top5/num,4))\n",
    "print(round(top10/num,4))\n",
    "print('')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate top-k accuracy for Reaction Center Identification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 5000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "ture_reactseq_lis = []\n",
    "with open('datasets/50k_ReactSeq/aug20_test/2023_7_13_50k_test_r20_v.txt') as f:\n",
    "    for line in f.readlines():\n",
    "        ture_reactseq_lis.append(','.join(line.split(',')[2:]).replace('\\n',''))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "true_reactseq_lis_g = [[ture_reactseq_lis[i + j*num] for j in range(20)] for i in range(num)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5000"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(true_reactseq_lis_g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "pre_reactseq_50_lis =[[j.split('<')[0] for j in i] for i in pre_reactseq_50_lis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "pre_reactseq_50_lis_1 = []\n",
    "for reactseq_50 in pre_reactseq_50_lis_:\n",
    "    reactseq_50_1 = []\n",
    "    for reactseq in reactseq_50:\n",
    "        if reactseq not in reactseq_50_1:\n",
    "            reactseq_50_1.append(reactseq)\n",
    "    if len(reactseq_50_1) < 10:\n",
    "        reactseq_50_1 += ['']*(10 - len(reactseq_50_1))\n",
    "    pre_reactseq_50_lis_1.append(reactseq_50_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "k_lis = []\n",
    "for i in range(num):\n",
    "    rank = 11\n",
    "    for k in range(n):\n",
    "        if pre_reactseq_50_lis_1[i][k] in [i.split('<')[0] for i in true_reactseq_lis_g[i]]:\n",
    "            rank = k+1\n",
    "            break\n",
    "    k_lis.append(rank)\n",
    "    \n",
    "#k_lis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top-1 Pred Reaction Center Identification accuracy after TTA: 0.731\n",
      "Top-2 Pred Reaction Center Identification accuracy after TTA: 0.873\n",
      "Top-3 Pred Reaction Center Identification accuracy after TTA: 0.920\n",
      "Top-5 Pred Reaction Center Identification accuracy after TTA: 0.955\n",
      "Top-10 Pred Reaction Center Identification accuracy after TTA: 0.975\n"
     ]
    }
   ],
   "source": [
    "top1 = 0\n",
    "top2 = 0\n",
    "top3 = 0\n",
    "top5 = 0\n",
    "top10 = 0\n",
    "for i in k_lis:\n",
    "    if i <= 1:\n",
    "        top1 += 1\n",
    "    if i <= 2:\n",
    "        top2 += 1\n",
    "    if i <= 3:\n",
    "        top3 += 1\n",
    "    if i <= 5:\n",
    "        top5 += 1\n",
    "    if i <= 10:\n",
    "        top10 += 1\n",
    "        \n",
    "\n",
    "print(f'Top-1 Pred Reaction Center Identification accuracy after TTA: {top1/num:.3f}')\n",
    "print(f'Top-2 Pred Reaction Center Identification accuracy after TTA: {top2/num:.3f}')\n",
    "print(f'Top-3 Pred Reaction Center Identification accuracy after TTA: {top3/num:.3f}')\n",
    "print(f'Top-5 Pred Reaction Center Identification accuracy after TTA: {top5/num:.3f}')\n",
    "print(f'Top-10 Pred Reaction Center Identification accuracy after TTA: {top10/num:.3f}')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7.0"
  },
  "vscode": {
   "interpreter": {
    "hash": "434d7bec00de210c09bd7dd45dd77a4f83e36aa303c7c87cac097981fb5e7765"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}