diff --git a/analysis/gnomad_v3/gwas_analysis.ipynb b/analysis/gnomad_v3/gwas_catalog_analysis.ipynb similarity index 100% rename from analysis/gnomad_v3/gwas_analysis.ipynb rename to analysis/gnomad_v3/gwas_catalog_analysis.ipynb diff --git a/analysis/gnomad_v3/gwas_causaldb_comparison.ipynb b/analysis/gnomad_v3/gwas_causaldb_comparison.ipynb new file mode 100644 index 0000000..3d9ba12 --- /dev/null +++ b/analysis/gnomad_v3/gwas_causaldb_comparison.ipynb @@ -0,0 +1,1151 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ] + } + ], + "source": [ + "from __future__ import print_function\n", + "import keras\n", + "from keras.models import Sequential, Model, load_model\n", + "from keras import backend as K\n", + "\n", + "import tensorflow as tf\n", + "\n", + "import os\n", + "import pandas as pd\n", + "\n", + "import numpy as np\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.cm as cm\n", + "\n", + "#import aparent.visualization as vis\n", + "\n", + "#from aparent_predictor import *\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#Store variant prediction dataframe\n", + "\n", + "variant_df = pd.read_csv('aparent_resnet_variant_predictions_polyadb_no_sequences_no_cutoff.csv', sep='\\t')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(polyadb_df) = 175451\n" + ] + } + ], + "source": [ + "#Load APADB Data and filter on targeted genes\n", + "\n", + "#genes = ['RUNX1', 'CEBPA', 'GATA2', 'ANKRD26', 'DDX41', 'ETV6', 'PTEN', 'BRCA1', 'BRCA2', 'TP53', 'APC', 'ATM', 'PALB2', 'MSH2', 'MLH1', 'MSH6', 'PMS2', 'MUTYH']\n", + "\n", + "polyadb_df = pd.read_csv('polyadb_processed.csv', sep=',')\n", + "\n", + "#polyadb_df = polyadb_df.loc[polyadb_df['gene'].isin(genes)].reset_index(drop=True).copy()\n", + "polyadb_df = polyadb_df.loc[((~polyadb_df['gene'].isnull()) & (polyadb_df['gene'] != 'na')) & (polyadb_df['pas'] != -1)].reset_index(drop=True).copy()\n", + "\n", + "print('len(polyadb_df) = ' + str(len(polyadb_df)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#Process PolyaDB data\n", + "\n", + "polyadb_df_minus = polyadb_df.query(\"strand == '-'\").copy().reset_index(drop=True)\n", + "polyadb_df_plus = polyadb_df.query(\"strand == '+'\").copy().reset_index(drop=True)\n", + "\n", + "polyadb_df_minus = polyadb_df_minus.sort_values(by='pas_pos', ascending=False).copy().reset_index(drop=True)\n", + "polyadb_df_plus = polyadb_df_plus.sort_values(by='pas_pos', ascending=True).copy().reset_index(drop=True)\n", + "\n", + "new_gene_id_list_plus = []\n", + "sitenum_list_plus = []\n", + "gene_id_dict = {}\n", + "for _, row in polyadb_df_plus.iterrows() :\n", + "\n", + " gene = row['gene']\n", + "\n", + " if gene not in gene_id_dict :\n", + " gene_id_dict[gene] = 0\n", + "\n", + " gene_id_dict[gene] += 1\n", + "\n", + " new_gene_id_list_plus.append(gene + \".\" + str(gene_id_dict[gene]))\n", + " sitenum_list_plus.append(gene_id_dict[gene])\n", + "\n", + "polyadb_df_plus['gene_id'] = new_gene_id_list_plus\n", + "polyadb_df_plus['sitenum'] = sitenum_list_plus\n", + "\n", + "new_gene_id_list_minus = []\n", + "sitenum_list_minus = []\n", + "gene_id_dict = {}\n", + "for _, row in polyadb_df_minus.iterrows() :\n", + "\n", + " gene = row['gene']\n", + "\n", + " if gene not in gene_id_dict :\n", + " gene_id_dict[gene] = 0\n", + "\n", + " gene_id_dict[gene] += 1\n", + "\n", + " new_gene_id_list_minus.append(gene + \".\" + str(gene_id_dict[gene]))\n", + " sitenum_list_minus.append(gene_id_dict[gene])\n", + "\n", + "polyadb_df_minus['gene_id'] = new_gene_id_list_minus\n", + "polyadb_df_minus['sitenum'] = sitenum_list_minus\n", + "\n", + "polyadb_df = pd.concat([polyadb_df_plus, polyadb_df_minus])\n", + "\n", + "polyadb_df = polyadb_df.sort_values(by=['gene', 'sitenum'], ascending=True).reset_index(drop=True).copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#Get variant positions in hg38 coordinates\n", + "\n", + "polyadb_bed_hg19 = pd.read_csv(\"polyadb_coordinates_hg19.bed\", sep='\\t', header=None, names=['chrom', 'pas_pos_hg19', 'end', 'gene', 'gene_id', 'strand'])\n", + "polyadb_bed_hg38 = pd.read_csv(\"polyadb_coordinates_hg38.bed\", sep='\\t', header=None, names=['chrom', 'pas_pos_hg38', 'end', 'gene', 'gene_id', 'strand'])\n", + "\n", + "polyadb_bed_hg38 = polyadb_bed_hg38.join(polyadb_bed_hg19[['gene_id', 'pas_pos_hg19']].set_index('gene_id'), on='gene_id', how='inner').copy().reset_index(drop=True)\n", + "\n", + "polyadb_bed_hg38['padb_join_id'] = polyadb_bed_hg38['chrom'] + \"_\" + polyadb_bed_hg38['pas_pos_hg19'].astype(str) + \"_\" + polyadb_bed_hg38['gene']\n", + "polyadb_df['padb_join_id'] = polyadb_df['chrom'] + \"_\" + polyadb_df['pas_pos'].astype(str) + \"_\" + polyadb_df['gene']\n", + "\n", + "polyadb_df = polyadb_df.join(polyadb_bed_hg38[['padb_join_id', 'pas_pos_hg38']].set_index(\"padb_join_id\"), on='padb_join_id', how='inner').copy().reset_index(drop=True)\n", + "\n", + "#polyadb_df = polyadb_df.query(\"site_type == '3_most_exon'\")\n", + "\n", + "polyadb_df = polyadb_df.drop_duplicates(subset=['gene_id'], keep='first').copy().reset_index(drop=True)\n", + "\n", + "variant_df = variant_df.join(polyadb_df[['gene_id', 'pas_pos', 'pas_pos_hg38']].set_index(\"gene_id\"), on='gene_id', how='inner').copy().reset_index(drop=True)\n", + "\n", + "variant_df['var_position_hg38'] = variant_df['var_position'] - variant_df['pas_pos'] + variant_df['pas_pos_hg38']\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\ncausaldb_dfs = []\\nfor _, row in causaldb_meta_df.iterrows() :\\n causaldb_dfs.append(\\n pd.read_csv(\"causaldb_credible_set/\" + row[\"ID\"] + \"_total_credible_set.txt\", sep=\\'\\t\\')\\n )\\n\\ncausaldb_df = pd.concat(causaldb_dfs).copy().reset_index(drop=True)\\n\\nprint(\"len(causaldb_df) = \" + str(len(causaldb_df)))\\n'" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Get CausalDB credible sets\n", + "\n", + "causaldb_meta_df = pd.read_csv(\"causaldb_credible_set/causaldb_meta_info_v1.txt\", sep='\\t')\n", + "\n", + "causaldb_dfs = []\n", + "for _, row in causaldb_meta_df.iterrows() :\n", + " causaldb_dfs.append(\n", + " pd.read_csv(\"causaldb_credible_set/\" + row[\"ID\"] + \"_total_credible_set.txt\", sep='\\t')\n", + " )\n", + "\n", + "causaldb_df = pd.concat(causaldb_dfs).copy().reset_index(drop=True)\n", + "\n", + "print(\"len(causaldb_df) = \" + str(len(causaldb_df)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(non_causaldb_df) = 705151\n" + ] + } + ], + "source": [ + "#Get CausalDB significant non-causal variants\n", + "\n", + "non_causaldb_df = pd.read_csv(\"causaldb_credible_set/causaldb_sig_noncausal_v1.txt\", sep='\\t')\n", + "\n", + "print(\"len(non_causaldb_df) = \" + str(len(non_causaldb_df)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#Map variants to predictions\n", + "\n", + "causaldb_df['causaldb_join_id'] = \"chr\" + causaldb_df['CHR'].astype(str) + \"_\" + causaldb_df['BP'].astype(str)\n", + "variant_df['causaldb_join_id'] = variant_df['chrom'] + \"_\" + variant_df['var_position'].astype(str)\n", + "\n", + "#causaldb_df = causaldb_df.drop_duplicates(subset=['causaldb_join_id'], keep='first').copy().reset_index(drop=True)\n", + "\n", + "variant_df_gwas = variant_df.join(causaldb_df[[\"causaldb_join_id\", 'rsID', 'MAF', 'EA', 'NEA', 'BETA', 'SE', 'P', 'Zscore', 'PAINTOR', 'CAVIARBF', 'FINEMAP', 'meta_id']].set_index(\"causaldb_join_id\"), on='causaldb_join_id', how='inner').copy().reset_index(drop=True)\n", + "variant_df_gwas = variant_df_gwas.query(\"EA == var_nucleotide\").copy().reset_index(drop=True)\n", + "\n", + "#variant_df_gwas.to_csv(\"aparent_resnet_variant_predictions_polyadb_no_sequences_causaldb_no_cutoff.csv\", sep='\\t', index=False)\n", + "\n", + "#Map non-causal variants to predictions\n", + "\n", + "non_causaldb_df['causaldb_join_id'] = \"chr\" + non_causaldb_df['CHR'].astype(str) + \"_\" + non_causaldb_df['BP'].astype(str)\n", + "variant_df['causaldb_join_id'] = variant_df['chrom'] + \"_\" + variant_df['var_position'].astype(str)\n", + "\n", + "#non_causaldb_df = non_causaldb_df.drop_duplicates(subset=['causaldb_join_id'], keep='first').copy().reset_index(drop=True)\n", + "\n", + "variant_df_gwas_noncausal = variant_df.join(non_causaldb_df[[\"causaldb_join_id\", 'rsID', 'MAF', 'EA', 'NEA', 'BETA', 'SE', 'P', 'Zscore', 'PAINTOR', 'CAVIARBF', 'FINEMAP', 'meta_id']].set_index(\"causaldb_join_id\"), on='causaldb_join_id', how='inner').copy().reset_index(drop=True)\n", + "variant_df_gwas_noncausal = variant_df_gwas_noncausal.query(\"EA == var_nucleotide\").copy().reset_index(drop=True)\n", + "\n", + "#variant_df_gwas_noncausal.to_csv(\"aparent_resnet_variant_predictions_polyadb_no_sequences_noncausaldb_no_cutoff.csv\", sep='\\t', index=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "variant_df_gwas = pd.read_csv(\"aparent_resnet_variant_predictions_polyadb_no_sequences_causaldb_no_cutoff.csv\", sep='\\t')\n", + "variant_df_gwas_noncausal = pd.read_csv(\"aparent_resnet_variant_predictions_polyadb_no_sequences_noncausaldb_no_cutoff.csv\", sep='\\t')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#Drop duplicates for partially overlapping annotated PASs\n", + "\n", + "variant_df_gwas['rsID'] = \"rs\" + variant_df_gwas['rsID'].astype(int).astype(str)\n", + "\n", + "variant_df_gwas['delta_logodds_77_127_abs'] = np.abs(variant_df_gwas['delta_logodds_77_127'])\n", + "\n", + "variant_df_gwas['rel_var_position'] = -1\n", + "variant_df_gwas.loc[variant_df_gwas['strand'] == '+', 'rel_var_position'] = variant_df_gwas['var_position'] - (variant_df_gwas['pas_pos'] - 70 + 1)\n", + "variant_df_gwas.loc[variant_df_gwas['strand'] == '-', 'rel_var_position'] = ((variant_df_gwas['pas_pos'] - (205 - 70)) + 205) - variant_df_gwas['var_position']\n", + "\n", + "variant_df_gwas['target_rel_var_position'] = np.abs(90 - variant_df_gwas['rel_var_position'])\n", + "variant_df_gwas['delta_logodds_77_127_abs'] = -variant_df_gwas['delta_logodds_77_127_abs']\n", + "variant_df_gwas = variant_df_gwas.sort_values(by=['target_rel_var_position', 'delta_logodds_77_127_abs'], ascending=True).drop_duplicates(subset=['causaldb_join_id', 'meta_id'], keep='first').copy().reset_index(drop=True)\n", + "\n", + "#Drop duplicates for partially overlapping annotated PASs (non-causal)\n", + "\n", + "variant_df_gwas_noncausal['delta_logodds_77_127_abs'] = np.abs(variant_df_gwas_noncausal['delta_logodds_77_127'])\n", + "\n", + "variant_df_gwas_noncausal['rel_var_position'] = -1\n", + "variant_df_gwas_noncausal.loc[variant_df_gwas_noncausal['strand'] == '+', 'rel_var_position'] = variant_df_gwas_noncausal['var_position'] - (variant_df_gwas_noncausal['pas_pos'] - 70 + 1)\n", + "variant_df_gwas_noncausal.loc[variant_df_gwas_noncausal['strand'] == '-', 'rel_var_position'] = ((variant_df_gwas_noncausal['pas_pos'] - (205 - 70)) + 205) - variant_df_gwas_noncausal['var_position']\n", + "\n", + "variant_df_gwas_noncausal['target_rel_var_position'] = np.abs(90 - variant_df_gwas_noncausal['rel_var_position'])\n", + "variant_df_gwas_noncausal['delta_logodds_77_127_abs'] = -variant_df_gwas_noncausal['delta_logodds_77_127_abs']\n", + "variant_df_gwas_noncausal = variant_df_gwas_noncausal.sort_values(by=['target_rel_var_position', 'delta_logodds_77_127_abs'], ascending=True).drop_duplicates(subset=['causaldb_join_id', 'meta_id'], keep='first').copy().reset_index(drop=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(variant_df_gwas_lead) = 8072\n" + ] + } + ], + "source": [ + "#Aggregate summary statistic for unique SNPs (by rsID)\n", + "\n", + "variant_df_gwas_lead = variant_df_gwas.copy().sort_values(by='FINEMAP', ascending=False).drop_duplicates(\"causaldb_join_id\").copy().reset_index(drop=True)\n", + "\n", + "print(\"len(variant_df_gwas_lead) = \" + str(len(variant_df_gwas_lead)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n = 8072\n", + "n (>= 1.4-fold) = 999\n", + "\n", + "n = 152 (PP >= 0.9)\n", + "n (>= 1.4-fold) = 26 (PP >= 0.9)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "variant_df_gwas_lead['delta_logodds_77_127_abs'] = np.abs(variant_df_gwas_lead['delta_logodds_77_127'])\n", + "\n", + "variant_df_gwas_lead_non_signi = variant_df_gwas_lead.query(\"FINEMAP < 0.9\")\n", + "variant_df_gwas_lead_signi = variant_df_gwas_lead.query(\"FINEMAP >= 0.9\")\n", + "\n", + "print(\"n = \" + str(len(variant_df_gwas_lead)))\n", + "print(\"n (>= 1.4-fold) = \" + str(len(variant_df_gwas_lead.query(\"delta_logodds_77_127_abs >= 0.336\"))))\n", + "\n", + "print(\"\")\n", + "print(\"n = \" + str(len(variant_df_gwas_lead_signi)) + \" (PP >= 0.9)\")\n", + "print(\"n (>= 1.4-fold) = \" + str(len(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs >= 0.336\"))) + \" (PP >= 0.9)\")\n", + "\n", + "plt.scatter(variant_df_gwas_lead_non_signi['delta_logodds_77_127_abs'] / np.log(2.), -np.log(np.clip(variant_df_gwas_lead_non_signi['P'], 1e-200, 1.)) / np.log(10), color='darkgreen', s=15, alpha=0.95)\n", + "\n", + "plt.scatter(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs < 0.336\")['delta_logodds_77_127_abs'] / np.log(2.), -np.log(np.clip(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs < 0.336\")['P'], 1e-200, 1.)) / np.log(10), color='red', s=15, alpha=0.95)\n", + "plt.scatter(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs >= 0.336\")['delta_logodds_77_127_abs'] / np.log(2.), -np.log(np.clip(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs >= 0.336\")['P'], 1e-200, 1.)) / np.log(10), color='red', s=35, marker=\"^\", alpha=0.95)\n", + "\n", + "plt.axvline(x=np.log2(1.4), linestyle='--', linewidth=2, color='black')\n", + "\n", + "plt.xlim(-0.1, 6.0)\n", + "plt.ylim(3, 80)\n", + "\n", + "plt.xticks([0, 1, 2, 3, 4, 5, 6], ['Ref', '2-fold', '4-fold', '8-fold', '16-fold', '32-fold', '64-fold'], fontsize=12, rotation=45)\n", + "plt.yticks([10, 20, 40, 60, 80], [\"1e-10\", \"1e-20\", \"1e-40\", \"1e-60\", \"1e-80\", \"1e-100\"], fontsize=12, rotation=45)\n", + "\n", + "plt.savefig(\"causaldb_aparent_resnet_scatter_pp_09_v2.png\", transparent=True, dpi=300)\n", + "plt.savefig(\"causaldb_aparent_resnet_scatter_pp_09_v2.eps\")\n", + "\n", + "plt.tight_layout()\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n = 8072\n", + "n (>= 1.4-fold) = 999\n", + "\n", + "n = 121 (PP >= 0.5)\n", + "n (>= 1.4-fold) = 13 (PP >= 0.5)\n", + "\n", + "n = 152 (PP >= 0.9)\n", + "n (>= 1.4-fold) = 26 (PP >= 0.9)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "variant_df_gwas_lead['delta_logodds_77_127_abs'] = np.abs(variant_df_gwas_lead['delta_logodds_77_127'])\n", + "\n", + "variant_df_gwas_lead_non_signi = variant_df_gwas_lead.query(\"FINEMAP < 0.5\")\n", + "variant_df_gwas_lead_semi_signi = variant_df_gwas_lead.query(\"FINEMAP >= 0.5 and FINEMAP < 0.9\")\n", + "variant_df_gwas_lead_signi = variant_df_gwas_lead.query(\"FINEMAP >= 0.9\")\n", + "\n", + "print(\"n = \" + str(len(variant_df_gwas_lead)))\n", + "print(\"n (>= 1.4-fold) = \" + str(len(variant_df_gwas_lead.query(\"delta_logodds_77_127_abs >= 0.336\"))))\n", + "\n", + "print(\"\")\n", + "print(\"n = \" + str(len(variant_df_gwas_lead_semi_signi)) + \" (PP >= 0.5)\")\n", + "print(\"n (>= 1.4-fold) = \" + str(len(variant_df_gwas_lead_semi_signi.query(\"delta_logodds_77_127_abs >= 0.336\"))) + \" (PP >= 0.5)\")\n", + "\n", + "print(\"\")\n", + "print(\"n = \" + str(len(variant_df_gwas_lead_signi)) + \" (PP >= 0.9)\")\n", + "print(\"n (>= 1.4-fold) = \" + str(len(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs >= 0.336\"))) + \" (PP >= 0.9)\")\n", + "\n", + "plt.scatter(variant_df_gwas_lead_non_signi['delta_logodds_77_127_abs'] / np.log(2.), -np.log(np.clip(variant_df_gwas_lead_non_signi['P'], 1e-200, 1.)) / np.log(10), color='darkgreen', s=15, alpha=0.95)\n", + "\n", + "plt.scatter(variant_df_gwas_lead_semi_signi.query(\"delta_logodds_77_127_abs < 0.336\")['delta_logodds_77_127_abs'] / np.log(2.), -np.log(np.clip(variant_df_gwas_lead_semi_signi.query(\"delta_logodds_77_127_abs < 0.336\")['P'], 1e-200, 1.)) / np.log(10), color='blue', s=15, alpha=0.95)\n", + "plt.scatter(variant_df_gwas_lead_semi_signi.query(\"delta_logodds_77_127_abs >= 0.336\")['delta_logodds_77_127_abs'] / np.log(2.), -np.log(np.clip(variant_df_gwas_lead_semi_signi.query(\"delta_logodds_77_127_abs >= 0.336\")['P'], 1e-200, 1.)) / np.log(10), color='blue', s=35, marker=\"^\", alpha=0.95)\n", + "\n", + "plt.scatter(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs < 0.336\")['delta_logodds_77_127_abs'] / np.log(2.), -np.log(np.clip(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs < 0.336\")['P'], 1e-200, 1.)) / np.log(10), color='red', s=15, alpha=0.95)\n", + "plt.scatter(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs >= 0.336\")['delta_logodds_77_127_abs'] / np.log(2.), -np.log(np.clip(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs >= 0.336\")['P'], 1e-200, 1.)) / np.log(10), color='red', s=35, marker=\"^\", alpha=0.95)\n", + "\n", + "plt.axvline(x=np.log2(1.4), linestyle='--', linewidth=2, color='black')\n", + "\n", + "plt.xlim(-0.1, 6.0)\n", + "plt.ylim(3, 80)\n", + "\n", + "plt.xticks([0, 1, 2, 3, 4, 5, 6], ['Ref', '2-fold', '4-fold', '8-fold', '16-fold', '32-fold', '64-fold'], fontsize=12, rotation=45)\n", + "plt.yticks([10, 20, 40, 60, 80], [\"1e-10\", \"1e-20\", \"1e-40\", \"1e-60\", \"1e-80\", \"1e-100\"], fontsize=12, rotation=45)\n", + "\n", + "plt.savefig(\"causaldb_aparent_resnet_scatter_pp_05_09_v2.png\", transparent=True, dpi=300)\n", + "plt.savefig(\"causaldb_aparent_resnet_scatter_pp_05_09_v2.eps\")\n", + "\n", + "plt.tight_layout()\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#Filter on 3' UTR SNPs only\n", + "\n", + "variant_df_gwas = variant_df_gwas.query(\"site_type == '3_most_exon'\").copy().reset_index(drop=True)\n", + "variant_df_gwas_lead = variant_df_gwas_lead.query(\"site_type == '3_most_exon'\").copy().reset_index(drop=True)\n", + "variant_df_gwas_noncausal = variant_df_gwas_noncausal.query(\"site_type == '3_most_exon'\").copy().reset_index(drop=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n = 4200\n", + "n (>= 1.4-fold) = 554\n", + "\n", + "n = 70 (PP >= 0.5)\n", + "n (>= 1.4-fold) = 8 (PP >= 0.5)\n", + "\n", + "n = 96 (PP >= 0.9)\n", + "n (>= 1.4-fold) = 17 (PP >= 0.9)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "variant_df_gwas_lead['delta_logodds_77_127_abs'] = np.abs(variant_df_gwas_lead['delta_logodds_77_127'])\n", + "\n", + "variant_df_gwas_lead_non_signi = variant_df_gwas_lead.query(\"FINEMAP < 0.5\")\n", + "variant_df_gwas_lead_semi_signi = variant_df_gwas_lead.query(\"FINEMAP >= 0.5 and FINEMAP < 0.9\")\n", + "variant_df_gwas_lead_signi = variant_df_gwas_lead.query(\"FINEMAP >= 0.9\")\n", + "\n", + "print(\"n = \" + str(len(variant_df_gwas_lead)))\n", + "print(\"n (>= 1.4-fold) = \" + str(len(variant_df_gwas_lead.query(\"delta_logodds_77_127_abs >= 0.336\"))))\n", + "\n", + "print(\"\")\n", + "print(\"n = \" + str(len(variant_df_gwas_lead_semi_signi)) + \" (PP >= 0.5)\")\n", + "print(\"n (>= 1.4-fold) = \" + str(len(variant_df_gwas_lead_semi_signi.query(\"delta_logodds_77_127_abs >= 0.336\"))) + \" (PP >= 0.5)\")\n", + "\n", + "print(\"\")\n", + "print(\"n = \" + str(len(variant_df_gwas_lead_signi)) + \" (PP >= 0.9)\")\n", + "print(\"n (>= 1.4-fold) = \" + str(len(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs >= 0.336\"))) + \" (PP >= 0.9)\")\n", + "\n", + "plt.scatter(variant_df_gwas_lead_non_signi['delta_logodds_77_127_abs'] / np.log(2.), -np.log(np.clip(variant_df_gwas_lead_non_signi['P'], 1e-200, 1.)) / np.log(10), color='darkgreen', s=15, alpha=0.95)\n", + "\n", + "plt.scatter(variant_df_gwas_lead_semi_signi['delta_logodds_77_127_abs'] / np.log(2.), -np.log(np.clip(variant_df_gwas_lead_semi_signi['P'], 1e-200, 1.)) / np.log(10), color='blue', s=15, alpha=0.95)\n", + "\n", + "plt.scatter(variant_df_gwas_lead_signi['delta_logodds_77_127_abs'] / np.log(2.), -np.log(np.clip(variant_df_gwas_lead_signi['P'], 1e-200, 1.)) / np.log(10), color='red', s=15, alpha=0.95)\n", + "\n", + "#Re-plot rs6796 with other association to make it visible\n", + "rs6796_df = variant_df_gwas.query(\"rsID == 'rs6796' and meta_id == 'AT690'\").copy()\n", + "rs6796_df['delta_logodds_77_127_abs'] = np.abs(rs6796_df['delta_logodds_77_127'])\n", + "plt.scatter(rs6796_df['delta_logodds_77_127_abs'] / np.log(2.), -np.log(np.clip(rs6796_df['P'], 1e-200, 1.)) / np.log(10), color='red', s=15, alpha=0.95)\n", + "\n", + "plt.axvline(x=np.log2(1.4), linestyle='--', linewidth=2, color='black')\n", + "\n", + "plt.xlim(-0.1, 5.0)\n", + "plt.ylim(3, 80)\n", + "\n", + "plt.xticks([0, 1, 2, 3, 4, 5], ['Ref', '2-fold', '4-fold', '8-fold', '16-fold', '32-fold'], fontsize=12, rotation=45)\n", + "plt.yticks([10, 20, 40, 60, 80], [\"1e-10\", \"1e-20\", \"1e-40\", \"1e-60\", \"1e-80\", \"1e-100\"], fontsize=12, rotation=45)\n", + "\n", + "plt.savefig(\"causaldb_aparent_resnet_scatter_utr3_only_pp_05_09_v2.png\", transparent=True, dpi=300)\n", + "plt.savefig(\"causaldb_aparent_resnet_scatter_utr3_only_pp_05_09_v2.eps\")\n", + "\n", + "plt.tight_layout()\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n = 4200\n", + "n (>= 1.4-fold) = 554\n", + "\n", + "n = 70 (PP >= 0.5)\n", + "n (>= 1.4-fold) = 8 (PP >= 0.5)\n", + "\n", + "n = 96 (PP >= 0.9)\n", + "n (>= 1.4-fold) = 17 (PP >= 0.9)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "variant_df_gwas_lead['delta_logodds_77_127_abs'] = np.abs(variant_df_gwas_lead['delta_logodds_77_127'])\n", + "\n", + "variant_df_gwas_lead_non_signi = variant_df_gwas_lead.query(\"FINEMAP < 0.5\")\n", + "variant_df_gwas_lead_semi_signi = variant_df_gwas_lead.query(\"FINEMAP >= 0.5 and FINEMAP < 0.9\")\n", + "variant_df_gwas_lead_signi = variant_df_gwas_lead.query(\"FINEMAP >= 0.9\")\n", + "\n", + "print(\"n = \" + str(len(variant_df_gwas_lead)))\n", + "print(\"n (>= 1.4-fold) = \" + str(len(variant_df_gwas_lead.query(\"delta_logodds_77_127_abs >= 0.336\"))))\n", + "\n", + "print(\"\")\n", + "print(\"n = \" + str(len(variant_df_gwas_lead_semi_signi)) + \" (PP >= 0.5)\")\n", + "print(\"n (>= 1.4-fold) = \" + str(len(variant_df_gwas_lead_semi_signi.query(\"delta_logodds_77_127_abs >= 0.336\"))) + \" (PP >= 0.5)\")\n", + "\n", + "print(\"\")\n", + "print(\"n = \" + str(len(variant_df_gwas_lead_signi)) + \" (PP >= 0.9)\")\n", + "print(\"n (>= 1.4-fold) = \" + str(len(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs >= 0.336\"))) + \" (PP >= 0.9)\")\n", + "\n", + "plt.scatter(variant_df_gwas_lead_non_signi['delta_logodds_77_127_abs'] / np.log(2.), -np.log(np.clip(variant_df_gwas_lead_non_signi['P'], 1e-200, 1.)) / np.log(10), color='darkgreen', s=15, alpha=0.95)\n", + "\n", + "plt.scatter(variant_df_gwas_lead_semi_signi['delta_logodds_77_127_abs'] / np.log(2.), -np.log(np.clip(variant_df_gwas_lead_semi_signi['P'], 1e-200, 1.)) / np.log(10), color='blue', s=35, marker=\"^\", alpha=0.95)\n", + "\n", + "plt.scatter(variant_df_gwas_lead_signi['delta_logodds_77_127_abs'] / np.log(2.), -np.log(np.clip(variant_df_gwas_lead_signi['P'], 1e-200, 1.)) / np.log(10), color='red', s=35, marker=\"^\", alpha=0.95)\n", + "\n", + "#Re-plot rs6796 with other association to make it visible\n", + "rs6796_df = variant_df_gwas.query(\"rsID == 'rs6796' and meta_id == 'AT690'\").copy()\n", + "rs6796_df['delta_logodds_77_127_abs'] = np.abs(rs6796_df['delta_logodds_77_127'])\n", + "plt.scatter(rs6796_df['delta_logodds_77_127_abs'] / np.log(2.), -np.log(np.clip(rs6796_df['P'], 1e-200, 1.)) / np.log(10), color='red', s=35, marker=\"^\", alpha=0.95)\n", + "\n", + "plt.axvline(x=np.log2(1.4), linestyle='--', linewidth=2, color='black')\n", + "\n", + "plt.xlim(-0.1, 5.0)\n", + "plt.ylim(3, 80)\n", + "\n", + "plt.xticks([0, 1, 2, 3, 4, 5], ['Ref', '2-fold', '4-fold', '8-fold', '16-fold', '32-fold'], fontsize=12, rotation=45)\n", + "plt.yticks([10, 20, 40, 60, 80], [\"1e-10\", \"1e-20\", \"1e-40\", \"1e-60\", \"1e-80\", \"1e-100\"], fontsize=12, rotation=45)\n", + "\n", + "plt.savefig(\"causaldb_aparent_resnet_scatter_utr3_only_pp_05_09_v2_alt.png\", transparent=True, dpi=300)\n", + "plt.savefig(\"causaldb_aparent_resnet_scatter_utr3_only_pp_05_09_v2_alt.eps\")\n", + "\n", + "plt.tight_layout()\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "#Get SNPs with PP >= 0.5 and PP >= 0.9\n", + "\n", + "variant_df_gwas_semi_signi = variant_df_gwas.query(\"FINEMAP >= 0.5 and FINEMAP < 0.9\").copy()\n", + "variant_df_gwas_lead_semi_signi = variant_df_gwas_lead_semi_signi.query(\"FINEMAP >= 0.5 and FINEMAP < 0.9\").copy()\n", + "\n", + "variant_df_gwas_semi_signi = variant_df_gwas_semi_signi.join(causaldb_meta_df[['ID', 'Trait', 'MeSH_term']].set_index(\"ID\"), on='meta_id', how='inner').copy().reset_index(drop=True)\n", + "variant_df_gwas_lead_semi_signi = variant_df_gwas_lead_semi_signi.join(causaldb_meta_df[['ID', 'Trait', 'MeSH_term']].set_index(\"ID\"), on='meta_id', how='inner').copy().reset_index(drop=True)\n", + "\n", + "variant_df_gwas_signi = variant_df_gwas.query(\"FINEMAP >= 0.9\").copy()\n", + "variant_df_gwas_lead_signi = variant_df_gwas_lead_signi.query(\"FINEMAP >= 0.9\").copy()\n", + "\n", + "variant_df_gwas_signi = variant_df_gwas_signi.join(causaldb_meta_df[['ID', 'Trait', 'MeSH_term']].set_index(\"ID\"), on='meta_id', how='inner').copy().reset_index(drop=True)\n", + "variant_df_gwas_lead_signi = variant_df_gwas_lead_signi.join(causaldb_meta_df[['ID', 'Trait', 'MeSH_term']].set_index(\"ID\"), on='meta_id', how='inner').copy().reset_index(drop=True)\n", + "\n", + "variant_df_gwas_lead_semi_signi['delta_logodds_77_127_abs_log_2'] = 2**(variant_df_gwas_lead_semi_signi['delta_logodds_77_127_abs'] / np.log(2.))\n", + "variant_df_gwas_lead_signi['delta_logodds_77_127_abs_log_2'] = 2**(variant_df_gwas_lead_signi['delta_logodds_77_127_abs'] / np.log(2.))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "#Get variant ids\n", + "\n", + "rs_ids = set(variant_df_gwas['rsID'].unique().tolist())\n", + "\n", + "rs_ids_semi_signi = set(variant_df_gwas_semi_signi['rsID'].unique().tolist())\n", + "rs_ids_lead_semi_signi = set(variant_df_gwas_lead_semi_signi['rsID'].unique().tolist())\n", + "\n", + "rs_ids_signi = set(variant_df_gwas_signi['rsID'].unique().tolist())\n", + "rs_ids_lead_signi = set(variant_df_gwas_lead_signi['rsID'].unique().tolist())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- SNPs from credible set w. PP >= 0.9 ---\n", + "rs78378222 : True\n", + " - delta_logodds_77_127 = -2.3624\n", + " - delta_logodds_77_127_abs_log_2 = 10.6162\n", + " -- Mean corpuscular hemoglobin, p-value = 6.44e-09, FINEMAP = 0.997827\n", + " -- Red blood cell (erythrocyte) count, p-value = 7.6177e-25, FINEMAP = 0.921756\n", + " -- Mean corpuscular haemoglobin, p-value = 1.1518e-23, FINEMAP = 1.0\n", + " -- Mean corpuscular volume, p-value = 1.8429000000000003e-23, FINEMAP = 1.0\n", + " -- Impedance measures - Basal metabolic rate, p-value = 1.538e-34, FINEMAP = 1.0\n", + " -- Impedance measures - Whole body water mass, p-value = 1.2809999999999999e-40, FINEMAP = 1.0\n", + " -- Weight, p-value = 1.7840000000000003e-18, FINEMAP = 0.999278\n", + " -- Impedance measures - Weight, p-value = 4.428e-18, FINEMAP = 0.999086\n", + " -- Impedance measures - Leg fat-free mass (right), p-value = 7.078e-33, FINEMAP = 1.0\n", + " -- Impedance measures - Leg predicted mass (right), p-value = 6.511e-33, FINEMAP = 1.0\n", + " -- Impedance measures - Leg fat-free mass (left), p-value = 1.2279999999999999e-29, FINEMAP = 1.0\n", + " -- Impedance measures - Leg predicted mass (left), p-value = 1.62e-29, FINEMAP = 1.0\n", + " -- Impedance measures - Whole body fat-free mass, p-value = 6.189e-40, FINEMAP = 1.0\n", + " -- Impedance measures - Arm fat-free mass (right), p-value = 6.931000000000001e-35, FINEMAP = 1.0\n", + " -- Impedance measures - Arm predicted mass (right), p-value = 1.617e-34, FINEMAP = 1.0\n", + " -- Impedance measures - Arm fat-free mass (left), p-value = 1.3809999999999998e-40, FINEMAP = 1.0\n", + " -- Impedance measures - Arm predicted mass (left), p-value = 1.9379999999999997e-35, FINEMAP = 1.0\n", + " -- Impedance measures - Trunk fat-free mass, p-value = 1.18e-42, FINEMAP = 1.0\n", + " -- Impedance measures - Trunk predicted mass, p-value = 6.612000000000001e-43, FINEMAP = 1.0\n", + " -- Mean reticulocyte volume, p-value = 3.1284e-13, FINEMAP = 0.975953\n", + " -- Mean sphered cell volume, p-value = 3.8348e-24, FINEMAP = 1.0\n", + " -- Basal metabolic rate, p-value = 2.99675e-34, FINEMAP = 1.0\n", + " -- Whole body water mass, p-value = 4.67851e-39, FINEMAP = 1.0\n", + " -- Whole body fat-free mass, p-value = 2.4184e-38, FINEMAP = 1.0\n", + " -- Basal metabolic rate, p-value = 2.5649e-43, FINEMAP = 1.0\n", + " -- Whole body water mass, p-value = 2.733599999999998e-51, FINEMAP = 1.0\n", + " -- Weight, p-value = 9.692900000000001e-23, FINEMAP = 0.999992\n", + " -- Weight, p-value = 5.4847e-23, FINEMAP = 0.999998\n", + " -- C43-C44 Melanoma and other malignant neoplasms of skin, p-value = 8.7235e-17, FINEMAP = 1.0\n", + " -- Impedance of arm (right), p-value = 3.3375999999999994e-26, FINEMAP = 0.999524\n", + " -- Impedance of whole body, p-value = 6.6648e-36, FINEMAP = 1.0\n", + " -- Impedance of arm (left), p-value = 6.980800000000001e-27, FINEMAP = 1.0\n", + " -- Impedance of leg (left), p-value = 4.849599999999999e-30, FINEMAP = 1.0\n", + " -- Impedance of leg (right), p-value = 3.5038999999999998e-31, FINEMAP = 1.0\n", + " -- L80-L99 Other disorders of the skin and subcutaneous tissue, p-value = 1.5893e-08, FINEMAP = 0.998027\n", + " -- C44 Other malignant neoplasms of skin, p-value = 1.9368e-15, FINEMAP = 1.0\n", + " -- Trunk predicted mass, p-value = 1.8052000000000002e-52, FINEMAP = 1.0\n", + " -- Trunk fat-free mass, p-value = 1.1203e-52, FINEMAP = 1.0\n", + " -- Arm predicted mass (left), p-value = 1.3085999999999993e-43, FINEMAP = 1.0\n", + " -- Arm fat-free mass (left), p-value = 2.0442999999999999e-44, FINEMAP = 1.0\n", + " -- Arm predicted mass (right), p-value = 8.2865e-44, FINEMAP = 1.0\n", + " -- Arm fat-free mass (right), p-value = 4.6606e-44, FINEMAP = 1.0\n", + " -- Leg predicted mass (left), p-value = 2.7929999999999995e-37, FINEMAP = 1.0\n", + " -- Leg fat-free mass (left), p-value = 1.8524999999999998e-37, FINEMAP = 1.0\n", + " -- Leg predicted mass (right), p-value = 1.4567999999999998e-41, FINEMAP = 1.0\n", + " -- Leg fat-free mass (right), p-value = 1.8934e-41, FINEMAP = 1.0\n", + " -- Whole body fat-free mass, p-value = 8.64389999999999e-51, FINEMAP = 1.0\n", + " -- Number of operations, self-reported, p-value = 2.8876e-17, FINEMAP = 1.0\n", + " -- Cancer register - Histology of cancer tumour: Basal cell carcinoma, NOS, p-value = 1.049e-09, FINEMAP = 0.998733\n", + " -- Ever had hysterectomy (womb removed) (female), p-value = 6.419e-09, FINEMAP = 0.99889\n", + " -- Impedance measures - Impedance of whole body, p-value = 8.096e-26, FINEMAP = 1.0\n", + " -- Impedance measures - Impedance of leg (right), p-value = 2.112e-21, FINEMAP = 1.0\n", + " -- Impedance measures - Impedance of leg (left), p-value = 4.0769999999999997e-20, FINEMAP = 1.0\n", + " -- Impedance measures - Impedance of arm (right), p-value = 3.779e-18, FINEMAP = 0.999041\n", + " -- Impedance measures - Impedance of arm (left), p-value = 3.066e-19, FINEMAP = 0.999904\n", + " -- C44 Other and unspecified malignant neoplasm of skin, p-value = 1.1990000000000002e-22, FINEMAP = 1.0\n", + " -- Years since last cervical smear test (female), p-value = 4.092e-10, FINEMAP = 0.978371\n", + " -- Weight, p-value = 5.9555e-18, FINEMAP = 0.999365\n", + " -- Weight, p-value = 4.066819999999999e-18, FINEMAP = 0.999456\n", + " -- Forced expiratory volume in 1-second (FEV1), Best measure, p-value = 6.6753200000000005e-09, FINEMAP = 0.955059\n", + " -- Forced vital capacity (FVC), Best measure, p-value = 5.29275e-12, FINEMAP = 0.996491\n", + " -- D25 Leiomyoma of uterus, p-value = 8.048380000000004e-14, FINEMAP = 0.999996\n", + " -- Impedance of arm (right), p-value = 1.52703e-19, FINEMAP = 0.99984\n", + " -- Impedance of whole body, p-value = 2.82892e-25, FINEMAP = 1.0\n", + " -- Impedance of arm (left), p-value = 1.8908999999999998e-20, FINEMAP = 0.999983\n", + " -- Impedance of leg (left), p-value = 1.2351e-19, FINEMAP = 1.0\n", + " -- Impedance of leg (right), p-value = 2.81817e-21, FINEMAP = 1.0\n", + " -- C44 Other malignant neoplasms of skin, p-value = 3.7645499999999996e-24, FINEMAP = 1.0\n", + " -- Trunk predicted mass, p-value = 1.3318199999999998e-39, FINEMAP = 1.0\n", + " -- Trunk fat-free mass, p-value = 8.77218e-40, FINEMAP = 1.0\n", + " -- Arm predicted mass (left), p-value = 1.32153e-32, FINEMAP = 1.0\n", + " -- Arm fat-free mass (left), p-value = 5.3152e-34, FINEMAP = 1.0\n", + " -- Arm predicted mass (right), p-value = 1.60397e-33, FINEMAP = 1.0\n", + " -- Arm fat-free mass (right), p-value = 9.020689999999998e-34, FINEMAP = 1.0\n", + " -- Leg predicted mass (left), p-value = 6.1356399999999995e-31, FINEMAP = 1.0\n", + " -- Leg fat-free mass (left), p-value = 4.4373299999999995e-31, FINEMAP = 1.0\n", + " -- Leg fat-free mass (right), p-value = 5.57084e-34, FINEMAP = 1.0\n", + " -- Leg predicted mass (right), p-value = 4.09828e-34, FINEMAP = 1.0\n", + "\n", + "rs6796 : True\n", + " - delta_logodds_77_127 = -2.2975\n", + " - delta_logodds_77_127_abs_log_2 = 9.9491\n", + " -- Mean platelet (thrombocyte) volume, p-value = 8.899099999999991e-69, FINEMAP = 0.933805\n", + " -- Monocyte count, p-value = 8.468099999999995e-67, FINEMAP = 0.999974\n", + " -- Monocyte percentage, p-value = 1.2099999999999982e-87, FINEMAP = 0.99999\n", + " -- Neutrophill percentage, p-value = 1.7466999999999994e-60, FINEMAP = 0.996227\n", + "\n", + "rs76020419 : True\n", + " - delta_logodds_77_127 = 1.4474\n", + " - delta_logodds_77_127_abs_log_2 = 4.252\n", + " -- Diastolic blood pressure (automated reading), p-value = 7.082e-11, FINEMAP = 0.972447\n", + " -- Intra-ocular pressure, corneal-compensated (right), p-value = 5.49045e-12, FINEMAP = 0.998956\n", + " -- Intra-ocular pressure, Goldmann-correlated (right), p-value = 3.5142800000000013e-10, FINEMAP = 0.98917\n", + "\n", + "rs544433296 : True\n", + " - delta_logodds_77_127 = -1.3535\n", + " - delta_logodds_77_127_abs_log_2 = 3.8708\n", + " -- Education - Qualifications, p-value = 1.1289999999999999e-07, FINEMAP = 0.974245\n", + "\n", + "rs3208787 : True\n", + " - delta_logodds_77_127 = -1.254\n", + " - delta_logodds_77_127_abs_log_2 = 3.5043\n", + " -- Red blood cell (erythrocyte) count, p-value = 9.0991e-19, FINEMAP = 0.999941\n", + " -- Mean corpuscular haemoglobin, p-value = 5.9438e-11, FINEMAP = 0.997529\n", + " -- Mean corpuscular volume, p-value = 7.326899999999999e-11, FINEMAP = 0.994247\n", + " -- Red blood cell (erythrocyte) distribution width, p-value = 1.0262e-09, FINEMAP = 0.998158\n", + " -- Mean reticulocyte volume, p-value = 4.0174e-09, FINEMAP = 0.984262\n", + " -- Red blood cell count, p-value = 1.49e-09, FINEMAP = 0.997299\n", + " -- Red cell distribution width, p-value = 9.69e-12, FINEMAP = 0.999368\n", + "\n", + "rs35979828 : True\n", + " - delta_logodds_77_127 = -1.0283\n", + " - delta_logodds_77_127_abs_log_2 = 2.7962\n", + " -- Immature reticulocyte fraction, p-value = 2.8606e-09, FINEMAP = 0.988875\n", + " -- Mean sphered cell volume, p-value = 2.6656999999999996e-52, FINEMAP = 1.0\n", + " -- Eosinophill percentage, p-value = 5.7338e-23, FINEMAP = 1.0\n", + " -- Monocyte count, p-value = 7.5808e-21, FINEMAP = 0.99999\n", + " -- Eosinophill count, p-value = 5.1232e-21, FINEMAP = 1.0\n", + "\n", + "rs884205 : True\n", + " - delta_logodds_77_127 = -0.798\n", + " - delta_logodds_77_127_abs_log_2 = 2.2211\n", + " -- Sitting height, p-value = 1.2315999999999998e-19, FINEMAP = 0.999446\n", + " -- Alkaline phosphatase, p-value = 5.457e-11, FINEMAP = 0.999985\n", + "\n", + "rs1419008 : True\n", + " - delta_logodds_77_127 = -0.7825\n", + " - delta_logodds_77_127_abs_log_2 = 2.187\n", + " -- Age at first live birth (female), p-value = 1.391e-09, FINEMAP = 0.968478\n", + "\n", + "rs10492321 : True\n", + " - delta_logodds_77_127 = -0.7597\n", + " - delta_logodds_77_127_abs_log_2 = 2.1376\n", + " -- Height tails, p-value = 9.4e-10, FINEMAP = 0.948431\n", + "\n", + "rs1055253 : True\n", + " - delta_logodds_77_127 = 0.4956\n", + " - delta_logodds_77_127_abs_log_2 = 1.6414\n", + " -- Red blood cell (erythrocyte) count, p-value = 1.3947000000000004e-15, FINEMAP = 0.98616\n", + "\n", + "rs185853558 : True\n", + " - delta_logodds_77_127 = 0.4924\n", + " - delta_logodds_77_127_abs_log_2 = 1.6363\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " -- Frequency of travelling from home to job workplace, p-value = 4.319e-10, FINEMAP = 0.999907\n", + "\n", + "rs148354990 : True\n", + " - delta_logodds_77_127 = 0.4284\n", + " - delta_logodds_77_127_abs_log_2 = 1.5349\n", + " -- Ease of skin tanning, p-value = 6.536e-10, FINEMAP = 0.974185\n", + "\n", + "rs7078 : True\n", + " - delta_logodds_77_127 = -0.4102\n", + " - delta_logodds_77_127_abs_log_2 = 1.5071\n", + " -- Heel bone mineral density (BMD) T-score, automated, p-value = 2.08993e-11, FINEMAP = 0.998068\n", + "\n", + "rs3741434 : True\n", + " - delta_logodds_77_127 = -0.4016\n", + " - delta_logodds_77_127_abs_log_2 = 1.4942\n", + " -- Cognitive performance, p-value = 4.68e-08, FINEMAP = 0.96687\n", + "\n", + "rs8045438 : True\n", + " - delta_logodds_77_127 = 0.3838\n", + " - delta_logodds_77_127_abs_log_2 = 1.4679\n", + " -- Dihomo-gamma-linolenic acid, p-value = 7.89e-14, FINEMAP = 1.0\n", + "\n", + "rs190092330 : True\n", + " - delta_logodds_77_127 = 0.3455\n", + " - delta_logodds_77_127_abs_log_2 = 1.4127\n", + " -- Nucleated red blood cell count, p-value = 1.0699e-14, FINEMAP = 0.947007\n", + "\n", + "rs1799963 : True\n", + " - delta_logodds_77_127 = 0.3436\n", + " - delta_logodds_77_127_abs_log_2 = 1.4101\n", + " -- I80 Phlebitis and thrombophlebitis, p-value = 1.29e-16, FINEMAP = 0.905818\n", + " -- deep venous thrombosis (dvt), p-value = 7.650299999999999e-32, FINEMAP = 0.982793\n", + " -- venous thromboembolic disease, p-value = 1.3731999999999999e-37, FINEMAP = 0.98843\n", + "\n" + ] + } + ], + "source": [ + "#Top candidates from CasualDB with PP >= 0.9 (cutoff immediately after known pathogenic variant rs1799963)\n", + "\n", + "cand_rs_ids = variant_df_gwas_lead_signi.sort_values(by='delta_logodds_77_127_abs_log_2', ascending=False).query(\"delta_logodds_77_127_abs_log_2 >= 1.4\")['rsID'].values.tolist()\n", + "\n", + "print(\"--- SNPs from credible set w. PP >= 0.9 ---\")\n", + "\n", + "for cand_rs_id in cand_rs_ids :\n", + " print((cand_rs_id + \" \" * 15)[:15] + \": \" + str((cand_rs_id in rs_ids_signi)))\n", + " \n", + " if cand_rs_id in rs_ids_signi :\n", + " print(\" - delta_logodds_77_127 = \" + str(round(variant_df_gwas_lead_signi.query(\"rsID == '\" + cand_rs_id + \"'\").iloc[0]['delta_logodds_77_127'], 4)))\n", + " print(\" - delta_logodds_77_127_abs_log_2 = \" + str(round(2**(np.abs(variant_df_gwas_lead_signi.query(\"rsID == '\" + cand_rs_id + \"'\").iloc[0]['delta_logodds_77_127']) / np.log(2.)), 4)))\n", + " \n", + " subset_df = variant_df_gwas_signi.query(\"rsID == '\" + cand_rs_id + \"'\")\n", + " for _, row in subset_df.iterrows() :\n", + " print(\" -- \" + row['Trait'] + \", p-value = \" + str(row['P']) + \", FINEMAP = \" + str(row['FINEMAP']))\n", + "\n", + " print(\"\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- SNPs from credible set w. PP >= 0.5 ---\n", + "rs11556473 : True\n", + " - delta_logodds_77_127 = -1.1012\n", + " - delta_logodds_77_127_abs_log_2 = 3.0076\n", + " -- Salt added to food, p-value = 3.142e-08, FINEMAP = 0.523251\n", + "\n", + "rs2732480 : True\n", + " - delta_logodds_77_127 = 0.9093\n", + " - delta_logodds_77_127_abs_log_2 = 2.4826\n", + " -- Red blood cell count, p-value = 1.44e-17, FINEMAP = 0.529911\n", + " -- Hematocrit, p-value = 3.9599999999999996e-36, FINEMAP = 0.585425\n", + " -- Hemoglobin concentration, p-value = 7.65e-29, FINEMAP = 0.602596\n", + "\n", + "rs12142199 : True\n", + " - delta_logodds_77_127 = 0.7497\n", + " - delta_logodds_77_127_abs_log_2 = 2.1164\n", + " -- Ulcerative colitis, p-value = 6.72223986453e-10, FINEMAP = 0.5131319999999999\n", + "\n", + "rs1049868 : True\n", + " - delta_logodds_77_127 = -0.6088\n", + " - delta_logodds_77_127_abs_log_2 = 1.8382\n", + " -- Mean platelet volume, p-value = 4.7499999999999995e-09, FINEMAP = 0.531417\n", + " -- Mean platelet (thrombocyte) volume, p-value = 4.977600000000001e-21, FINEMAP = 0.74954\n", + "\n", + "rs703862 : True\n", + " - delta_logodds_77_127 = 0.5425\n", + " - delta_logodds_77_127_abs_log_2 = 1.7203\n", + " -- Comparative height size at age 10, p-value = 5.0648e-09, FINEMAP = 0.676253\n", + "\n", + "rs71516780 : True\n", + " - delta_logodds_77_127 = 0.4584\n", + " - delta_logodds_77_127_abs_log_2 = 1.5816\n", + " -- Impedance of arm (right), p-value = 1.2835e-10, FINEMAP = 0.7825300000000001\n", + " -- Impedance of whole body, p-value = 1.1593e-08, FINEMAP = 0.702916\n", + " -- Impedance of arm (left), p-value = 7.13e-12, FINEMAP = 0.843332\n", + " -- Immature reticulocyte fraction, p-value = 1.9891000000000003e-08, FINEMAP = 0.586407\n", + " -- Impedance of arm (right), p-value = 2.03412e-08, FINEMAP = 0.549821\n", + " -- Impedance of arm (left), p-value = 7.879350000000001e-09, FINEMAP = 0.599094\n", + "\n", + "rs8077889 : True\n", + " - delta_logodds_77_127 = -0.4509\n", + " - delta_logodds_77_127_abs_log_2 = 1.5697\n", + " -- Triglycerides, p-value = 9.88e-09, FINEMAP = 0.862151\n", + "\n", + "rs13675 : True\n", + " - delta_logodds_77_127 = 0.3826\n", + " - delta_logodds_77_127_abs_log_2 = 1.466\n", + " -- Comparative height size at age 10, p-value = 1.2506999999999999e-14, FINEMAP = 0.559778\n", + " -- Comparative height size at age 10, p-value = 1.3000000000000001e-12, FINEMAP = 0.601916\n", + "\n" + ] + } + ], + "source": [ + "#Top candidates from CasualDB with PP >= 0.5 (cutoff immediately after known pathogenic variant rs1799963)\n", + "\n", + "cand_rs_ids = variant_df_gwas_lead_semi_signi.sort_values(by='delta_logodds_77_127_abs_log_2', ascending=False).query(\"delta_logodds_77_127_abs_log_2 >= 1.4\")['rsID'].values.tolist()\n", + "\n", + "print(\"--- SNPs from credible set w. PP >= 0.5 ---\")\n", + "\n", + "for cand_rs_id in cand_rs_ids :\n", + " print((cand_rs_id + \" \" * 15)[:15] + \": \" + str((cand_rs_id in rs_ids_semi_signi)))\n", + " \n", + " if cand_rs_id in rs_ids_semi_signi :\n", + " print(\" - delta_logodds_77_127 = \" + str(round(variant_df_gwas_lead_semi_signi.query(\"rsID == '\" + cand_rs_id + \"'\").iloc[0]['delta_logodds_77_127'], 4)))\n", + " print(\" - delta_logodds_77_127_abs_log_2 = \" + str(round(2**(np.abs(variant_df_gwas_lead_semi_signi.query(\"rsID == '\" + cand_rs_id + \"'\").iloc[0]['delta_logodds_77_127']) / np.log(2.)), 4)))\n", + " \n", + " subset_df = variant_df_gwas_semi_signi.query(\"rsID == '\" + cand_rs_id + \"'\")\n", + " for _, row in subset_df.iterrows() :\n", + " print(\" -- \" + row['Trait'] + \", p-value = \" + str(row['P']) + \", FINEMAP = \" + str(row['FINEMAP']))\n", + "\n", + " print(\"\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- SNPs from credible set w. PP > 0.9 ---\n", + "rs6796 : True\n", + " - delta_logodds_77_127 = -2.2975\n", + " - delta_logodds_77_127_abs_log_2 = 9.9491\n", + " -- Mean platelet (thrombocyte) volume, p-value = 8.899099999999991e-69, FINEMAP = 0.933805\n", + " -- Monocyte count, p-value = 8.468099999999995e-67, FINEMAP = 0.999974\n", + " -- Monocyte percentage, p-value = 1.2099999999999982e-87, FINEMAP = 0.99999\n", + " -- Neutrophill percentage, p-value = 1.7466999999999994e-60, FINEMAP = 0.996227\n", + "\n", + "rs35630683 : False\n", + "rs78378222 : True\n", + " - delta_logodds_77_127 = -2.3624\n", + " - delta_logodds_77_127_abs_log_2 = 10.6162\n", + " -- Mean corpuscular hemoglobin, p-value = 6.44e-09, FINEMAP = 0.997827\n", + " -- Red blood cell (erythrocyte) count, p-value = 7.6177e-25, FINEMAP = 0.921756\n", + " -- Mean corpuscular haemoglobin, p-value = 1.1518e-23, FINEMAP = 1.0\n", + " -- Mean corpuscular volume, p-value = 1.8429000000000003e-23, FINEMAP = 1.0\n", + " -- Impedance measures - Basal metabolic rate, p-value = 1.538e-34, FINEMAP = 1.0\n", + " -- Impedance measures - Whole body water mass, p-value = 1.2809999999999999e-40, FINEMAP = 1.0\n", + " -- Weight, p-value = 1.7840000000000003e-18, FINEMAP = 0.999278\n", + " -- Impedance measures - Weight, p-value = 4.428e-18, FINEMAP = 0.999086\n", + " -- Impedance measures - Leg fat-free mass (right), p-value = 7.078e-33, FINEMAP = 1.0\n", + " -- Impedance measures - Leg predicted mass (right), p-value = 6.511e-33, FINEMAP = 1.0\n", + " -- Impedance measures - Leg fat-free mass (left), p-value = 1.2279999999999999e-29, FINEMAP = 1.0\n", + " -- Impedance measures - Leg predicted mass (left), p-value = 1.62e-29, FINEMAP = 1.0\n", + " -- Impedance measures - Whole body fat-free mass, p-value = 6.189e-40, FINEMAP = 1.0\n", + " -- Impedance measures - Arm fat-free mass (right), p-value = 6.931000000000001e-35, FINEMAP = 1.0\n", + " -- Impedance measures - Arm predicted mass (right), p-value = 1.617e-34, FINEMAP = 1.0\n", + " -- Impedance measures - Arm fat-free mass (left), p-value = 1.3809999999999998e-40, FINEMAP = 1.0\n", + " -- Impedance measures - Arm predicted mass (left), p-value = 1.9379999999999997e-35, FINEMAP = 1.0\n", + " -- Impedance measures - Trunk fat-free mass, p-value = 1.18e-42, FINEMAP = 1.0\n", + " -- Impedance measures - Trunk predicted mass, p-value = 6.612000000000001e-43, FINEMAP = 1.0\n", + " -- Mean reticulocyte volume, p-value = 3.1284e-13, FINEMAP = 0.975953\n", + " -- Mean sphered cell volume, p-value = 3.8348e-24, FINEMAP = 1.0\n", + " -- Basal metabolic rate, p-value = 2.99675e-34, FINEMAP = 1.0\n", + " -- Whole body water mass, p-value = 4.67851e-39, FINEMAP = 1.0\n", + " -- Whole body fat-free mass, p-value = 2.4184e-38, FINEMAP = 1.0\n", + " -- Basal metabolic rate, p-value = 2.5649e-43, FINEMAP = 1.0\n", + " -- Whole body water mass, p-value = 2.733599999999998e-51, FINEMAP = 1.0\n", + " -- Weight, p-value = 9.692900000000001e-23, FINEMAP = 0.999992\n", + " -- Weight, p-value = 5.4847e-23, FINEMAP = 0.999998\n", + " -- C43-C44 Melanoma and other malignant neoplasms of skin, p-value = 8.7235e-17, FINEMAP = 1.0\n", + " -- Impedance of arm (right), p-value = 3.3375999999999994e-26, FINEMAP = 0.999524\n", + " -- Impedance of whole body, p-value = 6.6648e-36, FINEMAP = 1.0\n", + " -- Impedance of arm (left), p-value = 6.980800000000001e-27, FINEMAP = 1.0\n", + " -- Impedance of leg (left), p-value = 4.849599999999999e-30, FINEMAP = 1.0\n", + " -- Impedance of leg (right), p-value = 3.5038999999999998e-31, FINEMAP = 1.0\n", + " -- L80-L99 Other disorders of the skin and subcutaneous tissue, p-value = 1.5893e-08, FINEMAP = 0.998027\n", + " -- C44 Other malignant neoplasms of skin, p-value = 1.9368e-15, FINEMAP = 1.0\n", + " -- Trunk predicted mass, p-value = 1.8052000000000002e-52, FINEMAP = 1.0\n", + " -- Trunk fat-free mass, p-value = 1.1203e-52, FINEMAP = 1.0\n", + " -- Arm predicted mass (left), p-value = 1.3085999999999993e-43, FINEMAP = 1.0\n", + " -- Arm fat-free mass (left), p-value = 2.0442999999999999e-44, FINEMAP = 1.0\n", + " -- Arm predicted mass (right), p-value = 8.2865e-44, FINEMAP = 1.0\n", + " -- Arm fat-free mass (right), p-value = 4.6606e-44, FINEMAP = 1.0\n", + " -- Leg predicted mass (left), p-value = 2.7929999999999995e-37, FINEMAP = 1.0\n", + " -- Leg fat-free mass (left), p-value = 1.8524999999999998e-37, FINEMAP = 1.0\n", + " -- Leg predicted mass (right), p-value = 1.4567999999999998e-41, FINEMAP = 1.0\n", + " -- Leg fat-free mass (right), p-value = 1.8934e-41, FINEMAP = 1.0\n", + " -- Whole body fat-free mass, p-value = 8.64389999999999e-51, FINEMAP = 1.0\n", + " -- Number of operations, self-reported, p-value = 2.8876e-17, FINEMAP = 1.0\n", + " -- Cancer register - Histology of cancer tumour: Basal cell carcinoma, NOS, p-value = 1.049e-09, FINEMAP = 0.998733\n", + " -- Ever had hysterectomy (womb removed) (female), p-value = 6.419e-09, FINEMAP = 0.99889\n", + " -- Impedance measures - Impedance of whole body, p-value = 8.096e-26, FINEMAP = 1.0\n", + " -- Impedance measures - Impedance of leg (right), p-value = 2.112e-21, FINEMAP = 1.0\n", + " -- Impedance measures - Impedance of leg (left), p-value = 4.0769999999999997e-20, FINEMAP = 1.0\n", + " -- Impedance measures - Impedance of arm (right), p-value = 3.779e-18, FINEMAP = 0.999041\n", + " -- Impedance measures - Impedance of arm (left), p-value = 3.066e-19, FINEMAP = 0.999904\n", + " -- C44 Other and unspecified malignant neoplasm of skin, p-value = 1.1990000000000002e-22, FINEMAP = 1.0\n", + " -- Years since last cervical smear test (female), p-value = 4.092e-10, FINEMAP = 0.978371\n", + " -- Weight, p-value = 5.9555e-18, FINEMAP = 0.999365\n", + " -- Weight, p-value = 4.066819999999999e-18, FINEMAP = 0.999456\n", + " -- Forced expiratory volume in 1-second (FEV1), Best measure, p-value = 6.6753200000000005e-09, FINEMAP = 0.955059\n", + " -- Forced vital capacity (FVC), Best measure, p-value = 5.29275e-12, FINEMAP = 0.996491\n", + " -- D25 Leiomyoma of uterus, p-value = 8.048380000000004e-14, FINEMAP = 0.999996\n", + " -- Impedance of arm (right), p-value = 1.52703e-19, FINEMAP = 0.99984\n", + " -- Impedance of whole body, p-value = 2.82892e-25, FINEMAP = 1.0\n", + " -- Impedance of arm (left), p-value = 1.8908999999999998e-20, FINEMAP = 0.999983\n", + " -- Impedance of leg (left), p-value = 1.2351e-19, FINEMAP = 1.0\n", + " -- Impedance of leg (right), p-value = 2.81817e-21, FINEMAP = 1.0\n", + " -- C44 Other malignant neoplasms of skin, p-value = 3.7645499999999996e-24, FINEMAP = 1.0\n", + " -- Trunk predicted mass, p-value = 1.3318199999999998e-39, FINEMAP = 1.0\n", + " -- Trunk fat-free mass, p-value = 8.77218e-40, FINEMAP = 1.0\n", + " -- Arm predicted mass (left), p-value = 1.32153e-32, FINEMAP = 1.0\n", + " -- Arm fat-free mass (left), p-value = 5.3152e-34, FINEMAP = 1.0\n", + " -- Arm predicted mass (right), p-value = 1.60397e-33, FINEMAP = 1.0\n", + " -- Arm fat-free mass (right), p-value = 9.020689999999998e-34, FINEMAP = 1.0\n", + " -- Leg predicted mass (left), p-value = 6.1356399999999995e-31, FINEMAP = 1.0\n", + " -- Leg fat-free mass (left), p-value = 4.4373299999999995e-31, FINEMAP = 1.0\n", + " -- Leg fat-free mass (right), p-value = 5.57084e-34, FINEMAP = 1.0\n", + " -- Leg predicted mass (right), p-value = 4.09828e-34, FINEMAP = 1.0\n", + "\n", + "rs2066865 : False\n", + "rs16833132 : False\n", + "rs8753 : False\n", + "rs35979828 : True\n", + " - delta_logodds_77_127 = -1.0283\n", + " - delta_logodds_77_127_abs_log_2 = 2.7962\n", + " -- Immature reticulocyte fraction, p-value = 2.8606e-09, FINEMAP = 0.988875\n", + " -- Mean sphered cell volume, p-value = 2.6656999999999996e-52, FINEMAP = 1.0\n", + " -- Eosinophill percentage, p-value = 5.7338e-23, FINEMAP = 1.0\n", + " -- Monocyte count, p-value = 7.5808e-21, FINEMAP = 0.99999\n", + " -- Eosinophill count, p-value = 5.1232e-21, FINEMAP = 1.0\n", + "\n", + "rs2732480 : False\n", + "rs12459634 : False\n", + "rs555328608 : False\n", + "rs16833132 : False\n", + "\n", + "--- SNPs from credible set ---\n", + "rs6796 : True\n", + "rs35630683 : True\n", + "rs78378222 : True\n", + "rs2066865 : True\n", + "rs16833132 : False\n", + "rs8753 : True\n", + "rs35979828 : True\n", + "rs2732480 : True\n", + "rs12459634 : False\n", + "rs555328608 : False\n", + "rs16833132 : False\n" + ] + } + ], + "source": [ + "#Candidates from GWAS catalog\n", + "\n", + "cand_rs_ids = ['rs6796', 'rs35630683', 'rs78378222', 'rs2066865', 'rs16833132', 'rs8753', 'rs35979828', 'rs2732480', 'rs12459634', 'rs555328608', 'rs16833132']\n", + "\n", + "print(\"--- SNPs from credible set w. PP > 0.9 ---\")\n", + "\n", + "for cand_rs_id in cand_rs_ids :\n", + " print((cand_rs_id + \" \" * 15)[:15] + \": \" + str((cand_rs_id in rs_ids_signi)))\n", + " \n", + " if cand_rs_id in rs_ids_signi :\n", + " print(\" - delta_logodds_77_127 = \" + str(round(variant_df_gwas_lead_signi.query(\"rsID == '\" + cand_rs_id + \"'\").iloc[0]['delta_logodds_77_127'], 4)))\n", + " print(\" - delta_logodds_77_127_abs_log_2 = \" + str(round(2**(np.abs(variant_df_gwas_lead_signi.query(\"rsID == '\" + cand_rs_id + \"'\").iloc[0]['delta_logodds_77_127']) / np.log(2.)), 4)))\n", + " \n", + " subset_df = variant_df_gwas_signi.query(\"rsID == '\" + cand_rs_id + \"'\")\n", + " for _, row in subset_df.iterrows() :\n", + " print(\" -- \" + row['Trait'] + \", p-value = \" + str(row['P']) + \", FINEMAP = \" + str(row['FINEMAP']))\n", + "\n", + " print(\"\")\n", + "\n", + "print(\"\")\n", + "\n", + "print(\"--- SNPs from credible set ---\")\n", + "\n", + "for cand_rs_id in cand_rs_ids :\n", + " print((cand_rs_id + \" \" * 15)[:15] + \": \" + str((cand_rs_id in rs_ids)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Environment (conda_tensorflow_p36)", + "language": "python", + "name": "conda_tensorflow_p36" + }, + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/analysis/gnomad_v3/gwas_causaldb_enrichment_analysis.ipynb b/analysis/gnomad_v3/gwas_causaldb_enrichment_analysis.ipynb new file mode 100644 index 0000000..a402d92 --- /dev/null +++ b/analysis/gnomad_v3/gwas_causaldb_enrichment_analysis.ipynb @@ -0,0 +1,466 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "\n", + "import os\n", + "import pandas as pd\n", + "\n", + "import numpy as np\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.cm as cm\n", + "\n", + "#import aparent.visualization as vis\n", + "\n", + "#from aparent_predictor import *\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(polyadb_df) = 175451\n" + ] + } + ], + "source": [ + "#Load APADB Data and filter on targeted genes\n", + "\n", + "#genes = ['RUNX1', 'CEBPA', 'GATA2', 'ANKRD26', 'DDX41', 'ETV6', 'PTEN', 'BRCA1', 'BRCA2', 'TP53', 'APC', 'ATM', 'PALB2', 'MSH2', 'MLH1', 'MSH6', 'PMS2', 'MUTYH']\n", + "\n", + "polyadb_df = pd.read_csv('polyadb_processed.csv', sep=',')\n", + "\n", + "#polyadb_df = polyadb_df.loc[polyadb_df['gene'].isin(genes)].reset_index(drop=True).copy()\n", + "polyadb_df = polyadb_df.loc[((~polyadb_df['gene'].isnull()) & (polyadb_df['gene'] != 'na')) & (polyadb_df['pas'] != -1)].reset_index(drop=True).copy()\n", + "\n", + "print('len(polyadb_df) = ' + str(len(polyadb_df)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#Process PolyaDB data\n", + "\n", + "polyadb_df_minus = polyadb_df.query(\"strand == '-'\").copy().reset_index(drop=True)\n", + "polyadb_df_plus = polyadb_df.query(\"strand == '+'\").copy().reset_index(drop=True)\n", + "\n", + "polyadb_df_minus = polyadb_df_minus.sort_values(by='pas_pos', ascending=False).copy().reset_index(drop=True)\n", + "polyadb_df_plus = polyadb_df_plus.sort_values(by='pas_pos', ascending=True).copy().reset_index(drop=True)\n", + "\n", + "new_gene_id_list_plus = []\n", + "sitenum_list_plus = []\n", + "gene_id_dict = {}\n", + "for _, row in polyadb_df_plus.iterrows() :\n", + "\n", + " gene = row['gene']\n", + "\n", + " if gene not in gene_id_dict :\n", + " gene_id_dict[gene] = 0\n", + "\n", + " gene_id_dict[gene] += 1\n", + "\n", + " new_gene_id_list_plus.append(gene + \".\" + str(gene_id_dict[gene]))\n", + " sitenum_list_plus.append(gene_id_dict[gene])\n", + "\n", + "polyadb_df_plus['gene_id'] = new_gene_id_list_plus\n", + "polyadb_df_plus['sitenum'] = sitenum_list_plus\n", + "\n", + "new_gene_id_list_minus = []\n", + "sitenum_list_minus = []\n", + "gene_id_dict = {}\n", + "for _, row in polyadb_df_minus.iterrows() :\n", + "\n", + " gene = row['gene']\n", + "\n", + " if gene not in gene_id_dict :\n", + " gene_id_dict[gene] = 0\n", + "\n", + " gene_id_dict[gene] += 1\n", + "\n", + " new_gene_id_list_minus.append(gene + \".\" + str(gene_id_dict[gene]))\n", + " sitenum_list_minus.append(gene_id_dict[gene])\n", + "\n", + "polyadb_df_minus['gene_id'] = new_gene_id_list_minus\n", + "polyadb_df_minus['sitenum'] = sitenum_list_minus\n", + "\n", + "polyadb_df = pd.concat([polyadb_df_plus, polyadb_df_minus])\n", + "\n", + "polyadb_df = polyadb_df.sort_values(by=['gene', 'sitenum'], ascending=True).reset_index(drop=True).copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#Get CausalDB metadata\n", + "\n", + "causaldb_meta_df = pd.read_csv(\"causaldb_credible_set/causaldb_meta_info_v1.txt\", sep='\\t')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#Load cached causaldb dataframes (already intersected against predictions)\n", + "\n", + "variant_df_gwas = pd.read_csv(\"aparent_resnet_variant_predictions_polyadb_no_sequences_causaldb_no_cutoff.csv\", sep='\\t')\n", + "variant_df_gwas_noncausal = pd.read_csv(\"aparent_resnet_variant_predictions_polyadb_no_sequences_noncausaldb_no_cutoff.csv\", sep='\\t')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#Drop duplicates for partially overlapping annotated PASs and add additional fields\n", + "\n", + "variant_df_gwas['rsID'] = \"rs\" + variant_df_gwas['rsID'].astype(int).astype(str)\n", + "\n", + "variant_df_gwas['delta_logodds_77_127_abs'] = np.abs(variant_df_gwas['delta_logodds_77_127'])\n", + "\n", + "variant_df_gwas['rel_var_position'] = -1\n", + "variant_df_gwas.loc[variant_df_gwas['strand'] == '+', 'rel_var_position'] = variant_df_gwas['var_position'] - (variant_df_gwas['pas_pos'] - 70 + 1)\n", + "variant_df_gwas.loc[variant_df_gwas['strand'] == '-', 'rel_var_position'] = ((variant_df_gwas['pas_pos'] - (205 - 70)) + 205) - variant_df_gwas['var_position']\n", + "\n", + "variant_df_gwas['alt_usage'] = 1. / (1. + 1. / ((np.clip(variant_df_gwas['native_usage'], 1e-7, 1. - 1e-7) / (1. - np.clip(variant_df_gwas['native_usage'], 1e-7, 1. - 1e-7))) * np.exp(variant_df_gwas['delta_logodds_0_205'])))\n", + "variant_df_gwas['delta_usage'] = variant_df_gwas['alt_usage'] - variant_df_gwas['native_usage']\n", + "\n", + "variant_df_gwas['alt_usage_77_127'] = 1. / (1. + 1. / ((np.clip(variant_df_gwas['native_usage'], 1e-7, 1. - 1e-7) / (1. - np.clip(variant_df_gwas['native_usage'], 1e-7, 1. - 1e-7))) * np.exp(variant_df_gwas['delta_logodds_77_127'])))\n", + "variant_df_gwas['delta_usage_77_127'] = variant_df_gwas['alt_usage_77_127'] - variant_df_gwas['native_usage']\n", + "\n", + "polyadb_df_unique = polyadb_df.drop_duplicates(subset=[\"gene_id\"], keep='first').copy().reset_index(drop=True)\n", + "polyadb_df_unique['padb_join_id'] = polyadb_df_unique['chrom'] + \"_\" + polyadb_df_unique['pas_pos'].astype(str) + \"_\" + polyadb_df_unique['strand']\n", + "variant_df_gwas['padb_join_id'] = variant_df_gwas['chrom'] + \"_\" + variant_df_gwas['pas_pos'].astype(str) + \"_\" + variant_df_gwas['strand']\n", + "\n", + "variant_df_gwas = variant_df_gwas.join(polyadb_df_unique[['padb_join_id', 'pas']].set_index(\"padb_join_id\"), on='padb_join_id', how='inner').copy().reset_index(drop=True)\n", + "\n", + "variant_df_gwas['target_rel_var_position'] = np.abs(90 - variant_df_gwas['rel_var_position'])\n", + "variant_df_gwas['target_delta_logodds_77_127_abs'] = -variant_df_gwas['delta_logodds_77_127_abs']\n", + "variant_df_gwas = variant_df_gwas.sort_values(by=['target_rel_var_position', 'target_delta_logodds_77_127_abs'], ascending=True).drop_duplicates(subset=['causaldb_join_id', 'meta_id'], keep='first').copy().reset_index(drop=True)\n", + "#variant_df_gwas['pas'] = -1. * variant_df_gwas['pas']\n", + "#variant_df_gwas = variant_df_gwas.sort_values(by=[\"pas\", 'delta_logodds_77_127_abs'], ascending=False).drop_duplicates(subset=['causaldb_join_id', 'meta_id'], keep='first').copy().reset_index(drop=True)\n", + "\n", + "#Drop duplicates for partially overlapping annotated PASs and add additional fields (non-causal)\n", + "\n", + "variant_df_gwas_noncausal['delta_logodds_77_127_abs'] = np.abs(variant_df_gwas_noncausal['delta_logodds_77_127'])\n", + "\n", + "variant_df_gwas_noncausal['rel_var_position'] = -1\n", + "variant_df_gwas_noncausal.loc[variant_df_gwas_noncausal['strand'] == '+', 'rel_var_position'] = variant_df_gwas_noncausal['var_position'] - (variant_df_gwas_noncausal['pas_pos'] - 70 + 1)\n", + "variant_df_gwas_noncausal.loc[variant_df_gwas_noncausal['strand'] == '-', 'rel_var_position'] = ((variant_df_gwas_noncausal['pas_pos'] - (205 - 70)) + 205) - variant_df_gwas_noncausal['var_position']\n", + "\n", + "variant_df_gwas_noncausal['alt_usage'] = 1. / (1. + 1. / ((np.clip(variant_df_gwas_noncausal['native_usage'], 1e-7, 1. - 1e-7) / (1. - np.clip(variant_df_gwas_noncausal['native_usage'], 1e-7, 1. - 1e-7))) * np.exp(variant_df_gwas_noncausal['delta_logodds_0_205'])))\n", + "variant_df_gwas_noncausal['delta_usage'] = variant_df_gwas_noncausal['alt_usage'] - variant_df_gwas_noncausal['native_usage']\n", + "\n", + "variant_df_gwas_noncausal['alt_usage_77_127'] = 1. / (1. + 1. / ((np.clip(variant_df_gwas_noncausal['native_usage'], 1e-7, 1. - 1e-7) / (1. - np.clip(variant_df_gwas_noncausal['native_usage'], 1e-7, 1. - 1e-7))) * np.exp(variant_df_gwas_noncausal['delta_logodds_77_127'])))\n", + "variant_df_gwas_noncausal['delta_usage_77_127'] = variant_df_gwas_noncausal['alt_usage_77_127'] - variant_df_gwas_noncausal['native_usage']\n", + "\n", + "polyadb_df_unique = polyadb_df.drop_duplicates(subset=[\"gene_id\"], keep='first').copy().reset_index(drop=True)\n", + "polyadb_df_unique['padb_join_id'] = polyadb_df_unique['chrom'] + \"_\" + polyadb_df_unique['pas_pos'].astype(str) + \"_\" + polyadb_df_unique['strand']\n", + "variant_df_gwas_noncausal['padb_join_id'] = variant_df_gwas_noncausal['chrom'] + \"_\" + variant_df_gwas_noncausal['pas_pos'].astype(str) + \"_\" + variant_df_gwas_noncausal['strand']\n", + "\n", + "variant_df_gwas_noncausal = variant_df_gwas_noncausal.join(polyadb_df_unique[['padb_join_id', 'pas']].set_index(\"padb_join_id\"), on='padb_join_id', how='inner').copy().reset_index(drop=True)\n", + "\n", + "variant_df_gwas_noncausal['target_rel_var_position'] = np.abs(90 - variant_df_gwas_noncausal['rel_var_position'])\n", + "variant_df_gwas_noncausal['target_delta_logodds_77_127_abs'] = -variant_df_gwas_noncausal['delta_logodds_77_127_abs']\n", + "variant_df_gwas_noncausal = variant_df_gwas_noncausal.sort_values(by=['target_rel_var_position', 'target_delta_logodds_77_127_abs'], ascending=True).drop_duplicates(subset=['causaldb_join_id', 'meta_id'], keep='first').copy().reset_index(drop=True)\n", + "#variant_df_gwas_noncausal['pas'] = -1. * variant_df_gwas_noncausal['pas']\n", + "#variant_df_gwas_noncausal = variant_df_gwas_noncausal.sort_values(by=[\"pas\", 'delta_logodds_77_127_abs'], ascending=False).drop_duplicates(subset=['causaldb_join_id', 'meta_id'], keep='first').copy().reset_index(drop=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(variant_df_gwas_lead) = 8072\n", + "len(variant_df_gwas_all_lead) = 9205\n" + ] + } + ], + "source": [ + "#Aggregate summary statistic for unique SNPs (by rsID)\n", + "\n", + "variant_df_gwas_all = pd.concat([variant_df_gwas, variant_df_gwas_noncausal]).drop_duplicates(subset=[\"causaldb_join_id\"], keep='first').copy().reset_index(drop=True)\n", + "\n", + "variant_df_gwas_lead = variant_df_gwas.copy().sort_values(by='FINEMAP', ascending=False).drop_duplicates(subset=[\"causaldb_join_id\"], keep='first').copy().reset_index(drop=True)\n", + "variant_df_gwas_all_lead = variant_df_gwas_all.copy().sort_values(by='FINEMAP', ascending=False).drop_duplicates(subset=[\"causaldb_join_id\"], keep='first').copy().reset_index(drop=True)\n", + "\n", + "print(\"len(variant_df_gwas_lead) = \" + str(len(variant_df_gwas_lead)))\n", + "print(\"len(variant_df_gwas_all_lead) = \" + str(len(variant_df_gwas_all_lead)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x_thresh_low = -0.3365\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Fisher's exact test ---\n", + "\n", + "x (low) = 0.001\n", + "x (high) = 0.2\n", + "\n", + "n (low) = 1026\n", + "n (high) = 202\n", + "\n", + "[[942. 84.]\n", + " [179. 23.]]\n", + "\n", + "(1.4409417398244213, 0.09330476285498879)\n", + "\n", + "RanksumsResult(statistic=1.7953519202835833, pvalue=0.03629882382397424)\n", + "\n", + "x_thresh_low = -0.4055\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Fisher's exact test ---\n", + "\n", + "x (low) = 0.001\n", + "x (high) = 0.2\n", + "\n", + "n (low) = 1026\n", + "n (high) = 202\n", + "\n", + "[[965. 61.]\n", + " [183. 19.]]\n", + "\n", + "(1.6424796201737883, 0.05238394717543503)\n", + "\n", + "RanksumsResult(statistic=1.7953519202835833, pvalue=0.03629882382397424)\n", + "\n", + "x_thresh_low = -0.6931\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Fisher's exact test ---\n", + "\n", + "x (low) = 0.001\n", + "x (high) = 0.2\n", + "\n", + "n (low) = 1026\n", + "n (high) = 202\n", + "\n", + "[[996. 30.]\n", + " [190. 12.]]\n", + "\n", + "(2.096842105263158, 0.03188941718410415)\n", + "\n", + "RanksumsResult(statistic=1.7953519202835833, pvalue=0.03629882382397424)\n", + "\n" + ] + } + ], + "source": [ + "#Calculate statistics in intervals of FINEMAP PP (log odds)\n", + "\n", + "from scipy.stats import ranksums, fisher_exact\n", + "\n", + "x = -np.abs(variant_df_gwas_all_lead.query(\"site_type == '3_most_exon' and native_usage > 0. and native_usage < 1.\")['delta_logodds_0_205'].values)\n", + "y = np.array(variant_df_gwas_all_lead.query(\"site_type == '3_most_exon' and native_usage > 0. and native_usage < 1.\")['FINEMAP'].values)\n", + "\n", + "x_thresh_lows = [-np.log(1.4), -np.log(1.5), -np.log(2.0)]\n", + "\n", + "fisher_test_low_y = 0.001\n", + "fisher_test_high_y = 0.2\n", + "\n", + "for x_thresh_low in x_thresh_lows :\n", + "\n", + " print(\"x_thresh_low = \" + str(round(x_thresh_low, 4)))\n", + " \n", + " x_0 = x[(y >= 0.)]\n", + " x_0_01 = x[(y >= 0.01)]\n", + " x_0_05 = x[(y >= 0.05)]\n", + " x_0_2 = x[(y >= 0.2)]\n", + " x_0_5 = x[(y >= 0.5)]\n", + " x_0_9 = x[(y >= 0.9)]\n", + " x_0_95 = x[(y >= 0.95)]\n", + "\n", + " f_0 = np.sum(x_0 < x_thresh_low) / x_0.shape[0]\n", + " f_0_01 = np.sum(x_0_01 < x_thresh_low) / x_0_01.shape[0]\n", + " f_0_05 = np.sum(x_0_05 < x_thresh_low) / x_0_05.shape[0]\n", + " f_0_2 = np.sum(x_0_2 < x_thresh_low) / x_0_2.shape[0]\n", + " f_0_5 = np.sum(x_0_5 < x_thresh_low) / x_0_5.shape[0]\n", + " f_0_9 = np.sum(x_0_9 < x_thresh_low) / x_0_9.shape[0]\n", + " f_0_95 = np.sum(x_0_95 < x_thresh_low) / x_0_95.shape[0]\n", + "\n", + " r_0_01 = f_0_01 / f_0\n", + " r_0_05 = f_0_05 / f_0\n", + " r_0_2 = f_0_2 / f_0\n", + " r_0_5 = f_0_5 / f_0\n", + " r_0_9 = f_0_9 / f_0\n", + " r_0_95 = f_0_95 / f_0\n", + "\n", + " fs = np.array([1., r_0_01, r_0_05, r_0_2, r_0_5, r_0_9, r_0_95])\n", + "\n", + " f = plt.figure(figsize=(6, 4))\n", + "\n", + " plt.bar([0], [fs[0]], color='darkgray', linewidth=2, edgecolor='black')\n", + " plt.bar((np.arange(fs.shape[0]-1)+1).tolist(), fs[1:].tolist(), color='deepskyblue', linewidth=2, edgecolor='black')\n", + "\n", + " plt.axhline(y=1.0, linewidth=2, linestyle='--', color='black')\n", + "\n", + " plt.xticks(\n", + " np.arange(fs.shape[0]), [\n", + " \">= 0%\",\n", + " \">= 1%\",\n", + " \">= 5%\",\n", + " \">= 20%\",\n", + " \">= 50%\",\n", + " \">= 90%\",\n", + " \">= 95%\",\n", + " ], fontsize=12, rotation=45\n", + " )\n", + "\n", + " plt.yticks(fontsize=12)\n", + "\n", + " plt.xlabel(\"FINEMAP Posterior Probability\", fontsize=12)\n", + " plt.ylabel(\"Frequency of Disruptive Variants\\n(Relative to FINEMAP >= 0)\", fontsize=12)\n", + "\n", + " plt.ylim(0.3)\n", + "\n", + " plt.tight_layout()\n", + "\n", + " plt.savefig(\"apa_causaldb_disruptive_frequency_logodds_\" + str(round(x_thresh_low, 4)).replace(\".\", \"_\").replace(\"-\", \"\") + \"_v2.eps\")\n", + " plt.savefig(\"apa_causaldb_disruptive_frequency_logodds_\" + str(round(x_thresh_low, 4)).replace(\".\", \"_\").replace(\"-\", \"\") + \"_v2.png\", transparent=True, dpi=300)\n", + "\n", + " plt.show()\n", + " \n", + " x_low = x[(y < fisher_test_low_y)]\n", + " x_high = x[(y >= fisher_test_high_y)]\n", + "\n", + " print(\"--- Fisher's exact test ---\")\n", + " print(\"\")\n", + " print(\"x (low) = \" + str(fisher_test_low_y))\n", + " print(\"x (high) = \" + str(fisher_test_high_y))\n", + " print(\"\")\n", + " print(\"n (low) = \" + str(x_low.shape[0]))\n", + " print(\"n (high) = \" + str(x_high.shape[0]))\n", + " \n", + " t1 = np.zeros((2, 2))\n", + " \n", + " t1[0, 0] = np.sum(x_low >= x_thresh_low)\n", + " t1[0, 1] = np.sum(x_low < x_thresh_low)\n", + " t1[1, 0] = np.sum(x_high >= x_thresh_low)\n", + " t1[1, 1] = np.sum(x_high < x_thresh_low)\n", + "\n", + " print(\"\")\n", + " print(t1)\n", + " print(\"\")\n", + "\n", + " print(fisher_exact(t1, alternative='greater'))\n", + " \n", + " print(\"\")\n", + " \n", + " print(ranksums(x_low, x_high, alternative='greater'))\n", + " \n", + " print(\"\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Environment (conda_modisco_p37)", + "language": "python", + "name": "conda_modisco_p37" + }, + "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.7.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/analysis/gnomad_v3/gwas_ukbb_comparison.ipynb b/analysis/gnomad_v3/gwas_ukbb_comparison.ipynb new file mode 100644 index 0000000..6f4522a --- /dev/null +++ b/analysis/gnomad_v3/gwas_ukbb_comparison.ipynb @@ -0,0 +1,769 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ] + } + ], + "source": [ + "from __future__ import print_function\n", + "import keras\n", + "from keras.models import Sequential, Model, load_model\n", + "from keras import backend as K\n", + "\n", + "import tensorflow as tf\n", + "\n", + "import os\n", + "import pandas as pd\n", + "\n", + "import numpy as np\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.cm as cm\n", + "\n", + "#import aparent.visualization as vis\n", + "\n", + "#from aparent_predictor import *\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#Store variant prediction dataframe\n", + "\n", + "variant_df = pd.read_csv('aparent_resnet_variant_predictions_polyadb_no_sequences_no_cutoff.csv', sep='\\t')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(polyadb_df) = 175451\n" + ] + } + ], + "source": [ + "#Load APADB Data and filter on targeted genes\n", + "\n", + "#genes = ['RUNX1', 'CEBPA', 'GATA2', 'ANKRD26', 'DDX41', 'ETV6', 'PTEN', 'BRCA1', 'BRCA2', 'TP53', 'APC', 'ATM', 'PALB2', 'MSH2', 'MLH1', 'MSH6', 'PMS2', 'MUTYH']\n", + "\n", + "polyadb_df = pd.read_csv('polyadb_processed.csv', sep=',')\n", + "\n", + "#polyadb_df = polyadb_df.loc[polyadb_df['gene'].isin(genes)].reset_index(drop=True).copy()\n", + "polyadb_df = polyadb_df.loc[((~polyadb_df['gene'].isnull()) & (polyadb_df['gene'] != 'na')) & (polyadb_df['pas'] != -1)].reset_index(drop=True).copy()\n", + "\n", + "print('len(polyadb_df) = ' + str(len(polyadb_df)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#Process PolyaDB data\n", + "\n", + "polyadb_df_minus = polyadb_df.query(\"strand == '-'\").copy().reset_index(drop=True)\n", + "polyadb_df_plus = polyadb_df.query(\"strand == '+'\").copy().reset_index(drop=True)\n", + "\n", + "polyadb_df_minus = polyadb_df_minus.sort_values(by='pas_pos', ascending=False).copy().reset_index(drop=True)\n", + "polyadb_df_plus = polyadb_df_plus.sort_values(by='pas_pos', ascending=True).copy().reset_index(drop=True)\n", + "\n", + "new_gene_id_list_plus = []\n", + "sitenum_list_plus = []\n", + "gene_id_dict = {}\n", + "for _, row in polyadb_df_plus.iterrows() :\n", + "\n", + " gene = row['gene']\n", + "\n", + " if gene not in gene_id_dict :\n", + " gene_id_dict[gene] = 0\n", + "\n", + " gene_id_dict[gene] += 1\n", + "\n", + " new_gene_id_list_plus.append(gene + \".\" + str(gene_id_dict[gene]))\n", + " sitenum_list_plus.append(gene_id_dict[gene])\n", + "\n", + "polyadb_df_plus['gene_id'] = new_gene_id_list_plus\n", + "polyadb_df_plus['sitenum'] = sitenum_list_plus\n", + "\n", + "new_gene_id_list_minus = []\n", + "sitenum_list_minus = []\n", + "gene_id_dict = {}\n", + "for _, row in polyadb_df_minus.iterrows() :\n", + "\n", + " gene = row['gene']\n", + "\n", + " if gene not in gene_id_dict :\n", + " gene_id_dict[gene] = 0\n", + "\n", + " gene_id_dict[gene] += 1\n", + "\n", + " new_gene_id_list_minus.append(gene + \".\" + str(gene_id_dict[gene]))\n", + " sitenum_list_minus.append(gene_id_dict[gene])\n", + "\n", + "polyadb_df_minus['gene_id'] = new_gene_id_list_minus\n", + "polyadb_df_minus['sitenum'] = sitenum_list_minus\n", + "\n", + "polyadb_df = pd.concat([polyadb_df_plus, polyadb_df_minus])\n", + "\n", + "polyadb_df = polyadb_df.sort_values(by=['gene', 'sitenum'], ascending=True).reset_index(drop=True).copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#Get variant positions in hg38 coordinates\n", + "\n", + "polyadb_bed_hg19 = pd.read_csv(\"polyadb_coordinates_hg19.bed\", sep='\\t', header=None, names=['chrom', 'pas_pos_hg19', 'end', 'gene', 'gene_id', 'strand'])\n", + "polyadb_bed_hg38 = pd.read_csv(\"polyadb_coordinates_hg38.bed\", sep='\\t', header=None, names=['chrom', 'pas_pos_hg38', 'end', 'gene', 'gene_id', 'strand'])\n", + "\n", + "polyadb_bed_hg38 = polyadb_bed_hg38.join(polyadb_bed_hg19[['gene_id', 'pas_pos_hg19']].set_index('gene_id'), on='gene_id', how='inner').copy().reset_index(drop=True)\n", + "\n", + "polyadb_bed_hg38['padb_join_id'] = polyadb_bed_hg38['chrom'] + \"_\" + polyadb_bed_hg38['pas_pos_hg19'].astype(str) + \"_\" + polyadb_bed_hg38['gene']\n", + "polyadb_df['padb_join_id'] = polyadb_df['chrom'] + \"_\" + polyadb_df['pas_pos'].astype(str) + \"_\" + polyadb_df['gene']\n", + "\n", + "polyadb_df = polyadb_df.join(polyadb_bed_hg38[['padb_join_id', 'pas_pos_hg38']].set_index(\"padb_join_id\"), on='padb_join_id', how='inner').copy().reset_index(drop=True)\n", + "\n", + "#polyadb_df = polyadb_df.query(\"site_type == '3_most_exon'\")\n", + "\n", + "polyadb_df = polyadb_df.drop_duplicates(subset=['gene_id'], keep='first').copy().reset_index(drop=True)\n", + "\n", + "variant_df = variant_df.join(polyadb_df[['gene_id', 'pas_pos', 'pas_pos_hg38']].set_index(\"gene_id\"), on='gene_id', how='inner').copy().reset_index(drop=True)\n", + "\n", + "variant_df['var_position_hg38'] = variant_df['var_position'] - variant_df['pas_pos'] + variant_df['pas_pos_hg38']\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#Store hg19 interval of PAS sites to intersect UKBB data against\n", + "\n", + "polyadb_df['start'] = polyadb_df['pas_pos'] - 150\n", + "polyadb_df['end'] = polyadb_df['pas_pos'] + 150\n", + "\n", + "polyadb_bed = polyadb_df[['chrom', 'start', 'end', 'gene', 'gene_id', 'strand']].query(\"chrom != 'chrX' and chrom != 'chrY'\").copy().reset_index(drop=True)\n", + "\n", + "polyadb_bed['sort_chrom'] = polyadb_bed['chrom'].apply(lambda x: x[3:]).astype(int)\n", + "polyadb_bed['sort_start'] = polyadb_bed['start'].astype(int)\n", + "\n", + "polyadb_bed = polyadb_bed.sort_values(by=['sort_chrom', 'sort_start'], ascending=True).copy().reset_index(drop=True)\n", + "\n", + "polyadb_bed = polyadb_bed[['chrom', 'start', 'end', 'gene', 'gene_id', 'strand']].copy().reset_index(drop=True)\n", + "\n", + "polyadb_bed.to_csv(\"polyadb_interval_coordinates_hg19.sorted.bed\", sep='\\t', header=False, index=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#Intersect UKBB data against PolyADB\n", + "\n", + "!bedtools intersect -sorted -a polyadb_interval_coordinates_hg19.sorted.bed -b UKBB_94_traits/UKBB_94traits_release1_regions.bed.gz -wb > UKBB_94_traits/UKBB_94traits_release1_regions_intersect.bed\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(ukbb_df) = 5377879\n" + ] + } + ], + "source": [ + "#Get UKBB fine-mapping data\n", + "\n", + "column_names = [\n", + " 'chromosome',\n", + " 'start',\n", + " 'end',\n", + " 'variant',\n", + " 'rsid',\n", + " 'allele1',\n", + " 'allele2',\n", + " 'minorallele',\n", + " 'cohort',\n", + " 'model_marginal',\n", + " 'method',\n", + " 'trait',\n", + " 'region',\n", + " 'maf',\n", + " 'beta_marginal',\n", + " 'se_marginal',\n", + " 'chisq_marginal',\n", + " 'pip',\n", + " 'cs_id',\n", + " 'beta_posterior',\n", + " 'sd_posterior',\n", + " 'LD_HWE',\n", + " 'LD_SV',\n", + "]\n", + "\n", + "ukbb_df = pd.read_csv(\"UKBB_94_traits/UKBB_94traits_release1.bed.gz\", sep='\\t', compression='gzip', names=column_names)\n", + "\n", + "print(\"len(ukbb_df) = \" + str(len(ukbb_df)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(all_ukbb_df) = 3450965\n" + ] + } + ], + "source": [ + "#Get UKKB non-causal variants\n", + "\n", + "column_names = [\n", + " 'chromosome',\n", + " 'start',\n", + " 'end',\n", + " 'cohort',\n", + " 'trait',\n", + " 'region',\n", + " 'variant',\n", + " 'success_finemap',\n", + " 'success_susie',\n", + "]\n", + "\n", + "all_ukbb_df = pd.read_csv(\"UKBB_94_traits/UKBB_94traits_release1_regions_intersect.bed\", sep='\\t', names=column_names)\n", + "\n", + "#Apply filters\n", + "all_ukbb_df = all_ukbb_df.query(\"success_finemap == True and success_susie == True\").drop_duplicates(subset=['variant', 'trait', 'cohort'], keep='first').copy().reset_index(drop=True)\n", + "\n", + "print(\"len(all_ukbb_df) = \" + str(len(all_ukbb_df)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "#Extract non-causal variants\n", + "\n", + "all_ukbb_df = all_ukbb_df[['chromosome', 'start', 'end', 'cohort', 'trait', 'region', 'variant']]\n", + "\n", + "all_ukbb_df = all_ukbb_df.join(ukbb_df[['variant', 'pip']].set_index(\"variant\"), on='variant', how='left')\n", + "noncausal_ukbb_df = all_ukbb_df.loc[all_ukbb_df['pip'].isnull()].copy().reset_index(drop=True)\n", + "noncausal_ukbb_df['pip'] = 0.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'\\nvariant_df_gwas_noncausal = variant_df.join(noncausal_ukbb_df[[\"variant\", \\'trait\\', \\'pip\\']].set_index(\"variant\"), on=\\'ukbb_join_id\\', how=\\'inner\\').copy().reset_index(drop=True)\\n\\nvariant_df_gwas_noncausal.to_csv(\"aparent_resnet_variant_predictions_polyadb_no_sequences_ukbb_noncausal_no_cutoff.csv\", sep=\\'\\t\\', index=False)\\n'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Map variants to predictions\n", + "\n", + "variant_df['ukbb_join_id'] = variant_df['chrom'] + \":\" + variant_df['var_position'].astype(str) + \":\" + variant_df['ref_nucleotide'] + \":\" + variant_df['var_nucleotide']\n", + "\n", + "variant_df_gwas = variant_df.join(ukbb_df[[\"variant\", 'rsid', 'trait', 'maf', 'pip', 'cs_id', 'beta_marginal', 'se_marginal', 'chisq_marginal', 'beta_posterior', 'sd_posterior']].set_index(\"variant\"), on='ukbb_join_id', how='inner').copy().reset_index(drop=True)\n", + "\n", + "variant_df_gwas.to_csv(\"aparent_resnet_variant_predictions_polyadb_no_sequences_ukbb_no_cutoff_w_chisq.csv\", sep='\\t', index=False)\n", + "\n", + "#Map non-causal variants to predictions\n", + "\n", + "variant_df_gwas_noncausal = variant_df.join(noncausal_ukbb_df[[\"variant\", 'trait', 'pip']].set_index(\"variant\"), on='ukbb_join_id', how='inner').copy().reset_index(drop=True)\n", + "\n", + "variant_df_gwas_noncausal.to_csv(\"aparent_resnet_variant_predictions_polyadb_no_sequences_ukbb_noncausal_no_cutoff.csv\", sep='\\t', index=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "variant_df_gwas = pd.read_csv(\"aparent_resnet_variant_predictions_polyadb_no_sequences_ukbb_no_cutoff_w_chisq.csv\", sep='\\t')\n", + "variant_df_gwas_noncausal = pd.read_csv(\"aparent_resnet_variant_predictions_polyadb_no_sequences_ukbb_noncausal_no_cutoff.csv\", sep='\\t')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "#Drop duplicates for partially overlapping annotated PASs\n", + "\n", + "variant_df_gwas['rsID'] = variant_df_gwas['rsid'].astype(str)\n", + "\n", + "variant_df_gwas['delta_logodds_77_127_abs'] = np.abs(variant_df_gwas['delta_logodds_77_127'])\n", + "\n", + "variant_df_gwas['rel_var_position'] = -1\n", + "variant_df_gwas.loc[variant_df_gwas['strand'] == '+', 'rel_var_position'] = variant_df_gwas['var_position'] - (variant_df_gwas['pas_pos'] - 70 + 1)\n", + "variant_df_gwas.loc[variant_df_gwas['strand'] == '-', 'rel_var_position'] = ((variant_df_gwas['pas_pos'] - (205 - 70)) + 205) - variant_df_gwas['var_position']\n", + "\n", + "variant_df_gwas['target_rel_var_position'] = np.abs(90 - variant_df_gwas['rel_var_position'])\n", + "variant_df_gwas['delta_logodds_77_127_abs'] = -variant_df_gwas['delta_logodds_77_127_abs']\n", + "variant_df_gwas = variant_df_gwas.sort_values(by=['target_rel_var_position', 'delta_logodds_77_127_abs'], ascending=True).drop_duplicates(subset=['ukbb_join_id', 'trait'], keep='first').copy().reset_index(drop=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(variant_df_gwas_lead) = 17426\n" + ] + } + ], + "source": [ + "#Aggregate summary statistic for unique SNPs (by rsID)\n", + "\n", + "variant_df_gwas_lead = variant_df_gwas.copy().sort_values(by='pip', ascending=False).drop_duplicates(\"ukbb_join_id\").copy().reset_index(drop=True)\n", + "\n", + "print(\"len(variant_df_gwas_lead) = \" + str(len(variant_df_gwas_lead)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "#Filter on 3' UTR SNPs only\n", + "\n", + "variant_df_gwas = variant_df_gwas.query(\"site_type == '3_most_exon'\").copy().reset_index(drop=True)\n", + "variant_df_gwas_lead = variant_df_gwas_lead.query(\"site_type == '3_most_exon'\").copy().reset_index(drop=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n = 9190\n", + "n (>= 1.4-fold) = 1153\n", + "\n", + "n = 41 (PP >= 0.9)\n", + "n (>= 1.4-fold) = 13 (PP >= 0.9)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "variant_df_gwas_lead['delta_logodds_77_127_abs'] = np.abs(variant_df_gwas_lead['delta_logodds_77_127'])\n", + "\n", + "variant_df_gwas_lead_non_signi = variant_df_gwas_lead.query(\"pip < 0.9\")\n", + "variant_df_gwas_lead_signi = variant_df_gwas_lead.query(\"pip >= 0.9\")\n", + "\n", + "print(\"n = \" + str(len(variant_df_gwas_lead)))\n", + "print(\"n (>= 1.4-fold) = \" + str(len(variant_df_gwas_lead.query(\"delta_logodds_77_127_abs >= 0.336\"))))\n", + "\n", + "print(\"\")\n", + "print(\"n = \" + str(len(variant_df_gwas_lead_signi)) + \" (PP >= 0.9)\")\n", + "print(\"n (>= 1.4-fold) = \" + str(len(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs >= 0.336\"))) + \" (PP >= 0.9)\")\n", + "\n", + "plt.scatter(variant_df_gwas_lead_non_signi['delta_logodds_77_127_abs'] / np.log(2.), variant_df_gwas_lead_non_signi['chisq_marginal'], color='darkgreen', s=15, alpha=0.95)\n", + "\n", + "plt.scatter(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs < 0.336\")['delta_logodds_77_127_abs'] / np.log(2.), variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs < 0.336\")['chisq_marginal'], color='red', s=15, alpha=0.95)\n", + "plt.scatter(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs >= 0.336\")['delta_logodds_77_127_abs'] / np.log(2.), variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs >= 0.336\")['chisq_marginal'], color='red', s=35, marker=\"^\", alpha=0.95)\n", + "\n", + "plt.axvline(x=np.log2(1.4), linestyle='--', linewidth=2, color='black')\n", + "\n", + "plt.xlim(-0.1, 6.0)\n", + "plt.ylim(-25, 1000)\n", + "\n", + "plt.xticks([0, 1, 2, 3, 4, 5, 6], ['Ref', '2-fold', '4-fold', '8-fold', '16-fold', '32-fold', '64-fold'], fontsize=12, rotation=45)\n", + "plt.yticks(fontsize=12, rotation=45)\n", + "\n", + "plt.savefig(\"ukbb_aparent_resnet_scatter_utr3_only_pp_09_v2.png\", transparent=True, dpi=300)\n", + "plt.savefig(\"ukbb_aparent_resnet_scatter_utr3_only_pp_09_v2.eps\")\n", + "\n", + "plt.tight_layout()\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n = 9190\n", + "n (>= 1.4-fold) = 1153\n", + "\n", + "n = 26 (PP >= 0.5)\n", + "n (>= 1.4-fold) = 2 (PP >= 0.5)\n", + "\n", + "n = 41 (PP >= 0.9)\n", + "n (>= 1.4-fold) = 13 (PP >= 0.9)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "variant_df_gwas_lead['delta_logodds_77_127_abs'] = np.abs(variant_df_gwas_lead['delta_logodds_77_127'])\n", + "\n", + "variant_df_gwas_lead_non_signi = variant_df_gwas_lead.query(\"pip < 0.5\")\n", + "variant_df_gwas_lead_semi_signi = variant_df_gwas_lead.query(\"pip >= 0.5 and pip < 0.9\")\n", + "variant_df_gwas_lead_signi = variant_df_gwas_lead.query(\"pip >= 0.9\")\n", + "\n", + "print(\"n = \" + str(len(variant_df_gwas_lead)))\n", + "print(\"n (>= 1.4-fold) = \" + str(len(variant_df_gwas_lead.query(\"delta_logodds_77_127_abs >= 0.336\"))))\n", + "\n", + "print(\"\")\n", + "print(\"n = \" + str(len(variant_df_gwas_lead_semi_signi)) + \" (PP >= 0.5)\")\n", + "print(\"n (>= 1.4-fold) = \" + str(len(variant_df_gwas_lead_semi_signi.query(\"delta_logodds_77_127_abs >= 0.336\"))) + \" (PP >= 0.5)\")\n", + "\n", + "print(\"\")\n", + "print(\"n = \" + str(len(variant_df_gwas_lead_signi)) + \" (PP >= 0.9)\")\n", + "print(\"n (>= 1.4-fold) = \" + str(len(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs >= 0.336\"))) + \" (PP >= 0.9)\")\n", + "\n", + "plt.scatter(variant_df_gwas_lead_non_signi['delta_logodds_77_127_abs'] / np.log(2.), variant_df_gwas_lead_non_signi['chisq_marginal'], color='darkgreen', s=15, alpha=0.95)\n", + "\n", + "plt.scatter(variant_df_gwas_lead_semi_signi.query(\"delta_logodds_77_127_abs < 0.336\")['delta_logodds_77_127_abs'] / np.log(2.), variant_df_gwas_lead_semi_signi.query(\"delta_logodds_77_127_abs < 0.336\")['chisq_marginal'], color='blue', s=15, alpha=0.95)\n", + "plt.scatter(variant_df_gwas_lead_semi_signi.query(\"delta_logodds_77_127_abs >= 0.336\")['delta_logodds_77_127_abs'] / np.log(2.), variant_df_gwas_lead_semi_signi.query(\"delta_logodds_77_127_abs >= 0.336\")['chisq_marginal'], color='blue', s=35, marker=\"^\", alpha=0.95)\n", + "\n", + "plt.scatter(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs < 0.336\")['delta_logodds_77_127_abs'] / np.log(2.), variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs < 0.336\")['chisq_marginal'], color='red', s=15, alpha=0.95)\n", + "plt.scatter(variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs >= 0.336\")['delta_logodds_77_127_abs'] / np.log(2.), variant_df_gwas_lead_signi.query(\"delta_logodds_77_127_abs >= 0.336\")['chisq_marginal'], color='red', s=35, marker=\"^\", alpha=0.95)\n", + "\n", + "plt.axvline(x=np.log2(1.4), linestyle='--', linewidth=2, color='black')\n", + "\n", + "plt.xlim(-0.1, 6.0)\n", + "plt.ylim(-25, 1000)\n", + "\n", + "plt.xticks([0, 1, 2, 3, 4, 5, 6], ['Ref', '2-fold', '4-fold', '8-fold', '16-fold', '32-fold', '64-fold'], fontsize=12, rotation=45)\n", + "plt.yticks(fontsize=12, rotation=45)\n", + "\n", + "plt.savefig(\"ukbb_aparent_resnet_scatter_utr3_only_pp_05_09_v2.png\", transparent=True, dpi=300)\n", + "plt.savefig(\"ukbb_aparent_resnet_scatter_utr3_only_pp_05_09_v2.eps\")\n", + "\n", + "plt.tight_layout()\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "#Load trait metadata\n", + "\n", + "ukbb_meta_df = pd.read_csv(\"UKBB_94_traits/UKBB_94traits_release1.traits\", sep='\\t')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "#Get SNPs with PP >= 0.5 and PP >= 0.9\n", + "\n", + "variant_df_gwas_semi_signi = variant_df_gwas.query(\"pip >= 0.5 and pip < 0.9\").copy()\n", + "variant_df_gwas_lead_semi_signi = variant_df_gwas_lead_semi_signi.query(\"pip >= 0.5 and pip < 0.9\").copy()\n", + "\n", + "variant_df_gwas_semi_signi = variant_df_gwas_semi_signi.join(ukbb_meta_df[['trait', 'description']].set_index(\"trait\"), on='trait', how='inner').copy().reset_index(drop=True)\n", + "variant_df_gwas_lead_semi_signi = variant_df_gwas_lead_semi_signi.join(ukbb_meta_df[['trait', 'description']].set_index(\"trait\"), on='trait', how='inner').copy().reset_index(drop=True)\n", + "\n", + "variant_df_gwas_signi = variant_df_gwas.query(\"pip >= 0.9\").copy()\n", + "variant_df_gwas_lead_signi = variant_df_gwas_lead_signi.query(\"pip >= 0.9\").copy()\n", + "\n", + "variant_df_gwas_signi = variant_df_gwas_signi.join(ukbb_meta_df[['trait', 'description']].set_index(\"trait\"), on='trait', how='inner').copy().reset_index(drop=True)\n", + "variant_df_gwas_lead_signi = variant_df_gwas_lead_signi.join(ukbb_meta_df[['trait', 'description']].set_index(\"trait\"), on='trait', how='inner').copy().reset_index(drop=True)\n", + "\n", + "variant_df_gwas_lead_semi_signi['delta_logodds_77_127_abs_log_2'] = 2**(variant_df_gwas_lead_semi_signi['delta_logodds_77_127_abs'] / np.log(2.))\n", + "variant_df_gwas_lead_signi['delta_logodds_77_127_abs_log_2'] = 2**(variant_df_gwas_lead_signi['delta_logodds_77_127_abs'] / np.log(2.))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "#Get variant ids\n", + "\n", + "rs_ids = set(variant_df_gwas['rsID'].unique().tolist())\n", + "\n", + "rs_ids_semi_signi = set(variant_df_gwas_semi_signi['rsID'].unique().tolist())\n", + "rs_ids_lead_semi_signi = set(variant_df_gwas_lead_semi_signi['rsID'].unique().tolist())\n", + "\n", + "rs_ids_signi = set(variant_df_gwas_signi['rsID'].unique().tolist())\n", + "rs_ids_lead_signi = set(variant_df_gwas_lead_signi['rsID'].unique().tolist())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- SNPs from credible set w. PP >= 0.9 ---\n", + "rs3211995 : True\n", + " - delta_logodds_77_127 = 3.0457\n", + " - delta_logodds_77_127_abs_log_2 = 21.0241\n", + " -- Mean arterial pressure, statistic = 37.9865, PP = 0.996894\n", + " -- Systolic blood pressure, statistic = 43.1158, PP = 0.995952\n", + "\n", + "rs78378222 : True\n", + " - delta_logodds_77_127 = -2.3624\n", + " - delta_logodds_77_127_abs_log_2 = 10.6162\n", + " -- Adult height, statistic = 118.362, PP = 1.0\n", + " -- Mean corpuscular hemoglobin, statistic = 100.5, PP = 1.0\n", + " -- Mean corpuscular volume, statistic = 88.3365, PP = 1.0\n", + " -- Red blood cell count, statistic = 97.3022, PP = 1.0\n", + " -- Apolipoprotein A, statistic = 40.8586, PP = 0.926956\n", + " -- Diastolic blood pressure, statistic = 43.0585, PP = 1.0\n", + " -- Loss of Y, statistic = 296.598, PP = 1.0\n", + " -- Body weight, statistic = 77.2636, PP = 1.0\n", + " -- Hematocrit, statistic = 23.3951, PP = 0.902121\n", + " -- Pluse pressure, statistic = 90.6262, PP = 1.0\n", + "\n", + "rs6796 : True\n", + " - delta_logodds_77_127 = -2.2975\n", + " - delta_logodds_77_127_abs_log_2 = 9.9491\n", + " -- Monocyte count, statistic = 273.915, PP = 0.999998\n", + "\n", + "rs76020419 : True\n", + " - delta_logodds_77_127 = 1.4474\n", + " - delta_logodds_77_127_abs_log_2 = 4.252\n", + " -- Diastolic blood pressure, statistic = 29.4173, PP = 0.98914\n", + "\n", + "rs3208787 : True\n", + " - delta_logodds_77_127 = -1.254\n", + " - delta_logodds_77_127_abs_log_2 = 3.5043\n", + " -- Mean corpuscular hemoglobin, statistic = 33.9289, PP = 0.94508\n", + " -- Red blood cell count, statistic = 65.042, PP = 1.0\n", + "\n", + "rs35979828 : True\n", + " - delta_logodds_77_127 = -1.0283\n", + " - delta_logodds_77_127_abs_log_2 = 2.7962\n", + " -- Hemoglobin A1c, statistic = 40.9369, PP = 0.999966\n", + " -- Mean corpuscular hemoglobin, statistic = 76.1084, PP = 1.0\n", + " -- Mean corpuscular volume, statistic = 151.055, PP = 1.0\n", + " -- Red blood cell count, statistic = 65.6807, PP = 1.0\n", + " -- Eosinophil count, statistic = 67.447, PP = 1.0\n", + " -- Loss of Y, statistic = 87.508, PP = 1.0\n", + " -- Monocyte count, statistic = 67.3078, PP = 1.0\n", + " -- Platelet count, statistic = 181.556, PP = 0.945909\n", + "\n", + "rs884205 : True\n", + " - delta_logodds_77_127 = -0.798\n", + " - delta_logodds_77_127_abs_log_2 = 2.2211\n", + " -- Alkaline phosphatase, statistic = 254.701, PP = 1.0\n", + " -- Estimated heel bone mineral density, statistic = 93.8172, PP = 1.0\n", + "\n", + "rs1815009 : True\n", + " - delta_logodds_77_127 = 0.5175\n", + " - delta_logodds_77_127_abs_log_2 = 1.6778\n", + " -- Insulin-like growth factor 1, statistic = 63.3597, PP = 0.995106\n", + "\n", + "rs11666245 : True\n", + " - delta_logodds_77_127 = 0.5158\n", + " - delta_logodds_77_127_abs_log_2 = 1.6749\n", + " -- C-reactive protein, statistic = 51.5876, PP = 0.977589\n", + "\n", + "rs1055253 : True\n", + " - delta_logodds_77_127 = 0.4956\n", + " - delta_logodds_77_127_abs_log_2 = 1.6414\n", + " -- Red blood cell count, statistic = 46.9531, PP = 0.925224\n", + "\n", + "rs141870697 : True\n", + " - delta_logodds_77_127 = 0.471\n", + " - delta_logodds_77_127_abs_log_2 = 1.6016\n", + " -- FEV1/FVC ratio, statistic = 47.2386, PP = 0.918507\n", + "\n", + "rs7078 : True\n", + " - delta_logodds_77_127 = -0.4102\n", + " - delta_logodds_77_127_abs_log_2 = 1.5071\n", + " -- Estimated heel bone mineral density, statistic = 71.9146, PP = 1.0\n", + "\n", + "rs17352041 : True\n", + " - delta_logodds_77_127 = -0.4011\n", + " - delta_logodds_77_127_abs_log_2 = 1.4934\n", + " -- Adult height, statistic = 35.0065, PP = 0.999975\n", + "\n" + ] + } + ], + "source": [ + "#Top candidates from CasualDB with PP >= 0.9 (cutoff immediately after known pathogenic variant rs1799963)\n", + "\n", + "cand_rs_ids = variant_df_gwas_lead_signi.sort_values(by='delta_logodds_77_127_abs_log_2', ascending=False).query(\"delta_logodds_77_127_abs_log_2 >= 1.4\")['rsID'].values.tolist()\n", + "\n", + "print(\"--- SNPs from credible set w. PP >= 0.9 ---\")\n", + "\n", + "for cand_rs_id in cand_rs_ids :\n", + " print((cand_rs_id + \" \" * 15)[:15] + \": \" + str((cand_rs_id in rs_ids_signi)))\n", + " \n", + " if cand_rs_id in rs_ids_signi :\n", + " print(\" - delta_logodds_77_127 = \" + str(round(variant_df_gwas_lead_signi.query(\"rsID == '\" + cand_rs_id + \"'\").iloc[0]['delta_logodds_77_127'], 4)))\n", + " print(\" - delta_logodds_77_127_abs_log_2 = \" + str(round(2**(np.abs(variant_df_gwas_lead_signi.query(\"rsID == '\" + cand_rs_id + \"'\").iloc[0]['delta_logodds_77_127']) / np.log(2.)), 4)))\n", + " \n", + " subset_df = variant_df_gwas_signi.query(\"rsID == '\" + cand_rs_id + \"'\")\n", + " for _, row in subset_df.iterrows() :\n", + " print(\" -- \" + row['description'] + \", statistic = \" + str(row['chisq_marginal']) + \", PP = \" + str(row['pip']))\n", + "\n", + " print(\"\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- SNPs from credible set w. PP >= 0.5 ---\n", + "rs1064939 : True\n", + " - delta_logodds_77_127 = 0.9162\n", + " - delta_logodds_77_127_abs_log_2 = 2.4999\n", + " -- Body mass index, statistic = 41.7335, PP = 0.894186\n", + "\n", + "rs45463895 : True\n", + " - delta_logodds_77_127 = -0.3893\n", + " - delta_logodds_77_127_abs_log_2 = 1.4759\n", + " -- Monocyte count, statistic = 11.1444, PP = 0.679254\n", + "\n" + ] + } + ], + "source": [ + "#Top candidates from CasualDB with PP >= 0.5 (cutoff immediately after known pathogenic variant rs1799963)\n", + "\n", + "cand_rs_ids = variant_df_gwas_lead_semi_signi.sort_values(by='delta_logodds_77_127_abs_log_2', ascending=False).query(\"delta_logodds_77_127_abs_log_2 >= 1.4\")['rsID'].values.tolist()\n", + "\n", + "print(\"--- SNPs from credible set w. PP >= 0.5 ---\")\n", + "\n", + "for cand_rs_id in cand_rs_ids :\n", + " print((cand_rs_id + \" \" * 15)[:15] + \": \" + str((cand_rs_id in rs_ids_semi_signi)))\n", + " \n", + " if cand_rs_id in rs_ids_semi_signi :\n", + " print(\" - delta_logodds_77_127 = \" + str(round(variant_df_gwas_lead_semi_signi.query(\"rsID == '\" + cand_rs_id + \"'\").iloc[0]['delta_logodds_77_127'], 4)))\n", + " print(\" - delta_logodds_77_127_abs_log_2 = \" + str(round(2**(np.abs(variant_df_gwas_lead_semi_signi.query(\"rsID == '\" + cand_rs_id + \"'\").iloc[0]['delta_logodds_77_127']) / np.log(2.)), 4)))\n", + " \n", + " subset_df = variant_df_gwas_semi_signi.query(\"rsID == '\" + cand_rs_id + \"'\")\n", + " for _, row in subset_df.iterrows() :\n", + " print(\" -- \" + row['description'] + \", statistic = \" + str(row['chisq_marginal']) + \", PP = \" + str(row['pip']))\n", + "\n", + " print(\"\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Environment (conda_tensorflow_p36)", + "language": "python", + "name": "conda_tensorflow_p36" + }, + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/analysis/gnomad_v3/gwas_ukbb_enrichment_analysis.ipynb b/analysis/gnomad_v3/gwas_ukbb_enrichment_analysis.ipynb new file mode 100644 index 0000000..e5d10dd --- /dev/null +++ b/analysis/gnomad_v3/gwas_ukbb_enrichment_analysis.ipynb @@ -0,0 +1,455 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "\n", + "import os\n", + "import pandas as pd\n", + "\n", + "import numpy as np\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.cm as cm\n", + "\n", + "#import aparent.visualization as vis\n", + "\n", + "#from aparent_predictor import *\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(polyadb_df) = 175451\n" + ] + } + ], + "source": [ + "#Load APADB Data and filter on targeted genes\n", + "\n", + "#genes = ['RUNX1', 'CEBPA', 'GATA2', 'ANKRD26', 'DDX41', 'ETV6', 'PTEN', 'BRCA1', 'BRCA2', 'TP53', 'APC', 'ATM', 'PALB2', 'MSH2', 'MLH1', 'MSH6', 'PMS2', 'MUTYH']\n", + "\n", + "polyadb_df = pd.read_csv('polyadb_processed.csv', sep=',')\n", + "\n", + "#polyadb_df = polyadb_df.loc[polyadb_df['gene'].isin(genes)].reset_index(drop=True).copy()\n", + "polyadb_df = polyadb_df.loc[((~polyadb_df['gene'].isnull()) & (polyadb_df['gene'] != 'na')) & (polyadb_df['pas'] != -1)].reset_index(drop=True).copy()\n", + "\n", + "print('len(polyadb_df) = ' + str(len(polyadb_df)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#Process PolyaDB data\n", + "\n", + "polyadb_df_minus = polyadb_df.query(\"strand == '-'\").copy().reset_index(drop=True)\n", + "polyadb_df_plus = polyadb_df.query(\"strand == '+'\").copy().reset_index(drop=True)\n", + "\n", + "polyadb_df_minus = polyadb_df_minus.sort_values(by='pas_pos', ascending=False).copy().reset_index(drop=True)\n", + "polyadb_df_plus = polyadb_df_plus.sort_values(by='pas_pos', ascending=True).copy().reset_index(drop=True)\n", + "\n", + "new_gene_id_list_plus = []\n", + "sitenum_list_plus = []\n", + "gene_id_dict = {}\n", + "for _, row in polyadb_df_plus.iterrows() :\n", + "\n", + " gene = row['gene']\n", + "\n", + " if gene not in gene_id_dict :\n", + " gene_id_dict[gene] = 0\n", + "\n", + " gene_id_dict[gene] += 1\n", + "\n", + " new_gene_id_list_plus.append(gene + \".\" + str(gene_id_dict[gene]))\n", + " sitenum_list_plus.append(gene_id_dict[gene])\n", + "\n", + "polyadb_df_plus['gene_id'] = new_gene_id_list_plus\n", + "polyadb_df_plus['sitenum'] = sitenum_list_plus\n", + "\n", + "new_gene_id_list_minus = []\n", + "sitenum_list_minus = []\n", + "gene_id_dict = {}\n", + "for _, row in polyadb_df_minus.iterrows() :\n", + "\n", + " gene = row['gene']\n", + "\n", + " if gene not in gene_id_dict :\n", + " gene_id_dict[gene] = 0\n", + "\n", + " gene_id_dict[gene] += 1\n", + "\n", + " new_gene_id_list_minus.append(gene + \".\" + str(gene_id_dict[gene]))\n", + " sitenum_list_minus.append(gene_id_dict[gene])\n", + "\n", + "polyadb_df_minus['gene_id'] = new_gene_id_list_minus\n", + "polyadb_df_minus['sitenum'] = sitenum_list_minus\n", + "\n", + "polyadb_df = pd.concat([polyadb_df_plus, polyadb_df_minus])\n", + "\n", + "polyadb_df = polyadb_df.sort_values(by=['gene', 'sitenum'], ascending=True).reset_index(drop=True).copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#Load cached UKBB dataframes (already intersected against predictions)\n", + "\n", + "variant_df_gwas = pd.read_csv(\"aparent_resnet_variant_predictions_polyadb_no_sequences_ukbb_no_cutoff.csv\", sep='\\t')\n", + "variant_df_gwas = variant_df_gwas.query(\"maf >= 0.001\").copy().reset_index(drop=True)\n", + "\n", + "variant_df_gwas_noncausal = pd.read_csv(\"aparent_resnet_variant_predictions_polyadb_no_sequences_ukbb_noncausal_no_cutoff.csv\", sep='\\t')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#Drop duplicates for partially overlapping annotated PASs and add additional fields\n", + "\n", + "variant_df_gwas['delta_logodds_77_127_abs'] = np.abs(variant_df_gwas['delta_logodds_77_127'])\n", + "\n", + "variant_df_gwas['rel_var_position'] = -1\n", + "variant_df_gwas.loc[variant_df_gwas['strand'] == '+', 'rel_var_position'] = variant_df_gwas['var_position'] - (variant_df_gwas['pas_pos'] - 70 + 1)\n", + "variant_df_gwas.loc[variant_df_gwas['strand'] == '-', 'rel_var_position'] = ((variant_df_gwas['pas_pos'] - (205 - 70)) + 205) - variant_df_gwas['var_position']\n", + "\n", + "variant_df_gwas['alt_usage'] = 1. / (1. + 1. / ((np.clip(variant_df_gwas['native_usage'], 1e-7, 1. - 1e-7) / (1. - np.clip(variant_df_gwas['native_usage'], 1e-7, 1. - 1e-7))) * np.exp(variant_df_gwas['delta_logodds_0_205'])))\n", + "variant_df_gwas['delta_usage'] = variant_df_gwas['alt_usage'] - variant_df_gwas['native_usage']\n", + "\n", + "variant_df_gwas['alt_usage_77_127'] = 1. / (1. + 1. / ((np.clip(variant_df_gwas['native_usage'], 1e-7, 1. - 1e-7) / (1. - np.clip(variant_df_gwas['native_usage'], 1e-7, 1. - 1e-7))) * np.exp(variant_df_gwas['delta_logodds_77_127'])))\n", + "variant_df_gwas['delta_usage_77_127'] = variant_df_gwas['alt_usage_77_127'] - variant_df_gwas['native_usage']\n", + "\n", + "polyadb_df_unique = polyadb_df.drop_duplicates(subset=[\"gene_id\"], keep='first').copy().reset_index(drop=True)\n", + "polyadb_df_unique['padb_join_id'] = polyadb_df_unique['chrom'] + \"_\" + polyadb_df_unique['pas_pos'].astype(str) + \"_\" + polyadb_df_unique['strand']\n", + "variant_df_gwas['padb_join_id'] = variant_df_gwas['chrom'] + \"_\" + variant_df_gwas['pas_pos'].astype(str) + \"_\" + variant_df_gwas['strand']\n", + "\n", + "variant_df_gwas = variant_df_gwas.join(polyadb_df_unique[['padb_join_id', 'pas']].set_index(\"padb_join_id\"), on='padb_join_id', how='inner').copy().reset_index(drop=True)\n", + "\n", + "variant_df_gwas['target_rel_var_position'] = np.abs(90 - variant_df_gwas['rel_var_position'])\n", + "variant_df_gwas['target_delta_logodds_77_127_abs'] = -variant_df_gwas['delta_logodds_77_127_abs']\n", + "variant_df_gwas = variant_df_gwas.sort_values(by=['target_rel_var_position', 'target_delta_logodds_77_127_abs'], ascending=True).drop_duplicates(subset=['ukbb_join_id', 'trait'], keep='first').copy().reset_index(drop=True)\n", + "#variant_df_gwas['pas'] = -1. * variant_df_gwas['pas']\n", + "#variant_df_gwas = variant_df_gwas.sort_values(by=[\"pas\", 'delta_logodds_77_127_abs'], ascending=False).drop_duplicates(subset=['causaldb_join_id', 'meta_id'], keep='first').copy().reset_index(drop=True)\n", + "\n", + "#Drop duplicates for partially overlapping annotated PASs and add additional fields (non-causal)\n", + "\n", + "variant_df_gwas_noncausal['delta_logodds_77_127_abs'] = np.abs(variant_df_gwas_noncausal['delta_logodds_77_127'])\n", + "\n", + "variant_df_gwas_noncausal['rel_var_position'] = -1\n", + "variant_df_gwas_noncausal.loc[variant_df_gwas_noncausal['strand'] == '+', 'rel_var_position'] = variant_df_gwas_noncausal['var_position'] - (variant_df_gwas_noncausal['pas_pos'] - 70 + 1)\n", + "variant_df_gwas_noncausal.loc[variant_df_gwas_noncausal['strand'] == '-', 'rel_var_position'] = ((variant_df_gwas_noncausal['pas_pos'] - (205 - 70)) + 205) - variant_df_gwas_noncausal['var_position']\n", + "\n", + "variant_df_gwas_noncausal['alt_usage'] = 1. / (1. + 1. / ((np.clip(variant_df_gwas_noncausal['native_usage'], 1e-7, 1. - 1e-7) / (1. - np.clip(variant_df_gwas_noncausal['native_usage'], 1e-7, 1. - 1e-7))) * np.exp(variant_df_gwas_noncausal['delta_logodds_0_205'])))\n", + "variant_df_gwas_noncausal['delta_usage'] = variant_df_gwas_noncausal['alt_usage'] - variant_df_gwas_noncausal['native_usage']\n", + "\n", + "variant_df_gwas_noncausal['alt_usage_77_127'] = 1. / (1. + 1. / ((np.clip(variant_df_gwas_noncausal['native_usage'], 1e-7, 1. - 1e-7) / (1. - np.clip(variant_df_gwas_noncausal['native_usage'], 1e-7, 1. - 1e-7))) * np.exp(variant_df_gwas_noncausal['delta_logodds_77_127'])))\n", + "variant_df_gwas_noncausal['delta_usage_77_127'] = variant_df_gwas_noncausal['alt_usage_77_127'] - variant_df_gwas_noncausal['native_usage']\n", + "\n", + "polyadb_df_unique = polyadb_df.drop_duplicates(subset=[\"gene_id\"], keep='first').copy().reset_index(drop=True)\n", + "polyadb_df_unique['padb_join_id'] = polyadb_df_unique['chrom'] + \"_\" + polyadb_df_unique['pas_pos'].astype(str) + \"_\" + polyadb_df_unique['strand']\n", + "variant_df_gwas_noncausal['padb_join_id'] = variant_df_gwas_noncausal['chrom'] + \"_\" + variant_df_gwas_noncausal['pas_pos'].astype(str) + \"_\" + variant_df_gwas_noncausal['strand']\n", + "\n", + "variant_df_gwas_noncausal = variant_df_gwas_noncausal.join(polyadb_df_unique[['padb_join_id', 'pas']].set_index(\"padb_join_id\"), on='padb_join_id', how='inner').copy().reset_index(drop=True)\n", + "\n", + "variant_df_gwas_noncausal['target_rel_var_position'] = np.abs(90 - variant_df_gwas_noncausal['rel_var_position'])\n", + "variant_df_gwas_noncausal['target_delta_logodds_77_127_abs'] = -variant_df_gwas_noncausal['delta_logodds_77_127_abs']\n", + "variant_df_gwas_noncausal = variant_df_gwas_noncausal.sort_values(by=['target_rel_var_position', 'target_delta_logodds_77_127_abs'], ascending=True).drop_duplicates(subset=['ukbb_join_id', 'trait'], keep='first').copy().reset_index(drop=True)\n", + "#variant_df_gwas_noncausal['pas'] = -1. * variant_df_gwas_noncausal['pas']\n", + "#variant_df_gwas_noncausal = variant_df_gwas_noncausal.sort_values(by=[\"pas\", 'delta_logodds_77_127_abs'], ascending=False).drop_duplicates(subset=['causaldb_join_id', 'meta_id'], keep='first').copy().reset_index(drop=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(variant_df_gwas_lead) = 17324\n", + "len(variant_df_gwas_all_lead) = 90356\n" + ] + } + ], + "source": [ + "#Aggregate summary statistic for unique SNPs (by rsID)\n", + "\n", + "variant_df_gwas_all = pd.concat([variant_df_gwas, variant_df_gwas_noncausal]).drop_duplicates(subset=[\"ukbb_join_id\"], keep='first').copy().reset_index(drop=True)\n", + "\n", + "variant_df_gwas_lead = variant_df_gwas.copy().sort_values(by='pip', ascending=False).drop_duplicates(subset=[\"ukbb_join_id\"], keep='first').copy().reset_index(drop=True)\n", + "variant_df_gwas_all_lead = variant_df_gwas_all.copy().sort_values(by='pip', ascending=False).drop_duplicates(subset=[\"ukbb_join_id\"], keep='first').copy().reset_index(drop=True)\n", + "\n", + "print(\"len(variant_df_gwas_lead) = \" + str(len(variant_df_gwas_lead)))\n", + "print(\"len(variant_df_gwas_all_lead) = \" + str(len(variant_df_gwas_all_lead)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x_thresh_low = -0.3365\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Fisher's exact test ---\n", + "\n", + "x (low) = 0.001\n", + "x (high) = 0.05\n", + "\n", + "n (low) = 36567\n", + "n (high) = 323\n", + "\n", + "[[34005. 2562.]\n", + " [ 281. 42.]]\n", + "\n", + "(1.983839915990899, 9.913732451733462e-05)\n", + "\n", + "RanksumsResult(statistic=2.5272381034178766, pvalue=0.005748176600230651)\n", + "\n", + "x_thresh_low = -0.4055\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Fisher's exact test ---\n", + "\n", + "x (low) = 0.001\n", + "x (high) = 0.05\n", + "\n", + "n (low) = 36567\n", + "n (high) = 323\n", + "\n", + "[[34657. 1910.]\n", + " [ 286. 37.]]\n", + "\n", + "(2.3474334565957604, 8.912377113043503e-06)\n", + "\n", + "RanksumsResult(statistic=2.5272381034178766, pvalue=0.005748176600230651)\n", + "\n", + "x_thresh_low = -0.6931\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Fisher's exact test ---\n", + "\n", + "x (low) = 0.001\n", + "x (high) = 0.05\n", + "\n", + "n (low) = 36567\n", + "n (high) = 323\n", + "\n", + "[[3.5733e+04 8.3400e+02]\n", + " [2.9900e+02 2.4000e+01]]\n", + "\n", + "(3.4390895310507448, 7.308479447356434e-07)\n", + "\n", + "RanksumsResult(statistic=2.5272381034178766, pvalue=0.005748176600230651)\n", + "\n" + ] + } + ], + "source": [ + "#Calculate statistics in intervals of PP (log odds)\n", + "\n", + "from scipy.stats import ranksums, fisher_exact\n", + "\n", + "x = -np.abs(variant_df_gwas_all_lead.query(\"site_type == '3_most_exon' and native_usage > 0. and native_usage < 1.\")['delta_logodds_0_205'].values)\n", + "y = np.array(variant_df_gwas_all_lead.query(\"site_type == '3_most_exon' and native_usage > 0. and native_usage < 1.\")['pip'].values)\n", + "\n", + "x_thresh_lows = [-np.log(1.4), -np.log(1.5), -np.log(2.0)]\n", + "\n", + "fisher_test_low_y = 0.001\n", + "fisher_test_high_y = 0.05\n", + "\n", + "for x_thresh_low in x_thresh_lows :\n", + "\n", + " print(\"x_thresh_low = \" + str(round(x_thresh_low, 4)))\n", + " \n", + " x_0 = x[(y >= 0.)]\n", + " x_0_01 = x[(y >= 0.01)]\n", + " x_0_05 = x[(y >= 0.05)]\n", + " x_0_2 = x[(y >= 0.2)]\n", + " x_0_5 = x[(y >= 0.5)]\n", + " x_0_9 = x[(y >= 0.9)]\n", + " x_0_95 = x[(y >= 0.95)]\n", + "\n", + " f_0 = np.sum(x_0 < x_thresh_low) / x_0.shape[0]\n", + " f_0_01 = np.sum(x_0_01 < x_thresh_low) / x_0_01.shape[0]\n", + " f_0_05 = np.sum(x_0_05 < x_thresh_low) / x_0_05.shape[0]\n", + " f_0_2 = np.sum(x_0_2 < x_thresh_low) / x_0_2.shape[0]\n", + " f_0_5 = np.sum(x_0_5 < x_thresh_low) / x_0_5.shape[0]\n", + " f_0_9 = np.sum(x_0_9 < x_thresh_low) / x_0_9.shape[0]\n", + " f_0_95 = np.sum(x_0_95 < x_thresh_low) / x_0_95.shape[0]\n", + "\n", + " r_0_01 = f_0_01 / f_0\n", + " r_0_05 = f_0_05 / f_0\n", + " r_0_2 = f_0_2 / f_0\n", + " r_0_5 = f_0_5 / f_0\n", + " r_0_9 = f_0_9 / f_0\n", + " r_0_95 = f_0_95 / f_0\n", + "\n", + " fs = np.array([1., r_0_01, r_0_05, r_0_2, r_0_5, r_0_9, r_0_95])\n", + "\n", + " f = plt.figure(figsize=(6, 4))\n", + "\n", + " plt.bar([0], [fs[0]], color='darkgray', linewidth=2, edgecolor='black')\n", + " plt.bar((np.arange(fs.shape[0]-1)+1).tolist(), fs[1:].tolist(), color='deepskyblue', linewidth=2, edgecolor='black')\n", + "\n", + " plt.axhline(y=1.0, linewidth=2, linestyle='--', color='black')\n", + "\n", + " plt.xticks(\n", + " np.arange(fs.shape[0]), [\n", + " \">= 0%\",\n", + " \">= 1%\",\n", + " \">= 5%\",\n", + " \">= 20%\",\n", + " \">= 50%\",\n", + " \">= 90%\",\n", + " \">= 95%\",\n", + " ], fontsize=12, rotation=45\n", + " )\n", + "\n", + " plt.yticks(fontsize=12)\n", + "\n", + " plt.xlabel(\"Posterior Probability\", fontsize=12)\n", + " plt.ylabel(\"Frequency of Disruptive Variants\\n(Relative to PP >= 0)\", fontsize=12)\n", + "\n", + " plt.ylim(0.3)\n", + "\n", + " plt.tight_layout()\n", + "\n", + " plt.savefig(\"apa_ukbb_disruptive_frequency_logodds_\" + str(round(x_thresh_low, 4)).replace(\".\", \"_\").replace(\"-\", \"\") + \"_v2.eps\")\n", + " plt.savefig(\"apa_ukbb_disruptive_frequency_logodds_\" + str(round(x_thresh_low, 4)).replace(\".\", \"_\").replace(\"-\", \"\") + \"_v2.png\", transparent=True, dpi=300)\n", + "\n", + " plt.show()\n", + " \n", + " x_low = x[(y < fisher_test_low_y)]\n", + " x_high = x[(y >= fisher_test_high_y)]\n", + "\n", + " print(\"--- Fisher's exact test ---\")\n", + " print(\"\")\n", + " print(\"x (low) = \" + str(fisher_test_low_y))\n", + " print(\"x (high) = \" + str(fisher_test_high_y))\n", + " print(\"\")\n", + " print(\"n (low) = \" + str(x_low.shape[0]))\n", + " print(\"n (high) = \" + str(x_high.shape[0]))\n", + " \n", + " t1 = np.zeros((2, 2))\n", + " \n", + " t1[0, 0] = np.sum(x_low >= x_thresh_low)\n", + " t1[0, 1] = np.sum(x_low < x_thresh_low)\n", + " t1[1, 0] = np.sum(x_high >= x_thresh_low)\n", + " t1[1, 1] = np.sum(x_high < x_thresh_low)\n", + "\n", + " print(\"\")\n", + " print(t1)\n", + " print(\"\")\n", + "\n", + " print(fisher_exact(t1, alternative='greater'))\n", + " \n", + " print(\"\")\n", + " \n", + " print(ranksums(x_low, x_high, alternative='greater'))\n", + " \n", + " print(\"\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Environment (conda_modisco_p37)", + "language": "python", + "name": "conda_modisco_p37" + }, + "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.7.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/data/oligo_pool_2022/medium_library/analyze_library.ipynb b/data/oligo_pool_2022/medium_library/analyze_library.ipynb new file mode 100644 index 0000000..f6fd86f --- /dev/null +++ b/data/oligo_pool_2022/medium_library/analyze_library.ipynb @@ -0,0 +1,1727 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import scipy\n", + "import scipy.io as spio\n", + "import scipy.sparse as sp\n", + "\n", + "import regex as re\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#Load cached measurements\n", + "\n", + "hek_df = pd.read_csv(\"apa_100_variants_rev2_20220621_hek293_v3_umi_mut_0.csv\", sep='\\t')\n", + "sknsh_df = pd.read_csv(\"apa_100_variants_rev2_20220621_sknsh_v3_umi_mut_0.csv\", sep='\\t')\n", + "hmc3_df = pd.read_csv(\"apa_100_variants_rev2_20220621_hmc3_v3_umi_mut_0.csv\", sep='\\t')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- HEK293 ---\n", + "Wilcoxon statistic = -2.0682\n", + "Wilcoxon P-value = 0.038625305508977345\n", + "T-test statistic = -2.3702\n", + "T-test P-value = 0.02072423706876088\n", + "n1 / n2 = 34 / 36\n", + "--- SK-N-SH ---\n", + "Wilcoxon statistic = -2.1511\n", + "Wilcoxon P-value = 0.03146851890679132\n", + "T-test statistic = -2.187\n", + "T-test P-value = 0.032091653261210565\n", + "n1 / n2 = 36 / 36\n", + "--- HMC3 ---\n", + "Wilcoxon statistic = -2.016\n", + "Wilcoxon P-value = 0.04379985744145928\n", + "T-test statistic = -2.5153\n", + "T-test P-value = 0.014286754418166209\n", + "n1 / n2 = 32 / 38\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Analyze measured ASD variants (controls / cases)\n", + "\n", + "from scipy.stats import ranksums, ttest_ind\n", + "\n", + "import seaborn as sns\n", + "\n", + "save_figs = True\n", + "fig_name = \"asd_measured_lor\"\n", + "\n", + "#HEK293 measurements\n", + "hek_min_c = 5.\n", + "\n", + "hek_min_ref_prox_c = 5.\n", + "hek_min_var_prox_c = 1.\n", + "\n", + "hek_filtered_df = hek_df.query(\"ref_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hek_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hek_min_var_prox_c))\n", + "\n", + "hek_x1_true = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "hek_x2_true = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "\n", + "hek_x1_pred = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_0_205'].values)\n", + "hek_x2_pred = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_0_205'].values)\n", + "\n", + "wilcoxon_s_hek, wilcoxon_p_hek = ranksums(hek_x1_true, hek_x2_true)\n", + "ttest_s_hek, ttest_p_hek = ttest_ind(hek_x1_true, hek_x2_true, equal_var=False)\n", + "\n", + "print(\"--- HEK293 ---\")\n", + "print(\"Wilcoxon statistic = \" + str(round(wilcoxon_s_hek, 4)))\n", + "print(\"Wilcoxon P-value = \" + str(wilcoxon_p_hek))\n", + "print(\"T-test statistic = \" + str(round(ttest_s_hek, 4)))\n", + "print(\"T-test P-value = \" + str(ttest_p_hek))\n", + "print(\"n1 / n2 = \" + str(hek_x1_true.shape[0]) + \" / \" + str(hek_x2_true.shape[0]))\n", + "\n", + "#SK-N-SH measurements\n", + "sknsh_min_c = 5.\n", + "\n", + "sknsh_min_ref_prox_c = 5.\n", + "sknsh_min_var_prox_c = 1.\n", + "\n", + "sknsh_filtered_df = sknsh_df.query(\"ref_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(sknsh_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(sknsh_min_var_prox_c))\n", + "\n", + "sknsh_x1_true = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "sknsh_x2_true = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "\n", + "sknsh_x1_pred = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_0_205'].values)\n", + "sknsh_x2_pred = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_0_205'].values)\n", + "\n", + "wilcoxon_s_sknsh, wilcoxon_p_sknsh = ranksums(sknsh_x1_true, sknsh_x2_true)\n", + "ttest_s_sknsh, ttest_p_sknsh = ttest_ind(sknsh_x1_true, sknsh_x2_true, equal_var=False)\n", + "\n", + "print(\"--- SK-N-SH ---\")\n", + "print(\"Wilcoxon statistic = \" + str(round(wilcoxon_s_sknsh, 4)))\n", + "print(\"Wilcoxon P-value = \" + str(wilcoxon_p_sknsh))\n", + "print(\"T-test statistic = \" + str(round(ttest_s_sknsh, 4)))\n", + "print(\"T-test P-value = \" + str(ttest_p_sknsh))\n", + "print(\"n1 / n2 = \" + str(sknsh_x1_true.shape[0]) + \" / \" + str(sknsh_x2_true.shape[0]))\n", + "\n", + "#HMC3 measurements\n", + "hmc3_min_c = 5.\n", + "\n", + "hmc3_min_ref_prox_c = 5.\n", + "hmc3_min_var_prox_c = 1.\n", + "\n", + "hmc3_filtered_df = hmc3_df.query(\"ref_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hmc3_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hmc3_min_var_prox_c))\n", + "\n", + "hmc3_x1_true = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "hmc3_x2_true = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "\n", + "hmc3_x1_pred = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_0_205'].values)\n", + "hmc3_x2_pred = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_0_205'].values)\n", + "\n", + "wilcoxon_s_hmc3, wilcoxon_p_hmc3 = ranksums(hmc3_x1_true, hmc3_x2_true)\n", + "ttest_s_hmc3, ttest_p_hmc3 = ttest_ind(hmc3_x1_true, hmc3_x2_true, equal_var=False)\n", + "\n", + "print(\"--- HMC3 ---\")\n", + "print(\"Wilcoxon statistic = \" + str(round(wilcoxon_s_hmc3, 4)))\n", + "print(\"Wilcoxon P-value = \" + str(wilcoxon_p_hmc3))\n", + "print(\"T-test statistic = \" + str(round(ttest_s_hmc3, 4)))\n", + "print(\"T-test P-value = \" + str(ttest_p_hmc3))\n", + "print(\"n1 / n2 = \" + str(hmc3_x1_true.shape[0]) + \" / \" + str(hmc3_x2_true.shape[0]))\n", + "\n", + "#Visualize measurements (controls / cases)\n", + "\n", + "f = plt.figure(figsize=(6, 4))\n", + "\n", + "sns.swarmplot(data=[\n", + " hek_x1_true,\n", + " hek_x2_true,\n", + " sknsh_x1_true,\n", + " sknsh_x2_true,\n", + " hmc3_x1_true,\n", + " hmc3_x2_true,\n", + "], palette=['green', 'red', 'green', 'red', 'green', 'red'], size=4)\n", + "\n", + "plt.xticks([0, 1, 2, 3, 4, 5], [\"Control\\n(HEK293)\", \"Case\\n(HEK293)\", \"Control\\n(SK-N-SH)\", \"Case\\n(SK-N-SH)\", \"Control\\n(HMC3)\", \"Case\\n(HMC3)\"], rotation=45, fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- HEK293 ---\n", + "Wilcoxon statistic = -2.0682\n", + "Wilcoxon P-value = 0.038625305508977345\n", + "T-test statistic = -2.3702\n", + "T-test P-value = 0.02072423706876088\n", + "n1 / n2 = 34 / 36\n", + "--- SK-N-SH ---\n", + "Wilcoxon statistic = -2.2092\n", + "Wilcoxon P-value = 0.027163012509820155\n", + "T-test statistic = -2.2266\n", + "T-test P-value = 0.02931270488852479\n", + "n1 / n2 = 34 / 36\n", + "--- HMC3 ---\n", + "Wilcoxon statistic = -2.1379\n", + "Wilcoxon P-value = 0.03252418126532747\n", + "T-test statistic = -2.6009\n", + "T-test P-value = 0.011530170287279982\n", + "n1 / n2 = 32 / 36\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Analyze measured ASD variants (controls / cases), more stringent filtering (except low-count HEK293 data)\n", + "\n", + "from scipy.stats import ranksums, ttest_ind\n", + "\n", + "import seaborn as sns\n", + "\n", + "save_figs = True\n", + "fig_name = \"asd_measured_lor_stringent_filtering\"\n", + "\n", + "#HEK293 measurements\n", + "hek_min_c = 5.\n", + "\n", + "hek_min_ref_prox_c = 5.\n", + "hek_min_var_prox_c = 1.\n", + "\n", + "hek_filtered_df = hek_df.query(\"ref_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hek_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hek_min_var_prox_c))\n", + "\n", + "hek_x1_true = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "hek_x2_true = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "\n", + "hek_x1_pred = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_0_205'].values)\n", + "hek_x2_pred = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_0_205'].values)\n", + "\n", + "wilcoxon_s_hek, wilcoxon_p_hek = ranksums(hek_x1_true, hek_x2_true)\n", + "ttest_s_hek, ttest_p_hek = ttest_ind(hek_x1_true, hek_x2_true, equal_var=False)\n", + "\n", + "print(\"--- HEK293 ---\")\n", + "print(\"Wilcoxon statistic = \" + str(round(wilcoxon_s_hek, 4)))\n", + "print(\"Wilcoxon P-value = \" + str(wilcoxon_p_hek))\n", + "print(\"T-test statistic = \" + str(round(ttest_s_hek, 4)))\n", + "print(\"T-test P-value = \" + str(ttest_p_hek))\n", + "print(\"n1 / n2 = \" + str(hek_x1_true.shape[0]) + \" / \" + str(hek_x2_true.shape[0]))\n", + "\n", + "#SK-N-SH measurements\n", + "sknsh_min_c = 10.\n", + "\n", + "sknsh_min_ref_prox_c = 5.\n", + "sknsh_min_var_prox_c = 5.\n", + "\n", + "sknsh_filtered_df = sknsh_df.query(\"ref_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(sknsh_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(sknsh_min_var_prox_c))\n", + "\n", + "sknsh_x1_true = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "sknsh_x2_true = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "\n", + "sknsh_x1_pred = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_0_205'].values)\n", + "sknsh_x2_pred = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_0_205'].values)\n", + "\n", + "wilcoxon_s_sknsh, wilcoxon_p_sknsh = ranksums(sknsh_x1_true, sknsh_x2_true)\n", + "ttest_s_sknsh, ttest_p_sknsh = ttest_ind(sknsh_x1_true, sknsh_x2_true, equal_var=False)\n", + "\n", + "print(\"--- SK-N-SH ---\")\n", + "print(\"Wilcoxon statistic = \" + str(round(wilcoxon_s_sknsh, 4)))\n", + "print(\"Wilcoxon P-value = \" + str(wilcoxon_p_sknsh))\n", + "print(\"T-test statistic = \" + str(round(ttest_s_sknsh, 4)))\n", + "print(\"T-test P-value = \" + str(ttest_p_sknsh))\n", + "print(\"n1 / n2 = \" + str(sknsh_x1_true.shape[0]) + \" / \" + str(sknsh_x2_true.shape[0]))\n", + "\n", + "#HMC3 measurements\n", + "hmc3_min_c = 10.\n", + "\n", + "hmc3_min_ref_prox_c = 5.\n", + "hmc3_min_var_prox_c = 5.\n", + "\n", + "hmc3_filtered_df = hmc3_df.query(\"ref_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hmc3_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hmc3_min_var_prox_c))\n", + "\n", + "hmc3_x1_true = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "hmc3_x2_true = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "\n", + "hmc3_x1_pred = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_0_205'].values)\n", + "hmc3_x2_pred = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_0_205'].values)\n", + "\n", + "wilcoxon_s_hmc3, wilcoxon_p_hmc3 = ranksums(hmc3_x1_true, hmc3_x2_true)\n", + "ttest_s_hmc3, ttest_p_hmc3 = ttest_ind(hmc3_x1_true, hmc3_x2_true, equal_var=False)\n", + "\n", + "print(\"--- HMC3 ---\")\n", + "print(\"Wilcoxon statistic = \" + str(round(wilcoxon_s_hmc3, 4)))\n", + "print(\"Wilcoxon P-value = \" + str(wilcoxon_p_hmc3))\n", + "print(\"T-test statistic = \" + str(round(ttest_s_hmc3, 4)))\n", + "print(\"T-test P-value = \" + str(ttest_p_hmc3))\n", + "print(\"n1 / n2 = \" + str(hmc3_x1_true.shape[0]) + \" / \" + str(hmc3_x2_true.shape[0]))\n", + "\n", + "#Visualize measurements (controls / cases)\n", + "\n", + "f = plt.figure(figsize=(6, 4))\n", + "\n", + "sns.swarmplot(data=[\n", + " hek_x1_true,\n", + " hek_x2_true,\n", + " sknsh_x1_true,\n", + " sknsh_x2_true,\n", + " hmc3_x1_true,\n", + " hmc3_x2_true,\n", + "], palette=['green', 'red', 'green', 'red', 'green', 'red'], size=4)\n", + "\n", + "plt.xticks([0, 1, 2, 3, 4, 5], [\"Control\\n(HEK293)\", \"Case\\n(HEK293)\", \"Control\\n(SK-N-SH)\", \"Case\\n(SK-N-SH)\", \"Control\\n(HMC3)\", \"Case\\n(HMC3)\"], rotation=45, fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- HEK293 ---\n", + "Wilcoxon statistic = -2.0682\n", + "Wilcoxon P-value = 0.038625305508977345\n", + "T-test statistic = -2.3702\n", + "T-test P-value = 0.02072423706876088\n", + "n1 / n2 = 34 / 36\n", + "--- SK-N-SH ---\n", + "Wilcoxon statistic = -2.1511\n", + "Wilcoxon P-value = 0.03146851890679132\n", + "T-test statistic = -2.187\n", + "T-test P-value = 0.032091653261210565\n", + "n1 / n2 = 36 / 36\n", + "--- HMC3 ---\n", + "Wilcoxon statistic = -2.016\n", + "Wilcoxon P-value = 0.04379985744145928\n", + "T-test statistic = -2.5153\n", + "T-test P-value = 0.014286754418166209\n", + "n1 / n2 = 32 / 38\n", + "--- Average across cell lines ---\n", + "Wilcoxon statistic = -2.6675\n", + "Wilcoxon P-value = 0.007642882836288566\n", + "T-test statistic = -2.7049\n", + "T-test P-value = 0.00862842500296053\n", + "n1 / n2 = 34 / 36\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Analyze measured ASD variants (controls / cases), include average measurements across cell lines\n", + "\n", + "from scipy.stats import ranksums, ttest_ind\n", + "\n", + "import seaborn as sns\n", + "\n", + "save_figs = True\n", + "fig_name = \"asd_measured_lor_w_avg_cell_line\"\n", + "\n", + "#HEK293 measurements\n", + "hek_min_c = 5.\n", + "\n", + "hek_min_ref_prox_c = 5.\n", + "hek_min_var_prox_c = 1.\n", + "\n", + "hek_filtered_df = hek_df.query(\"ref_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hek_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hek_min_var_prox_c))\n", + "\n", + "hek_x1_true = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "hek_x2_true = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "\n", + "hek_x1_pred = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_0_205'].values)\n", + "hek_x2_pred = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_0_205'].values)\n", + "\n", + "wilcoxon_s_hek, wilcoxon_p_hek = ranksums(hek_x1_true, hek_x2_true)\n", + "ttest_s_hek, ttest_p_hek = ttest_ind(hek_x1_true, hek_x2_true, equal_var=False)\n", + "\n", + "print(\"--- HEK293 ---\")\n", + "print(\"Wilcoxon statistic = \" + str(round(wilcoxon_s_hek, 4)))\n", + "print(\"Wilcoxon P-value = \" + str(wilcoxon_p_hek))\n", + "print(\"T-test statistic = \" + str(round(ttest_s_hek, 4)))\n", + "print(\"T-test P-value = \" + str(ttest_p_hek))\n", + "print(\"n1 / n2 = \" + str(hek_x1_true.shape[0]) + \" / \" + str(hek_x2_true.shape[0]))\n", + "\n", + "#SK-N-SH measurements\n", + "sknsh_min_c = 5.\n", + "\n", + "sknsh_min_ref_prox_c = 5.\n", + "sknsh_min_var_prox_c = 1.\n", + "\n", + "sknsh_filtered_df = sknsh_df.query(\"ref_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(sknsh_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(sknsh_min_var_prox_c))\n", + "\n", + "sknsh_x1_true = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "sknsh_x2_true = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "\n", + "sknsh_x1_pred = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_0_205'].values)\n", + "sknsh_x2_pred = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_0_205'].values)\n", + "\n", + "wilcoxon_s_sknsh, wilcoxon_p_sknsh = ranksums(sknsh_x1_true, sknsh_x2_true)\n", + "ttest_s_sknsh, ttest_p_sknsh = ttest_ind(sknsh_x1_true, sknsh_x2_true, equal_var=False)\n", + "\n", + "print(\"--- SK-N-SH ---\")\n", + "print(\"Wilcoxon statistic = \" + str(round(wilcoxon_s_sknsh, 4)))\n", + "print(\"Wilcoxon P-value = \" + str(wilcoxon_p_sknsh))\n", + "print(\"T-test statistic = \" + str(round(ttest_s_sknsh, 4)))\n", + "print(\"T-test P-value = \" + str(ttest_p_sknsh))\n", + "print(\"n1 / n2 = \" + str(sknsh_x1_true.shape[0]) + \" / \" + str(sknsh_x2_true.shape[0]))\n", + "\n", + "#HMC3 measurements\n", + "hmc3_min_c = 5.\n", + "\n", + "hmc3_min_ref_prox_c = 5.\n", + "hmc3_min_var_prox_c = 1.\n", + "\n", + "hmc3_filtered_df = hmc3_df.query(\"ref_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hmc3_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hmc3_min_var_prox_c))\n", + "\n", + "hmc3_x1_true = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "hmc3_x2_true = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "\n", + "hmc3_x1_pred = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_0_205'].values)\n", + "hmc3_x2_pred = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_0_205'].values)\n", + "\n", + "wilcoxon_s_hmc3, wilcoxon_p_hmc3 = ranksums(hmc3_x1_true, hmc3_x2_true)\n", + "ttest_s_hmc3, ttest_p_hmc3 = ttest_ind(hmc3_x1_true, hmc3_x2_true, equal_var=False)\n", + "\n", + "print(\"--- HMC3 ---\")\n", + "print(\"Wilcoxon statistic = \" + str(round(wilcoxon_s_hmc3, 4)))\n", + "print(\"Wilcoxon P-value = \" + str(wilcoxon_p_hmc3))\n", + "print(\"T-test statistic = \" + str(round(ttest_s_hmc3, 4)))\n", + "print(\"T-test P-value = \" + str(ttest_p_hmc3))\n", + "print(\"n1 / n2 = \" + str(hmc3_x1_true.shape[0]) + \" / \" + str(hmc3_x2_true.shape[0]))\n", + "\n", + "#Join individual filtered dataframes (outer)\n", + "filtered_df = hek_filtered_df.join(sknsh_filtered_df, how='outer', rsuffix='_sknsh')\n", + "filtered_df = filtered_df.join(hmc3_filtered_df, how='outer', rsuffix='_hmc3').copy()\n", + "\n", + "#Compute average measurements\n", + "def _calc_avg_delta_logodds_true_0_205(row) :\n", + " \n", + " sum_delta_logodds_true_0_205_repl_pooled = 0.\n", + " n_delta_logodds_true_0_205_repl_pooled = 0.\n", + "\n", + " if not np.isnan(row['delta_logodds_true_0_205_repl_pooled']) :\n", + " sum_delta_logodds_true_0_205_repl_pooled += row['delta_logodds_true_0_205_repl_pooled']\n", + " n_delta_logodds_true_0_205_repl_pooled += 1.\n", + " \n", + " if not np.isnan(row['delta_logodds_true_0_205_repl_pooled_sknsh']) :\n", + " sum_delta_logodds_true_0_205_repl_pooled += row['delta_logodds_true_0_205_repl_pooled_sknsh']\n", + " n_delta_logodds_true_0_205_repl_pooled += 1.\n", + " \n", + " if not np.isnan(row['delta_logodds_true_0_205_repl_pooled_hmc3']) :\n", + " sum_delta_logodds_true_0_205_repl_pooled += row['delta_logodds_true_0_205_repl_pooled_hmc3']\n", + " n_delta_logodds_true_0_205_repl_pooled += 1.\n", + "\n", + " return sum_delta_logodds_true_0_205_repl_pooled / n_delta_logodds_true_0_205_repl_pooled\n", + "\n", + "filtered_df['mean_delta_logodds_true_0_205_repl_pooled'] = filtered_df.apply(_calc_avg_delta_logodds_true_0_205, axis=1)\n", + "\n", + "#Get mean measurements\n", + "x1_true = np.array(filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['mean_delta_logodds_true_0_205_repl_pooled'].values)\n", + "x2_true = np.array(filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['mean_delta_logodds_true_0_205_repl_pooled'].values)\n", + "\n", + "wilcoxon_s, wilcoxon_p = ranksums(x1_true, x2_true)\n", + "ttest_s, ttest_p = ttest_ind(x1_true, x2_true, equal_var=False)\n", + "\n", + "print(\"--- Average across cell lines ---\")\n", + "print(\"Wilcoxon statistic = \" + str(round(wilcoxon_s, 4)))\n", + "print(\"Wilcoxon P-value = \" + str(wilcoxon_p))\n", + "print(\"T-test statistic = \" + str(round(ttest_s, 4)))\n", + "print(\"T-test P-value = \" + str(ttest_p))\n", + "print(\"n1 / n2 = \" + str(x1_true.shape[0]) + \" / \" + str(x2_true.shape[0]))\n", + "\n", + "#Visualize measurements (controls / cases)\n", + "\n", + "f = plt.figure(figsize=(7, 4))\n", + "\n", + "sns.swarmplot(data=[\n", + " hek_x1_true,\n", + " hek_x2_true,\n", + " sknsh_x1_true,\n", + " sknsh_x2_true,\n", + " hmc3_x1_true,\n", + " hmc3_x2_true,\n", + " x1_true,\n", + " x2_true,\n", + "], palette=['green', 'red', 'green', 'red', 'green', 'red', 'darkgreen', 'darkred'], size=4)\n", + "\n", + "plt.xticks([0, 1, 2, 3, 4, 5, 6, 7], [\"Control\\n(HEK293)\", \"Case\\n(HEK293)\", \"Control\\n(SK-N-SH)\", \"Case\\n(SK-N-SH)\", \"Control\\n(HMC3)\", \"Case\\n(HMC3)\", \"Control\\n(Mean)\", \"Case\\n(Mean)\"], rotation=45, fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Compare predictions vs. measurements, ASD variants (controls / cases), 0 to 205\n", + "\n", + "from scipy.stats import spearmanr\n", + "\n", + "save_figs = True\n", + "fig_name = \"asd_predicted_vs_measured_lor_0_205\"\n", + "\n", + "#HEK293 measurements\n", + "hek_min_c = 50.\n", + "\n", + "hek_min_ref_prox_c = 5.\n", + "hek_min_var_prox_c = 1.\n", + "\n", + "hek_filtered_df = hek_df.query(\"ref_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hek_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hek_min_var_prox_c))\n", + "\n", + "hek_x1_true = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "hek_x2_true = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "\n", + "hek_x1_pred = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_0_205'].values)\n", + "hek_x2_pred = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_0_205'].values)\n", + "\n", + "#SK-N-SH measurements\n", + "sknsh_min_c = 50.\n", + "\n", + "sknsh_min_ref_prox_c = 5.\n", + "sknsh_min_var_prox_c = 1.\n", + "\n", + "sknsh_filtered_df = sknsh_df.query(\"ref_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(sknsh_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(sknsh_min_var_prox_c))\n", + "\n", + "sknsh_x1_true = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "sknsh_x2_true = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "\n", + "sknsh_x1_pred = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_0_205'].values)\n", + "sknsh_x2_pred = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_0_205'].values)\n", + "\n", + "#HMC3 measurements\n", + "hmc3_min_c = 50.\n", + "\n", + "hmc3_min_ref_prox_c = 5.\n", + "hmc3_min_var_prox_c = 1.\n", + "\n", + "hmc3_filtered_df = hmc3_df.query(\"ref_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hmc3_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hmc3_min_var_prox_c))\n", + "\n", + "hmc3_x1_true = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "hmc3_x2_true = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_true_0_205_repl_pooled'].values)\n", + "\n", + "hmc3_x1_pred = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_0_205'].values)\n", + "hmc3_x2_pred = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_0_205'].values)\n", + "\n", + "r_val_hek, _ = spearmanr(np.concatenate([hek_x1_pred, hek_x2_pred], axis=0), np.concatenate([hek_x1_true, hek_x2_true], axis=0))\n", + "r_val_sknsh, _ = spearmanr(np.concatenate([sknsh_x1_pred, sknsh_x2_pred], axis=0), np.concatenate([sknsh_x1_true, sknsh_x2_true], axis=0))\n", + "r_val_hmc3, _ = spearmanr(np.concatenate([hmc3_x1_pred, hmc3_x2_pred], axis=0), np.concatenate([hmc3_x1_true, hmc3_x2_true], axis=0))\n", + "\n", + "f, ax = plt.subplots(1, 3, figsize=(12, 4))\n", + "\n", + "#Plot HEK293 measurements\n", + "plt.sca(ax[0])\n", + "\n", + "plt.scatter(hek_x1_pred, hek_x1_true, color='lightgreen', s=45, edgecolor='black', linewidth=1)\n", + "plt.scatter(hek_x2_pred, hek_x2_true, color='lightcoral', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"HEK293, r = \" + str(round(r_val_hek, 3)) + \", n = \" + str(np.concatenate([hek_x1_pred, hek_x2_pred], axis=0).shape[0]), fontsize=12)\n", + "\n", + "#Plot SK-N-SH measurements\n", + "plt.sca(ax[1])\n", + "\n", + "plt.scatter(sknsh_x1_pred, sknsh_x1_true, color='lightgreen', s=45, edgecolor='black', linewidth=1)\n", + "plt.scatter(sknsh_x2_pred, sknsh_x2_true, color='lightcoral', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"SK-N-SH, r = \" + str(round(r_val_sknsh, 3)) + \", n = \" + str(np.concatenate([sknsh_x1_pred, sknsh_x2_pred], axis=0).shape[0]), fontsize=12)\n", + "\n", + "#Plot HMC3 measurements\n", + "plt.sca(ax[2])\n", + "\n", + "plt.scatter(hmc3_x1_pred, hmc3_x1_true, color='lightgreen', s=45, edgecolor='black', linewidth=1)\n", + "plt.scatter(hmc3_x2_pred, hmc3_x2_true, color='lightcoral', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"HMC3, r = \" + str(round(r_val_hmc3, 3)) + \", n = \" + str(np.concatenate([hmc3_x1_pred, hmc3_x2_pred], axis=0).shape[0]), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Compare predictions vs. measurements, ASD variants (controls / cases), 77 to 127\n", + "\n", + "from scipy.stats import spearmanr\n", + "\n", + "save_figs = True\n", + "fig_name = \"asd_predicted_vs_measured_lor_77_127\"\n", + "\n", + "#HEK293 measurements\n", + "hek_min_c = 50.\n", + "\n", + "hek_min_ref_prox_c = 5.\n", + "hek_min_var_prox_c = 1.\n", + "\n", + "hek_filtered_df = hek_df.query(\"ref_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hek_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hek_min_var_prox_c))\n", + "\n", + "hek_x1_true = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_true_77_127_repl_pooled'].values)\n", + "hek_x2_true = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_true_77_127_repl_pooled'].values)\n", + "\n", + "hek_x1_pred = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_77_127'].values)\n", + "hek_x2_pred = np.array(hek_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_77_127'].values)\n", + "\n", + "#SK-N-SH measurements\n", + "sknsh_min_c = 50.\n", + "\n", + "sknsh_min_ref_prox_c = 5.\n", + "sknsh_min_var_prox_c = 1.\n", + "\n", + "sknsh_filtered_df = sknsh_df.query(\"ref_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(sknsh_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(sknsh_min_var_prox_c))\n", + "\n", + "sknsh_x1_true = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_true_77_127_repl_pooled'].values)\n", + "sknsh_x2_true = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_true_77_127_repl_pooled'].values)\n", + "\n", + "sknsh_x1_pred = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_77_127'].values)\n", + "sknsh_x2_pred = np.array(sknsh_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_77_127'].values)\n", + "\n", + "#HMC3 measurements\n", + "hmc3_min_c = 50.\n", + "\n", + "hmc3_min_ref_prox_c = 5.\n", + "hmc3_min_var_prox_c = 1.\n", + "\n", + "hmc3_filtered_df = hmc3_df.query(\"ref_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hmc3_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hmc3_min_var_prox_c))\n", + "\n", + "hmc3_x1_true = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_true_77_127_repl_pooled'].values)\n", + "hmc3_x2_true = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_true_77_127_repl_pooled'].values)\n", + "\n", + "hmc3_x1_pred = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_control'\")['delta_logodds_77_127'].values)\n", + "hmc3_x2_pred = np.array(hmc3_filtered_df.query(\"data_source == 'ASD_1' and experiment == 'variant_case'\")['delta_logodds_77_127'].values)\n", + "\n", + "r_val_hek, _ = spearmanr(np.concatenate([hek_x1_pred, hek_x2_pred], axis=0), np.concatenate([hek_x1_true, hek_x2_true], axis=0))\n", + "r_val_sknsh, _ = spearmanr(np.concatenate([sknsh_x1_pred, sknsh_x2_pred], axis=0), np.concatenate([sknsh_x1_true, sknsh_x2_true], axis=0))\n", + "r_val_hmc3, _ = spearmanr(np.concatenate([hmc3_x1_pred, hmc3_x2_pred], axis=0), np.concatenate([hmc3_x1_true, hmc3_x2_true], axis=0))\n", + "\n", + "f, ax = plt.subplots(1, 3, figsize=(12, 4))\n", + "\n", + "#Plot HEK293 measurements\n", + "plt.sca(ax[0])\n", + "\n", + "plt.scatter(hek_x1_pred, hek_x1_true, color='lightgreen', s=45, edgecolor='black', linewidth=1)\n", + "plt.scatter(hek_x2_pred, hek_x2_true, color='lightcoral', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"HEK293, r = \" + str(round(r_val_hek, 3)) + \", n = \" + str(np.concatenate([hek_x1_pred, hek_x2_pred], axis=0).shape[0]), fontsize=12)\n", + "\n", + "#Plot SK-N-SH measurements\n", + "plt.sca(ax[1])\n", + "\n", + "plt.scatter(sknsh_x1_pred, sknsh_x1_true, color='lightgreen', s=45, edgecolor='black', linewidth=1)\n", + "plt.scatter(sknsh_x2_pred, sknsh_x2_true, color='lightcoral', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"SK-N-SH, r = \" + str(round(r_val_sknsh, 3)) + \", n = \" + str(np.concatenate([sknsh_x1_pred, sknsh_x2_pred], axis=0).shape[0]), fontsize=12)\n", + "\n", + "#Plot HMC3 measurements\n", + "plt.sca(ax[2])\n", + "\n", + "plt.scatter(hmc3_x1_pred, hmc3_x1_true, color='lightgreen', s=45, edgecolor='black', linewidth=1)\n", + "plt.scatter(hmc3_x2_pred, hmc3_x2_true, color='lightcoral', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"HMC3, r = \" + str(round(r_val_hmc3, 3)) + \", n = \" + str(np.concatenate([hmc3_x1_pred, hmc3_x2_pred], axis=0).shape[0]), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAEYCAYAAABBWFftAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xt4lOWZ+PHvnQAqJECAkBOGGIIHlCpJkN1WjlVYbCWuVdgKW621iK26rW237ba2tuu2u27VX7XFVKulVbBErA1taUElHGpXhISTeCjhEJPMJEhCkIRTkrl/f7wz42QyOZFJZpLcn+uaSzLvO+88E/Pe8xzvR1QVY4wxxhhjjDHdFxPpAhhjjDHGGGNMf2ENLGOMMcYYY4wJE2tgGWOMMcYYY0yYWAPLGGOMMcYYY8LEGljGGGOMMcYYEybWwDLGGGOMMcaYMLEGljHGGGOMMcaEiTWwwkxEDovItUHP3S4ifw0655SI1Ac8ftbGucNF5HUReUlEBovIN0TkLRE5ISKHROQbQe/1cRF503t8j4hcE3BstojsFZE6EakRkZdFJK3nfhudJyK3ikiZiDSIyO9FZFQ7584RkRIR+VBEDorI0oBjKSKyVkRcIqIiktEb5e8KEUkTkUIRqRWRChFZFnT8KRF5T0Q8InJ7hIppopyIXCMifxOR496/pddFZKr3WLtxJMS1rvXeLz8Nev4NEVnSThn+WUR2e+/FoyLyqoike489JCIrgs4fFC33pYhke+PISRHZLiIfa+fcTBH5i4gcE5EqEfmpiMQGHI8VkR+JiNsbe0tEJN577JdBsf6MiBzrjc/YWSJyuYhs8v5/3C8iCwKOTRaRYu9nrxWRDSJyaSTLa6JfF+pCZ0VkTNB5u4LjhIhcLSLrvPWXWm895/PeY5NEZIf3b/SYNw5N6tlP2Dki8kkRedcbZ4pEZHw75wbXDTcEHDtPRB7z1m2OicjywFgeFGPqRaRZRJ7o6c/XFSJyp4iUesv3FxFJDTjWbt22L7IGVuTcoKpxAY97gk8QkQTgVaAMWKSqjYAAnwMSgH8C7hGRf/GePwpYC/wvMBJ4GPiD9zoAbwPzVHUkkArsB548l8KLyKBzeV0b17oc+AXwr0AScBJY3sa5g4GXveePABYBj4rIld5TPMBfgM+Eq3w94HngEM5n/RTwIxGZHXB8N/AloCQCZTN9gIgMB/4IPAGMAtKAHwBnQpwbKo6EcgK4Q0Qu7GQZLgF+Bfwbzr14EZCPcw+GXZhjznlAIU75E4AXgN+Hanx65QOVQDIwBbgWuCvg+H8BU4GrgeHA7cBZAFW9MzDWAy96H1FBRIbgfG+8jPO7+BLwgohM8J5SgRNPRwGJwJ+BVREoqumfDgGf9f0gIpOBCwJPEJF/BDYCm4EsYDRwNzDfe4oLuBnnb3QMzt/zb8+lMGGOM2OA3wEPeMu2A1jdwcsC64ZzA57/FpALXAFcDGQD3/UdDIoxScApoivOzAR+BOTh/C4O4cRd/ym0Ubftq6yBFaW8N+ZGYB+wRFWbAFT1YVUtUdUmVX0Pp5LwCe/LPg5Uq+qLqtqsqs8DHwA3eV9braqugLdpxglWnSlPhrdH6Qsi8r63bOGyGPiDqm5R1XqcYHSTrwc4yCicCsxz6tgOvANMAv9nXA5s72ohAj7jbSLyvjg98t85508V+j3igFnAf6lqo6ruBtYAd/jOUdWfq+prwOlwvrfpVy4GUNUXvPf6KVXdoKp7Ak9qK460oRan8f+9TpZhClCqqpu89+IJVV2jqhVd/zihiTPC+w0R2YvT8RIunwRUVZ9Q1TPAY8B5wMw2zr8IWK2qZ1TVDWwALveWcTRwL3CnqpZ7fxd7vNcN/jzxwD8Dv+5MIcUZWTwsIv8uIh94e68/19UP24FJOBXWx71/S68A24AlAKp6TFUPq6riVII8dPJ7w5hOeA6nYu1zG/CboHP+F/i1qv6Pqh713mPFqroQQFXrgv5GO123AfB+739ZRPbjdDyHy03APm+d7DTwIHDlOY4A34Bzj9aq6gfA4wTUG4LcDBwBtnbmwiKyQkR+LiJ/8o4gbQvoYAmXG4AXVXWfqp4F/hOY4XufDuq2fZI1sKLTKJyemm3AHaoaskdYRASYjlN5AiewSPBpOD0evteki0gdTu/G13FGubpiJnAZMC9EedK9w/dtPW5t45qX44zaAKCqB3B6fy8OPlFVq3F6PT4vzrScfwTGA38NPrcbrgEuwamEfU9ELgt1koh8q73P28a1Jei/vn9fEeJcY9ryd6BZRH4tIvMDRqkDdSqOBHkI+BcR6UzlpBiYLCKPiDP9eFinS981/4LTUz0i1EER2dfOffh4G9cMjjkK7PU+H8r/Az4rIheIyDicHta/eI9diRNPF4tItTjTe+9q4zq3AC5Vfb2dzxtsHE6PfiqwDHjSO4LZioj8op3fRVsj4p353oj1xrQzwKPAj7tQfmPa8wYwXEQuE2fa7SKcjh4ARGQo8I84HZHt8v6NnsYZ2f9RF8txIzANb2dtqGu38/hWG9cMjjMNwAHajjMAK72dKRsCZuZA6/tUgHEiEiou3gb8xhvXOuuzOLMgEoBSnFH5kM7xdxGq/BCi7hOibtsnhW0o1LTwexEJ7CkeQuvpXsHnfENVn/b++0LgfJxKUXs3yIM4jeRfeX/+G5AqIp/FCUa3AhOAob4XqOr7wEhxphN+EXi3Kx8MeNAbJFrxXbuL1wOIA44HPXccCDWCBU4D65eAb73I3apafg7v25YfqOopYLeI7MapQL0TfJKq/jfw3125sKqeEJHXgQfEmWM8CWf6zQfdL7YZKFT1Q3HWV34TeBpIFpF1wBe9nRDQ+TgSeN1KEXka54t2cQfn7hdnautXcaaixInIKuAeVfWNNt0qIjd29fMF+Wl7o2Kq2l5lpS1djTmbgDtxplHGAs/gTNEEpwE0GqejJwOnc+Y1Efm7qhYFXec2Ojl6FeA08JCqNgNrReQMTufTjuATVfUuWk5d7Ix9QB3wVXHWbHwSp5PJv/7D+94jvSPwt+NUwIzpSGfqQvDRKNZmnDpJZcCxBJx6jrujN1PVkd6OnttwpkR3xY9Vtba9a3fxeuDEmeDv9vbizGKc34/gTL1eLyKXqmodztTcfxORIpwYdJ/3NUMJiGXirIGdCXyhi2X9naq+6b3GSpyOlJDO8XexDlgtIvk4o4TfA5SA+mmAB2lZt+2TbASrZ9yoqiN9D5w57e2eE9C4AqfH4+vAn0VkSqg3EJF7cALSp3xTUVS1Bmd+6/1ANU4v66s4c+hb8AaSXwOF0rU5x+FsyPjU40z7CzQcpzLTgndofTXOZx+C0xP07yLyqTCWpyrg3ydxgmQ4LcaZclSOswZuJSH+HxnTHlV9R1VvV9VxOL2AqTgjLT4h44g4CRt8C6FDjbT+GPi0iLToWfSOzPhe94/eMvxNVW9R1THADGAO8O2Al60KioUtFrN3UqRjziBgPU7cGYqzDimZj3p4T3n/+0PvVM1dQAFwfdB1LsJpuDzXxbIe9TZwfMIak7zTdfJwevCrcCp2awj9vVGPsx5tlThTI41pT2fqQuDcE7fiNN6Dpwcew5mWmtKZN/R2AOcDvxGRsV0oa0TjDICqvu6NISdV9cc4HR/TvYf/C9gJ7MLpTP890IgzFTDQ54C/quqhLpa1R+s93mUP3wdewmn8Hsb5PbSIM6Hqtn2VNbCilKr+FGd05JUQFZ07cBY8fjK4Z1dVN6vqVFUdhZM04hLgzTbeZhAwltYBoN2itXXAO0UwOJNN4KOtHvF9OKNEvutk4qyH+HuIc68A3lPV9arq8c7V/RMfLXbtNSLyH+193rZep6plqvppVU1U1Wk4vd9t/T8ypkOq+i6wgqDpFqHiiKoe1I8WRLfqifTO738C+GHQ85cEvO7/QrzuTZwv/XBPd2139C2o4Rf8+FkbLwuOOQJMJvSUlDE4SUSeUNWzqnoU53fta0D51r11NEr4OWCzqna1Z73TpHXGwsDH7rZep6q7VHWGqo5W1fk4Mx/aikkxOJWv1DaOG9Ml3nviEM499bugYyeB/6NriaticDpDupIluaM4017d5j/aeFlwnBmGc291duqbb00Z3obXPaqapqqZQA1QHNT5Ak6c6eooeZec4+/Ct758oqqOxWloDQLeCrhum3XbvsgaWFFMVR/GmQb3qjgZu/A2Un4EXKeqB4NfIyJTxEnnPhz4CVChquu9x24SkUtEJEZEEnGGgHf6hsVF5EER2dSN8r6vLTMjBj9WtvHSlcANIjLdG4B+iDNcHaqXZycwUZxU7SLOAslPEzDPWUTOx2mgAZzn/dl3rFufMZCq/qi9z9vW68SZax4vIkPESYE9l4DheO/z5+ME1sEicr6I2L1q/ETkUhH5mjjrgRAn899ncdYztBAqjnTCT3CSsUxspwwzxUm7O9b782U4C5lblaGda1wbNIWoy4IafsGPVtlZvTYCseIsbD8PZ9SmEWeKUrBqnN7tu8VJM5+AU4nZ7X3/93AqgN/13ruX46y1+lPQdT6H0zBrQUSeF5FfdvmDh6BBGQuDHle29ToR+Zg3zgwVZw3FKLwjCSIyT0SuFGcd1nCchCBHgPfCUWZjvL4AzNHQSxD+HbhdnIQ3owG8f5O/9f77Om/dx/c3+ijOyNc73uO3i8jh7hSug7pNW+u9XgauEJHPeL/Tvwfs8XaIteDtoP6E7/tfnCUEY4DXvcfTRCTVW+/5B5xkYN8PusbHcRqVrbIHipPIY1Y3fgV+5/K78H6mK7zlTweewpn+fcx7vN26bV9klbbI+UNQq//lUCep6n/irDd6zduYeAhnxGN7wGvzA17y78BRnApBCk7GKp80nIXZJ3AWdHuCjl+I92buTaq6D2fx9kqcL+54AqYSiMiffb0i6iTAuAMng86HOBWil3DWRPicwhmaB2c+96mAYxH5jEHmAQdxvgCWAf/kHTXw2YBT5o/jBKFTONOvjPE5gbMge5uINOA0at4Cvhbq5BBxpF3qzPn/CU5Fuy3HcOLHW+KM2K7DmRr3SBc+R6RizmmcaXF34kzDWQLkqTeFvYg8ICJ/8J6rONPnbsCJrX/noyRBPotwspbV4qSI/paqbvIdFJHpOKmTXwpRnGiISbfjrHE5gjMlaa5+lM4/Aef/63GcBfrjcWLW2QiU0/RTqnpAVVutK/Qe+xvO9OM5wEERqcX5blznPWUkztps399oFs7fqC8Tb6TizAc4I2//hRMvp+Ek7QFARPID6m/xOEsGjuGsQfsnYL46Sz/AGfn6G9CAM0L1LVX1r5P0uo0QndPejrh6nHpfpJyPs71DPc7o+P/hNBJ9Oqrb9jmiXUoyYvozEdmFMzRb0+HJfdRA+IzG9BXibET8nHd+/oDj7dXeCUzW9lPoG2POkTgb9v6bqrZKVjUQeGfKXK6q3+7wZBM21sAyxhhjjDHGmDCxKYLGGGOMMWEmIueJyDMiUibOBq47RSRkQibvOqHmoKUDs3q5yMaYMLF9sIwxxhhjwm8QznromcD7OFnyCkRksqoeDnH+/6nqNb1YPmNMD7EGljHGGGNMmHkz4j0Y8NQfReQQkIOzD5Axpp/qFw2sMWPGaEZGRqSLYcyAUVxcfFRVEyNdjmhg8ceY3tVX44+IJAEX0/Y+SFNE5ChONsrngB93lPzE4o8xvauz8adfNLAyMjLYsSNkdk9jTA8QkR7bLLWvsfhjTO/qi/FHRAbjbEXy61D7IAFbcDbpLgMuB1YDTcCPQ1xrKbAUID093eKPMb2os/EnqpJcdGVBqDHGGGNMtPNuFP8ccBYIufm1qh5U1UOq6lHVvcAPgZvbOPcpVc1V1dzExD43kGfMgBBVDSxaLggdgbMJWYGIZESwTMYYY4wxXSYiAjyDs9H0ZwI2cO6IAtJjBTPG9KioamCpaoOqPqiqh729OH8EfAtCjTHGGGP6kieBy4AbVPVUWyeJyHzvGi1E5FKcDubC3imiMSbcoqqBFawTC0KNMcYYY6KOiIwH7gKuAqoC9rdaLCLp3n+ne0//JLBHRBqAdcDvgB9FpuTGmO6K2iQXHS0IDV7kaYwxxhgTLVS1jPan+cUFnPt14Os9XihjTK+IygZWJxeEPgU8BZCbm6u9VzpjIk9VKSkpobS0lKysLLKzs3Gm+htjTM+y+GOMiZS+En+iroEVtCD0+i4sCDVmQHC73eTl5VFWVkZaWhqVlZWMHz+ewsJCUlJSIl08Y0w/ZvHHGBMpfSn+RF0Di48WhF7b3oJQYwYiVWXBggXEx8ezbNkyYmJi8Hg8bN26lby8PLZt2xaVPTnGmL7P4o8xJlL6WvyJqiQX7S0IjXDRjIkKJSUllJeXM336dGJinNs3JiaG6dOnU1ZWRklJSYRLaIzpryz+GGMipa/Fn6hqYKlqmaqKqp6vqnEBj5WRLpsx0aC0tJTU1FR/cPGJiYkhLS2N0tLSLl9TVSkuLmb16tUUFxejaksajTGt9UT8McaYzuhr8ScapwgaY9qQlZVFZWUlHo+nRZDxeDxUVlaSlZXVpev1pfnMxpjICnf8McaYzupr8SeqRrCMMe3Lzs4mPT2drVu34vF4ACe4bNmyhfHjx5Odnd3pa/nmM8fFxbFs2TLy8vJYtmwZcXFx5OXl2UiWMaaFcMYfY4zpir4Wf6yBZUwfIiKsXbuW+vp68vPzKSwsJD8/n4aGBtauXdulBZ59bT5zTxOR80TkGREpE5ETIrJTROZHulzGRItwxh9jjOmKvhZ/bIqgMX1MSkoK27Zta7EPRE5OTpev05n5zOdy3T5sEFAOzATeB64HCkRksqoejmTBjIkW4Yo/xhjTVX0p/lgDy5g+SETIycnpVmDpa/OZe5qqNgAPBjz1RxE5BOQAhyNRJmOiUTjijzHGnIu+En9siqAxA1Rfm8/c20QkCbgY2Bfi2FIR2SEiOz744IPeL5wxxhhjopaNYBkzQPnmM+fl5ZGfn98ii2A0zmfuTSIyGFgJ/FpV3w0+rqpPAU8B5ObmWjYQY4wxxvhZA8uYAawvzWfuLSISAzwHnAXuiXBxjDHGGNPHWAPLmAGur8xn7g3iDNs9AyQB16tqY4SLZIwxxpg+xhpYxhjzkSeBy4BrVfVUpAtjTH+nqi1G0LOzswf09GRjTP9gDSxjjAFEZDxwF3AGqAqo5N2lqisjVjBj+im3201eXh5lZWUt1oAWFhaSkpIS6eIZY8w5swaWMcYAqloGWNe5Mb1AVVmwYAHx8fEsW7aMmJgYPB4PW7duJS8vj23bttlIljGmz7I07cYYY4zpVSUlJZSXlzN9+nT/PnwxMTFMnz6dsrIySkpKIlxCY4w5d9bAMsYYY0yvKi0tJTU1tcUm5+A0stLS0igtLY1QycJHRM4TkWdEpExETojIThGZ3875XxWRKhE5LiLPish5vVleY0z4WAPLGGOMMb0qKyuLyspK/ybnPh6Ph8rKSrKysiJUsrAaBJQDM4ERwANAgYhkBJ8oIvOAbwGfBDKATOAHvVROY0yYWQPLGGOMMb0qOzub9PR0tm7d6m9keTwetmzZwvjx48nOzo5wCbtPVRtU9UFVPayqHlX9I3AICLUnxm3AM6q6T1WPAf8J3N6LxTXGhJEluTDGGGNMrxIR1q5dS15eHvn5+S2yCK5du7ZfJrgQkSTgYmBfiMOXA4UBP+8GkkRktKrWBF1nKbAUID09vYdKa4zpDmtgGWOMMabXpaSksG3bthb7YPXXDc9FZDCwEvi1qr4b4pQ44HjAz75/xwMtGliq+hTwFEBubq6Gv7TGmO6yBpYxxhhjIkJEyMnJ6bcNKwARiQGeA84C97RxWj0wPOBn379P9GDRjDE9xNZgGWOMMcb0AHHmOj4DJAGfUdXGNk7dB1wZ8POVQHXw9EBjTN9gDSxjjDHGmJ7xJHAZcIOqnmrnvN8AXxCRSSKSAHwXWNEL5TPG9ABrYBljjDHGhJmIjAfuAq4CqkSk3vtYLCLp3n+nA6jqX4CHgSKgzPv4fqTKbozpHluDZUw3qGqLBdrZ2dn9MvuVMcaYrlHVMqC9L4S4oPMfBR7t0UIZY3qFNbCMOUdut5u8vDzKyspapBguLCwkJSUl0sUzxhhjjDERYA0sY86BqrJgwQLi4+NZtmwZMTExeDwetm7dSl5eHtu2bbORLGOMMcaYAcjWYBlzDkpKSigvL2f69OnExDi3UUxMDNOnT6esrIySkpIIl9AYY4wxxkRC1DWwROQeEdkhImdEZEWky2NMKKWlpaSmpvobVz4xMTGkpaVRWloaoZIZY4wxxpiOqCrFxcWsXr2a4uJiVMO3b3c0ThF0AQ8B84ALIlwWY0LKysqisrISj8fTopHl8XiorKwkKysrgqUzxhhjjDFt6el19FHXwFLV3wGISC4wLsLFMSak7Oxs0tPT2bp1q3+aoMfjYcuWLYwfP57s7OxIF9EYY4wxxgTpjXX0UTdFsLNEZKl3KuGODz74INLFMf1IZ4aMRYS1a9dSX19Pfn4+hYWF5Ofn09DQwNq1ay3BhTHGGGNMFOqNdfRRN4LVWar6FPAUQG5ubvgmTZoBLXDIODU1lbKyMhISEli+fDlz585t0XBKSUlh27ZtLfbBysnJiWDpjTHGGGNMezqzjr679bk+O4JlTLj5hozj4uJYvHgxNTU1qCqDBw/mlltuYdq0abjd7havERFycnJYtGiRNa6MMcYYY6Jc4Dr6QOFcR99nR7CMCTffkPHSpUtZsWIFmZmZzJw5s8X6KtvjyhgTLVS1xQh6dna2xSZjjOlAb6yjj7oGlogMwilXLBArIucDTaraFNmSmf7ON2RcXV1NfX29v3EFzrDxjBkzyM/Pp6SkxEarjDER1dMZsIwxpr/yraPPy8sjPz+/RQwN1zr6qGtgAd8Fvh/w8xLgB8CDESmNGTB8Q8aZmZmkpKT06NxcY4w5V72RAcsYY/qznl5HH3VrsFT1QVWVoMeDkS6X6f98Q8ZlZWW4XK5zmpt7rpvW9eRmd8aY/qW4uJjDhw+HLQOWxR9jzEDUk+voo3EEy5iI8A0ZL1iwgDNnzlBUVMTs2bM7PTc3cMpOcnIyFRUVpKamsn79elJTU9t8X5vqEz1E5B7gdmAy8IKq3h7RApkBp6N1VW63m0WLFjFy5MiwjLJb/DHGmPCzBpYxAVJSUnjzzTfZsGED9957L8uXL2fcuHEt0rWHEpiBMHDKzsaNG5k0aRJvv/12yEaWTfWJOi7gIWAecEGEy2IGmI4aO754MWrUKEpLS/F4PC0aWb5R9sbGRlavXt1h4guLP8YY0zOiboqgMZEmIsybN493332X73//+xw5cgQRYcSIEXzuc58Lma7dl4FwxowZLabszJkzB1XluuuuCzntpjc2uzOdp6q/U9XfAzWRLosZWII7afLy8li2bBlxcXHk5eX5R7bKy8uZP38+8fHxbN682T+V2ePxsHnzZs6cOcO9997Lt771La677jquvvrqVvHKx+KPMcb0DBvBMiYEt9vNggUL2LdvH7m5uS2mCobq3S0tLSUpKSnklJ1x48ZRUVERMvtgb2x2Z8JPRJYCSwHS09MjXBrTH/gaO3fddVerxo4ve6kvXsTGxrJw4UIKCgrYvXs3qamplJeX4/F4GDTI+VofOnQodXV1HDhwgPnz57Nz585Wo1EWf4wxpmfYCJYxQXw9yarK+eef729cQdu9u1lZWVRUVIRMjOFyuUhJSaG0tLTVe/XGZncm/FT1KVXNVdXcxMTESBfH9AOdaewExov4+HjuuOMOFi5cyGWXXUZMTAzNzc1ceeWV3HfffSxcuJD77ruPyZMn8/e//53i4uJW72nxp+eJyD0iskNEzojIinbOu11EmkWkPuAxq/dKaowJJ2tgGRNk/fr1vPfee2RkZHSYrt0nOzublJQUNm7c2GLKzqZNm4iPj6e2tjZkZSVws7vA14VzsztjTPTzNXaam5txuVy89dZbuFwumpub/Y2d4HghIiQnJ1NTU8Pw4cMZPHgws2bNatEhNGvWLAYNGsQrr7zS6j0t/vQK37rOZztx7v+palzAY1PPFs0Y01NsiqAZ8AKzdo0YMYKbbrqJtLQ0Ro8e7U/XHryQvLS0lJEjR/qfExE2bNjApEmT2LNnD+PGjcPlchEfH8+4ceNoamoKWVnpjc3ujDHRLzs7m+TkZH72s5+hqqSmpuJyuRAR0tPT/ckq2ooXS5Ys4cUXXwzZIZSUlBTyPS3+9DxV/R2AiOQC4yJcHGOiUkfZU/sia2CZAc3lcjFv3jxcLhdpaWns37+fSy+9lMOHDzN06FAaGxvZuHEjc+bM8a/BKioqYtCgQXz3u99l7ty5/iCQmprK22+/zXXXXUdFRQUpKSkcO3aMpqamdisrPb3Znek8ERmEExdjgVgROR9oUtWmyJbMDAQxMTFcccUVLdZ8FhUVUV9f7z+nrXixY8cOfvazn4XsEKqurua6664L+Z4Wf6LKFBE5CtQCzwE/tthj+rv+ulWE9IcNBXNzc3XHjh2RLobpY1wuF5MmTWLy5MnMmTOHqqoqVq9ezX333cevfvUrGhoauPjii3G5XJw4caLFQvKlS5eycuVK1q1b16oyEtwT0x8rKyJSrKq5kS5HuInIg8D3g57+QXubnVv8Md2lqqxcuZKvfOUrfPnLX27VQMrPzw8Za4KvkZ2dTXx8fMgGWnFxcZ/vEfbpi/FHRB4CxrW1t56IZAIKlAGXA6uB51T1xyHODUyyk1NWVtZTxTamR6kqV199NfHx8f5spr5kYvX19VG5VURn44+twTJRQ1UpLi5m9erVFBcXh0xrHs73uvbaa1FV/+hUbW2tf5H55MmTaWxsZN68ef6F5JMmTWLRokUMHjyYhoaGVuuwfHpyZ3DTs1T1QVWVoMeDkS6X6b/cbjfTpk3jy1/+MqNHj/Y3rlQVl8vF22+/TUJCAvv372/3OiLCunXrOH36NMuXL2fNmjUsX76c06dPs27duqirpJiWVPWgqh5SVY+q7gV+CNzcxrmWZMf0C/15qwibImiiQm8PEZeUlOByuRg3bhwxMTGoKs3NzZSXl/Pss89SU1NDWlqa/4ZPTU31bxScmpr2BuFfAAAgAElEQVRKTU2NZdkyxnRL4Ea/CxcuZM2aNXg8HhoaGli9ejV1dXWMGDGC2tpaHnroIWbOnNluPLTpfv2KAtYqNv1af94qwhpYJuICKxnLli1rd7+pcCktLSU5ORmXy8Xx48dZs2YNx48fp6mpiYyMDObNm+ev7IgIbreb2tpaRo4cSWVlJRdccIFl2TLGdIuv93bp0qVUVVUxePBgioqKKC0t5fTp0wwaNIgRI0bQ0NCAy+Vqcz+rQL4R9L5aKelvOruuU0TmAyWqWi0ilwIPAC/2eoGN6UWBW0UET43u653Y1sAyEdeZDTY7U1noShaarKwsamtrGTZsGCtWrGDy5MlcfPHFrFmzhtmzZyMixMfHs2HDBiorK1uswTp79iyNjY2sX7/ept0YY85ZaWkpiYmJrFixghMnTpCYmMgbb7xBTEwM06ZNY9asWYgIlZWV/PWvf+Xdd99lx44dTJ06NdJFN533XVqu61wC/EBEngXeBiap6vvAJ4EVIhIHVAPPAz/q7cIa05sCt4oIXIPVH7aKsAaWibhwDBF3dYphdnY248eP5+zZsxw/fpxZs2bx9ttvt9j36pZbbuEXv/gFU6ZMaZFFcMuWLTQ0NLSZ+tgYYzojMzOTAwcOMHXqVP/+VZs3b2bHjh3MmjWLhoYGCgoK/B08gwYN4uabb+aNN97o09m1BhLvGs4H2zgcF3De14Gv90KRjIka/XmrCGtgmbA6l70MujtEfC5TDH039TXXXENycjIxMTEkJCT4swTGxMRQX1/PkCFD/I0rcBp9M2bM6NLImjHGBHO73dx2223+zYADY0xSUhIiQkFBAZmZmcycOdMf1zZv3txjU6eNMaa39de1o5ZF0ISNLxvW9ddfz//8z/9w/fXXM23aNNxud7uvCxwi9ng8AF0aIj7XLDQpKSn+heS+921qamLTpk14PB5qa2tbjGj5BI6sGWNMV/k6hXybCAdmDoyPj6eqqorKykrq6+v9jStwYs/MmTM5cOAAK1eu7NFMq8YY01v6Y/ZlG8EyYdGdRBXdHSLuzhTDnJwcMjIy2Lp1K6NGjeLCCy/k0KFD7N69m6FDh/Lhhx/2y8WXxpjI8XUK3XDDDS0yBxYUFPDhhx8CsHXr1jY7eMaMGcOXv/xlHn/88T6/GacxprVzmQ1koouNYJmw6O5eBr4h4nXr1vHNb36TdevW8eabb5KcnNzhewdOMQzUmYaQr3FXX1/Pxo0bcbvd5OTkcObMGY4fP46IsHHjxnMaWTPGmFB8nUJpaWnEx8ezadMmVq9eTWZmJvfeey/XXHMN5eXllJWVhYxrR44cYeHChcTFxZGXl2cjWcb0I+c6G8hEl3NuYInIx0TEUogaoHOjSB051yHi7k4x9DXuVq1ahcfjYd26dUydOpWvf/3r3HXXXZSVlfHYY4/x/PPPk5+fT0NDA4WFhZSUlPTKpsimNYs/JlLCsSG6r1NIVVm4cCHvvfcedXV1XHzxxTzyyCMUFRX53yu4g2fTpk3Ex8eTlpbWLzbjjBYWU0w08M0GiouLY9myZeTl5bFs2TLrTOmD2p0iKCJDgW8DVwH7cTLhjAEeAa4Dft3D5TN9RCT3MghXFpoHHniA1NRU3G43s2fPJiYmhvj4eO644w4qKyt57rnn+M53vsOdd97Zq5siD1QWf0y0CdeG6MGpia+55hreeustVq5cyfnnn8/kyZNbZBF87LHHSEpK4siRIwwbNoxbb70VEUFE+vxmnL3JYoqJduHatqY7bHpieHS0BuvnwBRgPTAfmAxcihOEvqiqR3u2eKav6Km9DDp7o3c2C01b1yspKeH999/n1KlTjBs3rkUjUUQYN24c6enpHD16tNc3RR7ALP6YqOAbtfrsZz/LuHHjun3vB3cKJSQkcPjwYX/c8WUVjI+P5/Of/zx79uzhj3/8IyNHjuTkyZMUFBSwcOFChg0bZutBu8Ziiolq4di2pjtcLhfz5s3D5XIxbtw4qqqqrAP5HHXUwJoHXKWqR0TkCeB9YKaqbu35opm+pCf2MgjsLU5NTaWsrIyEhASWL1/O3LlzQ6Zez8nJaTP4tNf7vH//foYPH87Jkyeprq5ucyTu7Nmz7N+/n1tuucX//r3duzSAWPwxEeeLG6WlpTQ1NXHrrbeGpWc5sFNo//793H333Zx33nmMHj3af/0TJ07498G66KKLqK6uZsSIEaSlpflTuNt60C6xmGKiWiRnA7lcLiZNmsTkyZO56aabWnSUd7YTyUa/PtJRAytOVY8AqGqFiNRbIDJtCedeBoFZCRcvXsyaNWtQVQYPHswtt9zCpZde2qpHpb0bu70sh/Pnz+fs2bOUl5eTmZlJfX09mzdvbrH3zF/+8heam5spKCggKSmJNWvWEB8fz8KFC4mPj++13qUBxuKPiajAuDFnzhzeeeedsPYs+zqFsrOz+cY3vkFtbS1nzpzB4/G0uw/WwYMHqa2tJT4+ntdee23AVmDOgcUUE9V6ajZQR1SVa6+9FlU9570/wzWFur/oqIE1SERmA/7oHfyzqm7sobKZPqijUaTO8s1DXrp0KStWrGhVyQjuUfHd2AcOHCApKYnq6momTJjgv7GD5zWrKlVVVSQkJPC3v/2NCy64AFWloqKCO++8kzVr1rB7925SU1OprKzk9OnT/MM//EOrik5BQQF33HEHqmpTdcLP4o+JqMC4UVVVhcvl6pGe5eLiYurq6khISODkyZNs2rSJiy++uM19sHbt2kVKSgrf+973OpVp1fhZTDFRrSdmA3VGSUmJf1pgqE6k5OTkdjuRurNVT3/VUQPrCPBswM81QT8rkBnuQpn+r6NhZN885Orq6pCVjMAelezsbK677joSEhK45557/Df2xo0bmTt3Lnv27Gkxr9k37ebDDz9k5MiRAHzsYx8jOzubp59+mu3bt3P77bdTXV1NTU2NvwIVqqKze/duKisrKS0ttak64Wfxx0RUYNxISUkhPj6+1ei2r2d5ypQpFBcXtzs1pq24t2HDBpKTk5kzZw4rVqxg27ZtbNu2rcUmxD4xMTEkJiZSVlbmj1+m0yymmKgXztlAnbV9+3ZGjBjRZidSRUVFu51I0ZCcI9q028BS1YxeKocZQDozjOybh5yZmdlqs03f6NPQoUPZsGEDzc3NlJWV8ZnPfKbFjT1nzhweeeQRtm/f7r9ec3MzL7zwAhMmTGD27Nm8/vrr1NbW+heV33XXXbzwwgvs2bOHxMREqquraW5u5pJLLglZ0Rk7diwFBQVccsklPdq7NBBZ/DGRFrweYuHChRQUFLB7927GjBlDXV0dF110EU8//TTTpk3jwIEDjBgxguPHjzNhwgTWrl3rj2ltxb2nnnqK/Px8ampqWLt2LVdeeSXvv/8+x48fx+12h6zsHD16lMsvv5wHHngg5HpUE5rFFNNXhGs2UGeoKo8//jjHjh1jxIgRrTqRNm7cSGpqarsdyJFOzhGNOhrBAkBE4oB/xEln+gGwTVVP9ESBRGQU8AwwFzgKfFtVV/XEe5ne19lhZN885LKyMn+Piohw4MAB1q9fz9mzZ0lMTOTRRx/liSeeYMyYMf6pf263m9raWkaNGkVSUhKf/vSn2bVrF+np6axbt44PP/zQn4YdICkpyf/v4cOHs3TpUtxuN4WFhVx66aUcOHCAioqKNis6P//5z1myZElEfp8DQW/GH2MCBa+HiI+P5/bbb2fdunUcO3aMP//5z+Tk5HDVVVdRXl6OqjJ06FDq6uo4cOAA8+fPZ+fOnQAt9rYJHP2aNWsWV111FWfOnKG+vh63282ll17KlClTePrpp9m4caN/TUTgPlg33HADv/jFLwZkz3B3WUwx5iMlJSXU1NQwYsQIxo0bx8GDB/1LJMrLyxER3n333XY7ciKZnCNaddjAEpGvAP8JnI/T4BkDnBaR76vqoz1Qpp8DZ4EknL0q/iQiu1V1Xw+8l+llnR1G9s1DXrBgAWfOnGH9+vVUVlZy9OhRpk6d6m8g+Soc27Zto66ujpdeeokTJ06QmpqKy+Xi9OnTTJgwgRtvvJHCwkKuvvpqkpOT/e+dmZnJtm3bWgQFESE5OZmGhgamTJlCU1MT9fX1IRedTpgwgcWLF0fs99nfRSD+GOPX3nqI119/neTkZHbs2MH+/fuZOnWqfyTcF5e2b99OcXExNTU1vPfee3z1q19tEfeysrLYsWMHM2fOJC4ujt27d9PQ0MCMGTNYsWIFkydP5r333vN3EFVWVjJkyBDmzZs3oHuGu8NiijEtlZaWkpaWxpw5c/zLJ0aNGsXhw4cRER555JEOk1REKjlHNOtoo+HbgW8BXwBeUtVmEYkFbgZ+KiLHVPVX4SqMiAwDPgNcoar1wF9FZC3wr95ymD6uK8PIKSkpFBYWMnv2bHbt2sVll11GQ0NDi9GnmJgYZs2aRXFxMb/85S/Jzs5uUckpKiri8OHDVFVV4Xa7+dKXvsR///d/+xtUqampDB8+nKKiohaNto0bNzJixAiSk5NxuVz85je/4YEHHujVRacDXW/HHzNwtbcmNCUlhTfeeINVq1axfft2pk6dyuLFi/3HX3nlFQYNGsTMmTOpqqryj57PnDmTnTt3smHDBp555pmQca+urs7/fFpaGkVFRWRkZPjXns6dOxe3282qVav805UTExP54x//SHx8PCdPnhyQPcPnymKKMa35Rp+GDRvGHXfc4Z8FNHLkSNauXUtubm6H14hUco5o1tEI1leB21R1ve8JVW0GVotIHfATIJzB6GKgWVX/HvDcbmBm8IkishRYCpCenh7GIpie1JVhZFUlLy+P4cOHM3ToUCZMmMDZs2dDNs5SUlIoLy/3N658z8+ePZvHH3+c0aNHU1payty5c3nooYfYtGmT/9xFixaxYsUKSkpKSE1N5ciRIwwfPpxFixaxdetWxo8fz9y5c5k7d26vLjo1vR5/zADU0ZrQ4OO//e1vefzxx1usGR09ejS/+tWvqKurY/jw4f4EOqNHj8blclFXV4fH42kV90aOHOmPh74kGuXl5dTU1PjXnvreY9KkSS06gYqKitizZw9TpkyJyO+tj7KYYkyQ4NGn1NRUkpOTuzz6FInkHNEspoPjE4BX2zj2GuHPthMHHA967jgQH3yiqj6lqrmqmpuYmBjmYphgqkpxcTGrV6+muLgYVT2n6wTeyB6PB8Cf8nzEiBGoqv/avumEY8eOZcyYMf7Kiu91Ph6PB7fbTWJiYsjGly8bYWNjI6WlpVx44YXs3buXxx9/nIKCAn71q1+hqiQnJ9Pc3ExMTAxjxozh+eefp6Ghoc3el3P9HZhO6+34YwYY35pQ39qovLw8li1bRlxcHAsWLGD79u3MmDGDYcOGsXTpUjIyMsjIyKC+vp4bbrjBv3eMy+WioaGBQYMGMXLkSGJjYzl+/DgVFRWkpKSQnp7uz0Do8Xj8W0Js2LCBpqYmNm3ahKqyePFiPB4PBw4c8Me6qqoqBg8e3Grkfvbs2QwZMsS/xst0isUUY4L4Rp/q6+vJz8+nsLCQ/Pz8dus/7V0rJyeHRYsWDejGFXQ8gnUCSMPZ7TxYmvd4ONUDw4OeG94D72O6oLubxwVPvyksLOTGG28kPz/fv7dCY2Mj6enpXH/99WRkZFBYWEhpaSkpKSkUFxdz6tQpkpKSQqZJ3rx5M01NTdTW1oYcGSsrKyMmJoavfe1rpKWlUVNT429InTx5EhEhKyuLtWvXkpSURElJCfv376epqYnBgwf7e5hvvPFG20Cvd/V2/DEDTHFxMQcPHmT27NlUVVX5R42uuuoq8vPzmTt3Ls3NzcyePZvHHnsMwL++s6mpiRdeeIGsrCxEhMmTJ7eanvzmm2/yzDPPUF9fz5IlS1izZg07d+5EVfF4PMTFxZGSksKhQ4fYs2cPqampeDwe3nnnHUSEoqIixo4d2+a06nHjxtkarK6xmGJMCKFGn7KzsykpKWHz5s1tbj1h2tZRA+v3wHIRuVlVT/ueFJELcJJRvBzm8vwdZyPAiaq63/vclYAluIiQ7m4e11bj7OWXX+Z3v/sd3/zmN4mNjWXixIm4XC7OP/986urquPbaa1mxYgVlZWWoKsOHD2fLli3cfPPN/k2Ax44di9vtJj09naFDh3LmzJlWGbdee+01mpubmTp1KjNmzGix8PLIkSM88MADTJw4sUUFJTU1lbvvvpuysjKSk5MpLy+nqamJnJwc20Cvd/V2/DF9XEf76wVyu93ceuutNDY28s4771BZWcn5559PTk4OJSUl5ObmMnbsWPbt28eqVavIzs5uNUXvrrvu4l//9V8ZMmRIyOnJe/fuZcSIEdTW1rJr1y5uu+02fvnLX3LxxRcza9YsqqqqKCgo4N5776W6upoDBw5QXl7OV77yFQ4dOsT69evZuXMnImLZucKj12OKiNwD3A5MBl5Q1dvbOferwDeBC4CXgLtV9Uy4y2RMKIGp4d1uN9OmTbNO5W7oqIH1LZxh88Mi8mfADaQA84EKIKy5qVW1QUR+B/xQRO7EySKYB3w8nO9jOq87m8e11Th79dVXmTRpEo2NjeTm5rZKLrF79248Hg+f//znGT58OOeddx6f/vSneeGFF9i5cycpKSkcO3bMXxG58soreeihh6itrWXHjh3s2rWLpKQkqqqq8Hg8DB061N+48pXft1HxxIkTyc7O9m8QOmHCBO6+++4W6ZQrKiooKChodY2BvIFeL+nV+AO2TURf1pWRdl9sSktL47Of/SwNDQ0UFBRw/Phx9u7dS319vX9Uq6ysjNjY2JBT9Hbu3MnOnTv9Wz0EbxORkpLChAkTKC8v54MPPuDnP/85TU1N/sZY4ObFs2bNora2lgsvvJDY2FiysrKYMGECLpeL3//+960S8Qzk7Fzd0OsxBXABDwHzcBpOIYnIPG/55nhf8zLwAyzBl+ll3e1YN46ONho+LiL/CHwOuBaYilPp+A7wnKqe7YEyfQlnZ/UjOLus320p2iOnO5vHhWqciQjvv/8+mZmZlJWVtaq0zJkzh7feeotFixaxf/9+zpw5Q3l5OS+++CInT55k9OjRlJeXEx8fT319PTfddBMABw4cYOrUqcycOZPq6mpqamo4ePAgb731FuPGjWuz/Nu3b/ePVqWlpXH48GGamppapFOuq6tr9xo2RadnRCj+2DYRfVBXKwSBsUlEKCgoIDMzk5kzZ/L222/z9ttv+xtAsbGxrTY7h4/Wd8bHx7N3716OHz/OmjVrWm0TkZOTQ1paGt/+9rc5dOgQq1atQkRwuVzU1tYyY8YMXnvtNUpKSkhMTOTIkSP+0SoRIS0tjSVLlvDkk09SUlLChAkTqKqqGtDZuc5VJGKKqv4OQERygXHtnHob8Iwv1ojIfwIrsQaW6WXd6Vg3H+lwHyxVbcTp0X0m8HkRiRWRH6rq98JZIFWtBW4M5zXNuevO5nGhGmdut5uGhgamTZvWZkbA1NRU6urqmDlzJj/96U/xeDxkZGS0mp7z5ptvoqqICIMGDfL3CqemppKamsrll1/Oe++9518sHlz+iooKfvaznzF27Fh/pWzv3r3s3bu3xbmjRo1q8xo2Radn9Wb8sW0i+q6uVggCY5PL5aK+vt6/rjP4fp8+fTpbtmwJef+7XC6+853v8Prrr/v3rQpeh7V582bq6+uZOHEiWVlZ/OQnP+HZZ5/lxIkTJCYmUl5eTmxsLAkJCXzwwQeoaqvRquLiYsaMGcPQoUOZNWsWn/vc56yCc456u07TBZcDhQE/7waSRGS0qtYEnmhZlE1P6k7HuvlIR1kE2zMIp9fH9GNtZf3rzPSUwMaZT21tLSkpKe1mBHS5XIwaNQpwRryGDBnSZgatV199lQMHDjBhwoSQwSArK4uRI0eGLH9iYiJHjx71b4oHTrpl39RCn5SUFOLi4ti4cWOXfwemx/RE/Glrm4jLw/w+Jsw6UyEIFBibfDHJ99rAaXsej4epU6f6Gz2B939RURGxsbEsWbKE//iP/+Ds2bMh12HV1dX5pwsuW7aMhoYGMjIyuPfeezl9+jRXX301X/va17jzzju5//77ycrKYvv27f4sp48//jiHDh1i4cKF1NXVWeOq50S6ThOcRdn3b8uibHpUcJboCRMm+OOjquJyuXjrrbeoqKigoqKi3U7lcGWc7g86HMHqgM1N6Oe6s3lcqJ29R44cSUVFRZsZAYuKioiPj0dVefjhh2lsbOSiiy4KWXFKSkoCnMpSWyNMVVVVbW4SfN999/GLX/yixWtSUlIYOnRoi2QZqkpaWho7d+5k165dZGZm2hSd6BDuX3ynt4mwHuTe1VHyivZG2isqKmhsbGT16tX+1wbGJt86p8BpeQsXLqSgoIAdO3aQmpqKqrJ9+3b/Xnlut5vY2Fi2bNniH/VqaxphUlIS999/P3l5eYgIF1xwgX99V319fatGWV5eHv/7v//LhAkTyMjI4JprrjmnPWnMOYlkMA/Oouz7t2U2ND0m1NrV9PR0UlNTefXVVykvL/dPe66oqEBE2kxy0d2M0/1NdxtYA7dpOoCc6+ZxgY2zJ598koSEBCorK2lubqaoqKhVRsDKykpGjRrF/Pnz+fWvf82QIUNITk7G7Xa32XgaN24cU6ZMadWQCxxhamuT4OLiYr73ve+1uLaI8C//8i88+eST7Nmzh3HjxuFyuYiPj2fy5Ml8+OGHfPvb326VedBERLjjT6e3iVDVp4CnAHJzcy0O9qDOfGmH6szxeDy88sornD171r9FQ+BrfbGpsLCQ5ubmFp0qw4YNIyMjg1OnTjFs2DA8Hg/Dhg0jPj6eiooKkpOTef3110lJSUFVeeKJJ6iurg4Zp44fP+7fQPiaa67h5MmTxMTEtBo58/EluPjwww/ZunVrlzq1TLdF8l7eh5M1ucD785VAdfD0QNN3dCWraSS0t3a1pqaGffv2MXny5BaZmbdu3cqNN97Yal2rJcZoTdobvhOROe28dgjwJ1WNDXupuig3N1d37NgR6WKYNng8Hq644gpEhI9//OOMGDGClStXcuLECZKTk6murmbQoEGcOnXKP2KUm5vLnDlzEBGefvppMjMzW9zkGzduZM+ePZx33nlkZGTw1FNPsXTp0laVsLVr15KcnByyXKrK1VdfTXx8fKuGWW1tLU1NTf6NQo8dO9bh9QYSESlW1dwefo9ejT/eNVjHgMt920SIyG8Al6q2uQbL4k/Paese3bp1K/X19S2+tIMbYhUVFZw9e5bs7Ow2X+t2u7nuuus4ePAgIkJsbCzp6em4XC4aGxv9jZ8rr7yyVSXDd42SkhKuv/56hgwZQmZmZos1WBs3bqSuro7vfOc7PPzww0ydOpWCggLuu+8+f4r2++67r1WjLD8/nz/96U+ISJc6tQaKc40/kajTiMggnM7s7+Mkufgi0KSqTUHn/ROwAieLoBsnTfub7cUesPgTrfrCaE5xcTGf+tSnWqxdBScGPfHEE8TGxvKlL30pZHxat25di5jU3rVCnd+XdTb+dDSC9UwHx0Nt1mdMCzt37qS2trbFjfeJT3yC4uJi6urqmDhxIh988AGXXHIJpaWlnDlzxj+Fpra2ljlz5rBp0yYeeeQRUlJSqKqqIiEhgS9+8YsMGzaMrVu3snTpUt544w127tzZ6QpJe9Mf169f79902Co4EdOr8ce2iYg+XUleETzS3tjYyNe//vUWayx9r33yySd5/vnnefDBBxk1ahSLFy/mt7/9LQCXXnopNTU1XHnllUycOJGXXnrJ37gK9f6lpaWkpaUxZ84cCgoK/BsG+6YdPvzww0ycOJHKyko+/elP+6dGz5gxg/j4eDZt2tSiUeYbec/JyfHvS2PCJhJ1mu/iNK58lgA/EJFngbeBSar6vqr+RUQeBor4aB+s77e6mol60T6a4xtZ+81vfuPfYiJQTEwMI0aMIC4urtOJLiwxRmsdpWm/qLcKYvqv4BvP4/FQU1NDdXU1//zP/8wrr7zCiRMnOH36NImJiTQ3N7NixYoW6Y7j4uIYNWoUhw8f5pprrmHWrFn+6/sqOzt37vRvkteWUEP27U1/7Oh6pudEKP7YNhFRpKtf2oEbZa5evTrkaxsaGjhz5gz/9m//xujRoyktLaW6uprhw4dz6tQp9u3b58/653a7GTNmTLvv71v/NWzYMO644w7/Plgf//jHWbt2Lbm5uf4pjH/9619bTI0eNWoUb775Jjt37iQzMxO3221TAXtQJGKKqj4IPNjG4bigcx8FHu3hIpkeFs1pzgNH1nzLNtqa2lxfX9/p7MndyTjdX3V3DZYxHQq88aqrq3n++ecBSEtLo7Cw0J+Z68yZM3ziE59g5cqVXH311S16dTdt2sSbb76JiDBjxowW1+9sD0l7Q/bWkDJg20REm+58aYd6raqyevVqPvaxj7WY8rdp0ya2b99Oc3Ozf1rwb3/7W06fPs35558f8v3LyspobGxstQY0NTW1VVKKwNHylStXkpqaSn19PQAvv/wyiYmJNlJuTD8RraM5wSNrviUYgetPfcnGxo8fz6BBg9pc2x6cbKetdbADOTmPNbBMj/PdeJs3b2b79u3k5OQwe/ZsRIRnnnnGH3ASEhKIiYlpsacVOEFp1qxZFBcXM2hQ6z/ZzlS2on3I3hjTWne+tEO9trKykg8//LDVlL8ZM2awbds2pk2bRm5uLmvWrGHQoEFcdNFFvP/++60qIBs3bqSxsZH777+fxx9/nKeffpqlS5e2m2m1o2RB1rAypn+I1tGc4JE1Xw6Gffv28dZbb/lnDImIv/P5xhtv7FQG6e5knO6vrIFlepzvxvvEJz7h3xsmcINP30148OBBamtrufDCC9vc0+rEiRPnVNmK5iF7Y0xogV/ay5cvJzk5maqqKi666KIOv7QDX/vYY4+RkpJCRUUFaWlpLeLLiRMneP755xk8eDCzZs1ixRQo+LEAACAASURBVIoVZGZm+rePqKur49lnn2Xnzp2kpKRw9OhRmpubmTlzJtnZ2V1aAxo4hdEY0z9F62hO8Mia2+3m1KlT3HPPPVRXV1NbW+vfFiI/Px+3292lDNLnmnG6v+rORsPGdFpKSgo33HBDi5u7traWhIQEGhoa+NSnPkV8fDyHDh3yp2UP5PF4cLvdLF++nPr6evLz8yksLCQ/P5+GhoYOK1td3YjUGBM9VJXm5mbq6+tpbm72P9eRlJQUli9fzuDBg5k8eTLz5s3jgw8+8McXVaWgoICEhATS09Oprq6mvr7e37g6ceIEL730EiJCQkIC5eXlxMbGIiL+eDJ9+nTKysr8a0AXLVo0oCsVxgx0vs6dc6mr9KTAkTXAv1VEbGwsqampXHHFFf645qsX+TqFOhvXunp+f9bmCJaIdKrxpaqejs8yBqZOncqzzz7rHzYfNWoU1dXVZGRkEBsby8KFC1m9ejWnT5+mqKjIP9Llm5IzduzYNve06ki0Dtmb0Cz+GGg5tffee+89p6m9Bw4cYPz48UyePBlVZceOHf7Mfb7NfufNm8eaNWuoqanx703la3wFjmb51ieUlJT4t2uI9LoK0zkWU0xvisbRnOCRtVGjRlFZWUl5eTmHDx8GIDMzk+TkZP8aU1UdkNP7wqG9KYJNdG7TvYjvg2X6hltvvZV77rnH33hKSUkhLi6O8vJyPB4P8fHxfOELX+DAgQOsX7+ekpISLrzwQqqqqvzpjn03elen2UTrkL1pk8UfE5apvcGdK7fccgurVq2iuLiY+Ph4Ro8eTVpamn8E3Zde3df48jWufO89e/Zs9u7dS1VVFampqdZJ03dYTDG9KtqmBAevk0pMTOTUqVOsXLmSwYMHk5SUxLZt24iNjaW5udm/xjSa9u7qS9rr0bkIyPQ+7gU2A/8EXOb9bxFwT08X0EQHVaW4uJjVq1dTXFzcqek5wWJiYti0aRN79uzh0Ucf5YUXXuDEiROcPXuWjRs34vF4EBEyMzO59NJLiYuL4/LLL+fmm29myJAh5Oae+7620Tpkb9pk8ceEZWpvYOfK8ePHefHFFzl58iSjRo2ipqYGt9uNqrJw4UKOHDniH0EPHM0Kfu/U1FRqa2utk6ZvsZhiBjzfyNqf/vQnTp8+zbBhw7j66qv56le/ypIlS7j//vuZPHkyI0aMYNmyZcTFxZGXl3dOdb6Brs0RLFUt8/1bRO4HclW1zvvU30VkB7ADeLJni2girTM7kofaXypUo+Wqq66itraWVatWsX37dqZOncqcOXOYO3cujz76KMnJyVRXVzNy5EiWLFnCsGHDKCoq4qKLLup2BSYah+xNaBZ/DIRnaq+vc2XBggXk5+eTk5PjzwjY3NzME0884c8S+IUvfIH9+/fzhz/8gcbGRgYNGhTyvd9//32am5v9jSvrpIl+FlOMcYiIv3PpvPPOa5W1ec6cOfz0pz+lurraEoF1Q2ezCI4AhgJ1Ac8N9T5v+rHOpDevqqrqsAEWKCYmhiVLlrBkyRL/c3v37mXDhg0sXbqUs2fPUldXR2FhIdXV1WRlZbFu3bqwVGCibcjedIrFnwHKN/q0ZcsWsrKyqKurY+TIkezfv79Lo0a+ZBef/OQnW6RoP3nyJEOHDmX79u3s2rXLn6XQN3Xw/7d39+F112Wex993mvDQJi1NS/PQNn1GBYuQVrqDhRZG2osqDTNiUdRRQSBVdHZcd8URVpS6M6jjdhmFM6izVUG2sYINY3EJU9JWWChNYsuCCH1uk5NACe02AdqmufePkxPyeHKSnOfzeV1XrivnnN/5/b4nae7+7u/D/d27dy9btmzptQZr69atzJw5k29+85vMmzevO5ZE28kkKUExRbKWu/PFL36RCRMmdG+P0/O15uZmxo4dy549eygpKdEa0xGKNsH6OfCkma0FDgHTga90PS8ZbKg1EHV1daxevXrU+0uZGcuXL2f//v3U1dVRU1MDwLJly/RHLYo/WSq8EebSpUvZsWNH9z4tY8aMYcuWLcNKYJ588kmKiop6bTpcVVXFvHnzuOmmm2hpaeGNN94gPz+fP//5z0ydOpVnnnmGm2++ud++LjU1Nd1FLiC6UX5JKYopkrXq6+s5evQoJ0+e5O233+4epT9+/DhVVVUcP36cyZMns2PHDl555RXeeustrTEdgWgTrP8C7AauB0qBIPAj4CdxapekiKHWQNTU1MR0fykzY+HChaNabyUZR/EnS7k7N998M+Xl5b2K02zbto2bb7552BuEt7S0dN9MBIPBXkUsSktLKS0t5YILLuC+++4jEAjwgQ98YMhpxdrEPC0ppmQAjRqPzO7duykrK+PIkSO0t7dTW1vLkiVLqKqqYtasWd1TBsNVU3ft2sXFF1+c7GannajLlrp7wN3/0t3f5+5Xdj0+He8GSnL13TchLLwGAtD+UhJXij/ZKzyCHk6u4N0OnAMHDlBfXw9EV4TnqquuoqOjg9raWjo7O7v3gBkodk2fPr07dg21r0u0bZTUoZiS/oLBIIsWLWLFihXcc889rFixgkWLFhEMBpPdtJQ3d+5cmpqa+PjHP87ZZ5/N9u3b+cEPfsDRo0e7k6vwVMEpU6ZgZopjIxDVCJaFugS+AHwCONfdLzSzy4Fid6+KZwMluYYqb37VVVexdu1a7S8lcaP4k72iqSJYWloa1fS8BQsWMG/ePF544QV27drFxIkTee2110Ydu6Jpo6Y5pxbFlPSWKaPGyRqBC9/X/fGPf+Smm26iubmZZ555hpMnT/abKlhaWsrp06e54YYb2LJli6Y8D0O0UwS/A1wFrAUCXc8dBv47oGCUwfrum9DzBqa6upqioiLtLyXxpviTpYaqIjhnzpyob7TMjN///vesXLmSPXv20NnZyenTp/ttaj7c2KVNzNOSYkoai8X+eMk23HWb4WTs1VdfpaOjg9zcXObNmzeipKznfd2//Mu/MHXqVJqamujo6OD06dMDbrC+devWtEpeU0G0CdbngIvd/YiZhUuY7iO0n4RkuKHKm0dKwPSHKDHwORR/stJQI+jAsG60SkpK2L59e3csO+ecc7jzzjtHFbu0iXla+hyKKWkr3UeNhzsC19TUxPLly2lsbGTy5MkEg0FycnLIy8tj9uzZIyqm0/e+bs6cOaxevZrHH398wA3WL7/88rRJXlNFtAnWGKCt6/vw5Pb8Hs9JhotU3lz7S0mcKf5kqaFG0Lds2TLsG62+sWzZsmWjil1DtVGdTClJMSWNpfuo8XBG4Jqamjj//POZP38+f/3Xf92djNXW1rJv3z7GjRs34pGlvrGwurqaxYsXM2nSpLRNXlNJtAnW48APzezvoHv+8t3AY/FqmKQX7S8lcaT4k8UideDEaiPi0cYudTKlHcWUNJbuo8bRjsC5Ox/+8Idx91779+Xk5LB06VJ27drF3Llzqa6upq6uDjMb1XqukpISfvzjH7Nq1aq0TV5TSbQJ1t8BvwCOAXmEenmeAP4mTu0SEQlT/MlygyVBI73RisficnUypZWExRQzKwR+BiwDjgDfcPdfDXDcXcA3gRM9nr7Q3ffGuk3pLt1HjaPtGKqvr6epqYlp06YNmIwVFxdz9OhRpkyZwg033MCxY8dGtQ+fu3PHHXeQm5tLbW1tr3LtmzdvprS0NOWT11QyZILV1bMzGbgOKARmAIfcvTnObRORLKf4I5GM5EZLmwJntyTElB8DJ4Ei4CLgd2a2091fHODY9e7+6Ti1I6Ok86hxtB1Du3fvpri4mKampgGTsaamJhYvXsyePXtYtGgRn/zkJ0dVUbG+vp7Dhw/zuc99jg0bNrBr167uzd3feecdysrK4vLzyFRDJlju7mb2AlDg7q8Br8WjIWZ2G6GFp/OBh939c/G4joikj0TFH0lfw7nRypTyzjJyiYwpZjYO+BjwfndvA/5gZtXAZ4Db43XdbJGuo8ZmxsaNG1m2bBlr167lnHPO4fjx48yZM4fHHnusOwbNnTuX1tZW8vPz2bJlS6+qfps3b2bs2LHU19eTm5vL5ZdfHnE9VzSj9rt376aoqIgJEyZw4403EgwGaW1tZfHixWzdupUDBw7w0EMP8alPfUpxMgrRThFsAM4DXo5jW5qANcBy4Ow4XkdE0ksi4o+ksWhvtDKhvLPERKJiynnAaXd/pcdzO4Elgxx/jZm1AkHgR+5+/yDHSRoLBoOsWLGCvXv3MmbMGM4444zuEuk9N0kvLy9n6tSpnHnmmezdu5edO3dSWlrKoUOHOHXqFOPGjePo0aPMmTMnJnsFzp07l8OHD3ePlpWWllJaWkpnZyeHDh3i3HPP5W//9m+59957NeIfhWgTrFrg92a2DjjEu1V3cPd/jUVD3P0RADNbCEyLxTklNSVrcz1JW7XEOf5Idkj38s4SM7UkJqbkE1rn1dMxoGCAY6uAB4AWYBHwGzM76u4P9z3QzG4BbgE0bSvNuDvXXHMNBw8e5IMf/GCvdU5PPfVUv5H0zs5OXnnlFTo7OyksLGT//v2MGTOGkpISqqqqMDOuvvrqAacQ7t+/n1mzZnWP2t966620tLQwe/ZsDhw4wMqVK9m+fXv3tcrLyykpKWHz5s3dRTXC7Zo4cSLLly+ntbV1wPdKf9EmWB8itEdE314XB5Jyg6MAk560/kFGIOXij6SndC/vLDGTqJjSBozv89x44HjfA939pR4PnzGz/0FonVi/BMvdHyCUjLFw4ULv+7qkrvr6evbt2wfQnVxBqJPniiuu4L777useSa+vr6elpYXbbruNlpYWWltbKSwspLi4mEAggJlx8cUXc/LkyX4bpm/evJm33nqLK6+8krPPPpvPfOYzrFu3juPHj3evqzpx4gRPPPEEy5cvB0IzAZ544gnOP//87vVXhw4dYsKECZgZv/71rwd9r/QXVYLl7lfEuyHDpQCTfrT+QUYiFeOPpKd0L+8ssZHAmPIKkGtm89z91a7nPgAMVOCiLwf0H2KG2b17N+PHj2fs2LGDVgYMj6SHR9zHjBnTPV3P3QkGg4wdO5YnnngCd2fMmDHU1dVRX1/P1KlTee211ygoKOBLX/oSmzZt4tSpU2zYsIHZs2f3Wsf11FNP8eUvf5mXX36ZhoaG7llFL774IsuWLWPfvn1MnjwZYND3/vnPf9Z92yByhj4EzCxnsK8o319rZj7I1x9G9xEkXYTXP4RvbODd9Q8HDhygvr4+yS2UVDTa+CMSFq462NbWRiAQYOPGjQQCAdrb29OivLPERqJiiru3A48A3zGzcWb2IaAC+OUAbaows4kWcgnwFWBjLNsjyTd37lyOHTvWXRmwp3BlwL1791JXV8ecOXO6R9zdnd27d3Pfffexfv16cnNz+eEPf8gNN9zAyZMnmT59Op2dncyfP59Vq1Zx0003MX78eBYvXkxjYyNtbW3dCZK709zczJQpU2hpaeHCCy9kxYoV3HPPPaxYsYK/+qu/oqamhgceeIBjx471ei+8O9p25MgRHnrooV7rxuRd0U4R7KDHHOU+xgz1ZndfGm2DJHNp/YOM0KjiT7RUyTQ7pHN5Z4mZhMSULl8kNO3wNeANYLW7v2hmlwGPu3t+13Gf6DruTOAwcI+7/zzGbZEkKy8vZ/bs2ezdu3fAvabefvttqqqqWLt2LWVlZZSWllJTU8PevXs5duwYH/zgB3tNBdyyZQsHDx5k/PjxTJs2jfnz5/e63tSpU3F3pkyZQk5ODsePH6eqqorjx49TUlLCyZMnKSws5GMf+1ivWUXXXnstzz77LN/61rfIzc2lubm5e4piSUkJOTk5TJ48mS996UsqejGIaBOsWX0elxAqMRqzXc/NLLerPWOAMWZ2FtDh7h2xuoaMXCwKU2j9g4xQ3ONPF1UyzRLpWt5ZYiZRMQV3bwWuHeD5bYSKYIQffzLW15bUY2Y89thjXH311Tz//PM0NDRQVFREMBgkLy+P1atXM378+O5Ep7m5mZdffpn3vve9nDx5sju5glDn9JIlS6irq2PcuHG89NJL/e6v3B0zo7GxkdOnT1NVVdU93a+5uZnm5uZ+5wxXVW1oaODuu+/mpptuoqqqqnv9VUFBAddddx2vv/46q1atYs+ePVrmMYBo12Ad6PPUATP7LPA8oR3KY+EO4Fs9Hn8a+DZwV4zOLyMUq8IUWv8gI5Gg+KNKpiOgiqCSjhIVU0QGUlJSQkNDA3V1ddTU1NDY2MjDDz/Ml770JVpaWjh48CCFhYV86EMf4vvf/z5nnnkmc+bM4eTJk4Ou25o4cSLu3q/YxVNPPcUZZ5zBeeedx6ZNm3pN92ttbe0ejQoLTx8866yzePzxx3n44Yf7jZrV1taybt068vPzmTp1KqWlpdrmYgDRjmANZDxwbqwa4u53oWQq5cSyMEV4/UNFRQWBQKBXsqb1DzJMMY0/MnyqCCoZRjFF4q5vp9Ttt99OVVUVW7Zs6Vfl78wzz8TMmDZtGpMmTepet9V3BlBLSwstLS3k5OTw/PPPU19f332O3Nxctm3bxrnnnsvixYuZNGlS9/sLCwt7nbPn9MFzzjmHu+++mzPOOIPrrruu1wjX0qVLqa+vZ+nSpZgZZqZlHgOIKsEys1/Se77yWOBy4MF4NEpSR6w35tT6BxmuVIw/2b5NhCqCSjpLxZgimW+wTqnvfOc77Nmzp9++WFVVVeTl5dHU1ERRUREFBQVs2bKlVzW/LVu2YGZceOGFXHnllQDs2rWL7du3M3nyZPbt29cdi9evX99rz6ySkhIKCgqora1lyZIlVFVVMWvWLC6//HJ++tOfMnv2bHJycgYcNSsrK+Odd94BtMxjMNGOYO3u87gdCLj7kzFuj6SYeBSm0PoHGaZRxx8zq6X/njdhT7v74uE0KNu3iRiq46Wurg4z09RBSVW6p5GEitQp9dWvfpXc3Nx++2ItXryYX/3qVxQWFrJ161auu+46NmzYwM6dO5kyZQrBYJCysjLy8vK6NwYGuOiii7jwwgu5//77e3WCL1iwgJkzZ/ZapnHdddexbt06tm/fTl5eHgsWLOAnP/kJ7e3tfPSjH2XDhg0Djpo1NTWxePFiLfOIINo1WN+Od0MkNakwhSRbLOKPKpnGVqSOl5KSEq6//nra2to0dVBSku5pJNEidUqtXbuWmTNn9ounU6dOJTc3l2nTprF371527txJSUkJra2tHDp0iEcffZQ333yTb33rWwPG4okTJ/Lqq692J1iDLdOYNGlS97TADRs2UFhYyKRJk5g6deqAo2abN2/mxIkTbN++naamJi3zGES0UwQ/CfzR3f9kZucBPwFOA19095fj2UBJLhWmkGRLVPxRJdPoRep42bt3L+95z3v49Kc/ramDkpJ0TyOJNlSn1EDx1N3Jy8ujra2Nd955h6Kiou4Oq3//93+nuLiYBx98cNC1WU1NTXR09P7va6BlGgBXXXUVjY2N5OXlsXz5cjZs2IC7s2rVKqqqqti5cyelpaUcPHiQGTNm8Oijj3L06FEt84gg2imCa4BLu77/J0KVdtqA+4Ar49AuGaVYVfdSYQpJAYmKP6pkGqXBOl62bNnC6dOnufrqq2OyZlMkTnRPIwkVqVMqXM1voI7s2bNn8+yzz9LQ0DDguvXc3FxycnL6jTLV1taSk5NDbm7/2/y+yzTcndmzZ/Pyyy8zZcqUfiNXN954I42NjTz99NOUlZXxwgsv6N4vCtEmWOe6e0tXj+5i4DrgFHAkbi2TEYumutdwEjAVppAkS0j8USXT6A3W8TJhwgRmz57NmDG992rVZuKSYnRPIwkVaTbQzJkz+e1vf8u11147YEd2Tk7OoOvW582bR15eHnv37uWPf/wjhYWFtLS0UFBQQG5uLvPmzRuybeG9uZYsWcLhw4cHHbmaOXMmNTU1Sq6iFG2C9bqZzQXmA8+7+wkzGwvop5xioqnu1dzcPOzyyipMIUmk+JOCBptqsmLFCq3ZlFSnmCIJNdRsoOLi4ogd2YN1ipeXlzNr1izy8vLYt28fb7zxBjNmzKCxsREz63VPF6ljvaSkhJdffpkLL7yw38jVM888Q1lZGbt27VJyNQzRJlh3A3WE5ihf3/XcXwI749EoGbloqnutXr1a5ZUlnSj+pKiBpppozaakAcUUSbihZgMN1pE91KykjRs3cv755zN//vzuaoLh+7prr7026o71nJwcampqtCQkRqKtIrjOzKq6vn+r6+nngE/Eq2EytIF6I4Yqq15TUxPTfa1E4k3xJ31ozaakA8UUSZbBkqjBRpeimZUUDAY566yzepVqH2nHupaExE60I1jdQchCvwVDc5WTarAejbvvvjtiWXUg5vtaicSb4k/6iOY/6FgV4REZKcUUiVYs49VA54o0utTU1DRkp/jzzz/PhAkTYtaxPtwkUAYWbZn2qcCPCO10fk6fl8f0f4fEU6QejTvvvJPp06cPOkXnqquuYu3atVojIWlD8Sf9RFqzGU0RHpF4UkyRaMUyXg10rrKyMjo6Opg4ceKAo0tf/epXI3aKv/rqq9x77700NzfHtWNdcXv4coY+BIAAcJLQHOU2oByoBirj1C6JILzOKpxAwbu9EQcOHOC73/0ubW1tBAIBNm7cSCAQoL29nerqahYsWNC9RqKzsxNAayQk1Sn+ZIhw51B+fj6VlZVUVFRQWVlJfn4+FRUVuHuymyjZQTFFhjTceOXu1NXVsX79eurq6nq9Pti5APbs2TPo/VxHR0f3rKSewslTR0cHb7zxBuPHj2fLli297us2b97MlClTuve4GuwcQ3WsK26PTLQJ1qXAje7+R8DdfSdwE/Cf4tYyGdRQ66yOHj3Kc889x6ZNm/j617/Opk2b2L59O8XFxd1rJAZLwDTcKylI8SdDDNU5VF9fn+QWSpZQTJEhDSdeBYNBFi1axIoVK7jnnntYsWIFixYtIhgMRjzXlClTKCoqGvR+Ljc3N2KneG5uLlOnTuX6669n79693HvvvVRVVXHvvfeya9cubrvttlF3rNfX13Pw4EFmz57N008/zbZt2wgGgyxevFhxO4Jo12CdBsLbQR81s3OB/wdMjUurJKJIG9aFeyMiTdHRIkZJM4o/GWKoziGtAZUEUUyRIUUbr6IpRDHQucIjXm+99dag93Pz5s2LWDiosbGRxsZGxo0bx4033kgwGKS1tZVLL72U6upqFi5cOOriQ88//zxvvfUWDz30EHl5eRQVFfHcc88xYcIEpkyZorg9iGgTrOeAFcCjwP8G1gNvAzvi1C6JINKGddFO89O+VpJGFH8yRDSdQyIJoJgiQ4o2Xg21PU59ff2A5woGg5w4cYIJEyZ07z0Vvp8LT+8LF5IYrFO8qKio1/1gaWkpxcXF/e4HR9qx7u788z//M7m5uZSXl7N06dLuNj711FPs2LGDOXPmxPTnnimiTbA+w7vTCf8joWH0AmBtPBolkakUsmQZxZ8MEYvOodFSJSxBMUWiEG28imaka9WqVf3O9cYbbzBlyhSuueYaqqqq2LlzJ6WlpTQ1NdHR0cH3v//97tg0WKf4aO4H3X3I2FdfX09zczNm1p1chT/bFVdcQUNDw7B/rtki2n2wjvb4/m1gTdxaJFHRND/JFoo/mSPZnUOqhCWQ2JhiZoXAz4BlhErBf8PdfzXAcQb8I/CFrqd+BnzdVUEgaaKNV5FGug4fPsypU6eoqqpizZo13HnnnQQCAaZMmcKePXvIyckZcHrfww8/TEdHx2BN6yWa+8GRxr7du3czfvx4xo4dO2ACOWPGDPbs2cPChQuj/bFmDYvmb9fMzgT+K/BJYJK7TzCzZcB57v6jOLdxSAsXLvQdOzSyL5IoZlbn7gmJqIo/mafvKFIiOofcnUsuuYSCgoJevdHbtm2jra2t12abktpGG38SGVPM7GFCo2U3ARcBvwMudfcX+xx3K/BVQpUNHagB7nX3QKTzK/7E31DxarDYUlNTw0svvcSZZ57Zqyz7mjVrqK+vZ82aNYwZM4aLLrqIK664ovt9tbW1vPDCC0yaNIlXXnll1HFpOLGv72d1d5YtW4a785WvfKVfAnnffffx+9//Pqs6+KONP9EmWPcRWvz5j8Dj7n5O1z4ST7j7BaNu7SgpwIgkVoITLMUfGbW6ujo+8pGP9FonAaGbhEAgwKZNm7LqJiGdxSDBSkhMMbNxwJvA+939la7nfgk0uvvtfY59Bljn7g90Pb4JuNnd/0Okayj+pIa+I0SHDx/m5MmTlJeXD5jUPPvss7z//e9n//79uDtnnXVW9/TAgoICPv7xj/OLX/wiJslLtLFvsH26Tp06xcGDB5k/f36/NVjvvPNO1nVORRt/ol2D9VfAXHdvN7NOAHdv7ApIIiLxpPgjo6YKhtJDomLKecDpcHLVZSewZIBjL+h6redxAyZ7ZnYLcAtAWVlZbFoqo9J3mt6pU6f42te+NmCJ90AgQENDA08++SRz585l+vTpXHHFFbS2trJ48WJKS0sBmD59ekziUjSxr7y8fNBKiK2trZSVlfH888/T0NBAUVERLS0tzJ07l02bNmVVcjUc0SZYJ/se21XW9I2Yt0hEpDfFHxk1VTCUHhIVU/KBY32eO0aooMZQxx4D8s3M+q7D6hrlegBCI1ixa66MRs9CFOvXr4+qQ+eRRx5h1apVFBcXdydWENu4FE3sG6oS4u9+9zsAampqAFi2bJk6pIYQ7UbDvwZ+bmazAMysBPgR8L/i1TARkS6KPzJqPSuCjWSzTckoiYopbcD4Ps+NB45Hcex4oE1FLtJTz6Smp76J0/Lly3nPe97D1q1b4xaXool9Q41yhQtZfOMb3+Ab3/iGkqsoRJtg/T2wH3gBOAd4FWgCvh2fZomIdFP8kVELVwRra2sjEAiwceNGAoEA7e3t2t4i+yQqprwC5JrZvB7PfQB4cYBjX+x6bajjJA1E26ETjkvt7e1xi0vRxL5otVnUhAAAGDdJREFUE0KJXlRFLnq9ITSMfiSVelW0yFMksRJZ5KLPdRV/ZFSSUcFQYiuW8SfeMcXM/hehqoBfIFRFcBMDVxGsBP4W+DDvVhH8Z1URTF+DlUavrq6muLi417E949KcOXMws5jv1Rcp9g1WaXDr1q20t7dnXSGLSGJSRdDMhlw96e4Hh9m2mFOAEUmsRCRYij8iMpCRxp9kxJSufbD+FbiK0Bqv2939V2Z2GaEKhvldxxlwD+/ug/VTotgHS/EntQ23QyeclO3bt4/i4mKam5uZNWtWQvbqG05CmM1ilWB1EupJARgodXV3HzOyJsaOAoxIYiUowVL8EZF+RpFgpUVMGQ7Fn8zh7pSXl1NQUNBrX6ynnnqKtrY26urq4j6KpBH+oUUbf4Zag7WL0NzkO4AZQF6frzNG2U4gtOmfmf3MzA6Y2XEzazCzq2NxbhFJWwmJPyKSNRRTJGXV1dWxZ8+e7uQKQkUmrrjiCl599VUSkUiHKyFef/31Sq5GKWKC5e4XAdcBhcAfCM0d/gRwhrufdvfTMWpHLnCI0N4QE4A7gSozmxmj84tImklg/BGRLKCYIiPh7tTV1bF+/Xrq6uqI1xLgmpoaioqKBqzkV1xczMc+9jGCwWBcri2xN2QVQXf/v+7+n4FZwA+BjwJBM4tZTVt3b3f3u9x9v7t3uvu/AfsApc8iWSwR8UdEsodiigxHMBhk0aJFrFixgnvuuYcVK1awaNGiuCU6LS0tA1byO3LkCOeeey4VFRVxS/AktqIt0w4wj9AI018ADcCbcWkRYGZFhHZAH7REqZndYmY7zGzH66+/Hq+miEhqSFj8EZGsoJgiEbk7K1euJD8/n8rKSioqKqisrCQ/Pz/miY67M23aNE6dOkVtbW2v0u61tbUUFBTwkY98hAMHDlBfXx+z60r85EZ6sav6zSeBzxLaefyXwOXxrNxlZnnAQ8DP3f3lwY7TTuYimS2R8cfMzgTuI1QiuRDYDfy9uz8e62uJSHIk455G0ld9fT2HDh3i1ltv7bUm6rLLLiMQCFBfXx+TdUrh6n379+8nNzeXhoYG6uvrKSsro6mpiYKCAlatWsWYMWOYOnUqu3fv1vqoNBAxwSK08d4+QkHo2a7n5ppZ945j7r55qIuYWS2hnqKBPO3ui7uOy+m61kngtqHOKyIZLSbxJ0o914EeBFYQWgc63933x+gaIpJciYwpkuZ2795NaWnpgGuihpvo9K3OF97bKjxKVlBQwOrVq2lvb2fdunW0t7fzvve9j8WLF1NaWgqERrN2797NOeecE/PPKrE3VILVDJwF3Nz11ZcDs4e6iLsvHeqYrj0gfgYUASvc/dRQ7xGRjBaT+BMNd28H7urx1L+ZWXgd6P5YXENEki5hMUXS39y5c2lsbKSzs7NXktXZ2UljYyNz586N8O53Dba/1MaNG2lqauo1Spafn8/ZZ59NZ2cnr732GhdccEH3NWtra8nNzeWOO+5g2bJl2vg3xUVMsNx9ZoLaAXA/8D7gw+7+dgKvKyIpKMHxp5do1oGKSHpJZkyR9FNeXk5ZWRnbtm3jsssu696XauvWrcyYMYPy8qHrovQcoaqsrOw+x7Zt26ioqODzn/88EyZM6E7ggsEg7e3tXH311TzyyCO88MILlJaWdk8V/PznP8+DDz4Ys+mJEj9DjWAlhJnNAG4FTgDNPbLyW939oaQ1TESyTjTrQM3sFuAWgLKysgS2TkREEsHMqK6upqKigkAg0Gv0qbq6OqoRpEjruO6//35+8IMfcOTIke5RstbWVkpKSjh58iSzZs3isssuo7W1tddUQa3DSg8pkWC5+wEG3lVdRGTUYr0OVEV2REQyX0lJCc8991yv9VPDSWwireMqLCzk9ddfZ/z48WzZsoUlS5ZQWFhIU1MTl156KcFgkOLi4u7ECoY/PVGSJyUSLBGReNI6UBERGQkzY8GCBSMaMYq0jisYDDJz5kyuuuoqqqqq2LlzJyUlJbzzzjv86U9/Ij8/vzvxGsn0REkuJVgiIiFaByoiIjETaR3XtGnTaG5uZty4cdx4440Eg0FaW1u5+OKLefTRRzn77LNpaGigrq6O0tJS3nzzTWbOnBn19ERJLiVYCTBYeU4RSQ3xXgeqGCAikn0ireN68sknWblyZXfyVVpaSnFxMVu3buWCCy7g/vvvZ/fu3XR0dJCXlzfs6YmSXEqw4ixSec6SkpJkN09EiO86UMUAEZHsFWkd12DJ12OPPUZxcTELFy5McutlpMw9/ddnL1y40Hfs2JHsZvTj7lxyySUUFBT0Ghretm0bbW1tPPfcc+rFlrRkZnXurshP5PijGCASe4o/70rV+x+JXt8ZDhqlSm3Rxp+coQ6QkQuX5wzfWMG75TkPHDhAfX19klsoIvGkGCAiktncnbq6OtavX09dXR3DGbgYaPq4ZAZNEYyjSOU5tY+BSOZTDBARyVyjmQKu6eOZTQlWHEUqz6l9DEQyn2KASPYys0JCWz8sA44A33D3Xw1y7F3ANwkV2gm70N33xrudMjLuzsqVKykoKKCysrLXFPCKioqIU8BH815JD5oiGEc9y3N2dnYCaB8DkSyiGCCS1X5MaNPyIuBTwP1mdkGE49e7e36PLyVXKWw0U8A1fTzzKcGKo3B5zra2NgKBABs3biQQCNDe3q59DESygGKASHYys3HAx4A73b3N3f8AVAOfSW7LJFaimQIej/dKesiaKYLJ2ocmUnlOEcl8yY4B2oNLJCnOA067+ys9ntsJLInwnmvMrBUIAj9y9/vj2UAZndFMAdf08cyXFQlWshcSmhkLFixQYiWSpZIVA5Id+0SyWD5wrM9zx4CCQY6vAh4AWoBFwG/M7Ki7P9z3QDO7BbgFoKysLGYNluHpOQW85zYc0UwBH817JT1k/D5Y2odGJPa0D827UnUfGsU+yVSpEH/MrJbBR6OeBr4MPO3uY3u85z8BS939mijOfzvwQXf/WKTjUjX+ZIvBOrGqq6spLi6O23sleaKNPxk/ghVeSHjrrbf2W0gYCASor6/XyJKIZBzFPpH4cfelkV7vWoOVa2bz3P3Vrqc/ALwY7SUA9YCkuNFMAU/29HGJr4xPsLQPjYhkI8U+keRx93YzewT4jpl9AbgIqAAuHeh4M6sAtgJHgQ8CXwH+PkHNlVEYzRRwLSHJXBlfRbDnQsKetJBQRDKZYp9I0n0ROBt4DXgYWO3uLwKY2WVm1tbj2E8Au4HjwC+Ae9z95wlur4jESMYnWNqHRkSykWKfSHK5e6u7X+vu49y9rOcmw+6+zd3zezz+pLtP6tr/6r3ufm9yWi0isZDxUwTD+9BUVFQQCAT6LSTUIm8RyUSKfSIiIsmR8QkWaCGhiGQnxT4REZHEy4oEC7SQUESyk2KfiMi7tPm6JELWJFgiIiIikjiplsxo83VJFCVYIiIiIhJTqZbMuDsrV66koKCAysrKXpuvV1RUaPN1iamMryIoIiIiIokTTmby8/OprKykoqKCyspK8vPzqaiowN0T3qbw5uuXXXZZv83XDxw4QH19fcLbJJlLCZaIiIiIxEwqJjPRbL4uEitKsEREREQkZlIxmRnp5uvuTl1dHevXr6eurm5Uo2+xPJekNq3BEhEREZGY6ZnM9Eyyhkpm4qnn5uvhkbWhNl+P5TqyVFuTJvFlqZI9m9mDwF8C44Bm4Hvu/tNo3rtw4ULfsWNHPJsnIj2YWZ27L0x2O1KB4o9IYin+vCtV44+7c8kll1BQUNAvmWlvb09aQYnBkpzq6mqKi4uj+gzbtm2jra1tWJ8hlueS5Io2/qTSFMF/AGa6+3hgJbDGzLRxi4iIiEgaMTOqq6tpa2sjEAiwceNGAoEA7e3tVFdXJy2ZCG++vmnTJr7+9a+zadMmtm/f3i+5gtiuI0vFNWkSXykzRdDdX+z5sOtrDlCXnBaJSDYZzSi6iIj0Fk5meu6DlQobnke7+Xo068ii/TyxPJekh5RJsADM7D7gc8DZQAOwKcKxtwC3AJSVlSWieSKS2f4BuMndT5jZe4FaM2twd3XyiIiMQLTJTCqK5TqyVFyTJvGVSlMEcfcvAgXAZcAjwIkIxz7g7gvdfeG5556bqCaKSIZy9xfdPRxzeo6ii4hIlulZFCNceXCoohiJOJekh4QkWGZWa2Y+yNcfeh7r7qfd/Q/ANGB1ItonIgKhUXQzewt4GQgSYRRdRERST6xKocdyHVmqrkmT+EnIFEF3XzqCt+Wi3mMRSSB3/6KZfRn4C2Apg4yia4qyiEjqiXUp9FiuI0vVNWkSHylRpt3MpgBXAv8GvA18mNAUwRvcfeNQ70/VMqUimSrdyiSbWS2wZJCXn3b3xQO8JwC85O73Rjq34o9IYqVb/IknxZ93qRS6JEK6lWl3QtMBDwNvAj8A/mM0yZWIyFDcfam72yBf/ZKrLhpFFxFJEyqFLqkkJRIsd3/d3Ze4+znuPt7d57v7T5LdLhHJDmY2xcw+YWb5ZjbGzJYDnwQ2J7ttIpJ+zOw2M9thZifMbF0Ux/+dmTWb2TEz+1czOzNWbYnVmqRUF00pdJFESaky7SIiSRIeRQ8Q6ng6gEbRRWTkmoA1wHJCW88MqqtD53ZCSyWagEeBb3c9NyqxXpOUylQKXVKJEiwRyXru/jqDr9ESERkWd38EwMwWEqqKHMlngZ+5+4td77kbeIhRJljuzsqVKykoKKCysrLXmqSKioqMW5PUsxR6zzVYKoUuyZASUwRFREREstQFwM4ej3cCRWY2aaCDzeyWrumHO15//fVBT5pta5JUCl1SiUawRERERJInHzjW43H4+wLgjb4Hu/sDwAMQqiI42EmjWZOUaWXCVQpdUoUSLBEREZEojWTbhyG0AeN7PA5/f3yY5+klW9ckmRkLFixQYiVJpSmCIiIiIlEa4bYPkbwIfKDH4w8ALe7eb/RqOHquSers7ATQmiSRBNEIloiIiEgMmVkuoXusMcAYMzsL6HD3jgEO/wWwzsweAoLAHcC6GLSB6upqKioqCAQCvaoIak2SSHwpwRIRERGJrTuAb/V4/GlCpdfvMrMy4CXgfHc/6O6/N7PvAU8RKun+mz7vHTGtSRJJDiVYIiIiIjHk7ncBdw3y2kFChS16PvdD4IfxaEuqrUly914JX3l5uUbTJOMowUoSBRgRSRbFHxFJhmza+FiymxKsJFCAEZFkUfwRkWTIto2PJbupimCChQNMfn4+lZWVVFRUUFlZSX5+PhUVFbgPuqWFiMioKP6ISLJk28bHkt2UYCWYAoyIJIvij4gkSzQbH4tkCiVYCaYAIyLJovgjIsnSc+PjnjJ942PJTkqwEkwBRkSSRfFHRJJFGx9LNlGClWAKMCKSLIo/IpIs4Y2P29raCAQCbNy4kUAgQHt7uzY+loyjKoIJpp3VRSRZFH9EJJm08bFkCyVYSaAAIyLJovgjIsmUahsfi8SDEqwkUYARkWRR/BEREYkfrcESERERERGJESVYIiIiIiIiMaIES0REREREJEaUYImIiIiIiMSIuXuy2zBqZvY6cCCGp5wMHInh+VKNPl96S4XPN8Pdz01yG1JCHOIPpMbvOF4y+bOBPl8iKP50UfwZtkz+bKDPlwhRxZ+MSLBizcx2uPvCZLcjXvT50lumfz7J7N9xJn820OeT9JfJv+NM/mygz5dKNEVQREREREQkRpRgiYiIiIiIxIgSrIE9kOwGxJk+X3rL9M8nmf07zuTPBvp8kv4y+XecyZ8N9PlShtZgiYiIiIiIxIhGsERERERERGJECZaIiIiIiEiMKMESERERERGJESVYgzCzM83sZ2Z2wMyOm1mDmV2d7HbFkpndZmY7zOyEma1LdntGy8wKzexRM2vv+r3dkOw2xUqm/a4kMsWf9KP4I5lC8Sf9KP6kntxkNyCF5QKHgCXAQWAFUGVm8919fzIbFkNNwBpgOXB2ktsSCz8GTgJFwEXA78xsp7u/mNxmxUSm/a4kMsWf9KP4I5lC8Sf9KP6kGFURHAYz2wV8291/k+y2xJKZrQGmufvnkt2WkTKzccCbwPvd/ZWu534JNLr77UltXAxlwu9KRkbxJ3Up/kimU/xJXYo/qUlTBKNkZkXAeUAm9AZkovOA0+Hg0mUncEGS2iMSM4o/KU/xRzKW4k/KU/xJQUqwomBmecBDwM/d/eVkt0cGlA8c6/PcMaAgCW0RiRnFn7Sg+CMZSfEnLSj+pKCsTbDMrNbMfJCvP/Q4Lgf4JaG5rbclrcHDFO3nyyBtwPg+z40HjiehLSIRKf5kHMUfSRuKPxlH8ScFZW2RC3dfOtQxZmbAzwgtGlzh7qfi3a5YiebzZZhXgFwzm+fur3Y99wE0pUFSkOJPxlH8kbSh+JNxFH9SUNaOYEXpfuB9wDXu/nayGxNrZpZrZmcBY4AxZnaWmaVl0u3u7cAjwHfMbJyZfQioINT7lvYy6XclUVP8SROKP5KBFH/ShOJPalKCNQgzmwHcSqjcZbOZtXV9fSrJTYulO4C3gduBT3d9f0dSWzQ6XyRUwvM14GFgdYaUKIXM+11JBIo/aUnxRzKC4k9aUvxJMSrTLiIiIiIiEiMawRIREREREYkRJVgiIiIiIiIxogRLREREREQkRpRgiYiIiIiIxIgSLBERERERkRhRgiUiIiIiIhIjSrBk2Mxsppl5eKM3M3vczD6bgOveZWYPxvs6IpK6FH9EJFkUfyRaSrAylJntN7O3uzYHbDGz/2lm+fG4lrtf7e4/j7JNH45HG8xsqZkdjvD6pWa22cyOm9kxM3vMzM7v8/7Orp/XcTP7s5l9Ph5tFcl0ij/9Xlf8EUkQxZ9+ryv+JIESrMx2jbvnA+XABxlg52sLyeh/B2b2F8ATwEagFJgF7ASeNrPZPQ5t6vp5jQf+DviJmb0n0e0VyRCKPyj+iCSJ4g+KP8mU0f+wJMTdG4HHgfcDmFmtmX3XzJ4G3gJmm9kEM/uZmQXNrNHM1pjZmK7jx5jZD8zsiJntBT7S8/xd5/tCj8c3m9mfunpCXjKzcjP7JVAGPNbVS/Jfuo79D2b2jJkdNbOdZra0x3lmmdmWrvPUAJNH+CP4HvALd/8f7n7c3Vvd/Q7gWeCuAX5e7u6bgFbgwhFeU0RQ/EHxRyRpFH8Uf5JFCVYWMLPpwAqgocfTnwFuAQqAA8DPgQ5gLnAxsAwIB42bgY92Pb8QuC7CtT5O6I/2bwj1hKwE3nD3zwAH6epVcvfvmdlU4HfAGqAQ+BrwGzM7t+t0vwLqCAWWu4Fhz3M2s7HApcCvB3i5CrhqgPfkmNnKruvuHu41ReRdij+KPyLJovij+JMsuclugMTVb82sAzhG6A/5v/V4bZ27vwhgZkXA1cA57v420G5m/51QAPoXYBWw1t0PdR3/D8DSQa75BeB77v581+NIf6CfBjZ19ZYA1JjZDmCFmT1FaFj/w+5+AthqZo8N47OHFRLqSAgO8FqQ3r1CpWZ2FDib0N/GV929YYD3icjQFH8Uf0SSRfFH8SeplGBltmvd/clBXjvU4/sZQB4QNLPwczk9jintc/yBCNecDuyJsn0zgI+b2TU9nssDnuq65pvu3t7nutOjPHfYm0AnUAK83Oe1EuBIj8dN7j7NzM4E/hG4Elg7zOuJSIjij+KPSLIo/ij+JJUSrOzlPb4/BJwAJrt7xwDHBun9h10W4byHgDlRXDN87C/d/ea+B5rZDGCimY3rEWTKBjhHRO7ebmb/B/g4ocDV0yrg3wd4zwkz+zrwZzO71t1/O5xrisiQFH8Uf0SSRfFH8SfutAZLcPcgoSoz/2Rm47vm4M4xsyVdh1QBXzGzaWY2Ebg9wul+CnzNzBZYyNyuYAHQAvSsWvMgcI2ZLe9aSHqWhcqFTnP3A8AO4NtmdoaZLQauYQhd5+j5ZV3t/ayZfcXMCsxsopmtAf4C+PYgP5OTwD8B/3Woa4rIyCn+DPgzUfwRSQDFnwF/Joo/MaAES8L+BjgDeInQsPIGQkPIAD8B/jeh0p71wCODncTdfw18l9ACzePAbwnNAwb4B+AOC1XM+VrXnOYK4O+B1wn16Pxn3v13eQOwiFA1m28BvxjiM0wF3u7zNcfd/wAsB/6aUG/UAUILVhe7+6sRzvevQFmfIXwRiT3Fn/4Uf0QSQ/GnP8WfUTL3YY04ioiIiIiIyCA0giUiIiIiIhIjSrBERERERERiRAmWiIiIiIhIjCjBEhERERERiRElWCIiIiIiIjGiBEtERERERCRGlGCJiIiIiIjEiBIsERERERGRGPn/Av2QEgmenmwAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Compare predictions vs. measurements, all variants, 0 to 205\n", + "\n", + "from scipy.stats import spearmanr\n", + "\n", + "save_figs = True\n", + "fig_name = \"all_vars_predicted_vs_measured_lor_0_205\"\n", + "\n", + "#HEK293 measurements\n", + "hek_min_c = 50.\n", + "\n", + "hek_min_ref_prox_c = 5.\n", + "hek_min_var_prox_c = 1.\n", + "\n", + "hek_filtered_df = hek_df.query(\"ref_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hek_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hek_min_var_prox_c))\n", + "\n", + "hek_true = np.array(hek_filtered_df['delta_logodds_true_0_205_repl_pooled'].values)\n", + "hek_pred = np.array(hek_filtered_df['delta_logodds_0_205'].values)\n", + "\n", + "#SK-N-SH measurements\n", + "sknsh_min_c = 50.\n", + "\n", + "sknsh_min_ref_prox_c = 5.\n", + "sknsh_min_var_prox_c = 1.\n", + "\n", + "sknsh_filtered_df = sknsh_df.query(\"ref_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(sknsh_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(sknsh_min_var_prox_c))\n", + "\n", + "sknsh_true = np.array(sknsh_filtered_df['delta_logodds_true_0_205_repl_pooled'].values)\n", + "sknsh_pred = np.array(sknsh_filtered_df['delta_logodds_0_205'].values)\n", + "\n", + "#HMC3 measurements\n", + "hmc3_min_c = 50.\n", + "\n", + "hmc3_min_ref_prox_c = 5.\n", + "hmc3_min_var_prox_c = 1.\n", + "\n", + "hmc3_filtered_df = hmc3_df.query(\"ref_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hmc3_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hmc3_min_var_prox_c))\n", + "\n", + "hmc3_true = np.array(hmc3_filtered_df['delta_logodds_true_0_205_repl_pooled'].values)\n", + "hmc3_pred = np.array(hmc3_filtered_df['delta_logodds_0_205'].values)\n", + "\n", + "r_val_hek, _ = spearmanr(hek_pred, hek_true)\n", + "r_val_sknsh, _ = spearmanr(sknsh_pred, sknsh_true)\n", + "r_val_hmc3, _ = spearmanr(hmc3_pred, hmc3_true)\n", + "\n", + "f, ax = plt.subplots(1, 3, figsize=(12, 4))\n", + "\n", + "#Plot HEK293 measurements\n", + "plt.sca(ax[0])\n", + "\n", + "plt.scatter(hek_pred, hek_true, color='gray', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"HEK293, r = \" + str(round(r_val_hek, 3)) + \", n = \" + str(hek_pred.shape[0]), fontsize=12)\n", + "\n", + "#Plot SK-N-SH measurements\n", + "plt.sca(ax[1])\n", + "\n", + "plt.scatter(sknsh_pred, sknsh_true, color='gray', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"SK-N-SH, r = \" + str(round(r_val_sknsh, 3)) + \", n = \" + str(sknsh_pred.shape[0]), fontsize=12)\n", + "\n", + "#Plot HMC3 measurements\n", + "plt.sca(ax[2])\n", + "\n", + "plt.scatter(hmc3_pred, hmc3_true, color='gray', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"HMC3, r = \" + str(round(r_val_hmc3, 3)) + \", n = \" + str(hmc3_pred.shape[0]), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Compare predictions vs. measurements, all variants, 77 to 127\n", + "\n", + "from scipy.stats import spearmanr\n", + "\n", + "save_figs = True\n", + "fig_name = \"all_vars_predicted_vs_measured_lor_77_127\"\n", + "\n", + "#HEK293 measurements\n", + "hek_min_c = 50.\n", + "\n", + "hek_min_ref_prox_c = 5.\n", + "hek_min_var_prox_c = 1.\n", + "\n", + "hek_filtered_df = hek_df.query(\"ref_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hek_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hek_min_var_prox_c))\n", + "\n", + "hek_true = np.array(hek_filtered_df['delta_logodds_true_77_127_repl_pooled'].values)\n", + "hek_pred = np.array(hek_filtered_df['delta_logodds_77_127'].values)\n", + "\n", + "#SK-N-SH measurements\n", + "sknsh_min_c = 50.\n", + "\n", + "sknsh_min_ref_prox_c = 5.\n", + "sknsh_min_var_prox_c = 1.\n", + "\n", + "sknsh_filtered_df = sknsh_df.query(\"ref_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(sknsh_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(sknsh_min_var_prox_c))\n", + "\n", + "sknsh_true = np.array(sknsh_filtered_df['delta_logodds_true_77_127_repl_pooled'].values)\n", + "sknsh_pred = np.array(sknsh_filtered_df['delta_logodds_77_127'].values)\n", + "\n", + "#HMC3 measurements\n", + "hmc3_min_c = 50.\n", + "\n", + "hmc3_min_ref_prox_c = 5.\n", + "hmc3_min_var_prox_c = 1.\n", + "\n", + "hmc3_filtered_df = hmc3_df.query(\"ref_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hmc3_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hmc3_min_var_prox_c))\n", + "\n", + "hmc3_true = np.array(hmc3_filtered_df['delta_logodds_true_77_127_repl_pooled'].values)\n", + "hmc3_pred = np.array(hmc3_filtered_df['delta_logodds_77_127'].values)\n", + "\n", + "r_val_hek, _ = spearmanr(hek_pred, hek_true)\n", + "r_val_sknsh, _ = spearmanr(sknsh_pred, sknsh_true)\n", + "r_val_hmc3, _ = spearmanr(hmc3_pred, hmc3_true)\n", + "\n", + "f, ax = plt.subplots(1, 3, figsize=(12, 4))\n", + "\n", + "#Plot HEK293 measurements\n", + "plt.sca(ax[0])\n", + "\n", + "plt.scatter(hek_pred, hek_true, color='gray', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"HEK293, r = \" + str(round(r_val_hek, 3)) + \", n = \" + str(hek_pred.shape[0]), fontsize=12)\n", + "\n", + "#Plot SK-N-SH measurements\n", + "plt.sca(ax[1])\n", + "\n", + "plt.scatter(sknsh_pred, sknsh_true, color='gray', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"SK-N-SH, r = \" + str(round(r_val_sknsh, 3)) + \", n = \" + str(sknsh_pred.shape[0]), fontsize=12)\n", + "\n", + "#Plot HMC3 measurements\n", + "plt.sca(ax[2])\n", + "\n", + "plt.scatter(hmc3_pred, hmc3_true, color='gray', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"HMC3, r = \" + str(round(r_val_hmc3, 3)) + \", n = \" + str(hmc3_pred.shape[0]), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAARgAAAEYCAYAAACHjumMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzsvXeUHFed9/25VZ3DdE9Pz4w0qScoZ8tKlm1ky3JiHeBFLLAHcHjAy7L4ZZ8FzC5rFhY4D7uwy/PsWcKz8Jq1jY0JDmDM2sZGjkiWlaysUZjR9OTU3dM5VNV9/xhrrDwjaUJLqs85c466qrrrd0fT37r3/pKQUmJiYmIyEShTbYCJicmliykwJiYmE4YpMCYmJhOGKTAmJiYThikwJiYmE4YpMCYmJhOGKTAmJiYThikwJiYmE4YpMCYmJhOGZaoNGA+CwaCsr6+fajNMTC4btm3bNiClLB/tuktCYOrr69m6detUm2FictkghGgby3XmEsnExGTCMAXGxMRkwjAFxsTEZMIwBcbExGTCuCQ2ec9EoVCgo6ODbDY71aZc8jgcDmpqarBarVNtikkRcUkLTEdHB16vl/r6eoQQU23OJYuUksHBQTo6OmhoaJhqc0yKiEt6iZTNZikrKzPFZYIRQlBWVmbOFE1O4ZIWGMAUl0nC/D2bnI5LeolkYnI5k81maWtrI5VK4Xa7CYVCOByOSbXBFBgTk0uQrq4uNryxgXAsjCY0LNJCnb+OtdeupaqqatLsuOSXSMVKfX09L7/88gnHHn74Ya655pqR806nE4/HM/Lzuc997pTrAOLxOFdffTUf+tCHKBQKfPe732XBggV4vV4aGhr47ne/e8J9Nm7cyIoVK/B6vSxatIg333xz5Nwrr7zCwoUL8fv9lJWV8cEPfpDOzs6J+jWYTADZbJYNb2ygJd1C7dJa5l0zj9qltbSkW9jwxoZJ3SszBaaI+d3vfkcymRz5+f73v3/KNdFolHXr1hEKhfjlL3+J1WpFSsmjjz5KNBrlhRde4Pvf/z6/+MUvAIhEItxxxx186UtfIhaL8cADD3D77bcTjUYBmDdvHi+++CKxWIyuri5mzpzJX/3VX03quE0ujLa2NsKxMA0LGnC6nQA43U4aFjQQjoVpaxtTGtG4YArMGchmszQ3N7N9+3aam5uL0kMyMDDA2rVrmT9/Po899hgWy/CK94EHHmDp0qVYLBZmz57NnXfeyZ/+9CdgePZSWVnJhz/8YVRV5eMf/zjl5eU8/fTTAFRWVp4whVZVlcOHD0/+4EzOm1QqhSa0EXE5htPtpECBVCo1abaYezCnoauri80bNqCHw9g1jZzFwr66Olaundz169mIRCKsWbOGa6+9lh/96Edn9OJIKXnjjTf4y7/8y5HXJzfbk1KyZ8+ekdfhcJhFixYRj8dRVZWf/OQnEzcQk3HH7XZjkRYyqcwJIpNJZbBixe12T5ot5gzmJLLZLJs3bMDX0sLNtbXcPm8eN9fW4mtpYfOG8V2/fuADH8Dv94/8fPaznz3r+eO/6O3t7Rw8eJB77rnnrC7ir3/96xiGwT333APA6tWr6erq4oknnqBQKPDII49w5MgR0un0yHvq6uqIxWIMDAzwrW99izlz5ozbmE0mnlAoRJ2/jtY9rWRSGWBYXFr3tFLnryMUCk2aLabAnERbWxt6OMzyhga8zmH19zqdLG9oQA+P7/r1N7/5DbFYbOTnhz/84VnPf/rTnx45t3jxYv71X/+VW2+9lR07dpz287///e/z6KOP8vvf/x673Q5AWVkZv/3tb/ne975HZWUlL7zwAuvWraOmpuaU9wcCAe666y7uvPNONE0bt3GbTCwOh4O1166lxlrD9he389KvXmL7i9upsdaw9tq1k+qqNpdIJ5FKpbBr2oi4HMPrdGIrTO76dTQ+//nPk8vluPHGG3n11VdZsGDByLmf/vSn/PM//zOvv/76KeKxZs0atmzZAoCmaTQ1NfGFL3zhtPfQNI2+vj7i8TiBQGDiBmMy/uTdMFiPyEhwCqiavKXRMcwZzEm43W5yFguJTOaE44lMhrx1ctevY+GBBx7g85//POvWraO5uRmAxx9/nK985Su89NJLNDY2nvKeHTt2UCgUiMfjfPGLX6Smpoabb74ZgKeffprm5mYMw6C/v5+//du/5YorrjDF5SIim82yYcNmOjrKWbr0Xtat+xuWLr2Xjo5yNmzYfPm6qYUQdiHEQ0KINiFEQgixQwhx62TaEAqFUOvq2NLaOiIyiUyGLa2tqHWTu369/fbbT4iD+eAHP3ja67761a/yqU99ihtuuIEjR47w4IMPMjg4yPLly0fe+5nPfGbk+u985zsEg0Fqa2vp7u7mmWeeGTnX2dnJLbfcgtfrZeHChSiKcsJ5k+Knra2NcFinoWE5TqcXAKfTS0PDcsJhfVLd1OJkj8JUIoRwA18CHgbCwPuBJ4CFUsqjZ3rfsmXL5Olq8u7fv5+5c+eesx3He5FshQJ5qxW1yLxIxcj5/r5Nxpft27fz3HOdzJt3+ynn9u59lttvr2Hp0qUXdA8hxDYp5bLRriuqPRgpZQr4+nGHnhNCtAJXAkcny46qqipuXb9+yvM4TEzOB7fbjcWSI5NJjMxgADKZBFZrflKX+UUlMCcjhKgEZgF7J/veDoeD2bNnT/ZtTUwumFAoRF3dPlpatowskzKZBK2tW2hsVCd1mV+0AiOEsAKPA49IKQ+c5vx9wH0wHLdhYmIyjMPhYO3alcBmwuEXKRRsWK15GhtV1q5dabqphRAK8DMgD3zudNdIKX8M/BiG92AmzzoTk+KnqqqK9etvnfJlftEJjBgOS30IqATeL6UsTLFJJpchxVBL5VKg6AQG+BEwF1gnpcyMdrGJyXjT1dXFhg2bCYd1NM2OxZKjrm4fa9euvGi8iMWST1dUAiOECAF/CeSAnuNybP5SSvn4lBlmctlwLEitpcV3wgZpS8sWYDPr199a9DOZ4/PpjqW8JDIZtrS0sBm4df16HA4HsViMTZs2EYlECAQCXHXVVfj9/nG1pagERkrZBpjFXU2mjLMHqb1IW1vbpHoXz2epdrZ8uhffzadLpVL86P/7Kfs62slJA7tQmPe73/NXn7r3gmNkjqeoBMbEZKpJpVJomv2E+BEYFplCwTapuWjnu1QbLZ+uu7ubh372ODs625le0UC5zUUqn2ZTy2GyP/gR//Fv3x23mUxRpQpcbrz55pusXr0an89HIBDg6quvZsuWLaOWxDyZl19+GSEEn//85084vmrVKh577LEz3v+ZZ55h8eLFlJSUEAwGWbduHeFwGIAHH3yQu++++4TrNU1DCMHRo0fPf9BFzvFBascz2UFqxy/VamtvZt6826mtvZmWFt+o+USj5dPt27ePXUcOEQqGmFM+jaayAHPKpxEKhth15BCvv/76uI3DFJgpIh6Pc9ttt3H//fcTiUTo7Ozka1/72khZhWOcriTm6fB6vfz0pz+lvb19TPdvbm7mnnvu4d///d8ZGhqitbWVz3zmMyjK5f0nMRykptLaumVEZI4FqdXVTV6Q2oXkE42WTxePx9HzeRorq7C9WwXRZrHQWFmFns9z8ODBcRuHuUQ6AxPtpjz2n/ixj30MAKfTyU033QQM55LAcEnMG2+8kSVLlvDQQw+d9csfCAS49dZb+cY3vjGmCnQ7duxgxowZXHfddcCwQK1fv/5ChnRJUCxBamNZqp3pb9ThcLBy7Vo2Ay8en0/X2MjKtWvpeOopLJpOPp/GZikZ+ex8Po1F0095yF0IpsCchslwU86aNQtVVbnrrrv46Ec/yqpVqygtLR05P9aSmMfz4IMPMmfOHL785S8zY8aMs1575ZVXsnv3br7whS9w2223sWLFiqIrRTFVFEOQ2mj5RMlkkid/++QZ25KcLZ9u1apV/O4Xv2L/wZ3MnbUYj6uEZDrO/oM7qbDaWLVq1biN4/KeD5+GC1n7ngslJSW8+eabCCH49Kc/TXl5OXfccQe9vb3A2EtiHk91dTWf/vSn+drXvjbqtTNnzuSVV14hHA7z4Q9/mLKyMu69994TSmf+/Oc/P6FkZzAYPL/BXoQcy0VbunQps2fPnnTX9NmWatOm6RwOHx61LcmZxrBw4UJuvvVmfPEEh3ZtZtu2Vzi0azO+eIKbb72ZhQsXjts4TIE5icmspTF37lwefvhhOjo62LNnD11dXfzN3/wNcOaSmC0tLSM1Xk630//3f//3PPfccycU8QaYPXv2yPs2bdoEDNfn/fWvf83AwACvv/46GzZs4Nvf/vbIe/7iL/7ihJKdAwMD4zZ2k7NzbKnW2DhEe/uL7N37LO3tL9LYOMSMGdPpSfWcd1sSh8PBx+69lz+/+5Osqg9xpc/HqvoQf373J/nYvfeOq5iaS6STmCo35Zw5c7j77rv5z//8z5HqcqcridnY2EgymTzj55SXl3P//ffzj//4jyccP1bt7kysWLGCD3zgA6cIk8nUcaal2r59+y64LUlVVRUfvusu2q67bkKXgabAnMRk1dI4cOAAv//97/nIRz5CTU0N7e3tPPHEE6esfx944AFyuRzr1q3jtddeG1OQ1xe/+EUaGxvPurR67bXXOHToEHfccQcVFRXs37+f3/3ud9x3330XPLbLmXNxDozl2tOVDRmvtiSTUZLEFJiTmKxaGl6vl82bN/O9732PWCyG3+/ntttu47vf/e5IE7RjfPWrXyWXy3HDDTfw2muv0dTUdNbP9vv9fPGLX+Qf/uEfznhNaWkpzzzzDF/5yldIp9OUl5fz0Y9+9IzFvy8XLsR7eC75PxfSO/pYW5KWPS0jy6RjbUka/Y2TWu9lNIqqZOb5MhElM495kY65Kevq1Isq2W0quNhLZl7Ilz6bzfL8k0+emv/T2spQY+NI/s+xa5/87ZO0pE8jEK5G1t+5flRRa2lp4clnnyQcDSNsgqAvSFN506Q1t78oS2YWC8XgpjSZXI5vGN+w9L0vfcueFniDUb/0Y8n/ObYcGekdvfQ0m7Tbw6PmO3V1dbFxy0YylgyKqqCndVwuF6uXry66B6ApMGfALJl5eXGhX/oz5f9YVZXO9nZan32WpqYmZsyYcUG9o48XwsaVjcx3zx+Z/WzcspGqqqqiehCaAmNiwoU3jD8+/+eYyHRFIjy+6Q2ePrwDou/gPuQmYA0wq3wWmls7r03aCxXCycaMgzEx4UTPzPGM1TNzcv5PNp/nNzve5tm2rch5DpasX8Lc2+aiNWrsie5hsH2Qg+8cPOfe0RcqhJONOYMxMeHCPTMn5//0dXfz32370Wu8zL12Pq4SFwDVM6vp0XpgELwpL+3b2ylQwIqVRn/jqL2jx8tFPVmYAmNiwnsN43kDwtvD5/SlP8bx+T9bt27FbfThqNQJVLzXdtfmsCEcAsWlcO3KawkEAufkSLiYXNRgCoyJyQhVVVWsv/PCGu4d7xzYengrHYUO8uk8ik0hHo+TSWaI98eZZp1GIBA45/2SY0KY35Bn+4vbSWtpXBYXC+sXjlkIJxNTYExMjmO8vIehUIiFjQtpe6uNw1sPo3sEibQk1hVF6ZHU1hlnrO0zJvJutN5qhvoHSSga5crQpDa1HytFt8krhPicEGKrECInhHh4qu0xuTzJZrM0Nzezfft2mpubz/nL63A4uOWGW7h6ztUMbh3i0Is9DG3PUNpfx9KK9fhc72Pjxp3n/LnHsv137dLo71eJxaYxMDCDl15K853vPERLS8s5fd5EU3QCA3QB3wJ+OtWGTCT19fW8/PLLJxw7vlRmfX09NpvtlAzmJUuWnFK28u233+b9738/fr+fQCDAihUr+K//+i8A9u3bx7JlyygtLaW0tJR169axb9++iR3cRU5XVxdP/vZJnnr1KZ7b+hxPvfoUT/72Sbq6us76vpNFKRAIcOOaG1k58//hplmfZa59HbWOldiVMmy2ErZtC5+2elwsFuP555/n8ccf5/nnnycWi42ca2tr4513uti16x327rUQjS4hnV6EEMvYu9fHk08+X1QzmaJbIkkpnwYQQiwDaqbYnCmloaGBJ554gvvvvx+A3bt3kzmpzuqmTZu48cYb+epXv8qjjz5KWVkZ27dv51/+5V+45557qKqq4sknnyQUCmEYBj/4wQ/46Ec/yq5du6ZiSEXP+Ub0ninNoNxfTiajcOjIVgaGmknlBzEcEru7lFJXCWXPJwgGgyMRuNu3b+fHDz9KS18fBUWgFDTKf/4Lbr/lJpYtW0Z3dzc7d+6lvz/EtGkfweGoQNMyDA0dJp/vpKUlWlSxMMU4gxkTQoj73l1Kbe3v7x/3z7/QKfJ48IlPfIJHH3105PUjjzzCJz/5yROu+dKXvsRdd93Fl7/8ZYLBIEIIrrzySn71q18Bw4mP9fX1CCGQUqKqKocPH57UcVxMjASynUOtleNF6eQCUC+9+hKvvP4LWod2k1Ry5KcZqE0q+WCUQaWDcCE8UiQqFovx44cf5eBQjIaV1zHryjUYHjdvd+/mf//6P3js+cf4/R9+z+DgEFZrDZrmZGgoRjar4XBUUyi4SSYpqliYopvBjJWJ7E19IUlv48mqVav42c9+xv79+5k1axa//OUvefPNN3nwwQcBSKfTbNq0iW9+85ujfpbf7yeZTGIYBt/4xjcm2vSLlvMJZDs5ujafyxPpi5DNZ3nuD88zkEljdVaiixR2t59soYBu9KLqKaK5KG/te4uykjIKhQItfX3MXHkdDqeHg7veIudJEVqzmEj4EBlPhqH4EKlCH5loM1r8AA61hILUScsMdmcWj4eiioW5aAVmorjQpLdz4QMf+AAWy3v/Bfl8/pSmV8dmMWvWrGHOnDlUV1ePnItGoxiGwfTp00e9VywWI5VK8cgjjxRdrEQxcT6BbMeLUqQvwp7tewh3h2k+0ExLtA3draLIAoah49AMXIDDolHQcuza1ck0h4Ic2I2UvSQLGTwlASI9nSTyA/hmV2Bx2Ohrh4JeoH5+PW8+vxdXdB96LoBwLMQhbEitg1x2L3V11UX1/3vRLpEmivOZIp8vv/nNb04oSfnDH/7wlGs+8YlP8POf/5yHH374lOVRaWkpiqLQ3d09pvu53W4+85nP8MlPfpK+vr5xGcOlxrFAttY9rWMO4z8mSkORIfZs30NXpouEkSDuSyIbbCg+JxafB7vNiZBWDNyk8zpCD+CRlXjt9YRC64jHa4n1DdB2YBe9R1tIJaMIVSGbSWKR4PF4cLgclLjSLKz1Mbe6C5vljxjyJazKa1SVvMOKFfOLKham6GYwQggLw3apgCqEcACalFKbjPsXW65HKBSioaGB//7v/+ahhx464ZzL5eKqq67iqaee4vrrrx/T5xmGQTqdprOzk4qKiokw+aLmfCJ6j4nS26+/TXemG8c0B4Ntg2RtBSxeH0aqFE2PYtNt6IlBcg43mgYBI4g1Bx5ZSU3NPAxDsvGdx9i0+de4SktJxqPE34yguKGhMsisWbMIt4ap9XiY7c9xuLMLj55AyARl3gwlAS+6rk/Bb+3MFJ3AAA8Cx5fF/zjwT8DXJ+PmxZjr8dBDDxGNRnG73WjaiTr7ne98h5tuuolQKMS9995LWVkZO3fu5Nvf/ja/+MUveOmllwgGgyxatIhUKsWDDz5IaWnpRV0YaqIZS0TvyY3jr1x0JUdbj7Kvdx8iI4hFYki7iiI86CUlaF3d6PkE9GeRygBCt6KUOPD5q5k3cw0AXf378dSXojBETvaRI06itxM/PpbecD0KCn3hPiqcFYQcFmaW9tIYKqHCFcCpKPz26FEO79zJmjVrimYWU3QCI6X8OpMkJqejGHM9zlYic/Xq1WzYsIGvfe1rfOtb30JVVWbOnMlf//VfA8NfhPvvv5+Ojg6cTifLly/nhRdeKJo/wGLlbBG9J7uSrYaksaKC61avYlAbJOfI0XGki6RmRVUdFGQfKFmkRYBmgawVkZdEYv2UWT2kUgZ79rxNW3QvLr+N2Y5yHFYrmVyQWCbFQGeSXX/YhjPp5IppV9A9w0fkrbe4p6mJCo+HTD7P4b4+5s+cSW8mU1RuarNk5mk43ot0bIo8FV6ki42LvWTmWIjFYvzdP36d/dFBpjUuwOrwUMgm6WnZw0yvj+XLF/JOzztsfvsAnZkYKZkk29+PYdeRNick7VgVK0ouhdFlp8K4gtoZH8HhjtKS+TWu0n5qfdUgXNgsGlWlkO6JU8Y0brnnHq6//npee+013vnxj3mf3Y5F09AsFpRgkJkLFvBmdzc1t99+irNgvDFLZl4A45H0ZnJpcHIR8AMHDrCvPYxjeiPp7gFUow9dUbB7KznY3cJ11lVUK9WIxFFcfSqpWBxdTcF0FeIGWJPoqopUHBi2JEORFkr6XkFUVZKM9JIx3NTagrgUKzmpsSsSIVgosLypjMrKShwOB/X19UQWLSLgcGAVArvdTnl5OTldJ28trpINpsCcAbNk5uXB2boIHF9Y21ANLNJCx74O2tuOcoWvluqyADaLhbym0TMUpysWI51Os3DOQv70agullioo5Mn74hiKBVklEEE7qgQjYUfNFzBiVnKpQwSDjXR0zyCfiFNSASGfl2Q2Q7IvT9+gQrrpvfiWUCjEvqYmOk9TYFxtLK6SDabAmFy2nC2gcmhoiH/6zj/Rqrdir7STK+SQOclgapDIUJTeznLKXUuweUuwWSx4rAI9HmPz5p3U1V2DrldxsGsfWSWNLW8nQwbpcWApKAghMZQ0NnspNn8JuaSX3s5OyizzycZ76G7tQA6lsBtWZmfqOJjpIWazjQjHaM3ti2mmbQqMyWXJ2QIq+57qY9vGTezu34pvjpPeeDdZm8QfCFBqLyUxEKUtcQBbm5VFc5aRzWdoad2DNZHHMJbQ2HgbFstSDuz+XySxoMZ1sBaQ5RLNWkDkBcagQT5VCkoBi+El0hfFqag0ViynXK3GncjiEBbsVg8d3igzFy48QTjO1ty+mLjkBUZKOebm8Sbnz8XmLDgWUFm9oJrIUIRcbw67w05FQwW//8/fEm09iq0ScpYsaT2FYUAsBV58lJZ6cBdstPftIxUZxO90UprLoTtCeL1l9PYeZaCzh9nBcuSAHV1VkEiyGEhFoAsDXAZGNkpe0UjLBEqigbg4Sqk7wa0rb8eKjWQ6ztHIQRprvKxYseKUMVwMy/hLWmAcDgeDg4OUlZWZIjOBSCkZHBwsuqfn8Zy81xKJRIgkI/Ts62EgPYCOjoqKkleI9naSU/LkhYaqKCgeBZfTSjyRJjYoKbP7WVxTQU9njAa9hKpAgD09YYb8ebqMd2jZtRm9LcvMabW0d9vpdRvYbRbyUUHBK8GjgG6DlMRI6qSdXeTUDtylLoac/fzx4ACNZfPx2BU83jAzrl/BrFmzpvpXeF5c0gJTU1NDR0cHE5FtbXIiDoeDmprirK5xur0W4tC8txnrQivVM6uxOWzks3n2btlLpD+G6oWh3gxDAzmMMgNHtR1paBidOk3BJg7raVo7w+xPdaAdNnCESqidv4zp82fS19tHa8drxPsPknYmSYo8WG3ovQbEC6BaICmgIBFlGsJhRRZ0LD4HoWtmku3opyf2FleEFlB7xfVce8stp4j3hbS4nUwuaYGxWq00NDRMtRkmk8jJX7zKysrT7rVs+uMmert7mR6aDsa7bzZALahkcxr9g0PkAiDtEqOjQLY1h5AKbs1NwpPgyNEjFOI60iHQbXkslgxa91ZcnumUeGrJihyRkg4S6ThIP3aLj6wnhV5IQcYCpTZQrKgOB8JfguzvJNuXpbSynLlr3kf7tnbmr3o/V111Fb29vWzfvn1ESCKRSFFk+4+FS1pgTC4vju8prml2LJYcVutL9GpHKZ9fTndvN3aHnfJgOdMbp2N5x4LWofFO6zvoqo7P76OqpIodcidZn4K92o3FbyefSZPriSN7QReS5p3NYLVQMqsUm89OKhcnV5ajp6cL/Z1ncRmV9Me60GUczaFiJC1kYoMYig10A1wCfHaUuA3FbgO7Cj47aiJLPpmnaUYT2e4siqLwynPPoYfD2DWNnMXCO9Om0ZdPEbVHJzzbfzwwBcbkkuBYrdqWFh8NDctxOr1kMgn+8Icfcyi2kZX5GpwICqpKRzCIVGwM9A4Q9UbRHTpGziAdT5P2pJEOC5ZSH2q5F1Wx4bCXYi2ppGDtRYY1jILEWecgPz1DOp2gkC0g04JcrEBfoRdnIUk6k4TpBqriQRVWtLwGWgxiefBkwOFFWhwYhSxGNoFLVXD7bDhtw4JBAQ7t2sW8TOaEWJent2zhrUIP135k7Qmb09WzqgnvKb7OjqbAmFwStLW1EQ7rI+ICoKp2jKyLxNEk+aoYjXXVeLwOWjq62NjWS1JN4gw6abyqEYtqoX9vP4feOIQhDUqCdah2FwWRAlXiEG4y1hzSFietpUnZh1D8CtInycfzyFYD/AKnz0Vlqor2nla0gIHWlUX3yGEvm2IBiw55HTJdSGspZBWshk6Jz4fHY6O2rpbWPa04NSeBdJrljY0jrWi9TieN5eUkdu1g66Y38ekGVl2noKoowSAyaSuqanZwAQIjhFgEfFVK+eFxtMfE5LxIpVJomh1VtdPZ2Ukul6Oj4zC9nTsxVJ0tHUcYyCWY7vJjV6x0th+lpLqE6lA1me4MhjCwOCx4SjxouQxWQ8duLcfnqAEMtEyWgh7D7rCRSBvIvI4lakWoCkIRDHvpJfmhAqlUGqfqIpeVpNVBJBJKXRBwQtAG4QIoKchFEbjx2zwo0QxV5U2IuKCxvJHyqnLymzePiMsxfE4nid4IVe1Wliycj9NmI5PPszfcQXvUguWm4poznNUaIYQL+HtgCXCI4SznIPBvwI3AIxNsn4nJmHC73aTT/Wx+fQOWeBqRz7CjdQP91lZqZk5jWkWBnJJnd287apeCzVAI1FSwYNkC4pE4hXwBq83KgBzg0KstpKJZDE8nmjINPa+TaD+CR9Oond5AZ7QTuiQFTYMAEDOGN4pzIIY8WKlGo4vcYAKZ1cFXAJ9A6HmwSpTqCvSOOKSGsLqzNARmcUX9FcybOY+mpqaRjd3d27aRyGROEJlULoc/KbDm1BM3p9NQFi8rz1IJAAAgAElEQVS+WKTR5O4HwBXAi8CtwEJgDsPC8mkp5cBZ3mtiMmlUVlaSje1l6GArq2euJpPPs8ebZEjPoooc181eTiqXI16W5kCmi3xawWV1YegGgcrh1q75dJ6kmmTp4sWk+vMc7mhnyNiDlsvhlw5uWHE9Rw93YrHZ0csVpEsHIcGahxSQVqiwhajzLmdv++vk8wOQE+C2oxg+JENYpB+Lq4xCwIoWK+DIKoiclWhfCXtyVo4cOUp3d5zrrluOWlfHlpPyjXa2tzNvWh0zPfW0HxikoOhYDZW5thoK06yn1AuaakYTmJuBJVLKPiHEfwBhYI2U8o2JN83EZOz09vYyz29FzErTH3+LtoFB8pYemipySC1Jc1cX5b4S7HYrBauB2x4k05mleUszTUuawIDDbx8m35pnUe0irr1hHjt37mT/rl2IQpZQIIBrcIjw0RhYbCjT7RhOOzKbB08OBpKQlqStWfqVOAgVI+KFdAasOoYvA3YbhsVLIRmBVBpseQoeG0cGu9F7DrOsrgHNXsIfwl2kUq/yZ392HTs5Md9Ia2qiye/nz2bOJJJMksrlcNvtBDweXuvtLapMahhdYDxSyj4AKWWHECJpiotJMZJKpZjucnHjohm09feztyONq9dLoK6c5/fs4GjHfjwRG5lkgXiPxoJZixFGjvZt7Rx9+yiyINHSGgiVjrYhXn1+J8l4H4Ytirc0iMwahPd3kRgoYLhdyJiGMAxkXsCABJuAnCSSaGVooAehOXEkp2PVphM7uheMPJTbwJ5FpNJoegrFreGZXYNryIOaHGIwto2F1Suxp7289cYR1qxZdkq+0brKSl557jl2XwSZ1DC6wFiEENcDI3H2J7+WUm6YINtMTMaM2+0mZ7FQ0HVmV1cTKi8ntjnFb5rfJhdQ8TVNJ5fK0dfZiepU8c33cd37ruPogaM8+/izxPQY9iYnyYIVR1plMNNJzp+ltGQJXqeLsmApQ+kBMuEOjGQF9BeQ6QQk01Cig8cLVg9Ksgyh9pLvSWF1BrDbFRzZKrJH+yGSRS9JoasFLG4Nb7UdI5rHkRbongJ7k9tJDsapsTaRGBzk8OHDLFq06BS388WSSQ2jC0wfJ7ZwHTzptQQax9MgIUQAeAi4CRgA/l5K+fPxvIfJpUcoFGLfSXsW1d4Afe1xIiUFert7yAxJ8kmJt9HK5t1bKfGWUBWswlJlQVEUhMNDuRLEnshxINZOXjcIKnaSmk4k3kf19BCHgp0MtqrgDqKmFqDbDoEtCnkNMjVY1FKyrg6Mygx5ZQjV60TNqbiipRQGc+iDg1ir8jQtmEZalyTaUxihUpx1HpSkglvx0pfoYLCzg3z+utOO9WLJpIZRBEZKWT9JdhzPD4A8UMmw9+r3QoidUsq9U2CLyUXC6Wqk7O7vR/P7cdh8uKnD74E+dSc5Z4HORB9/fPtVAvjoT/ajVCqkhjIYxIhGMmQVnZya42ikHatSTSSbxnB2YXVaQBuC7jS6PQxlEYgL0O3g6ifNIVBT4JSoqo6t1EshlUYzIkhbHhdOghUearVy2iMDw7E11iypWIR8Skf6JQV7AemL4nK5zjreYgqoOxNjcpoLITzAVQy7qPuBzVLKxHgbI4RwAx8CFkgpk8CbQohngU8Afzfe9zO5tDj5yd67bRvWzna8/jr8pctp3/squjWHI1iKkSgQ0QpEYx3EB2KoOQVDSRAhghbLk88nwS3QHDmMnEYsXcr+jjz5/ihY0+AFYbMjDSCiQIUHSgzIAhYJGGhqjIRuR6bjUJ1C1QqUZnzMnVXJ0UgflqE8ZdNdOJxDJJMpLDEHfdoBfGWC8qZKysvLp/g3euGMKjBCiL8Bvgk4GF6yBIGsEOJrUsrvjbM9swBdSnnwuGM7gTWnses+4D6Aurq6cTbD5GLl+Cd7LpfD+dRr9A3EsYtBdFcelxEk1dGHrljRnXYCVeVEjwwgFDtqk4XUUB6jooBslRBXMEps4IyQHUyT67VgxDSYlgHXNFAXA/vBdgiyTnDaIFeATH7432WgDGaRNguyzIOIRCmVBrWlAQYHB0mqKrasA2tBodzQCQYgTT+emoXU+mYQCASm9pc5DowWaHc3wzOH/wE8JaXUhRAqsB74dyFEVEr5X+NojwcYOunYEOA9+cKJ7E1tcmkQCARoqp1Fcl8XQ4nDpC192AMlZDoz6IUUekmSnFOi5O3Yc15Et4ExFMOwG4AKcRUlG0WqPmR8CNFTiihRwVWLqoYQdKBjYFjcENcgnAe7gKwdZluweAQilUGiI6UKORXFrtCn6zRUVeP0O3CknYgSSfW8Mqw2lT1dvdhtpSyoW1B0HqHzYbQZzP8E7pJSvnjsgJRSB34phIgB/wqMp8AkgZKTjpUA474cM7n0CYVCXHXVbPr6dPr7LeT0FNmIgZarQE/1II0C2XgWm8WG3eoiFRmCzPDyBp8CJTbUmBuZLUNkBWh+dFsvNrUUK5VABA0HBVGDLvshKyFYCqqOiMYQMo+1oJJLpbEqNtyyjPL5M5i1fDmJ5oOURyzcsGAh4aEBwgMDxPQ0WkSwoGnmGbtIXmyMJjBNwMtnOPdHxtmDBBxk2DU+U0p56N1jiwFzg9dkVE5XhOmWW64llUry3HNvsX/3djKlaVSvHSF1jFQJiVwMPVUAYZBNaxjkYTrgURE5ia5IZC6JNWYH7Ch5HUXX8asekghsuNBTglSuH93twF4WRHNpaAMp9JiOpthhKIs966F6biPXXHcd1dOreWnHYXwxnbnLq1kxYwb7Ojp4u6WFqiuv4uN3fxq/3z/Vv85xYTSBSQDVDEfwnkw14zyzkFKmhBBPA98QQnyKYS/SncDq8byPyaXH2ToEfOITH+LQ0Z3sT1uwWUoxbDmSIkUiE4U+L9JwkS8dxBBpsDHcFd1jQVpVpDYAA4NoBS9WAlgSARR3FM3Vj6IaoEv0tED2TYNgHGtSx2OzkrAFcSgO/IFqHF6NEpuPmoBCobdA72AvV8+5DlcTvNbbOxLLUnnNNaxcu/aSERcYXWB+A/xQCLFeSpk9dlAI4WTYnfzMBNj0WYZjbfoYjrv5K9NFbXI2ztYhgDdgWtk0msN7cFjclBpuugYjaJkYhuqCQB4sNmTBAhYDKhUYMmAgC1ZAAxIKhrShIrAXpmPpGcTw7gZblEIe8ol6HIU/w+jbjcXZiz3oxFsiSOUNrEqc+mlN3HbTtSxaNBOPxzMyuwIuiliWC2E0gfk7hpdCR4UQzwPdDE8gbwU6GG5MP65IKSPAB8b7c00uTbLZLK+88gpv7XuL2itrUa0qAE63k4YFDRzZfITdG7eQH+hGLUCsYCel59Bd+WGXglUDhwOMMsjnQAiwFcCmgaqD4oC8BCOHzB7EKRw4c3ncEYlfLScqc3QaEuikRLPgHXKQNvpJWmxoep6S8gC1TY24XB5mzJhxSknLiyGW5UIYLdBuSAhxFfBJYB2wnGFX9T8AP5NS5ifeRBOT09PV1cXmDRs4tGkT0eg+7NYIA12dzFywAI/HQ2Qowr7D+/AcjCMKVrJ5J3EpEV4QNifSZgMlAv4spN8VmVwHlAOVNlAkZAoQLaBip6S0kzk2P25dJxnJMahVkJMqbqFRau2jzmWl0jeLI5kmWuMe6hqs/PmHPkZlZQOtrVvYsGEz69ffesnNUs7GqHEwUsoCw6H7Dx1/XAihCiG+IaX8x4kyzsTkTGSzWTZv2ICvpYV1oRCaEiXo9tLZ28uOVBKH3YHW20+yuQ1bZ5ZC2oHiyKF74qhWBYQ2HIGbVcHpAqsCUQ2kNvytMIbPKb0SCy7cfhciqhJVXFyxeAbxoSFq83no76fUaiNuBAgE52AvLae7M0tlNkVDo5eqqlnYbA4aGpYTDr9YdCUtJ5oLKX9lYXgmYwqMyaTT1taGHg6zvKEBq6qyr7eDlq5eKio87Nq3j2qXB5/q5eqKJjqjrbgGfSjROMIfxZF1U8gXyFrsYCmBuA5uCVYJQyq0G9CvguZByQtcPg9K0kBJ+Qk0XcGSj1yHNZ+nZ/du4rt2MdPp5EA+iuYaoD81QKqQJFDqZ96867HZhmcrTqeXQqH4SlpONBdaX8/sZmYyJaRSKeyahlVVaevvp9xZQldnhObuLoZaepheVY+wCHqGsmztszKYsqEVZsNQCkMpw5pXyZXFkS4DojnoT0FSgUIZxCUYClZHOZ6gBUUkKSQThILzWb78BubNm01jYyOvB4O8lsvRE4/ziZUr0QyDrS0tDCajVM6/hRkzFo7Ym8kksFrzRVevZaK5UIExI2hNpgS32013Os3PXt9Gf9yDpnvI69X0d3dj6VUouA22GmE6hqzYXHb0WC+JbAmGVk++pBtcfmQ0D6kkGAYMuCCxBEUpx5i2F2EdwGbNYU0USA6l8EWCLL3mdrxeQTKZ5LnnXiEc1hGuq9kysI+W17dxRV0Z9kCAmsUWLB4DXc8BNjKZBK2tW2hsVC+J6NxzYbRUgbVnOW0bZ1tMTMZMZWUl+2IFYgddrJ65Cijw1sFt7GirIp4foj83RBKVpsoaapxuttmasR3ejyVfTbRPR/qOktFziGgD7lQNVk0hTgihO9B69qOkUig2BUPzY09WUBeaj8MhmTbN4PDhbjo6ymloWM6sWV6G5g7yzjt/pLO0kzvuuIFVHg8bN+4kHH6RQsGG1ZqnsVFl7dqVl9UGL4w+g3lolPOnC8AzMZlwent7cfjn45tVxd5ojCOtO4hkaimdPpNUNkPeHieT0DEMG2lD4nWUUF7jYK5aw47uQVKJIWTCTVpU4+Y2glYrsnCYLIMYBTv2yFwsIoOueEHqRHMHWLBgBTNm1PHmm30ntEfx+cpYseJW2ttfxG6309jYSFVV1SUf4zIWRnNTm31XTYqSVCqFy1XOokVr2bPnLbShIRqDN6PrfUS6StBckkK0h0ODcXrtBqV2B55SKySsaLqCqjTgUvxkjR5iym9xiibsSi95ow+FxfjVGrwWQdbSRl7spiaQY+nS2aiqiqYNjYjLMU7exL1Y6rVMNMXVRMVkyrlYmqq73W4slhy6nsPv9+DzVVFWVk1ra5j0UBRdRMjpGTKFLHnpIiNyiEyBrs5DoKvcMvNO3j4aY3/MQlK0kjH+hE2xIA0Vj5CUOpNgk4RcLmpDt1KwHqK9vZ358+djseTIZBIniMzluok7GqbAmIxwtnyeYmuqHgqFqKvbR0vLFhwOP7lclP27NxPpPEh2oBclZ8HrnY0he/CoSfoH+kj2JqnS3Vxdu5aGshq60pKjchAyPiL5NuxKCzZRT70vidcjKPf7qapqpKG6mj+19Z5y3+Nb1F6um7ijYQqMCTA8c3lhwwvs6NlBRV0FvoAPj9NDy8Gpbap+phmVw+Fg7dqVwGYOHGinp+OP5CIBAm4LZco0HDErA/FehDOL024hlA3QoydJWPxI73T2pNNYp/tZWpngaKaL3FAaj68Ea8rONMc0rqhfQJnXi9fh4GBvJ5YyOzNmzDjhvuYm7uiYAmMCwNtvv80Lm15A1kn6uvtQu1WCriAzQjMIt05NU/XRZlRVVVWsX38rr7zyCnQo5KO9bDh4hKizQLm3koCWx5vzMLtqFU2LFvLM1sfQpUZJqBq/y0NLdBu6J8Xs0hkosSzL1szh4DtH6d/VSr/RRC6lkE7G6BeDXH1tE7NmzQIYue/FsJScas4oMEIIZSwfIKU0Rr/KpJjJZrO8vvF1+o1+FsxdgM1hI5/N09veC23g03yTHoE6Wob08TOqTCaDz2Kh4M9RObtALmowPxCk1FbD4Y52dCWB32UnVF2J7orRET2IzVJHTB3AVeqjdfAoviorV1x5BY2NjbyqbySdb8NwTMPlkty0sIpbbrn2BAExN3HHxtlmMBpjC6RTx8kWkymira2NwdwgwWBwpN+xzWGjoraC7v3dqAV10jcv29raCMfCI+IC72VIh7cPz6i8Xi8b3tjAtkPbONC3l1whQV1TkKwlRk+iD4+1Gl8gSG+im5f3vkhoSQkf/NjHeeaJZ9n4zkt00I7f5cNXZWXNumtxu9243W7mL5nJFdMXUV9fb85OLpCzCczxLuo/Y7gO77eBNiAEfBl4auJMM5ksUqkUnqCH6bnp9B7spWJWBTaXDQwYCA+wuG7xpG9eplIpNKGNiMsxnG4nBQpEIhG2vLOFlnQLC65fwGC6m9bDO4k7M5QH3QzQz9b+fgyLGyOfY1G1lU/e9ymWLl3K7Nmz+clPfsLre6PUXlHF6mtWjxR5yqQyOC1O5s+fb85QxoEzCoyUsu3Yv4UQfwssk1LG3j10UAixFdgK/GhiTTSZaNxuN06Lk/KGcjgAA7sH0IWOkTMIakHed9X7Jv0J7na7sUjL8Bf+OJHJpDJYsRKLxU6Y4cxYMI/WnjAJRSOnxamqqkSdZmCxO7EN2fjs3Z9h6dKlI/s6RqmB1++lra0Nm9PG0iuW4rQ7ad3TSqO/+FqwXqyMdZPXB7iA2HHHXO8eN7nICYVC1PnraOltYfGKxSSHksQjcfrb+1lyzRJWrFgxdTbtaaFhwXt7MMcEwO/3o7W/N8OZMXcGPR1LaE20kvIOEVc9uGxVDHXGcGlBDh7spKqqhY1bNtKSbqFxZSPTF0xn+6btHN59mL5DfSyetZim8qZLpuB2MTBWgXkEeFkI8X+AdqAW+H/fPX5RcbEEko0XYxmvw+Fg7bVr4Q0I7w1ToIAVKyuaVkzZl+0Em7a/Z1Ojv5G1164lkUicMMOx2W0sWbGE/Bt5Opq70G2CumnlLAiuZkZoBR0dHTz11H+Tdg7SuLIRp9uJ0+3kfbe8j8YjjbTtaGNF0wquv/76S/rvYbIZq8A8ABwGPgJUMVw68/vAT8bLECHE54C7gYXAE1LKu8frs49xMQWSjQfnMt6qqirW31lc/Y7PZlM2mz1lhuN0O7FarFSri1ix6G7KymooLw9hszkoLZ3OW29tRakeYL57/sg9bHYbjfMayQxmqKysNMVlnBmTwLzriv6/7/5MFF3At4CbAeco154z5+L2vBQ4n/EWo+v1TDadaYZTrVTjnl3DokU3nHC90+lFUTzInDzjvo4Z5j/+jLU3tQA+BXwUKJdSLhJCvA+YJqX81XgYIqV8+t17LQNqxuMzj2csbs9i+3JdCJfDeE83w8nlcjz33MHT5goFg36cvjpa97Sedl/H3Ngdf8a6RPoGcCPwf3hvFtMB/G9gXARmohnN7XmplTK8XMZ78gwnm81SV3fktLlCTU1OVq9ez8YtG0+7r3MpzWCLhbEKzN3AFVLKASHEMbd0K+Pf2XHMCCHuA+4DqKurG/X60dyel9r0+HIb7zFGyxU6lmJQTHtNlzJjFRiV4b7R8F50r+e4Y2dFCPEqsOYMp/8kpbxmjHaMIKX8MfBjgGXLlo0acTya2/NSmx5P1niL0Ss3Wq5QMe41XaqMVWCeB74nhPifMLIn803gd2N5s5TyuvOybhwZze051V+K8WYyxlvMXjlTRIqDsQrM/wQeBYYYbqiZBP7AcEO2cUEIYXnXHhVQhRAOQJNSauN1j2J0xU4kEzney80rdzLFOHMrRkYVmHdnK0GGc5ECDOchtUspe8bZlgeBrx33+uPAPwFfH8+bXG5Ptoka7+XgpToTxTxzKzbG0tlRCiF2A14pZR/DTenHHSnl1xlnMTEZZqxP23N5Kl8uXqqTudxnbufKWJdIO4BZwIEJtMVkAhjr07arq4sNGzYTDutomh2LJUdd3b4Rz8vJXK5eqst55nY+jFVgXgVeEEI8zHAu0ojXRkr50/E3y2Q8GOvTNpvNsmHDZlpafCfEjrS0bAFO37D9cvVSXa4zt/NlrAJzNcNxLye7miVgCkyRMtanbVtbG+GwfkKvH6fTe9aG7ZPmpTqHWdVkcLnO3M6XseYiXT/RhpiMP2N92qZSKTTNPmqvn5OZcC/Vhs00N7vweOqxWKxIWaC5+ShnmlVNBpdbPNWFMtZcpDPW5zVr8hYvY33aHusxdD69fibSS7VnT5RMzEn6yF6suk5BVdFKXOwpRFm+fGr2Oi63eKoLZaxLpLPV5zVr8hYpY33aFmOvn0gkwtFDXcy2eJlRUYHTZiOTz3O4r4/mvk4ikcik23SMyy2e6kIYq8Cc3EJ2OvB3jDGS12RqGOvTthh7/cRiMZREN9UNV+K02QBw2mxU+z0cau0hFouN8glnZjw2ji+3eKrzZax7MG0nHWoTQtwFbAEeGnerTMaNsT5ti63Xj9/vZ5onTk/sME7bXJw2N5l8ip7YYSo98ZEi3edKMW4cX8pcSOO1EqB8vAwxmTjG+rR1OByEQqERkWlra5sykQkEAsyZVY2IHaV9cICC7sCqZplemmSav5pAIHDOn3k+7niTC2Osm7w/48Q9GBfwPuCxiTDKZGoopqd7KBSifMECnM3NXNl4bJPZTV/CIDN79nntCx1zx1dXLyYSiZPL9WO326muXkw4/IoZJDcBjHUGc/ik1yng/0opXx5ne0ymiGJ7ujscDlauXctmoCUcxlYokLdaUWfPZuXa8/PWpFIpIpEc0Z69GAMDI54pJRhE2rJmkNwEMNY9mH+aaENMppbzCbabaKqqqrh1/fh5aywWC93hfdRqOouqQyOeqb0dR2m3NGOxLBrnEZiMdYn0MeAdKeV+IcQshrsJ6MBnpZRmftIlwPkG20004+2tKZOdqJQx3BzDBhRQGaBMdo7bPUzeY6xLpG8Bq9/9978x7D1KAj8E1k6AXSaTzIUE210saJrG0lAQS76f8MAbIxvHc2vyFKxlaNq4lR4yeZexCky5lLL33SJQ1zBcG6YADEyYZSaTSjEG2403brcbTyDAmspKIskkqVwOtz1AwOPhtd7eS0JEi42xCky/EGIGw03Rtkgpc0IIFyAmzjSTyaQYg+3Gm1AoxL66Ona3tLC8oQGv00kik2FLaytqo5lHNBGMVWC+CWxjeN/lI+8euwHYORFGmUwNxRZsN94c75l68XjPVGPjeXumTM6OkHLUgvzDFw7PWJBSpt99XQEoE1A685xZtmyZ3Lp161SbYXKRUGw1Zi5GhBDbpJTLRrtuzJG8xwmLYHhpZO6/mFyUmHlEk8cZyzAcjxCiWgjxjBBikOHM6sJxPxeMEMIuhHhICNEmhEgIIXYIIW4dj882MTGZOsYkMAy3i80zvO+SBJYCzwKfGSc7LAyX4lwD+ICvAr8SQtSP0+ebmJhMAWNdIq0G6qSUKSGElFLuFEL8D2Ajw0F3F4SUMsWJHQWeE0K0AlcCRy/0801MTKaGsc5gdIaXRgAxIUQ5w/lI1RNhlBCikuEuBnvPcs19QoitQoit/f39E2GGiYnJBTJWgdkMvP/df78I/BJ4Ghh3140Qwgo8DjxytjQEKeWPpZTLpJTLysvNqhEmJsXIWAXmE/z/7d1/cBz1ecfx98c6yVYl+YeCCcj4ZAnzM5AAseuQpo1HQ+IxqRMaTEogP5oJ0KHDZEhDmk4mTQkhpWWagXZKkpLQhkA7mVBSUgqpm0aBFtIoNqGJgdiOkbhzLBOMZQVJ3Fk6+ekfuxJnoR+n8+3tonteMzvju9vbfXTWPfru97vf5wuPhv++HugGngKuKOXNkh6RZDNsjxXttwi4h6C/57qSfwrnXCKVOpt6sOjfOYK5SSUzs41z7RMOf98FvB642MwqMkJV6/yeDxenUmdTLwY+C7wfeJ2ZLZP0TuB0M/u7CsXyZeAs4KIwibnjlKQCUq42lXqJdBtwDnAlr1S2exq4thJBSGoH/hA4D3he0nC4XVmJ49ei4gJSq1dv4uyzt7B69SZ6e5fR3d1DPp+PO0RXA0odpv49YG04TH0UwMz2S6rIKFJYVNwnTlZQEgtIudpTagtmlCnJKByqPlTxiFxFJLWAlKstpbZg7gPulvRxAEknA7cD34wqMHd8yikg5R3CrtJKTTCfBm4FdhKsKPALgjt4vVZvQs23gFR/fz893d2MZ7MsLhQ4kkrxTDrNhq4u7xB2ZSt1mHqU4P6X68NLoxet1DoPLhbzKSCVz+fp6e5m2dRCTL299ACbt271lowry6wJRlJ6hpdWB7etgJllKx2Uq4yJAlJ79uxh7969wCLWrj31VYuWZTIZxrPZyeQC0NLYyPqODrZls94h7Mo2VwvmOV4Zlp5ulMeAukoG5CprYGCAn/3sWbLZoxQKi9m1aw/p9LPH3AszMjLC4kJhMrlMaGlspGFszDuEXdnmSjA/A5YAdxOs4tgfeUSuYkpdTK2pqYkjqRRDudwxSWYol2O0vt6LYbuyzTpMbWbnEawg0Ao8BjwMXA40mNm4mY1HH6Ir1+z3woyTyWSAoEO4Lp1me18fQ7ngJurJYtjptBfDdmWbs5PXzJ4CPinpU8A7gD8A7pDUZWY/iTg+dxxGRkbI5xcdsw7zypUrX3UvjBfDdlEpuSYvcBpBxbkLgSeBw5FE5CpmeHiYZ3c9wWHL0bSogbG6On55wgmsXtv+qnthKr1Mq3Mw9yhSK8EExw8DLQSlFH7HR46SL5/Pc2DvXtKFLIt4HWee9Eagnqd/+Rw/3P8E73xX26sufbwYtqu0uVow/UAfQWL5Ufjc2nARNgDMrDui2NxxyGQy1D3/PB/ZuJ4f7z0wuVTq4rphTmQ/a9e+2VsnLnJzJZjnCUaRrg63qQzorHRQ7vhNDD2f3tZG+oQTyBw8GC6VeiI7D4rm5ua4Q3Q1YNYEY2ZrqhSHq7CpQ89nrAomvg/lcuwM+1ici9p8Onnda8jEOszbe3t506pV5IeHOfTSS+x64QXs/PN96NlVhSeYBWpi6Pk/Dh/mf7Zto+HQIQoSL69YwdqREQYGBnwSo4ucJ5gFrLW1laamJtacdBKd557LiUuX0trczM79++np7vZJjC5ynmAWsImRpPeuX3/MFID1DQ0+idFVRakV7SIn6V5JByS9JGmPpKvijum1zicxurglqQVzC/BRM4EzrYoAAAy6SURBVDsi6UzgEUlPmtkTcQf2WlXOJEavaucqKTEJxsyKl4m1cDsV8ARTpuKRpGMKSfX1UdfZ6VXtXOQSk2AAJH2JYDJlI8F8p4dn2fca4BqAdHqmuli1bT6TGL2qnYuCklb5UlIdwYTKjcBflbLC47p162zHjoovk71glHLZs3v3bnbefz+bVq9+1eXUtn37OPfSS71D2E2S9ISZrZtrv6q0YCQ9QjATezqPm9nbJh6ENWYek/QBgoXd/jb6CBe2UiYxeoewi0JVEkwpa1NPI0XQB+OqwKvauSgkYpha0omSLpfULKlO0iaCMhE+U7tKvKqdi0JSOnmN4HLoKwRJLwNcb2bfiTWqGuJV7VwUEpFgzOwgM/fRuCrxqnau0hKRYFxyeFU7V0mJ6INxzi1M3oJxx8WnFrjZeIJxZfOpBW4ufonkyjIxtaBx9246UylWLVlCZypF4+7d9HR3k8/n4w7RJYC3YFxZMpkMB596Cg2O8ZNnF1EYbyRVl2Pl0pexsafIrF/vncXOE4wrz8DAALv27Gd5/W/SceJZNDY0kRsdoe+Fn3P4hR9z7sBA3CG6BPBLJFeWwcFBnh9eyknL19LYEEwjaGxo4qTla/nV8FIGBwdjjtAlgScYV5bly5dztOVk9g8OkxsdBSA3Osr+wWGONp/E8uXLY47QJYFfIrmytLa2sua0NgYHW/i/Q4dIFQoUUikKK1pYs3wVra2tcYfoEsATjCtLe3s755zzDLt3i+aONyDVYzbG8PBznHHGCp8c6QBPMK5MS5YsoatrA9BDNruTsbEG6utHOeOMOrq6NvjNdg7wBOOOQ1tbG1u3bvY7ed2MPMG44+KTI91sfBTJORcZTzDOuch4gnHORcYTjHMuMp5gnHORSWSCkXSapLyke+OOxTlXvkQmGOAOYHvcQTjnjk/iEoyky4FB4Ptxx+KcOz6JSjCSlgI3AZ8oYd9rJO2QtOPgwYPRB+ecm7dEJRjg88BdZrZvrh3N7E4zW2dm61auXFmF0Jxz81W1BCPpEUk2w/aYpPOAi4DbqhWTcy5aVZuLZGYbZ3td0vXAGiArCaAZqJN0tpldEHmAzrmKS9JkxzuBbxY9voEg4VwbSzTOueOWmARjZi8DL088ljQM5MN1qyvGFwpzrnoSk2CmMrMbK33M/v5+urt7yGbHKRQWk0odIZ1+hq6uDb5QmHMRSGyCqbR8Pk93dw+9vcvo6FhPY2MLudwQvb3bgR62bt3sLRnnKixpw9SRyWQyZLPjk8kFoLGxhY6O9WSz42QymZgjdG7hqZkEMzIyQqGweDK5TGhsbGFsrIGRkZGYInNu4aqZBNPU1EQqdYRcbuiY53O5IerrR2lqaoopMucWrppJMO3t7aTTdfT1bZ9MMrncEH1920mn63yZDeciUDOdvMcus7FtcpmNzk5fZsO5qNRMggFfZsO5aqupBAO+zIZz1VQzfTDOuerzBOOci0zNXSL5XCTnqqemEkx/fz893d2MZ7MsLhQ4kkrxTDrNhq4un4vkXARqJsHk83l6urtZ1tvL+o4OWhobGcrl2N7bSw+weetWb8k4V2E10weTyWQYz2YnkwtAS2Mj6zs6GM9mfS6ScxGomQQzMjLC4kJhMrlMaGlspGFszOciOReBmkkwTU1NHEmlGMrljnl+KJdjtL7e5yI5F4GaSTDt7e3UpdNs7+ubTDJDuRzb+/qoS6d9LpJzEaiZTt4lS5awoauLHmBbNkvD2Bij9fXUdXayoavLO3idi0CiEoykR4C3AIXwqf1mVrH7+tva2ti8davfB+NclSQqwYSuM7OvRXVwn4vkXPXUTB+Mc676kphgbpH0oqTHJW2caSdfm9q55EtagvkU0AmsIliI7UFJp063o69N7VzyJWZtagAz6zGzITM7YmZ3A48DF1crRudcZSVmbeqZ3gaowqE456pEZhZ3DABIWg5sAB4lGKb+fYLLpAvMbPcc7z0IlDOZ6ATgxTLeFxWPZ3ZJiweSF1O14mk3szn7JpI0TF0P3AycCYwDu4BL5kouAKX8oNORtMPM1pXz3ih4PLNLWjyQvJiSFk9iEky4yP36uONwzlVO0kaRnHMLSK0nmDvjDmAKj2d2SYsHkhdTouJJTCevc27hqfUWjHMuQp5gnHOR8QTjnIuMJ5iQpNMk5SXdm4BY7pV0QNJLkvZIuirGWBZLuktSRtKQpCclbY4rnjCm68KJrkckfT2mGFol/aukkfCzuSKOOMJYYv88ZpKY+2AS4A5ge9xBhG4BPmpmRySdCTwi6UkzeyKGWFLAPuDtQJZgbti3JJ1rZs/FEA9AP8FNmZuAxjn2jcodwCjweuA84CFJPzWzp2OIJQmfx7S8BQNIuhwYBL4fdywAZva0mR2ZeBhu084qr0IsI2Z2o5k9Z2ZHzezfgT7gzXHEE8b0bTN7ADgUx/klNQGXAn9mZsNm9hjwb8AH44gn7s9jNjWfYCQtBW4CPhF3LMUkfUnSywRTJg4AD8ccEgCSXg+cDsTxlzopTgfGzWxP0XM/Bd4QUzyJVfMJBvg8cJeZ7Ys7kGJm9kdAC/DbwLeBI7O/I3qS6oF/Au42s11xxxOjZuDXU577NcH/lyuyoBPMXDVoJJ0HXATclpSYivc1s/Gw+X0KcG2c8UhaBNxD0O9wXRSxzCeemA0DS6c8txQYiiGWRFvQnbxz1aCRdD2wBshKguAvU52ks83sgjhimkGKiPpgSolHwYdzF0GH5sVmNhZFLKXGkwB7gJSk08zsF+Fzb6K2LxuntaBbMCW4k+CLe164fQV4iKA3PhaSTpR0uaRmSXWSNgHvB7rjign4MnAWsMXMcnPtHDVJKUlLgDqCPwhLJFWzeNoIwWXrTZKaJP0W8B6CFl7Vxf15zMrMfAs34Ebg3phjWElQdGsQeAnYCVwdYzztBKNYeYJLg4ntypj/n2zKdmOVY2gFHgBGCIbvr6jlz2OmzSc7OuciU+uXSM65CHmCcc5FxhOMcy4ynmCcc5HxBOOci4wnGOdcZDzBuHmTtCa8dT8VPv6upA9X4bw3JqFejyudJ5gFStJzknKShiX9StI/SmqO4lxmttmCtcRLiemiKGKQtFHSL2d5/a2SusOiWb+W9KCks6e8/2j4eQ1J2i3pI1HEWks8wSxsW8ysGbiAYFG7z0zdQYEF/Xsg6ULgP4HvAG1AB0F5hccldRbt2h9+XkuBjwNflXRGteNdSBb0L5YLmNl+4LvAOTA5Y/kLkh4HXgY6JS0LS2MekLRf0s2S6sL96yT9taQXJfUC7yo+fni8q4oeXy3p52FL4BlJF0i6B0gDD4athD8J932LpB9KGpT0U0kbi47TIenR8DjfI1h3uRy3At8ws78xsyEzGzCzzwA/IrjNfurnZWb2MDAAvLHMczo8wdQESasJSl0+WfT0B4FrCGqYZIC7gQKwFjgfeCcwkTSuBn43fH4dsHWWc11G8KX9EEFL4N3AITP7IMGcnS1m1mxmt0paRTC59GaCuT03APdLmlhr/J+BJwgSy+eBeffzSPoN4K3AfdO8/C3gHdO8Z5Gkd4fn3Tvfc7pXJGPGpYvKA5IKBMWQHgL+oui1r1tYP1ZBlbrNwHILZkuPSLqNIAH9PfA+4HYLi3JJugXYOMM5rwJuNbOJ+sazfUE/ADwcthYAvidpB3CxpB8QXNZdZEH50P+W9OA8fvYJrQR/SA9M89oBjm0VtUkaJKhrmwL+2MyenOZ9rkSeYBa2S8zsv2Z4rbiCXztQDxwI6+JA8KWc2Kdtyv6ZWc65Gni2xPjagcskbSl6rh74QXjOwxaURig+7+oSjz3hMHAUOJmg/Gixk4EXix73m9kpkhYDfwl0AbfP83yuiCeY2lU8jX4fQUnOE8ysMM2+Bzj2i52e5bj7mLk41tSp+/uAe8zs6qk7SmoHVkhqKkoy6WmOMSszG5H0v8BlBImr2PuYptC7Bas5fArYLekSCwpquzJ4H4zDzA4QjLJ8UdLSsA/iVElvD3f5FvAxSadIWgH86SyH+xpwg6Q3hyNUa8NkAfAroHjU5l5gi6RNYUfyknC4+BQzywA7gM9JapD0NmALcwiPUbwpjPfDkj4mqUXSCkk3AxcCn5vhMxkFvgh8dq5zupl5gnETPgQ0AM8QXFb8C8ElBMBXgW0EQ7s/IajmNi0zuw/4AkEH7RBBUabW8OVbgM+EI0Y3hH067wE+DRwkaNF8kld+L68ANhCM5vw58I05foZVQG7KdqoFdY03Ae8laI1lCDqs32avlLyczj8A6SmXcG4evOCUcy4y3oJxzkXGE4xzLjKeYJxzkfEE45yLjCcY51xkPME45yLjCcY5FxlPMM65yPw/34QNOf5pPbgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Compare predictions vs. measurements, all variants, 77 to 127\n", + "\n", + "from scipy.stats import spearmanr\n", + "\n", + "save_figs = True\n", + "fig_name = \"all_vars_predicted_vs_measured_lor_77_127_superimposed\"\n", + "\n", + "#HEK293 measurements\n", + "hek_min_c = 50.\n", + "\n", + "hek_min_ref_prox_c = 5.\n", + "hek_min_var_prox_c = 1.\n", + "\n", + "hek_filtered_df = hek_df.query(\"ref_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hek_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hek_min_var_prox_c))\n", + "\n", + "hek_true = np.array(hek_filtered_df['delta_logodds_true_77_127_repl_pooled'].values)\n", + "hek_pred = np.array(hek_filtered_df['delta_logodds_77_127'].values)\n", + "\n", + "#SK-N-SH measurements\n", + "sknsh_min_c = 50.\n", + "\n", + "sknsh_min_ref_prox_c = 5.\n", + "sknsh_min_var_prox_c = 1.\n", + "\n", + "sknsh_filtered_df = sknsh_df.query(\"ref_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(sknsh_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(sknsh_min_var_prox_c))\n", + "\n", + "sknsh_true = np.array(sknsh_filtered_df['delta_logodds_true_77_127_repl_pooled'].values)\n", + "sknsh_pred = np.array(sknsh_filtered_df['delta_logodds_77_127'].values)\n", + "\n", + "#HMC3 measurements\n", + "hmc3_min_c = 50.\n", + "\n", + "hmc3_min_ref_prox_c = 5.\n", + "hmc3_min_var_prox_c = 1.\n", + "\n", + "hmc3_filtered_df = hmc3_df.query(\"ref_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hmc3_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hmc3_min_var_prox_c))\n", + "\n", + "hmc3_true = np.array(hmc3_filtered_df['delta_logodds_true_77_127_repl_pooled'].values)\n", + "hmc3_pred = np.array(hmc3_filtered_df['delta_logodds_77_127'].values)\n", + "\n", + "r_val_hek, _ = spearmanr(hek_pred, hek_true)\n", + "r_val_sknsh, _ = spearmanr(sknsh_pred, sknsh_true)\n", + "r_val_hmc3, _ = spearmanr(hmc3_pred, hmc3_true)\n", + "\n", + "f = plt.subplots(figsize=(4, 4))\n", + "\n", + "#Plot HEK293 measurements\n", + "plt.scatter(hek_pred, hek_true, color='red', alpha=0.33, s=45, edgecolor='black', linewidth=1.5, label='HEK293')\n", + "\n", + "#Plot SK-N-SH measurements\n", + "plt.scatter(sknsh_pred, sknsh_true, color='blue', alpha=0.33, s=45, edgecolor='black', linewidth=1.5, label='SK-N-SH')\n", + "\n", + "#Plot HMC3 measurements\n", + "plt.scatter(hmc3_pred, hmc3_true, color='green', alpha=0.33, s=45, edgecolor='black', linewidth=1.5, label='HMC3')\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.legend(fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n", + "\n", + "f = plt.figure(figsize=(2, 4))\n", + "\n", + "plt.bar([0], [r_val_hek], color='red', linewidth=1, edgecolor='black', alpha=0.5)\n", + "plt.bar([1], [r_val_sknsh], color='blue', linewidth=1, edgecolor='black', alpha=0.5)\n", + "plt.bar([2], [r_val_hmc3], color='green', linewidth=1, edgecolor='black', alpha=0.5)\n", + "\n", + "plt.ylim(0.5, 1.0)\n", + "\n", + "plt.xticks([0, 1, 2], ['HEK293', 'SK-N-SH', 'HMC3'], fontsize=12, rotation=45)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.ylabel(\"Spearman r\", fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_r_vals.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_r_vals.eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " snp_id gene_id delta_logodds_0_205 \\\n", + "16 rs78378222 TP53.9 -2.1716 \n", + "22 rs12459634 IGFLR1.1 -1.5258 \n", + "14 rs6796 KDELR2.14 -1.0956 \n", + "20 rs35979828 NFE2.1 -0.9556 \n", + "15 rs35630683 ZNF592.7 -0.3138 \n", + "18 rs16833132 KPNA1.26 0.3026 \n", + "19 rs8753 POLR2A.3 0.4854 \n", + "21 rs2732480 ZNF641.5 0.5996 \n", + "\n", + " delta_logodds_true_0_205_repl_pooled \n", + "16 -2.596713 \n", + "22 -3.556974 \n", + "14 -1.395183 \n", + "20 -1.442611 \n", + "15 -0.154653 \n", + "18 0.055570 \n", + "19 0.205128 \n", + "21 0.740291 \n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Compare predictions vs. measurements, GWAS SNPs, 0 to 205\n", + "\n", + "from scipy.stats import spearmanr\n", + "\n", + "save_figs = True\n", + "fig_name = \"GWAS_predicted_vs_measured_lor_0_205\"\n", + "\n", + "#HEK293 measurements\n", + "hek_min_c = 50.\n", + "\n", + "hek_min_ref_prox_c = 5.\n", + "hek_min_var_prox_c = 1.\n", + "\n", + "hek_filtered_df = hek_df.query(\"data_source == 'GWAS' and ref_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hek_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hek_min_var_prox_c))\n", + "\n", + "print(hek_filtered_df.sort_values(by='delta_logodds_0_205')[['snp_id', 'gene_id', 'delta_logodds_0_205', 'delta_logodds_true_0_205_repl_pooled']])\n", + "\n", + "hek_true = np.array(hek_filtered_df['delta_logodds_true_0_205_repl_pooled'].values)\n", + "hek_pred = np.array(hek_filtered_df['delta_logodds_0_205'].values)\n", + "\n", + "#SK-N-SH measurements\n", + "sknsh_min_c = 50.\n", + "\n", + "sknsh_min_ref_prox_c = 5.\n", + "sknsh_min_var_prox_c = 1.\n", + "\n", + "sknsh_filtered_df = sknsh_df.query(\"data_source == 'GWAS' and ref_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(sknsh_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(sknsh_min_var_prox_c))\n", + "\n", + "sknsh_true = np.array(sknsh_filtered_df['delta_logodds_true_0_205_repl_pooled'].values)\n", + "sknsh_pred = np.array(sknsh_filtered_df['delta_logodds_0_205'].values)\n", + "\n", + "#HMC3 measurements\n", + "hmc3_min_c = 50.\n", + "\n", + "hmc3_min_ref_prox_c = 5.\n", + "hmc3_min_var_prox_c = 1.\n", + "\n", + "hmc3_filtered_df = hmc3_df.query(\"data_source == 'GWAS' and ref_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hmc3_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hmc3_min_var_prox_c))\n", + "\n", + "hmc3_true = np.array(hmc3_filtered_df['delta_logodds_true_0_205_repl_pooled'].values)\n", + "hmc3_pred = np.array(hmc3_filtered_df['delta_logodds_0_205'].values)\n", + "\n", + "r_val_hek, _ = spearmanr(hek_pred, hek_true)\n", + "r_val_sknsh, _ = spearmanr(sknsh_pred, sknsh_true)\n", + "r_val_hmc3, _ = spearmanr(hmc3_pred, hmc3_true)\n", + "\n", + "f, ax = plt.subplots(1, 3, figsize=(12, 4))\n", + "\n", + "#Plot HEK293 measurements\n", + "plt.sca(ax[0])\n", + "\n", + "plt.scatter(hek_pred, hek_true, color='red', marker='^', s=125, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"HEK293, r = \" + str(round(r_val_hek, 3)) + \", n = \" + str(hek_pred.shape[0]), fontsize=12)\n", + "\n", + "#Plot SK-N-SH measurements\n", + "plt.sca(ax[1])\n", + "\n", + "plt.scatter(sknsh_pred, sknsh_true, color='red', marker='^', s=125, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"SK-N-SH, r = \" + str(round(r_val_sknsh, 3)) + \", n = \" + str(sknsh_pred.shape[0]), fontsize=12)\n", + "\n", + "#Plot HMC3 measurements\n", + "plt.sca(ax[2])\n", + "\n", + "plt.scatter(hmc3_pred, hmc3_true, color='red', marker='^', s=125, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"HMC3, r = \" + str(round(r_val_hmc3, 3)) + \", n = \" + str(hmc3_pred.shape[0]), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " snp_id gene_id delta_logodds_77_127 \\\n", + "16 rs78378222 TP53.9 -2.3632 \n", + "14 rs6796 KDELR2.14 -2.3504 \n", + "22 rs12459634 IGFLR1.1 -1.7076 \n", + "20 rs35979828 NFE2.1 -1.0283 \n", + "15 rs35630683 ZNF592.7 -0.4139 \n", + "18 rs16833132 KPNA1.26 0.7260 \n", + "19 rs8753 POLR2A.3 0.8946 \n", + "21 rs2732480 ZNF641.5 0.9084 \n", + "\n", + " delta_logodds_true_77_127_repl_pooled \n", + "16 -2.655698 \n", + "14 -2.888136 \n", + "22 -3.456609 \n", + "20 -1.478624 \n", + "15 -0.201321 \n", + "18 0.311756 \n", + "19 0.257417 \n", + "21 0.839856 \n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Compare predictions vs. measurements, GWAS SNPs, 77 to 127\n", + "\n", + "from scipy.stats import spearmanr\n", + "\n", + "save_figs = True\n", + "fig_name = \"GWAS_predicted_vs_measured_lor_77_127\"\n", + "\n", + "#HEK293 measurements\n", + "hek_min_c = 50.\n", + "\n", + "hek_min_ref_prox_c = 5.\n", + "hek_min_var_prox_c = 1.\n", + "\n", + "hek_filtered_df = hek_df.query(\"data_source == 'GWAS' and ref_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hek_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hek_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hek_min_var_prox_c))\n", + "\n", + "print(hek_filtered_df.sort_values(by='delta_logodds_77_127')[['snp_id', 'gene_id', 'delta_logodds_77_127', 'delta_logodds_true_77_127_repl_pooled']])\n", + "\n", + "hek_true = np.array(hek_filtered_df['delta_logodds_true_77_127_repl_pooled'].values)\n", + "hek_pred = np.array(hek_filtered_df['delta_logodds_77_127'].values)\n", + "\n", + "#SK-N-SH measurements\n", + "sknsh_min_c = 50.\n", + "\n", + "sknsh_min_ref_prox_c = 5.\n", + "sknsh_min_var_prox_c = 1.\n", + "\n", + "sknsh_filtered_df = sknsh_df.query(\"data_source == 'GWAS' and ref_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(sknsh_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(sknsh_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(sknsh_min_var_prox_c))\n", + "\n", + "sknsh_true = np.array(sknsh_filtered_df['delta_logodds_true_77_127_repl_pooled'].values)\n", + "sknsh_pred = np.array(sknsh_filtered_df['delta_logodds_77_127'].values)\n", + "\n", + "#HMC3 measurements\n", + "hmc3_min_c = 50.\n", + "\n", + "hmc3_min_ref_prox_c = 5.\n", + "hmc3_min_var_prox_c = 1.\n", + "\n", + "hmc3_filtered_df = hmc3_df.query(\"data_source == 'GWAS' and ref_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"var_count_total_repl_pooled >= \" + str(hmc3_min_c) + \" and \" + \"ref_count_0_205_repl_pooled >= \" + str(hmc3_min_ref_prox_c) + \" and \" + \"var_count_0_205_repl_pooled >= \" + str(hmc3_min_var_prox_c))\n", + "\n", + "hmc3_true = np.array(hmc3_filtered_df['delta_logodds_true_77_127_repl_pooled'].values)\n", + "hmc3_pred = np.array(hmc3_filtered_df['delta_logodds_77_127'].values)\n", + "\n", + "r_val_hek, _ = spearmanr(hek_pred, hek_true)\n", + "r_val_sknsh, _ = spearmanr(sknsh_pred, sknsh_true)\n", + "r_val_hmc3, _ = spearmanr(hmc3_pred, hmc3_true)\n", + "\n", + "f, ax = plt.subplots(1, 3, figsize=(12, 4))\n", + "\n", + "#Plot HEK293 measurements\n", + "plt.sca(ax[0])\n", + "\n", + "plt.scatter(hek_pred, hek_true, color='red', marker='^', s=125, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"HEK293, r = \" + str(round(r_val_hek, 3)) + \", n = \" + str(hek_pred.shape[0]), fontsize=12)\n", + "\n", + "#Plot SK-N-SH measurements\n", + "plt.sca(ax[1])\n", + "\n", + "plt.scatter(sknsh_pred, sknsh_true, color='red', marker='^', s=125, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"SK-N-SH, r = \" + str(round(r_val_sknsh, 3)) + \", n = \" + str(sknsh_pred.shape[0]), fontsize=12)\n", + "\n", + "#Plot HMC3 measurements\n", + "plt.sca(ax[2])\n", + "\n", + "plt.scatter(hmc3_pred, hmc3_true, color='red', marker='^', s=125, edgecolor='black', linewidth=1)\n", + "\n", + "#plt.xlim(x_min, x_max)\n", + "#plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Predicted LOR\", fontsize=12)\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(\"HMC3, r = \" + str(round(r_val_hmc3, 3)) + \", n = \" + str(hmc3_pred.shape[0]), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIgAAAEYCAYAAACHq76lAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAHC5JREFUeJztnXu8VVW5978/NyIgEnIRTcMtqWiKEqKmqQGGl9RXO1pkpw72wY1iaErH8ihE4u3oOZJ4BS+oaSe1N7yUpmFCZpqKb8iOEjMENBRB1F7wgm2e88czt0yWa801995z3fYa389nfPa8jDXWs/b6rXF9njFlZgQChdii0gYEqpsgkEAiQSCBRIJAAokEgQQSCQIJJBIEEkgkCKSESFom6T1J62LpMEn3S1otaa2kRyQNrrSthQgCKT3HmVnP1gS8DzwADAYGAM8A91fSwCQUZlJLh6RlwKlm9mhCnj7Am0A/M3uzXLalJdQglecw4PVqFAcEgZSD+yS9HaX74jck7QRcB0yqjGnF6VJpA+qAE/I1MZL6A78Grjezn5bfrHSEGqQCSNoWF8cDZnZJpe1JIgikzEjqBTwC/N7Mzqu0PcUIAik/Xwb2B76VMz8ysNKG5SMMcwOJhBokkEgQSCCRIJBAIkEggUTqbqKsX79+1tjYWGkzKs5zzz23xsz6F8tXdwJpbGxkwYIFlTaj4khaniZfaGICiVSdQCRNlLRA0geSbkvId4qklpzJphHls7Q+qMYmZiVwMXAk0L1I3qfM7JDSm1S/VJ1AzGwOgKThwE4VNqfuqbompo18VtIaSS9KmiIpr+AljY+arQWrV68ut401TS0L5HFgb2A74ETgZODcfBnN7EYzG25mw/v3LzqyC8SoWYGY2VIze9nMNppZMzANOKnSdnU2alYgeTBAlTais1F1ApHURVI3oAFokNQtX99C0tGSBkTHewBTqOLwgVql6gQCTAbeA84DvhEdT5Y0MMex5nBgkaT1wEPAHODSShjcmak7h6Hhw4dbmGoHSc+Z2fBi+aqxBglUEUEggUSCQAKJBIEEEgkCCSQSBBJIJAgkkEgQSCCRIJBAIkEggUSCQAKJBIEEEgkCCSQSBBJIJAgkkEgQSCCRIJBAIlUXONWZaW5u5qaZ17Bs6RIaB+1B0+kTGTJkSKXNSiTUIGXi6qumM3rEgfRdNZtxez5O31W3MHrEgVx91fRKm5ZI8EktA83NzYwecSDPTH2Pgf02XV+xBg64sDtz5z9d9pok+KRWETfNvIYJIzdsJg6Agf3g9JEbuHnWtZUxLAVVJ5C02z9Eec+R9LqkdyTNlrRVmcxsE8uWLmHowJa894YObGHZ0iVltig9VScQNm3/MDspk6Qj8diZw4FGYBBwYamNaw+NgwazcEVD3nsLVzTQOKhqnydUfQIxszlmdh/+DJUkxgK3mNliM3sLuAg4pdT2tYem08/khnldWbFm8+sr1sDMeV059bSJlTEsBbU8zN2LzUMtnwcGSOqb++wVSeOB8QADB7Z/x+v2DlOHDBnC+VMu5oALJ3P6yA0MHdjCwhUNzJzXlfOnXFzVQ92qq0HaQE/gndh56/E2uRmz2P6ho8PUs86exNz5T/PW9uO49YUv8Nb245g7/2nOOrtqHxXjmFlVJrwfclvC/eeBr8bO++IR/n2Tyt1vv/2srSxatMgG9Oluy2dg9pNNafkMbECf7rZo0aI2l1lpgAWW4nuo5RpkMbBv7HxfYJWV4NFetTxM7ShVJ5C02z8APwbGSfpM9ICeycBtpbCploepHaXqBELK7R/M7GHgCmAesDxKU0thUC0PUztKmGpPQTVOlXeUtFPttTzMLRu1PEztKEEgKTnr7EmMPHw0N8+6lltfWELjoMHMnV/9y/UdJTQxdUpYzQ1kQhBIIJEgkEAiQSCBRMIopsYot+NzqEFqiEo4Podhbo2Q9WxuGOZ2Miq1ohwEUiNUakW53QKRtI+kn2VpTKAwlVpRThSIpB6SLpL0C0nTJfWSNEjSvcCTwBslsSrwMSrl+FxsmHsd8FngEeBoYAiwB3A70GRmaxJeG8iQSq0oJ45iJK0EhprZG5J2AlYAXzCz35XEmjJQq6OYVpqbm7l51rXRPMhgTj2tffMgaUcxxQTyDzPrVei8Fql1gWRFVg5DXSSNJPYsuNxzM3us3VYGqp5iAnmDzUMg38w5NzzkMdBJSRSImTWWyY5AlZJqHkRST0mjJZ0s6YuSPha9lhWS+ki6V9J6Scslfb1Avh9K+jDydG9NoTbLmKKruZLOxgOjuwFrgH7A+5KmmlkpVomuAzYAA4ChwIOSnjezxXny3m1m3yiBDYGIYhNlp+DxKeOAbma2Ay6UU4HvSfpWlsZI2hp/zPoUM1tnZk8ADwDfzPJ9Aukp1sScA4w1s3vMrAXAzFrM7G58+4WsI493B1rM7MXYtefxSP58HCdpraTFkiYUKlTS+GhTmgWrV6/O0t5OTzGBfBp4tMC935D9CCY3Yp/oPF+f5x5gT6A/0AT8QNLJ+Qq1DKL765ViAvn/wI4F7u0Y3c+SdUDuRFyvfO9jZn82s5VRjfYkMAM4KWN76p5iArkPuD4Kpv4ISd3xzuS9GdvzIj45t1vs2r54JH8xjNgEXiAbio1izsObkmWSfgW8BuyAL9y9igdXZ4aZrZc0B5gm6VR8FHM8cHBuXknHA48DbwP7A2cB52dpTzXS3NzMNbNuYsnSZewxqJGJpzVVzifVzN4BDgIuwEcv+0d/LwAONrO3S2DTGUB3fBb3p8AEM1ss6VBJ62L5vga8hDc/PwYuN7PbS2BP1TB9xtUcOGo0s9f35fGDx3HL+r4cOGo002dcXbo3TbPLTL6E798xrb2vr1Rqzw5D1cCiRYuse78Bxl3LjXm2Kd213Lr3G9DmXY4oww5DXfCaJFAGrpl1ExuOnQADcjbhGzCQDceczrU33lyS9+2oT2roFJaJJUuX0fLpoXnvtew6lCVLl5XkfTsqkPqKmagggwc10vC3hXnvNby0kMGDGkvyvomjGEmjEm53zdiWQAJnntbEnaNG895R39q8mVm1gq4PzmTiY3NL8r7Fhrm3FLm/IitDAskMGTKEiyefz+SJB7DhmNNp2XUoDS8tpOuDM7l48vmV8UntjNS6y2FzczPX3ngzS5YuY/CgRiaOP7VyPqmdkVoXSFaE0MtAJgSBBBIJAgkkUnAUIymVeMxsY3bmBKqNpGHuP0k3EZY/ojjQKUgSyC6x42NwZ5zL8D3Rdwa+D/y8dKYFqoGCAjGz5a3HkiYBw23T8v6LkhYAC4AbSmtioJKk7aR+AuiRc61HdD3QiUm7y+HtwKOSrgJeAT6Fe3B1agedrCm3N1gWpK1BvgdcDYwBpuPeXNdG1wMpqIg3WBak8SrqTKkSHmVZe4NlAVl6lMlpkvQbSYuia4dJ+mpJ1dtJqJQ3WBakbWKm4eGXNwGtn/JVfKgbKEKlvMGyIK1ATgGONbO72DR59jIl2BukDdH9knS5pDejdIWkqnSBrJQ3WBakFUgDHvUGmwTSM3YtS+LR/f8K3CApX2zueOAEPLBqH+BY4LQS2NNhzjytia6/vAFW5fhXtXqDjT+1MoalIU1HBfcsux7YCliLOytfBVyf5vVpE7A1Lo7dY9fuAP4zT94ngfGx83HAH1K8hxVKs2bN+qgTN2vWrIL5ABv/7TM/6lwOGzasYL6mpiYzM7vyqhm2Ve8+iWUuWLDgo/dvamoqmG/YsGG5Hc72fKZMwx7OAT6JB1J/Aq85Wqfbs6Qt0f17RfeK5dssuj8rQ9s6TJ30nbO4feb1Wb19+UjxixPe1+gCbIdH122fZc0Re69DgddzrjUB8/PkbQH2iJ3vRhSfm/Qe7X00e7UNUzsKWdUgUWHNwEYze8PMnjWz1zNV6SZSR/fnydsLWBfZmym1PEztKGmbmD/i1X+paUt0/+LoXrF8HaaWh6kdJe1azHzgYUm34WsxH/1KzWx2gde0GWtDdD8esD1J0kORPd8FrsnKljiDBzXy+78tpOWQ4z92r9qHqR0mTTsEzCuQHkvz+rYkoA++L8l6PO7m67apf7Iulk/AFfioam10nNj/sNAH+QhS9kEy72hWe2rvWsyVV82w7v0GWMPYqcZF91rD2KnWvd8Au/KqGe0qr9KkFUiqJibJP9XqxCd10nfOYvSokR609NStHrT02NyqX67vKKkCpyRtpIB/qpnVlE9qCJxystrMv5Vdcs53wLen+kVbDQvUFqkEYjH/1IjlksYCz1I8wDtQw3QkcKoXvkdpoBOTtpN6B5v3QXoAhwF3lsKoQPWQtg/yUs75emCmmRXahTnQSUjbB7mw1IYEqpO0PqknS9ozOt5d0m8lPSZpj9KaF6g0aTupF+PT2QBX4qOXx3EnokAnJm0fpL+ZrYr2bD8Ej9P9EH/AUKATk1YgqyXtij9Y+Vkz+0BSD8I+qZ2etAK5CHgO9+IaE107nM1d/gKdkLSjmNsk3RMdvxtdfhoPwQx0YtLWIB8JI4o9EaH/URekHebuGAUzvYnvPPRhLAU6MWmHuTPxeJXDcWfhYfjTKE8vkV2BKiFtE3MwMNDcZ9TM7HlJ4/DgpZtKZ16g0qStQVrwpgXgbUn98fWYQg88DHQS0grkaeBL0fEjwN3AHHyPskAnJm0T8002ielsPMRgGzw+N9CJSbtZ7ttmtjY6fs/MLjaz75vZa1kak3brhyjvDyV9KGldLGW+HUW9k3aYu5WkSyQtlfROdO0ISRMztift1g+t3G1mPWNpacb21D1p+yA/AvbGv7RWz7LFwISsDJG0NXAiMMXM1pnZE/hQ+ptZvUeg7aQVyJfxCLengI0AZvZ3sh3FtGXrh1aOk7RW0mJJBcUa3/5h9erVWdlbF6QVyAZyOrTRUPfNDG3pie8/EucdvDOcj3uAPXHH6SbgB5JOzpfRzG40s+FmNrx//+Bn3RbSCuRnwO2SdgGQtAO+T+pdad9I0nxJViA9Qdu2fsDM/mxmK82sxcyeBGbgfiqBDEkrkPOBZfg+Ib2BvwIrgdS+qmY2wsxUIB1C27Z+yPsWBP+UzEk7zN1gZmebWU98hLGNmZ1jZhuyMsTM1uOTb9MkbS3p8/jWD3fkyy/peEnbRrsdHoBvDX5/VvYEnGLPzR1Y4NanWnecNLMsH416BjAbeAPv30wws8WRLYcCv4pECu6LMhvfWO9V4HIzC3vHZ0yxmdRlbBrW5qu+jQwfKBRNxp1Q4N7v8I5s63neDmkgW4o1MYvw/sZkfFfDLXNSePp2JydRIGY2FB8Z9AGeAB7Cq/au0eihpfQmBipJml0O/2Rm5+JbQEzHdzR+TdKwUhsXqDxtie7fDfgCcBC+6+FbJbEoUFUUG8X0AU4GxuIzmncAh2U8cglUMcVGMSvxpzrcAfwhurZrFEQFgJk9ViLbAlVAMYG8DnTD1zqa8tw3SvBIkED1kCgQM2sskx2BKqUjW1AF6oAgkEAiQSCBRIJAAokEgQQSCQIJJBIEEkgkCCSQSBBIIJEgkEAiQSCBRIJAAolUjUAkTYzCIz+Inq5ZLP85kl6X9I6k2ZK2KoOZdUfVCAT3PbkYD2VIRNKR+BOvDgcacZeD8MCBElA1AjGzOWZ2H+nifccCt5jZYjN7C9/o95RS2levVI1A2shebL7L8/PAAEl982UO0f3tp1YFkrsTQOtx3p0AQnR/+ymLQFJE9reV3J0AWo/z7gQQaD+pt+LuCGY2IuMiF+OR//dE5/sCq8wsy/1KAlRREyOpS/Q8mgagQVI3SYUE/GNgnKTPSNoWDw29rUym1hVVIxD8S34PH75+IzqeDL7LQLSL4UAAM3sYuAKYByyP0tRKGN3ZSfVo9s5EeDS7k/bR7NVUgwSqkCCQQCJBIIFEgkACiQSBBBIJAgkkEgQSSCQIJJBIEEggkSCQQCJBIIFEgkACiQSBBBIJAgkkEgQSSCQIJJBIEEggkSCQQCJBIIFEgkACiVSNQNoS3S/pFEktkad7axpRHkvri7IETqWkNbr/SKB7ivxPRY9TDZSQqhGImc0BkDQc2KnC5gQiqqaJaQeflbRG0ouSpiRE4YXo/g5QqwJ5HNgb2A44EX8q1rmFMofo/vZTk9H9ZrbUzF42s41m1gxMw5/OGciYWo3u/9hbkP/Bz4EOUjVNTFui+yUdLWlAdLwHMAW4v3zW1g9VIxDaEN2Pb163SNJ6/GHPc4BLy29y5ydE99cpaaP7604gklbj+4l0hH7Amgq+PosydjazokO6uhNIFkhakObXV6rXZ1VGGqqpDxKoQoJAAokEgbSPGyv8+qzKKErogwQSCTVIIJEgkEAiQSCBRIJAAokEgWSAJOWcN7SznC9KuqQ9T8+S1JBrRxYEgWSDJH1C0mEAZtbS3nKAs4FmSSe24c27m1mLmVnWIgkCyYZpwCzgRkl3SfrouTWKSFOImc01s63xhxX8JCprn0L5JR0p6TJcUBdEZWQ7b2FmIXUgAfsDq4HhwNeAPwGjgTHAfm0says2zU1NBjZGaRbQLyfvFsArwHeA/wBeAA4GGmN51NHPF2qQjnMV8CMzWwB0BfYE9gCGAc9Kmg4f76fEkbQDgJl9EDUTvYCJ+MMadwX2A96Q9LXYy34ELDSzGcAvgd2BI4BrJb0q6fhMapNK/wJrOQE7AtcCPaLzVcA3Y/dPxB9+1C+hjJ2AX+B9j+2ja7OAn+XkGwfsHx33An4H7BudP4U/L2eL6Hwa8Ba+pN+xz1jpf3ItJ2BL4JO4m6SAz0fXFV3bFngGOCihjMHA5cDdwM24d/7a2JfdPc9rhNdS3fCm5pLW/NH9bXHP/4M7+hnDWkyGSJKZmaQGM2uR9EXgZjNrLJC/i5n9U1JX3I1yNDAK+CfwNTN7KV5udNwD6GVmryeU1xNYAhxqZks79JmCQNqOpO74c/JGA88Bq83s2dh9AQOAJ4FLzOyWAuX8F/BLM/ttdL4dLpAjgD7A/wPuMbMXYq+ZAeyC93vmxcUTyzMHWGdm/9bhzxoE0nYk3YVX49sBPfDHsj4E/NTMlkTO1ScDnzaz8QXKuBQ4DDjbvIMbv9cf+ApwFPB3M5sQXf8ucAIwxsxW5imzD97vOQNv7t7t8IetdDteawn4HPAGmzqmg/Hq/K/AfxN1SHGf0W0KlDEAeJtYJzISywXANcCXomsjgL2i4264D+rw1tamQNm7Antk9XmrJni7htgOeNDM3o3a/CWSpuK/3JG4ME4xsySH4n+JylguaUtgN+Be4C+4CKZIesXM5sdecyTwnJktaO1rxAuUdCxwEDA1915HCPMgbedl4CRJZ8a+iOPxUcP/AT4dn0ktwN+AAyUNxie3ZgEPmG9nMRFowcUWZwUwWFJjXACSWr/DhcBn8KYvM4JA2oh5LPDpwBhJf406hPsAd5jZ3/G9TQpOj0fMxx/p+jBwO7AIGB+V/yqwDOid85rlwOvAl3MWA1s7kROj12e7fUGl2/RaSngsc8/oeAg+eXUysFN07St4pzJNWQPx6fmDgG6x63vjnd4+0Xl8fuN8POLwUryp6xrZNAr4B94pzvYzV/qfXgsJ6A/8AB+pXIvPL+Tm2RMfln6lA+8zCvgD8IPYtZ8DX46dj8F3Y1qNT64tjez6fik+exjmpkDSXLzafwWfGu9jZifl5NkSGGlmv04op3UiLT7xdRwwF9gGOBbY3cz+I7p3Ah53DPAb4HyL5lskTQC2x2ddf27eNGVPpX+d1Z7wX/WrsfPt8BXbf41d26JIGQ3EhqVA1+hvE7Aidn1rNm9uGvDm5DZ8lLMRuAPoX67PHzqpxRkJ3AogqZuZvQH8FB/JtK7Qnldkl8Vv453aAQBmtiG6fhk+qUU0Pb/ezN6PnbfgndgWPA5mZ6ARWCbp3KjWKi2V/oVWc8JHefsAp+Zc3wd4Njo+CJ/0+tiiWnS/G/A/wNPAlfiEWG+8STk3ZQ10JPA80Uoxvj3GG8BrQO+S/g8q/SVUa8Kdd26IjhviXyTQE1+D2Rl4AjgvRXmH434bj+N7oDQCXQrkPRP4Et4h7R1dOxqvcRpj+U4q+f+h0l9EtSZ80usv+JJ+l9j1VpFchg9HX2hjuWMiUd0d1QS75HnfjVGN8wDwEu6U9Nvo+jxg23L9H8IopgCRZ/ki4EQz+1Oe+4fjo4+RFq3G5tzfEu97rMX7EL2AP+LNVgvuEdYbnyFtMrNXotf1iu4dhQ+pF+L+H+uBY4Df47Ou5fniKv1LreYE/Ao4s8C9vsDxCa+dyiaf0kvxpf+H8XmLR4DHgA3Ak7HXjMOdh7rhfZtn8JrjWxTo45Q6hcW6HCTth8+M3o9/iQfhK6xI2hn3/fxilL6QUNQD+Bd9HD53coSZrYvKGQy8iK+8romubQG8D+wF/Bq4zswOkNSEOzCPifxbnzazdzL90ElU+ldabQmfzm4GpuNrLi/hncZFuM/pM8CduMdXsbJ640J6AK85JhfJ3wV3RDoD9zm9GxiKC+0y4F3gnHL+P0IfJEY0r/EJ3A/jX/DV0WHAz/AZzeeBlWb2jzaWuwPep5iAi+ByM7u7yGvm4V5l64AF+IMOegH/NLOO7rGWnkr/Yqsl4cK4gk1edoPxmc5fAI+SM6SksMNOfMa0S/S3deQzCI9heQsYG69p4q/FwxxW4Qt6RwCzcTeDUWX/v1T6i6mWhG/EOyv3y8ZXXC/A+yOPAkMTytgqn1jwYe3x0XE3vNlovXcCPhoawaaV4meBSa0iw/sq/0YFOqoV/2KqIQEH4p3FHrFrY4iWz3EnnNHRL3mvAmX0Au7MI44TgNcS3rsBD3X4Kz7ymQL8JU++xNnWIJDSCuQ54N9j50Px6fNeOfm2TCjjGODP+AxsfGLtf/B5jmKv740vyn2Ae5h1y62RgkAqI47Wmcu9iFZScY+vuE/GoOjLS/qCt8KHrkNzrvdooz274pFyv8E7yn0r+f8Jq7m+NjIH+L/AmZLOAj5lZtNieWYDq8zsw0KFmNkHuEBG5Vx/F0DSJ9MYYx4sdTA+m3orMDb9R8meup4okzQO9yj/Oh6lfyVwADArFqV2FO7EM6JAGYcCu5rZrfjM66HRdeG10mfwuZCRkj5r0WRZEuZVyS+j+JitO/gxO0Td1iCxmcu98dHJjmb2OdzH9AjgvujLvx6fPCvEcODbkm7CHZYPifbqWIo3E2fgU+pnpRFHHDPbYGZvte2TZUtdT5TJn0ezF/B5XBiv4TOWfwEuBP4d+KMV2BNdUiM+wvkkPqU+FK+B7sKbpcXA2qj5qUnqWiBxCsxcdgUwD2fIzb8D3m+5FK8pdsD7Dl+Kju8xs5llMb6E1GUTI6l39FfR3/3wvsJxeM2xDb7msmc+cUTcjPum/s7M3jezl/E1l4fwoe0ISX+QdFBJP0yJqbtOauQp/m1Jl+A1xTpgJr4+skLSSrz/MB/3vchXxueAYWZ2TOzaRcAheJOzEncu3h93DaxZ6k4g+NrKbsBNwJ2SNuJT3NMBzMMaX5K01Mw2FiijP96sIGlr4KvA94Dv4+ssp+Md4O9ajbfhddsHiZqZq/DO6W34ZnCWpkMpaQi+XvJf+I/sKOB6M7spun8d8IGZTSqN9eWjLvsgAGb2tpmdgo9i9gEeBI6R1DfFa5vxMMuj8Wbk0lZxROyLuxLWPHVbg8SJOqvHAD8BLmxtblK+truZvRcdN+CTbheb2c4lMbbM1GMf5GN0ZOYyJo4ueN/jVKJgqM5AqEEyIhLInviM7MOVticrgkACidRtJzWQjiCQQCJBIIFEgkACiQSBBBIJAgkkEgQSSOR/AYnwLwadOFJDAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Plot individual example: F2 variants (measurements, 77 to 127)\n", + "\n", + "save_figs = True\n", + "fig_name = \"F2_example_measured_lor_77_127\"\n", + "\n", + "plot_title = \"F2\"\n", + "\n", + "test_ixs = [9, 11]\n", + "test_colors = ['orange', 'deepskyblue']\n", + "\n", + "min_y = -1.6\n", + "max_y = 1.6\n", + "\n", + "f = plt.figure(figsize=(2, 4))\n", + "\n", + "for test_ix, test_color in zip(test_ixs, test_colors) :\n", + " \n", + " hek_true = hek_df.iloc[test_ix]['delta_logodds_true_77_127_repl_pooled']\n", + " sknsh_true = sknsh_df.iloc[test_ix]['delta_logodds_true_77_127_repl_pooled']\n", + " hmc3_true = hmc3_df.iloc[test_ix]['delta_logodds_true_77_127_repl_pooled']\n", + " \n", + " plt.scatter([0, 1, 2], [hek_true, sknsh_true, hmc3_true], s=55, color=test_color, edgecolor='black', linewidth=1)\n", + "\n", + "plt.axhline(y=0., linewidth=2, linestyle='--', color='black')\n", + "\n", + "plt.xlim(-1, 3)\n", + "plt.ylim(min_y, max_y)\n", + "\n", + "plt.xticks([0, 1, 2], [\"HEK293\", \"SK-N-SH\", \"HMC3\"], fontsize=12, rotation=60)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(plot_title, fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Plot individual example: SCAF8 variants (measurements, 77 to 127)\n", + "\n", + "save_figs = True\n", + "fig_name = \"SCAF8_example_measured_lor_77_127\"\n", + "\n", + "plot_title = \"SCAF8\"\n", + "\n", + "test_ixs = [99, 13]\n", + "test_colors = ['orange', 'deepskyblue']\n", + "\n", + "min_y = -1.6\n", + "max_y = 1.6\n", + "\n", + "f = plt.figure(figsize=(2, 4))\n", + "\n", + "for test_ix, test_color in zip(test_ixs, test_colors) :\n", + " \n", + " hek_true = hek_df.iloc[test_ix]['delta_logodds_true_77_127_repl_pooled']\n", + " sknsh_true = sknsh_df.iloc[test_ix]['delta_logodds_true_77_127_repl_pooled']\n", + " hmc3_true = hmc3_df.iloc[test_ix]['delta_logodds_true_77_127_repl_pooled']\n", + " \n", + " plt.scatter([0, 1, 2], [hek_true, sknsh_true, hmc3_true], s=55, color=test_color, edgecolor='black', linewidth=1)\n", + "\n", + "plt.axhline(y=0., linewidth=2, linestyle='--', color='black')\n", + "\n", + "plt.xlim(-1, 3)\n", + "plt.ylim(min_y, max_y)\n", + "\n", + "plt.xticks([0, 1, 2], [\"HEK293\", \"SK-N-SH\", \"HMC3\"], fontsize=12, rotation=60)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(plot_title, fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIgAAAEYCAYAAACHq76lAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAHbVJREFUeJztnXmYVNW1t9+fjcgcZBBNFDtExQkl2ME4gwQnVMzVXMSbBPIgiIpETUyMYnBA/Mz9RIlEwQmMGdTcOEavCYngEMf2i9LhKsYgYKICKpILDmi7vj/WaSnKqlOnuk91VXft93nO06fO2WfXqq5f7XGtvWVmBAL52KrcBgQqmyCQQCxBIIFYgkACsQSBBGIJAgnEEgRSAUjqL2mDpJpy25JNEEgzkbRC0vvRF7tO0gOSdmpOXma2ysy6mVlj2na2lCCQlnGcmXUDdgBWA9fmSlSJJUNSgkBSwMw+AP4L2BNA0gJJ10t6UNJGYLikUZL+Iulfkl6TdHHT85JqJZmkDtHrxZIuk/RnSf8r6Q+S+pTjswWBpICkLsAY4KmMy6cAlwPdgceBjcC3gZ7AKOB0SSfEZHsK8B1gO6Aj8P30LS9Mh3K8aTviHkkfA92ANcCRGffuNbM/R+cfAIsz7i2R9GvgMOCePHnPN7OXASTdCRyfpuFJCSVIyzjBzHoC2wBTgEckbR/dey0zoaT9JS2StFbSemAyEFdtvJlx/h4uwlYnCCQFzKzRzO4CGoGDmy5nJfsVcB+wk5l9DpgLqPWsbB5BICkgZzSwLfBinmTdgXfM7ANJQ/E2RsUT2iAt435JjXhpsRIYZ2ZLpZwFwxnAVZLmAI8Ad+IN1opGwWEoEEeoYgKxBIEEYgkCCcQSBBKIpep6MX369LHa2tpym1F2nnvuubfMrG+hdFUnkNraWurr68ttRtmRtDJJulDFBGKpOIFImiKpXtKHkhbEpBsvqTFy2Gk6hrWepdVBJVYxrwMz8JnRzgXSPmlmBxdIE2gBFSeQaNILSXXAjmU2p+qpuCqmSL4s6S1JL0u6qMkjKxtJk6Jqq37t2rWtbWObpi0L5FFgb9zj6kRgLHBeroRmdoOZ1ZlZXd++BXt2gQzarEDMbLmZvWpmn5hZA3ApcFK57WpvtFmB5MBoAw44bY2KE4ikDpI6ATVAjaROudoWko6W1C863x24CLi3da1t/1ScQIBpwPvA+cA3o/NpGdFn/aN0I3Dn343Ag8BdwMxyGNyeqTqHobq6OgtD7SDpOTOrK5SuEkuQQAURBBKIJQgkEEsQSCCWIJBALEEggViCQAKxBIEEYgkCCcQSBBKIJQgkEEsQSCCWIJBALEEggViCQAKxBIEEYgkCCcQSBBKIJQgkEEsQSCCWIJBALBUnkKTLP0Rpz5H0pqT1km6RtE0rmVk1VJxA2Lz8wy1xiSQdicfOjABqgQHAJaU2rtqoOIGY2V1mdg/wdoGk44CbzWypma0DLgPGl9q+ltDQ0MDUMydx/NGHMfXM02hoaCi3SQWpOIEUwV7ACxmvXwD6SeqdnbASln/46TWzGDlsf3qvvoUJezxK79U3M3LY/vz0mlllsScxZlaRB17NLIi5/3fgqIzXW+MB3LVx+e63337W2ixZssT69epsK2dj9svNx8rZWL9enW3JkiVF5XXWGRPtuKMOtbPOmFTUs5kA9Zbge2jLJcgGoEfG66bz/y2DLbHcOPdaTh++if5Zu8P07wOTh2/ipnlzEuVTjlKo4pagKoKlwL74rglE56vNrFDbpdVZsXwZI/bIvaHl4P6NzH9pWcE8GhoamHnZNJ6Z/v6nQhtd18h3Dn2foZdMY/iIkQwaNChNs4EKbIMkXf4B+DkwQdKekrbFVwVY0IqmJqZ2wECeX5V748vnV9VQO2BgwTzSKoWKpeIEQsLlH8zsIeAnwCJ8r5aVwPTymBzPxMlncf2ijqx6a8vrq96CuYs6cuppUwrmsWL5Mgb3z18KrVheuBRqDhVXxZjZxcDFeW5vsW+bmc0CKrwbAIMGDeKCi2Yw9JJpTB6+icH9G3l+VQ1zF3XkgotmJKoavBT6M6PrPiuSpKVQc6jEEqRdMvXsc1m4+GnWbT+B+S8dxrrtJ7Bw8dNMPfvcRM+nUQo1iyRdnfZ0lKObmxazr77K+vXqbNNPrLG7z8Gmn1hj/Xp1ttlXX1V0XiTs5lZcFRPIz9Szz2X4iJHcNG8O819aRu2AgSxcPKUkvZcmwhJUVUpYgiqQCkEggViCQAKxhEZqETQ0NHDj3GtZsXwZtQN2Z+Lk0jYQK4FQgiSkzU7Xt5DQi0lAQ0MDI4ftv8VEGfgg1dBLOrNw8dNtriQJvZgUKddEWSUQBJKAck2UVQLNFoikfST9Jk1jKpU0puvbKrECkdRF0mWS7pc0S1IPSQMk3Q08AaxpHTPLS9kmyiqAQt3cnwFfBn4PHA0MAnYHbgUmmtlbMc+2G9KYrm+rxPZiJL0ODDazNZJ2BFYBh5nZY61lYNq0ZC6moaGBm+bNicZBBnLqaW13HCRpL6aQQP5lZj3yvW6LhMk6J6lAClUxHSQNJ2MvuOzXZvZws60MVDyFBLKGLUMg3856bXjIY6CdEisQM6ttJTsCFUqicRBJ3SSNlDRW0tckdS+VQZJ6Sbpb0kZJKyWdkifdxZI+ijzdm45QmqVMwdlcSWfjgdGdgLeAPsAHkqabe5Wnzc+ATUA/YDDwgKQXzGxpjrR3mNk3S2BDIKLQQNl4PD5lAtDJzHbAhXIq8ANJ30nTGEld8W3WLzKzDWb2OHAf8K003yeQnEJVzDnAODO708waAcys0czuwJdfSOazn5zdgEYzeznj2gt4JH8ujpP0jqSlkk7Pl2la0f0NDQ1MmjKVw445ntOmTG0Tyze0lEIC+RLwxzz3/kT6PZhuwPqsa+uBXG2eO4E9gL7ARODHksbmytTMbjCzOjOr69u3b7MMmzX7p+x/+Ehu2dibRw+cwM0be7P/4SOZNfunifNokwKLi4kA3gD657m3M/BmktiKpAc+rP9e1rXvAfcnePZ84LeF0jUnLmbJkiXWuU8/4/aVxiLbfNy+0jr36ZdoCYarrpltnfv0s5rxFxuX3WM14y+2zn362VXXzC7anjQgpeUf7gGui4KpP0VSZ7wxeXdaQo14GR+c2zXj2r54JH8hjIwBvDS5dt6NbDr2dOjXf8sb/fqzadRk5txwU+zzDQ0NTJsxk/fnPEPjuOlw8Ggax03n/TnPMG3GzKJKktYuhQoJ5Hxge2CFpPmSZkqaD7waXf9RmsaY2UbgLuBSSV0lHQSMBm7LTitptKRt5QwFpgL3pmlPE8uWr6DxS4Nz3mvcZTDLlq+Ifb6lAmsijWquWGIFYmbrgQOAC/Hey1eivxcCB5rZuyWw6QygMz6K+2vgdDNbKukQSRsy0p0MvIIvGPNz4Eozu7UE9jBwQC01f38+572aV55n4IDa2OdbKjBItxQqhoIDZWb2kZndbGZjzWxk9PdmoFHSpWkbZGbvmNkJZtbVzPqb2a+i64+ZWbeMdGPNrLeZdTOz3c2sZD+js06bSMffXQ+rV215Y/UqOj4wlymTTo19vqUCg/RKoWJpicthB7wkafcMGjSIGdMuoPOUodQsuBgev4eaBRfTecpQZky7oOCUf0sFBumUQs2hpT6pJWkUViLnfncqTz+8kAnd13HYk/OZ0H0dTz+8kHO/O7Xgsy0VGKRTCjWLJF2dXAewDT6oVfYlHYo5yrn8w5IlS2zSlKl22DHH26QpU4te3bClXe1MSGP5B0mHx9zumKJOq4JBgwYx79rZzX52xrQLmDZlKJtGTaZxl8HUvPI8HR+Ym7gUag6FPMpeLZSBmX0xVYtKTFv3KGtoaGDODTexbPkKBg6oZcqkU5sljlRcDtsjbV0gaREi6wKpEAQSiCUIJBBLEEgglrzdXEmJxGNmn6RnTqDSiBsH+RifQi9E7qjmQLsgTiCZ4xujgJOAK/A10XcGfgj8tnSmBSqBvAIxs5VN55LOBeps8/T+y5LqgXrg+tKaGCgnSRupnwO6ZF3rEl0PtGOSrnJ4K/BHSdcArwE74R5cJXHQCVQOSQXyA9x7awzwedyZeQ5wY4nsClQIiQQSdWXnRkegikgamytJEyX9SdKS6Nqhkv69tOYFyk3SRuqlePjljUCTU+Q/8K5uoB2TVCDjgWPN7HY2D569SgnWBikiul+SrpT0dnT8RFLVuEC2FkkbqTX4PrWwWSDdMq6lSdLo/knACXhglQELgeWEdlK6JPFLBG4GrsP9UN/BnZWvAa5L8nzSA+iKi2O3jGu3Af8nR9ongEkZrycATyV4D8t3zJs371OfzXnz5uVN5/+2zQwZMiRvuokTJ36arr6+PjbP+vr6T9NOnDgxb7ohQ4Zk+5c25zOluvP2OXj3dj0+OLaBzcPtaVJMdP9e0b1C6baI7k/N0mohwS9OeFujA7AdHl23fZolR8Z7HUJWQDgeub84R9pGYPeM17sSxefGvUdb3tQwTUhrU0MzM0kNQHczW0NpV1feAGQvs9kDD68slLYHsCH68IGUSFrF/AUv/ktNMdH9S6N7hdIFWkDSXsxi4CFJC/C5mE9/pWZ2S55nisbMNkpqiu4/Fe/FjAYOzJH858C5kh6M7PkecG1atgScpAI5CB/3OCzrurHluqlpcEaU5xp8XdZPo/uB/7bNAdzz8LZRU1j7TdG1QIqEuJgqJa2luJsyy9tWseCT2q5JWsXE+acGn9R2TFKBZMff7oAvT3V/uuYEKo2k/iArsy6tlDQOeBYfhg+0U1oSONUDX6M00I5J2ki9jS3bIF2AQ4FflMKoQOWQtA3yStbrjcBcM8u3CnOgnZC0DXJJqQ0JVCZJfVLHStojOt9N0iOSHpa0e2nNC5SbpI3UGbijEMBVeO/lUdyJKNCOSdoG6Wtmq6M12w/G43Q/wjcYCrRjkgpkraRd8I2VnzWzDyV1oYrWSa1WkgrkMuA53ItrTHRtBFu6/AXaIUl7MQsk3RmdvxddfhpfUD/QjklagnwqjCj2RIT2R1WQtJv7hSiY6W18ZvejjCPQjknazZ2Lx6uMwJ2Fh+C7UU4ukV2BCiFpFXMgvnfdRklmZi9ImoAHL4UlINoxSUuQRrxqAXhXUl98PuYLJbEqUDEkFcjTwDHR+e+BO/C95YJzZzsnaRXzLTaL6Ww8xKA7Hp8baMckXSz3XTN7Jzp/38xmmNkPzeyNNI1JuvRDlPZiSR9J2pBxpL4cRbWTtJu7jaTLJS2XtD66doSkKSnbk7n0w38A10vKty07wB3mmxo2HctTtqfqSdoGuRrYG//SmjzLlgKnp2WIpK7AicBFZrbBzB7Hu9LfSus9AsWTVCBfB04xsyeBTwDM7J+k24spZumHJo6T9I6kpZLyijVz+Ye1a9emZW9VkFQgm8hq0EZd3bdTtKUbvv5IJuvxxnAu7gT2wB2nJwI/ljQ2V0Izu8HM6sysrm/f4GddDEkF8hvgVklfBJC0A75O6u1J30jSYkmW53ic4pZ+wMz+x8xeN7NGM3sCmI37qQRSJKlALgBW4IHSPYG/Aa8DiX1VzWyYmSnPcTDFLf2Q8y0I/impk7Sbu8nMzo4i6/vhi8mcY2ab0jLEzDbig2+XSuoq6SB86YfbcqWXNFrSttFqh0PxpcHvTcuegFNo39z+eW7t1LTipJmtypOmOeRc+iGyJXv5h5OjtNvga7ZeaWZh7fiUKTSSuoLN3dpcxbeRYvB2NBh3Qp57j+EN2abXORukgXQpVMUswdsb0/BVDbfOOsLu2+2cWIGY2WC8Z9ALeBx4EC/aO0a9h8bSmxgoJwUbqWb2VzM7D18CYhZwLPCGpCGlNi5QfoqJ7t8VX6PsAHzVw3UlsShQURTqxfQCxgLj8BHN24BDU+65BCqYQr2Y1/HVDW8Dnoqu7RIFUQFgZg+XyLZABVBIIG8CnfC5jok57hsl2BIkUDnECsTMalvJjkCF0pIlqAJVQBBIIJYgkEAsQSCBWIJAArEEgQRiCQIJxBIEEoglCCQQSxBIIJYgkEAsQSCBWCpGIJKmROGRH0a7axZKf46kNyWtl3SLpG1awcyqo2IEgvuezCDBLpqSjsR3vBoB1OIuB2HDgRJQMQIxs7vM7B6SxfuOA242s6Vmtg5f6Hd8Ke2rVipGIEWyF1uu8vwC0E9S71yJQ3R/82mrAsleCaDpPOdKACG6v/m0ikASRPYXS/ZKAE3nOVcCCDSfxEtxtwQzG5ZylkvxyP87o9f7AqvNLM31SgJUUBUjqUO0H00NUCOpk6R8Av45MEHSnpK2xUNDF7SSqVVFxQgE/5Lfx7uv34zOp4GvMhCtYtgfwMweAn4CLAJWRsf0chjd3pFZvh3X2yd1dXVWXx/W/5X0nJnVFUpXSSVIoAIJAgnEEgQSiCUIJBBLEEggliCQQCxBIIFYgkACsQSBBGIJAgnEEgQSiCUIJBBLEEggliCQQCxBIIFYgkACsQSBBGIJAgnEEgQSiCUIJBBLxQikmOh+SeMlNUae7k3HsNaxtLpolcCphDRF9x8JdE6Q/sloO9VACakYgZjZXQCS6oAdy2xOIKJiqphm8GVJb0l6WdJFMVF4Ibq/BbRVgTwK7A1sB5yI74p1Xr7EIbq/+bTJ6H4zW25mr5rZJ2bWAFyK784ZSJm2Gt3/mbcg98bPgRZSMVVMMdH9ko6W1C863x24CLi39aytHipGIBQR3Y8vXrdE0kZ8s+e7gJmtb3L7J0T3VylJo/urTiCS1uLribSEPsBbZXw+jTx2NrOCXbqqE0gaSKpP8usr1fNp5ZGESmqDBCqQIJBALEEgzeOGMj+fVh4FCW2QQCyhBAnEEgQSiCUIJBBLEEggliCQFJCkrNc1zczna5Iub87uWZJqsu1IgyCQdJCkz0k6FMDMGpubD3A20CDpxCLevLOZNZqZpS2SIJB0uBSYB9wg6XZJn+5bo4gkmZjZQjPrim9W8Msor33ypZd0pKQrcEFdGOWR7riFmYWjBQfwFWAtUAecDPwVGAmMAfYrMq9t2Dw2NQ34JDrmAX2y0m4FvAZ8F/gR8BJwIFCbkUYt/XyhBGk51wBXm1k90BHYA9gdGAI8K2kWfLadkomkHQDM7MOomugBTME3a9wF2A9YI+nkjMeuBp43s9nA74DdgCOAOZL+IWl0KqVJuX+BbfkAvgDMAbpEr1cD38q4fyK++VGfmDx2BO7H2x7bR9fmAb/JSjcB+Ep03gN4DNg3ev0kvl/OVtHrS4F1+JR+yz5juf/JbfkAtgY+j7tJCjgouq7o2rbAM8ABMXkMBK4E7gBuwr3z38n4sjvneEZ4KdUJr2oub0of3d8W9/w/sKWfMczFpIgkmZlJqjGzRklfA24ys9o86TuY2ceSOuJulCOBw4GPgZPN7JXMfKPzLkAPM3szJr9uwDLgEDNb3qLPFARSPJI64/vkjQSeA9aa2bMZ9wX0A54ALjezm/Pk85/A78zskej1drhAjgB6Af8PuNPMXsp4ZjbwRbzdsyhTPBlp7gI2mNm3W/xZg0CKR9LteDG+HdAF35b1QeDXZrYscq4eC3zJzCblyWMmcChwtnkDN/NeX+AbwFHAP83s9Oj694ATgDFm9nqOPHvh7Z4z8OruvRZ/2HLX423tAL4KrGFzw3QgXpz/Dfi/RA1S3Ge0e548+gHvktGIjMRyIXAtcEx0bRiwV3TeCfdBrWuqbfLkvQuwe1qft2KCt9sQ2wEPmNl7UZ2/TNJ0/Jc7HBfGeDOLcyj+tyiPlZK2BnYF7gZexEVwkaTXzGxxxjNHAs+ZWX1TWyMzQ0nHAgcA07PvtYQwDlI8rwInSTor44sYjfcajge+lDmSmoe/A/tLGogPbs0D7jNfzmIK0IiLLZNVwEBJtZkCkNT0HT4P7IlXfakRBFIk5rHAk4Exkv4WNQj3AW4zs3/ia5vkHR6PWIxv6foQcCuwBJgU5f8PYAXQM+uZlcCbwNezJgObGpFToufTXb6g3HV6WzrwWOZu0fkgfPBqLLBjdO0beKMySV798eH5A4BOGdf3xhu9vaLXmeMbF+ARhzPxqq5jZNPhwL/wRnG6n7nc//S2cAB9gR/jPZU5+PhCdpo98G7pN1rwPocDTwE/zrj2W+DrGa/H4KsxrcUH15ZHdv2wFJ89dHMTIGkhXuy/hg+N9zKzk7LSbA0MN7M/xOTTNJCWOfB1HLAQ6A4cC+xmZj+K7p2Axx0D/Am4wKLxFkmnA9vjo66/Na+a0qfcv85KP/Bf9T8yXm+Hz9j+R8a1rQrkUUNGtxToGP2dCKzKuN6VLaubGrw6WYD3cj4BbgP6ttbnD43UwgwH5gNI6mRma4Bf4z2Zphna8wussngm3qjtB2Bmm6LrV+CDWkTD8xvN7IOM1414I7YRj4PZGagFVkg6Lyq1Sku5f6GVfOC9vH2AU7Ou7wM8G50fgA96fWZSLbrfCfgV8DRwFT4g1hOvUs5LWAIdCbxANFOML4+xBngD6FnS/0G5v4RKPXDnneuj85rMLxLohs/B7Aw8DpyfIL8RuN/Go/gaKLVAhzxpzwKOwRukPaNrR+MlTm1GupNK/n8o9xdRqQc+6PUiPqXfIeN6k0iuwLujLxWZ75hIVHdEJcEXc7zvJ1GJcx/wCu6U9Eh0fRGwbWv9H0IvJg+RZ/kS4EQz+2uO+yPw3sdwi2Zjs+5vjbc93sHbED2Av+DVViPuEdYTHyGdaGavRc/1iO4dhXepn8f9PzYCo4A/46OurfPFlfuXWskH8N/AWXnu9QZGxzw7nc0+pTPxqf+H8HGL3wMPA5uAJzKemYA7D3XC2zbP4CXHd8jTxin1ESbrspC0Hz4yei/+JR6Az7AiaWfc9/Nr0XFYTFb34V/0cfjYyRFmtiHKZyDwMj7z+lZ0bSvgA2Av4A/Az8xsqKSJuAPzmMi/9WkzW5/qh46j3L/SSjvw4ewGYBY+5/IK3mhcgvucPgP8Avf4KpRXT1xI9+Elx7QC6Tvgjkhn4D6ndwCDcaFdAbwHnNOa/4/QBskgGtf4HO6H8W/47OgQ4Df4iOYLwOtm9q8i890Bb1OcjovgSjO7o8Azi3Cvsg1APb7RQQ/gYzNr6RprySn3L7ZSDlwYP2Gzl91AfKTzfuCPZHUpye+wkzli2iH629TzGYDHsKwDxmWWNJnP4mEOq/EJvSOAW3A3g8Nb/f9S7i+mUg58Id552V82PuN6Id4e+SMwOCaPbXKJBe/Wjo7OO+HVRtO9E/De0DA2zxQ/C5zbJDK8rfJtytBQLfsXUwkHsD/eWOyScW0M0fQ57oQzMvol75Unjx7AL3KI4wTgjZj3rsFDHf6G93wuAl7MkS52tDUIpLQCeQ74fsbrwfjweY+sdFvH5DEK+B98BDZzYO1X+DhHoed74pNyH+IeZp2yS6QgkPKIo2nkci+imVTc4yvTJ2NA9OXFfcHb4F3XwVnXuxRpzy54pNyf8IZy73L+f8Jsrs+N3AX8F3CWpKnATmZ2aUaaW4DVZvZRvkzM7ENcIIdnXX8PQNLnkxhjHix1ID6aOh8Yl/yjpE9VD5RJmoB7lJ+CR+lfBQwF5mVEqR2FO/EMy5PHIcAuZjYfH3k9JLouvFTaEx8LGS7pyxYNlsVhXpT8LoqP6drCj9kiqrYEyRi53BvvnXzBzL6K+5geAdwTffnX4YNn+agDzpR0I+6wfHC0VsdyvJo4Ax9Sn5pEHJmY2SYzW1fcJ0uXqh4ok+9HsxdwEC6MN/ARyxeBS4DvA3+xPGuiS6rFezifx4fUB+Ml0O14tbQUeCeqftokVS2QTPKMXHYEMA9nyE6/A95umYmXFDvgbYdjovM7zWxuqxhfQqqyipHUM/qr6O9+eFvhOLzk6I7PueyRSxwRN+G+qY+Z2Qdm9io+5/Ig3rUdJukpSQeU9MOUmKprpEae4mdKuhwvKTYAc/H5kVWSXsfbD4tx34tceXwVGGJmozKuXQYcjFc5r+POxV/BXQPbLFUnEHxuZVfgRuAXkj7Bh7hnAZiHNb4iabmZfZInj754tYKkrsC/Az8AfojPs0zGG8DfszZeh1dtGySqZq7BG6cL8MXgLEmDUtIgfL7kP/Ef2VHAdWZ2Y3T/Z8CHZnZuaaxvPaqyDQJgZu+a2Xi8F7MP8AAwSlLvBM824GGWR+PVyMwmcUTsi7sStnmqtgTJJGqsjgJ+CVzSVN0kfLazmb0fndfgg24zzGznkhjbylRjG+QztGTkMkMcHfC2x6lEwVDtgVCCpEQkkD3wEdmHym1PWgSBBGKp2kZqIBlBIIFYgkACsQSBBGIJAgnEEgQSiCUIJBDL/we6/ePi0SZK3wAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Plot individual example: Brain-specific aQTL (measurements, 77 to 127)\n", + "\n", + "save_figs = True\n", + "fig_name = \"brain_aQTL_example_measured_lor_77_127\"\n", + "\n", + "plot_title = \"Brain\"\n", + "\n", + "test_ixs = [6, 99]\n", + "test_colors = ['orange', 'deepskyblue']\n", + "\n", + "min_y = -1.6\n", + "max_y = 1.6\n", + "\n", + "f = plt.figure(figsize=(2, 4))\n", + "\n", + "for test_ix, test_color in zip(test_ixs, test_colors) :\n", + " \n", + " hek_true = hek_df.iloc[test_ix]['delta_logodds_true_77_127_repl_pooled']\n", + " sknsh_true = sknsh_df.iloc[test_ix]['delta_logodds_true_77_127_repl_pooled']\n", + " hmc3_true = hmc3_df.iloc[test_ix]['delta_logodds_true_77_127_repl_pooled']\n", + " \n", + " plt.scatter([0, 1, 2], [hek_true, sknsh_true, hmc3_true], s=55, color=test_color, edgecolor='black', linewidth=1)\n", + "\n", + "plt.axhline(y=0., linewidth=2, linestyle='--', color='black')\n", + "\n", + "plt.xlim(-1, 3)\n", + "plt.ylim(min_y, max_y)\n", + "\n", + "plt.xticks([0, 1, 2], [\"HEK293\", \"SK-N-SH\", \"HMC3\"], fontsize=12, rotation=60)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(plot_title, fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Plot individual example: Brain-specific GWAS SNP (measurements, 77 to 127)\n", + "\n", + "save_figs = True\n", + "fig_name = \"gwas_example_measured_lor_77_127\"\n", + "\n", + "plot_title = \"GWAS\"\n", + "\n", + "test_ixs = [17, 99]\n", + "test_colors = ['orange', 'deepskyblue']\n", + "\n", + "min_y = -1.6\n", + "max_y = 1.6\n", + "\n", + "f = plt.figure(figsize=(2, 4))\n", + "\n", + "for test_ix, test_color in zip(test_ixs, test_colors) :\n", + " \n", + " hek_true = hek_df.iloc[test_ix]['delta_logodds_true_77_127_repl_pooled']\n", + " sknsh_true = sknsh_df.iloc[test_ix]['delta_logodds_true_77_127_repl_pooled']\n", + " hmc3_true = hmc3_df.iloc[test_ix]['delta_logodds_true_77_127_repl_pooled']\n", + " \n", + " plt.scatter([0, 1, 2], [hek_true, sknsh_true, hmc3_true], s=55, color=test_color, edgecolor='black', linewidth=1)\n", + "\n", + "plt.axhline(y=0., linewidth=2, linestyle='--', color='black')\n", + "\n", + "plt.xlim(-1, 3)\n", + "plt.ylim(min_y, max_y)\n", + "\n", + "plt.xticks([0, 1, 2], [\"HEK293\", \"SK-N-SH\", \"HMC3\"], fontsize=12, rotation=60)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.ylabel(\"Measured LOR\", fontsize=12)\n", + "\n", + "plt.title(plot_title, fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:tensorflow]", + "language": "python", + "name": "conda-env-tensorflow-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 +} diff --git a/data/oligo_pool_2022/medium_library/process_reads_hek293.ipynb b/data/oligo_pool_2022/medium_library/process_reads_hek293.ipynb new file mode 100644 index 0000000..8dfe2ea --- /dev/null +++ b/data/oligo_pool_2022/medium_library/process_reads_hek293.ipynb @@ -0,0 +1,1851 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import scipy\n", + "import scipy.io as spio\n", + "import scipy.sparse as sp\n", + "\n", + "import regex as re\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(barcode_dict) = 201500\n" + ] + } + ], + "source": [ + "#Load reference library dataframe and build barcode dictionary\n", + "\n", + "library_df = pd.read_csv(\"apa_100_variants_rev2_20220621_pred.csv\", sep='\\t')\n", + "\n", + "#Build dictionary (double-mutation support)\n", + "bases = ['A', 'C', 'G', 'T']\n", + "\n", + "barcode_dict = {}\n", + "sequences = []\n", + "for i, [_, row] in enumerate(library_df.iterrows()) :\n", + " bc = row['ref_barcode']\n", + " \n", + " sequences.append(row['ref_seq'])\n", + " \n", + " barcode_dict[bc] = i\n", + " for pos1 in range(len(bc)) :\n", + " for pos2 in range(pos1, len(bc)) :\n", + " for b1 in bases :\n", + " for b2 in bases :\n", + " bc_mut = bc[:pos1] + b1 + bc[pos1+1:pos2] + b2 + bc[pos2+1:]\n", + " \n", + " if bc_mut in barcode_dict and barcode_dict[bc_mut] != i :\n", + " print(\"[ERROR] Barcode dictionary collision.\")\n", + " else :\n", + " barcode_dict[bc_mut] = i\n", + "\n", + "print(\"len(barcode_dict) = \" + str(len(barcode_dict)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'GATGCAGCTGGCTATCATGA': 0,\n", + " 'AAATGCAGCTGGCTATCATGA': 0,\n", + " 'ACATGCAGCTGGCTATCATGA': 0,\n", + " 'AGATGCAGCTGGCTATCATGA': 0,\n", + " 'ATATGCAGCTGGCTATCATGA': 0,\n", + " 'CAATGCAGCTGGCTATCATGA': 0,\n", + " 'CCATGCAGCTGGCTATCATGA': 0,\n", + " 'CGATGCAGCTGGCTATCATGA': 0,\n", + " 'CTATGCAGCTGGCTATCATGA': 0,\n", + " 'GAATGCAGCTGGCTATCATGA': 0,\n", + " 'GCATGCAGCTGGCTATCATGA': 0,\n", + " 'GGATGCAGCTGGCTATCATGA': 0,\n", + " 'GTATGCAGCTGGCTATCATGA': 0,\n", + " 'TAATGCAGCTGGCTATCATGA': 0,\n", + " 'TCATGCAGCTGGCTATCATGA': 0,\n", + " 'TGATGCAGCTGGCTATCATGA': 0,\n", + " 'TTATGCAGCTGGCTATCATGA': 0,\n", + " 'AATGCAGCTGGCTATCATGA': 0,\n", + " 'ACTGCAGCTGGCTATCATGA': 0,\n", + " 'AGTGCAGCTGGCTATCATGA': 0,\n", + " 'ATTGCAGCTGGCTATCATGA': 0,\n", + " 'CATGCAGCTGGCTATCATGA': 0,\n", + " 'CCTGCAGCTGGCTATCATGA': 0,\n", + " 'CGTGCAGCTGGCTATCATGA': 0,\n", + " 'CTTGCAGCTGGCTATCATGA': 0,\n", + " 'GCTGCAGCTGGCTATCATGA': 0,\n", + " 'GGTGCAGCTGGCTATCATGA': 0,\n", + " 'GTTGCAGCTGGCTATCATGA': 0,\n", + " 'TATGCAGCTGGCTATCATGA': 0,\n", + " 'TCTGCAGCTGGCTATCATGA': 0,\n", + " 'TGTGCAGCTGGCTATCATGA': 0,\n", + " 'TTTGCAGCTGGCTATCATGA': 0,\n", + " 'AAAGCAGCTGGCTATCATGA': 0,\n", + " 'AACGCAGCTGGCTATCATGA': 0,\n", + " 'AAGGCAGCTGGCTATCATGA': 0,\n", + " 'CAAGCAGCTGGCTATCATGA': 0,\n", + " 'CACGCAGCTGGCTATCATGA': 0,\n", + " 'CAGGCAGCTGGCTATCATGA': 0,\n", + " 'GAAGCAGCTGGCTATCATGA': 0,\n", + " 'GACGCAGCTGGCTATCATGA': 0,\n", + " 'GAGGCAGCTGGCTATCATGA': 0,\n", + " 'TAAGCAGCTGGCTATCATGA': 0,\n", + " 'TACGCAGCTGGCTATCATGA': 0,\n", + " 'TAGGCAGCTGGCTATCATGA': 0,\n", + " 'AATACAGCTGGCTATCATGA': 0,\n", + " 'AATCCAGCTGGCTATCATGA': 0,\n", + " 'AATTCAGCTGGCTATCATGA': 0,\n", + " 'CATACAGCTGGCTATCATGA': 0,\n", + " 'CATCCAGCTGGCTATCATGA': 0,\n", + " 'CATTCAGCTGGCTATCATGA': 0,\n", + " 'GATACAGCTGGCTATCATGA': 0,\n", + " 'GATCCAGCTGGCTATCATGA': 0,\n", + " 'GATTCAGCTGGCTATCATGA': 0,\n", + " 'TATACAGCTGGCTATCATGA': 0,\n", + " 'TATCCAGCTGGCTATCATGA': 0,\n", + " 'TATTCAGCTGGCTATCATGA': 0,\n", + " 'AATGAAGCTGGCTATCATGA': 0,\n", + " 'AATGGAGCTGGCTATCATGA': 0,\n", + " 'AATGTAGCTGGCTATCATGA': 0,\n", + " 'CATGAAGCTGGCTATCATGA': 0,\n", + " 'CATGGAGCTGGCTATCATGA': 0,\n", + " 'CATGTAGCTGGCTATCATGA': 0,\n", + " 'GATGAAGCTGGCTATCATGA': 0,\n", + " 'GATGGAGCTGGCTATCATGA': 0,\n", + " 'GATGTAGCTGGCTATCATGA': 0,\n", + " 'TATGAAGCTGGCTATCATGA': 0,\n", + " 'TATGGAGCTGGCTATCATGA': 0,\n", + " 'TATGTAGCTGGCTATCATGA': 0,\n", + " 'AATGCCGCTGGCTATCATGA': 0,\n", + " 'AATGCGGCTGGCTATCATGA': 0,\n", + " 'AATGCTGCTGGCTATCATGA': 0,\n", + " 'CATGCCGCTGGCTATCATGA': 0,\n", + " 'CATGCGGCTGGCTATCATGA': 0,\n", + " 'CATGCTGCTGGCTATCATGA': 0,\n", + " 'GATGCCGCTGGCTATCATGA': 0,\n", + " 'GATGCGGCTGGCTATCATGA': 0,\n", + " 'GATGCTGCTGGCTATCATGA': 0,\n", + " 'TATGCCGCTGGCTATCATGA': 0,\n", + " 'TATGCGGCTGGCTATCATGA': 0,\n", + " 'TATGCTGCTGGCTATCATGA': 0,\n", + " 'AATGCAACTGGCTATCATGA': 0,\n", + " 'AATGCACCTGGCTATCATGA': 0,\n", + " 'AATGCATCTGGCTATCATGA': 0,\n", + " 'CATGCAACTGGCTATCATGA': 0,\n", + " 'CATGCACCTGGCTATCATGA': 0,\n", + " 'CATGCATCTGGCTATCATGA': 0,\n", + " 'GATGCAACTGGCTATCATGA': 0,\n", + " 'GATGCACCTGGCTATCATGA': 0,\n", + " 'GATGCATCTGGCTATCATGA': 0,\n", + " 'TATGCAACTGGCTATCATGA': 0,\n", + " 'TATGCACCTGGCTATCATGA': 0,\n", + " 'TATGCATCTGGCTATCATGA': 0,\n", + " 'AATGCAGATGGCTATCATGA': 0,\n", + " 'AATGCAGGTGGCTATCATGA': 0,\n", + " 'AATGCAGTTGGCTATCATGA': 0,\n", + " 'CATGCAGATGGCTATCATGA': 0,\n", + " 'CATGCAGGTGGCTATCATGA': 0,\n", + " 'CATGCAGTTGGCTATCATGA': 0,\n", + " 'GATGCAGATGGCTATCATGA': 0,\n", + " 'GATGCAGGTGGCTATCATGA': 0,\n", + " 'GATGCAGTTGGCTATCATGA': 0,\n", + " 'TATGCAGATGGCTATCATGA': 0,\n", + " 'TATGCAGGTGGCTATCATGA': 0,\n", + " 'TATGCAGTTGGCTATCATGA': 0,\n", + " 'AATGCAGCAGGCTATCATGA': 0,\n", + " 'AATGCAGCCGGCTATCATGA': 0,\n", + " 'AATGCAGCGGGCTATCATGA': 0,\n", + " 'CATGCAGCAGGCTATCATGA': 0,\n", + " 'CATGCAGCCGGCTATCATGA': 0,\n", + " 'CATGCAGCGGGCTATCATGA': 0,\n", + " 'GATGCAGCAGGCTATCATGA': 0,\n", + " 'GATGCAGCCGGCTATCATGA': 0,\n", + " 'GATGCAGCGGGCTATCATGA': 0,\n", + " 'TATGCAGCAGGCTATCATGA': 0,\n", + " 'TATGCAGCCGGCTATCATGA': 0,\n", + " 'TATGCAGCGGGCTATCATGA': 0,\n", + " 'AATGCAGCTAGCTATCATGA': 0,\n", + " 'AATGCAGCTCGCTATCATGA': 0,\n", + " 'AATGCAGCTTGCTATCATGA': 0,\n", + " 'CATGCAGCTAGCTATCATGA': 0,\n", + " 'CATGCAGCTCGCTATCATGA': 0,\n", + " 'CATGCAGCTTGCTATCATGA': 0,\n", + " 'GATGCAGCTAGCTATCATGA': 0,\n", + " 'GATGCAGCTCGCTATCATGA': 0,\n", + " 'GATGCAGCTTGCTATCATGA': 0,\n", + " 'TATGCAGCTAGCTATCATGA': 0,\n", + " 'TATGCAGCTCGCTATCATGA': 0,\n", + " 'TATGCAGCTTGCTATCATGA': 0,\n", + " 'AATGCAGCTGACTATCATGA': 0,\n", + " 'AATGCAGCTGCCTATCATGA': 0,\n", + " 'AATGCAGCTGTCTATCATGA': 0,\n", + " 'CATGCAGCTGACTATCATGA': 0,\n", + " 'CATGCAGCTGCCTATCATGA': 0,\n", + " 'CATGCAGCTGTCTATCATGA': 0,\n", + " 'GATGCAGCTGACTATCATGA': 0,\n", + " 'GATGCAGCTGCCTATCATGA': 0,\n", + " 'GATGCAGCTGTCTATCATGA': 0,\n", + " 'TATGCAGCTGACTATCATGA': 0,\n", + " 'TATGCAGCTGCCTATCATGA': 0,\n", + " 'TATGCAGCTGTCTATCATGA': 0,\n", + " 'AATGCAGCTGGATATCATGA': 0,\n", + " 'AATGCAGCTGGGTATCATGA': 0,\n", + " 'AATGCAGCTGGTTATCATGA': 0,\n", + " 'CATGCAGCTGGATATCATGA': 0,\n", + " 'CATGCAGCTGGGTATCATGA': 0,\n", + " 'CATGCAGCTGGTTATCATGA': 0,\n", + " 'GATGCAGCTGGATATCATGA': 0,\n", + " 'GATGCAGCTGGGTATCATGA': 0,\n", + " 'GATGCAGCTGGTTATCATGA': 0,\n", + " 'TATGCAGCTGGATATCATGA': 0,\n", + " 'TATGCAGCTGGGTATCATGA': 0,\n", + " 'TATGCAGCTGGTTATCATGA': 0,\n", + " 'AATGCAGCTGGCAATCATGA': 0,\n", + " 'AATGCAGCTGGCCATCATGA': 0,\n", + " 'AATGCAGCTGGCGATCATGA': 0,\n", + " 'CATGCAGCTGGCAATCATGA': 0,\n", + " 'CATGCAGCTGGCCATCATGA': 0,\n", + " 'CATGCAGCTGGCGATCATGA': 0,\n", + " 'GATGCAGCTGGCAATCATGA': 0,\n", + " 'GATGCAGCTGGCCATCATGA': 0,\n", + " 'GATGCAGCTGGCGATCATGA': 0,\n", + " 'TATGCAGCTGGCAATCATGA': 0,\n", + " 'TATGCAGCTGGCCATCATGA': 0,\n", + " 'TATGCAGCTGGCGATCATGA': 0,\n", + " 'AATGCAGCTGGCTCTCATGA': 0,\n", + " 'AATGCAGCTGGCTGTCATGA': 0,\n", + " 'AATGCAGCTGGCTTTCATGA': 0,\n", + " 'CATGCAGCTGGCTCTCATGA': 0,\n", + " 'CATGCAGCTGGCTGTCATGA': 0,\n", + " 'CATGCAGCTGGCTTTCATGA': 0,\n", + " 'GATGCAGCTGGCTCTCATGA': 0,\n", + " 'GATGCAGCTGGCTGTCATGA': 0,\n", + " 'GATGCAGCTGGCTTTCATGA': 0,\n", + " 'TATGCAGCTGGCTCTCATGA': 0,\n", + " 'TATGCAGCTGGCTGTCATGA': 0,\n", + " 'TATGCAGCTGGCTTTCATGA': 0,\n", + " 'AATGCAGCTGGCTAACATGA': 0,\n", + " 'AATGCAGCTGGCTACCATGA': 0,\n", + " 'AATGCAGCTGGCTAGCATGA': 0,\n", + " 'CATGCAGCTGGCTAACATGA': 0,\n", + " 'CATGCAGCTGGCTACCATGA': 0,\n", + " 'CATGCAGCTGGCTAGCATGA': 0,\n", + " 'GATGCAGCTGGCTAACATGA': 0,\n", + " 'GATGCAGCTGGCTACCATGA': 0,\n", + " 'GATGCAGCTGGCTAGCATGA': 0,\n", + " 'TATGCAGCTGGCTAACATGA': 0,\n", + " 'TATGCAGCTGGCTACCATGA': 0,\n", + " 'TATGCAGCTGGCTAGCATGA': 0,\n", + " 'AATGCAGCTGGCTATAATGA': 0,\n", + " 'AATGCAGCTGGCTATGATGA': 0,\n", + " 'AATGCAGCTGGCTATTATGA': 0,\n", + " 'CATGCAGCTGGCTATAATGA': 0,\n", + " 'CATGCAGCTGGCTATGATGA': 0,\n", + " 'CATGCAGCTGGCTATTATGA': 0,\n", + " 'GATGCAGCTGGCTATAATGA': 0,\n", + " 'GATGCAGCTGGCTATGATGA': 0,\n", + " 'GATGCAGCTGGCTATTATGA': 0,\n", + " 'TATGCAGCTGGCTATAATGA': 0,\n", + " 'TATGCAGCTGGCTATGATGA': 0,\n", + " 'TATGCAGCTGGCTATTATGA': 0,\n", + " 'AATGCAGCTGGCTATCCTGA': 0,\n", + " 'AATGCAGCTGGCTATCGTGA': 0,\n", + " 'AATGCAGCTGGCTATCTTGA': 0,\n", + " 'CATGCAGCTGGCTATCCTGA': 0,\n", + " 'CATGCAGCTGGCTATCGTGA': 0,\n", + " 'CATGCAGCTGGCTATCTTGA': 0,\n", + " 'GATGCAGCTGGCTATCCTGA': 0,\n", + " 'GATGCAGCTGGCTATCGTGA': 0,\n", + " 'GATGCAGCTGGCTATCTTGA': 0,\n", + " 'TATGCAGCTGGCTATCCTGA': 0,\n", + " 'TATGCAGCTGGCTATCGTGA': 0,\n", + " 'TATGCAGCTGGCTATCTTGA': 0,\n", + " 'AATGCAGCTGGCTATCAAGA': 0,\n", + " 'AATGCAGCTGGCTATCACGA': 0,\n", + " 'AATGCAGCTGGCTATCAGGA': 0,\n", + " 'CATGCAGCTGGCTATCAAGA': 0,\n", + " 'CATGCAGCTGGCTATCACGA': 0,\n", + " 'CATGCAGCTGGCTATCAGGA': 0,\n", + " 'GATGCAGCTGGCTATCAAGA': 0,\n", + " 'GATGCAGCTGGCTATCACGA': 0,\n", + " 'GATGCAGCTGGCTATCAGGA': 0,\n", + " 'TATGCAGCTGGCTATCAAGA': 0,\n", + " 'TATGCAGCTGGCTATCACGA': 0,\n", + " 'TATGCAGCTGGCTATCAGGA': 0,\n", + " 'AATGCAGCTGGCTATCATAA': 0,\n", + " 'AATGCAGCTGGCTATCATCA': 0,\n", + " 'AATGCAGCTGGCTATCATTA': 0,\n", + " 'CATGCAGCTGGCTATCATAA': 0,\n", + " 'CATGCAGCTGGCTATCATCA': 0,\n", + " 'CATGCAGCTGGCTATCATTA': 0,\n", + " 'GATGCAGCTGGCTATCATAA': 0,\n", + " 'GATGCAGCTGGCTATCATCA': 0,\n", + " 'GATGCAGCTGGCTATCATTA': 0,\n", + " 'TATGCAGCTGGCTATCATAA': 0,\n", + " 'TATGCAGCTGGCTATCATCA': 0,\n", + " 'TATGCAGCTGGCTATCATTA': 0,\n", + " 'AATGCAGCTGGCTATCATGC': 0,\n", + " 'AATGCAGCTGGCTATCATGG': 0,\n", + " 'AATGCAGCTGGCTATCATGT': 0,\n", + " 'CATGCAGCTGGCTATCATGC': 0,\n", + " 'CATGCAGCTGGCTATCATGG': 0,\n", + " 'CATGCAGCTGGCTATCATGT': 0,\n", + " 'GATGCAGCTGGCTATCATGC': 0,\n", + " 'GATGCAGCTGGCTATCATGG': 0,\n", + " 'GATGCAGCTGGCTATCATGT': 0,\n", + " 'TATGCAGCTGGCTATCATGC': 0,\n", + " 'TATGCAGCTGGCTATCATGG': 0,\n", + " 'TATGCAGCTGGCTATCATGT': 0,\n", + " 'GACTGCAGCTGGCTATCATGA': 0,\n", + " 'GAGTGCAGCTGGCTATCATGA': 0,\n", + " 'GATTGCAGCTGGCTATCATGA': 0,\n", + " 'GCCTGCAGCTGGCTATCATGA': 0,\n", + " 'GCGTGCAGCTGGCTATCATGA': 0,\n", + " 'GCTTGCAGCTGGCTATCATGA': 0,\n", + " 'GGCTGCAGCTGGCTATCATGA': 0,\n", + " 'GGGTGCAGCTGGCTATCATGA': 0,\n", + " 'GGTTGCAGCTGGCTATCATGA': 0,\n", + " 'GTCTGCAGCTGGCTATCATGA': 0,\n", + " 'GTGTGCAGCTGGCTATCATGA': 0,\n", + " 'GTTTGCAGCTGGCTATCATGA': 0,\n", + " 'GCAGCAGCTGGCTATCATGA': 0,\n", + " 'GCCGCAGCTGGCTATCATGA': 0,\n", + " 'GCGGCAGCTGGCTATCATGA': 0,\n", + " 'GGAGCAGCTGGCTATCATGA': 0,\n", + " 'GGCGCAGCTGGCTATCATGA': 0,\n", + " 'GGGGCAGCTGGCTATCATGA': 0,\n", + " 'GTAGCAGCTGGCTATCATGA': 0,\n", + " 'GTCGCAGCTGGCTATCATGA': 0,\n", + " 'GTGGCAGCTGGCTATCATGA': 0,\n", + " 'GCTACAGCTGGCTATCATGA': 0,\n", + " 'GCTCCAGCTGGCTATCATGA': 0,\n", + " 'GCTTCAGCTGGCTATCATGA': 0,\n", + " 'GGTACAGCTGGCTATCATGA': 0,\n", + " 'GGTCCAGCTGGCTATCATGA': 0,\n", + " 'GGTTCAGCTGGCTATCATGA': 0,\n", + " 'GTTACAGCTGGCTATCATGA': 0,\n", + " 'GTTCCAGCTGGCTATCATGA': 0,\n", + " 'GTTTCAGCTGGCTATCATGA': 0,\n", + " 'GCTGAAGCTGGCTATCATGA': 0,\n", + " 'GCTGGAGCTGGCTATCATGA': 0,\n", + " 'GCTGTAGCTGGCTATCATGA': 0,\n", + " 'GGTGAAGCTGGCTATCATGA': 0,\n", + " 'GGTGGAGCTGGCTATCATGA': 0,\n", + " 'GGTGTAGCTGGCTATCATGA': 0,\n", + " 'GTTGAAGCTGGCTATCATGA': 0,\n", + " 'GTTGGAGCTGGCTATCATGA': 0,\n", + " 'GTTGTAGCTGGCTATCATGA': 0,\n", + " 'GCTGCCGCTGGCTATCATGA': 0,\n", + " 'GCTGCGGCTGGCTATCATGA': 0,\n", + " 'GCTGCTGCTGGCTATCATGA': 0,\n", + " 'GGTGCCGCTGGCTATCATGA': 0,\n", + " 'GGTGCGGCTGGCTATCATGA': 0,\n", + " 'GGTGCTGCTGGCTATCATGA': 0,\n", + " 'GTTGCCGCTGGCTATCATGA': 0,\n", + " 'GTTGCGGCTGGCTATCATGA': 0,\n", + " 'GTTGCTGCTGGCTATCATGA': 0,\n", + " 'GCTGCAACTGGCTATCATGA': 0,\n", + " 'GCTGCACCTGGCTATCATGA': 0,\n", + " 'GCTGCATCTGGCTATCATGA': 0,\n", + " 'GGTGCAACTGGCTATCATGA': 0,\n", + " 'GGTGCACCTGGCTATCATGA': 0,\n", + " 'GGTGCATCTGGCTATCATGA': 0,\n", + " 'GTTGCAACTGGCTATCATGA': 0,\n", + " 'GTTGCACCTGGCTATCATGA': 0,\n", + " 'GTTGCATCTGGCTATCATGA': 0,\n", + " 'GCTGCAGATGGCTATCATGA': 0,\n", + " 'GCTGCAGGTGGCTATCATGA': 0,\n", + " 'GCTGCAGTTGGCTATCATGA': 0,\n", + " 'GGTGCAGATGGCTATCATGA': 0,\n", + " 'GGTGCAGGTGGCTATCATGA': 0,\n", + " 'GGTGCAGTTGGCTATCATGA': 0,\n", + " 'GTTGCAGATGGCTATCATGA': 0,\n", + " 'GTTGCAGGTGGCTATCATGA': 0,\n", + " 'GTTGCAGTTGGCTATCATGA': 0,\n", + " 'GCTGCAGCAGGCTATCATGA': 0,\n", + " 'GCTGCAGCCGGCTATCATGA': 0,\n", + " 'GCTGCAGCGGGCTATCATGA': 0,\n", + " 'GGTGCAGCAGGCTATCATGA': 0,\n", + " 'GGTGCAGCCGGCTATCATGA': 0,\n", + " 'GGTGCAGCGGGCTATCATGA': 0,\n", + " 'GTTGCAGCAGGCTATCATGA': 0,\n", + " 'GTTGCAGCCGGCTATCATGA': 0,\n", + " 'GTTGCAGCGGGCTATCATGA': 0,\n", + " 'GCTGCAGCTAGCTATCATGA': 0,\n", + " 'GCTGCAGCTCGCTATCATGA': 0,\n", + " 'GCTGCAGCTTGCTATCATGA': 0,\n", + " 'GGTGCAGCTAGCTATCATGA': 0,\n", + " 'GGTGCAGCTCGCTATCATGA': 0,\n", + " 'GGTGCAGCTTGCTATCATGA': 0,\n", + " 'GTTGCAGCTAGCTATCATGA': 0,\n", + " 'GTTGCAGCTCGCTATCATGA': 0,\n", + " 'GTTGCAGCTTGCTATCATGA': 0,\n", + " 'GCTGCAGCTGACTATCATGA': 0,\n", + " 'GCTGCAGCTGCCTATCATGA': 0,\n", + " 'GCTGCAGCTGTCTATCATGA': 0,\n", + " 'GGTGCAGCTGACTATCATGA': 0,\n", + " 'GGTGCAGCTGCCTATCATGA': 0,\n", + " 'GGTGCAGCTGTCTATCATGA': 0,\n", + " 'GTTGCAGCTGACTATCATGA': 0,\n", + " 'GTTGCAGCTGCCTATCATGA': 0,\n", + " 'GTTGCAGCTGTCTATCATGA': 0,\n", + " 'GCTGCAGCTGGATATCATGA': 0,\n", + " 'GCTGCAGCTGGGTATCATGA': 0,\n", + " 'GCTGCAGCTGGTTATCATGA': 0,\n", + " 'GGTGCAGCTGGATATCATGA': 0,\n", + " 'GGTGCAGCTGGGTATCATGA': 0,\n", + " 'GGTGCAGCTGGTTATCATGA': 0,\n", + " 'GTTGCAGCTGGATATCATGA': 0,\n", + " 'GTTGCAGCTGGGTATCATGA': 0,\n", + " 'GTTGCAGCTGGTTATCATGA': 0,\n", + " 'GCTGCAGCTGGCAATCATGA': 0,\n", + " 'GCTGCAGCTGGCCATCATGA': 0,\n", + " 'GCTGCAGCTGGCGATCATGA': 0,\n", + " 'GGTGCAGCTGGCAATCATGA': 0,\n", + " 'GGTGCAGCTGGCCATCATGA': 0,\n", + " 'GGTGCAGCTGGCGATCATGA': 0,\n", + " 'GTTGCAGCTGGCAATCATGA': 0,\n", + " 'GTTGCAGCTGGCCATCATGA': 0,\n", + " 'GTTGCAGCTGGCGATCATGA': 0,\n", + " 'GCTGCAGCTGGCTCTCATGA': 0,\n", + " 'GCTGCAGCTGGCTGTCATGA': 0,\n", + " 'GCTGCAGCTGGCTTTCATGA': 0,\n", + " 'GGTGCAGCTGGCTCTCATGA': 0,\n", + " 'GGTGCAGCTGGCTGTCATGA': 0,\n", + " 'GGTGCAGCTGGCTTTCATGA': 0,\n", + " 'GTTGCAGCTGGCTCTCATGA': 0,\n", + " 'GTTGCAGCTGGCTGTCATGA': 0,\n", + " 'GTTGCAGCTGGCTTTCATGA': 0,\n", + " 'GCTGCAGCTGGCTAACATGA': 0,\n", + " 'GCTGCAGCTGGCTACCATGA': 0,\n", + " 'GCTGCAGCTGGCTAGCATGA': 0,\n", + " 'GGTGCAGCTGGCTAACATGA': 0,\n", + " 'GGTGCAGCTGGCTACCATGA': 0,\n", + " 'GGTGCAGCTGGCTAGCATGA': 0,\n", + " 'GTTGCAGCTGGCTAACATGA': 0,\n", + " 'GTTGCAGCTGGCTACCATGA': 0,\n", + " 'GTTGCAGCTGGCTAGCATGA': 0,\n", + " 'GCTGCAGCTGGCTATAATGA': 0,\n", + " 'GCTGCAGCTGGCTATGATGA': 0,\n", + " 'GCTGCAGCTGGCTATTATGA': 0,\n", + " 'GGTGCAGCTGGCTATAATGA': 0,\n", + " 'GGTGCAGCTGGCTATGATGA': 0,\n", + " 'GGTGCAGCTGGCTATTATGA': 0,\n", + " 'GTTGCAGCTGGCTATAATGA': 0,\n", + " 'GTTGCAGCTGGCTATGATGA': 0,\n", + " 'GTTGCAGCTGGCTATTATGA': 0,\n", + " 'GCTGCAGCTGGCTATCCTGA': 0,\n", + " 'GCTGCAGCTGGCTATCGTGA': 0,\n", + " 'GCTGCAGCTGGCTATCTTGA': 0,\n", + " 'GGTGCAGCTGGCTATCCTGA': 0,\n", + " 'GGTGCAGCTGGCTATCGTGA': 0,\n", + " 'GGTGCAGCTGGCTATCTTGA': 0,\n", + " 'GTTGCAGCTGGCTATCCTGA': 0,\n", + " 'GTTGCAGCTGGCTATCGTGA': 0,\n", + " 'GTTGCAGCTGGCTATCTTGA': 0,\n", + " 'GCTGCAGCTGGCTATCAAGA': 0,\n", + " 'GCTGCAGCTGGCTATCACGA': 0,\n", + " 'GCTGCAGCTGGCTATCAGGA': 0,\n", + " 'GGTGCAGCTGGCTATCAAGA': 0,\n", + " 'GGTGCAGCTGGCTATCACGA': 0,\n", + " 'GGTGCAGCTGGCTATCAGGA': 0,\n", + " 'GTTGCAGCTGGCTATCAAGA': 0,\n", + " 'GTTGCAGCTGGCTATCACGA': 0,\n", + " 'GTTGCAGCTGGCTATCAGGA': 0,\n", + " 'GCTGCAGCTGGCTATCATAA': 0,\n", + " 'GCTGCAGCTGGCTATCATCA': 0,\n", + " 'GCTGCAGCTGGCTATCATTA': 0,\n", + " 'GGTGCAGCTGGCTATCATAA': 0,\n", + " 'GGTGCAGCTGGCTATCATCA': 0,\n", + " 'GGTGCAGCTGGCTATCATTA': 0,\n", + " 'GTTGCAGCTGGCTATCATAA': 0,\n", + " 'GTTGCAGCTGGCTATCATCA': 0,\n", + " 'GTTGCAGCTGGCTATCATTA': 0,\n", + " 'GCTGCAGCTGGCTATCATGC': 0,\n", + " 'GCTGCAGCTGGCTATCATGG': 0,\n", + " 'GCTGCAGCTGGCTATCATGT': 0,\n", + " 'GGTGCAGCTGGCTATCATGC': 0,\n", + " 'GGTGCAGCTGGCTATCATGG': 0,\n", + " 'GGTGCAGCTGGCTATCATGT': 0,\n", + " 'GTTGCAGCTGGCTATCATGC': 0,\n", + " 'GTTGCAGCTGGCTATCATGG': 0,\n", + " 'GTTGCAGCTGGCTATCATGT': 0,\n", + " 'GAAAGCAGCTGGCTATCATGA': 0,\n", + " 'GAACGCAGCTGGCTATCATGA': 0,\n", + " 'GAAGGCAGCTGGCTATCATGA': 0,\n", + " 'GACAGCAGCTGGCTATCATGA': 0,\n", + " 'GACCGCAGCTGGCTATCATGA': 0,\n", + " 'GACGGCAGCTGGCTATCATGA': 0,\n", + " 'GAGAGCAGCTGGCTATCATGA': 0,\n", + " 'GAGCGCAGCTGGCTATCATGA': 0,\n", + " 'GAGGGCAGCTGGCTATCATGA': 0,\n", + " 'GATAGCAGCTGGCTATCATGA': 0,\n", + " 'GATCGCAGCTGGCTATCATGA': 0,\n", + " 'GATGGCAGCTGGCTATCATGA': 0,\n", + " 'GAAACAGCTGGCTATCATGA': 0,\n", + " 'GAACCAGCTGGCTATCATGA': 0,\n", + " 'GAATCAGCTGGCTATCATGA': 0,\n", + " 'GACACAGCTGGCTATCATGA': 0,\n", + " 'GACCCAGCTGGCTATCATGA': 0,\n", + " 'GACTCAGCTGGCTATCATGA': 0,\n", + " 'GAGACAGCTGGCTATCATGA': 0,\n", + " 'GAGCCAGCTGGCTATCATGA': 0,\n", + " 'GAGTCAGCTGGCTATCATGA': 0,\n", + " 'GAAGAAGCTGGCTATCATGA': 0,\n", + " 'GAAGGAGCTGGCTATCATGA': 0,\n", + " 'GAAGTAGCTGGCTATCATGA': 0,\n", + " 'GACGAAGCTGGCTATCATGA': 0,\n", + " 'GACGGAGCTGGCTATCATGA': 0,\n", + " 'GACGTAGCTGGCTATCATGA': 0,\n", + " 'GAGGAAGCTGGCTATCATGA': 0,\n", + " 'GAGGGAGCTGGCTATCATGA': 0,\n", + " 'GAGGTAGCTGGCTATCATGA': 0,\n", + " 'GAAGCCGCTGGCTATCATGA': 0,\n", + " 'GAAGCGGCTGGCTATCATGA': 0,\n", + " 'GAAGCTGCTGGCTATCATGA': 0,\n", + " 'GACGCCGCTGGCTATCATGA': 0,\n", + " 'GACGCGGCTGGCTATCATGA': 0,\n", + " 'GACGCTGCTGGCTATCATGA': 0,\n", + " 'GAGGCCGCTGGCTATCATGA': 0,\n", + " 'GAGGCGGCTGGCTATCATGA': 0,\n", + " 'GAGGCTGCTGGCTATCATGA': 0,\n", + " 'GAAGCAACTGGCTATCATGA': 0,\n", + " 'GAAGCACCTGGCTATCATGA': 0,\n", + " 'GAAGCATCTGGCTATCATGA': 0,\n", + " 'GACGCAACTGGCTATCATGA': 0,\n", + " 'GACGCACCTGGCTATCATGA': 0,\n", + " 'GACGCATCTGGCTATCATGA': 0,\n", + " 'GAGGCAACTGGCTATCATGA': 0,\n", + " 'GAGGCACCTGGCTATCATGA': 0,\n", + " 'GAGGCATCTGGCTATCATGA': 0,\n", + " 'GAAGCAGATGGCTATCATGA': 0,\n", + " 'GAAGCAGGTGGCTATCATGA': 0,\n", + " 'GAAGCAGTTGGCTATCATGA': 0,\n", + " 'GACGCAGATGGCTATCATGA': 0,\n", + " 'GACGCAGGTGGCTATCATGA': 0,\n", + " 'GACGCAGTTGGCTATCATGA': 0,\n", + " 'GAGGCAGATGGCTATCATGA': 0,\n", + " 'GAGGCAGGTGGCTATCATGA': 0,\n", + " 'GAGGCAGTTGGCTATCATGA': 0,\n", + " 'GAAGCAGCAGGCTATCATGA': 0,\n", + " 'GAAGCAGCCGGCTATCATGA': 0,\n", + " 'GAAGCAGCGGGCTATCATGA': 0,\n", + " 'GACGCAGCAGGCTATCATGA': 0,\n", + " 'GACGCAGCCGGCTATCATGA': 0,\n", + " 'GACGCAGCGGGCTATCATGA': 0,\n", + " 'GAGGCAGCAGGCTATCATGA': 0,\n", + " 'GAGGCAGCCGGCTATCATGA': 0,\n", + " 'GAGGCAGCGGGCTATCATGA': 0,\n", + " 'GAAGCAGCTAGCTATCATGA': 0,\n", + " 'GAAGCAGCTCGCTATCATGA': 0,\n", + " 'GAAGCAGCTTGCTATCATGA': 0,\n", + " 'GACGCAGCTAGCTATCATGA': 0,\n", + " 'GACGCAGCTCGCTATCATGA': 0,\n", + " 'GACGCAGCTTGCTATCATGA': 0,\n", + " 'GAGGCAGCTAGCTATCATGA': 0,\n", + " 'GAGGCAGCTCGCTATCATGA': 0,\n", + " 'GAGGCAGCTTGCTATCATGA': 0,\n", + " 'GAAGCAGCTGACTATCATGA': 0,\n", + " 'GAAGCAGCTGCCTATCATGA': 0,\n", + " 'GAAGCAGCTGTCTATCATGA': 0,\n", + " 'GACGCAGCTGACTATCATGA': 0,\n", + " 'GACGCAGCTGCCTATCATGA': 0,\n", + " 'GACGCAGCTGTCTATCATGA': 0,\n", + " 'GAGGCAGCTGACTATCATGA': 0,\n", + " 'GAGGCAGCTGCCTATCATGA': 0,\n", + " 'GAGGCAGCTGTCTATCATGA': 0,\n", + " 'GAAGCAGCTGGATATCATGA': 0,\n", + " 'GAAGCAGCTGGGTATCATGA': 0,\n", + " 'GAAGCAGCTGGTTATCATGA': 0,\n", + " 'GACGCAGCTGGATATCATGA': 0,\n", + " 'GACGCAGCTGGGTATCATGA': 0,\n", + " 'GACGCAGCTGGTTATCATGA': 0,\n", + " 'GAGGCAGCTGGATATCATGA': 0,\n", + " 'GAGGCAGCTGGGTATCATGA': 0,\n", + " 'GAGGCAGCTGGTTATCATGA': 0,\n", + " 'GAAGCAGCTGGCAATCATGA': 0,\n", + " 'GAAGCAGCTGGCCATCATGA': 0,\n", + " 'GAAGCAGCTGGCGATCATGA': 0,\n", + " 'GACGCAGCTGGCAATCATGA': 0,\n", + " 'GACGCAGCTGGCCATCATGA': 0,\n", + " 'GACGCAGCTGGCGATCATGA': 0,\n", + " 'GAGGCAGCTGGCAATCATGA': 0,\n", + " 'GAGGCAGCTGGCCATCATGA': 0,\n", + " 'GAGGCAGCTGGCGATCATGA': 0,\n", + " 'GAAGCAGCTGGCTCTCATGA': 0,\n", + " 'GAAGCAGCTGGCTGTCATGA': 0,\n", + " 'GAAGCAGCTGGCTTTCATGA': 0,\n", + " 'GACGCAGCTGGCTCTCATGA': 0,\n", + " 'GACGCAGCTGGCTGTCATGA': 0,\n", + " 'GACGCAGCTGGCTTTCATGA': 0,\n", + " 'GAGGCAGCTGGCTCTCATGA': 0,\n", + " 'GAGGCAGCTGGCTGTCATGA': 0,\n", + " 'GAGGCAGCTGGCTTTCATGA': 0,\n", + " 'GAAGCAGCTGGCTAACATGA': 0,\n", + " 'GAAGCAGCTGGCTACCATGA': 0,\n", + " 'GAAGCAGCTGGCTAGCATGA': 0,\n", + " 'GACGCAGCTGGCTAACATGA': 0,\n", + " 'GACGCAGCTGGCTACCATGA': 0,\n", + " 'GACGCAGCTGGCTAGCATGA': 0,\n", + " 'GAGGCAGCTGGCTAACATGA': 0,\n", + " 'GAGGCAGCTGGCTACCATGA': 0,\n", + " 'GAGGCAGCTGGCTAGCATGA': 0,\n", + " 'GAAGCAGCTGGCTATAATGA': 0,\n", + " 'GAAGCAGCTGGCTATGATGA': 0,\n", + " 'GAAGCAGCTGGCTATTATGA': 0,\n", + " 'GACGCAGCTGGCTATAATGA': 0,\n", + " 'GACGCAGCTGGCTATGATGA': 0,\n", + " 'GACGCAGCTGGCTATTATGA': 0,\n", + " 'GAGGCAGCTGGCTATAATGA': 0,\n", + " 'GAGGCAGCTGGCTATGATGA': 0,\n", + " 'GAGGCAGCTGGCTATTATGA': 0,\n", + " 'GAAGCAGCTGGCTATCCTGA': 0,\n", + " 'GAAGCAGCTGGCTATCGTGA': 0,\n", + " 'GAAGCAGCTGGCTATCTTGA': 0,\n", + " 'GACGCAGCTGGCTATCCTGA': 0,\n", + " 'GACGCAGCTGGCTATCGTGA': 0,\n", + " 'GACGCAGCTGGCTATCTTGA': 0,\n", + " 'GAGGCAGCTGGCTATCCTGA': 0,\n", + " 'GAGGCAGCTGGCTATCGTGA': 0,\n", + " 'GAGGCAGCTGGCTATCTTGA': 0,\n", + " 'GAAGCAGCTGGCTATCAAGA': 0,\n", + " 'GAAGCAGCTGGCTATCACGA': 0,\n", + " 'GAAGCAGCTGGCTATCAGGA': 0,\n", + " 'GACGCAGCTGGCTATCAAGA': 0,\n", + " 'GACGCAGCTGGCTATCACGA': 0,\n", + " 'GACGCAGCTGGCTATCAGGA': 0,\n", + " 'GAGGCAGCTGGCTATCAAGA': 0,\n", + " 'GAGGCAGCTGGCTATCACGA': 0,\n", + " 'GAGGCAGCTGGCTATCAGGA': 0,\n", + " 'GAAGCAGCTGGCTATCATAA': 0,\n", + " 'GAAGCAGCTGGCTATCATCA': 0,\n", + " 'GAAGCAGCTGGCTATCATTA': 0,\n", + " 'GACGCAGCTGGCTATCATAA': 0,\n", + " 'GACGCAGCTGGCTATCATCA': 0,\n", + " 'GACGCAGCTGGCTATCATTA': 0,\n", + " 'GAGGCAGCTGGCTATCATAA': 0,\n", + " 'GAGGCAGCTGGCTATCATCA': 0,\n", + " 'GAGGCAGCTGGCTATCATTA': 0,\n", + " 'GAAGCAGCTGGCTATCATGC': 0,\n", + " 'GAAGCAGCTGGCTATCATGG': 0,\n", + " 'GAAGCAGCTGGCTATCATGT': 0,\n", + " 'GACGCAGCTGGCTATCATGC': 0,\n", + " 'GACGCAGCTGGCTATCATGG': 0,\n", + " 'GACGCAGCTGGCTATCATGT': 0,\n", + " 'GAGGCAGCTGGCTATCATGC': 0,\n", + " 'GAGGCAGCTGGCTATCATGG': 0,\n", + " 'GAGGCAGCTGGCTATCATGT': 0,\n", + " 'GATAACAGCTGGCTATCATGA': 0,\n", + " 'GATACCAGCTGGCTATCATGA': 0,\n", + " 'GATATCAGCTGGCTATCATGA': 0,\n", + " 'GATCACAGCTGGCTATCATGA': 0,\n", + " 'GATCCCAGCTGGCTATCATGA': 0,\n", + " 'GATCTCAGCTGGCTATCATGA': 0,\n", + " 'GATGACAGCTGGCTATCATGA': 0,\n", + " 'GATGCCAGCTGGCTATCATGA': 0,\n", + " 'GATGTCAGCTGGCTATCATGA': 0,\n", + " 'GATTACAGCTGGCTATCATGA': 0,\n", + " 'GATTCCAGCTGGCTATCATGA': 0,\n", + " 'GATTTCAGCTGGCTATCATGA': 0,\n", + " 'GATAAAGCTGGCTATCATGA': 0,\n", + " 'GATAGAGCTGGCTATCATGA': 0,\n", + " 'GATATAGCTGGCTATCATGA': 0,\n", + " 'GATCAAGCTGGCTATCATGA': 0,\n", + " 'GATCGAGCTGGCTATCATGA': 0,\n", + " 'GATCTAGCTGGCTATCATGA': 0,\n", + " 'GATTAAGCTGGCTATCATGA': 0,\n", + " 'GATTGAGCTGGCTATCATGA': 0,\n", + " 'GATTTAGCTGGCTATCATGA': 0,\n", + " 'GATACCGCTGGCTATCATGA': 0,\n", + " 'GATACGGCTGGCTATCATGA': 0,\n", + " 'GATACTGCTGGCTATCATGA': 0,\n", + " 'GATCCCGCTGGCTATCATGA': 0,\n", + " 'GATCCGGCTGGCTATCATGA': 0,\n", + " 'GATCCTGCTGGCTATCATGA': 0,\n", + " 'GATTCCGCTGGCTATCATGA': 0,\n", + " 'GATTCGGCTGGCTATCATGA': 0,\n", + " 'GATTCTGCTGGCTATCATGA': 0,\n", + " 'GATACAACTGGCTATCATGA': 0,\n", + " 'GATACACCTGGCTATCATGA': 0,\n", + " 'GATACATCTGGCTATCATGA': 0,\n", + " 'GATCCAACTGGCTATCATGA': 0,\n", + " 'GATCCACCTGGCTATCATGA': 0,\n", + " 'GATCCATCTGGCTATCATGA': 0,\n", + " 'GATTCAACTGGCTATCATGA': 0,\n", + " 'GATTCACCTGGCTATCATGA': 0,\n", + " 'GATTCATCTGGCTATCATGA': 0,\n", + " 'GATACAGATGGCTATCATGA': 0,\n", + " 'GATACAGGTGGCTATCATGA': 0,\n", + " 'GATACAGTTGGCTATCATGA': 0,\n", + " 'GATCCAGATGGCTATCATGA': 0,\n", + " 'GATCCAGGTGGCTATCATGA': 0,\n", + " 'GATCCAGTTGGCTATCATGA': 0,\n", + " 'GATTCAGATGGCTATCATGA': 0,\n", + " 'GATTCAGGTGGCTATCATGA': 0,\n", + " 'GATTCAGTTGGCTATCATGA': 0,\n", + " 'GATACAGCAGGCTATCATGA': 0,\n", + " 'GATACAGCCGGCTATCATGA': 0,\n", + " 'GATACAGCGGGCTATCATGA': 0,\n", + " 'GATCCAGCAGGCTATCATGA': 0,\n", + " 'GATCCAGCCGGCTATCATGA': 0,\n", + " 'GATCCAGCGGGCTATCATGA': 0,\n", + " 'GATTCAGCAGGCTATCATGA': 0,\n", + " 'GATTCAGCCGGCTATCATGA': 0,\n", + " 'GATTCAGCGGGCTATCATGA': 0,\n", + " 'GATACAGCTAGCTATCATGA': 0,\n", + " 'GATACAGCTCGCTATCATGA': 0,\n", + " 'GATACAGCTTGCTATCATGA': 0,\n", + " 'GATCCAGCTAGCTATCATGA': 0,\n", + " 'GATCCAGCTCGCTATCATGA': 0,\n", + " 'GATCCAGCTTGCTATCATGA': 0,\n", + " 'GATTCAGCTAGCTATCATGA': 0,\n", + " 'GATTCAGCTCGCTATCATGA': 0,\n", + " 'GATTCAGCTTGCTATCATGA': 0,\n", + " 'GATACAGCTGACTATCATGA': 0,\n", + " 'GATACAGCTGCCTATCATGA': 0,\n", + " 'GATACAGCTGTCTATCATGA': 0,\n", + " 'GATCCAGCTGACTATCATGA': 0,\n", + " 'GATCCAGCTGCCTATCATGA': 0,\n", + " 'GATCCAGCTGTCTATCATGA': 0,\n", + " 'GATTCAGCTGACTATCATGA': 0,\n", + " 'GATTCAGCTGCCTATCATGA': 0,\n", + " 'GATTCAGCTGTCTATCATGA': 0,\n", + " 'GATACAGCTGGATATCATGA': 0,\n", + " 'GATACAGCTGGGTATCATGA': 0,\n", + " 'GATACAGCTGGTTATCATGA': 0,\n", + " 'GATCCAGCTGGATATCATGA': 0,\n", + " 'GATCCAGCTGGGTATCATGA': 0,\n", + " 'GATCCAGCTGGTTATCATGA': 0,\n", + " 'GATTCAGCTGGATATCATGA': 0,\n", + " 'GATTCAGCTGGGTATCATGA': 0,\n", + " 'GATTCAGCTGGTTATCATGA': 0,\n", + " 'GATACAGCTGGCAATCATGA': 0,\n", + " 'GATACAGCTGGCCATCATGA': 0,\n", + " 'GATACAGCTGGCGATCATGA': 0,\n", + " 'GATCCAGCTGGCAATCATGA': 0,\n", + " 'GATCCAGCTGGCCATCATGA': 0,\n", + " 'GATCCAGCTGGCGATCATGA': 0,\n", + " 'GATTCAGCTGGCAATCATGA': 0,\n", + " 'GATTCAGCTGGCCATCATGA': 0,\n", + " 'GATTCAGCTGGCGATCATGA': 0,\n", + " 'GATACAGCTGGCTCTCATGA': 0,\n", + " 'GATACAGCTGGCTGTCATGA': 0,\n", + " 'GATACAGCTGGCTTTCATGA': 0,\n", + " 'GATCCAGCTGGCTCTCATGA': 0,\n", + " 'GATCCAGCTGGCTGTCATGA': 0,\n", + " 'GATCCAGCTGGCTTTCATGA': 0,\n", + " 'GATTCAGCTGGCTCTCATGA': 0,\n", + " 'GATTCAGCTGGCTGTCATGA': 0,\n", + " 'GATTCAGCTGGCTTTCATGA': 0,\n", + " 'GATACAGCTGGCTAACATGA': 0,\n", + " 'GATACAGCTGGCTACCATGA': 0,\n", + " 'GATACAGCTGGCTAGCATGA': 0,\n", + " 'GATCCAGCTGGCTAACATGA': 0,\n", + " 'GATCCAGCTGGCTACCATGA': 0,\n", + " 'GATCCAGCTGGCTAGCATGA': 0,\n", + " 'GATTCAGCTGGCTAACATGA': 0,\n", + " 'GATTCAGCTGGCTACCATGA': 0,\n", + " 'GATTCAGCTGGCTAGCATGA': 0,\n", + " 'GATACAGCTGGCTATAATGA': 0,\n", + " 'GATACAGCTGGCTATGATGA': 0,\n", + " 'GATACAGCTGGCTATTATGA': 0,\n", + " 'GATCCAGCTGGCTATAATGA': 0,\n", + " 'GATCCAGCTGGCTATGATGA': 0,\n", + " 'GATCCAGCTGGCTATTATGA': 0,\n", + " 'GATTCAGCTGGCTATAATGA': 0,\n", + " 'GATTCAGCTGGCTATGATGA': 0,\n", + " 'GATTCAGCTGGCTATTATGA': 0,\n", + " 'GATACAGCTGGCTATCCTGA': 0,\n", + " 'GATACAGCTGGCTATCGTGA': 0,\n", + " 'GATACAGCTGGCTATCTTGA': 0,\n", + " 'GATCCAGCTGGCTATCCTGA': 0,\n", + " 'GATCCAGCTGGCTATCGTGA': 0,\n", + " 'GATCCAGCTGGCTATCTTGA': 0,\n", + " 'GATTCAGCTGGCTATCCTGA': 0,\n", + " 'GATTCAGCTGGCTATCGTGA': 0,\n", + " 'GATTCAGCTGGCTATCTTGA': 0,\n", + " 'GATACAGCTGGCTATCAAGA': 0,\n", + " 'GATACAGCTGGCTATCACGA': 0,\n", + " 'GATACAGCTGGCTATCAGGA': 0,\n", + " 'GATCCAGCTGGCTATCAAGA': 0,\n", + " 'GATCCAGCTGGCTATCACGA': 0,\n", + " 'GATCCAGCTGGCTATCAGGA': 0,\n", + " 'GATTCAGCTGGCTATCAAGA': 0,\n", + " 'GATTCAGCTGGCTATCACGA': 0,\n", + " 'GATTCAGCTGGCTATCAGGA': 0,\n", + " 'GATACAGCTGGCTATCATAA': 0,\n", + " 'GATACAGCTGGCTATCATCA': 0,\n", + " 'GATACAGCTGGCTATCATTA': 0,\n", + " 'GATCCAGCTGGCTATCATAA': 0,\n", + " 'GATCCAGCTGGCTATCATCA': 0,\n", + " 'GATCCAGCTGGCTATCATTA': 0,\n", + " 'GATTCAGCTGGCTATCATAA': 0,\n", + " 'GATTCAGCTGGCTATCATCA': 0,\n", + " 'GATTCAGCTGGCTATCATTA': 0,\n", + " 'GATACAGCTGGCTATCATGC': 0,\n", + " 'GATACAGCTGGCTATCATGG': 0,\n", + " 'GATACAGCTGGCTATCATGT': 0,\n", + " 'GATCCAGCTGGCTATCATGC': 0,\n", + " 'GATCCAGCTGGCTATCATGG': 0,\n", + " 'GATCCAGCTGGCTATCATGT': 0,\n", + " 'GATTCAGCTGGCTATCATGC': 0,\n", + " 'GATTCAGCTGGCTATCATGG': 0,\n", + " 'GATTCAGCTGGCTATCATGT': 0,\n", + " 'GATGAAAGCTGGCTATCATGA': 0,\n", + " 'GATGAGAGCTGGCTATCATGA': 0,\n", + " 'GATGATAGCTGGCTATCATGA': 0,\n", + " 'GATGCAAGCTGGCTATCATGA': 0,\n", + " 'GATGCGAGCTGGCTATCATGA': 0,\n", + " 'GATGCTAGCTGGCTATCATGA': 0,\n", + " 'GATGGAAGCTGGCTATCATGA': 0,\n", + " 'GATGGGAGCTGGCTATCATGA': 0,\n", + " 'GATGGTAGCTGGCTATCATGA': 0,\n", + " 'GATGTAAGCTGGCTATCATGA': 0,\n", + " 'GATGTGAGCTGGCTATCATGA': 0,\n", + " 'GATGTTAGCTGGCTATCATGA': 0,\n", + " 'GATGACGCTGGCTATCATGA': 0,\n", + " 'GATGAGGCTGGCTATCATGA': 0,\n", + " 'GATGATGCTGGCTATCATGA': 0,\n", + " 'GATGGCGCTGGCTATCATGA': 0,\n", + " 'GATGGGGCTGGCTATCATGA': 0,\n", + " 'GATGGTGCTGGCTATCATGA': 0,\n", + " 'GATGTCGCTGGCTATCATGA': 0,\n", + " 'GATGTGGCTGGCTATCATGA': 0,\n", + " 'GATGTTGCTGGCTATCATGA': 0,\n", + " 'GATGAAACTGGCTATCATGA': 0,\n", + " 'GATGAACCTGGCTATCATGA': 0,\n", + " 'GATGAATCTGGCTATCATGA': 0,\n", + " 'GATGGAACTGGCTATCATGA': 0,\n", + " 'GATGGACCTGGCTATCATGA': 0,\n", + " 'GATGGATCTGGCTATCATGA': 0,\n", + " 'GATGTAACTGGCTATCATGA': 0,\n", + " 'GATGTACCTGGCTATCATGA': 0,\n", + " 'GATGTATCTGGCTATCATGA': 0,\n", + " 'GATGAAGATGGCTATCATGA': 0,\n", + " 'GATGAAGGTGGCTATCATGA': 0,\n", + " 'GATGAAGTTGGCTATCATGA': 0,\n", + " 'GATGGAGATGGCTATCATGA': 0,\n", + " 'GATGGAGGTGGCTATCATGA': 0,\n", + " 'GATGGAGTTGGCTATCATGA': 0,\n", + " 'GATGTAGATGGCTATCATGA': 0,\n", + " 'GATGTAGGTGGCTATCATGA': 0,\n", + " 'GATGTAGTTGGCTATCATGA': 0,\n", + " 'GATGAAGCAGGCTATCATGA': 0,\n", + " 'GATGAAGCCGGCTATCATGA': 0,\n", + " 'GATGAAGCGGGCTATCATGA': 0,\n", + " 'GATGGAGCAGGCTATCATGA': 0,\n", + " 'GATGGAGCCGGCTATCATGA': 0,\n", + " 'GATGGAGCGGGCTATCATGA': 0,\n", + " 'GATGTAGCAGGCTATCATGA': 0,\n", + " 'GATGTAGCCGGCTATCATGA': 0,\n", + " 'GATGTAGCGGGCTATCATGA': 0,\n", + " 'GATGAAGCTAGCTATCATGA': 0,\n", + " 'GATGAAGCTCGCTATCATGA': 0,\n", + " 'GATGAAGCTTGCTATCATGA': 0,\n", + " 'GATGGAGCTAGCTATCATGA': 0,\n", + " 'GATGGAGCTCGCTATCATGA': 0,\n", + " 'GATGGAGCTTGCTATCATGA': 0,\n", + " 'GATGTAGCTAGCTATCATGA': 0,\n", + " 'GATGTAGCTCGCTATCATGA': 0,\n", + " 'GATGTAGCTTGCTATCATGA': 0,\n", + " 'GATGAAGCTGACTATCATGA': 0,\n", + " 'GATGAAGCTGCCTATCATGA': 0,\n", + " 'GATGAAGCTGTCTATCATGA': 0,\n", + " 'GATGGAGCTGACTATCATGA': 0,\n", + " 'GATGGAGCTGCCTATCATGA': 0,\n", + " 'GATGGAGCTGTCTATCATGA': 0,\n", + " 'GATGTAGCTGACTATCATGA': 0,\n", + " 'GATGTAGCTGCCTATCATGA': 0,\n", + " 'GATGTAGCTGTCTATCATGA': 0,\n", + " 'GATGAAGCTGGATATCATGA': 0,\n", + " 'GATGAAGCTGGGTATCATGA': 0,\n", + " 'GATGAAGCTGGTTATCATGA': 0,\n", + " 'GATGGAGCTGGATATCATGA': 0,\n", + " 'GATGGAGCTGGGTATCATGA': 0,\n", + " 'GATGGAGCTGGTTATCATGA': 0,\n", + " 'GATGTAGCTGGATATCATGA': 0,\n", + " 'GATGTAGCTGGGTATCATGA': 0,\n", + " 'GATGTAGCTGGTTATCATGA': 0,\n", + " 'GATGAAGCTGGCAATCATGA': 0,\n", + " 'GATGAAGCTGGCCATCATGA': 0,\n", + " 'GATGAAGCTGGCGATCATGA': 0,\n", + " 'GATGGAGCTGGCAATCATGA': 0,\n", + " 'GATGGAGCTGGCCATCATGA': 0,\n", + " 'GATGGAGCTGGCGATCATGA': 0,\n", + " 'GATGTAGCTGGCAATCATGA': 0,\n", + " 'GATGTAGCTGGCCATCATGA': 0,\n", + " 'GATGTAGCTGGCGATCATGA': 0,\n", + " 'GATGAAGCTGGCTCTCATGA': 0,\n", + " 'GATGAAGCTGGCTGTCATGA': 0,\n", + " 'GATGAAGCTGGCTTTCATGA': 0,\n", + " 'GATGGAGCTGGCTCTCATGA': 0,\n", + " 'GATGGAGCTGGCTGTCATGA': 0,\n", + " 'GATGGAGCTGGCTTTCATGA': 0,\n", + " 'GATGTAGCTGGCTCTCATGA': 0,\n", + " 'GATGTAGCTGGCTGTCATGA': 0,\n", + " 'GATGTAGCTGGCTTTCATGA': 0,\n", + " 'GATGAAGCTGGCTAACATGA': 0,\n", + " 'GATGAAGCTGGCTACCATGA': 0,\n", + " 'GATGAAGCTGGCTAGCATGA': 0,\n", + " 'GATGGAGCTGGCTAACATGA': 0,\n", + " 'GATGGAGCTGGCTACCATGA': 0,\n", + " 'GATGGAGCTGGCTAGCATGA': 0,\n", + " 'GATGTAGCTGGCTAACATGA': 0,\n", + " 'GATGTAGCTGGCTACCATGA': 0,\n", + " 'GATGTAGCTGGCTAGCATGA': 0,\n", + " 'GATGAAGCTGGCTATAATGA': 0,\n", + " 'GATGAAGCTGGCTATGATGA': 0,\n", + " 'GATGAAGCTGGCTATTATGA': 0,\n", + " 'GATGGAGCTGGCTATAATGA': 0,\n", + " 'GATGGAGCTGGCTATGATGA': 0,\n", + " 'GATGGAGCTGGCTATTATGA': 0,\n", + " 'GATGTAGCTGGCTATAATGA': 0,\n", + " 'GATGTAGCTGGCTATGATGA': 0,\n", + " 'GATGTAGCTGGCTATTATGA': 0,\n", + " 'GATGAAGCTGGCTATCCTGA': 0,\n", + " 'GATGAAGCTGGCTATCGTGA': 0,\n", + " 'GATGAAGCTGGCTATCTTGA': 0,\n", + " 'GATGGAGCTGGCTATCCTGA': 0,\n", + " 'GATGGAGCTGGCTATCGTGA': 0,\n", + " 'GATGGAGCTGGCTATCTTGA': 0,\n", + " 'GATGTAGCTGGCTATCCTGA': 0,\n", + " 'GATGTAGCTGGCTATCGTGA': 0,\n", + " 'GATGTAGCTGGCTATCTTGA': 0,\n", + " 'GATGAAGCTGGCTATCAAGA': 0,\n", + " 'GATGAAGCTGGCTATCACGA': 0,\n", + " 'GATGAAGCTGGCTATCAGGA': 0,\n", + " 'GATGGAGCTGGCTATCAAGA': 0,\n", + " 'GATGGAGCTGGCTATCACGA': 0,\n", + " 'GATGGAGCTGGCTATCAGGA': 0,\n", + " 'GATGTAGCTGGCTATCAAGA': 0,\n", + " 'GATGTAGCTGGCTATCACGA': 0,\n", + " 'GATGTAGCTGGCTATCAGGA': 0,\n", + " 'GATGAAGCTGGCTATCATAA': 0,\n", + " 'GATGAAGCTGGCTATCATCA': 0,\n", + " 'GATGAAGCTGGCTATCATTA': 0,\n", + " 'GATGGAGCTGGCTATCATAA': 0,\n", + " 'GATGGAGCTGGCTATCATCA': 0,\n", + " 'GATGGAGCTGGCTATCATTA': 0,\n", + " 'GATGTAGCTGGCTATCATAA': 0,\n", + " 'GATGTAGCTGGCTATCATCA': 0,\n", + " 'GATGTAGCTGGCTATCATTA': 0,\n", + " 'GATGAAGCTGGCTATCATGC': 0,\n", + " 'GATGAAGCTGGCTATCATGG': 0,\n", + " 'GATGAAGCTGGCTATCATGT': 0,\n", + " 'GATGGAGCTGGCTATCATGC': 0,\n", + " 'GATGGAGCTGGCTATCATGG': 0,\n", + " 'GATGGAGCTGGCTATCATGT': 0,\n", + " 'GATGTAGCTGGCTATCATGC': 0,\n", + " 'GATGTAGCTGGCTATCATGG': 0,\n", + " 'GATGTAGCTGGCTATCATGT': 0,\n", + " 'GATGCACGCTGGCTATCATGA': 0,\n", + " 'GATGCAGGCTGGCTATCATGA': 0,\n", + " 'GATGCATGCTGGCTATCATGA': 0,\n", + " 'GATGCCCGCTGGCTATCATGA': 0,\n", + " 'GATGCCGGCTGGCTATCATGA': 0,\n", + " 'GATGCCTGCTGGCTATCATGA': 0,\n", + " 'GATGCGCGCTGGCTATCATGA': 0,\n", + " 'GATGCGGGCTGGCTATCATGA': 0,\n", + " 'GATGCGTGCTGGCTATCATGA': 0,\n", + " 'GATGCTCGCTGGCTATCATGA': 0,\n", + " 'GATGCTGGCTGGCTATCATGA': 0,\n", + " 'GATGCTTGCTGGCTATCATGA': 0,\n", + " 'GATGCCACTGGCTATCATGA': 0,\n", + " 'GATGCCCCTGGCTATCATGA': 0,\n", + " 'GATGCCTCTGGCTATCATGA': 0,\n", + " 'GATGCGACTGGCTATCATGA': 0,\n", + " 'GATGCGCCTGGCTATCATGA': 0,\n", + " 'GATGCGTCTGGCTATCATGA': 0,\n", + " 'GATGCTACTGGCTATCATGA': 0,\n", + " 'GATGCTCCTGGCTATCATGA': 0,\n", + " 'GATGCTTCTGGCTATCATGA': 0,\n", + " 'GATGCCGATGGCTATCATGA': 0,\n", + " 'GATGCCGGTGGCTATCATGA': 0,\n", + " 'GATGCCGTTGGCTATCATGA': 0,\n", + " 'GATGCGGATGGCTATCATGA': 0,\n", + " 'GATGCGGGTGGCTATCATGA': 0,\n", + " 'GATGCGGTTGGCTATCATGA': 0,\n", + " 'GATGCTGATGGCTATCATGA': 0,\n", + " 'GATGCTGGTGGCTATCATGA': 0,\n", + " 'GATGCTGTTGGCTATCATGA': 0,\n", + " 'GATGCCGCAGGCTATCATGA': 0,\n", + " 'GATGCCGCCGGCTATCATGA': 0,\n", + " 'GATGCCGCGGGCTATCATGA': 0,\n", + " 'GATGCGGCAGGCTATCATGA': 0,\n", + " 'GATGCGGCCGGCTATCATGA': 0,\n", + " 'GATGCGGCGGGCTATCATGA': 0,\n", + " 'GATGCTGCAGGCTATCATGA': 0,\n", + " 'GATGCTGCCGGCTATCATGA': 0,\n", + " 'GATGCTGCGGGCTATCATGA': 0,\n", + " 'GATGCCGCTAGCTATCATGA': 0,\n", + " 'GATGCCGCTCGCTATCATGA': 0,\n", + " 'GATGCCGCTTGCTATCATGA': 0,\n", + " 'GATGCGGCTAGCTATCATGA': 0,\n", + " 'GATGCGGCTCGCTATCATGA': 0,\n", + " 'GATGCGGCTTGCTATCATGA': 0,\n", + " 'GATGCTGCTAGCTATCATGA': 0,\n", + " 'GATGCTGCTCGCTATCATGA': 0,\n", + " 'GATGCTGCTTGCTATCATGA': 0,\n", + " 'GATGCCGCTGACTATCATGA': 0,\n", + " 'GATGCCGCTGCCTATCATGA': 0,\n", + " 'GATGCCGCTGTCTATCATGA': 0,\n", + " 'GATGCGGCTGACTATCATGA': 0,\n", + " 'GATGCGGCTGCCTATCATGA': 0,\n", + " 'GATGCGGCTGTCTATCATGA': 0,\n", + " 'GATGCTGCTGACTATCATGA': 0,\n", + " 'GATGCTGCTGCCTATCATGA': 0,\n", + " 'GATGCTGCTGTCTATCATGA': 0,\n", + " 'GATGCCGCTGGATATCATGA': 0,\n", + " 'GATGCCGCTGGGTATCATGA': 0,\n", + " 'GATGCCGCTGGTTATCATGA': 0,\n", + " 'GATGCGGCTGGATATCATGA': 0,\n", + " 'GATGCGGCTGGGTATCATGA': 0,\n", + " 'GATGCGGCTGGTTATCATGA': 0,\n", + " 'GATGCTGCTGGATATCATGA': 0,\n", + " 'GATGCTGCTGGGTATCATGA': 0,\n", + " 'GATGCTGCTGGTTATCATGA': 0,\n", + " 'GATGCCGCTGGCAATCATGA': 0,\n", + " 'GATGCCGCTGGCCATCATGA': 0,\n", + " 'GATGCCGCTGGCGATCATGA': 0,\n", + " 'GATGCGGCTGGCAATCATGA': 0,\n", + " 'GATGCGGCTGGCCATCATGA': 0,\n", + " 'GATGCGGCTGGCGATCATGA': 0,\n", + " 'GATGCTGCTGGCAATCATGA': 0,\n", + " 'GATGCTGCTGGCCATCATGA': 0,\n", + " 'GATGCTGCTGGCGATCATGA': 0,\n", + " 'GATGCCGCTGGCTCTCATGA': 0,\n", + " 'GATGCCGCTGGCTGTCATGA': 0,\n", + " 'GATGCCGCTGGCTTTCATGA': 0,\n", + " 'GATGCGGCTGGCTCTCATGA': 0,\n", + " 'GATGCGGCTGGCTGTCATGA': 0,\n", + " 'GATGCGGCTGGCTTTCATGA': 0,\n", + " 'GATGCTGCTGGCTCTCATGA': 0,\n", + " 'GATGCTGCTGGCTGTCATGA': 0,\n", + " 'GATGCTGCTGGCTTTCATGA': 0,\n", + " 'GATGCCGCTGGCTAACATGA': 0,\n", + " 'GATGCCGCTGGCTACCATGA': 0,\n", + " 'GATGCCGCTGGCTAGCATGA': 0,\n", + " 'GATGCGGCTGGCTAACATGA': 0,\n", + " 'GATGCGGCTGGCTACCATGA': 0,\n", + " 'GATGCGGCTGGCTAGCATGA': 0,\n", + " 'GATGCTGCTGGCTAACATGA': 0,\n", + " 'GATGCTGCTGGCTACCATGA': 0,\n", + " 'GATGCTGCTGGCTAGCATGA': 0,\n", + " 'GATGCCGCTGGCTATAATGA': 0,\n", + " 'GATGCCGCTGGCTATGATGA': 0,\n", + " 'GATGCCGCTGGCTATTATGA': 0,\n", + " 'GATGCGGCTGGCTATAATGA': 0,\n", + " 'GATGCGGCTGGCTATGATGA': 0,\n", + " 'GATGCGGCTGGCTATTATGA': 0,\n", + " 'GATGCTGCTGGCTATAATGA': 0,\n", + " 'GATGCTGCTGGCTATGATGA': 0,\n", + " 'GATGCTGCTGGCTATTATGA': 0,\n", + " 'GATGCCGCTGGCTATCCTGA': 0,\n", + " 'GATGCCGCTGGCTATCGTGA': 0,\n", + " 'GATGCCGCTGGCTATCTTGA': 0,\n", + " 'GATGCGGCTGGCTATCCTGA': 0,\n", + " 'GATGCGGCTGGCTATCGTGA': 0,\n", + " 'GATGCGGCTGGCTATCTTGA': 0,\n", + " 'GATGCTGCTGGCTATCCTGA': 0,\n", + " 'GATGCTGCTGGCTATCGTGA': 0,\n", + " ...}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "barcode_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing read 0...\n", + "Processing read 10000...\n", + "Processing read 20000...\n", + "Processing read 30000...\n", + "Processing read 40000...\n", + "Processing read 50000...\n", + "Processing read 60000...\n", + "Processing read 70000...\n", + "Processing read 80000...\n", + "Processing read 90000...\n", + "Processing read 100000...\n", + "Processing read 110000...\n", + "Processing read 120000...\n", + "Processing read 130000...\n", + "Done!\n", + "Total # of unique-UMI reads = 86492\n" + ] + } + ], + "source": [ + "#Parse and map RNA sequencing reads\n", + "\n", + "save_suffix = \"_var_repl_2_hek293_v3\"\n", + "\n", + "r1_name = \"unprocessed_data/HEK_V2_trimmed.fastq\"\n", + "r2_name = \"unprocessed_data/HEK-V2_umi_trimmed.fastq\"\n", + "\n", + "polya_regexp = re.compile(r\"AAAAA(AAAAAAAAAAAAAAA){s<=2}\")\n", + "distal_regexp = re.compile(r\"(GCCTCGACTGTGCCTTCTAG){s<=2}\")\n", + "\n", + "def _hamming(s1, s2) :\n", + " \n", + " d = 0.\n", + " for j in range(len(s1)) :\n", + " if s1[j] != s2[j] :\n", + " d += 1.\n", + " \n", + " return d\n", + "\n", + "max_pos = 176\n", + "\n", + "umi_dict = {}\n", + "umi_n_muts = 0\n", + "\n", + "bases = ['A', 'C', 'G', 'T']\n", + "\n", + "cuts = np.zeros((len(library_df), 206))\n", + "\n", + "f1 = open(r1_name, 'rt')\n", + "f2 = open(r2_name, 'rt')\n", + "\n", + "#Iterate through reads sequenctially (r1 and r2)\n", + "\n", + "r1_counter = 0\n", + "while True :\n", + " \n", + " #Read 1\n", + " id1 = f1.readline().strip()\n", + " \n", + " #Check for end-of-file\n", + " if len(id1) == 0 :\n", + " break\n", + " \n", + " r1 = f1.readline().strip()\n", + " s1 = f1.readline().strip()\n", + " q1 = f1.readline().strip()\n", + " \n", + " #Read 2\n", + " id2 = f2.readline().strip()\n", + " r2 = f2.readline().strip()\n", + " s2 = f2.readline().strip()\n", + " q2 = f2.readline().strip()\n", + " \n", + " if r1_counter % 10000 == 0 :\n", + " print(\"Processing read \" + str(r1_counter) + \"...\")\n", + " \n", + " r1_counter += 1\n", + " \n", + " #Map read to library member\n", + " bc = r1[:20]\n", + " \n", + " lib_i = -1\n", + " if bc in barcode_dict :\n", + " lib_i = barcode_dict[bc]\n", + " \n", + " if lib_i == -1 :\n", + " continue\n", + " \n", + " if umi_n_muts == 0 :\n", + " bc = sequences[lib_i][:20]\n", + " \n", + " #Determine if we have seen this umi before, otherwise mark as visited\n", + " umi = r2[:8]\n", + " \n", + " if bc not in umi_dict :\n", + " umi_dict[bc] = {}\n", + " \n", + " umi_visited = False\n", + " if umi in umi_dict[bc] :\n", + " umi_visited = True\n", + " elif umi_n_muts == 1 :\n", + " for pos1 in range(len(umi)) :\n", + " for b1 in bases :\n", + " umi_mut = umi[:pos1] + b1 + umi[pos1+1:]\n", + " if umi_mut in umi_dict[bc] :\n", + " umi_visited = True\n", + " break\n", + " if umi_visited :\n", + " break\n", + " elif umi_n_muts == 2 :\n", + " for pos1 in range(len(umi)) :\n", + " for pos2 in range(pos1, len(umi)) :\n", + " for b1 in bases :\n", + " for b2 in bases :\n", + " umi_mut = umi[:pos1] + b1 + umi[pos1+1:pos2] + b2 + umi[pos2+1:]\n", + " if umi_mut in umi_dict[bc] :\n", + " umi_visited = True\n", + " break\n", + " if umi_visited :\n", + " break\n", + " if umi_visited :\n", + " break\n", + " if umi_visited :\n", + " break\n", + " \n", + " #Skip if umi already seen\n", + " if umi_visited :\n", + " continue\n", + " \n", + " #Determine polyA position (or alternative if the read is distally polyadenylated)\n", + " polya_match = re.search(polya_regexp, r1)\n", + " \n", + " polya_pos = -1\n", + " if polya_match is not None and polya_match.span()[0] < max_pos :\n", + " polya_pos = polya_match.span()[0]\n", + " \n", + " #Determine if distal read\n", + " is_distal = False\n", + " distal_match = re.search(distal_regexp, r1[209-5:209+20+5])\n", + " \n", + " if distal_match is not None :\n", + " is_distal = True\n", + " \n", + " #Aggregate read-position occurrence counts\n", + " if is_distal :\n", + " cuts[lib_i, -1] += 1.\n", + " \n", + " #Mark as seen and proceed\n", + " umi_dict[bc][umi] = True\n", + " \n", + " elif polya_pos != -1 and polya_pos >= 30 :\n", + " \n", + " #Perform hamming-based consistency check against reference of region upstream of cleavage\n", + " \n", + " hamming_dist = _hamming(sequences[lib_i][polya_pos-20:polya_pos], r1[polya_pos-20:polya_pos])\n", + " \n", + " if hamming_dist <= 3 :\n", + " cuts[lib_i, polya_pos] += 1.\n", + "\n", + " #Mark as seen and proceed\n", + " umi_dict[bc][umi] = True\n", + "\n", + "f1.close()\n", + "f2.close()\n", + "\n", + "print(\"Done!\")\n", + "\n", + "print(\"Total # of unique-UMI reads = \" + str(int(np.sum(cuts))))\n", + "\n", + "#Store processed read-position count matrix\n", + "np.save('apa_oligo_2022' + save_suffix + '_umi_mut_' + str(umi_n_muts) + '_cuts', cuts)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#Load processed read count data\n", + "\n", + "ref_cuts_repl_1 = np.load(\"apa_oligo_2022_ref_repl_1_hek293_v3_umi_mut_0_cuts.npy\")\n", + "var_cuts_repl_1 = np.load(\"apa_oligo_2022_var_repl_1_hek293_v3_umi_mut_0_cuts.npy\")\n", + "\n", + "ref_cuts_repl_2 = np.load(\"apa_oligo_2022_ref_repl_2_hek293_v3_umi_mut_0_cuts.npy\")\n", + "var_cuts_repl_2 = np.load(\"apa_oligo_2022_var_repl_2_hek293_v3_umi_mut_0_cuts.npy\")\n", + "\n", + "#Pooled counts\n", + "\n", + "ref_cuts_pooled = ref_cuts_repl_1 + ref_cuts_repl_2\n", + "var_cuts_pooled = var_cuts_repl_1 + var_cuts_repl_2\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#Augment library file with measured isoform summary statistics\n", + "\n", + "pseudo_c = 1.\n", + "\n", + "#Replicate 1\n", + "library_df['ref_count_77_127_repl_1'] = np.sum(ref_cuts_repl_1[:, 77:127], axis=-1)\n", + "library_df['ref_count_0_205_repl_1'] = np.sum(ref_cuts_repl_1[:, 0:205], axis=-1)\n", + "library_df['ref_count_total_repl_1'] = np.sum(ref_cuts_repl_1, axis=-1)\n", + "library_df['ref_logit_77_127_repl_1'] = np.log(\n", + " ((library_df['ref_count_77_127_repl_1'] + pseudo_c) / (library_df['ref_count_total_repl_1'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_77_127_repl_1'] + pseudo_c) / (library_df['ref_count_total_repl_1'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['ref_logit_0_205_repl_1'] = np.log(\n", + " ((library_df['ref_count_0_205_repl_1'] + pseudo_c) / (library_df['ref_count_total_repl_1'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_0_205_repl_1'] + pseudo_c) / (library_df['ref_count_total_repl_1'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['var_count_77_127_repl_1'] = np.sum(var_cuts_repl_1[:, 77:127], axis=-1)\n", + "library_df['var_count_0_205_repl_1'] = np.sum(var_cuts_repl_1[:, 0:205], axis=-1)\n", + "library_df['var_count_total_repl_1'] = np.sum(var_cuts_repl_1, axis=-1)\n", + "library_df['var_logit_77_127_repl_1'] = np.log(\n", + " ((library_df['var_count_77_127_repl_1'] + pseudo_c) / (library_df['var_count_total_repl_1'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_77_127_repl_1'] + pseudo_c) / (library_df['var_count_total_repl_1'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['var_logit_0_205_repl_1'] = np.log(\n", + " ((library_df['var_count_0_205_repl_1'] + pseudo_c) / (library_df['var_count_total_repl_1'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_0_205_repl_1'] + pseudo_c) / (library_df['var_count_total_repl_1'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['delta_logodds_true_77_127_repl_1'] = library_df['var_logit_77_127_repl_1'] - library_df['ref_logit_77_127_repl_1']\n", + "library_df['delta_logodds_true_0_205_repl_1'] = library_df['var_logit_0_205_repl_1'] - library_df['ref_logit_0_205_repl_1']\n", + "\n", + "#Replicate 2\n", + "library_df['ref_count_77_127_repl_2'] = np.sum(ref_cuts_repl_2[:, 77:127], axis=-1)\n", + "library_df['ref_count_0_205_repl_2'] = np.sum(ref_cuts_repl_2[:, 0:205], axis=-1)\n", + "library_df['ref_count_total_repl_2'] = np.sum(ref_cuts_repl_2, axis=-1)\n", + "library_df['ref_logit_77_127_repl_2'] = np.log(\n", + " ((library_df['ref_count_77_127_repl_2'] + pseudo_c) / (library_df['ref_count_total_repl_2'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_77_127_repl_2'] + pseudo_c) / (library_df['ref_count_total_repl_2'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['ref_logit_0_205_repl_2'] = np.log(\n", + " ((library_df['ref_count_0_205_repl_2'] + pseudo_c) / (library_df['ref_count_total_repl_2'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_0_205_repl_2'] + pseudo_c) / (library_df['ref_count_total_repl_2'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['var_count_77_127_repl_2'] = np.sum(var_cuts_repl_2[:, 77:127], axis=-1)\n", + "library_df['var_count_0_205_repl_2'] = np.sum(var_cuts_repl_2[:, 0:205], axis=-1)\n", + "library_df['var_count_total_repl_2'] = np.sum(var_cuts_repl_2, axis=-1)\n", + "library_df['var_logit_77_127_repl_2'] = np.log(\n", + " ((library_df['var_count_77_127_repl_2'] + pseudo_c) / (library_df['var_count_total_repl_2'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_77_127_repl_2'] + pseudo_c) / (library_df['var_count_total_repl_2'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['var_logit_0_205_repl_2'] = np.log(\n", + " ((library_df['var_count_0_205_repl_2'] + pseudo_c) / (library_df['var_count_total_repl_2'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_0_205_repl_2'] + pseudo_c) / (library_df['var_count_total_repl_2'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['delta_logodds_true_77_127_repl_2'] = library_df['var_logit_77_127_repl_2'] - library_df['ref_logit_77_127_repl_2']\n", + "library_df['delta_logodds_true_0_205_repl_2'] = library_df['var_logit_0_205_repl_2'] - library_df['ref_logit_0_205_repl_2']\n", + "\n", + "#Pooled replicates\n", + "library_df['ref_count_77_127_repl_pooled'] = np.sum(ref_cuts_pooled[:, 77:127], axis=-1)\n", + "library_df['ref_count_0_205_repl_pooled'] = np.sum(ref_cuts_pooled[:, 0:205], axis=-1)\n", + "library_df['ref_count_total_repl_pooled'] = np.sum(ref_cuts_pooled, axis=-1)\n", + "library_df['ref_logit_77_127_repl_pooled'] = np.log(\n", + " ((library_df['ref_count_77_127_repl_pooled'] + pseudo_c) / (library_df['ref_count_total_repl_pooled'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_77_127_repl_pooled'] + pseudo_c) / (library_df['ref_count_total_repl_pooled'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['ref_logit_0_205_repl_pooled'] = np.log(\n", + " ((library_df['ref_count_0_205_repl_pooled'] + pseudo_c) / (library_df['ref_count_total_repl_pooled'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_0_205_repl_pooled'] + pseudo_c) / (library_df['ref_count_total_repl_pooled'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['var_count_77_127_repl_pooled'] = np.sum(var_cuts_pooled[:, 77:127], axis=-1)\n", + "library_df['var_count_0_205_repl_pooled'] = np.sum(var_cuts_pooled[:, 0:205], axis=-1)\n", + "library_df['var_count_total_repl_pooled'] = np.sum(var_cuts_pooled, axis=-1)\n", + "library_df['var_logit_77_127_repl_pooled'] = np.log(\n", + " ((library_df['var_count_77_127_repl_pooled'] + pseudo_c) / (library_df['var_count_total_repl_pooled'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_77_127_repl_pooled'] + pseudo_c) / (library_df['var_count_total_repl_pooled'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['var_logit_0_205_repl_pooled'] = np.log(\n", + " ((library_df['var_count_0_205_repl_pooled'] + pseudo_c) / (library_df['var_count_total_repl_pooled'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_0_205_repl_pooled'] + pseudo_c) / (library_df['var_count_total_repl_pooled'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['delta_logodds_true_77_127_repl_pooled'] = library_df['var_logit_77_127_repl_pooled'] - library_df['ref_logit_77_127_repl_pooled']\n", + "library_df['delta_logodds_true_0_205_repl_pooled'] = library_df['var_logit_0_205_repl_pooled'] - library_df['ref_logit_0_205_repl_pooled']\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#Cache measurements in dataframe\n", + "\n", + "library_df.to_csv(\"apa_100_variants_rev2_20220621_hek293_v3_umi_mut_0.csv\", sep='\\t')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jlinder2/anaconda3/envs/tensorflow/lib/python3.6/site-packages/ipykernel/__main__.py:4: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/jlinder2/anaconda3/envs/tensorflow/lib/python3.6/site-packages/ipykernel/__main__.py:7: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/jlinder2/anaconda3/envs/tensorflow/lib/python3.6/site-packages/ipykernel/__main__.py:10: RuntimeWarning: invalid value encountered in true_divide\n" + ] + } + ], + "source": [ + "#Compute cleavage probabilities\n", + "\n", + "ref_cut_prob_repl_1 = ref_cuts_repl_1 / np.sum(ref_cuts_repl_1, axis=1)[:, None]\n", + "var_cut_prob_repl_1 = var_cuts_repl_1 / np.sum(var_cuts_repl_1, axis=1)[:, None]\n", + "\n", + "ref_cut_prob_repl_2 = ref_cuts_repl_2 / np.sum(ref_cuts_repl_2, axis=1)[:, None]\n", + "var_cut_prob_repl_2 = var_cuts_repl_2 / np.sum(var_cuts_repl_2, axis=1)[:, None]\n", + "\n", + "ref_cut_prob_pooled = ref_cuts_pooled / np.sum(ref_cuts_pooled, axis=1)[:, None]\n", + "var_cut_prob_pooled = var_cuts_pooled / np.sum(var_cuts_pooled, axis=1)[:, None]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "delta_logodds (repl 1) = 1.0482\n", + "delta_logodds (repl 2) = 0.7639\n", + "delta_logodds (pooled) = 0.9385\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Control: F2 variant (creation of new cutsite -1bp relative to reference)\n", + "\n", + "save_figs = True\n", + "fig_name = \"F2_control_profile_hek293\"\n", + "\n", + "test_ix = 9\n", + "\n", + "#Plot range\n", + "plot_start = 0\n", + "plot_end = 146\n", + "\n", + "#Isoform definition\n", + "cut_start = 77\n", + "cut_end = 127\n", + "\n", + "c_ref_1 = ref_cut_prob_repl_1[test_ix, :]\n", + "c_var_1 = var_cut_prob_repl_1[test_ix, :]\n", + "\n", + "c_ref_2 = ref_cut_prob_repl_2[test_ix, :]\n", + "c_var_2 = var_cut_prob_repl_2[test_ix, :]\n", + "\n", + "c_ref_pooled = ref_cut_prob_pooled[test_ix, :]\n", + "c_var_pooled = var_cut_prob_pooled[test_ix, :]\n", + "\n", + "delta_logodds_1 = np.log(np.sum(c_var_1[77:127]) / (1. - np.sum(c_var_1[77:127]))) - np.log(np.sum(c_ref_1[77:127]) / (1. - np.sum(c_ref_1[77:127])))\n", + "delta_logodds_2 = np.log(np.sum(c_var_2[77:127]) / (1. - np.sum(c_var_2[77:127]))) - np.log(np.sum(c_ref_2[77:127]) / (1. - np.sum(c_ref_2[77:127])))\n", + "delta_logodds_pooled = np.log(np.sum(c_var_pooled[77:127]) / (1. - np.sum(c_var_pooled[77:127]))) - np.log(np.sum(c_ref_pooled[77:127]) / (1. - np.sum(c_ref_pooled[77:127])))\n", + "\n", + "print(\"delta_logodds (repl 1) = \" + str(round(delta_logodds_1, 4)))\n", + "print(\"delta_logodds (repl 2) = \" + str(round(delta_logodds_2, 4)))\n", + "print(\"delta_logodds (pooled) = \" + str(round(delta_logodds_pooled, 4)))\n", + "\n", + "#Plot replicate 1 profile\n", + "f = plt.figure(figsize=(10, 3))\n", + "\n", + "plt.plot(c_ref_1[plot_start: plot_end], color='darkblue', linewidth=3)\n", + "plt.plot(c_var_1[plot_start: plot_end], color='darkorange', linewidth=3)\n", + "\n", + "plt.axvline(x=70, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "plt.axvline(x=76, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "\n", + "plt.xlim(plot_start, plot_end)\n", + "plt.ylim(0.)\n", + "\n", + "plt.title(\"Replicate 1. Delta Isoform Log Odds = \" + str(round(delta_logodds_1, 4)))\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_repl_1.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_repl_1.eps\")\n", + "\n", + "plt.show()\n", + "\n", + "#Plot replicate 2 profile\n", + "f = plt.figure(figsize=(10, 3))\n", + "\n", + "plt.plot(c_ref_2[plot_start: plot_end], color='darkblue', linewidth=3)\n", + "plt.plot(c_var_2[plot_start: plot_end], color='darkorange', linewidth=3)\n", + "\n", + "plt.axvline(x=70, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "plt.axvline(x=76, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "\n", + "plt.xlim(plot_start, plot_end)\n", + "plt.ylim(0.)\n", + "\n", + "plt.title(\"Replicate 2. Delta Isoform Log Odds = \" + str(round(delta_logodds_2, 4)))\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_repl_2.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_repl_2.eps\")\n", + "\n", + "plt.show()\n", + "\n", + "#Plot pooled replicate profile\n", + "f = plt.figure(figsize=(10, 3))\n", + "\n", + "plt.plot(c_ref_pooled[plot_start: plot_end], color='darkblue', linewidth=3)\n", + "plt.plot(c_var_pooled[plot_start: plot_end], color='darkorange', linewidth=3)\n", + "\n", + "plt.axvline(x=70, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "plt.axvline(x=76, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "\n", + "plt.xlim(plot_start, plot_end)\n", + "plt.ylim(0.)\n", + "\n", + "plt.title(\"Pooled replicates. Delta Isoform Log Odds = \" + str(round(delta_logodds_pooled, 4)))\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_pooled.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_pooled.eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(filtered_df) = 94\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from scipy.stats import spearmanr\n", + "\n", + "save_figs = True\n", + "fig_name = \"replicate_hek293\"\n", + "\n", + "min_c = 5.\n", + "\n", + "x_min = -6.\n", + "x_max = 4.\n", + "\n", + "filtered_df = library_df.query(\"ref_count_total_repl_1 >= \" + str(min_c) + \" and \" + \"ref_count_total_repl_2 >= \" + str(min_c) + \" and \" + \"var_count_total_repl_1 >= \" + str(min_c) + \" and \" + \"var_count_total_repl_2 >= \" + str(min_c))\n", + "\n", + "print(\"len(filtered_df) = \" + str(len(filtered_df)))\n", + "\n", + "#Reference library (replicate correlation)\n", + "r_val_ref, _ = spearmanr(filtered_df['ref_logit_77_127_repl_1'], filtered_df['ref_logit_77_127_repl_2'])\n", + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "plt.scatter(filtered_df['ref_logit_77_127_repl_1'], filtered_df['ref_logit_77_127_repl_2'], color='lightgreen', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "plt.xlim(x_min, x_max)\n", + "plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Ref Logit (Repl. 1)\", fontsize=12)\n", + "plt.ylabel(\"Ref Logit (Repl. 2)\", fontsize=12)\n", + "\n", + "plt.title(\"r = \" + str(round(r_val_ref, 3)) + \", n = \" + str(len(filtered_df)), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_ref_logits.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_ref_logits.eps\")\n", + "\n", + "plt.show()\n", + "\n", + "#Variant library (replicate correlation)\n", + "r_val_var, _ = spearmanr(filtered_df['var_logit_77_127_repl_1'], filtered_df['var_logit_77_127_repl_2'])\n", + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "plt.scatter(filtered_df['var_logit_77_127_repl_1'], filtered_df['var_logit_77_127_repl_2'], color='lightcoral', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "plt.xlim(x_min, x_max)\n", + "plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Var Logit (Repl. 1)\", fontsize=12)\n", + "plt.ylabel(\"Var Logit (Repl. 2)\", fontsize=12)\n", + "\n", + "plt.title(\"r = \" + str(round(r_val_var, 3)) + \", n = \" + str(len(filtered_df)), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_var_logits.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_var_logits.eps\")\n", + "\n", + "plt.show()\n", + "\n", + "#Ref-Var library (delta replicate correlation)\n", + "r_val_var, _ = spearmanr(filtered_df['delta_logodds_true_77_127_repl_1'], filtered_df['delta_logodds_true_77_127_repl_2'])\n", + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "plt.scatter(filtered_df['delta_logodds_true_77_127_repl_1'], filtered_df['delta_logodds_true_77_127_repl_2'], color='lightcoral', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "plt.xlim(x_min, x_max)\n", + "plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"LOR (Repl. 1)\", fontsize=12)\n", + "plt.ylabel(\"LOR (Repl. 2)\", fontsize=12)\n", + "\n", + "plt.title(\"r = \" + str(round(r_val_var, 3)) + \", n = \" + str(len(filtered_df)), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_delta_logodds.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_delta_logodds.eps\")\n", + "\n", + "plt.show()\n", + "\n", + "#Ref-Var control correlation\n", + "control_df = filtered_df.loc[filtered_df['experiment'].str.contains(\"control_\") & filtered_df['data_source'].str.contains(\"Array_2019\")]\n", + "\n", + "r_val_control, _ = spearmanr(control_df['ref_logit_77_127_repl_pooled'], control_df['var_logit_77_127_repl_pooled'])\n", + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "plt.scatter(control_df['ref_logit_77_127_repl_pooled'], control_df['var_logit_77_127_repl_pooled'], color='black', s=175, marker='^')\n", + "\n", + "plt.plot([x_min, x_max], [x_min, x_max], color='darkgreen', linestyle='--', linewidth=2,)\n", + "\n", + "plt.xlim(x_min, x_max)\n", + "plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Ref Logit\", fontsize=12)\n", + "plt.ylabel(\"Var Logit\", fontsize=12)\n", + "\n", + "plt.title(\"Controls; Spearman r = \" + str(round(r_val_control, 3)) + \", n = \" + str(len(control_df)), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_control_logits.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_control_logits.eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n (sequences) = 186066\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Compare controls from 2022 oligo array to the Cell paper 2019 array\n", + "\n", + "#Load oligo array from 2019\n", + "import isolearn.io as isoio\n", + "\n", + "save_figs = True\n", + "fig_name = \"replicate_hek293_to_2019\"\n", + "\n", + "isoform_pseudo_count = 1.\n", + "proximal_start = 77\n", + "proximal_end = 127\n", + "\n", + "file_prefix = str(proximal_start) + \"_\" + str(proximal_end)\n", + "\n", + "seq_dict = isoio.load('../../../../aparent/data/prepared_data/apa_array_data/apa_array_data_seq')\n", + "\n", + "seq_df = seq_dict['array_df']\n", + "seq_cuts = seq_dict['pooled_cuts']\n", + "\n", + "cut_true = np.concatenate([np.array(seq_cuts[:, 180: 180 + 205].todense()), np.array(seq_cuts[:, -1].todense()).reshape(-1, 1)], axis=-1)# - 1\n", + "\n", + "seq_df['proximal_count'] = [np.sum(cut_true[i, proximal_start:proximal_end]) for i in range(len(seq_df))]\n", + "seq_df['total_count'] = [np.sum(cut_true[i, :]) for i in range(len(seq_df))]\n", + "\n", + "seq_df['iso_true'] = (seq_df['proximal_count'] + isoform_pseudo_count) / (seq_df['total_count'] + 2. * isoform_pseudo_count)\n", + "seq_df['logodds_true'] = np.log(seq_df['iso_true'] / (1.0 - seq_df['iso_true']))\n", + "\n", + "seq_df['seq'] = seq_df['seq'].str.slice(0, 205)\n", + "\n", + "print(\"n (sequences) = \" + str(len(seq_df)))\n", + "\n", + "#Ref-Array 2019 control correlation\n", + "control_df_2019 = control_df.join(seq_df[['seq', 'logodds_true']].set_index(\"seq\"), on='ref_seq', how='inner').copy().reset_index(drop=True)\n", + "\n", + "r_val_control, _ = spearmanr(control_df_2019['ref_logit_77_127_repl_pooled'], control_df_2019['logodds_true'])\n", + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "plt.scatter(control_df_2019['ref_logit_77_127_repl_pooled'], control_df_2019['logodds_true'], color='deepskyblue', edgecolor='black', linewidth=1, s=175, marker='^')\n", + "\n", + "plt.plot([x_min, x_max], [x_min, x_max], color='darkgreen', linestyle='--', linewidth=2,)\n", + "\n", + "plt.xlim(x_min, x_max)\n", + "plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Logit (2022)\", fontsize=12)\n", + "plt.ylabel(\"Logit (2019)\", fontsize=12)\n", + "\n", + "plt.title(\"Controls; Spearman r = \" + str(round(r_val_control, 3)) + \", n = \" + str(len(control_df_2019)), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:tensorflow]", + "language": "python", + "name": "conda-env-tensorflow-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 +} diff --git a/data/oligo_pool_2022/medium_library/process_reads_hmc3.ipynb b/data/oligo_pool_2022/medium_library/process_reads_hmc3.ipynb new file mode 100644 index 0000000..d12eefd --- /dev/null +++ b/data/oligo_pool_2022/medium_library/process_reads_hmc3.ipynb @@ -0,0 +1,1877 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import scipy\n", + "import scipy.io as spio\n", + "import scipy.sparse as sp\n", + "\n", + "import regex as re\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(barcode_dict) = 201500\n" + ] + } + ], + "source": [ + "#Load reference library dataframe and build barcode dictionary\n", + "\n", + "library_df = pd.read_csv(\"apa_100_variants_rev2_20220621_pred.csv\", sep='\\t')\n", + "\n", + "#Build dictionary (double-mutation support)\n", + "bases = ['A', 'C', 'G', 'T']\n", + "\n", + "barcode_dict = {}\n", + "sequences = []\n", + "for i, [_, row] in enumerate(library_df.iterrows()) :\n", + " bc = row['ref_barcode']\n", + " \n", + " sequences.append(row['ref_seq'])\n", + " \n", + " barcode_dict[bc] = i\n", + " for pos1 in range(len(bc)) :\n", + " for pos2 in range(pos1, len(bc)) :\n", + " for b1 in bases :\n", + " for b2 in bases :\n", + " bc_mut = bc[:pos1] + b1 + bc[pos1+1:pos2] + b2 + bc[pos2+1:]\n", + " \n", + " if bc_mut in barcode_dict and barcode_dict[bc_mut] != i :\n", + " print(\"[ERROR] Barcode dictionary collision.\")\n", + " else :\n", + " barcode_dict[bc_mut] = i\n", + "\n", + "print(\"len(barcode_dict) = \" + str(len(barcode_dict)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'GATGCAGCTGGCTATCATGA': 0,\n", + " 'AAATGCAGCTGGCTATCATGA': 0,\n", + " 'ACATGCAGCTGGCTATCATGA': 0,\n", + " 'AGATGCAGCTGGCTATCATGA': 0,\n", + " 'ATATGCAGCTGGCTATCATGA': 0,\n", + " 'CAATGCAGCTGGCTATCATGA': 0,\n", + " 'CCATGCAGCTGGCTATCATGA': 0,\n", + " 'CGATGCAGCTGGCTATCATGA': 0,\n", + " 'CTATGCAGCTGGCTATCATGA': 0,\n", + " 'GAATGCAGCTGGCTATCATGA': 0,\n", + " 'GCATGCAGCTGGCTATCATGA': 0,\n", + " 'GGATGCAGCTGGCTATCATGA': 0,\n", + " 'GTATGCAGCTGGCTATCATGA': 0,\n", + " 'TAATGCAGCTGGCTATCATGA': 0,\n", + " 'TCATGCAGCTGGCTATCATGA': 0,\n", + " 'TGATGCAGCTGGCTATCATGA': 0,\n", + " 'TTATGCAGCTGGCTATCATGA': 0,\n", + " 'AATGCAGCTGGCTATCATGA': 0,\n", + " 'ACTGCAGCTGGCTATCATGA': 0,\n", + " 'AGTGCAGCTGGCTATCATGA': 0,\n", + " 'ATTGCAGCTGGCTATCATGA': 0,\n", + " 'CATGCAGCTGGCTATCATGA': 0,\n", + " 'CCTGCAGCTGGCTATCATGA': 0,\n", + " 'CGTGCAGCTGGCTATCATGA': 0,\n", + " 'CTTGCAGCTGGCTATCATGA': 0,\n", + " 'GCTGCAGCTGGCTATCATGA': 0,\n", + " 'GGTGCAGCTGGCTATCATGA': 0,\n", + " 'GTTGCAGCTGGCTATCATGA': 0,\n", + " 'TATGCAGCTGGCTATCATGA': 0,\n", + " 'TCTGCAGCTGGCTATCATGA': 0,\n", + " 'TGTGCAGCTGGCTATCATGA': 0,\n", + " 'TTTGCAGCTGGCTATCATGA': 0,\n", + " 'AAAGCAGCTGGCTATCATGA': 0,\n", + " 'AACGCAGCTGGCTATCATGA': 0,\n", + " 'AAGGCAGCTGGCTATCATGA': 0,\n", + " 'CAAGCAGCTGGCTATCATGA': 0,\n", + " 'CACGCAGCTGGCTATCATGA': 0,\n", + " 'CAGGCAGCTGGCTATCATGA': 0,\n", + " 'GAAGCAGCTGGCTATCATGA': 0,\n", + " 'GACGCAGCTGGCTATCATGA': 0,\n", + " 'GAGGCAGCTGGCTATCATGA': 0,\n", + " 'TAAGCAGCTGGCTATCATGA': 0,\n", + " 'TACGCAGCTGGCTATCATGA': 0,\n", + " 'TAGGCAGCTGGCTATCATGA': 0,\n", + " 'AATACAGCTGGCTATCATGA': 0,\n", + " 'AATCCAGCTGGCTATCATGA': 0,\n", + " 'AATTCAGCTGGCTATCATGA': 0,\n", + " 'CATACAGCTGGCTATCATGA': 0,\n", + " 'CATCCAGCTGGCTATCATGA': 0,\n", + " 'CATTCAGCTGGCTATCATGA': 0,\n", + " 'GATACAGCTGGCTATCATGA': 0,\n", + " 'GATCCAGCTGGCTATCATGA': 0,\n", + " 'GATTCAGCTGGCTATCATGA': 0,\n", + " 'TATACAGCTGGCTATCATGA': 0,\n", + " 'TATCCAGCTGGCTATCATGA': 0,\n", + " 'TATTCAGCTGGCTATCATGA': 0,\n", + " 'AATGAAGCTGGCTATCATGA': 0,\n", + " 'AATGGAGCTGGCTATCATGA': 0,\n", + " 'AATGTAGCTGGCTATCATGA': 0,\n", + " 'CATGAAGCTGGCTATCATGA': 0,\n", + " 'CATGGAGCTGGCTATCATGA': 0,\n", + " 'CATGTAGCTGGCTATCATGA': 0,\n", + " 'GATGAAGCTGGCTATCATGA': 0,\n", + " 'GATGGAGCTGGCTATCATGA': 0,\n", + " 'GATGTAGCTGGCTATCATGA': 0,\n", + " 'TATGAAGCTGGCTATCATGA': 0,\n", + " 'TATGGAGCTGGCTATCATGA': 0,\n", + " 'TATGTAGCTGGCTATCATGA': 0,\n", + " 'AATGCCGCTGGCTATCATGA': 0,\n", + " 'AATGCGGCTGGCTATCATGA': 0,\n", + " 'AATGCTGCTGGCTATCATGA': 0,\n", + " 'CATGCCGCTGGCTATCATGA': 0,\n", + " 'CATGCGGCTGGCTATCATGA': 0,\n", + " 'CATGCTGCTGGCTATCATGA': 0,\n", + " 'GATGCCGCTGGCTATCATGA': 0,\n", + " 'GATGCGGCTGGCTATCATGA': 0,\n", + " 'GATGCTGCTGGCTATCATGA': 0,\n", + " 'TATGCCGCTGGCTATCATGA': 0,\n", + " 'TATGCGGCTGGCTATCATGA': 0,\n", + " 'TATGCTGCTGGCTATCATGA': 0,\n", + " 'AATGCAACTGGCTATCATGA': 0,\n", + " 'AATGCACCTGGCTATCATGA': 0,\n", + " 'AATGCATCTGGCTATCATGA': 0,\n", + " 'CATGCAACTGGCTATCATGA': 0,\n", + " 'CATGCACCTGGCTATCATGA': 0,\n", + " 'CATGCATCTGGCTATCATGA': 0,\n", + " 'GATGCAACTGGCTATCATGA': 0,\n", + " 'GATGCACCTGGCTATCATGA': 0,\n", + " 'GATGCATCTGGCTATCATGA': 0,\n", + " 'TATGCAACTGGCTATCATGA': 0,\n", + " 'TATGCACCTGGCTATCATGA': 0,\n", + " 'TATGCATCTGGCTATCATGA': 0,\n", + " 'AATGCAGATGGCTATCATGA': 0,\n", + " 'AATGCAGGTGGCTATCATGA': 0,\n", + " 'AATGCAGTTGGCTATCATGA': 0,\n", + " 'CATGCAGATGGCTATCATGA': 0,\n", + " 'CATGCAGGTGGCTATCATGA': 0,\n", + " 'CATGCAGTTGGCTATCATGA': 0,\n", + " 'GATGCAGATGGCTATCATGA': 0,\n", + " 'GATGCAGGTGGCTATCATGA': 0,\n", + " 'GATGCAGTTGGCTATCATGA': 0,\n", + " 'TATGCAGATGGCTATCATGA': 0,\n", + " 'TATGCAGGTGGCTATCATGA': 0,\n", + " 'TATGCAGTTGGCTATCATGA': 0,\n", + " 'AATGCAGCAGGCTATCATGA': 0,\n", + " 'AATGCAGCCGGCTATCATGA': 0,\n", + " 'AATGCAGCGGGCTATCATGA': 0,\n", + " 'CATGCAGCAGGCTATCATGA': 0,\n", + " 'CATGCAGCCGGCTATCATGA': 0,\n", + " 'CATGCAGCGGGCTATCATGA': 0,\n", + " 'GATGCAGCAGGCTATCATGA': 0,\n", + " 'GATGCAGCCGGCTATCATGA': 0,\n", + " 'GATGCAGCGGGCTATCATGA': 0,\n", + " 'TATGCAGCAGGCTATCATGA': 0,\n", + " 'TATGCAGCCGGCTATCATGA': 0,\n", + " 'TATGCAGCGGGCTATCATGA': 0,\n", + " 'AATGCAGCTAGCTATCATGA': 0,\n", + " 'AATGCAGCTCGCTATCATGA': 0,\n", + " 'AATGCAGCTTGCTATCATGA': 0,\n", + " 'CATGCAGCTAGCTATCATGA': 0,\n", + " 'CATGCAGCTCGCTATCATGA': 0,\n", + " 'CATGCAGCTTGCTATCATGA': 0,\n", + " 'GATGCAGCTAGCTATCATGA': 0,\n", + " 'GATGCAGCTCGCTATCATGA': 0,\n", + " 'GATGCAGCTTGCTATCATGA': 0,\n", + " 'TATGCAGCTAGCTATCATGA': 0,\n", + " 'TATGCAGCTCGCTATCATGA': 0,\n", + " 'TATGCAGCTTGCTATCATGA': 0,\n", + " 'AATGCAGCTGACTATCATGA': 0,\n", + " 'AATGCAGCTGCCTATCATGA': 0,\n", + " 'AATGCAGCTGTCTATCATGA': 0,\n", + " 'CATGCAGCTGACTATCATGA': 0,\n", + " 'CATGCAGCTGCCTATCATGA': 0,\n", + " 'CATGCAGCTGTCTATCATGA': 0,\n", + " 'GATGCAGCTGACTATCATGA': 0,\n", + " 'GATGCAGCTGCCTATCATGA': 0,\n", + " 'GATGCAGCTGTCTATCATGA': 0,\n", + " 'TATGCAGCTGACTATCATGA': 0,\n", + " 'TATGCAGCTGCCTATCATGA': 0,\n", + " 'TATGCAGCTGTCTATCATGA': 0,\n", + " 'AATGCAGCTGGATATCATGA': 0,\n", + " 'AATGCAGCTGGGTATCATGA': 0,\n", + " 'AATGCAGCTGGTTATCATGA': 0,\n", + " 'CATGCAGCTGGATATCATGA': 0,\n", + " 'CATGCAGCTGGGTATCATGA': 0,\n", + " 'CATGCAGCTGGTTATCATGA': 0,\n", + " 'GATGCAGCTGGATATCATGA': 0,\n", + " 'GATGCAGCTGGGTATCATGA': 0,\n", + " 'GATGCAGCTGGTTATCATGA': 0,\n", + " 'TATGCAGCTGGATATCATGA': 0,\n", + " 'TATGCAGCTGGGTATCATGA': 0,\n", + " 'TATGCAGCTGGTTATCATGA': 0,\n", + " 'AATGCAGCTGGCAATCATGA': 0,\n", + " 'AATGCAGCTGGCCATCATGA': 0,\n", + " 'AATGCAGCTGGCGATCATGA': 0,\n", + " 'CATGCAGCTGGCAATCATGA': 0,\n", + " 'CATGCAGCTGGCCATCATGA': 0,\n", + " 'CATGCAGCTGGCGATCATGA': 0,\n", + " 'GATGCAGCTGGCAATCATGA': 0,\n", + " 'GATGCAGCTGGCCATCATGA': 0,\n", + " 'GATGCAGCTGGCGATCATGA': 0,\n", + " 'TATGCAGCTGGCAATCATGA': 0,\n", + " 'TATGCAGCTGGCCATCATGA': 0,\n", + " 'TATGCAGCTGGCGATCATGA': 0,\n", + " 'AATGCAGCTGGCTCTCATGA': 0,\n", + " 'AATGCAGCTGGCTGTCATGA': 0,\n", + " 'AATGCAGCTGGCTTTCATGA': 0,\n", + " 'CATGCAGCTGGCTCTCATGA': 0,\n", + " 'CATGCAGCTGGCTGTCATGA': 0,\n", + " 'CATGCAGCTGGCTTTCATGA': 0,\n", + " 'GATGCAGCTGGCTCTCATGA': 0,\n", + " 'GATGCAGCTGGCTGTCATGA': 0,\n", + " 'GATGCAGCTGGCTTTCATGA': 0,\n", + " 'TATGCAGCTGGCTCTCATGA': 0,\n", + " 'TATGCAGCTGGCTGTCATGA': 0,\n", + " 'TATGCAGCTGGCTTTCATGA': 0,\n", + " 'AATGCAGCTGGCTAACATGA': 0,\n", + " 'AATGCAGCTGGCTACCATGA': 0,\n", + " 'AATGCAGCTGGCTAGCATGA': 0,\n", + " 'CATGCAGCTGGCTAACATGA': 0,\n", + " 'CATGCAGCTGGCTACCATGA': 0,\n", + " 'CATGCAGCTGGCTAGCATGA': 0,\n", + " 'GATGCAGCTGGCTAACATGA': 0,\n", + " 'GATGCAGCTGGCTACCATGA': 0,\n", + " 'GATGCAGCTGGCTAGCATGA': 0,\n", + " 'TATGCAGCTGGCTAACATGA': 0,\n", + " 'TATGCAGCTGGCTACCATGA': 0,\n", + " 'TATGCAGCTGGCTAGCATGA': 0,\n", + " 'AATGCAGCTGGCTATAATGA': 0,\n", + " 'AATGCAGCTGGCTATGATGA': 0,\n", + " 'AATGCAGCTGGCTATTATGA': 0,\n", + " 'CATGCAGCTGGCTATAATGA': 0,\n", + " 'CATGCAGCTGGCTATGATGA': 0,\n", + " 'CATGCAGCTGGCTATTATGA': 0,\n", + " 'GATGCAGCTGGCTATAATGA': 0,\n", + " 'GATGCAGCTGGCTATGATGA': 0,\n", + " 'GATGCAGCTGGCTATTATGA': 0,\n", + " 'TATGCAGCTGGCTATAATGA': 0,\n", + " 'TATGCAGCTGGCTATGATGA': 0,\n", + " 'TATGCAGCTGGCTATTATGA': 0,\n", + " 'AATGCAGCTGGCTATCCTGA': 0,\n", + " 'AATGCAGCTGGCTATCGTGA': 0,\n", + " 'AATGCAGCTGGCTATCTTGA': 0,\n", + " 'CATGCAGCTGGCTATCCTGA': 0,\n", + " 'CATGCAGCTGGCTATCGTGA': 0,\n", + " 'CATGCAGCTGGCTATCTTGA': 0,\n", + " 'GATGCAGCTGGCTATCCTGA': 0,\n", + " 'GATGCAGCTGGCTATCGTGA': 0,\n", + " 'GATGCAGCTGGCTATCTTGA': 0,\n", + " 'TATGCAGCTGGCTATCCTGA': 0,\n", + " 'TATGCAGCTGGCTATCGTGA': 0,\n", + " 'TATGCAGCTGGCTATCTTGA': 0,\n", + " 'AATGCAGCTGGCTATCAAGA': 0,\n", + " 'AATGCAGCTGGCTATCACGA': 0,\n", + " 'AATGCAGCTGGCTATCAGGA': 0,\n", + " 'CATGCAGCTGGCTATCAAGA': 0,\n", + " 'CATGCAGCTGGCTATCACGA': 0,\n", + " 'CATGCAGCTGGCTATCAGGA': 0,\n", + " 'GATGCAGCTGGCTATCAAGA': 0,\n", + " 'GATGCAGCTGGCTATCACGA': 0,\n", + " 'GATGCAGCTGGCTATCAGGA': 0,\n", + " 'TATGCAGCTGGCTATCAAGA': 0,\n", + " 'TATGCAGCTGGCTATCACGA': 0,\n", + " 'TATGCAGCTGGCTATCAGGA': 0,\n", + " 'AATGCAGCTGGCTATCATAA': 0,\n", + " 'AATGCAGCTGGCTATCATCA': 0,\n", + " 'AATGCAGCTGGCTATCATTA': 0,\n", + " 'CATGCAGCTGGCTATCATAA': 0,\n", + " 'CATGCAGCTGGCTATCATCA': 0,\n", + " 'CATGCAGCTGGCTATCATTA': 0,\n", + " 'GATGCAGCTGGCTATCATAA': 0,\n", + " 'GATGCAGCTGGCTATCATCA': 0,\n", + " 'GATGCAGCTGGCTATCATTA': 0,\n", + " 'TATGCAGCTGGCTATCATAA': 0,\n", + " 'TATGCAGCTGGCTATCATCA': 0,\n", + " 'TATGCAGCTGGCTATCATTA': 0,\n", + " 'AATGCAGCTGGCTATCATGC': 0,\n", + " 'AATGCAGCTGGCTATCATGG': 0,\n", + " 'AATGCAGCTGGCTATCATGT': 0,\n", + " 'CATGCAGCTGGCTATCATGC': 0,\n", + " 'CATGCAGCTGGCTATCATGG': 0,\n", + " 'CATGCAGCTGGCTATCATGT': 0,\n", + " 'GATGCAGCTGGCTATCATGC': 0,\n", + " 'GATGCAGCTGGCTATCATGG': 0,\n", + " 'GATGCAGCTGGCTATCATGT': 0,\n", + " 'TATGCAGCTGGCTATCATGC': 0,\n", + " 'TATGCAGCTGGCTATCATGG': 0,\n", + " 'TATGCAGCTGGCTATCATGT': 0,\n", + " 'GACTGCAGCTGGCTATCATGA': 0,\n", + " 'GAGTGCAGCTGGCTATCATGA': 0,\n", + " 'GATTGCAGCTGGCTATCATGA': 0,\n", + " 'GCCTGCAGCTGGCTATCATGA': 0,\n", + " 'GCGTGCAGCTGGCTATCATGA': 0,\n", + " 'GCTTGCAGCTGGCTATCATGA': 0,\n", + " 'GGCTGCAGCTGGCTATCATGA': 0,\n", + " 'GGGTGCAGCTGGCTATCATGA': 0,\n", + " 'GGTTGCAGCTGGCTATCATGA': 0,\n", + " 'GTCTGCAGCTGGCTATCATGA': 0,\n", + " 'GTGTGCAGCTGGCTATCATGA': 0,\n", + " 'GTTTGCAGCTGGCTATCATGA': 0,\n", + " 'GCAGCAGCTGGCTATCATGA': 0,\n", + " 'GCCGCAGCTGGCTATCATGA': 0,\n", + " 'GCGGCAGCTGGCTATCATGA': 0,\n", + " 'GGAGCAGCTGGCTATCATGA': 0,\n", + " 'GGCGCAGCTGGCTATCATGA': 0,\n", + " 'GGGGCAGCTGGCTATCATGA': 0,\n", + " 'GTAGCAGCTGGCTATCATGA': 0,\n", + " 'GTCGCAGCTGGCTATCATGA': 0,\n", + " 'GTGGCAGCTGGCTATCATGA': 0,\n", + " 'GCTACAGCTGGCTATCATGA': 0,\n", + " 'GCTCCAGCTGGCTATCATGA': 0,\n", + " 'GCTTCAGCTGGCTATCATGA': 0,\n", + " 'GGTACAGCTGGCTATCATGA': 0,\n", + " 'GGTCCAGCTGGCTATCATGA': 0,\n", + " 'GGTTCAGCTGGCTATCATGA': 0,\n", + " 'GTTACAGCTGGCTATCATGA': 0,\n", + " 'GTTCCAGCTGGCTATCATGA': 0,\n", + " 'GTTTCAGCTGGCTATCATGA': 0,\n", + " 'GCTGAAGCTGGCTATCATGA': 0,\n", + " 'GCTGGAGCTGGCTATCATGA': 0,\n", + " 'GCTGTAGCTGGCTATCATGA': 0,\n", + " 'GGTGAAGCTGGCTATCATGA': 0,\n", + " 'GGTGGAGCTGGCTATCATGA': 0,\n", + " 'GGTGTAGCTGGCTATCATGA': 0,\n", + " 'GTTGAAGCTGGCTATCATGA': 0,\n", + " 'GTTGGAGCTGGCTATCATGA': 0,\n", + " 'GTTGTAGCTGGCTATCATGA': 0,\n", + " 'GCTGCCGCTGGCTATCATGA': 0,\n", + " 'GCTGCGGCTGGCTATCATGA': 0,\n", + " 'GCTGCTGCTGGCTATCATGA': 0,\n", + " 'GGTGCCGCTGGCTATCATGA': 0,\n", + " 'GGTGCGGCTGGCTATCATGA': 0,\n", + " 'GGTGCTGCTGGCTATCATGA': 0,\n", + " 'GTTGCCGCTGGCTATCATGA': 0,\n", + " 'GTTGCGGCTGGCTATCATGA': 0,\n", + " 'GTTGCTGCTGGCTATCATGA': 0,\n", + " 'GCTGCAACTGGCTATCATGA': 0,\n", + " 'GCTGCACCTGGCTATCATGA': 0,\n", + " 'GCTGCATCTGGCTATCATGA': 0,\n", + " 'GGTGCAACTGGCTATCATGA': 0,\n", + " 'GGTGCACCTGGCTATCATGA': 0,\n", + " 'GGTGCATCTGGCTATCATGA': 0,\n", + " 'GTTGCAACTGGCTATCATGA': 0,\n", + " 'GTTGCACCTGGCTATCATGA': 0,\n", + " 'GTTGCATCTGGCTATCATGA': 0,\n", + " 'GCTGCAGATGGCTATCATGA': 0,\n", + " 'GCTGCAGGTGGCTATCATGA': 0,\n", + " 'GCTGCAGTTGGCTATCATGA': 0,\n", + " 'GGTGCAGATGGCTATCATGA': 0,\n", + " 'GGTGCAGGTGGCTATCATGA': 0,\n", + " 'GGTGCAGTTGGCTATCATGA': 0,\n", + " 'GTTGCAGATGGCTATCATGA': 0,\n", + " 'GTTGCAGGTGGCTATCATGA': 0,\n", + " 'GTTGCAGTTGGCTATCATGA': 0,\n", + " 'GCTGCAGCAGGCTATCATGA': 0,\n", + " 'GCTGCAGCCGGCTATCATGA': 0,\n", + " 'GCTGCAGCGGGCTATCATGA': 0,\n", + " 'GGTGCAGCAGGCTATCATGA': 0,\n", + " 'GGTGCAGCCGGCTATCATGA': 0,\n", + " 'GGTGCAGCGGGCTATCATGA': 0,\n", + " 'GTTGCAGCAGGCTATCATGA': 0,\n", + " 'GTTGCAGCCGGCTATCATGA': 0,\n", + " 'GTTGCAGCGGGCTATCATGA': 0,\n", + " 'GCTGCAGCTAGCTATCATGA': 0,\n", + " 'GCTGCAGCTCGCTATCATGA': 0,\n", + " 'GCTGCAGCTTGCTATCATGA': 0,\n", + " 'GGTGCAGCTAGCTATCATGA': 0,\n", + " 'GGTGCAGCTCGCTATCATGA': 0,\n", + " 'GGTGCAGCTTGCTATCATGA': 0,\n", + " 'GTTGCAGCTAGCTATCATGA': 0,\n", + " 'GTTGCAGCTCGCTATCATGA': 0,\n", + " 'GTTGCAGCTTGCTATCATGA': 0,\n", + " 'GCTGCAGCTGACTATCATGA': 0,\n", + " 'GCTGCAGCTGCCTATCATGA': 0,\n", + " 'GCTGCAGCTGTCTATCATGA': 0,\n", + " 'GGTGCAGCTGACTATCATGA': 0,\n", + " 'GGTGCAGCTGCCTATCATGA': 0,\n", + " 'GGTGCAGCTGTCTATCATGA': 0,\n", + " 'GTTGCAGCTGACTATCATGA': 0,\n", + " 'GTTGCAGCTGCCTATCATGA': 0,\n", + " 'GTTGCAGCTGTCTATCATGA': 0,\n", + " 'GCTGCAGCTGGATATCATGA': 0,\n", + " 'GCTGCAGCTGGGTATCATGA': 0,\n", + " 'GCTGCAGCTGGTTATCATGA': 0,\n", + " 'GGTGCAGCTGGATATCATGA': 0,\n", + " 'GGTGCAGCTGGGTATCATGA': 0,\n", + " 'GGTGCAGCTGGTTATCATGA': 0,\n", + " 'GTTGCAGCTGGATATCATGA': 0,\n", + " 'GTTGCAGCTGGGTATCATGA': 0,\n", + " 'GTTGCAGCTGGTTATCATGA': 0,\n", + " 'GCTGCAGCTGGCAATCATGA': 0,\n", + " 'GCTGCAGCTGGCCATCATGA': 0,\n", + " 'GCTGCAGCTGGCGATCATGA': 0,\n", + " 'GGTGCAGCTGGCAATCATGA': 0,\n", + " 'GGTGCAGCTGGCCATCATGA': 0,\n", + " 'GGTGCAGCTGGCGATCATGA': 0,\n", + " 'GTTGCAGCTGGCAATCATGA': 0,\n", + " 'GTTGCAGCTGGCCATCATGA': 0,\n", + " 'GTTGCAGCTGGCGATCATGA': 0,\n", + " 'GCTGCAGCTGGCTCTCATGA': 0,\n", + " 'GCTGCAGCTGGCTGTCATGA': 0,\n", + " 'GCTGCAGCTGGCTTTCATGA': 0,\n", + " 'GGTGCAGCTGGCTCTCATGA': 0,\n", + " 'GGTGCAGCTGGCTGTCATGA': 0,\n", + " 'GGTGCAGCTGGCTTTCATGA': 0,\n", + " 'GTTGCAGCTGGCTCTCATGA': 0,\n", + " 'GTTGCAGCTGGCTGTCATGA': 0,\n", + " 'GTTGCAGCTGGCTTTCATGA': 0,\n", + " 'GCTGCAGCTGGCTAACATGA': 0,\n", + " 'GCTGCAGCTGGCTACCATGA': 0,\n", + " 'GCTGCAGCTGGCTAGCATGA': 0,\n", + " 'GGTGCAGCTGGCTAACATGA': 0,\n", + " 'GGTGCAGCTGGCTACCATGA': 0,\n", + " 'GGTGCAGCTGGCTAGCATGA': 0,\n", + " 'GTTGCAGCTGGCTAACATGA': 0,\n", + " 'GTTGCAGCTGGCTACCATGA': 0,\n", + " 'GTTGCAGCTGGCTAGCATGA': 0,\n", + " 'GCTGCAGCTGGCTATAATGA': 0,\n", + " 'GCTGCAGCTGGCTATGATGA': 0,\n", + " 'GCTGCAGCTGGCTATTATGA': 0,\n", + " 'GGTGCAGCTGGCTATAATGA': 0,\n", + " 'GGTGCAGCTGGCTATGATGA': 0,\n", + " 'GGTGCAGCTGGCTATTATGA': 0,\n", + " 'GTTGCAGCTGGCTATAATGA': 0,\n", + " 'GTTGCAGCTGGCTATGATGA': 0,\n", + " 'GTTGCAGCTGGCTATTATGA': 0,\n", + " 'GCTGCAGCTGGCTATCCTGA': 0,\n", + " 'GCTGCAGCTGGCTATCGTGA': 0,\n", + " 'GCTGCAGCTGGCTATCTTGA': 0,\n", + " 'GGTGCAGCTGGCTATCCTGA': 0,\n", + " 'GGTGCAGCTGGCTATCGTGA': 0,\n", + " 'GGTGCAGCTGGCTATCTTGA': 0,\n", + " 'GTTGCAGCTGGCTATCCTGA': 0,\n", + " 'GTTGCAGCTGGCTATCGTGA': 0,\n", + " 'GTTGCAGCTGGCTATCTTGA': 0,\n", + " 'GCTGCAGCTGGCTATCAAGA': 0,\n", + " 'GCTGCAGCTGGCTATCACGA': 0,\n", + " 'GCTGCAGCTGGCTATCAGGA': 0,\n", + " 'GGTGCAGCTGGCTATCAAGA': 0,\n", + " 'GGTGCAGCTGGCTATCACGA': 0,\n", + " 'GGTGCAGCTGGCTATCAGGA': 0,\n", + " 'GTTGCAGCTGGCTATCAAGA': 0,\n", + " 'GTTGCAGCTGGCTATCACGA': 0,\n", + " 'GTTGCAGCTGGCTATCAGGA': 0,\n", + " 'GCTGCAGCTGGCTATCATAA': 0,\n", + " 'GCTGCAGCTGGCTATCATCA': 0,\n", + " 'GCTGCAGCTGGCTATCATTA': 0,\n", + " 'GGTGCAGCTGGCTATCATAA': 0,\n", + " 'GGTGCAGCTGGCTATCATCA': 0,\n", + " 'GGTGCAGCTGGCTATCATTA': 0,\n", + " 'GTTGCAGCTGGCTATCATAA': 0,\n", + " 'GTTGCAGCTGGCTATCATCA': 0,\n", + " 'GTTGCAGCTGGCTATCATTA': 0,\n", + " 'GCTGCAGCTGGCTATCATGC': 0,\n", + " 'GCTGCAGCTGGCTATCATGG': 0,\n", + " 'GCTGCAGCTGGCTATCATGT': 0,\n", + " 'GGTGCAGCTGGCTATCATGC': 0,\n", + " 'GGTGCAGCTGGCTATCATGG': 0,\n", + " 'GGTGCAGCTGGCTATCATGT': 0,\n", + " 'GTTGCAGCTGGCTATCATGC': 0,\n", + " 'GTTGCAGCTGGCTATCATGG': 0,\n", + " 'GTTGCAGCTGGCTATCATGT': 0,\n", + " 'GAAAGCAGCTGGCTATCATGA': 0,\n", + " 'GAACGCAGCTGGCTATCATGA': 0,\n", + " 'GAAGGCAGCTGGCTATCATGA': 0,\n", + " 'GACAGCAGCTGGCTATCATGA': 0,\n", + " 'GACCGCAGCTGGCTATCATGA': 0,\n", + " 'GACGGCAGCTGGCTATCATGA': 0,\n", + " 'GAGAGCAGCTGGCTATCATGA': 0,\n", + " 'GAGCGCAGCTGGCTATCATGA': 0,\n", + " 'GAGGGCAGCTGGCTATCATGA': 0,\n", + " 'GATAGCAGCTGGCTATCATGA': 0,\n", + " 'GATCGCAGCTGGCTATCATGA': 0,\n", + " 'GATGGCAGCTGGCTATCATGA': 0,\n", + " 'GAAACAGCTGGCTATCATGA': 0,\n", + " 'GAACCAGCTGGCTATCATGA': 0,\n", + " 'GAATCAGCTGGCTATCATGA': 0,\n", + " 'GACACAGCTGGCTATCATGA': 0,\n", + " 'GACCCAGCTGGCTATCATGA': 0,\n", + " 'GACTCAGCTGGCTATCATGA': 0,\n", + " 'GAGACAGCTGGCTATCATGA': 0,\n", + " 'GAGCCAGCTGGCTATCATGA': 0,\n", + " 'GAGTCAGCTGGCTATCATGA': 0,\n", + " 'GAAGAAGCTGGCTATCATGA': 0,\n", + " 'GAAGGAGCTGGCTATCATGA': 0,\n", + " 'GAAGTAGCTGGCTATCATGA': 0,\n", + " 'GACGAAGCTGGCTATCATGA': 0,\n", + " 'GACGGAGCTGGCTATCATGA': 0,\n", + " 'GACGTAGCTGGCTATCATGA': 0,\n", + " 'GAGGAAGCTGGCTATCATGA': 0,\n", + " 'GAGGGAGCTGGCTATCATGA': 0,\n", + " 'GAGGTAGCTGGCTATCATGA': 0,\n", + " 'GAAGCCGCTGGCTATCATGA': 0,\n", + " 'GAAGCGGCTGGCTATCATGA': 0,\n", + " 'GAAGCTGCTGGCTATCATGA': 0,\n", + " 'GACGCCGCTGGCTATCATGA': 0,\n", + " 'GACGCGGCTGGCTATCATGA': 0,\n", + " 'GACGCTGCTGGCTATCATGA': 0,\n", + " 'GAGGCCGCTGGCTATCATGA': 0,\n", + " 'GAGGCGGCTGGCTATCATGA': 0,\n", + " 'GAGGCTGCTGGCTATCATGA': 0,\n", + " 'GAAGCAACTGGCTATCATGA': 0,\n", + " 'GAAGCACCTGGCTATCATGA': 0,\n", + " 'GAAGCATCTGGCTATCATGA': 0,\n", + " 'GACGCAACTGGCTATCATGA': 0,\n", + " 'GACGCACCTGGCTATCATGA': 0,\n", + " 'GACGCATCTGGCTATCATGA': 0,\n", + " 'GAGGCAACTGGCTATCATGA': 0,\n", + " 'GAGGCACCTGGCTATCATGA': 0,\n", + " 'GAGGCATCTGGCTATCATGA': 0,\n", + " 'GAAGCAGATGGCTATCATGA': 0,\n", + " 'GAAGCAGGTGGCTATCATGA': 0,\n", + " 'GAAGCAGTTGGCTATCATGA': 0,\n", + " 'GACGCAGATGGCTATCATGA': 0,\n", + " 'GACGCAGGTGGCTATCATGA': 0,\n", + " 'GACGCAGTTGGCTATCATGA': 0,\n", + " 'GAGGCAGATGGCTATCATGA': 0,\n", + " 'GAGGCAGGTGGCTATCATGA': 0,\n", + " 'GAGGCAGTTGGCTATCATGA': 0,\n", + " 'GAAGCAGCAGGCTATCATGA': 0,\n", + " 'GAAGCAGCCGGCTATCATGA': 0,\n", + " 'GAAGCAGCGGGCTATCATGA': 0,\n", + " 'GACGCAGCAGGCTATCATGA': 0,\n", + " 'GACGCAGCCGGCTATCATGA': 0,\n", + " 'GACGCAGCGGGCTATCATGA': 0,\n", + " 'GAGGCAGCAGGCTATCATGA': 0,\n", + " 'GAGGCAGCCGGCTATCATGA': 0,\n", + " 'GAGGCAGCGGGCTATCATGA': 0,\n", + " 'GAAGCAGCTAGCTATCATGA': 0,\n", + " 'GAAGCAGCTCGCTATCATGA': 0,\n", + " 'GAAGCAGCTTGCTATCATGA': 0,\n", + " 'GACGCAGCTAGCTATCATGA': 0,\n", + " 'GACGCAGCTCGCTATCATGA': 0,\n", + " 'GACGCAGCTTGCTATCATGA': 0,\n", + " 'GAGGCAGCTAGCTATCATGA': 0,\n", + " 'GAGGCAGCTCGCTATCATGA': 0,\n", + " 'GAGGCAGCTTGCTATCATGA': 0,\n", + " 'GAAGCAGCTGACTATCATGA': 0,\n", + " 'GAAGCAGCTGCCTATCATGA': 0,\n", + " 'GAAGCAGCTGTCTATCATGA': 0,\n", + " 'GACGCAGCTGACTATCATGA': 0,\n", + " 'GACGCAGCTGCCTATCATGA': 0,\n", + " 'GACGCAGCTGTCTATCATGA': 0,\n", + " 'GAGGCAGCTGACTATCATGA': 0,\n", + " 'GAGGCAGCTGCCTATCATGA': 0,\n", + " 'GAGGCAGCTGTCTATCATGA': 0,\n", + " 'GAAGCAGCTGGATATCATGA': 0,\n", + " 'GAAGCAGCTGGGTATCATGA': 0,\n", + " 'GAAGCAGCTGGTTATCATGA': 0,\n", + " 'GACGCAGCTGGATATCATGA': 0,\n", + " 'GACGCAGCTGGGTATCATGA': 0,\n", + " 'GACGCAGCTGGTTATCATGA': 0,\n", + " 'GAGGCAGCTGGATATCATGA': 0,\n", + " 'GAGGCAGCTGGGTATCATGA': 0,\n", + " 'GAGGCAGCTGGTTATCATGA': 0,\n", + " 'GAAGCAGCTGGCAATCATGA': 0,\n", + " 'GAAGCAGCTGGCCATCATGA': 0,\n", + " 'GAAGCAGCTGGCGATCATGA': 0,\n", + " 'GACGCAGCTGGCAATCATGA': 0,\n", + " 'GACGCAGCTGGCCATCATGA': 0,\n", + " 'GACGCAGCTGGCGATCATGA': 0,\n", + " 'GAGGCAGCTGGCAATCATGA': 0,\n", + " 'GAGGCAGCTGGCCATCATGA': 0,\n", + " 'GAGGCAGCTGGCGATCATGA': 0,\n", + " 'GAAGCAGCTGGCTCTCATGA': 0,\n", + " 'GAAGCAGCTGGCTGTCATGA': 0,\n", + " 'GAAGCAGCTGGCTTTCATGA': 0,\n", + " 'GACGCAGCTGGCTCTCATGA': 0,\n", + " 'GACGCAGCTGGCTGTCATGA': 0,\n", + " 'GACGCAGCTGGCTTTCATGA': 0,\n", + " 'GAGGCAGCTGGCTCTCATGA': 0,\n", + " 'GAGGCAGCTGGCTGTCATGA': 0,\n", + " 'GAGGCAGCTGGCTTTCATGA': 0,\n", + " 'GAAGCAGCTGGCTAACATGA': 0,\n", + " 'GAAGCAGCTGGCTACCATGA': 0,\n", + " 'GAAGCAGCTGGCTAGCATGA': 0,\n", + " 'GACGCAGCTGGCTAACATGA': 0,\n", + " 'GACGCAGCTGGCTACCATGA': 0,\n", + " 'GACGCAGCTGGCTAGCATGA': 0,\n", + " 'GAGGCAGCTGGCTAACATGA': 0,\n", + " 'GAGGCAGCTGGCTACCATGA': 0,\n", + " 'GAGGCAGCTGGCTAGCATGA': 0,\n", + " 'GAAGCAGCTGGCTATAATGA': 0,\n", + " 'GAAGCAGCTGGCTATGATGA': 0,\n", + " 'GAAGCAGCTGGCTATTATGA': 0,\n", + " 'GACGCAGCTGGCTATAATGA': 0,\n", + " 'GACGCAGCTGGCTATGATGA': 0,\n", + " 'GACGCAGCTGGCTATTATGA': 0,\n", + " 'GAGGCAGCTGGCTATAATGA': 0,\n", + " 'GAGGCAGCTGGCTATGATGA': 0,\n", + " 'GAGGCAGCTGGCTATTATGA': 0,\n", + " 'GAAGCAGCTGGCTATCCTGA': 0,\n", + " 'GAAGCAGCTGGCTATCGTGA': 0,\n", + " 'GAAGCAGCTGGCTATCTTGA': 0,\n", + " 'GACGCAGCTGGCTATCCTGA': 0,\n", + " 'GACGCAGCTGGCTATCGTGA': 0,\n", + " 'GACGCAGCTGGCTATCTTGA': 0,\n", + " 'GAGGCAGCTGGCTATCCTGA': 0,\n", + " 'GAGGCAGCTGGCTATCGTGA': 0,\n", + " 'GAGGCAGCTGGCTATCTTGA': 0,\n", + " 'GAAGCAGCTGGCTATCAAGA': 0,\n", + " 'GAAGCAGCTGGCTATCACGA': 0,\n", + " 'GAAGCAGCTGGCTATCAGGA': 0,\n", + " 'GACGCAGCTGGCTATCAAGA': 0,\n", + " 'GACGCAGCTGGCTATCACGA': 0,\n", + " 'GACGCAGCTGGCTATCAGGA': 0,\n", + " 'GAGGCAGCTGGCTATCAAGA': 0,\n", + " 'GAGGCAGCTGGCTATCACGA': 0,\n", + " 'GAGGCAGCTGGCTATCAGGA': 0,\n", + " 'GAAGCAGCTGGCTATCATAA': 0,\n", + " 'GAAGCAGCTGGCTATCATCA': 0,\n", + " 'GAAGCAGCTGGCTATCATTA': 0,\n", + " 'GACGCAGCTGGCTATCATAA': 0,\n", + " 'GACGCAGCTGGCTATCATCA': 0,\n", + " 'GACGCAGCTGGCTATCATTA': 0,\n", + " 'GAGGCAGCTGGCTATCATAA': 0,\n", + " 'GAGGCAGCTGGCTATCATCA': 0,\n", + " 'GAGGCAGCTGGCTATCATTA': 0,\n", + " 'GAAGCAGCTGGCTATCATGC': 0,\n", + " 'GAAGCAGCTGGCTATCATGG': 0,\n", + " 'GAAGCAGCTGGCTATCATGT': 0,\n", + " 'GACGCAGCTGGCTATCATGC': 0,\n", + " 'GACGCAGCTGGCTATCATGG': 0,\n", + " 'GACGCAGCTGGCTATCATGT': 0,\n", + " 'GAGGCAGCTGGCTATCATGC': 0,\n", + " 'GAGGCAGCTGGCTATCATGG': 0,\n", + " 'GAGGCAGCTGGCTATCATGT': 0,\n", + " 'GATAACAGCTGGCTATCATGA': 0,\n", + " 'GATACCAGCTGGCTATCATGA': 0,\n", + " 'GATATCAGCTGGCTATCATGA': 0,\n", + " 'GATCACAGCTGGCTATCATGA': 0,\n", + " 'GATCCCAGCTGGCTATCATGA': 0,\n", + " 'GATCTCAGCTGGCTATCATGA': 0,\n", + " 'GATGACAGCTGGCTATCATGA': 0,\n", + " 'GATGCCAGCTGGCTATCATGA': 0,\n", + " 'GATGTCAGCTGGCTATCATGA': 0,\n", + " 'GATTACAGCTGGCTATCATGA': 0,\n", + " 'GATTCCAGCTGGCTATCATGA': 0,\n", + " 'GATTTCAGCTGGCTATCATGA': 0,\n", + " 'GATAAAGCTGGCTATCATGA': 0,\n", + " 'GATAGAGCTGGCTATCATGA': 0,\n", + " 'GATATAGCTGGCTATCATGA': 0,\n", + " 'GATCAAGCTGGCTATCATGA': 0,\n", + " 'GATCGAGCTGGCTATCATGA': 0,\n", + " 'GATCTAGCTGGCTATCATGA': 0,\n", + " 'GATTAAGCTGGCTATCATGA': 0,\n", + " 'GATTGAGCTGGCTATCATGA': 0,\n", + " 'GATTTAGCTGGCTATCATGA': 0,\n", + " 'GATACCGCTGGCTATCATGA': 0,\n", + " 'GATACGGCTGGCTATCATGA': 0,\n", + " 'GATACTGCTGGCTATCATGA': 0,\n", + " 'GATCCCGCTGGCTATCATGA': 0,\n", + " 'GATCCGGCTGGCTATCATGA': 0,\n", + " 'GATCCTGCTGGCTATCATGA': 0,\n", + " 'GATTCCGCTGGCTATCATGA': 0,\n", + " 'GATTCGGCTGGCTATCATGA': 0,\n", + " 'GATTCTGCTGGCTATCATGA': 0,\n", + " 'GATACAACTGGCTATCATGA': 0,\n", + " 'GATACACCTGGCTATCATGA': 0,\n", + " 'GATACATCTGGCTATCATGA': 0,\n", + " 'GATCCAACTGGCTATCATGA': 0,\n", + " 'GATCCACCTGGCTATCATGA': 0,\n", + " 'GATCCATCTGGCTATCATGA': 0,\n", + " 'GATTCAACTGGCTATCATGA': 0,\n", + " 'GATTCACCTGGCTATCATGA': 0,\n", + " 'GATTCATCTGGCTATCATGA': 0,\n", + " 'GATACAGATGGCTATCATGA': 0,\n", + " 'GATACAGGTGGCTATCATGA': 0,\n", + " 'GATACAGTTGGCTATCATGA': 0,\n", + " 'GATCCAGATGGCTATCATGA': 0,\n", + " 'GATCCAGGTGGCTATCATGA': 0,\n", + " 'GATCCAGTTGGCTATCATGA': 0,\n", + " 'GATTCAGATGGCTATCATGA': 0,\n", + " 'GATTCAGGTGGCTATCATGA': 0,\n", + " 'GATTCAGTTGGCTATCATGA': 0,\n", + " 'GATACAGCAGGCTATCATGA': 0,\n", + " 'GATACAGCCGGCTATCATGA': 0,\n", + " 'GATACAGCGGGCTATCATGA': 0,\n", + " 'GATCCAGCAGGCTATCATGA': 0,\n", + " 'GATCCAGCCGGCTATCATGA': 0,\n", + " 'GATCCAGCGGGCTATCATGA': 0,\n", + " 'GATTCAGCAGGCTATCATGA': 0,\n", + " 'GATTCAGCCGGCTATCATGA': 0,\n", + " 'GATTCAGCGGGCTATCATGA': 0,\n", + " 'GATACAGCTAGCTATCATGA': 0,\n", + " 'GATACAGCTCGCTATCATGA': 0,\n", + " 'GATACAGCTTGCTATCATGA': 0,\n", + " 'GATCCAGCTAGCTATCATGA': 0,\n", + " 'GATCCAGCTCGCTATCATGA': 0,\n", + " 'GATCCAGCTTGCTATCATGA': 0,\n", + " 'GATTCAGCTAGCTATCATGA': 0,\n", + " 'GATTCAGCTCGCTATCATGA': 0,\n", + " 'GATTCAGCTTGCTATCATGA': 0,\n", + " 'GATACAGCTGACTATCATGA': 0,\n", + " 'GATACAGCTGCCTATCATGA': 0,\n", + " 'GATACAGCTGTCTATCATGA': 0,\n", + " 'GATCCAGCTGACTATCATGA': 0,\n", + " 'GATCCAGCTGCCTATCATGA': 0,\n", + " 'GATCCAGCTGTCTATCATGA': 0,\n", + " 'GATTCAGCTGACTATCATGA': 0,\n", + " 'GATTCAGCTGCCTATCATGA': 0,\n", + " 'GATTCAGCTGTCTATCATGA': 0,\n", + " 'GATACAGCTGGATATCATGA': 0,\n", + " 'GATACAGCTGGGTATCATGA': 0,\n", + " 'GATACAGCTGGTTATCATGA': 0,\n", + " 'GATCCAGCTGGATATCATGA': 0,\n", + " 'GATCCAGCTGGGTATCATGA': 0,\n", + " 'GATCCAGCTGGTTATCATGA': 0,\n", + " 'GATTCAGCTGGATATCATGA': 0,\n", + " 'GATTCAGCTGGGTATCATGA': 0,\n", + " 'GATTCAGCTGGTTATCATGA': 0,\n", + " 'GATACAGCTGGCAATCATGA': 0,\n", + " 'GATACAGCTGGCCATCATGA': 0,\n", + " 'GATACAGCTGGCGATCATGA': 0,\n", + " 'GATCCAGCTGGCAATCATGA': 0,\n", + " 'GATCCAGCTGGCCATCATGA': 0,\n", + " 'GATCCAGCTGGCGATCATGA': 0,\n", + " 'GATTCAGCTGGCAATCATGA': 0,\n", + " 'GATTCAGCTGGCCATCATGA': 0,\n", + " 'GATTCAGCTGGCGATCATGA': 0,\n", + " 'GATACAGCTGGCTCTCATGA': 0,\n", + " 'GATACAGCTGGCTGTCATGA': 0,\n", + " 'GATACAGCTGGCTTTCATGA': 0,\n", + " 'GATCCAGCTGGCTCTCATGA': 0,\n", + " 'GATCCAGCTGGCTGTCATGA': 0,\n", + " 'GATCCAGCTGGCTTTCATGA': 0,\n", + " 'GATTCAGCTGGCTCTCATGA': 0,\n", + " 'GATTCAGCTGGCTGTCATGA': 0,\n", + " 'GATTCAGCTGGCTTTCATGA': 0,\n", + " 'GATACAGCTGGCTAACATGA': 0,\n", + " 'GATACAGCTGGCTACCATGA': 0,\n", + " 'GATACAGCTGGCTAGCATGA': 0,\n", + " 'GATCCAGCTGGCTAACATGA': 0,\n", + " 'GATCCAGCTGGCTACCATGA': 0,\n", + " 'GATCCAGCTGGCTAGCATGA': 0,\n", + " 'GATTCAGCTGGCTAACATGA': 0,\n", + " 'GATTCAGCTGGCTACCATGA': 0,\n", + " 'GATTCAGCTGGCTAGCATGA': 0,\n", + " 'GATACAGCTGGCTATAATGA': 0,\n", + " 'GATACAGCTGGCTATGATGA': 0,\n", + " 'GATACAGCTGGCTATTATGA': 0,\n", + " 'GATCCAGCTGGCTATAATGA': 0,\n", + " 'GATCCAGCTGGCTATGATGA': 0,\n", + " 'GATCCAGCTGGCTATTATGA': 0,\n", + " 'GATTCAGCTGGCTATAATGA': 0,\n", + " 'GATTCAGCTGGCTATGATGA': 0,\n", + " 'GATTCAGCTGGCTATTATGA': 0,\n", + " 'GATACAGCTGGCTATCCTGA': 0,\n", + " 'GATACAGCTGGCTATCGTGA': 0,\n", + " 'GATACAGCTGGCTATCTTGA': 0,\n", + " 'GATCCAGCTGGCTATCCTGA': 0,\n", + " 'GATCCAGCTGGCTATCGTGA': 0,\n", + " 'GATCCAGCTGGCTATCTTGA': 0,\n", + " 'GATTCAGCTGGCTATCCTGA': 0,\n", + " 'GATTCAGCTGGCTATCGTGA': 0,\n", + " 'GATTCAGCTGGCTATCTTGA': 0,\n", + " 'GATACAGCTGGCTATCAAGA': 0,\n", + " 'GATACAGCTGGCTATCACGA': 0,\n", + " 'GATACAGCTGGCTATCAGGA': 0,\n", + " 'GATCCAGCTGGCTATCAAGA': 0,\n", + " 'GATCCAGCTGGCTATCACGA': 0,\n", + " 'GATCCAGCTGGCTATCAGGA': 0,\n", + " 'GATTCAGCTGGCTATCAAGA': 0,\n", + " 'GATTCAGCTGGCTATCACGA': 0,\n", + " 'GATTCAGCTGGCTATCAGGA': 0,\n", + " 'GATACAGCTGGCTATCATAA': 0,\n", + " 'GATACAGCTGGCTATCATCA': 0,\n", + " 'GATACAGCTGGCTATCATTA': 0,\n", + " 'GATCCAGCTGGCTATCATAA': 0,\n", + " 'GATCCAGCTGGCTATCATCA': 0,\n", + " 'GATCCAGCTGGCTATCATTA': 0,\n", + " 'GATTCAGCTGGCTATCATAA': 0,\n", + " 'GATTCAGCTGGCTATCATCA': 0,\n", + " 'GATTCAGCTGGCTATCATTA': 0,\n", + " 'GATACAGCTGGCTATCATGC': 0,\n", + " 'GATACAGCTGGCTATCATGG': 0,\n", + " 'GATACAGCTGGCTATCATGT': 0,\n", + " 'GATCCAGCTGGCTATCATGC': 0,\n", + " 'GATCCAGCTGGCTATCATGG': 0,\n", + " 'GATCCAGCTGGCTATCATGT': 0,\n", + " 'GATTCAGCTGGCTATCATGC': 0,\n", + " 'GATTCAGCTGGCTATCATGG': 0,\n", + " 'GATTCAGCTGGCTATCATGT': 0,\n", + " 'GATGAAAGCTGGCTATCATGA': 0,\n", + " 'GATGAGAGCTGGCTATCATGA': 0,\n", + " 'GATGATAGCTGGCTATCATGA': 0,\n", + " 'GATGCAAGCTGGCTATCATGA': 0,\n", + " 'GATGCGAGCTGGCTATCATGA': 0,\n", + " 'GATGCTAGCTGGCTATCATGA': 0,\n", + " 'GATGGAAGCTGGCTATCATGA': 0,\n", + " 'GATGGGAGCTGGCTATCATGA': 0,\n", + " 'GATGGTAGCTGGCTATCATGA': 0,\n", + " 'GATGTAAGCTGGCTATCATGA': 0,\n", + " 'GATGTGAGCTGGCTATCATGA': 0,\n", + " 'GATGTTAGCTGGCTATCATGA': 0,\n", + " 'GATGACGCTGGCTATCATGA': 0,\n", + " 'GATGAGGCTGGCTATCATGA': 0,\n", + " 'GATGATGCTGGCTATCATGA': 0,\n", + " 'GATGGCGCTGGCTATCATGA': 0,\n", + " 'GATGGGGCTGGCTATCATGA': 0,\n", + " 'GATGGTGCTGGCTATCATGA': 0,\n", + " 'GATGTCGCTGGCTATCATGA': 0,\n", + " 'GATGTGGCTGGCTATCATGA': 0,\n", + " 'GATGTTGCTGGCTATCATGA': 0,\n", + " 'GATGAAACTGGCTATCATGA': 0,\n", + " 'GATGAACCTGGCTATCATGA': 0,\n", + " 'GATGAATCTGGCTATCATGA': 0,\n", + " 'GATGGAACTGGCTATCATGA': 0,\n", + " 'GATGGACCTGGCTATCATGA': 0,\n", + " 'GATGGATCTGGCTATCATGA': 0,\n", + " 'GATGTAACTGGCTATCATGA': 0,\n", + " 'GATGTACCTGGCTATCATGA': 0,\n", + " 'GATGTATCTGGCTATCATGA': 0,\n", + " 'GATGAAGATGGCTATCATGA': 0,\n", + " 'GATGAAGGTGGCTATCATGA': 0,\n", + " 'GATGAAGTTGGCTATCATGA': 0,\n", + " 'GATGGAGATGGCTATCATGA': 0,\n", + " 'GATGGAGGTGGCTATCATGA': 0,\n", + " 'GATGGAGTTGGCTATCATGA': 0,\n", + " 'GATGTAGATGGCTATCATGA': 0,\n", + " 'GATGTAGGTGGCTATCATGA': 0,\n", + " 'GATGTAGTTGGCTATCATGA': 0,\n", + " 'GATGAAGCAGGCTATCATGA': 0,\n", + " 'GATGAAGCCGGCTATCATGA': 0,\n", + " 'GATGAAGCGGGCTATCATGA': 0,\n", + " 'GATGGAGCAGGCTATCATGA': 0,\n", + " 'GATGGAGCCGGCTATCATGA': 0,\n", + " 'GATGGAGCGGGCTATCATGA': 0,\n", + " 'GATGTAGCAGGCTATCATGA': 0,\n", + " 'GATGTAGCCGGCTATCATGA': 0,\n", + " 'GATGTAGCGGGCTATCATGA': 0,\n", + " 'GATGAAGCTAGCTATCATGA': 0,\n", + " 'GATGAAGCTCGCTATCATGA': 0,\n", + " 'GATGAAGCTTGCTATCATGA': 0,\n", + " 'GATGGAGCTAGCTATCATGA': 0,\n", + " 'GATGGAGCTCGCTATCATGA': 0,\n", + " 'GATGGAGCTTGCTATCATGA': 0,\n", + " 'GATGTAGCTAGCTATCATGA': 0,\n", + " 'GATGTAGCTCGCTATCATGA': 0,\n", + " 'GATGTAGCTTGCTATCATGA': 0,\n", + " 'GATGAAGCTGACTATCATGA': 0,\n", + " 'GATGAAGCTGCCTATCATGA': 0,\n", + " 'GATGAAGCTGTCTATCATGA': 0,\n", + " 'GATGGAGCTGACTATCATGA': 0,\n", + " 'GATGGAGCTGCCTATCATGA': 0,\n", + " 'GATGGAGCTGTCTATCATGA': 0,\n", + " 'GATGTAGCTGACTATCATGA': 0,\n", + " 'GATGTAGCTGCCTATCATGA': 0,\n", + " 'GATGTAGCTGTCTATCATGA': 0,\n", + " 'GATGAAGCTGGATATCATGA': 0,\n", + " 'GATGAAGCTGGGTATCATGA': 0,\n", + " 'GATGAAGCTGGTTATCATGA': 0,\n", + " 'GATGGAGCTGGATATCATGA': 0,\n", + " 'GATGGAGCTGGGTATCATGA': 0,\n", + " 'GATGGAGCTGGTTATCATGA': 0,\n", + " 'GATGTAGCTGGATATCATGA': 0,\n", + " 'GATGTAGCTGGGTATCATGA': 0,\n", + " 'GATGTAGCTGGTTATCATGA': 0,\n", + " 'GATGAAGCTGGCAATCATGA': 0,\n", + " 'GATGAAGCTGGCCATCATGA': 0,\n", + " 'GATGAAGCTGGCGATCATGA': 0,\n", + " 'GATGGAGCTGGCAATCATGA': 0,\n", + " 'GATGGAGCTGGCCATCATGA': 0,\n", + " 'GATGGAGCTGGCGATCATGA': 0,\n", + " 'GATGTAGCTGGCAATCATGA': 0,\n", + " 'GATGTAGCTGGCCATCATGA': 0,\n", + " 'GATGTAGCTGGCGATCATGA': 0,\n", + " 'GATGAAGCTGGCTCTCATGA': 0,\n", + " 'GATGAAGCTGGCTGTCATGA': 0,\n", + " 'GATGAAGCTGGCTTTCATGA': 0,\n", + " 'GATGGAGCTGGCTCTCATGA': 0,\n", + " 'GATGGAGCTGGCTGTCATGA': 0,\n", + " 'GATGGAGCTGGCTTTCATGA': 0,\n", + " 'GATGTAGCTGGCTCTCATGA': 0,\n", + " 'GATGTAGCTGGCTGTCATGA': 0,\n", + " 'GATGTAGCTGGCTTTCATGA': 0,\n", + " 'GATGAAGCTGGCTAACATGA': 0,\n", + " 'GATGAAGCTGGCTACCATGA': 0,\n", + " 'GATGAAGCTGGCTAGCATGA': 0,\n", + " 'GATGGAGCTGGCTAACATGA': 0,\n", + " 'GATGGAGCTGGCTACCATGA': 0,\n", + " 'GATGGAGCTGGCTAGCATGA': 0,\n", + " 'GATGTAGCTGGCTAACATGA': 0,\n", + " 'GATGTAGCTGGCTACCATGA': 0,\n", + " 'GATGTAGCTGGCTAGCATGA': 0,\n", + " 'GATGAAGCTGGCTATAATGA': 0,\n", + " 'GATGAAGCTGGCTATGATGA': 0,\n", + " 'GATGAAGCTGGCTATTATGA': 0,\n", + " 'GATGGAGCTGGCTATAATGA': 0,\n", + " 'GATGGAGCTGGCTATGATGA': 0,\n", + " 'GATGGAGCTGGCTATTATGA': 0,\n", + " 'GATGTAGCTGGCTATAATGA': 0,\n", + " 'GATGTAGCTGGCTATGATGA': 0,\n", + " 'GATGTAGCTGGCTATTATGA': 0,\n", + " 'GATGAAGCTGGCTATCCTGA': 0,\n", + " 'GATGAAGCTGGCTATCGTGA': 0,\n", + " 'GATGAAGCTGGCTATCTTGA': 0,\n", + " 'GATGGAGCTGGCTATCCTGA': 0,\n", + " 'GATGGAGCTGGCTATCGTGA': 0,\n", + " 'GATGGAGCTGGCTATCTTGA': 0,\n", + " 'GATGTAGCTGGCTATCCTGA': 0,\n", + " 'GATGTAGCTGGCTATCGTGA': 0,\n", + " 'GATGTAGCTGGCTATCTTGA': 0,\n", + " 'GATGAAGCTGGCTATCAAGA': 0,\n", + " 'GATGAAGCTGGCTATCACGA': 0,\n", + " 'GATGAAGCTGGCTATCAGGA': 0,\n", + " 'GATGGAGCTGGCTATCAAGA': 0,\n", + " 'GATGGAGCTGGCTATCACGA': 0,\n", + " 'GATGGAGCTGGCTATCAGGA': 0,\n", + " 'GATGTAGCTGGCTATCAAGA': 0,\n", + " 'GATGTAGCTGGCTATCACGA': 0,\n", + " 'GATGTAGCTGGCTATCAGGA': 0,\n", + " 'GATGAAGCTGGCTATCATAA': 0,\n", + " 'GATGAAGCTGGCTATCATCA': 0,\n", + " 'GATGAAGCTGGCTATCATTA': 0,\n", + " 'GATGGAGCTGGCTATCATAA': 0,\n", + " 'GATGGAGCTGGCTATCATCA': 0,\n", + " 'GATGGAGCTGGCTATCATTA': 0,\n", + " 'GATGTAGCTGGCTATCATAA': 0,\n", + " 'GATGTAGCTGGCTATCATCA': 0,\n", + " 'GATGTAGCTGGCTATCATTA': 0,\n", + " 'GATGAAGCTGGCTATCATGC': 0,\n", + " 'GATGAAGCTGGCTATCATGG': 0,\n", + " 'GATGAAGCTGGCTATCATGT': 0,\n", + " 'GATGGAGCTGGCTATCATGC': 0,\n", + " 'GATGGAGCTGGCTATCATGG': 0,\n", + " 'GATGGAGCTGGCTATCATGT': 0,\n", + " 'GATGTAGCTGGCTATCATGC': 0,\n", + " 'GATGTAGCTGGCTATCATGG': 0,\n", + " 'GATGTAGCTGGCTATCATGT': 0,\n", + " 'GATGCACGCTGGCTATCATGA': 0,\n", + " 'GATGCAGGCTGGCTATCATGA': 0,\n", + " 'GATGCATGCTGGCTATCATGA': 0,\n", + " 'GATGCCCGCTGGCTATCATGA': 0,\n", + " 'GATGCCGGCTGGCTATCATGA': 0,\n", + " 'GATGCCTGCTGGCTATCATGA': 0,\n", + " 'GATGCGCGCTGGCTATCATGA': 0,\n", + " 'GATGCGGGCTGGCTATCATGA': 0,\n", + " 'GATGCGTGCTGGCTATCATGA': 0,\n", + " 'GATGCTCGCTGGCTATCATGA': 0,\n", + " 'GATGCTGGCTGGCTATCATGA': 0,\n", + " 'GATGCTTGCTGGCTATCATGA': 0,\n", + " 'GATGCCACTGGCTATCATGA': 0,\n", + " 'GATGCCCCTGGCTATCATGA': 0,\n", + " 'GATGCCTCTGGCTATCATGA': 0,\n", + " 'GATGCGACTGGCTATCATGA': 0,\n", + " 'GATGCGCCTGGCTATCATGA': 0,\n", + " 'GATGCGTCTGGCTATCATGA': 0,\n", + " 'GATGCTACTGGCTATCATGA': 0,\n", + " 'GATGCTCCTGGCTATCATGA': 0,\n", + " 'GATGCTTCTGGCTATCATGA': 0,\n", + " 'GATGCCGATGGCTATCATGA': 0,\n", + " 'GATGCCGGTGGCTATCATGA': 0,\n", + " 'GATGCCGTTGGCTATCATGA': 0,\n", + " 'GATGCGGATGGCTATCATGA': 0,\n", + " 'GATGCGGGTGGCTATCATGA': 0,\n", + " 'GATGCGGTTGGCTATCATGA': 0,\n", + " 'GATGCTGATGGCTATCATGA': 0,\n", + " 'GATGCTGGTGGCTATCATGA': 0,\n", + " 'GATGCTGTTGGCTATCATGA': 0,\n", + " 'GATGCCGCAGGCTATCATGA': 0,\n", + " 'GATGCCGCCGGCTATCATGA': 0,\n", + " 'GATGCCGCGGGCTATCATGA': 0,\n", + " 'GATGCGGCAGGCTATCATGA': 0,\n", + " 'GATGCGGCCGGCTATCATGA': 0,\n", + " 'GATGCGGCGGGCTATCATGA': 0,\n", + " 'GATGCTGCAGGCTATCATGA': 0,\n", + " 'GATGCTGCCGGCTATCATGA': 0,\n", + " 'GATGCTGCGGGCTATCATGA': 0,\n", + " 'GATGCCGCTAGCTATCATGA': 0,\n", + " 'GATGCCGCTCGCTATCATGA': 0,\n", + " 'GATGCCGCTTGCTATCATGA': 0,\n", + " 'GATGCGGCTAGCTATCATGA': 0,\n", + " 'GATGCGGCTCGCTATCATGA': 0,\n", + " 'GATGCGGCTTGCTATCATGA': 0,\n", + " 'GATGCTGCTAGCTATCATGA': 0,\n", + " 'GATGCTGCTCGCTATCATGA': 0,\n", + " 'GATGCTGCTTGCTATCATGA': 0,\n", + " 'GATGCCGCTGACTATCATGA': 0,\n", + " 'GATGCCGCTGCCTATCATGA': 0,\n", + " 'GATGCCGCTGTCTATCATGA': 0,\n", + " 'GATGCGGCTGACTATCATGA': 0,\n", + " 'GATGCGGCTGCCTATCATGA': 0,\n", + " 'GATGCGGCTGTCTATCATGA': 0,\n", + " 'GATGCTGCTGACTATCATGA': 0,\n", + " 'GATGCTGCTGCCTATCATGA': 0,\n", + " 'GATGCTGCTGTCTATCATGA': 0,\n", + " 'GATGCCGCTGGATATCATGA': 0,\n", + " 'GATGCCGCTGGGTATCATGA': 0,\n", + " 'GATGCCGCTGGTTATCATGA': 0,\n", + " 'GATGCGGCTGGATATCATGA': 0,\n", + " 'GATGCGGCTGGGTATCATGA': 0,\n", + " 'GATGCGGCTGGTTATCATGA': 0,\n", + " 'GATGCTGCTGGATATCATGA': 0,\n", + " 'GATGCTGCTGGGTATCATGA': 0,\n", + " 'GATGCTGCTGGTTATCATGA': 0,\n", + " 'GATGCCGCTGGCAATCATGA': 0,\n", + " 'GATGCCGCTGGCCATCATGA': 0,\n", + " 'GATGCCGCTGGCGATCATGA': 0,\n", + " 'GATGCGGCTGGCAATCATGA': 0,\n", + " 'GATGCGGCTGGCCATCATGA': 0,\n", + " 'GATGCGGCTGGCGATCATGA': 0,\n", + " 'GATGCTGCTGGCAATCATGA': 0,\n", + " 'GATGCTGCTGGCCATCATGA': 0,\n", + " 'GATGCTGCTGGCGATCATGA': 0,\n", + " 'GATGCCGCTGGCTCTCATGA': 0,\n", + " 'GATGCCGCTGGCTGTCATGA': 0,\n", + " 'GATGCCGCTGGCTTTCATGA': 0,\n", + " 'GATGCGGCTGGCTCTCATGA': 0,\n", + " 'GATGCGGCTGGCTGTCATGA': 0,\n", + " 'GATGCGGCTGGCTTTCATGA': 0,\n", + " 'GATGCTGCTGGCTCTCATGA': 0,\n", + " 'GATGCTGCTGGCTGTCATGA': 0,\n", + " 'GATGCTGCTGGCTTTCATGA': 0,\n", + " 'GATGCCGCTGGCTAACATGA': 0,\n", + " 'GATGCCGCTGGCTACCATGA': 0,\n", + " 'GATGCCGCTGGCTAGCATGA': 0,\n", + " 'GATGCGGCTGGCTAACATGA': 0,\n", + " 'GATGCGGCTGGCTACCATGA': 0,\n", + " 'GATGCGGCTGGCTAGCATGA': 0,\n", + " 'GATGCTGCTGGCTAACATGA': 0,\n", + " 'GATGCTGCTGGCTACCATGA': 0,\n", + " 'GATGCTGCTGGCTAGCATGA': 0,\n", + " 'GATGCCGCTGGCTATAATGA': 0,\n", + " 'GATGCCGCTGGCTATGATGA': 0,\n", + " 'GATGCCGCTGGCTATTATGA': 0,\n", + " 'GATGCGGCTGGCTATAATGA': 0,\n", + " 'GATGCGGCTGGCTATGATGA': 0,\n", + " 'GATGCGGCTGGCTATTATGA': 0,\n", + " 'GATGCTGCTGGCTATAATGA': 0,\n", + " 'GATGCTGCTGGCTATGATGA': 0,\n", + " 'GATGCTGCTGGCTATTATGA': 0,\n", + " 'GATGCCGCTGGCTATCCTGA': 0,\n", + " 'GATGCCGCTGGCTATCGTGA': 0,\n", + " 'GATGCCGCTGGCTATCTTGA': 0,\n", + " 'GATGCGGCTGGCTATCCTGA': 0,\n", + " 'GATGCGGCTGGCTATCGTGA': 0,\n", + " 'GATGCGGCTGGCTATCTTGA': 0,\n", + " 'GATGCTGCTGGCTATCCTGA': 0,\n", + " 'GATGCTGCTGGCTATCGTGA': 0,\n", + " ...}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "barcode_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing read 0...\n", + "Processing read 10000...\n", + "Processing read 20000...\n", + "Processing read 30000...\n", + "Processing read 40000...\n", + "Processing read 50000...\n", + "Processing read 60000...\n", + "Processing read 70000...\n", + "Processing read 80000...\n", + "Processing read 90000...\n", + "Processing read 100000...\n", + "Processing read 110000...\n", + "Processing read 120000...\n", + "Processing read 130000...\n", + "Processing read 140000...\n", + "Processing read 150000...\n", + "Processing read 160000...\n", + "Processing read 170000...\n", + "Processing read 180000...\n", + "Processing read 190000...\n", + "Processing read 200000...\n", + "Processing read 210000...\n", + "Processing read 220000...\n", + "Processing read 230000...\n", + "Done!\n", + "Total # of unique-UMI reads = 164844\n" + ] + } + ], + "source": [ + "#Parse and map RNA sequencing reads\n", + "\n", + "save_suffix = \"_var_repl_2_hmc3_v3\"\n", + "\n", + "r1_name = \"unprocessed_data/HMC3_Var_R2_trimmed.fastq\"\n", + "r2_name = \"unprocessed_data/HMC3_Var_R2_UMI_trimmed.fastq\"\n", + "\n", + "polya_regexp = re.compile(r\"AAAAA(AAAAAAAAAAAAAAA){s<=2}\")\n", + "distal_regexp = re.compile(r\"(GCCTCGACTGTGCCTTCTAG){s<=2}\")\n", + "\n", + "def _hamming(s1, s2) :\n", + " \n", + " d = 0.\n", + " for j in range(len(s1)) :\n", + " if s1[j] != s2[j] :\n", + " d += 1.\n", + " \n", + " return d\n", + "\n", + "max_pos = 176\n", + "\n", + "umi_dict = {}\n", + "umi_n_muts = 0\n", + "\n", + "bases = ['A', 'C', 'G', 'T']\n", + "\n", + "cuts = np.zeros((len(library_df), 206))\n", + "\n", + "f1 = open(r1_name, 'rt')\n", + "f2 = open(r2_name, 'rt')\n", + "\n", + "#Iterate through reads sequenctially (r1 and r2)\n", + "\n", + "r1_counter = 0\n", + "while True :\n", + " \n", + " #Read 1\n", + " id1 = f1.readline().strip()\n", + " \n", + " #Check for end-of-file\n", + " if len(id1) == 0 :\n", + " break\n", + " \n", + " r1 = f1.readline().strip()\n", + " s1 = f1.readline().strip()\n", + " q1 = f1.readline().strip()\n", + " \n", + " #Read 2\n", + " id2 = f2.readline().strip()\n", + " r2 = f2.readline().strip()\n", + " s2 = f2.readline().strip()\n", + " q2 = f2.readline().strip()\n", + " \n", + " if r1_counter % 10000 == 0 :\n", + " print(\"Processing read \" + str(r1_counter) + \"...\")\n", + " \n", + " r1_counter += 1\n", + " \n", + " #Map read to library member\n", + " bc = r1[:20]\n", + " \n", + " lib_i = -1\n", + " if bc in barcode_dict :\n", + " lib_i = barcode_dict[bc]\n", + " \n", + " if lib_i == -1 :\n", + " continue\n", + " \n", + " if umi_n_muts == 0 :\n", + " bc = sequences[lib_i][:20]\n", + " \n", + " #Determine if we have seen this umi before, otherwise mark as visited\n", + " umi = r2[:8]\n", + " \n", + " if bc not in umi_dict :\n", + " umi_dict[bc] = {}\n", + " \n", + " umi_visited = False\n", + " if umi in umi_dict[bc] :\n", + " umi_visited = True\n", + " elif umi_n_muts == 1 :\n", + " for pos1 in range(len(umi)) :\n", + " for b1 in bases :\n", + " umi_mut = umi[:pos1] + b1 + umi[pos1+1:]\n", + " if umi_mut in umi_dict[bc] :\n", + " umi_visited = True\n", + " break\n", + " if umi_visited :\n", + " break\n", + " elif umi_n_muts == 2 :\n", + " for pos1 in range(len(umi)) :\n", + " for pos2 in range(pos1, len(umi)) :\n", + " for b1 in bases :\n", + " for b2 in bases :\n", + " umi_mut = umi[:pos1] + b1 + umi[pos1+1:pos2] + b2 + umi[pos2+1:]\n", + " if umi_mut in umi_dict[bc] :\n", + " umi_visited = True\n", + " break\n", + " if umi_visited :\n", + " break\n", + " if umi_visited :\n", + " break\n", + " if umi_visited :\n", + " break\n", + " \n", + " #Skip if umi already seen\n", + " if umi_visited :\n", + " continue\n", + " \n", + " #Determine polyA position (or alternative if the read is distally polyadenylated)\n", + " polya_match = re.search(polya_regexp, r1)\n", + " \n", + " polya_pos = -1\n", + " if polya_match is not None and polya_match.span()[0] < max_pos :\n", + " polya_pos = polya_match.span()[0]\n", + " \n", + " #Determine if distal read\n", + " is_distal = False\n", + " distal_match = re.search(distal_regexp, r1[209-5:209+20+5])\n", + " \n", + " if distal_match is not None :\n", + " is_distal = True\n", + " \n", + " #Aggregate read-position occurrence counts\n", + " if is_distal :\n", + " cuts[lib_i, -1] += 1.\n", + " \n", + " #Mark as seen and proceed\n", + " umi_dict[bc][umi] = True\n", + " \n", + " elif polya_pos != -1 and polya_pos >= 30 :\n", + " \n", + " #Perform hamming-based consistency check against reference of region upstream of cleavage\n", + " \n", + " hamming_dist = _hamming(sequences[lib_i][polya_pos-20:polya_pos], r1[polya_pos-20:polya_pos])\n", + " \n", + " if hamming_dist <= 3 :\n", + " cuts[lib_i, polya_pos] += 1.\n", + "\n", + " #Mark as seen and proceed\n", + " umi_dict[bc][umi] = True\n", + "\n", + "f1.close()\n", + "f2.close()\n", + "\n", + "print(\"Done!\")\n", + "\n", + "print(\"Total # of unique-UMI reads = \" + str(int(np.sum(cuts))))\n", + "\n", + "#Store processed read-position count matrix\n", + "np.save('apa_oligo_2022' + save_suffix + '_umi_mut_' + str(umi_n_muts) + '_cuts', cuts)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#Load processed read count data\n", + "\n", + "ref_cuts_repl_1 = np.zeros(np.load(\"apa_oligo_2022_ref_repl_1_hmc3_v3_umi_mut_0_cuts.npy\").shape)\n", + "var_cuts_repl_1 = np.load(\"apa_oligo_2022_var_repl_1_hmc3_v3_umi_mut_0_cuts.npy\")\n", + "\n", + "ref_cuts_repl_2 = np.load(\"apa_oligo_2022_ref_repl_2_hmc3_v3_umi_mut_0_cuts.npy\")\n", + "var_cuts_repl_2 = np.load(\"apa_oligo_2022_var_repl_2_hmc3_v3_umi_mut_0_cuts.npy\")\n", + "\n", + "#Pooled counts\n", + "\n", + "ref_cuts_pooled = ref_cuts_repl_1 + ref_cuts_repl_2\n", + "var_cuts_pooled = var_cuts_repl_1 + var_cuts_repl_2\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#Augment library file with measured isoform summary statistics\n", + "\n", + "pseudo_c = 1.\n", + "\n", + "#Replicate 1\n", + "library_df['ref_count_77_127_repl_1'] = np.sum(ref_cuts_repl_1[:, 77:127], axis=-1)\n", + "library_df['ref_count_0_205_repl_1'] = np.sum(ref_cuts_repl_1[:, 0:205], axis=-1)\n", + "library_df['ref_count_total_repl_1'] = np.sum(ref_cuts_repl_1, axis=-1)\n", + "library_df['ref_logit_77_127_repl_1'] = np.log(\n", + " ((library_df['ref_count_77_127_repl_1'] + pseudo_c) / (library_df['ref_count_total_repl_1'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_77_127_repl_1'] + pseudo_c) / (library_df['ref_count_total_repl_1'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['ref_logit_0_205_repl_1'] = np.log(\n", + " ((library_df['ref_count_0_205_repl_1'] + pseudo_c) / (library_df['ref_count_total_repl_1'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_0_205_repl_1'] + pseudo_c) / (library_df['ref_count_total_repl_1'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['var_count_77_127_repl_1'] = np.sum(var_cuts_repl_1[:, 77:127], axis=-1)\n", + "library_df['var_count_0_205_repl_1'] = np.sum(var_cuts_repl_1[:, 0:205], axis=-1)\n", + "library_df['var_count_total_repl_1'] = np.sum(var_cuts_repl_1, axis=-1)\n", + "library_df['var_logit_77_127_repl_1'] = np.log(\n", + " ((library_df['var_count_77_127_repl_1'] + pseudo_c) / (library_df['var_count_total_repl_1'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_77_127_repl_1'] + pseudo_c) / (library_df['var_count_total_repl_1'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['var_logit_0_205_repl_1'] = np.log(\n", + " ((library_df['var_count_0_205_repl_1'] + pseudo_c) / (library_df['var_count_total_repl_1'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_0_205_repl_1'] + pseudo_c) / (library_df['var_count_total_repl_1'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['delta_logodds_true_77_127_repl_1'] = library_df['var_logit_77_127_repl_1'] - library_df['ref_logit_77_127_repl_1']\n", + "library_df['delta_logodds_true_0_205_repl_1'] = library_df['var_logit_0_205_repl_1'] - library_df['ref_logit_0_205_repl_1']\n", + "\n", + "#Replicate 2\n", + "library_df['ref_count_77_127_repl_2'] = np.sum(ref_cuts_repl_2[:, 77:127], axis=-1)\n", + "library_df['ref_count_0_205_repl_2'] = np.sum(ref_cuts_repl_2[:, 0:205], axis=-1)\n", + "library_df['ref_count_total_repl_2'] = np.sum(ref_cuts_repl_2, axis=-1)\n", + "library_df['ref_logit_77_127_repl_2'] = np.log(\n", + " ((library_df['ref_count_77_127_repl_2'] + pseudo_c) / (library_df['ref_count_total_repl_2'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_77_127_repl_2'] + pseudo_c) / (library_df['ref_count_total_repl_2'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['ref_logit_0_205_repl_2'] = np.log(\n", + " ((library_df['ref_count_0_205_repl_2'] + pseudo_c) / (library_df['ref_count_total_repl_2'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_0_205_repl_2'] + pseudo_c) / (library_df['ref_count_total_repl_2'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['var_count_77_127_repl_2'] = np.sum(var_cuts_repl_2[:, 77:127], axis=-1)\n", + "library_df['var_count_0_205_repl_2'] = np.sum(var_cuts_repl_2[:, 0:205], axis=-1)\n", + "library_df['var_count_total_repl_2'] = np.sum(var_cuts_repl_2, axis=-1)\n", + "library_df['var_logit_77_127_repl_2'] = np.log(\n", + " ((library_df['var_count_77_127_repl_2'] + pseudo_c) / (library_df['var_count_total_repl_2'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_77_127_repl_2'] + pseudo_c) / (library_df['var_count_total_repl_2'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['var_logit_0_205_repl_2'] = np.log(\n", + " ((library_df['var_count_0_205_repl_2'] + pseudo_c) / (library_df['var_count_total_repl_2'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_0_205_repl_2'] + pseudo_c) / (library_df['var_count_total_repl_2'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['delta_logodds_true_77_127_repl_2'] = library_df['var_logit_77_127_repl_2'] - library_df['ref_logit_77_127_repl_2']\n", + "library_df['delta_logodds_true_0_205_repl_2'] = library_df['var_logit_0_205_repl_2'] - library_df['ref_logit_0_205_repl_2']\n", + "\n", + "#Pooled replicates\n", + "library_df['ref_count_77_127_repl_pooled'] = np.sum(ref_cuts_pooled[:, 77:127], axis=-1)\n", + "library_df['ref_count_0_205_repl_pooled'] = np.sum(ref_cuts_pooled[:, 0:205], axis=-1)\n", + "library_df['ref_count_total_repl_pooled'] = np.sum(ref_cuts_pooled, axis=-1)\n", + "library_df['ref_logit_77_127_repl_pooled'] = np.log(\n", + " ((library_df['ref_count_77_127_repl_pooled'] + pseudo_c) / (library_df['ref_count_total_repl_pooled'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_77_127_repl_pooled'] + pseudo_c) / (library_df['ref_count_total_repl_pooled'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['ref_logit_0_205_repl_pooled'] = np.log(\n", + " ((library_df['ref_count_0_205_repl_pooled'] + pseudo_c) / (library_df['ref_count_total_repl_pooled'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_0_205_repl_pooled'] + pseudo_c) / (library_df['ref_count_total_repl_pooled'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['var_count_77_127_repl_pooled'] = np.sum(var_cuts_pooled[:, 77:127], axis=-1)\n", + "library_df['var_count_0_205_repl_pooled'] = np.sum(var_cuts_pooled[:, 0:205], axis=-1)\n", + "library_df['var_count_total_repl_pooled'] = np.sum(var_cuts_pooled, axis=-1)\n", + "library_df['var_logit_77_127_repl_pooled'] = np.log(\n", + " ((library_df['var_count_77_127_repl_pooled'] + pseudo_c) / (library_df['var_count_total_repl_pooled'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_77_127_repl_pooled'] + pseudo_c) / (library_df['var_count_total_repl_pooled'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['var_logit_0_205_repl_pooled'] = np.log(\n", + " ((library_df['var_count_0_205_repl_pooled'] + pseudo_c) / (library_df['var_count_total_repl_pooled'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_0_205_repl_pooled'] + pseudo_c) / (library_df['var_count_total_repl_pooled'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['delta_logodds_true_77_127_repl_pooled'] = library_df['var_logit_77_127_repl_pooled'] - library_df['ref_logit_77_127_repl_pooled']\n", + "library_df['delta_logodds_true_0_205_repl_pooled'] = library_df['var_logit_0_205_repl_pooled'] - library_df['ref_logit_0_205_repl_pooled']\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#Cache measurements in dataframe\n", + "\n", + "library_df.to_csv(\"apa_100_variants_rev2_20220621_hmc3_v3_umi_mut_0.csv\", sep='\\t')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jlinder2/anaconda3/envs/tensorflow/lib/python3.6/site-packages/ipykernel/__main__.py:3: RuntimeWarning: invalid value encountered in true_divide\n", + " app.launch_new_instance()\n", + "/home/jlinder2/anaconda3/envs/tensorflow/lib/python3.6/site-packages/ipykernel/__main__.py:7: RuntimeWarning: invalid value encountered in true_divide\n" + ] + } + ], + "source": [ + "#Compute cleavage probabilities\n", + "\n", + "ref_cut_prob_repl_1 = ref_cuts_repl_1 / np.sum(ref_cuts_repl_1, axis=1)[:, None]\n", + "var_cut_prob_repl_1 = var_cuts_repl_1 / np.sum(var_cuts_repl_1, axis=1)[:, None]\n", + "\n", + "ref_cut_prob_repl_2 = ref_cuts_repl_2 / np.sum(ref_cuts_repl_2, axis=1)[:, None]\n", + "var_cut_prob_repl_2 = var_cuts_repl_2 / np.sum(var_cuts_repl_2, axis=1)[:, None]\n", + "\n", + "ref_cut_prob_pooled = ref_cuts_pooled / np.sum(ref_cuts_pooled, axis=1)[:, None]\n", + "var_cut_prob_pooled = var_cuts_pooled / np.sum(var_cuts_pooled, axis=1)[:, None]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "delta_logodds (repl 1) = nan\n", + "delta_logodds (repl 2) = 0.851\n", + "delta_logodds (pooled) = 0.7094\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Control: F2 variant (creation of new cutsite -1bp relative to reference)\n", + "\n", + "save_figs = True\n", + "fig_name = \"F2_control_profile_hmc3\"\n", + "\n", + "test_ix = 9\n", + "\n", + "#Plot range\n", + "plot_start = 0\n", + "plot_end = 146\n", + "\n", + "#Isoform definition\n", + "cut_start = 77\n", + "cut_end = 127\n", + "\n", + "c_ref_1 = ref_cut_prob_repl_1[test_ix, :]\n", + "c_var_1 = var_cut_prob_repl_1[test_ix, :]\n", + "\n", + "c_ref_2 = ref_cut_prob_repl_2[test_ix, :]\n", + "c_var_2 = var_cut_prob_repl_2[test_ix, :]\n", + "\n", + "c_ref_pooled = ref_cut_prob_pooled[test_ix, :]\n", + "c_var_pooled = var_cut_prob_pooled[test_ix, :]\n", + "\n", + "delta_logodds_1 = np.log(np.sum(c_var_1[77:127]) / (1. - np.sum(c_var_1[77:127]))) - np.log(np.sum(c_ref_1[77:127]) / (1. - np.sum(c_ref_1[77:127])))\n", + "delta_logodds_2 = np.log(np.sum(c_var_2[77:127]) / (1. - np.sum(c_var_2[77:127]))) - np.log(np.sum(c_ref_2[77:127]) / (1. - np.sum(c_ref_2[77:127])))\n", + "delta_logodds_pooled = np.log(np.sum(c_var_pooled[77:127]) / (1. - np.sum(c_var_pooled[77:127]))) - np.log(np.sum(c_ref_pooled[77:127]) / (1. - np.sum(c_ref_pooled[77:127])))\n", + "\n", + "print(\"delta_logodds (repl 1) = \" + str(round(delta_logodds_1, 4)))\n", + "print(\"delta_logodds (repl 2) = \" + str(round(delta_logodds_2, 4)))\n", + "print(\"delta_logodds (pooled) = \" + str(round(delta_logodds_pooled, 4)))\n", + "\n", + "#Plot replicate 1 profile\n", + "f = plt.figure(figsize=(10, 3))\n", + "\n", + "plt.plot(c_ref_1[plot_start: plot_end], color='darkblue', linewidth=3)\n", + "plt.plot(c_var_1[plot_start: plot_end], color='darkorange', linewidth=3)\n", + "\n", + "plt.axvline(x=70, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "plt.axvline(x=76, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "\n", + "plt.xlim(plot_start, plot_end)\n", + "plt.ylim(0.)\n", + "\n", + "plt.title(\"Replicate 1. Delta Isoform Log Odds = \" + str(round(delta_logodds_1, 4)))\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_repl_1.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_repl_1.eps\")\n", + "\n", + "plt.show()\n", + "\n", + "#Plot replicate 2 profile\n", + "f = plt.figure(figsize=(10, 3))\n", + "\n", + "plt.plot(c_ref_2[plot_start: plot_end], color='darkblue', linewidth=3)\n", + "plt.plot(c_var_2[plot_start: plot_end], color='darkorange', linewidth=3)\n", + "\n", + "plt.axvline(x=70, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "plt.axvline(x=76, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "\n", + "plt.xlim(plot_start, plot_end)\n", + "plt.ylim(0.)\n", + "\n", + "plt.title(\"Replicate 2. Delta Isoform Log Odds = \" + str(round(delta_logodds_2, 4)))\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_repl_2.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_repl_2.eps\")\n", + "\n", + "plt.show()\n", + "\n", + "#Plot pooled replicate profile\n", + "f = plt.figure(figsize=(10, 3))\n", + "\n", + "plt.plot(c_ref_pooled[plot_start: plot_end], color='darkblue', linewidth=3)\n", + "plt.plot(c_var_pooled[plot_start: plot_end], color='darkorange', linewidth=3)\n", + "\n", + "plt.axvline(x=70, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "plt.axvline(x=76, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "\n", + "plt.xlim(plot_start, plot_end)\n", + "plt.ylim(0.)\n", + "\n", + "plt.title(\"Pooled replicates. Delta Isoform Log Odds = \" + str(round(delta_logodds_pooled, 4)))\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_pooled.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_pooled.eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(filtered_df) = 93\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jlinder2/anaconda3/envs/tensorflow/lib/python3.6/site-packages/numpy/lib/function_base.py:2530: RuntimeWarning: invalid value encountered in true_divide\n", + " c /= stddev[:, None]\n", + "/home/jlinder2/anaconda3/envs/tensorflow/lib/python3.6/site-packages/numpy/lib/function_base.py:2531: RuntimeWarning: invalid value encountered in true_divide\n", + " c /= stddev[None, :]\n", + "/home/jlinder2/anaconda3/envs/tensorflow/lib/python3.6/site-packages/scipy/stats/_distn_infrastructure.py:901: RuntimeWarning: invalid value encountered in greater\n", + " return (a < x) & (x < b)\n", + "/home/jlinder2/anaconda3/envs/tensorflow/lib/python3.6/site-packages/scipy/stats/_distn_infrastructure.py:901: RuntimeWarning: invalid value encountered in less\n", + " return (a < x) & (x < b)\n", + "/home/jlinder2/anaconda3/envs/tensorflow/lib/python3.6/site-packages/scipy/stats/_distn_infrastructure.py:1892: RuntimeWarning: invalid value encountered in less_equal\n", + " cond2 = cond0 & (x <= _a)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from scipy.stats import spearmanr\n", + "\n", + "save_figs = True\n", + "fig_name = \"replicate_hmc3\"\n", + "\n", + "min_c = 5.\n", + "\n", + "x_min = -6.\n", + "x_max = 4.\n", + "\n", + "filtered_df = library_df.query(\"ref_count_total_repl_1 >= 0 and \" + \"ref_count_total_repl_2 >= \" + str(min_c) + \" and \" + \"var_count_total_repl_1 >= \" + str(min_c) + \" and \" + \"var_count_total_repl_2 >= \" + str(min_c))\n", + "\n", + "print(\"len(filtered_df) = \" + str(len(filtered_df)))\n", + "\n", + "#Reference library (replicate correlation)\n", + "r_val_ref, _ = spearmanr(filtered_df['ref_logit_77_127_repl_1'], filtered_df['ref_logit_77_127_repl_2'])\n", + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "plt.scatter(filtered_df['ref_logit_77_127_repl_1'], filtered_df['ref_logit_77_127_repl_2'], color='lightgreen', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "plt.xlim(x_min, x_max)\n", + "plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Ref Logit (Repl. 1)\", fontsize=12)\n", + "plt.ylabel(\"Ref Logit (Repl. 2)\", fontsize=12)\n", + "\n", + "plt.title(\"r = \" + str(round(r_val_ref, 3)) + \", n = \" + str(len(filtered_df)), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_ref_logits.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_ref_logits.eps\")\n", + "\n", + "plt.show()\n", + "\n", + "#Variant library (replicate correlation)\n", + "r_val_var, _ = spearmanr(filtered_df['var_logit_77_127_repl_1'], filtered_df['var_logit_77_127_repl_2'])\n", + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "plt.scatter(filtered_df['var_logit_77_127_repl_1'], filtered_df['var_logit_77_127_repl_2'], color='lightcoral', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "plt.xlim(x_min, x_max)\n", + "plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Var Logit (Repl. 1)\", fontsize=12)\n", + "plt.ylabel(\"Var Logit (Repl. 2)\", fontsize=12)\n", + "\n", + "plt.title(\"r = \" + str(round(r_val_var, 3)) + \", n = \" + str(len(filtered_df)), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_var_logits.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_var_logits.eps\")\n", + "\n", + "plt.show()\n", + "\n", + "#Ref-Var library (delta replicate correlation)\n", + "r_val_var, _ = spearmanr(filtered_df['delta_logodds_true_77_127_repl_1'], filtered_df['delta_logodds_true_77_127_repl_2'])\n", + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "plt.scatter(filtered_df['delta_logodds_true_77_127_repl_1'], filtered_df['delta_logodds_true_77_127_repl_2'], color='lightcoral', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "plt.xlim(x_min, x_max)\n", + "plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"LOR (Repl. 1)\", fontsize=12)\n", + "plt.ylabel(\"LOR (Repl. 2)\", fontsize=12)\n", + "\n", + "plt.title(\"r = \" + str(round(r_val_var, 3)) + \", n = \" + str(len(filtered_df)), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_delta_logodds.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_delta_logodds.eps\")\n", + "\n", + "plt.show()\n", + "\n", + "#Ref-Var control correlation\n", + "control_df = filtered_df.loc[filtered_df['experiment'].str.contains(\"control_\") & filtered_df['data_source'].str.contains(\"Array_2019\")]\n", + "\n", + "r_val_control, _ = spearmanr(control_df['ref_logit_77_127_repl_pooled'], control_df['var_logit_77_127_repl_pooled'])\n", + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "plt.scatter(control_df['ref_logit_77_127_repl_pooled'], control_df['var_logit_77_127_repl_pooled'], color='black', s=175, marker='^')\n", + "\n", + "plt.plot([x_min, x_max], [x_min, x_max], color='darkgreen', linestyle='--', linewidth=2,)\n", + "\n", + "plt.xlim(x_min, x_max)\n", + "plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Ref Logit\", fontsize=12)\n", + "plt.ylabel(\"Var Logit\", fontsize=12)\n", + "\n", + "plt.title(\"Controls; Spearman r = \" + str(round(r_val_control, 3)) + \", n = \" + str(len(control_df)), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_control_logits.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_control_logits.eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n (sequences) = 186066\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Compare controls from 2022 oligo array to the Cell paper 2019 array\n", + "\n", + "#Load oligo array from 2019\n", + "import isolearn.io as isoio\n", + "\n", + "save_figs = True\n", + "fig_name = \"replicate_hmc3_to_2019\"\n", + "\n", + "isoform_pseudo_count = 1.\n", + "proximal_start = 77\n", + "proximal_end = 127\n", + "\n", + "file_prefix = str(proximal_start) + \"_\" + str(proximal_end)\n", + "\n", + "seq_dict = isoio.load('../../../../aparent/data/prepared_data/apa_array_data/apa_array_data_seq')\n", + "\n", + "seq_df = seq_dict['array_df']\n", + "seq_cuts = seq_dict['pooled_cuts']\n", + "\n", + "cut_true = np.concatenate([np.array(seq_cuts[:, 180: 180 + 205].todense()), np.array(seq_cuts[:, -1].todense()).reshape(-1, 1)], axis=-1)# - 1\n", + "\n", + "seq_df['proximal_count'] = [np.sum(cut_true[i, proximal_start:proximal_end]) for i in range(len(seq_df))]\n", + "seq_df['total_count'] = [np.sum(cut_true[i, :]) for i in range(len(seq_df))]\n", + "\n", + "seq_df['iso_true'] = (seq_df['proximal_count'] + isoform_pseudo_count) / (seq_df['total_count'] + 2. * isoform_pseudo_count)\n", + "seq_df['logodds_true'] = np.log(seq_df['iso_true'] / (1.0 - seq_df['iso_true']))\n", + "\n", + "seq_df['seq'] = seq_df['seq'].str.slice(0, 205)\n", + "\n", + "print(\"n (sequences) = \" + str(len(seq_df)))\n", + "\n", + "#Ref-Array 2019 control correlation\n", + "control_df_2019 = control_df.join(seq_df[['seq', 'logodds_true']].set_index(\"seq\"), on='ref_seq', how='inner').copy().reset_index(drop=True)\n", + "\n", + "r_val_control, _ = spearmanr(control_df_2019['ref_logit_77_127_repl_pooled'], control_df_2019['logodds_true'])\n", + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "plt.scatter(control_df_2019['ref_logit_77_127_repl_pooled'], control_df_2019['logodds_true'], color='deepskyblue', edgecolor='black', linewidth=1, s=175, marker='^')\n", + "\n", + "plt.plot([x_min, x_max], [x_min, x_max], color='darkgreen', linestyle='--', linewidth=2,)\n", + "\n", + "plt.xlim(x_min, x_max)\n", + "plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Logit (2022)\", fontsize=12)\n", + "plt.ylabel(\"Logit (2019)\", fontsize=12)\n", + "\n", + "plt.title(\"Controls; Spearman r = \" + str(round(r_val_control, 3)) + \", n = \" + str(len(control_df_2019)), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:tensorflow]", + "language": "python", + "name": "conda-env-tensorflow-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 +} diff --git a/data/oligo_pool_2022/medium_library/process_reads_sknsh.ipynb b/data/oligo_pool_2022/medium_library/process_reads_sknsh.ipynb new file mode 100644 index 0000000..572a423 --- /dev/null +++ b/data/oligo_pool_2022/medium_library/process_reads_sknsh.ipynb @@ -0,0 +1,1865 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import scipy\n", + "import scipy.io as spio\n", + "import scipy.sparse as sp\n", + "\n", + "import regex as re\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(barcode_dict) = 201500\n" + ] + } + ], + "source": [ + "#Load reference library dataframe and build barcode dictionary\n", + "\n", + "library_df = pd.read_csv(\"apa_100_variants_rev2_20220621_pred.csv\", sep='\\t')\n", + "\n", + "#Build dictionary (double-mutation support)\n", + "bases = ['A', 'C', 'G', 'T']\n", + "\n", + "barcode_dict = {}\n", + "sequences = []\n", + "for i, [_, row] in enumerate(library_df.iterrows()) :\n", + " bc = row['ref_barcode']\n", + " \n", + " sequences.append(row['ref_seq'])\n", + " \n", + " barcode_dict[bc] = i\n", + " for pos1 in range(len(bc)) :\n", + " for pos2 in range(pos1, len(bc)) :\n", + " for b1 in bases :\n", + " for b2 in bases :\n", + " bc_mut = bc[:pos1] + b1 + bc[pos1+1:pos2] + b2 + bc[pos2+1:]\n", + " \n", + " if bc_mut in barcode_dict and barcode_dict[bc_mut] != i :\n", + " print(\"[ERROR] Barcode dictionary collision.\")\n", + " else :\n", + " barcode_dict[bc_mut] = i\n", + "\n", + "print(\"len(barcode_dict) = \" + str(len(barcode_dict)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'GATGCAGCTGGCTATCATGA': 0,\n", + " 'AAATGCAGCTGGCTATCATGA': 0,\n", + " 'ACATGCAGCTGGCTATCATGA': 0,\n", + " 'AGATGCAGCTGGCTATCATGA': 0,\n", + " 'ATATGCAGCTGGCTATCATGA': 0,\n", + " 'CAATGCAGCTGGCTATCATGA': 0,\n", + " 'CCATGCAGCTGGCTATCATGA': 0,\n", + " 'CGATGCAGCTGGCTATCATGA': 0,\n", + " 'CTATGCAGCTGGCTATCATGA': 0,\n", + " 'GAATGCAGCTGGCTATCATGA': 0,\n", + " 'GCATGCAGCTGGCTATCATGA': 0,\n", + " 'GGATGCAGCTGGCTATCATGA': 0,\n", + " 'GTATGCAGCTGGCTATCATGA': 0,\n", + " 'TAATGCAGCTGGCTATCATGA': 0,\n", + " 'TCATGCAGCTGGCTATCATGA': 0,\n", + " 'TGATGCAGCTGGCTATCATGA': 0,\n", + " 'TTATGCAGCTGGCTATCATGA': 0,\n", + " 'AATGCAGCTGGCTATCATGA': 0,\n", + " 'ACTGCAGCTGGCTATCATGA': 0,\n", + " 'AGTGCAGCTGGCTATCATGA': 0,\n", + " 'ATTGCAGCTGGCTATCATGA': 0,\n", + " 'CATGCAGCTGGCTATCATGA': 0,\n", + " 'CCTGCAGCTGGCTATCATGA': 0,\n", + " 'CGTGCAGCTGGCTATCATGA': 0,\n", + " 'CTTGCAGCTGGCTATCATGA': 0,\n", + " 'GCTGCAGCTGGCTATCATGA': 0,\n", + " 'GGTGCAGCTGGCTATCATGA': 0,\n", + " 'GTTGCAGCTGGCTATCATGA': 0,\n", + " 'TATGCAGCTGGCTATCATGA': 0,\n", + " 'TCTGCAGCTGGCTATCATGA': 0,\n", + " 'TGTGCAGCTGGCTATCATGA': 0,\n", + " 'TTTGCAGCTGGCTATCATGA': 0,\n", + " 'AAAGCAGCTGGCTATCATGA': 0,\n", + " 'AACGCAGCTGGCTATCATGA': 0,\n", + " 'AAGGCAGCTGGCTATCATGA': 0,\n", + " 'CAAGCAGCTGGCTATCATGA': 0,\n", + " 'CACGCAGCTGGCTATCATGA': 0,\n", + " 'CAGGCAGCTGGCTATCATGA': 0,\n", + " 'GAAGCAGCTGGCTATCATGA': 0,\n", + " 'GACGCAGCTGGCTATCATGA': 0,\n", + " 'GAGGCAGCTGGCTATCATGA': 0,\n", + " 'TAAGCAGCTGGCTATCATGA': 0,\n", + " 'TACGCAGCTGGCTATCATGA': 0,\n", + " 'TAGGCAGCTGGCTATCATGA': 0,\n", + " 'AATACAGCTGGCTATCATGA': 0,\n", + " 'AATCCAGCTGGCTATCATGA': 0,\n", + " 'AATTCAGCTGGCTATCATGA': 0,\n", + " 'CATACAGCTGGCTATCATGA': 0,\n", + " 'CATCCAGCTGGCTATCATGA': 0,\n", + " 'CATTCAGCTGGCTATCATGA': 0,\n", + " 'GATACAGCTGGCTATCATGA': 0,\n", + " 'GATCCAGCTGGCTATCATGA': 0,\n", + " 'GATTCAGCTGGCTATCATGA': 0,\n", + " 'TATACAGCTGGCTATCATGA': 0,\n", + " 'TATCCAGCTGGCTATCATGA': 0,\n", + " 'TATTCAGCTGGCTATCATGA': 0,\n", + " 'AATGAAGCTGGCTATCATGA': 0,\n", + " 'AATGGAGCTGGCTATCATGA': 0,\n", + " 'AATGTAGCTGGCTATCATGA': 0,\n", + " 'CATGAAGCTGGCTATCATGA': 0,\n", + " 'CATGGAGCTGGCTATCATGA': 0,\n", + " 'CATGTAGCTGGCTATCATGA': 0,\n", + " 'GATGAAGCTGGCTATCATGA': 0,\n", + " 'GATGGAGCTGGCTATCATGA': 0,\n", + " 'GATGTAGCTGGCTATCATGA': 0,\n", + " 'TATGAAGCTGGCTATCATGA': 0,\n", + " 'TATGGAGCTGGCTATCATGA': 0,\n", + " 'TATGTAGCTGGCTATCATGA': 0,\n", + " 'AATGCCGCTGGCTATCATGA': 0,\n", + " 'AATGCGGCTGGCTATCATGA': 0,\n", + " 'AATGCTGCTGGCTATCATGA': 0,\n", + " 'CATGCCGCTGGCTATCATGA': 0,\n", + " 'CATGCGGCTGGCTATCATGA': 0,\n", + " 'CATGCTGCTGGCTATCATGA': 0,\n", + " 'GATGCCGCTGGCTATCATGA': 0,\n", + " 'GATGCGGCTGGCTATCATGA': 0,\n", + " 'GATGCTGCTGGCTATCATGA': 0,\n", + " 'TATGCCGCTGGCTATCATGA': 0,\n", + " 'TATGCGGCTGGCTATCATGA': 0,\n", + " 'TATGCTGCTGGCTATCATGA': 0,\n", + " 'AATGCAACTGGCTATCATGA': 0,\n", + " 'AATGCACCTGGCTATCATGA': 0,\n", + " 'AATGCATCTGGCTATCATGA': 0,\n", + " 'CATGCAACTGGCTATCATGA': 0,\n", + " 'CATGCACCTGGCTATCATGA': 0,\n", + " 'CATGCATCTGGCTATCATGA': 0,\n", + " 'GATGCAACTGGCTATCATGA': 0,\n", + " 'GATGCACCTGGCTATCATGA': 0,\n", + " 'GATGCATCTGGCTATCATGA': 0,\n", + " 'TATGCAACTGGCTATCATGA': 0,\n", + " 'TATGCACCTGGCTATCATGA': 0,\n", + " 'TATGCATCTGGCTATCATGA': 0,\n", + " 'AATGCAGATGGCTATCATGA': 0,\n", + " 'AATGCAGGTGGCTATCATGA': 0,\n", + " 'AATGCAGTTGGCTATCATGA': 0,\n", + " 'CATGCAGATGGCTATCATGA': 0,\n", + " 'CATGCAGGTGGCTATCATGA': 0,\n", + " 'CATGCAGTTGGCTATCATGA': 0,\n", + " 'GATGCAGATGGCTATCATGA': 0,\n", + " 'GATGCAGGTGGCTATCATGA': 0,\n", + " 'GATGCAGTTGGCTATCATGA': 0,\n", + " 'TATGCAGATGGCTATCATGA': 0,\n", + " 'TATGCAGGTGGCTATCATGA': 0,\n", + " 'TATGCAGTTGGCTATCATGA': 0,\n", + " 'AATGCAGCAGGCTATCATGA': 0,\n", + " 'AATGCAGCCGGCTATCATGA': 0,\n", + " 'AATGCAGCGGGCTATCATGA': 0,\n", + " 'CATGCAGCAGGCTATCATGA': 0,\n", + " 'CATGCAGCCGGCTATCATGA': 0,\n", + " 'CATGCAGCGGGCTATCATGA': 0,\n", + " 'GATGCAGCAGGCTATCATGA': 0,\n", + " 'GATGCAGCCGGCTATCATGA': 0,\n", + " 'GATGCAGCGGGCTATCATGA': 0,\n", + " 'TATGCAGCAGGCTATCATGA': 0,\n", + " 'TATGCAGCCGGCTATCATGA': 0,\n", + " 'TATGCAGCGGGCTATCATGA': 0,\n", + " 'AATGCAGCTAGCTATCATGA': 0,\n", + " 'AATGCAGCTCGCTATCATGA': 0,\n", + " 'AATGCAGCTTGCTATCATGA': 0,\n", + " 'CATGCAGCTAGCTATCATGA': 0,\n", + " 'CATGCAGCTCGCTATCATGA': 0,\n", + " 'CATGCAGCTTGCTATCATGA': 0,\n", + " 'GATGCAGCTAGCTATCATGA': 0,\n", + " 'GATGCAGCTCGCTATCATGA': 0,\n", + " 'GATGCAGCTTGCTATCATGA': 0,\n", + " 'TATGCAGCTAGCTATCATGA': 0,\n", + " 'TATGCAGCTCGCTATCATGA': 0,\n", + " 'TATGCAGCTTGCTATCATGA': 0,\n", + " 'AATGCAGCTGACTATCATGA': 0,\n", + " 'AATGCAGCTGCCTATCATGA': 0,\n", + " 'AATGCAGCTGTCTATCATGA': 0,\n", + " 'CATGCAGCTGACTATCATGA': 0,\n", + " 'CATGCAGCTGCCTATCATGA': 0,\n", + " 'CATGCAGCTGTCTATCATGA': 0,\n", + " 'GATGCAGCTGACTATCATGA': 0,\n", + " 'GATGCAGCTGCCTATCATGA': 0,\n", + " 'GATGCAGCTGTCTATCATGA': 0,\n", + " 'TATGCAGCTGACTATCATGA': 0,\n", + " 'TATGCAGCTGCCTATCATGA': 0,\n", + " 'TATGCAGCTGTCTATCATGA': 0,\n", + " 'AATGCAGCTGGATATCATGA': 0,\n", + " 'AATGCAGCTGGGTATCATGA': 0,\n", + " 'AATGCAGCTGGTTATCATGA': 0,\n", + " 'CATGCAGCTGGATATCATGA': 0,\n", + " 'CATGCAGCTGGGTATCATGA': 0,\n", + " 'CATGCAGCTGGTTATCATGA': 0,\n", + " 'GATGCAGCTGGATATCATGA': 0,\n", + " 'GATGCAGCTGGGTATCATGA': 0,\n", + " 'GATGCAGCTGGTTATCATGA': 0,\n", + " 'TATGCAGCTGGATATCATGA': 0,\n", + " 'TATGCAGCTGGGTATCATGA': 0,\n", + " 'TATGCAGCTGGTTATCATGA': 0,\n", + " 'AATGCAGCTGGCAATCATGA': 0,\n", + " 'AATGCAGCTGGCCATCATGA': 0,\n", + " 'AATGCAGCTGGCGATCATGA': 0,\n", + " 'CATGCAGCTGGCAATCATGA': 0,\n", + " 'CATGCAGCTGGCCATCATGA': 0,\n", + " 'CATGCAGCTGGCGATCATGA': 0,\n", + " 'GATGCAGCTGGCAATCATGA': 0,\n", + " 'GATGCAGCTGGCCATCATGA': 0,\n", + " 'GATGCAGCTGGCGATCATGA': 0,\n", + " 'TATGCAGCTGGCAATCATGA': 0,\n", + " 'TATGCAGCTGGCCATCATGA': 0,\n", + " 'TATGCAGCTGGCGATCATGA': 0,\n", + " 'AATGCAGCTGGCTCTCATGA': 0,\n", + " 'AATGCAGCTGGCTGTCATGA': 0,\n", + " 'AATGCAGCTGGCTTTCATGA': 0,\n", + " 'CATGCAGCTGGCTCTCATGA': 0,\n", + " 'CATGCAGCTGGCTGTCATGA': 0,\n", + " 'CATGCAGCTGGCTTTCATGA': 0,\n", + " 'GATGCAGCTGGCTCTCATGA': 0,\n", + " 'GATGCAGCTGGCTGTCATGA': 0,\n", + " 'GATGCAGCTGGCTTTCATGA': 0,\n", + " 'TATGCAGCTGGCTCTCATGA': 0,\n", + " 'TATGCAGCTGGCTGTCATGA': 0,\n", + " 'TATGCAGCTGGCTTTCATGA': 0,\n", + " 'AATGCAGCTGGCTAACATGA': 0,\n", + " 'AATGCAGCTGGCTACCATGA': 0,\n", + " 'AATGCAGCTGGCTAGCATGA': 0,\n", + " 'CATGCAGCTGGCTAACATGA': 0,\n", + " 'CATGCAGCTGGCTACCATGA': 0,\n", + " 'CATGCAGCTGGCTAGCATGA': 0,\n", + " 'GATGCAGCTGGCTAACATGA': 0,\n", + " 'GATGCAGCTGGCTACCATGA': 0,\n", + " 'GATGCAGCTGGCTAGCATGA': 0,\n", + " 'TATGCAGCTGGCTAACATGA': 0,\n", + " 'TATGCAGCTGGCTACCATGA': 0,\n", + " 'TATGCAGCTGGCTAGCATGA': 0,\n", + " 'AATGCAGCTGGCTATAATGA': 0,\n", + " 'AATGCAGCTGGCTATGATGA': 0,\n", + " 'AATGCAGCTGGCTATTATGA': 0,\n", + " 'CATGCAGCTGGCTATAATGA': 0,\n", + " 'CATGCAGCTGGCTATGATGA': 0,\n", + " 'CATGCAGCTGGCTATTATGA': 0,\n", + " 'GATGCAGCTGGCTATAATGA': 0,\n", + " 'GATGCAGCTGGCTATGATGA': 0,\n", + " 'GATGCAGCTGGCTATTATGA': 0,\n", + " 'TATGCAGCTGGCTATAATGA': 0,\n", + " 'TATGCAGCTGGCTATGATGA': 0,\n", + " 'TATGCAGCTGGCTATTATGA': 0,\n", + " 'AATGCAGCTGGCTATCCTGA': 0,\n", + " 'AATGCAGCTGGCTATCGTGA': 0,\n", + " 'AATGCAGCTGGCTATCTTGA': 0,\n", + " 'CATGCAGCTGGCTATCCTGA': 0,\n", + " 'CATGCAGCTGGCTATCGTGA': 0,\n", + " 'CATGCAGCTGGCTATCTTGA': 0,\n", + " 'GATGCAGCTGGCTATCCTGA': 0,\n", + " 'GATGCAGCTGGCTATCGTGA': 0,\n", + " 'GATGCAGCTGGCTATCTTGA': 0,\n", + " 'TATGCAGCTGGCTATCCTGA': 0,\n", + " 'TATGCAGCTGGCTATCGTGA': 0,\n", + " 'TATGCAGCTGGCTATCTTGA': 0,\n", + " 'AATGCAGCTGGCTATCAAGA': 0,\n", + " 'AATGCAGCTGGCTATCACGA': 0,\n", + " 'AATGCAGCTGGCTATCAGGA': 0,\n", + " 'CATGCAGCTGGCTATCAAGA': 0,\n", + " 'CATGCAGCTGGCTATCACGA': 0,\n", + " 'CATGCAGCTGGCTATCAGGA': 0,\n", + " 'GATGCAGCTGGCTATCAAGA': 0,\n", + " 'GATGCAGCTGGCTATCACGA': 0,\n", + " 'GATGCAGCTGGCTATCAGGA': 0,\n", + " 'TATGCAGCTGGCTATCAAGA': 0,\n", + " 'TATGCAGCTGGCTATCACGA': 0,\n", + " 'TATGCAGCTGGCTATCAGGA': 0,\n", + " 'AATGCAGCTGGCTATCATAA': 0,\n", + " 'AATGCAGCTGGCTATCATCA': 0,\n", + " 'AATGCAGCTGGCTATCATTA': 0,\n", + " 'CATGCAGCTGGCTATCATAA': 0,\n", + " 'CATGCAGCTGGCTATCATCA': 0,\n", + " 'CATGCAGCTGGCTATCATTA': 0,\n", + " 'GATGCAGCTGGCTATCATAA': 0,\n", + " 'GATGCAGCTGGCTATCATCA': 0,\n", + " 'GATGCAGCTGGCTATCATTA': 0,\n", + " 'TATGCAGCTGGCTATCATAA': 0,\n", + " 'TATGCAGCTGGCTATCATCA': 0,\n", + " 'TATGCAGCTGGCTATCATTA': 0,\n", + " 'AATGCAGCTGGCTATCATGC': 0,\n", + " 'AATGCAGCTGGCTATCATGG': 0,\n", + " 'AATGCAGCTGGCTATCATGT': 0,\n", + " 'CATGCAGCTGGCTATCATGC': 0,\n", + " 'CATGCAGCTGGCTATCATGG': 0,\n", + " 'CATGCAGCTGGCTATCATGT': 0,\n", + " 'GATGCAGCTGGCTATCATGC': 0,\n", + " 'GATGCAGCTGGCTATCATGG': 0,\n", + " 'GATGCAGCTGGCTATCATGT': 0,\n", + " 'TATGCAGCTGGCTATCATGC': 0,\n", + " 'TATGCAGCTGGCTATCATGG': 0,\n", + " 'TATGCAGCTGGCTATCATGT': 0,\n", + " 'GACTGCAGCTGGCTATCATGA': 0,\n", + " 'GAGTGCAGCTGGCTATCATGA': 0,\n", + " 'GATTGCAGCTGGCTATCATGA': 0,\n", + " 'GCCTGCAGCTGGCTATCATGA': 0,\n", + " 'GCGTGCAGCTGGCTATCATGA': 0,\n", + " 'GCTTGCAGCTGGCTATCATGA': 0,\n", + " 'GGCTGCAGCTGGCTATCATGA': 0,\n", + " 'GGGTGCAGCTGGCTATCATGA': 0,\n", + " 'GGTTGCAGCTGGCTATCATGA': 0,\n", + " 'GTCTGCAGCTGGCTATCATGA': 0,\n", + " 'GTGTGCAGCTGGCTATCATGA': 0,\n", + " 'GTTTGCAGCTGGCTATCATGA': 0,\n", + " 'GCAGCAGCTGGCTATCATGA': 0,\n", + " 'GCCGCAGCTGGCTATCATGA': 0,\n", + " 'GCGGCAGCTGGCTATCATGA': 0,\n", + " 'GGAGCAGCTGGCTATCATGA': 0,\n", + " 'GGCGCAGCTGGCTATCATGA': 0,\n", + " 'GGGGCAGCTGGCTATCATGA': 0,\n", + " 'GTAGCAGCTGGCTATCATGA': 0,\n", + " 'GTCGCAGCTGGCTATCATGA': 0,\n", + " 'GTGGCAGCTGGCTATCATGA': 0,\n", + " 'GCTACAGCTGGCTATCATGA': 0,\n", + " 'GCTCCAGCTGGCTATCATGA': 0,\n", + " 'GCTTCAGCTGGCTATCATGA': 0,\n", + " 'GGTACAGCTGGCTATCATGA': 0,\n", + " 'GGTCCAGCTGGCTATCATGA': 0,\n", + " 'GGTTCAGCTGGCTATCATGA': 0,\n", + " 'GTTACAGCTGGCTATCATGA': 0,\n", + " 'GTTCCAGCTGGCTATCATGA': 0,\n", + " 'GTTTCAGCTGGCTATCATGA': 0,\n", + " 'GCTGAAGCTGGCTATCATGA': 0,\n", + " 'GCTGGAGCTGGCTATCATGA': 0,\n", + " 'GCTGTAGCTGGCTATCATGA': 0,\n", + " 'GGTGAAGCTGGCTATCATGA': 0,\n", + " 'GGTGGAGCTGGCTATCATGA': 0,\n", + " 'GGTGTAGCTGGCTATCATGA': 0,\n", + " 'GTTGAAGCTGGCTATCATGA': 0,\n", + " 'GTTGGAGCTGGCTATCATGA': 0,\n", + " 'GTTGTAGCTGGCTATCATGA': 0,\n", + " 'GCTGCCGCTGGCTATCATGA': 0,\n", + " 'GCTGCGGCTGGCTATCATGA': 0,\n", + " 'GCTGCTGCTGGCTATCATGA': 0,\n", + " 'GGTGCCGCTGGCTATCATGA': 0,\n", + " 'GGTGCGGCTGGCTATCATGA': 0,\n", + " 'GGTGCTGCTGGCTATCATGA': 0,\n", + " 'GTTGCCGCTGGCTATCATGA': 0,\n", + " 'GTTGCGGCTGGCTATCATGA': 0,\n", + " 'GTTGCTGCTGGCTATCATGA': 0,\n", + " 'GCTGCAACTGGCTATCATGA': 0,\n", + " 'GCTGCACCTGGCTATCATGA': 0,\n", + " 'GCTGCATCTGGCTATCATGA': 0,\n", + " 'GGTGCAACTGGCTATCATGA': 0,\n", + " 'GGTGCACCTGGCTATCATGA': 0,\n", + " 'GGTGCATCTGGCTATCATGA': 0,\n", + " 'GTTGCAACTGGCTATCATGA': 0,\n", + " 'GTTGCACCTGGCTATCATGA': 0,\n", + " 'GTTGCATCTGGCTATCATGA': 0,\n", + " 'GCTGCAGATGGCTATCATGA': 0,\n", + " 'GCTGCAGGTGGCTATCATGA': 0,\n", + " 'GCTGCAGTTGGCTATCATGA': 0,\n", + " 'GGTGCAGATGGCTATCATGA': 0,\n", + " 'GGTGCAGGTGGCTATCATGA': 0,\n", + " 'GGTGCAGTTGGCTATCATGA': 0,\n", + " 'GTTGCAGATGGCTATCATGA': 0,\n", + " 'GTTGCAGGTGGCTATCATGA': 0,\n", + " 'GTTGCAGTTGGCTATCATGA': 0,\n", + " 'GCTGCAGCAGGCTATCATGA': 0,\n", + " 'GCTGCAGCCGGCTATCATGA': 0,\n", + " 'GCTGCAGCGGGCTATCATGA': 0,\n", + " 'GGTGCAGCAGGCTATCATGA': 0,\n", + " 'GGTGCAGCCGGCTATCATGA': 0,\n", + " 'GGTGCAGCGGGCTATCATGA': 0,\n", + " 'GTTGCAGCAGGCTATCATGA': 0,\n", + " 'GTTGCAGCCGGCTATCATGA': 0,\n", + " 'GTTGCAGCGGGCTATCATGA': 0,\n", + " 'GCTGCAGCTAGCTATCATGA': 0,\n", + " 'GCTGCAGCTCGCTATCATGA': 0,\n", + " 'GCTGCAGCTTGCTATCATGA': 0,\n", + " 'GGTGCAGCTAGCTATCATGA': 0,\n", + " 'GGTGCAGCTCGCTATCATGA': 0,\n", + " 'GGTGCAGCTTGCTATCATGA': 0,\n", + " 'GTTGCAGCTAGCTATCATGA': 0,\n", + " 'GTTGCAGCTCGCTATCATGA': 0,\n", + " 'GTTGCAGCTTGCTATCATGA': 0,\n", + " 'GCTGCAGCTGACTATCATGA': 0,\n", + " 'GCTGCAGCTGCCTATCATGA': 0,\n", + " 'GCTGCAGCTGTCTATCATGA': 0,\n", + " 'GGTGCAGCTGACTATCATGA': 0,\n", + " 'GGTGCAGCTGCCTATCATGA': 0,\n", + " 'GGTGCAGCTGTCTATCATGA': 0,\n", + " 'GTTGCAGCTGACTATCATGA': 0,\n", + " 'GTTGCAGCTGCCTATCATGA': 0,\n", + " 'GTTGCAGCTGTCTATCATGA': 0,\n", + " 'GCTGCAGCTGGATATCATGA': 0,\n", + " 'GCTGCAGCTGGGTATCATGA': 0,\n", + " 'GCTGCAGCTGGTTATCATGA': 0,\n", + " 'GGTGCAGCTGGATATCATGA': 0,\n", + " 'GGTGCAGCTGGGTATCATGA': 0,\n", + " 'GGTGCAGCTGGTTATCATGA': 0,\n", + " 'GTTGCAGCTGGATATCATGA': 0,\n", + " 'GTTGCAGCTGGGTATCATGA': 0,\n", + " 'GTTGCAGCTGGTTATCATGA': 0,\n", + " 'GCTGCAGCTGGCAATCATGA': 0,\n", + " 'GCTGCAGCTGGCCATCATGA': 0,\n", + " 'GCTGCAGCTGGCGATCATGA': 0,\n", + " 'GGTGCAGCTGGCAATCATGA': 0,\n", + " 'GGTGCAGCTGGCCATCATGA': 0,\n", + " 'GGTGCAGCTGGCGATCATGA': 0,\n", + " 'GTTGCAGCTGGCAATCATGA': 0,\n", + " 'GTTGCAGCTGGCCATCATGA': 0,\n", + " 'GTTGCAGCTGGCGATCATGA': 0,\n", + " 'GCTGCAGCTGGCTCTCATGA': 0,\n", + " 'GCTGCAGCTGGCTGTCATGA': 0,\n", + " 'GCTGCAGCTGGCTTTCATGA': 0,\n", + " 'GGTGCAGCTGGCTCTCATGA': 0,\n", + " 'GGTGCAGCTGGCTGTCATGA': 0,\n", + " 'GGTGCAGCTGGCTTTCATGA': 0,\n", + " 'GTTGCAGCTGGCTCTCATGA': 0,\n", + " 'GTTGCAGCTGGCTGTCATGA': 0,\n", + " 'GTTGCAGCTGGCTTTCATGA': 0,\n", + " 'GCTGCAGCTGGCTAACATGA': 0,\n", + " 'GCTGCAGCTGGCTACCATGA': 0,\n", + " 'GCTGCAGCTGGCTAGCATGA': 0,\n", + " 'GGTGCAGCTGGCTAACATGA': 0,\n", + " 'GGTGCAGCTGGCTACCATGA': 0,\n", + " 'GGTGCAGCTGGCTAGCATGA': 0,\n", + " 'GTTGCAGCTGGCTAACATGA': 0,\n", + " 'GTTGCAGCTGGCTACCATGA': 0,\n", + " 'GTTGCAGCTGGCTAGCATGA': 0,\n", + " 'GCTGCAGCTGGCTATAATGA': 0,\n", + " 'GCTGCAGCTGGCTATGATGA': 0,\n", + " 'GCTGCAGCTGGCTATTATGA': 0,\n", + " 'GGTGCAGCTGGCTATAATGA': 0,\n", + " 'GGTGCAGCTGGCTATGATGA': 0,\n", + " 'GGTGCAGCTGGCTATTATGA': 0,\n", + " 'GTTGCAGCTGGCTATAATGA': 0,\n", + " 'GTTGCAGCTGGCTATGATGA': 0,\n", + " 'GTTGCAGCTGGCTATTATGA': 0,\n", + " 'GCTGCAGCTGGCTATCCTGA': 0,\n", + " 'GCTGCAGCTGGCTATCGTGA': 0,\n", + " 'GCTGCAGCTGGCTATCTTGA': 0,\n", + " 'GGTGCAGCTGGCTATCCTGA': 0,\n", + " 'GGTGCAGCTGGCTATCGTGA': 0,\n", + " 'GGTGCAGCTGGCTATCTTGA': 0,\n", + " 'GTTGCAGCTGGCTATCCTGA': 0,\n", + " 'GTTGCAGCTGGCTATCGTGA': 0,\n", + " 'GTTGCAGCTGGCTATCTTGA': 0,\n", + " 'GCTGCAGCTGGCTATCAAGA': 0,\n", + " 'GCTGCAGCTGGCTATCACGA': 0,\n", + " 'GCTGCAGCTGGCTATCAGGA': 0,\n", + " 'GGTGCAGCTGGCTATCAAGA': 0,\n", + " 'GGTGCAGCTGGCTATCACGA': 0,\n", + " 'GGTGCAGCTGGCTATCAGGA': 0,\n", + " 'GTTGCAGCTGGCTATCAAGA': 0,\n", + " 'GTTGCAGCTGGCTATCACGA': 0,\n", + " 'GTTGCAGCTGGCTATCAGGA': 0,\n", + " 'GCTGCAGCTGGCTATCATAA': 0,\n", + " 'GCTGCAGCTGGCTATCATCA': 0,\n", + " 'GCTGCAGCTGGCTATCATTA': 0,\n", + " 'GGTGCAGCTGGCTATCATAA': 0,\n", + " 'GGTGCAGCTGGCTATCATCA': 0,\n", + " 'GGTGCAGCTGGCTATCATTA': 0,\n", + " 'GTTGCAGCTGGCTATCATAA': 0,\n", + " 'GTTGCAGCTGGCTATCATCA': 0,\n", + " 'GTTGCAGCTGGCTATCATTA': 0,\n", + " 'GCTGCAGCTGGCTATCATGC': 0,\n", + " 'GCTGCAGCTGGCTATCATGG': 0,\n", + " 'GCTGCAGCTGGCTATCATGT': 0,\n", + " 'GGTGCAGCTGGCTATCATGC': 0,\n", + " 'GGTGCAGCTGGCTATCATGG': 0,\n", + " 'GGTGCAGCTGGCTATCATGT': 0,\n", + " 'GTTGCAGCTGGCTATCATGC': 0,\n", + " 'GTTGCAGCTGGCTATCATGG': 0,\n", + " 'GTTGCAGCTGGCTATCATGT': 0,\n", + " 'GAAAGCAGCTGGCTATCATGA': 0,\n", + " 'GAACGCAGCTGGCTATCATGA': 0,\n", + " 'GAAGGCAGCTGGCTATCATGA': 0,\n", + " 'GACAGCAGCTGGCTATCATGA': 0,\n", + " 'GACCGCAGCTGGCTATCATGA': 0,\n", + " 'GACGGCAGCTGGCTATCATGA': 0,\n", + " 'GAGAGCAGCTGGCTATCATGA': 0,\n", + " 'GAGCGCAGCTGGCTATCATGA': 0,\n", + " 'GAGGGCAGCTGGCTATCATGA': 0,\n", + " 'GATAGCAGCTGGCTATCATGA': 0,\n", + " 'GATCGCAGCTGGCTATCATGA': 0,\n", + " 'GATGGCAGCTGGCTATCATGA': 0,\n", + " 'GAAACAGCTGGCTATCATGA': 0,\n", + " 'GAACCAGCTGGCTATCATGA': 0,\n", + " 'GAATCAGCTGGCTATCATGA': 0,\n", + " 'GACACAGCTGGCTATCATGA': 0,\n", + " 'GACCCAGCTGGCTATCATGA': 0,\n", + " 'GACTCAGCTGGCTATCATGA': 0,\n", + " 'GAGACAGCTGGCTATCATGA': 0,\n", + " 'GAGCCAGCTGGCTATCATGA': 0,\n", + " 'GAGTCAGCTGGCTATCATGA': 0,\n", + " 'GAAGAAGCTGGCTATCATGA': 0,\n", + " 'GAAGGAGCTGGCTATCATGA': 0,\n", + " 'GAAGTAGCTGGCTATCATGA': 0,\n", + " 'GACGAAGCTGGCTATCATGA': 0,\n", + " 'GACGGAGCTGGCTATCATGA': 0,\n", + " 'GACGTAGCTGGCTATCATGA': 0,\n", + " 'GAGGAAGCTGGCTATCATGA': 0,\n", + " 'GAGGGAGCTGGCTATCATGA': 0,\n", + " 'GAGGTAGCTGGCTATCATGA': 0,\n", + " 'GAAGCCGCTGGCTATCATGA': 0,\n", + " 'GAAGCGGCTGGCTATCATGA': 0,\n", + " 'GAAGCTGCTGGCTATCATGA': 0,\n", + " 'GACGCCGCTGGCTATCATGA': 0,\n", + " 'GACGCGGCTGGCTATCATGA': 0,\n", + " 'GACGCTGCTGGCTATCATGA': 0,\n", + " 'GAGGCCGCTGGCTATCATGA': 0,\n", + " 'GAGGCGGCTGGCTATCATGA': 0,\n", + " 'GAGGCTGCTGGCTATCATGA': 0,\n", + " 'GAAGCAACTGGCTATCATGA': 0,\n", + " 'GAAGCACCTGGCTATCATGA': 0,\n", + " 'GAAGCATCTGGCTATCATGA': 0,\n", + " 'GACGCAACTGGCTATCATGA': 0,\n", + " 'GACGCACCTGGCTATCATGA': 0,\n", + " 'GACGCATCTGGCTATCATGA': 0,\n", + " 'GAGGCAACTGGCTATCATGA': 0,\n", + " 'GAGGCACCTGGCTATCATGA': 0,\n", + " 'GAGGCATCTGGCTATCATGA': 0,\n", + " 'GAAGCAGATGGCTATCATGA': 0,\n", + " 'GAAGCAGGTGGCTATCATGA': 0,\n", + " 'GAAGCAGTTGGCTATCATGA': 0,\n", + " 'GACGCAGATGGCTATCATGA': 0,\n", + " 'GACGCAGGTGGCTATCATGA': 0,\n", + " 'GACGCAGTTGGCTATCATGA': 0,\n", + " 'GAGGCAGATGGCTATCATGA': 0,\n", + " 'GAGGCAGGTGGCTATCATGA': 0,\n", + " 'GAGGCAGTTGGCTATCATGA': 0,\n", + " 'GAAGCAGCAGGCTATCATGA': 0,\n", + " 'GAAGCAGCCGGCTATCATGA': 0,\n", + " 'GAAGCAGCGGGCTATCATGA': 0,\n", + " 'GACGCAGCAGGCTATCATGA': 0,\n", + " 'GACGCAGCCGGCTATCATGA': 0,\n", + " 'GACGCAGCGGGCTATCATGA': 0,\n", + " 'GAGGCAGCAGGCTATCATGA': 0,\n", + " 'GAGGCAGCCGGCTATCATGA': 0,\n", + " 'GAGGCAGCGGGCTATCATGA': 0,\n", + " 'GAAGCAGCTAGCTATCATGA': 0,\n", + " 'GAAGCAGCTCGCTATCATGA': 0,\n", + " 'GAAGCAGCTTGCTATCATGA': 0,\n", + " 'GACGCAGCTAGCTATCATGA': 0,\n", + " 'GACGCAGCTCGCTATCATGA': 0,\n", + " 'GACGCAGCTTGCTATCATGA': 0,\n", + " 'GAGGCAGCTAGCTATCATGA': 0,\n", + " 'GAGGCAGCTCGCTATCATGA': 0,\n", + " 'GAGGCAGCTTGCTATCATGA': 0,\n", + " 'GAAGCAGCTGACTATCATGA': 0,\n", + " 'GAAGCAGCTGCCTATCATGA': 0,\n", + " 'GAAGCAGCTGTCTATCATGA': 0,\n", + " 'GACGCAGCTGACTATCATGA': 0,\n", + " 'GACGCAGCTGCCTATCATGA': 0,\n", + " 'GACGCAGCTGTCTATCATGA': 0,\n", + " 'GAGGCAGCTGACTATCATGA': 0,\n", + " 'GAGGCAGCTGCCTATCATGA': 0,\n", + " 'GAGGCAGCTGTCTATCATGA': 0,\n", + " 'GAAGCAGCTGGATATCATGA': 0,\n", + " 'GAAGCAGCTGGGTATCATGA': 0,\n", + " 'GAAGCAGCTGGTTATCATGA': 0,\n", + " 'GACGCAGCTGGATATCATGA': 0,\n", + " 'GACGCAGCTGGGTATCATGA': 0,\n", + " 'GACGCAGCTGGTTATCATGA': 0,\n", + " 'GAGGCAGCTGGATATCATGA': 0,\n", + " 'GAGGCAGCTGGGTATCATGA': 0,\n", + " 'GAGGCAGCTGGTTATCATGA': 0,\n", + " 'GAAGCAGCTGGCAATCATGA': 0,\n", + " 'GAAGCAGCTGGCCATCATGA': 0,\n", + " 'GAAGCAGCTGGCGATCATGA': 0,\n", + " 'GACGCAGCTGGCAATCATGA': 0,\n", + " 'GACGCAGCTGGCCATCATGA': 0,\n", + " 'GACGCAGCTGGCGATCATGA': 0,\n", + " 'GAGGCAGCTGGCAATCATGA': 0,\n", + " 'GAGGCAGCTGGCCATCATGA': 0,\n", + " 'GAGGCAGCTGGCGATCATGA': 0,\n", + " 'GAAGCAGCTGGCTCTCATGA': 0,\n", + " 'GAAGCAGCTGGCTGTCATGA': 0,\n", + " 'GAAGCAGCTGGCTTTCATGA': 0,\n", + " 'GACGCAGCTGGCTCTCATGA': 0,\n", + " 'GACGCAGCTGGCTGTCATGA': 0,\n", + " 'GACGCAGCTGGCTTTCATGA': 0,\n", + " 'GAGGCAGCTGGCTCTCATGA': 0,\n", + " 'GAGGCAGCTGGCTGTCATGA': 0,\n", + " 'GAGGCAGCTGGCTTTCATGA': 0,\n", + " 'GAAGCAGCTGGCTAACATGA': 0,\n", + " 'GAAGCAGCTGGCTACCATGA': 0,\n", + " 'GAAGCAGCTGGCTAGCATGA': 0,\n", + " 'GACGCAGCTGGCTAACATGA': 0,\n", + " 'GACGCAGCTGGCTACCATGA': 0,\n", + " 'GACGCAGCTGGCTAGCATGA': 0,\n", + " 'GAGGCAGCTGGCTAACATGA': 0,\n", + " 'GAGGCAGCTGGCTACCATGA': 0,\n", + " 'GAGGCAGCTGGCTAGCATGA': 0,\n", + " 'GAAGCAGCTGGCTATAATGA': 0,\n", + " 'GAAGCAGCTGGCTATGATGA': 0,\n", + " 'GAAGCAGCTGGCTATTATGA': 0,\n", + " 'GACGCAGCTGGCTATAATGA': 0,\n", + " 'GACGCAGCTGGCTATGATGA': 0,\n", + " 'GACGCAGCTGGCTATTATGA': 0,\n", + " 'GAGGCAGCTGGCTATAATGA': 0,\n", + " 'GAGGCAGCTGGCTATGATGA': 0,\n", + " 'GAGGCAGCTGGCTATTATGA': 0,\n", + " 'GAAGCAGCTGGCTATCCTGA': 0,\n", + " 'GAAGCAGCTGGCTATCGTGA': 0,\n", + " 'GAAGCAGCTGGCTATCTTGA': 0,\n", + " 'GACGCAGCTGGCTATCCTGA': 0,\n", + " 'GACGCAGCTGGCTATCGTGA': 0,\n", + " 'GACGCAGCTGGCTATCTTGA': 0,\n", + " 'GAGGCAGCTGGCTATCCTGA': 0,\n", + " 'GAGGCAGCTGGCTATCGTGA': 0,\n", + " 'GAGGCAGCTGGCTATCTTGA': 0,\n", + " 'GAAGCAGCTGGCTATCAAGA': 0,\n", + " 'GAAGCAGCTGGCTATCACGA': 0,\n", + " 'GAAGCAGCTGGCTATCAGGA': 0,\n", + " 'GACGCAGCTGGCTATCAAGA': 0,\n", + " 'GACGCAGCTGGCTATCACGA': 0,\n", + " 'GACGCAGCTGGCTATCAGGA': 0,\n", + " 'GAGGCAGCTGGCTATCAAGA': 0,\n", + " 'GAGGCAGCTGGCTATCACGA': 0,\n", + " 'GAGGCAGCTGGCTATCAGGA': 0,\n", + " 'GAAGCAGCTGGCTATCATAA': 0,\n", + " 'GAAGCAGCTGGCTATCATCA': 0,\n", + " 'GAAGCAGCTGGCTATCATTA': 0,\n", + " 'GACGCAGCTGGCTATCATAA': 0,\n", + " 'GACGCAGCTGGCTATCATCA': 0,\n", + " 'GACGCAGCTGGCTATCATTA': 0,\n", + " 'GAGGCAGCTGGCTATCATAA': 0,\n", + " 'GAGGCAGCTGGCTATCATCA': 0,\n", + " 'GAGGCAGCTGGCTATCATTA': 0,\n", + " 'GAAGCAGCTGGCTATCATGC': 0,\n", + " 'GAAGCAGCTGGCTATCATGG': 0,\n", + " 'GAAGCAGCTGGCTATCATGT': 0,\n", + " 'GACGCAGCTGGCTATCATGC': 0,\n", + " 'GACGCAGCTGGCTATCATGG': 0,\n", + " 'GACGCAGCTGGCTATCATGT': 0,\n", + " 'GAGGCAGCTGGCTATCATGC': 0,\n", + " 'GAGGCAGCTGGCTATCATGG': 0,\n", + " 'GAGGCAGCTGGCTATCATGT': 0,\n", + " 'GATAACAGCTGGCTATCATGA': 0,\n", + " 'GATACCAGCTGGCTATCATGA': 0,\n", + " 'GATATCAGCTGGCTATCATGA': 0,\n", + " 'GATCACAGCTGGCTATCATGA': 0,\n", + " 'GATCCCAGCTGGCTATCATGA': 0,\n", + " 'GATCTCAGCTGGCTATCATGA': 0,\n", + " 'GATGACAGCTGGCTATCATGA': 0,\n", + " 'GATGCCAGCTGGCTATCATGA': 0,\n", + " 'GATGTCAGCTGGCTATCATGA': 0,\n", + " 'GATTACAGCTGGCTATCATGA': 0,\n", + " 'GATTCCAGCTGGCTATCATGA': 0,\n", + " 'GATTTCAGCTGGCTATCATGA': 0,\n", + " 'GATAAAGCTGGCTATCATGA': 0,\n", + " 'GATAGAGCTGGCTATCATGA': 0,\n", + " 'GATATAGCTGGCTATCATGA': 0,\n", + " 'GATCAAGCTGGCTATCATGA': 0,\n", + " 'GATCGAGCTGGCTATCATGA': 0,\n", + " 'GATCTAGCTGGCTATCATGA': 0,\n", + " 'GATTAAGCTGGCTATCATGA': 0,\n", + " 'GATTGAGCTGGCTATCATGA': 0,\n", + " 'GATTTAGCTGGCTATCATGA': 0,\n", + " 'GATACCGCTGGCTATCATGA': 0,\n", + " 'GATACGGCTGGCTATCATGA': 0,\n", + " 'GATACTGCTGGCTATCATGA': 0,\n", + " 'GATCCCGCTGGCTATCATGA': 0,\n", + " 'GATCCGGCTGGCTATCATGA': 0,\n", + " 'GATCCTGCTGGCTATCATGA': 0,\n", + " 'GATTCCGCTGGCTATCATGA': 0,\n", + " 'GATTCGGCTGGCTATCATGA': 0,\n", + " 'GATTCTGCTGGCTATCATGA': 0,\n", + " 'GATACAACTGGCTATCATGA': 0,\n", + " 'GATACACCTGGCTATCATGA': 0,\n", + " 'GATACATCTGGCTATCATGA': 0,\n", + " 'GATCCAACTGGCTATCATGA': 0,\n", + " 'GATCCACCTGGCTATCATGA': 0,\n", + " 'GATCCATCTGGCTATCATGA': 0,\n", + " 'GATTCAACTGGCTATCATGA': 0,\n", + " 'GATTCACCTGGCTATCATGA': 0,\n", + " 'GATTCATCTGGCTATCATGA': 0,\n", + " 'GATACAGATGGCTATCATGA': 0,\n", + " 'GATACAGGTGGCTATCATGA': 0,\n", + " 'GATACAGTTGGCTATCATGA': 0,\n", + " 'GATCCAGATGGCTATCATGA': 0,\n", + " 'GATCCAGGTGGCTATCATGA': 0,\n", + " 'GATCCAGTTGGCTATCATGA': 0,\n", + " 'GATTCAGATGGCTATCATGA': 0,\n", + " 'GATTCAGGTGGCTATCATGA': 0,\n", + " 'GATTCAGTTGGCTATCATGA': 0,\n", + " 'GATACAGCAGGCTATCATGA': 0,\n", + " 'GATACAGCCGGCTATCATGA': 0,\n", + " 'GATACAGCGGGCTATCATGA': 0,\n", + " 'GATCCAGCAGGCTATCATGA': 0,\n", + " 'GATCCAGCCGGCTATCATGA': 0,\n", + " 'GATCCAGCGGGCTATCATGA': 0,\n", + " 'GATTCAGCAGGCTATCATGA': 0,\n", + " 'GATTCAGCCGGCTATCATGA': 0,\n", + " 'GATTCAGCGGGCTATCATGA': 0,\n", + " 'GATACAGCTAGCTATCATGA': 0,\n", + " 'GATACAGCTCGCTATCATGA': 0,\n", + " 'GATACAGCTTGCTATCATGA': 0,\n", + " 'GATCCAGCTAGCTATCATGA': 0,\n", + " 'GATCCAGCTCGCTATCATGA': 0,\n", + " 'GATCCAGCTTGCTATCATGA': 0,\n", + " 'GATTCAGCTAGCTATCATGA': 0,\n", + " 'GATTCAGCTCGCTATCATGA': 0,\n", + " 'GATTCAGCTTGCTATCATGA': 0,\n", + " 'GATACAGCTGACTATCATGA': 0,\n", + " 'GATACAGCTGCCTATCATGA': 0,\n", + " 'GATACAGCTGTCTATCATGA': 0,\n", + " 'GATCCAGCTGACTATCATGA': 0,\n", + " 'GATCCAGCTGCCTATCATGA': 0,\n", + " 'GATCCAGCTGTCTATCATGA': 0,\n", + " 'GATTCAGCTGACTATCATGA': 0,\n", + " 'GATTCAGCTGCCTATCATGA': 0,\n", + " 'GATTCAGCTGTCTATCATGA': 0,\n", + " 'GATACAGCTGGATATCATGA': 0,\n", + " 'GATACAGCTGGGTATCATGA': 0,\n", + " 'GATACAGCTGGTTATCATGA': 0,\n", + " 'GATCCAGCTGGATATCATGA': 0,\n", + " 'GATCCAGCTGGGTATCATGA': 0,\n", + " 'GATCCAGCTGGTTATCATGA': 0,\n", + " 'GATTCAGCTGGATATCATGA': 0,\n", + " 'GATTCAGCTGGGTATCATGA': 0,\n", + " 'GATTCAGCTGGTTATCATGA': 0,\n", + " 'GATACAGCTGGCAATCATGA': 0,\n", + " 'GATACAGCTGGCCATCATGA': 0,\n", + " 'GATACAGCTGGCGATCATGA': 0,\n", + " 'GATCCAGCTGGCAATCATGA': 0,\n", + " 'GATCCAGCTGGCCATCATGA': 0,\n", + " 'GATCCAGCTGGCGATCATGA': 0,\n", + " 'GATTCAGCTGGCAATCATGA': 0,\n", + " 'GATTCAGCTGGCCATCATGA': 0,\n", + " 'GATTCAGCTGGCGATCATGA': 0,\n", + " 'GATACAGCTGGCTCTCATGA': 0,\n", + " 'GATACAGCTGGCTGTCATGA': 0,\n", + " 'GATACAGCTGGCTTTCATGA': 0,\n", + " 'GATCCAGCTGGCTCTCATGA': 0,\n", + " 'GATCCAGCTGGCTGTCATGA': 0,\n", + " 'GATCCAGCTGGCTTTCATGA': 0,\n", + " 'GATTCAGCTGGCTCTCATGA': 0,\n", + " 'GATTCAGCTGGCTGTCATGA': 0,\n", + " 'GATTCAGCTGGCTTTCATGA': 0,\n", + " 'GATACAGCTGGCTAACATGA': 0,\n", + " 'GATACAGCTGGCTACCATGA': 0,\n", + " 'GATACAGCTGGCTAGCATGA': 0,\n", + " 'GATCCAGCTGGCTAACATGA': 0,\n", + " 'GATCCAGCTGGCTACCATGA': 0,\n", + " 'GATCCAGCTGGCTAGCATGA': 0,\n", + " 'GATTCAGCTGGCTAACATGA': 0,\n", + " 'GATTCAGCTGGCTACCATGA': 0,\n", + " 'GATTCAGCTGGCTAGCATGA': 0,\n", + " 'GATACAGCTGGCTATAATGA': 0,\n", + " 'GATACAGCTGGCTATGATGA': 0,\n", + " 'GATACAGCTGGCTATTATGA': 0,\n", + " 'GATCCAGCTGGCTATAATGA': 0,\n", + " 'GATCCAGCTGGCTATGATGA': 0,\n", + " 'GATCCAGCTGGCTATTATGA': 0,\n", + " 'GATTCAGCTGGCTATAATGA': 0,\n", + " 'GATTCAGCTGGCTATGATGA': 0,\n", + " 'GATTCAGCTGGCTATTATGA': 0,\n", + " 'GATACAGCTGGCTATCCTGA': 0,\n", + " 'GATACAGCTGGCTATCGTGA': 0,\n", + " 'GATACAGCTGGCTATCTTGA': 0,\n", + " 'GATCCAGCTGGCTATCCTGA': 0,\n", + " 'GATCCAGCTGGCTATCGTGA': 0,\n", + " 'GATCCAGCTGGCTATCTTGA': 0,\n", + " 'GATTCAGCTGGCTATCCTGA': 0,\n", + " 'GATTCAGCTGGCTATCGTGA': 0,\n", + " 'GATTCAGCTGGCTATCTTGA': 0,\n", + " 'GATACAGCTGGCTATCAAGA': 0,\n", + " 'GATACAGCTGGCTATCACGA': 0,\n", + " 'GATACAGCTGGCTATCAGGA': 0,\n", + " 'GATCCAGCTGGCTATCAAGA': 0,\n", + " 'GATCCAGCTGGCTATCACGA': 0,\n", + " 'GATCCAGCTGGCTATCAGGA': 0,\n", + " 'GATTCAGCTGGCTATCAAGA': 0,\n", + " 'GATTCAGCTGGCTATCACGA': 0,\n", + " 'GATTCAGCTGGCTATCAGGA': 0,\n", + " 'GATACAGCTGGCTATCATAA': 0,\n", + " 'GATACAGCTGGCTATCATCA': 0,\n", + " 'GATACAGCTGGCTATCATTA': 0,\n", + " 'GATCCAGCTGGCTATCATAA': 0,\n", + " 'GATCCAGCTGGCTATCATCA': 0,\n", + " 'GATCCAGCTGGCTATCATTA': 0,\n", + " 'GATTCAGCTGGCTATCATAA': 0,\n", + " 'GATTCAGCTGGCTATCATCA': 0,\n", + " 'GATTCAGCTGGCTATCATTA': 0,\n", + " 'GATACAGCTGGCTATCATGC': 0,\n", + " 'GATACAGCTGGCTATCATGG': 0,\n", + " 'GATACAGCTGGCTATCATGT': 0,\n", + " 'GATCCAGCTGGCTATCATGC': 0,\n", + " 'GATCCAGCTGGCTATCATGG': 0,\n", + " 'GATCCAGCTGGCTATCATGT': 0,\n", + " 'GATTCAGCTGGCTATCATGC': 0,\n", + " 'GATTCAGCTGGCTATCATGG': 0,\n", + " 'GATTCAGCTGGCTATCATGT': 0,\n", + " 'GATGAAAGCTGGCTATCATGA': 0,\n", + " 'GATGAGAGCTGGCTATCATGA': 0,\n", + " 'GATGATAGCTGGCTATCATGA': 0,\n", + " 'GATGCAAGCTGGCTATCATGA': 0,\n", + " 'GATGCGAGCTGGCTATCATGA': 0,\n", + " 'GATGCTAGCTGGCTATCATGA': 0,\n", + " 'GATGGAAGCTGGCTATCATGA': 0,\n", + " 'GATGGGAGCTGGCTATCATGA': 0,\n", + " 'GATGGTAGCTGGCTATCATGA': 0,\n", + " 'GATGTAAGCTGGCTATCATGA': 0,\n", + " 'GATGTGAGCTGGCTATCATGA': 0,\n", + " 'GATGTTAGCTGGCTATCATGA': 0,\n", + " 'GATGACGCTGGCTATCATGA': 0,\n", + " 'GATGAGGCTGGCTATCATGA': 0,\n", + " 'GATGATGCTGGCTATCATGA': 0,\n", + " 'GATGGCGCTGGCTATCATGA': 0,\n", + " 'GATGGGGCTGGCTATCATGA': 0,\n", + " 'GATGGTGCTGGCTATCATGA': 0,\n", + " 'GATGTCGCTGGCTATCATGA': 0,\n", + " 'GATGTGGCTGGCTATCATGA': 0,\n", + " 'GATGTTGCTGGCTATCATGA': 0,\n", + " 'GATGAAACTGGCTATCATGA': 0,\n", + " 'GATGAACCTGGCTATCATGA': 0,\n", + " 'GATGAATCTGGCTATCATGA': 0,\n", + " 'GATGGAACTGGCTATCATGA': 0,\n", + " 'GATGGACCTGGCTATCATGA': 0,\n", + " 'GATGGATCTGGCTATCATGA': 0,\n", + " 'GATGTAACTGGCTATCATGA': 0,\n", + " 'GATGTACCTGGCTATCATGA': 0,\n", + " 'GATGTATCTGGCTATCATGA': 0,\n", + " 'GATGAAGATGGCTATCATGA': 0,\n", + " 'GATGAAGGTGGCTATCATGA': 0,\n", + " 'GATGAAGTTGGCTATCATGA': 0,\n", + " 'GATGGAGATGGCTATCATGA': 0,\n", + " 'GATGGAGGTGGCTATCATGA': 0,\n", + " 'GATGGAGTTGGCTATCATGA': 0,\n", + " 'GATGTAGATGGCTATCATGA': 0,\n", + " 'GATGTAGGTGGCTATCATGA': 0,\n", + " 'GATGTAGTTGGCTATCATGA': 0,\n", + " 'GATGAAGCAGGCTATCATGA': 0,\n", + " 'GATGAAGCCGGCTATCATGA': 0,\n", + " 'GATGAAGCGGGCTATCATGA': 0,\n", + " 'GATGGAGCAGGCTATCATGA': 0,\n", + " 'GATGGAGCCGGCTATCATGA': 0,\n", + " 'GATGGAGCGGGCTATCATGA': 0,\n", + " 'GATGTAGCAGGCTATCATGA': 0,\n", + " 'GATGTAGCCGGCTATCATGA': 0,\n", + " 'GATGTAGCGGGCTATCATGA': 0,\n", + " 'GATGAAGCTAGCTATCATGA': 0,\n", + " 'GATGAAGCTCGCTATCATGA': 0,\n", + " 'GATGAAGCTTGCTATCATGA': 0,\n", + " 'GATGGAGCTAGCTATCATGA': 0,\n", + " 'GATGGAGCTCGCTATCATGA': 0,\n", + " 'GATGGAGCTTGCTATCATGA': 0,\n", + " 'GATGTAGCTAGCTATCATGA': 0,\n", + " 'GATGTAGCTCGCTATCATGA': 0,\n", + " 'GATGTAGCTTGCTATCATGA': 0,\n", + " 'GATGAAGCTGACTATCATGA': 0,\n", + " 'GATGAAGCTGCCTATCATGA': 0,\n", + " 'GATGAAGCTGTCTATCATGA': 0,\n", + " 'GATGGAGCTGACTATCATGA': 0,\n", + " 'GATGGAGCTGCCTATCATGA': 0,\n", + " 'GATGGAGCTGTCTATCATGA': 0,\n", + " 'GATGTAGCTGACTATCATGA': 0,\n", + " 'GATGTAGCTGCCTATCATGA': 0,\n", + " 'GATGTAGCTGTCTATCATGA': 0,\n", + " 'GATGAAGCTGGATATCATGA': 0,\n", + " 'GATGAAGCTGGGTATCATGA': 0,\n", + " 'GATGAAGCTGGTTATCATGA': 0,\n", + " 'GATGGAGCTGGATATCATGA': 0,\n", + " 'GATGGAGCTGGGTATCATGA': 0,\n", + " 'GATGGAGCTGGTTATCATGA': 0,\n", + " 'GATGTAGCTGGATATCATGA': 0,\n", + " 'GATGTAGCTGGGTATCATGA': 0,\n", + " 'GATGTAGCTGGTTATCATGA': 0,\n", + " 'GATGAAGCTGGCAATCATGA': 0,\n", + " 'GATGAAGCTGGCCATCATGA': 0,\n", + " 'GATGAAGCTGGCGATCATGA': 0,\n", + " 'GATGGAGCTGGCAATCATGA': 0,\n", + " 'GATGGAGCTGGCCATCATGA': 0,\n", + " 'GATGGAGCTGGCGATCATGA': 0,\n", + " 'GATGTAGCTGGCAATCATGA': 0,\n", + " 'GATGTAGCTGGCCATCATGA': 0,\n", + " 'GATGTAGCTGGCGATCATGA': 0,\n", + " 'GATGAAGCTGGCTCTCATGA': 0,\n", + " 'GATGAAGCTGGCTGTCATGA': 0,\n", + " 'GATGAAGCTGGCTTTCATGA': 0,\n", + " 'GATGGAGCTGGCTCTCATGA': 0,\n", + " 'GATGGAGCTGGCTGTCATGA': 0,\n", + " 'GATGGAGCTGGCTTTCATGA': 0,\n", + " 'GATGTAGCTGGCTCTCATGA': 0,\n", + " 'GATGTAGCTGGCTGTCATGA': 0,\n", + " 'GATGTAGCTGGCTTTCATGA': 0,\n", + " 'GATGAAGCTGGCTAACATGA': 0,\n", + " 'GATGAAGCTGGCTACCATGA': 0,\n", + " 'GATGAAGCTGGCTAGCATGA': 0,\n", + " 'GATGGAGCTGGCTAACATGA': 0,\n", + " 'GATGGAGCTGGCTACCATGA': 0,\n", + " 'GATGGAGCTGGCTAGCATGA': 0,\n", + " 'GATGTAGCTGGCTAACATGA': 0,\n", + " 'GATGTAGCTGGCTACCATGA': 0,\n", + " 'GATGTAGCTGGCTAGCATGA': 0,\n", + " 'GATGAAGCTGGCTATAATGA': 0,\n", + " 'GATGAAGCTGGCTATGATGA': 0,\n", + " 'GATGAAGCTGGCTATTATGA': 0,\n", + " 'GATGGAGCTGGCTATAATGA': 0,\n", + " 'GATGGAGCTGGCTATGATGA': 0,\n", + " 'GATGGAGCTGGCTATTATGA': 0,\n", + " 'GATGTAGCTGGCTATAATGA': 0,\n", + " 'GATGTAGCTGGCTATGATGA': 0,\n", + " 'GATGTAGCTGGCTATTATGA': 0,\n", + " 'GATGAAGCTGGCTATCCTGA': 0,\n", + " 'GATGAAGCTGGCTATCGTGA': 0,\n", + " 'GATGAAGCTGGCTATCTTGA': 0,\n", + " 'GATGGAGCTGGCTATCCTGA': 0,\n", + " 'GATGGAGCTGGCTATCGTGA': 0,\n", + " 'GATGGAGCTGGCTATCTTGA': 0,\n", + " 'GATGTAGCTGGCTATCCTGA': 0,\n", + " 'GATGTAGCTGGCTATCGTGA': 0,\n", + " 'GATGTAGCTGGCTATCTTGA': 0,\n", + " 'GATGAAGCTGGCTATCAAGA': 0,\n", + " 'GATGAAGCTGGCTATCACGA': 0,\n", + " 'GATGAAGCTGGCTATCAGGA': 0,\n", + " 'GATGGAGCTGGCTATCAAGA': 0,\n", + " 'GATGGAGCTGGCTATCACGA': 0,\n", + " 'GATGGAGCTGGCTATCAGGA': 0,\n", + " 'GATGTAGCTGGCTATCAAGA': 0,\n", + " 'GATGTAGCTGGCTATCACGA': 0,\n", + " 'GATGTAGCTGGCTATCAGGA': 0,\n", + " 'GATGAAGCTGGCTATCATAA': 0,\n", + " 'GATGAAGCTGGCTATCATCA': 0,\n", + " 'GATGAAGCTGGCTATCATTA': 0,\n", + " 'GATGGAGCTGGCTATCATAA': 0,\n", + " 'GATGGAGCTGGCTATCATCA': 0,\n", + " 'GATGGAGCTGGCTATCATTA': 0,\n", + " 'GATGTAGCTGGCTATCATAA': 0,\n", + " 'GATGTAGCTGGCTATCATCA': 0,\n", + " 'GATGTAGCTGGCTATCATTA': 0,\n", + " 'GATGAAGCTGGCTATCATGC': 0,\n", + " 'GATGAAGCTGGCTATCATGG': 0,\n", + " 'GATGAAGCTGGCTATCATGT': 0,\n", + " 'GATGGAGCTGGCTATCATGC': 0,\n", + " 'GATGGAGCTGGCTATCATGG': 0,\n", + " 'GATGGAGCTGGCTATCATGT': 0,\n", + " 'GATGTAGCTGGCTATCATGC': 0,\n", + " 'GATGTAGCTGGCTATCATGG': 0,\n", + " 'GATGTAGCTGGCTATCATGT': 0,\n", + " 'GATGCACGCTGGCTATCATGA': 0,\n", + " 'GATGCAGGCTGGCTATCATGA': 0,\n", + " 'GATGCATGCTGGCTATCATGA': 0,\n", + " 'GATGCCCGCTGGCTATCATGA': 0,\n", + " 'GATGCCGGCTGGCTATCATGA': 0,\n", + " 'GATGCCTGCTGGCTATCATGA': 0,\n", + " 'GATGCGCGCTGGCTATCATGA': 0,\n", + " 'GATGCGGGCTGGCTATCATGA': 0,\n", + " 'GATGCGTGCTGGCTATCATGA': 0,\n", + " 'GATGCTCGCTGGCTATCATGA': 0,\n", + " 'GATGCTGGCTGGCTATCATGA': 0,\n", + " 'GATGCTTGCTGGCTATCATGA': 0,\n", + " 'GATGCCACTGGCTATCATGA': 0,\n", + " 'GATGCCCCTGGCTATCATGA': 0,\n", + " 'GATGCCTCTGGCTATCATGA': 0,\n", + " 'GATGCGACTGGCTATCATGA': 0,\n", + " 'GATGCGCCTGGCTATCATGA': 0,\n", + " 'GATGCGTCTGGCTATCATGA': 0,\n", + " 'GATGCTACTGGCTATCATGA': 0,\n", + " 'GATGCTCCTGGCTATCATGA': 0,\n", + " 'GATGCTTCTGGCTATCATGA': 0,\n", + " 'GATGCCGATGGCTATCATGA': 0,\n", + " 'GATGCCGGTGGCTATCATGA': 0,\n", + " 'GATGCCGTTGGCTATCATGA': 0,\n", + " 'GATGCGGATGGCTATCATGA': 0,\n", + " 'GATGCGGGTGGCTATCATGA': 0,\n", + " 'GATGCGGTTGGCTATCATGA': 0,\n", + " 'GATGCTGATGGCTATCATGA': 0,\n", + " 'GATGCTGGTGGCTATCATGA': 0,\n", + " 'GATGCTGTTGGCTATCATGA': 0,\n", + " 'GATGCCGCAGGCTATCATGA': 0,\n", + " 'GATGCCGCCGGCTATCATGA': 0,\n", + " 'GATGCCGCGGGCTATCATGA': 0,\n", + " 'GATGCGGCAGGCTATCATGA': 0,\n", + " 'GATGCGGCCGGCTATCATGA': 0,\n", + " 'GATGCGGCGGGCTATCATGA': 0,\n", + " 'GATGCTGCAGGCTATCATGA': 0,\n", + " 'GATGCTGCCGGCTATCATGA': 0,\n", + " 'GATGCTGCGGGCTATCATGA': 0,\n", + " 'GATGCCGCTAGCTATCATGA': 0,\n", + " 'GATGCCGCTCGCTATCATGA': 0,\n", + " 'GATGCCGCTTGCTATCATGA': 0,\n", + " 'GATGCGGCTAGCTATCATGA': 0,\n", + " 'GATGCGGCTCGCTATCATGA': 0,\n", + " 'GATGCGGCTTGCTATCATGA': 0,\n", + " 'GATGCTGCTAGCTATCATGA': 0,\n", + " 'GATGCTGCTCGCTATCATGA': 0,\n", + " 'GATGCTGCTTGCTATCATGA': 0,\n", + " 'GATGCCGCTGACTATCATGA': 0,\n", + " 'GATGCCGCTGCCTATCATGA': 0,\n", + " 'GATGCCGCTGTCTATCATGA': 0,\n", + " 'GATGCGGCTGACTATCATGA': 0,\n", + " 'GATGCGGCTGCCTATCATGA': 0,\n", + " 'GATGCGGCTGTCTATCATGA': 0,\n", + " 'GATGCTGCTGACTATCATGA': 0,\n", + " 'GATGCTGCTGCCTATCATGA': 0,\n", + " 'GATGCTGCTGTCTATCATGA': 0,\n", + " 'GATGCCGCTGGATATCATGA': 0,\n", + " 'GATGCCGCTGGGTATCATGA': 0,\n", + " 'GATGCCGCTGGTTATCATGA': 0,\n", + " 'GATGCGGCTGGATATCATGA': 0,\n", + " 'GATGCGGCTGGGTATCATGA': 0,\n", + " 'GATGCGGCTGGTTATCATGA': 0,\n", + " 'GATGCTGCTGGATATCATGA': 0,\n", + " 'GATGCTGCTGGGTATCATGA': 0,\n", + " 'GATGCTGCTGGTTATCATGA': 0,\n", + " 'GATGCCGCTGGCAATCATGA': 0,\n", + " 'GATGCCGCTGGCCATCATGA': 0,\n", + " 'GATGCCGCTGGCGATCATGA': 0,\n", + " 'GATGCGGCTGGCAATCATGA': 0,\n", + " 'GATGCGGCTGGCCATCATGA': 0,\n", + " 'GATGCGGCTGGCGATCATGA': 0,\n", + " 'GATGCTGCTGGCAATCATGA': 0,\n", + " 'GATGCTGCTGGCCATCATGA': 0,\n", + " 'GATGCTGCTGGCGATCATGA': 0,\n", + " 'GATGCCGCTGGCTCTCATGA': 0,\n", + " 'GATGCCGCTGGCTGTCATGA': 0,\n", + " 'GATGCCGCTGGCTTTCATGA': 0,\n", + " 'GATGCGGCTGGCTCTCATGA': 0,\n", + " 'GATGCGGCTGGCTGTCATGA': 0,\n", + " 'GATGCGGCTGGCTTTCATGA': 0,\n", + " 'GATGCTGCTGGCTCTCATGA': 0,\n", + " 'GATGCTGCTGGCTGTCATGA': 0,\n", + " 'GATGCTGCTGGCTTTCATGA': 0,\n", + " 'GATGCCGCTGGCTAACATGA': 0,\n", + " 'GATGCCGCTGGCTACCATGA': 0,\n", + " 'GATGCCGCTGGCTAGCATGA': 0,\n", + " 'GATGCGGCTGGCTAACATGA': 0,\n", + " 'GATGCGGCTGGCTACCATGA': 0,\n", + " 'GATGCGGCTGGCTAGCATGA': 0,\n", + " 'GATGCTGCTGGCTAACATGA': 0,\n", + " 'GATGCTGCTGGCTACCATGA': 0,\n", + " 'GATGCTGCTGGCTAGCATGA': 0,\n", + " 'GATGCCGCTGGCTATAATGA': 0,\n", + " 'GATGCCGCTGGCTATGATGA': 0,\n", + " 'GATGCCGCTGGCTATTATGA': 0,\n", + " 'GATGCGGCTGGCTATAATGA': 0,\n", + " 'GATGCGGCTGGCTATGATGA': 0,\n", + " 'GATGCGGCTGGCTATTATGA': 0,\n", + " 'GATGCTGCTGGCTATAATGA': 0,\n", + " 'GATGCTGCTGGCTATGATGA': 0,\n", + " 'GATGCTGCTGGCTATTATGA': 0,\n", + " 'GATGCCGCTGGCTATCCTGA': 0,\n", + " 'GATGCCGCTGGCTATCGTGA': 0,\n", + " 'GATGCCGCTGGCTATCTTGA': 0,\n", + " 'GATGCGGCTGGCTATCCTGA': 0,\n", + " 'GATGCGGCTGGCTATCGTGA': 0,\n", + " 'GATGCGGCTGGCTATCTTGA': 0,\n", + " 'GATGCTGCTGGCTATCCTGA': 0,\n", + " 'GATGCTGCTGGCTATCGTGA': 0,\n", + " ...}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "barcode_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing read 0...\n", + "Processing read 10000...\n", + "Processing read 20000...\n", + "Processing read 30000...\n", + "Processing read 40000...\n", + "Processing read 50000...\n", + "Processing read 60000...\n", + "Processing read 70000...\n", + "Processing read 80000...\n", + "Processing read 90000...\n", + "Processing read 100000...\n", + "Processing read 110000...\n", + "Processing read 120000...\n", + "Processing read 130000...\n", + "Processing read 140000...\n", + "Processing read 150000...\n", + "Processing read 160000...\n", + "Processing read 170000...\n", + "Processing read 180000...\n", + "Processing read 190000...\n", + "Processing read 200000...\n", + "Processing read 210000...\n", + "Processing read 220000...\n", + "Processing read 230000...\n", + "Processing read 240000...\n", + "Processing read 250000...\n", + "Processing read 260000...\n", + "Processing read 270000...\n", + "Done!\n", + "Total # of unique-UMI reads = 192543\n" + ] + } + ], + "source": [ + "#Parse and map RNA sequencing reads\n", + "\n", + "save_suffix = \"_var_repl_2_sknsh_v3\"\n", + "\n", + "r1_name = \"unprocessed_data/SKNSH_Var_R2_trimmed.fastq\"\n", + "r2_name = \"unprocessed_data/SKNSH_Var_R2_UMI_trimmed.fastq\"\n", + "\n", + "polya_regexp = re.compile(r\"AAAAA(AAAAAAAAAAAAAAA){s<=2}\")\n", + "distal_regexp = re.compile(r\"(GCCTCGACTGTGCCTTCTAG){s<=2}\")\n", + "\n", + "def _hamming(s1, s2) :\n", + " \n", + " d = 0.\n", + " for j in range(len(s1)) :\n", + " if s1[j] != s2[j] :\n", + " d += 1.\n", + " \n", + " return d\n", + "\n", + "max_pos = 176\n", + "\n", + "umi_dict = {}\n", + "umi_n_muts = 0\n", + "\n", + "bases = ['A', 'C', 'G', 'T']\n", + "\n", + "cuts = np.zeros((len(library_df), 206))\n", + "\n", + "f1 = open(r1_name, 'rt')\n", + "f2 = open(r2_name, 'rt')\n", + "\n", + "#Iterate through reads sequenctially (r1 and r2)\n", + "\n", + "r1_counter = 0\n", + "while True :\n", + " \n", + " #Read 1\n", + " id1 = f1.readline().strip()\n", + " \n", + " #Check for end-of-file\n", + " if len(id1) == 0 :\n", + " break\n", + " \n", + " r1 = f1.readline().strip()\n", + " s1 = f1.readline().strip()\n", + " q1 = f1.readline().strip()\n", + " \n", + " #Read 2\n", + " id2 = f2.readline().strip()\n", + " r2 = f2.readline().strip()\n", + " s2 = f2.readline().strip()\n", + " q2 = f2.readline().strip()\n", + " \n", + " if r1_counter % 10000 == 0 :\n", + " print(\"Processing read \" + str(r1_counter) + \"...\")\n", + " \n", + " r1_counter += 1\n", + " \n", + " #Map read to library member\n", + " bc = r1[:20]\n", + " \n", + " lib_i = -1\n", + " if bc in barcode_dict :\n", + " lib_i = barcode_dict[bc]\n", + " \n", + " if lib_i == -1 :\n", + " continue\n", + " \n", + " if umi_n_muts == 0 :\n", + " bc = sequences[lib_i][:20]\n", + " \n", + " #Determine if we have seen this umi before, otherwise mark as visited\n", + " umi = r2[:8]\n", + " \n", + " if bc not in umi_dict :\n", + " umi_dict[bc] = {}\n", + " \n", + " umi_visited = False\n", + " if umi in umi_dict[bc] :\n", + " umi_visited = True\n", + " elif umi_n_muts == 1 :\n", + " for pos1 in range(len(umi)) :\n", + " for b1 in bases :\n", + " umi_mut = umi[:pos1] + b1 + umi[pos1+1:]\n", + " if umi_mut in umi_dict[bc] :\n", + " umi_visited = True\n", + " break\n", + " if umi_visited :\n", + " break\n", + " elif umi_n_muts == 2 :\n", + " for pos1 in range(len(umi)) :\n", + " for pos2 in range(pos1, len(umi)) :\n", + " for b1 in bases :\n", + " for b2 in bases :\n", + " umi_mut = umi[:pos1] + b1 + umi[pos1+1:pos2] + b2 + umi[pos2+1:]\n", + " if umi_mut in umi_dict[bc] :\n", + " umi_visited = True\n", + " break\n", + " if umi_visited :\n", + " break\n", + " if umi_visited :\n", + " break\n", + " if umi_visited :\n", + " break\n", + " \n", + " #Skip if umi already seen\n", + " if umi_visited :\n", + " continue\n", + " \n", + " #Determine polyA position (or alternative if the read is distally polyadenylated)\n", + " polya_match = re.search(polya_regexp, r1)\n", + " \n", + " polya_pos = -1\n", + " if polya_match is not None and polya_match.span()[0] < max_pos :\n", + " polya_pos = polya_match.span()[0]\n", + " \n", + " #Determine if distal read\n", + " is_distal = False\n", + " distal_match = re.search(distal_regexp, r1[209-5:209+20+5])\n", + " \n", + " if distal_match is not None :\n", + " is_distal = True\n", + " \n", + " #Aggregate read-position occurrence counts\n", + " if is_distal :\n", + " cuts[lib_i, -1] += 1.\n", + " \n", + " #Mark as seen and proceed\n", + " umi_dict[bc][umi] = True\n", + " \n", + " elif polya_pos != -1 and polya_pos >= 30 :\n", + " \n", + " #Perform hamming-based consistency check against reference of region upstream of cleavage\n", + " \n", + " hamming_dist = _hamming(sequences[lib_i][polya_pos-20:polya_pos], r1[polya_pos-20:polya_pos])\n", + " \n", + " if hamming_dist <= 3 :\n", + " cuts[lib_i, polya_pos] += 1.\n", + "\n", + " #Mark as seen and proceed\n", + " umi_dict[bc][umi] = True\n", + "\n", + "f1.close()\n", + "f2.close()\n", + "\n", + "print(\"Done!\")\n", + "\n", + "print(\"Total # of unique-UMI reads = \" + str(int(np.sum(cuts))))\n", + "\n", + "#Store processed read-position count matrix\n", + "np.save('apa_oligo_2022' + save_suffix + '_umi_mut_' + str(umi_n_muts) + '_cuts', cuts)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#Load processed read count data\n", + "\n", + "ref_cuts_repl_1 = np.load(\"apa_oligo_2022_ref_repl_1_sknsh_v3_umi_mut_0_cuts.npy\")\n", + "var_cuts_repl_1 = np.load(\"apa_oligo_2022_var_repl_1_sknsh_v3_umi_mut_0_cuts.npy\")\n", + "\n", + "ref_cuts_repl_2 = np.load(\"apa_oligo_2022_ref_repl_2_sknsh_v3_umi_mut_0_cuts.npy\")\n", + "var_cuts_repl_2 = np.load(\"apa_oligo_2022_var_repl_2_sknsh_v3_umi_mut_0_cuts.npy\")\n", + "\n", + "#Pooled counts\n", + "\n", + "ref_cuts_pooled = ref_cuts_repl_1 + ref_cuts_repl_2\n", + "var_cuts_pooled = var_cuts_repl_1 + var_cuts_repl_2\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#Augment library file with measured isoform summary statistics\n", + "\n", + "pseudo_c = 1.\n", + "\n", + "#Replicate 1\n", + "library_df['ref_count_77_127_repl_1'] = np.sum(ref_cuts_repl_1[:, 77:127], axis=-1)\n", + "library_df['ref_count_0_205_repl_1'] = np.sum(ref_cuts_repl_1[:, 0:205], axis=-1)\n", + "library_df['ref_count_total_repl_1'] = np.sum(ref_cuts_repl_1, axis=-1)\n", + "library_df['ref_logit_77_127_repl_1'] = np.log(\n", + " ((library_df['ref_count_77_127_repl_1'] + pseudo_c) / (library_df['ref_count_total_repl_1'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_77_127_repl_1'] + pseudo_c) / (library_df['ref_count_total_repl_1'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['ref_logit_0_205_repl_1'] = np.log(\n", + " ((library_df['ref_count_0_205_repl_1'] + pseudo_c) / (library_df['ref_count_total_repl_1'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_0_205_repl_1'] + pseudo_c) / (library_df['ref_count_total_repl_1'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['var_count_77_127_repl_1'] = np.sum(var_cuts_repl_1[:, 77:127], axis=-1)\n", + "library_df['var_count_0_205_repl_1'] = np.sum(var_cuts_repl_1[:, 0:205], axis=-1)\n", + "library_df['var_count_total_repl_1'] = np.sum(var_cuts_repl_1, axis=-1)\n", + "library_df['var_logit_77_127_repl_1'] = np.log(\n", + " ((library_df['var_count_77_127_repl_1'] + pseudo_c) / (library_df['var_count_total_repl_1'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_77_127_repl_1'] + pseudo_c) / (library_df['var_count_total_repl_1'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['var_logit_0_205_repl_1'] = np.log(\n", + " ((library_df['var_count_0_205_repl_1'] + pseudo_c) / (library_df['var_count_total_repl_1'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_0_205_repl_1'] + pseudo_c) / (library_df['var_count_total_repl_1'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['delta_logodds_true_77_127_repl_1'] = library_df['var_logit_77_127_repl_1'] - library_df['ref_logit_77_127_repl_1']\n", + "library_df['delta_logodds_true_0_205_repl_1'] = library_df['var_logit_0_205_repl_1'] - library_df['ref_logit_0_205_repl_1']\n", + "\n", + "#Replicate 2\n", + "library_df['ref_count_77_127_repl_2'] = np.sum(ref_cuts_repl_2[:, 77:127], axis=-1)\n", + "library_df['ref_count_0_205_repl_2'] = np.sum(ref_cuts_repl_2[:, 0:205], axis=-1)\n", + "library_df['ref_count_total_repl_2'] = np.sum(ref_cuts_repl_2, axis=-1)\n", + "library_df['ref_logit_77_127_repl_2'] = np.log(\n", + " ((library_df['ref_count_77_127_repl_2'] + pseudo_c) / (library_df['ref_count_total_repl_2'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_77_127_repl_2'] + pseudo_c) / (library_df['ref_count_total_repl_2'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['ref_logit_0_205_repl_2'] = np.log(\n", + " ((library_df['ref_count_0_205_repl_2'] + pseudo_c) / (library_df['ref_count_total_repl_2'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_0_205_repl_2'] + pseudo_c) / (library_df['ref_count_total_repl_2'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['var_count_77_127_repl_2'] = np.sum(var_cuts_repl_2[:, 77:127], axis=-1)\n", + "library_df['var_count_0_205_repl_2'] = np.sum(var_cuts_repl_2[:, 0:205], axis=-1)\n", + "library_df['var_count_total_repl_2'] = np.sum(var_cuts_repl_2, axis=-1)\n", + "library_df['var_logit_77_127_repl_2'] = np.log(\n", + " ((library_df['var_count_77_127_repl_2'] + pseudo_c) / (library_df['var_count_total_repl_2'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_77_127_repl_2'] + pseudo_c) / (library_df['var_count_total_repl_2'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['var_logit_0_205_repl_2'] = np.log(\n", + " ((library_df['var_count_0_205_repl_2'] + pseudo_c) / (library_df['var_count_total_repl_2'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_0_205_repl_2'] + pseudo_c) / (library_df['var_count_total_repl_2'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['delta_logodds_true_77_127_repl_2'] = library_df['var_logit_77_127_repl_2'] - library_df['ref_logit_77_127_repl_2']\n", + "library_df['delta_logodds_true_0_205_repl_2'] = library_df['var_logit_0_205_repl_2'] - library_df['ref_logit_0_205_repl_2']\n", + "\n", + "#Pooled replicates\n", + "library_df['ref_count_77_127_repl_pooled'] = np.sum(ref_cuts_pooled[:, 77:127], axis=-1)\n", + "library_df['ref_count_0_205_repl_pooled'] = np.sum(ref_cuts_pooled[:, 0:205], axis=-1)\n", + "library_df['ref_count_total_repl_pooled'] = np.sum(ref_cuts_pooled, axis=-1)\n", + "library_df['ref_logit_77_127_repl_pooled'] = np.log(\n", + " ((library_df['ref_count_77_127_repl_pooled'] + pseudo_c) / (library_df['ref_count_total_repl_pooled'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_77_127_repl_pooled'] + pseudo_c) / (library_df['ref_count_total_repl_pooled'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['ref_logit_0_205_repl_pooled'] = np.log(\n", + " ((library_df['ref_count_0_205_repl_pooled'] + pseudo_c) / (library_df['ref_count_total_repl_pooled'] + 2. * pseudo_c)) / (1. - ((library_df['ref_count_0_205_repl_pooled'] + pseudo_c) / (library_df['ref_count_total_repl_pooled'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['var_count_77_127_repl_pooled'] = np.sum(var_cuts_pooled[:, 77:127], axis=-1)\n", + "library_df['var_count_0_205_repl_pooled'] = np.sum(var_cuts_pooled[:, 0:205], axis=-1)\n", + "library_df['var_count_total_repl_pooled'] = np.sum(var_cuts_pooled, axis=-1)\n", + "library_df['var_logit_77_127_repl_pooled'] = np.log(\n", + " ((library_df['var_count_77_127_repl_pooled'] + pseudo_c) / (library_df['var_count_total_repl_pooled'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_77_127_repl_pooled'] + pseudo_c) / (library_df['var_count_total_repl_pooled'] + 2. * pseudo_c)))\n", + ")\n", + "library_df['var_logit_0_205_repl_pooled'] = np.log(\n", + " ((library_df['var_count_0_205_repl_pooled'] + pseudo_c) / (library_df['var_count_total_repl_pooled'] + 2. * pseudo_c)) / (1. - ((library_df['var_count_0_205_repl_pooled'] + pseudo_c) / (library_df['var_count_total_repl_pooled'] + 2. * pseudo_c)))\n", + ")\n", + "\n", + "library_df['delta_logodds_true_77_127_repl_pooled'] = library_df['var_logit_77_127_repl_pooled'] - library_df['ref_logit_77_127_repl_pooled']\n", + "library_df['delta_logodds_true_0_205_repl_pooled'] = library_df['var_logit_0_205_repl_pooled'] - library_df['ref_logit_0_205_repl_pooled']\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#Cache measurements in dataframe\n", + "\n", + "library_df.to_csv(\"apa_100_variants_rev2_20220621_sknsh_v3_umi_mut_0.csv\", sep='\\t')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jlinder2/anaconda3/envs/tensorflow/lib/python3.6/site-packages/ipykernel/__main__.py:4: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/jlinder2/anaconda3/envs/tensorflow/lib/python3.6/site-packages/ipykernel/__main__.py:7: RuntimeWarning: invalid value encountered in true_divide\n", + "/home/jlinder2/anaconda3/envs/tensorflow/lib/python3.6/site-packages/ipykernel/__main__.py:10: RuntimeWarning: invalid value encountered in true_divide\n" + ] + } + ], + "source": [ + "#Compute cleavage probabilities\n", + "\n", + "ref_cut_prob_repl_1 = ref_cuts_repl_1 / np.sum(ref_cuts_repl_1, axis=1)[:, None]\n", + "var_cut_prob_repl_1 = var_cuts_repl_1 / np.sum(var_cuts_repl_1, axis=1)[:, None]\n", + "\n", + "ref_cut_prob_repl_2 = ref_cuts_repl_2 / np.sum(ref_cuts_repl_2, axis=1)[:, None]\n", + "var_cut_prob_repl_2 = var_cuts_repl_2 / np.sum(var_cuts_repl_2, axis=1)[:, None]\n", + "\n", + "ref_cut_prob_pooled = ref_cuts_pooled / np.sum(ref_cuts_pooled, axis=1)[:, None]\n", + "var_cut_prob_pooled = var_cuts_pooled / np.sum(var_cuts_pooled, axis=1)[:, None]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "delta_logodds (repl 1) = 1.1978\n", + "delta_logodds (repl 2) = 1.1273\n", + "delta_logodds (pooled) = 1.0435\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAADQCAYAAAAasZepAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xl8XHW9//HXp2mT7gvdoBst0FYKIktZ5F6RChTqLdQFpbihck1R0asWFa5XRH9e915cQKUKAqICImqNhQJSFRSQlrJDS4FC0y1dadM2aZbP74/vSeZkMpOcNGlmcng/H488cuacM+d85+S085nPfL7fr7k7IiIiIiIS9Cp0A0REREREiokCZBERERGRGAXIIiIiIiIxCpBFRERERGIUIIuIiIiIxChAFhERERGJUYAs8jplZjea2dej5beY2cpCt6nQzMzN7IhCtyPOzL5uZlvMbGOh21JMzOx0M6tsY3vz/S0i0lEKkEWKmJmtMbO9ZlZtZhujN/2BXX0ed3/A3ad29jhRe8/sxPMvNbNlZlZrZjd28Lk3mtk+M9sV/TxtZt80syH72ZZOBVhmdpWZ3bK/z4+OMR6YD0xz94M7c6z9PH+bQWgXn+vDZvaUme2J7vWfmNnQ7jh3VzCzhWa20swazezD7ez7XjP7Z/Ra/5pj+7nR/Vsd7Tcttu2n0fqmn1oz2xXbPtHMFpvZ9ug6XmNmvbvytYq8HihAFil+57r7QOBY4DjgigK350BaD3wduGE/n/8ddx8EjAQ+ApwC/MPMBnRR+7rbocBWd6/q6BN7UlBkZvOBbwOfB4YQ/m6HAveaWWkh29YBTwCfAB5LsO824PvAt7I3mNlk4FfAJcBQ4E/Aoqa/p7tf4u4Dm36A3wC/jR3ix0AVcAjh/4y3Ru0SkQ5QgCzSQ7j7RmAJ4U0PADMrM7PvmdmrZrYpyi71i7adbmaVZvbf0Vf0a8zs/bmOnZ0pNLPxZnanmW02s61mdk20/nAzuz9at8XMftWU5TOzXwITgD9Fma0vROtPibJgO8zsCTM7vY3XeKe7/wHY2slrVePujwLnAcMJwXLTa/uomT0XZdiWmNmhOa5HOfB+4AvRa/lTtP5yM3sxylA/a2bvTNIeC642syoze83MnjSzo6NtQ8zs5uhav2Jm/2NmvaJM/L3AmKgNN0b7n2dmz0TX869mdmTsPGvM7Itm9iSw28x6R+s+H51zt5ldb2ajzeyu6HXcZ2bDOnqN87U72lZiZguie+RlC98MeK6g3cwGA18FPuXud7t7nbuvAd5LCJI/EO3Xz0JWf7uZPQucmHWc48zsseg13Qb0jW0bYWYV0TXbZmYPNLW1q7j7te7+F6Amwb73ufvthA+E2c4GHnD3B929nvDBYSwh0G0h+uD3buCm2OpJwO3Rv4GNwN3AUR1+QSKvcwqQRXoIMxsHzAJWx1Z/G5hCCJqPILyRXhnbfjAwIlp/EbDQzNospTCzEqACeAWYGD331qbNwDeBMcCRwHjgKgB3/yDwKlHG292/Y2ZjgT8TssIHAZcBvzOzkR2+APvB3XcRgsy3RK/tHcB/A+8iZJkfIGTgsp+3kJDF+070Ws6NNr0YHWsIIai7xcwOSdCUmcBphL/VUOACMh8CfhQd7zBCEPQh4CPufh/h770+asOHzWxK1N7PRO1fTPhAEs+yXgj8BzA0CrAgBFFnRec/F7grug4jCO8Dn07wGrLlbHe07WNR248Fjgfe0cZxTiUEs3fGV7p7ddTOs6JVXwEOj37OJtzPAESv/w/ALwn32W8Jr7nJfKCScM1GE16752pM9EFiR56fH7fxOrqKRT/Zj4/Ose+7gc3A32PrfgDMNbP+0b+/WYQgWUQ6QAGySPH7g4Uaw7WEr06/AiErSQhEPuvu26Jg8BvA3Kznf9nda939b4Rg9b3tnO8kQgD8eXffHWWiHgRw99Xufm90vM3A/5EjsxXzAWCxuy9290Z3vxdYBry9A6+/s9YTgiaAecA33f25KHj8BnBsrixyLu7+W3dfH72W24AXCNerPXXAIOANgEXn3xB9GLkAuMLdd0WZ0wXAB/Mc5wLgz9HfoA74HtCPEGQ2+aG7r3X3vbF1P3L3Te6+jvCh4BF3X+HutcDvCaU7iSVo93uBH7h7pbtvJ0cpQcwIYEssmI/bEG1vOub/Rvf6WuCHsf1OAfoA348y0HcAj8a21xFKDg6Ntj/g7jkDZHc/xt2H5vnpjlKFe4G3Rt/qlBKC+VKgf459LwJuznotfyNkjHcSPhQsI3x4EJEOUIAsUvzeEdXVnk4IsJoChpGEN83lTRkuQqYonp3d7u67Y49fIQS/bRkPvJIrYDGzUWZ2q5mtM7OdwC2x9uRyKPCeeBYO+HdCsNJdxhJqPpva84NYW7YRsnNjkxzIzD5kZo/Hnn80bb9+ANz9fuAa4Fpgk4UOXYOj55YS/i5NXmmjPWPi+7p7I+GDU3z/tTmetym2vDfH4452/Gyv3WOy2pGrTU22ACNylV8Q7pMteY4ZP/cYYF1WoBjf/l3CNy/3mNlLZnZ5G+0pKHd/nhD4XkPmA8KzhGC3mYUOnG8Fbo6t60Uow7oTGBA9dxjhmyYR6QAFyCI9RJQBvpGQNYQQOOwFjopluIZEHXeaDLOWHdQmkLvuMW4tMCFPwPJNwlfTx7j7YEKGOP51cHZWbi3wy6ws3AB3byuj2GUsjPhxJiFr2tSeeVnt6efu/8zx9BavJcoy/wy4FBju7kOBp2n5+vNy9x+6+wmE7N4UQoe0LYTsZjyDPQFYl+cw6+P7Rt8ijM/aP2dmtIu11+4NwLjYtvFtHOshoJZQ9tIsum9nAX+JHTN+nAmx5Q3A2Oh6tNoeZbnnu/thhBKTz5nZGbkaE9V3V+f5+Wkbr6PLuPsd7n60uw8nfGN0KC0z4hBKWv7p7i/F1h1EuEbXRN/ybAV+Qfd+YyOSCgqQRXqW7wNnmdmxUfbwZ8DVZjYKwMzGmtnZWc/5qpmVmtlbgNm07PGey78IAce3zGyAmfU1s3+Ltg0CqoEdUX3j57Oeu4lQk9rkFuBcMzs76rjVN/rqeBw5RJ3K+gIlQNP+HR6NwULnxRMIXy1vJwQJAD8FrjCzo6L9hpjZe/IcJvu1DCAEn5uj536E3HWhudpzopmdbGZ9gN2EjlwN7t4A3A78r5kNioLwzxGuWy63A/9hZmdEx5pPCC5zBfhdJvo7NP8Aje20+3bgv6L7cSjwxXzHdvfXCPXcPzKzc8ysj5lNJNynlYS64qZjXmFmw6L751OxwzwE1AOfju6hdxErfTGz2WZ2RBRA7wQaop9c7TkqPkpE1s8lbVyj0ujaGNAnulY532Ob/i0AvYFe0b59YttPiPYZCVwH/CnKLMd9iPCBOd72LcDLwMej6zCUkI1+Il+7RSQ3BcgiPUhU93sz8OVo1RcJXx0/HJU83AfEO+FtJASI64mGjsrxRpt9jgZClu0IQqe7SkK9KYRA5njgNUI9851ZT/8m8D9RCcJlUa3oHEId5WZCBvfz5P+/538IWfHLCdnpvdE6zGxClMWbkOe5EEad2EUonbgZWA6c2lRm4u6/J3zdfGt0vZ4mZClzuR6YFr2WP7j7s4Q624cIwfMbgX+00Za4wYQPM9sJX/1vJfNNwKcIQfNLwIPAr8kzzJ27ryRclx8RsrjnEjpF7kvYjv0xlvB3iP8c3k67fwbcAzwJrCB0Jqwnf1D6HcI98j1CAPsI4V45I6qThnDvvUIIAO8hEzgTvf53AR8mXOMLaHlvTib826gm/P1+7O5/7fCVaNs9hGtzKrAwWj4NwMzeb2bPxPb9YLT9J4ROn3sJ16zJD4AdwMro98fiJzKzNxMy9Lk+7L4LOIfw72014bp/tnMvTeT1x/L0UxCRHs7CcGq3uHvObK1IdzGzWcBP3T1RZ0gRkUJTBllERLqUhTGL3x59zT+WUEf7+0K3S0QkKQXIIiLS1YxQErGdUGLxHC3H5xYRKWoqsRARERERiVEGWUREREQkJtHwSWZ2DqFXbQnw8+wxTM3sNMLwU8cAc6NZjJq2XUTUCx34urvH54xvZcSIET5x4sTEL0BEJA1WrlwJwNSpbc4E3uPOJSJSTJYvX77F3Ue2t1+7AbKFKUWvBc4iDPf0qJktioY8avIqYXidy7KeexChc8Z0wvihy6Pnbs93vokTJ7Js2bL2miUikiozZswAYOnSpak6l4hIMTGzV9rfK1mJxUnAand/KRpr8lbCuKbN3H2Nuz9JGDw+7mzgXnffFgXF9xLGZxQRERERKUpJSizGEgZsb1IJnJzw+LmeOzbhc0VEXje6M5urzLGISNuSZJAtx7qkQ18keq6ZlZvZMjNbtnnz5oSHFhERERHpekkC5EpgfOzxOMK0tUkkeq67L3T36e4+feTIduumRUREREQOmCQB8qPAZDObZGalwFxgUcLjLwFmmtkwMxsGzIzWiYhITHl5OeXl5ak7V8FtWwVr7oHGhkK3RER6kHZrkN293swuJQS2JcAN7v6MmX0NWObui8zsRMI0osOAc83sq+5+lLtvM7P/RwiyAb7m7tsO0GsREemxXnjhhVSeq6B2VcJNR0FjPZx+NZzwmUK3SER6iETjILv7YmBx1rorY8uPEsoncj33BuCGTrRRRESk49b9IwTHAGv/qgBZRBLTTHoiIpJODTWx5drCtUNEehwFyCIikk71CpBFZP8oQBYRkXSKB8XxYFlEpB0KkEVEJJ1aZJAVIItIcok66YmIyIE1e/bsVJ6roFSDLCL7SQGyiEgRmD9/firPVVAqsRCR/aQSCxERSSd10hOR/aQAWUSkCKxatYpVq1al7lwFFQ+QlUEWkQ5QiYWISBGYN28eAEuXLk3VuQoqnjVWJz0R6QBlkEVEJJ3USU9E9pMCZBERSad4WUVjPTQ2FK4tItKjKEAWEZF0yi6rUBZZRBJSgCwiIulUnxUQq6OeiCSkAFlERNKpVQZZAbKIJKMAWURE0ik7Y6wSCxFJSMO8iYgUgeuuuy6V5yqo7IBYJRYikpACZBGRIjBlypRUnqug1ElPRPaTSixERCSdsjPGyiCLSEIKkEVEisCCBQtYsGBB6s5VUNkZY3XSE5GEFCCLiBSBiooKKioqUneuglInPRHZTwqQRUQknbIzxiqxEJGEFCCLiEj6uEPDvpbrlEEWkYQUIIuISPrkCoaVQRaRhBIFyGZ2jpmtNLPVZnZ5ju1lZnZbtP0RM5sYre9jZjeZ2VNm9pyZXdG1zRcREckhVzCsTnoiklC7AbKZlQDXArOAacCFZjYta7eLge3ufgRwNfDtaP17gDJ3fyNwAjCvKXgWERE5YHIFw/UqsRCRZJJMFHISsNrdXwIws1uBOcCzsX3mAFdFy3cA15iZAQ4MMLPeQD9gH7Cza5ouIpIekydPTuW5CiZXiYUyyCKSUJIAeSywNva4Ejg53z7uXm9mrwHDCcHyHGAD0B/4rLtvyz6BmZUD5QATJkzo4EsQEen5Fi5cmMpzFUzOEgtlkEUkmSQ1yJZjnSfc5ySgARgDTALmm9lhrXZ0X+ju0919+siRIxM0SUREpA25AmR10hORhJIEyJXA+NjjccD6fPtE5RRDgG3A+4C73b3O3auAfwDTO9toERGRNmkUCxHphCQB8qPAZDObZGalwFxgUdY+i4CLouXzgfvd3YFXgbdZMAA4BXi+a5ouIpIeM2bMYMaMGak7V8HkqjdWiYWIJNRugOzu9cClwBLgOeB2d3/GzL5mZudFu10PDDez1cDngKah4K4FBgJPEwLtX7j7k138GkRERFrSMG8i0glJOunh7ouBxVnrrowt1xCGdMt+XnWu9SIiIgdUzlEslEEWkWQ0k56IiKSPOumJSCcoQBYRkfTJOVGIAmQRSUYBsoiIpE+uWfNUYiEiCSlAFhGR9Mk5ioUyyCKSTKJOeiIicmDNnz8/lecqGM2kJyKdoABZRKQIzJ49O5XnKhjVIItIJ6jEQkRE0kcz6YlIJyhAFhEpAhUVFVRUVKTuXAWjEgsR6QSVWIiIFIEFCxYA3VP+0J3nKhjNpCcinaAMsoiIpI9m0hORTlCALCIi6aNOeiLSCQqQRUQkffJNNe3e/W0RkR5HAbKIiKRPznIKh8b6bm+KiPQ8CpBFRCR98pVTqKOeiCSgAFlERNInXyBcr456ItI+DfMmIlIEli5dmspzFYwyyCLSCcogi4hI+uQb0k0jWYhIAgqQRUQkfeKBsMXe6jQWsogkoABZRKQIlJeXU15enrpzFUy8lKJsSO71IiJ5qAZZRKQIvPDCC6k8V8HEM8WlQ6Bme1hWJz0RSUAZZBERSZ96ZZBFZP8pQBYRkfTJV2KhTnoikoACZBERSRf3lqUUpfEMskosRKR9iQJkMzvHzFaa2WozuzzH9jIzuy3a/oiZTYxtO8bMHjKzZ8zsKTPr23XNFxERydJYB3hY7tUH+vTPbFMGWUQSaDdANrMS4FpgFjANuNDMpmXtdjGw3d2PAK4Gvh09tzdwC3CJux8FnA7UdVnrRUREssWD4JIy6B3LyyiDLCIJJBnF4iRgtbu/BGBmtwJzgGdj+8wBroqW7wCuMTMDZgJPuvsTAO6+tYvaLSKSKrNnz07luQoiHgT37huC5OZtyiCLSPuSBMhjgbWxx5XAyfn2cfd6M3sNGA5MAdzMlgAjgVvd/TvZJzCzcqAcYMKECR19DSIiPd78+fNTea6CaJFB7ht+cm0TEckjSQ2y5VjnCffpDfw78P7o9zvN7IxWO7ovdPfp7j595MiRCZokIiKSRzxL3CqDrBILEWlfkgC5EhgfezwOWJ9vn6jueAiwLVr/N3ff4u57gMXA8Z1ttIhI2qxatYpVq1al7lwF0VYNsjLIIpJAkgD5UWCymU0ys1JgLrAoa59FwEXR8vnA/e7uwBLgGDPrHwXOb6Vl7bKIiADz5s1j3rx5qTtXQWTXIKuTnoh0ULs1yFFN8aWEYLcEuMHdnzGzrwHL3H0RcD3wSzNbTcgcz42eu93M/o8QZDuw2N3/fIBei4iISI4aZHXSE5GOSdJJD3dfTCiPiK+7MrZcA7wnz3NvIQz1JiIicuC1qEEuUyc9EekwzaQnIiLpEi+jaJVBVomFiLRPAbKIiKRLfdYoFuqkJyIdpABZRETSpUEz6YlI5yhAFhGRdKlvq8RCGWQRaV+iTnoiInJgXXfddak8V0G0mihEJRYi0jEKkEVEisCUKVNSea6CaDVRiDrpiUjHqMRCRETSJXuiEGWQRaSDFCCLiBSBBQsWsGDBgtSdqyCyJwpRJz0R6SAFyCIiRaCiooKKiorUnasgWtUgq5OeiHSMAmQREUmXVjXI8RILZZBFpH0KkEVEJF1a1SArgywiHaMAWURE0qUhqwZZnfREpIMUIIuISLq0VWKhTnoikoACZBERSZdWJRalLbe5d3+bRKRH0UQhIiJFYPLkyak8V0HUZ41iYb1CkNywL6xr2Ndy8hARkSwKkEVEisDChQtTea6CaMgqsWj63Rwg1yhAFpE2qcRCRETSJT6UW1MHPXXUE5EOUIAsIiLpkj1RSPw3qKOeiLRLAbKISBGYMWMGM2bMSN25CiJ7FIv47+ztIiI5KEAWEZF0yR7FIv47e7uISA4KkEVEJF2yJwoBzaYnIh2iAFlERNIle5g3UCc9EemQRAGymZ1jZivNbLWZXZ5je5mZ3RZtf8TMJmZtn2Bm1WZ2Wdc0W0REJI9cNcjxYd1UYiEi7Wg3QDazEuBaYBYwDbjQzKZl7XYxsN3djwCuBr6dtf1q4K7ON1dERKQduWqQlUEWkQ5IkkE+CVjt7i+5+z7gVmBO1j5zgJui5TuAM8zMAMzsHcBLwDNd02QREZE8GuvBG8KylUCvaD4sddITkQ5IMpPeWGBt7HElcHK+fdy93sxeA4ab2V7gi8BZgMorRETymD9/firP1e1ylVdkL+9PJ71Ny+GlxTDtAzBk0v63T0R6hCQBsuVY5wn3+SpwtbtXRwnl3CcwKwfKASZMmJCgSSIi6TJ79uxUnqvb5SqvgM6VWNTXwp1vhz1VsGYJXPhg59ooIkUvSYBcCYyPPR4HrM+zT6WZ9QaGANsImebzzew7wFCg0cxq3P2a+JPdfSGwEGD69OnZwbeIiEgyuUawgM510tu5JgTHABsfAW8E0yBQImmWJEB+FJhsZpOAdcBc4H1Z+ywCLgIeAs4H7nd3B97StIOZXQVUZwfHIiICFRUVQPdkd7vzXN2uIV+JRScyyNWxnFBjfQiWBxy8f+0TkR6h3QA5qim+FFgClAA3uPszZvY1YJm7LwKuB35pZqsJmeO5B7LRIiJps2DBAqB7gtbuPFe3i2eH40FxZzrp7d7Q8vGuSgXIIimXJIOMuy8GFmetuzK2XAO8p51jXLUf7RMREUkuX4lFPJvcmQwyhAD54Okdb5uI9BgqohIRkfSozzHNdPZyR0exyM4gV1d2vF0i0qMoQBYRkfSIB7/xjnmd6aSXK4MsIqmmAFlERNIjXw1yZzrptcogr+t4u0SkR1GALCIi6ZF3mLfM8obKbWzcuDv5MVViIfK6owBZRETSI8FMen/9ywsceeQN7NyZsNRCJRYirzuJRrEQEZEDa+nSpak8V7fLN5NebLlv7zp27Kjl4Yc3MHPmxLaPt28X1FW3XFddCe7QxgyxItKzKYMsIiLp0ZBvFItMBrmsdwMAVVV72j9e9YbW6+proGbb/rZQRHoABcgiIpIeeUssYhnkPnVAwgA5u/64icosRFJNAbKISBEoLy+nvLw8defqdglKLMpK6oGkGeT1edZrJAuRNFMNsohIEXjhhRdSea5ul3eikEw2uW+fDgTI+TLIGslCJNWUQRYRkfTIO1FIvJPefgbI8Yy0SixEUk0BsoiIpEfeiULinfRCgLxpU4KxkOMlFiOPyywrQBZJNQXIIiKSHvkmCinpggzywSdmllViIZJqCpBFRCQ98tUgxzvpNQfIe3H3to8XzyAfclJmWRlkkVRTgCwiIumRrwY53kkvCpBrauqprq5r+3jxDPLoeAZZo1iIpJlGsRARKQKzZ89O5bm6Xb4a5N6tx0GGUGYxaFBp7mPV7YZ9O6NjlcKwI0Kg3VAb1tfuhLLBXdl6ESkSCpBFRIrA/PnzU3mubpevBrlXn+bFPiWN9LJGGr0XVVV7OPzwobmPFZ9Fb8AhYL1g0DjY8WK0fZ0CZJGUUomFiIikR0OemfTMqKnPBMmJRrLYnRUgAwwcl1mnOmSR1FKALCJSBFatWsWqVatSd65uV5+nxALYW5f50rQsyUgW8Q56A8eE34NiAbJGshBJLZVYiIgUgXnz5gGwdOnSVJ2r2zXkLrHYvXsftXUl0C88TjTUmzLIIq9bCpBFRCQ96nOXWFRV7cFiJRaJpptuN4OskSxE0kolFiIikh7xUSxiGeRNm/ZQWx8rsSjpggyySixEUksBsoiIpEeeiUI2bdpDTSxAbhrqre0AOZZBbgqQB43NrFOJhUhqJQqQzewcM1tpZqvN7PIc28vM7LZo+yNmNjFaf5aZLTezp6Lfb+va5ouIiMTkmSikqiorg9y7AQiBc17xYd6aSixUgyzyutBugGxmJcC1wCxgGnChmU3L2u1iYLu7HwFcDXw7Wr8FONfd3whcBPyyqxouIiLSSp6JQjZt2t0yg9w7SQY5R4lF/1HQKzpOzVao29vpJotI8UmSQT4JWO3uL7n7PuBWYE7WPnOAm6LlO4AzzMzcfYW7N31H9QzQ18zKEBERORDyTBRSVbWHmrp4gBxqkLdu3Ut9fWPr49TthdodYblXH+g3PFougQFjMvupo55IKiUZxWIssDb2uBI4Od8+7l5vZq8BwwkZ5CbvBla4e23WczGzcqAcYMKECYkbLyKSFtddd10qz9WtGhugsWkaaWsxe96mTXuoHZh5yxs5LOSH3EOQPHr0gJbHapE9PjjMotdk0DjY9WpYrl4XpqAWkVRJEiBbjnXekX3M7ChC2cXMXCdw94XAQoDp06dnH1tEJPWmTJmSynN1qxYjWJSBZd6aqqr2UFOWCZhHDe/VYlurALk6Rwe9JhrJQiT1kpRYVALjY4/HAevz7WNmvYEhwLbo8Tjg98CH3P3FzjZYREQkpzz1xxBqkGvrS5ofDx/WMkBuZXeODnpNBqmjnkjaJQmQHwUmm9kkMysF5gKLsvZZROiEB3A+cL+7u5kNBf4MXOHu/+iqRouIpM2CBQtYsGBB6s7VrfLUHwNUVe2lJjZRyIghmexyzpEscnXQa6IAWST12g2Q3b0euBRYAjwH3O7uz5jZ18zsvGi364HhZrYa+BzQNBTcpcARwJfN7PHoZ1SXvwoRkR6uoqKCioqK1J2rWzXknkWvrq6BrVv3thjF4qAhmV1zZpBzzaLX/Dg2FrJKLERSKdFU0+6+GFicte7K2HIN8J4cz/s68PVOtlFERKR99blLLDZvDkOxxcdBHjqoZX1yK21lkDUWskjqaSY9ERFJh4b8Q7wBLYZ5GzLQW21voa1OevESi7aGeXOHx34A//gy7Ktuu+0iUlQSZZBFRESKXn3uEotNm3YDUNuQecsb3L+dALmtTnoDDiEM3uSweyM01EFJH1pZ/UdY+pmwbL3h1K8kfSUiUmDKIIuISDq0GOat7QzyoH4Nrba3sLuNDHJJnzA2MhCC5A3k9Op9meXKv7bVchEpMgqQRUQkHVp00otPMx0FyLFRLAb0bYxt393yOPU1ULM9LFsJ9B/Z+lxJRrLY+GhmuerxUHIhIj2CSixERIrA5MmTU3mubpWnxKIpQxwfB7l/WRsZ5N0bM8vZs+g1GTiOMAoquUeyaNgHmx/PPK7dATvXwJBJ7b0KESkCCpBFRIrAwoULU3mubpWnxKIpQxzPIPexOsrKSqitbWDPnnp2797HgAGlYWNbHfSaxDPIr61pvX3zkyFIjqtaoQBZpIdQiYWIiKRDnolCMhnkTE7IGmoZNap/q32AtjvoNRk+LbO8/p+tt8fLK5pP8njrdSJSlBQgi4hIOrRXgxzrpEdDTVaAvDezLUcGeffufTzwQCU1NfVh/bjTM/tU/g0aMyUbQJ4AeUWilyEihacAWUSkCMxPA4BfAAAPOElEQVSYMYMZM2ak7lzdKu8wb02d9Hq32DdpBnnjxt288Y03cdppt/KRj9wd1h80NTOSRe0O2PxEy7ZsUoAs0pMpQBYRkXTIUYPs7jlLLMgqsWgxksXOV5oX60pH8c53/oGXX34NgNtue55t2/aCGYyPfchYuzSzXLcbtj4bPbBMsF69DvZs3v/XJyLdRgGyiIikQ44a5O3ba6ivD0O6lZT2y2xvqGH06BwZZPcWwe63rt/Dww9nMsru8Je/vBoe5AuQNz0GHg0jN3wajDwms011yCI9ggJkERFJh4bWJRbx0okBgwdmttfn6aS3+YnmEou9DOaqn9a3Os0996wJC/EAufLv0Bjtu/FfmfUHnwijjss8VpmFSI+gAFlERNKhPlZiEXXSa6o/Bhg4dFBme6tOetF+L9/VvO6Pjx9Go4e3yTe/OTOaxT33rMHdYejh0XjIwL5dIXMMLTvoZQfIm5VBFukJFCCLiEg6NLQusYhnkAcNHZzZnq+TXixAXvzcVABOPXUM9957PoMHh3GSX311FytXbgt1yBNylFm0FSArgyzSIyhAFhGRdMgxikW8893Q4UMy23ONg1yzo8WYxktWTmX8+EHceeccBgwo5YwzDm3eds89UUe+7DrkvVvhtZfC4159YMQxMOKNmdn4tq0MnfhEpKhpJj0RkSIwf/78VJ6rW+UYxSKeQR46Mh4g12SNYrEHXr0PPIxnvGztOKqqB/Gv+89j9OgBAMyceSi///0LQCiz+PSnj28ZIK97ENY/lHk88k3QOxrBYthU2PYc4LD5KRhzShe8YBE5UBQgi4gUgdmzZ6fyXN0qx0Qh8Rrkg0YMgaYYur6WkSMzAfKWLXtpfGlx89eqi59/A2972wROPDEz1fTMmRObl5cufZXa2nrKhkyEwRNh55qQGX7ix5k2HHxSZnnUcVGATCizUIAsUtRUYiEiIumQY5i3eIA8fPTQzPaGGkr79GLYsLBfY2Mj/tLdzZvven4qH//4m1oc/rDDhnL44eEYe/bU89BD0Yx78SxyrIaZg0/MLKsOWaRHUYAsIlIEKioqqKioSN25ulWOGuR4icXI0YPBSsIDb4TG+uYyi2MO2UDJ3jC829bd/VlbdyRz5hzR6hQzZ+aoQ56QZ1bCg0+kqmo3r7zyGow6NrNeI1mIFD0FyCIiRWDBggUsWLAgdefqVjlqkOOd9EaPHtBiCup4R71Zb3i+efU9q6bw0YvfRJ8+Ja1OcfbZk5qXlyxZExbG5wiQ+wzgb08P4PDDf85hh/2cm+7uk9m25anMmMkiUpQUIIuISDrkqEGOZ5BHjerfHDgD0VBvYXa9WW9Y2bx6yco38LGPxWa/i5kxYzwlJQbAY49tYvPmPTBoHAxtmW3eO+RNvPv8P1NdXUdjo3PxJ5dR02dM83nZ9nz2oUWkiKiTnoiIFJV9+xr43e9WsWbNzhbr+/XrzXnnHc5hhw3N/cSsEos9e+qorq4DoLS0hKFDy3JmkAf33cu/TVyTWT/pbMaPj42ZHDN4cBlvfvMYHnxwHQD33fcKF154ZMgi71jdvN9tfx3E1q17M6dqcJY+M5xZU6K65arHYcTR7VwJESkUBcgixah2JzzzC9jwL5g0C6a+F0pKC90qkQNu6dJX+eQn7+O557Y1r+vXZx8fPGE5px32Mt/97REccsY8Pn/FafTrFytbaKgLs9k16d23VfbYzFpmkKOh3s6c/AK9SxqBMLzb+/7z9DbbOHPmxOYA+Z571mQC5Kd+1rzP4hUjgUxgXlW1h3+tGc2sKU+FHapWwLQPdOTS9Djr1u1i0aIX6dOnF+9612QOOqhfoZskkliiANnMzgF+AJQAP3f3b2VtLwNuBk4AtgIXuPuaaNsVwMVAA/Bpd1/SZa0XSZsdL8KKH8HTN2Te7J//Nfz9C3DsJ+GYcug/srBtFElgw4Zqli3bxLJlG9m2rYajjx7B9OmjOfroEZSVtX7r2bChmssu+xu//vVzzevGDtnBJ0/9J+WnPMLwASHYff/xK9iy+8/c8NG3MvWCL3Hm2W+AJxfC49dA9frm566vquOPSzIZ3eYxj+MZ5PoaRo8ewLhYecXDm97EJ87MdMTLZebMiVx55T+A0FHP3bHxp7fY59G14wH42c9mMnXqQbz1rbeyYt3Y5u2+aQWWddx9+xp4+uktLFu2kaee2sKwYWVMn34w06cfzJgxA9tsU3uqq/exYkUVy5dvYtWqbUyYMJjp0w/mhBNGN4/k0RUaG517713DT3/6BH/604s0NDgAn/rU/bz3vVO45JJjOeWUQ8KHFZEiZu7e9g5mJcAq4CygEngUuNDdn43t8wngGHe/xMzmAu909wvMbBrwG+AkYAxwHzDFPRqJPYcjDxngN334yE6+LJGep1/vGo4a8iy9LP+/ydqGUp5+bRoNja07D0nP9vFfhyDtJ++b2qPP1eiwa+c+ampzd0LrZcagwaX0LWt5D2/dVkN9fWPz44F9Gzht0ouUWN63C+oaetFICWUldS3Wv7B1NFO/9TncM91sZs2axOLF74abj8uMIjH2LWzY1pv+2x5iSL9QnvFr/znvu+ziNl9jQ0MjI0Zcy44doVPgzJkTKS3txZeO+ganjFzOgy9P5C3XfoLLLjuR7373dABuueVZvvTpX/HKl74BQE19KU/ueGPzMWtrG9i5cx+Ned6Ty8pKGDyolF69Oh5Y7tlTz67qfXm3D+jfhwED+tAVMeuuXXXs2VvX5j6DBpbSv7++wJbu86Yv/42y/mHCHzNb7u7T23tOkjv0JGC1u78UHfhWYA7wbGyfOcBV0fIdwDUWPh7OAW5191rgZTNbHR0vNtVQSwN67+GkEcsTNEsk3Z7dNIq7n5/K3GOfYMyQUItZVrKPEw7SEFFpNDiqFuiO//8O+Ln250uOEe1sHzIJP/wdVK+4jUEeMsV9ShqBTFC9cedAfvzQqVzz4L+1CI4BzmzKCveOfc2/7gEOAYhWbdvTj7MvuaDdppaU9OLMMw/ljjtWAaHMAmDJXedz/Ng3s2LdWM45ZxLf+tZpzc/5wAem8dRTZ7Ftz9Uc1H8vfXvva339x9Lztfd3FCmAPXUdHzUmSQb5fOAcd//P6PEHgZPd/dLYPk9H+1RGj18ETiYEzQ+7+y3R+uuBu9z9jqxzlAPl0cOjgac7/Epkf40AthS6Ea8TutbdR9e6++hadx9d6+6l6919uvNaH+ru7X6MT5JBzvWlS3ZUnW+fJM/F3RcCCwHMbFmS1Ld0DV3v7qNr3X10rbuPrnX30bXuXrre3acYr3WScZArgfGxx+OA9fn2MbPewBBgW8LnioiIiIgUjSQB8qPAZDObZGalwFxgUdY+i4CLouXzgfs91G4sAuaaWZmZTQImA//qmqaLiIiIiHS9dkss3L3ezC4FlhCGebvB3Z8xs68By9x9EXA98MuoE942QhBNtN/thA599cAn2xrBIrJw/1+O7Add7+6ja919dK27j65199G17l663t2n6K51u530REREREReT5KUWIiIiIiIvG4oQBYRERERiSmqANnMzjGzlWa22swuL3R70sTMxpvZUjN7zsyeMbP/itYfZGb3mtkL0e9hhW5rWphZiZmtMLOK6PEkM3skuta3RZ1epZPMbKiZ3WFmz0f395t1Xx84ZvbZ6P+Qp83sN2bWV/d21zCzG8ysKppboGldznvZgh9G75dPmtnxhWt5z5PnWn83+n/kSTP7vZkNjW27IrrWK83s7MK0umfKda1j2y4zMzezEdHjormviyZAjqa0vhaYBUwDLoymqpauUQ/Md/cjgVOAT0bX93LgL+4+GfhL9Fi6xn8Bz8Uefxu4OrrW24G257OVpH4A3O3ubwDeRLjmuq8PADMbC3wamO7uRxM6bs9F93ZXuRE4J2tdvnt5FmFkqMmEibZ+0k1tTIsbaX2t7wWOdvdjgFXAFQDRe+Vc4KjoOT+OYhZJ5kZaX2vMbDxwFvBqbHXR3NdFEyATm9La3fcBTVNaSxdw9w3u/li0vIsQRIwlXOObot1uAt5RmBami5mNA/4D+Hn02IC3EaZiB13rLmFmg4HTCCPp4O773H0Huq8PpN5Av2jM+/7ABnRvdwl3/zthJKi4fPfyHOBmDx4GhprZId3T0p4v17V293vcvWlO4ocJczdAuNa3unutu78MrCbELJJAnvsa4GrgC7ScQK5o7utiCpDHAmtjjytJx8z0RcfMJgLHAY8Ao919A4QgGhhVuJalyvcJ//Abo8fDgR2x/3x1f3eNw4DNwC+icpafm9kAdF8fEO6+DvgeIeOzAXgNWI7u7QMp372s98wD66PAXdGyrnUXM7PzgHXu/kTWpqK51sUUICeallo6x8wGAr8DPuPuOwvdnjQys9lAlbsvj6/Osavu787rDRwP/MTdjwN2o3KKAyaqf50DTALGAAMIX4lm07194On/lAPEzL5EKEv8VdOqHLvpWu8nM+sPfAm4MtfmHOsKcq2LKUDWtNQHmJn1IQTHv3L3O6PVm5q+voh+VxWqfSnyb8B5ZraGUCr0NkJGeWj0tTTo/u4qlUCluz8SPb6DEDDrvj4wzgRedvfN7l4H3Amciu7tAynfvaz3zAPAzC4CZgPv98xEEbrWXetwwofsJ6L3yXHAY2Z2MEV0rYspQE4ypbXsp6gG9nrgOXf/v9im+DThFwF/7O62pY27X+Hu49x9IuE+vt/d3w8sJUzFDrrWXcLdNwJrzWxqtOoMwsyduq8PjFeBU8ysf/R/StP11r194OS7lxcBH4p6/Z8CvNZUiiH7x8zOAb4InOfue2KbFgFzzazMzCYROpD9qxBtTAN3f8rdR7n7xOh9shI4Pvr/vGju66KaSc/M3k7ItDVNaf2/BW5SapjZvwMPAE+RqYv9b0Id8u3ABMKb33vcPVcxvewHMzsduMzdZ5vZYYSM8kHACuAD7l5byPalgZkdS+gMWQq8BHyE8OFf9/UBYGZfBS4gfAW9AvhPQo2g7u1OMrPfAKcDI4BNwFeAP5DjXo4+oFxDGB1gD/ARd19WiHb3RHmu9RVAGbA12u1hd78k2v9LhLrkekKJ4l3Zx5Tccl1rd78+tn0NYWScLcV0XxdVgCwiIiIiUmjFVGIhIiIiIlJwCpBFRERERGIUIIuIiIiIxChAFhERERGJUYAsIiIiIhKjAFlEREREJEYBsoiIiIhIzP8HnOtdHMi0bXgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Control: F2 variant (creation of new cutsite -1bp relative to reference)\n", + "\n", + "save_figs = True\n", + "fig_name = \"F2_control_profile_sknsh\"\n", + "\n", + "test_ix = 9\n", + "\n", + "#Plot range\n", + "plot_start = 0\n", + "plot_end = 146\n", + "\n", + "#Isoform definition\n", + "cut_start = 77\n", + "cut_end = 127\n", + "\n", + "c_ref_1 = ref_cut_prob_repl_1[test_ix, :]\n", + "c_var_1 = var_cut_prob_repl_1[test_ix, :]\n", + "\n", + "c_ref_2 = ref_cut_prob_repl_2[test_ix, :]\n", + "c_var_2 = var_cut_prob_repl_2[test_ix, :]\n", + "\n", + "c_ref_pooled = ref_cut_prob_pooled[test_ix, :]\n", + "c_var_pooled = var_cut_prob_pooled[test_ix, :]\n", + "\n", + "delta_logodds_1 = np.log(np.sum(c_var_1[77:127]) / (1. - np.sum(c_var_1[77:127]))) - np.log(np.sum(c_ref_1[77:127]) / (1. - np.sum(c_ref_1[77:127])))\n", + "delta_logodds_2 = np.log(np.sum(c_var_2[77:127]) / (1. - np.sum(c_var_2[77:127]))) - np.log(np.sum(c_ref_2[77:127]) / (1. - np.sum(c_ref_2[77:127])))\n", + "delta_logodds_pooled = np.log(np.sum(c_var_pooled[77:127]) / (1. - np.sum(c_var_pooled[77:127]))) - np.log(np.sum(c_ref_pooled[77:127]) / (1. - np.sum(c_ref_pooled[77:127])))\n", + "\n", + "print(\"delta_logodds (repl 1) = \" + str(round(delta_logodds_1, 4)))\n", + "print(\"delta_logodds (repl 2) = \" + str(round(delta_logodds_2, 4)))\n", + "print(\"delta_logodds (pooled) = \" + str(round(delta_logodds_pooled, 4)))\n", + "\n", + "#Plot replicate 1 profile\n", + "f = plt.figure(figsize=(10, 3))\n", + "\n", + "plt.plot(c_ref_1[plot_start: plot_end], color='darkblue', linewidth=3)\n", + "plt.plot(c_var_1[plot_start: plot_end], color='darkorange', linewidth=3)\n", + "\n", + "plt.axvline(x=70, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "plt.axvline(x=76, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "\n", + "plt.xlim(plot_start, plot_end)\n", + "plt.ylim(0.)\n", + "\n", + "plt.title(\"Replicate 1. Delta Isoform Log Odds = \" + str(round(delta_logodds_1, 4)))\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_repl_1.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_repl_1.eps\")\n", + "\n", + "plt.show()\n", + "\n", + "#Plot replicate 2 profile\n", + "f = plt.figure(figsize=(10, 3))\n", + "\n", + "plt.plot(c_ref_2[plot_start: plot_end], color='darkblue', linewidth=3)\n", + "plt.plot(c_var_2[plot_start: plot_end], color='darkorange', linewidth=3)\n", + "\n", + "plt.axvline(x=70, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "plt.axvline(x=76, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "\n", + "plt.xlim(plot_start, plot_end)\n", + "plt.ylim(0.)\n", + "\n", + "plt.title(\"Replicate 2. Delta Isoform Log Odds = \" + str(round(delta_logodds_2, 4)))\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_repl_2.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_repl_2.eps\")\n", + "\n", + "plt.show()\n", + "\n", + "#Plot pooled replicate profile\n", + "f = plt.figure(figsize=(10, 3))\n", + "\n", + "plt.plot(c_ref_pooled[plot_start: plot_end], color='darkblue', linewidth=3)\n", + "plt.plot(c_var_pooled[plot_start: plot_end], color='darkorange', linewidth=3)\n", + "\n", + "plt.axvline(x=70, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "plt.axvline(x=76, linewidth=2, linestyle='--', color='black', alpha=0.75)\n", + "\n", + "plt.xlim(plot_start, plot_end)\n", + "plt.ylim(0.)\n", + "\n", + "plt.title(\"Pooled replicates. Delta Isoform Log Odds = \" + str(round(delta_logodds_pooled, 4)))\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_pooled.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_pooled.eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "len(filtered_df) = 95\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAARgAAAEYCAYAAACHjumMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xl8VOX1+PHPyUIgIFtABGSRoohaiorVry3KroAoigouiLaK1KIiiMSqaNVqRQW0RZQK4kKi1p8LgoICRWiR2qBStRbFJaCyhM0sEJJJzu+Pe5MOIcskmcm9M3Per9e8MnPnLmcmM2fOfe69zyOqijHGREKC1wEYY2KXJRhjTMRYgjHGRIwlGGNMxFiCMcZEjCUYY0zEWILxARFZKCL3ex2HMeEWNwlGRC4XkSwRyReRbSLytoj8Mgzr9U1yEJELRORjEckVkV0islJEunodV6wQkZNEZLn73tZ4ApmI9BaRDSKy3/3buyHirA0ROUVE1rjfix0icnM41x8XCUZEJgOzgQeAdkBn4AngggbYdlKkt+FupzvwHDAFaAEcg/MaSxti+0FxNMjrDVWY4ykGXgZ+HcJ2GwFvAC8ArYBngTfc6b4gIm2AZcBTQBrQHXgnrBtR1Zi+4XzZ8oFLqpknBScB/eDeZgMp7nP9gO9wvrg7gW3ANe5z43E+dEXuNt50p38LTAP+DRwEkoCewGpgH/AZcH7Q9hcC97v32wBL3Pn2AGuBBPe5J4AnqngNFwMfV/Ma7wFeAV4C8oAPgZ8FPd8B+H9ADvANcFPQcz8H3ndj2gb8GWgU9LwCvwW+BL4JmnaDOy0PuA/4ibueXJwvaiN33lbua84B9rr3jw5a/2p3+X+463oHaFPF6yz7f00DtgPPR+Az1d356lQ7zxDge0CCpm0Bzg1xGwpMcN+/vcCc4HWF6XU8EIn355BtRHLlfrgB5wIBIKmaee4F1gNHAm2BdcB97nP93OXvBZKBYcB+oJX7fHlyCFrft8DHQCegibvcZuB3QCNggPtF6VFxHcCDwJPuMslA31A+WEA3oBCYBfQHmlV4/h6cZHixu95b3USSjFPJbgCmu/F1A74GznGXPRU4AydRdgU+ByZV+DK8C7QGmgRNWww0B07ESbQr3XW3AP4DjHPnTQNGAanAEcBfgdeD1r8a+Ao4zn0/VwN/rOJ9KPt/PYTzw9Gkknl+iZMsq7r9sob3OpQEcwvwdoVpS4ApIX5u1Z2/JU7FnUMVyQm4vIbX07mK5VYBj+F83ncCb1Y1b52/f15++RviBlwBbK9hnq+AYUGPzwG+DfrAHiAoQbn/jDPc+wupPMH8KuhxX5xf04SgaZnAPRXXgZPI3gC61+G1noFTGeTgJJuFuIkGJ8GsD5o3Aaca6QucDmypsK7bgWeq2M4k4LWgxwoMqDCPAr8IerwBmBb0+FFgdhXr7w3sDXq8Grgz6PENwLIqlu2HU1E2juBnKpQEcxfwYoVpi8r+5yFsQwlKdO7/NT3Mr+MLNwGdBjQGHgf+Ec5txEMbzG6gTQ374h2A7KDH2e608nWoaiDo8X6gWQ3b3Vph/VtVNbg9JBvoWMlyD+NUO++IyNcikl7Ddsqp6npVvVRV2+IkjrOAOyqLyY3lOze2LkAHEdlXdsOpttoBiMhxIrJERLaLSC5Oad2mmtdbZkfQ/QOVPG7mrj9VRJ4SkWx3/WuAliKSGDT/9qD7Nb3/OapaWM3zDSEfp3oL1hyncg1VbV5zXRzA+aH4l/t+/R44U0RahGsD8ZBg3sf5NR9ZzTw/4HzJynR2p4WiqqMJwdN/ADqJSPD73RlnH/3QhVTzVHWKqnYDRgCTRWRgiLEEr+dfwKvASUGTO5XdcWM52o1tK07bScug2xGqOsydfS7wX+BYVW2Ok3ykmtdbW1OAHsDp7vrPKguzjuurNhYR6eseNanq1reO2w32GdBLRIJfQy93eliJyBU1vJ7OVSz6bw59r8ru1/V9P0zMJxhV/RGnbWGOiIx0fy2TRWSoiMxwZ8sE7hSRtm7L+nSc1v9Q7MBpV6jOP4EC4DZ32/1wkseLFWcUkfNEpLv7wcwFStxb2SHxhZVtQER+KSLXiciR7uPjgfNx2pbKnCoiF7nV3CScdpH1wAdArohME5EmIpLoHpI9zV3uCDeWfHe9v6nh9dbWETi/pvtEpDVwd5jXfwhVXauqzaq5ra1sOXE0xmmnQkQai0hKFZtZjfN/u0lEUkRkojt9lbvs1SLybZhez6IaXs+WKhZ9BrjQPZyejLNb93dV3ReOuCAOEgyAqs4EJgN34rRPbAUmAq+7s9wPZOFk9E9wjrCEem7LfOAEd9fi9cpmUNUinC/7UGAXztGgq1T1v5XMfiywAqfEfh/nqNFq97lOOEdSKrPP3cYnIpKPc/jxNWBG0DxvAKNxjkqMBS5S1WJVLcFJeL1xGn53AU/jNMaC0yB8OU55/xecI1HhNBun8XYXTsJbFub1h0sXnERYVoUcADaVPemeW/U7KP+fjwSuwvnf/AoY6U6H6v+XDUJVV+FUo0tx2hW74/yfw0bcxh7jc+75ExuBXqpaXIfl78FpOL4y3LGZ2hORd4CbVfVzr2OJJF+dFGWq5v7y9fQ6DhMeqjrE6xgagm93kUTkWBEpFJFQ20KMMT7j210kt4RsAmRbWW9MdPJlBSMiY3AaxlZ6HYsxpu581wYjIs1xzmYdSDUXlYnIeJxrgWjatOmpxx9/fMMEaIxhw4YNu9wTOqvluwSDc1HbfFXdeug5SodS1XnAPIA+ffpoVlZWA4VnTPwpLC4kURJJTkoGQESya1gE8FmCcfvLGASc7HUsxhhHwcECRs4ZSZtmbXjh2hdITEiseSGXrxIMzoVqXYEtbvXSDEgUkRNU9RQP4zImLuUV5jH88eGs/XIt7Zq347u939ElrUvNC7r8lmDmcejp87fiJJxwn5pujKnBvv37GPrYUNZ/vZ6OLTuycsrKWiUX8FmCUdX9OFeNAuCe8l6oqjneRWVM/Nmdv5shs4bw4ZYP6ZLWhVVTVtGtbU2X3B3OVwmmIlW9x+sYjIk3O3N3MnDmQD79/lO6H9mdlZNX0jmtqguyq+frBGOMaXhNU5rSKrUVxx91PCunrKRDyw41L1QFSzDGmEM0TWnKkhuXUFhcyJHNj6zXunx5Jq8xpmFt3rmZGzNuJFDidNzYvEnzeicXsArGmLj3+bbPGfjoQLb9uI12zdtx53l3hm3dlmCMiWMbt25k8KzB5OTl0K9HPyYNmhTW9dsukjFxKuvbLPo/0p+cvByGnDCEpTcupVnj8PYrbgnGmDi0bvM6Bs4cyN79exnxsxEsnriY1JTUsG/HEowxceihZQ+ReyCXS069hFcmvEJKclV9l9ePtcEYE4cyrsvg8ZWPM/WcqSQlRi4NWAVjTJx4/6v3KQ44/cU3TWnK7cNuj2hyAUswxsSFVza8wlkPn8UVT19BSWlJg23XEowxMW7R+kWMfmo0gZIAXdt0JUEa7mtvCcaYGDZ/7XzGLhhLqZYy/bzpPDTqIarrKTLcrJHXmBg1529zmJjhjFj7wIUPcPuw2xs8BkswxsSgVza8Up5cZo2eFfYzdENlCcaYGDTspGH079GfS/tcyoR+EzyLwxKMMTFCVSkpLSEpMYnUlFTenfxurTrojgRr5DUmBqgqU16ewiVPXlJ+rovXyQWsgjEm6pWWljIxcyJzV88lOTGZDdkbOOMnZ3gdFmAJxpioVlJawnXPXccz/3iGlKQUXr3hVd8kF7AEY0zUCpQEGLdgHBkfZJDaKJXFExczsOdAr8M6hCUYY6JQUaCIy/5yGa9++CrNUprx1k1v0fe4vl6HdRhLMMZEoVItJfdALi2atGDZzct8tVsUzBKMMVGocXJj3vjtG3yz6xtO7Hii1+FUyQ5TGxMl8grzuOv1uygKFAGQmpLq6+QCVsEYExWCx4neXbCbJ654wuuQQmIJxhifCx4numtaV24dcqvXIYXMEowxPrYjdweDZg4qHyd61ZRVdGrdyeuwQmYJxhif+n7v9wycOZBN2zfRs31PVk5eSfuW7b0Oq1askdcYHwkEAsyYMYNAIMB9S+5j0/ZN9Dq6F6tvXR11yQWsgjGmwQUCAWbOnMnkyZNJSjr0K5iRkcG0adNo3749s0bPIiU5hbtH3E3rpq09irZ+RFW9jqHe+vTpo1lZWV6HYUxInnvuOcaNG8dzzz3H2LFjy6cHAgE69OhAzrc5dDiqA9nZ2YclIL8QkQ2q2qem+WwXyZgGFAgESE9PByA9PZ1AIFD+3B//8kd2nbkLBsKP+T+SmZnpVZhh46sEIyIpIjJfRLJFJE9EPhKRoV7HZUy4ZGRkkJeXB0Bubm55EvnnV/9k+vrpaGOFRCgoKDgsAUUjXyUYnDahrcDZQAvgLuBlEenqYUzGhEVZ9ZKfnw9Afn4+6enprNm0hv4P90cbKWQD7wAlhyagaOWrBKOqBap6j6p+q6qlqroE+AY41evYjKmv4OqlzJ7GexgycwgHSg7A18BKoNR5riwBRXMV46sEU5GItAOOAz6r5LnxIpIlIlk5OTkNH5wxtVCxegGgDRSeVcjB0oMkfZMEf6M8uZSJ9irGtwlGRJKBRcCzqvrfis+r6jxV7aOqfdq2bdvwARpTC5VVL+wBtgObILAyAJUc0I32KsaXCUZEEoDngSJgosfhGFMvlVYv4FQr7wJrq18+mqsY3yUYcca1nA+0A0aparHHIRlTL4dUL92BIfzvmxfCOPTRXMX4LsEAc4GewAhVPeB1MMbUxyHVSw+c46Odga61W0+0VjG+SjAi0gW4HugNbBeRfPd2hcehGVMn5dVLT6AvIMC/cI4Y1UK0VjG+SjCqmq2qoqqNVbVZ0G2R17EZU1vl1csx+fALd+L7wMa6rW/nzp1RV8X480IHY2LAokWL2NF+B5ziTvgH8Hn1y4gIP//5z+natWulz7duHV0XPVqCMSZCWqW1ol2vdmzX7ZxWeBrH9DoGetW83NixYxk+fHjkA2wAlmCMiZDzzzufIecM4e9f/p1BJwzyOhxP+KoNxphoV1payp9X/ZnC4kLAGV4kXpMLWIIxJmxKSkv49bO/5sbMG7ny6Su9DscXbBfJmDAoDhQz7plxZH6QSZNGTZhw9gSvQ/IFSzDG1FNRoIgx88bw2kev+XqcaC9YgjGmHgqLC7l47sUs/WQpLVNbsuzmZZze7XSvw/INSzDG1MMjyx9h6SdLSWuWxru3vMvJnU/2OiRfsQRjTD1MPWcqX+V8xZQhUzip40leh+M7lmCMqaV9+/fRKLERqSmppCSn8Mw1z3gdkm/ZYWpjamF3/m4GPjqQkU+MLD/XxVTNEowxIdqRu4N+j/Tjwy0f8s2ub9hTsMfrkHzPdpGMCUHFcaJXTF5Bh5YdvA7L9yzBGFOD7N3ZDHh0AF/nfE2vo3vx7i3vcmTzI70OKypYgjGmGt/t+Y6+M/qydc9W+nTpw/JblkftONFesARjTDXaNW/HKZ1PoVOrTrx101u0SG3hdUhRxRKMMdVITkrmpfEvUVxSTLPGzbwOJ+rYUSRjKtiQvYGL517MgSKnz/mU5BRLLnVkFYwxQd7/6n3Ofexccg/kcnLnk7lj+B1ehxTVrIIxxvXepvcYPGswuQdyueTUS7jtnNu8DinqWYIxBnjns3cY+vhQCg4WMPaMsWRcl0FyUrLXYUU9SzAm7r258U1G/HkEB4oOcF3f61h4zUKSEq31IBwswZi4l/lBJkWBIm4ccCNPjX2KhAT7WoSLpWkT9xZes5AhJwxh3JnjcIZGN+FiqdrEpcUfL6bgYAEAjZIacfUvrrbkEgGWYEzcmfO3OVww5wIumHMBJaUlXocT0yzBmLjy6DuPMjFjIgDn9TqPxIREjyOKbdYGY+LG/Uvu56437gJg7hVzmdDPhhaJNKtgTMxTVe587U7ueuMuEiSBZ65+hgn9JhAIBJgxYwaBQMDrEGOWJRgT8zI/yOQPb/2BxIREFl27iKt/cTUAGRkZTJs2jczMTG8DjGGiql7HUG99+vTRrKwsr8MwPlUcKGbsgrGM7jOaC0+5EIBAIEDnzp3Ztm0bHTp0IDs7m6QkazEIlYhsUNU+Nc0XUgUjIpV2PioiO2sbmDENoaS0pPwwdHJSMi+Of7E8uYBTveTl5QGQm5trVUyEhLqLdNhFGSKSDIS9CV5EWovIayJSICLZInJ5uLdholtNbSfFgWLGzh/LsMeHsf/g/kqXT09PJz8/H4D8/HzS09OtLSYCqk0wIrJWRNYAjUVkTfAN2ASsi0BMc4AioB1wBTBXRE6MwHZMlKqu7aQoUMToeaPJ/CCTD7M/ZNOOTZUuX1a9lLEqJjKqbYMRkXGAAHOB4GN6CuwAVqlqcdiCEWkK7AVOUtUv3GnPA9+ranpVy1kbTPyoru2ksLiQUXNH8dYnb1U5TnTw8hVZW0zowtIGo6rPqupC4GT3ftntOVVdHs7k4joOKClLLq6NwGEVjIiMF5EsEcnKyckJcxjGr6pqOyk4WMB5fzqPtz55i7RmaayasqrSQegrq17KWBUTflVWMCIyVlWfd+//qqoVqOqCsAUj0hf4q6oeFTTtOuAKVe1X1XJWwcSHyqqPDh068Nmmzzj/ifNZ++Va2jVvx4rJKyodJ7q66iV4fVbF1CzUCqa6d/Ey4Hn3/tgq5lEgbAkGyAeaV5jWHKj8J8fElaraTl5/9XXat2hPx5YdWTllJT2O6hHy8hWVVTFjx1b1kTe14avzYILaYE5U1S/dac8BP1gbTHyrqe1k89eb2V2wm6NbH13r5Stbn1Ux1Qv3eTAJld3qH+ahVLUAeBW4V0SaisgvgAv4XyVl4tRh1UcToC+Q5FQdr7z8SpXJpdLlq2FtMeETUgUjIqU4u0MVBYAfcJLC3aqaX++ARFrj7HYNBnYD6aqaUd0yVsHEtsOqj1RgGNAS+C/w9+qrjtpUL2WsiqleWCsY4EZgFTAE6AmcA6wEbgN+A5wJzK5bqIdS1T2qOlJVm6pq55qSi4l9h1QfzYDzcJLLbsD9Xamu6sjIyKC2Rxp37txpVUwYhJqeJwOnqOqP7uMvRCQL2KCqPxGRT4ANEYnQxLVDzrptjlO5NANygGXAQWe+srNxL7vsssOqjrS0NEaNGlXrbbdubWNQ11eoCaY5TmH6Y9C0VKBsoN7tOHvFxoRVefXSEhgKNMU5xXMZUOEsrKqOAA0fPpzhw4c3TMDmEKHuIj0HvCsi14nIuSJyLbAceNZ9fgjOpQPGhM0h1UtPnOTyA/A2hyUXsGuK/CjUCmYq8CUwBugAbMO5Zugv7vN/A1aHOzgT3w5pO1kPFACfAdV0o1vWdmLnsfhDSAlGVUuBJ91bZc8XhjMoYwD2Ju7l/FHnkxx8MX/PmpezthP/CPkYnIhcg3NGb0fge+B5VX0mUoGZ+LZ602rueP8Oep/cm+WTltM0panXIZk6CCnBiMgdwFXAo0A20AW4TUQ6qOofIhifiUPvfPYOF8y5gMLiQo5pcwwpSSleh2TqKNQK5lqgn6pml00QkeXAGsASjAmbNze+ycVPXkxRoIhr+17Lk1c+aUOLRLFQjyI1xTnzINhu7NC0CaO/Zv2Vi+ZeRFGgiIn9J/LUlU9ZcolyoSaYZcAiEekhIk1E5HicQ9TLIxeaiSfrNq9jzLwxBEoCTD1nKo9f9rgNQh8DQt1Fmgj8Gafzp2ScsxBeBm6KUFwmzpze7XTGnDaG7kd2557z77FxomNErbprcK+gbgPsUtVSEemmql9HLLoQ2cWO0as4UExyknMYurS01KqWKBHuix0B53wYVd3pJpcUnJPvjKmTR5Y/wlkPn0VeoXMhoyWX2FPf/6jVsaZO7l9yP1Nfmcr6r9ez8vOVXodjIqS+nV34pzs8ExVUlTtfv5MH3nqABElgwdULGHnySK/DMhFivemYBqOqTHl5CrNWzCofJ3r0aaO9DstEULUJRkS2UnWVYrtHJmSlpaVMzJzI3NVzSU5M5qXxLx0ylKuJTTVVMFc2SBQmLuw/uJ+UpBReveFVhv10mNfhmAbgq1EF6soOU0eHktISPv3+U37W6Wdeh2LqKSKHqY2pjaJAEb979Xfs278PgMSEREsuccYaeU1EFBYXcvHci1n6yVI2freRpTct9Tok4wFLMCbsCg4WMHLOSFZ8voK0ZmncP/J+r0MyHqlxF0lEEkVktXvmrjHVyivMY+hjQ1nx+QraNW/He7e+x8mdT/Y6LOORGisYVS0RkWOw9hpTg3379zH0saGs/3o9HVt2ZNWUVRx31HFeh2U8FGrS+D0wV0S6uBVNxIaPNdFr7uq5rP96PV3TurLmtjWWXEzIbTBPu3+Du2oXnJPwrEcgA8Bt595GbmEuN/S7gU6tO3kdjvGBUBPMMRGNwkSt7/d+T2qjVFo1bUViQiIPXvSg1yEZHwl12JLsmucy8SZ7dzYDHh1AWtM0VkxeQfMmzb0OyfhMbYYtOR84G6fDqfLrkFT1qgjEZXxu887NDHh0AFv3bKV1amsCpTaaojlcSI20InI38JQ7/yU4HX6fA+yLXGjGrz7f9jlnzTiLrXu2cuZPzmTF5BW0bmqDnZnDhXoU6FfAYFW9BShy/44AukYqMONP//7u35z98Nls+3Eb/Xv0Z/mk5bRIbeF1WManQt1Faqmqn7r3i0QkWVU/EJGzIxWY8Z9vcr6h/yP92VOwh3NOPIfXbniNJo1s5BpTtVATzFcicqKqfgZ8CvxGRPYCe8MRhHuW8BPAIKA1sBn4naq+HY71m/DoktaFkb1Hsit/Fy9f/zIpyXZyt6leqAnmTiDNvZ8OZADNgBvCGMdWnEbkLcAw4GUR+amqfhumbZg6UlVEhISEBOZdNY/S0tLykQCMqU61bTBlZ+qq6luqusa9/4GqdlfVo1T11XAEoaoFqnqPqn7rjlywBPgGODUc6zd1985n79B3Rt9Dulyw5GJCVVMj7/ciMkNETmqQaFwi0g44DvismnnGi0iWiGTl5FQc1daEw5sb32TEn0fwj83/YN6aeV6HY6JQTQlmAs5ZvP8SkQ9F5GYRaRvJgEQkGVgEPKuq/61qPlWdp6p9VLVP27YRDSkuVRwn+tYht3odkolC1SYYVX1DVS8B2uOcB3MJsFVEFovIKDcZ1Mjt7kGruP09aL4E4HmgCGe4WuOBF9a/YONEm7AI6VOjqvtU9SlV/SXQE8gCZgHbQly+n6pKFbdfAogzGPF8oB0wSlWL6/SKTL08vfZprlpwFaVayvTzpvPQqIdsnGhTZ7Xq0c49nHwacDpOIlgXxljm4iSvQap6IIzrNbWwIXsDqsoDFz7A7cNu9zocE+VCGlVARH4JXAVcCuzE2Y15LlwXQYpIF+Bb4CAQfFHL9aq6qKblbVSB8CktLeXd/7zLOSed43UoxsfCMqqAiNwjIl8Bb7qThqvqcap6XzivsFbVbHd3qbGqNgu61ZhcTP2oKk+99xS783cDzgD0llxMuNTUBnMGcAfQXlXHq+o/GiAm00BUlTteu4MJL0xg2OPDKCkt8TokE2OqbYNR1XMbKhDTsFSVyS9PZvaK2SQmJHLLoFtITLDOCU142bAlcai0tJTfZvyWJ9970saJNhFlCSbOlJSWcO2z17Jw3UIbJ9pEnCWYOJPxzwwWrltIk0ZNWPzbxQw6YZDXIZkYZgkmzlx5xpV8uOVDLjr5Ivoe19frcEyMswQTBwqLC8kvzKfNEW0QEWaNnuV1SCZO2AUmMa7gYAEj/jSCgTMHsqdgj9fhmDhjCcZHAoEAM2bMIBAITw/9uQdyy8eJ3pG7gx25O8KyXmNCZQnGRzIyMpg2bRqZmZn1Xte+/fsYMmsIa79cS8eWHXlv6nv0bN8zDFEaEzpLMD4RCARIT08HID09vV5VzK68XQx4dAD//OafdEnrwprb1tDjqB7hCtWYkFmC8YmMjAzy8vIAyM3NrXMV8+P+H+n/aH8+2vIR3Y/szpqpa+jWtls4QzUmZJZgfKCsesnPzwcgPz+/zlVM8ybNOfu4s+nZvidrpq6hc1rncIdrTMgswfhAcPVSpq5VjIjw+JjHWZe+jvYt24crRGPqxBKMxypWL2VqU8Vs3rmZYY8NY1feLsDpcqFlasuIxGtMbViC8Vhl1UuZUKqYsnGi3/70be54/Y5IhGhMnYXUo53fRWuPdoFAgM6dO7NtW9VdG3fo0IHs7GySkg4/6Xrj1o0MnjWYnLwc+vfoz+KJi2nWuFkkQzYGCFOPdiayqqteylRVxWR9m0X/R/qTk5fDuSedy9KbllpyMb5jFYxHQqleylSsYtZtXsfQx4eSeyCXC3pfwEvjX7Jxok2DsgrG50KpXspUrGKW/HsJuQdyubTPpfz1+r9acjG+ZRWMB2pTvZQJrmJUlefff57LT7+cpES7IN40PKtgfCwjI4Pajqe9PWk7Tz77JOCc63LVmVdZcjG+Z59QD6SlpTFq1KiQ59+atJX3G7/Po/95lHGF4zii8RERjM6Y8LEE44Hhw4czfPjwkOZdtH4RVy24ClXl0v+7lGYpdqTIRA/bRfKx+WvnM3bBWEq1lLtH3M0fR/3Rxok2UcUqGJ+a87c5TMyYCMCDFz1I+tB0jyMypvYswfjQmi/WlCeX2aNnc/Ogmz2OyJi6sQTjQ32P7cukQZM4/qjjuf7s670Ox5g6swTjE6pK7oFcWqS2sJ7/TcywRl4fKBsn+v/++H/szN3pdTjGhI0lGI+VlpZyw6IbmL1iNpt3bubjrR97HZIxYWO7SB6qbJzoIScO8TosY8LGEoxHigPFjHtmHJkfZJLaKJXFExczsOdAr8MyJqx8uYskIseKSKGIvOB1LJEQKAkw5i9jyPwgkyMaH8Gym5dZcjExya8VzBzgX14HESmJCYkc0+YYWqa2ZNnNyzi92+leh2RMRPiughGRMcA+YKXXsUSKiPDwxQ+zcfpGSy4mpvkqwYhIc+BeYEoI844XkSwRyapt1wdeyCvM45pnrmH7j9sBJ8nYmEUm1vkqwQD3AfNVdWtNM6rqPFXto6p92rZt2wCh1d2+/fsYPHMwC9ctZNyCcV6HY0yDabAEIyKrRUSruP1dRHr40gGrAAAK50lEQVQDg4CYOoU1eJzormldmXvlXK9DMqbBNFgjr6r2q+55EZkEdAW2uF0SNAMSReQEVT0l4gFGwPYftzN41mA+/f5Tuh/ZnVVTVtGpdSevwzKmwfjpKNI84MWgx7fiJJzfeBJNPX235zsGzhzIFzu+oGf7nqycvNKGcjVxxzcJRlX3A/vLHotIPlCoqv5vwa3ES1kv8cWOL+h1dC/eveVdjmx+pNchGdPgfJNgKlLVe7yOoT4mD55McmIyV55xJa2btvY6HGM84dsEE40+3/Y5zRs3p2OrjogINw28yeuQjPGU3w5TR62NWzdy9sNnM+DRAdblgjEuSzBhEDxOdNe0rtbzvzEuSzD1tG7zOgbOHMje/XsZ8bMRLJ64mNSUVK/DMsYXLMHUw+pNqxkyewi5B3K55NRLeGXCKzZOtDFBrJG3jr7a+RVDHxtKYXEhY88Yy4KrF9hQrsZUYN+IOurWths3D7yZ3QW7eerKp0hIsGLQmIoswdRSUaCIRkmNEBEevOhBABtt0Zgq2M9uLbyw/gV6/b4XP+z7AXASiyUXY6pmCSZET699mqsWXMWm7Zt47aPXvA7HmKhgCSYEc/42h+ueuw5V5cGLHuS3/X/rdUjGRAVrg6nBI8sfYeorUwGYNXoWkwZN8jgiY6KHJZhq3LfkPqa/MR2AuVfMZUK/CR5HZEx0sQRTjUBJgARJYMHVCxh3pnV1aUxtWYKpxj3n38OFJ19I7869vQ7FmKgUs428gUCAGTNmEAgEQl6mtLSUu9+4m617nD7HRcSSizH1ELMJJiMjg2nTppGZmRnS/CWlJfz62V9z75J7Oe9P51FSWhLhCI2JfTGZYAKBAOnp6QCkp6fXWMUUB4oZO38sC9ctJLVRKrMunUViQmJDhGpMTIvJBJORkUFeXh4Aubm51VYxRYEiRs8bXT5O9PJJyxnQc0BDhWpMTBNV9TqGeuvTp49mZWUBTvXSuXNntm3bVv58hw4dyM7OJinp0DbtwuJCLp57MUs/WUrL1JYsn7Scnx/z8waN3ZhoJCIbVLVPTfPFXAUTXL2UqaqKefXDV1n6yVLSmqWxasoqSy7GhFlMVTCVVS9lqqpiZiybwfCfDufEjic2VLjGRL24rGAqq17KlFUx+/bvY8vuLeXTbzv3NksuxkRIzFQw69evr7J6KdOuSzva/6o9uYW5vHfrexzd+ugGjNKY2BF3FUx11QsATSDntBw+3voxCZKAEv2J1Ri/i4kK5tRTT9Vt27ZVXb2kAsOAlpCUl8TXc76mU5oNQm9MXcVVBbNnz56qq5dmwHlAS2A3pKxIYfVbqxsuOGPiWExUMI0aNdLi4uJKngAuwkkyO4HlwMGqjygZY0ITVxVMpckFoAjYBOwA3gYOOpN37twZ8jVKxpi6i4mf8FatWjFkyJDyx4oiSPn9UkpJvOjQa4tat27doDEaE49iIsF069aNF198EXDGiR7//Hheu+E1uqR18TgyY+JbTOwilSkbJ/qjLR/xyPJHvA7HmLgXMwmm4jjRMy+d6XVIxsQ9XyUYERkjIp+LSIGIfCUifUNZLvdALkMfG0rBwQLGnjGWjOsySE5KjnS4xpga+KYNRkQGAw8Bo4EPgPahLrs5ZzNarFzb91obJ9oYH/FNggF+D9yrquvdx9+HuqCqMrH/RB4b85glF2N8xBcn2olIInAAmA5cCzQGXgemquqBKpYZD4x3H54EfNoAoYZLG2CX10HUgsUbedEWcw9VPaKmmfySYDrgVCwbgBFAMfAGsFpV7whh+axQzir0C4s3sqItXoi+mEONt0H2J0RktYhoFbe/41QvAH9S1W2quguYiXOJojEmSjVIG4yq9qtpHhH5DqwPBWNiiZ9aRJ8BbhSRI0WkFTAJWBLisvMiF1ZEWLyRFW3xQvTFHFK8vmiDARCRZOAx4HKgEHgZuE1VCz0NzBhTZ75JMMaY2OOnXSRjTIyxBGOMiZiYSjB1vZbJayJyrIgUisgLXsdSFRFJEZH5IpItInki8pGIDPU6rmAi0lpEXnP//9kicrnXMVUnGt7TqoT6mfXTpQL1Up9rmXxgDvAvr4OoQRKwFTgb2IJzjtLLIvJTVf3Wy8CCzMHpx7Ad0BtYKiIbVfUzb8OqUjS8p1UJ6TMbM428IrIOmK+q872OpTZEZAxOz8H/Abqr6pUehxQyEfk38HtV/X8+iKUpsBc4SVW/cKc9D3yvqumeBlcLfnpPq1Kbz2xM7CK51zL1AdqKyGYR+U5E/iwiTbyOrToi0hy4F5jidSy1JSLtgOMAv1QHxwElZcnFtRGImmE7ffieHqa2n9mYSDA4JXEycDHQF6c8Phm408ugQnAfTtW11etAasM9Z2kR8Kyq/tfreFzNgB8rTPsRqPGCPD/w6XtamVp9ZqMiwUTjtUw1xSwivYFBwCyvYgwWwntcNl8C8DxOW8dEzwI+XD7QvMK05kA1w336g4/f00PU5TMbFY280XgtU00xi8gkoCuwRUTA+QVOFJETVPWUiAdYQYjvsQDzcSrGYapaxXgxnvgCSBKRY1X1S3faz/Dx7gb4/j2tqB+1/MzGUiPvvcBQYDhOdw+Lcbp7uMvTwKogIqkc+ot7K84/7zeqmuNJUDUQkSdxdj8HqWq+1/FUJCIv4vzIXIsT51vAmT4+iuT79zRYXT6zUVHBhOg+nE57vuB/1zL9wdOIqqGq+4H9ZY9FJB8o9HFy6QJcjzN83Xb3FwzgelVd5Flgh7oBWIAzjudunA++n5NLNLyn5erymY2ZCsYY4z9R0chrjIlOlmCMMRFjCcYYEzGWYIwxEWMJxhgTMZZgjDERYwnGRISI/EZEdohIvoikNdA2nxQRX55YGa/sPBhTKRH5Fuf09RKc63yWARNDOdvUvXAvFzhDVTdW8nxX4BsgWVUD4Yv6kG30A15Q1aMjsX4TGqtgTHVGqGoz/nd1+u0hLtcOZ/hf355FaxqGJRhTI1XdDizHSTRAeXePj4jIFndX6EkRaSIixwGb3Nn2iciq2mzLXe9sEfnBvc0WkZSg528TkW3uc9e6V3t3d59bKCL3u51PvQ10cHfR8sUZntg0MEswpkYicjTOhaSbgyY/hNM5Um+gO9ARmO52+FTWyVNLVR1Qy83dAZzhrvdnwM9x+/URkXOByThdBnTH6WryMKpa4Mb7g6o2c28/1DIOEwaWYEx1XheRPJx+Y3cCd0N5FwPXAbeo6h5VzQMeAMaEYZtXAPeq6k73IrrfA2Pd5y4FnlHVz9wL734fhu2ZCLIEY6ozUlWPwOkH5Hicq9UB2gKpwAYR2Sci+3AagduGYZsdgOygx9nutLLngntSi6qeAOORJRhTI1V9D1gIPOJO2oXTi+CJqtrSvbVwG4Tr6wegS9Djzu40gG1A8FGhTtWFHYZYTD1ZgjGhmg0MFpHeqloK/AWYJSJHAohIRxE5p5brTBGRxkG3BCATuFNE2opIG2A6UDb2zsvANSLS0+38aHo1694BpIlIi1rGZMLIEowJidse8hxQdiLbNJxG3/UikgusAHrUcrX5OJVQ2W0AcD+QBfwb+AT40J2Gqr4NPA78zd32++56DlYS739xktXX7m6cHUXygJ1oZ6KWiPQEPgVSInXCnqkfq2BMVBGRC0WkkYi0wjlU/qYlF/+yBGOizfVADvAVzmUMv/E2HFMd20UyxkSMVTDGmIixBGOMiRhLMMaYiLEEY4yJGEswxpiI+f/wSosGfzW8aAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from scipy.stats import spearmanr\n", + "\n", + "save_figs = True\n", + "fig_name = \"replicate_sknsh\"\n", + "\n", + "min_c = 5.\n", + "\n", + "x_min = -6.\n", + "x_max = 4.\n", + "\n", + "filtered_df = library_df.query(\"ref_count_total_repl_1 >= \" + str(min_c) + \" and \" + \"ref_count_total_repl_2 >= \" + str(min_c) + \" and \" + \"var_count_total_repl_1 >= \" + str(min_c) + \" and \" + \"var_count_total_repl_2 >= \" + str(min_c))\n", + "\n", + "print(\"len(filtered_df) = \" + str(len(filtered_df)))\n", + "\n", + "#Reference library (replicate correlation)\n", + "r_val_ref, _ = spearmanr(filtered_df['ref_logit_77_127_repl_1'], filtered_df['ref_logit_77_127_repl_2'])\n", + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "plt.scatter(filtered_df['ref_logit_77_127_repl_1'], filtered_df['ref_logit_77_127_repl_2'], color='lightgreen', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "plt.xlim(x_min, x_max)\n", + "plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Ref Logit (Repl. 1)\", fontsize=12)\n", + "plt.ylabel(\"Ref Logit (Repl. 2)\", fontsize=12)\n", + "\n", + "plt.title(\"r = \" + str(round(r_val_ref, 3)) + \", n = \" + str(len(filtered_df)), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_ref_logits.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_ref_logits.eps\")\n", + "\n", + "plt.show()\n", + "\n", + "#Variant library (replicate correlation)\n", + "r_val_var, _ = spearmanr(filtered_df['var_logit_77_127_repl_1'], filtered_df['var_logit_77_127_repl_2'])\n", + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "plt.scatter(filtered_df['var_logit_77_127_repl_1'], filtered_df['var_logit_77_127_repl_2'], color='lightcoral', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "plt.xlim(x_min, x_max)\n", + "plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Var Logit (Repl. 1)\", fontsize=12)\n", + "plt.ylabel(\"Var Logit (Repl. 2)\", fontsize=12)\n", + "\n", + "plt.title(\"r = \" + str(round(r_val_var, 3)) + \", n = \" + str(len(filtered_df)), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_var_logits.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_var_logits.eps\")\n", + "\n", + "plt.show()\n", + "\n", + "#Ref-Var library (delta replicate correlation)\n", + "r_val_var, _ = spearmanr(filtered_df['delta_logodds_true_77_127_repl_1'], filtered_df['delta_logodds_true_77_127_repl_2'])\n", + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "plt.scatter(filtered_df['delta_logodds_true_77_127_repl_1'], filtered_df['delta_logodds_true_77_127_repl_2'], color='lightcoral', s=45, edgecolor='black', linewidth=1)\n", + "\n", + "plt.xlim(x_min, x_max)\n", + "plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"LOR (Repl. 1)\", fontsize=12)\n", + "plt.ylabel(\"LOR (Repl. 2)\", fontsize=12)\n", + "\n", + "plt.title(\"r = \" + str(round(r_val_var, 3)) + \", n = \" + str(len(filtered_df)), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_delta_logodds.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_delta_logodds.eps\")\n", + "\n", + "plt.show()\n", + "\n", + "#Ref-Var control correlation\n", + "control_df = filtered_df.loc[filtered_df['experiment'].str.contains(\"control_\") & filtered_df['data_source'].str.contains(\"Array_2019\")]\n", + "\n", + "r_val_control, _ = spearmanr(control_df['ref_logit_77_127_repl_pooled'], control_df['var_logit_77_127_repl_pooled'])\n", + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "plt.scatter(control_df['ref_logit_77_127_repl_pooled'], control_df['var_logit_77_127_repl_pooled'], color='black', s=175, marker='^')\n", + "\n", + "plt.plot([x_min, x_max], [x_min, x_max], color='darkgreen', linestyle='--', linewidth=2,)\n", + "\n", + "plt.xlim(x_min, x_max)\n", + "plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Ref Logit\", fontsize=12)\n", + "plt.ylabel(\"Var Logit\", fontsize=12)\n", + "\n", + "plt.title(\"Controls; Spearman r = \" + str(round(r_val_control, 3)) + \", n = \" + str(len(control_df)), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \"_control_logits.png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \"_control_logits.eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n (sequences) = 186066\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Compare controls from 2022 oligo array to the Cell paper 2019 array\n", + "\n", + "#Load oligo array from 2019\n", + "import isolearn.io as isoio\n", + "\n", + "save_figs = True\n", + "fig_name = \"replicate_sknsh_to_2019\"\n", + "\n", + "isoform_pseudo_count = 1.\n", + "proximal_start = 77\n", + "proximal_end = 127\n", + "\n", + "file_prefix = str(proximal_start) + \"_\" + str(proximal_end)\n", + "\n", + "seq_dict = isoio.load('../../../../aparent/data/prepared_data/apa_array_data/apa_array_data_seq')\n", + "\n", + "seq_df = seq_dict['array_df']\n", + "seq_cuts = seq_dict['pooled_cuts']\n", + "\n", + "cut_true = np.concatenate([np.array(seq_cuts[:, 180: 180 + 205].todense()), np.array(seq_cuts[:, -1].todense()).reshape(-1, 1)], axis=-1)# - 1\n", + "\n", + "seq_df['proximal_count'] = [np.sum(cut_true[i, proximal_start:proximal_end]) for i in range(len(seq_df))]\n", + "seq_df['total_count'] = [np.sum(cut_true[i, :]) for i in range(len(seq_df))]\n", + "\n", + "seq_df['iso_true'] = (seq_df['proximal_count'] + isoform_pseudo_count) / (seq_df['total_count'] + 2. * isoform_pseudo_count)\n", + "seq_df['logodds_true'] = np.log(seq_df['iso_true'] / (1.0 - seq_df['iso_true']))\n", + "\n", + "seq_df['seq'] = seq_df['seq'].str.slice(0, 205)\n", + "\n", + "print(\"n (sequences) = \" + str(len(seq_df)))\n", + "\n", + "#Ref-Array 2019 control correlation\n", + "control_df_2019 = control_df.join(seq_df[['seq', 'logodds_true']].set_index(\"seq\"), on='ref_seq', how='inner').copy().reset_index(drop=True)\n", + "\n", + "r_val_control, _ = spearmanr(control_df_2019['ref_logit_77_127_repl_pooled'], control_df_2019['logodds_true'])\n", + "\n", + "f = plt.figure(figsize=(4, 4))\n", + "\n", + "plt.scatter(control_df_2019['ref_logit_77_127_repl_pooled'], control_df_2019['logodds_true'], color='deepskyblue', edgecolor='black', linewidth=1, s=175, marker='^')\n", + "\n", + "plt.plot([x_min, x_max], [x_min, x_max], color='darkgreen', linestyle='--', linewidth=2,)\n", + "\n", + "plt.xlim(x_min, x_max)\n", + "plt.ylim(x_min, x_max)\n", + "\n", + "plt.xticks(fontsize=12)\n", + "plt.yticks(fontsize=12)\n", + "\n", + "plt.xlabel(\"Logit (2022)\", fontsize=12)\n", + "plt.ylabel(\"Logit (2019)\", fontsize=12)\n", + "\n", + "plt.title(\"Controls; Spearman r = \" + str(round(r_val_control, 3)) + \", n = \" + str(len(control_df_2019)), fontsize=12)\n", + "\n", + "plt.tight_layout()\n", + "\n", + "if save_figs :\n", + " plt.savefig(fig_name + \".png\", dpi=600, transparent=True)\n", + " plt.savefig(fig_name + \".eps\")\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:tensorflow]", + "language": "python", + "name": "conda-env-tensorflow-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 +}