aug_emb_training.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import re\n",
    "import pandas as pd\n",
    "from torch.nn import functional as F\n",
    "from normalize_text import normalize\n",
    "from transformers import AutoModel, AutoTokenizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils import *"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Load raw data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at m3rg-iitd/matscibert were not used when initializing BertModel: ['cls.predictions.transform.LayerNorm.weight', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.decoder.bias', 'cls.predictions.bias']\n",
      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
      "Some weights of BertModel were not initialized from the model checkpoint at m3rg-iitd/matscibert and are newly initialized: ['bert.pooler.dense.weight', 'bert.pooler.dense.bias']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
     ]
    }
   ],
   "source": [
    "tokenizer = AutoTokenizer.from_pretrained('m3rg-iitd/matscibert')\n",
    "model = AutoModel.from_pretrained('m3rg-iitd/matscibert')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_length = 128\n",
    "base_path = './abs_data/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "nas_csv_file = \"./abs_data/TITLE-ABS-KEY ( room-temperature AND sodium-sulfur AND batteries ) AND ( DOCTYPE ( ar ) )_1.csv\"\n",
    "lis_csv_file = \"./abs_data/TITLE-ABS-KEY (  lithium-sulfur AND electrocatalysts) AND ( DOCTYPE ( ar ) )_1.csv\"\n",
    "sa_csv_file = \"./abs_data/TITLE-ABS-KEY ( single-atom AND electrocatalysts ) AND ( DOCTYPE ( ar ) )_1.csv\"\n",
    "lissa_csv_file = r\"./abs_data/Li-S SA_1.csv\"\n",
    "irrelevant1_csv_file = r'./abs_data/Low_relevant_1.csv'\n",
    "irrelevant2_csv_file = r'./abs_data/Low_relevant_2.csv'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "nas_df, nas_list = load_csv_abstracts(nas_csv_file)\n",
    "lis_df, lis_list = load_csv_abstracts(lis_csv_file)\n",
    "lissa_df, lissa_list = load_csv_abstracts(lissa_csv_file)\n",
    "sa_df, sa_list = load_csv_abstracts(sa_csv_file)\n",
    "\n",
    "ir1_df, ir1_list = load_csv_abstracts(irrelevant1_csv_file)\n",
    "ir2_df, ir2_list = load_csv_abstracts(irrelevant2_csv_file)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check duplicate abstracts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1218, 4), (312, 4), (81, 4))"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sa_df.shape, lis_df.shape, lissa_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Index(['title', 'abs', 'pub', 'doi'], dtype='object'), (1611, 4))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_duplicate_df = pd.concat([sa_df, lis_df, lissa_df])\n",
    "check_duplicate_df.columns, check_duplicate_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "check_series = check_duplicate_df.duplicated(subset='doi', keep='last')\n",
    "sa_check_series = check_series[:sa_df.shape[0]]\n",
    "lis_check_series = check_series[sa_df.shape[0]:sa_df.shape[0] + lis_df.shape[0]]\n",
    "lissa_check_series = check_series[-lissa_df.shape[0]:]\n",
    "del check_duplicate_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False    1198\n",
      "True       20\n",
      "dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(1198, 4)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(sa_check_series.value_counts())\n",
    "sa_df[sa_check_series==False].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_duplicate(check_series, df, abs_list):\n",
    "    print(check_series.value_counts())\n",
    "    new_df = df[check_series==False]\n",
    "    new_list = [] \n",
    "    for check, abs in zip(check_series, abs_list):\n",
    "        if check == False:\n",
    "            new_list.append(abs)\n",
    "    return new_df, new_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False    1198\n",
      "True       20\n",
      "dtype: int64\n",
      "False    297\n",
      "True      15\n",
      "dtype: int64\n",
      "False    81\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "sa_df, sa_list = remove_duplicate(sa_check_series, sa_df, sa_list)\n",
    "lis_df, lis_list = remove_duplicate(lis_check_series, lis_df, lis_list)\n",
    "lissa_df, lissa_list = remove_duplicate(lissa_check_series, lissa_df, lissa_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>> statistical info\n",
      "NaS: 202  |  LiS:  297  |  Sa:  1198  |  LiSSA: 81\n",
      "Irrelevant 1: 623  |  Irrelevant 2: 1234\n"
     ]
    }
   ],
   "source": [
    "print(\">>> statistical info\")\n",
    "print(\"NaS: {nas}  |  LiS:  {lis}  |  Sa:  {sa}  |  LiSSA: {lissa}\".\n",
    "        format(nas=len(nas_list), lis=len(lis_list), sa=len(sa_list), lissa=len(lissa_list)))\n",
    "print(\"Irrelevant 1: {ir1}  |  Irrelevant 2: {ir2}\".format(ir1=len(ir1_list), ir2=len(ir2_list)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# supply more data\n",
    "nssup_csv_file = r'./abs_data/ns_supply_more.csv'\n",
    "npsup_csv_file = r'./abs_data/np_supply_more.csv'\n",
    "othersup_csv_file = r'./abs_data/other_supply_more.csv'\n",
    "\n",
    "nssup_df, nssup_list = load_csv_abstracts(nssup_csv_file)\n",
    "npsup_df, npsup_list = load_csv_abstracts(npsup_csv_file)\n",
    "othersup_df, othersup_list = load_csv_abstracts(othersup_csv_file)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Retrieve MatSciBert Embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if pre calculated\n",
    "emb_nas_list = torch.load('./embs/nas_list.pt')\n",
    "emb_sa_list = torch.load('./embs/sa_list.pt')\n",
    "emb_lis_list = torch.load('./embs/lis_list.pt')\n",
    "emb_lissa_list = torch.load('./embs/lissa_list.pt')\n",
    "emb_ir1_list = torch.load('./embs/ir1_list.pt')\n",
    "emb_ir2_list = torch.load('./embs/ir2_list.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# remove duplicate abstracts' embeddings\n",
    "def remove_duplicate_embs(check_series, emb_list):\n",
    "    new_list = [] \n",
    "    for check, emb in zip(check_series, emb_list):\n",
    "        if check == False:\n",
    "            new_list.append(emb)\n",
    "    return new_list\n",
    "emb_sa_list = remove_duplicate_embs(sa_check_series, emb_sa_list)\n",
    "emb_lis_list = remove_duplicate_embs(lis_check_series, emb_lis_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # calculate other emebeddings\n",
    "# tokenized_lissa_list = [tokenize_sentences(lissa, tokenizer, max_length) for lissa in lissa_list]\n",
    "# tokenized_ir1_list = [tokenize_sentences(ir, tokenizer, max_length) for ir in ir1_list]\n",
    "# tokenized_ir2_list = [tokenize_sentences(ir, tokenizer, max_length) for ir in ir2_list]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# emb_lissa_list = [get_sum_hidden_emb(tokenized_lissa, model) for tokenized_lissa in tokenized_lissa_list]\n",
    "# del tokenized_lissa_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# emb_ir1_list = [get_sum_hidden_emb(tokenized_ir, model) for tokenized_ir in tokenized_ir1_list]\n",
    "# del tokenized_ir1_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# emb_ir2_list = [get_sum_hidden_emb(tokenized_ir, model) for tokenized_ir in tokenized_ir2_list]\n",
    "# del tokenized_ir2_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "nas_sa_list = []\n",
    "for i in range(1, 6):\n",
    "    nas_sa_list.append(load_paper_to_sentences(base_path + 'nasa_{i}.txt'.format(i=i)))\n",
    "tokenized_nas_sa_list = [tokenize_sentences(nasa, tokenizer, max_length) for nasa in nas_sa_list]\n",
    "emb_nas_sa_list = [get_sum_hidden_emb(tokenized_nasa, model) for tokenized_nasa in tokenized_nas_sa_list]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # retrieve data\n",
    "# tokenized_nssup_list = [tokenize_sentences(nssup, tokenizer, max_length) for nssup in nssup_list]\n",
    "# tokenized_npsup_list = [tokenize_sentences(npsup, tokenizer, max_length) for npsup in npsup_list]\n",
    "# tokenized_othersup_list = [tokenize_sentences(othersup, tokenizer, max_length) for othersup in othersup_list]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# emb_nssup_list = [get_sum_hidden_emb(tokenized_nssup, model) for tokenized_nssup in tokenized_nssup_list]\n",
    "# emb_npsup_list = [get_sum_hidden_emb(tokenized_npsup, model) for tokenized_npsup in tokenized_npsup_list]\n",
    "# emb_othersup_list = [get_sum_hidden_emb(tokenized_othersup, model) for tokenized_othersup in tokenized_othersup_list]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# torch.save(emb_nssup_list, './embs/nssup_list.pt')\n",
    "# torch.save(emb_npsup_list, './embs/npsup_list.pt')\n",
    "# torch.save(emb_othersup_list, './embs/othersup_list.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "emb_nssup_list = torch.load('./embs/nssup_list.pt')\n",
    "emb_npsup_list = torch.load('./embs/npsup_list.pt')\n",
    "emb_othersup_list = torch.load('./embs/othersup_list.pt')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## supply more data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "sup_title = [\n",
    "    \"Tuning the Coordination Structure of CuNC Single Atom Catalysts for Simultaneous Electrochemical Reduction of CO2 and NO3– to Urea\",\n",
    "    \"Fluorine-tuned single-atom catalysts with dense surface Ni-N4 sites on ultrathin carbon nanosheets for efficient CO2 electroreduction\",\n",
    "    \"Insights on forming N,O-coordinated Cu single-atom catalysts for electrochemical reduction CO2 to methane\",\n",
    "    \"Coordination-tuned Fe single-atom catalyst for efficient CO2 electroreduction: The power of B atom\",\n",
    "    \"Axial coordination regulation of MOF-based single-atom Ni catalysts by halogen atoms for enhanced CO2 electroreduction\",\n",
    "    \"Engineering unsymmetrically coordinated Cu-S1N3 single atom sites with enhanced oxygen reduction activity\",\n",
    "    \"Tuning the Coordination Environment in Single-Atom Catalysts to Achieve Highly Efficient Oxygen Reduction Reactions\",\n",
    "    \"Fe Isolated Single Atoms on S, N Codoped Carbon by Copolymer Pyrolysis Strategy for Highly Efficient Oxygen Reduction Reaction\"\n",
    "]\n",
    "\n",
    "sup_doi = [\n",
    "    \"10.1002/aenm.202201500\",\n",
    "    \"10.1016/j.apcatb.2020.119591\",\n",
    "    \"10.1038/s41467-020-20769-x\",\n",
    "    \"10.1016/j.cej.2021.134270\",\n",
    "    \"10.1007/s12274-022-4467-3\",\n",
    "    \"10.1038/s41467-020-16848-8\",\n",
    "    \"10.1021/jacs.9b09352\",\n",
    "    \"10.1002/adma.201800588\"\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "sup_abs = [\n",
    "    r\"Closing both the carbon and nitrogen loops is a critical venture to support the establishment of the circular, net-zero carbon economy. Although single atom catalysts (SACs) have gained interest for the electrochemical reduction reactions of both carbon dioxide (CO2RR) and nitrate (NO3RR), the structure–activity relationship for Cu SAC coordination for these reactions remains unclear and should be explored such that a fundamental understanding is developed. To this end, the role of the Cu coordination structure is investigated in dictating the activity and selectivity for the CO2RR and NO3RR. In agreement with the density functional theory calculations, it is revealed that Cu-N4 sites exhibit higher intrinsic activity toward the CO2RR, whilst both Cu-N4 and Cu-N4−x-Cx sites are active toward the NO3RR. Leveraging these findings, CO2RR and NO3RR are coupled for the formation of urea on Cu SACs, revealing the importance of *COOH binding as a critical parameter determining the catalytic activity for urea production. To the best of the authors’ knowledge, this is the first report employing SACs for electrochemical urea synthesis from CO2RR and NO3RR, which achieves a Faradaic efficiency of 28% for urea production with a current density of −27 mA cm–2 at −0.9 V versus the reversible hydrogen electrode.\",\n",
    "    r\"A fluorine-tuned single-atom catalyst with an ultrathin nanosheet morphology (only ∼1.25 nm) and high Ni content of 5.92 wt% was fabricated by a polymer-assisted pyrolysis approach. The synthetic approach not only controls the establishment of the ultrathin nanosheet structure for achieving high surface communication, but also incorporates F dopants to manipulate the electronic structure of the metalloporphyrin-like active sites (Ni-N4). As a result, such catalyst with unique structural features exhibits a remarkable electrocatalytic performance for CO2-to-CO conversion with the Faradaic efficiency (FE) over 95 % in a wide potential range and an outstanding CO evolution rate of 1146 mmol gcat–1 h–1 at –0.97 V vs. RHE. The in situ attenuated total reflection-infrared spectroscopy (ATR-IR) and theoretical calculations further demonstrate that the F-doping modulates the electron configuration of the central Ni-N4 sites and thereby reduces the energy barrier for CO2 activation, which is favorable to the generation of the key *COOH intermediate.\",\n",
    "    r\"Single-atom catalysts (SACs) are promising candidates to catalyze electrochemical CO2 reduction (ECR) due to maximized atomic utilization. However, products are usually limited to CO instead of hydrocarbons or oxygenates due to unfavorable high energy barrier for further electron transfer on synthesized single atom catalytic sites. Here we report a novel partial-carbonization strategy to modify the electronic structures of center atoms on SACs for lowering the overall endothermic energy of key intermediates. A carbon-dots-based SAC margined with unique CuN2O2 sites was synthesized for the first time. The introduction of oxygen ligands brings remarkably high Faradaic efficiency (78%) and selectivity (99% of ECR products) for electrochemical converting CO2 to CH4 with current density of 40 mA·cm-2 in aqueous electrolytes, surpassing most reported SACs which stop at two-electron reduction. Theoretical calculations further revealed that the high selectivity and activity on CuN2O2 active sites are due to the proper elevated CH4 and H2 energy barrier and fine-tuned electronic structure of Cu active sites.\",\n",
    "    r\"Designing of effective electrocatalysts for electrocatalytic CO2 reduction into value-added chemicals is the key to reducing CO2 concentration and achieving carbon neutrality. However, achieving high activity and product selectivity simultaneously remains a significant challenge. Herein, a series of Fe single-atom catalysts coordinated by B atoms, namely FeBxCy (x + y = 3 or 4), are constructed to systematically investigate the electrocatalytic CO2 reduction reaction (CO2RR) based on density functional theory computations. Eight catalysts, including FeO4, are identified that can effectively activate CO2 molecules and significantly inhibit competitive hydrogen evolution reaction (HER). Among them, FeB2C and FeB2C2h (h represents a cis structure) show the higher CO2RR activity with the less negative limiting potentials of −0.24 and −0.40 V toward production of CH4, indicating the optimal content for doping B atoms. The activity mechanism shows that d-band center and magnetic moment of central Fe atom can be manipulated by rational modulating the coordinated B atoms to improve the CO2RR performance. By the coordinated B atom, an optimal adsorption strength of the reaction intermediates can be achieved on the FeBxCy surface, and thereby increasing CO2RR catalytic activity and product selectivity. FeB2C with more negative d-band center and the optimal Fe atomic magnetic moment shows the best CO2RR performance. These results reveal a great potential of coordination tuning for CO2RR, and provide a new theoretical perspective for rational design of high activity, selective CO2RR catalysts.\",\n",
    "    r\"Single-atom catalysts (SACs), with the utmost atom utilization, have attracted extensive interests for various catalytic applications. The coordination environment of SACs has been recognized to play a vital role in catalysis while their precise regulation at atomic level remains an immense challenge. Herein, a post metal halide modification (PMHM) strategy has been developed to construct Ni-N4 sites with axially coordinated halogen atoms, named Ni1N-C (X) (X = Cl, Br, and I), on pre-synthetic nitrogen-doped carbon derived from metal-organic frameworks. The axial halogen atoms with distinct electronegativity can break the symmetric charge distribution of planar Ni-N4 sites and regulate the electronic states of central Ni atoms in Ni1N-C (X) (X = Cl, Br, and I). Significantly, the Ni1N-C (Cl) catalyst, decorated with the most electronegative Cl atoms, exhibits Faradaic efficiency of CO up to 94.7% in electrocatalytic CO2 reduction, outperforming Ni1N-C (Br) and Ni1N-C (I) catalysts. Moreover, Ni1N-C (Cl) also presents superb performance in Zn-CO2 battery with ultrahigh CO selectivity and great durability. Theoretical calculations reveal that the axially coordinated Cl atom remarkably facilitates *COOH intermediate formation on single-atom Ni sites, thereby boosting the CO2 reduction performance of Ni1N-C (Cl). This work offers a facile strategy to tailor the axial coordination environments of SACs at atomic level and manifests the crucial role of axial coordination microenvironments in catalysis.\",\n",
    "    r\"Atomic interface regulation is thought to be an efficient method to adjust the performance of single atom catalysts. Herein, a practical strategy was reported to rationally design single copper atoms coordinated with both sulfur and nitrogen atoms in metal-organic framework derived hierarchically porous carbon (S-Cu-ISA/SNC). The atomic interface configuration of the copper site in S-Cu-ISA/SNC is detected to be an unsymmetrically arranged Cu-S1N3 moiety. The catalyst exhibits excellent oxygen reduction reaction activity with a half-wave potential of 0.918 V vs. RHE. Additionally, through in situ X-ray absorption fine structure tests, we discover that the low-valent Cuprous-S1N3 moiety acts as an active center during the oxygen reduction process. Our discovery provides a universal scheme for the controllable synthesis and performance regulation of single metal atom catalysts toward energy applications.\",\n",
    "    r\"Designing atomically dispersed metal catalysts for oxygen reduction reaction (ORR) is a promising approach to achieve efficient energy conversion. Herein, we develop a template-assisted method to synthesize a series of single metal atoms anchored on porous N,S-codoped carbon (NSC) matrix as highly efficient ORR catalysts to investigate the correlation between the structure and their catalytic performance. The structure analysis indicates that an identical synthesis method results in distinguished structural differences between Fe-centered single-atom catalyst (Fe-SAs/NSC) and Co-centered/Ni-centered single-atom catalysts (Co-SAs/NSC and Ni-SAs/NSC) because of the different trends of each metal ion in forming a complex with the N,S-containing precursor during the initial synthesis process. The Fe-SAs/NSC mainly consists of a well-dispersed FeN4S2 center site where S atoms form bonds with the N atoms. The S atoms in Co-SAs/NSC and Ni-SAs/NSC, on the other hand, form metal–S bonds, resulting in CoN3S1 and NiN3S1 center sites. Density functional theory (DFT) reveals that the FeN4S2 center site is more active than the CoN3S1 and NiN3S1 sites, due to the higher charge density, lower energy barriers of the intermediates, and products involved. The experimental results indicate that all three single-atom catalysts could contribute high ORR electrochemical performances, while Fe-SAs/NSC exhibits the highest of all, which is even better than commercial Pt/C. Furthermore, Fe-SAs/NSC also displays high methanol tolerance as compared to commercial Pt/C and high stability up to 5000 cycles. This work provides insights into the rational design of the definitive structure of single-atom catalysts with tunable electrocatalytic activities for efficient energy conversion.\",\n",
    "    r\"Heteroatom-doped Fe-NC catalyst has emerged as one of the most promising candidates to replace noble metal-based catalysts for highly efficient oxygen reduction reaction (ORR). However, delicate controls over their structure parameters to optimize the catalytic efficiency and molecular-level understandings of the catalytic mechanism are still challenging. Herein, a novel pyrrole–thiophene copolymer pyrolysis strategy to synthesize Fe-isolated single atoms on sulfur and nitrogen-codoped carbon (Fe-ISA/SNC) with controllable S, N doping is rationally designed. The catalytic efficiency of Fe-ISA/SNC shows a volcano-type curve with the increase of sulfur doping. The optimized Fe-ISA/SNC exhibits a half-wave potential of 0.896 V (vs reversible hydrogen electrode (RHE)), which is more positive than those of Fe-isolated single atoms on nitrogen codoped carbon (Fe-ISA/NC, 0.839 V), commercial Pt/C (0.841 V), and most reported nonprecious metal catalysts. Fe-ISA/SNC is methanol tolerable and shows negligible activity decay in alkaline condition during 15 000 voltage cycles. X-ray absorption fine structure analysis and density functional theory calculations reveal that the incorporated sulfur engineers the charges on N atoms surrounding the Fe reactive center. The enriched charge facilitates the rate-limiting reductive release of OH* and therefore improved the overall ORR efficiency.\"\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sup_dict = {'title': sup_title, 'abs': sup_abs, 'pub': None, 'doi': sup_doi, 'class': ['supply_more' for _ in range(len(sup_doi))]}\n",
    "sup_df = pd.DataFrame(sup_dict)\n",
    "sup_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "sup_df.to_csv(\"./abs_data/supplied_abs.csv\", index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sup_list = []\n",
    "# for abs in sup_df['abs']:\n",
    "#     sup_list.append(split_into_sentences(abs))\n",
    "# tokenized_sup_list = [tokenize_sentences(sup, tokenizer, max_length) for sup in sup_list]\n",
    "# emb_sup_list = [get_sum_hidden_emb(tokenized_sup, model) for tokenized_sup in tokenized_sup_list]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# torch.save(emb_sup_list, './embs/sup_list.pt')\n",
    "emb_sup_list = torch.load('./embs/sup_list.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # save emb\n",
    "# torch.save(emb_lissa_list, './embs/lissa_list.pt')\n",
    "# torch.save(emb_ir1_list, './embs/ir1_list.pt')\n",
    "# torch.save(emb_ir2_list, './embs/ir2_list.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# release memory\n",
    "del tokenizer, model"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Create Labeled Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import Dataset\n",
    "from torch.utils.data import DataLoader\n",
    "class AbstractDataset(Dataset):\n",
    "    def __init__(self, emb_nas_list, emb_lis_list, emb_sa_list, emb_lissa_list,\n",
    "                       emb_ir1_list, emb_ir2_list, emb_nssup_list, emb_npsup_list, emb_othersup_list) -> None:\n",
    "        # create labels\n",
    "        label_nas = torch.full([len(emb_nas_list) + len(emb_nssup_list) + len(emb_npsup_list) + len(emb_othersup_list)], 0)\n",
    "        label_lis = torch.full([len(emb_lis_list)], 1)\n",
    "        label_sa = torch.full([len(emb_sa_list)], 2)\n",
    "        label_lissa = torch.full([len(emb_lissa_list)], 3)\n",
    "        label_ir1 = torch.full([len(emb_ir1_list)], 4)\n",
    "        label_ir2 = torch.full([len(emb_ir2_list)], 5)\n",
    "        self.labels = torch.cat([label_nas, label_lis, label_sa, label_lissa, label_ir1, label_ir2])\n",
    "        # data\n",
    "        emb_nas = torch.stack(emb_nas_list)\n",
    "        emb_nssup = torch.stack(emb_nssup_list)\n",
    "        emb_npsup = torch.stack(emb_npsup_list)\n",
    "        emb_othersup = torch.stack(emb_othersup_list)\n",
    "        emb_lis = torch.stack(emb_lis_list)\n",
    "        emb_sa = torch.stack(emb_sa_list)\n",
    "        emb_lissa = torch.stack(emb_lissa_list)\n",
    "        emb_ir1 = torch.stack(emb_ir1_list)\n",
    "        emb_ir2 = torch.stack(emb_ir2_list)\n",
    "        self.data = torch.cat([emb_nas, emb_nssup, emb_npsup, emb_othersup, emb_lis, emb_sa, emb_lissa, emb_ir1, emb_ir2])\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self.data.shape[0]\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        return self.data[index], self.labels[index]     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3666"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset = AbstractDataset(emb_nas_list, emb_lis_list, emb_sa_list, emb_lissa_list, emb_ir1_list, emb_ir2_list, emb_nssup_list, emb_npsup_list, emb_othersup_list)\n",
    "len(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split train, test set\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "def gen_train_test_idxs(offset, cls_idxs, test_rate=0, train_test_num={}):\n",
    "    if test_rate > 0:\n",
    "        train_idxs, test_idxs = train_test_split(cls_idxs, test_size=test_rate)\n",
    "    else:\n",
    "        train_idxs, test_idxs = train_test_split(cls_idxs, train_size = train_test_num['train'], test_size = train_test_num['test'])\n",
    "    print(\"Train size: {tr} | Test size: {te}\".format(tr=len(train_idxs), te=len(test_idxs)))\n",
    "    return [idx + offset for idx in train_idxs], [idx + offset for idx in test_idxs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train size: 209 | Test size: 24\n",
      "Train size: 267 | Test size: 30\n",
      "Train size: 270 | Test size: 30\n",
      "Train size: 72 | Test size: 9\n",
      "Train size: 270 | Test size: 30\n",
      "Train size: 270 | Test size: 30\n"
     ]
    }
   ],
   "source": [
    "# each class has a maximun number of 300\n",
    "start_offset = 0\n",
    "cut_points = []\n",
    "train_idxs, val_idxs = [], []\n",
    "# nas\n",
    "temp_train, temp_test = gen_train_test_idxs(start_offset, list(range(len(emb_nas_list) + len(emb_nssup_list) + len(emb_npsup_list) + len(emb_othersup_list))), test_rate=0.1)\n",
    "train_idxs += temp_train\n",
    "val_idxs += temp_test\n",
    "cut_points.append([start_offset, start_offset + len(emb_nas_list) + len(emb_nssup_list) + len(emb_npsup_list) + len(emb_othersup_list)])\n",
    "start_offset += len(emb_nas_list)\n",
    "# lis\n",
    "temp_train, temp_test = gen_train_test_idxs(start_offset, list(range(len(emb_lis_list))), test_rate=0.1)\n",
    "train_idxs += temp_train\n",
    "val_idxs += temp_test\n",
    "cut_points.append([start_offset, start_offset + len(emb_lis_list)])\n",
    "start_offset += len(emb_lis_list)\n",
    "# sa\n",
    "temp_train, temp_test = gen_train_test_idxs(start_offset, list(range(len(emb_sa_list))), train_test_num={'train': 270, 'test':30})\n",
    "train_idxs += temp_train\n",
    "val_idxs += temp_test\n",
    "cut_points.append([start_offset, start_offset + len(emb_sa_list)])\n",
    "start_offset += len(emb_sa_list)\n",
    "# lissa\n",
    "temp_train, temp_test = gen_train_test_idxs(start_offset, list(range(len(emb_lissa_list))), test_rate=0.1)\n",
    "train_idxs += temp_train\n",
    "val_idxs += temp_test\n",
    "cut_points.append([start_offset, start_offset + len(emb_lissa_list)])\n",
    "start_offset += len(emb_lissa_list)\n",
    "# ir1\n",
    "temp_train, temp_test = gen_train_test_idxs(start_offset, list(range(len(emb_ir1_list))), train_test_num={'train': 270, 'test':30})\n",
    "train_idxs += temp_train\n",
    "val_idxs += temp_test\n",
    "cut_points.append([start_offset, start_offset + len(emb_ir1_list)])\n",
    "start_offset += len(emb_ir1_list)\n",
    "# ir2\n",
    "temp_train, temp_test = gen_train_test_idxs(start_offset, list(range(len(emb_ir2_list))), train_test_num={'train': 270, 'test':30})\n",
    "train_idxs += temp_train\n",
    "val_idxs += temp_test\n",
    "cut_points.append([start_offset, start_offset + len(emb_ir2_list)])\n",
    "start_offset += len(emb_ir2_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1358, 153)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(train_idxs), len(val_idxs)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Train MLP for Augmented Embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "class MLP(nn.Module):\n",
    "    def __init__(self, num_layers, input_dim, hidden_dim, output_dim, dropout=0):\n",
    "        super().__init__()\n",
    "        self.linears = nn.ModuleList()\n",
    "        self.linears.append(nn.Linear(input_dim, hidden_dim, bias=False))\n",
    "        for _ in range(num_layers-2):\n",
    "            self.linears.append(nn.Linear(hidden_dim, hidden_dim, bias=False))\n",
    "        self.linears.append(nn.Linear(hidden_dim, output_dim, bias=False))\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        # self.batch_norm = nn.BatchNorm1d((hidden_dim))\n",
    "\n",
    "    def forward(self, x):\n",
    "        h = x\n",
    "        for layer in self.linears[:-1]:\n",
    "            h = F.relu(layer(self.dropout(h)))\n",
    "        # output layer\n",
    "        out = self.linears[-1](h)\n",
    "        return out\n",
    "    \n",
    "    def retrieve_emb(self, x):\n",
    "        h = x\n",
    "        for layer in self.linears[:-1]:\n",
    "            h = F.relu(layer(h))\n",
    "        return h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "\n",
    "class EarlyStopping:\n",
    "    def __init__(self, patience=10, name='', base='./mlp_models/'):\n",
    "        self.patience = patience\n",
    "        self.counter = 0\n",
    "        self.best_score = None\n",
    "        self.early_stop = False\n",
    "        self.name = name\n",
    "        self.base = base\n",
    "\n",
    "    def step(self, acc, model):\n",
    "        score = acc\n",
    "        if self.best_score is None:\n",
    "            self.best_score = score\n",
    "            self.save_checkpoint(model)\n",
    "        elif score < self.best_score:\n",
    "            self.counter += 1\n",
    "            print(f'EarlyStopping counter: {self.counter} out of {self.patience}')\n",
    "            if self.counter >= self.patience:\n",
    "                self.early_stop = True\n",
    "        else:\n",
    "            self.best_score = score\n",
    "            self.save_checkpoint(model)\n",
    "            self.counter = 0\n",
    "        return self.early_stop\n",
    "\n",
    "    def save_checkpoint(self, model):\n",
    "        '''Saves model when validation loss decrease.'''\n",
    "        torch.save(model.state_dict(), self.base + self.name + '_checkpoint.pt')\n",
    "\n",
    "def evaluate(dataloader, model):\n",
    "    model.eval()\n",
    "    total = 0\n",
    "    total_correct = 0\n",
    "    for batched_data, labels in dataloader:\n",
    "        total += len(labels)\n",
    "        logits = model(batched_data)\n",
    "        _, predicted = torch.max(logits, 1)\n",
    "        total_correct += (predicted == labels).sum().item()\n",
    "    acc = 1.0 * total_correct / total\n",
    "    return acc\n",
    "\n",
    "def train(model, train_loader, val_loader, epochs, lr=0.01, verbose=True, stopper=None):\n",
    "    loss_fcn = nn.CrossEntropyLoss()\n",
    "    optimizer = optim.Adam(model.parameters(), lr=lr)\n",
    "    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=15, gamma=0.5)\n",
    "\n",
    "    loss_values = []\n",
    "    train_acc_values = []\n",
    "    val_acc_values = []\n",
    "    \n",
    "    for epoch in range(epochs):\n",
    "        model.train()\n",
    "        total_loss = 0\n",
    "        for batch, (batched_data, labels) in enumerate(train_loader):\n",
    "            logits = model(batched_data)\n",
    "            loss = loss_fcn(logits, labels)\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            total_loss += loss.item()\n",
    "        scheduler.step()\n",
    "        train_acc = evaluate(train_loader, model)\n",
    "        valid_acc = evaluate(val_loader, model)\n",
    "        loss_values.append(total_loss / (batch + 1))\n",
    "        train_acc_values.append(train_acc)\n",
    "        val_acc_values.append(valid_acc)\n",
    "        if verbose:\n",
    "            print(\n",
    "                \"Epoch {:05d} | Loss {:.4f} | Train Acc. {:.4f} | Validation Acc. {:.4f} \".format(\n",
    "                    epoch, total_loss / (batch + 1), train_acc, valid_acc\n",
    "                )\n",
    "            )\n",
    "        if stopper is not None:\n",
    "            if stopper.step(valid_acc, model):\n",
    "                break\n",
    "    \n",
    "    return loss_values, train_acc_values, val_acc_values\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLP(\n",
       "  (linears): ModuleList(\n",
       "    (0): Linear(in_features=98304, out_features=128, bias=False)\n",
       "    (1): Linear(in_features=128, out_features=128, bias=False)\n",
       "    (2): Linear(in_features=128, out_features=128, bias=False)\n",
       "    (3): Linear(in_features=128, out_features=6, bias=False)\n",
       "  )\n",
       "  (dropout): Dropout(p=0, inplace=False)\n",
       ")"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "n_layer = 4\n",
    "in_dim = emb_sa_list[0].shape[0]\n",
    "out_dim = 6\n",
    "hidden_dim = 128\n",
    "\n",
    "name = datetime.now().strftime('%Y-%m-%d %H:%M:%S')\n",
    "early_stop = EarlyStopping(patience=15, name=name)\n",
    "\n",
    "# del mlp\n",
    "mlp = MLP(n_layer, in_dim, hidden_dim, out_dim, dropout=0)\n",
    "mlp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data.sampler import SubsetRandomSampler\n",
    "train_dataloader = DataLoader(dataset, sampler=SubsetRandomSampler(train_idxs), batch_size=64)\n",
    "test_dataloader = DataLoader(dataset, sampler=SubsetRandomSampler(val_idxs), batch_size=64)\n",
    "# train_dataloader = DataLoader(dataset, sampler=SubsetRandomSampler([0,1,2]), batch_size=1)\n",
    "# test_dataloader = DataLoader(dataset, sampler=SubsetRandomSampler([8,24]), batch_size=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 00000 | Loss 55.3923 | Train Acc. 0.2371 | Validation Acc. 0.2745 \n",
      "Epoch 00001 | Loss 1.6214 | Train Acc. 0.5155 | Validation Acc. 0.4902 \n",
      "Epoch 00002 | Loss 0.8891 | Train Acc. 0.7062 | Validation Acc. 0.6732 \n",
      "Epoch 00003 | Loss 0.6136 | Train Acc. 0.6325 | Validation Acc. 0.5948 \n",
      "EarlyStopping counter: 1 out of 15\n",
      "Epoch 00004 | Loss 0.6313 | Train Acc. 0.7835 | Validation Acc. 0.7843 \n",
      "Epoch 00005 | Loss 0.3704 | Train Acc. 0.9168 | Validation Acc. 0.8039 \n",
      "Epoch 00006 | Loss 0.2739 | Train Acc. 0.9374 | Validation Acc. 0.8301 \n",
      "Epoch 00007 | Loss 0.2632 | Train Acc. 0.9315 | Validation Acc. 0.8693 \n",
      "Epoch 00008 | Loss 0.2644 | Train Acc. 0.9448 | Validation Acc. 0.7712 \n",
      "EarlyStopping counter: 1 out of 15\n",
      "Epoch 00009 | Loss 0.1742 | Train Acc. 0.9433 | Validation Acc. 0.8235 \n",
      "EarlyStopping counter: 2 out of 15\n",
      "Epoch 00010 | Loss 0.1069 | Train Acc. 0.9521 | Validation Acc. 0.8170 \n",
      "EarlyStopping counter: 3 out of 15\n",
      "Epoch 00011 | Loss 0.1772 | Train Acc. 0.7990 | Validation Acc. 0.6536 \n",
      "EarlyStopping counter: 4 out of 15\n",
      "Epoch 00012 | Loss 0.2201 | Train Acc. 0.8844 | Validation Acc. 0.7386 \n",
      "EarlyStopping counter: 5 out of 15\n",
      "Epoch 00013 | Loss 0.1706 | Train Acc. 0.9772 | Validation Acc. 0.8170 \n",
      "EarlyStopping counter: 6 out of 15\n",
      "Epoch 00014 | Loss 0.0747 | Train Acc. 0.9948 | Validation Acc. 0.8431 \n",
      "EarlyStopping counter: 7 out of 15\n",
      "Epoch 00015 | Loss 0.0431 | Train Acc. 0.9948 | Validation Acc. 0.9085 \n",
      "Epoch 00016 | Loss 0.0215 | Train Acc. 0.9971 | Validation Acc. 0.8954 \n",
      "EarlyStopping counter: 1 out of 15\n",
      "Epoch 00017 | Loss 0.0121 | Train Acc. 0.9978 | Validation Acc. 0.8824 \n",
      "EarlyStopping counter: 2 out of 15\n",
      "Epoch 00018 | Loss 0.0101 | Train Acc. 0.9963 | Validation Acc. 0.8105 \n",
      "EarlyStopping counter: 3 out of 15\n",
      "Epoch 00019 | Loss 0.0154 | Train Acc. 0.9971 | Validation Acc. 0.8235 \n",
      "EarlyStopping counter: 4 out of 15\n",
      "Epoch 00020 | Loss 0.0167 | Train Acc. 0.9978 | Validation Acc. 0.8431 \n",
      "EarlyStopping counter: 5 out of 15\n",
      "Epoch 00021 | Loss 0.0083 | Train Acc. 0.9978 | Validation Acc. 0.8301 \n",
      "EarlyStopping counter: 6 out of 15\n",
      "Epoch 00022 | Loss 0.0066 | Train Acc. 0.9985 | Validation Acc. 0.8824 \n",
      "EarlyStopping counter: 7 out of 15\n",
      "Epoch 00023 | Loss 0.0087 | Train Acc. 0.9993 | Validation Acc. 0.8889 \n",
      "EarlyStopping counter: 8 out of 15\n",
      "Epoch 00024 | Loss 0.0053 | Train Acc. 0.9985 | Validation Acc. 0.8105 \n",
      "EarlyStopping counter: 9 out of 15\n",
      "Epoch 00025 | Loss 0.0086 | Train Acc. 0.9993 | Validation Acc. 0.8627 \n",
      "EarlyStopping counter: 10 out of 15\n",
      "Epoch 00026 | Loss 0.0056 | Train Acc. 0.9993 | Validation Acc. 0.8824 \n",
      "EarlyStopping counter: 11 out of 15\n",
      "Epoch 00027 | Loss 0.0040 | Train Acc. 0.9993 | Validation Acc. 0.8693 \n",
      "EarlyStopping counter: 12 out of 15\n",
      "Epoch 00028 | Loss 0.0056 | Train Acc. 0.9985 | Validation Acc. 0.8562 \n",
      "EarlyStopping counter: 13 out of 15\n",
      "Epoch 00029 | Loss 0.0077 | Train Acc. 0.9993 | Validation Acc. 0.8954 \n",
      "EarlyStopping counter: 14 out of 15\n",
      "Epoch 00030 | Loss 0.0042 | Train Acc. 0.9993 | Validation Acc. 0.8693 \n",
      "EarlyStopping counter: 15 out of 15\n"
     ]
    }
   ],
   "source": [
    "epochs = 100\n",
    "loss_values, train_acc_values, val_acc_values = train(mlp, train_dataloader, test_dataloader, epochs, stopper=early_stop, lr=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8823529411764706"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mlp.load_state_dict(torch.load('./mlp_models/' + name +  '_checkpoint.pt'))\n",
    "evaluate(test_dataloader, mlp)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# loss plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "epochs = range(len(loss_values))\n",
    "\n",
    "fig, ax1 = plt.subplots()\n",
    "\n",
    "color = 'tab:red'\n",
    "ax1.set_xlabel('Epochs')\n",
    "ax1.set_ylabel('Loss', color=color)\n",
    "ax1.plot(epochs, loss_values, color=color)\n",
    "ax1.tick_params(axis='y', labelcolor=color)\n",
    "\n",
    "ax2 = ax1.twinx()\n",
    "\n",
    "color = 'tab:blue'\n",
    "ax2.set_ylabel('Accuracy', color=color)\n",
    "ax2.plot(epochs, train_acc_values, color=color, label='Train Accuracy')\n",
    "ax2.plot(epochs, val_acc_values, color=color, label='Validation Accuracy', linestyle='--')\n",
    "ax2.tick_params(axis='y', labelcolor=color)\n",
    "\n",
    "plt.title('Loss and Accuracy vs. Epochs')\n",
    "plt.legend(loc='best')\n",
    "\n",
    "plt.savefig('./save_files/loss_acc_plot.png', dpi=300)\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "\n",
    "with open('./save_files/loss_acc_values.csv', 'w', newline='') as csvfile:\n",
    "    writer = csv.writer(csvfile)\n",
    "    writer.writerow(['Epoch', 'Loss', 'Train Accuracy', 'Validation Accuracy'])\n",
    "    for i in range(len(loss_values)):\n",
    "        writer.writerow([i, loss_values[i], train_acc_values[i], val_acc_values[i]])\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metrics records"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mlp.eval()\n",
    "feats, labels = dataset[val_idxs]\n",
    "logits = mlp(feats)\n",
    "_, preds = torch.max(logits, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np_logits = logits.detach().softmax(dim=1).numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7584351706339528, 0.6862745098039216, 0.7142846639020763, None)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metrics.precision_recall_fscore_support(labels, preds, average='weighted')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9584567901234567"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# AUROC\n",
    "metrics.roc_auc_score(labels, np_logits, multi_class='ovo')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aupr_labels = torch.zeros(labels.shape[0], 6)\n",
    "for i, label in enumerate(labels):\n",
    "    aupr_labels[i][label] = 1\n",
    "aupr_labels = aupr_labels.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average precision score, micro-averaged over all classes: 0.9151\n"
     ]
    }
   ],
   "source": [
    "# AUPR\n",
    "from sklearn.metrics import precision_recall_curve\n",
    "from sklearn.metrics import average_precision_score\n",
    "\n",
    "# For each class\n",
    "precision = dict()\n",
    "recall = dict()\n",
    "average_precision = dict()\n",
    "for i in range(6):\n",
    "    precision[i], recall[i], _ = precision_recall_curve(aupr_labels[:, i],\n",
    "                                                        np_logits[:, i])\n",
    "    average_precision[i] = average_precision_score(aupr_labels[:, i], np_logits[:, i])\n",
    "\n",
    "# A \"micro-average\": quantifying score on all classes jointly\n",
    "precision[\"micro\"], recall[\"micro\"], _ = precision_recall_curve(aupr_labels.ravel(),\n",
    "    np_logits.ravel())\n",
    "average_precision[\"micro\"] = average_precision_score(aupr_labels, np_logits,\n",
    "                                                     average=\"micro\")\n",
    "print('Average precision score, micro-averaged over all classes: {0:0.4f}'\n",
    "      .format(average_precision[\"micro\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9150790237341047"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "average_precision[\"micro\"]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "cf_mat = confusion_matrix(labels, preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[15,  4,  0,  0,  1,  1],\n",
       "       [ 5, 23,  2,  0,  0,  0],\n",
       "       [ 0,  1, 28,  1,  0,  0],\n",
       "       [ 2,  5,  1,  1,  0,  0],\n",
       "       [ 0,  0,  0,  0, 29,  1],\n",
       "       [ 0,  0,  0,  0,  1, 29]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cf_mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame(cf_mat).to_csv(\"./save_files/confusion_matrix.csv\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## save MLP embbeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_x(dataset, cut_point):\n",
    "    x, _ = dataset[cut_point[0]: cut_point[1]]\n",
    "    return x\n",
    "def save_MLP_emb(mlp, dataset, cut_point, name):\n",
    "    mlp.eval()\n",
    "    with torch.no_grad():\n",
    "        x = get_x(dataset, cut_point)\n",
    "        emb = mlp.retrieve_emb(x)\n",
    "        torch.save(emb, \"./embs/\" + name)\n",
    "        return emb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mlp.load_state_dict(torch.load(\"./mlp_models/084valacc.pt\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 0.0000,  0.0000,  0.0000,  ...,  7.9829,  0.0000,  0.0000],\n",
       "        [ 0.0000,  0.0000,  0.0000,  ..., 24.0979,  0.0000,  0.0000],\n",
       "        [ 0.0000,  0.0000,  0.0000,  ..., 17.1625,  0.0000,  0.0000],\n",
       "        ...,\n",
       "        [ 0.0000,  0.0000,  0.0000,  ...,  0.0000,  0.0000,  0.0000],\n",
       "        [ 0.0000,  0.0000,  0.0000,  ...,  0.0000,  0.0000,  0.0000],\n",
       "        [ 0.0000,  0.0000,  0.0000,  ...,  0.0000,  0.0000,  0.0000]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# nas\n",
    "save_MLP_emb(mlp, dataset, cut_points[0], name=\"mlp_84_nas.pt\")\n",
    "# lis\n",
    "save_MLP_emb(mlp, dataset, cut_points[1], name=\"mlp_84_lis.pt\")\n",
    "# sa\n",
    "save_MLP_emb(mlp, dataset, cut_points[2], name=\"mlp_84_sa.pt\")\n",
    "# lissa\n",
    "save_MLP_emb(mlp, dataset, cut_points[3], name=\"mlp_84_lissa.pt\")\n",
    "# ir1\n",
    "save_MLP_emb(mlp, dataset, cut_points[4], name=\"mlp_84_ir1.pt\")\n",
    "# ir2\n",
    "save_MLP_emb(mlp, dataset, cut_points[5], name=\"mlp_84_ir2.pt\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# load trained MLP "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "del mlp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_layer = 4\n",
    "in_dim = emb_nssup_list[0].shape[0]\n",
    "out_dim = 6\n",
    "hidden_dim = 128\n",
    "\n",
    "mlp = MLP(n_layer, in_dim, hidden_dim, out_dim, dropout=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mlp.load_state_dict(torch.load('./mlp_models/084valacc.pt'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([5, 98304])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# save nassa emb\n",
    "emb_nassa = torch.stack(emb_nas_sa_list)\n",
    "emb_nassa.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "mlp.eval()\n",
    "with torch.no_grad():\n",
    "    emb = mlp.retrieve_emb(emb_nassa)\n",
    "    torch.save(emb, './embs/mlp_84_nassa.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "mlp.eval()\n",
    "with torch.no_grad():\n",
    "    emb_sup = torch.stack(emb_sup_list)\n",
    "    torch.save(mlp.retrieve_emb(emb_sup), './embs/mlp_84_sup.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "mlp.eval()\n",
    "with torch.no_grad():\n",
    "    emb_nssup = torch.stack(emb_nssup_list)\n",
    "    torch.save(mlp.retrieve_emb(emb_nssup), './embs/mlp_84_nssup.pt')\n",
    "    emb_npsup = torch.stack(emb_npsup_list)\n",
    "    torch.save(mlp.retrieve_emb(emb_npsup), './embs/mlp_84_npsup.pt')\n",
    "    emb_othersup = torch.stack(emb_othersup_list)\n",
    "    torch.save(mlp.retrieve_emb(emb_othersup), './embs/mlp_84_othersup.pt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.13 ('matscibert')",
   "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.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "cd95327b7c7cceca9cf309281dbc71e99bfcc59fee14e06289becc9905c21812"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}