Inference Interpro2GO.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/mnt/e/ML/cafa-5-protein-function-prediction\n",
      "/mnt/e/ML/output\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from dotenv import load_dotenv\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import datetime\n",
    "from tqdm.notebook import tqdm\n",
    "import warnings\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "load_dotenv(override=True)\n",
    "\n",
    "DATA_PATH = os.getenv('DATA_PATH')\n",
    "DATA_PATH_INTERPRO = os.getenv('DATA_PATH_INTERPRO')\n",
    "print(DATA_PATH)\n",
    "print(DATA_PATH_INTERPRO)\n",
    "\n",
    "SO=\"CCO\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "from Bio import SeqIO\n",
    "\n",
    "sequences = [rec.seq for rec in SeqIO.parse(os.path.join(DATA_PATH, \"Test (Targets)/testsuperset.fasta\"),\"fasta\")]\n",
    "ids = [rec.id for rec in SeqIO.parse(os.path.join(DATA_PATH, \"Test (Targets)/testsuperset.fasta\"),\"fasta\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx\n",
    "import obonet\n",
    "\n",
    "# Read the taxrank ontology\n",
    "url = os.path.join(DATA_PATH, \"Train/go-basic.obo\")\n",
    "graph = obonet.read_obo(url)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "id_to_name = {id_: data.get('name') for id_, data in graph.nodes(data=True)}\n",
    "name_to_id = {data['name']: id_ for id_, data in graph.nodes(data=True) if 'name' in data}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def getAllAncestors(go):\n",
    "    try:\n",
    "        paths = networkx.all_simple_paths(\n",
    "            graph,\n",
    "            source=go,\n",
    "            target=name_to_id[\"cellular_component\"]\n",
    "        )\n",
    "    except:\n",
    "        paths = []\n",
    "    gos = []\n",
    "    for path in paths:\n",
    "        for node in path:\n",
    "            gos.append(node)\n",
    "    ccList = list(set(gos))\n",
    "\n",
    "    try:\n",
    "        paths = networkx.all_simple_paths(\n",
    "            graph,\n",
    "            source=go,\n",
    "            target=name_to_id[\"molecular_function\"]\n",
    "        )\n",
    "    except:\n",
    "        paths = []\n",
    "    gos = []\n",
    "    for path in paths:\n",
    "        for node in path:\n",
    "            gos.append(node)\n",
    "    mfList = list(set(gos))\n",
    "\n",
    "    try:\n",
    "        paths = networkx.all_simple_paths(\n",
    "            graph,\n",
    "            source=go,\n",
    "            target=name_to_id[\"biological_process\"]\n",
    "        )\n",
    "    except:\n",
    "        paths = []\n",
    "    gos = []\n",
    "    for path in paths:\n",
    "        for node in path:\n",
    "            gos.append(node)\n",
    "    bpList = list(set(gos))\n",
    "\n",
    "    return [*ccList, *mfList, *bpList]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['GO:0097159',\n",
       " 'GO:0003674',\n",
       " 'GO:0003676',\n",
       " 'GO:0003677',\n",
       " 'GO:0005488',\n",
       " 'GO:1901363']"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getAllAncestors(\"GO:0003677\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read Interpro2GO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30447\n",
      "30447\n"
     ]
    }
   ],
   "source": [
    "ipList=[]\n",
    "GOList=[]\n",
    "with open(os.path.join(DATA_PATH, \"interpro2go.txt\")) as file:\n",
    "    while line := file.readline():\n",
    "        if not line.startswith(\"!\"):\n",
    "            firstSplit = line.split(\">\")\n",
    "            ip = firstSplit[0].split(\" \")[0].split(\":\")[1].strip()\n",
    "            go = firstSplit[1].split(\" ; \")[-1][0:-1]\n",
    "            ipList.append(ip)\n",
    "            GOList.append(go)\n",
    "\n",
    "print(len(ipList))\n",
    "print(len(GOList))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "dictData = {'Interpro': ipList, 'GO': GOList}\n",
    "ip2go = pd.DataFrame.from_dict(dictData)\n",
    "ip2go.set_index(\"Interpro\", inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Interpro\n",
       "IPR000003    GO:0003677\n",
       "IPR000003    GO:0003707\n",
       "IPR000003    GO:0008270\n",
       "IPR000003    GO:0006355\n",
       "IPR000003    GO:0005634\n",
       "                ...    \n",
       "IPR048182    GO:0043464\n",
       "IPR048197    GO:0004867\n",
       "IPR048197    GO:0004869\n",
       "IPR048205    GO:0102560\n",
       "IPR048205    GO:0102561\n",
       "Name: GO, Length: 30447, dtype: object"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ip2go[\"GO\"]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read Interpro Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing  testsuperset1.fasta.json\n",
      "Processing  testsuperset2.fasta.json\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "allInterproData =[]\n",
    "\n",
    "for root,dirs,files in os.walk(DATA_PATH_INTERPRO):\n",
    "    for f in files:\n",
    "        if f.endswith(\".json\") and f.startswith(\"test\"):\n",
    "            print(\"Processing \", f)\n",
    "            with open(os.path.join(root, f)) as inputFile:\n",
    "                iprData = json.load(inputFile)\n",
    "            allInterproData=[*allInterproData, *iprData[\"results\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "ipMatches={}\n",
    "\n",
    "for ipData in allInterproData:\n",
    "    temp=[]\n",
    "    for match in ipData[\"matches\"]:\n",
    "        if match[\"signature\"][\"entry\"]:\n",
    "            temp.append(match[\"signature\"][\"entry\"][\"accession\"])\n",
    "    ipMatches[ipData[\"xref\"][0][\"id\"]] = temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "139946"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ipMatches)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combine the data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ca638135c1d64f81bff66544bb213a16",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/141865 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tableData=[]\n",
    "noMatch=0\n",
    "\n",
    "for i,seqId in tqdm(enumerate(ids), total=len(ids)):\n",
    "    if not seqId in ipMatches:\n",
    "        noMatch +=1\n",
    "        continue\n",
    "    gos=[]\n",
    "    for ipEntry in ipMatches[seqId]:\n",
    "        if ipEntry in ip2go.index:\n",
    "            # print(ip2go.loc[ipEntry][\"GO\"])\n",
    "            if ip2go.loc[ipEntry].size==1:\n",
    "                gos.append(ip2go.loc[ipEntry][\"GO\"])\n",
    "            else:\n",
    "                gos = [*gos, *ip2go.loc[ipEntry][\"GO\"].to_numpy()]\n",
    "        else:\n",
    "            continue\n",
    "\n",
    "    gosWithAnc=[]\n",
    "    for g in gos:\n",
    "        tempGos=getAllAncestors(g)\n",
    "        gosWithAnc = [*gosWithAnc, *tempGos]\n",
    "    gosWithAnc = list(set(gosWithAnc))\n",
    "    \n",
    "    for g in gosWithAnc:\n",
    "        tableData.append([seqId , g, 1.0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = pd.DataFrame(tableData, columns=['Entry ID', 'GO', 'Probability'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "results.to_csv(os.path.join(DATA_PATH, \"submissionIp2Go.tsv\"), sep=\"\\t\", header=False, index=False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf",
   "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.9.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}