08-Properties-calculation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO: Pandarallel will run on 8 workers.\n",
      "INFO: Pandarallel will use Memory file system to transfer data between the main process and workers.\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import torch.nn as nn\n",
    "import torch\n",
    "import time\n",
    "import math\n",
    "import pickle\n",
    "import pandas as pd\n",
    "from pandas import Series, DataFrame\n",
    "from pandarallel import pandarallel\n",
    "pandarallel.initialize(progress_bar=True)\n",
    "import sys\n",
    "import json\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.naive_bayes import GaussianNB, MultinomialNB\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn import svm\n",
    "from sklearn.metrics import roc_auc_score, roc_curve, accuracy_score, matthews_corrcoef, f1_score, precision_score, recall_score\n",
    "import random\n",
    "import pickle\n",
    "from rdkit.Chem import rdchem, Lipinski\n",
    "from rdkit import Chem\n",
    "from rdkit.Chem.rdmolfiles import MolFromFASTA, MolToSmiles, MolFromSmiles\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "import numpy as np\n",
    "import torch.optim as optim\n",
    "folder = \"/data/AIpep-clean/\"\n",
    "import matplotlib.pyplot as plt\n",
    "from Levenshtein import distance as lev_dist\n",
    "from models import Classifier\n",
    "import tmap as tm\n",
    "from map4 import MAP4Calculator\n",
    "import os\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load Classifiers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ClassifierRNN(\n",
       "  (embedding): Embedding(42, 100)\n",
       "  (rnn): GRU(100, 400, num_layers=2, batch_first=True)\n",
       "  (output_layer): Linear(in_features=400, out_features=2, bias=True)\n",
       "  (softmax): LogSoftmax()\n",
       ")"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_embedding = 100\n",
    "n_hidden = 400\n",
    "n_layers = 2\n",
    "epoch = 38\n",
    "\n",
    "filename = folder + \"models/RNN-classifier/em{}_hi{}_la{}_ep{}\".format(n_embedding, n_hidden, n_layers, epoch)\n",
    "\n",
    "model_activity = Classifier.load_from_file(filename)\n",
    "\n",
    "if torch.cuda.is_available():\n",
    "    device = \"cuda\" \n",
    "else:\n",
    "    device = \"cpu\" \n",
    "\n",
    "model_activity.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_embedding = 100\n",
    "n_hidden = 400\n",
    "n_layers = 1\n",
    "epoch = 95\n",
    "\n",
    "filename = folder + \"models/RNN-classifier-hem/em{}_hi{}_la{}_ep{}\".format(n_embedding, n_hidden, n_layers, epoch)\n",
    "\n",
    "model_hemolysis = Classifier.load_from_file(filename)\n",
    "\n",
    "if torch.cuda.is_available():\n",
    "    device = \"cuda\" \n",
    "else:\n",
    "    device = \"cpu\" \n",
    "\n",
    "model_hemolysis.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(folder + \"pickles/all_sequences-hem.pkl\"):\n",
    "    df_training_test = pd.read_pickle(folder+\"pickles/DAASP_RNN_dataset_with_hem_and_prediction_hem.plk\")\n",
    "    df_generated = pd.read_pickle(folder+\"pickles/Generated.pkl\")\n",
    "    df_generated_tl_pos = pd.read_pickle(folder+\"pickles/Generated-TL-grampos-hem.pkl\")\n",
    "    df_generated_tl_neg = pd.read_pickle(folder+\"pickles/Generated-TL-gramneg-hem.pkl\")\n",
    "    df_generated_all = pd.concat([df_generated, df_generated_tl_pos, df_generated_tl_neg])\n",
    "\n",
    "    df_generated_all[\"prediction\"] = df_generated_all.Sequence.map(lambda x: model_activity.predict_peptide_sequence(x)[:,1][0])\n",
    "    df_generated_all[\"isPredActive\"] = df_generated_all[\"prediction\"] > 0.99205756\n",
    "    df_generated_all[\"prediction_hem\"] = df_generated_all.Sequence.map(lambda x: model_hemolysis.predict_peptide_sequence(x)[:,1][0])\n",
    "    df_generated_all[\"isPredNotHemolytic\"] = df_generated_all[\"prediction_hem\"] > 0.99981695\n",
    "\n",
    "    df_all = pd.concat([df_training_test, df_generated_all])\n",
    "\n",
    "    count_neg = 0\n",
    "    count_pos = 0\n",
    "    count = 0\n",
    "\n",
    "    def make_id(row):\n",
    "        global count_neg\n",
    "        global count_pos\n",
    "        global count\n",
    "\n",
    "        if row.Set == \"generated-TL-GN-hem\":\n",
    "            count_neg += 1\n",
    "            return f\"gen_gramneg_{count_neg}\"\n",
    "\n",
    "        elif row.Set == \"generated-TL-GP-hem\":\n",
    "            count_pos += 1\n",
    "            return f\"gen_grampos_{count_pos}\"\n",
    "\n",
    "        elif row.Set == \"generated\":\n",
    "            count += 1\n",
    "            return f\"gen_{count}\"\n",
    "\n",
    "        else:\n",
    "            return row.ID\n",
    "\n",
    "    new_ids = df_all.apply(make_id, axis=1)\n",
    "\n",
    "    df_all[\"ID\"] = new_ids\n",
    "    df_all = df_all.reset_index(drop=True)\n",
    "\n",
    "    df_all.to_pickle(folder+\"pickles/all_sequences-hem.pkl\")\n",
    "else:\n",
    "    df_all = pd.read_pickle(folder+\"pickles/all_sequences-hem.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_training_test_hem = pd.read_pickle(folder+\"pickles/DAASP_RNN_dataset_with_hem_and_prediction_hem.plk\")\n",
    "df_training_test_act = pd.read_pickle(folder+\"pickles/DAASP_RNN_dataset_with_prediction.plk\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "476"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df_all.query(\"activity == 0\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Find NN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_seqNN(seq, dataframe):\n",
    "    best_dist = float(\"inf\")\n",
    "    dists = dataframe[\"Sequence\"].map(lambda seq2 : lev_dist(seq,seq2))\n",
    "    NNi = np.argmin(dists)\n",
    "    best_dist = dists.iloc[NNi]\n",
    "    NN = dataframe[\"Sequence\"].iloc[NNi]\n",
    "    return best_dist, NN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def seq_to_smiles(seq):\n",
    "    mol = MolFromFASTA(seq, flavor=True, sanitize = True)\n",
    "    smiles = MolToSmiles(mol, isomericSmiles=True)\n",
    "    return smiles\n",
    "\n",
    "MAP4 = MAP4Calculator(dimensions=1024)\n",
    "def calc_map4(smiles):\n",
    "    mol = Chem.MolFromSmiles(smiles)\n",
    "    map4 = MAP4.calculate(mol)\n",
    "    return np.array(map4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def distance(a, b):\n",
    "    \"\"\"Estimates the Jaccard distance of two binary arrays based on their hashes.\n",
    "\n",
    "Arguments:\n",
    "  a {numpy.ndarray} -- An array containing hash values.\n",
    "  b {numpy.ndarray} -- An array containing hash values.\n",
    "\n",
    "Returns:\n",
    "  float -- The estimated Jaccard distance.\n",
    "\"\"\"\n",
    "\n",
    "    # The Jaccard distance of Minhashed values is estimated by\n",
    "    return 1.0 - np.float(np.count_nonzero(a == b)) / np.float(len(a))\n",
    "\n",
    "def find_map_seqNN(fp, dataframe):\n",
    "    best_dist = float(\"inf\")\n",
    "    dists = dataframe[\"MAP4\"].map(lambda fp2 : distance(fp,fp2))\n",
    "    NNi = np.argmin(dists)\n",
    "    best_dist = dists.iloc[NNi]\n",
    "    NN = dataframe[\"Sequence\"].iloc[NNi]\n",
    "    return best_dist, NN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c8e9943657d14984a7bca899a9c87f07",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=16152), Label(value='0 / 16152')))…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a62b0125d888488e8ddbcf4e8c141c5e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=16152), Label(value='0 / 16152')))…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9317e5e755a94e8db413c06739f9fe15",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=16152), Label(value='0 / 16152')))…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "119c762918e34c89bafeb589afb55a79",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=16152), Label(value='0 / 16152')))…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if not os.path.exists(folder+\"pickles/all_sequences_with_NN_hem.pkl\"):\n",
    "    df_all[\"dist-NN-Training_hem\"] = df_all[\"Sequence\"].parallel_map(lambda x: find_seqNN(x, df_training_test_hem[df_training_test_hem[\"Set\"]==\"training\"]))\n",
    "    df_all[\"dist-NN-Test_hem\"] = df_all[\"Sequence\"].parallel_map(lambda x: find_seqNN(x, df_training_test_hem[df_training_test_hem[\"Set\"]==\"test\"]))\n",
    "    df_all[\"dist_Training_hem\"] = df_all[\"dist-NN-Training_hem\"].map(lambda x: x[0])\n",
    "    df_all[\"NN_Training_hem\"] = df_all[\"dist-NN-Training_hem\"].map(lambda x: x[1])\n",
    "    df_all[\"dist_Test_hem\"] = df_all[\"dist-NN-Test_hem_hem\"].map(lambda x: x[0])\n",
    "    df_all[\"NN_Test_hem\"] = df_all[\"dist-NN-Test_hem\"].map(lambda x: x[1])\n",
    "    del df_all[\"dist-NN-Training_hem\"]\n",
    "    del df_all[\"dist-NN-Test_hem\"]\n",
    "    \n",
    "    df_all[\"dist-NN-Training_act\"] = df_all[\"Sequence\"].parallel_map(lambda x: find_seqNN(x, df_training_test_act[df_training_test_act[\"Set\"]==\"training\"]))\n",
    "    df_all[\"dist-NN-Test_act\"] = df_all[\"Sequence\"].parallel_map(lambda x: find_seqNN(x, df_training_test_act[df_training_test_act[\"Set\"]==\"test\"]))\n",
    "    df_all[\"dist_Training_act\"] = df_all[\"dist-NN-Training_act\"].map(lambda x: x[0])\n",
    "    df_all[\"NN_Training_act\"] = df_all[\"dist-NN-Training_act\"].map(lambda x: x[1])\n",
    "    df_all[\"dist_Test_act\"] = df_all[\"dist-NN-Test_act\"].map(lambda x: x[0])\n",
    "    df_all[\"NN_Test_act\"] = df_all[\"dist-NN-Test_act\"].map(lambda x: x[1])\n",
    "    del df_all[\"dist-NN-Training_act\"]\n",
    "    del df_all[\"dist-NN-Test_act\"]\n",
    "    \n",
    "    df_all[\"SMILES\"] = df_all.Sequence.parallel_map(seq_to_smiles)\n",
    "    df_all[\"MAP4\"] = df_all.SMILES.parallel_map(calc_map4)\n",
    "    \n",
    "    df_all[\"map-dist-NN-Training_act\"] = df_all[\"MAP4\"].parallel_map(lambda x: find_map_seqNN(x, df_all[df_all[\"Set\"]==\"training\"]))\n",
    "    df_all[\"map-dist-NN-Test_act\"] = df_all[\"MAP4\"].parallel_map(lambda x: find_map_seqNN(x, df_all[df_all[\"Set\"]==\"test\"]))\n",
    "    df_all[\"map_dist_Training_act\"] = df_all[\"map-dist-NN-Training_act\"].map(lambda x: x[0])\n",
    "    df_all[\"map_NN_Training_act\"] = df_all[\"map-dist-NN-Training_act\"].map(lambda x: x[1])\n",
    "    df_all[\"map_dist_Test_act\"] = df_all[\"map-dist-NN-Test_act\"].map(lambda x: x[0])\n",
    "    df_all[\"map_NN_Test_act\"] = df_all[\"map-dist-NN-Test_act\"].map(lambda x: x[1])\n",
    "    del df_all[\"map-dist-NN-Training\"]\n",
    "    del df_all[\"map-dist-NN-Test\"]\n",
    "    \n",
    "    df_all.to_pickle(folder+\"pickles/all_sequences_with_NN_hem.pkl\")\n",
    "else:\n",
    "    df_all = pd.read_pickle(folder+\"pickles/all_sequences_with_NN_hem.pkl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calculate properties"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_neg(seq):\n",
    "    seq = seq.upper()\n",
    "    neg = (seq.count('D') + seq.count('E'))\n",
    "    return neg\n",
    "\n",
    "def calc_pos(seq):\n",
    "    seq = seq.upper()\n",
    "    pos = (seq.count('K') + seq.count('R'))\n",
    "    return pos\n",
    "\n",
    "def calc_aa(seq, aa):\n",
    "    seq = seq.upper()\n",
    "    aa_f = seq.count(aa)/len(seq) \n",
    "    return aa_f\n",
    "\n",
    "def calc_hac(smiles):\n",
    "    mol = MolFromSmiles(smiles)\n",
    "    hac = Lipinski.HeavyAtomCount(mol)\n",
    "    return hac\n",
    "\n",
    "def calc_hydr(seq):\n",
    "    hydr = (seq.count('A') + seq.count('L') + seq.count('I') + seq.count('L') \\\n",
    "            + seq.count('V') + seq.count('M') + seq.count('F') + seq.count('C'))\n",
    "    return hydr\n",
    "\n",
    "def hydropatch(seq):\n",
    "    seq = seq.upper()\n",
    "    \n",
    "    hydro = [\"A\", \"L\", \"I\", \"V\", \"M\", \"F\", \"C\"]\n",
    "    patch = \"\"\n",
    "    patches = []\n",
    "    for aa in seq:\n",
    "        if aa in hydro:\n",
    "            patch+=aa\n",
    "        else:\n",
    "            if patch != \"\":\n",
    "                patches.append(len(patch))\n",
    "            patch=\"\"\n",
    "    if patch != \"\":\n",
    "        patches.append(len(patch))    \n",
    "    return np.array(patches)\n",
    "\n",
    "\n",
    "def calc_hba(smiles):\n",
    "    mol = MolFromSmiles(smiles)\n",
    "    hba = Lipinski.NumHAcceptors(mol)\n",
    "    return hba\n",
    "\n",
    "def calc_hbd(smiles):\n",
    "    mol = MolFromSmiles(smiles)\n",
    "    hbd = Lipinski.NumHDonors(mol)\n",
    "    return hbd\n",
    "\n",
    "def mean(patches):\n",
    "    if len(patches) == 0:\n",
    "        return 0\n",
    "    return round(patches.mean(),2)\n",
    "\n",
    "d_aminoacids = [\"a\",\"c\",\"d\",\"e\",\"f\",\"g\",\"h\",\"i\",\"l\",\"m\",\"n\",\"p\",\"k\",\"q\",\"r\",\"s\",\"t\",\"v\",\"w\",\"y\"]\n",
    "def d_aa(seq):\n",
    "    for aa in d_aminoacids:\n",
    "        if aa in seq:\n",
    "            return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/usr/bin/env python\n",
    "\n",
    "\"\"\"\n",
    "Calculates a set of properties from a protein sequence:\n",
    "    - hydrophobicity (according to a particular scale)\n",
    "    - mean hydrophobic dipole moment assuming it is an alpha-helix.\n",
    "    - total charge (at pH 7.4)\n",
    "    - amino acid composition\n",
    "    - discimination factor according to Rob Keller (IJMS, 2011)\n",
    "Essentially the same as HeliQuest (reproduces the same values).\n",
    "Author:\n",
    "  Joao Rodrigues\n",
    "  j.p.g.l.m.rodrigues@gmail.com\n",
    "\"\"\"\n",
    "\n",
    "from __future__ import print_function\n",
    "\n",
    "import argparse\n",
    "import csv\n",
    "import math\n",
    "import os\n",
    "import time\n",
    "\n",
    "#\n",
    "# Definitions\n",
    "#\n",
    "scales = {'Fauchere-Pliska': {'A':  0.31, 'R': -1.01, 'N': -0.60,\n",
    "                              'D': -0.77, 'C':  1.54, 'Q': -0.22,\n",
    "                              'E': -0.64, 'G':  0.00, 'H':  0.13,\n",
    "                              'I':  1.80, 'L':  1.70, 'K': -0.99,\n",
    "                              'M':  1.23, 'F':  1.79, 'P':  0.72,\n",
    "                              'S': -0.04, 'T':  0.26, 'W':  2.25,\n",
    "                              'Y':  0.96, 'V':  1.22},\n",
    "\n",
    "          'Eisenberg': {'A':  0.25, 'R': -1.80, 'N': -0.64,\n",
    "                        'D': -0.72, 'C':  0.04, 'Q': -0.69,\n",
    "                        'E': -0.62, 'G':  0.16, 'H': -0.40,\n",
    "                        'I':  0.73, 'L':  0.53, 'K': -1.10,\n",
    "                        'M':  0.26, 'F':  0.61, 'P': -0.07,\n",
    "                        'S': -0.26, 'T': -0.18, 'W':  0.37,\n",
    "                        'Y':  0.02, 'V':  0.54},\n",
    "          }\n",
    "_supported_scales = list(scales.keys())\n",
    "\n",
    "aa_charge = {'E': -1, 'D': -1, 'K': 1, 'R': 1}\n",
    "\n",
    "#\n",
    "# Functions\n",
    "#\n",
    "def assign_hydrophobicity(sequence, scale='Fauchere-Pliska'):  # noqa: E302\n",
    "    \"\"\"Assigns a hydrophobicity value to each amino acid in the sequence\"\"\"\n",
    "\n",
    "    hscale = scales.get(scale, None)\n",
    "    if not hscale:\n",
    "        raise KeyError('{} is not a supported scale. '.format(scale))\n",
    "\n",
    "    hvalues = []\n",
    "    for aa in sequence:\n",
    "        sc_hydrophobicity = hscale.get(aa, None)\n",
    "        if sc_hydrophobicity is None:\n",
    "            raise KeyError('Amino acid not defined in scale: {}'.format(aa))\n",
    "        hvalues.append(sc_hydrophobicity)\n",
    "\n",
    "    return hvalues\n",
    "\n",
    "\n",
    "def calculate_moment(array, angle=100):\n",
    "    \"\"\"Calculates the hydrophobic dipole moment from an array of hydrophobicity\n",
    "    values. Formula defined by Eisenberg, 1982 (Nature). Returns the average\n",
    "    moment (normalized by sequence length)\n",
    "    uH = sqrt(sum(Hi cos(i*d))**2 + sum(Hi sin(i*d))**2),\n",
    "    where i is the amino acid index and d (delta) is an angular value in\n",
    "    degrees (100 for alpha-helix, 180 for beta-sheet).\n",
    "    \"\"\"\n",
    "\n",
    "    sum_cos, sum_sin = 0.0, 0.0\n",
    "    for i, hv in enumerate(array):\n",
    "        rad_inc = ((i*angle)*math.pi)/180.0\n",
    "        sum_cos += hv * math.cos(rad_inc)\n",
    "        sum_sin += hv * math.sin(rad_inc)\n",
    "    if len(array) != 0:\n",
    "        return math.sqrt(sum_cos**2 + sum_sin**2) / len(array)\n",
    "    else:\n",
    "        print(array)\n",
    "        return 0\n",
    "\n",
    "\n",
    "def calculate_charge(sequence, charge_dict=aa_charge):\n",
    "    \"\"\"Calculates the charge of the peptide sequence at pH 7.4\n",
    "    \"\"\"\n",
    "    sc_charges = [charge_dict.get(aa, 0) for aa in sequence]\n",
    "    return sum(sc_charges)\n",
    "\n",
    "\n",
    "def calculate_discrimination(mean_uH, total_charge):\n",
    "    \"\"\"Returns a discrimination factor according to Rob Keller (IJMS, 2011)\n",
    "    A sequence with d>0.68 can be considered a potential lipid-binding region.\n",
    "    \"\"\"\n",
    "    d = 0.944*mean_uH + 0.33*total_charge\n",
    "    return d\n",
    "\n",
    "\n",
    "def calculate_composition(sequence):\n",
    "    \"\"\"Returns a dictionary with percentages per classes\"\"\"\n",
    "\n",
    "    # Residue character table\n",
    "    polar_aa = set(('S', 'T', 'N', 'H', 'Q', 'G'))\n",
    "    speci_aa = set(('P', 'C'))\n",
    "    apolar_aa = set(('A', 'L', 'V', 'I', 'M'))\n",
    "    charged_aa = set(('E', 'D', 'K', 'R'))\n",
    "    aromatic_aa = set(('W', 'Y', 'F'))\n",
    "\n",
    "    n_p, n_s, n_a, n_ar, n_c = 0, 0, 0, 0, 0\n",
    "    for aa in sequence:\n",
    "        if aa in polar_aa:\n",
    "            n_p += 1\n",
    "        elif aa in speci_aa:\n",
    "            n_s += 1\n",
    "        elif aa in apolar_aa:\n",
    "            n_a += 1\n",
    "        elif aa in charged_aa:\n",
    "            n_c += 1\n",
    "        elif aa in aromatic_aa:\n",
    "            n_ar += 1\n",
    "\n",
    "    return {'polar': n_p, 'special': n_s,\n",
    "            'apolar': n_a, 'charged': n_c, 'aromatic': n_ar}\n",
    "\n",
    "\n",
    "def analyze_sequence(name=None, sequence=None, window=18, verbose=False):\n",
    "    \"\"\"Runs all the above on a sequence. Pretty prints the results\"\"\"\n",
    "\n",
    "\n",
    "\n",
    "    w = window\n",
    "\n",
    "    outdata = []  # for csv writing\n",
    "\n",
    "    # Processing...\n",
    "    seq_len = len(sequence)\n",
    "    print('[+] Analysing sequence {} ({} aa.)'.format(name, seq_len))\n",
    "    print('[+] Using a window of {} aa.'.format(w))\n",
    "    for seq_range in range(0, seq_len):\n",
    "\n",
    "        seq_w = sequence[seq_range:seq_range+w]\n",
    "        if seq_range and len(seq_w) < w:\n",
    "            break\n",
    "\n",
    "        # Numerical values\n",
    "        z = calculate_charge(seq_w)\n",
    "        seq_h = assign_hydrophobicity(seq_w)\n",
    "        av_h = sum(seq_h)/len(seq_h)\n",
    "        av_uH = calculate_moment(seq_h)\n",
    "        d = calculate_discrimination(av_uH, z)\n",
    "\n",
    "        # AA composition\n",
    "        aa_comp = calculate_composition(seq_w)\n",
    "        n_tot_pol = aa_comp['polar'] + aa_comp['charged']\n",
    "        n_tot_apol = aa_comp['apolar'] + aa_comp['aromatic'] + aa_comp['special']  # noqa: E501\n",
    "        n_charged = aa_comp['charged']  # noqa: E501\n",
    "        n_aromatic = aa_comp['aromatic']  # noqa: E501\n",
    "\n",
    "        _t = [name, sequence, seq_range+1, w, seq_w, z, av_h, av_uH, d,\n",
    "              n_tot_pol, n_tot_apol, n_charged, n_aromatic]\n",
    "        outdata.append(_t)\n",
    "\n",
    "        if verbose:\n",
    "            print('  Window {}: {}-{}-{}'.format(seq_range+1, seq_range,\n",
    "                                                 seq_w, seq_range+w))\n",
    "            print('    z={:<3d} <H>={:4.3f} <uH>={:4.3f} D={:4.3f}'.format(z, av_h,  # noqa: E501\n",
    "                                                                           av_uH, d))  # noqa: E501\n",
    "            print('    Amino acid composition')\n",
    "            print('      Polar    : {:3d} / {:3.2f}%'.format(n_tot_pol, n_tot_pol*100/w))  # noqa: E501\n",
    "            print('      Non-Polar: {:3d} / {:3.2f}%'.format(n_tot_apol, n_tot_apol*100/w))  # noqa: E501\n",
    "            print('      Charged  : {:3d} / {:3.2f}%'.format(n_charged, n_charged*100/w))  # noqa: E501\n",
    "            print('      Aromatic : {:3d} / {:3.2f}%'.format(n_aromatic, n_aromatic*100/w))  # noqa: E501\n",
    "            print()\n",
    "\n",
    "    return outdata\n",
    "\n",
    "\n",
    "def read_fasta_file(afile):\n",
    "    \"\"\"Parses a file with FASTA formatted sequences\"\"\"\n",
    "\n",
    "    if not os.path.isfile(afile):\n",
    "        raise IOError('File not found/readable: {}'.format(afile))\n",
    "\n",
    "    sequences = []\n",
    "    seq_name, cur_seq = None, None\n",
    "    with open(afile) as handle:\n",
    "        for line in handle:\n",
    "            line = line.strip()\n",
    "            if line.startswith('>'):\n",
    "                if cur_seq:\n",
    "                    sequences.append((seq_name, ''.join(cur_seq)))\n",
    "                seq_name = line[1:]\n",
    "                cur_seq = []\n",
    "            elif line:\n",
    "                cur_seq.append(line)\n",
    "    sequences.append((seq_name, ''.join(cur_seq)))  # last seq\n",
    "\n",
    "    return sequences\n",
    "\n",
    "def hydr_moment(seq):\n",
    "    seq = seq.upper()\n",
    "    hdr = assign_hydrophobicity(seq,\"Eisenberg\")\n",
    "    return calculate_moment(hdr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists(folder+\"pickles/all_sequences_with_NN_prop-hem.pkl\"):\n",
    "    df_all[\"length\"] = df_all.Sequence.map(len)\n",
    "    df_all = df_all.query(\"length>1\")\n",
    "\n",
    "    df_all[\"D_AA\"] = df_all.Sequence.map(d_aa) \n",
    "\n",
    "    aminoacids = [\"A\",\"C\",\"D\",\"E\",\"F\",\"G\",\"H\",\"I\",\"L\",\"M\",\"N\",\"P\",\"K\",\"Q\",\"R\",\"S\",\"T\",\"V\",\"W\",\"Y\"]\n",
    "    for aa in aminoacids:\n",
    "        df_all[f\"{aa}_fract\"] = df_all.Sequence.map(lambda x: calc_aa(x, aa))   \n",
    "\n",
    "    df_all[\"positive\"] = df_all.Sequence.parallel_map(calc_pos)\n",
    "    df_all[\"negative\"] = df_all.Sequence.parallel_map(calc_neg)\n",
    "    df_all[\"HAC\"] = df_all.SMILES.parallel_map(calc_hac)\n",
    "    df_all[\"HBA\"] = df_all.SMILES.parallel_map(calc_hba)\n",
    "    df_all[\"HBD\"] = df_all.SMILES.parallel_map(calc_hbd)\n",
    "    df_all[\"hydrophobic\"] = df_all.Sequence.parallel_map(calc_hydr)\n",
    "    df_all[\"hydrophobic_patches\"] = df_all.Sequence.parallel_map(hydropatch)\n",
    "    df_all[\"hydrophobic_patches_num\"] = df_all.hydrophobic_patches.map(len)\n",
    "    df_all[\"hydrophobic_patches_len\"] = df_all.hydrophobic_patches.map(mean)\n",
    "    df_all[\"hydro_res_fract\"] = df_all.apply(lambda x: x.hydrophobic / x.length, axis=1)\n",
    "    df_all[\"pos_res_fract\"] = df_all.apply(lambda x: x.positive / x.length, axis=1)\n",
    "\n",
    "\n",
    "    df_all[\"HydroMoment\"] = df_all.Sequence.map(hydr_moment)\n",
    "    df_all[\"charge\"] = df_all[\"Sequence\"].map(lambda x: calculate_charge(x.upper()))\n",
    "    df_all[\"hydrophobicity\"] = df_all[\"Sequence\"].map(lambda x: assign_hydrophobicity(x.upper()))\n",
    "    df_all[\"av_hydrophobicity\"] = df_all[\"hydrophobicity\"].map(lambda x: sum(x)/len(x)) \n",
    "    df_all[\"discrimination\"] = df_all.apply(lambda x: calculate_discrimination(x.HydroMoment, x.charge), axis=1)\n",
    "\n",
    "    df_all.to_pickle(folder+\"pickles/all_sequences_with_NN_prop-hem.pkl\")\n",
    "else:\n",
    "    df_all = pd.read_pickle(folder+\"pickles/all_sequences_with_NN_prop-hem.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_training_test_all = pd.read_pickle(folder+\"pickles/DAASP_RNN_dataset_with_hemolysis.plk\")\n",
    "df_training_test_all[\"HydroMoment\"] = df_training_test_all.Sequence.map(hydr_moment)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SPIDER helicity prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def row_to_fasta(row):\n",
    "    seq = row[\"Sequence\"]\n",
    "    ID = row[\"Sequence\"]\n",
    "    l = 40\n",
    "    fasta_seq = seq\n",
    "    fasta = \">{}\\n{}\".format(ID,fasta_seq)\n",
    "    return fasta\n",
    "\n",
    "def fastafile(row, folder=\"/data/AIpep/spiderData/\"):\n",
    "    fasta = row[\"fasta\"]\n",
    "    fasta = fasta.upper()\n",
    "    ID = str(row[\"ID\"])\n",
    "    name = folder+ID+\".seq\"\n",
    "    with open(name, \"w\") as output:\n",
    "        output.write(fasta)\n",
    "        \n",
    "def filename(row, folder=\"/data/AIpep/spiderData/\"):\n",
    "    ID = str(row[\"ID\"])\n",
    "    name = ID+\".seq\"\n",
    "    return name\n",
    "\n",
    "def fileloc(row, folder=\"/data/AIpep/spiderData/\"):\n",
    "    ID = str(row[\"ID\"])\n",
    "    name = folder+ID+\".seq\"\n",
    "    return name\n",
    "\n",
    "def read_spider(row, folder=\"/data/AIpep/spider3/\"):\n",
    "    ss = []\n",
    "    ID = str(row[\"ID\"])\n",
    "    name = ID+\".seq.i2\"\n",
    "\n",
    "    with open(folder+name) as infile:\n",
    "        for line in infile:\n",
    "            line = line.strip()\n",
    "            line = line.split(\" \")\n",
    "            ss.append(line[2])\n",
    "    return ss[1:]\n",
    "\n",
    "def count_ss(ss, pred = \"H\"):\n",
    "    return ss.count(pred)\n",
    "def fract_ss(ss, pred = \"H\"):\n",
    "    if len(ss)!=0:\n",
    "        return ss.count(pred)/len(ss)\n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_all[\"fasta\"] = df_all.apply(row_to_fasta, axis = 1)\n",
    "df_all.apply(fastafile, axis=1)\n",
    "df_all[\"SpiderFilename\"] = df_all.apply(filename, axis=1)\n",
    "df_all[\"SpiderFileloc\"] = df_all.apply(fileloc, axis=1)\n",
    "df_all[[\"SpiderFilename\", \"SpiderFileloc\"]].to_csv(\"SPIDER3-Single_np/file_list-hem\", header=False, index=False, sep=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_training_test_all[\"fasta\"] = df_training_test_all.apply(row_to_fasta, axis = 1)\n",
    "df_training_test_all.apply(fastafile, axis=1)\n",
    "df_training_test_all[\"SpiderFilename\"] = df_training_test_all.apply(filename, axis=1)\n",
    "df_training_test_all[\"SpiderFileloc\"] = df_training_test_all.apply(fileloc, axis=1)\n",
    "df_training_test_all[[\"SpiderFilename\", \"SpiderFileloc\"]].to_csv(\"../AIpep/SPIDER3-Single_np/file_list-hem_alltraining\", header=False, index=False, sep=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9548"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df_training_test_all)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['ID', 'Name', 'N terminus', 'Sequence', 'C terminus', 'targetSpecies',\n",
       "       'baumannii', 'aureus', 'aeruginosa', 'activity', 'Set', 'hemolysis',\n",
       "       'len_hemolysis', 'isNotHemolytic', 'Hemolysis_pred', 'Repetition',\n",
       "       'inTraining', 'prediction', 'isPredActive', 'prediction_hem',\n",
       "       'dist_Training', 'NN_Training', 'dist_Test', 'NN_Test', 'SMILES',\n",
       "       'MAP4', 'map_dist_Training', 'map_NN_Training', 'map_dist_Test',\n",
       "       'map_NN_Test', 'length', 'D_AA', 'A_fract', 'C_fract', 'D_fract',\n",
       "       'E_fract', 'F_fract', 'G_fract', 'H_fract', 'I_fract', 'L_fract',\n",
       "       'M_fract', 'N_fract', 'P_fract', 'K_fract', 'Q_fract', 'R_fract',\n",
       "       'S_fract', 'T_fract', 'V_fract', 'W_fract', 'Y_fract', 'positive',\n",
       "       'negative', 'HAC', 'HBA', 'HBD', 'hydrophobic', 'hydrophobic_patches',\n",
       "       'hydrophobic_patches_num', 'hydrophobic_patches_len', 'hydro_res_fract',\n",
       "       'pos_res_fract', 'HydroMoment', 'charge', 'hydrophobicity',\n",
       "       'av_hydrophobicity', 'discrimination', 'fasta', 'SpiderFilename',\n",
       "       'SpiderFileloc', 'SS', 'countH', 'fraction_PredHelical',\n",
       "       'fraction_PredBetaSheet', 'fraction_PredCoil', 'isPredNotHemolytic'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_all.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run SPIDER\n",
    "%%bash\n",
    "./SPIDER3-Single_np/impute_script_np.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_all[\"SS\"] = df_all.apply(read_spider, axis=1)\n",
    "df_all[\"countH\"] = df_all.SS.map(count_ss)\n",
    "df_all[\"fraction_PredHelical\"] = df_all.SS.map(fract_ss)\n",
    "df_all[\"fraction_PredBetaSheet\"] = df_all.SS.map(lambda x : fract_ss(x, \"E\"))\n",
    "df_all[\"fraction_PredCoil\"] = df_all.SS.map(lambda x : fract_ss(x, \"C\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_training_test_all[\"SS\"] = df_training_test_all.apply(read_spider, axis=1)\n",
    "df_training_test_all[\"countH\"] = df_training_test_all.SS.map(count_ss)\n",
    "df_training_test_all[\"fraction_PredHelical\"] = df_training_test_all.SS.map(fract_ss)\n",
    "df_training_test_all[\"fraction_PredBetaSheet\"] = df_training_test_all.SS.map(lambda x : fract_ss(x, \"E\"))\n",
    "df_training_test_all[\"fraction_PredCoil\"] = df_training_test_all.SS.map(lambda x : fract_ss(x, \"C\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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>ID</th>\n",
       "      <th>Name</th>\n",
       "      <th>N terminus</th>\n",
       "      <th>Sequence</th>\n",
       "      <th>C terminus</th>\n",
       "      <th>targetSpecies</th>\n",
       "      <th>baumannii</th>\n",
       "      <th>aureus</th>\n",
       "      <th>aeruginosa</th>\n",
       "      <th>activity</th>\n",
       "      <th>...</th>\n",
       "      <th>av_hydrophobicity</th>\n",
       "      <th>discrimination</th>\n",
       "      <th>fasta</th>\n",
       "      <th>SpiderFilename</th>\n",
       "      <th>SpiderFileloc</th>\n",
       "      <th>SS</th>\n",
       "      <th>countH</th>\n",
       "      <th>fraction_PredHelical</th>\n",
       "      <th>fraction_PredBetaSheet</th>\n",
       "      <th>fraction_PredCoil</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>118</td>\n",
       "      <td>Magainin-2 [F16W]</td>\n",
       "      <td>nan</td>\n",
       "      <td>GIGKFLHSAKKFGKAWVGEIMNS</td>\n",
       "      <td>AMD</td>\n",
       "      <td>[Escherichia coli, Pseudomonas aeruginosa, Sta...</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.393478</td>\n",
       "      <td>1.251559</td>\n",
       "      <td>&gt;GIGKFLHSAKKFGKAWVGEIMNS\\nGIGKFLHSAKKFGKAWVGEIMNS</td>\n",
       "      <td>118.seq</td>\n",
       "      <td>/data/AIpep/spiderData/118.seq</td>\n",
       "      <td>[C, H, H, H, H, H, H, H, H, H, H, H, H, H, H, ...</td>\n",
       "      <td>21</td>\n",
       "      <td>0.913043</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.086957</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>119</td>\n",
       "      <td>Magainin-2 [I2L][K11R][I20A]</td>\n",
       "      <td>nan</td>\n",
       "      <td>GLGKFLHSAKRFGKAFVGEAMNS</td>\n",
       "      <td>AMD</td>\n",
       "      <td>[Escherichia coli, Pseudomonas aeruginosa, Sta...</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.303478</td>\n",
       "      <td>1.260918</td>\n",
       "      <td>&gt;GLGKFLHSAKRFGKAFVGEAMNS\\nGLGKFLHSAKRFGKAFVGEAMNS</td>\n",
       "      <td>119.seq</td>\n",
       "      <td>/data/AIpep/spiderData/119.seq</td>\n",
       "      <td>[C, H, H, H, H, H, H, H, H, H, H, H, H, H, H, ...</td>\n",
       "      <td>20</td>\n",
       "      <td>0.869565</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.130435</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>120</td>\n",
       "      <td>Magainin-2 [L6I][A15L]</td>\n",
       "      <td>nan</td>\n",
       "      <td>GIGKFIHSAKKFGKLFVGEIMNS</td>\n",
       "      <td>AMD</td>\n",
       "      <td>[Escherichia coli, Pseudomonas aeruginosa, Sta...</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.438261</td>\n",
       "      <td>1.258047</td>\n",
       "      <td>&gt;GIGKFIHSAKKFGKLFVGEIMNS\\nGIGKFIHSAKKFGKLFVGEIMNS</td>\n",
       "      <td>120.seq</td>\n",
       "      <td>/data/AIpep/spiderData/120.seq</td>\n",
       "      <td>[C, H, H, H, H, H, H, H, H, H, H, H, H, H, H, ...</td>\n",
       "      <td>21</td>\n",
       "      <td>0.913043</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.086957</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>122</td>\n",
       "      <td>Magainin-2 [L6I][K11R][F16W]</td>\n",
       "      <td>nan</td>\n",
       "      <td>GIGKFIHSAKRFGRAWVGEIMNS</td>\n",
       "      <td>AMD</td>\n",
       "      <td>[Escherichia coli, Pseudomonas aeruginosa, Sta...</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.396087</td>\n",
       "      <td>1.303737</td>\n",
       "      <td>&gt;GIGKFIHSAKRFGRAWVGEIMNS\\nGIGKFIHSAKRFGRAWVGEIMNS</td>\n",
       "      <td>122.seq</td>\n",
       "      <td>/data/AIpep/spiderData/122.seq</td>\n",
       "      <td>[C, H, H, H, H, H, H, H, H, H, H, H, H, H, H, ...</td>\n",
       "      <td>21</td>\n",
       "      <td>0.913043</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.086957</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>124</td>\n",
       "      <td>Magainin-2 [L6G,H7K,S8A,K10A,K11H,A15K,F16W]</td>\n",
       "      <td>nan</td>\n",
       "      <td>GIAKFGKAAAHFGKKWVGELMNS</td>\n",
       "      <td>AMD</td>\n",
       "      <td>[Escherichia coli, Pseudomonas aeruginosa, Sta...</td>\n",
       "      <td>False</td>\n",
       "      <td>True</td>\n",
       "      <td>True</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.343913</td>\n",
       "      <td>1.262218</td>\n",
       "      <td>&gt;GIAKFGKAAAHFGKKWVGELMNS\\nGIAKFGKAAAHFGKKWVGELMNS</td>\n",
       "      <td>124.seq</td>\n",
       "      <td>/data/AIpep/spiderData/124.seq</td>\n",
       "      <td>[C, H, H, H, H, H, H, H, H, H, H, H, H, H, H, ...</td>\n",
       "      <td>21</td>\n",
       "      <td>0.913043</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.086957</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>129208</th>\n",
       "      <td>gen_gramneg_41446</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>wallktflklakilsaG</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>...</td>\n",
       "      <td>0.736471</td>\n",
       "      <td>1.226820</td>\n",
       "      <td>&gt;wallktflklakilsaG\\nwallktflklakilsaG</td>\n",
       "      <td>gen_gramneg_41446.seq</td>\n",
       "      <td>/data/AIpep/spiderData/gen_gramneg_41446.seq</td>\n",
       "      <td>[C, H, H, H, H, H, H, H, H, H, H, H, H, H, H, ...</td>\n",
       "      <td>15</td>\n",
       "      <td>0.882353</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.117647</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>129209</th>\n",
       "      <td>gen_gramneg_41447</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>GRWRWWWWRWRM</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>...</td>\n",
       "      <td>0.890833</td>\n",
       "      <td>1.428664</td>\n",
       "      <td>&gt;GRWRWWWWRWRM\\nGRWRWWWWRWRM</td>\n",
       "      <td>gen_gramneg_41447.seq</td>\n",
       "      <td>/data/AIpep/spiderData/gen_gramneg_41447.seq</td>\n",
       "      <td>[C, C, C, E, E, E, E, E, E, E, E, C]</td>\n",
       "      <td>0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.666667</td>\n",
       "      <td>0.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>129210</th>\n",
       "      <td>gen_gramneg_41448</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>GWRDTLSKVFPHSGEVIGLNAGSFYRAKHHH</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>...</td>\n",
       "      <td>0.336129</td>\n",
       "      <td>0.800447</td>\n",
       "      <td>&gt;GWRDTLSKVFPHSGEVIGLNAGSFYRAKHHH\\nGWRDTLSKVFPH...</td>\n",
       "      <td>gen_gramneg_41448.seq</td>\n",
       "      <td>/data/AIpep/spiderData/gen_gramneg_41448.seq</td>\n",
       "      <td>[C, H, H, H, H, H, H, H, H, C, C, C, C, C, C, ...</td>\n",
       "      <td>8</td>\n",
       "      <td>0.258065</td>\n",
       "      <td>0.129032</td>\n",
       "      <td>0.612903</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>129211</th>\n",
       "      <td>gen_gramneg_41449</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>GVFDIIKGAGKDLVIGATSLI</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>...</td>\n",
       "      <td>0.578571</td>\n",
       "      <td>0.217489</td>\n",
       "      <td>&gt;GVFDIIKGAGKDLVIGATSLI\\nGVFDIIKGAGKDLVIGATSLI</td>\n",
       "      <td>gen_gramneg_41449.seq</td>\n",
       "      <td>/data/AIpep/spiderData/gen_gramneg_41449.seq</td>\n",
       "      <td>[C, H, H, H, H, H, H, C, H, H, H, H, H, H, H, ...</td>\n",
       "      <td>17</td>\n",
       "      <td>0.809524</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.190476</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>129212</th>\n",
       "      <td>gen_gramneg_41450</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>KKVFKRLAKLWK</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>...</td>\n",
       "      <td>0.250833</td>\n",
       "      <td>2.487481</td>\n",
       "      <td>&gt;KKVFKRLAKLWK\\nKKVFKRLAKLWK</td>\n",
       "      <td>gen_gramneg_41450.seq</td>\n",
       "      <td>/data/AIpep/spiderData/gen_gramneg_41450.seq</td>\n",
       "      <td>[C, H, H, H, H, H, H, H, H, H, H, C]</td>\n",
       "      <td>10</td>\n",
       "      <td>0.833333</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.166667</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>129211 rows × 77 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                       ID                                          Name  \\\n",
       "0                     118                             Magainin-2 [F16W]   \n",
       "1                     119                  Magainin-2 [I2L][K11R][I20A]   \n",
       "2                     120                        Magainin-2 [L6I][A15L]   \n",
       "3                     122                  Magainin-2 [L6I][K11R][F16W]   \n",
       "4                     124  Magainin-2 [L6G,H7K,S8A,K10A,K11H,A15K,F16W]   \n",
       "...                   ...                                           ...   \n",
       "129208  gen_gramneg_41446                                           NaN   \n",
       "129209  gen_gramneg_41447                                           NaN   \n",
       "129210  gen_gramneg_41448                                           NaN   \n",
       "129211  gen_gramneg_41449                                           NaN   \n",
       "129212  gen_gramneg_41450                                           NaN   \n",
       "\n",
       "       N terminus                         Sequence C terminus  \\\n",
       "0             nan          GIGKFLHSAKKFGKAWVGEIMNS        AMD   \n",
       "1             nan          GLGKFLHSAKRFGKAFVGEAMNS        AMD   \n",
       "2             nan          GIGKFIHSAKKFGKLFVGEIMNS        AMD   \n",
       "3             nan          GIGKFIHSAKRFGRAWVGEIMNS        AMD   \n",
       "4             nan          GIAKFGKAAAHFGKKWVGELMNS        AMD   \n",
       "...           ...                              ...        ...   \n",
       "129208        NaN                wallktflklakilsaG        NaN   \n",
       "129209        NaN                     GRWRWWWWRWRM        NaN   \n",
       "129210        NaN  GWRDTLSKVFPHSGEVIGLNAGSFYRAKHHH        NaN   \n",
       "129211        NaN            GVFDIIKGAGKDLVIGATSLI        NaN   \n",
       "129212        NaN                     KKVFKRLAKLWK        NaN   \n",
       "\n",
       "                                            targetSpecies baumannii aureus  \\\n",
       "0       [Escherichia coli, Pseudomonas aeruginosa, Sta...     False   True   \n",
       "1       [Escherichia coli, Pseudomonas aeruginosa, Sta...     False   True   \n",
       "2       [Escherichia coli, Pseudomonas aeruginosa, Sta...     False   True   \n",
       "3       [Escherichia coli, Pseudomonas aeruginosa, Sta...     False   True   \n",
       "4       [Escherichia coli, Pseudomonas aeruginosa, Sta...     False   True   \n",
       "...                                                   ...       ...    ...   \n",
       "129208                                                NaN       NaN    NaN   \n",
       "129209                                                NaN       NaN    NaN   \n",
       "129210                                                NaN       NaN    NaN   \n",
       "129211                                                NaN       NaN    NaN   \n",
       "129212                                                NaN       NaN    NaN   \n",
       "\n",
       "       aeruginosa  activity  ... av_hydrophobicity discrimination  \\\n",
       "0            True       0.0  ...          0.393478       1.251559   \n",
       "1            True       0.0  ...          0.303478       1.260918   \n",
       "2            True       0.0  ...          0.438261       1.258047   \n",
       "3            True       0.0  ...          0.396087       1.303737   \n",
       "4            True       0.0  ...          0.343913       1.262218   \n",
       "...           ...       ...  ...               ...            ...   \n",
       "129208        NaN       NaN  ...          0.736471       1.226820   \n",
       "129209        NaN       NaN  ...          0.890833       1.428664   \n",
       "129210        NaN       NaN  ...          0.336129       0.800447   \n",
       "129211        NaN       NaN  ...          0.578571       0.217489   \n",
       "129212        NaN       NaN  ...          0.250833       2.487481   \n",
       "\n",
       "                                                    fasta  \\\n",
       "0       >GIGKFLHSAKKFGKAWVGEIMNS\\nGIGKFLHSAKKFGKAWVGEIMNS   \n",
       "1       >GLGKFLHSAKRFGKAFVGEAMNS\\nGLGKFLHSAKRFGKAFVGEAMNS   \n",
       "2       >GIGKFIHSAKKFGKLFVGEIMNS\\nGIGKFIHSAKKFGKLFVGEIMNS   \n",
       "3       >GIGKFIHSAKRFGRAWVGEIMNS\\nGIGKFIHSAKRFGRAWVGEIMNS   \n",
       "4       >GIAKFGKAAAHFGKKWVGELMNS\\nGIAKFGKAAAHFGKKWVGELMNS   \n",
       "...                                                   ...   \n",
       "129208              >wallktflklakilsaG\\nwallktflklakilsaG   \n",
       "129209                        >GRWRWWWWRWRM\\nGRWRWWWWRWRM   \n",
       "129210  >GWRDTLSKVFPHSGEVIGLNAGSFYRAKHHH\\nGWRDTLSKVFPH...   \n",
       "129211      >GVFDIIKGAGKDLVIGATSLI\\nGVFDIIKGAGKDLVIGATSLI   \n",
       "129212                        >KKVFKRLAKLWK\\nKKVFKRLAKLWK   \n",
       "\n",
       "               SpiderFilename                                 SpiderFileloc  \\\n",
       "0                     118.seq                /data/AIpep/spiderData/118.seq   \n",
       "1                     119.seq                /data/AIpep/spiderData/119.seq   \n",
       "2                     120.seq                /data/AIpep/spiderData/120.seq   \n",
       "3                     122.seq                /data/AIpep/spiderData/122.seq   \n",
       "4                     124.seq                /data/AIpep/spiderData/124.seq   \n",
       "...                       ...                                           ...   \n",
       "129208  gen_gramneg_41446.seq  /data/AIpep/spiderData/gen_gramneg_41446.seq   \n",
       "129209  gen_gramneg_41447.seq  /data/AIpep/spiderData/gen_gramneg_41447.seq   \n",
       "129210  gen_gramneg_41448.seq  /data/AIpep/spiderData/gen_gramneg_41448.seq   \n",
       "129211  gen_gramneg_41449.seq  /data/AIpep/spiderData/gen_gramneg_41449.seq   \n",
       "129212  gen_gramneg_41450.seq  /data/AIpep/spiderData/gen_gramneg_41450.seq   \n",
       "\n",
       "                                                       SS countH  \\\n",
       "0       [C, H, H, H, H, H, H, H, H, H, H, H, H, H, H, ...     21   \n",
       "1       [C, H, H, H, H, H, H, H, H, H, H, H, H, H, H, ...     20   \n",
       "2       [C, H, H, H, H, H, H, H, H, H, H, H, H, H, H, ...     21   \n",
       "3       [C, H, H, H, H, H, H, H, H, H, H, H, H, H, H, ...     21   \n",
       "4       [C, H, H, H, H, H, H, H, H, H, H, H, H, H, H, ...     21   \n",
       "...                                                   ...    ...   \n",
       "129208  [C, H, H, H, H, H, H, H, H, H, H, H, H, H, H, ...     15   \n",
       "129209               [C, C, C, E, E, E, E, E, E, E, E, C]      0   \n",
       "129210  [C, H, H, H, H, H, H, H, H, C, C, C, C, C, C, ...      8   \n",
       "129211  [C, H, H, H, H, H, H, C, H, H, H, H, H, H, H, ...     17   \n",
       "129212               [C, H, H, H, H, H, H, H, H, H, H, C]     10   \n",
       "\n",
       "        fraction_PredHelical fraction_PredBetaSheet  fraction_PredCoil  \n",
       "0                   0.913043               0.000000           0.086957  \n",
       "1                   0.869565               0.000000           0.130435  \n",
       "2                   0.913043               0.000000           0.086957  \n",
       "3                   0.913043               0.000000           0.086957  \n",
       "4                   0.913043               0.000000           0.086957  \n",
       "...                      ...                    ...                ...  \n",
       "129208              0.882353               0.000000           0.117647  \n",
       "129209              0.000000               0.666667           0.333333  \n",
       "129210              0.258065               0.129032           0.612903  \n",
       "129211              0.809524               0.000000           0.190476  \n",
       "129212              0.833333               0.000000           0.166667  \n",
       "\n",
       "[129211 rows x 77 columns]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_all.to_pickle(folder+\"pickles/all_sequences_with_NN_prop_helicity-hem.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}