notebooks/5_metapath_generation.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Metagraph and Metapath Generation\n",
    "\n",
    "Here, we use the same syntax as [HetNetPy](https://github.com/hetio/hetnetpy/tree/e1ff1f8296b766dd5a63e5870a8a1a7d82427a80) to create a metagraph and extract metapaths from the KG.\n",
    "\n",
    "Metagraph creation is based on [this notebook](https://github.com/dhimmel/integrate/blob/93feba1765fbcd76fd79e22f25121f5399629148/integrate.ipynb)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import os.path as osp\n",
    "import os\n",
    "\n",
    "import hetnetpy.hetnet\n",
    "import hetnetpy.readwrite\n",
    "import hetnetpy.stats\n",
    "\n",
    "from hetnetpy.abbreviation import metaedges_from_metapath\n",
    "import re\n",
    "import json\n",
    "from collections import Counter\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define and Instantiate Metagraph:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "kind_to_abbev = {\n",
    "    \n",
    "    # metanodes\n",
    "    'Compound': 'C',\n",
    "    'Gene': 'G',\n",
    "    'Biological Process': 'BP',\n",
    "    \n",
    "    # metaedges\n",
    "    'upregulates': 'u',\n",
    "    'downregulates': 'd',\n",
    "    'interacts': 'i',\n",
    "    'participates': 'p',\n",
    "    'induces': 't',\n",
    "}\n",
    "\n",
    "metaedge_tuples = [\n",
    "    ('Compound', 'Gene', 'upregulates', 'forward'),\n",
    "    ('Compound', 'Gene', 'downregulates', 'forward'),\n",
    "    ('Gene', 'Gene', 'interacts', 'forward'),\n",
    "    ('Gene', 'Biological Process', 'participates', 'forward'),\n",
    "    ('Compound', 'Biological Process', 'induces', 'forward')\n",
    "]\n",
    "\n",
    "metagraph = hetnetpy.hetnet.MetaGraph.from_edge_tuples(metaedge_tuples, kind_to_abbev)\n",
    "graph = hetnetpy.hetnet.Graph(metagraph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "KG_DIR = '../data/kg/'\n",
    "SPLITS_DIR = osp.join(KG_DIR, 'splits')\n",
    "MOA_NET_DIR = osp.join(SPLITS_DIR, 'MoA-net')\n",
    "MARS_DIR = osp.join(MOA_NET_DIR, 'MARS')\n",
    "\n",
    "for dir in [KG_DIR, SPLITS_DIR, MOA_NET_DIR, MARS_DIR]:\n",
    "    if not osp.exists(dir):\n",
    "        os.makedirs(dir)\n",
    "\n",
    "kg = pd.read_csv(osp.join(MOA_NET_DIR, 'kg_no_cmp_bp.tsv'), sep='\\t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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>source</th>\n",
       "      <th>source_node_type</th>\n",
       "      <th>target</th>\n",
       "      <th>target_node_type</th>\n",
       "      <th>edge_type</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [source, source_node_type, target, target_node_type, edge_type]\n",
       "Index: []"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# show me the duplicated rows in the dataframe\n",
    "kg[kg.duplicated(keep=False)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0        False\n",
       "1        False\n",
       "2        False\n",
       "3        False\n",
       "4        False\n",
       "         ...  \n",
       "94942    False\n",
       "94943    False\n",
       "94944    False\n",
       "94945    False\n",
       "94946    False\n",
       "Length: 94947, dtype: bool"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kg.duplicated()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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>source</th>\n",
       "      <th>source_node_type</th>\n",
       "      <th>target</th>\n",
       "      <th>target_node_type</th>\n",
       "      <th>edge_type</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>pubchem.compound:10607</td>\n",
       "      <td>Compound</td>\n",
       "      <td>ncbigene:3553</td>\n",
       "      <td>Gene</td>\n",
       "      <td>upregulates</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>pubchem.compound:10607</td>\n",
       "      <td>Compound</td>\n",
       "      <td>ncbigene:203068</td>\n",
       "      <td>Gene</td>\n",
       "      <td>downregulates</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>pubchem.compound:10607</td>\n",
       "      <td>Compound</td>\n",
       "      <td>ncbigene:54658</td>\n",
       "      <td>Gene</td>\n",
       "      <td>downregulates</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>pubchem.compound:10607</td>\n",
       "      <td>Compound</td>\n",
       "      <td>ncbigene:7153</td>\n",
       "      <td>Gene</td>\n",
       "      <td>downregulates</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>pubchem.compound:10607</td>\n",
       "      <td>Compound</td>\n",
       "      <td>ncbigene:7277</td>\n",
       "      <td>Gene</td>\n",
       "      <td>downregulates</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   source source_node_type           target target_node_type  \\\n",
       "0  pubchem.compound:10607         Compound    ncbigene:3553             Gene   \n",
       "1  pubchem.compound:10607         Compound  ncbigene:203068             Gene   \n",
       "2  pubchem.compound:10607         Compound   ncbigene:54658             Gene   \n",
       "3  pubchem.compound:10607         Compound    ncbigene:7153             Gene   \n",
       "4  pubchem.compound:10607         Compound    ncbigene:7277             Gene   \n",
       "\n",
       "       edge_type  \n",
       "0    upregulates  \n",
       "1  downregulates  \n",
       "2  downregulates  \n",
       "3  downregulates  \n",
       "4  downregulates  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kg.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "seen = set()\n",
    "\n",
    "for i, row in kg.iterrows():\n",
    "    if not row['source'] in seen:\n",
    "        graph.add_node(kind=row['source_node_type'], identifier=row['source'])\n",
    "        seen.add(row['source'])\n",
    "    if not row['target'] in seen:\n",
    "        graph.add_node(kind=row['target_node_type'], identifier=row['target'])\n",
    "        seen.add(row['target'])\n",
    "\n",
    "    src_id = row['source_node_type'], row['source']\n",
    "    trgt_id = row['target_node_type'], row['target']\n",
    "\n",
    "    graph.add_edge(source_id=src_id, target_id=trgt_id, kind=row['edge_type'], direction='forward')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network Visualization and Stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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>metanode</th>\n",
       "      <th>abbreviation</th>\n",
       "      <th>metaedges</th>\n",
       "      <th>nodes</th>\n",
       "      <th>unconnected_nodes</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Biological Process</td>\n",
       "      <td>BP</td>\n",
       "      <td>2</td>\n",
       "      <td>86</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Compound</td>\n",
       "      <td>C</td>\n",
       "      <td>3</td>\n",
       "      <td>300</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Gene</td>\n",
       "      <td>G</td>\n",
       "      <td>4</td>\n",
       "      <td>9301</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             metanode abbreviation  metaedges  nodes  unconnected_nodes\n",
       "2  Biological Process           BP          2     86                  0\n",
       "0            Compound            C          3    300                  0\n",
       "1                Gene            G          4   9301                  0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metanode_df = hetnetpy.stats.get_metanode_df(graph)\n",
    "metanode_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = sns.barplot(x='metanode', y='nodes', data=metanode_df.sort_values('nodes'))\n",
    "for tick in ax.get_xticklabels():\n",
    "    tick.set_rotation(90)\n",
    "ax.set_xlabel(''); ax.set_ylabel('nodes');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9687"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Total number of nodes\n",
    "metanode_df.nodes.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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>metaedge</th>\n",
       "      <th>abbreviation</th>\n",
       "      <th>edges</th>\n",
       "      <th>source_nodes</th>\n",
       "      <th>target_nodes</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Compound &gt; downregulates &gt; Gene</td>\n",
       "      <td>Cd&gt;G</td>\n",
       "      <td>2205</td>\n",
       "      <td>271</td>\n",
       "      <td>916</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Compound &gt; induces &gt; Biological Process</td>\n",
       "      <td>Ct&gt;BP</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Compound &gt; upregulates &gt; Gene</td>\n",
       "      <td>Cu&gt;G</td>\n",
       "      <td>1631</td>\n",
       "      <td>184</td>\n",
       "      <td>865</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Gene &gt; interacts &gt; Gene</td>\n",
       "      <td>Gi&gt;G</td>\n",
       "      <td>86786</td>\n",
       "      <td>5240</td>\n",
       "      <td>8578</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Gene &gt; participates &gt; Biological Process</td>\n",
       "      <td>Gp&gt;BP</td>\n",
       "      <td>4325</td>\n",
       "      <td>3159</td>\n",
       "      <td>86</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                   metaedge abbreviation  edges  source_nodes  \\\n",
       "1           Compound > downregulates > Gene         Cd>G   2205           271   \n",
       "4   Compound > induces > Biological Process        Ct>BP      0             0   \n",
       "0             Compound > upregulates > Gene         Cu>G   1631           184   \n",
       "2                   Gene > interacts > Gene         Gi>G  86786          5240   \n",
       "3  Gene > participates > Biological Process        Gp>BP   4325          3159   \n",
       "\n",
       "   target_nodes  \n",
       "1           916  \n",
       "4             0  \n",
       "0           865  \n",
       "2          8578  \n",
       "3            86  "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Summary of metaedges and cooresponding edges\n",
    "metaedge_df = hetnetpy.stats.get_metaedge_df(graph)\n",
    "\n",
    "metaedge_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "metaedge_df.to_excel('../paper_materials/metaedge_df.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = sns.barplot(x='abbreviation', y='edges', data=metaedge_df.sort_values('edges'))\n",
    "for tick in ax.get_xticklabels():\n",
    "    tick.set_rotation(90)\n",
    "ax.set_xlabel(''); ax.set_ylabel('edges');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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>metaedge</th>\n",
       "      <th>unicode_metaedge</th>\n",
       "      <th>standard_metaedge</th>\n",
       "      <th>abbreviation</th>\n",
       "      <th>standard_abbreviation</th>\n",
       "      <th>source</th>\n",
       "      <th>target</th>\n",
       "      <th>inverted</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Biological Process &lt; induces &lt; Compound</td>\n",
       "      <td>Biological Process←induces←Compound</td>\n",
       "      <td>Compound &gt; induces &gt; Biological Process</td>\n",
       "      <td>BP&lt;tC</td>\n",
       "      <td>CtBP</td>\n",
       "      <td>Biological Process</td>\n",
       "      <td>Compound</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Biological Process &lt; participates &lt; Gene</td>\n",
       "      <td>Biological Process←participates←Gene</td>\n",
       "      <td>Gene &gt; participates &gt; Biological Process</td>\n",
       "      <td>BP&lt;pG</td>\n",
       "      <td>GpBP</td>\n",
       "      <td>Biological Process</td>\n",
       "      <td>Gene</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Compound &gt; downregulates &gt; Gene</td>\n",
       "      <td>Compound→downregulates→Gene</td>\n",
       "      <td>Compound &gt; downregulates &gt; Gene</td>\n",
       "      <td>Cd&gt;G</td>\n",
       "      <td>CdG</td>\n",
       "      <td>Compound</td>\n",
       "      <td>Gene</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Compound &gt; induces &gt; Biological Process</td>\n",
       "      <td>Compound→induces→Biological Process</td>\n",
       "      <td>Compound &gt; induces &gt; Biological Process</td>\n",
       "      <td>Ct&gt;BP</td>\n",
       "      <td>CtBP</td>\n",
       "      <td>Compound</td>\n",
       "      <td>Biological Process</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Compound &gt; upregulates &gt; Gene</td>\n",
       "      <td>Compound→upregulates→Gene</td>\n",
       "      <td>Compound &gt; upregulates &gt; Gene</td>\n",
       "      <td>Cu&gt;G</td>\n",
       "      <td>CuG</td>\n",
       "      <td>Compound</td>\n",
       "      <td>Gene</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Gene &lt; downregulates &lt; Compound</td>\n",
       "      <td>Gene←downregulates←Compound</td>\n",
       "      <td>Compound &gt; downregulates &gt; Gene</td>\n",
       "      <td>G&lt;dC</td>\n",
       "      <td>CdG</td>\n",
       "      <td>Gene</td>\n",
       "      <td>Compound</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Gene &lt; interacts &lt; Gene</td>\n",
       "      <td>Gene←interacts←Gene</td>\n",
       "      <td>Gene &gt; interacts &gt; Gene</td>\n",
       "      <td>G&lt;iG</td>\n",
       "      <td>GiG</td>\n",
       "      <td>Gene</td>\n",
       "      <td>Gene</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Gene &lt; upregulates &lt; Compound</td>\n",
       "      <td>Gene←upregulates←Compound</td>\n",
       "      <td>Compound &gt; upregulates &gt; Gene</td>\n",
       "      <td>G&lt;uC</td>\n",
       "      <td>CuG</td>\n",
       "      <td>Gene</td>\n",
       "      <td>Compound</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Gene &gt; interacts &gt; Gene</td>\n",
       "      <td>Gene→interacts→Gene</td>\n",
       "      <td>Gene &gt; interacts &gt; Gene</td>\n",
       "      <td>Gi&gt;G</td>\n",
       "      <td>GiG</td>\n",
       "      <td>Gene</td>\n",
       "      <td>Gene</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Gene &gt; participates &gt; Biological Process</td>\n",
       "      <td>Gene→participates→Biological Process</td>\n",
       "      <td>Gene &gt; participates &gt; Biological Process</td>\n",
       "      <td>Gp&gt;BP</td>\n",
       "      <td>GpBP</td>\n",
       "      <td>Gene</td>\n",
       "      <td>Biological Process</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                   metaedge  \\\n",
       "9   Biological Process < induces < Compound   \n",
       "7  Biological Process < participates < Gene   \n",
       "2           Compound > downregulates > Gene   \n",
       "8   Compound > induces > Biological Process   \n",
       "0             Compound > upregulates > Gene   \n",
       "3           Gene < downregulates < Compound   \n",
       "5                   Gene < interacts < Gene   \n",
       "1             Gene < upregulates < Compound   \n",
       "4                   Gene > interacts > Gene   \n",
       "6  Gene > participates > Biological Process   \n",
       "\n",
       "                       unicode_metaedge  \\\n",
       "9   Biological Process←induces←Compound   \n",
       "7  Biological Process←participates←Gene   \n",
       "2           Compound→downregulates→Gene   \n",
       "8   Compound→induces→Biological Process   \n",
       "0             Compound→upregulates→Gene   \n",
       "3           Gene←downregulates←Compound   \n",
       "5                   Gene←interacts←Gene   \n",
       "1             Gene←upregulates←Compound   \n",
       "4                   Gene→interacts→Gene   \n",
       "6  Gene→participates→Biological Process   \n",
       "\n",
       "                          standard_metaedge abbreviation  \\\n",
       "9   Compound > induces > Biological Process        BP<tC   \n",
       "7  Gene > participates > Biological Process        BP<pG   \n",
       "2           Compound > downregulates > Gene         Cd>G   \n",
       "8   Compound > induces > Biological Process        Ct>BP   \n",
       "0             Compound > upregulates > Gene         Cu>G   \n",
       "3           Compound > downregulates > Gene         G<dC   \n",
       "5                   Gene > interacts > Gene         G<iG   \n",
       "1             Compound > upregulates > Gene         G<uC   \n",
       "4                   Gene > interacts > Gene         Gi>G   \n",
       "6  Gene > participates > Biological Process        Gp>BP   \n",
       "\n",
       "  standard_abbreviation              source              target  inverted  \n",
       "9                  CtBP  Biological Process            Compound         1  \n",
       "7                  GpBP  Biological Process                Gene         1  \n",
       "2                   CdG            Compound                Gene         0  \n",
       "8                  CtBP            Compound  Biological Process         0  \n",
       "0                   CuG            Compound                Gene         0  \n",
       "3                   CdG                Gene            Compound         1  \n",
       "5                   GiG                Gene                Gene         1  \n",
       "1                   CuG                Gene            Compound         1  \n",
       "4                   GiG                Gene                Gene         0  \n",
       "6                  GpBP                Gene  Biological Process         0  "
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Summary of different styles for representing each metaedge\n",
    "metaedge_style_df = hetnetpy.stats.get_metaedge_style_df(metagraph)\n",
    "metaedge_style_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "94947"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Number of edges in the network\n",
    "metaedge_df.edges.sum()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Metapath Extraction\n",
    "\n",
    "Here, we have functions which can extract metapaths:"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extract all metapaths up to a certain length:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "len_3_metapaths = metagraph.extract_all_metapaths(max_length=3, exclude_inverts=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[BP<tC,\n",
       " BP<pG,\n",
       " Cd>G,\n",
       " Cu>G,\n",
       " G<iG,\n",
       " BP<tCt>BP,\n",
       " BP<tCd>G,\n",
       " BP<tCu>G,\n",
       " BP<pGp>BP,\n",
       " BP<pG<dC,\n",
       " BP<pG<uC,\n",
       " BP<pG<iG,\n",
       " BP<pGi>G,\n",
       " Ct>BP<tC,\n",
       " Ct>BP<pG,\n",
       " Cd>G<dC,\n",
       " Cd>G<uC,\n",
       " Cd>G<iG,\n",
       " Cd>Gi>G,\n",
       " Cu>G<uC,\n",
       " Cu>G<iG,\n",
       " Cu>Gi>G,\n",
       " Gp>BP<pG,\n",
       " G<dCd>G,\n",
       " G<dCu>G,\n",
       " G<uCu>G,\n",
       " G<iG<iG,\n",
       " G<iGi>G,\n",
       " Gi>G<iG,\n",
       " BP<tCt>BP<tC,\n",
       " BP<tCt>BP<pG,\n",
       " BP<tCd>Gp>BP,\n",
       " BP<tCd>G<dC,\n",
       " BP<tCd>G<uC,\n",
       " BP<tCd>G<iG,\n",
       " BP<tCd>Gi>G,\n",
       " BP<tCu>Gp>BP,\n",
       " BP<tCu>G<dC,\n",
       " BP<tCu>G<uC,\n",
       " BP<tCu>G<iG,\n",
       " BP<tCu>Gi>G,\n",
       " BP<pGp>BP<tC,\n",
       " BP<pGp>BP<pG,\n",
       " BP<pG<dCd>G,\n",
       " BP<pG<dCu>G,\n",
       " BP<pG<uCd>G,\n",
       " BP<pG<uCu>G,\n",
       " BP<pG<iGp>BP,\n",
       " BP<pG<iG<dC,\n",
       " BP<pG<iG<uC,\n",
       " BP<pG<iG<iG,\n",
       " BP<pG<iGi>G,\n",
       " BP<pGi>G<dC,\n",
       " BP<pGi>G<uC,\n",
       " BP<pGi>G<iG,\n",
       " BP<pGi>Gi>G,\n",
       " Ct>BP<tCd>G,\n",
       " Ct>BP<tCu>G,\n",
       " Ct>BP<pG<dC,\n",
       " Ct>BP<pG<uC,\n",
       " Ct>BP<pG<iG,\n",
       " Ct>BP<pGi>G,\n",
       " Cd>Gp>BP<pG,\n",
       " Cd>G<dCd>G,\n",
       " Cd>G<dCu>G,\n",
       " Cd>G<uCd>G,\n",
       " Cd>G<uCu>G,\n",
       " Cd>G<iG<dC,\n",
       " Cd>G<iG<uC,\n",
       " Cd>G<iG<iG,\n",
       " Cd>G<iGi>G,\n",
       " Cd>Gi>G<uC,\n",
       " Cd>Gi>G<iG,\n",
       " Cd>Gi>Gi>G,\n",
       " Cu>Gp>BP<pG,\n",
       " Cu>G<dCd>G,\n",
       " Cu>G<dCu>G,\n",
       " Cu>G<uCd>G,\n",
       " Cu>G<uCu>G,\n",
       " Cu>G<iG<uC,\n",
       " Cu>G<iG<iG,\n",
       " Cu>G<iGi>G,\n",
       " Cu>Gi>G<iG,\n",
       " Cu>Gi>Gi>G,\n",
       " Gp>BP<tCd>G,\n",
       " Gp>BP<tCu>G,\n",
       " Gp>BP<pG<iG,\n",
       " Gp>BP<pGi>G,\n",
       " G<dCd>G<iG,\n",
       " G<dCd>Gi>G,\n",
       " G<dCu>G<iG,\n",
       " G<dCu>Gi>G,\n",
       " G<uCd>G<iG,\n",
       " G<uCd>Gi>G,\n",
       " G<uCu>G<iG,\n",
       " G<uCu>Gi>G,\n",
       " G<iG<iG<iG,\n",
       " G<iG<iGi>G,\n",
       " G<iGi>G<iG,\n",
       " Gi>G<iG<iG]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len_3_metapaths"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extract metapaths from a given source node type (and, optionally, to a target node type):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Ct>BP, Cd>Gp>BP, Cu>Gp>BP, Ct>BP<tCt>BP, Ct>BP<pGp>BP, Cd>G<dCt>BP, Cd>G<uCt>BP, Cd>G<iGp>BP, Cd>Gi>Gp>BP, Cu>G<dCt>BP, Cu>G<uCt>BP, Cu>G<iGp>BP, Cu>Gi>Gp>BP, Ct>BP<tCd>Gp>BP, Ct>BP<tCu>Gp>BP, Ct>BP<pG<dCt>BP, Ct>BP<pG<uCt>BP, Ct>BP<pG<iGp>BP, Ct>BP<pGi>Gp>BP, Cd>Gp>BP<tCt>BP, Cd>Gp>BP<pGp>BP, Cd>G<dCd>Gp>BP, Cd>G<dCu>Gp>BP, Cd>G<uCd>Gp>BP, Cd>G<uCu>Gp>BP, Cd>G<iG<dCt>BP, Cd>G<iG<uCt>BP, Cd>G<iG<iGp>BP, Cd>G<iGi>Gp>BP, Cd>Gi>G<dCt>BP, Cd>Gi>G<uCt>BP, Cd>Gi>G<iGp>BP, Cd>Gi>Gi>Gp>BP, Cu>Gp>BP<tCt>BP, Cu>Gp>BP<pGp>BP, Cu>G<dCd>Gp>BP, Cu>G<dCu>Gp>BP, Cu>G<uCd>Gp>BP, Cu>G<uCu>Gp>BP, Cu>G<iG<dCt>BP, Cu>G<iG<uCt>BP, Cu>G<iG<iGp>BP, Cu>G<iGi>Gp>BP, Cu>Gi>G<dCt>BP, Cu>Gi>G<uCt>BP, Cu>Gi>G<iGp>BP, Cu>Gi>Gi>Gp>BP]\n"
     ]
    }
   ],
   "source": [
    "tgt_metapaths = metagraph.extract_metapaths(source='Compound', target='Biological Process')\n",
    "print(tgt_metapaths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ct>BP\n",
      "Cd>Gp>BP\n",
      "Cu>Gp>BP\n",
      "Ct>BP<tCt>BP\n",
      "Ct>BP<pGp>BP\n",
      "Cd>G<dCt>BP\n",
      "Cd>G<uCt>BP\n",
      "Cd>G<iGp>BP\n",
      "Cd>Gi>Gp>BP\n",
      "Cu>G<dCt>BP\n",
      "Cu>G<uCt>BP\n",
      "Cu>G<iGp>BP\n",
      "Cu>Gi>Gp>BP\n",
      "Ct>BP<tCd>Gp>BP\n",
      "Ct>BP<tCu>Gp>BP\n",
      "Ct>BP<pG<dCt>BP\n",
      "Ct>BP<pG<uCt>BP\n",
      "Ct>BP<pG<iGp>BP\n",
      "Ct>BP<pGi>Gp>BP\n",
      "Cd>Gp>BP<tCt>BP\n",
      "Cd>Gp>BP<pGp>BP\n",
      "Cd>G<dCd>Gp>BP\n",
      "Cd>G<dCu>Gp>BP\n",
      "Cd>G<uCd>Gp>BP\n",
      "Cd>G<uCu>Gp>BP\n",
      "Cd>G<iG<dCt>BP\n",
      "Cd>G<iG<uCt>BP\n",
      "Cd>G<iG<iGp>BP\n",
      "Cd>G<iGi>Gp>BP\n",
      "Cd>Gi>G<dCt>BP\n",
      "Cd>Gi>G<uCt>BP\n",
      "Cd>Gi>G<iGp>BP\n",
      "Cd>Gi>Gi>Gp>BP\n",
      "Cu>Gp>BP<tCt>BP\n",
      "Cu>Gp>BP<pGp>BP\n",
      "Cu>G<dCd>Gp>BP\n",
      "Cu>G<dCu>Gp>BP\n",
      "Cu>G<uCd>Gp>BP\n",
      "Cu>G<uCu>Gp>BP\n",
      "Cu>G<iG<dCt>BP\n",
      "Cu>G<iG<uCt>BP\n",
      "Cu>G<iG<iGp>BP\n",
      "Cu>G<iGi>Gp>BP\n",
      "Cu>Gi>G<dCt>BP\n",
      "Cu>Gi>G<uCt>BP\n",
      "Cu>Gi>G<iGp>BP\n",
      "Cu>Gi>Gi>Gp>BP\n"
     ]
    }
   ],
   "source": [
    "for i in tgt_metapaths:\n",
    "    print(i)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We do not want any with a compound in the middle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "CtoBP_metapaths = []\n",
    "\n",
    "\n",
    "for i in tgt_metapaths:\n",
    "    if '<' in repr(i):  # get rid of those with inverse edges\n",
    "        continue\n",
    "    if (repr(i) != 'Ct>BP') & (Counter(re.split('>|<|[^A-Z]', repr(i)))['C'] == 1):\n",
    "        CtoBP_metapaths.append(i)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many did it prune?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "47\n"
     ]
    }
   ],
   "source": [
    "print(len(CtoBP_metapaths))\n",
    "print(len(tgt_metapaths))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Cd>Gp>BP, Cu>Gp>BP, Cd>Gi>Gp>BP, Cu>Gi>Gp>BP, Cd>Gi>Gi>Gp>BP, Cu>Gi>Gi>Gp>BP]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CtoBP_metapaths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write CtoBP_metapaths to a file\n",
    "with open(osp.join(MOA_NET_DIR, 'CtoBP_metapaths.txt'), 'w') as f:\n",
    "    for i in CtoBP_metapaths:\n",
    "        f.write(repr(i) + '\\n')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MARS Input Preparation\n",
    "\n",
    "What if we want to get these in a format similar to the MARS input?\n",
    "\n",
    "First let's give them all a uniform probability:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#prob = 1 / (2 * len(CtoBP_metapaths))\n",
    "prob = 0.5"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can split the metapaths into a series of individual relations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_forward_rule_body(mpath, conf, metagraph):\n",
    "    \"\"\"Gets the rule body for a given metapath in the format that MARS requires\n",
    "        :param mpath: the metapath instance, written in hetnetpy format\n",
    "        :param conf: the confidence value to use for the rule\n",
    "        :param metagraph: the metagraph instance, as a hetnetpy object\n",
    "    \"\"\"\n",
    "    st_edges = metaedges_from_metapath(mpath, standardize_by=metagraph)\n",
    "    directional_edges = metaedges_from_metapath(mpath)\n",
    "    rule_head = re.split('>|<|[^A-Z]', mpath)\n",
    "    rule_head = rule_head[0] + 't' + rule_head[-1]\n",
    "    rule_body = [conf, rule_head]\n",
    "    for st, dic in zip(st_edges, directional_edges):\n",
    "        if '>' in dic:\n",
    "            rule_body.append(st)\n",
    "        else:\n",
    "            rule_body.append('_' + st)\n",
    "    return rule_body"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.5, 'CtBP', 'CuG', '_CuG', 'CdG', 'GpBP']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# just testing the function\n",
    "get_forward_rule_body('Cu>G<uCd>Gp>BP', prob, metagraph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_reverse_rule_body(forward_body):\n",
    "    \"\"\"Gets the REVERSE rule body for a given metapath in the format that MARS requires\n",
    "        :param forward_body: the forward rule body as a list\n",
    "    \"\"\"\n",
    "    rev_body = [forward_body[0], '_' + forward_body[1]]\n",
    "    for i in reversed(forward_body[2:]):\n",
    "        if '_' in i:\n",
    "            rev_body.append(re.sub('_', '', i))\n",
    "        else:\n",
    "            rev_body.append('_' + i)\n",
    "    return rev_body"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.5, '_CtBP', '_GpBP', '_CdG', 'CuG', '_CuG']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fw = get_forward_rule_body('Cu>G<uCd>Gp>BP', prob, metagraph)\n",
    "get_reverse_rule_body(fw)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we'll do it for all the compound to BP metapaths!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'CtBP': [[0.5, 'CtBP', 'CdG', 'GpBP'], [0.5, 'CtBP', 'CuG', 'GpBP'], [0.5, 'CtBP', 'CdG', 'GiG', 'GpBP'], [0.5, 'CtBP', 'CuG', 'GiG', 'GpBP'], [0.5, 'CtBP', 'CdG', 'GiG', 'GiG', 'GpBP'], [0.5, 'CtBP', 'CuG', 'GiG', 'GiG', 'GpBP']]}\n"
     ]
    }
   ],
   "source": [
    "rules = {}\n",
    "rules['CtBP'] = [get_forward_rule_body(str(mpath), prob, metagraph) for mpath in CtoBP_metapaths]\n",
    "print(rules)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['CtBP'])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rules.keys()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's write it to a file we can use for MARS:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(osp.join(MARS_DIR, 'rules.txt'), 'w') as f:\n",
    "    json.dump(rules, f)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's get the input triples in a format consistent with MARS's input files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_to_mars(df):\n",
    "    \"\"\"Converts the KG into a format that MARS can use\n",
    "    \"\"\"\n",
    "    df['metaedge'] = [kind_to_abbev[row['source_node_type']] + kind_to_abbev[row['edge_type']] + \\\n",
    "                       kind_to_abbev[row['target_node_type']] for i, row in df.iterrows()]\n",
    "    return df[['source', 'metaedge', 'target']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = convert_to_mars(pd.read_csv(osp.join(MOA_NET_DIR, 'train.tsv'), sep='\\t'))\n",
    "test = convert_to_mars(pd.read_csv(osp.join(MOA_NET_DIR, 'test.tsv'), sep='\\t'))\n",
    "val = convert_to_mars(pd.read_csv(osp.join(MOA_NET_DIR, 'dev.tsv'), sep='\\t'))\n",
    "\n",
    "sub_test = convert_to_mars(pd.read_csv(osp.join(MOA_NET_DIR, 'sub_test.tsv'), sep='\\t'))\n",
    "\n",
    "kg_triples = convert_to_mars(pd.read_csv(osp.join(MOA_NET_DIR, 'kg_with_train_smpls.tsv'), sep='\\t'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get the inverse triples of the KG:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "inverse_triples = kg_triples[['source', 'target', 'metaedge']].copy()\n",
    "inverse_triples['inv_metaedge'] = ['_' + i for i in inverse_triples['metaedge']]\n",
    "inverse_triples = inverse_triples[['target', 'inv_metaedge', 'source']]\n",
    "\n",
    "# get rid of those with _CtBP\n",
    "#inverse_triples = inverse_triples.loc[inverse_triples['inv_metaedge'] != '_CtBP']"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great, write to the MARS folder:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "kg_triples.to_csv(osp.join(MARS_DIR, 'graph_triples.txt'), sep='\\t', index=False, header=False)\n",
    "inverse_triples.to_csv(osp.join(MARS_DIR, 'graph_inverses.txt'), sep='\\t', index=False, header=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "train.to_csv(osp.join(MARS_DIR, 'train.txt'), sep='\\t', index=False, header=False)\n",
    "test.to_csv(osp.join(MARS_DIR, 'test.txt'), sep='\\t', index=False, header=False)\n",
    "val.to_csv(osp.join(MARS_DIR, 'dev.txt'), sep='\\t', index=False, header=False)\n",
    "\n",
    "sub_test.to_csv(osp.join(MARS_DIR, 'sub_test.txt'), sep='\\t', index=False, header=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we need dictionaries to map the entities and relations to unique IDs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "entities = {\"PAD\": 0, \"UNK\": 1}\n",
    "\n",
    "next_id = 2\n",
    "for df in kg_triples, train, test, val:\n",
    "    for i in df['source'].unique():\n",
    "        if i not in entities:\n",
    "            entities[i] = next_id\n",
    "            next_id += 1\n",
    "    for i in df['target'].unique():\n",
    "        if i not in entities:\n",
    "            entities[i] = next_id\n",
    "            next_id += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "relations = {\"PAD\": 0, \"DUMMY_START_RELATION\": 1, \"NO_OP\": 2, \"UNK\": 3}\n",
    "\n",
    "metaedges = set(kg_triples['metaedge']) | (set(inverse_triples['inv_metaedge']))\n",
    "\n",
    "next_id = 4\n",
    "for rel in metaedges:\n",
    "    relations[rel] = next_id\n",
    "    next_id += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write dictionary to json file\n",
    "VOCAB_DIR = osp.join(MARS_DIR, 'vocab')\n",
    "os.makedirs(VOCAB_DIR, exist_ok=True)\n",
    "\n",
    "with open(osp.join(VOCAB_DIR, 'entity_vocab.json'), 'w') as f:\n",
    "    json.dump(entities, f)\n",
    "\n",
    "with open(osp.join(VOCAB_DIR, 'relation_vocab.json'), 'w') as f:\n",
    "    json.dump(relations, f)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also write the meta-edge and meta-node mappings to json files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "meta_mapping = {v: k for k, v in kind_to_abbev.items()}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(osp.join(VOCAB_DIR, 'meta_mapping.json'), 'w') as f:\n",
    "    json.dump(meta_mapping, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'C': 'Compound',\n",
       " 'G': 'Gene',\n",
       " 'BP': 'Biological Process',\n",
       " 'u': 'upregulates',\n",
       " 'd': 'downregulates',\n",
       " 'i': 'interacts',\n",
       " 'p': 'participates',\n",
       " 't': 'induces'}"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "meta_mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "moanet_env",
   "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.10.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}