{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "import sys\n",
    "import os\n",
    "import numpy as np\n",
    "\n",
    "import scipy.sparse as sp\n",
    "import scipy.io as spio\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.cm as cm\n",
    "\n",
    "from scipy.stats import norm\n",
    "\n",
    "from prepare_aparent_data_helpers import *\n",
    "\n",
    "import isolearn.io as isoio\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<h2>Load and Aggregate designed MPRA</h2>\n",
    "<br/>\n",
    "Load the processed dataframe and cut matrix of the designed MPRA library.\n",
    "<br/>\n",
    "Group and aggregate the dataset as four separate versions:<br/>\n",
    "-- Group by: Barcode+Sequence and Version <br/>\n",
    "-- Group by: Barcode+Sequence <br/>\n",
    "-- Group by: Sequence and Version <br/>\n",
    "-- Group by: Sequence <br/>\n",
    "<br/>\n",
    "Version corresponds to two independent library constructions: (1) LoFi Array (2) HiFi Array.<br/>\n",
    "Sequence corresponds to the 50 nt USE - 6 nt CSE - 108 nt DSE designed sequence.<br/>\n",
    "Barcode corresponds to the 20 nt random barcode sequence placed upstream of the USE. <br/>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "444220\n",
      "Collapsing with groupby = ['master_seq', 'array_version']\n",
      "Filtering...\n",
      "Size before filtering = 444220\n",
      "Size after filtering = 323890\n",
      "Grouped dataframe.\n",
      "Filtering...\n",
      "Summarizing...\n",
      "Dropping intermediate columns...\n",
      "Size(master_seq_ver_df) = 79078\n",
      "Collapsing with groupby = ['master_seq']\n",
      "Filtering...\n",
      "Size before filtering = 444220\n",
      "Size after filtering = 323890\n",
      "Grouped dataframe.\n",
      "Filtering...\n",
      "Summarizing...\n",
      "Dropping intermediate columns...\n",
      "Size(master_seq_df) = 39833\n"
     ]
    }
   ],
   "source": [
    "#Load Array data\n",
    "\n",
    "library_name = 'array_noacut_score_50'\n",
    "library_version = 'unfiltered'\n",
    "\n",
    "#Read dataframe and cut matrices\n",
    "folder_path = 'designed_mpra/processed_data/' + library_version + '/'\n",
    "\n",
    "df = pd.read_csv(folder_path + library_name + '_' + library_version + '_misprime_mapped.csv', delimiter=',').reset_index(drop=True)\n",
    "cuts = spio.loadmat(folder_path + library_name + '_' + library_version + '_cuts.mat')['cuts']\n",
    "print(len(df))\n",
    "\n",
    "clinvar_snv_df = pd.read_csv('clinvar_data/processed_data/clinvar_variants.csv', delimiter=('\\t'))\n",
    "\n",
    "misprime_filters = {\n",
    "    'max_iso' : ['misprime_16_of_20'],\n",
    "    'max_cut' : ['misprime_16_of_20'],\n",
    "    'tgta' : ['misprime_16_of_20'],\n",
    "    \n",
    "    'clinvar_wt' : ['misprime_10_of_12', 'misprime_12_of_16', 'misprime_15_of_20'],\n",
    "    'clinvar_mut' : ['misprime_10_of_12', 'misprime_12_of_16', 'misprime_15_of_20'],\n",
    "    'intronic_pas' : ['misprime_10_of_12', 'misprime_12_of_16', 'misprime_15_of_20'],\n",
    "    'acmg_apadb' : ['misprime_10_of_12', 'misprime_12_of_16', 'misprime_15_of_20'],\n",
    "    'acmg_polyadb' : ['misprime_10_of_12', 'misprime_12_of_16', 'misprime_15_of_20'],\n",
    "    'sensitive_genes' : ['misprime_10_of_12', 'misprime_12_of_16', 'misprime_15_of_20'],\n",
    "    'human variant' : ['misprime_10_of_12', 'misprime_12_of_16', 'misprime_15_of_20'],\n",
    "}\n",
    "\n",
    "seq_ver_df_group = group_dataframe(df, cuts, min_total_count=100, drop_nans=False, misprime_filters=misprime_filters, groupby_list=['seq', 'array_version'])\n",
    "\n",
    "seq_ver_df_group = seq_ver_df_group.reset_index()\n",
    "seq_ver_df_group['flat_index'] = seq_ver_df_group['seq'] + '_' + seq_ver_df_group['array_version']\n",
    "seq_ver_df_group = seq_ver_df_group.set_index('flat_index')\n",
    "\n",
    "seq_ver_df = summarize_dataframe(\n",
    "                    seq_ver_df_group,\n",
    "                    min_barcodes=1,\n",
    "                    min_pooled_count=1,\n",
    "                    min_mean_count=1,\n",
    "                    prox_cut_start=70 + 7,\n",
    "                    prox_cut_end=70 + 7 + 30,\n",
    "                    isoform_pseudo_count=1.0,\n",
    "                    pooled_isoform_pseudo_count=2.0,\n",
    "                    cut_pseudo_count=0.0005,\n",
    "                    drop_nans=False#True\n",
    ")\n",
    "\n",
    "seq_ver_df = manual_df_processing(seq_ver_df, clinvar_snv_df)\n",
    "\n",
    "print('Size(seq_ver_df) = ' + str(len(seq_ver_df)))\n",
    "\n",
    "seq_df_group = group_dataframe(df, cuts, min_total_count=100, drop_nans=False, misprime_filters=misprime_filters, groupby_list=['seq'])\n",
    "\n",
    "seq_df = summarize_dataframe(\n",
    "                    seq_df_group,\n",
    "                    min_barcodes=1,\n",
    "                    min_pooled_count=1,\n",
    "                    min_mean_count=1,\n",
    "                    prox_cut_start=70 + 7,\n",
    "                    prox_cut_end=70 + 7 + 30,\n",
    "                    isoform_pseudo_count=1.0,\n",
    "                    pooled_isoform_pseudo_count=2.0,\n",
    "                    cut_pseudo_count=0.0005,\n",
    "                    drop_nans=False#True\n",
    ")\n",
    "\n",
    "seq_df = manual_df_processing(seq_df, clinvar_snv_df)\n",
    "\n",
    "print('Size(seq_df) = ' + str(len(seq_df)))\n",
    "\n",
    "master_seq_ver_df_group = group_dataframe(df, cuts, cut_start=20, min_total_count=100, drop_nans=False, misprime_filters=misprime_filters, groupby_list=['master_seq', 'array_version'])\n",
    "\n",
    "master_seq_ver_df_group = master_seq_ver_df_group.reset_index()\n",
    "master_seq_ver_df_group['flat_index'] = master_seq_ver_df_group['master_seq'] + '_' + master_seq_ver_df_group['array_version']\n",
    "master_seq_ver_df_group = master_seq_ver_df_group.set_index('flat_index')\n",
    "\n",
    "master_seq_ver_df = summarize_dataframe(\n",
    "                    master_seq_ver_df_group,\n",
    "                    min_barcodes=1,\n",
    "                    min_pooled_count=1,\n",
    "                    min_mean_count=1,\n",
    "                    prox_cut_start=50 + 7,\n",
    "                    prox_cut_end=50 + 7 + 30,\n",
    "                    isoform_pseudo_count=1.0,\n",
    "                    pooled_isoform_pseudo_count=2.0,\n",
    "                    cut_pseudo_count=0.0005,\n",
    "                    drop_nans=False#True\n",
    ")\n",
    "\n",
    "master_seq_ver_df = manual_df_processing(master_seq_ver_df, clinvar_snv_df)\n",
    "\n",
    "print('Size(master_seq_ver_df) = ' + str(len(master_seq_ver_df)))\n",
    "\n",
    "master_seq_df_group = group_dataframe(df, cuts, cut_start=20, min_total_count=100, drop_nans=False, misprime_filters=misprime_filters, groupby_list=['master_seq'])\n",
    "\n",
    "master_seq_df = summarize_dataframe(\n",
    "                    master_seq_df_group,\n",
    "                    min_barcodes=1,\n",
    "                    min_pooled_count=1,\n",
    "                    min_mean_count=1,\n",
    "                    prox_cut_start=50 + 7,\n",
    "                    prox_cut_end=50 + 7 + 30,\n",
    "                    isoform_pseudo_count=1.0,\n",
    "                    pooled_isoform_pseudo_count=2.0,\n",
    "                    cut_pseudo_count=0.0005,\n",
    "                    drop_nans=False#True\n",
    ")\n",
    "\n",
    "master_seq_df = manual_df_processing(master_seq_df, clinvar_snv_df)\n",
    "\n",
    "print('Size(master_seq_df) = ' + str(len(master_seq_df)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<h3>Consolidate designed MPRA</h3>\n",
    "<br/>\n",
    "Re-format the Barcode+Sequence- grouped designed MPRA to the same column and sequence format as the random MPRA library.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Format array data to have identical columns and sequence padding as random MPRA library\n",
    "\n",
    "array_df = seq_df.copy()\n",
    "\n",
    "array_df['mask'] = ('N' * 206)\n",
    "array_df['proximal_count'] = array_df['pooled_proximal_count']\n",
    "array_df['distal_count'] = array_df['pooled_distal_count']\n",
    "array_df['total_count'] = array_df['pooled_total_count']\n",
    "array_df['library'] = 'array'\n",
    "array_df['library_index'] = 40\n",
    "array_df['sublibrary'] = array_df['gene']#'array'\n",
    "array_df['sublibrary_index'] = 40\n",
    "\n",
    "array_df = array_df[[\n",
    "    'seq',\n",
    "    'mask',\n",
    "    'proximal_count',\n",
    "    'distal_count',\n",
    "    'total_count',\n",
    "    'library',\n",
    "    'library_index',\n",
    "    'sublibrary',\n",
    "    'sublibrary_index'\n",
    "]]\n",
    "\n",
    "up_padding = 'XXXXXXXXXXTACAAGGCCAAGAAGCCCGTGCAGCTGCCCGGCGCCTACAACGTCAACATCAAGTTGGACATCACCTCCCACAACGAGGACTACACCATCGTGGAACAGTACGAACGCGCCGAGGGCCGCCACTCCACCGGCGGCATGGACGAGCTGTACAAGTCTTGATACACGACGCTCTTCCGATCT'\n",
    "dn_padding = 'TGCGCCTCGACTGTGCCTTCTAGTTGCCAGCCATCTGTTGTTTGCCCCTCCCCCGTGCCTTCCTTGACCCTGGAAGGTGCCACTCCCACTGTCCTTTCCTAATAAAATGAGGAAATTGCA'\n",
    "\n",
    "array_metadata = pd.DataFrame([['array', 40, 'array', 40, up_padding, dn_padding]], columns=['library', 'library_index', 'sublibrary', 'sublibrary_index', 'upstream_padding', 'downstream_padding'])\n",
    "\n",
    "array_cuts = sp.csr_matrix(np.array(list(seq_df['pooled_cuts'].values))[:, :-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Load and Merge random MPRA</h2>\n",
    "<br/>\n",
    "Load the processed dataframe and cut matrix of the random MPRA library.<br/>\n",
    "Append the designed MPRA dataframe and matrix to the random MPRA library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded library size = 3632011\n"
     ]
    }
   ],
   "source": [
    "#Load plasmid dataframe and cut matrices\n",
    "\n",
    "library_name = 'combined_random_plasmid_library_v1'\n",
    "library_version = 'final'\n",
    "\n",
    "folder_path = 'random_mpra/combined_library/processed_data/final/'\n",
    "\n",
    "plasmid_library_dict = {}\n",
    "plasmid_library_dict['metadata'] = pd.read_csv(folder_path + library_name + '_metadata.csv', sep=',').reset_index(drop=True)\n",
    "plasmid_library_dict['data'] = pd.read_csv(folder_path + library_name + '_' + library_version + '.csv', sep=',').reset_index(drop=True)\n",
    "\n",
    "plasmid_library_dict['cuts'] = spio.loadmat(folder_path + library_name + '_' + library_version + '_cuts.mat')['cuts']\n",
    "\n",
    "print('Loaded library size = ' + str(len(plasmid_library_dict['data'])))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Append array data to plasmid data\n",
    "\n",
    "plasmid_library_dict['metadata'] = plasmid_library_dict['metadata'].append(array_metadata).reset_index(drop=True)\n",
    "plasmid_library_dict['data'] = plasmid_library_dict['data'].append(array_df).reset_index(drop=True)\n",
    "plasmid_library_dict['cuts'] = sp.csr_matrix(sp.vstack([plasmid_library_dict['cuts'], array_cuts]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<h3>Filter the random + designed MPRA library</h3>\n",
    "<br/>\n",
    "Filter the combined dataset on specific sublibraries (e.g., TOMM5, Alien1, etc.) and minimum readcount.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Arranging lib 2\n",
      "Arranging lib 5\n",
      "Arranging lib 8\n",
      "Arranging lib 11\n",
      "Arranging lib 20\n",
      "Arranging lib 22\n",
      "Arranging lib 30\n",
      "Arranging lib 31\n",
      "Arranging lib 32\n",
      "Arranging lib 33\n",
      "Arranging lib 34\n",
      "Arranging lib 35\n",
      "Arranging lib 40\n",
      "Prepared library size = 3818077\n",
      "Sublibrary counts:\n",
      "Lib 2 = 220686\n",
      "Lib 5 = 244218\n",
      "Lib 8 = 53319\n",
      "Lib 11 = 194639\n",
      "Lib 20 = 773340\n",
      "Lib 22 = 747674\n",
      "Lib 30 = 30643\n",
      "Lib 31 = 208306\n",
      "Lib 32 = 375912\n",
      "Lib 33 = 483445\n",
      "Lib 34 = 136874\n",
      "Lib 35 = 162955\n",
      "Lib 40 = 186066\n"
     ]
    }
   ],
   "source": [
    "#Filter dataframe and cut matrix with basic library parameters\n",
    "\n",
    "included_libs = [\n",
    "    2,  #TOMM5 Random USE Region 1\n",
    "    5,  #TOMM5 Random USE Region 2\n",
    "    8,  #TOMM5 Random USE Region 1 and Random DSE\n",
    "    11, #TOMM5 Random USE Region 2 and Random DSE\n",
    "    20, #Alien1\n",
    "    22, #Alien2\n",
    "    30, #AARS\n",
    "    31, #ATR\n",
    "    32, #HSPE1\n",
    "    33, #SNHG6\n",
    "    34, #SOX13\n",
    "    35, #WHAMMP2\n",
    "    40  #Designed MPRA\n",
    "]\n",
    "\n",
    "#Filter library on minimum read count\n",
    "minimum_count = 1\n",
    "count_filter = LibraryCountFilter(minimum_count)\n",
    "\n",
    "#Include only selected sub libraries and re-balance the filtered data.\n",
    "balancer = LibraryBalancer(included_libs)\n",
    "\n",
    "plasmid_library_dict = balancer(count_filter(plasmid_library_dict))\n",
    "\n",
    "\n",
    "print('Prepared library size = ' + str(len(plasmid_library_dict['data'])))\n",
    "\n",
    "print('Sublibrary counts:')\n",
    "for lib in included_libs :\n",
    "    print(\"Lib \" + str(lib) + \" = \" + str(len(plasmid_library_dict['data'].query(\"library_index == \" + str(lib)))))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<h3>Plot cumulative library proportions</h3>\n",
    "<br/>\n",
    "The X-axis displays the percentile in the prepared (random + designed) MPRA data.<br/>\n",
    "-- The train set will be taken from the left (lower percentile) portion of the data.<br/>\n",
    "-- The test set will be taken from the right (higher percentile) portion of the data.<br/>\n",
    "<br/>\n",
    "The Y-axis displays the relative proportion of each sublibrary, from the given percentile up to 100% of the data.<br/>\n",
    "-- For example, at 90% of the data, each sublibrary has an equal proportion, meaning the final 10% of the data is perfectly balanced among sublibraries.<br/>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot sublibrary cumulative proportions\n",
    "\n",
    "plot_cumulative_library_proportion(plasmid_library_dict, percentile_step=0.01, figsize=(8, 6), n_xticks=10, n_yticks=10)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<h3>Plot read count distribution</h3>\n",
    "<br/>\n",
    "The X-axis displays the percentile in the prepared (random + designed) MPRA data.<br/>\n",
    "<br/>\n",
    "The Y-axis displays the average sequence read depth at the given percentile.<br/>\n",
    "-- The library is shuffled in such as way that half the high read-count sequences are in the first 50% of the data, improving training performance, while still retaining a high average read depth in the test set (final 10%).<br/>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot read count distribution over library\n",
    "\n",
    "plot_individual_library_count_distribution(plasmid_library_dict, figsize=(8, 6), n_xticks=10, y_max=500)\n",
    "\n",
    "plot_combined_library_count_distribution(plasmid_library_dict, figsize=(8, 6), n_xticks=10, x_min=0.8, x_max=1, y_max=500)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<h3>Plot cut profiles</h3>\n",
    "<br/>\n",
    "The X-axis displays sequence position (position 0 = CSE - 70).<br/>\n",
    "<br/>\n",
    "The Y-axis displays the average cleavage proportion at the given nucleotide per sublibrary.<br/>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot library cut profiles\n",
    "\n",
    "plot_library_cut_profile(plasmid_library_dict, figsize=(8, 6))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<h3>Pad and Dump prepared (random + designed) MPRA data</h3>\n",
    "<br/>\n",
    "Append constant reporter sequence background upstream and downstream of the randomized sequence regions.<br/>\n",
    "Dump the prepared dataframe and cut matrix to file.<br/>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3818077\n"
     ]
    }
   ],
   "source": [
    "#Pad sequences\n",
    "\n",
    "padding_df = plasmid_library_dict['metadata'][['sublibrary_index', 'upstream_padding', 'downstream_padding']].set_index('sublibrary_index')\n",
    "\n",
    "library_df = plasmid_library_dict['data'].join(padding_df, on='sublibrary_index')\n",
    "\n",
    "library_df['padded_seq'] = library_df['upstream_padding'].str.slice(10,190) + library_df['seq'] + library_df['downstream_padding']\n",
    "\n",
    "print(len(library_df))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3818077, 507)\n"
     ]
    }
   ],
   "source": [
    "#Prepare cut matrix\n",
    "\n",
    "cut_mat = sp.csr_matrix(\n",
    "    sp.hstack([\n",
    "        sp.csc_matrix((plasmid_library_dict['cuts'].shape[0], 180)),\n",
    "        sp.csc_matrix(plasmid_library_dict['cuts']),\n",
    "        sp.csc_matrix((plasmid_library_dict['cuts'].shape[0], 120)),\n",
    "        sp.csc_matrix(np.reshape(np.ravel(plasmid_library_dict['data']['distal_count'].values), (-1, 1)))\n",
    "    ])\n",
    ")\n",
    "\n",
    "print(cut_mat.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Dump random+designed MPRA dataset\n",
    "\n",
    "#pickle.dump({'plasmid_df' : library_df, 'plasmid_cuts' : cut_mat}, open('apa_plasmid_data.pickle', 'wb'))\n",
    "isoio.dump({'plasmid_df' : library_df, 'plasmid_cuts' : cut_mat}, 'prepared_data/apa_plasmid_data/apa_plasmid_data')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Load and Aggregate native cell type-specific data</h2>\n",
    "<br/>\n",
    "Load the processed APADB and Leslie data.<br/>\n",
    "Aggregate isoform counts per tissue/celltype and dump as a dataframe.<br/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Load processed leslie and apadb data\n",
    "\n",
    "load_suffix = '_wider_v2'\n",
    "\n",
    "file_path = 'native_data/processed_data/leslie_apadb/final/'\n",
    "\n",
    "index = np.load(file_path + 'leslie_apadb_index' + load_suffix + '.npy')\n",
    "\n",
    "df = pd.read_csv(file_path + 'leslie_apadb_data' + load_suffix + '.csv', sep=',')\n",
    "gene_index = np.load(file_path + 'apadb_gene_index' + load_suffix + '.npy')\n",
    "\n",
    "leslie_cell_type_index = np.load(file_path + 'apadb_celltype_index' + load_suffix + '.npy')\n",
    "leslie_cleavage_count_matrix_dict = spio.loadmat(file_path + 'apadb_cleavage_count' + load_suffix + '.mat')\n",
    "leslie_cleavage_count_matrix_dict_wide = spio.loadmat(file_path + 'apadb_cleavage_count_wide_ext' + load_suffix + '.mat')\n",
    "\n",
    "df['apadb_count_pooled'] = np.load(file_path + 'apadb_orig_count' + load_suffix + '.npy')\n",
    "df['apadb_total_count_pooled'] = np.load(file_path + 'apadb_orig_total_count' + load_suffix + '.npy')\n",
    "\n",
    "df['row_index'] = np.arange(len(df), dtype=np.int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Rename cell type names\n",
    "\n",
    "new_cell_type_index = []\n",
    "for cell_type in leslie_cell_type_index :\n",
    "    new_cell_type_index.append(cell_type.replace('-', '').replace('.', '_'))\n",
    "    \n",
    "    leslie_cleavage_count_matrix_dict[cell_type.replace('-', '').replace('.', '_')] = leslie_cleavage_count_matrix_dict[cell_type]\n",
    "    leslie_cleavage_count_matrix_dict_wide[cell_type.replace('-', '').replace('.', '_')] = leslie_cleavage_count_matrix_dict_wide[cell_type]\n",
    "    \n",
    "    if cell_type.replace('-', '').replace('.', '_') != cell_type :\n",
    "        leslie_cleavage_count_matrix_dict[cell_type] = None\n",
    "        leslie_cleavage_count_matrix_dict_wide[cell_type] = None\n",
    "\n",
    "leslie_cell_type_index = np.array(new_cell_type_index, dtype=np.object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size before filtering = 59731\n",
      "Size after filtering = 51964\n"
     ]
    }
   ],
   "source": [
    "#Do some pre-filtering\n",
    "\n",
    "print('Size before filtering = ' + str(len(df)))\n",
    "\n",
    "df = df.query(\"apadb_total_count_pooled >= 100 and num_sites >= 2 and pas != -1\").copy().reset_index(drop=True)\n",
    "\n",
    "index = index[df['row_index']]\n",
    "gene_index = gene_index[df['row_index']]\n",
    "\n",
    "for cell_type_i, cell_type in enumerate(leslie_cell_type_index) :\n",
    "    leslie_cleavage_count_matrix_dict[cell_type] = leslie_cleavage_count_matrix_dict[cell_type][df['row_index'], :]\n",
    "    leslie_cleavage_count_matrix_dict_wide[cell_type] = leslie_cleavage_count_matrix_dict_wide[cell_type][df['row_index'], :]\n",
    "\n",
    "df = df.drop(columns=['row_index'])\n",
    "df['row_index'] = np.arange(len(df), dtype=np.int)\n",
    "\n",
    "print('Size after filtering = ' + str(len(df)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aggregating counts for tissue = kidney\n",
      "Aggregating counts for tissue = pancreas\n",
      "Aggregating counts for tissue = monocytes\n",
      "Aggregating counts for tissue = all\n",
      "Aggregating counts for tissue = pdac\n",
      "Aggregating counts for tissue = prcc\n",
      "Aggregating counts for tissue = full_blood\n",
      "Aggregating counts for tissue = hlf\n"
     ]
    }
   ],
   "source": [
    "#Add apadb tissue-specific counts to dataframe\n",
    "\n",
    "tissue_dict = {}\n",
    "\n",
    "for tissue in ['kidney', 'pancreas', 'monocytes', 'all', 'pdac', 'prcc', 'full_blood', 'hlf'] :\n",
    "    tissue_df = pd.read_csv('native_data/processed_data/apadb/apadb_' + tissue + '_tissue_data.csv', sep='\\t')\n",
    "    unique_genes = sorted(list(tissue_df['gene_symbol'].unique()))\n",
    "    tissue_df = tissue_df.groupby('gene_symbol')\n",
    "    \n",
    "    tissue_dict[tissue] = {}\n",
    "    for gene in unique_genes :\n",
    "        tissue_dict[tissue][gene] = []\n",
    "        tissue_gene_df = tissue_df.get_group(gene)\n",
    "        for _, row in tissue_gene_df.iterrows() :\n",
    "            tissue_dict[tissue][gene].append({\n",
    "                'reads_supporting_site' : row['reads_supporting_site'],\n",
    "                'total_count' : row['total_count'],\n",
    "                'start' : row['start'],\n",
    "                'end' : row['end']\n",
    "            })\n",
    "\n",
    "for tissue in tissue_dict :\n",
    "    print('Aggregating counts for tissue = ' + str(tissue))\n",
    "    \n",
    "    tissue_counts = []\n",
    "    tissue_total_counts = []\n",
    "    \n",
    "    for index, row in df.iterrows() :\n",
    "        gene = row['gene']\n",
    "        gene_id = row['gene_id']\n",
    "        \n",
    "        tissue_count = 0.\n",
    "        tissue_total_count = 0.\n",
    "        \n",
    "        if gene in tissue_dict[tissue] and len(tissue_dict[tissue][gene]) > 0 :\n",
    "            tissue_total_count = tissue_dict[tissue][gene][0]['total_count']\n",
    "        \n",
    "        cut_start = row['cut_start']\n",
    "        cut_end = row['cut_end']\n",
    "\n",
    "        if gene in tissue_dict[tissue] :\n",
    "            tissue_sites = tissue_dict[tissue][gene]\n",
    "\n",
    "            for tissue_site in tissue_sites :\n",
    "                cand_start = int(tissue_site['start'])\n",
    "                cand_end = int(tissue_site['end'])\n",
    "\n",
    "                if (cand_start >= cut_start and cand_start <= cut_end) or (cand_end >= cut_start and cand_end <= cut_end) :\n",
    "                    tissue_count = float(tissue_site['reads_supporting_site'])\n",
    "                    break\n",
    "        \n",
    "        tissue_counts.append(tissue_count)\n",
    "        tissue_total_counts.append(tissue_total_count)\n",
    "    \n",
    "    df['apadb_count_' + tissue] = tissue_counts\n",
    "    df['apadb_total_count_' + tissue] = tissue_total_counts\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aggregating counts for cell type = hek293\n",
      "Aggregating counts for cell type = mcf10a_hras2\n",
      "Aggregating counts for cell type = mcf10a1\n",
      "Aggregating counts for cell type = mcf10a2\n",
      "Aggregating counts for cell type = mcf10a_hras1\n",
      "Aggregating counts for cell type = bcells1\n",
      "Aggregating counts for cell type = mcf7\n",
      "Aggregating counts for cell type = bcells2\n",
      "Aggregating counts for cell type = ovary\n",
      "Aggregating counts for cell type = breast\n",
      "Aggregating counts for cell type = brain\n",
      "Aggregating counts for cell type = skmuscle\n",
      "Aggregating counts for cell type = blcl\n",
      "Aggregating counts for cell type = hES\n",
      "Aggregating counts for cell type = testis\n",
      "Aggregating counts for cell type = hela\n",
      "Aggregating counts for cell type = ntera\n",
      "Processing APA site 0...\n",
      "Processing APA site 10000...\n",
      "Processing APA site 20000...\n",
      "Processing APA site 30000...\n",
      "Processing APA site 40000...\n",
      "Processing APA site 50000...\n",
      "Aggregating counts for cell type = hek293\n",
      "Aggregating counts for cell type = mcf10a_hras2\n",
      "Aggregating counts for cell type = mcf10a1\n",
      "Aggregating counts for cell type = mcf10a2\n",
      "Aggregating counts for cell type = mcf10a_hras1\n",
      "Aggregating counts for cell type = bcells1\n",
      "Aggregating counts for cell type = mcf7\n",
      "Aggregating counts for cell type = bcells2\n",
      "Aggregating counts for cell type = ovary\n",
      "Aggregating counts for cell type = breast\n",
      "Aggregating counts for cell type = brain\n",
      "Aggregating counts for cell type = skmuscle\n",
      "Aggregating counts for cell type = blcl\n",
      "Aggregating counts for cell type = hES\n",
      "Aggregating counts for cell type = testis\n",
      "Aggregating counts for cell type = hela\n",
      "Aggregating counts for cell type = ntera\n"
     ]
    }
   ],
   "source": [
    "#Add leslie tissue-specific counts to dataframe\n",
    "\n",
    "cut_start = 57\n",
    "cut_end = 87\n",
    "\n",
    "leslie_cleavage_count_matrix_pooled = sp.lil_matrix(leslie_cleavage_count_matrix_dict[leslie_cell_type_index[0]].shape)\n",
    "\n",
    "for cell_type_i, cell_type in enumerate(leslie_cell_type_index) :\n",
    "    print('Aggregating counts for cell type = ' + str(cell_type))\n",
    "    \n",
    "    leslie_cleavage_count_matrix = leslie_cleavage_count_matrix_dict[cell_type]\n",
    "    leslie_cleavage_count_matrix_pooled += sp.coo_matrix(leslie_cleavage_count_matrix)\n",
    "    \n",
    "    leslie_site_counts = leslie_cleavage_count_matrix[:, cut_start:cut_end].sum(axis=1)\n",
    "    \n",
    "    df['leslie_count_' + cell_type] = leslie_site_counts\n",
    "    df['leslie_total_count_' + cell_type] = df.groupby('gene')['leslie_count_' + cell_type].transform(lambda x : x.sum())\n",
    "\n",
    "\n",
    "leslie_cleavage_count_matrix_pooled = sp.csr_matrix(leslie_cleavage_count_matrix_pooled)\n",
    "leslie_site_counts_pooled = leslie_cleavage_count_matrix_pooled[:, cut_start:cut_end].sum(axis=1)\n",
    "\n",
    "df['leslie_count_pooled'] = leslie_site_counts_pooled\n",
    "df['leslie_total_count_pooled'] = df.groupby('gene')['leslie_count_pooled'].transform(lambda x : x.sum())\n",
    "\n",
    "#Add apadb cut region measures\n",
    "\n",
    "leslie_cleavage_count_dense_matrix_dict = {}\n",
    "\n",
    "leslie_count_dict_apadb_region = {}\n",
    "for cell_type in leslie_cell_type_index :\n",
    "    leslie_cleavage_count_dense_matrix_dict[cell_type] = np.array(leslie_cleavage_count_matrix_dict[cell_type].todense())\n",
    "    leslie_count_dict_apadb_region[cell_type] = []\n",
    "\n",
    "leslie_count_dict_apadb_region['pooled'] = []\n",
    "\n",
    "i = 0\n",
    "for _, row in df.iterrows() :\n",
    "    \n",
    "    if i % 10000 == 0 :\n",
    "        print('Processing APA site ' + str(i) + '...')\n",
    "    \n",
    "    strand = row['strand']\n",
    "    \n",
    "    cut_start = row['cut_start']\n",
    "    cut_end = row['cut_end']\n",
    "    pas_pos = row['pas_pos']\n",
    "    \n",
    "    start = 0\n",
    "    end = 1\n",
    "    if strand == '+' :\n",
    "        start = cut_start - pas_pos + 50\n",
    "        end = cut_end - pas_pos + 50\n",
    "    else :\n",
    "        start = pas_pos - cut_end + 56\n",
    "        end = pas_pos - cut_start + 56\n",
    "    \n",
    "    pooled_cuts = np.zeros(186)\n",
    "    \n",
    "    for cell_type in leslie_cell_type_index :\n",
    "        cuts = leslie_cleavage_count_dense_matrix_dict[cell_type][i, :]#np.ravel(leslie_cleavage_count_matrix_dict[cell_type][i, :].todense())\n",
    "        pooled_cuts += cuts\n",
    "        \n",
    "        tissue_count = np.sum(cuts[start:end])\n",
    "        leslie_count_dict_apadb_region[cell_type].append(tissue_count)\n",
    "    \n",
    "    pooled_count = np.sum(pooled_cuts[start:end])\n",
    "    leslie_count_dict_apadb_region['pooled'].append(pooled_count)\n",
    "    \n",
    "    i += 1\n",
    "\n",
    "\n",
    "for cell_type in leslie_cell_type_index :\n",
    "    print('Aggregating counts for cell type = ' + str(cell_type))\n",
    "    \n",
    "    df['leslie_count_apadb_region_' + cell_type] = leslie_count_dict_apadb_region[cell_type]\n",
    "    df['leslie_total_count_apadb_region_' + cell_type] = df.groupby('gene')['leslie_count_apadb_region_' + cell_type].transform(lambda x : x.sum())\n",
    "    \n",
    "df['leslie_count_apadb_region_pooled'] = leslie_count_dict_apadb_region['pooled']\n",
    "df['leslie_total_count_apadb_region_pooled'] = df.groupby('gene')['leslie_count_apadb_region_pooled'].transform(lambda x : x.sum())\n",
    "\n",
    "leslie_cleavage_count_dense_matrix_dict = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of dataframe = 51964\n",
      "Size of wide ext tissue cuts = (51964, 356)\n"
     ]
    }
   ],
   "source": [
    "#Dump APADB and Leslie data\n",
    "\n",
    "print('Size of dataframe = ' + str(len(df)))\n",
    "print('Size of wide ext tissue cuts = ' + str(leslie_cleavage_count_matrix_dict_wide['hek293'].shape))\n",
    "\n",
    "data_dump_dict = { 'df' : df }\n",
    "for cell_type in leslie_cell_type_index :\n",
    "    data_dump_dict[cell_type] = leslie_cleavage_count_matrix_dict_wide[cell_type]\n",
    "\n",
    "isoio.dump(data_dump_dict, 'prepared_data/apa_leslie_apadb_data/apa_leslie_apadb_data')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<h3>Join pair-wise pA sites and filter selection</h3>\n",
    "Join adjacent pA sites such that each data row contains a proximal and distal site.<br/>\n",
    "Filter data set on read count and a few other parameters.<br/>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Leslie tissues = ['hek293' 'mcf10a_hras2' 'mcf10a1' 'mcf10a2' 'mcf10a_hras1' 'bcells1'\n",
      " 'mcf7' 'bcells2' 'ovary' 'breast' 'brain' 'skmuscle' 'blcl' 'hES'\n",
      " 'testis' 'hela' 'ntera']\n",
      "APADB tissues = ['kidney' 'pancreas' 'monocytes' 'all' 'pdac' 'prcc' 'full_blood' 'hlf']\n"
     ]
    }
   ],
   "source": [
    "#Extract isoform count matrices and tissue indexes\n",
    "leslie_tissue_index = np.array(['hek293', 'mcf10a_hras2', 'mcf10a1', 'mcf10a2', 'mcf10a_hras1', 'bcells1', 'mcf7', 'bcells2', 'ovary', 'breast', 'brain', 'skmuscle', 'blcl', 'hES', 'testis', 'hela', 'ntera'], dtype=np.object)\n",
    "apadb_tissue_index = np.array(['kidney', 'pancreas', 'monocytes', 'all', 'pdac', 'prcc', 'full_blood', 'hlf'], dtype=np.object)\n",
    "\n",
    "leslie_isoform_count_matrix = np.concatenate([np.ravel(df['leslie_count_' + tissue]).reshape(-1, 1) for tissue in leslie_tissue_index], axis=1)\n",
    "apadb_isoform_count_matrix = np.concatenate([np.ravel(df['apadb_count_' + tissue]).reshape(-1, 1) for tissue in apadb_tissue_index], axis=1)\n",
    "\n",
    "print('Leslie tissues = ' + str(leslie_tissue_index))\n",
    "print('APADB tissues = ' + str(apadb_tissue_index))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29756\n"
     ]
    }
   ],
   "source": [
    "#Join adjacent sites into pair-wise APA df\n",
    "\n",
    "df['gene_id_dist'] = df['gene_id'].apply(lambda x: '.'.join(x.split('.')[:-1]) + '.' + str(int(x.split('.')[-1]) - 1))\n",
    "\n",
    "df_dist = df.copy().set_index('gene_id')\n",
    "\n",
    "dist_columns = [\n",
    "    'sitenum',\n",
    "    'pas',\n",
    "    'seq',\n",
    "    'wide_seq',\n",
    "    'wide_seq_ext',\n",
    "    'site_type',\n",
    "    'pas_pos',\n",
    "    'cut_start',\n",
    "    'cut_end',\n",
    "    'cut_mode',\n",
    "    'mirna',\n",
    "    'ratio',\n",
    "    'row_index'\n",
    "]\n",
    "\n",
    "for cell_type in leslie_tissue_index :\n",
    "    dist_columns.append('leslie_count_' + cell_type)\n",
    "    dist_columns.append('leslie_count_apadb_region_' + cell_type)\n",
    "dist_columns.append('leslie_count_pooled')\n",
    "dist_columns.append('leslie_count_apadb_region_pooled')\n",
    "\n",
    "for tissue in apadb_tissue_index :\n",
    "    dist_columns.append('apadb_count_' + tissue)\n",
    "dist_columns.append('apadb_count_pooled')\n",
    "\n",
    "df_dist = df_dist[dist_columns]\n",
    "\n",
    "df_pair = df.join(df_dist, on='gene_id_dist', how='inner', lsuffix='_prox', rsuffix='_dist')\n",
    "\n",
    "\n",
    "#Aggregate prox + dist total counts\n",
    "\n",
    "for tissue in leslie_tissue_index :\n",
    "    df_pair['leslie_pair_count_' + tissue] = df_pair['leslie_count_' + tissue + '_prox'] + df_pair['leslie_count_' + tissue + '_dist']\n",
    "    df_pair['leslie_pair_count_apadb_region_' + tissue] = df_pair['leslie_count_apadb_region_' + tissue + '_prox'] + df_pair['leslie_count_apadb_region_' + tissue + '_dist']\n",
    "\n",
    "df_pair['leslie_pair_count_pooled'] = df_pair['leslie_count_pooled_prox'] + df_pair['leslie_count_pooled_dist']\n",
    "df_pair['leslie_pair_count_apadb_region_pooled'] = df_pair['leslie_count_apadb_region_pooled_prox'] + df_pair['leslie_count_apadb_region_pooled_dist']\n",
    "\n",
    "for tissue in apadb_tissue_index :\n",
    "    df_pair['apadb_pair_count_' + tissue] = df_pair['apadb_count_' + tissue + '_prox'] + df_pair['apadb_count_' + tissue + '_dist']\n",
    "df_pair['apadb_pair_count_pooled'] = df_pair['apadb_count_pooled_prox'] + df_pair['apadb_count_pooled_dist']\n",
    "\n",
    "\n",
    "#Compute site distance\n",
    "df_pair['distance'] = np.abs(df_pair['cut_start_dist'] - df_pair['cut_start_prox'])\n",
    "\n",
    "#Filter pair dataframe\n",
    "filter_query = \"(apadb_count_pooled_prox + apadb_count_pooled_dist >= 10) and \"\n",
    "filter_query += \"pas_prox != -1 and pas_dist != -1\"\n",
    "filter_query += \"and (site_type_prox == 'UTR3' or site_type_prox == 'Extension' or site_type_prox == 'Intron')\"\n",
    "filter_query += \"and (site_type_dist == 'UTR3' or site_type_dist == 'Extension' or site_type_dist == 'Intron')\"\n",
    "filter_query += \" and (cut_end_prox - cut_start_prox <= 60) and (cut_end_dist - cut_start_dist <= 60)\"\n",
    "filter_query += \" and (distance >= 40 and distance <= 4000)\"\n",
    "\n",
    "df_pair_filtered = df_pair.query(filter_query).copy().reset_index(drop=True)\n",
    "print(len(df_pair_filtered))\n",
    "\n",
    "df_pair_filtered['row_index'] = np.arange(len(df_pair_filtered), dtype=np.int)\n",
    "\n",
    "\n",
    "#Join cleavage measures and onto filtered pair dataframe\n",
    "keep_index_prox = []\n",
    "keep_index_dist = []\n",
    "\n",
    "for _, row in df_pair_filtered.iterrows() :\n",
    "    keep_index_prox.append(row['row_index_prox'])\n",
    "    keep_index_dist.append(row['row_index_dist'])\n",
    "\n",
    "leslie_cleavage_dict_prox = {}\n",
    "leslie_cleavage_dict_dist = {}\n",
    "for cell_type in leslie_tissue_index :\n",
    "    leslie_cleavage_dict_prox[cell_type] = np.array(leslie_cleavage_count_matrix_dict_wide[cell_type][keep_index_prox, :].todense())\n",
    "    leslie_cleavage_dict_dist[cell_type] = np.array(leslie_cleavage_count_matrix_dict_wide[cell_type][keep_index_dist, :].todense())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of dataframe = 29756\n",
      "Size of prox wide ext tissue cuts = (29756, 356)\n",
      "Size of dist wide ext tissue cuts = (29756, 356)\n"
     ]
    }
   ],
   "source": [
    "#Dump APADB and Leslie pair-wise data\n",
    "\n",
    "print('Size of dataframe = ' + str(len(df_pair_filtered)))\n",
    "print('Size of prox wide ext tissue cuts = ' + str(leslie_cleavage_dict_prox['hek293'].shape))\n",
    "print('Size of dist wide ext tissue cuts = ' + str(leslie_cleavage_dict_dist['hek293'].shape))\n",
    "\n",
    "data_dump_dict = { 'df_pair' : df_pair_filtered }\n",
    "for cell_type in leslie_cell_type_index :\n",
    "    data_dump_dict[cell_type + '_prox'] = sp.csr_matrix(leslie_cleavage_dict_prox[cell_type])\n",
    "    data_dump_dict[cell_type + '_dist'] = sp.csr_matrix(leslie_cleavage_dict_dist[cell_type])\n",
    "\n",
    "isoio.dump(data_dump_dict, 'prepared_data/apa_leslie_apadb_pair_data/apa_leslie_apadb_pair_data')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<h3>Unpivot APADB data</h3>\n",
    "<br/>\n",
    "Unpivot the APADB dataframe such that each row measures one single cell type.<br/>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "len(df_pair_apadb) = 267804\n"
     ]
    }
   ],
   "source": [
    "#Unpivot APADB\n",
    "\n",
    "df_pair_apadb = df_pair_filtered.copy()\n",
    "df_pair_apadb = df_pair_apadb[[\n",
    "    'gene_id', 'strand', 'gene', 'sitenum_prox', 'sitenum_dist', 'num_sites', 'pas_prox', 'pas_dist', 'wide_seq_ext_prox', 'wide_seq_ext_dist', 'mirna_prox', 'mirna_dist', 'site_type_prox', 'site_type_dist', 'pas_pos_prox', 'pas_pos_dist', 'cut_start_prox', 'cut_start_dist', 'cut_end_prox', 'cut_end_dist', 'cut_mode_prox', 'cut_mode_dist', 'apadb_count_pooled_prox', 'apadb_count_pooled_dist', 'apadb_total_count_pooled', 'apadb_pair_count_pooled'\n",
    "]]\n",
    "\n",
    "df_pair_apadb = df_pair_apadb.rename(columns={\n",
    "    'apadb_count_pooled_prox' : 'count_prox',\n",
    "    'apadb_count_pooled_dist' : 'count_dist',\n",
    "    'apadb_total_count_pooled' : 'total_count',\n",
    "    'apadb_pair_count_pooled' : 'pair_count'\n",
    "})\n",
    "df_pair_apadb['source'] = 'apadb'\n",
    "df_pair_apadb['tissue'] = 'pooled'\n",
    "\n",
    "for tissue_i, tissue in enumerate(apadb_tissue_index) :\n",
    "    df_tmp = df_pair_filtered.copy()\n",
    "    df_tmp = df_tmp[[\n",
    "        'gene_id', 'strand', 'gene', 'sitenum_prox', 'sitenum_dist', 'num_sites', 'pas_prox', 'pas_dist', 'wide_seq_ext_prox', 'wide_seq_ext_dist', 'mirna_prox', 'mirna_dist', 'site_type_prox', 'site_type_dist', 'pas_pos_prox', 'pas_pos_dist', 'cut_start_prox', 'cut_start_dist', 'cut_end_prox', 'cut_end_dist', 'cut_mode_prox', 'cut_mode_dist', 'apadb_count_' + tissue + '_prox', 'apadb_count_' + tissue + '_dist', 'apadb_total_count_' + tissue, 'apadb_pair_count_' + tissue\n",
    "    ]]\n",
    "\n",
    "    df_tmp = df_tmp.rename(columns={\n",
    "        'apadb_count_' + tissue + '_prox' : 'count_prox',\n",
    "        'apadb_count_' + tissue + '_dist' : 'count_dist',\n",
    "        'apadb_total_count_' + tissue : 'total_count',\n",
    "        'apadb_pair_count_' + tissue : 'pair_count'\n",
    "    })\n",
    "    \n",
    "    df_tmp['source'] = 'apadb'\n",
    "    df_tmp['tissue'] = tissue\n",
    "    \n",
    "    df_pair_apadb = df_pair_apadb.append(df_tmp)\n",
    "\n",
    "print('len(df_pair_apadb) = ' + str(len(df_pair_apadb)))\n",
    "\n",
    "#Calculate relative APADB cut start and end positions within each sequence\n",
    "\n",
    "def get_start_pos_prox(row) :\n",
    "    if row['strand'] == '+' :\n",
    "        return row['cut_start_prox'] - row['pas_pos_prox'] + 70\n",
    "    else :\n",
    "        return row['pas_pos_prox'] - row['cut_end_prox'] + 76\n",
    "\n",
    "def get_end_pos_prox(row) :\n",
    "    if row['strand'] == '+' :\n",
    "        return row['cut_end_prox'] - row['pas_pos_prox'] + 70\n",
    "    else :\n",
    "        return row['pas_pos_prox'] - row['cut_start_prox'] + 76\n",
    "\n",
    "def get_start_pos_dist(row) :\n",
    "    if row['strand'] == '+' :\n",
    "        return row['cut_start_dist'] - row['pas_pos_dist'] + 70\n",
    "    else :\n",
    "        return row['pas_pos_dist'] - row['cut_end_dist'] + 76\n",
    "\n",
    "def get_end_pos_dist(row) :\n",
    "    if row['strand'] == '+' :\n",
    "        return row['cut_end_dist'] - row['pas_pos_dist'] + 70\n",
    "    else :\n",
    "        return row['pas_pos_dist'] - row['cut_start_dist'] + 76\n",
    "\n",
    "df_pair_apadb['rel_start_prox'] = df_pair_apadb.apply(get_start_pos_prox, axis=1)\n",
    "df_pair_apadb['rel_end_prox'] = df_pair_apadb.apply(get_end_pos_prox, axis=1)\n",
    "\n",
    "df_pair_apadb['rel_start_dist'] = df_pair_apadb.apply(get_start_pos_dist, axis=1)\n",
    "df_pair_apadb['rel_end_dist'] = df_pair_apadb.apply(get_end_pos_dist, axis=1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<h3>Unpivot Leslie data</h3>\n",
    "<br/>\n",
    "Unpivot the Leslie dataframe and cut matrix such that each row measures one single cell type.<br/>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "len(df_pair_apadb) = 535608\n"
     ]
    }
   ],
   "source": [
    "#Unpivot Leslie\n",
    "\n",
    "df_pair_leslie = df_pair_filtered.copy()\n",
    "df_pair_leslie = df_pair_leslie[[\n",
    "    'gene_id', 'strand', 'gene', 'sitenum_prox', 'sitenum_dist', 'num_sites', 'pas_prox', 'pas_dist', 'wide_seq_ext_prox', 'wide_seq_ext_dist', 'mirna_prox', 'mirna_dist', 'site_type_prox', 'site_type_dist', 'pas_pos_prox', 'pas_pos_dist', 'cut_start_prox', 'cut_start_dist', 'cut_end_prox', 'cut_end_dist', 'cut_mode_prox', 'cut_mode_dist', 'leslie_count_apadb_region_pooled_prox', 'leslie_count_apadb_region_pooled_dist', 'leslie_total_count_apadb_region_pooled', 'leslie_pair_count_apadb_region_pooled'\n",
    "]]\n",
    "\n",
    "df_pair_leslie = df_pair_leslie.rename(columns={\n",
    "    'leslie_count_apadb_region_pooled_prox' : 'count_prox',\n",
    "    'leslie_count_apadb_region_pooled_dist' : 'count_dist',\n",
    "    'leslie_total_count_apadb_region_pooled' : 'total_count',\n",
    "    'leslie_pair_count_apadb_region_pooled' : 'pair_count'\n",
    "})\n",
    "df_pair_leslie['source'] = 'leslie'\n",
    "df_pair_leslie['tissue'] = 'pooled'\n",
    "\n",
    "leslie_cut_mat_prox = np.zeros(leslie_cleavage_dict_prox['hek293'].shape)\n",
    "leslie_cut_mat_dist = np.zeros(leslie_cleavage_dict_dist['hek293'].shape)\n",
    "for tissue in leslie_tissue_index :\n",
    "    leslie_cut_mat_prox += leslie_cleavage_dict_prox[tissue][:, :]\n",
    "    leslie_cut_mat_dist += leslie_cleavage_dict_dist[tissue][:, :]\n",
    "\n",
    "for tissue_i, tissue in enumerate(leslie_tissue_index) :\n",
    "    df_tmp = df_pair_filtered.copy()\n",
    "    df_tmp = df_tmp[[\n",
    "        'gene_id', 'strand', 'gene', 'sitenum_prox', 'sitenum_dist', 'num_sites', 'pas_prox', 'pas_dist', 'wide_seq_ext_prox', 'wide_seq_ext_dist', 'mirna_prox', 'mirna_dist', 'site_type_prox', 'site_type_dist', 'pas_pos_prox', 'pas_pos_dist', 'cut_start_prox', 'cut_start_dist', 'cut_end_prox', 'cut_end_dist', 'cut_mode_prox', 'cut_mode_dist', 'leslie_count_apadb_region_' + tissue + '_prox', 'leslie_count_apadb_region_' + tissue + '_dist', 'leslie_total_count_apadb_region_' + tissue, 'leslie_pair_count_apadb_region_' + tissue\n",
    "    ]]\n",
    "\n",
    "    df_tmp = df_tmp.rename(columns={\n",
    "        'leslie_count_apadb_region_' + tissue + '_prox' : 'count_prox',\n",
    "        'leslie_count_apadb_region_' + tissue + '_dist' : 'count_dist',\n",
    "        'leslie_total_count_apadb_region_' + tissue : 'total_count',\n",
    "        'leslie_pair_count_apadb_region_' + tissue : 'pair_count'\n",
    "    })\n",
    "    \n",
    "    df_tmp['source'] = 'leslie'\n",
    "    df_tmp['tissue'] = tissue\n",
    "    \n",
    "    df_pair_leslie = df_pair_leslie.append(df_tmp)\n",
    "    \n",
    "    leslie_cut_mat_prox = np.concatenate([leslie_cut_mat_prox, leslie_cleavage_dict_prox[tissue]], axis=0)\n",
    "    leslie_cut_mat_dist = np.concatenate([leslie_cut_mat_dist, leslie_cleavage_dict_dist[tissue]], axis=0)\n",
    "\n",
    "print('len(df_pair_apadb) = ' + str(len(df_pair_leslie)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<h3>Dump prepared APADB and Leslie data</h3>\n",
    "<br/>\n",
    "Dump the prepared dataframes and cut matrices to file.<br/>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Dump APADB and Leslie data\n",
    "\n",
    "#pickle.dump({'apadb_df' : df_pair_apadb}, open('apa_apadb_data.pickle', 'wb'))\n",
    "#pickle.dump({'leslie_df' : df_pair_leslie, 'leslie_cuts_prox' : sp.csr_matrix(leslie_cut_mat_prox), 'leslie_cuts_dist' : sp.csr_matrix(leslie_cut_mat_dist)}, open('apa_leslie_data.pickle', 'wb'))\n",
    "isoio.dump({'apadb_df' : df_pair_apadb}, 'prepared_data/apa_apadb_data/apa_apadb_data')\n",
    "isoio.dump({'leslie_df' : df_pair_leslie, 'leslie_cuts_prox' : sp.csr_matrix(leslie_cut_mat_prox), 'leslie_cuts_dist' : sp.csr_matrix(leslie_cut_mat_dist)}, 'prepared_data/apa_leslie_data/apa_leslie_data')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Process, Filter and Dump designed MPRA variant data</h2>\n",
    "<br/>\n",
    "Process and dump the designed MPRA data.<br/>\n",
    "Filter data to only retain human variants and dump as a wt/variant pair-wise dataset.<br/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing name suffix = _master_seq\n",
      "len(array_df) = 39833\n",
      "len(seq_df_delta) = 21734\n",
      "Processing name suffix = _master_seq_ver\n",
      "len(array_df) = 79078\n",
      "len(seq_df_delta) = 43202\n"
     ]
    }
   ],
   "source": [
    "#Process and dump designed MPRA data\n",
    "\n",
    "df_list = [\n",
    "    #(seq_df, '_seq'),\n",
    "    #(seq_ver_df, '_seq_ver'),\n",
    "    (master_seq_df, '_master_seq'),\n",
    "    (master_seq_ver_df, '_master_seq_ver')\n",
    "]\n",
    "\n",
    "for agg_df, name_suffix in df_list :\n",
    "    print(\"Processing name suffix = \" + str(name_suffix))\n",
    "    \n",
    "    #Store array data\n",
    "\n",
    "    array_df = agg_df.copy()\n",
    "\n",
    "    if 'master' not in name_suffix :\n",
    "        up_padding = 'TACAAGGCCAAGAAGCCCGTGCAGCTGCCCGGCGCCTACAACGTCAACATCAAGTTGGACATCACCTCCCACAACGAGGACTACACCATCGTGGAACAGTACGAACGCGCCGAGGGCCGCCACTCCACCGGCGGCATGGACGAGCTGTACAAGTCTTGATACACGACGCTCTTCCGATCT'\n",
    "        dn_padding = 'TGCGCCTCGACTGTGCCTTCTAGTTGCCAGCCATCTGTTGTTTGCCCCTCCCCCGTGCCTTCCTTGACCCTGGAAGGTGCCACTCCCACTGTCCTTTCCTAATAAAATGAGGAAATTGCA'\n",
    "        \n",
    "        array_df['seq_ext'] = up_padding + array_df['seq'] + dn_padding\n",
    "        array_df['pooled_cuts_ext'] = array_df['pooled_cuts'].apply(lambda c: np.ravel(np.concatenate([np.zeros((180, 1)), c[:-1].reshape(-1, 1), np.zeros((120, 1)), np.array(c[-1]).reshape(-1, 1)], axis=0)))\n",
    "    else :\n",
    "        up_padding = 'TACAAGGCCAAGAAGCCCGTGCAGCTGCCCGGCGCCTACAACGTCAACATCAAGTTGGACATCACCTCCCACAACGAGGACTACACCATCGTGGAACAGTACGAACGCGCCGAGGGCCGCCACTCCACCGGCGGCATGGACGAGCTGTACAAGTCTTGATACACGACGCTCTTCCGATCTXXXXXXXXXXXXXXXXXXXX'\n",
    "        dn_padding = 'TGCGCCTCGACTGTGCCTTCTAGTTGCCAGCCATCTGTTGTTTGCCCCTCCCCCGTGCCTTCCTTGACCCTGGAAGGTGCCACTCCCACTGTCCTTTCCTAATAAAATGAGGAAATTGCA'\n",
    "\n",
    "        array_df['seq_ext'] = up_padding + array_df['master_seq'] + dn_padding\n",
    "        array_df['pooled_cuts_ext'] = array_df['pooled_cuts'].apply(lambda c: np.ravel(np.concatenate([np.zeros((200, 1)), c[:-1].reshape(-1, 1), np.zeros((120, 1)), np.array(c[-1]).reshape(-1, 1)], axis=0)))\n",
    "    \n",
    "    print(\"len(array_df) = \" + str(len(array_df)))\n",
    "\n",
    "    array_pooled_cuts_ext = sp.csr_matrix(np.array(list(array_df['pooled_cuts_ext'].values)))\n",
    "\n",
    "    array_df = array_df.drop(columns = ['pooled_cuts', 'pooled_cuts_ext', 'mean_cuts', 'mean_cut_prob', 'pooled_cut_prob'])\n",
    "\n",
    "    #pickle.dump({'array_df' : array_df, 'pooled_cuts' : array_pooled_cuts_ext}, open('apa_array_data' + name_suffix + '.pickle', 'wb'))\n",
    "    isoio.dump({'array_df' : array_df, 'pooled_cuts' : array_pooled_cuts_ext}, 'prepared_data/apa_array_data/apa_array_data' + name_suffix)\n",
    "    \n",
    "    \n",
    "    #Store variant data\n",
    "    \n",
    "    seq_df_var = agg_df.query(\"(variant == 'snv' or (experiment == 'tgta' and subexperiment != 'n=0') or (variant == 'indel' and significance == 'Pathogenic')) and wt_seq != 'Unmapped'\").copy()\n",
    "    seq_df_ref = agg_df.query(\"(variant == 'wt' or (experiment == 'tgta' and (subexperiment == 'n=0' or (subexperiment == 'n=1' and tgta_fixed == True)))) and wt_seq != 'Unmapped'\").copy()\n",
    "\n",
    "    var_list = ['seq'] if 'master' not in name_suffix else []\n",
    "    if 'ver' in name_suffix :\n",
    "        var_list.append('array_version')\n",
    "    var_list.extend([\n",
    "        'master_seq',\n",
    "        'wt_seq',\n",
    "        'gene',\n",
    "        'subexperiment',\n",
    "        'significance',\n",
    "        'clinvar_id',\n",
    "        'in_acmg',\n",
    "        'sitetype',\n",
    "        'variant',\n",
    "\n",
    "        'mean_proximal_usage',\n",
    "        'median_proximal_usage',\n",
    "        'pooled_proximal_usage',\n",
    "        'mean_proximal_logodds',\n",
    "        'median_proximal_logodds',\n",
    "        'pooled_proximal_logodds',\n",
    "        'mean_proximal_vs_distal_usage',\n",
    "        'median_proximal_vs_distal_usage',\n",
    "        'pooled_proximal_vs_distal_usage',\n",
    "        'mean_proximal_vs_distal_logodds',\n",
    "        'median_proximal_vs_distal_logodds',\n",
    "        'pooled_proximal_vs_distal_logodds',\n",
    "\n",
    "        'pooled_cuts',\n",
    "        'mean_cuts',\n",
    "\n",
    "        'mean_cut_prob',\n",
    "        'pooled_cut_prob',\n",
    "        'n_barcodes',\n",
    "        'pooled_total_count',\n",
    "        'mean_total_count',\n",
    "        \n",
    "        'tgta_pos_1',\n",
    "        'tgta_pos_2',\n",
    "        'tgta_pos_3',\n",
    "        'tgta_fixed'\n",
    "    ])\n",
    "    seq_df_var = seq_df_var[var_list]\n",
    "\n",
    "    ref_list = ['seq'] if 'master' not in name_suffix else []\n",
    "    if 'ver' in name_suffix :\n",
    "        ref_list.append('array_version')\n",
    "    ref_list.extend([\n",
    "        'master_seq',\n",
    "        'experiment',\n",
    "\n",
    "        'mean_proximal_usage',\n",
    "        'median_proximal_usage',\n",
    "        'pooled_proximal_usage',\n",
    "        'mean_proximal_logodds',\n",
    "        'median_proximal_logodds',\n",
    "        'pooled_proximal_logodds',\n",
    "        'mean_proximal_vs_distal_usage',\n",
    "        'median_proximal_vs_distal_usage',\n",
    "        'pooled_proximal_vs_distal_usage',\n",
    "        'mean_proximal_vs_distal_logodds',\n",
    "        'median_proximal_vs_distal_logodds',\n",
    "        'pooled_proximal_vs_distal_logodds',\n",
    "\n",
    "        'pooled_cuts',\n",
    "        'mean_cuts',\n",
    "\n",
    "        'mean_cut_prob',\n",
    "        'pooled_cut_prob',\n",
    "        'n_barcodes',\n",
    "        'pooled_total_count',\n",
    "        'mean_total_count'\n",
    "    ])\n",
    "    seq_df_ref = seq_df_ref[ref_list]\n",
    "\n",
    "    seq_df_delta = seq_df_var.join(seq_df_ref.set_index('master_seq'), on='wt_seq', lsuffix='_var', rsuffix='_ref', how='inner')\n",
    "    if 'ver' in name_suffix :\n",
    "        seq_df_delta = seq_df_delta.query(\"array_version_var == array_version_ref\").copy()\n",
    "\n",
    "    print(\"len(seq_df_delta) = \" + str(len(seq_df_delta)))\n",
    "\n",
    "    #Map SNV positions\n",
    "\n",
    "    snv_poses = []\n",
    "    for _, row in seq_df_delta.iterrows() :\n",
    "\n",
    "        snv_pos = -1\n",
    "        seq = row['master_seq']\n",
    "        wt_seq = row['wt_seq']\n",
    "\n",
    "        for j in range(0, len(seq)) :\n",
    "            if seq[j] != wt_seq[j] :\n",
    "                snv_pos = j\n",
    "                break\n",
    "\n",
    "        snv_poses.append(snv_pos)\n",
    "\n",
    "    seq_df_delta['snv_pos'] = snv_poses\n",
    "\n",
    "\n",
    "    def differential_prop_test(count_1, total_count_1, count_2, total_count_2) :\n",
    "        p1_hat = count_1 / total_count_1\n",
    "        p2_hat = count_2 / total_count_2\n",
    "        p_hat = (count_1 + count_2) / (total_count_1 + total_count_2)\n",
    "\n",
    "        z = (p1_hat - p2_hat) / np.sqrt(p_hat * (1. - p_hat) * (1. / total_count_1 + 1. / total_count_2))\n",
    "        z_abs = np.abs(z)\n",
    "\n",
    "        z_rv = norm()\n",
    "        p_val = 2. * z_rv.sf(z_abs)\n",
    "        log_p_val = np.log(2) + z_rv.logsf(z_abs)\n",
    "\n",
    "        return p_val, log_p_val\n",
    "\n",
    "    #Compute Delta significance tests\n",
    "    delta_p_vals = []\n",
    "    log_delta_p_vals = []\n",
    "    for _, row in seq_df_delta.iterrows() :\n",
    "\n",
    "        pooled_proximal_count_var = row['pooled_proximal_usage_var'] * row['pooled_total_count_var']\n",
    "        pooled_total_count_var = row['pooled_total_count_var']\n",
    "        pooled_proximal_count_wt = row['pooled_proximal_usage_ref'] * row['pooled_total_count_ref']\n",
    "        pooled_total_count_wt = row['pooled_total_count_ref']\n",
    "\n",
    "        p_val, log_p_val = differential_prop_test(pooled_proximal_count_var, pooled_total_count_var, pooled_proximal_count_wt, pooled_total_count_wt)\n",
    "\n",
    "        delta_p_vals.append(p_val)\n",
    "        log_delta_p_vals.append(log_p_val)\n",
    "\n",
    "    seq_df_delta['delta_p_val'] = delta_p_vals\n",
    "    seq_df_delta['log_delta_p_val'] = log_delta_p_vals\n",
    "\n",
    "    #Compute Delta statistics\n",
    "\n",
    "    seq_df_delta['delta_logodds_true'] = seq_df_delta['pooled_proximal_logodds_var'] - seq_df_delta['pooled_proximal_logodds_ref']\n",
    "    \n",
    "    #Manually annotate variants from the HGMD database\n",
    "    seq_df_delta = manually_annotate_hgmd_variants(seq_df_delta)\n",
    "\n",
    "    if 'master' not in name_suffix :\n",
    "        up_padding = 'TACAAGGCCAAGAAGCCCGTGCAGCTGCCCGGCGCCTACAACGTCAACATCAAGTTGGACATCACCTCCCACAACGAGGACTACACCATCGTGGAACAGTACGAACGCGCCGAGGGCCGCCACTCCACCGGCGGCATGGACGAGCTGTACAAGTCTTGATACACGACGCTCTTCCGATCT'\n",
    "        dn_padding = 'TGCGCCTCGACTGTGCCTTCTAGTTGCCAGCCATCTGTTGTTTGCCCCTCCCCCGTGCCTTCCTTGACCCTGGAAGGTGCCACTCCCACTGTCCTTTCCTAATAAAATGAGGAAATTGCA'\n",
    "\n",
    "        seq_df_delta['seq_var_ext'] = up_padding + seq_df_delta['seq_var'] + dn_padding\n",
    "        seq_df_delta['seq_ref_ext'] = up_padding + seq_df_delta['seq_ref'] + dn_padding\n",
    "\n",
    "        seq_df_delta['pooled_cuts_var_ext'] = seq_df_delta['pooled_cuts_var'].apply(lambda c: np.ravel(np.concatenate([np.zeros((180, 1)), c[:-1].reshape(-1, 1), np.zeros((120, 1)), np.array(c[-1]).reshape(-1, 1)], axis=0)))\n",
    "        seq_df_delta['pooled_cuts_ref_ext'] = seq_df_delta['pooled_cuts_ref'].apply(lambda c: np.ravel(np.concatenate([np.zeros((180, 1)), c[:-1].reshape(-1, 1), np.zeros((120, 1)), np.array(c[-1]).reshape(-1, 1)], axis=0)))\n",
    "    else :\n",
    "        up_padding = 'TACAAGGCCAAGAAGCCCGTGCAGCTGCCCGGCGCCTACAACGTCAACATCAAGTTGGACATCACCTCCCACAACGAGGACTACACCATCGTGGAACAGTACGAACGCGCCGAGGGCCGCCACTCCACCGGCGGCATGGACGAGCTGTACAAGTCTTGATACACGACGCTCTTCCGATCTXXXXXXXXXXXXXXXXXXXX'\n",
    "        dn_padding = 'TGCGCCTCGACTGTGCCTTCTAGTTGCCAGCCATCTGTTGTTTGCCCCTCCCCCGTGCCTTCCTTGACCCTGGAAGGTGCCACTCCCACTGTCCTTTCCTAATAAAATGAGGAAATTGCA'\n",
    "\n",
    "        seq_df_delta['seq_var_ext'] = up_padding + seq_df_delta['master_seq'] + dn_padding\n",
    "        seq_df_delta['seq_ref_ext'] = up_padding + seq_df_delta['wt_seq'] + dn_padding\n",
    "\n",
    "        seq_df_delta['pooled_cuts_var_ext'] = seq_df_delta['pooled_cuts_var'].apply(lambda c: np.ravel(np.concatenate([np.zeros((200, 1)), c[:-1].reshape(-1, 1), np.zeros((120, 1)), np.array(c[-1]).reshape(-1, 1)], axis=0)))\n",
    "        seq_df_delta['pooled_cuts_ref_ext'] = seq_df_delta['pooled_cuts_ref'].apply(lambda c: np.ravel(np.concatenate([np.zeros((200, 1)), c[:-1].reshape(-1, 1), np.zeros((120, 1)), np.array(c[-1]).reshape(-1, 1)], axis=0)))\n",
    "\n",
    "    array_pooled_cuts_var_ext = sp.csr_matrix(np.array(list(seq_df_delta['pooled_cuts_var_ext'].values)))\n",
    "    array_pooled_cuts_ref_ext = sp.csr_matrix(np.array(list(seq_df_delta['pooled_cuts_ref_ext'].values)))\n",
    "\n",
    "    seq_df_delta = seq_df_delta.drop(columns = ['pooled_cuts_var_ext', 'pooled_cuts_var', 'mean_cuts_var', 'mean_cut_prob_var', 'pooled_cut_prob_var'])\n",
    "    seq_df_delta = seq_df_delta.drop(columns = ['pooled_cuts_ref_ext', 'pooled_cuts_ref', 'mean_cuts_ref', 'mean_cut_prob_ref', 'pooled_cut_prob_ref'])\n",
    "\n",
    "    #pickle.dump({'variant_df' : seq_df_delta, 'pooled_cuts_var' : array_pooled_cuts_var_ext, 'pooled_cuts_ref' : array_pooled_cuts_ref_ext}, open('apa_variant_data' + name_suffix + '.pickle', 'wb'))\n",
    "    isoio.dump({'variant_df' : seq_df_delta, 'pooled_cuts_var' : array_pooled_cuts_var_ext, 'pooled_cuts_ref' : array_pooled_cuts_ref_ext}, 'prepared_data/apa_variant_data/apa_variant_data' + name_suffix)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:aparent]",
   "language": "python",
   "name": "conda-env-aparent-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}