clean_aaa2vec.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#encoding. word encoding\n",
    "import codecs\n",
    "#finds all pathnames matching a pattern, like regex\n",
    "import glob\n",
    "#log events for libraries\n",
    "import logging\n",
    "#concurrency\n",
    "import multiprocessing\n",
    "#dealing with operating system , like reading file\n",
    "import os\n",
    "#pretty print, human readable\n",
    "import pprint\n",
    "#regular expressions\n",
    "import re\n",
    "#natural language toolkit\n",
    "import nltk\n",
    "#word 2 vec\n",
    "import gensim.models.word2vec as w2v\n",
    "#dimensionality reduction\n",
    "import sklearn.manifold\n",
    "#math\n",
    "import numpy as np\n",
    "#plotting\n",
    "import matplotlib.pyplot as plt\n",
    "#parse dataset\n",
    "import pandas as pd\n",
    "#visualization\n",
    "import seaborn as sns\n",
    "#Clear cell output from IPython\n",
    "from IPython.display import clear_output\n",
    "#make copies of data structures\n",
    "from copy import deepcopy\n",
    "#Logistic regression learning model\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "import sklearn.metrics as metrics\n",
    "#Get ordered dictionaries\n",
    "import collections\n",
    "#Show the results of our logistic regression\n",
    "#import statsmodels.api as sm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#filepaths and default settings. Change values here\n",
    "positive_set = './AAA_InterPro_reviewed.fasta'\n",
    "generic_proteins = './uniprot_sprot.fasta'\n",
    "aaa2vec_NN = \"aaa2vec_1745pos_1745neg_contextsize7.w2v\"\n",
    "\n",
    "#Choose the number of examples you would like to use for the training positive, training negative,\n",
    "#testing positive, and testing negative examples\n",
    "#70/30 split between training set and test set\n",
    "numPos = 1745\n",
    "numNeg = 1745\n",
    "numTestPos = 700\n",
    "numTestNeg = 700\n",
    "\n",
    "#Build our word2vec model\n",
    "#define hyperparameters\n",
    "#Dimensionality of the resulting word vectors.\n",
    "#more dimensions mean more traiig them, but more generalized\n",
    "num_features = 300\n",
    "# Minimum word count threshold.\n",
    "min_word_count = 1\n",
    "\n",
    "# Number of threads to run in parallel.\n",
    "num_workers = multiprocessing.cpu_count()\n",
    "\n",
    "# Context window length.\n",
    "context_size = 7\n",
    "\n",
    "# Downsample setting for frequent words.\n",
    "#rate 0 and 1e-5 \n",
    "#how often to use\n",
    "downsampling = 1e-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Pass the path of a fasta file to process file and get an orderedDict back\n",
    "def fastaToDict(filepath):\n",
    "    proteinDict = collections.OrderedDict()\n",
    "    with open(filepath, 'r') as f:\n",
    "        currentKey = \"n/a\"\n",
    "        currentSeq = \"\"\n",
    "        i = 0\n",
    "        for line in f:\n",
    "            #This portion of the code is responsible for printing the values\n",
    "            if (i % 10000 == 0):\n",
    "                clear_output(wait=True)    \n",
    "                print (\"Processing hit %i\"%(i))\n",
    "            #If we're at the beginning of the FASTA file\n",
    "            if currentKey == \"n/a\" and line[0] == \">\":\n",
    "                currentKey = line[1:].rstrip()\n",
    "\n",
    "            #When we've finishing scanning our current training example  \n",
    "            elif line[0] == \">\":\n",
    "                proteinDict[currentKey] = currentSeq\n",
    "                currentKey = line[1:].strip()\n",
    "                currentSeq = \"\"\n",
    "                i += 1\n",
    "            else:\n",
    "                currentSeq = currentSeq + line.rstrip()\n",
    "\n",
    "    #The last entry\n",
    "    proteinDict[currentKey] = currentSeq\n",
    "    \n",
    "    #return the dict\n",
    "    print('Processed a total of %i sequences'%(i))\n",
    "    return proteinDict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Input: Ordered Dictionary of protein sequences, output: tokenized words of protein sequences\n",
    "def tokenizeProteins(proteinDict):\n",
    "    tokensMapping = {}\n",
    "    proteinName = ''\n",
    "    \n",
    "    for protein in proteinDict.keys():\n",
    "        proteinName = protein\n",
    "        sentence_raw = deepcopy(proteinDict[proteinName]) \n",
    "        sentence_length = len(sentence_raw)\n",
    "        \n",
    "        for j in range(3):\n",
    "            sentence_tokenized = []\n",
    "            temp_string = sentence_raw[j:]\n",
    "            n = len(temp_string)//3\n",
    "            unit = []\n",
    "            for i in range(n):\n",
    "                unit = sentence_raw[(i*3)+j:(((i+1)*3)+j)]\n",
    "                sentence_tokenized.append(unit)\n",
    "            tokensMapping[proteinName+str(j)]=sentence_tokenized\n",
    "    \n",
    "    proteinTokens = []\n",
    "    for key in tokensMapping:\n",
    "        proteinTokens.append(tokensMapping[key])\n",
    "    return proteinTokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generateTraining(positiveDict, numPos, negativeDict, numNeg):\n",
    "    combinedDict = collections.OrderedDict()\n",
    "    Y = []\n",
    "    i = 0\n",
    "    for item in positiveDict:\n",
    "        if (i == numPos):\n",
    "            break\n",
    "        Y.append(1)\n",
    "        combinedDict[item] = positiveDict[item]\n",
    "        i += 1\n",
    "    j = 0\n",
    "    for item in negativeDict:\n",
    "        if (j == numNeg):\n",
    "            break\n",
    "        Y.append(0)\n",
    "        combinedDict[item] = negativeDict[item]\n",
    "        j+=1\n",
    "    return combinedDict,Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generateTest(positiveDict, numPos, numTestPos, negativeDict, numNeg, numTestNeg):\n",
    "    combinedTestDict = collections.OrderedDict()\n",
    "    Y = []\n",
    "    i = 0\n",
    "    for item in positiveDict:\n",
    "        if (i == numPos + numTestPos):\n",
    "            break\n",
    "        if (i < numPos):\n",
    "            i +=1\n",
    "            continue\n",
    "        else:\n",
    "            Y.append(1)\n",
    "            combinedTestDict[item] = positiveDict[item]\n",
    "        i += 1\n",
    "    j = 0\n",
    "    for item in negativeDict:\n",
    "        if (j == numNeg + numTestNeg):\n",
    "            break\n",
    "        if (j < numNeg):\n",
    "            j+=1\n",
    "            continue\n",
    "        else:\n",
    "            Y.append(0)\n",
    "            combinedTestDict[item] = negativeDict[item]\n",
    "        j+=1\n",
    "    return combinedTestDict,Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generateX(proteinTokens, vec):\n",
    "    #We have tokens of our \"positive\"\n",
    "    i = 0\n",
    "    X = []\n",
    "    while (i < len(proteinTokens)-1):\n",
    "      frame1 = proteinTokens[i]\n",
    "      frame2 = proteinTokens[i+1]\n",
    "      frame3 = proteinTokens[i+2]\n",
    "      total = frame1+frame2+frame3\n",
    "      index = i//3\n",
    "      currentSum = np.zeros((300,))\n",
    "      num_words = 1  \n",
    "      for word in total:\n",
    "        if word in vec:\n",
    "            num_words +=1    \n",
    "            currentSum = np.add(currentSum,vec[word])\n",
    "      X.append(np.divide(currentSum,num_words))\n",
    "      i += 3\n",
    "    return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def perf_measure(y_actual, y_pred):\n",
    "    TP = 0\n",
    "    FP = 0\n",
    "    TN = 0\n",
    "    FN = 0\n",
    "\n",
    "    for i in range(len(y_pred)): \n",
    "        if y_actual[i]==y_pred[i]==1:\n",
    "           TP += 1\n",
    "        if y_pred[i]==1 and y_actual[i]!=y_pred[i]:\n",
    "           FP += 1\n",
    "        if y_actual[i]==y_pred[i]==0:\n",
    "           TN += 1\n",
    "        if y_pred[i]==0 and y_actual[i]!=y_pred[i]:\n",
    "           FN += 1\n",
    "\n",
    "    return(TP, FP, TN, FN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing hit 0\n",
      "Processed a total of 2494 sequences\n"
     ]
    }
   ],
   "source": [
    "positiveDict = fastaToDict(positive_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing hit 560000\n",
      "Processed a total of 563551 sequences\n"
     ]
    }
   ],
   "source": [
    "negativeDict = fastaToDict(generic_proteins)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainingSet,Ytrain = generateTraining(positiveDict, numPos, negativeDict, numNeg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "testSet,Ytest = generateTest(positiveDict, numPos, numTestPos, negativeDict, numNeg, numTestNeg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "testTokens = tokenizeProteins(testSet)\n",
    "trainingTokens = tokenizeProteins(trainingSet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "aaa2vec = w2v.Word2Vec(\n",
    "    sg=1,\n",
    "    seed=1,\n",
    "    workers=num_workers,\n",
    "    size=num_features,\n",
    "    min_count=min_word_count,\n",
    "    window=context_size,\n",
    "    sample=downsampling\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "aaa2vec.build_vocab(trainingTokens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(145778900, 145778900)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aaa2vec.train(trainingTokens, total_examples=aaa2vec.corpus_count, epochs=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#save model\n",
    "if not os.path.exists(\"trained\"):\n",
    "    os.makedirs(\"trained\")\n",
    "aaa2vec.save(os.path.join(\"trained\", aaa2vec_NN))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load model\n",
    "aaa2vec = w2v.Word2Vec.load(os.path.join(\"trained\", aaa2vec_NN))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-16-a30099c907a6>:14: DeprecationWarning: Call to deprecated `__contains__` (Method will be removed in 4.0.0, use self.wv.__contains__() instead).\n",
      "  if word in vec:\n",
      "<ipython-input-16-a30099c907a6>:16: DeprecationWarning: Call to deprecated `__getitem__` (Method will be removed in 4.0.0, use self.wv.__getitem__() instead).\n",
      "  currentSum = np.add(currentSum,vec[word])\n"
     ]
    }
   ],
   "source": [
    "Xtrain = generateX(trainingTokens,aaa2vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = LogisticRegression()\n",
    "model.fit(Xtrain,Ytrain)\n",
    "#Ytrain_Pred=logistic_regression.predict(Xtrain)\n",
    "\n",
    "\n",
    "# calculate the fpr and tpr for all thresholds of the classification\n",
    "probs = model.predict_proba(Xtrain)\n",
    "preds = probs[:,1]\n",
    "fpr, tpr, threshold = metrics.roc_curve(Ytrain, preds)\n",
    "roc_auc = metrics.auc(fpr, tpr)\n",
    "\n",
    "# method I: plt\n",
    "import matplotlib.pyplot as plt\n",
    "plt.title('Receiver Operating Characteristic - Training Set')\n",
    "plt.plot(fpr, tpr, 'b', label = 'AUC = %0.2f' % roc_auc)\n",
    "plt.legend(loc = 'lower right')\n",
    "plt.plot([0, 1], [0, 1],'r--')\n",
    "plt.xlim([0, 1])\n",
    "plt.ylim([0, 1])\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-16-a30099c907a6>:14: DeprecationWarning: Call to deprecated `__contains__` (Method will be removed in 4.0.0, use self.wv.__contains__() instead).\n",
      "  if word in vec:\n",
      "<ipython-input-16-a30099c907a6>:16: DeprecationWarning: Call to deprecated `__getitem__` (Method will be removed in 4.0.0, use self.wv.__getitem__() instead).\n",
      "  currentSum = np.add(currentSum,vec[word])\n"
     ]
    }
   ],
   "source": [
    "Xtest = generateX(testTokens,aaa2vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# calculate the fpr and tpr for all thresholds of the classification\n",
    "probs = model.predict_proba(Xtest)\n",
    "preds = probs[:,1]\n",
    "fpr, tpr, threshold = metrics.roc_curve(Ytest, preds)\n",
    "roc_auc = metrics.auc(fpr, tpr)\n",
    "\n",
    "# method I: plt\n",
    "import matplotlib.pyplot as plt\n",
    "plt.title('Receiver Operating Characteristic - Test Set')\n",
    "plt.plot(fpr, tpr, 'b', label = 'AUC = %0.2f' % roc_auc)\n",
    "plt.legend(loc = 'lower right')\n",
    "plt.plot([0, 1], [0, 1],'r--')\n",
    "plt.xlim([0, 1])\n",
    "plt.ylim([0, 1])\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y_trainpred = model.predict(Xtrain)\n",
    "Y_testpred = model.predict(Xtest)\n",
    "train_stats = perf_measure(Ytrain, Y_trainpred)\n",
    "test_stats = perf_measure(Ytest, Y_testpred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The confusion matrix for the training set of data is the following in order --> TP,FP,TN,FN =\n",
      "(1680, 87, 1658, 65)\n"
     ]
    }
   ],
   "source": [
    "print(\"The confusion matrix for the training set of data is the following in order --> TP,FP,TN,FN =\")\n",
    "print(train_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The confusion matrix for the test set of data is the following in order --> TP,FP,TN,FN =\n",
      "(645, 123, 577, 55)\n"
     ]
    }
   ],
   "source": [
    "print(\"The confusion matrix for the test set of data is the following in order --> TP,FP,TN,FN =\")\n",
    "print(test_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "word2vec",
   "language": "python",
   "name": "word2vec"
  },
  "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}