NegativeSamplingExperiments.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generating negative samples based on scoring gradients\n",
    "\n",
    "\\> Generating negative samples based target swapping on top FIRE or SAE difference magnitudes creates nonexistant specificity for the RPI107 evaluation set <br/>\n",
    "\\> Hypothesize that this is because generated negative samples are too obvious, which causes model to fail on edge cases <br/>\n",
    "\\> To test, we'll be generating negative samples based on gradiented FIRE/SAE difference magnitue scores <br/>\n",
    "\\> Seperate out into bins based on percentile and sampling different proportions from each sample <br/>\n",
    "\\> These will then be used to train models and observe performce differences on RPI1807 evaluation set <br/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Generate difference vectors between protein pairs\n",
    "# 2. Generate negative sampling distributor AND max/min sampling\n",
    "#### 3. Generate default hyperparameters for each model\n",
    "# 4. Load each model using default parameters\n",
    "# 5. Train models using each negative sampling method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5:\n",
    "# load models w/ default parameters\n",
    "# load positive samples\n",
    "# generate negative samples w/ distribution & Extreme sampler\n",
    "# "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bobby/anaconda3/envs/NegativeSampling/lib/python3.8/site-packages/gensim/similarities/__init__.py:15: UserWarning: The gensim.similarities.levenshtein submodule is disabled, because the optional Levenshtein package <https://pypi.org/project/python-Levenshtein/> is unavailable. Install Levenhstein (e.g. `pip install python-Levenshtein`) to suppress this warning.\n",
      "  warnings.warn(msg)\n",
      "/home/bobby/anaconda3/envs/NegativeSampling/lib/python3.8/site-packages/sklearn/utils/deprecation.py:143: FutureWarning: The sklearn.utils.testing module is  deprecated in version 0.22 and will be removed in version 0.24. The corresponding classes / functions should instead be imported from sklearn.utils. Anything that cannot be imported from sklearn.utils is now part of the private API.\n",
      "  warnings.warn(message, FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "sys.path.append(\"..\")\n",
    "\n",
    "import pandas as pd\n",
    "from transformers import AutoTokenizer, AutoModel\n",
    "\n",
    "import torch\n",
    "from torch.utils.data import WeightedRandomSampler\n",
    "\n",
    "from tqdm.notebook import tqdm\n",
    "\n",
    "from sklearn.preprocessing import KBinsDiscretizer\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "import fastai\n",
    "from fastai.basics import Learner, DataLoaders\n",
    "from fastai.vision.all import *\n",
    "from fastai.callback.all import *\n",
    "\n",
    "import seaborn as sbn\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# # DistributionSampler\n",
    "from Utils.negative_sampling import IterableProteinEmbedding, magnitude\n",
    "from Utils.misc import filter_sequences_by_len_from_fasta\n",
    "from Utils.encoders import SkipGramEmbedder\n",
    "\n",
    "from lazypredict.Supervised import LazyClassifier\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods overview\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "SAVE = True\n",
    "SAMPLING_DISTRIBUTIONS = dict()\n",
    "\n",
    "############################################\n",
    "# Exclusive max sampling\n",
    "############################################\n",
    "\n",
    "# fig, axes = plt.subplots(3,4,figsize = (5.5,6))\n",
    "\n",
    "XTICKS = [1, 5, 10]\n",
    "XLIM = range(1,11)\n",
    "\n",
    "data = [1] + [0]*9\n",
    "\n",
    "# print(data)\n",
    "# print(data[::-1])\n",
    "# axes[0,0].bar(x = XLIM, height = data)\n",
    "# axes[0,0].set_title(\"Lowest\\nscores\")\n",
    "\n",
    "# axes[0,1].bar(x = XLIM, height = data[::-1])\n",
    "# axes[0,1].set_title(\"Highest\\nscores\")\n",
    "\n",
    "SAMPLING_DISTRIBUTIONS['lowest'] = data\n",
    "SAMPLING_DISTRIBUTIONS['highest']  = data[::-1]\n",
    "\n",
    "############################################\n",
    "# Uniform distribution\n",
    "############################################\n",
    "\n",
    "data = [.10]*10\n",
    "# print(data)\n",
    "\n",
    "# axes[0,2].bar(x =XLIM, height = data)\n",
    "# axes[0,2].set_title(\"Uniformly\\ndistributed\")\n",
    "\n",
    "SAMPLING_DISTRIBUTIONS['uniform']  = data\n",
    "\n",
    "############################################\n",
    "# Exponential distributions\n",
    "############################################\n",
    "\n",
    "x = 1\n",
    "data = list()\n",
    "for _ in range(10):\n",
    "    x /= 2\n",
    "    data.append(round(x,4))\n",
    "\n",
    "data[6] = 0.0088\n",
    "\n",
    "# print(data)\n",
    "# print(data[::-1])\n",
    "# axes[0,3].bar(x = XLIM, height = data)\n",
    "# axes[0,3].set_title(\"Exponentially\\ndistributed (low)\")\n",
    "\n",
    "# axes[1,0].bar(x = XLIM, height = data[::-1])\n",
    "# axes[1,0].set_title(\"Exponentially\\ndistributed (high)\")\n",
    "\n",
    "SAMPLING_DISTRIBUTIONS['expoential_low']   = data\n",
    "SAMPLING_DISTRIBUTIONS['expoential_high']  = data[::-1]\n",
    "\n",
    "############################################\n",
    "# Normal distribution\n",
    "############################################\n",
    "\n",
    "x = .5\n",
    "data = list()\n",
    "for _ in range(5):\n",
    "    x /= 2\n",
    "    data.append(round(x,6))\n",
    "\n",
    "# Just to make it sum to 100%, converting 0.125 --> 0.0088\n",
    "data[1] = 0.140625\n",
    "    \n",
    "data = data[::-1] + data\n",
    "\n",
    "# print(data)\n",
    "\n",
    "# axes[1,1].bar(x = XLIM, height = data)\n",
    "# axes[1,1].set_title(\"Normally\\ndistributed\")\n",
    "\n",
    "SAMPLING_DISTRIBUTIONS['normal'] = data\n",
    "\n",
    "####################################################\n",
    "# Normal distribution (slightly shifted and skewed)\n",
    "####################################################\n",
    "\n",
    "data = [ 0.0625, 0.140625, 0.30, 0.25, 0.125, .0625, 0.03125, .015, .008, .006-.000875]\n",
    "# print(data)\n",
    "# print(data[::-1])\n",
    "# axes[1,2].bar(x = XLIM, height = data)\n",
    "# axes[1,2].set_title(\"Slight\\nright skew\")\n",
    "\n",
    "# axes[1,3].bar(x = XLIM, height = data[::-1])\n",
    "# axes[1,3].set_title(\"Slight\\nleft skew\")\n",
    "\n",
    "SAMPLING_DISTRIBUTIONS['slight_right_skew'] = data\n",
    "SAMPLING_DISTRIBUTIONS['slight_left_skew']  = data[::-1]\n",
    "\n",
    "############################################\n",
    "# Normal distribution (major shift and skew)\n",
    "############################################\n",
    "\n",
    "data = [0.25, 0.30, 0.22, 0.11, 0.06, 0.03,0.015,0.01,0.004,0.001]\n",
    "\n",
    "# print(data)\n",
    "# print(data[::-1])\n",
    "# axes[2,0].bar(x = XLIM, height = data)\n",
    "# axes[2,0].set_title(\"Major\\nright skew\")\n",
    "\n",
    "# axes[2,1].bar(x = XLIM, height = data[::-1])\n",
    "# axes[2,1].set_title(\"Major\\nleft skew\")\n",
    "\n",
    "SAMPLING_DISTRIBUTIONS['major_right_skew'] = data\n",
    "SAMPLING_DISTRIBUTIONS['major_left_skew']  = data[::-1]\n",
    "\n",
    "########################################################\n",
    "# Figure Aesthetics\n",
    "########################################################\n",
    "FONTSIZE = 12\n",
    "\n",
    "# plt.setp(axes, xticks = [1,5,10], xticklabels = XTICKS)\n",
    "# sbn.despine()\n",
    "\n",
    "# axes[2,2].remove()\n",
    "# axes[2,3].remove()\n",
    "\n",
    "# plt.tight_layout()\n",
    "\n",
    "# if SAVE:\n",
    "#     plt.savefig(\"negative_gradient_sampling_strategies.png\", dpi = 300, bbox_inches = \"tight\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig,ax = plt.subplots(1,1,figsize=(6,4))\n",
    "\n",
    "t = np.array([weights for weights in SAMPLING_DISTRIBUTIONS.values()])\n",
    "\n",
    "sbn.heatmap(t, cmap = \"Purples\", \n",
    "            vmax = 0.4,\n",
    "            annot = t, fmt=\".2f\",\n",
    "            cbar_kws={\"label\" : \"Bin weights\"})\n",
    "\n",
    "ax.set_xlabel(\"Magnitude bin\")\n",
    "\n",
    "ax.set_yticklabels([weights.replace(\"_\",\" \") for weights in SAMPLING_DISTRIBUTIONS.keys()], rotation = 0);\n",
    "\n",
    "# If percentage is less than 0.10, set text to be invisible\n",
    "for text in ax.texts:\n",
    "    if float(text.get_text()) < 0.10:\n",
    "        text.set_visible(False)\n",
    "\n",
    "# Remove bottom and left ticks\n",
    "ax.tick_params(left=False, bottom=False)\n",
    "        \n",
    "plt.tight_layout()\n",
    "plt.savefig(\"NegativeSamplingBinWeights.png\", dpi = 300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load data and take difference magnitudes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_all_combos(list1, list2, list_limit = None):\n",
    "    \"\"\"\n",
    "    Returns all combinations of items in two input lists\n",
    "    \n",
    "    ex)\n",
    "    ---\n",
    "    >>> x = [1,2,3]\n",
    "    >>> y = ['x','y']\n",
    "    >>> generate_all_combos(x,y)\n",
    "    [(1, 'x'), (1, 'y'), (2, 'x'), (2, 'y'), (3, 'x'), (3, 'y')]\n",
    "    \"\"\"\n",
    "    return [(i,j) for i in list1[:list_limit] for j in list2[:list_limit]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load swissprot and RNAInter\n",
    "# Take all protein combos\n",
    "\n",
    "from Bio import SeqIO\n",
    "\n",
    "# SWISS_PATH = \"../Data/RawData/uniprot_sprot.fasta\"\n",
    "\n",
    "reduced_positive_df = pd.read_csv(\"../Data/TrainingData/PositiveSamples/reduced_RNAInter_small_interactions_current.csv\")\n",
    "\n",
    "# with open(SWISS_PATH) as handle:\n",
    "#     swiss_fasta = [record for record in SeqIO.parse(handle, 'fasta') if len(record.seq) <= 110]\n",
    "\n",
    "# swiss = [\" \".join(protein) for protein in filter_sequences_by_len_from_fasta(SWISS_PATH, 110)]\n",
    "# reduced_positive_prot_seqs = "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4876"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(reduced_positive_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RNAInterIDConverter:\n",
    "    \"\"\"\n",
    "    RNAInterIDConverter is designed to X\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, seed):\n",
    "        self.seed = seed\n",
    "        self._taken_names = list()\n",
    "    \n",
    "    def clear_taken_names(self):\n",
    "        self._taken_names = list()\n",
    "    \n",
    "    def get_uniprot_id_from_seq(self, df, protein_seq):\n",
    "        return df[df['proteins'] == protein_seq]['UniprotID'].iloc[0]\n",
    "    \n",
    "    def get_random_rna_id(self, rna_names : pd.Series):\n",
    "        shuffled_names = rna_names.sample(frac = 1, random_state = self.seed)\n",
    "        \n",
    "        for i in range(len(shuffled_names)):\n",
    "            \n",
    "            if shuffled_names.iloc[i] not in self._taken_names:\n",
    "                name = shuffled_names.iloc[i]\n",
    "                self._taken_names.append(name)\n",
    "                return name\n",
    "            \n",
    "            # If it's the final entry, just use that\n",
    "            elif i == len(shuffled_names)-1:\n",
    "                return shuffled_names.iloc[i]\n",
    "        \n",
    "    def get_rna_id_from_seq(self, df, seq):\n",
    "        self.clear_taken_names()\n",
    "        rna_ids = df[df['proteins'] == seq]['RNA_Name']\n",
    "        random_rna_id = self.get_random_rna_id(rna_ids)\n",
    "        return random_rna_id\n",
    "        \n",
    "    def get_rna_and_unirpot_id_from_seq(self, df, seq):\n",
    "        return (self.get_uniprot_id_from_seq(df, seq), self.get_rna_id_from_seq(df, seq))\n",
    "    \n",
    "    def get_unique_protein_uniprot_ids_and_rna_pair_from_df(self, df : pd.DataFrame):\n",
    "        unique_seqs    = df['proteins'].unique()\n",
    "        unique_protein_ids = [self.get_rna_and_unirpot_id_from_seq(df, protein_seq) for protein_seq in unique_seqs]\n",
    "        return unique_protein_ids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "rnainter_idconverter = RNAInterIDConverter(seed = 255)\n",
    "rnainter_protein_rna_pairs = rnainter_idconverter.get_unique_protein_uniprot_ids_and_rna_pair_from_df(reduced_positive_df)\n",
    "uniprot2rnaname = dict(rnainter_protein_rna_pairs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RNAInterRNACovnerter:\n",
    "    \"\"\"\n",
    "    Generates the dictionary that converts RNA names to\n",
    "    their encoded sequences\n",
    "    \"\"\"\n",
    "    \n",
    "    def encode_sequences(self, rna_seqs, embedder):\n",
    "        return embedder(rna_seqs)\n",
    "    \n",
    "    def generate_rna_name_to_embedded_seq_converter(self, rna_names, embedded_seqs):\n",
    "        return dict(zip(rna_names, embedded_seqs))\n",
    "    \n",
    "    def generate_rna_name_to_encoded_tensor_dict(self, rna_names, rna_seqs, embedder):\n",
    "        embedded_seqs  = self.encode_sequences(rna_seqs, embedder)\n",
    "        converter_dict = self.generate_rna_name_to_embedded_seq_converter(rna_names, embedded_seqs)\n",
    "        return converter_dict\n",
    "    \n",
    "    def find_rna_seq_from_name(self, rna_name, df):\n",
    "        return df[df['RNA_Name'] == rna_name]['rnas'].iloc[0]\n",
    "    \n",
    "    def return_rna_seqs_from_names(self, rna_names, df):\n",
    "        return [self.find_rna_seq_from_name(rna_name, df) for rna_name in rna_names]\n",
    "    \n",
    "    def generate_rna_name_to_encoded_tensor_dict_from_df(self, rna_names, df, embedder):\n",
    "        rna_seqs       = self.return_rna_seqs_from_names(rna_names, df)\n",
    "        # print(list(rna_seqs))\n",
    "        converter_dict = self.generate_rna_name_to_encoded_tensor_dict(rna_names, list(rna_seqs), embedder)\n",
    "        return converter_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "rnainter_rna_to_tensor_converter = RNAInterRNACovnerter()\n",
    "\n",
    "rna_embedder = SkipGramEmbedder(\"../SeqEmbedders/GensimWord2Vec/RNA2Vec_1024_hidden.model\", reduce = True)\n",
    "rna_embedder_2d = SkipGramEmbedder(\"../SeqEmbedders/GensimWord2Vec/RNA2Vec_1024_hidden.model\", reduce = False, outsize = 100)\n",
    "\n",
    "rnaname2tensor = rnainter_rna_to_tensor_converter.generate_rna_name_to_encoded_tensor_dict_from_df(uniprot2rnaname.values(), reduced_positive_df, rna_embedder)\n",
    "rnaname2tensor_2d = rnainter_rna_to_tensor_converter.generate_rna_name_to_encoded_tensor_dict_from_df(uniprot2rnaname.values(), reduced_positive_df, rna_embedder_2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#########\n",
    "# 2D test?\n",
    "#########\n",
    "# rna_embedder_2d = SkipGramEmbedder(\"../SeqEmbedders/GensimWord2Vec/RNA2Vec_1024_hidden.model\", reduce = False)\n",
    "# rnaname2tensor = rnainter_rna_to_tensor_converter.generate_rna_name_to_encoded_tensor_dict_from_df(uniprot2rnaname.values(), reduced_positive_df, rna_embedder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SwissIdCovnerter:\n",
    "    \"\"\"\n",
    "    Generates the dictionary that converts Swiss names to\n",
    "    their encoded sequences\n",
    "    \"\"\"\n",
    "    \n",
    "    def encode_sequences(self, rna_seqs, embedder):\n",
    "        return embedder(rna_seqs)\n",
    "    \n",
    "    def generate_rna_name_to_embedded_seq_converter(self, rna_names, embedded_seqs):\n",
    "        return dict(zip(rna_names, embedded_seqs))\n",
    "    \n",
    "    def generate_rna_name_to_encoded_tensor_dict(self, rna_names, rna_seqs, embedder):\n",
    "        embedded_seqs  = self.encode_sequences(rna_seqs, embedder)\n",
    "        converter_dict = self.generate_rna_name_to_embedded_seq_converter(rna_names, embedded_seqs)\n",
    "        return converter_dict\n",
    "    \n",
    "    def find_rna_seq_from_name(self, rna_name, df):\n",
    "        return df[df['RNA_Name'] == rna_name]['rnas'].iloc[0]\n",
    "    \n",
    "    def return_rna_seqs_from_names(self, rna_names, df):\n",
    "        return [self.find_rna_seq_from_name(rna_name, df) for rna_name in rna_names]\n",
    "    \n",
    "    def generate_swiss_name_to_encoded_tensor_dict_from_df(self, rna_names, df, embedder):\n",
    "        rna_seqs       = self.return_rna_seqs_from_names(rna_names, df)\n",
    "        # print(list(rna_seqs))\n",
    "        converter_dict = self.generate_rna_name_to_encoded_tensor_dict(rna_names, list(rna_seqs), embedder)\n",
    "        return converter_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "unique_proteins = reduced_positive_df['proteins'].unique()\n",
    "# unique_proteins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1497, 13)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = reduced_positive_df.groupby(\"rnas\").first()\n",
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "292\n",
      "292\n"
     ]
    }
   ],
   "source": [
    "grouped_df = reduced_positive_df.groupby(\"proteins\").first()\n",
    "first_values = grouped_df.reset_index()\n",
    "\n",
    "unique_reduced_rnainter_uniprot_ids = first_values['UniprotID'].unique()\n",
    "unique_proteins = first_values['proteins']\n",
    "\n",
    "print(len(unique_reduced_rnainter_uniprot_ids))\n",
    "print(len(unique_proteins))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# unique_proteins.apply(lambda x: \"\".join(x))[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at Rostlab/prot_bert_bfd were not used when initializing BertModel: ['cls.predictions.transform.LayerNorm.weight', 'cls.predictions.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.seq_relationship.weight', 'cls.predictions.decoder.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.dense.weight', 'cls.seq_relationship.bias']\n",
      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'swiss' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-dee5ec1025dd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mtokenizer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mAutoTokenizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_pretrained\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Rostlab/prot_bert_bfd\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdo_lower_case\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mswiss_embedder\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mIterableProteinEmbedding\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mswiss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtokenizer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchunksize\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmax_len\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m110\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcuda\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;31m# Need sorted set to make a reproducable set initialization for redoing stuff\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'swiss' is not defined"
     ]
    }
   ],
   "source": [
    "# proteins, tokenizer, model, chunksize, max_len, cuda = True):\n",
    "model     = AutoModel.from_pretrained(\"Rostlab/prot_bert_bfd\")\n",
    "tokenizer = AutoTokenizer.from_pretrained(\"Rostlab/prot_bert_bfd\", do_lower_case = False)\n",
    "\n",
    "swiss_embedder = IterableProteinEmbedding(swiss, tokenizer, model, chunksize = 3, max_len = 110, cuda = True)\n",
    "\n",
    "# Need sorted set to make a reproducable set initialization for redoing stuff\n",
    "from Utils.encoders import ProtBERTEmbedder\n",
    "from Utils.encoders import ProtBERTEmbedder\n",
    "\n",
    "rnainter_prot_embedder = ProtBERTEmbedder(112,True)\n",
    "print(rnainter_prot_embedder.model.training)\n",
    "\n",
    "rnainter_prot_embedder_2d = IterableProteinEmbedding(unique_proteins, tokenizer, model, chunksize = 3, max_len = 110, reduce = False, cuda = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "swiss_ids = [swiss_id[0] for swiss_id in np.load(\"../Data/EncodedData/reduced_ProtBERT_encoded_110_swissprot_v2_names.npy\")]\n",
    "swiss_ids_2d = [swiss_id for swiss_id in np.load(\"../Data/EncodedData/reduced_ProtBERT_2dim_encoded_110_swissprot_names.npy\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "# x\n",
    "SWISS_EMBEDDED_PATH = \"../Data/EncodedData/reduced_ProtBERT_encoded_110_swissprot_v2.pt\"\n",
    "SWISS_EMBEDDED_PATH_2D =  \"../Data/EncodedData/reduced_ProtBERT_2dim_encoded_110_swissprot.pt\"\n",
    "\n",
    "if not os.path.exists(SWISS_EMBEDDED_PATH):\n",
    "    with torch.no_grad():\n",
    "        swiss_embedded = torch.cat([i for i in swiss_embedder])\n",
    "    torch.save(swiss_embedded, SWISS_EMBEDDED_PATH)\n",
    "else:\n",
    "    swiss_embedded = torch.load(SWISS_EMBEDDED_PATH)\n",
    "    \n",
    "\n",
    "# swiss_embedded_2d = torch.load(SWISS_EMBEDDED_PATH_2D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([9164, 1024])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "swiss_embedded.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9164"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(swiss_ids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Swiss uniptot IDs linked to their corresponding tensors\n",
    "swiss2tensor = dict(zip(swiss_ids, swiss_embedded))\n",
    "# swiss2tensor_2d = dict(zip(swiss_ids_2d, swiss_embedded_2d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rnainter_embedded = torch.cat([i for i in rnainter_prot_embedder])\n",
    "# rnainter_embedded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# len(rnainter_embedded) == len(reduced_positive_df['proteins'].unique())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ComboDifferenceIterator:\n",
    "    \"\"\"\n",
    "    \n",
    "    \"\"\"\n",
    "    def __init__(self, seq_matrix1, seq_matrix2, model, chunksize, limit = None):\n",
    "        self.seq_matrix1 = seq_matrix1\n",
    "        self.seq_matrix2 = seq_matrix2\n",
    "        self.model = model\n",
    "        \n",
    "        assert chunksize > 1, f\"ComboIterator fails when chunksize is less than 2. recieved chunksize: {chunksize}\"\n",
    "        self.chunksize = chunksize\n",
    "        self.limit = limit\n",
    "    \n",
    "    def _format_matrix_for_sae_diff(self, combo):\n",
    "        return torch.stack(combo)\n",
    "    \n",
    "    def format_combos_for_sae_diff(self, combos):\n",
    "        combo1, combo2 = zip(*combos)\n",
    "        combo1 = self._format_matrix_for_sae_diff(combo1)\n",
    "        combo2 = self._format_matrix_for_sae_diff(combo2)\n",
    "        return combo1, combo2\n",
    "    \n",
    "    def __iter__(self):\n",
    "        \n",
    "        combos = generate_all_combos(self.seq_matrix1, self.seq_matrix2, list_limit = self.limit)\n",
    "        \n",
    "        for i in tqdm(range(0,len(combos),self.chunksize)):\n",
    "            combo1, combo2 = self.format_combos_for_sae_diff(combos[i:i+self.chunksize])\n",
    "            \n",
    "            reduced_combo1 = self.model(combo1)\n",
    "            reduced_combo2 = self.model(combo2)\n",
    "            \n",
    "            combo_len = len(reduced_combo1)\n",
    "            \n",
    "            difference_magnitude = magnitude(reduced_combo1 - reduced_combo2).reshape(combo_len, 1)\n",
    "            \n",
    "            yield difference_magnitude"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "SAE_DIR  = '/data/Chapter_3/Notebooks'\n",
    "rna_sae  = torch.load(f\"{SAE_DIR}/rnavec_encoded_aggregated_u_t_swapped_rnas_DenseSAE.pt\")\n",
    "prot_sae = torch.load(f\"{SAE_DIR}/ProtBERT_encoded_110_swissprot_DenseSAE.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'rnainter_embedded' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-26-9c0fd400dcad>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprotein_combo_iterator\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mComboDifferenceIterator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrnainter_embedded\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mswiss_embedded\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprot_sae\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'rnainter_embedded' is not defined"
     ]
    }
   ],
   "source": [
    "protein_combo_iterator = ComboDifferenceIterator(rnainter_embedded, swiss_embedded.cuda(), prot_sae.cuda(), 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "DIFFERENCE_MATRIX = \"../Data/EncodedData/Difference_Magnitude_ProtBERT_encoded_110_swissprot_v2_and_Unique_RNAInter_Proteins.pt\"\n",
    "\n",
    "if not os.path.exists(DIFFERENCE_MATRIX):\n",
    "    protein_combo_magnitudes = torch.cat([i for i in protein_combo_iterator])\n",
    "    torch.save(protein_combo_magnitudes, DIFFERENCE_MATRIX)\n",
    "else:\n",
    "    protein_combo_magnitudes = torch.load(DIFFERENCE_MATRIX)\n",
    "\n",
    "# protein_combo_magnitudes = torch.cat([i for i in protein_combo_iterator])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([2675888, 1])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "protein_combo_magnitudes.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2675888"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "combo_ids = generate_all_combos(unique_reduced_rnainter_uniprot_ids, swiss_ids)\n",
    "len(combo_ids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "bin_assigner = KBinsDiscretizer(n_bins=10, encode='ordinal')\n",
    "bins         = bin_assigner.fit_transform(protein_combo_magnitudes.cpu()).squeeze().astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_bin_and_diff_magnitudes(bins, protein_combo_magnitudes, ax):\n",
    "    sbn.boxplot(x = bins, y = np.array( protein_combo_magnitudes.cpu().squeeze()), showfliers = False, \n",
    "                linewidth = 1.3, ax = ax)\n",
    "    ax.set_ylabel(\"Difference magnitude\")\n",
    "    ax.set_xlabel(\"Bins\")\n",
    "\n",
    "def plot_combo_magnitude_dist(protein_combo_magnitudes, ax):\n",
    "    sbn.histplot(protein_combo_magnitudes.cpu(), legend = False, ax = ax)\n",
    "    ax.set_xlabel(\"Difference magnitude\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig,axes = plt.subplots(1,2, figsize = (6,3))\n",
    "\n",
    "# sbn.boxplot(x = bins, y = np.array( protein_combo_magnitudes.cpu().squeeze()), ax = axes[0])\n",
    "# sbn.histplot(protein_combo_magnitudes.cpu(), legend = False, ax = axes[1])\n",
    "\n",
    "# axes[0].set_ylabel(\"Difference magnitude\")\n",
    "# axes[0].set_xlabel(\"Bins\")\n",
    "# axes[1].set_xlabel(\"Difference magnitude\")\n",
    "\n",
    "plot_bin_and_diff_magnitudes(bins, protein_combo_magnitudes, axes[0])\n",
    "plot_combo_magnitude_dist(protein_combo_magnitudes, axes[1])\n",
    "\n",
    "plt.tight_layout()\n",
    "sbn.despine()\n",
    "\n",
    "plt.savefig(\"bin_and_diff_magnitude.png\",dpi = 300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sample protein pairs using difference magnitudes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NegativeSampleIdxGenerator():\n",
    "    \"\"\"\n",
    "    NegativeSampleIdxGenerator is used to assign negative sample \n",
    "    indeces using assigned bins and bin weights. This is meant \n",
    "    to be used for protein difference vector magnitudes, but can \n",
    "    be applied for any dataset that is assigned into bins and\n",
    "    have bin weights.Can be used on its own, but is primarily \n",
    "    intended to be used within the <TBD> class. \n",
    "    \n",
    "    It has two main functions:\n",
    "    \n",
    "    ####################################################\n",
    "    generate_negative_sample_idxs_from_sample_weights\n",
    "    ####################################################\n",
    "    This will generate a list of negative indecies from a list\n",
    "    of weights from each sample and a number of desired samples\n",
    "    \n",
    "    ###########################################\n",
    "    generate_negative_sample_idxs_from_bins\n",
    "    ###########################################\n",
    "    This will generate a list of negative indecies using a list of\n",
    "    bins that each sample is in, each bin's specific weight, and a\n",
    "    number of desired samples. This converts each sample's bin\n",
    "    assignment into a sample weight where the \n",
    "    generate_negative_sample_idxs_from_sample_weights method is\n",
    "    then run\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, seed):\n",
    "        self.seed = seed\n",
    "    \n",
    "    def _generate_weight_assigner(self, bin_weights):\n",
    "        return dict(zip(range(len(bin_weights)), bin_weights))\n",
    "    \n",
    "    def _convert_bins_to_weights(self, bins, bin_weights):\n",
    "        weight_assigner = self._generate_weight_assigner(bin_weights)\n",
    "        sample_weights = pd.Series(bins).apply(lambda x: weight_assigner[x])\n",
    "        return sample_weights\n",
    "    \n",
    "    def generate_negative_sample_idxs_from_sample_weights(self, sample_weights, sample_count):\n",
    "        torch.manual_seed(self.seed)\n",
    "        negative_pair_idx = list(WeightedRandomSampler(sample_weights, sample_count, replacement=False))\n",
    "        return negative_pair_idx\n",
    "    \n",
    "    def generate_negative_sample_idxs_from_bins(self, bins, bin_weights, sample_count):\n",
    "        sample_weights = self._convert_bins_to_weights(bins, bin_weights)\n",
    "        negative_pair_idx = self.generate_negative_sample_idxs_from_sample_weights(sample_weights, sample_count)\n",
    "        return negative_pair_idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['lowest', 'highest', 'uniform', 'expoential_low', 'expoential_high', 'normal', 'slight_right_skew', 'slight_left_skew', 'major_right_skew', 'major_left_skew'])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SAMPLING_DISTRIBUTIONS.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 0, 0, 0, 0, 0, 0, 0, 1]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SAMPLING_DISTRIBUTIONS['highest']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def get_rna_partner_from_rnainter_uniprot_id(uniprot_id : str) -> torch.tensor:\n",
    "    rna_partner_name = uniprot2rnaname[uniprot_id]\n",
    "    # encoded_rna_partner = rnaname2tensor[rna_partner_name] # 1Dim\n",
    "    encoded_rna_partner = rnaname2tensor_2d[rna_partner_name] # 2Dim\n",
    "    return encoded_rna_partner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_new_encoded_swiss_partner_from_rnainter_uniprot_id(rnainter_swiss_id_pair: tuple) -> torch.tensor:\n",
    "    _, swiss_id = rnainter_swiss_id_pair\n",
    "    # encoded_swiss_seq = swiss2tensor[swiss_id] # 1Dim\n",
    "    encoded_swiss_seq = swiss2tensor_2d[swiss_id] #2Dim\n",
    "    return encoded_swiss_seq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_positive_samples(df, rna_embedder, reduce = True):\n",
    "    model     = AutoModel.from_pretrained(\"Rostlab/prot_bert_bfd\")\n",
    "    tokenizer = AutoTokenizer.from_pretrained(\"Rostlab/prot_bert_bfd\", do_lower_case = False)\n",
    "\n",
    "    rnainter_prot_embedder = IterableProteinEmbedding(df['proteins'], tokenizer, model, chunksize = 3, max_len = 110, reduce = reduce, cuda = True)\n",
    "    encoded_rnainter_prots = torch.cat([encoded_prot for encoded_prot in rnainter_prot_embedder])\n",
    "\n",
    "    encoded_rnainter_rnas = rna_embedder(df['rnas'])\n",
    "    interaction = torch.ones(len(df))\n",
    "\n",
    "    return encoded_rnainter_prots, encoded_rnainter_rnas, interaction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from Bio import SeqIO\n",
    "\n",
    "def generate_swiss2seq(negative_pairs, swiss_path):\n",
    "    _, neg_swiss_ids = zip(*negative_pairs)\n",
    "    neg_swiss_ids = set(swiss_ids)\n",
    "    \n",
    "    with open(swiss_path) as handle:\n",
    "        swiss2seq = {record.description.split(\"|\")[1] : \" \".join(list(record.seq)) for record in SeqIO.parse(handle, 'fasta') if record.description.split(\"|\")[1] in neg_swiss_ids}\n",
    "        \n",
    "    return swiss2seq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_negative_samples(negative_pairs, reduce):\n",
    "    encoded_rnas = list()\n",
    "    encoded_swiss_prots = list()\n",
    "    non_interaction = torch.zeros(len(negative_pairs))\n",
    "    \n",
    "    for negative_pair in negative_pairs:\n",
    "\n",
    "        encoded_rna = get_rna_partner_from_rnainter_uniprot_id(negative_pair[0])\n",
    "        encoded_rnas.append(encoded_rna)\n",
    "\n",
    "    model     = AutoModel.from_pretrained(\"Rostlab/prot_bert_bfd\")\n",
    "    tokenizer = AutoTokenizer.from_pretrained(\"Rostlab/prot_bert_bfd\", do_lower_case = False)\n",
    "    \n",
    "    _, swiss_ids = zip(*negative_pairs)\n",
    "    SWISS_PATH = \"../Data/RawData/uniprot_sprot.fasta\"\n",
    "    swiss2seq = generate_swiss2seq(negative_pairs, SWISS_PATH)\n",
    "    \n",
    "    seqs = [swiss2seq[swiss_id] for swiss_id in swiss_ids]\n",
    "    neg_swiss_embedder = IterableProteinEmbedding(seqs, tokenizer, model, chunksize = 3, max_len = 110, reduce = reduce, cuda = True)\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        encoded_swiss_prots = torch.cat(list(neg_swiss_embedder))\n",
    "\n",
    "    encoded_rnas = torch.stack(encoded_rnas)\n",
    "    # encoded_swiss_prots = torch.stack(encoded_swiss_prots)\n",
    "    \n",
    "    return encoded_swiss_prots, encoded_rnas, non_interaction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_positive_samples(df, rna_embedder, reduce = True):\n",
    "    model     = AutoModel.from_pretrained(\"Rostlab/prot_bert_bfd\")\n",
    "    tokenizer = AutoTokenizer.from_pretrained(\"Rostlab/prot_bert_bfd\", do_lower_case = False)\n",
    "\n",
    "    rnainter_prot_embedder = IterableProteinEmbedding(df['proteins'], tokenizer, model, chunksize = 3, max_len = 110, reduce = reduce, cuda = True)\n",
    "    encoded_rnainter_prots = torch.cat([encoded_prot for encoded_prot in rnainter_prot_embedder])\n",
    "\n",
    "    encoded_rnainter_rnas = rna_embedder(df['rnas'])\n",
    "    interaction = torch.ones(len(df))\n",
    "\n",
    "    return encoded_rnainter_prots, encoded_rnainter_rnas, interaction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RPI1807_processor:\n",
    "    \"\"\"\n",
    "    RPI1807 is currently as a csv, it must be processed into\n",
    "    encoded data before being validated.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, rpi1807_csv_path, mode):\n",
    "        assert mode in ['negative_samples','dl_prediction'], \\\n",
    "        'mode must either be in \"negative_samples\" or \"dl_prediction\" for LazyClassifier and DL model evaluation respectively'\n",
    "        \n",
    "        self.rpi1807_path = rpi1807_csv_path\n",
    "        self.mode = mode\n",
    "        \n",
    "        self.rna_embedder = SkipGramEmbedder(\"../SeqEmbedders/GensimWord2Vec/RNA2Vec_1024_hidden.model\", reduce = True)\n",
    "        self.data = pd.read_csv(rpi1807_csv_path)\n",
    "        \n",
    "        def truncate_rpi1807_sequences():\n",
    "            short_rnas = self.data['rnas'].apply(len) <= 100\n",
    "            short_proteins = self.data['proteins'].apply(len) <= 110\n",
    "            self.data = self.data[short_rnas & short_proteins]\n",
    "        \n",
    "        truncate_rpi1807_sequences()\n",
    "        \n",
    "    def encode_rnas(self, rna_seqs) -> torch.Tensor:\n",
    "        return self.rna_embedder(rna_seqs)\n",
    "        \n",
    "    def _preprocess_protein(self, protein_seq):\n",
    "        return \" \".join(list(protein_seq))\n",
    "    \n",
    "    def _preprocess_proteins(self, protein_seqs):\n",
    "        return [self._preprocess_protein(seq) for seq in protein_seqs]\n",
    "    \n",
    "    def encode_proteins(self, prot_seqs) -> torch.Tensor:\n",
    "        processed_proteins = self._preprocess_proteins(prot_seqs)\n",
    "        # print(processed_proteins)\n",
    "        model     = AutoModel.from_pretrained(\"Rostlab/prot_bert_bfd\")\n",
    "        tokenizer = AutoTokenizer.from_pretrained(\"Rostlab/prot_bert_bfd\", do_lower_case = False)\n",
    "\n",
    "        rpi1807_embedder = IterableProteinEmbedding(processed_proteins, tokenizer, model, chunksize = 3, max_len = 110, cuda = True)\n",
    "        encoded_proteins = torch.cat([i for i in rpi1807_embedder])\n",
    "        \n",
    "        return encoded_proteins\n",
    "        \n",
    "    def process_rpi1807(self) -> tuple:\n",
    "        encoded_proteins = self.encode_proteins(self.data['proteins']).cpu()\n",
    "        encoded_rnas = self.encode_rnas(self.data['rnas']).cpu()\n",
    "        interaction = torch.tensor(self.data['interacts'].values)\n",
    "        \n",
    "        processed_data = (encoded_proteins, encoded_rnas, interaction)\n",
    "        \n",
    "        if self.mode == 'negative_samples':\n",
    "            processed_data = get_lazy_X_and_y_data(processed_data)\n",
    "            \n",
    "        return processed_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_lazy_X_and_y_data(data):\n",
    "    X_data = np.concatenate([np.array(i) for i in data[:2]], axis = 1)\n",
    "    y_data = np.array(data[-1])\n",
    "    \n",
    "    return X_data, y_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def isolate_split_data(data, idx):\n",
    "    return [encoded[idx] for encoded in data]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fig, ax = plt.subplots(1,1, figsize = (6,3))\n",
    "\n",
    "# sbn.violinplot(data = models.iloc[:,:-1].melt(), x = 'variable', y = 'value', ax = ax, \n",
    "#                color = 'white')\n",
    "# sbn.swarmplot(data = models.iloc[:,:-1].melt(), x = 'variable', y = 'value', \n",
    "#               palette=\"tab10\", ax = ax)\n",
    "\n",
    "# sbn.despine()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['lowest', 'highest', 'uniform', 'expoential_low', 'expoential_high', 'normal', 'slight_right_skew', 'slight_left_skew', 'major_right_skew', 'major_left_skew'])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SAMPLING_DISTRIBUTIONS.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "distributions = ['uniform', 'expoential_low', 'expoential_high', 'lowest', 'highest', 'normal', \n",
    "                 'slight_right_skew', 'slight_left_skew', 'major_right_skew', 'major_left_skew']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4876"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(reduced_positive_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performing lowest sampling experiments...\n",
      "[1, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'bins' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-26-60ab00862535>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     15\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbin_weights\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m     \u001b[0mnegative_pair_idx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mneg_idx_generator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate_negative_sample_idxs_from_bins\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbins\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbin_weights\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSAMPLES\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m     \u001b[0mneg_pair_idxs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnegative_pair_idx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'bins' is not defined"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x273.6 with 10 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(2,5, figsize = (6,3.8), sharex = True, sharey = True)\n",
    "\n",
    "i = 0\n",
    "\n",
    "SEED = 255\n",
    "SAMPLES = len(reduced_positive_df)\n",
    "\n",
    "neg_idx_generator = NegativeSampleIdxGenerator(SEED)\n",
    "\n",
    "neg_pair_idxs = list()\n",
    "\n",
    "for i,distribution in enumerate(SAMPLING_DISTRIBUTIONS.keys()):\n",
    "    print(f\"Performing {distribution} sampling experiments...\")\n",
    "    bin_weights = SAMPLING_DISTRIBUTIONS[distribution]\n",
    "    print(bin_weights)\n",
    "    \n",
    "    negative_pair_idx = neg_idx_generator.generate_negative_sample_idxs_from_bins(bins, bin_weights, SAMPLES)\n",
    "    \n",
    "    neg_pair_idxs.append(negative_pair_idx)\n",
    "    \n",
    "#     negative_pairs = np.array(combo_ids)[negative_pair_idx]\n",
    "    \n",
    "#     positive_samples = return_positive_samples(reduced_positive_df, rna_embedder)\n",
    "#     negative_samples = return_negative_samples(negative_pairs)\n",
    "    \n",
    "#     data = [torch.cat([pos.cpu(),neg.cpu()]) for pos,neg in zip(*[positive_samples, negative_samples])]\n",
    "    \n",
    "# #     train_idx, test_idx = train_test_split(range(len(data[0])), random_state = 255, test_size = 0.2, \n",
    "# #                                         stratify = data[-1])\n",
    "#      # test_idx, val_idx = train_test_split(test_idx, random_state = 255, test_size = 0.5,\n",
    "# #                                      stratify = data[-1][test_idx])\n",
    "\n",
    "#     rpi1807_processor = RPI1807_processor(\"../Data/EvaluationData/RPI1807.csv\", mode = 'negative_samples')\n",
    "    \n",
    "#     x,y = rpi1807_processor.process_rpi1807()\n",
    "    \n",
    "#     X_train, y_train = get_lazy_X_and_y_data(data)\n",
    "#     # X_test, y_test = get_lazy_X_and_y_data(train_data)\n",
    "#     # X_test, y_test = get_lazy_X_and_y_data(test_data)\n",
    "    \n",
    "#     clf = LazyClassifier(random_state = 255)\n",
    "#     models, _ = clf.fit(X_train, x, y_train, y)\n",
    "    \n",
    "#     models['distribution'] = distribution\n",
    "    \n",
    "    # models.to_csv(f\"../PreTrainingExperimentResults/Lazypred{distribution}SamplingRPI1807Eval.csv\")\n",
    "    \n",
    "    n = i>4\n",
    "    k = i if i <= 4 else i - 5\n",
    "    \n",
    "    # axes[int(n),k].set_xlim(None,9)\n",
    "    \n",
    "#     if i == 1:\n",
    "#         print(bins[negative_pair_idx])\n",
    "#          t = bins[negative_pair_idx]\n",
    "#          t.append(0)\n",
    "    \n",
    "    # Need to add one sample from each entry for visualization to prevent\n",
    "    # a graphical glitch. This was NOT inlucded in negative sampling\n",
    "    # experiments\n",
    "    negative_sample_bins = np.append(bins[negative_pair_idx],np.arange(10))\n",
    "    \n",
    "    sbn.countplot(x = negative_sample_bins, ax = axes[int(n),k], \n",
    "                  palette = 'summer')\n",
    "    \n",
    "    \n",
    "    # axes[int(n),k].set_title(distribution.replace('_','\\n'))\n",
    "    axes[int(n),k].set_ylabel(\"\")\n",
    "\n",
    "axes[0,0].set_xticks(range(0,10,3))\n",
    "    \n",
    "axes[0,0].set_ylabel(\"Sample count\")\n",
    "axes[1,0].set_ylabel(\"Sample count\")\n",
    "\n",
    "# axes[0,0].set_yticks(range(0,10,2))\n",
    "# axes[0,0].set_yticklabels(list(np.linspace(0,1,5)))\n",
    "\n",
    "# labels = axes[0,0].get_yticklabels()\n",
    "# axes[0,0].set_yticklabels([round(i/len(bins[negative_pair_idx]),2) for label in labels])\n",
    "\n",
    "axes[0,0].set_ylim(0,5000)\n",
    "\n",
    "for i in range(5):\n",
    "    axes[1,i].set_xlabel(\"Bin\")\n",
    "\n",
    "plt.tight_layout()\n",
    "sbn.despine()\n",
    "\n",
    "# plt.savefig(\"BinnedSampleCount.png\", dpi = 300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at Rostlab/prot_bert_bfd were not used when initializing BertModel: ['cls.predictions.transform.LayerNorm.weight', 'cls.predictions.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.seq_relationship.weight', 'cls.predictions.decoder.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.dense.weight', 'cls.seq_relationship.bias']\n",
      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4b6cd989f94d44e1975cbc3df3d5685b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1626 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at Rostlab/prot_bert_bfd were not used when initializing BertModel: ['cls.predictions.transform.LayerNorm.weight', 'cls.predictions.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.seq_relationship.weight', 'cls.predictions.decoder.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.dense.weight', 'cls.seq_relationship.bias']\n",
      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "20107a1f41eb40efae65da630c56ff09",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/1626 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bin_weights = SAMPLING_DISTRIBUTIONS['slight_left_skew']\n",
    "negative_pair_idx = neg_idx_generator.generate_negative_sample_idxs_from_bins(bins, bin_weights, SAMPLES)\n",
    "\n",
    "negative_pairs = np.array(combo_ids)[negative_pair_idx]\n",
    "\n",
    "positive_samples = return_positive_samples(reduced_positive_df, rna_embedder_2d, reduce = False)\n",
    "negative_samples = return_negative_samples(negative_pairs, reduce = False)\n",
    "\n",
    "# 2D Data\n",
    "data = [torch.cat([pos.cpu(),neg.cpu()]) for pos,neg in zip(*[positive_samples, negative_samples])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SAVE DISTRIBUTION DATA AS TUPLE\n",
    "# Protein, RNA, interacts\n",
    "\n",
    "import pickle\n",
    "\n",
    "with open(\"../Data/TrainingData/ReducedEmbeddedTrainingData_2D.pickle\",'wb') as outfile:\n",
    "    pickle.dump(data, outfile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluate combined experiments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "combined_experiments = pd.concat([pd.read_csv(f\"../PreTrainingExperimentResults/Lazypred{distribution}SamplingRPI1807Eval.csv\") for distribution in SAMPLING_DISTRIBUTIONS.keys()]).reset_index(drop=True).round(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AUROC and balanced accuracy are identical: True\n"
     ]
    }
   ],
   "source": [
    "# All balanced accuracy and AUROC values are identical\n",
    "print(f\"AUROC and balanced accuracy are identical: {(combined_experiments['Balanced Accuracy'] == combined_experiments['ROC AUC']).all()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "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>Accuracy</th>\n",
       "      <th>Balanced Accuracy</th>\n",
       "      <th>ROC AUC</th>\n",
       "      <th>F1 Score</th>\n",
       "      <th>Time Taken</th>\n",
       "      <th>distribution</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Model</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>LinearSVC</th>\n",
       "      <td>0.75</td>\n",
       "      <td>0.76</td>\n",
       "      <td>0.76</td>\n",
       "      <td>0.75</td>\n",
       "      <td>16.35</td>\n",
       "      <td>uniform</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CalibratedClassifierCV</th>\n",
       "      <td>0.74</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.74</td>\n",
       "      <td>57.06</td>\n",
       "      <td>uniform</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Perceptron</th>\n",
       "      <td>0.73</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.74</td>\n",
       "      <td>1.98</td>\n",
       "      <td>uniform</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PassiveAggressiveClassifier</th>\n",
       "      <td>0.73</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.74</td>\n",
       "      <td>3.02</td>\n",
       "      <td>uniform</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>LogisticRegression</th>\n",
       "      <td>0.71</td>\n",
       "      <td>0.73</td>\n",
       "      <td>0.73</td>\n",
       "      <td>0.71</td>\n",
       "      <td>2.58</td>\n",
       "      <td>uniform</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                             Accuracy  Balanced Accuracy  ROC AUC  F1 Score  \\\n",
       "Model                                                                         \n",
       "LinearSVC                        0.75               0.76     0.76      0.75   \n",
       "CalibratedClassifierCV           0.74               0.75     0.75      0.74   \n",
       "Perceptron                       0.73               0.74     0.74      0.74   \n",
       "PassiveAggressiveClassifier      0.73               0.74     0.74      0.74   \n",
       "LogisticRegression               0.71               0.73     0.73      0.71   \n",
       "\n",
       "                             Time Taken distribution  \n",
       "Model                                                 \n",
       "LinearSVC                         16.35      uniform  \n",
       "CalibratedClassifierCV            57.06      uniform  \n",
       "Perceptron                         1.98      uniform  \n",
       "PassiveAggressiveClassifier        3.02      uniform  \n",
       "LogisticRegression                 2.58      uniform  "
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "combined_experiments.groupby(\"Model\").max().sort_values(\"Balanced Accuracy\", ascending = False)[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "TOP 5 PERFORMING MODELS:\n",
      "['LinearSVC', 'CalibratedClassifierCV', 'Perceptron', 'PassiveAggressiveClassifier', 'LogisticRegression']\n",
      "\n"
     ]
    }
   ],
   "source": [
    "top_models = combined_experiments.groupby(\"Model\").max().sort_values(\"Balanced Accuracy\", ascending = False)[:5].index\n",
    "\n",
    "print(f\"\"\"\n",
    "TOP 5 PERFORMING MODELS:\n",
    "{list(top_models)}\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": true
   },
   "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>Model</th>\n",
       "      <th>Balanced Accuracy</th>\n",
       "      <th>ROC AUC</th>\n",
       "      <th>F1 Score</th>\n",
       "      <th>distribution</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>0.66</td>\n",
       "      <td>0.66</td>\n",
       "      <td>0.63</td>\n",
       "      <td>lowest</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>PassiveAggressiveClassifier</td>\n",
       "      <td>0.57</td>\n",
       "      <td>0.57</td>\n",
       "      <td>0.49</td>\n",
       "      <td>lowest</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>LinearSVC</td>\n",
       "      <td>0.47</td>\n",
       "      <td>0.47</td>\n",
       "      <td>0.31</td>\n",
       "      <td>lowest</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>CalibratedClassifierCV</td>\n",
       "      <td>0.47</td>\n",
       "      <td>0.47</td>\n",
       "      <td>0.31</td>\n",
       "      <td>lowest</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>Perceptron</td>\n",
       "      <td>0.46</td>\n",
       "      <td>0.46</td>\n",
       "      <td>0.30</td>\n",
       "      <td>lowest</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>30</th>\n",
       "      <td>Perceptron</td>\n",
       "      <td>0.68</td>\n",
       "      <td>0.68</td>\n",
       "      <td>0.65</td>\n",
       "      <td>highest</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32</th>\n",
       "      <td>PassiveAggressiveClassifier</td>\n",
       "      <td>0.66</td>\n",
       "      <td>0.66</td>\n",
       "      <td>0.64</td>\n",
       "      <td>highest</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>33</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>0.66</td>\n",
       "      <td>0.66</td>\n",
       "      <td>0.64</td>\n",
       "      <td>highest</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>LinearSVC</td>\n",
       "      <td>0.61</td>\n",
       "      <td>0.61</td>\n",
       "      <td>0.61</td>\n",
       "      <td>highest</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>CalibratedClassifierCV</td>\n",
       "      <td>0.60</td>\n",
       "      <td>0.60</td>\n",
       "      <td>0.60</td>\n",
       "      <td>highest</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>54</th>\n",
       "      <td>Perceptron</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.74</td>\n",
       "      <td>uniform</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>55</th>\n",
       "      <td>CalibratedClassifierCV</td>\n",
       "      <td>0.73</td>\n",
       "      <td>0.73</td>\n",
       "      <td>0.72</td>\n",
       "      <td>uniform</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>56</th>\n",
       "      <td>PassiveAggressiveClassifier</td>\n",
       "      <td>0.73</td>\n",
       "      <td>0.73</td>\n",
       "      <td>0.71</td>\n",
       "      <td>uniform</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>60</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>0.68</td>\n",
       "      <td>0.68</td>\n",
       "      <td>0.64</td>\n",
       "      <td>uniform</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>69</th>\n",
       "      <td>LinearSVC</td>\n",
       "      <td>0.57</td>\n",
       "      <td>0.57</td>\n",
       "      <td>0.47</td>\n",
       "      <td>uniform</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>81</th>\n",
       "      <td>Perceptron</td>\n",
       "      <td>0.73</td>\n",
       "      <td>0.73</td>\n",
       "      <td>0.72</td>\n",
       "      <td>expoential_low</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>82</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>0.73</td>\n",
       "      <td>0.73</td>\n",
       "      <td>0.71</td>\n",
       "      <td>expoential_low</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>91</th>\n",
       "      <td>PassiveAggressiveClassifier</td>\n",
       "      <td>0.61</td>\n",
       "      <td>0.61</td>\n",
       "      <td>0.56</td>\n",
       "      <td>expoential_low</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>95</th>\n",
       "      <td>LinearSVC</td>\n",
       "      <td>0.54</td>\n",
       "      <td>0.54</td>\n",
       "      <td>0.44</td>\n",
       "      <td>expoential_low</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>96</th>\n",
       "      <td>CalibratedClassifierCV</td>\n",
       "      <td>0.54</td>\n",
       "      <td>0.54</td>\n",
       "      <td>0.44</td>\n",
       "      <td>expoential_low</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>108</th>\n",
       "      <td>PassiveAggressiveClassifier</td>\n",
       "      <td>0.70</td>\n",
       "      <td>0.70</td>\n",
       "      <td>0.69</td>\n",
       "      <td>expoential_high</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>109</th>\n",
       "      <td>LinearSVC</td>\n",
       "      <td>0.68</td>\n",
       "      <td>0.68</td>\n",
       "      <td>0.65</td>\n",
       "      <td>expoential_high</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>112</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.64</td>\n",
       "      <td>expoential_high</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>117</th>\n",
       "      <td>Perceptron</td>\n",
       "      <td>0.66</td>\n",
       "      <td>0.66</td>\n",
       "      <td>0.64</td>\n",
       "      <td>expoential_high</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>118</th>\n",
       "      <td>CalibratedClassifierCV</td>\n",
       "      <td>0.65</td>\n",
       "      <td>0.65</td>\n",
       "      <td>0.63</td>\n",
       "      <td>expoential_high</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>135</th>\n",
       "      <td>PassiveAggressiveClassifier</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.74</td>\n",
       "      <td>normal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>136</th>\n",
       "      <td>CalibratedClassifierCV</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.73</td>\n",
       "      <td>normal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>139</th>\n",
       "      <td>LinearSVC</td>\n",
       "      <td>0.68</td>\n",
       "      <td>0.68</td>\n",
       "      <td>0.65</td>\n",
       "      <td>normal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>140</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>0.68</td>\n",
       "      <td>0.68</td>\n",
       "      <td>0.65</td>\n",
       "      <td>normal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>143</th>\n",
       "      <td>Perceptron</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.64</td>\n",
       "      <td>normal</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>166</th>\n",
       "      <td>Perceptron</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.63</td>\n",
       "      <td>slight_right_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>167</th>\n",
       "      <td>CalibratedClassifierCV</td>\n",
       "      <td>0.66</td>\n",
       "      <td>0.66</td>\n",
       "      <td>0.62</td>\n",
       "      <td>slight_right_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>173</th>\n",
       "      <td>LinearSVC</td>\n",
       "      <td>0.55</td>\n",
       "      <td>0.55</td>\n",
       "      <td>0.45</td>\n",
       "      <td>slight_right_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>176</th>\n",
       "      <td>PassiveAggressiveClassifier</td>\n",
       "      <td>0.53</td>\n",
       "      <td>0.53</td>\n",
       "      <td>0.43</td>\n",
       "      <td>slight_right_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>187</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>0.47</td>\n",
       "      <td>0.47</td>\n",
       "      <td>0.31</td>\n",
       "      <td>slight_right_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>189</th>\n",
       "      <td>LinearSVC</td>\n",
       "      <td>0.76</td>\n",
       "      <td>0.76</td>\n",
       "      <td>0.75</td>\n",
       "      <td>slight_left_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>190</th>\n",
       "      <td>CalibratedClassifierCV</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.74</td>\n",
       "      <td>slight_left_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>191</th>\n",
       "      <td>PassiveAggressiveClassifier</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.73</td>\n",
       "      <td>slight_left_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>197</th>\n",
       "      <td>Perceptron</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.64</td>\n",
       "      <td>slight_left_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>198</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.63</td>\n",
       "      <td>slight_left_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>224</th>\n",
       "      <td>Perceptron</td>\n",
       "      <td>0.55</td>\n",
       "      <td>0.55</td>\n",
       "      <td>0.46</td>\n",
       "      <td>major_right_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>228</th>\n",
       "      <td>LinearSVC</td>\n",
       "      <td>0.54</td>\n",
       "      <td>0.54</td>\n",
       "      <td>0.44</td>\n",
       "      <td>major_right_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>229</th>\n",
       "      <td>CalibratedClassifierCV</td>\n",
       "      <td>0.54</td>\n",
       "      <td>0.54</td>\n",
       "      <td>0.44</td>\n",
       "      <td>major_right_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>239</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>0.46</td>\n",
       "      <td>0.46</td>\n",
       "      <td>0.30</td>\n",
       "      <td>major_right_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>240</th>\n",
       "      <td>PassiveAggressiveClassifier</td>\n",
       "      <td>0.46</td>\n",
       "      <td>0.46</td>\n",
       "      <td>0.30</td>\n",
       "      <td>major_right_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>247</th>\n",
       "      <td>Perceptron</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.64</td>\n",
       "      <td>major_left_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>248</th>\n",
       "      <td>PassiveAggressiveClassifier</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.64</td>\n",
       "      <td>major_left_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>249</th>\n",
       "      <td>LogisticRegression</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.63</td>\n",
       "      <td>major_left_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>252</th>\n",
       "      <td>LinearSVC</td>\n",
       "      <td>0.66</td>\n",
       "      <td>0.66</td>\n",
       "      <td>0.63</td>\n",
       "      <td>major_left_skew</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>253</th>\n",
       "      <td>CalibratedClassifierCV</td>\n",
       "      <td>0.65</td>\n",
       "      <td>0.65</td>\n",
       "      <td>0.62</td>\n",
       "      <td>major_left_skew</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                           Model  Balanced Accuracy  ROC AUC  F1 Score  \\\n",
       "2             LogisticRegression               0.66     0.66      0.63   \n",
       "11   PassiveAggressiveClassifier               0.57     0.57      0.49   \n",
       "22                     LinearSVC               0.47     0.47      0.31   \n",
       "23        CalibratedClassifierCV               0.47     0.47      0.31   \n",
       "26                    Perceptron               0.46     0.46      0.30   \n",
       "30                    Perceptron               0.68     0.68      0.65   \n",
       "32   PassiveAggressiveClassifier               0.66     0.66      0.64   \n",
       "33            LogisticRegression               0.66     0.66      0.64   \n",
       "35                     LinearSVC               0.61     0.61      0.61   \n",
       "37        CalibratedClassifierCV               0.60     0.60      0.60   \n",
       "54                    Perceptron               0.74     0.74      0.74   \n",
       "55        CalibratedClassifierCV               0.73     0.73      0.72   \n",
       "56   PassiveAggressiveClassifier               0.73     0.73      0.71   \n",
       "60            LogisticRegression               0.68     0.68      0.64   \n",
       "69                     LinearSVC               0.57     0.57      0.47   \n",
       "81                    Perceptron               0.73     0.73      0.72   \n",
       "82            LogisticRegression               0.73     0.73      0.71   \n",
       "91   PassiveAggressiveClassifier               0.61     0.61      0.56   \n",
       "95                     LinearSVC               0.54     0.54      0.44   \n",
       "96        CalibratedClassifierCV               0.54     0.54      0.44   \n",
       "108  PassiveAggressiveClassifier               0.70     0.70      0.69   \n",
       "109                    LinearSVC               0.68     0.68      0.65   \n",
       "112           LogisticRegression               0.67     0.67      0.64   \n",
       "117                   Perceptron               0.66     0.66      0.64   \n",
       "118       CalibratedClassifierCV               0.65     0.65      0.63   \n",
       "135  PassiveAggressiveClassifier               0.74     0.74      0.74   \n",
       "136       CalibratedClassifierCV               0.74     0.74      0.73   \n",
       "139                    LinearSVC               0.68     0.68      0.65   \n",
       "140           LogisticRegression               0.68     0.68      0.65   \n",
       "143                   Perceptron               0.67     0.67      0.64   \n",
       "166                   Perceptron               0.67     0.67      0.63   \n",
       "167       CalibratedClassifierCV               0.66     0.66      0.62   \n",
       "173                    LinearSVC               0.55     0.55      0.45   \n",
       "176  PassiveAggressiveClassifier               0.53     0.53      0.43   \n",
       "187           LogisticRegression               0.47     0.47      0.31   \n",
       "189                    LinearSVC               0.76     0.76      0.75   \n",
       "190       CalibratedClassifierCV               0.75     0.75      0.74   \n",
       "191  PassiveAggressiveClassifier               0.74     0.74      0.73   \n",
       "197                   Perceptron               0.67     0.67      0.64   \n",
       "198           LogisticRegression               0.67     0.67      0.63   \n",
       "224                   Perceptron               0.55     0.55      0.46   \n",
       "228                    LinearSVC               0.54     0.54      0.44   \n",
       "229       CalibratedClassifierCV               0.54     0.54      0.44   \n",
       "239           LogisticRegression               0.46     0.46      0.30   \n",
       "240  PassiveAggressiveClassifier               0.46     0.46      0.30   \n",
       "247                   Perceptron               0.67     0.67      0.64   \n",
       "248  PassiveAggressiveClassifier               0.67     0.67      0.64   \n",
       "249           LogisticRegression               0.67     0.67      0.63   \n",
       "252                    LinearSVC               0.66     0.66      0.63   \n",
       "253       CalibratedClassifierCV               0.65     0.65      0.62   \n",
       "\n",
       "          distribution  \n",
       "2               lowest  \n",
       "11              lowest  \n",
       "22              lowest  \n",
       "23              lowest  \n",
       "26              lowest  \n",
       "30             highest  \n",
       "32             highest  \n",
       "33             highest  \n",
       "35             highest  \n",
       "37             highest  \n",
       "54             uniform  \n",
       "55             uniform  \n",
       "56             uniform  \n",
       "60             uniform  \n",
       "69             uniform  \n",
       "81      expoential_low  \n",
       "82      expoential_low  \n",
       "91      expoential_low  \n",
       "95      expoential_low  \n",
       "96      expoential_low  \n",
       "108    expoential_high  \n",
       "109    expoential_high  \n",
       "112    expoential_high  \n",
       "117    expoential_high  \n",
       "118    expoential_high  \n",
       "135             normal  \n",
       "136             normal  \n",
       "139             normal  \n",
       "140             normal  \n",
       "143             normal  \n",
       "166  slight_right_skew  \n",
       "167  slight_right_skew  \n",
       "173  slight_right_skew  \n",
       "176  slight_right_skew  \n",
       "187  slight_right_skew  \n",
       "189   slight_left_skew  \n",
       "190   slight_left_skew  \n",
       "191   slight_left_skew  \n",
       "197   slight_left_skew  \n",
       "198   slight_left_skew  \n",
       "224   major_right_skew  \n",
       "228   major_right_skew  \n",
       "229   major_right_skew  \n",
       "239   major_right_skew  \n",
       "240   major_right_skew  \n",
       "247    major_left_skew  \n",
       "248    major_left_skew  \n",
       "249    major_left_skew  \n",
       "252    major_left_skew  \n",
       "253    major_left_skew  "
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "top_experiments = combined_experiments[ combined_experiments['Model'].isin(top_models) ]\n",
    "top_experiment_data = top_experiments[['Model','Balanced Accuracy','ROC AUC','F1 Score','distribution']]\n",
    "top_experiment_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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>Balanced Accuracy</th>\n",
       "      <th>ROC AUC</th>\n",
       "      <th>F1 Score</th>\n",
       "      <th>distribution</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Model</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>LinearSVC</th>\n",
       "      <td>0.76</td>\n",
       "      <td>0.76</td>\n",
       "      <td>0.75</td>\n",
       "      <td>uniform</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CalibratedClassifierCV</th>\n",
       "      <td>0.75</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.74</td>\n",
       "      <td>uniform</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>PassiveAggressiveClassifier</th>\n",
       "      <td>0.74</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.74</td>\n",
       "      <td>uniform</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Perceptron</th>\n",
       "      <td>0.74</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.74</td>\n",
       "      <td>uniform</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>LogisticRegression</th>\n",
       "      <td>0.73</td>\n",
       "      <td>0.73</td>\n",
       "      <td>0.71</td>\n",
       "      <td>uniform</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                             Balanced Accuracy  ROC AUC  F1 Score distribution\n",
       "Model                                                                         \n",
       "LinearSVC                                 0.76     0.76      0.75      uniform\n",
       "CalibratedClassifierCV                    0.75     0.75      0.74      uniform\n",
       "PassiveAggressiveClassifier               0.74     0.74      0.74      uniform\n",
       "Perceptron                                0.74     0.74      0.74      uniform\n",
       "LogisticRegression                        0.73     0.73      0.71      uniform"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "top_experiment_data.groupby(\"Model\").max().sort_values(\"Balanced Accuracy\", ascending = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1,1, figsize = (6,3))\n",
    "\n",
    "# ADD MAX CLUSTERING\n",
    "\n",
    "sbn.violinplot(data = top_experiments, x = 'Model', y = 'Balanced Accuracy', color = 'white', inner = None, ax = ax)\n",
    "              # palette = \"tab10\", ax = ax)\n",
    "    \n",
    "sbn.swarmplot(data = top_experiments, x = 'Model', y = 'Balanced Accuracy',\n",
    "              palette = \"tab10\", ax = ax)\n",
    "\n",
    "ax.set_xticklabels(ax.get_xticklabels(), rotation = 10, ha = 'right')\n",
    "\n",
    "sbn.despine()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"BestLazyPredModels.png\", dpi = 300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import partial\n",
    "\n",
    "partial_heatmap_data = partial(pd.pivot_table, top_experiment_data, index = 'distribution', columns='Model')\n",
    "partial_clustermap_data = partial(pd.pivot_table, top_experiment_data, index = 'distribution', columns='Model')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "distribution\n",
       "slight_left_skew    0.72\n",
       "normal              0.70\n",
       "uniform             0.69\n",
       "expoential_high     0.67\n",
       "major_left_skew     0.66\n",
       "highest             0.64\n",
       "expoential_low      0.63\n",
       "slight_right_skew   0.58\n",
       "slight_right_skew   0.58\n",
       "lowest              0.53\n",
       "dtype: float64"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "partial_heatmap_data(values = 'Balanced Accuracy').loc[['slight_left_skew','normal','uniform','expoential_high','major_left_skew','highest','expoential_low','slight_right_skew','slight_right_skew','lowest'],:].mean(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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>Model</th>\n",
       "      <th>CalibratedClassifierCV</th>\n",
       "      <th>LinearSVC</th>\n",
       "      <th>LogisticRegression</th>\n",
       "      <th>PassiveAggressiveClassifier</th>\n",
       "      <th>Perceptron</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>distribution</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>slight_left_skew</th>\n",
       "      <td>0.75</td>\n",
       "      <td>0.76</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.67</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>normal</th>\n",
       "      <td>0.74</td>\n",
       "      <td>0.68</td>\n",
       "      <td>0.68</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.67</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>uniform</th>\n",
       "      <td>0.73</td>\n",
       "      <td>0.57</td>\n",
       "      <td>0.68</td>\n",
       "      <td>0.73</td>\n",
       "      <td>0.74</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>expoential_high</th>\n",
       "      <td>0.65</td>\n",
       "      <td>0.68</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.70</td>\n",
       "      <td>0.66</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>major_left_skew</th>\n",
       "      <td>0.65</td>\n",
       "      <td>0.66</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.67</td>\n",
       "      <td>0.67</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>highest</th>\n",
       "      <td>0.60</td>\n",
       "      <td>0.61</td>\n",
       "      <td>0.66</td>\n",
       "      <td>0.66</td>\n",
       "      <td>0.68</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>expoential_low</th>\n",
       "      <td>0.54</td>\n",
       "      <td>0.54</td>\n",
       "      <td>0.73</td>\n",
       "      <td>0.61</td>\n",
       "      <td>0.73</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>slight_right_skew</th>\n",
       "      <td>0.66</td>\n",
       "      <td>0.55</td>\n",
       "      <td>0.47</td>\n",
       "      <td>0.53</td>\n",
       "      <td>0.67</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>slight_right_skew</th>\n",
       "      <td>0.66</td>\n",
       "      <td>0.55</td>\n",
       "      <td>0.47</td>\n",
       "      <td>0.53</td>\n",
       "      <td>0.67</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>lowest</th>\n",
       "      <td>0.47</td>\n",
       "      <td>0.47</td>\n",
       "      <td>0.66</td>\n",
       "      <td>0.57</td>\n",
       "      <td>0.46</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Model              CalibratedClassifierCV  LinearSVC  LogisticRegression  \\\n",
       "distribution                                                               \n",
       "slight_left_skew                     0.75       0.76                0.67   \n",
       "normal                               0.74       0.68                0.68   \n",
       "uniform                              0.73       0.57                0.68   \n",
       "expoential_high                      0.65       0.68                0.67   \n",
       "major_left_skew                      0.65       0.66                0.67   \n",
       "highest                              0.60       0.61                0.66   \n",
       "expoential_low                       0.54       0.54                0.73   \n",
       "slight_right_skew                    0.66       0.55                0.47   \n",
       "slight_right_skew                    0.66       0.55                0.47   \n",
       "lowest                               0.47       0.47                0.66   \n",
       "\n",
       "Model              PassiveAggressiveClassifier  Perceptron  \n",
       "distribution                                                \n",
       "slight_left_skew                          0.74        0.67  \n",
       "normal                                    0.74        0.67  \n",
       "uniform                                   0.73        0.74  \n",
       "expoential_high                           0.70        0.66  \n",
       "major_left_skew                           0.67        0.67  \n",
       "highest                                   0.66        0.68  \n",
       "expoential_low                            0.61        0.73  \n",
       "slight_right_skew                         0.53        0.67  \n",
       "slight_right_skew                         0.53        0.67  \n",
       "lowest                                    0.57        0.46  "
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "partial_heatmap_data(values = 'Balanced Accuracy').loc[['slight_left_skew','normal','uniform','expoential_high','major_left_skew','highest','expoential_low','slight_right_skew','slight_right_skew','lowest'],:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x288 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize = (7,4))\n",
    "gs = fig.add_gridspec(2,4, width_ratios=[0.42, 0.08, 0.42, 0.08], height_ratios=[0.05,0.95])\n",
    "\n",
    "cbar1 = fig.add_subplot(gs[0,:2])\n",
    "heatmap1 = fig.add_subplot(gs[1,0])\n",
    "average1 = fig.add_subplot(gs[1,1])\n",
    "\n",
    "cbar2 = fig.add_subplot(gs[0,2:])\n",
    "heatmap2 = fig.add_subplot(gs[1,2])\n",
    "average2 = fig.add_subplot(gs[1,-1])\n",
    "\n",
    "sbn.heatmap(partial_heatmap_data(values = 'Balanced Accuracy').loc[['slight_left_skew','normal','uniform','expoential_high','major_left_skew','highest','expoential_low','slight_right_skew','slight_right_skew','lowest'],:], \n",
    "            linewidths=1, cmap=\"coolwarm\", ax = heatmap1, cbar_ax = cbar1, cbar_kws = {'orientation': 'horizontal'})\n",
    "\n",
    "sbn.heatmap(pd.DataFrame(partial_heatmap_data(values = 'Balanced Accuracy').loc[['slight_left_skew','normal','uniform','expoential_high','major_left_skew','highest','expoential_low','slight_right_skew','slight_right_skew','lowest'],:].mean(axis=1)), \n",
    "            linewidths=1, yticklabels = False, xticklabels = False, cbar = False, annot = True, cmap=\"coolwarm\", ax = average1)\n",
    "\n",
    "cbar1.xaxis.tick_top()\n",
    "\n",
    "f1_cmap = sbn.diverging_palette(275, 130, s=80, l=55, as_cmap = True)\n",
    "\n",
    "sbn.heatmap(partial_heatmap_data(values = 'F1 Score').loc[['slight_left_skew','normal','uniform','expoential_high','major_left_skew','highest','expoential_low','slight_right_skew','slight_right_skew','lowest'],:], \n",
    "            linewidths=1, yticklabels=False, cmap = f1_cmap, ax = heatmap2, cbar_ax = cbar2, cbar_kws = {'orientation': 'horizontal'})\n",
    "\n",
    "sbn.heatmap(pd.DataFrame(partial_heatmap_data(values = 'F1 Score').loc[['slight_left_skew','normal','uniform','expoential_high','major_left_skew','highest','expoential_low','slight_right_skew','slight_right_skew','lowest'],:].mean(axis=1)), \n",
    "            linewidths=1, yticklabels = False, xticklabels = False, cbar = False, annot = True, cmap=f1_cmap, ax = average2)\n",
    "\n",
    "cbar2.xaxis.tick_top()\n",
    "\n",
    "for ax in [heatmap1,heatmap2]:\n",
    "    ax.xaxis.set_ticklabels(ax.xaxis.get_ticklabels(), rotation = 30, ha = 'right');\n",
    "\n",
    "heatmap1.yaxis.set_ticklabels([label.get_text().replace(\"_\",\" \") for label in heatmap1.yaxis.get_ticklabels()])\n",
    "\n",
    "heatmap1.set_ylabel(\"\")\n",
    "average1.set_ylabel(\"\")\n",
    "average2.set_ylabel(\"\")\n",
    "heatmap2.set_ylabel(\"\")\n",
    "\n",
    "heatmap1.set_xlabel(\"\")\n",
    "heatmap2.set_xlabel(\"\")\n",
    "\n",
    "# Using plt.tight_layout() just ruins everything\n",
    "# The rest of the modifications are made in PowerPoint\n",
    "plt.savefig(\"OptimalNegativeSamplingStrategy.png\", dpi = 300, bbox = \"tight\", pad_inches=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NegativeSampleGenerator():\n",
    "    \"\"\"\n",
    "    Difference magnitudes\n",
    "    Swiss ID position in matrix\n",
    "    RNAInter ID position in matrix\n",
    "    \n",
    "    Encoded RNAs: RNA RNAInter uniprot ID --> RNA partner name --> Encoded RNA\n",
    "    Encoded Swiss proteins: \n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, interaction_df, seed, n_bins, bin_weights, n_generated_samples):\n",
    "        assert n_bins == len(bin_weights), \"number of bins and bin weights must be identical\"\n",
    "        self.seed = seed\n",
    "        self.n_bins = n_bins\n",
    "        self.bin_weights = bin_weights\n",
    "        self.n_generated_samples = n_generated_samples\n",
    "        \n",
    "        # Negative sample indecies generator\n",
    "        self.negative_idx_generator = NegativeSampleIdxGenerator(self.seed)\n",
    "        self.bin_assigner = KBinsDiscretizer(n_bins = self.n_bins, encode = 'ordinal')\n",
    "        \n",
    "        # rna_embedder = SkipGramEmbedder(\"../SeqEmbedders/GensimWord2Vec/RNA2Vec_1024_hidden.model\", reduce = True)\n",
    "        \n",
    "        def generate_rna_name2tensor(rna_embedder):\n",
    "            rnainter_rna_to_tensor_converter = RNAInterRNACovnerter()\n",
    "            rnaname2tensor = rnainter_rna_to_tensor_converter.generate_rna_name_to_encoded_tensor_dict_from_df(self.uniprot2rnaname.values(), reduced_positive_df, rna_embedder)\n",
    "            return rnaname2tensor\n",
    "        \n",
    "#         rnainter_idconverter = RNAInterIDConverter(seed = 255)\n",
    "#         rnainter_protein_rna_pairs = rnainter_idconverter.get_unique_protein_uniprot_ids_and_rna_pair_from_df(reduced_positive_df)\n",
    "#         uniprot2rnaname = dict(rnainter_protein_rna_pairs)\n",
    "\n",
    "        # Correct\n",
    "        self.uniprot2rna_partner = dict(RNAInterRNACovnerter(self.seed).get_unique_protein_uniprot_ids_and_rna_pair_from_df(interaction_df))\n",
    "        \n",
    "        # Correct\n",
    "        self.rnaname2tensor = generate_rna_name2tensor( SkipGramEmbedder(\"../SeqEmbedders/GensimWord2Vec/RNA2Vec_1024_hidden.model\", reduce = True) )\n",
    "        \n",
    "        #\n",
    "        self.rnainter_uniprot2swiss = 'test'\n",
    "        self.swiss2tensor = 'test'\n",
    "    \n",
    "    def get_new_encoded_swiss_partner_from_rnainter_uniprot_id(rnainter_swiss_id_pair: tuple) -> torch.tensor:\n",
    "        _, swiss_id = rnainter_swiss_id_pair\n",
    "        encoded_swiss_seq = swiss2tensor[swiss_id]\n",
    "        return encoded_swiss_seq\n",
    "    \n",
    "    def get_rna_partner_from_rnainter_uniprot_id(uniprot_id : str) -> torch.tensor:\n",
    "        rna_partner_name = self.uniprot2rnaname[uniprot_id]\n",
    "        encoded_rna_partner = self.rnaname2tensor[rna_partner_name]\n",
    "        return encoded_rna_partner\n",
    "    \n",
    "    def return_negative_samples(negative_pairs):\n",
    "        encoded_rnas = list()\n",
    "        encoded_swiss_prots = list()\n",
    "        non_interaction = torch.zeros(len(negative_pairs))\n",
    "\n",
    "        for negative_pair in negative_pairs:\n",
    "            encoded_rna = self.get_rna_partner_from_rnainter_uniprot_id(negative_pair[0])\n",
    "            encoded_swiss_protein = self.get_new_encoded_swiss_partner_from_rnainter_uniprot_id(negative_pair)\n",
    "\n",
    "            encoded_rnas.append(encoded_rna)\n",
    "            encoded_swiss_prots.append(encoded_swiss_protein)\n",
    "\n",
    "        encoded_rnas = torch.stack(encoded_rnas)\n",
    "        encoded_swiss_prots = torch.stack(encoded_swiss_prots)\n",
    "\n",
    "        return encoded_swiss_prots, encoded_rnas, non_interaction\n",
    "    \n",
    "    ##########################################################################\n",
    "    def generate_negative_samples(self, difference_magnitudes, rnainter_ids, swiss_ids):\n",
    "        assert len(difference_magnitudes) == len(rnainter_ids) == len(swiss_ids), \\\n",
    "        f\"Difference magnitudes, RNAInter IDs and Swiss IDs need to be the same length Got {len(difference_magnitudes)}, {len(rnainter_ids)}, {len(swiss_ids)} entries for the difference magnitudes, RNAInter IDs, and Swiss IDs respectively\"\n",
    "        \n",
    "        # Assign difference magnitudes into bins and generate the negative sample indeces\n",
    "        bins = self.bin_assigner.fit_transform(difference_magnitudes).squeeze().astype(int)\n",
    "        negative_sample_idxs = self.negative_idx_generator.generate_negative_sample_idxs_from_bins(bins, self.bin_weights, self.n_generated_samples)\n",
    "        \n",
    "        # Isolate X\n",
    "        X = combos[negative_sample_idxs]\n",
    "        self.negative_idx_generator(rnainter_ids)\n",
    "        \n",
    "        # 1. Generate negative sample IDs\n",
    "        # 2. Isolate RNA and protein IDs for each position\n",
    "        # 3. Convert RNAs --> vectors\n",
    "        # 4. Swap RNAInter prot IDs w/ Swiss IDs --> vectors\n",
    "        # 5. Add 0\n",
    "        # return (prot tesnors, rna tensors, 0)\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generate training data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is split anc concatted properly\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train_dataset = EncodedRPIDataset(train_data)\n",
    "# val_dataset = EncodedRPIDataset(val_data)\n",
    "\n",
    "# loaders = DataLoaders.from_dsets(train_dataset, val_dataset,\n",
    "#                                  bs = 32,\n",
    "#                                  device = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train models using positive and negative data\n",
    "\n",
    "Find package that automatically trains all the models using our training data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Old \"Train models using positive and negative data\"\n",
    "\n",
    "contains model optimization that handles default hyperparameter opt. I need to come back to this and make sure that\n",
    "everything works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import Dataset\n",
    "\n",
    "class EncodedRPIDataset(Dataset):\n",
    "    def __init__(self, data):\n",
    "        super().__init__()\n",
    "        self.encoded_proteins = data[0]\n",
    "        self.encoded_rnas = data[1]\n",
    "        self.interaction = data[2]\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.encoded_proteins)\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        return self.encoded_proteins[idx], self.encoded_rnas[idx], self.interaction[idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import yaml\n",
    "\n",
    "class DefaultHyperparameterHandler:\n",
    "    \"\"\"\n",
    "    Nabbed from \"data_handlers\", put back in there when completed\n",
    "    \n",
    "    --------\n",
    "    Designed to load default hyperparameters for a MainModel that has\n",
    "    not been previously optimized through the nni wrapper. Assumes a\n",
    "    model name of \"RNA_{block}_Prot_{block}\"\n",
    "    \n",
    "    Relies on the find_default_hyperparams funciton. This parses the\n",
    "    default hyperparameters file for a given MainModel block name and\n",
    "    returns the parameters for an RNA and Protein block in addition to \n",
    "    the default parameters used for the MainModel class. \n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, default_hyperparam_path : str):\n",
    "        self.file_name = default_hyperparam_path\n",
    "        \n",
    "#         def convert_act_strings_to_activations(default_params):\n",
    "#             \"\"\"\n",
    "#             I finally get to use a recurrent function, yay!\n",
    "#             ---\n",
    "#             Recursively searches through the default parameters dictionaries\n",
    "#             for pytorch activation function strings. Converts them to real\n",
    "#             pytorch activation functions. \n",
    "#             \"\"\"\n",
    "#             for key, value in default_params.items():\n",
    "#                 if type(value) is dict:\n",
    "#                     convert_act_strings_to_activations(value)\n",
    "#                 elif type(value) == str:\n",
    "#                     if value[:3] == 'nn.':\n",
    "#                         default_params[key] = eval(value)\n",
    "        \n",
    "        with open(default_hyperparam_path) as handle:\n",
    "            self.default_params = yaml.load(handle, Loader = yaml.FullLoader)\n",
    "            # convert_act_strings_to_activations(self.default_params)\n",
    "            \n",
    "    def _split_into_blocks(self, model_str : str) -> tuple:\n",
    "        model_parts = model_str.split('_')\n",
    "        rna_params, protein_params = model_parts[1], model_parts[3]\n",
    "        return rna_params, protein_params\n",
    "    \n",
    "    def split_hyperparameters_into_blocks(self, rna_block_name : str, prot_block_name : str) -> tuple:\n",
    "        \n",
    "        assert rna_block_name in self.default_params.keys(), \\\n",
    "        f\"RNA block name must be: {list(self.default_params.keys())}. Received {rna_block_name}\"\n",
    "        \n",
    "        assert prot_block_name in self.default_params.keys(), \\\n",
    "        f\"RNA block name must be: {list(self.default_params.keys())}. Received {prot_block_name}\"\n",
    "        \n",
    "        main_params = self.default_params[\"MainModel\"]\n",
    "        rna_params  = self.default_params[rna_block_name]\n",
    "        prot_params = self.default_params[prot_block_name]\n",
    "    \n",
    "        return main_params, rna_params, prot_params\n",
    "        \n",
    "    def find_default_hyperparams(self, model_name):\n",
    "        \"\"\n",
    "        rna_block_name, prot_block_name = self._split_into_blocks(model_name)\n",
    "        main_params, prot_params, rna_params = self.split_hyperparameters_into_blocks(rna_block_name, prot_block_name)\n",
    "        return main_params, prot_params, rna_params\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"../Data/TrainingData/ReducedEmbeddedTrainingData_2D.pickle\",'rb') as infile:\n",
    "    data = pickle.load(infile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([9752, 1024, 100])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[1].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def MainModelHyperparameter:\n",
    "#     \"\"\"\n",
    "    \n",
    "#     \"\"\"\n",
    "    \n",
    "#     def __init__(self, X):\n",
    "#         pass\n",
    "    \n",
    "#     def"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "DEFAULT_HYPERPARAM_PATH = \"../Data/ModelHyperparameters/DefaultHyperparameters.yaml\"\n",
    "default_hyperparam_handler = DefaultHyperparameterHandler(DEFAULT_HYPERPARAM_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'MainModel': {'batchsize': 32,\n",
       "  'dense_hidden_layers': [5000, 3000, 1000, 500, 100, 50],\n",
       "  'p': 0.3,\n",
       "  'act': 'nn.LeakyReLU()',\n",
       "  'bn': True},\n",
       " 'Dense': {'hidden_layer_sizes': [80, 60, 40, 20],\n",
       "  'bn': True,\n",
       "  'p': 0.2,\n",
       "  'act': 'nn.LeakyReLU()'},\n",
       " 'ConvPool': {'conv_channel_sizes': [110, 20],\n",
       "  'pooling_kernel_sizes': 2,\n",
       "  'pooling_type': 'mixed',\n",
       "  'mixed_a': 0.5,\n",
       "  'ks': 3,\n",
       "  'act_cls': 'nn.LeakyReLU()',\n",
       "  'conv_kwargs': {'act_cls': 'nn.LeakyReLU()'},\n",
       "  'pooling_kwargs': {'stride': 1}},\n",
       " 'Reccurent': {'reccurent_type': 'LSTM',\n",
       "  'bidirectional': True,\n",
       "  'dropout': 0.3,\n",
       "  'num_layers': 3,\n",
       "  'hidden_size': 40},\n",
       " 'Attention': {'layer_count': 16},\n",
       " 'StackedRes': {'hidden_sizes': [100]}}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "default_hyperparam_handler.default_params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = torch.rand(32,1024)\n",
    "prot_Y = torch.rand(32,112,1024)\n",
    "rna_Y  = torch.rand(32,100,1024)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([23, 100, 20])\n",
      "torch.Size([23, 20, 100])\n"
     ]
    }
   ],
   "source": [
    "# GOAL: swap last two tensors\n",
    "x = torch.rand(23,100,20)\n",
    "print(x.shape)\n",
    "x = torch.swapaxes(x,-1,1)\n",
    "print(x.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from Utils.model_blocks import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BlockInputSizeCalculator:\n",
    "    \"\"\"\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, max_rna_len, max_prot_len):\n",
    "        self.max_rna_len = max_rna_len\n",
    "        self.max_prot_len = max_prot_len\n",
    "\n",
    "    def calculate_one_dim_block_input_sizes(self, block, input_tensor):\n",
    "        if block not in ['ConvPool']:\n",
    "            return 1024,1024\n",
    "        else:\n",
    "            return self.max_rna_len, self.max_prot_len\n",
    "            \n",
    "    def calculate_two_dim_block_input_sizes(self, block, input_tensor):\n",
    "        if block not in ['ConvPool', 'Dense']:\n",
    "            return 1024,1024\n",
    "        \n",
    "        if block == 'Dense':\n",
    "            _, width, channel_length = input_tensor.shape\n",
    "            dense_input_size = width * channel_length\n",
    "            return dense_input_size\n",
    "        else:\n",
    "            return self.max_rna_len, self.max_prot_len\n",
    "        \n",
    "    def calculate_block_input_sizes(self, block, input_tensor):\n",
    "        if len(input_tensor.shape) == 2:\n",
    "            return self.calculate_one_dim_block_input_sizes(block, input_tensor)\n",
    "        if len(input_tensor.shape) > 2:\n",
    "            return self.calculate_two_dim_block_input_sizes(block, input_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "class BlockInializer:\n",
    "    \"\"\"\n",
    "    Used to initialize blocks from a string.\n",
    "    \n",
    "    NOTE: This class is only used in this notebook\n",
    "    \"\"\"\n",
    "    \n",
    "    def _reformat_block_act(self, block_params):\n",
    "        preprocessed_block_str = re.sub(r\"'act': 'nn.(.+)\\(\\)'\", r\"'act': nn.\\1()\", block_params)\n",
    "        return preprocessed_block_str\n",
    "    \n",
    "    def generate_block_str(self, block_name, input_size, block_params):\n",
    "        return f\"{block_name}Block({input_size}, **{block_params})\"\n",
    "    \n",
    "    def initialize_block(self, block_name, input_size, block_params):\n",
    "        block_str = self.generate_block_str(block_name, input_size, block_params)\n",
    "        preprocessed_block_str = self._reformat_block_act(block_str)\n",
    "        return eval(preprocessed_block_str)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from Utils.train import BlockInputShapeReformatter, MainModelDenseInputSizeCalculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([32, 1024])\n",
      "torch.Size([32, 100, 1024])\n",
      "torch.Size([32, 112, 1024])\n"
     ]
    }
   ],
   "source": [
    "print(X.shape)\n",
    "print(rna_Y.shape)\n",
    "print(prot_Y.shape)\n",
    "\n",
    "blocks = list(default_hyperparam_handler.default_params.keys())[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "RNA: Dense | Prot: Dense\n",
      "---\n",
      "ERROR: 'BlockInializer' object has no attribute 'initialize_block_from_str'\n",
      "\n",
      "RNA: ConvPool | Prot: ConvPool\n",
      "---\n",
      "ERROR: 'BlockInializer' object has no attribute 'initialize_block_from_str'\n",
      "ERROR: 'BlockInializer' object has no attribute 'initialize_block_from_str'\n",
      "\n",
      "RNA: Reccurent | Prot: Reccurent\n",
      "---\n",
      "ERROR: 'BlockInializer' object has no attribute 'initialize_block_from_str'\n",
      "\n",
      "RNA: Attention | Prot: Attention\n",
      "---\n",
      "ERROR: 'BlockInializer' object has no attribute 'initialize_block_from_str'\n",
      "\n",
      "RNA: StackedRes | Prot: StackedRes\n",
      "---\n",
      "ERROR: 'BlockInializer' object has no attribute 'initialize_block_from_str'\n"
     ]
    }
   ],
   "source": [
    "##########################################\n",
    "# Test individual block creation\n",
    "##########################################\n",
    "\n",
    "for block in blocks:\n",
    "    print(f\"\"\"\n",
    "RNA: {block} | Prot: {block}\n",
    "---\"\"\")\n",
    "    \n",
    "    _, rna_params, protein_params = default_hyperparam_handler.find_default_hyperparams(f\"RNA_{block}_Protein_{block}\")\n",
    "    \n",
    "    input_size_calculator = BlockInputSizeCalculator(max_rna_len = 100, max_prot_len = 110)\n",
    "    block_initializer = BlockInializer()\n",
    "    shape_reformatter = BlockInputShapeReformatter()\n",
    "    \n",
    "    if block == 'ConvPool':\n",
    "        try:\n",
    "            rna_input_size, prot_input_size = input_size_calculator.calculate_block_input_sizes(block, prot_Y)\n",
    "\n",
    "            formatted_rna_input = shape_reformatter.reformat_input(block, rna_Y)\n",
    "            formatted_prot_input = shape_reformatter.reformat_input(block, prot_Y)\n",
    "\n",
    "            rna_block = block_initializer.initialize_block_from_str(block, rna_input_size, rna_params)\n",
    "            prot_block = block_initializer.initialize_block_from_str(block, prot_input_size, protein_params)\n",
    "\n",
    "            rna_block(formatted_rna_input)\n",
    "            print(\"2D RNA Input success\")\n",
    "\n",
    "            prot_block(formatted_prot_input)\n",
    "            print(\"2D Protein Input success\")\n",
    "\n",
    "        except:\n",
    "            print(f\"ERROR: {sys.exc_info()[1]}\")\n",
    "    \n",
    "    try:\n",
    "        rna_input_size, prot_input_size = input_size_calculator.calculate_block_input_sizes(block, X)\n",
    "        \n",
    "        formatted_input = shape_reformatter.reformat_input(block, X)\n",
    "        \n",
    "        rna_block = block_initializer.initialize_block_from_str(block, rna_input_size, rna_params)\n",
    "        \n",
    "#         if block == 'StackedRes':\n",
    "#             print(rna_block)\n",
    "            \n",
    "        prot_block = block_initializer.initialize_block_from_str(block, prot_input_size, protein_params)\n",
    "        \n",
    "        rna_block(formatted_input)\n",
    "        prot_block(formatted_input)\n",
    "        print(\"1D Input success\")\n",
    "        \n",
    "    except:\n",
    "        print(f\"ERROR: {sys.exc_info()[1]}\")\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---\n",
      "RNA: Dense | Prot: Dense\n",
      "ERROR: name 'InputSizeCalculator' is not defined\n",
      "---\n",
      "RNA: ConvPool | Prot: ConvPool\n",
      "ERROR: __init__() got multiple values for argument 'conv_channel_sizes'\n",
      "---\n",
      "RNA: Reccurent | Prot: Reccurent\n",
      "ERROR: name 'InputSizeCalculator' is not defined\n",
      "---\n",
      "RNA: Attention | Prot: Attention\n",
      "ERROR: name 'InputSizeCalculator' is not defined\n",
      "---\n",
      "RNA: StackedRes | Prot: StackedRes\n",
      "ERROR: name 'InputSizeCalculator' is not defined\n"
     ]
    }
   ],
   "source": [
    "###############################\n",
    "# Test main model incorperation\n",
    "###############################\n",
    "\n",
    "# main_model_params, rna_params, protein_params = default_hyperparam_handler.find_default_hyperparams(f\"RNA_{block}_Protein_{block}\")\n",
    "\n",
    "# BATCHSIZE = main_model_params.pop('batchsize')\n",
    "# MAIN_ACT = eval(main_model_params.pop('act'))\n",
    "\n",
    "for block in blocks:\n",
    "    print(f\"---\\nRNA: {block} | Prot: {block}\")\n",
    "    _, rna_params, protein_params = default_hyperparam_handler.find_default_hyperparams(f\"RNA_{block}_Protein_{block}\")\n",
    "    \n",
    "    block_input_size_calculator = BlockInputSizeCalculator(max_rna_len = 100, max_prot_len = 110)\n",
    "    block_initializer = BlockInializer()\n",
    "    shape_reformatter = BlockInputShapeReformatter()\n",
    "    \n",
    "    try:\n",
    "        rna_input_size, prot_input_size = block_input_size_calculator.calculate_block_input_sizes(block, X)\n",
    "        \n",
    "        formatted_input = shape_reformatter.reformat_input(block, X)\n",
    "        \n",
    "        rna_block = block_initializer.initialize_block(block, rna_input_size, rna_params)\n",
    "        prot_block = block_initializer.initialize_block(block, prot_input_size, protein_params)\n",
    "        \n",
    "        input_calculator = InputSizeCalculator(formatted_input, formatted_input)\n",
    "    \n",
    "        input_size = input_calculator.calcualte_input_shape(rna_blocks  = [rna_block.cpu()], \n",
    "                                                            prot_blocks = [prot_block.cpu()])\n",
    "        \n",
    "        model = MainModel(rna_blocks  = [rna_block],\n",
    "                          prot_blocks = [prot_block],\n",
    "                          dense_input_size = input_size,\n",
    "                          act = MAIN_ACT,\n",
    "                          **main_model_params)\n",
    "        \n",
    "        model(formatted_input,formatted_input)\n",
    "        \n",
    "        print(\"Blocks passed through MainModel\")\n",
    "        \n",
    "    except:\n",
    "        print(f\"ERROR: {sys.exc_info()[1]}\")\n",
    "    \n",
    "#     if block == 'ConvPool':\n",
    "#         try:\n",
    "#             rna_input_size, prot_input_size = input_size_calculator.calculate_block_input_sizes(block, prot_Y)\n",
    "\n",
    "#             formatted_rna_input = shape_reformatter.reformat_input(block, rna_Y)\n",
    "#             formatted_prot_input = shape_reformatter.reformat_input(block, prot_Y)\n",
    "\n",
    "#             rna_block = block_initializer.initialize_block_from_str(block, rna_input_size, rna_params)\n",
    "#             prot_block = block_initializer.initialize_block_from_str(block, prot_input_size, protein_params)\n",
    "\n",
    "#             rna_block(formatted_rna_input)\n",
    "#             print(\"2D RNA Input success\")\n",
    "\n",
    "#             prot_block(formatted_prot_input)\n",
    "#             print(\"2D Protein Input success\")\n",
    "\n",
    "#         except:\n",
    "#             print(f\"ERROR: {sys.exc_info()[1]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attention success\n",
      "Reccurent success\n",
      "StackedRes success\n",
      "Dense success\n",
      "DenseProtSAE success\n",
      "DenseRNASAE success\n"
     ]
    }
   ],
   "source": [
    "###############################\n",
    "# Test 1D blocks invidiually\n",
    "# \n",
    "# ConvPool is not applicable here\n",
    "###############################\n",
    "\n",
    "attention = AttentionBlock(1024, layer_count = 100)\n",
    "attention(X)\n",
    "\n",
    "print(\"Attention success\")\n",
    "\n",
    "reccurent = ReccurentBlock(1024, reccurent_type = 'LSTM', bidirectional = True, dropout = 0.3, num_layers = 3, hidden_size = 40)\n",
    "reccurent(X.unsqueeze(1))\n",
    "\n",
    "print(\"Reccurent success\")\n",
    "\n",
    "stackedres = StackedResBlock(1024, [100])\n",
    "# print(stackedres)\n",
    "stackedres(X.unsqueeze(-1));\n",
    "\n",
    "print(\"StackedRes success\")\n",
    "\n",
    "dense = DenseBlock(1024, [500])\n",
    "dense(X)\n",
    "\n",
    "print(\"Dense success\")\n",
    "\n",
    "prot_sae_block = SAEBlock('Dense','/data/Chapter_3/Notebooks/ProtBERT_encoded_110_swissprot_DenseSAE.pt').cpu()\n",
    "prot_sae_block(X)\n",
    "\n",
    "print(\"DenseProtSAE success\")\n",
    "\n",
    "rna_sae_block = SAEBlock('Dense','/data/Chapter_3/Notebooks/rnavec_encoded_aggregated_u_t_swapped_rnas_DenseSAE.pt').cpu()\n",
    "rna_sae_block(X)\n",
    "\n",
    "print(\"DenseRNASAE success\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attention:\n",
      "---\n",
      "Prot success\n",
      "RNA success\n",
      "\n",
      "Reccurent:\n",
      "---\n",
      "Prot success\n",
      "RNA success\n",
      "\n",
      "ConvPool:\n",
      "---\n",
      "INPUT SHAPE: torch.Size([32, 112, 1024])\n",
      "Prot success\n",
      "INPUT SHAPE: torch.Size([32, 100, 1024])\n",
      "RNA success\n",
      "\n",
      "StackedRes:\n",
      "---\n",
      "Prot success\n",
      "RNA success\n",
      "\n",
      "Dense:\n",
      "---\n",
      "Prot success\n",
      "RNA success\n"
     ]
    }
   ],
   "source": [
    "###############################\n",
    "# Test 2D blocks invidiually\n",
    "###############################\n",
    "\n",
    "print(\"\"\"Attention:\n",
    "---\"\"\")\n",
    "attention = AttentionBlock(112, layer_count = 10)\n",
    "attention(prot_Y)\n",
    "print(\"Prot success\")\n",
    "\n",
    "attention = AttentionBlock(100, layer_count = 10)\n",
    "attention(rna_Y)\n",
    "print(\"RNA success\")\n",
    "\n",
    "\n",
    "print(\"\"\"\n",
    "Reccurent:\n",
    "---\"\"\")\n",
    "reccurent = ReccurentBlock(1024, reccurent_type = 'LSTM', bidirectional = True, dropout = 0.3, num_layers = 3, hidden_size = 40)\n",
    "reccurent(prot_Y)\n",
    "\n",
    "print(\"Prot success\")\n",
    "\n",
    "reccurent = ReccurentBlock(1024, reccurent_type = 'LSTM', bidirectional = True, dropout = 0.3, num_layers = 3, hidden_size = 40)\n",
    "reccurent(rna_Y)\n",
    "print(\"RNA success\")\n",
    "\n",
    "print(\"\"\"\n",
    "ConvPool:\n",
    "---\"\"\")\n",
    "# NEEDSSS 2D INPUT, cannot be a restructured 1D input\n",
    "# Input format as: Batchsize x Sequence position x Vector\n",
    "convpool = ConvPoolBlock(conv_channel_sizes = [112,50,25], pooling_kernel_sizes = 2, pooling_type = 'mixed', mixed_a = 0.5)\n",
    "convpool(prot_Y)\n",
    "print(\"Prot success\")\n",
    "\n",
    "convpool = ConvPoolBlock(conv_channel_sizes = [100,50,25], \n",
    "                         pooling_kernel_sizes = 2, pooling_type = 'mixed', mixed_a = 0.5)\n",
    "convpool(rna_Y)\n",
    "print(\"RNA success\")\n",
    "\n",
    "print(\"\"\"\n",
    "StackedRes:\n",
    "---\"\"\")\n",
    "stackedres = StackedResBlock(112, [100])\n",
    "stackedres(prot_Y);\n",
    "print(\"Prot success\")\n",
    "\n",
    "stackedres = StackedResBlock(100, [100])\n",
    "stackedres(rna_Y);\n",
    "print(\"RNA success\")\n",
    "\n",
    "print(\"\"\"\n",
    "Dense:\n",
    "---\"\"\")\n",
    "dense = DenseBlock(1024*112, [500])\n",
    "dense(prot_Y.reshape(32,1024*112))\n",
    "print(\"Prot success\")\n",
    "\n",
    "dense = DenseBlock(1024*100, [500])\n",
    "dense(rna_Y.reshape(32,1024*100))\n",
    "print(\"RNA success\")\n",
    "\n",
    "####################################################\n",
    "# Train Conv SAEs and then test\n",
    "####################################################\n",
    "\n",
    "# prot_sae_block = SAEBlock('Conv','/data/Chapter_3/Notebooks/ProtBERT_encoded_110_swissprot_DenseSAE.pt').cpu()\n",
    "# prot_conv_sae_block(Y)\n",
    "\n",
    "# rna_sae_block = SAEBlock('Conv','/data/Chapter_3/Notebooks/rnavec_encoded_aggregated_u_t_swapped_rnas_DenseSAE.pt').cpu()\n",
    "# rna_conv_sae_block(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvPoolBlock(nn.Module):\n",
    "    \"Try max pool, average pool, and average pool\"\n",
    "    \n",
    "    def __init__(self, conv_channel_sizes, pooling_kernel_sizes, \n",
    "                 pooling_type, mixed_a = 0.5,\n",
    "                 conv_kwargs = dict(), pool_kwargs = dict()):\n",
    "        super().__init__()\n",
    "        \n",
    "        assert pooling_type in ['max','avg','mixed'] \n",
    "        assert len(conv_channel_sizes) >= 2\n",
    "        \n",
    "        if type(pooling_kernel_sizes) == int:\n",
    "            self.pooling_kernel_sizes = [pooling_kernel_sizes for _ in range(len(conv_channel_sizes)-1)]\n",
    "        \n",
    "        self.conv_channel_sizes   = conv_channel_sizes\n",
    "        \n",
    "        assert 0 <= mixed_a <= 1, \"mixed_a must be between 0 and 1\"\n",
    "        assert len(self.conv_channel_sizes)-1 == len(self.pooling_kernel_sizes), \\\n",
    "        \"need equal number of conv_channel_sizes and pooling_kernel_sizes\"\n",
    "        \n",
    "        self.pooling_type = pooling_type\n",
    "        \n",
    "        self.conv_kwargs = conv_kwargs\n",
    "        self.pool_kwargs = pool_kwargs\n",
    "        \n",
    "        self.mixed_a = mixed_a\n",
    "        \n",
    "        self.pool = {'max'   : MaxPool,\n",
    "                     'avg'   : AvgPool,\n",
    "                     'mixed' : partial(MaxAvgPooling, a = self.mixed_a)}\n",
    "        \n",
    "        self.conv = nn.ModuleList([ConvLayer(self.conv_channel_sizes[i-1], self.conv_channel_sizes[i], ndim=1, **self.conv_kwargs) \n",
    "                                   for i in range(1, len(self.conv_channel_sizes))])\n",
    "        \n",
    "        self.pooling = nn.ModuleList([self.pool[self.pooling_type](kernel_size, ndim = 1, **self.pool_kwargs)\n",
    "                                      for kernel_size in self.pooling_kernel_sizes])\n",
    "        \n",
    "    def forward(self, x):\n",
    "        #print(f\"INPUT SHAPE: {x.shape}\")\n",
    "        for i in range(len(self.conv)):\n",
    "            x = self.conv[i](x)\n",
    "            #print(f\"CONV OUTPUT SHAPE: {x.shape}\")\n",
    "            x = self.pooling[i](x)\n",
    "            #print(f\"POOL OUTPUT SHAPE: {x.shape}\")\n",
    "            \n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INPUT SHAPE: torch.Size([32, 112, 1024])\n",
      "CONV OUTPUT SHAPE: torch.Size([32, 93, 1024])\n",
      "POOL OUTPUT SHAPE: torch.Size([32, 93, 512])\n",
      "CONV OUTPUT SHAPE: torch.Size([32, 75, 512])\n",
      "POOL OUTPUT SHAPE: torch.Size([32, 75, 256])\n",
      "CONV OUTPUT SHAPE: torch.Size([32, 56, 256])\n",
      "POOL OUTPUT SHAPE: torch.Size([32, 56, 128])\n",
      "CONV OUTPUT SHAPE: torch.Size([32, 38, 128])\n",
      "POOL OUTPUT SHAPE: torch.Size([32, 38, 64])\n",
      "CONV OUTPUT SHAPE: torch.Size([32, 20, 64])\n",
      "POOL OUTPUT SHAPE: torch.Size([32, 20, 32])\n",
      "Prot success\n"
     ]
    }
   ],
   "source": [
    "# Mess around with ConvPool args to see what works best for arguments\n",
    "\n",
    "\n",
    "convpool = ConvPoolBlock(conv_channel_sizes = [112,93,75,56,38,20], \n",
    "                         pooling_kernel_sizes = 2,\n",
    "                         conv_kwargs = {'ks':5, 'act_cls':nn.LeakyReLU},\n",
    "                         pooling_type = 'avg')\n",
    "\n",
    "convpool(prot_Y)\n",
    "print(\"Prot success\")\n",
    "\n",
    "# convpool(rna_Y)\n",
    "# print(\"RNA success\")\n",
    "# convpool = ConvPoolBlock(conv_channel_sizes = [100,50,25], \n",
    "#                          pooling_kernel_sizes = 2, pooling_type = 'mixed', mixed_a = 0.5)\n",
    "# convpool(rna_Y)\n",
    "# print(\"RNA success\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([112.,  66.,  20.])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(112,20,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.nn.modules.activation import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'hidden_sizes': [100]}"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "protein_params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'initialize_default_block' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-85-aeed7cd76870>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mBLOCK\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mblocks\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0minitialize_default_block\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBLOCK\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1024\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdefault_hyperparam_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdefault_params\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mBLOCK\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'initialize_default_block' is not defined"
     ]
    }
   ],
   "source": [
    "BLOCK = blocks[3] \n",
    "initialize_default_block(BLOCK, 1024, default_hyperparam_handler.default_params[BLOCK])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'initialize_default_block' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-86-1d90066afa18>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprot_block\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minitialize_default_block\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Dense\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1024\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprotein_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'initialize_default_block' is not defined"
     ]
    }
   ],
   "source": [
    "prot_block = initialize_default_block(\"Dense\", 1024, protein_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prot_block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "protein_params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#######################################################\n",
    "# Initialize and train model (80-10-10 train-test-val)\n",
    "#######################################################    \n",
    "protein_block = initialize_default_block(X)\n",
    "rna_block     = initialize_default_block(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'input_calculator' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-87-7b11406c53b3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# REPAIR INPUT CALCULATOR CLASS\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# input_calculator = InputSizeCalculator()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m input_size = input_calculator.calcualte_input_shape(rna_blocks  = [rna_block.cpu()], \n\u001b[0m\u001b[1;32m      4\u001b[0m                                                     prot_blocks = [protein_block.cpu()])\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'input_calculator' is not defined"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# REPAIR INPUT CALCULATOR CLASS\n",
    "# input_calculator = InputSizeCalculator()\n",
    "input_size = input_calculator.calcualte_input_shape(rna_blocks  = [rna_block.cpu()], \n",
    "                                                    prot_blocks = [protein_block.cpu()])\n",
    "\n",
    "model_model = MainModel(rna_blocks  = [rna_block],\n",
    "                        prot_blocks = [protein_block],\n",
    "                        dense_input_size = input_size,\n",
    "                        dense_hidden_layers = [5000,2500,1250,625,322,161,80,40,20], \n",
    "                        p = 0.2,\n",
    "                        act = nn.LeakyReLU()).cuda()\n",
    "\n",
    "learner = Learner(loaders, model,\n",
    "                  loss_func = nn.BCELoss(),\n",
    "                  splitter = main_model_splitter,\n",
    "                  model_dir = '.'\n",
    "                  )\n",
    "\n",
    "lr_min, lr_steep = learner.lr_find()\n",
    "learner.fit_one_cycle(10, lr_max = slice(lr_steep, lr_min))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Old, but might still be useful sometime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.preprocessing import KBinsDiscretizer\n",
    "from torch.utils.data import WeightedRandomSampler\n",
    "import torch\n",
    "\n",
    "import random \n",
    "\n",
    "SEED = 255\n",
    "POSITIVE_SAMPLES = 12161\n",
    "PAIRS = round(POSITIVE_SAMPLES / 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "PAIRS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## FIRE negative scoring gradient sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "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>uniprot1</th>\n",
       "      <th>uniprot2</th>\n",
       "      <th>seq_similarity</th>\n",
       "      <th>func_similarity</th>\n",
       "      <th>domain_similarity</th>\n",
       "      <th>similarity_score</th>\n",
       "      <th>species</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>P61014</td>\n",
       "      <td>Q30KN4</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>Mus musculus</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Q9JHY3</td>\n",
       "      <td>P63213</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>Mus musculus</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>P35754</td>\n",
       "      <td>Q8N6N7</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>Homo sapiens</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>P35754</td>\n",
       "      <td>Q9NZ45</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>Homo sapiens</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>P35754</td>\n",
       "      <td>O14625</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>Homo sapiens</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",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4190</th>\n",
       "      <td>P13500</td>\n",
       "      <td>P80098</td>\n",
       "      <td>0.74</td>\n",
       "      <td>0.30</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.68</td>\n",
       "      <td>Homo sapiens</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4191</th>\n",
       "      <td>P51671</td>\n",
       "      <td>P80098</td>\n",
       "      <td>0.69</td>\n",
       "      <td>0.40</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.70</td>\n",
       "      <td>Homo sapiens</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4192</th>\n",
       "      <td>P09341</td>\n",
       "      <td>P19876</td>\n",
       "      <td>0.87</td>\n",
       "      <td>0.50</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.79</td>\n",
       "      <td>Homo sapiens</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4193</th>\n",
       "      <td>Q96FJ2</td>\n",
       "      <td>P63167</td>\n",
       "      <td>0.93</td>\n",
       "      <td>0.46</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.80</td>\n",
       "      <td>Homo sapiens</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4194</th>\n",
       "      <td>P61024</td>\n",
       "      <td>P33552</td>\n",
       "      <td>0.81</td>\n",
       "      <td>0.69</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.83</td>\n",
       "      <td>Homo sapiens</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>4195 rows × 7 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     uniprot1 uniprot2  seq_similarity  func_similarity  domain_similarity  \\\n",
       "0      P61014   Q30KN4            0.00             0.00               0.00   \n",
       "1      Q9JHY3   P63213            0.00             0.00               0.00   \n",
       "2      P35754   Q8N6N7            0.00             0.00               0.00   \n",
       "3      P35754   Q9NZ45            0.00             0.00               0.00   \n",
       "4      P35754   O14625            0.00             0.00               0.00   \n",
       "...       ...      ...             ...              ...                ...   \n",
       "4190   P13500   P80098            0.74             0.30               1.00   \n",
       "4191   P51671   P80098            0.69             0.40               1.00   \n",
       "4192   P09341   P19876            0.87             0.50               1.00   \n",
       "4193   Q96FJ2   P63167            0.93             0.46               1.00   \n",
       "4194   P61024   P33552            0.81             0.69               1.00   \n",
       "\n",
       "      similarity_score       species  \n",
       "0                 0.00  Mus musculus  \n",
       "1                 0.00  Mus musculus  \n",
       "2                 0.00  Homo sapiens  \n",
       "3                 0.00  Homo sapiens  \n",
       "4                 0.00  Homo sapiens  \n",
       "...                ...           ...  \n",
       "4190              0.68  Homo sapiens  \n",
       "4191              0.70  Homo sapiens  \n",
       "4192              0.79  Homo sapiens  \n",
       "4193              0.80  Homo sapiens  \n",
       "4194              0.83  Homo sapiens  \n",
       "\n",
       "[4195 rows x 7 columns]"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "SIMILARITY_FRAME_PATH = \"../Data/TrainingData/NegativeSamples/small_interaction_similarity_frame.csv\"\n",
    "fire_df = pd.read_csv(SIMILARITY_FRAME_PATH)\n",
    "fire_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "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>uniprot1</th>\n",
       "      <th>uniprot2</th>\n",
       "      <th>seq_similarity</th>\n",
       "      <th>func_similarity</th>\n",
       "      <th>domain_similarity</th>\n",
       "      <th>similarity_score</th>\n",
       "      <th>species</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4194</th>\n",
       "      <td>P61024</td>\n",
       "      <td>P33552</td>\n",
       "      <td>0.81</td>\n",
       "      <td>0.69</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.83</td>\n",
       "      <td>Homo sapiens</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4193</th>\n",
       "      <td>Q96FJ2</td>\n",
       "      <td>P63167</td>\n",
       "      <td>0.93</td>\n",
       "      <td>0.46</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.80</td>\n",
       "      <td>Homo sapiens</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4192</th>\n",
       "      <td>P09341</td>\n",
       "      <td>P19876</td>\n",
       "      <td>0.87</td>\n",
       "      <td>0.50</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.79</td>\n",
       "      <td>Homo sapiens</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     uniprot1 uniprot2  seq_similarity  func_similarity  domain_similarity  \\\n",
       "4194   P61024   P33552            0.81             0.69               1.00   \n",
       "4193   Q96FJ2   P63167            0.93             0.46               1.00   \n",
       "4192   P09341   P19876            0.87             0.50               1.00   \n",
       "\n",
       "      similarity_score       species  \n",
       "4194              0.83  Homo sapiens  \n",
       "4193              0.80  Homo sapiens  \n",
       "4192              0.79  Homo sapiens  "
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fire_df.sort_values('similarity_score', ascending=False).iloc[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "bin_assigner = KBinsDiscretizer(n_bins=10, encode='ordinal')\n",
    "fire_bins    = bin_assigner.fit_transform(fire_df['similarity_score'].values.reshape(-1, 1) ).squeeze().astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_kbin_data(df, x, y, ax, **kwargs):\n",
    "    sbn.boxplot(x = x, y = y, data = df, ax = ax, **kwargs)\n",
    "    ax.set_title(\"Score bins\")\n",
    "    ax.set_xlabel(\"bins\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_score_distributions(df, x, score_bins, ax, **kwargs):\n",
    "    sbn.histplot(x=x, hue=score_bins, data = df, ax = ax, **kwargs)\n",
    "    ax.set_title(\"Score distribution\")\n",
    "    leg = ax.get_legend()\n",
    "    leg.set_title(\"bins\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(1,2, figsize = (6,3))\n",
    "\n",
    "# fig.suptitle(\"FIRE similarity score quantile split\")\n",
    "\n",
    "plot_kbin_data(fire_df, fire_bins, \"similarity_score\", axes[0])\n",
    "plot_score_distributions(fire_df, \"similarity_score\", fire_bins, axes[1])\n",
    "\n",
    "plt.tight_layout()\n",
    "sbn.despine()\n",
    "\n",
    "# if FIGPATH:\n",
    "#     plt.savefig(FIGPATH, dpi = 300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above graphs suggest that the dataset is so 0 heavy that it can't even be split into 10 quantiles. For the 4 quantiles it does generate, the score is so imbalanced that negative sampling wouldn't be viable here. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SAE vector-difference magnitude scoring gradient sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "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>Protein_name</th>\n",
       "      <th>NCBI_GeneID</th>\n",
       "      <th>Protein_Type</th>\n",
       "      <th>Also_species</th>\n",
       "      <th>proteins</th>\n",
       "      <th>Protein_name.1</th>\n",
       "      <th>NCBI_GeneID.1</th>\n",
       "      <th>Protein_Type.1</th>\n",
       "      <th>Also_species.1</th>\n",
       "      <th>proteins.1</th>\n",
       "      <th>difference_magnitudes</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>RPL41</td>\n",
       "      <td>6171.00</td>\n",
       "      <td>protein</td>\n",
       "      <td>Homo sapiens</td>\n",
       "      <td>MRAKWRKKRMRRLKRKRRKMRQRSK</td>\n",
       "      <td>KRTAP19-1</td>\n",
       "      <td>337882.00</td>\n",
       "      <td>protein</td>\n",
       "      <td>Homo sapiens</td>\n",
       "      <td>MSHYGSYYGGLGYSCGGFGGLGYGYGCGCGSFCRRGSGCGYGGYGYGSGFGSYGYGSGFGGYGYGSGFGGYGYGCCRPSYNGGYGFSGFY</td>\n",
       "      <td>24.88</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>RPL41</td>\n",
       "      <td>6171.00</td>\n",
       "      <td>protein</td>\n",
       "      <td>Homo sapiens</td>\n",
       "      <td>MRAKWRKKRMRRLKRKRRKMRQRSK</td>\n",
       "      <td>KRTAP6-1</td>\n",
       "      <td>337966.00</td>\n",
       "      <td>protein</td>\n",
       "      <td>Homo sapiens</td>\n",
       "      <td>MCGSYYGNYYGTPGYGFCGYGGLGYGYGGLGCGYGSCCGCGFRRLGCGYGYGSRSLCGYGYGCGSGSGYYY</td>\n",
       "      <td>24.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lyrm7</td>\n",
       "      <td>75530.00</td>\n",
       "      <td>protein</td>\n",
       "      <td>Mus musculus</td>\n",
       "      <td>MGQPAKVLQLFKTLHRTRQQVFKNDKRALEAARVKINEEFKKHKNETSPEKIKEMMKLGSDVELLLRTAVIQGIHTDHDTLQLVPRKDLLTENVPYCDAPTQKQ</td>\n",
       "      <td>Prm1</td>\n",
       "      <td>19118.00</td>\n",
       "      <td>TF</td>\n",
       "      <td>Mus musculus</td>\n",
       "      <td>MARYRCCRSKSRSRCRRRRRRCRRRRRRCCRRRRRRCCRRRRSYTIRCKKY</td>\n",
       "      <td>24.30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>LYRM7</td>\n",
       "      <td>90624.00</td>\n",
       "      <td>protein</td>\n",
       "      <td>Homo sapiens</td>\n",
       "      <td>MGRAVKVLQLFKTLHRTRQQVFKNDARALEAARIKINEEFKNNKSETSSKKIEELMKIGSDVELLLRTSVIQGIHTDHNTLKLVPRKDLLVENVPYCDAPTQKQ</td>\n",
       "      <td>Prm1</td>\n",
       "      <td>19118.00</td>\n",
       "      <td>TF</td>\n",
       "      <td>Mus musculus</td>\n",
       "      <td>MARYRCCRSKSRSRCRRRRRRCRRRRRRCCRRRRRRCCRRRRSYTIRCKKY</td>\n",
       "      <td>24.22</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>SRP9</td>\n",
       "      <td>6726.00</td>\n",
       "      <td>protein</td>\n",
       "      <td>Homo sapiens</td>\n",
       "      <td>MPQYQTWEEFSRAAEKLYLADPMKARVVLKYRHSDGNLCVKVTDDLVCLVYKTDQAQDVKKIEKFHSQLMRLMVAKEARNVTMETE</td>\n",
       "      <td>Prm1</td>\n",
       "      <td>19118.00</td>\n",
       "      <td>TF</td>\n",
       "      <td>Mus musculus</td>\n",
       "      <td>MARYRCCRSKSRSRCRRRRRRCRRRRRRCCRRRRRRCCRRRRSYTIRCKKY</td>\n",
       "      <td>24.10</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Protein_name  NCBI_GeneID Protein_Type  Also_species  \\\n",
       "0        RPL41      6171.00      protein  Homo sapiens   \n",
       "1        RPL41      6171.00      protein  Homo sapiens   \n",
       "2        Lyrm7     75530.00      protein  Mus musculus   \n",
       "3        LYRM7     90624.00      protein  Homo sapiens   \n",
       "4         SRP9      6726.00      protein  Homo sapiens   \n",
       "\n",
       "                                                                                                   proteins  \\\n",
       "0                                                                                 MRAKWRKKRMRRLKRKRRKMRQRSK   \n",
       "1                                                                                 MRAKWRKKRMRRLKRKRRKMRQRSK   \n",
       "2  MGQPAKVLQLFKTLHRTRQQVFKNDKRALEAARVKINEEFKKHKNETSPEKIKEMMKLGSDVELLLRTAVIQGIHTDHDTLQLVPRKDLLTENVPYCDAPTQKQ   \n",
       "3  MGRAVKVLQLFKTLHRTRQQVFKNDARALEAARIKINEEFKNNKSETSSKKIEELMKIGSDVELLLRTSVIQGIHTDHNTLKLVPRKDLLVENVPYCDAPTQKQ   \n",
       "4                    MPQYQTWEEFSRAAEKLYLADPMKARVVLKYRHSDGNLCVKVTDDLVCLVYKTDQAQDVKKIEKFHSQLMRLMVAKEARNVTMETE   \n",
       "\n",
       "  Protein_name.1  NCBI_GeneID.1 Protein_Type.1 Also_species.1  \\\n",
       "0      KRTAP19-1      337882.00        protein   Homo sapiens   \n",
       "1       KRTAP6-1      337966.00        protein   Homo sapiens   \n",
       "2           Prm1       19118.00             TF   Mus musculus   \n",
       "3           Prm1       19118.00             TF   Mus musculus   \n",
       "4           Prm1       19118.00             TF   Mus musculus   \n",
       "\n",
       "                                                                                   proteins.1  \\\n",
       "0  MSHYGSYYGGLGYSCGGFGGLGYGYGCGCGSFCRRGSGCGYGGYGYGSGFGSYGYGSGFGGYGYGSGFGGYGYGCCRPSYNGGYGFSGFY   \n",
       "1                     MCGSYYGNYYGTPGYGFCGYGGLGYGYGGLGCGYGSCCGCGFRRLGCGYGYGSRSLCGYGYGCGSGSGYYY   \n",
       "2                                         MARYRCCRSKSRSRCRRRRRRCRRRRRRCCRRRRRRCCRRRRSYTIRCKKY   \n",
       "3                                         MARYRCCRSKSRSRCRRRRRRCRRRRRRCCRRRRRRCCRRRRSYTIRCKKY   \n",
       "4                                         MARYRCCRSKSRSRCRRRRRRCRRRRRRCCRRRRRRCCRRRRSYTIRCKKY   \n",
       "\n",
       "   difference_magnitudes  \n",
       "0                  24.88  \n",
       "1                  24.50  \n",
       "2                  24.30  \n",
       "3                  24.22  \n",
       "4                  24.10  "
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sae_df = pd.read_csv('../Data/TrainingData/NegativeSamples/latent_protein_pair_differences.csv')\n",
    "sae_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60726, 11)"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sae_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "bin_assigner = KBinsDiscretizer(n_bins=10, encode='ordinal')\n",
    "sae_bins     = bin_assigner.fit_transform(sae_df['difference_magnitudes'].values.reshape(-1, 1) ).squeeze().astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'generate_highest_or_lowest_samples' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-79-66bc941b9d62>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mgenerate_highest_or_lowest_samples\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msae_df\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'difference_magnitudes'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mPAIRS\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhighest\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'generate_highest_or_lowest_samples' is not defined"
     ]
    }
   ],
   "source": [
    "generate_highest_or_lowest_samples(sae_df, 'difference_magnitudes', PAIRS, highest = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sae_df['bin'] = sae_bins\n",
    "\n",
    "fig, axes = plt.subplots(2,4, figsize = (5,5), sharey = True, sharex = True)\n",
    "\n",
    "i = 0\n",
    "\n",
    "for distribution in SAMPLING_DISTRIBUTIONS.keys():\n",
    "    \n",
    "    n = i>3\n",
    "    k = i if i <= 3 else i - 4\n",
    "    \n",
    "    WEIGHT_ASSIGNER = dict(zip(range(10), SAMPLING_DISTRIBUTIONS[distribution]))\n",
    "    \n",
    "    sae_df['weights'] = sae_df['bin'].apply(lambda x: WEIGHT_ASSIGNER[x])\n",
    "\n",
    "    torch.manual_seed(SEED)\n",
    "    negative_pair_idx = list(WeightedRandomSampler(sae_df['weights'], PAIRS, replacement=False))\n",
    "    \n",
    "    sbn.countplot(x = \"bin\", data = sae_df.iloc[negative_pair_idx], \n",
    "                  ax = axes[int(n),k], palette= 'summer')\n",
    "    \n",
    "    axes[int(n),k].set_title(distribution.replace('_','\\n'))\n",
    "    \n",
    "    i += 1\n",
    "\n",
    "plt.tight_layout()\n",
    "sbn.despine()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "FIGPATH = \"FIRE_and_SAE_scoring_distributions.png\"\n",
    "\n",
    "fig, axes = plt.subplots(2,2, figsize = (6,8))\n",
    "\n",
    "PALETTE_ONE = 'Blues_r'\n",
    "PALETTE_TWO = 'Greens'\n",
    "\n",
    "plot_kbin_data(fire_df, fire_bins, \"similarity_score\", axes[0,0])\n",
    "plot_score_distributions(fire_df, \"similarity_score\", fire_bins, axes[0,1], palette = PALETTE_ONE, bins = 50)\n",
    "\n",
    "plot_kbin_data(sae_df, sae_bins, \"difference_magnitudes\", axes[1,0])\n",
    "plot_score_distributions(sae_df, \"difference_magnitudes\", sae_bins, axes[1,1], palette = PALETTE_TWO)\n",
    "\n",
    "axes[0,1].set_xlabel(\"FIRE similarity scores\")\n",
    "axes[1,1].set_xlabel(\"SAE difference magnitudes\")\n",
    "\n",
    "axes[0,1].set_ylim(None, 3000)\n",
    "axes[1,1].set_ylim(None, 1800)\n",
    "axes[0,0].set_ylabel(\"FIRE similarity scores\")\n",
    "axes[1,0].set_ylabel(\"SAE difference magnitudes\")\n",
    "\n",
    "sbn.despine()\n",
    "plt.tight_layout()\n",
    "\n",
    "if FIGPATH:\n",
    "    plt.savefig(FIGPATH, dpi = 300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/data/Chapter_3/Notebooks'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "swaedxs"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "NegativeSampling",
   "language": "python",
   "name": "negativesampling"
  },
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}