From 05748efc0b6720f94c88eb32e1dde67c9e2a5118 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Fri, 3 May 2019 18:16:36 -0400 Subject: [PATCH 01/71] added initial dot-calling notebook --- doc/examples/dot-calling-internals.ipynb | 719 +++++++++++++++++++++++ 1 file changed, 719 insertions(+) create mode 100644 doc/examples/dot-calling-internals.ipynb diff --git a/doc/examples/dot-calling-internals.ipynb b/doc/examples/dot-calling-internals.ipynb new file mode 100644 index 00000000..d486d903 --- /dev/null +++ b/doc/examples/dot-calling-internals.ipynb @@ -0,0 +1,719 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "!export MKL_NUM_THREADS=1\n", + "\n", + "# this isn't working in Jupyter notebook as it turned out ..." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import mkl\n", + "mkl.set_num_threads(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "import os.path as op\n", + "from scipy.stats import poisson\n", + "import pandas as pd\n", + "import numpy as np\n", + "import cooler\n", + "\n", + "\n", + "from cooltools import dotfinder" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "cpath = \"ESC-R1\"\n", + "basename = \"U54-H1ESC4DN-FA-DSG-MNase_hg19\"\n", + "\n", + "COOL10=\"{}/{}.10000.cool\".format(cpath,basename)\n", + "EXP10=\"{}/{}.10000.cool.cis.expected\".format(cpath,basename)\n", + "LOOP10=\"{}/cloops_{}.10000.bedpe\".format(cpath,basename)\n", + "# HDF10=test_scores$TESTIDX\\_$BASENAME.10000.hdf\n", + "FLOOP10=\"{}/final_cloops_{}.10000.bedpe\".format(cpath,basename)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### provide arguments to replace CLI interface" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "cool_path = COOL10\n", + "expected_path = EXP10\n", + "expected_name = 'balanced.avg'\n", + "nproc = 8\n", + "max_loci_separation = 10000000\n", + "max_nans_tolerated = 11\n", + "tile_size = 10000000\n", + "fdr = 0.1\n", + "dots_clustering_radius = 21000\n", + "verbose = True\n", + "output_scores = 'xxx'\n", + "output_hists = 'yyy'\n", + "output_calls = 'zzz'\n", + "score_dump_mode = 'parquet'\n", + "# score_dump_mode = 'local'\n", + "temp_dir = './'\n", + "no_delete_temp = True" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### load cooler and expected" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tokenization took: 45.74 ms\n", + "Type conversion took: 19.43 ms\n", + "Parser memory cleanup took: 0.01 ms\n", + "Tokenization took: 33.22 ms\n", + "Type conversion took: 18.70 ms\n", + "Parser memory cleanup took: 0.00 ms\n", + "Tokenization took: 11.04 ms\n", + "Type conversion took: 6.39 ms\n", + "Parser memory cleanup took: 0.00 ms\n" + ] + } + ], + "source": [ + "clr = cooler.Cooler(cool_path)\n", + "\n", + "expected_columns = ['chrom', 'diag', 'n_valid', expected_name]\n", + "expected_index = ['chrom', 'diag']\n", + "expected_dtypes = {\n", + " 'chrom': np.str,\n", + " 'diag': np.int64,\n", + " 'n_valid': np.int64,\n", + " expected_name: np.float64\n", + "}\n", + "expected = pd.read_table(\n", + " expected_path,\n", + " usecols=expected_columns,\n", + " index_col=expected_index,\n", + " dtype=expected_dtypes,\n", + " comment=None,\n", + " verbose=verbose)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### we'll everyhting for `chr1` only to save time\n", + "\n", + "demonstration purposes only this way ..." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "expected = expected.loc[[\"chr1\"]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### some silly validation" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ESC-R1/U54-H1ESC4DN-FA-DSG-MNase_hg19.10000.cool and ESC-R1/U54-H1ESC4DN-FA-DSG-MNase_hg19.10000.cool.cis.expected passed cross-compatibility checks.\n" + ] + } + ], + "source": [ + "# Input validation\n", + "# unique list of chroms mentioned in expected_path\n", + "# do simple column-name validation for now\n", + "get_exp_chroms = lambda df: df.index.get_level_values(\"chrom\").unique()\n", + "expected_chroms = get_exp_chroms(expected)\n", + "if not set(expected_chroms).issubset(clr.chromnames):\n", + " raise ValueError(\n", + " \"Chromosomes in {} must be subset of \".format(expected_path) +\n", + " \"chromosomes in cooler {}\".format(cool_path))\n", + "# check number of bins\n", + "# compute # of bins by comparing matching indexes\n", + "get_exp_bins = lambda df, ref_chroms: (\n", + " df.index.get_level_values(\"chrom\").isin(ref_chroms).sum())\n", + "expected_bins = get_exp_bins(expected, expected_chroms)\n", + "cool_bins = clr.bins()[:][\"chrom\"].isin(expected_chroms).sum()\n", + "if not (expected_bins == cool_bins):\n", + " raise ValueError(\n", + " \"Number of bins is not matching: \",\n", + " \"{} in {}, and {} in {} for chromosomes {}\".format(\n", + " expected_bins,\n", + " expected_path,\n", + " cool_bins,\n", + " cool_path,\n", + " expected_chroms))\n", + "if verbose:\n", + " print(\"{} and {} passed cross-compatibility checks.\".format(\n", + " cool_path, expected_path))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### prepare some other parameters " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "we are dealing with the data binned at 10000\n" + ] + } + ], + "source": [ + "# Prepare some parameters.\n", + "binsize = clr.binsize\n", + "loci_separation_bins = int(max_loci_separation / binsize)\n", + "tile_size_bins = int(tile_size / binsize)\n", + "balance_factor = 1.0 #clr._load_attrs(\"bins/weight\")[\"scale\"]\n", + "\n", + "print(\"we are dealing with the data binned at {}\".format(binsize))\n", + "\n", + "# clustering would deal with bases-units for now, so supress this for now\n", + "# clustering_radius_bins = int(dots_clustering_radius/binsize)\n", + "\n", + "# kernels\n", + "# 'upright' is a symmetrical inversion of \"lowleft\", not needed.\n", + "ktypes = ['donut', 'vertical', 'horizontal', 'lowleft']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### choosing w and p for the kernel sizes\n", + "we should replace it or hide it with the function that \"recommends\" `w` and `p` based on the `binsize`\n", + "but also we should provide a CLI interface for changing those at will ...\n", + "\n", + "or should we \"read\" kernel-footprints from a separate file ... for ultimate customizability ?!" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kernel parameters w=5 p=2\n" + ] + } + ], + "source": [ + "w,p = dotfinder.recommend_kernel_params(binsize)\n", + "print(\"Kernel parameters w={} p={}\".format(w,p))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "kernels = {k: dotfinder.get_kernel(w, p, k) for k in ktypes}\n", + "\n", + "# list of tile coordinate ranges\n", + "tiles = list(\n", + " dotfinder.heatmap_tiles_generator_diag(\n", + " clr,\n", + " expected_chroms,\n", + " w,\n", + " tile_size_bins,\n", + " loci_separation_bins\n", + " )\n", + ") " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import tempfile\n", + "tmp_scores = tempfile.NamedTemporaryFile(\n", + " suffix='.parquet',\n", + " delete= not no_delete_temp,\n", + " dir=temp_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Preparing to convolve 49 tiles:\n", + "creating a Pool of 8 workers to tackle 49 tiles\n", + "parquet output ...\n" + ] + }, + { + "ename": "ArrowException", + "evalue": "Unsupported Parquet format version", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mArrowException\u001b[0m Traceback (most recent call last)", + "\u001b[0;31mArrowException\u001b[0m: Unsupported Parquet format version" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Exception ignored in: 'pyarrow._parquet.ParquetWriter._set_version'\n", + "pyarrow.lib.ArrowException: Unsupported Parquet format version\n" + ] + } + ], + "source": [ + "cccc = dotfinder.scoring_step(clr,\n", + " expected,\n", + " expected_name,\n", + " \"weight\",\n", + " tiles,\n", + " kernels,\n", + " max_nans_tolerated,\n", + " loci_separation_bins,\n", + " tmp_scores,\n", + " nproc,\n", + " score_dump_mode,\n", + " verbose)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, '# of interactions')" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "nlchunks = dotfinder.HiCCUPS_W1_MAX_INDX\n", + "base = 2 ** (1/3)\n", + "ledges = np.concatenate((\n", + " [-np.inf],\n", + " np.logspace(0, nlchunks - 1, num=nlchunks, base=base, dtype=np.float),\n", + " [np.inf]))\n", + "\n", + "#################################################\n", + "plt.plot(ledges,np.zeros_like(ledges),'r|')\n", + "plt.title(\"those freaking lambda-chunks/bins/whatever\")\n", + "plt.xlabel(\"# of interactions\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "parquet input ...\n" + ] + } + ], + "source": [ + "gw_hist = dotfinder.histogramming_step(tmp_scores,\n", + " score_dump_mode,\n", + " kernels,\n", + " ledges,\n", + " output_path=None,\n", + " nproc=1,\n", + " verbose=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### determine thresholds using the fdr thing ..." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "threshold_df, qvalues = dotfinder.determine_thresholds(\n", + " kernels, ledges, gw_hist, 0.99)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### oveview of the 2D histogram \n", + "\n", + "x-bins corresponding to the $\\lambda$-chunks and y-bins correspodning to the observed counts ..." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/venevs/miniconda3/envs/dots-latest/lib/python3.6/site-packages/ipykernel_launcher.py:3: RuntimeWarning: divide by zero encountered in log\n", + " This is separate from the ipykernel package so we can avoid doing imports until\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'lambda-chunks')" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.gcf()\n", + "fig.set_size_inches(10,30)\n", + "plt.imshow(np.log(gw_hist[\"donut\"]),aspect=0.05)\n", + "ax = plt.gca()\n", + "ax.plot(np.arange(threshold_df[\"donut\"].values.size)-0.05,threshold_df[\"donut\"].values,color='r',marker=\"_\",linestyle=\":\")\n", + "\n", + "ax.set_ylabel(\"observed counts\")\n", + "ax.set_xlabel(\"lambda-chunks\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### a histogram for a particular $\\lambda$-chunk" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5962\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "binid = 20\n", + "print(gw_hist[\"donut\"].iloc[:,binid].values.sum())\n", + "hs = np.clip(gw_hist[\"donut\"].iloc[:,binid].values,a_min=None,a_max=10000)\n", + "# hs = np.log(gw_hist[\"donut\"].iloc[:,binid].values)\n", + "plt.bar(gw_hist[\"donut\"].iloc[:,binid].index,hs)\n", + "plt.bar(threshold_df[\"donut\"].iloc[binid],hs.max(),width=10,color='red')\n", + "# plt.gca().set_ylim(0,1)\n", + "# plt.gca().set_xlim(0,60)\n", + "# gw_hist[\"donut\"].iloc[:,20]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### now extract \"significant\" pixels using the defined thresholds_df and the same parquet file with the score dump as for the histogramming step" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "parquet input ...\n", + "Number of filtered pixels 21545\n" + ] + } + ], + "source": [ + "filtered_pixels = dotfinder.extraction_step(tmp_scores,\n", + " score_dump_mode,\n", + " kernels,\n", + " ledges,\n", + " threshold_df,\n", + " nproc=1,\n", + " output_path=output_scores,\n", + " verbose=False)\n", + "\n", + "print(\"Number of filtered pixels {}\".format(len(filtered_pixels)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### annotate filtered pixeles and cluster them -> get centroids after that to proceed with post-processing ..." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "filtered_pixels_qvals = dotfinder.annotate_pixels_with_qvalues(filtered_pixels,\n", + " qvalues,\n", + " kernels)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/venevs/miniconda3/envs/dots-latest/lib/python3.6/site-packages/sklearn/cluster/birch.py:77: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n", + " node1_dist, node2_dist = dist[[farthest_idx]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Clustering is completed:\n", + "6296 clusters detected\n", + "3.42+/-3.53 mean size\n", + "\n", + "Clustering is over!\n", + "Number of clustered pixels, i.e. centroids 6296\n" + ] + } + ], + "source": [ + "filtered_pixels_annotated = cooler.annotate(filtered_pixels_qvals, clr.bins()[:])\n", + "centroids = dotfinder.clustering_step(\n", + " filtered_pixels_annotated,\n", + " expected_chroms,\n", + " dots_clustering_radius,\n", + " verbose)\n", + "print(\"Number of clustered pixels, i.e. centroids {}\".format(len(centroids)))" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "final_out = dotfinder.thresholding_step(centroids)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2327" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(final_out)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From cd08bc0abe16fff62c302f6859dd9d4a9daa977e Mon Sep 17 00:00:00 2001 From: sergpolly Date: Wed, 8 May 2019 17:56:26 -0400 Subject: [PATCH 02/71] updated notebook --- doc/examples/dot-calling-internals.ipynb | 373 +++++++++++++++-------- 1 file changed, 247 insertions(+), 126 deletions(-) diff --git a/doc/examples/dot-calling-internals.ipynb b/doc/examples/dot-calling-internals.ipynb index d486d903..7ced6114 100644 --- a/doc/examples/dot-calling-internals.ipynb +++ b/doc/examples/dot-calling-internals.ipynb @@ -2,13 +2,19 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "!export MKL_NUM_THREADS=1\n", + "# Setup the environment first\n", "\n", - "# this isn't working in Jupyter notebook as it turned out ..." + "# read: https://github.com/mirnylab/cooler/issues/138 for more details:\n", + "\n", + "# !export MKL_NUM_THREADS=1 - # not working in a notebook ((\n", + "# instead do this, after making sure mkl is installed\n", + "import mkl\n", + "mkl.set_num_threads(1)\n", + "\n" ] }, { @@ -17,70 +23,94 @@ "metadata": {}, "outputs": [], "source": [ - "import mkl\n", - "mkl.set_num_threads(1)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], - "source": [ - "%load_ext autoreload\n", - "%autoreload 2" + "# are you developing?\n", + "# turn module reloading on\n", + "\n", + "# %load_ext autoreload\n", + "# %autoreload 2" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ + "# neccessary modules to be imported\n", + "\n", "import os.path as op\n", "from scipy.stats import poisson\n", "import pandas as pd\n", "import numpy as np\n", "import cooler\n", "\n", + "from cooltools import dotfinder\n", "\n", - "from cooltools import dotfinder" + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as colors\n", + "import matplotlib.ticker as ticker" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0m\u001b[01;32mcall_dots_simple.sh\u001b[0m* GM12878_insitu_primary_30.KR.cis.expected\r\n", + "cloops10mb.10kb.KR.txt GM12878_insitu_primary_30.KR.cool\r\n", + "cloops10mb.10kb.KR.txt.postproc hist10mb.10kb.KR.fixed\r\n", + "explore_coolbox.ipynb zxzx\r\n", + "final_cloops10mb.10kb.KR.txt\r\n" + ] + } + ], "source": [ - "%matplotlib inline\n", - "import matplotlib.pyplot as plt" + "ls /home/venevs/DOTS_TESTING/prim_rep_rao_Mar19" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "cpath = \"ESC-R1\"\n", - "basename = \"U54-H1ESC4DN-FA-DSG-MNase_hg19\"\n", + "# input files to play with\n", + "# pick Rao et al primary @10kb to enable comparison\n", "\n", - "COOL10=\"{}/{}.10000.cool\".format(cpath,basename)\n", - "EXP10=\"{}/{}.10000.cool.cis.expected\".format(cpath,basename)\n", - "LOOP10=\"{}/cloops_{}.10000.bedpe\".format(cpath,basename)\n", - "# HDF10=test_scores$TESTIDX\\_$BASENAME.10000.hdf\n", - "FLOOP10=\"{}/final_cloops_{}.10000.bedpe\".format(cpath,basename)\n", - "\n" + "# what I have here is Rao et al 2014 sample for GM cells\n", + "# the dataset that they refer to as \"primary\" in the paper\n", + "# the cooler created using hic2cool tool\n", + "# and what I have here is an older version before divisive/multiplicative\n", + "# balancing weights situation happened\n", + "path = \"/home/venevs/DOTS_TESTING/prim_rep_rao_Mar19\"\n", + "basename = \"GM12878_insitu_primary_30.KR\"\n", + "\n", + "# this is a 10kb cooler file\n", + "# and we should also have expected calculated for 10kb\n", + "\n", + "COOL10=\"{}/{}.cool\".format(path,basename)\n", + "EXP10=\"{}/{}.cis.expected\".format(path,basename)\n", + "\n", + "LOOP10=\"{}/cloops_{}.bedpe\".format(path,basename)\n", + "# # HDF10=test_scores$TESTIDX\\_$BASENAME.10000.hdf\n", + "FLOOP10=\"{}/cloops_{}.bedpe.postprocess\".format(path,basename)\n", + "\n", + "# keeping some of the relevant CLI commands here\n", + "# useful for preprocessing cooler files - before calling dots\n", + "\n", + "# 0. consider adding downloading command for Rao data e.g.\n", + "# 0. also condsider showing hic2cool usage here to turn .hic to .cool\n", + "\n", + "# 1. re-balancing - cis-only is worth checking out at the very least ...\n", + "# cooler balance -p {threads} --ignore-diags 1 --force --name 'wsnake' {input}::/resolutions/{res}\n", + "\n", + "# 2. calculation of expected\n", + "# cooltools compute-expected -p {threads} --weight-name 'wsnake' --drop-diags 1 {input[0]}::/resolutions/{res}\n" ] }, { @@ -92,20 +122,22 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 50, "metadata": {}, "outputs": [], "source": [ + "# specify parameters for call-dots\n", "cool_path = COOL10\n", "expected_path = EXP10\n", "expected_name = 'balanced.avg'\n", "nproc = 8\n", - "max_loci_separation = 10000000\n", - "max_nans_tolerated = 11\n", + "max_loci_separation = 1000000\n", + "max_nans_tolerated = 4\n", "tile_size = 10000000\n", "fdr = 0.1\n", "dots_clustering_radius = 21000\n", "verbose = True\n", + "balancing_weight_name = \"weight\"\n", "output_scores = 'xxx'\n", "output_hists = 'yyy'\n", "output_calls = 'zzz'\n", @@ -124,21 +156,21 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Tokenization took: 45.74 ms\n", - "Type conversion took: 19.43 ms\n", - "Parser memory cleanup took: 0.01 ms\n", - "Tokenization took: 33.22 ms\n", - "Type conversion took: 18.70 ms\n", + "Tokenization took: 61.52 ms\n", + "Type conversion took: 19.38 ms\n", + "Parser memory cleanup took: 0.00 ms\n", + "Tokenization took: 33.60 ms\n", + "Type conversion took: 19.17 ms\n", "Parser memory cleanup took: 0.00 ms\n", - "Tokenization took: 11.04 ms\n", - "Type conversion took: 6.39 ms\n", + "Tokenization took: 10.19 ms\n", + "Type conversion took: 6.11 ms\n", "Parser memory cleanup took: 0.00 ms\n" ] } @@ -160,44 +192,48 @@ " index_col=expected_index,\n", " dtype=expected_dtypes,\n", " comment=None,\n", - " verbose=verbose)" + " verbose=verbose)\n", + "# include Geoff's fix for the datatypes in expected" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### we'll everyhting for `chr1` only to save time\n", + "### we'll do everyhting for `chr1` only to save time (reconsider it later ...)\n", "\n", "demonstration purposes only this way ..." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ - "expected = expected.loc[[\"chr1\"]]" + "# beware of chromosome naming converntion, i.e. \"chr1\" vs \"1\" ...\n", + "expected = expected.loc[[\"1\"]]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### some silly validation" + "### some validation\n", + "Just making sure that expected anb cooler are \"compatible\"\n", + "i.e. they refer to the same chromosomes and those chromosomes have the same length" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "ESC-R1/U54-H1ESC4DN-FA-DSG-MNase_hg19.10000.cool and ESC-R1/U54-H1ESC4DN-FA-DSG-MNase_hg19.10000.cool.cis.expected passed cross-compatibility checks.\n" + "/home/venevs/DOTS_TESTING/prim_rep_rao_Mar19/GM12878_insitu_primary_30.KR.cool and /home/venevs/DOTS_TESTING/prim_rep_rao_Mar19/GM12878_insitu_primary_30.KR.cis.expected passed cross-compatibility checks.\n" ] } ], @@ -240,7 +276,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -281,7 +317,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 44, "metadata": {}, "outputs": [ { @@ -299,7 +335,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 45, "metadata": {}, "outputs": [], "source": [ @@ -319,68 +355,137 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "import tempfile\n", - "tmp_scores = tempfile.NamedTemporaryFile(\n", - " suffix='.parquet',\n", - " delete= not no_delete_temp,\n", - " dir=temp_dir)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, + "execution_count": 47, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Preparing to convolve 49 tiles:\n", - "creating a Pool of 8 workers to tackle 49 tiles\n", - "parquet output ...\n" - ] - }, - { - "ename": "ArrowException", - "evalue": "Unsupported Parquet format version", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mArrowException\u001b[0m Traceback (most recent call last)", - "\u001b[0;31mArrowException\u001b[0m: Unsupported Parquet format version" - ] + "data": { + "text/plain": [ + "[Text(1, 0, 'Excluded from calculation'),\n", + " Text(1, 0, 'Included in calculations')]" + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "Exception ignored in: 'pyarrow._parquet.ParquetWriter._set_version'\n", - "pyarrow.lib.ArrowException: Unsupported Parquet format version\n" - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "cccc = dotfinder.scoring_step(clr,\n", - " expected,\n", - " expected_name,\n", - " \"weight\",\n", - " tiles,\n", - " kernels,\n", - " max_nans_tolerated,\n", - " loci_separation_bins,\n", - " tmp_scores,\n", - " nproc,\n", - " score_dump_mode,\n", - " verbose)" + "# it is important to demonstrate filters here \n", + "# consider moving plotting code elsewhere or simplify it significantly ...\n", + "# split cell above and demonstrate kernels - it's nice:\n", + "\n", + "ktype='donut'\n", + "kernel= kernels[ktype]\n", + "y,x = np.ogrid[-w:w+1, -w:w+1]\n", + "\n", + "extent = (0-0.5,\n", + " x.size-0.5,\n", + " 0-0.5,\n", + " y.size-0.5)\n", + "########################\n", + "plt.clf()\n", + "# axes setup\n", + "ax = plt.gca()\n", + "# discrete colormap with 2 colors ...\n", + "cmap = colors.ListedColormap([plt.cm.viridis(0),\n", + " plt.cm.viridis(1.0)])\n", + "# kernel:\n", + "imk = ax.imshow(kernel,\n", + " alpha=0.7,\n", + " cmap=cmap,\n", + " extent=extent,\n", + " interpolation='nearest')\n", + "ax.set_xticks([])\n", + "ax.set_yticks([])\n", + "ax.set_xticklabels('',visible=False)\n", + "ax.set_yticklabels('',visible=False)\n", + "ax.set_title(\"{} kernel\".format(ktype),fontsize=16)\n", + "\n", + "# add checkerboard to depict pixels:\n", + "checkerboard = np.add.outer(range(x.size),\n", + " range(y.size)) % 2\n", + "ax.imshow(checkerboard,\n", + " cmap=plt.cm.gray,\n", + " interpolation='nearest',\n", + " extent=extent,\n", + " alpha=0.3)\n", + "#####################\n", + "# colorbar and that's it:\n", + "cb = plt.colorbar(imk)\n", + "cb.ax.get_yaxis().set_major_locator(ticker.MaxNLocator(1))\n", + "cb.ax.set_yticklabels(['Excluded from calculation','Included in calculations'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Getting to the calculations of locally-adjusted expected\n", + "\n", + "we could try to store all of the values in a separate file,\n", + "but practice shows that for large genomes - it degrades performnce too much\n", + "\n", + "consider using this for yeast or other smaller genomes\n", + "\n", + "for human/etc use 2-pass strategy, where we calculate locally-adjusted expected\n", + "for each pixel and use this value *immediately* without trying to store it" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# for smaller genomes saving pre-calculated locally adjusted expected\n", + "# might be feasible:\n", + "\n", + "# import tempfile\n", + "# tmp_scores = tempfile.NamedTemporaryFile(\n", + "# suffix='.parquet',\n", + "# delete= not no_delete_temp,\n", + "# dir=temp_dir)\n", + "\n", + "# cccc = dotfinder.scoring_step(clr,\n", + "# expected,\n", + "# expected_name,\n", + "# \"weight\",\n", + "# tiles,\n", + "# kernels,\n", + "# max_nans_tolerated,\n", + "# loci_separation_bins,\n", + "# tmp_scores,\n", + "# nproc,\n", + "# score_dump_mode,\n", + "# verbose)\n", + "\n", + "# histogramming using temp input:\n", + "\n", + "# gw_hist = dotfinder.histogramming_step(tmp_scores,\n", + "# score_dump_mode,\n", + "# kernels,\n", + "# ledges,\n", + "# output_path=None,\n", + "# nproc=1,\n", + "# verbose=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 48, "metadata": {}, "outputs": [ { @@ -389,13 +494,13 @@ "Text(0.5, 0, '# of interactions')" ] }, - "execution_count": 16, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -407,6 +512,8 @@ } ], "source": [ + "# for large genomes- calculate histograms i.e. start with lambda-chunking right away:\n", + "\n", "nlchunks = dotfinder.HiCCUPS_W1_MAX_INDX\n", "base = 2 ** (1/3)\n", "ledges = np.concatenate((\n", @@ -422,25 +529,30 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 51, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "parquet input ...\n" + "Preparing to convolve 49 tiles:\n", + "creating a Pool of 8 workers to tackle 49 tiles\n" ] } ], "source": [ - "gw_hist = dotfinder.histogramming_step(tmp_scores,\n", - " score_dump_mode,\n", - " kernels,\n", - " ledges,\n", - " output_path=None,\n", - " nproc=1,\n", - " verbose=False)" + "gw_hist = dotfinder.scoring_and_histogramming_step(clr,\n", + " expected,\n", + " expected_name,\n", + " balancing_weight_name,\n", + " tiles,\n", + " kernels,\n", + " ledges,\n", + " max_nans_tolerated,\n", + " loci_separation_bins,\n", + " nproc,\n", + " verbose)\n" ] }, { @@ -452,7 +564,16 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "##### to be continued ..." + ] + }, + { + "cell_type": "code", + "execution_count": 52, "metadata": {}, "outputs": [], "source": [ @@ -471,14 +592,14 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 53, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/venevs/miniconda3/envs/dots-latest/lib/python3.6/site-packages/ipykernel_launcher.py:3: RuntimeWarning: divide by zero encountered in log\n", + "/home/venevs/miniconda3/envs/dots-stable/lib/python3.6/site-packages/ipykernel_launcher.py:3: RuntimeWarning: divide by zero encountered in log\n", " This is separate from the ipykernel package so we can avoid doing imports until\n" ] }, @@ -488,13 +609,13 @@ "Text(0.5, 0, 'lambda-chunks')" ] }, - "execution_count": 19, + "execution_count": 53, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] From 956c5da0fba0bf38346ea0183194a010d5c3135b Mon Sep 17 00:00:00 2001 From: sergpolly Date: Thu, 6 Jun 2019 18:37:52 -0400 Subject: [PATCH 03/71] updated the dots notebook --- doc/examples/dot-calling-internals.ipynb | 1226 ++++++++++++++++++++-- 1 file changed, 1144 insertions(+), 82 deletions(-) diff --git a/doc/examples/dot-calling-internals.ipynb b/doc/examples/dot-calling-internals.ipynb index 7ced6114..92df5b8d 100644 --- a/doc/examples/dot-calling-internals.ipynb +++ b/doc/examples/dot-calling-internals.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -47,6 +47,7 @@ "from cooltools import dotfinder\n", "\n", "%matplotlib inline\n", + "import matplotlib.cm as cm\n", "import matplotlib.pyplot as plt\n", "import matplotlib.colors as colors\n", "import matplotlib.ticker as ticker" @@ -54,28 +55,7 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[0m\u001b[01;32mcall_dots_simple.sh\u001b[0m* GM12878_insitu_primary_30.KR.cis.expected\r\n", - "cloops10mb.10kb.KR.txt GM12878_insitu_primary_30.KR.cool\r\n", - "cloops10mb.10kb.KR.txt.postproc hist10mb.10kb.KR.fixed\r\n", - "explore_coolbox.ipynb zxzx\r\n", - "final_cloops10mb.10kb.KR.txt\r\n" - ] - } - ], - "source": [ - "ls /home/venevs/DOTS_TESTING/prim_rep_rao_Mar19" - ] - }, - { - "cell_type": "code", - "execution_count": 9, + "execution_count": 55, "metadata": {}, "outputs": [], "source": [ @@ -100,6 +80,9 @@ "# # HDF10=test_scores$TESTIDX\\_$BASENAME.10000.hdf\n", "FLOOP10=\"{}/cloops_{}.bedpe.postprocess\".format(path,basename)\n", "\n", + "RAOLOOPS=\"/home/venevs/DOTS_TESTING/rao_combined_hic/Rao2014_GM12878_primary_and_replicate_HiCCUPS_looplist.txt\"\n", + "RAOLOOPS=\"/home/venevs/DOTS_TESTING/prim_rep_rao/Rao2014_GM12878_primary_HiCCUPS_looplist.txt\"\n", + "\n", "# keeping some of the relevant CLI commands here\n", "# useful for preprocessing cooler files - before calling dots\n", "\n", @@ -117,12 +100,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### provide arguments to replace CLI interface" + "### provide arguments to replace CLI interface\n", + "\n", + "instead of providing comman line arguments to the `call-dots` tool we are going to provide corresponding argumnets right in the notebook:" ] }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -156,21 +141,21 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Tokenization took: 61.52 ms\n", - "Type conversion took: 19.38 ms\n", - "Parser memory cleanup took: 0.00 ms\n", - "Tokenization took: 33.60 ms\n", - "Type conversion took: 19.17 ms\n", - "Parser memory cleanup took: 0.00 ms\n", - "Tokenization took: 10.19 ms\n", - "Type conversion took: 6.11 ms\n", + "Tokenization took: 47.45 ms\n", + "Type conversion took: 19.71 ms\n", + "Parser memory cleanup took: 0.01 ms\n", + "Tokenization took: 31.80 ms\n", + "Type conversion took: 18.99 ms\n", + "Parser memory cleanup took: 0.01 ms\n", + "Tokenization took: 9.56 ms\n", + "Type conversion took: 5.91 ms\n", "Parser memory cleanup took: 0.00 ms\n" ] } @@ -207,7 +192,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -226,7 +211,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -276,7 +261,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -299,8 +284,7 @@ "# clustering would deal with bases-units for now, so supress this for now\n", "# clustering_radius_bins = int(dots_clustering_radius/binsize)\n", "\n", - "# kernels\n", - "# 'upright' is a symmetrical inversion of \"lowleft\", not needed.\n", + "# pre-defined kernel types that are going to be used in the analysis\n", "ktypes = ['donut', 'vertical', 'horizontal', 'lowleft']" ] }, @@ -317,7 +301,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -335,7 +319,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -355,7 +339,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -365,7 +349,7 @@ " Text(1, 0, 'Included in calculations')]" ] }, - "execution_count": 47, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, @@ -435,57 +419,1074 @@ "source": [ "### Getting to the calculations of locally-adjusted expected\n", "\n", - "we could try to store all of the values in a separate file,\n", - "but practice shows that for large genomes - it degrades performnce too much\n", + " - for demonstration and debugging purposes we are going to dump the dataframe with locally adjusted expected right in place (i.e. in memory).\n", + " - This might be also ok for smaller genomes and potentially for small subsets of large genomes.\n", + " - This is not recommended whatsoever for genome-wide dot-calling.\n", + "\n", + "A side note, we've tried to store all of the values in a separate file,\n", + "but practice shows that for large genomes even parquet/hdf5 are not fast enough.\n", + "Thus using a **2-pass** strategy seems to be the best option indeed.\n", + "\n", + "**2-pass**: calculate locally-adjusted expected for each pixel and use this value *immediately* to build a hitogram with predefined bins, then recalculate locally-adjusted expected values and again use them *in place* to select significantly enriched pixels.\n", "\n", - "consider using this for yeast or other smaller genomes\n", "\n", - "for human/etc use 2-pass strategy, where we calculate locally-adjusted expected\n", - "for each pixel and use this value *immediately* without trying to store it" + " - an example on how to store locally adjusted expected in a temporary file:\n", + "```python\n", + "import tempfile\n", + "tmp_scores = tempfile.NamedTemporaryFile(\n", + " suffix='.parquet',\n", + " delete= False,\n", + " dir='.')\n", + "```\n", + " - now calculate locally adjusted expected:\n", + "```python\n", + "loc_adj_exp = dotfinder.scoring_step(clr,\n", + " expected,\n", + " expected_name,\n", + " \"weight\",\n", + " tiles,\n", + " kernels,\n", + " max_nans_tolerated,\n", + " loci_separation_bins,\n", + " tmp_scores,\n", + " nproc,\n", + " score_dump_mode,\n", + " verbose)\n", + "```\n", + " - histogramming using temporary input:\n", + "```python\n", + "gw_hist = dotfinder.histogramming_step(tmp_scores,\n", + " score_dump_mode,\n", + " kernels,\n", + " ledges,\n", + " output_path=None,\n", + " nproc=1,\n", + " verbose=False)\n", + "```" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Preparing to convolve 49 tiles:\n", + "creating a Pool of 8 workers to tackle 49 tiles\n", + "returning local copy of the dataframe ...\n" + ] + } + ], + "source": [ + "# locally adjusted returned in place for just 1 chromosome:\n", + "la_exp = dotfinder.scoring_step(clr,\n", + " expected,\n", + " expected_name,\n", + " balancing_weight_name,\n", + " tiles,\n", + " kernels,\n", + " 1,\n", + " loci_separation_bins,\n", + " None,\n", + " nproc,\n", + " \"local\",\n", + " verbose)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### that is how locally adjusted expected dataframe looks like:\n", + "\n", + "bin1_id|bin2_id|count|la_exp.donut.value|la_exp.vertical.value|la_exp.horizontal.value|la_exp.lowleft.value\n", + "---|---|---|---|---|---|---\n", + "76|87|20|16.343724585366036|19.112339277607475|14.789222300465001|17.55971648783403\n", + "76|88|29|21.109446293886823|23.76004284738352|19.119195822013385|23.30209962326733\n", + "76|89|15|17.254427190306977|18.545853810657224|14.695003640984938|19.784933947834944\n", + "76|90|21|14.277047600786759|14.642767228999286|12.928217571836717|17.27371365389384\n", + "76|91|13|11.22588212884422|11.279966641429564|10.064704945467405|14.514049136987758\n", + "\n", + " - here we use `cooler`-based `bin1/2_id` instead of actual genomic coordinates for compactness and performance reasons.\n", + " - Observed is recorded in the `count` columns, again as in the parent `cooler`-file.\n", + " - observer and all types of expected are expressed in the raw units in order to apply Poisson statistics to the data\n", + "\n", + "\n", + "### Now let's load in, some known called/annotated dots to see where they end up on the obs/exp scatter-plot" + ] + }, + { + "cell_type": "code", + "execution_count": 140, "metadata": {}, "outputs": [], "source": [ - "# for smaller genomes saving pre-calculated locally adjusted expected\n", - "# might be feasible:\n", + "# let us read in some of the known dots to display stronger ones on the obs/exp scatter plot:\n", + "raodots = pd.read_csv(RAOLOOPS,sep='\\t')\n", + "# beware of the UCSC/NCBI chromosome naming conventions `X` vs `chrX` ...\n", + "raodots_chr1 = raodots[raodots['chr1']=='1']\n", + "\n", + "# do we need a notion of strength here ?\n", + "# #let's quickly define some measure of strengths for the dots:\n", + "# raodots_chr1['strength'] = raodots_chr1['o']/raodots_chr1['e_donut']\n", + "# # now sort and select only the strongest (according to this measure):\n", + "# raodots_chr1_strong = raodots_chr1.sort_values(by=['o','strength'],ascending=False)\n", + "\n", + "# let's convert genomic coordinates into `cooler`-based bin_id-s:\n", + "bin1_ids = (raodots_chr1['x1']/binsize).astype('int')\n", + "bin2_ids = (raodots_chr1['y1']/binsize).astype('int')\n", + "# beware Rao et al, use x1,x2 for start1,end1 and y1,y2 for start2,end2\n", + "\n", + "# now let's look up these called/annotated dots in our pre-calculated la_exp dataframe:\n", + "rao_dots_idxs = list(zip(bin1_ids,bin2_ids))\n", + "la_exp_indexed = la_exp.set_index(['bin1_id','bin2_id'])\n", + "\n", + "# these are the rao-dots that we have caculated locally adjusted expected for:\n", + "intersect_raodots = la_exp_indexed[la_exp_indexed.index.isin(rao_dots_idxs)]\n", + "# we don't have for every rao-dot since we don't get close enough to diagonal and\n", + "# potentially treat NaNs differently." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### obs/exp scatter\n", + "\n", + " - let's plot a scatter of obs/exp for a subsample of surveyed pixels\n", + " - highlight called rao-dots on this scatter plot\n", + " - we need subsampling because there are a LOT of pixels" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 130, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAEPCAYAAAC5sYRSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzsnXd8HNX1t587ZZt6cTcuYGNTXAADoROCKaF3cKg2IUAKIQRCGiaQEEhIAgmEF4ceQu+92xBCtU2xDbj3JqtrpS0zc8/7x+xqV7ZsGduyJH7zfD7j3Z2duXNnrP3OmXPPPUeJCAEBAQEB3yyMru5AQEBAQMC2JxD3gICAgG8ggbgHBAQEfAMJxD0gICDgG0gg7gEBAQHfQAJxDwgICPgGEoh7QEBAQBeglLpHKVWllJqdt65cKfW6Ump+5rUss14ppf6ulFqglPpcKbVnR+0H4h4QEBDQNdwHHLXeuquBN0VkOPBm5jPA0cDwzHIRcEdHjQfiHhAQENAFiMg7QO16q08A7s+8vx84MW/9A+LzAVCqlOq3qfYDcQ8ICAjoPvQRkdUAmdfemfUDgOV5263IrNsoVqd0r5NRSh0HHFdUVPT9nXfeuau7ExDwf4J4HGprwXUhFIKKCohGO95Pa6ipgUQCDANKSqCoKPf94sUQtoWS2rmI60E2JYphYPbuzfyaSoYP37xjbYoZM2ZUi0ivrWnjqKP2l+rq+s041pdzgGTeqikiMmUrDq3aWbfJ3DE9UtxF5Hng+XHjxn1/+vTpXd2dgIBvNE1NcNpp/uuVV8KgQTB7Ntx9NxxwANxxB5hm+/s++SRcdBEccohw4B5NNKdDPPp0BIBnnoGBA2HpUr+dCVe2cELLFFKvv4pdWUb9iT/mFw/vx6VnwC23bP15KKWWbm0b1dX1TP/4gY6PZeydFJFxW3CItUqpfiKyOuN2qcqsXwHskLfdQGDVphrqkeIeEBCw/TjvPOjXD158MSfiZ5wBv/gFHH88XH013HSTb5Xn8/bb8MMfwhM3fAZ//Cnpl2sQrTnqO/vx6l5/54gjosycCYMHw7vvws9+FuNv037KqFE/pb4Oam6GK66An/50+5/zxhFAd+YBngPOA27MvD6bt/5HSqlHgH2Bhqz7ZmP0SHHPumWGDRvW1V0JCPhG8+WX8P77vnWdb52vXAk33wwzZ8LUqb71PmECXHUVZH+Wv/89/OGKKtI/OxfdkvNQ1LzxHt9edzbvDHySxx+Hc86BIUPgqadg1SqYN893wey1F1jdUaG2USZdpdTDwKFApVJqBTAZX9QfU0pNApYBp2U2fwn4LrAAaAEu6Kj9HjmgKiLPi8hFJSUlXd2VgIBvNE8+6Yt2KJRbt2AB7LsvKM9h6q+e4duD53L9Ce/SrzzJAQfA9On+zeDjj2HPxf9Cp502bYrj0vzFQiYcvoJHHml7vP794dBD/fa7pbAjIF7Hy+a0JHKWiPQTEVtEBorI3SJSIyLfEZHhmdfazLYiIj8UkZ1EZJSIdOiP7paXLyAgoHvQ1AS91huCPP98uPKSRg5/4Ei8hkYKaq4j/vwMTiy5nKUHv8n++xejFKTTcNGjJ3GMu4x9mdamDWWZVMha6uoGbrdz2Xb0jBoYPdJyDwgI2D7svDN8+GHu82efwbJlcOy8a3CrqtHNCWbrsfR3F/LTNTcy962lDB0KDz8MxcVw4kFVTFG/4TG+36ZdnUqzwBnG0KHb+YS2FgFEd7x0A3qkuCuljlNKTWloaOjqrgQEfKM54wx45x344gv/84cfwvjx0PLaG+B5THXHY+LyhTealIS5zTuVU0/2mDULTjoJkiO+xS0VP+R5zmEBuwJgxKJUnnUSU/5TwqRJXXhyW4pIx0s3oEeKe+BzDwjYPhQWwt/+BkceCa+9Rqu7xbWivOicwPWpG/hV+Boed77HpeG/YZlC2lGYJlx7LdzzYIRlP36QM/eaxcvRiRSMGErJL69hctXv2H13+Pa3u/oMvy6ymUvXE/jcAwICNsm554I19xN+cnIp9akYNV4lr0TeYoj7JbdGv89gYzF1Us7o8GwKjxrPk08ZPPKIHwEzbRpcemkxMxcfjmPBdQOPY+Zf4cIL4Q9/8G8WPY7NHDDtagJxDwgI2CRVt9/Lbnf9hYdIsMDemRv17xggq5m8138wFy+k0YuRjoe5NfQHFi4+gXDYD2MEGD4cXn8dnnjCnwB1+eVw8MFtZ6j2LKTb+NQ7okeKexDnHhCwfdDJFKuv/yu6JYFSUKZqGWbM5ankWbz00XGYhmAaApbBM4mTaZ6uiET8SU/PPQff+pbfznvv+bNcjzmma89n29A93C4d0SPFPT/9QFf3JSDgm0xqyTJQioREeTh9Hnc6PyFCkl2MWfSz1jDVPQJBkXYV0pjm1wW/o9fAAh6I/pwDDghz5pn+TNWVK/1Y+eXL/Vmn47ZkYn53oZsMmHZEjxxQDQgI6DxEBGfObFJvvIrhplmbKuXslqf5jzORo6znuTd2OueFpvBJeg8KdD1Rt4Fz7H8hwM3Nv+CNhTvxvbk/IhZ2efhhob7W4e/HPM6HV9/HXrs0ccwx/mzUnovejKXr6ZGWe0BAQOega2upn3QO7uJFKNNE0g6/Sj/Gt8Lv80rqGK4K/Y4P9EG86J5IHZUYuLhi86BzIYIiToin02fwdPoMQKMQSCS57cURfPrKW3w3fDyP/PUWTrlwDAcfDJWVXX3GX5NuFOrYEYHlHhAQ0ErjVZfjzpsLiQQSj/NJ4wjWpcsZG/mcMcYMLk0+wIPORI4tfhUPC4cwgoG0+qE1EVoy7w0EhYfBJP7Mp944zml5ntt/+iUHHai5996uOsutZBulH+hsAnEPCAgAQDc2kP7gPXBdRCCZUrxafwjfcl+hojDBbPZgn+JPeW3n0zmn7zPk3A++vJdTjYWH1+oQEEwcksS4nn/QSBljeZ8XksczbarmL3+B6uouOtmtIZjE1HkEM1QDArY9kkgiymBO41CeWTSOj5f1p6YxREhSlHjrqPYq+H7lfSgFTzScgAIUQoxmhqsvqKWSctYRwqGMKkChMxKTIMZE/sy1/IixfMB+8aeJufUceSSkUl162l+TbMrf7u9zV9JN7jJbwrhx4yQo1hEQsGU0NMCUKXDXXVBfD+m0EK938TAx8BCgnLWAiYGwjr4YaCrMWiJGkuVOP0wEF5sQLbiEuTB0G684x7FGBuBgIeTyBBfSyGVcQ4oQ93IFZ/D/+HzUT7jk6nImTOj881VKzdjCAhqtjNtzmEx/5+aOj1V00lYfa2sJBlQDAv4P8vnncMgh0Nws7Dw4QV1NGNczECzCJPgOz/ERh9BALxxClLKOElVPo5RQ55XgeJWAws1YqWliFNDAg+kLaKEY33r1rfbeLKGKIcQp4i/cQAGN1FPGYTxH6aw67vzD1UyYsMlaz92MnmEQ90i3TEBAwJbT0pLJ6aI9duVT5iyI4Hj+oOiBvIFC8xbHUUcFDn4i93p6US9laBQeJjnXQ05CminBJQRIm4KfVQzBwMPEZRdmUENfwOArxtCXZaz4soGV9/aU2EgJskIGBAR0P9Jp+MlPoL5eqG80mOWMwiaNRZoQad7lcJIUkCSGh53Zq62lqjEBs82aLB4mRdRik8Ii3fq9RqEx6cNKQiQZwGL+xF+YzV6Uy1oWTL61M0972yEE0TIBAQFdg+f5U/8nTYKzzoLrr/fL173zDgweJNx7j6A1GHhoTBzCuIToxSoKaMLIE+tjeYQwSQrIBi+0l+krJyMeNk1UkCaKSwgDlxApQDGaD/iYw/gBf2AlQzmcp3iSCzmcp0mtWNOp12SbEkTLdB5BtExAQPssWwZjxvgZF8fs2MARY1aycoXHyJHCUd9JUVo1C53RHt368/fFfCVDaCHaxqkyn13QmCSJbVF/NCZpooBiIbtxCb/j27wACOvoTyOl7M/rIFD1wtQtP/HtRpDyt1MJcssEBGxIOu3nXb/gzGZO+3AiiX98hrItvmWaLI7cwbtNo/mKUa3bTzT+wX/0RYRI0kQpfmCjhU0ShwgAcxnN+ta6QlNMXavgO4TzbhTrk9vXIcQ/uJ7+LAYUCQooop4QDiFDM/8Xf6Jo5yFEd+7m5Zm6iU+9I3qkuAcEBGzIU0/52RiPmXYBD07fiQ9TZ6ExGGV+xjvJsUSJ00IB2UiWh/VECmiglt7kR7cosj5joT03jGDQQAUKzW7qM+bI2Dbf5u9TRC0eRuam4QKwhBH8mN9i4QGKqKkxDZAFC/l07+MpGD2SXZ6+E7uyfJtfo21D97DMO6JHumUCAgI25IknYL9da/j2O7fxWmI8e5ofcZA1lU+9PUkSpZ6sWGYnFhVSSx98Mc5JQZqCzLtNV9IQFF/JbnlunJywR4kDEKeUFkrRGHyH52ikjDKqOYSXeJJJnGo95Fd30grXE7yWJPGZs5n7vZ9uk2uyzREB7XW8dAMCyz0g4BvCunXw8oulDDLn8YFzIB95B9DbWMNB1lRMUniEAQiRQmNgkybRKuRbgsLNRNRYOK3vFRoPmxDJ1lDKFDFe4nR6s4o0Ea7lXwxlLuO8N0kbCk+DJ/6NISYuje/PJL26ilC/3lvRv84isNwDAgK2I4sWgasNLoj+i1tiF7Oz8QW1upwXnJPwMiILsKOaR5mq3Uph9zHwIC9tGPgWfZowLjY2DrvwGSBEaaGK/tRSyX68yWT755TFNKURTUVUE7V8X3aLp0g5mvTabpp4podEywSWe0BAD2T1anjgAVi8GMrK/LJ2q1YJERLc3TSJ+bILvdRabBx6qSqaJFfX7isZtYmWN4ec+0VnJMSPifcdNEP5ggJaqKOSlIrRJKWM4UN+xO+5iOfYl7f5nn0vsZD2a6gK1KcMUp5qbTeZ9Jhz+R/Z560HUN2q0Go2t0z3J7DcAwJ6ECJ+mOOuu8LChTB6NCQScMYZoDW06CjzZFcEqJMyhqm5VOm+tO8/31KRUhiZwdF8SqhBUCxjGON5iiIaqJdyVjCISfyVR/k+gmIHlhC2dGtxbEdDOk/YszRMn03NWx9sYR87kcByDwgI2Nbcfjs88ghMmwZ3/j/NjZNbWF6d717x8GePKhzCzJB98UUzFw2TY3Ntu2zsdm573UY6PBQGjZQTIkkZ67iHK6jHr8QxgCX8iimEcNiJL4nSgpGn42lPtevF9uIt1L7zMZXf2W8z+7md6Cbi3RE9UtyDAtkB/xdJp+GaayASgbFjfckWClBIxiEigMkQYyHD+Io39HehdX2+Vdye0G8K36pWuAjWBvvvzkwMHL5iLGmiNFGWCbmEHVhEX5YTp5g9eZeF7MquzMTToJS/GBvxuhiREOG+3a1Uk3Sb9AId0SPdMiLyvIhcVFJS0tVdCQjYLojAmWf6aXrXrhGGFa+klFoADNLYpFrle4keylv6KHKCvr7LY8t+9tJqCxqtawCaKWQW+3GUejpzKzFQwMGhaewTmcnuoS+5RZ3Dvup/eITYW71PylWt5xWxpH2nUTJN31OO2KK+di7BDNWAgIDNYNEieOEFP1vjbrvB0UeDlffLFIHJk+Gll0BrIUySQ90XuJuJAHiEaWtLGttpyE8y4ZSFCIoP5VAEIUWIg3iZK6N/Y3RsHovSg7iz9jxekxP4izkRW2k8rahtUURtjW1Cka1pcow2qQ/McIimz+YSHt+NrHehx8xQ7ZGWe0DAN4GmJn8gdJ99YNYsoaZG+OMfYccd4Y03/G0cB84+G266CVzHj9T4TuQNnk8cm2dJbw5ba02uv7+gEE63/s21kV/Sj2X8jKvZk/f4Cb+lP0s5v+E/DFm9hFPqnkVjcpd9CiPMrzANIWQJIVNoTJvUJExSjkkIRQhaF0OB15zYyn5vazZjMLWb+OQDyz0goAvQGk46CXYY4LHgN38l9OpDsDCBMWZ3/vuDPzFhwo48+yw8/TRUVfmZHgvsBI2pKC8lj92CI25tOOH6+yuKqedU7y5u0n/iRO5nZz5nAbvxYyZzBE9zLrcgKAYWpmhOWqwf0WgbYCrwBFzAVrmjiIDnacoP3Wcr+90ZdA/x7ohA3AMCuoA33vBF+9n9foZ6eSqkU4jAex9aTH39dfYZcw4/+EGM5cvh/fdhl12g0YvkDZ6CL4ld8xOOEed3XMLf5bckiHI0j/IkExnBZ/RhpZ+CzAAlmuq4TdRqRxCVEDY1La6ZmQaVl8ZAKUbc+mvs0uLteVqbRw9xywTiHhDQBTzwAPxgQj1qqi/sy5P9OG3WP6lKV7JXyWwGNX/Gi7P2Qyk/pt2nbcigCXRV3EaEFn7LFI7gKSaqW/mP+jlv6/HczARspYlka3ko/1ZUWugSDWvq4ibNSQNTKZRSRC0hrTWis1E9gGkw4rbJDPjBWV10dptCAnEPCAhon08/hf/+F1bNg4U1P+PbBdM4a87taAy+W/EWKR1myvvjANmk+9ZrUw1pe+B35kTuZykj+II9eI2TeU2fzHfNZ7grdCrlVGfCHPMjdaC60SKNwvFUq4bHLI2hFIUhTTrtR9hoUcRsh2VX3UDLjM8ZducN3WyGKoG4BwQEtCWZhPPO890sZWWaAYMNpEZx4qy7KTBb+HjcMXzVMowfzf09hcRppLSDFtcXvfZT9G4dmhAODgohRIhmLuZGFJAiTJIYRTRQajl+D8QfCG2Ta0ag2TUy63L9a3YNQDBdgxCCMhSGEmxDcJMJqh9/iYoTxlN+zGHb+Jy2lm3jc1dKXQ5cmGlwFnAB0A94BCgHZgLniEh6o41sgiBaJiBgO3HppeA4wvwZ/+Ovv32FmbM8drxgRwoiSWzlMvajV7l8/mTqnKI8YddfI7CxMyxclzRhJJPxcT+mth4lTIoSagkZuVQE7RnZrrCBsOcw8ARS4rtlbFNa29DNLVT9u5sVzhYQkQ6XjlBKDQB+AowTkd3xvWxnAjcBfxOR4UAdMGlLuxqIe0DAdmDZMnj2WXjgnzMIy1ccdtByBg9sYvLNe5NwIxy8yzyiVpqyomYsnNb9/MQBRt7n7e0SyGaT9EMfR/JZ3ne+iIXNnJiJbGjXblzqcq4bAUxDiIa0H0qe3anbeUAyPveOls3DAqJKKQuIAauBw4AnMt/fD5y4pT3tkW6ZIP1AQE/jqafg+OOE++9Pc98jxxGP2/Tp1UJdQwhQvLloDEo5fLZu5w3S59Lmc+fYYwq9ibb9dL0xEoywF2F6mQLbSggZ0po+YGMGq9nhA4XviomGfFFMpg1AYRTE6HXOSVtwNp3M5ol3pVJqet7nKSIypbUJkZVKqZuBZUACeA2YAdSLSPZRaAUwYEu72SPFPaihGtDTWLgQHn4EHvT2ZdiQBmrrQ3y1wHe9xKIOTc1hyBTTyMcvghHCIombqWvaGbQv7L5LSDAZwlesYyA7O+9j2RoRhQvEPQM8X8AjZuYZQ7V1wJgKbCW4gEj7Sh82hLRnoO0IohyMaJiKE8dTfmw39LdvnrhXi8i4jX2plCoDTgCGAvXA48DR7R9wy+iR4h4Q0JOYPRv++U8y1q5i5WIbW6V5bOIdnH7PFbQkbAwlxCTOjqXL+by+NfYRN+MW6Uxhbx8/C2QRdfRmFesYyCT+hIGmxcm/Efhi7YnQ7BoUWr7Ai2T97742FUU0aQ+a01br00g2+NHCL7NnKcXgP1yJbopTesRBFI0bvd3O9uuxTQZUDwcWi8g6AKXUU8D+QKlSyspY7wOBVVt6gEDcAwI6kenT4eCDwTKFqGrkgdKzuLz+HwxWi/nBPefnJiWJn5Pl8/pdurrLANik8LBJUEAdvZjETRzCy5lv28s06a9LeYqQ4fvPzUy+MtvUFEVd1jSG2nk+EEx8cY+aJv1/dG73C31cn22TXmAZ8C2lVAzfLfMdYDowFTgVP2LmPODZLT1AIO4BAZ2E58Hpp4Nlepwx+hXGzH+VSbX3kZIwL5d+h8Pr3qZZF1BgtFCny9HYdE7Ey9fDwGNHtYBVMpDzjX9yhnUfojTNaRMtsGGWySwq8z14GuyQnxQMFA0tFinHaHc/nVmbTAvJpSuJDhnYOSe2LWgz2rsVzYh8qJR6Aj/c0QU+AaYALwKPKKV+n1l395YeI4iWCQjoBDzPz+SYTEJzs8KIJzjWfJbLCv5Kghjj66axVvclTYR6XZbZq2t/jsP4gnKqON54nF/YkylUcc6w7sNUGlOg2NYU2xpzo2ltJS83u8Jxc0LuaWMj9y3VWrgundbM/80t2/istjXZ3na0bEZLIpNFZKSI7C4i54hISkQWicg+IjJMRE4TkdSW9jQQ94CAbcxHH8GwYXDffTBihIdlujwy71hOrH+Jve2PiNDCIGMJ/gShxHrlpbuGHxo3cbA9lTilfDf0PNc5f+IC8w5M5btflFKthTUK7ax4tY3rAT/5F2QSf+VpnGVubLZt9uwVCkXtG+9v4zPrBLZdKGSnErhlAgK+JiICWqPMDaf/z58Pxx4L//oXzJgB4rkM7z+ffz85kr1DH3Jc3cu42PzPPRiFoDfq4th+mHi8q47gc2csu1uz+HnqDiaG7+Q4eWyDbQU/i2O2HpPOSLOBH/Hiu8v980l5BjHt+da8QFHEI54088I7/X01qtXKtMt7QAGebiLeHRGIe0BAO3zxBaxcCb16wZgxfuSHeB7N//wHifvuQuJxzKE7Uviba1nS62DuvBPmzIF58/yi1W++nOC9Dwzmzjf45WXNWJbHA/HzUWhOjj3Bl+ldSXoWi2REF56lPzGpv1rOIj2MPsYajgi/ymmxx+ljrKW60cbVuYpJzY7CyQtlNICYIevlkWlrnjenDQpCGssUikIejgdJx2rdPr8yqwqHGHzFxE48321B98nX3hGBWyYgII+pU/3iGUcdBTfeCKec4ov1c89B/E830HL3nUg8DoC3eBGTT/2Eg/ZziEbhsstgxQrhnbcc7r/L5bzUHymPNfLQ08PR2kCLoqDQ46nEaSxUI7tY2P2ImB1YQhOlnBN7gP/2OpAfF91GX3MtAGE7Z6E2pY2MsOcWDTjiR8YYKuuHz4m/AI6nsAxNNOTheIqkY5Bfjk5l3xuKQT+cQOGuO9Hw/idoN5fSoGnOfD4+ahKvFY7lrYEHs+jmuxHdldZzUGYvIKBH8eqrcO658M8/rOZ49XfMVV8hvYfwevQyLrxkEL826zklmqsM9HjjSTxeexzf2+UVXn75OO6+G1wXpuz8K9KOxZ8W/ZC/7nQlFy34C0nPxDQ1p524gLsf3JWUs70zOvqojI/bJs2evMfZ4fv5dsmHFBptKx7lB4Wk3Wxq4Q0LdnhANOR/qwUSaQOtc1EzliFYhtDYYpJ2DcKGtMqfARTvO5r+v7gEwzKZO/FXrL3rcb9l22b3x28lPGQA7+93Bl68BUTwmhMsmPx3EotXsNvtkzvhCm0GPcQtozYnyU13Zdy4cTJ9+vSONwwI6ACt/UHQKb9fwmGfnA1OKqNuCuwwM0dcx1GXjGXG0P1wJMTjjSdyQ/VVpAmxf8mnXPvMvlx4XooVyzSDIisZFlnCR41jSUqEvQs+4Z2m/fG6/EFZYyAIBr8L/Yx90i9hG8LQXqm8KJfMlgI1jRYp1yDuZPPbbDg2oBD6FPrinq0wF08aONq37MNm1qMuGQsfUi7YmZwERmGMPee8zocjjvQFPA+zIEbpqUey6sHnkTxLHsCIhPj28rcJVZZv9tkrpWZsatbo5jBu937y8VPndbidMeKmrT7W1tLVf20BAd2CN9+E8nI4rOp6SCfz/KoCTpI91/yD0dE5/KH6KvZe/F9ei3+HZing5JJniYcqmTQJGmocLur3IPsWfcK0hv0pD9VzQMlHfKfs3XaEXWPgrt+NTqNCVWMiFBlxni47hu/az6IARxusrrfR2o9uyS6r6mycTP4Yy1AbiL+Pb5VnUSq3CH6+9vzdsm24eZa9MgxW3vZvRGsMpTEN/xUE0ZqaN9/fQNgBjHCY+FeLts3F+VoIaK/jpRsQuGUCAvCjXPbeG1j+Zfsb1KygbKdyHvh8AjcPnszqgqFMn7s3/z7uD1DRn2uNR/nTLTEm7fwIB3/2FIPCK1id7oMIzGwa1W6Terv8/IRxoekMDK3i2NhLHF34GqmUMLcu3Oohb0yZNFX5A58aSLkKT6tMcKLve4+ZQn2ydeiTbEqz4rBe72jgkImk0WRyEAim8iNpslkjk54iZgniuKTXrMNMt4CRS1kggJtMECobTHJlVaaxHDqVJjZ0h866aJumh3g7AnEPCACKivyapuxWAg3r8LTBy0v359F5R7C2pZwV8X7Mqx9EeSzBPY3nM2fZMLQoViV6MaB2NT93j+ZP8jbP1BxFkdlMxEjT4BXR4G2sBuj2eWg+rfBJbu398zZ51g0DSqMe9Yls7VJfqlvSBqIUYUOIWH7IpydQENEoraiIejSnDVwRbAMKbI213tCBwh9EFSCpFRHTX2eaviY6nvKfYkRwMSgYPJDkF/P8ffMmQCmEsC0MPP8EvvzNP/BacmMCRiRMr2MOJTKgT2ddtk3TQ8Q9cMsEBADHHANvvQVVe1zIOrcvBz5+D9d/+H3G9JrHV3U7UlRuIwK91Go8MbGUh0I44KUH0QJFVpxDKz7gztXnsDLdh6p0Bb5Idc3gm4EHCH+s/E0bYRcR6psM6hLZePPc4qEoMDVWZrKSafi52osigm0JlgmlUU1lTFMc1phGTuey/vaWtGpt18s4ZQxDWoU94flPAwaKlKeon7eC5pmz2/Xmaw3pF59nrxfvpGDEUJRpYkTCDDj/JMY8+OfOvYAbQ7ZpPvdOJRD3gAB8f/ukSXD27Sdz8ltTOGDALF447Zesbu7FwQPn4C33wwPr0kXsXTmLi0c+xqiy+axo6c2wp15idXMFPxl0F+vS5QiwyvGtys7Kv74xiqklRIIi6jHxsHBbBVhrSCQVq+o3nsPGE9X2ZoCitsEkGtEoQ9Dix7q4HiTS4Hg5P33SUcTzMkZmm0l5/mSnZs/ICH+2Q4JOpRG9cUs4NftLSnbdkYO/eoXDG6Yzvmkmu9/xO8zIhumRtxvZO9mmlm5At3LLKKVOBI4BegO3i8hrXdylgP9D3HgjHH644r2v+vOReSb/+Ox0XC8nVgaai3vdw+3LLuKRQ67k9i/PpE9kHcua+zLTXdnXAAAgAElEQVT4ydeJGi04WGz/GadZ77mgMTDR7M80qunDilUGZcUmlil4Wqiq3/hP3nefZEsp5SYvOVqxpsb25+/gu088rTCV4AitdaNSOuuJ96NoKgscQibEE2YmgVjWpm97fRwNtsF6JfqEkCWgDHTST69iFcS28jptC8RPHNQD6HSzQil1j1KqSik1e731Ryml5iqlFiilrgYQkWdE5PvA+cAZnd23gIB8/vhHeOedjH8Yhef5ghkhAQiVqoo/r/oxWuCUqbcwomQxa5O9MTJpBJp1IV2TSiB3zMEs5Fp+zAz241TuxXHBdRWe5+eSryz1MkK7IQKIp9oYn7rV7ZJzt4j48qzFX7J2qsq1QknEozSqiYU0vYodDCWUhnW7V8dpjZ7JTQKyMpWZrN6V2DsM8N1JH3zKupfexqmt37rLtTVkJwAEljsA9wG3AQ9kVyilTOB2YDx+KamPlVLPicgXmU1+k/k+IKDTqK+HxQscYove4d/3pPnzG+PZY9cUFf0LqKn2WPhJPY2UoRDGh19jRnpvWiRKSzrGkX2m8X7tOMJGGkebdLWH0ybJj7mGdWowN8qfmcCd7K3epbzYQ3uQdLMzQ2FwL4dFVTZa50utYCNofH+4ofI1qh2PuPIFX2vf2lfKt74BLCX0Lmobvhi2NVoMDJW7YeS1RsqDyoiLoLBMwQxbqFCEgXf+jcSi5cwYfwHpdbVgGEjaYadrf8zQX3RRIbZuIt4d0el/kSLyDlC73up9gAWZ9JZp/MT0Jyifm4CXRWRme+0ppS5SSk1XSk1ft25d53Y+4BvJihVw3nkwZIhw/vGrOeSCsdz42hH0jlRzZtndTJvqsXKV8MrAEzg0NJWQShPXhaQJYWdi019deygeRiYBbFfMNvUFJkyCMC30ZxkvcDYtqpi/qXM4Rd1PLKzRHnml7XzLOx5XVBR5bdoy8RN4pTxFwlWkMul6249vz7SWjWsnp3dWO9srBXYmK2RBSNPeFH0TRX2LTcoxcMSibOK5DP/oTaL77sXMoy8ksWQlXrwFrzGOTqZYeN3t1LzVRRkkte546QZ0lc99ALA87/MKYF/gx/jlp0qUUsNE5P+tv2OmyOwU8Geoboe+BnyDWLECDjgAzj49yWcXX0//hlf5yX+v4oM1o1ga78/S+l44rsH5Zyxhx3R/znvqQd6uOpj3nQMI04KD3dpWsxMjJ1Jt86p0JrZKs2vxQno3fMU+TONbvImZuekUm34WRsdT2Ja0W7NUKYjYuZ/OhkOg4IpgyqaLW/ul9PLi17MCb274s8yGR5rKj41PuQoXBYaJcrzWbJIpM0bBIfvR/8bfAtA4cw6p1es2sJZ1S4Llt/2HisP26+BqbWu6j9ulI7pK3Nv7kxER+Tvw9+3dmYD/O1x1FZx7ZpIfvHkoJTu0YPS3mVU7nOGlS/EwuGP2aQDc9PfB3BJ+CC+ds8xTZAf08oV8/ddtj60cHMkN1D60zxV8t/dU5n3qUbVcWstHkClzVxTxKC/WOG62YEYuxW44JCgDUl7btLvt5Y1xMi6XjW2jlLRa7dkKTQqhJNrWJaMFGhN+JSYrmxZYFI4yKB03CjOdJv7JlxiREH3PO5lhf7m6dV+3ockPzG+HdE3dZly9bUx+0p1uTleJ+wogf3rZ1yoEq5Q6Djhu2LBh27pfAd9gqqvh5Zfh08vvwquuQVfafFW7E3NqdmJm1S4kvBAV4XpqUmVUFsWpbiraSEvbb9A0TApTeSjRDIhVsaylP0OdBeg6hx0HgtMM1bX+wG9YQUWhS0Wxbwk7rqKuyb8x2bZQXto2yiPlQjxp4TntHBhAshNMJVPAOuPYUf4TgZsZTI1agqEUIUujPYF8S94wqIsrXM/ANMikEFYZfdTUT5/N+PrpKNtCWdYG9VOL9x6FuBtGpxixCH1OOXKrru0W003SC3REV40CfQwMV0oNVUqFgDOB5zZ3ZxF5XkQuKinpAYn9A7oNCxbAzjuD/d8XIZXiy3mVjH9uCgf0+wRHG3yrz2wOHjATW6Wpbipi2AB/TKdvYTUAZaE6NreE2rYijY0jNqbycB2wDZe+dhWIb9AOGyZEQhpLacKmxjYFT/uiHLL9yUegKS/1MAzaLDv08hi3t2C263uRTBUmP3JIlMIwNbGwi2kISQ2OKEK2UFKoKYx5OC54YlDfbLG8NsSK+hCNg3fHMhUFEY/CiEdR1MukB849D2jHxbDtdgtjW4UFjLjlVxixSGuspBGLEB26AwMmndoJV7wjJBcmtKmlG9DplrtS6mHgUKBSKbUCmCwidyulfgS8CpjAPSIyp7P7EvB/m2gU6urAGFoBwF/X/JAJ5Y8SqbB4a8W+XLjbk0z+8NKMC0RYuLISgDVx/7VPWQN1a8s21vwm2LCIxeYSo4W0hDAMYVTBXKLWLEqsOCJC3VqPZKNmSC/BMCCZUjQ2GTS1mBQXepQUaJJpA8tq/9gKWDbPpd8OIVYu9WevZvtqALaZ80D0LvBdLVogngZbCRHLHyRtiOcPKPtWvZO10BcuwFC5Zx0DiIQ86pMmoCjYdRh2ycaekHx2+P7pFI8ZybLb/0N6bTW9TjicAeediBmLbtE13SoCt0wOETlrI+tfAl7q7OMHBGQZNcrPtz734J/R94NZvJI8mqnpQ7jmy99z+eB/csV7P6MhWUR+xHY+X60dAoChPLR8nQiZLREDoUC1MKrgK44omUqFXc/1K67gkT5nkohrks2aVJNHYWEuaiVkC4Uxj1VrLRriJtGQRgsYpu9nV0Zr05nBUH+Ac8USGDAYVi71J2pZBq21Ux0N0VDGoy/+TFRLCWZ2CED8m4FkfO6CH2kjKMxoGNPL5YQR8Yt+tDi5cYD06iqa5y+hYPiQTV6Nkn1GM2qf0VtwHTuBbpJeoCO61QzVzSXwuQdsCY4D++8PR/98T5T3MUkxuS19BSmifJEcQ0OymPwwvdJInPpkzqpUaATjawr75iLsrj7FJsUc9kChOLJsGoVmM/+pPo2okeChHS6gb90CqprB00JlRduxRqUyScGKPWrqTRqbDQojHoVF/vqs20PwBzVdFxqa/XNZuVQoDGtU3n0o4QoiBuFMGGPa9WemWpn4yJz3wf+c9LKTmhRWaREDvjWCxLsftLaXdFUbYQdIr6tjxnEXc9CXL7frlumW9BDLvUfmlgl87gFfl5YWv3Te4kXC3mMasSOCaSnqx47nv87BPLPqMIxWf7ovQI5ua/ts+zwxWZHw6M0aCo1mRljzeLToRD4ddQiHF7/NHgWzuWPolby9y/EMis/y95KNBpD4YY4RaT0L29KEQrQRzux7x1U0teQa0l7bnOxRC2xDk3YVSVdRn7RaqyxpaSvSSgkxy3fVKOCw2o+pOO1YVJ7rZH1hz55McvkamrskN/sWIJn0Ax0t3YAeabkHBLSHCLz9Nvz733763gED4IIL/JqoZ5yu+fB/LmnXBFWAFn8a/bQPYxTZTdS4pcTsFpqdGIIibCRpTkc6uce+0BUT55boDxhpZiZoa0gthWN6P4VtgZMU1q6T1iANyXOrtEd2u2hIY4c2cmSlSKbbVldq74ZhGpByDVoycequVplZprmMj9mJToYBpgazqAClFBVnnUT1nQ+QWrQEkqmNO6dMA6+5ZWPfdj8Cyz0gYPsRj/uW+aWXwsCBsO++YFkwYQKMHQsvvKgoset46dprSD97MisfuIATx/6P+mQhNYlSvw2nsDXxVUpH6LyQR2mtwmTicmX4upywZ9CeULtas26FprFW2kTfaSDtGqRSG+qM1tAQNyiOetgWbdws+XgaEqlcrLuhNpyNmpt96vvQFeCKylRS8i1411O4Hq3pChzDZodLJwBgRCMMe/lhzHAo8ySw4cxUAGWZFI0ZuVlXrlsQ5JbpPAKfe8D6TJwIBQUwdCjcdps/eFpdDYkELF7shwN+dsfl9KpoBqBvWT23fus6XvrsOdKSnz628/2+Ng4OIQw090dOZhdzTt5xBaVybhXDbC1mlKlPapJI+zZZc8pkhz4OkbC0WvLV9SZNzSZ9S/1MitoDxwXbylnmWf2pbcyNHUStDQcJs5OTBLAy/TLId63kfO8igiMG5Wcey06Tf0jLBx8jrktqxZrW6fgFIU3CVXjZ7JGmgREOMfq+GzFse4Pjd08kGFDtTETkeeD5cePGdVHmoIDuxPz5fg1U2/ZnoD7+OMQyk0kvugjuu1dw3NxDat26EBddcQZP156UKfycz7ZKI7B+O7nPFi4FNPOv6AR2MuehxR+sNY1MkQwLIiUmXlqwLY0INDdAIm1khD0jqlqxdHUIyxJsE1JplXGXCGvqwwys8AV+7VqDslKhsNCfYJRyFItXWng6F/aotX/srKsna3x62p9wZGUia7z20hkAZsRk96lPYLlpFo4+AEml/clMqTSS9J9SDAW9Yh4JV5F0DYr3G8vIu2/qMFKmWyF0mzj2juiR4h4QkM+zz0JJscfF32/g8svCKLOg9bt162BgvzSLl4e55enj+NVZT3DUddfzVXxgO8K+LclZ4n1YyYFF7/Jk05lUsobLIjdzhPUiYZUG/KgV0/LFr3KITcVg2zcOFaSTwvyP03iOkHRMNrzxKNxMWt/8dY7ri7hfs9Sgpg7W1QqNKQVtEp3lfOkChEyNzlRBcrXK5Kbx2/bEP5/1+yBAMmmw9p7H0M8/hY43t7ZsGBC1/TFGxzPQKGK2UFgWYdBVk3qWsGfpJm6XjgjEPaBH4jjwzDMwbZrLe+80smJFCZOOfwJWNyMFo6H0MJRSRFUzEVsoinjcO+0I7JDL7BWDSTj+YGlZuJ66VGley9vSLSNUmLX8eadruXrNHzHQPFlwNCVGY94mQmFU42mDwkqTisE2hqnwRFi7xKVujcYKKVIJv/pR+7TTZ+Vb+unME0s2pj1qQ2K9dANG5l9PCwmdfTL4mtfB84i/9DrRjO4pJVhG9j0oEyxTk0gbaDuE3a8PxUcd9vWO0S2QIP1AZ6KUOk4pNaWhoaGruxLQBcyYATvtBLffDsP6fUHfynq0KMaMP5P33y1Gaqfjvnwz3h/O4NjETTi1dXjapLqxiOseO7tV2IH1hH3b06JjnD9/ClXxcn5d8GuKVGPGR+0/3UdCulUEywdYvrC7wpz/pVm1wKOlUWhu8K1l29SAxlCSsbez6Mzn3DoRSLVj6YfaCdFXbd5tXNRtUygrdP2pSio7NiCt7hyrIOo/huBH2ag8N0/2fTiiKD/rZIa9/gTK6oG2ZdYt0wPSD/RIcQ/i3L+h6DTEP4f6NyH+mf95PZYv94tZ33orTH0rxU/Pf5PrLp8GIly21wOceOHJLLp3FsYHzyIrF3DS4FdpSkVpSYdw9fYatBNGx2ZzSq+XGFv8BeVWPb/Z8R/8cv9nqBzoC26k2KDvzjaVw0JESw1/sNL2lXDdchfD9SgKuxSE3dZcLBFbU1HkUlHkUFnsUBx1sE2XiC2EbU3E1hjKz5ceMnW7oZKWLZks9H5ckMWGIZW5G0VWpPz3vYodygpcdqhMUlnkUFmcJmT5xzFiUXr/aGIm5EY2eoswLYMd/vFHrPLOval2HpkB1aBAdkDAZuI2wtp7oOFtaP7Mf117N7htn85uu80PbzzpJEDS1NRFmfaQgW04/OaVi9ihdA1/ffMkiAppM8TvPvsRVYky1h/cDJnr3zh8IcvmRf86FKomsgnFIjRzovEIacdiTstIdipYzjN7XcIvh03BNBW9B5sM3zfE0H0jlA8PUzIyRvnIKJGw0FTt4aY1qTVJiqMuBRFNYVTTq8TBtjxM0w89zCYGC9tCUVS3mXgUsvzydCF7fevR/+y6UBjWRAzByuRiz9/GUL6f3FBZgRYsQ9OrOE3I9s/RMqEw4vnXtLAYIxph8OSf0Oficyg+9QRUdOO1Ts2ynirqeQShkAEBX4OGqaD9WqU+ru/brH8TKk9u3eyRR/y0vQCPPl7IpRefx7HD3ubcPV/msc8PY+66QcxcOZK3F+3BvOpBuLq9VAGKtJc/uyc3SOi1+UnkDx62H0UzgGVEpYkF7Or3iW9TJA0YHuy5j0E43HYfpRS2KTiNDjrhi2W62SOeNLELbeJrUhjkRNdQ4HqQdsw2T/uWIRREdMb9kSvKoVQmZt0AvZ57QOcVsLYtQdy2HgRDCZYJjgfKEDxPYVuaorBHY4uJ4xrEwr6/Oe0ZmGeew6gLTqFgt2GYhf4gdr9bbqRw/Lep+d0N6OXL21QlUtEoJRdf2M7/Rw+jm4h3RwTiHtA9SC4GhHizTTJlUlaS8gtFpJa2mY5ZVwf9+8P//geXX+Yx9dZ/M2TVc7Q0Q+/Cem5772QUwtx1O+CJiaU83EwumN4VjVTV5BKDgW+p+4LuVw9ty6aE3V+3hr54mdIEB/AaRaoR37EhrF0uDBrW/mCnJDR4oF0/5W7v/tBY5WIY3gZHqo3brcUwsrjaj4YJ276Ye3l5XkSEgrDr+91dA60VKQc8bbZGsGSt/ITjh1EqlJ9vxoO0VpDJ6ug5BknHIGIKLWloSRvEQpomooy78kJiOw1qe2pKUXzsURQddTjrfvEb4o89BSEbHIficydQeulF7f3v9ywCcQ8I2Hxee2cIf75jD/73cX8iYY9w2OX7Z83myktmkp8Qdscd4ZPpDfzt97WcsvcCLvnnaXw8fSKeNvIG7wQvk7bXzUvyVV1btEGB5pyl3lbYK60aqt1y2rPWswnEImYK1zMZzhesYiAX8+fWbUQU8cYNdvW/05n8LqaAB4apiBWCakjRXJeLMgHf8E23qaaU60XaNQjbHl6ei1fEn0WaLaMXDXnUNxto8ccbNArP8y3/pAdITthFMsLe5lj++7SGqKEJW5qCqMeAf92ygbC36Z1l0fsvN1Lx21/iLl+BNXgHzOLijW7fYxDy76RbhVKqFLgL2D3T8kRgLvAoMARYApwuIltUcqpH+tyDaJlvFlOmwKSfH8l5x3/Cgn9fza9Pf4rdBq/i3sd2Y5fDLmDpsoz312th0ukfcc2vmnjh7cHc/cahfPJ5EaN2WsteA+diKhcRac17QqbsWxYtitKSBH17NWJbm/at17jrh0dmZ436vubvxR7g+gP+yVE7/Jcq+vM7LmOAWt5ml8L1tExEEBG8lK/GylSEi01Chf5S2DdEQ7PR5uazKRnJZmrMCrBkZpMmHUXaVa1++NIC3VrrNJtOIOkq/9dvKNKefySlZKPH0wJhS9O7xKGgLEpRdPMGDc3SEsKjdvtmCDvQOlV42/jcbwVeEZGRwBjgS+Bq4E0RGQ68mfm8RfRIcQ+iZb45LF0Kv/wlTH1wJuVrZzD6gmv4ZHYfjtl5KhMPegXDCDNyJLz6Kkj1C3w1z+b9Gf0RFIMGNBIOOcxZ2peZq0YwZuhyiiMt5FuegmqNNgGorY+xrqYQx93wobUyWktFpD6znx/VYlsOBXYCUAxgEWXUcIT9HPWRvry7cBSHlbzPs2Xj2cvIpbaVTKBJ38GZmaSeIFoQD9wWjWTCpE1boVRmMRTaUzSnLRIpX+C1zsz+NNoTC1+IW1Jmm9DKlrSv6H45u1x/Inae71uBZUCxrXG1b+kXRDwioY1HuSigotjFMEA8D69q3Ub/T7/xyGYsHaCUKgYOBu4GEJG0iNQDJwD3Zza7HzhxS7sZuGUCupQpU+Ccsz1SHz/MeXf+nl8f/xAPvX8Y78wdxdBea0g1x0mnizj9dDjn5OE8/vwIDFPwtGLeovKMcAumoVlc049woVBhNVET9505kZBLMm1hmRoEXG34Lhw/q3mbvpRHG0m6EWqS/mdDCVHbYWhyFufwV97gFFaqodw14Y/0LnBgSQI0eP2EJXOhapU/BiyAK1BVrRg4SNFYrQlbgpk3tqsMNohBtMNgmorqphB2iyZsazytSLkG2Up4/i7+AGrWD5+fLVJl3E75Yp79LlfIOrMOI5MODEQJzam2WSJb+4pQWeRgm9mnFwjvPW5z/nu/eQjbyue+I7AOuFcpNQaYAVwG9BGR1QAislop1XtLD9AjLfeAnk9NDdx8sy/u/3s7xfl3XsaBw2fzpxdP59fHP8TCm8/lhtPu4bt7TMe2PJqa4Pb7xnL4gYsZM2w5+46ch6GES454jojtMH7UTHrFqqmqjvH8o9NyB8oon+sZ9O6VaE3K1VbYfSFcVDeQ5U19iNhpKgobGT1wISf3f4Z+LOM6/h9xinn4xCvpvVsUlqf93RRYMZPh42z2P9Ziv1NDjLmklF672bhakbIswn1D1DabeJnAclECYZWrjJRBKcXg4X6kiuMp4kmLRNrEMBTRcoiVQXGJJhbyWisfrY8IlBe6mOu1nUgbefuIn8fGgFiBr1eJpInnKSzy4+B9V05ZCVQW+m4sFY0SOfJI7JF+FsfEJ5+z7OwfMH/fw1lx8c9IzV/4tf8WehybZ7lXKqWm5y3rjyRbwJ7AHSKyB9DMVrhg2iOw3AO2O6++Ct/7HhzzXc3AyiQH7LyCO58ZwvRFO3HDafdw9OiPOefOq5m+eDgXH/o8pbE9CcVCLF8VZcl8E8tLAhpE+HLlYI4e+xEzlwynNl4IwCEnfLf1WEnXz/hYXtzCoXsv5KEXdicrimErhQJ2G7CYGUtHcvnBj/LYnMN59+qf0Le4ltfn7MmHb/Vl7P4Ofx98LpXuCor2KMI44kzc/01BlEvaM9BxTazERFkKS4TiiMuo/W0kqTEyeXQLKkykzGbdnASNn8YRF0JRReUgm3BBTonLKxXeIJeqKkU6pSjrbTBgJ4NINJssTKhZ6RKfS8aCbOtvL4m6VBS4beJ7aputvJuZ/y5kC+X9FGLAysWaXsUunnbRWmGZgtaQ8hTlZ5xIyejhtDz9DCocpvDcs4mdfjoA8bfeYdnZFyPJJIiQXriExhdeZceXHycyatdt+jfTrdi8AdVqEdnU480KYIWIfJj5/AS+uK9VSvXLWO39gKot7aaSHhLW0x7jxo2T6dOnd3U3Ar4G8+bBgQfCA9fPIzL5fJ6sP4FZ3h685x7CyN6LWZPoy+G7zaQxEeOxH17HrMWDOePOa2hIFFKfKKRfWS2r68o3aNc2HbSYeFoxaofFrK6roDq+/phMVvIE23BxtIVSUBBKEE/FOG2vafz5tH9SuWYp0uIRDiuUm4s5F0CZBhx5IC03v8LS2Wk8p7VJBuxuU9bfRotAxMQw21rWKz6Ik6h1kbyxXGXAgF1C2GED7Qna0bTUuCgD4rWaSKVF2Yio7+tucmmu8fhyltCSNLCM3KO3Ft83HwtrbFtTXuT5baQMUmkD0/CTdyUSBpYFvforKvsrGuuhdkmK0HqTd7P1Uo2SEkYs/rz9/8s9D8VZvHSD9QWH7M+QZ/6zkb+ArkMpNaMDwe2QcTuWyMc37NfhdsZZr3Z4LKXUf4ELRWSuUupaIJvxrkZEblRKXQ2Ui8hVW9LXHmm5B/ncey433AD7jnN5/aePsFOyN4fxKP9hIhFaKK9exAlHfcBNr36PZX+bgJtSXP7ID7n4oOe45oULAKhqKKYgkkD/f/bOO86Os7r73zPt1u1VvRfLttzkhmNjm25sWrANwbRQwxsCL4QkDqG8BEJPILzkDSZAgADGFFOCDaa6YBvLlmxLsiRbWpVd7a627969dWae8/7x3G3alTGOZctif5/PfqR7Z+aZZ+7MnDlzzu/8jnFoyOQIY4/+sXpEDK4I2USZnYeW8dIzb+X7Wy7GISI0EwVL1ti6Ylje1kfvcANr27rYenANguGLz/sAvrpQl6AyVCAhBplmoAXAGHTHZvJr6ll0cZLiniIDvxwizsV0bQtJ1br4tQ5udbtyzjDQUaGSiwmHo1nJNlUY7I5J1wtD/QqhobnJbtv6jBoS7Qm7Y6PQHNC3J8ey9cK+R4RS3j54FAhcpS4dk0kbkgmlWBE6exIYYzd1BFIZOOUs8HwbAjKxEniGdI0QlXTGnCaj60dp92TyBcKDXXMuK2y+/7FfEE9HPHH+8NuBb4hIAHQAr8c+r28QkTcAB4ErH+/gT0vjPq/n/vTD6Ci85S1www3wrI397Ig28nXeSDO9vJWP8Ck+xt3mElZ3/IDYCO/46lv5xc6zWd9+gKvP+iXX/vDNgHLRhh2cuXovvUP1fPP2S3AdJZuJGM/b8EsUO9SmCnz33kuoT4/juzH50Nbr54t2HaMunUOtmEjYcWg5r9n03+wrLCd7TiPiCHs+tJfARGTOSsA0465GKedikhfX07JGcAKH2lOztFzexMP/0EGlt0LfIxWybS4NKx1yfTEH7iqixiZnfXcOW6kw1m841Gl120PjcHhQaFnlsrY9geNVN6jOY8WltYzeP45roLEmJpU0pJNKMphpnLv6g6qKZDWco1DIK12dwopVlsEThVAcV7SpBUbyaD4/yfQzChIE1L38xXOeT0kmkMBHi7MVEp++ujGPEU9QtENV7wfm8u6f9USMP59QnccxR6ViW+A11Bvq62M+/qIv827n7/kqz+LZ/JAv8PdcyzupEPCfu6/EqMvdHSdzxcbf0lIzytoPfnNyrO2dy9lxcCmtC4QPf7CDKHbwp+mo+G5MrpjCcQy5UopSFBBGLmHkkk2XOOfkDlYs6mdZ+yBvfuEt3PbBd3Hn/tN4+xX/jQj0fm4vfucI/ngR8ZzJ3nOqSn57juSFrUjSwQmqQrkJBzftsvi1C1BVSsMho/srmFjpuqdAfb2yaInS2n6kjgvVcW25vzFQjITQCOVQaFodTBn2aRCBQ4eEStkgQH3WzDDsYMcL5yh8UhUO90A+Z1v4de6O8BMOi6/7DMtuvwVpW4BJZTCuj2SyBGtW0vIP75nznIrr0vCaVyCpmX1mJZ2i6e0nuM/1BFAhnww8LT33eTz1qFTgxhvhllusGNXZZ8OrXw1zlR7ccAMkk/Bvn93Kju2r2Jk+jzbvetxKhcu5nj4WspULWclu9ss6UKhviNk6ejbdvUmec8HD3KXglUMAACAASURBVHz7ehyBL7z3ev7in67m9l01rHqohONAvmA5hkFgAJe21hDPU8ZzDi3pUToOt7KoZYRcIcErn38ff3rpVnwn5Mbvr+BlH/wbzo9+RuZTX2Xv0gi/EBIsr6Xpb87F3dBkb9SOfsL/2kK6xkMWpWx16TSII9RszHLyJSl6OiLGD5Xpunuc5hbbx1UEnEAIkkqlNLXdRPhjvOQRGpkKhXDUaAgAyYQhqA3xHOtmq8qMDkrxo8iNRxHsekCpTRsSSQiyLjue+zrE92l4xUuov/g8okPdJDasJ3PpRchcXbOraPvQtcQjo4z94CbrxYchjX9+DY1veu3RJ/B0x5F80uMY88Z9Hn8wtm2DK66wUgBXXQWJBPz0p/CBD8CXvwwvPuJN/itfgbf/rwLCKG99Uyef+39n8X8vO4ORm7cS5yu8iP/izdyEOFBfV2F4NEHrYsMlZ26mWHb5wrfPJ52MqIQOr/3g66hELh/76D4O78mxe9cp1KUKvOCCzfxqxybe8e5+3v2uw2hPHwf+8Ydc++tXceFlKa57/7e484GVfO76S/joV56PMcLa8n28JfoQZ3EHAQYvH+LWBbR9/rk4GR+peu3x8iYkH9vPsdqec0ciMni+sHCVRzeCGSnh1jkzjHRtg5AfU4r5KY99tOBj1Jnl7PXsiqhf7OH5s/eV74toztgCpLExIZWGoJpWKJehs8+3rfPm0MQRlKRvqG0UWpd7eFmHxgWGoa4yw9f/gLh/iJXX//tjug6cIGDxv/8z0Uf+gbCrm2D5Uty6E6US9VEwb9zncSJiYMCGWD71KXjlK6e+f/3r4d574bLLrLDX2WdPLevqgpPWjwPC1Vce5obvtfG+sU/zt9d+j7qffY+G2BBvTlBXF7Jh3RCv+LMR3vGuNQz0C+efdoDvffarXP7WN1KJHFSUqy/5HXf/ZhHe6BgvOvtuBkZr2NqxiuGxBK9Y9020chHmfZ+i0N3Mzw+ew51XvxsNPc4/dQ/nn7oHFPp/coCt/7Rv0qhmE1awq/6Va3ESzqRhB+j7xh5a4hhE0IdzsLbGhmyq0MjAIzkAXE9YuMqlb6czy/sWETK1gpeAri6Hcugc1U4c3hPRuiaiaamH61fp+grbflpkeNwj7U3ptRfy9g+U4aJLPrRvMhMznJDuBcj4hsb6mMWnpm0uwBPaV/oMdcVoqczYL2+j0tlNsGThY7oeALymRrym2QymExVPF4LhvHGfxx+EL30Jnve8mYZ9Aps2wfvfD5/8pA3FTKC1FfbtT3PSGnBd+M43t/GxTyzllZ97DbU1V1f1UHw2LBjhpm/eTKJ1Oecs+Cnv/9zzuf6mM7hz63LbfzN2WNY+wFfe9kkkqIHxIcLI5ay/+Vd2HlrKheu30VR6gIFb6vnm9pfy8R2v4xOnfIpVD92DDqTh0kWQj+Ghfg59f3QGJTHtx7g1DomltUgw87bo/s+HaTzVskz0ngGk1kVbU3ahCBwuofcOTa7vuIIzV/KUKYrhVMOeKoMHZirJKzx4U4n6hS6NS13CstK3O6JSsJbF6Ixcb3VsoaUNxg5YaYJqjRUO4LuGbBDTUG9oXOiT76lMTj/RNMWDlCCgvP/gH2Tc/6jwxFWoHnM8JuMuIr9U1Wf9vu/mceLjhhvgM585+vLXvAbe8x7b49Sv2oxrroEvfDHDZc9NgebxPcP73nkXf/cXhl27M3zpm+toay5OqkEy1sfG5fv5wT9/gcMjtfQMNJBNFrjwde/k4QMLOfl/f5HXXvATEk6Fb9x+KY/0LGJJ02FGC1lqXvUdEl7MC1t+zXfOfSfnNVY52lEI93VBlY5Y1+zQfyDGVcOCupDAAdd10O4RtBLNMPDRcIXeLpfFL6pDmgJ0rARjZcxQiPSUkbEjRMgcSK1NEXcUZ/0+jgOHB6zXPh3TRCKZ0I0BGOqOGeqO8e2w9oYVmzB1j2DIhLFQGRHqE4bQ1njhORNiYRAal8YFLlUFg8ntSv0hnmfj8Vouk1y76lGugHkcLwnT34dHNe4ikgTS2FLa6e1saoGn7NE+z3N/6jA6Cm1tR19eW2u982JxpnH/zGeED398E9f+9UO45iCo4gewv7OGb35/NT/72jd47qv/jB1bYjaMfwcqRWirp80bpG3FMPtGllEJXf7r09/mU/9xIf/03VegCitae/jS2/6Zq55xh9WPcX104XMwn/gCMt3DCgRGpnjmi9Z77HuwwtKaCvmiQy50GcpDz+f2cdpz1+O4ji1YApLLa6i90IPGoMp7r94G9R653UWOjDJLjUs26TLaVcZa2YkFUI6E/PjcGi6OgKOK7xsCV6lEkI9c/FlJVmGk4NPsVqxeTdWwG5Xq24jiO7PHT6Xtbid+lulJ2Gw9jOaTNF75Ivy2lqOf4HmcMJ77W4B3Yg35fUxdkWPA54/hvB4V8zz3pw5r1tjY+tq1cy/ftQuyWfs3gYx/mF9c/1uuftO5fPk/lvHyFydJJgrc8utFHO4L+MF1N3D6yX185D2/4cWv/1O+/5cPcOoF45NMjZ19K3nZX76GD7z9V1x52Q6uvGyHzRzu3oUaM2UmRWDBCoo33oFXiq3qYtXI5bsqZNp8aEoiZ7VCWVm6ZQ+je2MSaVhzkksybbnsvW/9KU3vPAt/QysH/2Ub8VCe2pWts6iJbuAQtibJH8iTSYmNrWRdSHsQK3Xn1VLeVyQcrFR59g5798Cc4lxiufA1Sau8WCgLUezY3K3qLIYOwHjJJRlMBF8ehV4zMV8XDh9SRkcEVUgkoX2hNfpBTZIFf/l2Wt85f0v9XhwfLVJ/Lx7VuKvqZ4HPisjbVfVzT9Kc5nEc481vho98BK68csozn45PfALe+EYbfgBsD9SBG1jUHHLHjfvZfH8bP/3NUkLN8N533c8LzttsOy4Bb7ziDmT3Lp73qY+x7roDrA32sreyjO2ja/nAi7/GX5xyC9q/GJob0AcPE98xgLsyAQtSkPCtwpUUSV5eS7R8PeHP9+JVQkpF5cHbYs59exr3mYvQSNnzrm1EoxFeIKzY4E5WlIprueNjn93M8JAw0huTXuBh4qkG1tORrHPZvy1kwxXZGUlYjOK4Dum1GSaqyju+m8fEsy2D68KSZTGVYRseKQdJSod00l7Pbbatp24V6x/dsE9QLvPjVYX7quNZLsHBfbBsJbR84sMEL3zpo44zD+wPeSKxZVT1cyLyDGx3EG/a9187RvOax3GKF73IUhuvvBL+9V9habUZz/CwlRa46y7bAm8S41vQwij0H4RyiU1t9Wx63TYgBY1tUJl2oxRLvG7ND3jFBV/jZ4eeQW/tMp6/cTsvOOV9JP0QJAW5EeLb9qK/7YYwJu6w95v7kvU4S2uRwAU3xF/ioS9fjBku4ZSFhc3jVJbUkiwrpfvGWPb8Wkb3ltDe8qzEp+MKvm8YPWxDKqX+aIYMwQQUKI0ZigWIhkP8JstHNJEyvjtPzSnZSUldgIYlHrm+yqSe+wSMUQoDIYEHtQs8OjpgIn4SuEoUz2W8Fd9VW0kqE6o5OkP5ceJfETDGjnfkg0AVBodd2p5z2aw9zGMu6AkTlgFARL4OrALuZyLnY6+eeeP+RwbXhe9+F973PjjjDFi3zhYobd0KL3wh3HYbNFZZcVruRg/dDvu2MGFktDBmPZ/RElRceOZ5SFXoPOrMY37djxspl63eTPKaURg8bAdrb4S6LIyX4OAg0uKhfQYiRWoCnLMWIL6Llsqw+wBUwzVu2iGVhmUvb0IqMWzrIykRstAn2ewydEuFwT4hCqGmbqp7UmgcHN8QlxUTQqUspI54UxGBmrUparKDlHoqEDiYomH8kTyVgZCaDdkZ6y/aGNC9PSQs6lQcHiUd2FBM7DhEjk9hfKLMUYhiG66Z2UNVq3IGE8ZdQcXKD7v2cxTbXqqOM8VtL4VzFyRFbSuQIPF4L4k/Pjw9bPtjpkJuAjbo01lCch5PGIIAPv5xS3vcvNmyLDZutJRHAFUDfd9De++HRx5AUtO6VOBC7yiEPjznmWBCdCwHqQTht7eghRgTQ/KqP4Hcw9Ud+lCXgX2HYXAcZ2XKxj3XQ7x1FGnO2o7RvguH+mwt/xGQYgjdRYiiSU89P2DY9aD1aI0KjkBdI6zZAJmT05gdualjbgnAUShFVRqKCykP30BDTcxwR0hpW4mEpwRVOYTxnePUnFIz6fV7STjj5Sm2fLtAVJ6aW6HsUQpdGluEXfdbwz7he4NNtApKXPXSA9cQeLZEyXOVdBqKpUnpelxnevcmJeEpjqNzG3fPpfaZ5z3GMz8P4MTy3IHtQDvQcwznMo+nGTIZuPjiORbkt0NhN9GNm/FOr3qEXmCJ4nGEXHIZLFiH3rcZbvv1ZM18sMCh2O3Yas8zV8IDh6BShkwShvMwNG6Ti45MVui4p9US7ygx2Z1ivDD3ZCMDhSnKoqqy49u5qkGcEtcaHYKBQWHxpWka1lcY3l1GI6iMRKTaAwjcGcNKZMjUukRV/nk5sgbXcSDqDynsHCexLIWbdhnvC9n9m8oMw87U7hnqt0000kFMJhnRO2J1WxxHrcRN1YvPJCceXvZtKJtVMhmlp1dwHZkWZrIPCc+16yU8QzmaydRxkgkWvOMNc/9m85iNiQKCpwEeq3FvBh4SkXuAyUtTVV90TGY1j+MXUR9a3gm9W6F/DxhBs6fCgQHYfx+k62HdQmg1mPu74YwVNkvpumAiZPlZ0L4G+vuRZSvgtavQnTvgnrtwNi0l+9o1kE0hyRDOPhe9/z4o52FkbO5EVuDgPbsFimXUS9pMrpktrqKRQmsGWZQFRxjfMkJcmd1U3hjoL6RZnE2y8opauhvy9N1XpPumEVZc0zwpGAagoSHcMYY4Qv0CH0cqqIE4FoKs4HhCOBASDoWMFB0O7nFQM1f83Jrb9oYKgWePsVipxsuZ1C6Daj/YCccxCKC+3rbvMwZiHOKIyTE8zxr0CWOfTRpMySHCBcel5vwzWf7p95FcseT3n/d5TOFESqgCHzyWk5jH0wRhJ5Tug447YfgQmBitxHDrVlt2qcBIDxzeDcuakOY0WnKQhUvs9wALNyDiovUNyATd5pzzYd0iMHnEm7gkFRyQM89Bd26D3o45pyQAouhwP7oXiA3izWSYmEqMplK4i1NTsgGNqSqlZ44QTn0aWbMcc/d2kq0+rec5mBjGduSpPSmNeDaDWdk2RrRlBBEb305kHKKiwXUFrRYRVSrQdxiWnOLSuXd2uNZSIA2ey2SPUlUYK7g4YitLQ2MToo4DjS2KU44ZL1mJBK9qyEVgwWLY/rAHKJm0w5rXv4zi92/EFIqgStl41L7g2ay47hN4DfPN5R83TqSwjKreeqwnMo/jHKpQfgAtjcBQF2jVKHaPTRn26WhM4b96PSBQGbXqYpUQHBvWkOk8SkfBqSDOHJejKLJ8PWb7I0cn/OUizI5RnDVZQO3bxMTKFYMoOK3pGVTFmrUZnECISzOHEgfaXraSfKKJbZ8dIY4UMxHN+VWB5pZ+FixzoBxPPhe8lIO4U5x6ETARdPZCWI1zpzIuK1ZV2LfHmbQNArTWVahEkEnYGDoK4yUbOnFdQz6cEhUTFUbyDo0epBOGMJ4WQxfoG5LJD8nTTmXBP/8T+okPEQ0OopHi1tXgZjPM43+A40jS9/fhsbJlckwdUgD4QF5V/wgk4OYBgFZAQ8gPVUsbHfvvsibIJmHfEFRi8AVObYdsMCUX27AYGhaC60FUxgwPwe9+A33dkExhTjsHaUzgJNw59quQ8CypPgznnlqpgrMqPVU9qgrlGF2+DFmx1CY/CzkY6LEyBIC4wsnvX84D13agobXSjmPzCHXFYR568/bJ7kRTjwQl4QNHNKiIigYv7WDCqbeAiZxrGFr2yt77SmSDiGXNTCY2k74NmYgIQ+OebYVnQMQBlHI0UwZYFXJjQpBxySZikr6i1T6qZXXpH5gy9n5jg93S8/AfraR4Hn84TjDPvWb6ZxF5CXDOMZnRPI5PSPVSiQvWClYvcHFBG5KQbYXdfVCXsHF3LwlaxPg1sOsADO6Ghgao8WHPbqS1GVPTSPF3+yjd9Rsar30OtsRz1o7tP1GM6lF0zo1S7CyTWp22YZeRMpyxEWlttuGT+w5hChUSpy7BGTkwGZOvXZ/i5He1c+jGAZxcSH0mpqYGxm/cSdgzF21QGBkRGhtm39xa4+EvTEFXiXjQinLZeiXFcywX3osdXFcnjTpMCIkJYewSxnZ9V+wbhNHZlaeqQq5kjXvCV8KSMlwQugbdyXUFyN25Zc7TOI8nACdYQnUGVPUH1eatTwnmtWWefCgCoz1QGpryXIyB8XHEGOtBLmlFzr/UGv+xXnS0BwnH0d5B2NkH2mGzg8kE4wWXkc/fY+25DhG/MY8sqp3dHEIV7exCli6C+nrYvmPCatophIbhe8cZvD2H3+Kz9F3LcdNpaGsmemSQ4b+7eXL9sciQvWotmQtq0dgg/TkaV7s0vqcNjBLtK1D8xYA9PJ2thQ5T0agZ8IXEuY346yztsbRtjMFvHiIOrSEPYwdUyJWqKo2OUp+JcB2qzTqmP9SEWJWkp8zgQ06DqcZvNIIYJeMaXKn2SqV6U0eP0rFjHo8fJ1qzDhF52bSPDpb3/pQd4by2zDGGhqA9qI5AbhAeuQskBzU6EWewF3mxOMUpH4+Qi/7EGv/KOFrMIZUyum8AdvVN3RCxEh3OM/zNO2zjiyr63vI9mj9+GcEp7VNVneLAoS7o2INcdBG4DlrKo7v3obEBA6P35xn45Sheaw11rzofzRqQMTSMGf67m9HcTN7h+Hcexl+wDj9rIIqnzLcjeMtSeCdnqe0tc9LagLCo9D4UMtYzVbdXUzuXtQV/bQ1O0hrpxMm1xKeW0F8NExshNlMeuGKfNaMFj7p0xPC4RxTPfktIunPkMaojZIKY2AhGLUXSdZSFtRX6xyZopy5NV1z6aGd4Hv8TRCeQcQeumPb/CNgPzN05dx5Pb2gZzAMosS1nz3iw8Rmw9ydVSmP1klGdGQNvaIGxTibfWX0fauvQfXtnGHGA/MHSLO8n7s/T97bv0/ja1aRXJa1hK5dshdS6tZN8wIGfDNB8eTud73+QUmcZrSjBqhaWf+8tSOAhvQcxW++h8kDvDA9/EpWY4h09+Bc3zV7mCMl6Dw0cUp6gRmlc5nFwc5lDD4aA4PtMhocUEE9IPb8NZ1qhlpNwaHlWA70/H63G0I98AxDCSOgZnhDyPXKp/XkygWG8MtVyQ1A8V8kk7HFFMQSepfjXpmP6xxQnk8arq2H1p/529vHN43+OE1Bb5vXHeiLzOE5gDgLRpEcrjuVEa5ACU7HkatezlaVGKdw5hnP6JSTXDaJMKTROGjSZHUfXSGd5pennraLuDWfgtWUhn4fde9GRCoXdFdJNQ+BtJxyNyI/k2H/NHhZftYiF/7gUN+1iNEV4w6+o3LSNOIzIXtGMasPcx6dA5ShB08EKhDqp/iiO4Dqw9JwEvbtDggTUrwjIZoRwPEIDIfGiRfgLkrOGcpMOC9+4hqEfdRIOHFm1ZJOsSxZEFEvC0IhXja/bCSaqoRzfhYaMIdPkMD5icOOY1LR4/XQOvDjCgjddTc2mU2n/s8txM+m5j3Ee/3OcSDF3EVkMfA64AHt73AG8Q1W7juHc5vEkQqOKLTJyqx2FVNEqswQNoTRuvXFxYOE6GBth7Bt7yLz5dbgb1kDHj2bqp1saCKxuhYG8pUCKpY+kFgTk9xUnBbSyL99A/V9swkn5NtySTqObNlL5+t1krlphxcCAoNllyRtW0nrFQhIL0rhpS6cUU8E9J0V4u4fpj+C8TbiHDmIq0eyoeeCQOKnWWsUjPbCREJnDKdMY6tpdRrpiDuwwbLzYx8skiEKF5OyHlwkNJkix8HVL0VxE/40H7ANtGlwXfA+8jJJKhnT2eICQ8Gw4Rqu5h/omWLRSMDGMDwnD3VNjTFSeAiTOP58lX/jHuU7tPJ5InGieO/AV4JvAldXP11S/e86xmNQ8njxocRi99ZPQuRlQeNW1EJesRXMEykV0771Ql0GSNlyiUYT+ajs1TgW++AU04yPXbJpZGer74HnIxmVw/rlI2yngpSA2JDdvJjn8dUoPj6Ex1L/xTMQTzM8fRFatRTauQ8Qh+bISWhicMV835ZJakoI9XWjgw6IWpKkdVqwm/W9/Qu7//Ji9V/0IjQ1uxiPlRviOfVOQwMFbniZxWp2VIxirTP0ORi033uhM6V4AgaisqIHCmDI2qNQ12wrU3hv7WfBn7YgLju8QlwxxwZA4fTFO0mPBm9Yyclsv0WiIKcXgghilqT6efP65gOcrYwWH5gUui5Y7OK5N3mrVkDiukG1yGT0cY2LFdaxUgTGA49Dw0Y8ck+tjHnPgRPLcgRZV/cq0z/8pIu88FhOaxzGERoCDarXbsnjoj94JY91VUnYFKuOWwu5Vi4xSWdhwITqyFx0bgEQC/c6tcGBo0oORU9ptbHy6UQxDcH2obUXaN9nwDti+b2dvovn/1VP45HUUHy4iSRe9aSty3jnQ3gpiuyBpWJi7cEmxweZyBYZKcMrJiOPS/ZdfJ3/7I7ZqFojHIvK+0PyMOlwfkqfVE5xcixrI3T+GyUdkFnk4gFQMw3eNUr8ujUwLg6tRorKSO2zvaFXIjyq1TYr4DgsuyrD/811k12UIWn3GdxWJTMCSU8X2Lq0POPnbFzPwk07GtwxZiZ37DuJNu/McgXQCGppg0UpnUlueKuNUq4UzaiB2XEbHhFQQERulEjnkSh5LVs23xnvScIJ57gMicg3wrernVwKDj7L+PI4nmDEIt6M6Zi1FaQiG96DdQ9BWj1z6LCvqFYXgOVOGGNCwgt7yfbS/E0saN7A/Z70XV5BnrobVDXMb4bCC1C6fRU4Xz4ela0i//lzSsQdBgriljejjP4BcEXwP70Xn4V/QAOHsPqSIQGjLRmX1qSBC2D1iDXt5Zj9TjZUyPgtetQD93SB8Yz+okqxAfjzGKSRxfNtoVI0y9OA4jRuz1pNHiErKjpumxMjEgVTGutzS5iMJh+xCj94fDkw23E4sy85o7OGmPdquXEHLi5dRuLmD/ANHnB6rm0b70mmGffJQLR/SJnGFwRGPKIRSaPvrOQKJBc1zdmqaxzGA6gnHlvlz4P8C/4L1m+4E5pOsTwdoGSr3oBNJUhE02QB+C8gQsvGcKS/d9Wax7/Tm69HB3mqoQlDPnYxXy3PXw4pGJJq7chRjwE9XKy5nL5OWVtRxMPd3En3tbqhUrWNcIfrhXUjqXLz1zgxyuRoDY4Up76mmDhGHsGsYCbxZxh0D5Z4QvScHe3KTzB3fg7p6d+qhpFC7IkX3z4fJH6gQNHoMDLmM9U20sbP/BAmob6uSNatRqMYzM/TdNk5cvenLB8bJbxsms7FxRtWthobcj/aCmepUZaoeebZe8R9FUj2OleFBYeqntqJibuCy7IPvOPqG83hicQKqQv4j8FpVHQYQkUbgU1ijP4/jGVEXGhWh6160OIBWBGlYCU3tyOozYWwUGpsB0J4O2L3VcslLCcy2AWSZLdVHgESAnHYBctVJ1nse7oXYhWAAUnXgJmxc3bEyA1YVy0Wn9wAVx74F7L4VlixAHIfwxgemDPsE4gi9fSu6Jw0YWFoP61sgV4D+EetBDZXRr96AGiWxaDGuG0/ed15bltZ3P5PsM1dBGCF37kB3DzGdpiMA4zE0WEvrZ13aL65jYEuecn9IykRUUj6lot0mkzSsOtW1x+IAWXv7eGmH1W9spvMHIxS6QkA58He/Y/G7T6X22YsRV8jvybH7H7czsj1mWauQTdkxS2UhkRYWrk6hxXguchEAh3uga1I7zSZS/UzAsg//Ne1vuOrxXRvzeHw4wcIyGycMO4CqDonIGcdoTvN4AqHxCOz7NcQVa9jXPANc31aCBgk0SKAjQ5Drh+13QRyjwxXMzzug0YcldVYvxhXkOa+AuiakynXX1AoodkPchLgBBDVTIZgJPnyYBy9twwqOh/bth99+C2prQdvtOIPjMyctEJyURXyxcXWAPQNwaBiWZ+w+eoowHk3aaunoYPlL6+m4fgD1A1Z877W4dVMqkPq8M2FxM3rdz2bu64hX7ESDz6KXNGHKSvH+UTKPFJkQ3xCB8f3gBpBamIQGb9Lz9+tdGs/JUO4exBVwQkPvx7bS84n7wRGGRxzyoRDjsKcngSOGTEpZv8LYB4ULXquPGZz5kItjZfcOGOgXak9aztn3/gDEoJHBzWbnwzFPBU4w4+6ISMMRnvvjki6Yx7GBFg/B4F1QHkQdD2lZao1pzzbY32nDKKc8Azx/RphEPB+tbYAHf2FpG0Yo3z1K6WAJPVQi2ZQgsTaNLFgONfXWdscVQJG4DCZC4wj15jY0aiL09lthyUpYtQYe/DnEERTykw8CZ3ED5uG+yW3cRh/xZCZrRcHkIsYfzJM+uRZvmmGfOhZhwflZSqtOwkkHU/K+gAQ+nLwMbauHwyNTGx3Z9NoBk48xB4rkD5Rs3nn6Kgqje0vs3eOwKFGhbnVAXFJ6fpun7648tcHM9cUoGlvNdSIf17ENN5rrlYUtZnJMJ3AwIUSqxBVLlSwVYf9eGKpmt5b+/dtw06k5z/88niScgGGZTwN3ish3sYd3FTDPvTpOoGObIe6AGgdqm6pGtojp6oTb/9syYZ5xDjS2zh3/VgO1dSAh4/cXyd0xMHkBl77fS3JDlvqPXGyleXVafD0uo+US+rNbkKted5TJKfEXvgdLluN94J0w1m+/L5dheAgaGvGuPJPKJ39uVSUBybhzNqQWV8iuyOAkHBv3P6LyVRwh3R6QuXgJzpENT8FWrC5qgsMjVgvHESQ77RYQYEECJ+0ivhDfl5s9BqChkh+IePjrIzO+DxI62ZZ6xrzENtDQkrJuaUQmNfUAMAbyBRi5r0xjk7Llfsc2s56+wNY+fgAAIABJREFUPyBoaaT9qhfMOZ95PIlQZtUsHK+Yu2PuEVDVrwF/ChwG+oGXqerXj+XE/tigUQmNK79/xSNhimD2I56HOI41LGEZwgIc3GHDIyett7zzuMKcbXAdF8p54jhF7vqHJw27ZAOkIY2ma6phFIMp5jFhZXI73bYNCgUoleaWQq0U0bEKenjAziE1JTCqe3ajnZ04y+oJ/vcl0FqDcQTjJSaLeGbOU3BqA0h5M7x2jRUTGssJL8dwaAgNozm3Z3AMBUqjMUPdIXFsqvkEBxYlkYyHiCBLU3iNczwgOPpbeRzJnKwhVYhiu2xvl8PgqG18HYbQP+jQecjFDyzncUIaf3IXjkPTs87ngp03Ib5PPDaGHkX6eB5PEoz+/r/jAI85tKKqDwEPHcO5/FFCxzth57/bYC6gjafC+rciifrHtn3UaztDuAE6ehiivDWiapC2Fjj1Aijus65iacjGxacrlKuCCWH9eZS/c4ft7nNKGw2feCluU71dNY7Rgx3oD38EuTIgmMVLkOc8D0oh8pKrwXdRE9k3A7Fa7xpHmHvusS5EIYc+8EMk7ULZRTPNyDlXQMYep8R7MGxBS4Zw1zBxrUewJoObqMbMAUk40GgpJeoIphhReCBHubsMCm7WJbMhg79nDxKfZrsOTP5OMfQNo72DFAYr5DoruAmHyM3grk7PDinFSnZ9mpG7RmeFfya88+lfiwtuyiGMBH9a5ejE+rmyS+AqTfXQ0+3SM3kOlCCAoQHoPChTb/winPaNT7HwlZcDMHbTLRz42w8S9fUjnkv9a15B2//5eyQIHtN1Mo8nEE+TsMxj8tzncWyg4Ths+QDk9tqKUI1hcBts+SA6p7bsXLD0Ci2OAmUkkbAevOtBQx0cemCKShiXIX8YNfFkdYzEJSQcRxIpaGjDWVhL0+evxm2y8XUB9PB++PVmGCtX3UqFrk70Zzcjz3wOUldv9ymCqkFNjJZK6L6taMcjoOC9fiOYEcik0CCNXPRKyDTYh0E5ovjX10H30GTzCs3FlLfnMLFBYyX2PTiz1S7bNQodeXK/HbGG3QAKcS5m7N4xzOA45hs3Y7oG0Ci2fzv2E33+vyn0lCj1VqzgZKcQlY6ivqiWBZM9vRZJOVMFRdhnZ2tDhFs14uJColYo5wyjeZdyKJPFR5UI+nMeokIqUBa0xaTTdsIiSrbGNrjOjQlxKKSc6s5V2fbG9zKy+UEKd2+m+01/RXSoG8IQLZYY+dr19Lznff+Ty28ejwf6GLz2p5vnPo9jgN7bmOrhNoEYKiPQ9XM03Qq1qxG/GspQA1EXmEFQH40dKB+EqATjA0hqpoCVuB7athDtPgDqQV0tEghSHmYusfDkRWugnEeSKUDRg4cgPwbd+2dfsKrISeumCNsT+xSx8gQ3fxc2nYuccy6y51aoT9gEZ7EAi06GqIBIxjaZ/o/vIaXi7JCRsaH5ju8MUXN6LYvPrj7KHhgiykVEo7OTqhgoHiiSTQ+iP76VoZ90YUoREseTWjYAQdrBIOz9TYlTTsniBkd47q4QPLuNhOuQLcb0fLmb8Z3juI7geuB7hkVNFXpHA6IKVEaV5vNbKI5HxLuHGM4DKiiCJ0oqHVFfb58OSxdGDMYBAweV8XFwkEkpgmrrWAxgimU6Pnodzc4YWpzZD1CLJcZuuJG2D/09bt18P9QnFceJ8f59OG6Mu4isBN4L1Knqy5/q+TwpyHdbpcUjEZeg4xuWN24idOkVyJKLINwCUQGt5KA4CKURCB3wM5CtnTWWVkL0zt/B4IA1wiZGl62CszdxZF5VjcFJGFIvWI8OjcG9d0BjYD2V8dkSvRoZ1MvizhUbVwOXXYPUtyPG4CxZgXZuti7u4vVIsgbJHyK+ezf6td8glYggAQQulfw0Ixwrnie0vaCB3h8PM/LbYRr+pAEtxpiKzt3MQiEerw6Qy+FJTCWMZ6QDHF/wEgIGct0RB36SY/nltZhqgtbxBKmzMR0TGkbvGiX3UIFC2SMyMhlycQIhju14y649i6bLVyCuEPfl2fHnv6LUU8R3DW0NIW619mtsUOgeDIhjK+IrQEXtjTipOjChaabK+O4OaoO5E7vi+0Q9ffPG/cnGE2jbRcQF7gUOqerlIrICuB5oBLYAr1bVx5GMO8ZhGRH5soj0icj2I75/vojsFpE9Ex2dVLVDVd9wLOdz3KF2NThHKUvUGOKiZacc+hkabrHGOxy3+i+lQfDqbXn+svMQPzt7iK0PwkC/pR6GFVvjfqAD3dMxe39x2Y6vBu64DRp82/TZcyDjz7pSwl15zI6DaDRX4tJFHr7VJiZd1+rL+B40LoRExmqh9w6hX7sVwtiuJ5b6GGSmVfF4gtPo03xRHevevwQZL5F7IAc1AW7Smfsmc8Crtz6LpBy85oBErYefcfFSLkGNR5DxiCNbiBSq8MitRX77oX4e/t4YD10/yuC2GPVrOHxDH/s+vJ++7/dTCh2iatMNVftnjJBZmOD0n15B2yvX4dUEuGkfb3EtJ//bhTTXVWhrCPE9a7BVoXswwJgpT10EAoGymcpHTz5HXYf6c08jecZps96Q7CVi8JcunuNHmMcxg2JrI37f32PHO4Cd0z5/HPgXVV0DDAOP2yYe65j7fwLPn/5F9Un1eeAFwAbglSKy4RjP4/FD1WqzmGHm7rH2GIeJRtHiPjSaVrDTdj742Tk1z2egdSVEFcJHdlHesgMK/eCmrAzvgtMs2yW7mOmnU+MYRgZh9SpYsRwyVX50HMGuHTPnFlbQyL72m22d0OLP4IhTnwTfBU/AE8tO6a8Q/fh3oMZKAkzuN4SeDujdj5ZGrYxwuhEyrZDMTrbRM7/dZR8201HrQZ1ndVkckDofZ7nVJfdrXBrOq6P2wnbk9EbcpENQ583iHYorpJamrN2v9Umc14D4Dq7v4CUcHFcwRuk7bGmIln0pFHJK5+YixUeKJDa2MnLnEPmHi3jtadx6n0pkDfvM300p9ocEC2e0GMbxHLzlDcTN9bjTfsZC2Tlqb2VPrE2IYVIV300lWXXtW2h5z1/NDrmlUzS9460487z3JxfKExZzr0qpvxD4j+pnAS4Fvltd5avASx7vVI9pWEZVbxOR5Ud8fQ6wR1U7AETkemxXp8fExBGRNwNvBli6dOkTNtc5YfIQ3gdqGSI2y3YKeAse8xBqQjj8HSjsBvFAI7TmdGh5MeIm0LP/CfZ+C/o3V/dZAYx16ZI1sP5izNAg+rMv4S5biruy2T5wBKhrhvrFNinpp6HpZMgdQCs51FSQZ57DZEs8/wy0/xDcvdV68YhNfFYM0rQaGdoOGqO5EmSPeOZXYqjzq0Ioat1MEXQoh959E7LuTLSx3XL7OnfCwd32txp5xM4z3QYtJ0G5Z9I+aq44dRPUechptVYOF0goRL0h3hkN9mEgxuqmN1kddlmcprgkSybj4u4rUuqvgILfEpBZl0ECB4YqaH8FxyjpjTWUusqY4QrGc+jdF5NYk2L1EoedPysxPmhIeIaFDRGuJwx8+n7EdWj7q/WkNjYivlD3i372/cueWUwJUzEz5RUmzntkCBMJdFpExRzFNxABUUiuX0VYLOMNjVL/jDNY/8m/IbNmOQDLb/oOfR/4KMV7t+K2NNP0zr+g/pqrH/N1OI8nEI/Nx2sWkXunfb5OVa87Yp3PAH8DTHgHTcCI6oQEHV3Aosc7zaci5r4I6Jz2uQs4V0SasIVRZ4jItar60bk2rv5A1wFs2rTp2GU2VKFyD3BEF51oGzg14MwOg8yJgZutYdeISdnA3APgNUDjxUhQBye9FU56K2oqcOfbbMxdHFh7EajAtl/gLmmHpqZpr+cK5SEYeQRt3GCNi5+Bxg3QfaetHq2yLgAIc0jbMnRTCD3jtoZ+fBhpW2erVBN1UBrCPX0Z3N2NtqURR2zzjMO5qRCICDRlkeZxtC+PeaQPp3jrbA30ZBKpdr7QQh90d0DrIgisp+k0KGai49GZtTPfFAB/cQICFznjPEhkoGOLXWCU8oFx9n59gA2fXkU24TD9TJj7hmBffsYNKCMVUmfV4qytQT2H2kIE4yEoPGNdBRMZDnz5MKakaKU6Z2IOf2YnSz97Dn57iuZnt1A+XKL7v2b2p/ETglYiJDGTE29iGH5ojMa2qe9SibmZOapggoCN3/0cNRvmbvqePPVkln7/v+ZcNo8nGY/NMx9Q1U1HWygilwN9qnqfiFw88fUcqz5uG/dUUCHnrvNQHVTVt6rqqqMZ9icVZgjbLnbWAogPPqYhVA3ktkwZ9ckFIYzeNWt9cQJY/TpwAqhpAT8Jh/fZ8EVjqw2/zBwI8r0Qx5iCDatoVIHKGHNmGsMcNDYhp51umSl1CxGvypPOLgLxkGyKaCwJkbGGvTC7YEaWtOG/+gwIXMI7ByG0WidM7FUEVp40tT7Gzv/gbvu2EIWQLtqEbftReNqqICkklbGeu+tXyzlLDN46TFw0HPrGYUzZTDa0iEsxeoRhtwuAvXnbjAOFfPWYHIHAoXiwjMaz7yGNlLFf9NhVA5f2ly6yejdYqQPxhKxXofi7brRkz7GJDHEx4uH3bba7wp98vnou1Gcj25tWpw7TOA7tr33pUQ37PI4jPHFUyAuAF4nIfmwC9VKsJ18vIhNO92Kge+7Nfz+eCs+9C1gy7fMffAAicgVwxerVx+hm0AiKO6BcnZafrsbGJ2IKR3jz4QCM3QVhL7h1UHseJJZCNIqaCtHdnVR+shvNlfE2thO8dANOU9VQl3ZCaTs4gpok5pZb0dv2QF0K5zUrES/ESXpWbGROGEzPQeJ9h/BPXWolAo72sI/KkMuhcS8cLCHrLrGHE+btA6F2mb141xYp/fIuEqckEMdAtgE56xJoXw75UbRvC+6igMT7LiW67RHi3jJuS4CqEI8KtK7BDVrBeIhnbJGU46I7DkAUIo3tVjDyoma0IzdFE5kOATJVFkilDMWizRc4SrAsA2aUodvHKHVVaLq0Hr/OY+z+HAsC5nYfIgOlGArT6JPGUhPjo3HdYyUaniIqeFmXpgsbKewr4BQqBPkSrgMDH7oN/7L11F26hKhQofdbe4gfGqSx2RCoQQKxnZwUUokYZ0UjJWmj1DOEt3ghy9/7Nlpf/KyjnN95HHd4AoqYVPVa4FqAquf+16r6KhH5DvByrMF/LfDDx7uPp8K4bwbWVCk/h4BXAH/2hwygqj8Gfrxp06Y3PeGzUwOjP4FomEnB7sqY5ZKnmm3c3GmZWj/sh/7rq965QpyDwR+gNRdB339T+e4OKjfvtmXxQHjrPsLNXWQ+/XKc8duQqAucBJpoJn7PR6GzBzJJ3I++C9JJKAxC14NQGIdM7azGF3hpnLoETu1SpJq9UyeYTbEMK1ApIJ6CF9gWdcO70FTWMnCC7KTujH/RaXgnr2D8bZ8l+7GXIqvOAy+w8e+aeggidGgnkhL81hiMA6UI1MW7/IVWnMyrFlfFVT30rgMwWoa+ETQqI44gKpB2j1JDJMiCNjSO4MBDlj3kOuA6ND63DRyXri92UthXovClXsD+NG2XJnGDOV5IazzIH/kGpZALSS1MMFemU5IOmTMbq5eFEnWM4T14mEw1dDPx3puQGOe2XaQvMIgv1F6TQUc9hm7oJf9QmXwJotipjumy7kt/giOCNL4aWXbWHEc/j+MWE2yZY4e/Ba4XkQ8DW4EvPd6BjjUV8lvAXcA6EekSkTdUkwV/CfwMSwG6QVV3PNo4TyrCLohGmDTsEzChLTiSNLgLp74fvd2GWWaInUQw+FM0N0blJ7smDTtgxa6KEZWfH7AFSQDJRnTzNug+DGGIc/klkEpYvZjaNmhaBn09NiwxwdhRY+PyNcsQNZOGHYDsQma4r0q1o9HUHEUEGtdA4fAMw26XOUhDDcHzzkSWbpgy7BOoX44EWejonJEllFVWw2bCsAN2Xl4S3fmI/aIav9e6FAjoUAjVpOTkdFWtl93YAEO9tkPUtIea4zs0PqsZv3kqzi2OzS9HY5HtoqQTsXObtmBxajJ8Y8+nQiFGK4rnQ2ZlEpnm6kjgECzNkDmv2Ta8LhnGru8g0zDzlvESIIFQ8+L2ybyDOILUJai/pAEVqysD1rC3/q9TcJMe+A66a16e6WmHJ5AtMzmk6m9U9fLq/ztU9RxVXa2qV6oeGSZ47DjWbJlXHuX7m4CbjuW+HzfCPuaOtStoLQTnMaMCqNI79zhRgbhzyPYMDY94j4sM8QMHpj47AbprD5Sq5/HUtYg/LUF3ynPg8CNw+GHIpG24ohLC4rMRjcDMPP8SZNG6lVZLPSqAl4XCTAVDAFKNkO+ZYt9MH8N18c5eCYnamYYdEMdF28+FsdtmbtTabnntRyIMIZkCxqw7MToOjocmkzAWwWgIbQm0xrNzGQxhNILeHhg9NHs8rJRu+9kZ+m8bwXGgvtUhUwflXIwsyuBnBPIRfQ9XiFMedekSmWU62WCD8QjyseVAKTSckibd4tN7b4GoYIgSAekLFjH+SIHcrhyHbjhEs1OiockhcUoL4gm6p4fEqjR1z2/DX3wEJVHBqfGpuXoN3DOI15yi8apVpE+3bCdxHTT7uO/beTyVeJpoyxw3Fap/CI5JzN0UofwAmG4I6mxRTzy95NsHf/FsTrqbtiGbGXCgdjHO6jaIfzu16saVJP/qWYgMgCmj++9CyyGE9TgvORMuTNs3BK8DHS4zJZoSQ74fHcijt3fhvOBSWLQWKuOY8rhNOo6NoPfdAf2HrBLksqVw7ktxknXo2GE41GXj1o4DdfWw5Cxw0lC7CirjqEaQbLLHVx6GkT24C9X+Dl6SWXADm/CN81Pf5cfR+sZZDwMch8r+CPeZf4p3xjqbFwgLYArovV+EoTz0lO3fBDwH3bmdaAy8NXWzJYAdyDgx6ZOmXcKBQ9kodauStqlH1qdpLKb7J8Ns//YwZ7/Zxc3btyhVJfdwkZFteeKisb1IU5Ctdekc9qnklNF/3gdAwjc0ZEJcX8n1CvXXrMdrTtL53n6yp9ThLZzj96lOt/F1G2h64xHXjIh9s/B9dO+HwZQguRRaL0cSC2ePNY/jBgoz3wCPYzwthcNU9ceq+ua6J6rsWiMo/AqiQzDRncFN2CTqBMSB4P+z9+ZBdmTXeefv5PbWqld7oQoorA2g0UDv3VxEqimxJUqkSVnLSLJW2vJII2tmPLI9Y014ZrzJmpAVYY01EZZlxki25CFteSxKNGVSIkWxuffGZrP3BtBorFWFWl+9/eVyz/xxs/ZXALqJZqPI/CISr17mzZs370uce/Pcc77vwPZz+97Kpvd5gOIY5AZw947i3j4Fnot7xwGK/+SHEH8JSdrWlSIgeR9KDXQ6zUBFIYlYdQuJOFbjdHAcuW0/zncfQA7ss66PqArRMtpqoJ/+I7iaukmiEM6dg8/9J7SxBF/8A0vLq+lAcegh2HuPdZmYrl2sLYwhbmDFsfNDMHa/va+VV9Et/DdqEvTiWVjYTEugZ1/cFsxtk6mWCH7+p/EePInkAsTPIYUBJD8MD91jE6Q2wnPQ/RUav3eBzienLQ/7pusrWg3RqxvEsz3Bu6/C2M9PwR39SCVAXCEY9Jj6b4Y58NOjzD3fJYlse1eea7H0RJ2kacDY0MV2A5ww4cBkhOPYcoFnGKuE5PzUzZMo1d/6Aiv/6ktM/HdTrHx2aVukjaqiYQKDlU0uqs1+fYFKAZJGuoB/Di7+DhpmuvO3NNLo4utttwJ2pXG/6YgusUmEAlij+5MA3EGovH+7EQconoC+t4P4dvOK4HhrLuLiP/4pvPuOkPub34d2riLR1ll+6qPVZP2pyPcDsikxRhwX+oagU0fbNRtm2V5ETNfK422lATAGpi+hz/2ZjTJZRaECe45a1sikC3EbcgO2/rVbT2l7S5NQvwzzz6FJZFWVTGJdOfXn0ekqULZvCp6PLi+hTz+Khl1LHpYksHgVfepLyMzpzesC6QAqb387PHSnNfC+C65DvGeA5ceW0NBg5jq0PvwqphaiYWI5baodwi9O2yibNGvWO9WPd6rf7tsys3LzDnsernDlqQ5LpzskoaH6THMTkdgqum0bcTo8mCCiDJSibcE32omJpusUJwOcnMPs713GtBM76BiFVszcXyzz7IcW6My2bYimMWg3tOSf3Rhcby0PYL3iGJY/t71RGW4pmFivu90K2JVumZsO02MBFaxxL90P+euwI/Q9COV7baRMfAnCl9ar6CtQ/LUPWj6ShefsFPF68HK9tTHVQL4I7RUs01aK5UV6UiM4Dqxc3Xysb8S2wXFhTRbCsEodvNZux0WDih0kahegdtGGhCahdR35gO/B+EF41zuRbhtZuALPfAn+4mNQLNk3iCi0xrE2x3YojhfA9z2MeceD8OgnwTEEnlBMThF94lEA4tM16r/+HM5ggHYNjgvOuE/+x/ZCrEjZ3ZwE1StRKFbGDjnUnqhR/5oNne8Fk1iPyvgk7D3hUj2rPQcBsARlwWSe2heXOff3X8Yf88FxmD0P7Yb9/R59zyMU9he4/zf24RWLcN//BuUczP1H647ZfHXo9F5jyHCL4BqRxrcadqVxv+k+d6cPa9y2/i92wBuxf5o22j0HCxfg/Ax4ZfToJDL3ZbS5DDqI3P5BMPOoV0TqSzbSo1KBQhG8gp0NO952ml/HBS+AXH/qZne2p7SLa4nEi4OWlsDdYNzLJVhe3lzn1EEY3gtOgk6/gCTpm0lzyQpnTJ+Fg8ewpmzzC5x223DhOahNg9uGYs4Wi1L/enEM/AHkx0bsusTKCnr6PLRriKZPf2udQ0cVmLmKPvJxpK+A9g1DGCPdDgxX0JERpDoLrgE/gMnDuEsxUc6HbtpuBbOUhncGgl61oYpbM1vX5PO2/JLiC8liev41xtfVJRU355AvCF7eIWr2HgncfpfcHcMEMwnhKzWiq5FlZ2htJoOLFru4rrGJYhN3wStfsTkH296bBYLxrTsz3FLQXeNz35XG/abHufsHoPsim//XCzgFcEchvIjW/hLiEALgNgMvfxWe+iPU9xA14F6B8HNQGkacEuSrMD6CddKlM9jKQSh2Ye759dl0vgx+DsIOLKasDK4PE8fXLY1XsLHrAGNHUheKoPlha4CHSnDFsbNs30Pe82M2w9VNf96jD8ITfwz1RVhegE/8jt3fWobjD0BYQ4N+O1u/eh4e+Ujqn4/SBdg+OLLfDkz7vwvSsozFlkb42Y+hjz0FC0040Qclb11nSNUOWGcuAhfRPbm1RCJFbNpmIUArrnVlRTFcPEvwwFvo/IG7btw3QoDQEL/UwDteRvwNVjIBcpvfQkzX0PjqCialAs6XLflZ2GHbLCzI2V25Ptt3ffsCls90Nr38iC+UHxrC6c/T/4E99L3vMPVHppn/refohJs1UJ2ccOBHBhE/D8d/Ev2dvw3nnobvug0OjWz2yYsHQ+/afr8Zbhkot45P/XrIfO5gfeWl77aG3O4AbxIK7wJiqH0WIUE8F3FdG6Z44ggyMGINO8Cek9A3ahcLoxUkCbFSDaxtOD7StxfGTtmZt+dbw64K9Q2hikkEc6+g3SYqHuoEG2hxU2MQNWw8e30RqZThntuhXIR73mIpdj1/7Ry8AO59n/VFd9PVQ5PAS4/DS49ZV0tn0TI6fuEP7SC2OtM3BlbqUG3A8AnIVRDXtwu9bmBdSMceRh46BIlBX6zBYpguLKXx6ldaNr4/0TVOFwu1awX1FjTSWbVJIImQC1+j/Js/i3tqndJWKj7egLcWTx4/t4IudNfi2nUlInlknuTTV1HfDoZqoPZolbl/fwURKPQJ+aJDruzg59ebIg7kinYpoLGixJEBF/KTOQZPFnFy6wbbG/EoPTSOTO5BfBcn79H3rklG3jfB8HcfI9g7bh+hPpdDPzHMvr92DO7/e+jZ8/DK1yBsw188B89fRqPE9lMwDvv+JpLLZu63NJS1tZVrbbcCduXM/Q2BU4biQ+mMelUWB+heSJkVt5Z3YWACGkv2+54TiJvGpvfkdgHxrOy99O+F/r1o9Qx0q3bWvhVhG66ehclTNmGoFzSycfSOi/SX4f6TMHTCLpZuvK4ImivBvtvg9Mubpx4LF6E6Ap4Hr3zBGvatMAaWmzB0DHG21u2gxSEoFmGwAMtt9GwdRnOpi2Zjn/W+DcDyvfRt4JkJu7jDAeXf+CnMlbNI9TI61yb63Rdwf3APzkQB85VFks/Ms03UNOehrRJy6rAlzzym+KUXaP/Jy2uuLkeEYDSge9EORCTQXo3qFKheCHGMsVWqXad1VlMPqhFLH5lmz32H1m+t4FF5zxT9f36OyZcfQb0ceB6CWesz/chPw+qCulH44hm75Yrwd/8dUjh4jQ7KcKvgG2D+/qZiVxr3N5RbZqtE0bUb8o1e7Bs7/WZMEDbdwzUqVNjuyX6DkQ4OTmBljDS9vIiDE7iW93y1yVubrmy4N0U8p/ci9XUga//cQFet+6Jw1oSrb+B5upXi5zJcG0pPkrlbEbvSLdMzzt2ElsArqUFS3R7auKmCGEwdkhV7zsaySSutp4qG54hnL6BJr9lsAitz0DeO9u1BTz+OWZm3/0mdfMqVHhK/cpHk4lWMUTTurqfFx10ruKFiXTOev31gEQficE0sW7sttLViRahVoTFnCbEMEPTZNP/arOVj2XbPCZS2MDAGgQ3ujkPotuzsu4cBVMeBgyfQqGZDITceUwPdGhgBTdvvOjDUt70ug42wqfTZz7X7xKo9rcJ1oFCAQglQqM2jYYL52oItvicHfoBz/xgUezzCxiDHR9bb2I6IHr20qXtVoHwkv/P4nGymRLD3atMEkgTK3ze1+ViYoC8uwKE7kFJ/7zrf+gGb+LUVxX7Yc3iHhmS41ZC5Zb5ZUIXGY9B+zvKZuz7WreKAfwRyd25gc1RIztutecVS4OLY8qV7IF60gtNugPYfgZWruM/+Z+gbQI/dhxoxRbr/AAAgAElEQVRFXBeNYswKuKd+AExi/eC1aXT2K2h9xNa5dBmtL+F0Y+gbBm6HXBkw6NzT0F6y7fICG2I4lAqAdFuwsmCzQg++08a8N2fR05+HVi2Nv3csN3rOg4nbYej2NHkotjzuSYxqel9o6lCuWCNyYD/MzMBth6CQswus579uy7geHD+KvviybYsxNrv0chu88+RKChNvRdNY/jV+G6+A3P/jyPHvRM99Ff3YY/DqMlpywHcRYyy97ttPwW371url1Uvw/BkIHOgLUHGQ4Yp1ETkuvPI4mitDvYGZaZI8PY/7vZPIqTvRQh4BvLfdhfnsM5iPp9KBjuD8xN2WuyUxxH/xCuaTp8lFBkZ94o6hXbXxjuZCh9KgQ2Mpfc9Ou6tyex6tx8QL4dpsPIqh3ZZ0wi5Ef3QR/45hgsmiTbI6V4V5xflH/2zHR1W+44fRZx6xkUhhx67eiov83D9/XW8VGb752E0LqrJNcX4X4YEHHtAnP/9vofG4NZKpT3sdLgR3QO6Y/ZpMQ3IGGpdSw74lYxAARYfvtjSzf/5bkESE51us/MkC+YdOIMUA8v2Uf/GHkGB9tqlxCMsvWK7upRlYnk1n8S7c/xPg2kVRnXkcWgv22m7OClFsmlJik46GT64lM/Hkf4TWyub2isDBU7D/nYi49o1DFWrnbRy6W7ADhEkgaqLDJ230Tf0iLKQsi4tXobMhy9MYtNVGyhXoxtDtolEH7Rrmf+Msw//qB/D29kN+FPr2Q2F4k1FSk0D9IjrzPPpvPm2N3lgROTAABybhwN7N3DPGoO0QOgnxV76Kd9dED+FuxTx5Bb1cw5kqIO95OwTBJnEQTRL0M09iLlZxporIQAGGKiQvLZP811c3cYEYo8Rtg8a6vjAbKt22welz6X9rP7nxHCYy1D+1AF2l20xYXtzyuAD+1CiHf/evw9Uu9B9F3vI9SO7asneqCme/ahdW+4fhnu9Fin3XPCfDzYGIfPVaAho3gntLef3cqanrlqs8fvYbvtY3it0/c299HYjB60GHSwLRmQ3GPc1E3WbYWf8eVKxBvvTM2hDd+sICZrZO6z89DsDIx//PTYYdQKLaeo3VufXhfegAq9mmGnehvcFK+IUerhjszNXP28XK2lXoNre3VxWaLbtYZ1K3UtJZj6FP2nZbrbY9B30HUL9kr5Ekmw072OlpYtYjdwQkcFEDuaMlWh9/if5ffAt05mH4jm2zTXFctG8K5l6EI+NwegY5MQGHhpCRvdtFnh0HKeWhL4d/cgRkdWV0Y6WCc6QC+QRGBsFzt6k+iQgcn8TNpy6jbggz85gvzW4jeXIcwS86RI31A14geIGLFBxy4zZGXTyH3FSB+GKHsGp6TtfihQad6EGKf+Ut247tBBGBow/YLcOuxG6ZEO9K475pQXWNEXGH11rd6C8Pr7/U7aZ+6U59zVAmK5v9985Qj5mWSfncYXMWql9cN2pJuLmd11q8XTXSYYsd7y1MjfPqw7Y1OWojku7mT5Owpq+6CjXb5fKw9AhO2cPMbSAJc/xt5Wxh1w6OpTSRp5TOsq/ldtBUaalXhJGABuljGuygxOE4kM9t263ta/zWG6NrVsuHZtNxJ29/n15LGPYEJZ7tlXmb4VsWeuvQC1wPu39B1R9Ld+6QdugMrv8tFZsoci2j2l0BBEYOrBn64Gh5k1pQ+NSZtUXONfgl1gxPrri+v3513YAGRTYZJxPt7MBz04W3/vHelAUiUBpANdmQ7NRjsQ4Ax76RoPZT1S7gbrum17M5CkTTHYL7NzAWhrXel4pbgIErNkRUr6xYwY5kpwXuNAug26aX4VZVqKeDWLXWe5xLEqiubK95fCcJP3pGu7iDG/rEKMmSbXOuyDYyUFvGUHjw3t7XyPAtiVWfe0Yc9s1A+e2AZ1Pjt/WsC/m71796R6xxL4yz2UqILYtro266y7DnNqiMguNReucwTtFdo1+p/1//H9reEMWiirp5SCxBFCP7QBxrPxrzsDKNJpH1jQ/fvj64hKm7ZevT4BWhegFNYiQowt5TdgFzI1wXcgZMnIYIOnY2nevfdm/q+mhhBJIQ8XLQn2abVoY2z6hdx/KMbwj1Mt2E8KUGGrkUHj6SVulA62r6oK/2gbERQnPPw7k5mEuN/5k52y+Nau+3JnHh6kVbZ2Vis06spCRg1Zb93mrDzDwarw92miRopwNqUJE1m61GcU/2b+oKVcUYpTYX2aiGTf0JwR02n0CBpBqTLEQgUBx08SreZgPveQz8zI/j73vd4vQZditusljHG4Vd6ZbZhKSKugMw/bSNUHFzMHIEdQLiixcR/1G88XGkvMdGZZgmrCyis5fRif04fSW0reiVZZzD+0FD9PwLSF8eDh8COYIjfVTy53GOTOFODiKBQjIHrQB1fOvHj2MYOmEzR/NNGLwNpl9F1SCJWr6Wggt9e1OXhkBQgsY8arqIhtbgiqSaozGEK6iXh6m7bbjk5a9bMq7xo3D4bTb8MelAYxFtTFuDnx9Y568RF4IBG/d39UXUdKB+1RrvuIm0m5bNMUqgMInsPQYoWr2Inn6GZKFN80uLNF6JGf5fvjNNlXcgGIVgDyzNQJBDixXQBJ09Q/yfP4d56jzusI8z4sOBIah1IVY0jKFcQfJFa8TjBI2bUBmGYBCef9n25WDeJmclieXNGRtH5xasMMkrr6DNGlouIo0aSa3D8qfmaD5XJz+VY/DdI/hlF6oheqaFHBqEVogutiCB+ooS9hcJ7h1Gzi9j5ttowSXq88kXXFQgWYgIX+kgo2UYLFDYH7Ovqyz85QqNSxFSKjPyK7/M0C/+3Jv88Gf4pkOzJKZvDpIauvI5eO4vbQjhaq+vzOAMjhIcvwPKe5C+A2jzCmIiIICxCRidQLwyUhqDqIPscxHXT43xl6C9sF6f1AjeMYGUJyBOZ6RpVIsmggQVtLLXThK9ADV98PXPIkfvh0IJCTZT+Gr/FKB2wTQ/aB0Tmqahq4HGZSgMAzbxRjGw5zjkXWvQR06t1WczIYsw93QaeWPWxTI0gaiK+n1IIYcaH7SNTL8ErebaG4OlKOjC6D5EBGdwD/WzHuf/4YfRjp0lL//ipxn5a8cZv1NhrkpytoX/q38PBvesZ+aOHMc51SD+ry9i5rvkfvldyJiwOp/WJIbZK+jT5+DYYeTkcRtGKYK6EcyvwOLKusvEEZjsg2OjiFdAQusmkU4Nba8gIngBDH3PILm9AVf+zRXiWkL3hRqT/+NBcnf3I48vgafIeA4FhvcJ8q5xVp6osvh0DV3TQ23Tfq7B3nf243pCYSIHR/chP/pu4q9doPvr/4U+T+k76FJdaLH8z/8F5Xe+jdydJ2/mE51hF+BWcbtcD7vbLaMRzJ+zC4upIV7jcakupqn+hyBupYZ9/VcRAUmaVohCnHUD1Zy1/uSNw7MaaC2g8XY/s6TiHtZwq5111xYhyEO+ZCkHtnKzi6xploqkeZ/irHPHFMcQcdfOWeNXL0/C4HHL67LxmOvD+N2QL29RQVIwMbK20GqgNrPJsNtiCs1FqFq6WfED+r73fvzxgfUi7YSFD79EfPAg4gruw3fB2MH1fgOkkMd95wPIoSkIE8KPPIFs7HPXsQyTe4bgjmM2Wma1Xy7PW/6ajf9xjMJ0HVohEmz2n2/sTzfvUjpRonCwQP1rDXKHisx/ZBperiOJrnlmBBCj6FOLLH10dt2wp10Ttw31S+mCcxjDmcvI3BL+fQdxj0+kv4/QPyRos8ncP/hHZPj2w25JYtrdxh218eQ7LTjGqcGNGvRcQQNr/LwNhqM113tx1svtWMUaFe5qOxYvw56DVkFJ3GtHiqy2ddUE7TAtEBE7a9/qeyc18H3XkGdbDZWMWjZ+v9clTALLlzfsUMrvPLb5Or5D83Td+uYPHksjXLbAdXDvs7NZvVzf9qCL58Lk2DZ1JS5fhXiHRfFqx4aHXgNOzqF0omQHnn6fcKYLyz0yiwFWIsTrsXhroHl1w8JvGKNnrkDg4d59YP1als6HzhNPXbNNGb4FkdIPXG+7FbArjbuIfEBEPrRSa1tf9I4FjTWcPQzihkJ2EXQVbo6eIRlqdoxIXFNoWjXifh667XSx8SYun6+GL/ZCEu48+Kwu4DqutUw9qxAbd78KVeKl5rZSXiWwM+p2s/egGifoSt3+7W+/lhq1QuBb76OQ631vglVouk4faqTEjRiENJNYrEpTLzg7+03dDeyP+C6U8hAlaH1DToDY851y6ZptyvCtB8X+9tfbbgXsSuO+FgrZX4TxQ5sjLFbh+tZnG3cg2BpBktrBVdrajb9G//7eRsYk9JTZAwjK1viI5Vlnz2E4/5xdEOwRe74tCWLV1w5oOhhsDbW0snrz0F7cfsxEMP9877bBeuy+V4RCHzvGio/dttY+DWPqn3lh/bhY5sPSiKKJwTz1ZO+nWA3JF54E38V9297tfakKr16BTmdzPxw7YH+vrRCB4SJ0u9uPbaoXao/XEE8IL7boe1sFDpS2PeHqgBzuwxvwtudLOVA5uCGcVAS5+zZQJfrCy+ntKd2mgVyeyl//6Wu3KcO3JFT1ututgF1p3Nfg9iP9E3DgTmvgXc/K2TkuptBnZ8/zz9sQvfwImjKsqzHQ7aD+MNpq2zT7JEKjDjgBjNyTulPSzc3BwFGQkuVXh7QuUHHRsIGayH738pYK4diD8PJjliwsaqY/urGGeTVsMInSfcm6PmnchqWXIGyshxeqgU4VGjMw/yxE7bW6VBWa87B8DlZm03pM2j4HDQZQcWzdquD3w+ik7S+RNHxQ4PA7QDw0CqHTpP6pzyIeOCUfp+DhT5Q49KsPwNOn0UZC/PgM5tE/svQESYR2OujyCt1/+JsQhzh3TuD90LuA1EcZJzaE8aXL0Arh1bOWFM0YNI6hmEMPjaFig3twxIpu3DthQylzBXtPabijqmJiQ9JOSJoJl/71JcQTigcCgvEcg+8fg0MlIt9DXQcNPEwCHdeHuwaZ+OXD+GMB4ot9sREYPJ4nN+BB4Ns3iR//XjQ2tP7pR9FGBzVKFDvUay6l976H4V/5u2/ao5/hTYLunpn77ueWeeJxiOdtan99GvwcpuljLn4NHZgiXAoJ9AzewBCMH0GXLyGxgcig/XtozrbwF57CqV+F8T4c00JDB2ffEZygDr6A5kmefhEjLs7hvTijFei0bMZkYcAa68XLSL4ExSHLKOhElmdmYQ58j7hlXd9BPoJSAfFKsLSM1qrI/kNQKtkY+6Rj3zYc39alCXRqNlNVxS4euwFaHETEQ5s1JDZoO0YqHmhowzJLg0BgZ7wt2wYaDWh0bfx+3oFWHdNJMKaMLl7BOzSBOAFEy5AkmGpM+5UlnNEy+WN7YCVG5+pI0oJhDxkoW4EPp2glAOdraLWDjFSIFqtwaRrv2AjaDpEwwSw3kcEScvI40qqhl+ZIrrQwxTK4IcwtozMNnP4AmRjCyceoJkhfP+Lk0TAhWqkjSQcaHSRQjOvTOhsixuAUAvwhF1Pv0L7SJekkDDy0D9OOab1QxQ9c8gMOcRTjDhVoTYe0XwoxbgEn30fpu7+TgYcfQPIJURiD5PE8F331JUxuHB2aIGlHBLcdwZvY82Y//hleI24Gt8zduUD/7AZ++8kLlzJumW8E2p4jWfoEjp+HeAVa02i7QdTKAR3My88SvzhLd6lO6ce+A+fpx3GHK5goITr7Ak7YolDpR44cgWfq6MwKUklwygFSqqFR22qT5kZI9k6x8vxlirWI4tQQMnQQnTuDmT5D9NUZTDsif3sFx38FdQRnbD/aP44zNgVBkaBbR+dOY6p1khcbuBMF3OEKcnAc+ofsDSWuZUysjECjBpfPQD6PdgzS6KArTRiuQF8Op9VG4zqyNAPLDVAfc94DN0H2lGBmDlMF5/gJnL3HoVuH+gqm0yA638IYD/+OPXgH9uDWF9PM3dAOJvkKWl/BPbKP8vGTEEWYyEUrggw3ENpILJi5WaRdw7SmcUbGkJEhVGP09DlYcZH9x5A9AzjLl6E6j1MSdDFEnnoVJgeg7uBcqOIczMFghdalKt0LEcU7i+TcLslSjFQKNJ6YR9s+pbfsp7XQofXyHJUjA+RCg1aF4vHjOG6Mt/gi0m4TRzFB2eD0CXJhljhXRJvg7PWJ+vMk4++k+MO/hP+XH6Mw9GWS8QPkf/AnMKcfoXP2Cby73kPu3g2Zp6ceejMe7wy3KHbLfHh3z9zv3q9PfPzvoIOHkKhp/dvtOUzkIbkyGqfhkb6Dnj+Dc/e7rSvg8x+BjZwgik0Aqvjr4Xmi6eKjgyYJofaT+54ftYulqlC7QPfzX2f5//gUq0Rcmij97x2leG/Fcp184H+wbvrZZ9H5V6zhVgN9/eAH6y7fJIHRU9C/D9wifP4/wOw51ghQ8kV48GEolNCvPw3lpl2sXIUXoJEgElmahA0Lu8npZZIzEcEvvB8zs8TSf/vbaK1t/fpGyT98D/2/+lM2BLNZg0IZNAa2RJqIa5kmg4rNrL3wSJps5cHY7fYzThewXzqD+cRnMOrgvnMC6o31rD2j6NU2zIYwH7Oaz61hQqtlKB7I2UVXsSIdcv8k8q6HoThAksbcd2frPPmD/557fvun6H/4HtQYRBRaDczv/zbUVmzXOYKWHJrTSvl4nlXlDUGJFoTwzy6t/Qb+dwzjnrLkc+JC/fwolV/5/S2hpRl2M27GzP2uINBPjF5fCnFq+vKbPnPf9U+u+C6ycgHJD0N3CTTGKfTh5H3ccg63nMPJ+TjH77Bc7C8+Yg37Kr/I6tiWJGDUco+zGuVi0/tFlNw7vt/qhQJ0ljALsyz/73+OtiO0FaFdA7FS++S85QEPY6Rbt77yxVcRk1iPf6GA+IE1Gqub58Lcc0hYhRc+bw17Els+liSGVh2efwxcQYa6iO9s0maVOESKHlIsrMXNCyBRB/fYMBI0MF95gerf/wPM3Ara6lqq3W5E57Nfp/2xJxA/gMow4nkI4eb6sUlWYkLrkrnyFbs2YGIYuQ1cH3FcJPAR34PjR5CTt+MOOFBr2PMdGyOOK8hYAYZ9KGAFsMMYcZTSoRyOJ7iBg+s7VqbvazNo4iGeh1fO4ZVzFPYPcv/Hf4nSd92N5AOcYh4pFGBgCOdHftpeK6UucGLoO55HVJHV39co/rDiHq6sPQPRY0tQj3HzDo7v0Ld/ntr/+39/8x7kDLsGGbfMNxMmsan1Iqg/sGOcqUZNuPBy75BBAcJk/e+NUR75PigNrifOtObofPFVtGdUjdJ+tgZ+YGfcy6+i8YbY6cIGlsi1azvge2jUhTNf3U5DqAoLs1CfZ6d4TImjnlFD4ijeOw4QPXOO+Ozsdt6Ldkj7Dz+3dttrMfG9oAkat63yEtgoHC+/lpC1ds0gQO6/E4aDbcEyIqmBzznWwK8i3/tRVAV54eymfU7gUjp5CK+0OQxWXBf2HkgVnNJrddOBeisE/LeMrn9PlPiF9SQ18QXOf6pnmzJ8e2MtMOMa262AXWncN8W5w3oooTj2tdrb6bY0VSzqfWhHuN62jFXtJr0Jggw289H1WM0Q3dL6na9jkmvwy5Ie26mhO+xXRXzXuqh6hRqCncVfr55Nx9N6rsWu6fs7Xs+eK5uPi/TuGmPQsNeAs0PdqpsTnja+nW0qx+ZEJgU2UP6KIzjODklVGb59cQOz9mzm/g1gPc49TbrxXMQrQhwiUX1zUtIaxJYZm9zZvvo7dEdzeTNlbX6I3Funev6K4gv528vQakAUQf8+689eRbe7/TxVWzbIw77bt8/sAUp90D+285Pj+T2PqTjEz8ziHt6D09dDJSjwyH///bYs7MzTDtaYO7n1zNS4Q69sXo1i9IXTsBz2jvlVLGdNdcNA1jG9J9ieC8cObdsfzS1guj2Mfn3FbqT5BIHsOMjEL1bXv/iCe7S89jXpGJK+u3qel+HbG5lx/yZB4wTNjaFRA4ojYCJMrYVppTHUxmA6ISwvoirIve+FUmGzgRcgcK0wM0CimwyNUcE88xc25hygOIa3d4Tyz9yH5Dckw/hC7kQZf38eXMfSAPdNQP/QWlw87aYdfFYHIJOq/AwcRPw+uOd7IF9eN6BOqm1673dCArjDaGw22UF1XBvT3rLUuKvH1A3QRkz82CzB99xP5Z/9JOQDm3kJUAhwJ4cpfvB7resoDi33upPrMeF1bESNX4a9b11P2Fp4ZT0WH9AwhOoK+tWvo8sx+MF6e9JFXF3oWHfJcrxmeE2kJNUYE2/g6AA4UEHGBjDp7D1pR8T1Ls9+8HcJZ5bRVsfWHUVot4v+8UfWroUIxheitqAbDbwjGC9P9NV5+90FZ6qIM2UHP9M1dKaVvp/9Bz2euAzfzlCExFx/uxWwu6NlTu7Txx/5TSSftyIbzUVMfQVDgOkq8cU68WKL1hfP0PeegxT253DGD2HCCHP6MWSliuIggyMwE+H0GyjGkM8jY/sh6aKdJhTHWD6XEF5dYvDhewn27kM8D61eJHrqRdqfOo22O+RP9hNM+UjOh32HkYmj1lCLB0tnMYvnIQwxy02cch4Z7Ef8IgzdZlkgHQ/iVC3qwgswfwEKBXT0gDWGr15GW03kvpMgbZu8FHbRZgtdjDHzXWQihzNaQtXBvNJABiZxv+MkgkHPv0jy6hU6z7ZJFtv4Dxyh8O6TSNxCL5+2byfDU0jfMKoRUihBUABc1AkgctFOFXGaiOOh86/C8jwaJsjEQaSvgl64gnnqRaKZkLiyj8L7juJUz8DSItQ66GIEWkSO7LPG+LkZ8DySsWGqj04Tn75C39EC+dvKyHARHSjTON9BvCFyd+yjfm6Zhc+9zOAd/QzkDVLZi3vyKNJeQZ55FGlWUVcwobFxMa2Y1lxMUsxRvm8AfIf6FZf8PX8NeeRPMZdfJS4PIO96D56egU4NHXuA0g/+Ek6heL1HMMMuws2IlrnTz+kfD1w/zv3owsU3PVpmdxv3Bx7QJ5988s1uRoYMGXYBbpZx/+gNGPdjt4Bx3/VumQwZMmT4ZsH61OW62/UgIlMi8lkReVFEnheR/yndPyQinxaRM+nn4PXq2gmZcc+QIUOG14CbpLIXA39PVU8AbwP+exG5A/hfgc+o6lHgM+n314XMuGfIkCHDa8DNiJZR1RlVfSr9uw68COwF/irw+2mx3wd+8PW2c1dzy9C5wtK//hlMTSk+MEXUjLn6H16i++IsB//xeyg+eJBopka0vEx+RJGVNszMop0uUszhOArlACoFxPfQ8rBdYI27CAnqB2ACJDcIjot6LrJ4GfpGYXgK3DxaW4BAkMhAo4ouzsKBwwgtaC+vhzm2WjBxwvLPr0xDt4n6BbgyDTnHRo0MDCKtGjRXYPw47L3bhjg2F9DnHwEnQEYmoDSEloaJz5/DHR3FKRahuWgTfir7ACF64Wn0zHMQhciBSbxjh5HikBWgmD9jF0vzJTBdQFC3ADMzUJ2HkgflAWRgyjJiLk2nWrUgSYK6A8i+e6E1hzYuAjG025hqm+a5Jr7Twal1SM40UD/PypxL0ogo3zNK5W2TyOJVzFINbcYktx8kcXPEM8s4hPgjBZyigzdaglgxsUPzCxdof3UadzhP6YExzAvzxKEiJ4Zx+wJYbOKdnqY20yWaj/AGPYrHi5bhsWIXhJMLTZILHUxLcL7vfgp/9e04w/uhOI7IIDjjbFbAzpBhOxQbPXczISIHgXuBx4BxVZ0BOwCIyNjrrndXL6jeOaFPfOLvoIng+C4mjNFYac8Y8ofH8UpBGmet6FOPw0svbE4SmuiHkfJ6VKSIzSCtDG4QuPDAL0IwDi8/DW/9K5DrJxXHs1mvJkaENL5eoXYJVl5lLZiwOAajJwFBHMcyKbZX0Oc+CaN7kWIJ7XaQsy/a0MhT74G9p9bDIZMIls8Civg+mqSiHX1T4BVT7Vd7LTGh1SqNQvSPfgfqy5Y3Z2QI7j+J5Ids9E77ahqOaemBiWM4cw4G8lCZRI6+ey0pjNkn0qxUsz41Mc56XoCI5daZuQTtEPHEJk0ZpfvRizTPh1z9Wo2pHx+huC+XaqeIDT298w6cU0dTKmQgaqR/K6beZPpv/QXxdMPGxXuCuA6Vn72dyvv2I57g5D1MJ8Z0Ei7/7S8QT7fAtUlIe358lOLxsv0VFLjcIpntEr3Sxv2eY+R++q3gFWDsQcTJg3svyDXi/DPsatyMBdWTXk7/sHwN1bMUd66cvwAsbNj1IVX9UI82lYHPAb+mqh8VkaqqDmw4vqyqr8vvvrvdMuKAuDhp3LYTeLhFn9LhPF7R/icVEUt1+9Lzmw17zoOh4uZ8JlVotyBKwxHV2CSduA0vPg73PYwEZWvYRaxR13gtxV4cxyYs9U9tSAYSGD1huVfS5CRxfShUYOwosmwJzGT6om1f/zjsPYV4Qaq1KkhUA99H/PSe3LSu1iySqkytabE6HuJ6EOSRd/4V24QkgYUlWK7ZjNlVXhhWdWfVGtrD++09HH4ISflirKZsfa2szSx11t/5Vm++VoU4Xsv6FM9BApfg/fvIa8jgqQKFSX+DKJbadj3zPNoNU51YWRPMFhHCV+pEV+prIt3EinYTVj78MpJzcPK2Mifv4fb5DP9CKladgEbK/J8uYjpxymsDMpbDHQ5w+lySz5zGNFtWerBxEQjBXLjRJy/Dtys0zXu5zgYsqOoDG7Zeht0H/gj4sKp+NN19VUQm0uMTwNzW824Uu9u4bxGeXt+tmzMnpy9vL9O3k5yeQqeT1uOk6ex5u8/12KSJanbQ6EShkNL45rarQIE18DJyGMKOnUE3Ul6T8dtS6oINiOqbhKbXb9NsboMIqz+pOA7sO7J+LEkgVqvG1K2yFVajNYB8ZfP1m7M9s1C3odmwRF9b6/UdZMBn4O4ybtDjcXMdmJ1fb8Oq9RfBGy2n3DBboEp0obH5Oq5D6cHNb7BJPSGprfIFCeRdcMAd9O3Y8uZInrAAABWxSURBVKXzgLF89yjo4vXvM8O3PW6Gz12s4fpd4EVV/c0Nh/4L8MH07w8CH3u97dyVPncR+QDwgSMHhq9Vav1Pz9tMBAbpkrbS08Bvk4ZLM0q3DSTX4YmBaxvGVUoDSd8EVO0+Y9azZeHaHC7XakPS69rpfez0AJp4833eqB96J21XRyBRTGistulWKgDFsmJu2pH+Fe3QdwYkv71dGm2VJsRqqW6sWlkT7Zb07W69f3f5XCfDGw7lptELvAP4GeBZEXk63fcPgF8H/pOI/E3gIvCjr/cCu/JpXuWWGejLbeMuMYkBdTYzJE4d2G7MVjrsaBgLhdULpf7kLgyPQmPF6pWuXnNVm7QXOuksMGxAEm1rpyYRevVlKPbZawyO2M8rL7CtscHANqY5VbVZoxvboOtvLBpHcPpr68dcB/KedckURrfduxoDrSbabdj1gFV6hL6p6wwuKfoHtrFkqlHMYhddiVj4cg2Ne/yvcAT2jK3d09qAp4qpt7cbcQGn38cb28yTY7oJK392cVO5/N4Arz893yg0LX+8WYjAEdy3HbT31rcPS68wcf37zPBtj5vBCqmqX1RVUdW7VPWedPuEqi6q6sOqejT9XHq97dyVxn0dBuIOJkpImiFJIyScbXLlI2cw3dgusBpjZ+5ve5v9XGUMTAxMr1g7Lc66AasMgZdDV33A4kB+FI4/CC98GRrzVqdUjdUmdfLW0IYhGnatUV0+a2f7q2zoV78GJrYGPY5QE8PV0zB/CR0cs0Rbo5NQLNvB4JlPpmUt8ZZ6ZZifQ5PYcqhEkTVWxdEN5VIt1rhj9VLnr6BP/qW9X8dBjx1G+svgD9hBIOjDGjTH3muYwEvnrETg6b+EqIUmoS3Xlw6OJrFvFUkCbsX2V/oeqqWyFRNJrF9cuwlaj+h+9ALVMKC9LCw82rQJHn4AQQ71PPTtb1n7nTSOMM2Gvec4IjgxSPn7DiKBgxRcpODhDucZ+fv3073QIGnHJK0Y04npnKmy/AcvWU1UX/ArLiM/MIJ6juWp6Rp0rkt0roXpGvxfesiuTZQmobAHZBCcvd/0JzjD7kNirr/dCtjd0TKnJvWRX30/4ZUWhZN7UXFZfGQOPb/AwDsmKX33HUTLTTovXCR/pIIrIXrZLmA7oxWcQp/VJ3VDtFTCeCOYxRpuro3jB2u8KuT6IF9EXQda84j4UBkDv4xenoWgiZQqUK1Cu4ruuw0JfCsegkC7DYuXoTJh9UubS1ZEO1eCuavQWLJarSPjkITQakJlEoYP2ZltYw7mzkGrY9syuhfFIXrmJWRkFH9qEBoLUKvDyBE0jNDFq4SvXsYkCbm7bsP1A8tz4wlUr0DUgf5huz4RdyHfD406rFQtuZijqF9G3AC6DTTnIa2qHShaMVqeQv08El1GkjYsLKG1kMiUCBdbONUmznKIM16h0ymSrLQoTLnkD49BrY6ZX0b9AjLUR9iM6T53GdPoUDwxgDdZxB0fhk5EexF0pU5ycQF3uGCXQc4u4Y4WMQM5NFbceouchtTmIqLZFm7FI1dyQH3c73gb6kA808VZNGjs4n7gIQr3HIPCMOLlQPpAMh6Zb3XcjGiZE05e/yC/77rl3tJ+5U2nH9iVPvc15Ccp/9DmRejid20u4gL5B2+sutcV5bzR7b//GuWO7rD/+lFVUAZ60Fm413rGjoL3th2OTd3ANV8nPKzA0kb0IBre1Nc+UNqhvvIO+3vhdedpZ8jwGrBb5sO727hnyJAhwzcZmXHPkCFDhm9B7BLbnhn3DBkyZLhRKNwyYhzXQ2bcM2TIkOFGcQvJ6F0PmXHPkCFDhteAG+FrvxWQGfcMGTJkeA3YJRP3zLhnyJAhw43iJtIPvOHIjHuGDBkyvAbcbD73NwqZcc+QIUOGG4QCSTZzz5AhQ4ZvPdwi1DHXRWbcM2TIkOE1IDPurxEiUgJ+GwiBR1T1w9c9qXkJ89TftWRYYYy5NI9WuxB7OAf2IyeOIvkCproE4QpSGbTvVZfOooUSMnkUcgMQddFmHW1Wkep5pFBCJk+CH6BhHWk3UROCK1aOLY7Q0hAa9CErC2i7g/QPQCmAGJL5ELPSwpsMcIIINQ4EJUvSNX8FZqah04KxCpQKaKOBjIwhfg6SGK2vQM6357gltBpizr+Ce9ft4PuWtrdZtQRjIlAYwJw9S+elGZxTdxMcGkVyBkdAxUO6oAuzllhs/xEIchB10Lxj+dVnpqHZsHqt4sPAMMRd9OoZpNGA/mFk4iAauGi9jSy00Jl5tBAihZTyfXgPjE2CGEtE1m1hnBwigb3XZhOpjNo+WKliGm3qX7lE53wDf2qC3H0nyB2u4PkJ8Rc/R/LCLMx2cHIu7u39yKF+tNYlWQzRSg691CS+0IRKASfnY1qK3HGA3OEp3PIeEneU9hceR6uLJOP7aTQqmOUVgpEKxXvvpPLeh9eUrTJkuFGsqkDsBryhrJAi8nvA+4E5VT21Yf/3A7+F5Y/6f1T110XkZ4Cqqn5cRP5QVX/8evU/cHKPPvFvvh9EMMsNa2T2TCGTt0PlIKuUtlZsI4LusuV5VwP5EQjKrLEen/4sXPn6uijHxG0wMsX6T6lWyKI5Z9WVBk9YWTzPt/VFNcgNgl/CUv2m54V1YIvoRLeFXn4Wlq7C+AhSmbRC1K1F6K5sEcsQyFVg4FDajLTe2mUIq+j8Evr1l9FcGfe9P2Apfk1or6+wNs9YacPht9q2WcFX9Oyj8NhnII5SGl8Xcnl49w8hz37aMkcmEQyPw8Q+K69nGwVOCepgvv4FnIm8rdMPYDQVmi6OQKeash6nv4NXTJWWFBKDaUec/xt/THh+CW84z8F/+3PIY39K+1NXyWvKwrzalQUX+b49SN5Fn6/CyRF4ZgFdCW2fuIIoMBTQnemw/KnFlB8e8AVvMs+FZw0aKYVKnmBynKOf+Sje0JpcZYZvcdwMVsijktd/yYHrlns/p990Vsg3ms/93wHfv3GHiLjAvwLeC9wB/ISI3AHsAy6lxW5A1w1rWIO8nU36gpSKyMRtSHkCEc/qlorYTzdA3Lz9HvRB0IeIPc7KNFx5JlVPUkv1O7IP0HUdU3GsYcr1Q1iDzhLipzqnSQtxc4hfQsRZKy/iIEH/Kqv72kauCCOTsGccyfdZw56EqTGUzRtAtw5Ry9bnuKlO6z4UB547g6jivvNdEASIJmtyAbaK1EIOD1tpPzftF9eHc2eg21lXbEoSqyH7hY9Bt2kNux9sMezYPjJNq0FbOGSVjVQhDKFes8c7y/acjULj4qy3zXVwyzn2/Yvvx7QTovk28ujHiU7X8UNj1QydtO8dgU4CTy3be7qjAl+egXqY3qcgqTa5zndZ/vSiFQZZfYoiJZ7usOduK2zSrXUIL15m5h/++g09ZhkybIS5ge1WwBtq3FX188BWJZG3AGdV9ZyqhsB/BP4qcBlr4F9DuwRKA4BBfMfykyvglbbLvomTClTY47JRXWj2xVQwOsXAuD1lSx0ijp2Zq4H2/OpN2reCtRn7VugGsey1ViOFEcRzIVex1wkb11DMM9De0o2qkASpxqsPQ6O2fT1k/WRVTcpEG043cOVMj+YqrNRTsRGgf4DeL6IK2kUeOA6zrfV9rWZ60S0/oRP01Lv1R0v4U/0UD+TQyBCfaeLlnR59L+iV9uoXKHs9wxbCxWjbPgAiJZ/EgGAUNIyp/skne5fNkGEHKBDfwHYr4M1QYtrL+gwdrFHfC3wU+BER+dfAx3c6WUR+QUSeFJEn5xcbOxV7jVibU6e4lqvqZrqxXku87LXKvt427VDnpt3XqftmuPU2OjK/0RDia5y/LTx5d4QrZ7iFoGQz92uh5/RWVZuq+jdU9W9dazFVVT+kqg+o6gOjwyVoLgOOFUeuLdjao8b6zHPtRGPdKdjjuvH4xInNmqvVq6vX2nJtA1HTzkqLY+ndiJ2ZR016G0LZNGMmLaWteTSOoVu11wnK17CjAoWhLbsE3NC2JY5hYc62z9m+Rq6q1vWz4Q1CxIGp4z0uJdDfvz7zXqnS+ycTkBz65Euwp7i+r5jKa2ztfxP26E8lmm0QXa7RvtRBfAf/WJm4bXqWlX2p7MeqHqq7vV3BiN+7ub7QFevvdwScnM/gD7+/R8EMGa6NzLjvjMts1gLaB0y/rpriCMIu0ldAQ0WbbfTyabQ5Y3VOTWL1OE2CJl27qUGjJnRXrOaoKvTvgal7rYEXB6IuzF8AxJ6vag2niaz/OxiA3CAapRqnbtHWHTZSLVNNPw0arqxNTNcmqJ0GzE/D9AzaaUDcsULXhUG7oJvqkq7NinMV8Iv2PtKN2iUEA3cdRR0h/uIj0O2iOOmWVmFSZ/TiwrqGa2L1XDlw0IqBu+mA4LpQLMF3/rCV5HN9O3DMXLLtAtYsp1OC+QbauWB94iKQC6CvYsvkh9bvBezis5pUQBg0MZh6l0v/8ydx8i7eeAn9jh/Gu61MVHCtFqtJ+94oFFy4b9De0wsr8I5J6A9sXUZRR+x4M5Jj6D0jiCeIJ/YJ9wRvX4HZp7uAkOvPExw5yMQ/+ZXX9dhl+PbGbjHub7iGqogcBP50NVpGRDzgNPAwcAV4AvhJVX3+NdT5AeADR/ZWfv7lj/0c4jtWoPriQhoK6eLsP4CcOAz5AmZpGYlWkMFB+25+8YwNhdx7DIIKdDtoq4626zYUsliCyZPW6MUN60c2EXgOuAWIQygOoH4Fqc2jzRYyMAilHERKMtclWWnh78shfmx/7cAKyencJbg6h0QdGBuAYs5qr46Ng58Hk6C1KlIIrB/fLaELTZILr+LdewL8XBoKuQzNJrgOlAbQM6/QfukKcuwUwZExnEKqwe740FWYvwq1GkwdsqGQSYQGgvhuGgrZtPtVoG8Qki46/wrUGkhlCMYPQM5HV5ow34S5BbQvRnIOIgZGJmBsAkhs/4RNDDnAt4u07SbO4Kg19tVltNWh9sQVwvMtvKkJgrtuI3ekguca4i9/AfPyVXS6g1NwcW+vIAfK6HKXpBqi/Xn0YoPoUgtnuITjBSRNg5w6Qu62/bilcUwwTvuLj2KWFzF7DtFs9WOWqgTD/RTvPkXf974LcV+XsGKGXYqbES1zWPL6azcQLfOTt0C0zBsdCvkfgO8CRoCrwD9S1d8VkfcB/xIbCvl7qvprr6f+Bx54QJ988smb1dwMGTJ8C+NmGPdDktd/egPG/WdvAeP+hiYxqepP7LD/E8An3shrZ8iQIcMbgd2SxPRm+Ny/YYjIB0TkQysrK292UzJkyPBtht3ic9+Vxl1VP66qv1CpVN7spmTIkOHbCLspFPKW4ZbJkCFDht2AW8V4Xw+Zcc+QIUOGG8TqzH03YFe6ZTKfe4YMGd4sZPQDbyAyn3uGDBneDGQ+9wwZMmT4FsWtYryvh8y4Z8iQIcMNYjf53DPjniFDhgyvAbvFuO9Kn3u2oJohQ4Y3A4rVgLneditgVxr3bEE1Q4YMbxZ2y4LqrjTuGTJkyPBm4f9v7+5CrCjjOI5/f0ViaQi2FVGoCSJRRKYSURBmiBcRlZaFRoUEEXlVF0YmRRAs0UUWaavFCkloIvYCoWVIFpErJiq+ZIGhdCEa0Ru9CP8uZg57XM/seZudszv7+8DCzDPPzHnmz+G/z86e8/zzSu6S5ks6KukHScvzHqeTu5lZg/L6KOQgtaRz4+RuZtaEnGbuWbWkczMiPy1TKdYB/CXpcEa3CUDWf1xrHWukrQs43dxo2zLYPeR9fiN96/XJOu54t96/2fdxVrvjDdPaeC0AfuafbSv5vquBrmMlVReb6ImInqr9WrWkb2l3fOfoLyM38n7SgOVyrJE2YM9wub+8z2+kb70+Wccd76GJueOdf7wLvPcHgHVV+48Ab+T5GiP9sczHOR5rtK1I7b5+M+c30rden6zjjnfr/Vt5jzveQ/N6ecqvlnSGIa+hWiaS9kSHS2eNJo53sRzv4uRRS7qeEfnMvYN66nexHDnexXK8CxIRZyU9DWyjv5Z0bokdPHM3Myulkf7M3czManByNzMrISd3M7MScnJvkaRxktZLWitpcafHMxpImirpHUmbOz2W0UDSven7+0NJ8zo9HmuOk3sVSe9KOiXp4ID2Wgv83A9sjogngHsKH2xJNBPzSL6qvbQzIy2HJuO9NX1/PwYs6sBwrQ1O7ufqBeZXNwyywM819H99eLgs4TwS9dJ4zK19vTQf7xXpcRtBnNyrRMSXwC8DmrMW+DlJkuDBcWxZkzG3NjUTbyW6gU8jYm/RY7X2OCnVV2uBn6uBLcACSasZXl9rLoOaMZd0maQ1wAxJz3VmaKWU9R5fBtwFLJT0ZCcGZq3zN1TrU422iIg/gceLHswokRXzM4CTTP6y4r0KWFX0YCwfnrnXN+QL/Nh5HPNiOd4l5OReXx8wTdK1ksYADwEfdXhMZeeYF8vxLiEn9yqS3ge+AaZLOilpaUScBSoL/BwGNuW9wM9o5pgXy/EePbxwmJlZCXnmbmZWQk7uZmYl5ORuZlZCTu5mZiXk5G5mVkJO7mZmJeTkbmZWQk7uNmQk/dHpMbRKUq+khZ0eh1mrnNzNzErIyd2GnKTxknZI2ivpgKRB12aXtETSbkn7JL0t6UJJkyUdk9Ql6QJJuyTNkzRF0pG05OF+SZslXTLgetdJ2l21P0XS/nR7paQ+SQcl9Ug6b4VESccldaXbsyTtTLfHpZWN+iR9V+++zIrk5G5F+Bu4LyJuBuYAr9VKopAkYpKSbrdFxE0kVa4WR8RPQDewBngGOBQR29PTpgM9EXEj8BvwVPU1I+IwMEbS1LRpEbAp3X4zImZHxA3AxcDdTdzX88AXETE7va9XJY1r4nyzIePkbkUQ8Eo6W/6cpBDElRl95wIzgT5J+9L9qQARsQ64lGRN92erzjkREV+n2+8Bt9e47ibgwXR7EbAx3Z4j6VtJB4A7geubuK95wPJ0nDuBscCkJs43GzIu1mFFWAxcDsyMiP8kHSdJhLUIWB8R51VaSh+3VEobjgd+T7cHrn5XazW8jcAHkraQFKI4Jmks8BYwKyJOSHoxY1xn6Z8IVR8XsCAijmbci1nHeOZuRZgAnEoT+xxg8iB9d5CUdbsCQNJESZX+3cAGYCWwtuqcSZJuTbcfBr4aeNGI+JHkEc8L9M/aK4n6tKTxQNanY46T/DUBsKCqfRuwrPKISdKMQe7LrFBO7laEDcAsSXtIZvFHsjpGxCFgBbA9fYzzGXCVpDuA2UB3RGwA/pVUKXN4GHg07T8RWJ1x+Y3AEtLn7RHxK8kviQPAVpKiFbW8BLwuaRfJL4iKl4GLgP2SDqb7ZsOC13O3EU3SFOCT9B+iZpbyzN3MrIQ8c7eOkHQZyfP1geZGxJmix2NWNk7uZmYl5McyZmYl5ORuZlZCTu5mZiXk5G5mVkJO7mZmJfQ/sknMxQ5EbS4AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "xlabel = 'la_exp.donut.value'\n", + "ylabel = 'count'\n", + "\n", + "# we might consider \"downsampling\" la_exp dataframe in order to make obs/exp scatter plot less busy:\n", + "sub_la_exp = la_exp.sample(frac=0.7)\n", + "\n", + "sct = plt.scatter(sub_la_exp[xlabel],\n", + " sub_la_exp[ylabel],\n", + " # color dots on the scatter by their genomic separation\n", + " c=sub_la_exp['bin2_id']-sub_la_exp['bin1_id'],\n", + " vmin=0,\n", + " vmax = 100,\n", + " cmap=\"YlOrRd_r\")\n", + "\n", + "\n", + "\n", + "plt.scatter(yyy[xlabel],yyy[ylabel], s=80, facecolors='none', edgecolors='b')\n", + "# plt.scatter(eeee[xlabel],eeee[ylabel], s=80, facecolors='none', edgecolors='y')\n", + "\n", + "\n", + "\n", + "# plt.vlines(ledges[1:-15],ymin=0.5,ymax=900,color='red')\n", + "\n", + "ax = plt.gca()\n", + "fig = plt.gcf()\n", + "\n", + "ax.set_xscale('log')\n", + "ax.set_yscale('log')\n", + "\n", + "ax.set_xlim(0.5,400)\n", + "ax.set_ylim(0.5,900)\n", + "\n", + "ax.set_ylabel(\"count\")\n", + "ax.set_xlabel(\"la_exp value\")\n", "\n", - "# import tempfile\n", - "# tmp_scores = tempfile.NamedTemporaryFile(\n", - "# suffix='.parquet',\n", - "# delete= not no_delete_temp,\n", - "# dir=temp_dir)\n", + "fig.colorbar(scat)" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1.2599210498948732" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2**0.3333333333333333333333333333333333333333333333333333333333333" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
bin1_idbin2_idcountla_exp.donut.valuela_exp.vertical.valuela_exp.horizontal.valuela_exp.lowleft.value
455272551256512.9438753.3695222.5396122.749783
456152552256544.8086696.3406584.1303554.223058
457032553256534.9771636.8206464.0212244.243577
462362559257064.1402802.6441045.2731573.869909
462382559257233.1910472.2625943.7841512.541656
462392559257303.2950562.3608853.8228432.604651
463262560257233.5285512.2610383.8357932.749389
463272560257303.6920402.3923164.0233912.799043
463282560257473.1717752.8016293.7760332.344038
465032562257354.3532903.7435783.7896063.972032
465042562257423.5976913.4752683.2680913.027295
465922563257444.7247354.6614373.4098264.485879
467732565257964.7681584.7936794.3657004.043452
8044009402324.5433564.4475764.3141694.470755
9804011402344.3116204.2447564.1115684.076849
20484023403524.4544235.4200553.4452204.243512
20494023403644.0940515.2905083.0354424.150209
20504023403724.0157595.0476662.9002484.307997
640834720473433.1136373.7187973.4543403.803006
641714721473423.2872913.1587214.1312363.923242
641724721473513.1733552.8231523.8702553.709589
642594722473442.4060182.2185102.7683582.740342
642604722473532.3265391.8766882.6770092.606179
643474723473453.3284052.9295433.7454443.527099
643484723473593.2910072.4885383.6533793.420079
644364724473532.4979201.9563962.4076142.646544
653264734474524.1903194.4200084.3136033.897382
653284734474732.2113182.2980352.3958942.147404
653294734474843.9182644.0261134.1701333.688275
654164735474742.3674392.4272572.6418222.152733
........................
28305243182433210.4814950.4839700.4630260.671160
28391243192433000.1999430.3226960.1659830.194306
28392243192433100.2357000.2847580.4066520.256279
28393243192433200.1955040.1871880.3289220.277225
28394243192433300.1867490.1246040.3098860.281714
28480243202433100.2096850.2613370.3625780.159748
28481243202433210.1735830.1920310.3222130.184054
28482243202433300.1550040.0902930.2923450.169176
28483243202433400.1255770.1076980.1575620.152450
28569243212433200.3874200.2830230.5233290.312621
28570243212433300.3392540.2343670.4569510.270146
28571243212433410.2759190.2105740.3411470.312869
28572243212433500.3756080.4230050.4358180.415337
28658243222433300.5597650.4160900.4327360.487651
28659243222433410.4921630.3638670.4813140.537668
28660243222433510.6120810.7643670.6621780.623300
28661243222433600.5233550.6122360.5729530.587157
28747243232433400.2404360.1897840.2866990.253029
28748243232433510.3038890.3245800.3482750.314315
28749243232433610.2633720.2449220.2529040.285490
28750243232433700.4022900.3855410.2821680.358838
28836243242433500.6360080.6339670.6739540.622197
28837243242433600.5866020.5085920.5452570.630282
28838243242433700.7848590.6752320.3923580.797384
28839243242433811.8504671.5114241.2268231.766548
28925243252433620.9066620.6233610.6676710.993947
28926243252433701.1250320.7361820.8021251.220882
28927243252433822.5891472.1576511.9890262.826989
28928243252433922.6195162.1492162.4820552.672861
29014243262433764.5717114.2775284.0720854.764073
\n", + "

579 rows × 7 columns

\n", + "
" + ], + "text/plain": [ + " bin1_id bin2_id count la_exp.donut.value la_exp.vertical.value \\\n", + "45527 2551 2565 1 2.943875 3.369522 \n", + "45615 2552 2565 4 4.808669 6.340658 \n", + "45703 2553 2565 3 4.977163 6.820646 \n", + "46236 2559 2570 6 4.140280 2.644104 \n", + "46238 2559 2572 3 3.191047 2.262594 \n", + "46239 2559 2573 0 3.295056 2.360885 \n", + "46326 2560 2572 3 3.528551 2.261038 \n", + "46327 2560 2573 0 3.692040 2.392316 \n", + "46328 2560 2574 7 3.171775 2.801629 \n", + "46503 2562 2573 5 4.353290 3.743578 \n", + "46504 2562 2574 2 3.597691 3.475268 \n", + "46592 2563 2574 4 4.724735 4.661437 \n", + "46773 2565 2579 6 4.768158 4.793679 \n", + "804 4009 4023 2 4.543356 4.447576 \n", + "980 4011 4023 4 4.311620 4.244756 \n", + "2048 4023 4035 2 4.454423 5.420055 \n", + "2049 4023 4036 4 4.094051 5.290508 \n", + "2050 4023 4037 2 4.015759 5.047666 \n", + "64083 4720 4734 3 3.113637 3.718797 \n", + "64171 4721 4734 2 3.287291 3.158721 \n", + "64172 4721 4735 1 3.173355 2.823152 \n", + "64259 4722 4734 4 2.406018 2.218510 \n", + "64260 4722 4735 3 2.326539 1.876688 \n", + "64347 4723 4734 5 3.328405 2.929543 \n", + "64348 4723 4735 9 3.291007 2.488538 \n", + "64436 4724 4735 3 2.497920 1.956396 \n", + "65326 4734 4745 2 4.190319 4.420008 \n", + "65328 4734 4747 3 2.211318 2.298035 \n", + "65329 4734 4748 4 3.918264 4.026113 \n", + "65416 4735 4747 4 2.367439 2.427257 \n", + "... ... ... ... ... ... \n", + "28305 24318 24332 1 0.481495 0.483970 \n", + "28391 24319 24330 0 0.199943 0.322696 \n", + "28392 24319 24331 0 0.235700 0.284758 \n", + "28393 24319 24332 0 0.195504 0.187188 \n", + "28394 24319 24333 0 0.186749 0.124604 \n", + "28480 24320 24331 0 0.209685 0.261337 \n", + "28481 24320 24332 1 0.173583 0.192031 \n", + "28482 24320 24333 0 0.155004 0.090293 \n", + "28483 24320 24334 0 0.125577 0.107698 \n", + "28569 24321 24332 0 0.387420 0.283023 \n", + "28570 24321 24333 0 0.339254 0.234367 \n", + "28571 24321 24334 1 0.275919 0.210574 \n", + "28572 24321 24335 0 0.375608 0.423005 \n", + "28658 24322 24333 0 0.559765 0.416090 \n", + "28659 24322 24334 1 0.492163 0.363867 \n", + "28660 24322 24335 1 0.612081 0.764367 \n", + "28661 24322 24336 0 0.523355 0.612236 \n", + "28747 24323 24334 0 0.240436 0.189784 \n", + "28748 24323 24335 1 0.303889 0.324580 \n", + "28749 24323 24336 1 0.263372 0.244922 \n", + "28750 24323 24337 0 0.402290 0.385541 \n", + "28836 24324 24335 0 0.636008 0.633967 \n", + "28837 24324 24336 0 0.586602 0.508592 \n", + "28838 24324 24337 0 0.784859 0.675232 \n", + "28839 24324 24338 1 1.850467 1.511424 \n", + "28925 24325 24336 2 0.906662 0.623361 \n", + "28926 24325 24337 0 1.125032 0.736182 \n", + "28927 24325 24338 2 2.589147 2.157651 \n", + "28928 24325 24339 2 2.619516 2.149216 \n", + "29014 24326 24337 6 4.571711 4.277528 \n", + "\n", + " la_exp.horizontal.value la_exp.lowleft.value \n", + "45527 2.539612 2.749783 \n", + "45615 4.130355 4.223058 \n", + "45703 4.021224 4.243577 \n", + "46236 5.273157 3.869909 \n", + "46238 3.784151 2.541656 \n", + "46239 3.822843 2.604651 \n", + "46326 3.835793 2.749389 \n", + "46327 4.023391 2.799043 \n", + "46328 3.776033 2.344038 \n", + "46503 3.789606 3.972032 \n", + "46504 3.268091 3.027295 \n", + "46592 3.409826 4.485879 \n", + "46773 4.365700 4.043452 \n", + "804 4.314169 4.470755 \n", + "980 4.111568 4.076849 \n", + "2048 3.445220 4.243512 \n", + "2049 3.035442 4.150209 \n", + "2050 2.900248 4.307997 \n", + "64083 3.454340 3.803006 \n", + "64171 4.131236 3.923242 \n", + "64172 3.870255 3.709589 \n", + "64259 2.768358 2.740342 \n", + "64260 2.677009 2.606179 \n", + "64347 3.745444 3.527099 \n", + "64348 3.653379 3.420079 \n", + "64436 2.407614 2.646544 \n", + "65326 4.313603 3.897382 \n", + "65328 2.395894 2.147404 \n", + "65329 4.170133 3.688275 \n", + "65416 2.641822 2.152733 \n", + "... ... ... \n", + "28305 0.463026 0.671160 \n", + "28391 0.165983 0.194306 \n", + "28392 0.406652 0.256279 \n", + "28393 0.328922 0.277225 \n", + "28394 0.309886 0.281714 \n", + "28480 0.362578 0.159748 \n", + "28481 0.322213 0.184054 \n", + "28482 0.292345 0.169176 \n", + "28483 0.157562 0.152450 \n", + "28569 0.523329 0.312621 \n", + "28570 0.456951 0.270146 \n", + "28571 0.341147 0.312869 \n", + "28572 0.435818 0.415337 \n", + "28658 0.432736 0.487651 \n", + "28659 0.481314 0.537668 \n", + "28660 0.662178 0.623300 \n", + "28661 0.572953 0.587157 \n", + "28747 0.286699 0.253029 \n", + "28748 0.348275 0.314315 \n", + "28749 0.252904 0.285490 \n", + "28750 0.282168 0.358838 \n", + "28836 0.673954 0.622197 \n", + "28837 0.545257 0.630282 \n", + "28838 0.392358 0.797384 \n", + "28839 1.226823 1.766548 \n", + "28925 0.667671 0.993947 \n", + "28926 0.802125 1.220882 \n", + "28927 1.989026 2.826989 \n", + "28928 2.482055 2.672861 \n", + "29014 4.072085 4.764073 \n", + "\n", + "[579 rows x 7 columns]" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cccc[(cccc['bin2_id']-cccc['bin1_id']<15)&(cccc[xlabel]<5)]" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'la_exp value')" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "xlabel = 'la_exp.donut.value'\n", + "ylabel = 'count'\n", "\n", - "# cccc = dotfinder.scoring_step(clr,\n", - "# expected,\n", - "# expected_name,\n", - "# \"weight\",\n", - "# tiles,\n", - "# kernels,\n", - "# max_nans_tolerated,\n", - "# loci_separation_bins,\n", - "# tmp_scores,\n", - "# nproc,\n", - "# score_dump_mode,\n", - "# verbose)\n", + "plt.scatter(cccc['bin2_id']-cccc['bin1_id'],(cccc[xlabel]))\n", + "# plt.scatter(dddd[xlabel],dddd[ylabel], s=80, facecolors='none', edgecolors='r')\n", + "# plt.scatter(eeee[xlabel],eeee[ylabel], s=80, facecolors='none', edgecolors='y')\n", "\n", - "# histogramming using temp input:\n", + "ax = plt.gca()\n", "\n", - "# gw_hist = dotfinder.histogramming_step(tmp_scores,\n", - "# score_dump_mode,\n", - "# kernels,\n", - "# ledges,\n", - "# output_path=None,\n", - "# nproc=1,\n", - "# verbose=False)" + "ax.set_xlabel(\"genomic separation\")\n", + "ax.set_ylabel(\"la_exp value\")\n" ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 71, "metadata": {}, "outputs": [ { @@ -494,7 +1495,7 @@ "Text(0.5, 0, '# of interactions')" ] }, - "execution_count": 48, + "execution_count": 71, "metadata": {}, "output_type": "execute_result" }, @@ -808,12 +1809,73 @@ "len(final_out)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## stuff that require clean up, but might be usefull in general " + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/venevs/miniconda3/envs/dots-stable/lib/python3.6/site-packages/ipykernel_launcher.py:11: RuntimeWarning: divide by zero encountered in log\n", + " # This is added back by InteractiveShellApp.init_path()\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plt.imshow(np.log(clr.matrix()[18030:18100,18030:18100]),cmap='YlOrRd')\n", + "# plt.scatter(53,18,s=80, facecolors='none', edgecolors='b')\n", + "\n", + "bin1,bin2 = 18030+18,18030+53\n", + "\n", + "bin1_n,bin2_n = 18030+23,18030+49\n", + "\n", + "\n", + "bin1,bin2 = 24322, 24334\n", + "\n", + "plt.imshow(np.log(clr.matrix(balance=True)[bin1-20:bin1+20,bin2-20:bin2+20]),cmap='YlOrRd')\n", + "\n", + "# something to have in mind - is the difference between JUicer balancing and cooler balacning ...\n", + "# MAD max filtering in particular\n", + "# in Juicer some of thesparse/low coverage regions are kept - what re the effects on the distriubtions, etc\n", + "# to be seen\n", + "# here is the region for reference: chr1:242,019,651-244,387,558 & chr1:242,713,339-243,695,154 [offset 0,0:0,0]\n", + "\n", + "dddd = cccc[(cccc['bin1_id']==bin1)&(cccc['bin2_id']==bin2)]\n", + "eeee = cccc[(cccc['bin1_id']==bin1_n)&(cccc['bin2_id']==bin2_n)]\n", + "\n", + "(cccc['bin2_id']-cccc['bin1_id']).min()" + ] } ], "metadata": { From 950d465ac94d78d2fa649fe29a67968260951a1e Mon Sep 17 00:00:00 2001 From: sergpolly Date: Fri, 7 Jun 2019 19:25:32 -0400 Subject: [PATCH 04/71] updated notebook again --- doc/examples/dot-calling-internals.ipynb | 889 ++--------------------- 1 file changed, 41 insertions(+), 848 deletions(-) diff --git a/doc/examples/dot-calling-internals.ipynb b/doc/examples/dot-calling-internals.ipynb index 92df5b8d..ff5f3183 100644 --- a/doc/examples/dot-calling-internals.ipynb +++ b/doc/examples/dot-calling-internals.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 7, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -55,7 +55,7 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -107,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -141,21 +141,21 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Tokenization took: 47.45 ms\n", - "Type conversion took: 19.71 ms\n", + "Tokenization took: 47.11 ms\n", + "Type conversion took: 22.51 ms\n", "Parser memory cleanup took: 0.01 ms\n", - "Tokenization took: 31.80 ms\n", - "Type conversion took: 18.99 ms\n", - "Parser memory cleanup took: 0.01 ms\n", - "Tokenization took: 9.56 ms\n", - "Type conversion took: 5.91 ms\n", + "Tokenization took: 35.54 ms\n", + "Type conversion took: 20.07 ms\n", + "Parser memory cleanup took: 0.00 ms\n", + "Tokenization took: 9.75 ms\n", + "Type conversion took: 6.25 ms\n", "Parser memory cleanup took: 0.00 ms\n" ] } @@ -192,7 +192,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -211,7 +211,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -261,7 +261,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -292,16 +292,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### choosing w and p for the kernel sizes\n", - "we should replace it or hide it with the function that \"recommends\" `w` and `p` based on the `binsize`\n", - "but also we should provide a CLI interface for changing those at will ...\n", - "\n", - "or should we \"read\" kernel-footprints from a separate file ... for ultimate customizability ?!" + "### Kernels used to define local enrichment of a pixel\n", + "\n", + " - Dots observed on Hi-C heatmaps as *small* and concentrated clusters of locally enriched pixels.\n", + " - Biologically relevant sizes of such clusters and their surroundings are empirically defined at `~50kb` for the diameter of clusters, and `~100kb` for the diameter of the local surrounding\n", + " - Several types of kernels (i.e. local environments) could be used to rule out unwanted enrichment types, e.g. elongated clusters, large corners, etc.\n", + " - One can choose from pre-defined set of kernels from *Rao et al 2014*, or provide custome ones\n", + " - Even for the predefined set of kernels one can control their parameters `w` and `p`, where `2w+1` is the outter dimensions of kernel's footprint and `2p+1` is the inner one, the approximate size of an enriched cluster of pixels\n", + " - function `recommend_kernel_params` would yield recommended `w` and `p` for a given bin size, as in *Rao et al 2014*, otherwise feel free to experiment with those" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -319,7 +322,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -339,7 +342,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -349,7 +352,7 @@ " Text(1, 0, 'Included in calculations')]" ] }, - "execution_count": 16, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, @@ -467,7 +470,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -520,7 +523,7 @@ }, { "cell_type": "code", - "execution_count": 140, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -563,7 +566,7 @@ }, { "cell_type": "code", - "execution_count": 130, + "execution_count": 17, "metadata": { "scrolled": false }, @@ -571,16 +574,16 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 130, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -596,7 +599,7 @@ "ylabel = 'count'\n", "\n", "# we might consider \"downsampling\" la_exp dataframe in order to make obs/exp scatter plot less busy:\n", - "sub_la_exp = la_exp.sample(frac=0.7)\n", + "sub_la_exp = la_exp.sample(frac=0.1)\n", "\n", "sct = plt.scatter(sub_la_exp[xlabel],\n", " sub_la_exp[ylabel],\n", @@ -608,11 +611,13 @@ "\n", "\n", "\n", - "plt.scatter(yyy[xlabel],yyy[ylabel], s=80, facecolors='none', edgecolors='b')\n", - "# plt.scatter(eeee[xlabel],eeee[ylabel], s=80, facecolors='none', edgecolors='y')\n", - "\n", - "\n", + "plt.scatter(intersect_raodots[xlabel],\n", + " intersect_raodots[ylabel],\n", + " s=80,\n", + " facecolors='none',\n", + " edgecolors='b')\n", "\n", + "# we can add a visual of the lambda-chunking grid on top of obs/exp scatter ...\n", "# plt.vlines(ledges[1:-15],ymin=0.5,ymax=900,color='red')\n", "\n", "ax = plt.gca()\n", @@ -627,819 +632,7 @@ "ax.set_ylabel(\"count\")\n", "ax.set_xlabel(\"la_exp value\")\n", "\n", - "fig.colorbar(scat)" - ] - }, - { - "cell_type": "code", - "execution_count": 98, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1.2599210498948732" - ] - }, - "execution_count": 98, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "2**0.3333333333333333333333333333333333333333333333333333333333333" - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
bin1_idbin2_idcountla_exp.donut.valuela_exp.vertical.valuela_exp.horizontal.valuela_exp.lowleft.value
455272551256512.9438753.3695222.5396122.749783
456152552256544.8086696.3406584.1303554.223058
457032553256534.9771636.8206464.0212244.243577
462362559257064.1402802.6441045.2731573.869909
462382559257233.1910472.2625943.7841512.541656
462392559257303.2950562.3608853.8228432.604651
463262560257233.5285512.2610383.8357932.749389
463272560257303.6920402.3923164.0233912.799043
463282560257473.1717752.8016293.7760332.344038
465032562257354.3532903.7435783.7896063.972032
465042562257423.5976913.4752683.2680913.027295
465922563257444.7247354.6614373.4098264.485879
467732565257964.7681584.7936794.3657004.043452
8044009402324.5433564.4475764.3141694.470755
9804011402344.3116204.2447564.1115684.076849
20484023403524.4544235.4200553.4452204.243512
20494023403644.0940515.2905083.0354424.150209
20504023403724.0157595.0476662.9002484.307997
640834720473433.1136373.7187973.4543403.803006
641714721473423.2872913.1587214.1312363.923242
641724721473513.1733552.8231523.8702553.709589
642594722473442.4060182.2185102.7683582.740342
642604722473532.3265391.8766882.6770092.606179
643474723473453.3284052.9295433.7454443.527099
643484723473593.2910072.4885383.6533793.420079
644364724473532.4979201.9563962.4076142.646544
653264734474524.1903194.4200084.3136033.897382
653284734474732.2113182.2980352.3958942.147404
653294734474843.9182644.0261134.1701333.688275
654164735474742.3674392.4272572.6418222.152733
........................
28305243182433210.4814950.4839700.4630260.671160
28391243192433000.1999430.3226960.1659830.194306
28392243192433100.2357000.2847580.4066520.256279
28393243192433200.1955040.1871880.3289220.277225
28394243192433300.1867490.1246040.3098860.281714
28480243202433100.2096850.2613370.3625780.159748
28481243202433210.1735830.1920310.3222130.184054
28482243202433300.1550040.0902930.2923450.169176
28483243202433400.1255770.1076980.1575620.152450
28569243212433200.3874200.2830230.5233290.312621
28570243212433300.3392540.2343670.4569510.270146
28571243212433410.2759190.2105740.3411470.312869
28572243212433500.3756080.4230050.4358180.415337
28658243222433300.5597650.4160900.4327360.487651
28659243222433410.4921630.3638670.4813140.537668
28660243222433510.6120810.7643670.6621780.623300
28661243222433600.5233550.6122360.5729530.587157
28747243232433400.2404360.1897840.2866990.253029
28748243232433510.3038890.3245800.3482750.314315
28749243232433610.2633720.2449220.2529040.285490
28750243232433700.4022900.3855410.2821680.358838
28836243242433500.6360080.6339670.6739540.622197
28837243242433600.5866020.5085920.5452570.630282
28838243242433700.7848590.6752320.3923580.797384
28839243242433811.8504671.5114241.2268231.766548
28925243252433620.9066620.6233610.6676710.993947
28926243252433701.1250320.7361820.8021251.220882
28927243252433822.5891472.1576511.9890262.826989
28928243252433922.6195162.1492162.4820552.672861
29014243262433764.5717114.2775284.0720854.764073
\n", - "

579 rows × 7 columns

\n", - "
" - ], - "text/plain": [ - " bin1_id bin2_id count la_exp.donut.value la_exp.vertical.value \\\n", - "45527 2551 2565 1 2.943875 3.369522 \n", - "45615 2552 2565 4 4.808669 6.340658 \n", - "45703 2553 2565 3 4.977163 6.820646 \n", - "46236 2559 2570 6 4.140280 2.644104 \n", - "46238 2559 2572 3 3.191047 2.262594 \n", - "46239 2559 2573 0 3.295056 2.360885 \n", - "46326 2560 2572 3 3.528551 2.261038 \n", - "46327 2560 2573 0 3.692040 2.392316 \n", - "46328 2560 2574 7 3.171775 2.801629 \n", - "46503 2562 2573 5 4.353290 3.743578 \n", - "46504 2562 2574 2 3.597691 3.475268 \n", - "46592 2563 2574 4 4.724735 4.661437 \n", - "46773 2565 2579 6 4.768158 4.793679 \n", - "804 4009 4023 2 4.543356 4.447576 \n", - "980 4011 4023 4 4.311620 4.244756 \n", - "2048 4023 4035 2 4.454423 5.420055 \n", - "2049 4023 4036 4 4.094051 5.290508 \n", - "2050 4023 4037 2 4.015759 5.047666 \n", - "64083 4720 4734 3 3.113637 3.718797 \n", - "64171 4721 4734 2 3.287291 3.158721 \n", - "64172 4721 4735 1 3.173355 2.823152 \n", - "64259 4722 4734 4 2.406018 2.218510 \n", - "64260 4722 4735 3 2.326539 1.876688 \n", - "64347 4723 4734 5 3.328405 2.929543 \n", - "64348 4723 4735 9 3.291007 2.488538 \n", - "64436 4724 4735 3 2.497920 1.956396 \n", - "65326 4734 4745 2 4.190319 4.420008 \n", - "65328 4734 4747 3 2.211318 2.298035 \n", - "65329 4734 4748 4 3.918264 4.026113 \n", - "65416 4735 4747 4 2.367439 2.427257 \n", - "... ... ... ... ... ... \n", - "28305 24318 24332 1 0.481495 0.483970 \n", - "28391 24319 24330 0 0.199943 0.322696 \n", - "28392 24319 24331 0 0.235700 0.284758 \n", - "28393 24319 24332 0 0.195504 0.187188 \n", - "28394 24319 24333 0 0.186749 0.124604 \n", - "28480 24320 24331 0 0.209685 0.261337 \n", - "28481 24320 24332 1 0.173583 0.192031 \n", - "28482 24320 24333 0 0.155004 0.090293 \n", - "28483 24320 24334 0 0.125577 0.107698 \n", - "28569 24321 24332 0 0.387420 0.283023 \n", - "28570 24321 24333 0 0.339254 0.234367 \n", - "28571 24321 24334 1 0.275919 0.210574 \n", - "28572 24321 24335 0 0.375608 0.423005 \n", - "28658 24322 24333 0 0.559765 0.416090 \n", - "28659 24322 24334 1 0.492163 0.363867 \n", - "28660 24322 24335 1 0.612081 0.764367 \n", - "28661 24322 24336 0 0.523355 0.612236 \n", - "28747 24323 24334 0 0.240436 0.189784 \n", - "28748 24323 24335 1 0.303889 0.324580 \n", - "28749 24323 24336 1 0.263372 0.244922 \n", - "28750 24323 24337 0 0.402290 0.385541 \n", - "28836 24324 24335 0 0.636008 0.633967 \n", - "28837 24324 24336 0 0.586602 0.508592 \n", - "28838 24324 24337 0 0.784859 0.675232 \n", - "28839 24324 24338 1 1.850467 1.511424 \n", - "28925 24325 24336 2 0.906662 0.623361 \n", - "28926 24325 24337 0 1.125032 0.736182 \n", - "28927 24325 24338 2 2.589147 2.157651 \n", - "28928 24325 24339 2 2.619516 2.149216 \n", - "29014 24326 24337 6 4.571711 4.277528 \n", - "\n", - " la_exp.horizontal.value la_exp.lowleft.value \n", - "45527 2.539612 2.749783 \n", - "45615 4.130355 4.223058 \n", - "45703 4.021224 4.243577 \n", - "46236 5.273157 3.869909 \n", - "46238 3.784151 2.541656 \n", - "46239 3.822843 2.604651 \n", - "46326 3.835793 2.749389 \n", - "46327 4.023391 2.799043 \n", - "46328 3.776033 2.344038 \n", - "46503 3.789606 3.972032 \n", - "46504 3.268091 3.027295 \n", - "46592 3.409826 4.485879 \n", - "46773 4.365700 4.043452 \n", - "804 4.314169 4.470755 \n", - "980 4.111568 4.076849 \n", - "2048 3.445220 4.243512 \n", - "2049 3.035442 4.150209 \n", - "2050 2.900248 4.307997 \n", - "64083 3.454340 3.803006 \n", - "64171 4.131236 3.923242 \n", - "64172 3.870255 3.709589 \n", - "64259 2.768358 2.740342 \n", - "64260 2.677009 2.606179 \n", - "64347 3.745444 3.527099 \n", - "64348 3.653379 3.420079 \n", - "64436 2.407614 2.646544 \n", - "65326 4.313603 3.897382 \n", - "65328 2.395894 2.147404 \n", - "65329 4.170133 3.688275 \n", - "65416 2.641822 2.152733 \n", - "... ... ... \n", - "28305 0.463026 0.671160 \n", - "28391 0.165983 0.194306 \n", - "28392 0.406652 0.256279 \n", - "28393 0.328922 0.277225 \n", - "28394 0.309886 0.281714 \n", - "28480 0.362578 0.159748 \n", - "28481 0.322213 0.184054 \n", - "28482 0.292345 0.169176 \n", - "28483 0.157562 0.152450 \n", - "28569 0.523329 0.312621 \n", - "28570 0.456951 0.270146 \n", - "28571 0.341147 0.312869 \n", - "28572 0.435818 0.415337 \n", - "28658 0.432736 0.487651 \n", - "28659 0.481314 0.537668 \n", - "28660 0.662178 0.623300 \n", - "28661 0.572953 0.587157 \n", - "28747 0.286699 0.253029 \n", - "28748 0.348275 0.314315 \n", - "28749 0.252904 0.285490 \n", - "28750 0.282168 0.358838 \n", - "28836 0.673954 0.622197 \n", - "28837 0.545257 0.630282 \n", - "28838 0.392358 0.797384 \n", - "28839 1.226823 1.766548 \n", - "28925 0.667671 0.993947 \n", - "28926 0.802125 1.220882 \n", - "28927 1.989026 2.826989 \n", - "28928 2.482055 2.672861 \n", - "29014 4.072085 4.764073 \n", - "\n", - "[579 rows x 7 columns]" - ] - }, - "execution_count": 67, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cccc[(cccc['bin2_id']-cccc['bin1_id']<15)&(cccc[xlabel]<5)]" + "fig.colorbar(sct)" ] }, { From f3928b37952f52a6affb78e421b15592b05e24ce Mon Sep 17 00:00:00 2001 From: sergpolly Date: Tue, 9 Jul 2019 12:06:42 -0400 Subject: [PATCH 05/71] before vacation notebook updates --- doc/examples/dot-calling-internals.ipynb | 494 +++++++++++++++++++---- 1 file changed, 411 insertions(+), 83 deletions(-) diff --git a/doc/examples/dot-calling-internals.ipynb b/doc/examples/dot-calling-internals.ipynb index ff5f3183..d7f7c635 100644 --- a/doc/examples/dot-calling-internals.ipynb +++ b/doc/examples/dot-calling-internals.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -148,14 +148,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "Tokenization took: 47.11 ms\n", - "Type conversion took: 22.51 ms\n", + "Tokenization took: 46.16 ms\n", + "Type conversion took: 19.26 ms\n", "Parser memory cleanup took: 0.01 ms\n", - "Tokenization took: 35.54 ms\n", - "Type conversion took: 20.07 ms\n", + "Tokenization took: 31.21 ms\n", + "Type conversion took: 18.80 ms\n", "Parser memory cleanup took: 0.00 ms\n", - "Tokenization took: 9.75 ms\n", - "Type conversion took: 6.25 ms\n", + "Tokenization took: 9.84 ms\n", + "Type conversion took: 6.06 ms\n", "Parser memory cleanup took: 0.00 ms\n" ] } @@ -358,7 +358,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -374,7 +374,7 @@ "# consider moving plotting code elsewhere or simplify it significantly ...\n", "# split cell above and demonstrate kernels - it's nice:\n", "\n", - "ktype='donut'\n", + "ktype='horizontal'\n", "kernel= kernels[ktype]\n", "y,x = np.ogrid[-w:w+1, -w:w+1]\n", "\n", @@ -430,7 +430,7 @@ "but practice shows that for large genomes even parquet/hdf5 are not fast enough.\n", "Thus using a **2-pass** strategy seems to be the best option indeed.\n", "\n", - "**2-pass**: calculate locally-adjusted expected for each pixel and use this value *immediately* to build a hitogram with predefined bins, then recalculate locally-adjusted expected values and again use them *in place* to select significantly enriched pixels.\n", + "**2-pass**: calculate locally-adjusted expected for each pixel and use this value *immediately* to build a histogram with predefined bins, then recalculate locally-adjusted expected values and again use them *in place* to select significantly enriched pixels.\n", "\n", "\n", " - an example on how to store locally adjusted expected in a temporary file:\n", @@ -441,7 +441,7 @@ " delete= False,\n", " dir='.')\n", "```\n", - " - now calculate locally adjusted expected:\n", + " - now calculate locally adjusted expected (not performed in the call-dots command line implementation):\n", "```python\n", "loc_adj_exp = dotfinder.scoring_step(clr,\n", " expected,\n", @@ -456,7 +456,7 @@ " score_dump_mode,\n", " verbose)\n", "```\n", - " - histogramming using temporary input:\n", + " - histogramming using temporary input (this steps is performed in actual call-dots implementation and it involves de novo calculation of locally adjusted expected for each surveyed pixel):\n", "```python\n", "gw_hist = dotfinder.histogramming_step(tmp_scores,\n", " score_dump_mode,\n", @@ -470,7 +470,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 95, "metadata": {}, "outputs": [ { @@ -485,6 +485,7 @@ ], "source": [ "# locally adjusted returned in place for just 1 chromosome:\n", + "# beware: this step is not performed in the actual call-dots CLI implementation\n", "la_exp = dotfinder.scoring_step(clr,\n", " expected,\n", " expected_name,\n", @@ -523,7 +524,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 96, "metadata": {}, "outputs": [], "source": [ @@ -566,24 +567,24 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 97, "metadata": { - "scrolled": false + "scrolled": true }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 17, + "execution_count": 97, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -626,8 +627,130 @@ "ax.set_xscale('log')\n", "ax.set_yscale('log')\n", "\n", - "ax.set_xlim(0.5,400)\n", - "ax.set_ylim(0.5,900)\n", + "ax.set_xlim(0.5,700)\n", + "ax.set_ylim(0.5,1200)\n", + "\n", + "ax.set_ylabel(\"count\")\n", + "ax.set_xlabel(\"la_exp value\")\n", + "\n", + "fig.colorbar(sct)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# starting from here it requires more cleaning/trimming down ...\n", + "\n", + "### we can do some quick and educational statistics here\n", + "\n", + "*Null hypothesis*: intensity of a HiC pixel is Poisson-distributed with a certain expected. In the case of dot-calling procedure, that would be *locally-adjusted expected*.\n", + "\n", + "Thus for the dot-calling, we could estimate a p-value for each of the pixel's intensities (for all of the kernel-types):\n", + "\n", + "```\n", + "p =1-Poisson.cdf(obs,exp)\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.stats import poisson\n", + "\n", + "for k in ktypes:\n", + " la_exp[\"la_exp.\"+k+\".pval\"] = 1.0 - \\\n", + " poisson.cdf(la_exp[\"count\"],\n", + " la_exp[\"la_exp.\"+k+\".value\"])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### now let's select pixels that are \"significantly\" brighter than their surroundings ...\n", + "\n", + "Just use *naive* p-value thresholding for simplicity and quick turn around.\n", + "\n", + "And then see where such \"bright\" pixels end up on the obs/exp scatter plot depending on the p-value threshold" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "ename": "KeyError", + "evalue": "'la_exp.donut.pval'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m~/miniconda3/envs/dots-stable/lib/python3.6/site-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3077\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3078\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3079\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'la_exp.donut.pval'", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# let's test p-value for all of the 4 filters - feel free to play with individual filters/kernels as well:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0msignif_pvals\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mones_like\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mla_exp\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"la_exp.donut.pval\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbool\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 6\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mktypes\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0msignif_pvals\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msignif_pvals\u001b[0m \u001b[0;34m&\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mla_exp\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"la_exp.\"\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;34m\".pval\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m<=\u001b[0m\u001b[0mp_th\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/dots-stable/lib/python3.6/site-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 2686\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_multilevel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2687\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2688\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_column\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2689\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2690\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_getitem_column\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/dots-stable/lib/python3.6/site-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m_getitem_column\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 2693\u001b[0m \u001b[0;31m# get column\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2694\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_unique\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2695\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_item_cache\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2696\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2697\u001b[0m \u001b[0;31m# duplicate columns & possible reduce dimensionality\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/dots-stable/lib/python3.6/site-packages/pandas/core/generic.py\u001b[0m in \u001b[0;36m_get_item_cache\u001b[0;34m(self, item)\u001b[0m\n\u001b[1;32m 2487\u001b[0m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcache\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2488\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mres\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2489\u001b[0;31m \u001b[0mvalues\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2490\u001b[0m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_box_item_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2491\u001b[0m \u001b[0mcache\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/dots-stable/lib/python3.6/site-packages/pandas/core/internals.py\u001b[0m in \u001b[0;36mget\u001b[0;34m(self, item, fastpath)\u001b[0m\n\u001b[1;32m 4113\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4114\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misna\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 4115\u001b[0;31m \u001b[0mloc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4116\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4117\u001b[0m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0misna\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/dots-stable/lib/python3.6/site-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 3078\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3079\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3080\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_maybe_cast_indexer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3081\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3082\u001b[0m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_indexer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'la_exp.donut.pval'" + ] + } + ], + "source": [ + "# arbitrary p-value threshold\n", + "p_th = 0.0001\n", + "\n", + "# let's test p-value for all of the 4 filters - feel free to play with individual filters/kernels as well:\n", + "signif_pvals = np.ones_like(la_exp[\"la_exp.donut.pval\"].values,dtype=np.bool)\n", + "for k in ktypes:\n", + " signif_pvals = signif_pvals & (la_exp[\"la_exp.\"+k+\".pval\"]<=p_th)\n", + "\n", + "\n", + "# plotting - consider making it shorter:\n", + "sct = plt.scatter(sub_la_exp[xlabel],\n", + " sub_la_exp[ylabel],\n", + " # color dots on the scatter by their genomic separation\n", + " c=sub_la_exp['bin2_id']-sub_la_exp['bin1_id'],\n", + " vmin=0,\n", + " vmax = 100,\n", + " cmap=\"YlOrRd_r\")\n", + "\n", + "# let's select pixels with \"small\" p-values:\n", + "kinda_signif_pixels = la_exp[signif_pvals]\n", + "\n", + "plt.scatter(kinda_signif_pixels[xlabel],\n", + " kinda_signif_pixels[ylabel],\n", + " s=80,\n", + " facecolors='none',\n", + " edgecolors='b')\n", + "\n", + "# we can add a visual of the lambda-chunking grid on top of obs/exp scatter ...\n", + "# plt.vlines(ledges[1:-15],ymin=0.5,ymax=900,color='red')\n", + "\n", + "ax = plt.gca()\n", + "fig = plt.gcf()\n", + "\n", + "ax.set_xscale('log')\n", + "ax.set_yscale('log')\n", + "\n", + "ax.set_xlim(0.5,700)\n", + "ax.set_ylim(0.5,1200)\n", "\n", "ax.set_ylabel(\"count\")\n", "ax.set_xlabel(\"la_exp value\")\n", @@ -635,26 +758,38 @@ "fig.colorbar(sct)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Rao et al 2014 statistics is more nuanced\n", + "\n", + " 1. Simple p-value thresholding should be replaced to more \"productive\" FDR, which is more tractable and better suited for the job.\n", + " 2. Another argument is that it is \"unfair\" to treat all of the pixels with the same statitical testing (multiple hypothesis) - the range of \"expecteds\" is \"too wide\"\n", + " 3. 2nd point is addressed by spliting the pixels in the groups by their localy adjusted expected - the so-called $\\lambda$-chunking\n", + " 4. Another nuance of $\\lambda$-chunking is that Rao et al are using the upper boundary of each $\\lambda$-chunk as an expected for every pixel in the chunk (clearly for technical reasons) - we could see how that affects the significance by itself." + ] + }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 99, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Text(0, 0.5, 'la_exp value')" + "(-100, 8500)" ] }, - "execution_count": 89, + "execution_count": 99, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAEKCAYAAADn+anLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3X+U3HV97/HnazcDTEDZUCIlSzDIxVCQI2gK2HhawLaoVImiUq5W9HgPvad6FYrxBqUCipcoVu1PerBa8UJjwq+IxRYRYmnxBk3IhhBJKvIjyZJCqllEspDN5n3/+H4nzM7Od+a7m52d2f2+Hufs2ZnPfGfms5PJ9/39/Hp/FBGYmZnV09XuCpiZWedykDAzs0wOEmZmlslBwszMMjlImJlZJgcJMzPL5CBhZmaZHCTMzCyTg4SZmWWa0e4K7K/DDz885s2b1+5qmJlNKWvXrv2viJjd7LgpHyTmzZvHmjVr2l0NM7MpRdKTeY5zd5OZmWVykDAzs0wOEmZmlslBwszMMjlImJlZpik/u2kirFzXz7V3beapgUHm9JRZfPZ8Fp3S2+5qmZm1XeGDxMp1/Vx22wYGh4YB6B8Y5LLbNgA4UJhZ4RW+u+nauzbvCxAVg0PDXHvX5jbVyMyscxSyJVHdvZS1w/dTA4OTWiczs05UuCBR272UZU5PeZJqZGbWuQrX3VSve6lWudTN4rPnT1KNzMw6V+GCRLNupG6J817f60FrMzMKGCSadSMNR3Dr2n5WruufpBqZmXWuwgWJxWfPp1zqbniMZzeZmSUKN3Bd6Uby7CYzs+YKFyQgCRSVYLFw6b301wkInt1kZlbA7qZa9bqfPLvJzCxRyJZEtdruJ+duMjN7SeGDBIzsfjIzs5cUvrvJzMyyOUiYmVkmBwkzM8vkIGFmZpkcJMzMLFNLg4SkuZJWSXpE0kZJH0vLr5TUL6kv/Xlr1XMuk/SopM2Szm5l/czMrLFWT4HdA1waEQ9KehmwVtLd6WNfjogvVh8s6QTgD4ETgTnA9yW9OiIa5/Y2M7OWaGlLIiK2R8SD6e3ngEeARgsSzgW+FREvRsTjwKPAqa2so5mZZZu0MQlJ84BTgAfSoo9IekjS1yXNSst6ga1VT9tG46BiZmYtNClBQtIhwK3AxRHxS+A64FjgZGA78OeVQ+s8fVSiVkkXSVojac2OHTtaVGszM2t5kJBUIgkQN0XEbQAR8XREDEfEXuCrvNSltA2YW/X0o4Cnal8zIq6PiAURsWD27Nmt/QPMzAqspQPXkgR8DXgkIr5UVX5kRGxP774DeDi9fQfwj5K+RDJwfRzwo1bWEWDlun4n+DMzq6PVs5sWAn8EbJDUl5Z9ErhA0skkXUlPAH8MEBEbJa0AfkIyM+rDrZ7ZtHJdP5fdtoHBoeRt+gcGuey2DQAOFGZWeIrI2pttaliwYEGsWbNm3M/P2nSot6fM/UvO2p+qmZl1LElrI2JBs+MKv+I6a5tSb19qZuYgkblNqbcvNTPzpkMsPnv+iDEJGLl96UQPanuQ3MymksKPSUD2ibt2UBuShRxBMmYx1hN8vdcrl7q55p0nOVCY2aTKOyZR+JYEZG9feu1dm0ec0OGllX39A4MsvmX9vufnUe/1BoeGufauzQ4SZtaRChkkalsOZx4/m1WbdvDUwCCHlktIMLBraPRS7xpDw8FV39mY+wTvQXIzm2oKFyRWrutn8c3rGdqbhID+gUFuXL1l3+MDg0Njer2du/IfP6enXHe6rQfJzaxTFW5205V3bNwXICbb4rPnUy51jyirHiQ3M+s0hWtJjLWl0Ey5lD/OVrqlPLvJzKaKwgWJ8ejtKTOwazfP7x6dIaRL9RLXZssaJDcz60SF626aNbM05uecefzsugECyCw3M5sOChckrnjbiZS6R179d3eJnnJ28Fi1qfmeFSvX9bNw6b0cs+ROFi69l5Xr+ve7rmZm7Va4ILHolF6ufddr6e0pI5KupAtOncvBB2b3vDWbolpZJNc/MEjwUiZZBwozm+oKFyRqPf/iHpb/eGvdqakVzaaoNlokZ2Y2lRUuSNRe9Q8MDjE0nD0ltotk6mp3xgB1t9R0kZy7osxsqipckKh31d/IXmDNk7/ggtPm1n38oFJX5srsOT1ld0WZ2ZRWuCAxnhQYyx7YytWLTuJ9px+9r0UhkgHvrNlNlUVy7ooys6mscEFiPCkwhtNMuVcvOomfXfNWnlh6DnN6ygxnrNzu7Snvy+zqfE1mNpUVLkjM+7X6QeLAGWP7KLJO8oJ9254uXHpvZldUzzjWa5iZTbbCBYnVj+2sW/7inr0Nn1c76NxoR7vqcYgsU3wbDzMriMIFieFxnp1rB50bJevLMzj+7ATnkDIza4XCBYn9Vb1J0DXvPGnEorxm4xDVnB7czKYCJ/gbh2ZBIGvfiIqs9ODe/9rMOk3hWhK9E3AFf2i51HD9Q72uqMpSvOoWRzWvpzCzTlS4lsS8X2t8lV9NUHd20tDw3sz1Dxcv76O3p8x5r+/dtyVqnlaB9782s05UuCCRNbupnqwh7ud3D/P87uxA0z8wyK1r++u2GLJ4PYWZdaLCdTeNd3ZTraxcThVjXVXdaEqtmVm7tDRISJoraZWkRyRtlPSxtPwwSXdL+mn6e1ZaLkl/KelRSQ9Jel0r69fIAd2Ng0CeYDOWVoD3vzazTtTqlsQe4NKI+A3gdODDkk4AlgD3RMRxwD3pfYC3AMelPxcB17W4fpl2N8gMm3fD0rG0AhpNqTUza5eWjklExHZge3r7OUmPAL3AucAZ6WE3AD8A/nda/s2ICGC1pB5JR6av0zHKpS52DTVeoV3qErt27+GYJXeOGLhuNM3V+1+bWaeZtIFrSfOAU4AHgCMqJ/6I2C7pFelhvcDWqqdtS8tGBAlJF5G0NDj66KNbWu96mgWInnKJ53fvYeeuZFV1/8Aglyzv4+LlfSNmTFWmuQIODmbWkSZl4FrSIcCtwMUR8ctGh9YpG9XvExHXR8SCiFgwe/bsiarmhDn4wBmjNjKKmt8VThtuZp2s5UFCUokkQNwUEbelxU9LOjJ9/EjgmbR8G1C9u89RwFOtruNEG+u01f6BQe9aZ2YdqdWzmwR8DXgkIr5U9dAdwIXp7QuBb1eVvz+d5XQ68GynjUfk0dVkemw9XmVtZp2o1S2JhcAfAWdJ6kt/3gosBX5P0k+B30vvA3wXeAx4FPgq8Cctrl9L7M9aDHc/mVknafXspn8ne8bom+ocH8CHW1mnqcCrrM2sUxRuxXWnmDWzlJls0KuszaxTOEi0yc5dQ5x5fP2ZWVnlZmaTzUGijVZt2lG3/MbVWzzTycw6goNEm5RLXQ1Tlnumk5l1AgeJNhlssmo7OcYzncysvRwkOpxnOplZOxVu06GppksalSSwlvfGNrNWcZDocJWFeVnJACt7Y1e2PnXSQDObSLm7mySVJXkHnBbolhBJ9thZM0uI+jvf1RujaLQ3tpnZ/srVkpD0NuCLwAHAMZJOBj4TEW9vZeWKoEvw5+957air/mOW3Fn3+MoYRaWLKWuGlMcyzGwi5G1JXAmcCgwAREQfMK81VSqWvQFrnvzFqPJGe16vXNfP4lvWN5xC61XbZjYR8o5J7ImIZzWO7KbW3E2rt3D1opO4fOUGlj2wtWGCwDOPn81V39k4ar+Kat4b28wmSt4g8bCk/w50SzoO+Cjww9ZVq1gCuHzlBm5cvaXpsas27di34109vfsxu8mzpMysVt4g8b+ATwEvAsuAu4DPtqpSRbTsga3ND6L5WMP9S84acT/vid+zpMysnlxjEhGxKyI+FRG/mW4b+qmIeKHVlSuSvHtQjGWsoXrsorKp0eJb1tdN9eFZUmZWT64gIWmVpHtrf1pdORup1C0Wnz2fWTNLdR+vLa83djE0HFz1nY2jnpvVQvEsKbNiy9vd9PGq2wcB5wF7Jr461sjQcHDx8j5mzSzRpWRmVEWpW1zxthNHHJ81dlGvfE5Pue5sKc+SMiu2vN1Na6t+7o+IPwVOa3HdLMPOXUN0d4mecrLwbtbMEgcfMINLlveNO8X44rPnUy51jyjzLCkzy7uY7rCqu13A64Ffb0mNLJeh4eDgA2dw5dtPzBxw7imXGBgc3WroKY/urqoMTnt2k5lVy9vdtJZkpqZIupkeBz7UqkpZPv0Dg1y8vG9U+eDQMJeuWF93MLzUJa58+4mjyiEJFA4KZlYtV5CIiGNaXRGbWNUBQiQRfn/WUJhZMTUMEpLe2ejxiLhtYqtjrVAJELVrKMzMmmnWknhbg8cCcJCYIjyV1czGo2GQiIgPTlZFrLUqU1mdesPMxiL3pkOSzgFOJFknAUBEfKYVlbKJd+bxs516w8zGLO+K678DzifJ4STg3cArW1gvm2CrNu1w6g0zG7O8+0n8VkS8H9gZEVcBbwDmNnuSpK9LekbSw1VlV0rql9SX/ry16rHLJD0qabOks8f6x1i2/oHBzP0nGu1LYWbFlre7qXIW2SVpDvBzIM+02G8Afw18s6b8yxHxxeoCSScAf0jSpTUH+L6kV0fEMLbfKtuh1ls7UW+r1GoexzArrrwtiX+S1ANcCzwIPEGSMryhiLgPGL3tWn3nAt+KiBcj4nHgUZLd8KyBJ5aew/tOP7rpiX44IjPTbKMMtJVxjOpMspfdtmFcqT/MbOrJm7vpsxExEBG3koxFHB8Rn96P9/2IpIfS7qhZaVkvUL2pwra0zBqYt+ROlj2wlQtOm8sTS89pGizq6W2QxM/jGGbFlnfger2kT0o6Nr3Sf3Y/3vM64FjgZGA78OeVt6lzbN1LXEkXSVojac2OHTv2oyrTw3AEN67ewrwld+bel6KiWRI/pxA3K7a83U1vJ8nZtELSjyV9XNLR43nDiHg6IoYjYi/wVV7qUtrGyMHwo4CnMl7j+nTzowWzZ88eTzUKTyQtiGveeVLd8YXLV27g2Mu+Wz9K4xTiZkWRN3fTk8AXgC+ke1z/GfB5oLvhE+uQdGREbE/vvgOozHy6A/hHSV8iGbg+DvjRWF/fmps1s8S6T/9+5uPN9tt2CnGz4hjLYrp5wHtI1ksMA5/I8ZxlwBnA4ZK2AVcAZ0g6maQr6QngjwEiYqOkFcBPSFotH/bMptao9EhdvnIDyx7YynAE3RIXnDaXqxed1HC/7d6eMmceP5tr79rMJcv7PNvJbJrLu5/EA0AJWAG8OyIey/O8iLigTvHXGhz/OeBzeV7bxu/ZwaFRrYXKuEbldpbFZ8/3qm2zAsnbkrgwIja1tCY2aeb0lDNbC8se2Eq3lLmeotFsJwcJs+kn7xRYB4hp5MzjZzdcM3HBafUX019w2lzPdjIrmLyzm2waaTQo3S1x9aKTWHjsYSPKFx57GFcvOilzVpNnO5lNTw4SNsIFp81l5bp+HtwycinMD3/2C+YtuZPnX9xDqXvkkhbPdjKbvvIOXB8E/AnwRpJZSf8OXBcRL7SwbjaJqmc3LVx676hxh0rn1MDgEKUuMWtmiYFdQw1nNznnk9nUl3fg+pvAc8BfpfcvAP4vScpwmwZ+ds2+ZLxNxxeG9gYzD5jRcK2F964wmx7yBon5EfHaqvurJK1vRYVs8tXmQ5nTU26aPrxZIPEsKLPpIe+YxDpJp1fuSDoNuL81VbLJNvOAkQvnF589n3Kp8WL6ZgPVngVlNj3kDRKnAT+U9ISkJ4D/B/yOpA2SHmpZ7WxSPL97mIVL792X/nvRKb287uhDM48vdYvnX9zDMUvuHPE8SLqZFi691zmfzKaJvN1Nb25pLazt+gcGWXxL0oO45slfcP/P6m8DMmtmiV+9sIeBwaF9z6uMNQAjxiFqeRaU2dSTN0gcFxHfry6QdGFE3NCCOlmbDA0Hf7qij70ZzYBuiZkHzGDnrqER5dX7S2QFiF7PbjKbkvIGiU9LOg/4OHAI8PfAi4CDxDSTFSAgWY3daJ/srO2OBNy/5Kz9rpuZTb68QeJ3gEuBvvT+pyOi6falNr1k5XSqOLRc2tcNVVsOXjdhNhXlHbieRTJ4/TOSFsQrpXHsk2lT2umvmtXw8axvhOS9ss2mqrxBYjXwzxHxZuA3STYF8hTYgskazK6oHauoLvde2WZTU97upt+NiC0AETEIfFTSb7euWjbVdAlEdopxr5swm5ryBomtkt4HvCoiPpPub+28TbZPMuCdnX68N2MVdyesm/BYiVm2vN1Nfwu8gSRnEyR5nP6mJTWyaacy/bU2eywkYxO1C/ImU7OxksriwHoLB82KIG9L4rSIeJ2kdQARsVPSAS2sl00TIxbQZUyMqk3+l/fKfiJaAM3GSpyk0Ioub5AYktRN+t9c0mxgb8tqZVOeYMSJe+HSexlqsAhjrCfmicoymzUm0j8wyKUr1o8aY3GSQiuavEHiL4HbgVdI+hzwLuDyltXKprQuwWPXnDOiLM8A9VMDg02zx1ZaD/XGN8ZzAm+U8TZrTYgH261I8u5xfRPwCeAaYDuwKCJurjwuqfEEeiuUeg2GPAPUc3rKDWdBVY8fZBnrCTxPxtt69TQrirwtCSJiE7Ap4+F7gNdNSI1s2rh85QaWPbCV4QikpIWR1eNUGbvIaiXM6SnXbWXUO24sKq2OrPfNqqdZUUzUHtdefW37dJEEiBtXb9nXZRORBIiZpS4E9JRLzJpZQiSzn65550ksOqW37pV95cTcrJUw3hP4olN6uX/JWfRmBJhuaVQ9zYoid0uiiQZp4axo9gI3rt5S97HBob08vvScUeWVqaZPDQxyaLnEQaWuUXtoN7ra7+0pc+bxs7n2rs1csryPQ8slJJruw11t8dnzR6U6L5e6HRis0CYqSJjlUrmaqJ6+2jOzxLO7hvZNlxsYHKLUJb58/skjTs6NTuIwclZUdaLBvDOfqruevLDOLKFokNUz94tI6yLilAmoz5gtWLAg1qxZk/v4eUvubGFtLC/RvPnZUy7Rd8XvjyjLWhuxcOm9TccUenvKTllulpK0NiIWNDtuTC0JSa8ADqrcr+RzAt6UcfzXgT8AnomI16RlhwHLgXnAE8B70sV5Av4CeCuwC/hARDw4lvrZ1JHn0mRgcIiFS+8dcTW/6JTeulf2eafYmtnY5Bq4lvR2ST8FHgf+leTk/s+VxyMiKz3oNxi99ekS4J6IOI5kVtSStPwtwHHpz0XAdbn+ApvWKtuqNkuTkXeKrZmNTd7ZTZ8FTgf+IyKOIWk5NE0VHhH3AbUB5Fxe2tHuBmBRVfk3I7Ea6JF0ZM762TQ2NBxc9Z2NDfMsnXn87Iav4amrZuOTOy1HRPxcUpekrohYJenz43zPIyJiO0BEbE+7sAB6ga1Vx21Ly7aP831sGtm5a4iLl/eNKh8cGubi5X10N9gDy/trm41f3iAxIOkQ4D7gJknPAHsmuC71/pfX7bqWdBFJlxRHH330BFfDpqKsFBreX9ts/+QNEueS7B9xCfBe4FDgM+N8z6clHZm2Io4EnknLtwFzq447Cniq3gtExPXA9ZDMbhpnPawA6o1DVK8E75a44LS5XL3opDbUzqzz5QoSEfF81d0bMg/M5w7gQmBp+vvbVeUfkfQtkv20n610S5mNV+1YRWUleMVwBDeu3sLtD/aza/fwhK2N8EZGNl00DBKSnqN+l4+AiIiXN3n+MuAM4HBJ24ArSILDCkkfArYA704P/y7J9NdHSabAfjD/n2FW342rt7Bq0459J+mbMlaCP7974vaMmKg05madoGGQiIiX7c+LR8QFGQ+NWlcRyaq+D+/P+5nVU32SztM3ub97RjRLd242lUxUgj+zjla9qVEe+7PwrlG6c7OpxkHCCiNPKvCK/Vl4l/VcL+azqcgJ/sxqVC+8azQAnfVYViLCZov5PNhtnchBwgqtkmJ81aYdo07O9QagL1nex8XL++gpl3h+9x6GhmPfY7WD02M54Xuw2zqVg4QVWqOFdvUGoCsD39WpyCuqB6ezEhGO5b082F0sndqSdJCwwstaXDeegeaxjHvASyeGrOd5sLsYOrkl6SBhhZa1uC5rZ71m6uWQyrpCXLmun8U3r2coa+NvJn6wu1OvVouuk1uSE7LpUDt50yHbH1Ky//ZE6q0NBLes3zd2MeK9abxuY6K3Tq29Wm3Fe9hoeQLzMUvuzPwuCFoS0PNuOuQpsFZorbhG6h8YZPHNyR4YV31nY90AAY0DRG9PecJP3o2uVq01GqW3r9aoxVh53iXL+5hXs4/KZHCQMGuBob3BJcv72Llr9AB3HvcvOavpbKh6my814kV+ky9vYF589nzKpe6Gr1W5qMgKNK3iMQmzFhlvI2XWzBKQfyyj0nKBxoOcc3rKdQfIvcivdfIG5tpp082+O4NDw1y6Yj2XLO9r+diSg4RZB+kSXPG2ExvOdrnyjo2jBruH9gZX3rGx4YlivIv8Jlt1cDy0XEKCgV1DHT3QnhXQswJzQMP92xcuvbfpTLnKHiqtngnlgWuzDtQt1d1IqTfjpFPxxNJzGr5uO2c3VU81lqA8o4vBob0NFzDW6sSB9kYTAoCGf0+pSxxy0IxRQbDZ51BPb095TBts5R24dkvCrANl7bTXbPyg9uq01lgX+e2P6oBULnWxa2jvvsci2He/+kq4Xh9+tU6ZFlqt0bhD5aSdtRZmaG/sG7fKWrWfd+1Nq8aWHCTMppBm7f684xMTpdG4SfWVcHWAqKdyUs1zopvMgfY8La9m4w6VwNxommtFZc/2a+/aPGrDrGZ60rGsieYgYTbNDO0NLlnR13RQs/oE2DOzRAQ8O5i/77/RuEmzFkE9lRNxsyvnyRpoz7sK+tByqW6alkPLI0/aef62iv6BwTEv6GzVyIGnwJpNQxEvza//0xV9o6ZL1s7f37lriIHBoYZz+Ws16mYZz9X+nDTZYiOTOdCed/pqnUX2I8or05XHmrJlrJ6tE6gmgoOE2TS3N+CTtz00oixv338jjbpZxnq1X+oSi8+ez6pNOzKP6e0pc97re7n2rs1N14eMZx1JrbzTVwcy1sIM7BoaEYwnSu8k71fiIGFWALuG9nLsZd/l8pVJd0meK/3+gcG6J9nKCTird6PSXVW7OKxL2Vfde0mm9madTEUyhffWtf1NVy/nXeXcTN7No7KOC+DSFeubdrvVy/fVyK7deyh1jXxOK1tYngJrVjDlUjL1dCwqeaZq99EY/dovTVHNyq47nq6XytVzvefVTv3Mev2sKaJ5B98b/X2TrdQtDj5gxpjGkGp5CqyZ1TXWAAGN99GoqGzgdO1dm7l4ed+IBIbDEdy6tp8FrzxszAGicpV88fK+uo/Xvt5Y0o/kGZyuF0BqswdPtqHh4LkX9kzKezlImNl+q3QHVZ9wa6+vK+McWQsF65mVzrq6JCNAwEvdNZUWQaNusFrNUnRXryupvP4ly/vGnXJlIk3WimsHCTPbb5X+92Yn/7G0InrKJV4Y2tu0T384glM+8z1+9cKezL05svrs87Y6GqV87wStXGTogWszmxB5WwdZs3OqVQa586612LlrKDNANEq73mjQuXrAvlHK907hFddm1hEq+YbGmwY9T2tibzDu168mRu9jXruIsNSlugGmuhtnIurSarWL9yaKWxJmlltvT5nzT53LzAOmxvVlbUuh3iJClHRt1VNJyT0VDA2PfUJCHlPjX9rMOsJTA4Ms+9FWhhvsy90p6o1D1BuoHhoODj5wRubMrXZMcR2P53ePLQ1KXm0LEpKeAJ4DhoE9EbFA0mHAcmAe8ATwnojY2a46mtlIAVMiQEggkt0BK8nyVm3akdnV1eqUGVNZu7ubzoyIk6sWdCwB7omI44B70vtmZmNSSUVeWXF94+ot0z4QjG3ddn7tDhK1zgVuSG/fACxqY13MzKaMVrXv2hkkAviepLWSLkrLjoiI7QDp71fUe6KkiyStkbRmx47shGBmZkUxaxruJ7EwIp6S9Argbkmb8j4xIq4Hrockd1OrKmhmNlW8MMb9O/JqW0siIp5Kfz8D3A6cCjwt6UiA9Pcz7aqfmdlUMp6cXHm0JUhIOljSyyq3gd8HHgbuAC5MD7sQ+HY76mdmZol2dTcdAdyuJDHXDOAfI+JfJP0YWCHpQ8AW4N1tqp+Z2ZTS1aLpTW0JEhHxGPDaOuU/B940+TUyM+sclbTrjdZ21GrV8hWvuDYz6zD9A4PcvfE/+a9f5c8ZNR1nN5mZWYann9s9puN/9UJrkhB22mI6MzMbhxZNbnKQMDOzbA4SZmaWyUHCzMwyOUiYmVkmBwkzM8vkIGFmZpkcJMzMLJODhJmZZXKQMDOzTA4SZmaWyUHCzMwyOUiYmVkmBwkzM8vkIGFmZpkcJMzMLJODhJmZZXKQMDOzTA4SZmaWyUHCzMwyOUiYmVkmBwkzM8vkIGFmZpkcJMzMLFPHBQlJb5a0WdKjkpa0uz5mZkXWUUFCUjfwN8BbgBOACySd0N5amZkVV0cFCeBU4NGIeCwidgPfAs5tc53MzAqr04JEL7C16v62tMzMzNqg04KE6pTFqIOkiyStkbRmx44dk1AtM7Ni6rQgsQ2YW3X/KOCp2oMi4vqIWBARC2bPnj1plTMzK5pOCxI/Bo6TdIykA4A/BO5oc53MzAqro4JEROwBPgLcBTwCrIiIjRP5Hk8sPWciX87MrCO06tw2oyWvuh8i4rvAd1v5Hg4UZmb5dFRLwszMOouDhJmZZXKQMDOzTA4SZmaWyUHCzMwyKWLUguYpRdIO4Ml212McDgf+q92V6ED+XEbzZzKaP5PRxvqZvDIimq5GnvJBYqqStCYiFrS7Hp3Gn8to/kxG82cyWqs+E3c3mZlZJgcJMzPL5CDRPte3uwIdyp/LaP5MRvNnMlpLPhOPSZiZWSa3JMzMLJODxCSQNFfSKkmPSNoo6WNp+WGS7pb00/T3rHbXdbJJ6pa0TtI/pfePkfRA+pksT1PGF4akHkm3SNqUfl/eUPTviaRL0v83D0taJumgIn5PJH1d0jOSHq4qq/vdUOIvJT0q6SFJrxvv+zpITI49wKUR8RvA6cCHJZ0ALAHuiYjjgHvS+0XzMZK08BWfB76cfiY7gQ+1pVbt8xfAv0TE8cBrST6bwn5PJPUCHwUWRMRrgG6SfWaK+D35BvCWcX0KAAAGpElEQVTmmrKs78ZbgOPSn4uA68b7pg4SkyAitkfEg+nt50j+4/cC5wI3pIfdACxqTw3bQ9JRwDnA36f3BZwF3JIeUqjPRNLLgd8GvgYQEbsjYoCCf09ItjQoS5oBzAS2U8DvSUTcB/yipjjru3Eu8M1IrAZ6JB05nvd1kJhkkuYBpwAPAEdExHZIAgnwivbVrC2+AnwC2Jve/zVgIN18CpLtbHvbUbE2eRWwA/iHtAvu7yUdTIG/JxHRD3wR2EISHJ4F1lLs70m1rO9GL7C16rhxf0YOEpNI0iHArcDFEfHLdtennST9AfBMRKytLq5zaJGm380AXgdcFxGnAM9ToK6letI+9nOBY4A5wMEkXSm1ivQ9yWPC/i85SEwSSSWSAHFTRNyWFj9daQKmv59pV/3aYCHwdklPAN8i6T74CkmzuLJj4lHAU+2pXltsA7ZFxAPp/VtIgkaRvye/CzweETsiYgi4Dfgtiv09qZb13dgGzK06btyfkYPEJEj72r8GPBIRX6p66A7gwvT2hcC3J7tu7RIRl0XEURExj2Qg8t6IeC+wCnhXeljRPpP/BLZKmp8WvQn4CQX+npB0M50uaWb6/6jymRT2e1Ij67txB/D+dJbT6cCzlW6psfJiukkg6Y3AvwEbeKn//ZMk4xIrgKNJ/jO8OyJqB6amPUlnAB+PiD+Q9CqSlsVhwDrgfRHxYjvrN5kknUwykH8A8BjwQZKLucJ+TyRdBZxPMktwHfA/SPrXC/U9kbQMOIMk2+vTwBXASup8N9KA+tcks6F2AR+MiDXjel8HCTMzy+LuJjMzy+QgYWZmmRwkzMwsk4OEmZllcpAwM7NMDhJmTUj6n5Le3+56jEWaTfZPqu7PkXRLo+eY1eMpsGZTlKQZVfmLah+bB/xTmjnVbNzckrCOJenP0n0V7k73Efh4Wn6spH+RtFbSv0k6Pi3/RppD/4eSHpP0rrRckq5N9yPYIOn8tPwMSf8qaYWk/5C0VNJ7Jf0oPe7Y9Lgrq977v0n6vqT1kh6sHFNV54Ml3Zk+/nDVe70+fa+1ku6qSqXwA0lfSev8sKRT0/JT07J16e/5afkHJN0s6TvA9yQdIumetC4bJJ2bVmUpcKykvvRvn6d0HwIl+zH8Q3r8OklnVr32beln+1NJX2jZP65NHRHhH/903A+wAOgDysDLgJ+SrMqGJG/+cent00hSekCSb/9mkoufE4BH0/LzgLtJ9iI4gmRl6pEkq1cH0tsHAv3AVelzPgZ8Jb19ZdV7PwC8I719EDCzpt7nAV+tun8oUAJ+CMxOy84Hvp7e/kHleJI04Q+nt18OzEhv/y5wa3r7AyR5eQ5L788AXp7ePhx4lCS527zKa6WPzat67UuBf0hvH59+Hgelr/1YWueDgCeBue3+LvinvT+VBFlmneaNwLcjYhAgvXKuZNL9LeDmJPMAkJzgK1ZGxF7gJ5KOqHqtZRExTJIQ7V+B3wR+Cfw40pw2kn4GfC99zgbgzOoKSXoZ0BsRtwNExAt16r0B+KKkz5N09/ybpNcArwHuTuvcTZL2umJZ+nr3SXq5pB6SwHiDpONIsneWqo6/O15KyyHg/0j6bZKUL70kgbCRNwJ/lb7nJklPAq9OH7snIp5N/96fAK9kZMppKxgHCetU9VIdQ9JKGIiIkzMer87fo5rfzY7fW3V/L6P/fzR6HQAi4j8kvR54K3CNpO8BtwMbI+INWU+rc/+zwKqIeEc6vvCDqsefr7r9XmA28PqIGFKSVfegJtXM+3kM43NE4XlMwjrVvwNvS/vPDyHZwY5I9uF4XNK7Yd94w2ubvNZ9wPlK9tOeTdKt86OxVih9722SFqXvfaCkmdXHSJoD7IqIG0k2y3kdsBmYLekN6TElSSdWPa0ybvFGkmydz5J0+fSnj3+gQbUOJdmXYygdW3hlWv4cSWuknvtIgguSXk2SHG5zkz/fCspBwjpSRPyYJN3xepI9BNaQ7EoGyQnuQ5LWAxtJNqVp5HbgofS17gU+EUla7vH4I+Cjkh4iGWf49ZrHTwJ+JKkP+BRwdUTsJklr/fm0zn0kXWYVOyX9EPg7Xtqr+QskLZH7SbqnstwELJC0huRz2QQQET8H7k8Hw6+tec7fAt2SNgDLgQ/ENM+gauPnKbDWsSQdEhG/Sq/W7wMuinSv8OlC0g9IBsXHlcbZrNXc32id7HpJJ5D0sd8w3QKE2VTgloSZmWXymISZmWVykDAzs0wOEmZmlslBwszMMjlImJlZJgcJMzPL9P8BHiH9ldrRdaYAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -664,39 +799,48 @@ } ], "source": [ - "xlabel = 'la_exp.donut.value'\n", - "ylabel = 'count'\n", - "\n", - "plt.scatter(cccc['bin2_id']-cccc['bin1_id'],(cccc[xlabel]))\n", - "# plt.scatter(dddd[xlabel],dddd[ylabel], s=80, facecolors='none', edgecolors='r')\n", - "# plt.scatter(eeee[xlabel],eeee[ylabel], s=80, facecolors='none', edgecolors='y')\n", + "# The essence of lambda-chunking - let's split the surveyed pixels into \"chunks\" based on\n", + "# their la-expected value and do multiple hypothesis testing separately for these chunks.\n", + "nlchunks = dotfinder.HiCCUPS_W1_MAX_INDX\n", + "base = 5 ** (1/3)\n", + "ledges = np.concatenate((\n", + " [-np.inf],\n", + " np.logspace(0, nlchunks - 1, num=nlchunks, base=base, dtype=np.float),\n", + " [np.inf]))\n", "\n", + "#################################################\n", + "plt.plot(ledges,np.zeros_like(ledges),'r|')\n", + "plt.title(\"the $\\lambda$-chunks\")\n", + "plt.xlabel(\"# of interactions\")\n", + "fig = plt.gcf()\n", + "fig.set_size_inches(6,1)\n", "ax = plt.gca()\n", + "ax.set_yticks([])\n", + "ax.set_xlim(-100,8500)\n", "\n", - "ax.set_xlabel(\"genomic separation\")\n", - "ax.set_ylabel(\"la_exp value\")\n" + "# consider embedding this picture to the markdown section ..." ] }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 100, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Text(0.5, 0, '# of interactions')" + "" ] }, - "execution_count": 71, + "execution_count": 100, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -706,24 +850,79 @@ } ], "source": [ - "# for large genomes- calculate histograms i.e. start with lambda-chunking right away:\n", + "# here are trying to see the effect of using the chunk boundary as an expected instread of actual expected for a given pixel:\n", "\n", - "nlchunks = dotfinder.HiCCUPS_W1_MAX_INDX\n", - "base = 2 ** (1/3)\n", - "ledges = np.concatenate((\n", - " [-np.inf],\n", - " np.logspace(0, nlchunks - 1, num=nlchunks, base=base, dtype=np.float),\n", - " [np.inf]))\n", + "# we can exaggerate the \"ledges\", i.e. make lambda-chunks very wide to see the side effect of replacing expected within each chunk\n", "\n", - "#################################################\n", - "plt.plot(ledges,np.zeros_like(ledges),'r|')\n", - "plt.title(\"those freaking lambda-chunks/bins/whatever\")\n", - "plt.xlabel(\"# of interactions\")" + "for k in ktypes:\n", + " la_exp[\"la_exp.\"+k+\".value.chunked\"] = ledges[np.digitize(la_exp[\"la_exp.\"+k+\".value\"],ledges)]\n", + " \n", + "# recalculate the p-values to take 4th item into account:\n", + "for k in ktypes:\n", + " la_exp[\"la_exp.\"+k+\".pval\"] = 1.0 - \\\n", + " poisson.cdf(la_exp[\"count\"],\n", + " la_exp[\"la_exp.\"+k+\".value.chunked\"])\n", + "\n", + " \n", + "# arbitrary p-value threshold\n", + "p_th = 0.0001\n", + "\n", + "# let's test p-value for all of the 4 filters - feel free to play with individual filters/kernels as well:\n", + "signif_pvals = np.ones_like(la_exp[\"la_exp.donut.pval\"].values,dtype=np.bool)\n", + "for k in ktypes:\n", + " signif_pvals = signif_pvals & (la_exp[\"la_exp.\"+k+\".pval\"]<=p_th)\n", + "\n", + "\n", + "# plotting - consider making it shorter:\n", + "sct = plt.scatter(sub_la_exp[xlabel],\n", + " sub_la_exp[ylabel],\n", + " # color dots on the scatter by their genomic separation\n", + " c=sub_la_exp['bin2_id']-sub_la_exp['bin1_id'],\n", + " vmin=0,\n", + " vmax = 100,\n", + " cmap=\"YlOrRd_r\")\n", + "\n", + "# let's select pixels with \"small\" p-values:\n", + "kinda_signif_pixels = la_exp[signif_pvals]\n", + "\n", + "plt.scatter(kinda_signif_pixels[xlabel],\n", + " kinda_signif_pixels[ylabel],\n", + " s=80,\n", + " facecolors='none',\n", + " edgecolors='b')\n", + "\n", + "# we can add a visual of the lambda-chunking grid on top of obs/exp scatter ...\n", + "plt.vlines(ledges[1:-15],ymin=0.5,ymax=900,color='red')\n", + "\n", + "ax = plt.gca()\n", + "fig = plt.gcf()\n", + "\n", + "ax.set_xscale('log')\n", + "ax.set_yscale('log')\n", + "\n", + "ax.set_xlim(0.5,700)\n", + "ax.set_ylim(0.5,1200)\n", + "\n", + "ax.set_ylabel(\"count\")\n", + "ax.set_xlabel(\"la_exp value\")\n", + "\n", + "fig.colorbar(sct)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Assigning pixels to $\\lambda$-chunks:\n", + "\n", + " - After defining the bins for the expected (boundaries of $\\lambda$-chunks) let's actually chunk the data\n", + " - this step involves *de novo* calculation of locally adjusted expected\n", + " - l.a. expected is used to build histograms of observed data" ] }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 101, "metadata": {}, "outputs": [ { @@ -753,24 +952,25 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### determine thresholds using the fdr thing ..." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "##### to be continued ..." + "### determine thresholds using the fdr thing ...\n", + "\n", + "[we should understand a little better - what is going on here with the multiple hypothesis testing, see https://github.com/mirnylab/cooltools/issues/82]\n", + "\n", + "long story short:\n", + " - for each $\\lambda$-chunk we are calculating q-values in an efficient way, skipping calculations of p-values for each surveyed pixel\n", + " - in part this is achieved by using upper boundary of each $\\lambda$-chunk as an expected for every pixel in this chunk\n", + " - and in part the efficiency comes from collapsing identical observed values, i.e. histogramming\n", + " - to be checked: q-values > 1.0 seem to be weird - we need to check if that is ok\n", + " - also to be comared with the stats-packages implementations - just in case, e.g. `from statsmodels.stats import multitest; multitest.multipletests(pvals,alpha=0.99,method=\"fdr_bh\")`\n" ] }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 129, "metadata": {}, "outputs": [], "source": [ + "# this determines observed thresholds for each chunk and corresponding q-values for every observed value\n", "threshold_df, qvalues = dotfinder.determine_thresholds(\n", " kernels, ledges, gw_hist, 0.99)" ] @@ -786,7 +986,7 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 137, "metadata": {}, "outputs": [ { @@ -803,13 +1003,13 @@ "Text(0.5, 0, 'lambda-chunks')" ] }, - "execution_count": 53, + "execution_count": 137, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmcAAALkCAYAAABKlpJnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xd4VFX+BvD3TEsPpBB6CyAgSpGggiIivSiKYkexrK5rY3VXXfnZUXHXAoJ117Ky1lVBURAQFVdRERQFBUR6b+ll+v39cSMQSTIz39y5c2fyfp5nHiTMOfdISd6c8j1K0zQQERERkTXYYj0AIiIiIjqM4YyIiIjIQhjOiIiIiCyE4YyIiIjIQhjOiIiIiCyE4YyIiIjIQiwVzpRSI5VS65VSvyql7oj1eIiIiIjMpqxS50wpZQfwC4BhAHYA+BbARZqm/RzTgRERERGZyEozZycC+FXTtE2apnkBvAFgXIzHRERERGQqR6wHcITWALYf8fMdAE76/ZuUUtcAuAYAklNV37b5SRE/qNCfJhqgXQVF7RzCdjZl7qymX5NldU9Q9tfI45e183vtEbexeZXoWY5K2Z+BKq0UtZM6pm++qc8jIqLIrVy58oCmac1Cvc9K4ay2r55HfWXUNO15AM8DQJOuzbX8WRdG/KAOmuwLdY8mu0Xtjk3dJXte0k5Ru1aOKlG7ZCX7fXELl8a3+1NF7b6r6hhxmyUHuome9cOmNqJ2qb9E/k0DAOSu9ovaJX+wXNRucfC/onZERBQ5pdTWcN5npXC2A0DbI37eBkC9qcbtdWLdthYRP8iRJPsCKJ3JSnd4RO2aOUpl7eyycJZti3xGCgCaCNslK9k4gc0RtyjLShY96UBL2SzrrtI8Ubuq3bLfy7QunDkjIkoUVgpn3wLoopTqCGAngAsBXFxfA2eJQssPXRE/qDJX9oX6l3zZTM/Wjlmidptb5YjaFWatE7XrlxxWoD9KR4cstObZZcEnXXkjbpOR+YPoWal2WbCea+starc9EPk3GwAQtDcXtRvV6gZRuwW7ZonaERFRaJYJZ5qm+ZVSNwBYCMAO4EVN036qr023/Ob46o1bj/6F+fOBPXuAK6/Ufz5vHlBYCFx+OQDgzr6XIyXgweLWJwAABu1eDYcWwJJW+hfUwbv1L+SftuwFABiyaxX8yo737Pr7R69bCbfTiU869QQADP31B2xvkov1zVrXOs7SpPSwfx+OtDZJ9oW6matc1k44U9fEdkDULknJ/vql2iIP5M1sst+TLkl7RO06Zh4UtdueJwvyVftTRO18+bK/Y8NsE0TtuIxKRBSaZUppSDRx5WkDcs8HAFxSthyXln971Hv+k94PHfyFaOMvwnXNLgIA3Fv4IbIDFbip2fl1tttrS8ek5nqYe+zAO3ArJyYP1WcZnv/iSaT53WhbefQX4Jc6D4WChrVN2uKr5t0BAPv7OEX/f5XtfaJ2x3SW7Y07I2+9qN2gNNlMXVenbFYqyx75DGZ50C161nqf7JDEB6WymbMPth8nalf6g2yWNfcH2b//pp9HvrTcEJypI6JEoJRaqWlaQcj3xXM4y1TZ2klqyFEfT9L8UADc1TMzv//54vJ/A8EgkF49o1VRof+Yllbvz0eecD8AIDnohQYFj00PXbm+Urg0P3a5smHTgpi96RksanI8/p17GmxaEI9tmY15acfj05SugKbBiQB8Ycwa7R8h20d0sLfszzTnGNlsz+BWG0TtRmX+KGp3rKss4jbpShaQS4KRL6ECwHfeXFG7uQf7itp9urGLqF3SGtlSfdvFkf8ZAMCib+4WtSMiSgThhjPLLGtKHNM3H4tXGLBMkpYW1s8DGzYBACp+13zvof8qRgDAhdpIOAuDCBRtQqrmRfeRfdD9yitx24QJwM6dQPv2wMsvA5deqv98+nRg0iSgRw/gwAFg8WJg8GAMuehFJAe8yPWUYm9SE/js4QUMd45siWt/00xRu/Xpsv1OnZKFy7b23/8JhJbkCIielaxkM2dNbbJSGs2TZEvLGWmymcGKdNnflfJ2slA3suvtonYfrX9E1I6IKB7FdTgzmyH7ZZ54AggEgIkT9ddvdu0CXn0V+Pln4OKLgcWLseTTO4FPPgGGDAGWLgVOOw1YtAi48EJg4UKgXz9g9Wq93U03Aa1aAcXFuGTkVOxLaoJgxKcoZV+of/C3E7UTExyEPDllk+hRzWyyUCc9Mds9RVZ2ZV22LCCvzJYF8qoc2alSR2fZ8isRUWPCcGa2Rx/VX3Xp108PaG3bYphtArK1KvRBP+QP+gPOxy+H33fiiQCApWiNAdiFqx75AbtVOkZoW/AqVgAbNwL5+cDcucBTTwGvvw7k5gI//aT3P24c4HIBmgZU1zc75dx6xlUPd57sr9HWYtnm9y2ZkS8ZdnLtDf2mWmSoElE7+9El+sJ7nk0W6nKSIp9NBABHpmzZ1ttENnOm7ZLV0iMiakwYzqwmJQXorh8kCGembhAABIN4RSk9ZG3cCHz+OdC6+uToa68BH38MNPtdQeIpU4CpU4EHHgBmzAD27sWX7/xFD3PLlwMPPqj3t3070LQpkJFR5xhOvvgx0f/qfpssnH2e1DniNunCkhjOdNkhiRaCpVcAyLHLTpW2Ty4UtcvNku0dO5glm2UNOmXhjKdDiagxYThLBLYj9kV16qS/fvPWWzXfW1qqB64ePfSf9+sHXHUV4HBgVKsbcGXpMpxetQGXvazvfZpStABpQS/uzKn7mtOmGbJ6ZWXtZHvO9pdEXppkR44sCO5Pli37NbXJ9oBJZ9yaOGR73NJdspmzvemyK8n8KbJwFhzUR9SOiCgeMZw1NpmZh4MZAIwapb9wRLkCTcOC++4D7rvv0NsW7H5K/4977gHuvbdGl9JN3qm7ZUGkvCjyIsLbKoThLK3uGcP6tHYUidrZhPewptlkM4MZTlmI1NJke/G8GbJTs44i6W0SRETxh+GMjqaUHsB+F8LqIj1JV1t1+mO9u+FWDmxyNsOfSpaim3cvbmqm17K7oHwFWvhLcWvLPwAAzlyzAhmeKrzWdyAAoMfu7QgqhbUtjr4Pc0NWyHtma/V9quywQ1O7bCarlVMW6sTPS5GdDv05QxYG3TmRFxAGgIqOshlMLocSUTxiOKP6lZQAlZVAy5aGd60dsRx66YEvcGnhsqPe82Nym0PvS/LYkAzt0Izb8NWrcfz+rZjy8Zyj2j3fczg6Fe+B1+7A3QMvQXlJEi78/BuUpKViQd/jAQDNSspQmpoMj7Pu2Zy9VbJQUJwu2zAvvaXBBuGMm/DeV5dLdj+tT5bNoNlky6GOFrJTrEREscRwRvX785/1umvbtxveda0zbj/+qJ8i7dYNANATwEe/e4ur+lTpXQWX1Tht2q5sH5L9XvySpc+cXbZuCfw2G1zlQaRuceKqj5ZhU05zLM3Rr+F669nnsT6vJW4Zr98E8eC817GmZTu8XnAKAGDgr2uxvSoJm1tHfjq0XVqriNsAQLZDdiBAuqyZ65QdCGiaIlsO3dlEFiLLW8tKd2QI90MSEcUSwxnV7/LLgaFDzXtez54h35KxZn+tHy+CApCEjJ36r89Bz0Pvr8xrjgvH34okvx/JBzVc++1C5B/ch/yD+zDqwVsO9dH2QCHmdBwAaBpmvPNvvFrcD1MvHgtoGpbd8gj+PbQ/nhszCABwxaIvsax7J6xve/TBhkKvLBQUB2TtkpXsqq9kJZsBS3fJwmAwWRbObF7ZzNlvhaOJiOJJXF/fVFBQoK1YsSLWwyAjLVwItGgB9OplaLeDh02LrIGmoVP5HmwYnI4d2Tlw+v2YMu89NK2sxJk/rDrq7c+cfgbaHzyAlweehpUdOiLn+NoDZCgjWq8VteueLCteWxqUlcT4rLCrqN3XG2RXkmWsShK1a/mlbGZQ+3a1qB33qhFRfRrF9U1kgqIi/ZUv+6IasUmTgLPOAp57rs631HaQIBRv/w4Rt1nbpC1K/Hak7AMAJx455TwAwN+GXQYAyKyqgKZsKEtOQf7BvXjq+38he48HKakKLVcXY9ajb+KvN47Hd93aIcXthcvnR0lG/XvRDnojLxMCAO4k2SlIqRS7bKbOkSxrF0iShTNfpmyTGz8xElEs8XMQ1e+RR/QrpzyyZayILVqkl/uox6GSHxGQlvsoa1N3LbZyu74EafMCWzKaY8zlUwBNg80LeHxO/NChNXakZsHrdmLYN2vx1Kw3MPLBG7GuXUu023sQ7fYVYnm3jvA6D/8zLPbJZrIqgrLw4lSykhjScGa3y2bqg8KDBM5SWR23RZwBI6IYYjij+k2YULMuWrQdf7x5zwqDq1QSJjT80qE9brpwEgDAth848Xv9QMVHU2bWeOczZwzGP8aOwaC1a9F91258eEN3BOyRX7beRViPraWrWNROesozJUkWlkqyZXvVSjrL9vCxBAcRxRLDGdWvb1/9FQW1fQEcqO3ANmRgq2pSZzvJF0BpLbb+F8quprJX1tzAPnXUeEwdNf7QzzOqqnDM3t1Y2SEf9kpg4E8bMGb1Krx+XW8gAFz9xhdovacY900eCwBw+APwO+o+sVgeEC77abJTkOIZN5dsxq1Uls0AXuVJRHGI4YzqV1QE7N4NdO0K2GVfyOtyVMjSNP0ZU6bod34aSLJPDQBsgr1qAJCyr/7ZLz9S8XNqp+r9bMD0grPxbK/RKCrSU4i/3A5UKBQV6XvQ/v33l+B1OvCHP08EACR7vHAnHV7r25ndVDTOPJesrpo0nKU7ZTNnu5Nly6HS+mjaANmBFOnfM8lSPRElLoYzqt/LLwO33AIUFwNN6p7NMszq1UBOTr1vkSw5SZebhp90v6hdVW7kG/v9cELz6jNLj585AgAw+b+L8ef3lxx6z5aJdwIASlKSMad/H9xziX7nqf+gQnlG5NdaeYKygwR24TVTdpusneaStQvaZZ/inJv2iNoxZBGRERjOqH6jRwOtWgHJkX/hj5hSYe1vM3Nfj/LIluGcFbKZHseBmmFp1imjMeuU0TU+ZgsGcfXnn2FjXh4cB5xI8Xrw+rX/wlOXnY7Z554MFdSQVVKBwqzQAbEoU3aTQaZDVoQ23Snbq6Zcspm6qmbmnmIlIjICwxnVr2tX/WUGrxd46y2gXz/znhmCbZ/srktXqezaJ7snnH+SdrzQf0j1+wGXW8PMSwbjm2M7wOu3o/PWfZhz03O45bZzsfiUY2EP6LNOtR00kM+cye7ylFI2Wdi1y1ZREczLkjUkIjIAwxnVr7gY2LpVv05JWGsqbKWlwMSJwMyZhocz6ek7qaTCuktw1Ce8cFZTlUrB06P1WwvgBva4MvHFcfl4/O/vAHinxnufPO90PDnhjEM/L/XL/kxzXLL9h2kOWVqyCUtw+IS3N0lDORGRERjOqH4ffghceinwyy9Aly7RfVZWFrBhQ8g9ZxLSpVBpfTTZpUh6zTQJX+nhkLXLnoRLbr720M/7bNyKi/+3HHdMHI+A3Y7z53+L9vsP4rFxw1HYQpZeWiZLL2iXhSyn8KL1gHA1PtA2T9ZQiKU7iOhIDGdUv9NOA+bM0a9Uija7HejcOfrPiYD0bkZbU1m9tuSDsvBS4a37dOiqth2x6uKOQABQAeDYrXtw3LYd0MY44Ak4cOI3m7G1fTb2tgj/wIcnKPvU4bDJ9o45HLJ2bpe519MxZBGRERjOqH5t2+ovM5SUAO+8A5x+unnXRYVg9oybzS+7vsnmCb9kxANnnQ17IACbR6GoJAW3PbQQy07ohDtvPRsAkFHuRll6/VNOFemy5VCb8JRnkjCcVQnrnJV2ks0oZnwrex4R0ZEYzqh+JSXA+vVA9+5AhqwKfdh27gSuugp4803Dw5nZe85UP9nMmc0vXPYri/RWARtsACqDLpz392vg8Afh8TmQV1iKj6+bjrv/eBbmDu5dZ+ugJq3uGvntBwDgcsiWNTWH7PfTVSILg5wBIyIjMJxR/ZYvB4YPB774AjjllOg+q0sX/fBBdrbhXZv9RVM6c5a6T3aJZHlr2UxWlceJzU2q91d5gIlzl8PlD2LarLmYNmvuofc9N3YgHrl45KGfl/hkm7myXFWidk5hfbSgsHitO0d24IFFaInICAxnVL8+fYAPPtBnzqLN6QTatYv+c0ygyipE7byZzYQPlDULuGuGkKnnjsXUc8ce+vnET77CX99ZiCdHDUHAbUeLwhIUZqTBK9xzJl3WFBevFc6cSX9DGbKIyAgMZ1S/3FxgzBhznrV7NzB3LnDmmUCbNuY8M0r8e/aK2jkqZfv7bD7h1Vr1HCQAgNmnnoK3+/VDld0FeIF/vPA2mlZU4uaXLhA9zp8kG6dNCUOWsJ0vVRbOpDOm0rtfiSgxMZxR/crLgVWr9DpnubnRfdb69cCf/qTP0sV5OJNKKpRV0HeVCIvJlocOS16kwF59UcK/Th2MDLcblT4noGm46/H5WHBGD6zo0yGs5wWFM1LSEhwQzpwJ74MXz5gSER2J4Yzqt3EjMHAg8O67wDnnRPdZAwbos2dZ8V+dXbrHbeipU2UPFC5rRrrK+GUXvThwhq8QeQdL0eeH7fimR0d4fA4keXxofrAM21rVvWewKiALkUo6cya8WSDoFF6YniGsektEdASGM6pffj6weDHQs2f0n+VymVNPzQTSjeF24bVBSaWyDfo2v+z0ZKXbhS1puThj5mTYNA0Btx3Dlq7FP2a9i3MfvgarO7eutZ3bLwtn0mVNm1O4V004c0ZEZASGM6pfRgYwdKg5z9qwAZg/H7jkkugvoUaZdM/ZYuGG8r5XPy5qp2QVI+D3/5Ze9B9vfmMJbn7nUwDAO397/tD7Xh3SD3ddPe5wO00WBh3CAwHSOzmF5x24rElEhmA4o/p5PMCXX+p3XbaufTbEMN9/D0yeDAwbFvfhTLqsKZ1xSy1oL2rnzpZ9CvC4a7Z7fOwIPD52xOEPaBqW3Pk4OuwqROCI93oCsucl2WV1zux2WagLyCqawN2jce6VJCJjMZxR/QoLgSFDgGefBa69NvT7G+Kcc4CDB4HMzOg+xwTSoreOFs1l7apkU2A2YVgKdcoTAM657Xo0rawCvDZkVlbhvjfew9t/7I0dbSKvYycNZ9K9aprwtyX5px2yhkRER2A4o/rl5ACffQYcc0z0n+V0RqUAbSyYfe2TvUoWXpxlsiki5Q29Yb7MmYayJmlQXqDH5t0Y8uNazKnoCU/ADhXUoNnC33SfKryRQDpzpglvrg8K9wwSER2J4Yzq53IBgwaZ86zvvwc+/lgvp5EW36fezL4Ae/hJ94vaSfec2TyR7R1b3q4L+t91N1ztywEf8OcXPkbL/aW4/bZzwgppwSRhCQ7hnjPhuQUEhHeOEhEdieGM6hcMAgsXAp0769crRdOXXwK33QZccUXchzNpyJKGOu+IAlE7YcF+EbfLBXtQD3VFGWlw+ILwww4EgWYHy7A/p+67WzXhzJl0WTOQJGtX0SZF1M7su195ByiRtTGcUf00DRg9Grj/fuCuu6L7rD/+EZg0Ke6DGWD+zJm0PpqziexTgKNSdurS49Wf9/RZ1bOxXqDN3iJ8NHkm7r7mTLw7uE+t7aSnPKXXs0vvdVdBWahjWCKiIzGcUf3sduCrr4C2smuFIuJwAOnp0X+OCcw+rYl8WX04FZDePSkT8NcsIHbT24dLcEx7ei6mPa1ftj7j3MF48rwhh9sFZeFMfCenU/b7Il0mNjvME5G1MZxRaCefbM5zli4FvvgC+NvfAJvsi3G8k16cPaK3bFbT5pftkZKGkICv5p/rE+OG4Ylxww5/QNPw/Iz/oFlheY33BoVTWdLl0KAwnAkn+IiIamA4o9Dmz9drnPXqFd3nLFkCTJ0K3HlndJ9jYWbvPfL06i9q56iUPc/tqz+92IJBrG3dEsVpqdCOeK83ILwwXVq8NigLddL6aFKccSNKTErTzF3WMFJBQYG2YsWKWA8j8WVn61X7Z86M7nM0DfD79ZIaZArpKc+9J9W9eb8+xb29Eb3/5HUbMWnJMky7dThKMlNFz5Qo3tpU1K75V7JQl/3JZlE76UwrEcWGUmqlpmkhT3Bx5oxC++wzvd5ZtCnFYCYkDVnuXNmdnJCe8gwxc/Z77fYUo+Oeg/C4zP17oTmk37TKwhlDFhEdieGMQjPj0nMAmDcP+Pln4HZZIdbGTHl8onaaXVb6ISDMdJHWR3u74CTM6VOAZFc57L4g/vriYsw+60TsbB5esVe7sJSGlDddej6UiOgwhjMKbcECoEkTYMCA6D9nzhyGMwFVFdly4W9St5WK2rmzZJXwq1pEHl40OBAI2NBl8z6cvWQVvjumLbblhjeTa3dIq+wKQ50wm3HvGBEdieGMQrvlFn32LNrh7Omngaeeiu4zElRgwyZRO3uXfNnzpBvfhcuhfr8da9q2xpCZf0ZhRirgVxi4agN25TbFxjbN6myX7JLNKEJ46lJ6WlP650BEiYnhjEKbNw9IkS1/RUxxWUhCOoMyeNg0UTtnpWxmyeYXnoKsro+2PzUTCOinOu96cT72N83AhXddXeffG7/wlKeUxr+/RGQAhjMKrXNnc54zezawf78+U0emcCxZKWoXmCQrwWEL48L02vgCh9tNfvdjTJ7zCQCg456D2HTJ/wEAnh57Gv5+wcga7cQ7zoR71TRhFlRlFbKGRJSQGM4otIUL9R9HjIjuc+bPBzZsYDgTkN4s4GjRXNbOLQsvdo+wmKz/8HrhE2cNxxNnDa/x61NfmYNRy3/Ck2OHoirp8JqrtAitdO+YJvyM6t+zV9aQiBISwxmF9tBD+rJRtMPZ669Ht/8EJi3FIL2TU3phuriCfojnzTn5BGzLzUGV01XjvWaHs6DwM6o0JPMgAVFiYjij0F59tdFepxQvxDNnGbJL5oPtZXsQxZUtQlTsX5nfASvzOwBB4Jide3DdR5/h7ovGISA7VCoeaFBYjk0T/jlgj6wZEVkbwxmF1qaNOc958kn9ovXrrzfneQnE7Ds5nZWyqTN7hHXOfqMiKF7bc9MunLxuE1IqAygJyD7FKWEpDZusogn8zWQ3Lny8njNgRImI4YxCW7IEKCoCzjsvus9ZsEC/IYDhzDS2fUWidlqnJrJ20lVGX/gN3+3bD/OP7wW3ywV7oAKnrdqAz3t3iewksPjCdFEzaE7OTBPRYQxnFNqzzwI//WROOKO4kFwomyKqaCG7WiCScAYAHpUE5QMGr9iAfz76H1z354uw6MQe4XdgchFa1/pdsoZElJAYzii0p58GgtLLFCkS8bLBW/lkfx+kBwmkPundFTfcdCEW9T0Wmqbg9Pvhc4TxaU+YzaQzg4G2ebKGRJSQGM4otGZ1V2A31L33Am3bAlddZc7zLMjskGX2Kc+AS5Ze7F5ZWvIF7figoCcQBJqUVuLd+5/FzHGDMfeUPqL+QtGEy5pB4bJmvIR5IooMwxmF9vnnwK+/AldeGd3nLFyoXxPViMOZ2aRf3AND+oraucpkIauypahZzaksTWFD6+bY3LyZfIorgsdFwpchS3VLGbKIEhLDGYX25pv6K9rh7Kuvott/ApOGLCnXfllFe1tL4dSS8Fok7YgSHJMWLcPIlT9h5MqfarzniXFDMP3sYTUfJ9xzpoT3rCcVekTtzP5z54wbkTmUpokvOIm5goICbcWKFbEeRuIrLQV8PiAnJ9YjSXhmf7GV0gb0ErUrE9ZHKzxOFs68zWu/+Lzt/oP47M7H8PTo0/HYOcOP+nXllG2Oc+xMErVrvVR2QfvSBbeL2hFRbCilVmqaVhDqfZw5o9AyM815zo03Av37AxdfbM7zLMjsmQlpGJSWfpDePekqEYaznNrHuT2rGa644Qp80yUf8B/9HulNBtIiuzZ//H6TTETGYzij0L76Sn9F+87LTz8FsrOj+4wEZfbdmtquElE7e3PZqcSAK/R7IvV5j64AgCSfD9cv+ARPjxwMt0t/kHRZU8qbyU/FRHQYPyNQaIsW6ScpJ0+O7jVOa9ZEr+8EJz11KZ05s2fky9p5pCU4ovf37sQNm3H9gk+xqmM7fHJ8dwCAdLeH9ECAzWduGOQpTyJr454zCq2qSt9zlpEh3phNiWVkV9lep7LjZGVZylvL1kNLuoW3Q7/tgYPYnnt4T6XmkoVIZ6Hs+91WS/2idp9/eJuoHRHFBveckXFSUvRXNAWDwMSJwIQJwNlnR/dZdIh0BsUvLKUhvVmgJF/49y8Q3jcT27NygQDQY/sOXLf4E9z6hwlwJwnWUoXf6waF9d84A0aUmBjOKLTvvtNrkN18M5CaGp1n+P3A8uXAgAHR6Z9qZe8iXJ7cJruTs6SPbM+ZtESFLcIJqS679uH47TuRVVmB3cmRl/2wyQ5dwpshW7bNEO4ZJCJrYzij0L75BrjzTuCKK6IXzlwuYMOG6PTdCJhdgkNaSiP5oCy9lLWVlaiIdA/YewUnYEGv4+FuYgP8GhyBIPyO8JdUpRef22UTikSUoBjOKLSrr9YL0LqicGSODCFdppKGOuemPaJ23j7tRO0cFdKisJEvF/psLkALYPK8xSjYuBVXXT8JHmd4qUtagkPK7IMgXA4lMgfDGYUW5hemBikqAv7wB+Daa4Fhw0K/nwwh/WI7ovddonYqKAxZ0vphwuXQYEBhe3YOmheVwQdH2CFPuqypArL/QWkJFYYsImtjOKPQfv4Z+O9/geuuA/Jke4ZC8niAtWuB4uLo9E+1ks6giOujtc4QtVOyw4ziDfrQgHdPKsC7J+mHqpqUV8LjdByqg1ZnM2GRXV+asKhvRprsgURkaQxnFNratXqds3POiV44a9EC+Omn0O8jQ5k9gzJgwqOidpFu7P+N3S07Bek/IvPYAwH8Z+bz2NskE1dfc0W95WSky5rOSlnpjsCGTbIHEpGlMZxRaOecAwQC0S1AS41CUrEsZVXlyvY7iveAHXGSIGBz4MVBp+FARjoAW72zcZpdNlXnTZcNtAlPaxIlJIYzCs2MULZ5s16q4847gZNPjv7zKCacpbJjiSkHZZ+q3NnCdcYjTJ6/EJM/WnzUx6ePHIbpo0fU+Jg0DAZN/kzMAwFE1sZwRqFt3gz861/6ic1OnaLzDLcb2L5d/5FMEy9fpN1NZKlHWtpZrRqCAAAgAElEQVTiSNNHjzgUwnpv2Yq3ZjyN2y86H3NOPLoQr90rW0aVltLw79kra0hElsZwRqHt3An8/e/AkCHRC2fduwPffx+dvqlO0pAlPSXo6dVW1C6pTLZcWOWXhaW69ritadUWTw8dgk+7da/1PdK7NaXtOJNFlJgYzii0U0/V79akhGN28drkvCxRO196E1E7aWmLupYZg7Bh+pjhAAAVDCLD7UFp6uGrpezSmwyEpTTiZeaTiCLDcEbWsHIlMGUK8PjjwLHHxno0jYbZM2eyM4nyUhPSvVzhhLoZs19Dq6IiXHT9n+C3N2xvmy9VNnUmLWlCRNbGcEah7d0LPPoocMklQO/e0XmG16vXOAtKv3yTmYLCGTBVJdtclbpXNgVW2Vx4q0UY64wfHd8TueVl8Cv74fcL66o5hFstueeMKDExnFFopaXA008DJ54YvXDWvz/w9dfR6ZsMt3DVA6J20hk3X3ozUTtpWAqnrtrCHvr9orYA4PL74XU4oITfW/hTQr/HCriMSmQOhjMKrUsXoKIi1qMgCzH7ZgEIN8xLr32KJNQdu2sHnn3lJdx80UR8l99B9LigQ/g/aDKGLCJzMJyRNSxeDDz8MPDKK0CbNrEeDYUg/SI98Kx/iNrZfLKU5SqVtXPnhv/enVnZWN+iJUpTU6CEBwIcVbJx2rvkyx5IRJbGcEahlZfrxWHPPRcYNCg6zwgG9ROhvIUgoSUVekTt3M2SZA8ULjNGErJKk1JxzWVXA6iuc6Zp9V7xVJtAknSKj4gSEcMZheb3A7NnAz16RC+cjRihvyguSJc1ncJlTU92e1E76bKm6E5OTcOfl36ATHcV7jnrvIiaSu8OleLeMSJrYzij0Jo2BYqKYj0KqofZX2zNLsEh5U+W7eXSRJ8ZFTR79RVOjiCCkcwCC0OkKpPtBWXIIrI2hjOyhjfeAGbNAj76CEhPj/Vo4o70i63ZRWjjpS6XEhavfWzoaH1JM4iITm76hXXOpMz+c2cYJIoMwxmF57rrgJEjgXHjotO/3Q4kJ+s/kmnM/qI5suvtonaa8K+Fwy289sklDUsK0IBWRYW494N38X/jJmBfZujbDZTJy5oMS0TWxnBG4Zk3D2jfPnrhbMIE/UUJLbBhk6hdatM0UTtPpmwWVnrq8rfl0HSfB91370KHwgPY1zR0OLN7ZCFSy5D9vkhxrxqRORjOKDw7dsR6BGQh0i/S0tIPnkxZpX9npey4pt0rm6pT1TcFbGzaCsNumAKfwwF7GNX/A8mix5mOIYvIHAxnZA0zZ+r7zr78MtYjoTCYfienI1vUzptubmmWI2fc/MoBFQDGrFmJJL8f7/Y+qc520pkzf7MMUTsisjaGMwrP5Mn61U2TJkWn//R0IC8vOn2TZUjvgnTmtxC1S7XJ9o55mjpF7XyZv/uApuGsNSuR5Pfh3RP6QVO1h8WA8FSpY3+ZqB0RWRvDGYVn2TJ9w360XHGF/iJTmb2HSLqsGfTJlifdObLlSVkpjZozZ9d//hFu+N+iQz9f+8BfAACzBg7HU6eNrNHO5pXNnElLaRCRtTGcUXiWL4/1CCgKzN5DJD0QoPodL2sn3Nhvl11kAO8RM2dPDhuJJ4cdDmGpHg967NqObzt2Prqh8HCo2QcCiMgcDGdkDXfdBXzzDbBoUej3UtyShsHhJ90vamcXzkj5ozBJPGXBXIxaswqDbr0bZSkpNX7NJqyrJg27RGRtDGcUnjvuAJo1A269NTr95+UBHTtGp28ynNnLoT7haU3pjJSjUtYuWM9WtWf6D8ecHieiUqUcdYIzKPxMbOvZTdaQiCyN4YzCs3YtUFoavf5vvDF6fZPhzD6tKZ3ICvZqK2vXWrhXrZ7DobuysrArKwsAkOTzwuM8HDj9KbIUadvHa9WIEhHDGYXnvfdiPQKyEOnMmfT6pmBelqidL0NYr0x2/iCsi9bHrlmJvyyZh/FX34rCNL0UhqNKtvwq/X0hImtjOCNruOYa4OBB4J13Yj0SiiJpKQ27cOO7XXh9U1C4ihpOwdn1WW3wbZvOsHnUodvKpNdTqSqvrCERWRrDGYXn/vsBtxt46KHo9N+5s76njeJCvFy0Lg094YSs2nhD39SEDa2b46/nXvq758mWNXkggCgxMZxReHbsAKqqotf/bbdFr2+yDOmyJoT1vFQgV9TO5pfNuNl84YesZmUluOHLj/CPwWehypESukFtz+OBAKKExHBG4Xn++ViPgBLAgl2zRO1Gdr1d1E4FhMVdhfXRIjkd2ryiBKPWrcLCbr2xIvsY2eOEy5q8wJzI2hjOyBrGjQOys4GXXor1SMiCgk1le86clX7ZA6VXBESQBde0aIehf7wLpcmpcJXKQqSWItscx5BFZG0MZxSeRx8FfvklejNoffoAmb+/mJBIZ9++T9Su/JQOonZJZbKw5MuMbO9YuSMVNj/Qa+8mrG3WFh5HZHd6BtKTIno/EcUHhjMKT3ExsE/2BTIs994bvb4p7kmvKZKWxPClyjboS5ZDOxTtw4tznsbMk0fhxYKhEbXlxedEiYnhjMIzdWqsR0AJQLx3THggILkwjOOTtajMk5W9lYSzrZl5+NuQS/G/9sdGfN2Ur5Xs/4+IrI3hjKyhXz/glFOA6dNjPRKKImnIkvJmRLZM+JukEtmyprupqBkWd+oNALAH9XQXsIVXAyToqOdKAiKKWwxnFJ5nnwU++giYOzc6/Q8ZAnRjWYBEJz2tKSU9leie2F/ULugSLod6NKR53Xhu3rNYnN8T/+5zRljtbH7hui0RWRrDGYXH4wEqojjrMW1a9Pomw5ldTFZaH80/pK+onU1agiMovCPTC1QhGWuz22BXag5sUS78z1IaRNamNE32ScgKCgoKtBUrVsR6GEQUJmkosHfJF7Wrys8WtQsky5YLizvJvt91Vsg+D+d9Jbv4PPjjOlE7hjOihlFKrdQ0rSDU+zhzRtbQujXwhz/w1GaCk35xH9XqBlE7Z1mGqB0g26vmEpbgqDFTpmkYs3ElNAXM71T/53AtSTZOhiwia2M4o/C8+irw3HPAkiWAU/YFoV4XXKDXOiMykL3cI2pX0UZ2nVJAuOfM9rtTmmM2fgufzYH5+X0BVXefyuMTPY+IrI3hjMLncACBQHTC2eOPG98nNXrSmSUVlM2A2T2ydsEaw1S4bejlKEtKhlZPMANYhJYoUTGcUXguuUR/EUG+d0y6sV96ynPoqbL6fNK7NbXwKmAcJZB0OIRd9/VHuO6bRUe955mThuOZk0fW+Ji3iez6Jh4IILI2hjOKvYoKIC8PePhh4KabYj0aCoPZX6Sle86Q30LUTDpzFsndmkdyVB5u+M+eI/DPniMATcOrc55AlTMJV595/VHvAwBXiexYJ0MWkbUxnFF45s3Tbwl4/32guWz2o042G3DddUDPnsb2S1FjdikNMWE4SyqW7eUKJMlOebqzalu+VHiu33AUJ6fVOSMn3VNHRNbGcEbhcbmArKzo9J2Sol+sTnHD7JkXaRi0+WRFWiuay65vkt7Jaa8jY33R8rh6f72qtfQ0KhFZGcMZhWfECP1F1ABm71XTioWFk9ukipoFZFvAoOpZDk32e3HF90vwQ4uOWNa25i0aqb8eFD2Pe86IrI3hjGJv82agSxfg5ZeBSy+N9Wgoisz+4j6i912idtI9Z44qUTME6jl06Vd2jNi4CkoDlrWpGc78zWQzZx+vZ8gisjKGMwrP558Dkyfr9c66dze274wM4PbbgR49jO2XEob4QECebCk+dZcsZflT0kTt6qtlpsGOS8fegipnEuy/2//vE17szpkzImtjOKPwpKQAbdrotc6MlpsLPPig8f1SwpCW0pCGEO+IkLer1EoJ7yG3e+ufqfPCBbtXQ05VKYqS0hG06QcPnGWygwsMWUTWxnBG4enXTz+pGQ2apr9sspNuRHXRBvQStfNkyT412nyy5VBfSui/+10Kd+GlD2fggVMuwML8E6qfJ0yDRGRpDGcUe998A/TvD8yfD4waFevRkAVJZ8BkZyeBpAzZzJk7R/YpNZwZt41NWuC1YwdhTU77Q+8POvkNDVEiYjij8Pz4I3DRRcCzzwIDBxrbd+vW+oXnXboY2y8lDOkynPRAgDT0hFqerIs/I5wYacNT/UbX+IjGcEaUkBjOKDypqfpBgFRZiYF6tW0L3HOP8f1Soxf8cZ2ondbxRNnzHLK5OldF+KGuZflBnLfhSzzda4zoWURkfQxnFJ7OnYG3345O336//kpKqvfUGsU/s28WsPXsFvpNBgo4ZX9/nVXh7x3rWLIX5/66DJ+26YlfHa1FzyMia2M4o9ibPx8YNw5YuRI44YRYj4aiKF7qnJldSiPgCj/UfdGuO8Y1n4Ki5Aw0XVMseh4RWRvDGYVn+3bgjDOARx4Bxo83tu9u3YCHHtL3nhHVwuybBdw92ojaaWZsAVMKRcl68Vlnlh0VDtlVU0RkXQxnFJ6UFL2cRk6O8X0fcwzwt78Z3y8lDOnypFblDf2mWkj3jkF2HgDOyshLYly+fgnO2bgMl58wGR678N4oIrIkhjMKT24u8Npr0enb49Ff6emsdUa1WrjqAVE76bJm8u5yUTtPVlNRO29G5H/vv2nXGcklbth9QdiCkYU73hBAZG0MZxR7s2cDf/iDvnTaRracRIlNGiakM27+rBRRO+kNAZrgIMwPzfOxY3MaUOaDDZHdFBCI+GkNwzBIFBmGMwpPRQVw7LH68uMf/2hs3yeeCDz6KNBUNutAVBfpjNvQU6eK2tk90or9shljLcWFYyu2o5m3FEuzrHs3LUMWUWQYzig8Tqd+IKB9e+P77tlTfxHVQfrFfWTX20Xt7CmyPVzOFNmn1KRi2R2ZAHDBvmVo5SnE502PDXsGjmGJyNoYzig8Lhfw0kvR6buiAqiq0g8bsM4Z1WJUqxtE7bS8LFE76bKmp6nwU6rwr70j1YG/50xAuSMFbgcPBRAliqiFM6VUWwCvAGgBIAjgeU3TZiilsgG8CaADgC0Aztc0rUgppQDMADAaQCWASZqmfRet8ZGFzJgBTJmiHwpw8QsMHW3BrlmmPm/wsGmidpHUKzuSwy075pl8wI1yJAEIIlmrgkMLwG/j99xE8S6a/4r9AG7VNO07pVQGgJVKqcUAJgFYomnaNKXUHQDuAHA7gFEAulS/TgLwTPWPZBUdOwKTJhl/1dLw4UBmpr50SgnN7BsCpHXO7PktRO2SC2XhLJAsvMtz+z4AgEML4JGDc7Ha1QovZ/YX9UVE1hG1cKZp2m4Au6v/u0wptRZAawDjAJxe/bZ/A/gMejgbB+AVTdM0AF8rpZoqpVpW90NWcOaZwHHHGd9vQYH+ooRn9t4x/4ZNonZ24XJoZUtZQVibXzZzpmXoNxL4APzsaYutSXmHPlYfnp4ksjZT5r+VUh0A9AHwDYDmvwUuTdN2K6Xyqt/WGsD2I5rtqP5YjXCmlLoGwDUA0K5du6iOm37nySej029REeB2Ay1bRqd/insfrX9E1E66V0165tJZLitS4Uu3y9q1anLov59pdXbY7WwbRI8jIpNEPZwppdIBvANgsqZpparuDd+1/cJR305qmvY8gOcBoKCgQFiPmyzlvvuAl18GinlPINVOOnMW2LNX1E76iTHYLlPUTlofzVFU8w5QpWkYVPwTfkxvj0JnRp3tFnIGjMjSohrOlFJO6MHsVU3T3q3+8N7fliuVUi0B7Kv++A4AbY9o3gbArmiOjyLUqxcwYADwzDPG9nvBBUCfPsb2SdQAQeGypqNKNnPmSZZ9Kv79qdI8dxH+uvp9zG4/GP/pcIaoTyKKvWie1lQAXgCwVtO0x4/4pfcBXA5gWvWP7x3x8RuUUm9APwhQwv1mFnPuuUB+vvH99u+vv4jqEBDuHZMeCJAua0qXJ6Xslf5D/z1xx6eYuOszAMAVW5bgii1LAACzW52O2W0G12jHPWdE1hbNmbNTAEwEsFoptar6Y3dCD2VvKaWuArANwG+fJeZDL6PxK/RSGldEcWwkcffd0el3zx7A7+fVTY2A2aFA+jzpJ0atU5PQb6rteRWyOBh0Hj7l+e+OQ/DvjkPCasdqgkTWFs3Tml+g7s8BR30GqT6leX20xkMWdsstwIoVwC+/xHokFGVmz7xIZ87COfFYG1epP/SbahFwyUpp1GXE3u9wfOkWPNplfK2/zhkwImtjtUIK36BBQFYWMHeusf1edx1w8KCxfRIB8AsPBHh7yUq7SOuVSXmb1F60OXN/FVr6ioF0Ba/96PqBXNYksjaGMwrfeecBqanG9ztwoPF9EjXA0gWy06GnnPuoqF1yoVfULuioPQy+0fY0vNFuEBAA7IGjl0wZsoisjeGMwnfjjdHpd+tW/cdoXKpOJCAt3eFqJzvlWdVMdm1Zyv76Qp0GZ8AHn83BO2uJ4gzDGcXelVfq92p+8UWsR0IUV5y7Sur8tWOrduD+ne9gSusJWJ/SysRREVFDMZxR+MaNA3bvBpYvN7bf//s/ICCrD0WNg7TSv5SWIpvJslfJDgSkCtsdeUPA723wJ+ELXw+UtciBL012ipSIYoPhjMJ33nlAWZnx/Q4eHPo91Kgt2DVL1E668d22r0jULpAuuzDdl3H0pv1wJO8ur/PXvACeaD4a8AIOb82bBHgggMjaGM4ofBMnRqffdeuA5GSgQ4fo9E9xT7oHTFpKw9tVtgyofLJ6ZdKLz73NQpf8aOYuRlLAhx1pzQ59jJ/4iayN/0YpfJqmF4t1yr7Lr9OECcAxxwDvvGNsv5QwpBefi2fOhCU4VL/jRe18GdHZsK+0IJ759mmsbtoB9/S55NDHOQNGZG0MZxS+K68EliwBtm0ztt/p04H0dGP7JIL5RWil1z5JOct8Id/zaKdzsCM5J6z3EpE1MJxR+MaPB3r3Nr7fIeFdOUMUKWkRWuyRNZPOnGk22cyZc1Poga5CBgAvnNL/KSIyHcMZhe/MM6PT73ffATk5rHNGhjP7Tk5fpuyUp1QwL7y6al0qd6FP+Ra8lTcgyiMiIiMwnFH4/H69HlmabMmnTqNG6bNyzzxjbL9EJkvaJjvlWdk5R9Qu+OO6sN53grYWF2I9PtydjjLl4mlNIotjOKPwTZkCzJgBuN3G9vvaa0BenrF9EkF+ytNsad/L9nH6BvQK631z/V3xrrLBbddn9tSyH0TPIyJzMJxR+EaPjk6I4p6zRsPsGRvpKc8Rve8StUOV7I5Md482onau/RVhvc8DBUCDHR4AwELOgBFZGsMZhW/QIP1ltP/9T99v1q6d8X2TpcTLsli4y4W/5x/SV9YuxS5qF8kOt1aeQty0Yz5easGiz0RWx3BG4fN4gIoKICvLuIuUNQ047TTg7ruB++4zpk+iatJrn6QhcvhJ94vaufZHv8xFsSMNTf0VyAxUcc8ZkcUxnFH4Zs0C/vIXoKQEyMw0rt+PP+btABQV0lIa0vASHNRH1E42bwbYt+8L+71uAH/KOh9wA4uDsuuwiMgcDGcUvsGD9YKxLgPLBSjFPWdkOeLitbtKZO2EF6378gV3eWoaUFwMNG0qeiYRRZ/SNNmdblZQUFCgrVixItbDoIbw+YDPPgO6dwfayDZFE1mF9CCBliS7Ek15Il8OfWLDSzhQCTyg+kfclsuaRA2jlFqpaVpBqPdx5ozC53br33Hn5gIOg/7qFBcDw4frS6bXX29Mn0QNJF3WtHfJF7Vzt5RdX5ayKbzTmkf6OL0HyiuLRc8jInMwnFH4/vtf4LLLgA0bgM6djemzSRP9tGa+7IsaNQ7SsCRdnpSGLOnypPTeS1UWeThbYO8CvxJea0VEpmA4o/CddJJexT8317g+XS7g1FON648SUrwspw0eNk3Uzlkqq48mvaA9PZiF47278G1yB1F7IoouhjMK3zHH6C8jlZcDS5cCJ5wAtGxpbN/U6MVLyQhbceQzYIBs5gwAxuz9CldjDS7FKOxVBl/HRkQNxnBG4XO7gX37gObNgaQkY/rcuhUYOxZ46y1gguwLKZHRpKEuWbiMGmgru3kj2CxD1O6TQAHWBo7BQWcLOIyqWUhEhmE4o/AtXQqMHAl8+SUwYIAxfXbsCHzzDdCpkzH9UUKShiUp6V41aV01W16WqB2csm+SXtv7kux5RGQKhjMK33HHAf/6l7Gb91NTgRNPNK4/SkhmLzNKbxaQCqTLQpZz0x5Ru2G2CUjXvDgHG7AMrbBRhRcO42XvH1G8Yzij8LVuDVx1lbF9Hjign9Y89VSgWTNj+yYymep3vKzhsh9EzTThqVLsAYJQmIBfUAYXNkI4c0dEUcFwRuHzeIBt2/SN++myukxHWb0aGD9eL0QbjUvVKSGYvbFfujxpF56e1Hp2E7VT+4pE7QCgUjlxkTYGFcrAGz+IyBAMZxS+tWuBPn2AOXOAs882ps9+/YDvvzeubholJGnIGtn1dlE7aZ0z6elJKelBgsW7eLcmkZUxnFH42rcHZs/Wy14YJT0d6N3buP6IjvDR+kdE7cw+gODv0VfULmmbfObskFtuAQoLgZdfbnhfRGQIhjMKX1YWcOmlxva5bRvw1Vf6KdAmTYztmxJGvJzWXCCckZIeQJAuv9aQng74/fqF6CyrQWQJDGcUPp9Pv7qpRQsgO9uYPpctAy66CPj5Z4YzqpPZpwSlYVAasoLSUhpGhLP77294H0RkKIYzCt/+/UCPHsBzzwHXXGNMn6NH68GMd2tSPeKl0r+UluQUtZPujavt9zNHq8JBlVJvu3j5/SSKdwxnFL7sbODNN4GCAuP6zMzUX0T1iJdQIF1mVMKN/UYdQBiubcGtWIHLtVHYw+uciGKO4YzCl5wMnH++sX2uWwd8+61+dVNysrF9EwmZfVrT57TJnmfQcuj3yMOLOA6V/JJAZAn8l0jhCwaBH37Q95wZdUn5okXAzTcDY8YwnJFlBDZsErWThrqPv/g/UTup3y9r7lepeBOyWmtEZDyGMwpfMKiX0bj/fuCuu4zpc9IkPZjxMABFgdl71YYMfkjULpanNSdqP+EyrD3q46+gO2arHg3un4gix3BG4bPb9QK03bsb1yf3nJEFSUOdbHFSfg2TAw2/oH226oHZ6IF2WilewCI8jhOwQPGADlEsKU3TYj0GsYKCAm3FihWxHgY1xIoVwKpV+p2drLFEFiEOZ8JrmBauekDUztCZQU0DFi7U77k16no2IqpBKbVS07SQp+o4c0aRWbFCP7VpVOmLuXOBadOAq682pj8iA4iL0ApDlvSaKek46w91L9T5K/FyapYo3nHmjCKTnQ1ccgkwc6Yx/ZWWAiUlQNu2xvRHdATpXi6zK/1LScdZp+Ji4NVXgaFDga5dje2biDhzRlHy1ltA69bG9cc9ZxRFhoeXEKSV/lWVV9TO6IMETTU3/osP8DR6YY7qctSvc+aMyBwMZxSZoUON7e+zz4DNm4ErrjC2X6IGkC4zxvuuyWKVjIu10diP+m8KIKLoYjijyHz7LZCaql/jZITXXgM++IDhjCxFWudMSrp3TIozYETWxj1nFJlu3YDevYE33jCmv/JywO0GcnON6Y8SUrzcrTmit6z+n21fkahdVJZtDx7Uaxmedx4wcKDx/RM1YuHuOWM4o8h8/TWQkWHczBlRFJl9IEAaIqUzZ1qG7B7M+mYGXVoAr+NDvIQe+EB1qvFrnHEjahiGM4oP77+vn9acODHWIyGKGcud8vT7AQd3vRAZjac1KTq+/Vb/sV8/Y/p78UVgyxaGM0oI0pAlnQGTXrQeL8vERI0VwxlF5tZb9e+oP/nEmP5efx3w+Yzpi+h3zA4h0rsubXmymwWk4SzUMmp60I07ihZhcWp3LE05uqQGEUUXwxlFZtYswCa9QbAWKSn6iygKpCFLGuqkpHXOorU3rkTT4EQVlLcI/pKGX65ORJFhOKPI9OxpbH+zZwNOJ3Dhhcb2S9QA8RLqpKdDQ9GUwq04PSp9E1FoDGcUmZUrgbIy4PTTjenvmWf0S5YZzigBmL0nS7rHbWG449Q0IBDg4QAik/FfHEXm4YeBdeuANWuM6W/pUv2TP5GFmD0DJi2l4ctvYfBIjlBWBhx/PHDjjfpeUyIyDcMZRWbaNMDjMa4/p1N/EVmIdAZs+En3yx64fZ+omXPTHtnzwpGRAYwdqxeeJiJTMZxRZDp3Nra/mTP1i9THjze2X6IGMHvmbIFVS1TMMvfieCLSMZxRZFatAnbs0L+jNsKMGcDJJzOcUVSYXUpDugdMOuNmK5aV0vho/SPhv7msTJ8t5xVrRKbhDQEUmT/9CXj7bWCfbBnmKJoGBIOA3W5Mf0RxSBoi7V3yRe3CvdjdqQXwDt7He+iMF9TxLEJL1EC8IYCi48479Q3CRlGKwYwShtnLoeGGLCmfsuN5rSc2ICuqzyGimhjOKDJt2hjb3/33A337AmPGGNsvUQPEy3KotAgtEVkbwxlFZvVq/XXxxcb0N2MGMGkSwxlZitnLd9Jrn0yhafq/eZeLJzeJTMJwRpF55x3gvvuAiy7SlyQb6uDBhvdBFOcsvZcrGAQGDdIP7bzwQqxHQ9QoMJxRZK6/3rhZM6IEY/aeM6mIwqDdrn9Tdswx0RsQEdXAcEaRadZMfxkhEAD++ld9SXPIEGP6JDKA2SFLOnM2suvtonbc40ZkbQxnFJl164CvvtKXNZOTG9aXzwf8859Aq1YMZ5QQpNcwSS8wDwpPa0Y8Tk3Dqe6NwKefAoMHi55JROFjOKPIfPKJvrQ5enTDw1lysl7gkshizD51adtXJGoXFLUSzoB16oSlZ1yGqerkiJtaek8dkQUxnFFkLr1UX4ZktXAiw0iXC01dfl2yBIPatMEgB79sEEWbLdYDoDiTmQm0b29M4djiYuCGG4BlyxreFxFFV4cOAIMZkSn4L40is2kTsHgxcP75QFYDq4aXlwNvvKHfrTlggDHjI4pD0j1ntp4m1rdRFHgAACAASURBVB3TNGDaNH2P6OWXm/dcokaI4Ywi8913wB//qIephoazNm2AAweMGReRgaTLhdIDAQtXPSBqZyqlgPffB7p3ZzgjijKGM4rM6NHAzp3GldMgsiDpBnZpqDP7uijx89xL9ZsCiCiqGM4oMqmp+ssI27YBU6fqpz979TKmTyIKiacniayN4Ywis3OnXi18/PiGX4JeVATMmwecd54xYyMyiNnLmlpGmqhdTPzpT/pp7fvvj/VIiBIWwxlFZuNG4OabgR49Gh7OevUCdu82ZlxEFiAtiSGtjxaTSv9VVfqLiKJGaZoW6zGIFRQUaCtWrIj1MBoXr1cvHJuZCTidsR4NkaWYvXeMiOKLUmqlpmkFod7HmTOKjMsF5OQY09fq1cCjjwJ33QV07mxMn0QxJF3WlM6ASZdDA8Jrn2qEyGAQsLFUJlE0MJxRZA4eBF56CRg7FujWwBpLBw4AS5cCf/6zMWMjijHpcqG0zpm0BEeDbxY4+2z9+rU33mhYP0RUK4Yzisz+/cBf/wq0bt3wcDZ4MLBliyHDIrICU69TasDzGryM2r8/S2oQRRHDGUWmSxegtBRISYn1SIgsR7qs6d+z1+CRRNntt8d6BEQJjeGMImO3AxkZxvT1v/8BzzwDPPEE0Fz2RY0oEcRlqAsE9K0J/LdLZDiGM4pMZSUwfTowbBjQr1/D+jpwAFixAvD5jBkbUYw1qERFvBkyRL/S6dNPYz0SooTDcEaRcbuBKVOAtLSGh7NzztFfRI1cXJbguOEGPZwRkeEYzigyWVl6QGONMyLDSEPWyK6yvV8frX9E1K4G3uxBFDUMZxQZpYCkJGP6eu894JVXgNmzjbuvkygOxeXMGQDs2qW/CkLW1CSiCDCcUeTuvRcYOFDfc9IQhYXA+vUsZEmWY/bdmtJ2MXf55foVbGvWxHokRAmF1zdR5JxO4I47gAdkBTCJEpXZd13GfMZt+XL980GfPsb0R5TgeH0TRY/Xy43ARLWQlrYwu3itYU48MdYjIEpIDGcUOaOC2YsvAh9+CLzzjjH9EcWYdEYqbsMZAHz9NbBtG3D++bEeCVHCYDijyD30kH510/jxDeunrAzYt8+YMRHFsbgsQnvvvcB99x3++QUX6D/ec4/+a0Qkxj1nFLkOHYAxY4Cnnor1SIgsxew9YGbvcavVvn36bQEtWxrXJ1GC4p4zih5eVk4JLl6WGS1xI0FeXqxHQJRwGM4odv7xD+DHH/U6Z0QWYvbeMbNn3Ax93vLlwPffA9deK+qTiI7GcEaRe/RRIDsbuPLKhvXjdut3dRIliEQPdbV6/33g4YeBa67hKW4ig3DPGUXulFOAdu2A11+P9UiIKNZKSwGPB8jNZTgjCoF7zih6vvwy1iMgSiiWmAGTysyM9QiIEg7DGcXObbcBJSXAc8/FeiREMWWJkCW1Zg2weLG+rJmWFuvRECUEhjOK3MyZ+i0Bt97asH6UAux2Y8ZE1AhZYsZt+XLglluAc89lOCMyCPecUeQmTAAqKoD582M9EqJ6WSK8hMES9cqk3G59z1lGBmCzxXo0RJYW7p4zhjMiIiIiE/BAAFnfpElATg7w2GOxHglRTJld9NbQmcEtW4A33wQuuQRo08a4fokaMYYzitw//6l/Qn7wwYb1k56uv4gsxuzl0Lg+ELB5M3DHHcDJJzOcERmE4Ywi98MPwKpVDe9nlgX2yxDVIl7CkiX21A0cqO9BTU42rk+iRo7hjCLHUEVUK0uEJbM5HPqLiAzDf1EUO6NGASedBNx7b6xHQmQIs0OWJUJdYSHw1FPAWWcBvXrFejRECYHhjCL36qvA5583vHhsy5b6gQAiigu1zQzmaRV4FQvw6N3vY6HqUGs7S4RIojjCcEaR27wZ+Oqrhvfz4osN74MoCsyuOxYvdc5qDVmaBgQC+IvDgb+YOhqixMU6Z0REvxMve8fiZZxEpGOdM7K+Pn2AiRP1q1+ILCRewoslxhkMAvfcA5x+OjBkSKxHQ5QQGM4ocnPnAq+9pr8ackqrWzegeXPjxkUUY3FdTFZKKeDhh/XPBQxnRIZgOKPI7dsHrFkD+P0NC2evv27cmIjimKOF7JuUkV1vF7X7aP0jona1Ugrw+fQficgQ3HNGRBRj0gMB/j17Re0sMeNG1AhxzxlZW3m5XhNpyhTgyitjPRoiQzTaDfoPPwx06ABcdFGsR0KUEBjOKHKLF+u3BLz4orxOmVLAgAF6rTMii4mXkGWZcf7nP/q/Z4YzIkMwnFHkKiqArVsBr1feR1oaMHu2cWMiMpA0vDTKAwEA8NNPsR4BUULhnjMiokbGMjNuRI0M95yRtW3ZAgwcCMyYAYwfH+vREDUqhoesWbP009uTJxvbL1EjxXBGkfv6a+C++4CZM4HOnWV9JCcDw4cDrVoZOzaiGDJ7RsoyM2Aff6xvc2A4IzIEwxlFzucDDh7Uf5Rq0QJ44QXjxkRkIGnokdYrk7LMMuPcubEeAVFC4Z4zIiKDNNoDAUQUFu45I2v79ltgzBjgrbf0O/mIGjGzZ9wMN3u2fmvIIwbePEDUiDGcUeR+/hm48Ua98OSJJ8r6yMoCzj2Xd2tSQmm0M1mrVgGffMJwRmQQhjOS8XqBQEDevnNn4JlnjBsPEcXOY4/FegRECYXhjCJ37LHA//4X61EQERElJFusB0CN1IcfAk2bAj/+GOuREFFDzZsHXHYZEAzGeiRECYEzZxS5nTuBCy8E7rwTGDVK1kfbtsCkSUBurqFDI2pMLFPnbNs24Isv9O0OycnG9k3UCDGcUeTsdsDpBGwNmHjt2ROYPt24MRHFMcuELKnrr9dfRGQIhjOKXIsW+sksIjJE3JfSICJDMZxRbLzwgl6O49dfeYUTNXoLds2K9RAa5ssv9evcpk/Xv3kjogbhgQCKXEWFXt9s9mx5Hz166MsgGRnGjYuIYqO4WK91VlER65EQJQTOnFHkHA4gJwdISZH3cfLJ+osogcT93jGpMWP0FxEZguGMIpeUBCxY0LA+NA1QypjxEFlE3IcsIrKEqC9rKqXsSqnvlVIfVP+8o1LqG6XUBqXUm0opV/XHk6p//mv1r3eI9tgohh58UJ+B8/liPRIiaqj164Hx44Hvv4/1SIgSghkzZzcDWAsgs/rnjwB4QtO0N5RSzwK4CsAz1T8WaZrWWSl1YfX7LjBhfCRx8snA+ecDt9wia3/KKcAdd+gBjchizF6ejPvlUK8X2LABKC+P9UiIEoLSNC16nSvVBsC/ATwI4BYAZwLYD6CFpml+pVR/APdqmjZCKbWw+r+/Uko5AOwB0EyrZ4AFBQXaihUrojZ+qscFF+gFaCdNivVIiIiI4oJSaqWmaQWh3hftaYvpAG4D8NuRvBwAxZqm+at/vgNA6+r/bg1gOwBUB7eS6vcfOLJDpdQ1AK4BgHbt2kV18FSPN99sWHu/Xy9i25BCtkRREvczWUQU16IWzpRSYwHs0zRtpVLq9N8+XMtbtTB+7fAHNO15AM8D+syZAUOlWLjlFr0UR1FRrEdCdJRGuzwpVVio36153XU8tUlkgGjOnJ0C4Cyl1GgAydD3nE0H0FQp5aiePWsDYFf1+3cAaAtgR/WyZhMAhVEcHzXE0KFAQQEwbZqs/ejRAGc+KcGYHbIsEwZtNmD3bqCy0th+iRqpqIUzTdP+BuBvAFA9c/YXTdMuUUr9F8B5AN4AcDmA96qbvF/986+qf/2T+vabUYx166ZfXi41cqT+Ikogo1rdIGonvSHAMjNuTZsCK1fGehRECSMWR+VuB/CGUmoqgO8BvFD98RcAzFZK/Qp9xuzCGIyNwjWrgdfNVFXpdc6Sk40ZD5EF+PfsjfUQiCgBRPW0ZrTxtGYcu/BC/bqXdetiPRKiuGWZZU0AGDsWOPNM4Nprje+bKEFY5bQmJapzztGXMl56Sdb+4ouBYcOMHRNRI2OZZU0AcLv1U9hE1GAMZyTTqxeQni5vf9ZZxo2FqJGy1MzZxx8b3ydRI8VwRjL33tuw9qWl+gmvhgQ8okbOUjNnRGQYVgCl2Dj7bL2cBhElhssvB/7v/2I9CqKEwJkzkpk0Cdi7F1iwQNb++uuBYNDQIRE1NpZa1nQ4eFcukUH4L4lk+vYFSkrk7c8917ixEFHsvfBC6PcQUVgYzkjmxhsb1n7/fsDlApo0MWY8RI0Q95wRJSaGM4qNwYP1WwbefjvWIyGKOUstT0rdeiuwb59+Zy4RNQjDGcncfDPw2WfADz/I2t91l14njYisFbKkMjMBrzfWoyBKCAxnJNOvH5CRIW9/wQXGjYWIYu+ee2I9AqKEwXBGMpde2rD227frNc6ysowZDxERUYJgOKPY6NsXOO884OmnYz0SokYnKnvcHnkEmDcP+OIL4aiI6DcMZyRz773AU0/ppy4lpk8HOnQwckREFKao7HHLyQHatze+X6JGiOGMZAoKgCuukLe/+GLjxkLUSI1qdYOo3YJdswweCYCrr9ZfRNRgDGckM3as/pL65RcgNxfIzjZuTESNjH/P3lgPgYiigOGMzKdpQNeu+umuhl6gTtSIWaoExyuvAFOnAitXNuwkNxHx4nMSmjFDr/BfVhZ5W00DXn0VGD/e+HERUWzk5uoHfYiowThzRjInnKBXBJdcdGyzcc8ZUaIZPVp/EVGDMZyRzMCB+kvC7wfWrgVat+aeMyLIS1tIWWo5lIiOwnBGcpr2/+3dd5xdRf3/8dekkUJC6CUJSSjSCSWAIL0oKIJIEemIgiAgwhepQqQoNrASFEHpfAEFEfgiEKoggdBbaKEXCYSW3ub3x9z8siGbzd3de++cs/t6Ph7nsXvuOWf3zeFm97Mzc2bSxxBad92ECbDuumkqjiOOqH0uqWTaWiw1uqhr0e23w6GHwk03wVpr5U4jlZrFmdrmssvggAPgpZdg5ZVbd23fvnDttbD++vXJJnUShWoBW2op2HJL6N07dxKp9FpVnIUQugCLxhg/qVMelcWwYelpy8UWa/21vXql1QEktUtdZvpvq/XXh0suqf3XlTqhhRZnIYQrge8Cs4BHgMVCCOfGGH9R73AqsHXXTVtbTJkCzz6bWtz6969tLqkTKVTLmaSaqWYqjTUrLWVfA24BVgT2r2sqFV+MMH06zJrV+mtfeimtMDBqVO1zScrj2WfTQz633JI7iVR61XRrdg8hdCcVZ7+PMc4IrR0Aro7ntttgxx3hgQdg001bd+3gwfCPf6QCTVKbFapbs3//NJXGssvW/mtLnUw1xdkfgVeBJ4B7QwiDgY/rGUol8LnPwdlnw8CBrb+2Xz/YZZfaZ5I6mUJ1a66wAlx4Ye4UUocQ4pzpEBZ0QghDY4yvNNkPwCoxxhfrHW5hhg8fHseMGZM7hlrr449TF8haa6VCTerkCtUCJqluQgiPxBgX2m1UTcvZ34AN5uzEGGMI4WrAdTo6s9mzYdIk6NkTundv3bVjxsD228O997Z9IlupA+kQRdann8JKK6WnuI88MncaqdQWWJyFEFYH1iI9ndl0EcR+QM96B1PBPfFEWsLphhtg111bd+1668Gtt8Laa9cnm6TG69kT9toLVl89dxKp9FpqOVsN2BnoD3y1yeufAt+pZyiVwMCB8ItfwJprtv7aJZeEL32p9pmkTqZQ3aHdu6dVPyS1WzVjzjaNMf6nQXlaxTFnJfXf/8LYsbDRRs4mLknqNGo55uylEMLJwJCm58cYv9X2eCq92bPhww9TcdWrV+uuvfNO2GefVKCttlp98kmdQKNbzhb2/S6Nt/AAK3BBWK8m30/qrKopzv4B3AfcQVolQIK334ZBg+BPf4LvtLKXe7vtUoE2aFB9skmdRKMXTF/o9zv9dHZfd1123333Nn19SUk13ZqPxxjXa/GkTOzWzGjSJLjoIth2Wwf2S5JUhVp2a94UQvhyjNE1OTRXnz5w9NFtu/a11+CFF2CrraBHj9rmkkqoaN2Ttf5+klqnmuLs+8DJIYRpwAwgkKY7c/bQzixGePfdVKS1diLZG26AY46BCRMsziSg23KNXfKobkXW5punZZxuuqk+X1/qJBZanMUY+zYiiEpmxoy0XMtZZ8Epp7Tu2r32Sutq9vWtJQHMfPe/bbqucC1g++7b+geEJM1nocVZCGHL5l6PMd5b+zgqje7dYeRI2Hjj1l+7/PJpkwQ0vruwbkXd4Ye36etKmlc13ZrHN/m8J7Ax8AiwbV0SqRxCgO9+t23Xjh0LL78MX/lKbTNJJdXoFrC6FYMxwqxZ0K2aXy2SFqSabs2mqwMQQhgE/LxuiVQer7+e5jlbaqnWXXfZZfDzn6euUUkdZ6D93nvDk0/Cc8/lTiKVWlv+vHkTcO4EwbrrwoEHwm9+07rrvvc92G23+mSSSqhwY8faas89YYstcqeQSq+aMWe/A+ZMhtYFWA94op6hVBLnnw8rr9z661ZYIW2SOpY99sidQOoQqmk5azrL60zgqhjj/XXKozLZZ5+2XffII2kaDsecSR3LrFkwdWqaYkdSm1Uz5uySEEIP4HOVl56vbySVxiuvpHnKBgxo3XUXXAC33AJvvVWfXFLJFK57sq1OOQXOOw+mTcudRCq1aro1twYuAV4lTUA7KIRwoFNpiB13hA02gKuuat11I0bAscfWJZKkjHbaCZZYIj21GULuNFJpVdOt+SvgizHG5wFCCJ8DrgI2rGcwlcCvfpV+ELfWgAGtb22TVHxbbZU2Se1STXHWfU5hBhBjfCGE0L2OmVQWO+/ctuvuuQcmT05/ZUvqOGbMgIkTYbHFoEuX3Gmk0qrmX8+YEMJFIYStK9uFpElo1dmNG5cmk22tc8+Fk0+ufR5Jef3lL6k1/d13cyeRSq2alrPDge8BR5PGnN0LnF/PUCqJAw9MyzjdeWfrrhs50gHDUhMdZp6zTTdNDwQsumjuJFKphRhjyyeE0AeYGmOcVdnvCiwSY5zcgHwtGj58eBwzZszCT1R93H03dO3qpJOSJFUhhPBIjHH4ws6rpltzFNCryX4v4I62BlMHsvXWbSvMbr4Zbrut5nEkZTZjBvz3vzB9eu4kUqlVU5z1jDFOnLNT+bx3/SKpNF5+GZ5+uvXXnXlmGncmqWO5+25Ybjl4+OHcSaRSq2bM2aQQwgYxxkcBQggbAlPqG0ul8MMfwvPPt75Au+GGNA+SpI5lzTXhD3+AoUNzJ5FKrZri7Bjg2hDC25X95YFv1C+SSuOkk2DSpNZft9xytc8iKb8BA+CII3KnkEqvmuWbHg4hrA6sRnpac2yMcUbdk6n4hi90TGPzrrwyFWjbblvbPJLymjkT3nkHFl/cJzaldqhqlsAY44wY49MxxqcszPT/jRsHo0e3/rpTT4W//rXmcSRl9uqrsOKKcP31uZNIpVZNt6bUvF/8Av72N3jvvdZdN3o0dPOtJ3U4yy0HF14In/987iRSqfkbUm139NGw996tv27ppWufRVJ+iy4K3/527hRS6S2wOAshbNDShXOe3lQntsYaaWutkSNh7bWdvFYdToeZ6b+tYoRXXklray65ZO40Umm11HL2q8rHnsBw4AnSAwHrAqOBzesbTYX3yitpa+3A/uOPh+9+1+JMHU5bi6wOU9TNng0rrwwjRsDpp+dOI5XWAouzGOM2ACGEq4FDY4xPVfbXBv6nMfFUaH/9K5xxRvqBHEL11735pmPOpCYKV2S1VdeucOmlMGxY7iRSqVXzG3L1OYUZQIzx6RDCenXMpLI4+GDYbrvWX9e/f+2zSJ1QIVvc9t+/fl9b6iSqKc6eCyH8GbgciMB+wHN1TaVyGDIkba0xaxb86lew1VawySb1SCV1GoVscXvpJVhkERg0KHcSqbSqmefsYOAZ4Puk1QKerbymzu711+GWW1q3yPG0aXDCCXDPPfXLJSmf7beHH/0odwqp1KpZIWBqCOEC4JYY4/MNyKSy+Oc/4cgj0zxn1U6P0asXTJzomDOpo/rDH2CZZXKnkEptoS1nIYRdgMeBWyv764UQbqx3MJXA7rvDgw+mx+arFQL06ZO6PSR1PF/5Cmy0Ue4UUqlV0615OrAx8BFAjPFxYEgdM6ksllsujRvr0aP6az75BM48Ex5/vH65JOXz0kswdmzuFFKpVVOczYwxflz3JCqft96CG26ATz+t/poJE+C00yzOpI7qO9+BQw/NnUIqtWoG/jwdQtgH6BpCWBU4GnigvrFUCg88AHvtBU8/DWutVd01gwfDjBmtmxdNUnmcdVbuBFLpVdNydhSwFjANuBL4mPTUpjq77beHRx+FlVaq/poQ0sMAXbvWL5ekfL7whbRJarNqWs5WizGeApxS7zAqmcUXT1trvP02XHAB7LsvrLZafXJJymfcuDR8Yfjw3Emk0qqm5ezcEMLYEMKZIYQq+67UKbz3HlxzTfpYrbfeSg8EvPxy/XJJyufss2G33XKnkEptocVZZY3NrYHxwJ9CCE+FEE6tdzCVwHPPwTe+kcacVWujjdJanDvtVL9ckvI55hi4/PLcKaRSCzHG6k8OYR3gh8A3YoytmD+hPoYPHx7HjBmTO0bnNWkSvPpqWsKpT5/caSRJKrQQwiMxxoX2+S90zFkIYQ3gG8AewAfA1cBx7U6o8uvTp/qnNOd4/nm4+GL43vdgxRXrk0sqmUIuYN5Wr7+e5jrbZhufypbaqJoHAv4CXAV8Mcb4dp3zqEw++ghuugk237z6BdDHjYPf/CZNwWFxJgFtL7IKWdRdemlaW3P6dOjevX7fR+rAWizOQghdgZdjjL9pUB6Vybvvwv77w1VXVV+c7bQTTJ1a11hSZ1HIlrP99oMttoAu1TxvJqk5LRZnMcZZIYQlQwg9YozTGxVKJbHSSvDii2kZJ0mC9IdatX+sSWpWNd2arwH3VxY7nzTnxRjjuXVLpXLo0QNWWaV11zz0UGppO/VUWHLJ+uSSlM8778ATT8CWW0Lv3rnTSKVUTbvz28BNlXP7NtnU2U2Zkgb3P/NM9de88AJcdBFMnly/XJLyueuuNHzhjTdyJ5FKq+qpNEIIfWKMkxZ+ZuM4lUZmEyak1q/f/AaOPjp3Gqm0Cjmwv63Gj09Pa663HvTqlTuNVCi1nEpjU+AiYFFgxRDCMOCwGOMR7Y+pUuvfH157DZZYIncSqdQKWWS11dJLp01Sm1XTrflr4EukOc6IMT4BbFnPUCqJLl3SdBiLLlr9NbffnuY4mzatfrkk5TNhAtx4Y+uWdZM0j6qedY4xfnbwwKw6ZFHZxAgjR8Lo0dVfM3ZsWo9TUsf0wguw667w6KO5k0ilVU1x9kYIYTMghhB6hBD+B3iuzrlUBiHAkUfCP/9Z/TVHHZXGpCyySP1yScpn7bVhzBjYbLPcSaTSqmYqje8CvwEGAG8CtwHfq2colchbb0FfH96VVLHoorDhhrlTSKW20JazGOP7McZ9Y4zLxhiXiTHuF2P8oBHhVALLLde6Rc+vuSaNOZPUMU2ZAtddBy+/nDuJVFoLLc5CCD8PIfQLIXQPIYwKIbwfQtivEeFUAn/6E9xxR/Xnjx3buvMllcsnn8Cee8Jtt+VOIpVWNWPOvhhj/ATYmdSt+Tng+LqmUnmcfnrrBvifdho8/3z98kjKa8kl4cknYe+9cyeRSquaMWfdKx+/DFwVY5wQQqhjJJXKc885uF/SXN26wTrr5E4hlVo1LWf/DCGMBYYDo0IISwNT6xtLpdG/f+tmAb/gAjjuuPrlkZTf1Vc7lYbUDtU8EHAisCkwPMY4g7T4+a71DqaS+Mtf4Prrqz//pZf8oS11dN/6Flx1Ve4UUmlVs3xTT+BgYPMQQgT+DYysdzCVxK9/DUOHwm67VXf+L39Z3zyS8nviCZd1k9qhmjFnlwKfAr+r7H8TuAxo20q96lj+8x/o3n3h50nqPFZdNXcCqdSqKc5WizEOa7J/VwjhiXoFUsn07t2683/yE5g0Cc4+uz55JOV3/fXQrx9st13uJFIpVfNAwGMhhM/P2QkhbALcX79IKpXLL0/jzqr1yitOTil1dD/6EZx/fu4UUmktsOUshPAUEElTaRwQQni9cmhF4NkGZFMZXHJJagk7+ODqzr/wwvrmkZTfv/4FPXvmTiGVVkvdmjs3LIXK6//+D7p2zZ1CUpEMGJA7gVRqCyzOYoyvzfk8hDAM2KKye1+M0TFnSrpVM2yxiWOPTTOIn3JKffJIyu+WW1KL+p4+Nya1RTVra34fuAJYprJdHkI4qt7BVBLXXgvnnVf9+W+/DePH1y+PpPwuuAB++tPcKaTSCjHGlk8I4Ulg0xjjpMp+H+A/McZ1G5CvRcOHD49jxozJHaNz239/GDMmLeMkSQATJkAIsPjiuZNIhRJCeCTGOHxh51XTJxWAWU32Z1Vek+Cyy3InkFQ0TkArtUs1U2n8BRgdQhgRQhgBPAhcVNdU6rj23x9+85vcKSTV0913w0gXkpHaqpq1Nc8lLd80AfgQODjG+Ot6B1NJ3HhjmtOoWh9+mAYKS+q4rr8eTjopdwqptBY65qzIHHNWAD/8IVx6Kbz7bu4kkopi0iSYPRv69s2dRCqUasecVdOtKS3Yz39uYSZpXn36WJhJ7WBxpsb60pfgIocsSh3aww+nqTSmT8+dRColizO1z223wVFHwaxZCz8X0g/ras+VVE4PPAAnn+z4UqmNLM7UPk8/DVdcATNmVHf+XXfBoYfWN5OkvA4/HKZOhf79cyeRSsniTO1z7LFpwkkXOZY0R48esMgiaSJaSa1mcabGmTgRNtsMrrkmdxJJ9TR2LPz4xz4sJLWRxZna5/774bDD0vxlCzN7dnqKq7WLpUsqlxdfhBEj4K23cieRSsniTO3z2mtpItpqBv726we33w5f/3r9c0nK5ytfSQ/+bLhh7iRSKVmcqX322QfeeQcGDsydRFJRdOmSNklt4r8eNc7rr8Pw4XDrrbmTSKqnt9+GU06BZ57JnUQqJYszlKbXjgAAIABJREFUtc9jj8HBB6fuzYUJAZZdFnr1qn8uSflMmJBWD3n++dxJpFJyZLba54MPYNQo+MEPFn7uoEFw8831zyRlskOXPdt03e2zr61xkszWWqv6uQ8lzcfiTO2z/fapu1JSxyuy2sr5zaR2sVtTjfPYY7DuuvDgg7mTSKqnKVPg+OPh7rtzJ5FKyeJM7fPii+mJzSefXPi5iywCK68MvXvXP5ekfGKE88+HJ57InUQqJbs11T6TJ8PDD1c3Ce2aa8L119c/k6S8evd20XOpHSzO1D7DhqXWM0mSVBN2a6pxbrsNVlstrbsnqWM76STX0ZXayOJM7fPuu7DnnnDPPQs/d7HFYP31HXMmdQZ/+1sa8iCp1ezWVPvMnAnPPgsffbTwczfZBK6+uv6ZJOX3wgu5E0ilZXGm9hk40CVaJEmqIbs11ThXXAErrQTvvZc7iaR6+8lP4Le/zZ1CKiWLM7XP5Mmwyy7VTZGx/PKw+ebQs2f9c0nK69//hoceyp1CKiW7NdU+XbrAG2/Ap58u/Nxtt02bpI7vlltyJ5BKy+JM7dOzZ1qWSZIk1YTdmmqc886DAQPSE56SOrbzz4cTT8ydQiqluhZnIYT+IYTrQghjQwjPhRA2DSEsEUK4PYTwYuXj4pVzQwjhtyGEl0IIT4YQNqhnNtXQV78Kf/7zws9bZRXYaSfo2rX+mSTl9dxzMGZM7hRSKdW75ew3wK0xxtWBYcBzwInAqBjjqsCoyj7ATsCqle1QYGSds6lWJk6EadMWft6cIi6E+meSlNfvfgd33JE7hVRKdRtzFkLoB2wJHAQQY5wOTA8h7ApsXTntEuBu4ARgV+DSGGMEHqy0ui0fY3ynXhlVI3fdlTuBJEkdRj1bzlYCxgN/CSE8FkL4cwihD7DsnIKr8nGZyvkDgDeaXP9m5bV5hBAODSGMCSGMGT9+fB3jq+ZOOAE+97ncKSQ1wlVXwX775U4hlVI9i7NuwAbAyBjj+sAk5nZhNqe5vq443wsx/inGODzGOHzppZeuTVK1z957wznnLPy8DTeE3Xarfx5J+b3zDjzxRO4UUinVszh7E3gzxji6sn8dqVj7bwhheYDKx/eanD+oyfUDgbfrmE+Nttde8LOf5U4hqRGOPRaeeip3CqmU6jbmLMb4bgjhjRDCajHG54HtgGcr24HAOZWP/6hcciNwZAjhamAT4GPHm5WEi5lLklQz9X5a8yjgihDCk8B6wE9IRdkOIYQXgR0q+wC3AOOAl4ALgSPqnE2NdsABsNFGuVNIaoTbboNdd4UPP8ydRCqduq4QEGN8HBjezKHtmjk3At+rZx7VySGHQP/+8KtftXzedtvBWms1JpOkvD79FF57rbppdiTNw+Wb1H69e0OvXgs/78AD659FUjHsvnvaJLWaxZna73e/y51AkqQOw7U11Tjbbw877JA7haRGePTRtFzbs8/mTiKVji1nar9jjoH334fLL2/5vL32akweSfnNnAkffOCYM6kNLM7UfkssUd16mYceWv8skoph443hoYdyp5BKyeJM7XfaadWdN3s2dLEnXZKkllicqXHWXjtt11yTO4nUqe3QZc82XXf77GurP/nNN9MT2iee6FhTqZUsztR+P/oRPPgg3H57y+cdcQQss0zL50iqu1YVWW3VtStMnQqzZtX/e0kdjMWZ2m+55WCllRZ+3pFH1j+LpGJYfnm4//7cKaRSsjhT+32vyoUdpk6F7t3TX9SSJKlZjs5W4wwcCEcfnTuFpEaYORO23BL+8pfcSaTSsThT+/3iF7DOOgs/75RTYJdd6p9HUn5du0K3braUS21gt6bab+BA2GCDhZ/3gx/UP4ukYggB7rwzdwqplGw5U/t985twySULP+/jj2H69PrnkSSpxCzO1BizZ0P//vDTn+ZOIqlRdtkFfvzj3Cmk0rE4U/tdeCGsuCJMmrTgc2KEX/0KvvjFxuWSlNeSS0LfvrlTSKXjmDO136BBsP32La+v2bUrHHts4zJJnUBDZvpvD5/UlNokxBhzZ2iz4cOHxzFjxuSOoWrMng0ffAD9+sEii+ROI0lSw4UQHokxDl/YebacqTHeey/NGH7++XD44bnTSB1C4VvODjkk/WFmC5rUKhZnar/rrktLMz34IAwZ0vw5ffvC738PW2zR0GhSR9awIqutVlghjTeV1CoWZ2q/QYPga1+DXr0WfE6fPtUv8ySpYzjzzNwJpFKyOFP7bbJJ2loyY0bq2lxySejZszG5JEkqIafSUGM891xaSeDmm3MnkdQoJ58MW2+dO4VUOhZnar9Ro2DxxeGhhxZ8zoAB8Mc/VrfMk6SOYfBgWHvt3Cmk0rFbU+03YADsvz8stdSCz1lySTj00MZlkpTfYYflTiCVksWZ2m/11eG3v235nMmT4d1309NbjjmTJGmB7NZUYzzwAKy8Mjz8cO4kkhrld79LS7vNnp07iVQqFmdqvyeeSFNl/POfCz5nzTXhr3+F1VZrWCxJmQ0eDNttB7Nm5U4ilYrdmmq/pZeGI46AoUMXfM4KK8CBBzYuk6T8dtklbZJaxeJM7bfCCvCLX7R8zscfpzFnQ4dCjx6NySVJUgnZranGuPnm9ODAq6/mTiKpUf72N1huOXjlldxJpFKxOFP7vfUWdO8OF1204HM22wyuvDItfi6pcxg0CHbdteWl3STNx25NtV+/fnD88bDuugs+Z8iQBS+KLqlj2njjtElqFYsztV/fvvCTn7R8zvjx8M476anNbr7tJElaELs1VRuzZ7f8uPzll8OwYTBxYuMyScrroYfS6iB33ZU7iVQqFmdqv2nToGtX+NnPFnzOV78K112X5kOT1Dksswzssw8su2zuJFKp2L+k9uveHUaMgC22WPA5q6ySNkmdx5AhaZUASa1icab269IFTj+95XPeeAPeew823LAxmSRJKim7NVUb06albUHOPx823bRxeSTl98476YGhlqbZkTQfizPVxrLLwgknLPj4QQfBDTc0LI6kAujbFw49ND2lLalqdmuqNkaMgLXXXvDx1VZz0XOps1l0UfjVr3KnkErH4ky1ccwxLR9/8cW0vubw4Y3JI6k4YoQQcqeQSsNuTdXGxIktz2F2zjnwta81Lo+kYujbF04+OXcKqVQszlQbG2yQxpYsyHHHpbU1JXUuxx0HW22VO4VUKnZrqjZOPjlNOLkgDgiWOqcRI3InkErH4ky1cdBBLR9/4gmYPh022qghcSQVRIxpaTfX1JWqZremauOjj2DChAUfP/VUOOywxuWRVAxrrgn77Zc7hVQq/imj2th5Z+jZE+64o/nj55wDU6c2NpOk/I46quUhD5LmY3Gm2jjuuLT4+YKstVbjskgqjiOOyJ1AKh2LM9XGbru1fPyBB6BHD+c5kzqbGTPS1rt37iRSaVicqTYmTEhray6/fPPHf/ADWHxxuPXWxuaSlNeuu8L778NDD+VOIpWGxZlq45BD4OWX4cknmz9+8cXQxedPpE7nW9+CSZNyp5BKxeJMtfG978Ennyz4uGPOpM5pjz1yJ5BKx+JMtbH99i0fv+02WGqptJKApM5j6lSYMiUNa5BUFfuZVBvvvw/jxi34+GGHwa9/3bg8korhuONg1VVzp5BKxZYz1cYpp8A//gHvvtv88Ztv9mktqTPaYw9YZ53cKaRSsThTbRx8MOyww4KPu7am1Dlts03aJFXN4ky18fnPt3z8b3+DVVaBYcMak0dSMUyZkpZ3W3ZZn9iWquS/FNXG+PHwzDMLPn7AAXD55Y3LI6kYzj8fVljB6TSkVrDlTLXxu9/BWWfBrFkQwvzHH3kE+vdvfC5JeW2/PVxwAXTvnjuJVBoWZ6qNPfdsedDv6qs3Louk4hg2zOEMUivZranaWGedVKA112o2axZcemnL3Z6SOqYpU+C112D69NxJpNKwOFNtvP8+PPoozJw5/7EpU+DAA+GWWxqfS1Je//d/MGQIPPdc7iRSaVicqTauvho23BA+/HD+Y717p3U3Dzmk8bkk5bXhhmlt3YEDcyeRSsMxZ6qNL38ZBg2Cvn3nP9alC6y0UuMzScpv8OA0D6KkqtlyptpYaSXYdVfo2XP+YxMnwoUXwgsvND6XpLymTYMXX4RPP82dRCoNizPVxoQJ8OCDMHny/Mfeew8OPRT+85/G55KU13PPwec+B3fckTuJVBoWZ6qNO+6ATTeFV16Z/9iKK8Ibb8Duuzc+l6S8hgxJE1BvuGHuJFJpOOZMtbHFFumprBVXnP9Yt24OBpY6q/79Yd99c6eQSsWWM9XG8svDjjs2/0DAf/8Lf/hDmutIUucya1aa43D8+NxJpNKwOFNtfPQR3Htv+vhZr7wCRx4Jzz7b+FyS8po0CdZeGy67LHcSqTQszlQbjz8OW20Fjz02/7ENN0ytZ9tu2/hckvLq0weuuQZ23jl3Eqk0HHOm2hg2DEaNgvXWm/9Y9+6wzDKNzyQpv65d09Jukqpmy5lqY/HFU8vY4ovPf2zcODjvPHj33cbnkpTfk0865lRqBYsz1cbEiWk6jeYKsKefhmOPhbfeanwuSfltsw388pe5U0ilYXGm2nj9ddhhB7jnnvmPffnL6UGBYcMan0tSfpdfDocdljuFVBqOOVNtDBkC990Hq68+/7Fu3WCxxRoeSVJB7LRT7gRSqdhyptro3Rs23xyWWmr+Y08+CT/7GXz8ceNzScrvqafSXGeSqmJxptqYNg1uvrn55ZseeghOPBE++aTxuSTld/DB8MMf5k4hlYbFmWrj00/TPEY33TT/sYMPThNRDhjQ+FyS8vvd7+Css3KnkErDMWeqjf79YfToNPbss7p2Td2ekjqnTTfNnUAqFVvOVBvdusHGGzc/2ey//w1nngkzZjQ+l6T8nn0WHnwwdwqpNCzOVBsxwvXXN79+5r33wmmnwezZjc8lKb8RI9LwBklVsThTbYQAu+8OV101/7GTT4aZM6FHj8bnkpTfaafBpZfmTiGVhmPOVDuPPQbLLdf8sa5dG5tFUnGsvXbuBFKp2HKm2hk2DJZddv7Xb7kFzjij8XkkFcMLL8C//pU7hVQaFmeqnRtugIcfnv/1O+9MC59L6pwuvhh22SV3Cqk0LM5UO4cfDn/+8/yv//KX8OGHjc8jqRgOPzwt7yapKo45U+3cey/065c7haSiGTw4bZKqYsuZamfVVZsfc3bllXDOOY3PI6kYXn01TbUzbVruJFIpWJypdm68MY0v+6xRo+CKKxqfR1Ix/Otf8PWvwwcf5E4ilUKIMebO0GbDhw+PY8aMyR1DcwwbBiutlP5CllR3O3TZs03X3T772honWYjx4+Gtt2DNNZ3vUJ1aCOGRGOPwhZ3nmDPVzs03+4NXaoPSFFlttfTSaZNUFYsz1c7Agc2//oc/wPTp8IMfNDaPVBKlKbLa6t134Z57YLvtYKmlcqeRCs8xZ6qdW25J484+a9QouPXWxueRVAxPPQV77w3PP587iVQKtpypds47DyZPnn+yyb//PU8eScWw6abwzDMwZEjuJFIpWJypdq68Mi2ALklNLbpoehhAUlXs1lTtLL108+NJzjoLRo5sfB5JxfDJJ3DZZTBuXO4kUilYnKl2brst/QD+rLvugtGjG59HUjG89x4ccAD8+9+5k0ilYLemaueSS+Chh2D//ed9fdSoPHkkFcPgwfDCC7D88rmTSKVgcabaGTkSZs/OnUJS0XTvnpZ3k1QVuzVVO/36Qf/+879+zDHw1782PI6kgpg1Cy6+GB57LHcSqRQszlQ7d90Fv//9/K/ff7/zG0md3SGHND8PoqT52K2p2rnxxvTX8ZFHzvv6ww/nySOpGLp2hVdfhSWWyJ1EKgVbzlQ7P/kJvP127hSSimjwYOjbN3cKqRQszlQ7vXpBnz7zv77ffnDNNY3PI6k4Lr3UJ7elKlmcqXYeeADOPnv+JzbHjIG33sqTSVIxnHZa8/MgSpqPY85UO3ffDaeeCv/zP7DIInNfHzs2WyRJBfHww6l1XdJC2XKm2jn+eJg2DXr0yJ1EUtEsvXRaY1PSQlmcqXa6d0+FWdPFzydNgq9/HW6+OV8uSflde61jT6UqWZypdh55JI0r+fTTua9Nnw4vvggffZQvl6T8zj+/+XkQJc3HMWeqnccegzPPhO98Z+4j84svDk89lTeXpPxuvBG6+StHqoYtZ6qdb30rPak5aFDuJJKKpm9fHwiQqmRxptrp0mXe8WYAb74JO+8M996bJ5OkYrj5ZvjDH3KnkErB4ky18+yzcNJJ864SMGMGvPsuTJ2aL5ek/P7+dzjnnNwppFJwAIBq5+WX4dxzYa+9YIUV0mtDh6ZJaCV1buefn1rXJS2UxZlq56tfTfOcSdJnNZ2YWlKL/DNG9fXUU/DFL6YnOSV1XvfcA6efDjHmTiIVnsWZaufVV+HYY+ddrmnmTJg4cf71NiV1LvfdB2eckX4mSGqRxZlqZ/x4uPBCeOONua+tv35aEH3DDfPlkpTfSSelP9K6d8+dRCo8x5ypdjbaaN7VASRpjq5dcyeQSsOWM9XX3XfD1lvDuHG5k0jK6bHH4MQTYcKE3EmkwrM4U+2MHw9HHgmjR89/7LOT00rqXJ57Ds47Dz74IHcSqfAszlQ7kyfDVVelBwPm2Hrr1Ho2dGimUJIKYZ990lQ7q66aO4lUeI45U+0MHuxfxZIktZMtZ6qvv/0NNtvMcSZSZzduXJpq54UXcieRCs/iTLUzZQoceijcdtvc17p3h0UX9UktqbNrbqodSc2yW1O1EyPcdBNssMHc13bZJW2SOrdNNnGqHalKFmeqnd694e23c6eQJKnU7NZUff3xj2l1AJdvkjq3Dz+Eo46C++/PnUQqvLoWZyGEH4QQngkhPB1CuCqE0DOEMDSEMDqE8GII4X9DCD0q5y5S2X+pcnxIPbOpTr79bfjf/52737cvrLACdPHvAKlTmzEDrrwSXnopdxKp8Or2GzOEMAA4GhgeY1wb6ArsDfwMOC/GuCrwIXBI5ZJDgA9jjKsA51XOU9k88AC88src/X32gX/+M18eScWwzDJpqp0DD8ydRCq8eo856wb0CiHMAHoD7wDbAvtUjl8CjABGArtWPge4Dvh9CCHEGGOdM6qWnn02dwJJkkqtbi1nMca3gF8Cr5OKso+BR4CPYowzK6e9CQyofD4AeKNy7czK+Ut+9uuGEA4NIYwJIYwZP358veKrVs48E7bcMncKSUVwxBFp7kNJLapnt+bipNawocAKQB9gp2ZOndMy1tzii/O1msUY/xRjHB5jHL700kvXKq5q5aijYOTIufvLLedyLZKSW2+FsWNzp5AKr57dmtsDr8QYxwOEEP4ObAb0DyF0q7SODQTmzL3wJjAIeDOE0A1YDHBa+bJ55pk06ewc3/lO2iRp3LjcCaRSqGdx9jrw+RBCb2AKsB0wBrgL2AO4GjgQ+Efl/Bsr+/+pHL/T8WYldOeduRNIklRq9RxzNpo0sP9R4KnK9/oTcAJwbAjhJdKYsosql1wELFl5/VjgxHplUwMdeSR8+cu5U0gqghNPhN//PncKqfDq+rRmjPF04PTPvDwO2LiZc6cCe9Yzjxrghz+Efv3g1FPT/iqrpJUDJOnRR2HSpNwppMJz+SbV1ptvwuKLz90/5ph8WSQVy2235U4glYLFmWrryitzJ5AkqdRcU0f1tccesPfeuVNIKoJzzoGTTsqdQio8W85UWyNGwEcfwa9/nfY33BC6ds0aSVJBvPpqWsJJUosszlRbH38ME5pMT+dfyZLmuOCC3AmkUrA4U22dd17uBJIklZpjzlRfX/gCHHZY7hSSiuBPf4L998+dQio8izPV1i9+AfvsM3d/++1ho43y5ZFUHB98AK+/njuFVHh2a6q2ZsyAadPm7v/4x/mySCqWk05yHKpUBYsz1dbJJ+dOIElSqdmtqfoaOjStpydJf/87fOlLMHVq7iRSoVmcqbYuuCCNM5vjG99wzJmkZOrUNN3OjBm5k0iFZremaqtLF+jW5G11zjn5skgqln32mfeBIUnNsuVMtXXooXDrrblTSJJUWhZnqp9Zs6BXL/jZz3InkVQE990H22wD48blTiIVmsWZauuKK9IYsylTIEY46igYPjx3KklFMWtW2iQtkGPOVFu9esHSS8Ps2Wns2c9/njuRpKLYYgu4997cKaTCszhTbX3962mTJEltYrem6uedd9LTmxdemDuJpCJ4/vm03u599+VOIhWaxZlq66abYNgwePNN6N0bTjkF1lsvdypJRdC9exr6EELuJFKh2a2p2lp0UVhpJejaFRZbDM48M3ciSUWx0kpwxx25U0iFZ3Gm2tp667RBeiggxlSoSZKkqtitqfp58sn0xOb11+dOIqkIPvkkTbVzxRW5k0iFZnGm2rrvPlhjDXjiCVh2WTjjDFhzzdypJBVB9+5pqp3evXMnkQrNbk3VVr9+sM460LMnLL88/OhHuRNJKopeveCWW3KnkArP4ky1NWwYXHNN+nzmTJg+PRVqXWyklSSpGv7GVP3ceSf06QP/+U/uJJKKYvPN4ac/zZ1CKjSLM9XW00/Dyiunx+VXXRXOOQeGDMmdSlJRrLxyGncmaYHs1lRt9e0Lm20Giy8OQ4fCCSfkTiSpSC65JHcCqfAszlRbgwfDZZelz6dNg6lTU8HmmDNJkqrib0zVz7XXQv/+8PLLuZNIKoqvfx0OPTR3CqnQLM5UW2+/DYMGwVVXwYYbwrnnwjLL5E4lqSjWWANWWSV3CqnQ7NZUbfXuDTvsAAMGpB/Ca6yRO5GkIjn77NwJpMKzOFNt9e8PF1+cPp80KW1LLeWYM6lAduiyZ5uuu332tTVOIqk5Fmeqnz/+EY47Dj76CBZbLHcaSRVZi6wjjoDnn4dRo/JlkArO4ky1NW1aGnN20kmw3Xbwhz+4jp6kudZaK021I2mBLM5UW927w+67p7Fmw4alTZLm+N73cieQCs/iTLXVpQuMHJk+//DDNOZs4MC8mSRJKhFHaat+fvaztFSLJM1x5pku6SYthC1nqr0VV4RvfhP22ANWXz13GklFstZa8NWv5k4hFZrFmWpv331h441ho43SJklzfP3raZO0QBZnqr2f/jR9fPfd9PTm4MF580iSVCKOOVP9nHwybL557hSSiuTii9Nk1ePH504iFZYtZ6q9ddeF9daDww+HnXfOnUZSkay2Ghx0UJp2R1KzLM5Ue/vvn9bW3HTT3EkkFc0XvpA2SQtkcabaO/749PG112D2bBg6NG8eSZJKxDFnqo8Y00zge7ZtgWVJHdTtt6cl3UaPzp1EKixbzlR7W24JPXrAiBEwZUruNJKKZPBgOPJIWHbZ3EmkwrI4U+0dcAB06+aTmpLm97nPwc9/njuFVGgWZ6q9b387fRw7Nj2R5RJOkj4rRgghdwqpkBxzptqbPRumT09PbR51VO40korkhRdSy/rVV+dOIhWWLWeqvd13h5dfht//3rmMJM1rqaXghBNgjTVyJ5EKy+JMtbfvvjBhQnowQJKaWmIJOPvs3CmkQrM4U+3tsUf6+OijaZmWlVbKm0dSscyenbZu/gqSmuOYM9Xe9OkwcSLsthuccUbuNJKKZPp06NrVJzalFvhni2rvqKPgxhvTgN/FF8+dRlKRdO+e5kDcYovcSaTCsjhT7e2+OwwbBlttlTuJpKIJAU4/PXcKqdAszlR7X/xi2u67DwYOdG1NSfOaOjXNc9arV+4kUiE55ky1N2UKvP9+KtBGjsydRlLRrLKKcyBKLbDlTLX3k5+k7c47YcCA3GkkFc0pp8CQIblTSIVlcaba+8pXYJll0jxnLs8i6bMOPzx3AqnQLM5Ue5//PGy0Edx2G6y+OgwenDuRpCKZOBFmzYLFFsudRCokx5yp9iZPTss37bgjXHtt7jSSimanndI8iJKaZcuZau+ii+Doo9NcZ+uvnzuNpKL5/vcd8iC1wOJMtbfNNvDHP8J220Hv3rnTSCqaOUu8SWqW3ZqqvbXXhv32g1Gj4M03c6eRVDSffgr//W/uFFJhWZyp9iZPhv/8B3bZJU2nIUlNHXlkenBIUrPs1lTt/fOfsPfecNll6aEASWrqwAPTJNWSmmVxptrbeGP4y1/SfGcufC7ps7bdNncCqdDs1lTtDR06t0vz3Xdzp5FUNJ98Aq+8kjuFVFgWZ6q9yZNT1+Yee8Djj+dOI6lozj0XVloJZs/OnUQqJLs1VXujR8NBB8FvfwubbZY7jaSi2XXX1MIeY+4kUiFZnKn21loLrrgizXPWr1/uNJKKZv31naBaaoHdmqq9OYuejxoFEybkTiOpaD79FMaOhenTcyeRCsniTLU3dSpccgnsuy+89lruNJKK5vrrYY014I03cieRCsniTLX38stw6qlwxhnpB7AkNbXFFnDllbD00rmTSIXkmDPV3qBBcO21aQbwnj1zp5FUNEOHpk1Ss2w5U+316wfrrpvGnE2cmDuNpKKZPBmeeiqNPZM0H4sz1d6MGWkeo4MOgo8/zp1GUtE8+mj6A2706NxJpEKyOFPtffQR/PGPcOyxsOyyudNIKpo11oDrroN11smdRCokx5yp9hZbDP7xj/SDt5tvMUmfseSSsPvuuVNIhWXLmWqvRw8YOBBuvx1mzsydRlLRTJ8OjzwC772XO4lUSBZnqr0Y4Uc/gsMOc3kWSfMbPx6GD08t7JLmY5+T6uOWW+CQQ+zWlDS/pZZKhdl66+VOIhWSvzlVeyHArbfCyiunzyWpqUUWgV12yZ1CKiy7NVUfvXrBnXfmTiGpqP7zH3j11dwppEKyOFN9HHdcGnMmSc3Zaqs05Y6k+ditqfoYOxb22CN3CklFdfPNLuEkLYDFmerj1ltd1FjSgu2wQ+4EUmHZran6+PBD+Pe/c6eQVFSjR6f1NSXNx+JM9XHEEWkqDUlqzoEHwlln5U4hFZLdmqqyscPMAAAL30lEQVSPnj3ttpC0YJdeCv365U4hFZLFmerjmmugd+/cKSQV1cYb504gFZbFmerjmWdg1iz43OdyJ5FURI88AlOnwhe+kDuJVDiOOVN9nHUWnHZa7hSSmrFDlz3btNXUaafNHXP21lswcCBcfXXaf+WVtP/3v6f9559P+zfdlPaffjrt/+tfaf+xx9L+nImvH3ww7d9/f9q/7760/9BDaX/UqLT/+ONp///+L+0/+2zav/HGtP/ii2n/uuvS/muvpf0rr0z777yT9v/617T/wQdp/8IL0/4nn6T9889P+1OmpP3zzkv7s2en/Z//HAYPnntvzjoLVl113nu11lpz9086ad6lr447bt6WyKOOgs03n7t/2GGw7bZz97/1LfjSl+bu778/7Lzz3P299oLdd5+7v9tusPfec/e/8hU44IC5+zvsAN/+9tz9rbeGww+fu7/ZZvD978/dHz4cjj9+7v6668Ipp8zdX2MNGDFi7v4qq8DZZ8/dHzQIfvnL9PnMmele/uY3aX/y5LQ/cmTa/+ijtH/RRWl//Pi0f+mlab/W770aseVMtTViBPz4x3P35yzfdPrp8/5jk5TN7bOvzffNF/QzYv310y85gD59YMcdYfnl0/6ii8Iyy8BXvzrv19pxx/Sz5YAD0udzpu9ZYom0v8QS836/TTaZe+3668Nii6XPl102nd+3b9pfbrn0/T7b8j9kSPp+222Xzl9kkfT6iium/R495v1+c77+nO/XtWv6fJVV0vlzrLpqWm/0s8vdhZC+3xprpO85x5prwrRpc+/nuefOey9h3hbJ9dZL/41zbLABjBu34O+38cap52OOTTaB7t3nfr9bbkmfX3bZ3HN22mnu55tvngqoObbcMhW+Tb/fI4+kAuv001PhuOaac49tvz2svvrc7/fyy3DqqWmbY8yYuZl33DEtFwjpHu+4YyrMjzhi7vnf/nbaTjghHV9xxfR6z55pf+DAef/fNS1O118/vScgjZPcccf0/oD0/3iZZeb9/zNHO37vhRhjmy4sguHDh8cxc/4HSZIkFVgI4ZEY4/CFnWe3piRJUoFYnEmSJBWIxZkkSVKBWJxJkiQViMWZJElSgVicSZIkFYjFmSRJUoFYnEmSJBWIxZkkSVKBWJxJkiQViMWZJElSgVicSZIkFYjFmSRJUoFYnEmSJBWIxZkkSVKBWJxJkiQViMWZJElSgVicSZIkFYjFmSRJUoFYnEmSJBWIxZkkSVKBWJxJkiQViMWZJElSgVicSZIkFYjFmSRJUoFYnEmSJBWIxZkkSVKBWJxJkiQViMWZJElSgVicSZIkFYjFmSRJUoGEGGPuDG0WQhgPvLaAw0sB7zcwTll4X5rnfZmf96R53pfmeV+a532ZX2e+J4NjjEsv7KRSF2ctCSGMiTEOz52jaLwvzfO+zM970jzvS/O8L83zvszPe7JwdmtKkiQViMWZJElSgXTk4uxPuQMUlPeled6X+XlPmud9aZ73pXnel/l5Txaiw445kyRJKqOO3HImSZJUOhZnkiRJBdIhi7MQwo4hhOdDCC+FEE7MnacIQgivhhCeCiE8HkIYkztPLiGEi0MI74UQnm7y2hIhhNtDCC9WPi6eM2MOC7gvI0IIb1XeM4+HEL6cM2OjhRAGhRDuCiE8F0J4JoTw/crrnfr90sJ96ezvl54hhIdCCE9U7suPK68PDSGMrrxf/jeE0CN31kZq4b78NYTwSpP3y3q5sxZJhxtzFkLoCrwA7AC8CTwMfDPG+GzWYJmFEF4FhscYO+vEfwCEELYEJgKXxhjXrrz2c2BCjPGcSjG/eIzxhJw5G20B92UEMDHG+Muc2XIJISwPLB9jfDSE0Bd4BPgacBCd+P3Swn3Zi879fglAnxjjxBBCd+DfwPeBY4G/xxivDiFcADwRYxyZM2sjtXBfvgvcFGO8LmvAguqILWcbAy/FGMfFGKcDVwO7Zs6kgogx3gtM+MzLuwKXVD6/hPSLplNZwH3p1GKM78QYH618/inwHDCATv5+aeG+dGoxmVjZ7V7ZIrAtMKcA6YzvlwXdF7WgIxZnA4A3muy/iT84IP1juC2E8EgI4dDcYQpm2RjjO5B+8QDLZM5TJEeGEJ6sdHt2qu67pkIIQ4D1gdH4fvn/PnNfoJO/X0IIXUMIjwPvAbcDLwMfxRhnVk7plL+PPntfYoxz3i9nV94v54UQFskYsXA6YnEWmnnNKh2+EGPcANgJ+F6lG0tqyUhgZWA94B3gV3nj5BFCWBT4G3BMjPGT3HmKopn70unfLzHGWTHG9YCBpF6cNZo7rbGp8vvsfQkhrA2cBKwObAQsAXSaoQHV6IjF2ZvAoCb7A4G3M2UpjBjj25WP7wHXk35wKPlvZRzNnPE072XOUwgxxv9WfqjOBi6kE75nKmNk/gZcEWP8e+XlTv9+ae6++H6ZK8b4EXA38HmgfwihW+VQp/591OS+7FjpHo8xxmnAX+jE75fmdMTi7GFg1coTMj2AvYEbM2fKKoTQpzJwlxBCH+CLwNMtX9Wp3AgcWPn8QOAfGbMUxpwCpGI3Otl7pjKQ+SLguRjjuU0Oder3y4Lui++XsHQIoX/l817A9qTxeHcBe1RO64zvl+buy9gmf+AE0ji8TvV+WZgO97QmQOUR7l8DXYGLY4xnZ46UVQhhJVJrGUA34MrOek9CCFcBWwNLAf8FTgduAK4BVgReB/aMMXaqwfELuC9bk7qoIvAqcNicsVadQQhhc+A+4ClgduXlk0njqzrt+6WF+/JNOvf7ZV3SgP+upIaPa2KMZ1R+/l5N6rp7DNiv0lrUKbRwX+4EliYNRXoc+G6TBwc6vQ5ZnEmSJJVVR+zWlCRJKi2LM0mSpAKxOJMkSSoQizNJkqQCsTiTJEkqEIszSVmFEGry+HwIYUQI4X+qOO+vIYQ9FnZeo75O5WtVlV1S52BxJkmSVCAWZ5IKIYSwaAhhVAjh0RDCUyGEXSuvDwkhjA0h/DmE8HQI4YoQwvYhhPtDCC+GEJou+zIshHBn5fXvVK4PIYTfhxCeDSHcTJOFykMIp4UQHq583T9VZitvLtsBlQWanwghXNbk0JYhhAdCCOPmtKKFELYOIdzU5NrfhxAOqnz+agjhx03+G1dv5nt9J4TwfyGEXiGEoyu5nwwhXN32uyupTLot/BRJaoipwG4xxk9CCEsBD4YQ5iy9tgqwJ3AoaYm2fYDNgV1Is9N/rXLeuqT1DPsAj1WKsc8DqwHrAMsCzwIXV87/fYzxDIBK0bUz8M+moUIIawGnAF+IMb4fQliiyeHlKzlWJy3rdF0V/53vxxg3CCEcAfwP8O0m3+tI0vJqX4sxTgshnAgMrXzev4qvLakDsOVMUlEE4CchhCeBO4ABpGIK4JUY41OVRbWfAUbFtLzJU8CQJl/jHzHGKTHG90lrGm4MbAlcVVmU+23gzibnbxNCGB1CeArYFlirmVzbAtdVviafWarphhjj7Bjjs02yLsycBdQf+Uz2/YGdgN2bLO/zJHBFCGE/YGaVX19SyVmcSSqKfUlr7W0YY1yPtMZnz8qxpmsRzm6yP5t5ewA+ux5dXMDrhBB6AucDe8QY1wEuBHqGEAaFEB6vbN8lFY0LWueuaa45XaIzmfdna0/mNeeaWZ/J/jSpWBvY5LWvAH8ANgQeCSHY2yF1AhZnkopiMeC9GOOMEMI2wOA2fI1dQwg9QwhLkhZufxi4F9g7hNA1hLA8sE3l3DlF0/shhEWBPQBijG/EGNerbBcAo4C9Kl+Tz3RrNuc1YM0QwiIhhMWA7arM/hhwGHBjCGGFEEIXYFCM8S7gh0B/YNEqv5akEvOvMElFcQXwzxDCGOBxYGwbvsZDwM3AisCZMca3QwjXk7omnwJeAO4BiDF+FEK4sPL6q6RCbj4xxmdCCGcD94QQZpGKqIMWFCDG+EYI4RpSl+SLlfOrEmP8d2VKjZtJY88urxR4ATgvxvhRtV9LUnmFNGxDkiRJRWC3piRJUoFYnEmSJBWIxZkkSVKBWJxJkiQViMWZJElSgVicSZIkFYjFmSRJUoH8PwSYw6fQiR7xAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -840,14 +1040,14 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 140, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "5962\n" + "204896\n" ] }, { @@ -856,13 +1056,13 @@ "" ] }, - "execution_count": 20, + "execution_count": 140, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -874,7 +1074,7 @@ } ], "source": [ - "binid = 20\n", + "binid = 7\n", "print(gw_hist[\"donut\"].iloc[:,binid].values.sum())\n", "hs = np.clip(gw_hist[\"donut\"].iloc[:,binid].values,a_min=None,a_max=10000)\n", "# hs = np.log(gw_hist[\"donut\"].iloc[:,binid].values)\n", @@ -889,36 +1089,113 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### now extract \"significant\" pixels using the defined thresholds_df and the same parquet file with the score dump as for the histogramming step" + "### now extract \"significant\" pixels using the defined thresholds_df and the same parquet file with the score dump as for the histogramming step\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 143, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "parquet input ...\n", - "Number of filtered pixels 21545\n" + "Preparing to convolve 49 tiles:\n", + "creating a Pool of 8 workers to tackle 49 tiles\n", + "Number of filtered pixels 4013\n" ] } ], "source": [ - "filtered_pixels = dotfinder.extraction_step(tmp_scores,\n", - " score_dump_mode,\n", - " kernels,\n", - " ledges,\n", - " threshold_df,\n", - " nproc=1,\n", - " output_path=output_scores,\n", - " verbose=False)\n", + "filtered_pixels = dotfinder.scoring_and_extraction_step(clr,\n", + " expected,\n", + " expected_name,\n", + " balancing_weight_name,\n", + " tiles,\n", + " kernels,\n", + " ledges,\n", + " threshold_df,\n", + " max_nans_tolerated,\n", + " balance_factor, \n", + " loci_separation_bins,\n", + " None, \n", + " nproc,\n", + " verbose)\n", "\n", "print(\"Number of filtered pixels {}\".format(len(filtered_pixels)))" ] }, + { + "cell_type": "code", + "execution_count": 145, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 145, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "xlabel = 'la_exp.donut.value'\n", + "ylabel = 'count'\n", + "\n", + "# we might consider \"downsampling\" la_exp dataframe in order to make obs/exp scatter plot less busy:\n", + "sub_la_exp = la_exp.sample(frac=0.1)\n", + "\n", + "sct = plt.scatter(sub_la_exp[xlabel],\n", + " sub_la_exp[ylabel],\n", + " # color dots on the scatter by their genomic separation\n", + " c=sub_la_exp['bin2_id']-sub_la_exp['bin1_id'],\n", + " vmin=0,\n", + " vmax = 100,\n", + " cmap=\"YlOrRd_r\")\n", + "\n", + "\n", + "\n", + "plt.scatter(filtered_pixels[xlabel],\n", + " filtered_pixels[ylabel],\n", + " s=80,\n", + " facecolors='none',\n", + " edgecolors='b')\n", + "\n", + "# we can add a visual of the lambda-chunking grid on top of obs/exp scatter ...\n", + "# plt.vlines(ledges[1:-15],ymin=0.5,ymax=900,color='red')\n", + "\n", + "ax = plt.gca()\n", + "fig = plt.gcf()\n", + "\n", + "ax.set_xscale('log')\n", + "ax.set_yscale('log')\n", + "\n", + "ax.set_xlim(0.5,700)\n", + "ax.set_ylim(0.5,1200)\n", + "\n", + "ax.set_ylabel(\"count\")\n", + "ax.set_xlabel(\"la_exp value\")\n", + "\n", + "fig.colorbar(sct)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1069,6 +1346,57 @@ "\n", "(cccc['bin2_id']-cccc['bin1_id']).min()" ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'la_exp value')" + ] + }, + "execution_count": 73, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# also supplementary stuff to note\n", + "# about the previous point - how do we ended up having super small la_exp at small genomic separatrions ...\n", + "xlabel = 'la_exp.donut.value'\n", + "ylabel = 'count'\n", + "\n", + "plt.scatter(la_exp['bin2_id']-la_exp['bin1_id'],(la_exp[xlabel]))\n", + "# plt.scatter(dddd[xlabel],dddd[ylabel], s=80, facecolors='none', edgecolors='r')\n", + "# plt.scatter(eeee[xlabel],eeee[ylabel], s=80, facecolors='none', edgecolors='y')\n", + "\n", + "ax = plt.gca()\n", + "\n", + "ax.set_xlabel(\"genomic separation\")\n", + "ax.set_ylabel(\"la_exp value\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From b125e1c156666f79c3e41264e7ef511ffc417a60 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Tue, 9 Jul 2019 17:38:14 -0400 Subject: [PATCH 06/71] dot-calling notebook cleanup --- doc/examples/dot-calling-internals.ipynb | 337 ++++++++++++----------- 1 file changed, 178 insertions(+), 159 deletions(-) diff --git a/doc/examples/dot-calling-internals.ipynb b/doc/examples/dot-calling-internals.ipynb index d7f7c635..fb3d37f7 100644 --- a/doc/examples/dot-calling-internals.ipynb +++ b/doc/examples/dot-calling-internals.ipynb @@ -148,14 +148,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "Tokenization took: 46.16 ms\n", - "Type conversion took: 19.26 ms\n", + "Tokenization took: 46.27 ms\n", + "Type conversion took: 19.94 ms\n", "Parser memory cleanup took: 0.01 ms\n", - "Tokenization took: 31.21 ms\n", - "Type conversion took: 18.80 ms\n", + "Tokenization took: 31.56 ms\n", + "Type conversion took: 19.25 ms\n", "Parser memory cleanup took: 0.00 ms\n", - "Tokenization took: 9.84 ms\n", - "Type conversion took: 6.06 ms\n", + "Tokenization took: 9.59 ms\n", + "Type conversion took: 5.80 ms\n", "Parser memory cleanup took: 0.00 ms\n" ] } @@ -304,7 +304,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 72, "metadata": {}, "outputs": [ { @@ -317,17 +317,9 @@ ], "source": [ "w,p = dotfinder.recommend_kernel_params(binsize)\n", - "print(\"Kernel parameters w={} p={}\".format(w,p))" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "kernels = {k: dotfinder.get_kernel(w, p, k) for k in ktypes}\n", + "print(\"Kernel parameters w={} p={}\".format(w,p))\n", "\n", + "kernels = {k: dotfinder.get_kernel(w, p, k) for k in ktypes}\n", "# list of tile coordinate ranges\n", "tiles = list(\n", " dotfinder.heatmap_tiles_generator_diag(\n", @@ -342,7 +334,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 82, "metadata": {}, "outputs": [ { @@ -352,15 +344,15 @@ " Text(1, 0, 'Included in calculations')]" ] }, - "execution_count": 12, + "execution_count": 82, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAD/CAYAAAAJz1qSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAFWhJREFUeJzt3Xm0pHV95/H3R2xARJtBUJQJ4AkEY4iSgAtKiCgaEAIIJhgZJ4hmlMhoZmIyZlzS7kA8ydHAeEKigAQ5LpkmCIKsDYZFQGhAkMWlnaA4iuQ2ItBA850/nudCdVF3+d1bN32neb/OqVNVz/P8lue599SnnqV+T6oKSZJaPGl9d0CS9P8fw0OS1MzwkCQ1MzwkSc0MD0lSM8NDktRsgwuPJMuSVJIn/zu0tSLJioVuZ4Y+LEvyynmUn3EdkuzQb9O3zrWd9aXv97L13Q9pQ7PBhce/sz/uH+vTXwJzDg9JmosF/3a+IUqySVWtqaqb13dfNgRJAiypqgfXd18kzc6GvOfx3CRnJ7k3yQ+SfCDJOuubZOcky5NMJLk/yZVJ9h1aZvIw2C5JvpbkXuCL/bx1Dvn0y416rBpYZkmSjyRZleTB/vkjSZYMLDN5mOhtST6U5M6+j19J8h8H2+tfvnegrWX9vBcl+XKSO/p1uzXJx5I8ZRwbN8lWSb6R5NtJthuYfki/He/r+/ylwfn9MquS/GOSI5PcAjwI7D/b9R6o54+SXJ/kgSR3JflMki3HsX6Sprchh8dy4CLgYOAM4IPAH07OTPIc4F+AFwJHA78PTABnJ9lvRH3/DFwCHAj8zRRt7jH0OAS4H/j2wDKnAO8BPgccAJwE/I9++rC/AHYEjgTe1dd52lB7ACcPtPkP/bTtgJXA24F9gU/29Zw0Rd9nLckOwGVAAXtW1f/pp78d+CfgZuD1wNuAXYBLkjxtqJq9gf9O93fZF7hhYN5M602SY4D/BVxA9zf5s76ec5JsNN91lDSDqtqgHsAyug+1Nw9NvxE4b+D9J4CHgR0Hpm0E3ApcO6K+d41oawWwYop+PAW4CrgdeEY/bZe+rmVDy76vn/6C/v0O/ftLhpZ7dz/9OQPTCvjIDNskdIco/xPwyGR/ZlqHgWUm+/NWurD9EfBVYLOBZTYHVgOfHVH2QeBPBqatAu4DtpminWnXu19uLfCBoeVe3i938ND2WTbd+vnw4aP9sSHveZw99P5bdN/GJ+0FXFlV35mcUFVrgdOBXZM8faj88tk23B/DP4Xu2/P+VfWzgTYB/nGoyOT7355hHW7sn7djBkmenuTYJN8F1gAPAafSBclOM67EaHvR7X1dABxYVfcNzNsDeDpwWpInTz6AO4BbeGzdJ11ZVT+eop2Z1vvVdHvNw219A7hnRFuSxmxDPmF+99D7NcCmA++3BK4bUe7HdB+w/4Hug2jSnQ1tf4jucNlrquq2oTZH1fXjofmTRq0DrLseUzkJ2Af4AN3hq18ALwZOmGX5UV5Lt4fxd1X18NC8Z/bPF0xR9t+G3k+3PWda78m2vsNoz5imbkljsCGHx0zuBrYZMX0bukMdwx9gsxq7PskbgfcCR1bVihFtTrbx3aE2AX7GGCTZFDiI7nDNJwem//o8q34/8Bq68wr7VdVlA/Mm+34EcNOIsj8fej+fewFMtvUaHh9Kg/MlLZAncnhcAvxJkh2qahVAf6L1MOC6qhr+sJtRkj2AzwLHVNXJU7QJ8AbgowPTD++fL21tk+58wvAVVJvQnb95aGj6EXOof9BDdBcWnA6cm+S1VfX1ft7ldAGxY1WNOvk/TufTnbvZrqrOX+C2JI3wRA6Pv6H7MD0/yV/SHaL6Y+BXgP1bK+vPkZxBd3z/K0leOjB7TVVdV1U3JTkdWNYfo7+c7lzB+4HTq+qGx1U8s5vpLnM9l+5b+I+q6kdJrgT+NMmdwF10Vy5tO4f611FVDyV5A93VT+ck2b+qLqmqe5L8GXBCkq2Bc+hOoG9Ldy5nRVV9fr7t9334bpJjgeOT7EwXyg8Av0R3PuQfquricbQlabQnbHj0H7B7AscCn6b7tr6S7gT3uXOocku6Y/HPpAuFQT+gu0IIusuFv0f3Yf4+uiuXjqW7ZHUujgY+BXyFbh0+SHeF2B/QrdcJdJcLf5Hustez5tjOo6rq4f7w3KnAV5McUFUXV9XfJflXustm3wgsAX5It0e1cr7tDvXhfyb5NvCO/lHAvwIX0l3hJmkBpcrb0EqS2mzIl+pKkhaI4SFpSv1wPHMp94okTYdI+6GA3t1YZmT/kgwfOh6rhdwuSXZN8tqB9wcmec9c2ltIhoekDU5VvWx992EedqX7TRUAVXVmVR2zHvszkuEhaUb9N+YV/WCbtyQ5rR9JYXIQzsv7QSqvGh7HbHiPIsm3+vHRSPLeftDOC4CdB5b55STnJvlmkq8neV4//blJrkhydZIPT9Pfe2fq99DyOya5oF+Ha/v2N09yYf/+xiQHTdHWn/fzr+/HXJscNHX3/vVWGRgcdaDci/vtdl3/vHOSjel+ZHxYkpVJDktyRJLj+zLb9326oX/erp9+cpJP9fV8L8nr++nPTnJpX9e3kvzWVNusVdPVVpss2bSeuvHm42qbpVssHVtdAKsnVo+trsXcN7B/87GY+7b6vomH19bDS2Zecmq/86pfqp/d/cCslv3myrtuorvMedKJVXXiFIv/BvBrdFcIXga8PMlVwBeAw6rq6v6S9ftn03aS3eh+8/QbdJ9F1wLfnOwH8Paquj3JS+gGwXwl3QCfn66qzyV5x6xWckS/6QZFHXQa3e+zlvc/sn0S3W+oXtdfhr4VcGWSM2vgKqN0g6geDLykqu5L26jOtwB79Vcv7gN8rKoOTfIBYPeqOrpv44iBMscDn6uqU5IcSXel5cH9vGcDewLPA84Evkx31ePXquqj6X7HtllD/6bVFB5P3XhzXrNL808gprT/AQeMrS6As8+a91Woj1rMfQP7Nx+LuW9nXPXFNTMvNb2f3f0AV110yKyW3WjLEx+oqt1nWfVVVXUHQJKVdJefrwburKqrAarqnn7+bOr7LWD55BhpSc7snzcHXgZ8aaCeTfrnlwOH9q9PpbvMfS79fjQ8+j2lbatqeb8OD/TTlwAfS7IX3Y9StwWexWPDCUE3BNBJk+tQVcMjU0xnKXBKkp3oLjWfzZeGydG6oVv/4wbmnVFVjwA3J3lWP+1q4LP9upxRVWO7ZN7DVpJmazDY1tJ9+QwzDzXzMOt+1gyOrTaq7JOAiaradeDxqzOUmc6ofg+aKukOB7YGdquqXYH/y+PHhZtq/QfXeaqx5D4MXFxVuwC/O81y0xlse3A9A1BVl9INFPpD4NQk/3kObYxkeEiaj1uA5yR5EXTf4tONnjBoFfCb/fzfBJ7bT78UeF2Sp/Tf/n8XHt17+X6S3+vLJMkL+zKX0R3qgseG9ZmXvr07khzct7dJks3o9gx+0o+qsDew/Yji5wFH9sszcNhqFbBb//r1UzS9lO5DHdYdOujnwPD9byZdzrrrP3z4bR1Jtu/X4e+Bz9D/HcbB8JA0Z9XdOvgw4G+TXE837tjwN+h/ArbsDxkdBdzWl72W7nzJyn6Zrw+UORx4S1/nTXQDfUI3SsI7klxN9+E7Lm8C3pnkBroP6G3ozoPsnuSavj+3DBfqR6M4E7imX7/JCwM+ARyV7pLhraZo8zjg40kuoxuLbtLFwPMnT5gPlXkn8Oa+n2+i2x7TeQWwMsl1dIf7Pjn94rP3hB2eRNLMqmrz/nkF3Y3DJqcfPfD6auClQ0UfXb6q7qcbAXlU/R9l3UFCJ6d/n+7OkKOm7zEwaeQlrLPp99Dyt9OdkB+2x4hpj9bfvz5muB9VdQvwgoFJ7xvuT1VdQTeW3qT399PvBl401OTJ/bxVo/pZVUeM6l8/SOmCDFTqnockqZnhIUlqZnhIkpoZHpKkZoaHJKmZ4SFJamZ4SJKaGR6SpGaGhySpmeEhSWpmeEiSmhkekqRmhockqZnhIUlq1jQk+9Itlo71Fp6L+dani7lvYP/mYzH3bcVt542tLmkhuechSWpmeEiSmhkekqRmhockqZnhIUlqZnhIkpoZHpKkZoaHJKmZ4SFJamZ4SJKaGR6SpGaGhySpmeEhSWpmeEiSmhkekqRmhockqZnhIUlqZnhIkpoZHpKkZk33MF89sXqs939ezPfNXsx9A/s3H4u5bxMTE2OrS1pI7nlIkpoZHpKkZoaHJKmZ4SFJamZ4SJKaGR6SpGaGhySpmeEhSWpmeEiSmhkekqRmhockqZnhIUlqZnhIkpoZHpKkZoaHJKmZ4SFJamZ4SJKaGR6SpGZNt6FdusXSsd7CczHf+nQx9w3s33ws5r6tuO28sdUlLST3PCRJzQwPSVIzw0OS1MzwkCQ1MzwkSc0MD0lSM8NDktTM8JAkNTM8JEnNDA9JUjPDQ5LUzPCQJDUzPCRJzQwPSVIzw0OS1MzwkCQ1MzwkSc0MD0lSM8NDktSs6R7mG21yF0t3+szYGv/8heO9b/ZZZ42vb/sf8Jax1QWL+77ZsPj790T5v9tok5+OrS5pIbnnIUlqZnhIkpoZHpKkZoaHJKmZ4SFJamZ4SJKaGR6SpGaGhySpmeEhSWpmeEiSmhkekqRmhockqZnhIUlqZnhIkpoZHpKkZoaHJKmZ4SFJamZ4SJKaGR6SpGZN9zDfYoulHDDGe1OfNeb7Zo+zb2981eK+p/div+f4uPs3zvuOL+b/u7/44DVjq0taSO55SJKaGR6SpGaGhySpmeEhSWpmeEiSmhkekqRmhockqZnhIUlqZnhIkpo1/cJc0uL3wC/WcOtV31nf3dAGzvCQNjB3/+TpfP6EV89y6YsWtC/acHnYSpLUzPCQJDUzPCRJzQwPSVIzw0OS1MzwkCQ1MzwkSc0MD0lSs6YfCU5MrB7r/Z/Hee9nGO+9qfc/4C1jqwueePccH3f/zjrrM2OrazH/303828TY6pIWknsekqRmhockqZnhIUlqZnhIkpoZHpKkZoaHJKmZ4SFJamZ4SJKaGR6SpGaGhySpmeEhSWpmeEiSmhkekqRmhockqZnhIUlqZnhIkpoZHpKkZoaHJKmZ4SFJatZ0D/O1a7Zi9e3ju7f3G1817vtmj69vi/2e3k+8/j0x/u/Wrrl+bHVJC8k9D0lSM8NDktTM8JAkNTM8JEnNDA9JUjPDQ5LUzPCQJDUzPCRJzQwPSVIzw0OS1MzwkCQ1MzwkSc0MD0lSM8NDktTM8JAkNTM8JEnNDA9JUjPDQ5LUzPCQJDVruof56onVY7039WK+b/Zi7hvYv/lYzH2bmJgYW13SQnLPQ5LUzPCQJDUzPCRJzQwPSVIzw0OS1MzwkCQ1MzwkSc0MD0lSM8NDktTM8JAkNTM8JEnNDA9JUjPDQ5LUzPCQJDUzPCRJzQwPSVIzw0OS1MzwkCQ1a7oN7dItlo71Fp6L+dani7lvYP/mYzH3bcVt542tLmkhuechSWpmeEiSmhkekqRmhockqZnhIUlqZnhIkpoZHpKkZoaHJKmZ4SFJamZ4SJKaGR6SpGaGhySpmeEhSWpmeEiSmhkekqRmhockqZnhIUlqZnhIkpoZHpKkZk33MF89sXqs939ezPfNXsx9A/s3H4u5bxMTE2OrS1pI7nlIkpoZHpKkZoaHJKmZ4SFJamZ4SJKaGR6SpGaGhySpmeEhSWpmeEiSmhkekqRmhockqZnhIUlqZnhIkpoZHpKkZoaHJKmZ4SFJamZ4SJpSkrVJVg483jOHOo5IcnxjmZOTvL5h+R2SfGuKeX+V5KYkf9XSh4WW5N45lntFkmnvQJZk1ySvHXh/4Fz+dtNpupOgpCec+6tq1/XdiXl6G7B1Va0ZnJjkyVX18Hrq00LbFdgd+CpAVZ0JnDnOBtzzkNQkydIktybZuX9/epI/6l/vm+TaJNcnuXBE2XX2KCa/fadzfJKbk5wNPHNgmd2SXJLkm0m+luTZA9OvT3IF8I4p+nom8FTgG0kO69v/6yQXA8cm2TLJGUluSHJlkhf05ZYlOSXJeUlWJTkkyXFJbkxybpIlI9raMckFfZ+uTfLLSTZPcmH//sYkB03Rzz/v51+f5Jh+2ooku/evt0qyakS5Fye5PMl1/fPOSTYGPgQc1u8tHja495dk+75PN/TP2w38bT7V1/O9mfb8UlXTzR/u6E+BH8y6gKRW21fV1vOpIMm5wFazXHxT4IGB9ydW1YkDda0FbhyY//Gq+kKSV9N9QH0SOKKq9k2yNXAtsFdVfT/JllV1d5IjgN2r6ugkJwNnVdWX+/rvrarNkxwCHAXsCzwLuBl4K/DPwCXAQVX10ySHAb9TVUcmuQH4r1V1SX9Iar+q2mXE9ri3qjbvX5/cb5uDqmptkr8F7qqqDyZ5JfDXVbVrkmXAPsDewPOBK4BDq+qcJMuBU6rqjKF2vgEcU1XLk2xK9+X8QWCzqronyVbAlcBOVVUD674f8H5gn6q6b2C7rQDeXVXX9GWvqaodkryin35AkqcD91XVw0n2AY6qqkMHt3nft8G/wVeAL1fVKUmOBA6sqoP7bfNU4DDgecCZVbXj8Pac1HTYar7/1JIWXlXtO8bqRh62qqrzk/wecALwwn7yS4FLq+r7/TJ3N7SzF3B6Va0FfpTkon76zsAuwPlJADYC7kyyFNiiqi7plzsV2G+WbX2pbwdgT+DQvr8XJXlGXzfAOVX1UJIb+3bP7affCOwwWGGSpwHbVtXyvq4H+ulLgI8l2Qt4BNiWLhx/PFB8H+CkqrqvL9uy3ZYCpyTZCSjgcXtEI+wBHNK/PhU4bmDeGVX1CHBzkmdNV4nnPCQ1S/Ik4FeB+4EtgTuA0H2ATedh+sPl6dJg44F5o8oGuKmq9hhqf4tZtDWVXwzVP2yy3jUAVfVIkofqscM0j/D4z85R9QAcDmwN7NYH0Sq6vb3hsqPW5dFtNaLMpA8DF1fV65LsAKyYYrnpDLY9eF5oqnUCPOchaW7+G/Bt4A+Az/bfsK8AfjvJcwGSbDmi3Cpgt/71QTz2TflS4A1JNurPaezdT78V2DrJHn2dS5L8WlVNAKuT7Nkvd/gc1+PSybL94aC7quqe1kr6MnckObiva5Mkm9HtGfykD469ge1HFD8POLJffnC7reKxbTXV+YelwA/710cMTP858LQpylwOvKF/fTjwL1Ov2dQMD0nTeUrWvVT3mCS/Qnc+4k+r6ut0H8Dvq6qfAv8F+N9Jrge+MKK+v6cLmKuAl/DYXsBy4Ha6Q0KfpjvPQVU9SPfBeWxf50rgZX2ZNwMnpDthfv8c128ZsHt//uQY4A/nWA/Am4B39nVdDmwDnNbXfw3dB/Utw4Wq6ly6K6GuSbISeHc/6xPAUUkuZ+pzWMcBH09yGd2htUkXA8+fPGE+VOadwJv7fr4JeFf7qjaeMJckCdzzkCTNgeEhSWpmeEiSmhkekqRmhockqZnhIUlqZnhIkpr9Pwq28fs1/9J3AAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -373,49 +365,60 @@ "# it is important to demonstrate filters here \n", "# consider moving plotting code elsewhere or simplify it significantly ...\n", "# split cell above and demonstrate kernels - it's nice:\n", - "\n", - "ktype='horizontal'\n", - "kernel= kernels[ktype]\n", - "y,x = np.ogrid[-w:w+1, -w:w+1]\n", - "\n", - "extent = (0-0.5,\n", - " x.size-0.5,\n", - " 0-0.5,\n", - " y.size-0.5)\n", - "########################\n", - "plt.clf()\n", - "# axes setup\n", - "ax = plt.gca()\n", - "# discrete colormap with 2 colors ...\n", - "cmap = colors.ListedColormap([plt.cm.viridis(0),\n", - " plt.cm.viridis(1.0)])\n", - "# kernel:\n", - "imk = ax.imshow(kernel,\n", - " alpha=0.7,\n", - " cmap=cmap,\n", - " extent=extent,\n", - " interpolation='nearest')\n", - "ax.set_xticks([])\n", - "ax.set_yticks([])\n", - "ax.set_xticklabels('',visible=False)\n", - "ax.set_yticklabels('',visible=False)\n", - "ax.set_title(\"{} kernel\".format(ktype),fontsize=16)\n", - "\n", - "# add checkerboard to depict pixels:\n", - "checkerboard = np.add.outer(range(x.size),\n", - " range(y.size)) % 2\n", - "ax.imshow(checkerboard,\n", - " cmap=plt.cm.gray,\n", - " interpolation='nearest',\n", - " extent=extent,\n", - " alpha=0.3)\n", - "#####################\n", + "def draw_kernel(kernel,\n", + " axis,\n", + " cmap='viridis'):\n", + " # kernel:\n", + " imk = axis.imshow(\n", + " kernel[::-1,::-1],\n", + " alpha=0.7,\n", + " cmap=cmap,\n", + " interpolation='nearest')\n", + " # clean axis:\n", + " axis.set_xticks([])\n", + " axis.set_yticks([])\n", + " axis.set_xticklabels('',visible=False)\n", + " axis.set_yticklabels('',visible=False)\n", + " axis.set_title(\"{} kernel\".format(ktype),fontsize=16)\n", + " # add a checkerboard to highlight pixels:\n", + " checkerboard = np.add.outer(range(kernel.shape[0]),\n", + " range(kernel.shape[1])) % 2\n", + " # show it:\n", + " axis.imshow(checkerboard,\n", + " cmap='gray',\n", + " interpolation='nearest',\n", + " alpha=0.3)\n", + " #\n", + " return imk\n", + "\n", + "fig = plt.figure(figsize=(12,2.5))\n", + "gs = plt.GridSpec(nrows=1,\n", + " ncols=5,\n", + " figure=fig,\n", + " width_ratios=[1,1,1,1,0.1])\n", + "\n", + "for i,ktype in enumerate(ktypes):\n", + " kernel= kernels[ktype]\n", + " ax = plt.subplot(gs[i])\n", + " draw_kernel(kernel,ax)\n", + " \n", "# colorbar and that's it:\n", - "cb = plt.colorbar(imk)\n", + "ax = plt.subplot(gs[i+1])\n", + "cb = fig.colorbar(imk, cax=ax)\n", "cb.ax.get_yaxis().set_major_locator(ticker.MaxNLocator(1))\n", "cb.ax.set_yticklabels(['Excluded from calculation','Included in calculations'])" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "a little remark on the `lowleft` kernel:\n", + " - by the definition of convolution, it implies integrating f(x)*g(-x) ...\n", + " - in other words the kernel is being \"flipped\" when it is applied to a matrix\n", + " - we should try to make it explicit or hide it away on a better way" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -470,7 +473,7 @@ }, { "cell_type": "code", - "execution_count": 95, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -516,77 +519,28 @@ "\n", " - here we use `cooler`-based `bin1/2_id` instead of actual genomic coordinates for compactness and performance reasons.\n", " - Observed is recorded in the `count` columns, again as in the parent `cooler`-file.\n", - " - observer and all types of expected are expressed in the raw units in order to apply Poisson statistics to the data\n", - "\n", - "\n", - "### Now let's load in, some known called/annotated dots to see where they end up on the obs/exp scatter-plot" - ] - }, - { - "cell_type": "code", - "execution_count": 96, - "metadata": {}, - "outputs": [], - "source": [ - "# let us read in some of the known dots to display stronger ones on the obs/exp scatter plot:\n", - "raodots = pd.read_csv(RAOLOOPS,sep='\\t')\n", - "# beware of the UCSC/NCBI chromosome naming conventions `X` vs `chrX` ...\n", - "raodots_chr1 = raodots[raodots['chr1']=='1']\n", - "\n", - "# do we need a notion of strength here ?\n", - "# #let's quickly define some measure of strengths for the dots:\n", - "# raodots_chr1['strength'] = raodots_chr1['o']/raodots_chr1['e_donut']\n", - "# # now sort and select only the strongest (according to this measure):\n", - "# raodots_chr1_strong = raodots_chr1.sort_values(by=['o','strength'],ascending=False)\n", - "\n", - "# let's convert genomic coordinates into `cooler`-based bin_id-s:\n", - "bin1_ids = (raodots_chr1['x1']/binsize).astype('int')\n", - "bin2_ids = (raodots_chr1['y1']/binsize).astype('int')\n", - "# beware Rao et al, use x1,x2 for start1,end1 and y1,y2 for start2,end2\n", - "\n", - "# now let's look up these called/annotated dots in our pre-calculated la_exp dataframe:\n", - "rao_dots_idxs = list(zip(bin1_ids,bin2_ids))\n", - "la_exp_indexed = la_exp.set_index(['bin1_id','bin2_id'])\n", - "\n", - "# these are the rao-dots that we have caculated locally adjusted expected for:\n", - "intersect_raodots = la_exp_indexed[la_exp_indexed.index.isin(rao_dots_idxs)]\n", - "# we don't have for every rao-dot since we don't get close enough to diagonal and\n", - "# potentially treat NaNs differently." + " - observer and all types of expected are expressed in the raw units in order to apply Poisson statistics to the data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### obs/exp scatter\n", + "### Scatter plot of observed vs expected\n", "\n", - " - let's plot a scatter of obs/exp for a subsample of surveyed pixels\n", - " - highlight called rao-dots on this scatter plot\n", - " - we need subsampling because there are a LOT of pixels" + "A scatter plot with observed vs expected should be a good \"platform\" for understanding what a dot-calling is:" ] }, { "cell_type": "code", - "execution_count": 97, - "metadata": { - "scrolled": true - }, + "execution_count": 93, + "metadata": {}, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" - ] - }, - "execution_count": 97, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -596,44 +550,113 @@ } ], "source": [ - "xlabel = 'la_exp.donut.value'\n", - "ylabel = 'count'\n", + "def quick_obs_exp_scatter(data,\n", + " axis,\n", + " xlabel='la_exp.donut.value',\n", + " ylabel='count'):\n", + " # obs exp\n", + " # the base scatter:\n", + " sct = axis.scatter(data[xlabel],\n", + " data[ylabel],\n", + " # color dots on the scatter by their genomic separation\n", + " c=data['bin2_id']-data['bin1_id'],\n", + " vmin=0,\n", + " vmax = 100,\n", + " cmap=\"YlOrRd_r\")\n", + " # we can add a visual of the lambda-chunking grid on top of obs/exp scatter ...\n", + " # plt.vlines(ledges[1:-15],ymin=0.5,ymax=900,color='red')\n", + " axis.set_xscale('log')\n", + " axis.set_yscale('log')\n", + " # limits\n", + " axis.set_xlim(0.5,700)\n", + " axis.set_ylim(0.5,1200)\n", + " # labels\n", + " axis.set_ylabel(ylabel)\n", + " axis.set_xlabel(xlabel)\n", + " # return axes\n", + " return sct\n", + "\n", + "\n", + "\n", + "fig = plt.figure(figsize=(7,5))\n", + "gs = plt.GridSpec(nrows=1,\n", + " ncols=2,\n", + " figure=fig,\n", + " width_ratios=[1,0.1])\n", "\n", "# we might consider \"downsampling\" la_exp dataframe in order to make obs/exp scatter plot less busy:\n", - "sub_la_exp = la_exp.sample(frac=0.1)\n", - "\n", - "sct = plt.scatter(sub_la_exp[xlabel],\n", - " sub_la_exp[ylabel],\n", - " # color dots on the scatter by their genomic separation\n", - " c=sub_la_exp['bin2_id']-sub_la_exp['bin1_id'],\n", - " vmin=0,\n", - " vmax = 100,\n", - " cmap=\"YlOrRd_r\")\n", + "data = la_exp.sample(frac=0.1)\n", + "ax = plt.subplot(gs[0])\n", + "sct = quick_obs_exp_scatter(data,ax)\n", "\n", "\n", + "# y=x line to highlight the \"enriched\" pixels ...\n", + "ax.plot(ax.get_xlim(),ax.get_ylim(),'b-',label='obs=exp')\n", + "ax.legend(loc='best')\n", "\n", - "plt.scatter(intersect_raodots[xlabel],\n", - " intersect_raodots[ylabel],\n", - " s=80,\n", - " facecolors='none',\n", - " edgecolors='b')\n", - "\n", - "# we can add a visual of the lambda-chunking grid on top of obs/exp scatter ...\n", - "# plt.vlines(ledges[1:-15],ymin=0.5,ymax=900,color='red')\n", + "# cbar\n", + "cb = plt.colorbar(sct,cax=plt.subplot(gs[1]))\n", + "cb.ax.get_yaxis().set_major_locator(ticker.MaxNLocator(1))\n", + "# cb.ax.set_yticklabels(['Excluded from calculation','Included in calculations'])\n", + "\n", + "# enriched = data[data[ylabel]/data[xlabel]>1]\n", + "# ax.scatter(enriched[xlabel],\n", + "# enriched[ylabel],\n", + "# s=80,\n", + "# facecolors='none',\n", + "# edgecolors='b')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Obs vs exp scatter plot highlights the enriched pixels:\n", + " - pixels that are above the blue line `obs=exp` are all \"enriched\", i.e. for all of them `obs` is more than `exp`.\n", + " - Problem is, such a naive way of extracting enriched interactions yields too many false positives\n", + " - should we show a heatmap of all of such \"enriched\" pixels - to demonstrate that it's not so good ?!\n", + " - we need to do more rigorous statistical analysis to extract \"significantly\" enriched pixels instead." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now let's load in, some known called/annotated dots to see where they end up on the obs/exp scatter-plot\n", "\n", - "ax = plt.gca()\n", - "fig = plt.gcf()\n", + "we would use this pre-called dots to see them on our obs/exp scatter plot, later" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# let us read in some of the known dots to display stronger ones on the obs/exp scatter plot:\n", + "raodots = pd.read_csv(RAOLOOPS,sep='\\t')\n", + "# beware of the UCSC/NCBI chromosome naming conventions `X` vs `chrX` ...\n", + "raodots_chr1 = raodots[raodots['chr1']=='1']\n", "\n", - "ax.set_xscale('log')\n", - "ax.set_yscale('log')\n", + "# do we need a notion of strength here ?\n", + "# #let's quickly define some measure of strengths for the dots:\n", + "# raodots_chr1['strength'] = raodots_chr1['o']/raodots_chr1['e_donut']\n", + "# # now sort and select only the strongest (according to this measure):\n", + "# raodots_chr1_strong = raodots_chr1.sort_values(by=['o','strength'],ascending=False)\n", "\n", - "ax.set_xlim(0.5,700)\n", - "ax.set_ylim(0.5,1200)\n", + "# let's convert genomic coordinates into `cooler`-based bin_id-s:\n", + "bin1_ids = (raodots_chr1['x1']/binsize).astype('int')\n", + "bin2_ids = (raodots_chr1['y1']/binsize).astype('int')\n", + "# beware Rao et al, use x1,x2 for start1,end1 and y1,y2 for start2,end2\n", "\n", - "ax.set_ylabel(\"count\")\n", - "ax.set_xlabel(\"la_exp value\")\n", + "# now let's look up these called/annotated dots in our pre-calculated la_exp dataframe:\n", + "rao_dots_idxs = list(zip(bin1_ids,bin2_ids))\n", + "la_exp_indexed = la_exp.set_index(['bin1_id','bin2_id'])\n", "\n", - "fig.colorbar(sct)" + "# these are the rao-dots that we have caculated locally adjusted expected for:\n", + "intersect_raodots = la_exp_indexed[la_exp_indexed.index.isin(rao_dots_idxs)]\n", + "# we don't have for every rao-dot since we don't get close enough to diagonal and\n", + "# potentially treat NaNs differently." ] }, { @@ -642,35 +665,31 @@ "source": [ "# starting from here it requires more cleaning/trimming down ...\n", "\n", - "### we can do some quick and educational statistics here\n", + "### Extracting statistically significant interactions\n", "\n", - "*Null hypothesis*: intensity of a HiC pixel is Poisson-distributed with a certain expected. In the case of dot-calling procedure, that would be *locally-adjusted expected*.\n", + "So how could one extract significantly enriched interactions instead of calling every marginally brighter pixel \"enriched\" ?\n", "\n", - "Thus for the dot-calling, we could estimate a p-value for each of the pixel's intensities (for all of the kernel-types):\n", + "We have our *null* hypothesis: intensity of a HiC pixel is Poisson-distributed with a certain expected. In this case that would be *locally-adjusted expected*.\n", "\n", - "```\n", - "p =1-Poisson.cdf(obs,exp)\n", - "```" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ + "Thus for the dot-calling, we could estimate a *p*-value for every pixel based on its observed intensity and its expected intensity:\n", + "```python\n", "from scipy.stats import poisson\n", "\n", "for k in ktypes:\n", " la_exp[\"la_exp.\"+k+\".pval\"] = 1.0 - \\\n", " poisson.cdf(la_exp[\"count\"],\n", - " la_exp[\"la_exp.\"+k+\".value\"])\n" + " la_exp[\"la_exp.\"+k+\".value\"])\n", + "```\n", + "\n", + "However going that route would be technically challenging for the further genome-wide calculations, so we can introduce the *lambda*-chunking procedure introduced in Rao et al 2014 to tackle technicall challenges and some issues associated with the wide dynamic range of the expected for the dot-calling (due to distance decay)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ + "# should we keep in some form or go straight to Rao procedure ?!\n", + "\n", "### now let's select pixels that are \"significantly\" brighter than their surroundings ...\n", "\n", "Just use *naive* p-value thresholding for simplicity and quick turn around.\n", From ea21dba0dfd799eed8f08a68cd4788a1652a235a Mon Sep 17 00:00:00 2001 From: Nezar Date: Thu, 14 Nov 2019 17:00:19 -0500 Subject: [PATCH 07/71] Remove deprecated functions --- cooltools/expected.py | 236 ++---------------------------------------- 1 file changed, 6 insertions(+), 230 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index 6cfb059f..b3234e58 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -4,7 +4,6 @@ import numpy as np import pandas as pd -from scipy.linalg import toeplitz from scipy.signal import fftconvolve from cooler.tools import split, partition @@ -281,231 +280,6 @@ def _make_diag_table(n_bins, bad_locs): return diags.astype(int) -def _sum_diagonals(df, field): - reduced = df.groupby('diag')[field].sum() - reduced.name = field + '.sum' - return reduced - - -def cis_expected(clr, regions, field='balanced', chunksize=1000000, - use_dask=True, ignore_diags=2): - """ - Compute the mean signal along diagonals of one or more regional blocks of - intra-chromosomal contact matrices. Typically used as a background model - for contact frequencies on the same polymer chain. - - Parameters - ---------- - clr : cooler.Cooler - Input Cooler - regions : iterable of genomic regions or pairs of regions - Iterable of genomic region strings or 3-tuples, or 5-tuples for pairs - of regions - field : str, optional - Which values of the contact matrix to aggregate. This is currently a - no-op. *FIXME* - chunksize : int, optional - Size of dask chunks. - - Returns - ------- - Dataframe of diagonal statistics, indexed by region and diagonal number - - """ - import dask.dataframe as dd - from cooler.sandbox.dask import read_table - - if use_dask: - pixels = read_table(clr.uri + '/pixels', chunksize=chunksize) - else: - pixels = clr.pixels()[:] - pixels = cooler.annotate(pixels, clr.bins(), replace=False) - pixels = pixels[pixels.chrom1 == pixels.chrom2] - - named_regions = False - if isinstance(regions, pd.DataFrame): - named_regions = True - chroms = regions['chrom'].values - names = regions['name'].values - regions = regions[['chrom', 'start', 'end']].to_records(index=False) - else: - chroms = [region[0] for region in regions] - names = chroms - cis_maps = {chrom: pixels[pixels.chrom1 == chrom] for chrom in chroms} - - diag_tables = [] - data_sums = [] - - for region in regions: - if len(region) == 1: - chrom, = region - start1, end1 = 0, clr.chromsizes[chrom] - start2, end2 = start1, end1 - elif len(region) == 3: - chrom, start1, end1 = region - start2, end2 = start1, end1 - elif len(region) == 5: - chrom, start1, end1, start2, end2 = region - else: - raise ValueError("Regions must be sequences of length 1, 3 or 5") - - bins = clr.bins().fetch(chrom).reset_index(drop=True) - bad_mask = np.array(bins['weight'].isnull()) - lo1, hi1 = clr.extent((chrom, start1, end1)) - lo2, hi2 = clr.extent((chrom, start2, end2)) - co = clr.offset(chrom) - lo1 -= co - lo2 -= co - hi1 -= co - hi2 -= co - - dt = make_diag_table(bad_mask, [lo1, hi1], [lo2, hi2]) - sel = bg2slice_frame( - cis_maps[chrom], - (chrom, start1, end1), - (chrom, start2, end2) - ).copy() - sel['diag'] = sel['bin2_id'] - sel['bin1_id'] - sel['balanced'] = sel['count'] * sel['weight1'] * sel['weight2'] - agg = _sum_diagonals(sel, field) - diag_tables.append(dt) - data_sums.append(agg) - - # run dask scheduler - if len(data_sums) and isinstance(data_sums[0], dd.Series): - data_sums = dd.compute(*data_sums) - - # append to tables - for dt, agg in zip(diag_tables, data_sums): - dt[agg.name] = 0 - dt[agg.name] = dt[agg.name].add(agg, fill_value=0) - dt.iloc[:ignore_diags, dt.columns.get_loc(agg.name)] = np.nan - - # merge and return - if named_regions: - dtable = pd.concat( - diag_tables, - keys=zip(names, chroms), - names=['name', 'chrom']) - else: - dtable = pd.concat( - diag_tables, - keys=list(chroms), - names=['chrom']) - - # the actual expected is balanced.sum/n_valid: - dtable['balanced.avg'] = dtable['balanced.sum'] / dtable['n_valid'] - return dtable - - -def trans_expected(clr, chromosomes, chunksize=1000000, use_dask=False): - """ - Aggregate the signal in intrachromosomal blocks. - Can be used as abackground for contact frequencies between chromosomes. - - Parameters - ---------- - clr : cooler.Cooler - Cooler object - chromosomes : list of str - List of chromosome names - chunksize : int, optional - Size of dask chunks - use_dask : bool, optional - option to use dask - - Returns - ------- - pandas.DataFrame that stores total number of - interactions between a pair of chromosomes: 'balanced.sum', - corresponding number of bins involved - in the inter-chromosomal interactions: 'n_valid', - and a ratio 'balanced.avg = balanced.sum/n_valid', that is - the actual value of expected for every interchromosomal pair. - - """ - def n_total_trans_elements(clr, chromosomes): - n = len(chromosomes) - x = [clr.extent(chrom)[1] - clr.extent(chrom)[0] - for chrom in chromosomes] - pairblock_list = [] - for i in range(n): - for j in range(i + 1, n): - # appending to the list of tuples - pairblock_list.append((chromosomes[i], - chromosomes[j], - x[i] * x[j])) - return pd.DataFrame(pairblock_list, - columns=['chrom1', 'chrom2', 'n_total']) - - def n_bad_trans_elements(clr, chromosomes): - n = 0 - # bad bins are ones with - # the weight vector being NaN: - x = [np.sum(clr.bins()['weight'] - .fetch(chrom) - .isnull() - .astype(int) - .values) - for chrom in chromosomes] - pairblock_list = [] - for i in range(len(x)): - for j in range(i + 1, len(x)): - # appending to the list of tuples - pairblock_list.append((chromosomes[i], - chromosomes[j], - x[i] * x[j])) - return pd.DataFrame(pairblock_list, - columns=['chrom1', 'chrom2', 'n_bad']) - - if use_dask: - # pixels = daskify(clr.filename, clr.root + '/pixels', chunksize=chunksize) - raise NotImplementedError( - "To be implemented once dask supports MultiIndex") - else: - pixels = clr.pixels()[:] - # getting pixels that belong to trans-area, - # defined by the list of chromosomes: - pixels = cooler.annotate(pixels, clr.bins(), replace=False) - pixels = pixels[ - (pixels.chrom1.isin(chromosomes)) & - (pixels.chrom2.isin(chromosomes)) & - (pixels.chrom1 != pixels.chrom2) - ] - pixels['balanced'] = pixels['count'] * \ - pixels['weight1'] * pixels['weight2'] - ntot = n_total_trans_elements(clr, chromosomes).groupby( - ('chrom1', 'chrom2'))['n_total'].sum() - nbad = n_bad_trans_elements(clr, chromosomes).groupby( - ('chrom1', 'chrom2'))['n_bad'].sum() - trans_area = ntot - nbad - trans_area.name = 'n_valid' - # processing with use_dask=True is different: - if use_dask: - # trans_sum = pixels.groupby(['chrom1', 'chrom2'])['balanced'].sum().compute() - pass - else: - trans_sum = pixels.groupby(['chrom1', 'chrom2'])['balanced'].sum() - # for consistency with the cis_expected function: - trans_sum.name = trans_sum.name + '.sum' - - # returning a DataFrame with MultiIndex, that stores - # pairs of 'balanced.sum' and 'n_valid' values for each - # pair of chromosomes. - dtable = pd.merge( - trans_sum.to_frame(), - trans_area.to_frame(), - left_index=True, - right_index=True) - - # the actual expected is balanced.sum/n_valid: - dtable['balanced.avg'] = dtable['balanced.sum'] / dtable['n_valid'] - return dtable - - -################### - - def make_diag_tables(clr, supports): bins = clr.bins()[:] @@ -518,7 +292,6 @@ def make_diag_tables(clr, supports): bad_bin_dict = {chrom: np.zeros(sizes[chrom], dtype=bool) for chrom in sizes.keys()} - where = np.flatnonzero diag_tables = {} for region in supports: if isinstance(region, str): @@ -573,7 +346,8 @@ def _diagsum_symm(clr, fields, transforms, supports, span): } -def _diagsum_asymm(clr, fields, transforms, contact_type, supports1, supports2, span): +def _diagsum_asymm(clr, fields, transforms, contact_type, supports1, supports2, + span): lo, hi = span bins = clr.bins()[:] pixels = clr.pixels()[lo:hi] @@ -673,7 +447,8 @@ def diagsum(clr, supports, transforms=None, chunksize=10000000, ignore_diags=2, def diagsum_asymm(clr, supports1, supports2, contact_type='cis', - transforms=None, chunksize=10000000, ignore_diags=2, map=map): + transforms=None, chunksize=10000000, ignore_diags=2, + map=map): """ Intra-chromosomal diagonal summary statistics. @@ -733,7 +508,8 @@ def diagsum_asymm(clr, supports1, supports2, contact_type='cis', return dtables -def blocksum_pairwise(clr, supports, transforms=None, chunksize=1000000, map=map): +def blocksum_pairwise(clr, supports, transforms=None, chunksize=1000000, + map=map): """ Summary statistics on inter-chromosomal rectangular blocks. From e39c7c1586f45d6f1ece419433bfc5a34828e43d Mon Sep 17 00:00:00 2001 From: mimakaev Date: Fri, 31 Jan 2020 16:39:31 -0500 Subject: [PATCH 08/71] added logbin_expected --- cooltools/expected.py | 242 ++++++++++++++++++++++++++++++++++++++ cooltools/lib/numutils.py | 108 +++++++++++++++++ 2 files changed, 350 insertions(+) diff --git a/cooltools/expected.py b/cooltools/expected.py index 0f42be7a..b30caee1 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -950,3 +950,245 @@ def blocksum_pairwise( records[supports1[i], supports2[j]][agg_name] += s return records + + +def logbin_expected(exp, ratio=1.2, + spread_funcs="logstd", + spread_funcs_slope = "std", + minmax_drop_bins=2, + der_smooth_function_by_reg = lambda x:numutils.robust_gauss_filter(x,2), + der_smooth_function_combined = lambda x:numutils.robust_gauss_filter(x,1.3), + mid_nvalid = 200, + min_count = 50, + ): + """ + Logarithmically bins expected as produced by diagsum method + See description below + + Parameters + ---------- + + exp: dict + {region:expected_df} produced by diagsum + + ratio: float >1 (optional) + ratio of neighboring bins for binning expected + + spread_funcs: "minmax", "std", "logstd" or a function (see below) + A way to estimate the spread of the P(s) curves between regions. + * "minmax" - use the minimum/maximum of by-region P(s) + * "std" - use weighted standard deviation of P(s) curves (may produce negative results) + * "logstd" (recommended) weighted standard deviation in logspace (as seen on the plot) + + spread_funcs_slope: "minmax", "std" or a funciton + Similar to spread_func, but for slopes rather than P(s) + + der_smooth_function_by_reg: callable + A smoothing function to be applied to log(P(s)) and log(x) + before calculating P(s) slopes for by-region data + + der_smooth_function_combined: callable + A smoothing function for calculating slopes on combined data + + min_nvalid: int + For each region, throw out bins (log-spaced) that have less than min_nvalid valid pixels + This will ensure that each entree in Pc_by_region has at least n_valid valid pixels + Don't set it to zero, or it will introduce bugs. Setting it to 1 is OK, but not recommended. + + min_count: int + If counts are found in the data, then for each region, throw out bins (log-spaced) + that have more than min_counts of counts.sum (raw Hi-C counts). + This will ensure that each entree in Pc_by_region has at least min_count raw Hi-C reads + + + Returns + ------- + + dict with dataframes with the following keys + * "Pc": dataframe of contact probabilities and spread across regions + * "slope": slope of Pc(s) on a log-log plot and spread across regions + * "Pc_by_region": a dataframe of Pc(s) for each region. + * "slope_by_region": a dataframe of slopes for each region + + + Description + ----------- + + For main Pc and slope, the algorithm is the following + + 1. concatenate all the expected for all regions into a large dataframe. + 2. find the furthest diagonal with n_valid>0 + 3. create logarithmically-spaced buckets of diagonals that end at the furthest diagonal + 4. pool together n_valid and balanced.sum for diagonals in each bin + 5. calculate the average diagonal for each bucket, weighted by n_valid + 6. divide balanced.sum by n_valid after summing for each bucket (not before) + 7. calculate the slope in log space. + + NOTE: that it creates x values that are not necessarily centered at the center of the bin + This is especially true for the last few bins + + step #5 is important for three reasons. + First, we would not count diagonals that have n_valid=0 because those have weight of 0 + Second, we would correctly account for the fact that some regions end in the center of the bin + Third, we would account for the fact that the very last diagonals are very short and have very few + values (hence weighing diagonals with a weight of n_valid) + + steps #4 and #6 are important because the ratio of sums does not equal to the sum of ratios, and + the former is more correct (the latter is more susceptible to noise). + It is generally better to divide at the very end, rather than dividing things for each diagonal. + + + For errorbars / spread, it does the following + + 1. Take all by-region P(s) + 2. Remove the last var_drop_last_bins bins for each region + (by default two. They are most noisy and would inflate the + spread for the last points) + 3. Groupby P(s) by region + 4. Apply spread_funcs to the pd.GroupBy object + Options are: minimum and maximum ("minmax"), standard deviation ("std"), + standard deviation in logspace ("logstd", default) or two custom functions + 5. Append them to the P(s) for the same bin. + + NOTE as a result, by default, we do not estimate spread for the last two bins + This is because there are often very few chromosomal arms there, and different arm + measurements are noisy + + + + example + ------- + + c = cooler.Cooler(file+"::resolutions/1000") + with multiprocess.Pool(20) as pool: + exp = cooltools.expected.diagsum( + c, + list(arms.itertuples(index=False,name=None)), + transforms={'balanced': lambda p: p['count'] * p['weight1'] * p['weight2']}, + map=pool.map) + + scal_dict = logbin_expected(exp, ratio=1.2, spread_funcs="logstd") + scal = scal_dict["Pc"] + der = scal_dict["slope"] + plt.figure(figsize=(5, 5)) + plt.subplot(211) + + for dummy,ind in scal_dict["Pc_by_region"].groupby("region"): + plt.plot(ind["x"], ind["Pc"], color="gray", linewidth=0.5, alpha=0.5) + + plt.plot(scal["x"], scal["Pc"], color="blue") + plt.fill_between(scal["x"], scal["low_err"], + scal["high_err"], color="blue", alpha=0.3) + + + + plt.ylabel("Pc, contact probability") + plt.xscale("log") + plt.yscale("log") + plt.subplot(212) + + for dummy,ind in scal_dict["slope_by_region"].groupby("region"): + plt.plot(ind["x"], ind["slope"], color="gray", linewidth=0.5, alpha=0.5) + + plt.plot(der["x"], der["slope"]) + plt.fill_between(der["x"], der["low_err"], + der["high_err"], color="blue", alpha=0.3) + + plt.ylabel("Pc slope") + plt.xlabel("Genomic separation (kb)") + plt.xscale("log") + plt.tight_layout() + + + """ + + from cooltools.lib.numutils import logbins + + exp = pd.concat([i.reset_index() for i in exp.values()], keys=map(repr, exp.keys()), + names=["region"]).reset_index(level=0).reset_index(drop=True) + exp = exp[~pd.isna(exp["balanced.sum"])] + exp["x"] = exp.pop("diag") + diagmax = exp["x"].max() + bins = logbins(1, diagmax+1, 1.2) + + exp["bin_id"] = np.searchsorted(bins, exp["x"]) + + # constructing expected grouped by region + byReg = exp.copy() + byReg["x"] *= byReg["n_valid"] + byRegExp = byReg.groupby(["region", "bin_id"]).sum() + byRegExp["x"] /= byRegExp["n_valid"] + byRegExp = byRegExp.reset_index() + byRegExp = byRegExp[byRegExp["n_valid"] > mid_nvalid] + byRegExp["Pc"] = byRegExp["balanced.sum"] / byRegExp["n_valid"] + byRegExp = byRegExp[byRegExp["Pc"] > 0] + if min_count: + if "count.sum" in byRegExp: + byRegExp = byRegExp[byRegExp["count.sum"] > min_count] + else: + warnings.warn(RuntimeWarning("counts not found")) + + + byRegDer = [] + for reg,subdf in byRegExp.groupby("region"): + subdf = subdf.sort_values("bin_id") + valid = np.minimum(subdf.n_valid.values[:-1], subdf.n_valid.values[1:]) + mids = np.sqrt(subdf.x.values[:-1] * subdf.x.values[1:]) + f = der_smooth_function_by_reg + slope = np.diff(f(np.log(subdf.Pc.values))) / np.diff(f(np.log(subdf.x.values))) + newdf = pd.DataFrame({"x":mids, "slope":slope, "n_valid":valid, "bin_id":subdf.bin_id.values[:-1]}) + + newdf["region"] = reg + byRegDer.append(newdf) + byRegDer = pd.concat(byRegDer).reset_index(drop=True) + + + + scal = numutils.weighted_groupby_mean(byRegExp[["x", "Pc", "bin_id","n_valid"]], "bin_id", "n_valid", mode="mean") + + if spread_funcs == "minmax": + byRegVar = byRegExp.copy() + byRegVar = byRegVar.loc[byRegVar.index.difference(byRegVar.groupby('region') + ['n_valid'].tail(minmax_drop_bins).index)] + low_err = byRegVar.groupby("bin_id")["Pc"].min() + high_err = byRegVar.groupby("bin_id")["Pc"].max() + elif spread_funcs == "std": + var = numutils.weighted_groupby_mean(byRegExp[["Pc", "bin_id","n_valid"]], "bin_id", "n_valid", mode="std")["Pc"] + low_err = scal["Pc"] - var + high_err = scal["Pc"] + var + elif spread_funcs == "logstd": + var = numutils.weighted_groupby_mean(byRegExp[["Pc", "bin_id","n_valid"]], "bin_id", "n_valid", mode="logstd")["Pc"] + low_err = scal["Pc"] / var + high_err = scal["Pc"] * var + + else: + low_err, high_err = spread_func(byRegExp, scal) + + scal["low_err"] = low_err + scal["high_err"] = high_err + + mids = np.sqrt(scal.x.values[:-1] * scal.x.values[1:]) + f = der_smooth_function_combined + + slope = np.diff(f(np.log(scal.Pc.values))) / np.diff(f(np.log(scal.x.values))) + slope_df = pd.DataFrame({"x": mids, "slope": slope}) + + if spread_funcs_slope == "minmax": + byRegDer = byRegDer.copy() + byRegDer = byRegDer.loc[byRegDer.index.difference(byRegDer.groupby('region') + ['n_valid'].tail(minmax_drop_bins).index)] + low_err = byRegDer.groupby("bin_id")["slope"].min() + high_err = byRegDer.groupby("bin_id")["slope"].max() + elif spread_funcs_slope == "std": + var = numutils.weighted_groupby_mean(byRegDer[["slope", "bin_id","n_valid"]], "bin_id", "n_valid", mode="std")["slope"] + low_err = slope_df["slope"] - var + high_err = slope_df["slope"] + var + + else: + low_err, high_err = spread_func(byRegExp, scal) + + slope_df["low_err"] = low_err + slope_df["high_err"] = high_err + + return {"Pc": scal, "Pc_by_region": byRegExp, + "slope_by_region":byRegDer, "slope":slope_df} diff --git a/cooltools/lib/numutils.py b/cooltools/lib/numutils.py index a19e6b2b..3002023e 100644 --- a/cooltools/lib/numutils.py +++ b/cooltools/lib/numutils.py @@ -3,6 +3,7 @@ import scipy.sparse.linalg import scipy.interpolate from scipy.ndimage.interpolation import zoom +import scipy.ndimage.filters import numpy as np import numba import cooler @@ -1361,3 +1362,110 @@ def _expand(ar, counts=None): ar_next = ar_next[:Norig, :Norig] return ar_next + + +def robust_gauss_filter(ar, + sigma=2, + functon=scipy.ndimage.filters.gaussian_filter1d, + kwargs = None): + """ + Implements an edge-handling mode for gaussian filter that basically ignores the edge, and also handles NANs. + + Available edge-handling modes in ndimage.filters attempt to somehow "extrapolate" the edge value and then + apply the filter (see https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.convolve.html). + That's likely because convolve uses fast fourier transform, which requires the kernel to be constant. + Here we design a better edge-handling for the gaussian smoothing. + + In a gaussian-filtered array, a pixel away from the edge is a mean of nearby pixels with gaussian weights. + With this mode, pixels near start/end are also a mean of nearby pixels with gaussian weights. That's it. + If we encounter NANs, we also simply ignore them, following the same definition: mean of nearby valid pixels. + Yes, it rases the weights for the first/last pixels, because now only a part of the whole gaussian is being used + (up to 1/2 for the first/last pixel and large sigma). But it preserves the "mean of nearby pixels" definition. + It is different from padding with zeros (it would drag the first pixel down to be more like zero). + It is also different from "nearest" - that gives too much weight to the first/last pixel. + + + To achieve this smoothing, we preform regular gaussian smoothing using mode="constant" + (pad with zeros). Then we takes an array of valid pixels and smooth it the same way. + This calculates how many "average valid pixels" contributed to each point of a smoothed array. + Dividing one by the other achieves the desired result. + + Parameters + ---------- + ar: array-like + Input array + sigma: float + sigma to be passed to the filter + function: callable + Filter to use. Default is gauusian_filter1d + kwargs: dict + Additional args to pass to the filter. Default:None + + """ + if kwargs == None: + kwargs = {} + ar = np.asarray(ar, dtype=float) + mask = np.isfinite(ar) + ar[~mask] = 0 + a = functon(ar, sigma=sigma, mode="constant", **kwargs) + b = functon(1. * mask, sigma=sigma, mode="constant", **kwargs) + return a/b + + +def weighted_groupby_mean(df, group_by, weigh_by, mode="mean"): + """ + Weighted mean, std, and std in log space for a dataframe.groupby + + Parameters + ---------- + df : dataframe + Dataframe to groupby + group_by : str or list + Columns to group by + weight_by : str + Column to use as weights + mode : "mean", "std" or "logstd" + Do the weighted mean, the weighted standard deviaton, + or the weighted std in log-space from the mean-log value + (useful for P(s) etc.) + + + """ + if type(group_by) == str: + group_by = [group_by] + gr = df.groupby(group_by) + if mode == "mean": + def wstd(x): + return np.average(x, weights=df.loc[x.index, weigh_by]) + wm = wstd + elif mode == "std": + def wstd(x): + wm = np.average(x, weights=df.loc[x.index, weigh_by]) + dev = x - wm + res = np.sqrt(np.average(dev**2, weights=df.loc[x.index, weigh_by])) + return res + wm = wstd + elif mode == "logstd": + def wstd(x): + x = np.log(x) + wm = np.average(x, weights=df.loc[x.index, weigh_by]) + dev = x - wm + res = np.sqrt(np.average(dev**2, weights=df.loc[x.index, weigh_by])) + return np.exp(res) + wm = wstd + else: + raise NotImplementedError + + + f = {} + for i in df.columns: + if i in group_by: + continue + elif i == weigh_by: + f[i] = ['sum'] + else: + f[i] = [wm] + agg = gr.agg(f) + agg.columns = [i[0] for i in agg.columns] + return agg + \ No newline at end of file From bd52d3a69a1e698b368dd2edc9104832c38b0ddc Mon Sep 17 00:00:00 2001 From: mimakaev Date: Sat, 1 Feb 2020 20:42:40 -0500 Subject: [PATCH 09/71] split logbin_expected into two functions --- cooltools/expected.py | 302 ++++++++++++++++++++++++------------------ 1 file changed, 175 insertions(+), 127 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index b30caee1..cbaac3bb 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -952,13 +952,10 @@ def blocksum_pairwise( return records -def logbin_expected(exp, ratio=1.2, - spread_funcs="logstd", - spread_funcs_slope = "std", - minmax_drop_bins=2, +def logbin_expected(exp, bins_per_order_magnitude=10, + bin_layout = "fixed", der_smooth_function_by_reg = lambda x:numutils.robust_gauss_filter(x,2), - der_smooth_function_combined = lambda x:numutils.robust_gauss_filter(x,1.3), - mid_nvalid = 200, + min_nvalid = 200, min_count = 50, ): """ @@ -971,17 +968,19 @@ def logbin_expected(exp, ratio=1.2, exp: dict {region:expected_df} produced by diagsum - ratio: float >1 (optional) - ratio of neighboring bins for binning expected + bins_per_order_magnitude : int (optional) + How many bins per order of magnitude. Default of 10 has a ratio of neighboring bins of about 1.25 - spread_funcs: "minmax", "std", "logstd" or a function (see below) - A way to estimate the spread of the P(s) curves between regions. - * "minmax" - use the minimum/maximum of by-region P(s) - * "std" - use weighted standard deviation of P(s) curves (may produce negative results) - * "logstd" (recommended) weighted standard deviation in logspace (as seen on the plot) + bin_layout : "fixed", "longest_region", or array + "fixed" means that bins are exactly the same for different datasets, + and only depend on bins_per_order_magnitude - spread_funcs_slope: "minmax", "std" or a funciton - Similar to spread_func, but for slopes rather than P(s) + "longest_region" means that the last bin will end at size of the longest region. + GOOD: the last bin will have as much data as possible. But makes + BAD: bin edges will end up different for different datasets, you can't divide them by each other + + array: provide your own bin edges. Can be of any size, and end at any value: bins exceeding the size + of the largest region will be simply ignored. der_smooth_function_by_reg: callable A smoothing function to be applied to log(P(s)) and log(x) @@ -1017,89 +1016,58 @@ def logbin_expected(exp, ratio=1.2, For main Pc and slope, the algorithm is the following 1. concatenate all the expected for all regions into a large dataframe. - 2. find the furthest diagonal with n_valid>0 - 3. create logarithmically-spaced buckets of diagonals that end at the furthest diagonal - 4. pool together n_valid and balanced.sum for diagonals in each bin - 5. calculate the average diagonal for each bucket, weighted by n_valid - 6. divide balanced.sum by n_valid after summing for each bucket (not before) - 7. calculate the slope in log space. + 2. create logarithmically-spaced bins of diagonals (or use provided) + 3. pool together n_valid and balanced.sum for each region and for each bin + 4. calculate the average diagonal for each bucket, weighted by n_valid + 5. divide balanced.sum by n_valid after summing for each bucket (not before) + 6. calculate the slope in log space (for each region) - NOTE: that it creates x values that are not necessarily centered at the center of the bin - This is especially true for the last few bins - - step #5 is important for three reasons. - First, we would not count diagonals that have n_valid=0 because those have weight of 0 - Second, we would correctly account for the fact that some regions end in the center of the bin - Third, we would account for the fact that the very last diagonals are very short and have very few - values (hence weighing diagonals with a weight of n_valid) + + X values are not midpoints of bins + ---------------------------------- + + In step 4, we calculate the average diag index weighted by n_valid. This seems counter-intuitive, but + it actually is justified. + + Let's take the worst case scenario. Let there be a bin from 40MB to 44MB. Let there be a + region that is exactly 41 MB long. The midpoint of the bin is at 42MB. But the only part + of this region belonging to this bin is actually between 40MB and 41MB. Moreover, + the "average" read in this little triangle of the heatmap is actually not coming even from 40.5 MB + because the triangle is getting narrower towards 41MB. The center of mass of a triangle is 1/3 of the way up, + or 40.33 MB. So an average read for this region in this bin is coming from 40.33. + + + Consider the previous bin, say, from 36MB to 40MB. The heatmap there is a trapezoid with a long side of 5MB, + the short side of 1MB, and height of 4MB. The center of mass of this trapezoid is at 36 + 14/9 = 37.55MB, + and not at 38MB. So the last bin center is definitely mis-assigned, and the second-to-last bin center is + off by some 25%. + + In presence of missing bins, this all becomes more complex, but this kind of averaging should take care of everything. + It follows a general principle: when averaging the y values with some weights, one needs to average the x values with + the same weights. The y values here are being added together, so they are effectively averaged with the weight of n_valid. + Therefore, the x values (diag) should be averaged with the same weights. + + Other considerations + -------------------- - steps #4 and #6 are important because the ratio of sums does not equal to the sum of ratios, and + steps #3 and #5 are important because the ratio of sums does not equal to the sum of ratios, and the former is more correct (the latter is more susceptible to noise). It is generally better to divide at the very end, rather than dividing things for each diagonal. - - - For errorbars / spread, it does the following - 1. Take all by-region P(s) - 2. Remove the last var_drop_last_bins bins for each region - (by default two. They are most noisy and would inflate the - spread for the last points) - 3. Groupby P(s) by region - 4. Apply spread_funcs to the pd.GroupBy object - Options are: minimum and maximum ("minmax"), standard deviation ("std"), - standard deviation in logspace ("logstd", default) or two custom functions - 5. Append them to the P(s) for the same bin. + Here we divide at the end twice: first we divide balanced.sum by n_valid for each region, + then we divide it for each bin when combining different regions (see next function). - NOTE as a result, by default, we do not estimate spread for the last two bins - This is because there are often very few chromosomal arms there, and different arm - measurements are noisy - - - - example - ------- - - c = cooler.Cooler(file+"::resolutions/1000") - with multiprocess.Pool(20) as pool: - exp = cooltools.expected.diagsum( - c, - list(arms.itertuples(index=False,name=None)), - transforms={'balanced': lambda p: p['count'] * p['weight1'] * p['weight2']}, - map=pool.map) - - scal_dict = logbin_expected(exp, ratio=1.2, spread_funcs="logstd") - scal = scal_dict["Pc"] - der = scal_dict["slope"] - plt.figure(figsize=(5, 5)) - plt.subplot(211) - - for dummy,ind in scal_dict["Pc_by_region"].groupby("region"): - plt.plot(ind["x"], ind["Pc"], color="gray", linewidth=0.5, alpha=0.5) - - plt.plot(scal["x"], scal["Pc"], color="blue") - plt.fill_between(scal["x"], scal["low_err"], - scal["high_err"], color="blue", alpha=0.3) - - - - plt.ylabel("Pc, contact probability") - plt.xscale("log") - plt.yscale("log") - plt.subplot(212) - - for dummy,ind in scal_dict["slope_by_region"].groupby("region"): - plt.plot(ind["x"], ind["slope"], color="gray", linewidth=0.5, alpha=0.5) - - plt.plot(der["x"], der["slope"]) - plt.fill_between(der["x"], der["low_err"], - der["high_err"], color="blue", alpha=0.3) - - plt.ylabel("Pc slope") - plt.xlabel("Genomic separation (kb)") - plt.xscale("log") - plt.tight_layout() - - + Smoothing P(s) for the slope + ---------------------------- + + For calcuating the slope, we apply smoothing to the P(s) to ensure the slope is not too noisy. + There are several caveats here: the P(s) has to be smoothed in logspace, and both P and s have + to be smoothed. It is discussed in detail here https://gist.github.com/mimakaev/4becf1310ba6ee07f6b91e511c531e73 + + Examples + -------- + + For example, see this gist: TODO put a gist here """ from cooltools.lib.numutils import logbins @@ -1107,28 +1075,44 @@ def logbin_expected(exp, ratio=1.2, exp = pd.concat([i.reset_index() for i in exp.values()], keys=map(repr, exp.keys()), names=["region"]).reset_index(level=0).reset_index(drop=True) exp = exp[~pd.isna(exp["balanced.sum"])] - exp["x"] = exp.pop("diag") + exp["x"] = exp.pop("diag") diagmax = exp["x"].max() - bins = logbins(1, diagmax+1, 1.2) - - exp["bin_id"] = np.searchsorted(bins, exp["x"]) + + if bin_layout == "fixed": + bins = np.unique(np.logspace(0,10,10 * bins_per_order_magnitude+1,dtype=int)) + elif bin_layout == "longest_region": + bins = logbins(1,diagmax+1, ratio=10**(1/bins_per_order_magnitude)) + else: + bins = bin_layout + + if bins[-1] < diagmax: + raise ValueError("Bins end is less than the size of the largest region") + + exp["bin_id"] = np.searchsorted(bins, exp["x"], side='right') - 1 + exp = exp[exp["bin_id"] >= 0] + # constructing expected grouped by region byReg = exp.copy() + + #this averages x with the weight equal to n_valid, and sums everything else byReg["x"] *= byReg["n_valid"] byRegExp = byReg.groupby(["region", "bin_id"]).sum() - byRegExp["x"] /= byRegExp["n_valid"] + byRegExp["x"] /= byRegExp["n_valid"] + byRegExp = byRegExp.reset_index() - byRegExp = byRegExp[byRegExp["n_valid"] > mid_nvalid] + byRegExp = byRegExp[byRegExp["n_valid"] > min_nvalid] # filtering by n_valid byRegExp["Pc"] = byRegExp["balanced.sum"] / byRegExp["n_valid"] - byRegExp = byRegExp[byRegExp["Pc"] > 0] + byRegExp = byRegExp[byRegExp["Pc"] > 0] #drop bins with 0 counts if min_count: if "count.sum" in byRegExp: byRegExp = byRegExp[byRegExp["count.sum"] > min_count] else: warnings.warn(RuntimeWarning("counts not found")) - - + + byRegExp["bin_start"] = bins[byRegExp["bin_id"].values] + byRegExp["bin_end"] = bins[byRegExp["bin_id"].values+1] - 1 + byRegDer = [] for reg,subdf in byRegExp.groupby("region"): subdf = subdf.sort_values("bin_id") @@ -1141,54 +1125,118 @@ def logbin_expected(exp, ratio=1.2, newdf["region"] = reg byRegDer.append(newdf) byRegDer = pd.concat(byRegDer).reset_index(drop=True) + return byRegExp, byRegDer, bins[:byRegExp.bin_id.max()+2] - +def combine_binned_expected(binned_exp, + binned_exp_slope=None, + der_smooth_function_combined = lambda x:numutils.robust_gauss_filter(x,1.3), + spread_funcs="logstd", + spread_funcs_slope = "std", + minmax_drop_bins=2, + concat_original=False, + ): + """ + Parameters + ---------- + binned_exp: dataframe + binned expected as outputed by logbin_expected + + binned_exp_slope : dataframe or None + If provided, estimates spread of slopes as well + + spread_funcs: "minmax", "std", "logstd" or a function (see below) + A way to estimate the spread of the P(s) curves between regions. + * "minmax" - use the minimum/maximum of by-region P(s) + * "std" - use weighted standard deviation of P(s) curves (may produce negative results) + * "logstd" (recommended) weighted standard deviation in logspace (as seen on the plot) + + spread_funcs_slope: "minmax", "std" or a funciton + Similar to spread_func, but for slopes rather than P(s) + + concat_original: bool (default = False) + Append original dataframe, and put combined under region "combined" + + Calculating errorbars/spread + ---------------------------- - scal = numutils.weighted_groupby_mean(byRegExp[["x", "Pc", "bin_id","n_valid"]], "bin_id", "n_valid", mode="mean") + 1. Take all by-region P(s) + 2. For "minmax", remove the last var_drop_last_bins bins for each region + (by default two. They are most noisy and would inflate the + spread for the last points). Min/max are most susceptible to this. + 3. Groupby P(s) by region + 4. Apply spread_funcs to the pd.GroupBy object + Options are: minimum and maximum ("minmax"), weighted standard deviation ("std"), + weighted standard deviation in logspace ("logstd", default) or two custom functions + We do not remove the last bins for "std" / "logstd" because we are doing weighted + standard deviation. Therefore, noisy "ends" of regions would contribute very little to this. + 5. Append them to the P(s) for the same bin. + + NOTE as a result, by for minmax, we do not estimate spread for the last two bins + This is because there are often very few chromosomal arms there, and different arm + measurements are noisy. For other methods, we do estimate the spread there, and noisy + last bins are taken care of by the weighted standard deviation. However, the spread + in the last bins may be noisy, and may become a 0 if only one region is contributing to the last pixel. + + + + + """ + scal = numutils.weighted_groupby_mean(binned_exp.select_dtypes(np.number), "bin_id", "n_valid", mode="mean") if spread_funcs == "minmax": - byRegVar = byRegExp.copy() + byRegVar = binned_exp.copy() byRegVar = byRegVar.loc[byRegVar.index.difference(byRegVar.groupby('region') ['n_valid'].tail(minmax_drop_bins).index)] low_err = byRegVar.groupby("bin_id")["Pc"].min() high_err = byRegVar.groupby("bin_id")["Pc"].max() elif spread_funcs == "std": - var = numutils.weighted_groupby_mean(byRegExp[["Pc", "bin_id","n_valid"]], "bin_id", "n_valid", mode="std")["Pc"] + var = numutils.weighted_groupby_mean(binned_exp[["Pc", "bin_id","n_valid"]], "bin_id", "n_valid", mode="std")["Pc"] low_err = scal["Pc"] - var high_err = scal["Pc"] + var elif spread_funcs == "logstd": - var = numutils.weighted_groupby_mean(byRegExp[["Pc", "bin_id","n_valid"]], "bin_id", "n_valid", mode="logstd")["Pc"] + var = numutils.weighted_groupby_mean(binned_exp[["Pc", "bin_id","n_valid"]], "bin_id", "n_valid", mode="logstd")["Pc"] low_err = scal["Pc"] / var high_err = scal["Pc"] * var else: - low_err, high_err = spread_func(byRegExp, scal) + low_err, high_err = spread_func(binned_exp, scal) scal["low_err"] = low_err scal["high_err"] = high_err - mids = np.sqrt(scal.x.values[:-1] * scal.x.values[1:]) f = der_smooth_function_combined slope = np.diff(f(np.log(scal.Pc.values))) / np.diff(f(np.log(scal.x.values))) - slope_df = pd.DataFrame({"x": mids, "slope": slope}) - - if spread_funcs_slope == "minmax": - byRegDer = byRegDer.copy() - byRegDer = byRegDer.loc[byRegDer.index.difference(byRegDer.groupby('region') - ['n_valid'].tail(minmax_drop_bins).index)] - low_err = byRegDer.groupby("bin_id")["slope"].min() - high_err = byRegDer.groupby("bin_id")["slope"].max() - elif spread_funcs_slope == "std": - var = numutils.weighted_groupby_mean(byRegDer[["slope", "bin_id","n_valid"]], "bin_id", "n_valid", mode="std")["slope"] - low_err = slope_df["slope"] - var - high_err = slope_df["slope"] + var + valid = np.minimum(scal.n_valid.values[:-1], scal.n_valid.values[1:]) + mids = np.sqrt(scal.x.values[:-1] * scal.x.values[1:]) + slope_df = pd.DataFrame({"x":mids, "slope":slope, "n_valid":valid, "bin_id":scal.index.values[:-1]}) + slope_df = slope_df.set_index("bin_id") + + + if binned_exp_slope is not None: + if spread_funcs_slope == "minmax": + byRegDer = binned_exp_slope.copy() + byRegDer = byRegDer.loc[byRegDer.index.difference(byRegDer.groupby('region') + ['n_valid'].tail(minmax_drop_bins).index)] + low_err = byRegDer.groupby("bin_id")["slope"].min() + high_err = byRegDer.groupby("bin_id")["slope"].max() + elif spread_funcs_slope == "std": + var = numutils.weighted_groupby_mean(binned_exp_slope[["slope", "bin_id","n_valid"]], "bin_id", "n_valid", mode="std")["slope"] + low_err = slope_df["slope"] - var + high_err = slope_df["slope"] + var - else: - low_err, high_err = spread_func(byRegExp, scal) - - slope_df["low_err"] = low_err - slope_df["high_err"] = high_err + else: + low_err, high_err = spread_funcs_slope(binned_exp_slope, scal) + slope_df["low_err"] = low_err + slope_df["high_err"] = high_err + + slope_df= slope_df.reset_index() + scal = scal.reset_index() + + if concat_original: + scal["region"] = "combined" + slope_df["region"] = "combined" + scal = pd.concat([scal, binned_exp], sort=False).reset_index(drop=True) + slope_df = pd.concat([slope_df, binned_exp_slope], sort=False).reset_index(drop=True) - return {"Pc": scal, "Pc_by_region": byRegExp, - "slope_by_region":byRegDer, "slope":slope_df} + return scal, slope_df From dc7302aa37196ca4d4b68868b3e48e25065978c5 Mon Sep 17 00:00:00 2001 From: mimakaev Date: Sun, 2 Feb 2020 07:52:10 -0500 Subject: [PATCH 10/71] improved logbins; added persistent logbins --- cooltools/expected.py | 2 +- cooltools/lib/_numutils.pyx | 12 ++++++- cooltools/lib/numutils.py | 69 +++++++++++++++++++++++++++++++++---- 3 files changed, 75 insertions(+), 8 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index cbaac3bb..aacf6d74 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -1079,7 +1079,7 @@ def logbin_expected(exp, bins_per_order_magnitude=10, diagmax = exp["x"].max() if bin_layout == "fixed": - bins = np.unique(np.logspace(0,10,10 * bins_per_order_magnitude+1,dtype=int)) + bins = numutils.persistent_log_bins(10,bins_per_order_magnitude=bins_per_order_magnitude) elif bin_layout == "longest_region": bins = logbins(1,diagmax+1, ratio=10**(1/bins_per_order_magnitude)) else: diff --git a/cooltools/lib/_numutils.pyx b/cooltools/lib/_numutils.pyx index 19b2fede..cc4c1729 100644 --- a/cooltools/lib/_numutils.pyx +++ b/cooltools/lib/_numutils.pyx @@ -17,7 +17,7 @@ cdef extern from "stdlib.h": double c_libc_drandom "drand48"() -def logbins(lo, hi, ratio=0, N=0): +def logbins(lo, hi, ratio=0, N=0, version=2): """Make bins with edges evenly spaced in log-space. Parameters @@ -30,6 +30,12 @@ def logbins(lo, hi, ratio=0, N=0): N : int The target number of bins. The resulting number of bins is not guaranteed. Either ratio or N must be specified. + + version : int + version=1 is a legacy mirnylib version + + version=2 fixes ordering of bin gaps for some values, making sure + that bin gaps are always increasing (2/2/2020) """ lo = int(lo) @@ -43,6 +49,10 @@ def logbins(lo, hi, ratio=0, N=0): data10 = np.logspace(np.log10(lo), np.log10(hi), N) data10 = np.array(np.rint(data10), dtype=int) data10 = np.sort(np.unique(data10)) + + if version > 1: + data10 = np.cumsum(np.r_[data10[0], np.sort(np.diff(data10))]) + assert data10[0] == lo assert data10[-1] == hi diff --git a/cooltools/lib/numutils.py b/cooltools/lib/numutils.py index 3002023e..7746912a 100644 --- a/cooltools/lib/numutils.py +++ b/cooltools/lib/numutils.py @@ -25,8 +25,7 @@ def get_diag(arr, i=0): """ return arr.ravel()[ max(i, -arr.shape[1] * i) : max(0, (arr.shape[1] - i)) - * arr.shape[1] : arr.shape[1] - + 1 + * arr.shape[1] : arr.shape[1] + 1 ] @@ -656,7 +655,6 @@ def iterative_correction_symmetric( _x = x.copy() if ignore_diags > 0: for d in range(0, ignore_diags): - # set_diag(_x, 0, d) # explicit cycles are easier to jit for j in range(0, N - d): _x[j, j + d] = 0 _x[j + d, j] = 0 @@ -678,8 +676,6 @@ def iterative_correction_symmetric( s += 1 totalBias *= s - # _x = _x / s[:, None] / s[None,:] - # an explicit cycle is 2x faster here for i in range(N): for j in range(N): _x[i, j] /= s[i] * s[j] @@ -1468,4 +1464,65 @@ def wstd(x): agg = gr.agg(f) agg.columns = [i[0] for i in agg.columns] return agg - \ No newline at end of file + + +def persistent_log_bins(end=10, bins_per_order_magnitude=10): + """ + Creates most nicely looking log-spaced integer bins starting at 1, + with the defined number of bins per order of magnitude. This is not a replacement for logbins, + and it has a different purpose (see note below). + + Parameters + ---------- + + end : number (int recommended) + log10 of the last value. It is safe to put a large value here and select your range of bins later. + + bins_per_order_magnitude : int >0 + how many bins per order of magnitude + + + Difference between this and logbins + ----------------------------------- + + Logbins creates bins from lo to hi, spaced logarithmically with an appriximate ratio. Logbins + makes sure that the last bin is large (i.e. hi/ratio ... hi), and will not allow the last + bin to be much less than ratio. It would slightly adjust the ratio to achieve that. + As a result, by construciton, logbins bins are different for different lo or hi. + + This function is designed to create exactly the same bins that only depend on one parameter, + bins_per_order_magnitude. The goal is to make things calculated for different datasets/organisms/etc. + comparable. For example, if these bins are used, it would allow us to divide P(s) for two different organisms + by each other because it was calculated for the same bins. + + The price you pay for such versatility is that the last bin can be much less than others in real application. + For example, if you have 10 bins per order of magnitude (ratio of 1.25), but your data ends at 10500, then + the only points in the last bin would be 10000..10500, 1/5 of what could be. This may make the last point noisy. + + The main part is done using np.logspace and rounding to the nearest integer, followed by unique. + The gaps are then re-sorted to ensure that gaps are strictly increasing. The re-sorting of + gaps was essential, and produced better results than manual adjustment. + + Alternatives that produce irregular bins + ---------------------------------------- + + Using np.unique(np.logspace(a,b,N,dtype=int)) can be sub-optimal + For example, np.unique(np.logspace(0,1,11,dtype=int)) = [ 1, 2, 3, 5, 6, 7, 10] + Note the gaps jump from 1 to 2 back to 1 + + Similarly using np.unique(np.rint(np.logspace..)) can be suboptimal + np.unique(np.array(np.rint(np.logspace(0,1,9)),dtype=int)) = [ 1, 2, 3, 4, 6, 7, 10] + + for bins_per_order_of_magnitude=16, 10 is not in bins. Other than that, 10, 100, 1000, etc. are always included. + + + """ + + if end > 50: + raise ValueError("End is a log10(max_value), not the max_value itself") + + bin_float = np.logspace(0, end, end * bins_per_order_magnitude + 1) + bin_int = np.array(np.rint(bin_float), dtype=int) # rounding to the nearest int + bins = np.unique(bin_int) # unique bins + bins = np.cumsum(np.sort(np.r_[1,np.diff(bins)])) #re-ordering gaps (important step) + return bins From ec4acd5d44fc63d4cb0598596406d02e139b53c2 Mon Sep 17 00:00:00 2001 From: mimakaev Date: Tue, 3 Mar 2020 20:53:18 -0500 Subject: [PATCH 11/71] updated docs for logbin_expected; black --- cooltools/expected.py | 261 +++++++++++++++++++++++++----------------- 1 file changed, 153 insertions(+), 108 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index aacf6d74..32a978ef 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -73,7 +73,6 @@ def compute_scaling(df, region1, region2=None, dmin=int(1e1), dmax=int(1e7), n_b return distbins, obs, areas - def lattice_pdist_frequencies(n, points): """ Distribution of pairwise 1D distances among a collection of distinct @@ -219,8 +218,7 @@ def count_all_pixels_per_block(clr, supports): dictionary with total number of pixels per pair of support regions """ n = len(supports) - x = [clr.extent(region)[1] - clr.extent(region)[0] - for region in supports] + x = [clr.extent(region)[1] - clr.extent(region)[0] for region in supports] blocks = {} for i in range(n): for j in range(i + 1, n): @@ -228,7 +226,6 @@ def count_all_pixels_per_block(clr, supports): return blocks - def count_bad_pixels_per_block(clr, supports, weight_name="weight", bad_bins=None): """ Calculate number of "bad" pixels per rectangular block of a contact map @@ -263,8 +260,10 @@ def count_bad_pixels_per_block(clr, supports, weight_name="weight", bad_bins=Non n = len(supports) if bad_bins is not None: - raise NotImplementedError("providing external list \ - of bad bins is not implemented.") + raise NotImplementedError( + "providing external list \ + of bad bins is not implemented." + ) if weight_name is None: # ignore bad bins @@ -275,12 +274,10 @@ def count_bad_pixels_per_block(clr, supports, weight_name="weight", bad_bins=Non raise KeyError("Balancing weight {weight_name} not found!") # bad bins are ones with # the weight vector being NaN: - x = [np.sum(clr.bins()[weight_name] - .fetch(region) - .isnull() - .astype(int) - .values) - for region in supports] + x = [ + np.sum(clr.bins()[weight_name].fetch(region).isnull().astype(int).values) + for region in supports + ] else: raise ValueError("`weight_name` can be `str` or `None`") @@ -291,7 +288,6 @@ def count_bad_pixels_per_block(clr, supports, weight_name="weight", bad_bins=Non return blocks - def make_diag_table(bad_mask, span1, span2): """ Compute the total number of elements ``n_elem`` and the number of bad @@ -439,7 +435,7 @@ def _bg2slice_frame(bg2, region1, region2): for region in regions: if len(region) == 1: - chrom, = region + (chrom,) = region start1, end1 = 0, clr.chromsizes[chrom] start2, end2 = start1, end1 elif len(region) == 3: @@ -531,32 +527,33 @@ def trans_expected(clr, chromosomes, chunksize=1000000, use_dask=False): raise NotImplementedError("To be implemented once dask supports MultiIndex") # turn chromosomes into supports: - chrom_supports = [ (chrom, 0, None) for chrom in chromosomes ] + chrom_supports = [(chrom, 0, None) for chrom in chromosomes] # use balaned transformation only: balanced_transform = { - "balanced": \ - lambda pixels: pixels["count"] * pixels["weight1"] * pixels["weight2"] - } + "balanced": lambda pixels: pixels["count"] + * pixels["weight1"] + * pixels["weight2"] + } # trans_expected is simply a wrapper around new blocksum_pairwise # but it preserved the interface of the original trans_expected - trans_records = blocksum_pairwise(clr, - supports=chrom_supports, - transforms=balanced_transform, - chunksize=chunksize) + trans_records = blocksum_pairwise( + clr, supports=chrom_supports, transforms=balanced_transform, chunksize=chunksize + ) # trans_records are inter-chromosomal only, # changing trans_records keys to reflect that: # region[0] for a region = (chrom, start, stop) trans_records = { - ( region1[0], region2[0] ): val for ( region1, region2 ), val in trans_records.items() - } + (region1[0], region2[0]): val + for (region1, region2), val in trans_records.items() + } # turn trans_records into a DataFrame with # MultiIndex, that stores values of 'balanced.sum' # and 'n_valid' values for each pair of chromosomes: - trans_df = pd.DataFrame.from_dict( trans_records, orient="index" ) - trans_df.index.rename( ["chrom1","chrom2"], inplace=True ) + trans_df = pd.DataFrame.from_dict(trans_records, orient="index") + trans_df.index.rename(["chrom1", "chrom2"], inplace=True) # an alternative way to get from records to DataFrame, as in CLI expected: # result = pd.DataFrame( # [ @@ -608,9 +605,10 @@ def make_diag_tables(clr, supports, weight_name="weight", bad_bins=None): """ if bad_bins is not None: - raise NotImplementedError("providing external list \ - of bad bins is not implemented.") - + raise NotImplementedError( + "providing external list \ + of bad bins is not implemented." + ) bins = clr.bins()[:] if weight_name is None: @@ -638,7 +636,7 @@ def make_diag_tables(clr, supports, weight_name="weight", bad_bins=None): region = bioframe.parse_region(region) # unpack region(s) into chroms,starts,ends if len(region) == 1: - chrom, = region + (chrom,) = region start1, end1 = 0, clr.chromsizes[chrom] start2, end2 = start1, end1 elif len(region) == 2: @@ -740,7 +738,7 @@ def diagsum( bad_bins=None, chunksize=10000000, ignore_diags=2, - map=map + map=map, ): """ @@ -778,7 +776,9 @@ def diagsum( """ spans = partition(0, len(clr.pixels()), chunksize) fields = ["count"] + list(transforms.keys()) - dtables = make_diag_tables(clr, supports, weight_name=weight_name, bad_bins=bad_bins) + dtables = make_diag_tables( + clr, supports, weight_name=weight_name, bad_bins=bad_bins + ) for dt in dtables.values(): for field in fields: @@ -816,7 +816,7 @@ def diagsum_asymm( bad_bins=None, chunksize=10000000, ignore_diags=2, - map=map + map=map, ): """ @@ -893,7 +893,7 @@ def blocksum_pairwise( weight_name="weight", bad_bins=None, chunksize=1000000, - map=map + map=map, ): """ Summary statistics on inter-chromosomal rectangular blocks. @@ -934,7 +934,9 @@ def blocksum_pairwise( fields = ["count"] + list(transforms.keys()) n_tot = count_all_pixels_per_block(clr, supports) - n_bad = count_bad_pixels_per_block(clr, supports, weight_name=weight_name, bad_bins=bad_bins) + n_bad = count_bad_pixels_per_block( + clr, supports, weight_name=weight_name, bad_bins=bad_bins + ) records = {(c1, c2): defaultdict(int) for (c1, c2) in blocks} for c1, c2 in blocks: records[c1, c2]["n_valid"] = n_tot[c1, c2] - n_bad[c1, c2] @@ -952,12 +954,14 @@ def blocksum_pairwise( return records -def logbin_expected(exp, bins_per_order_magnitude=10, - bin_layout = "fixed", - der_smooth_function_by_reg = lambda x:numutils.robust_gauss_filter(x,2), - min_nvalid = 200, - min_count = 50, - ): +def logbin_expected( + exp, + bins_per_order_magnitude=10, + bin_layout="fixed", + der_smooth_function_by_reg=lambda x: numutils.robust_gauss_filter(x, 2), + min_nvalid=200, + min_count=50, +): """ Logarithmically bins expected as produced by diagsum method See description below @@ -976,7 +980,7 @@ def logbin_expected(exp, bins_per_order_magnitude=10, and only depend on bins_per_order_magnitude "longest_region" means that the last bin will end at size of the longest region. - GOOD: the last bin will have as much data as possible. But makes + GOOD: the last bin will have as much data as possible. BAD: bin edges will end up different for different datasets, you can't divide them by each other array: provide your own bin edges. Can be of any size, and end at any value: bins exceeding the size @@ -1002,12 +1006,11 @@ def logbin_expected(exp, bins_per_order_magnitude=10, Returns ------- - - dict with dataframes with the following keys - * "Pc": dataframe of contact probabilities and spread across regions - * "slope": slope of Pc(s) on a log-log plot and spread across regions - * "Pc_by_region": a dataframe of Pc(s) for each region. - * "slope_by_region": a dataframe of slopes for each region + (Pc, slope, bins) + + * Pc: dataframe of contact probabilities and spread across regions + * slope: slope of Pc(s) on a log-log plot and spread across regions + * bins: an array of bin edges used for calculating P(s) Description @@ -1044,7 +1047,8 @@ def logbin_expected(exp, bins_per_order_magnitude=10, In presence of missing bins, this all becomes more complex, but this kind of averaging should take care of everything. It follows a general principle: when averaging the y values with some weights, one needs to average the x values with - the same weights. The y values here are being added together, so they are effectively averaged with the weight of n_valid. + the same weights. The y values here are being added together, so per-diag means are + effectively averaged with the weight of n_valid. Therefore, the x values (diag) should be averaged with the same weights. Other considerations @@ -1055,7 +1059,8 @@ def logbin_expected(exp, bins_per_order_magnitude=10, It is generally better to divide at the very end, rather than dividing things for each diagonal. Here we divide at the end twice: first we divide balanced.sum by n_valid for each region, - then we divide it for each bin when combining different regions (see next function). + then we effectively multiply it back up and divide it for each bin when combining + different regions (see weighted average in the next function). Smoothing P(s) for the slope ---------------------------- @@ -1067,82 +1072,102 @@ def logbin_expected(exp, bins_per_order_magnitude=10, Examples -------- - For example, see this gist: TODO put a gist here + For example, see this gist: https://gist.github.com/mimakaev/e9117a7fcc318e7904702eba5b47d9e6 """ from cooltools.lib.numutils import logbins - exp = pd.concat([i.reset_index() for i in exp.values()], keys=map(repr, exp.keys()), - names=["region"]).reset_index(level=0).reset_index(drop=True) + exp = ( + pd.concat( + [i.reset_index() for i in exp.values()], + keys=map(repr, exp.keys()), + names=["region"], + ) + .reset_index(level=0) + .reset_index(drop=True) + ) exp = exp[~pd.isna(exp["balanced.sum"])] - exp["x"] = exp.pop("diag") + exp["x"] = exp.pop("diag") diagmax = exp["x"].max() - + if bin_layout == "fixed": - bins = numutils.persistent_log_bins(10,bins_per_order_magnitude=bins_per_order_magnitude) + bins = numutils.persistent_log_bins( + 10, bins_per_order_magnitude=bins_per_order_magnitude + ) elif bin_layout == "longest_region": - bins = logbins(1,diagmax+1, ratio=10**(1/bins_per_order_magnitude)) + bins = logbins(1, diagmax + 1, ratio=10 ** (1 / bins_per_order_magnitude)) else: - bins = bin_layout - + bins = bin_layout + if bins[-1] < diagmax: raise ValueError("Bins end is less than the size of the largest region") - - exp["bin_id"] = np.searchsorted(bins, exp["x"], side='right') - 1 + + exp["bin_id"] = np.searchsorted(bins, exp["x"], side="right") - 1 exp = exp[exp["bin_id"] >= 0] - # constructing expected grouped by region byReg = exp.copy() - - #this averages x with the weight equal to n_valid, and sums everything else + + # this averages x with the weight equal to n_valid, and sums everything else byReg["x"] *= byReg["n_valid"] byRegExp = byReg.groupby(["region", "bin_id"]).sum() - byRegExp["x"] /= byRegExp["n_valid"] - + byRegExp["x"] /= byRegExp["n_valid"] + byRegExp = byRegExp.reset_index() byRegExp = byRegExp[byRegExp["n_valid"] > min_nvalid] # filtering by n_valid byRegExp["Pc"] = byRegExp["balanced.sum"] / byRegExp["n_valid"] - byRegExp = byRegExp[byRegExp["Pc"] > 0] #drop bins with 0 counts - if min_count: + byRegExp = byRegExp[byRegExp["Pc"] > 0] # drop bins with 0 counts + if min_count: if "count.sum" in byRegExp: byRegExp = byRegExp[byRegExp["count.sum"] > min_count] else: warnings.warn(RuntimeWarning("counts not found")) - + byRegExp["bin_start"] = bins[byRegExp["bin_id"].values] - byRegExp["bin_end"] = bins[byRegExp["bin_id"].values+1] - 1 - + byRegExp["bin_end"] = bins[byRegExp["bin_id"].values + 1] - 1 + byRegDer = [] - for reg,subdf in byRegExp.groupby("region"): + for reg, subdf in byRegExp.groupby("region"): subdf = subdf.sort_values("bin_id") valid = np.minimum(subdf.n_valid.values[:-1], subdf.n_valid.values[1:]) mids = np.sqrt(subdf.x.values[:-1] * subdf.x.values[1:]) f = der_smooth_function_by_reg slope = np.diff(f(np.log(subdf.Pc.values))) / np.diff(f(np.log(subdf.x.values))) - newdf = pd.DataFrame({"x":mids, "slope":slope, "n_valid":valid, "bin_id":subdf.bin_id.values[:-1]}) - + newdf = pd.DataFrame( + { + "x": mids, + "slope": slope, + "n_valid": valid, + "bin_id": subdf.bin_id.values[:-1], + } + ) + newdf["region"] = reg byRegDer.append(newdf) byRegDer = pd.concat(byRegDer).reset_index(drop=True) - return byRegExp, byRegDer, bins[:byRegExp.bin_id.max()+2] - -def combine_binned_expected(binned_exp, - binned_exp_slope=None, - der_smooth_function_combined = lambda x:numutils.robust_gauss_filter(x,1.3), - spread_funcs="logstd", - spread_funcs_slope = "std", - minmax_drop_bins=2, - concat_original=False, - ): + return byRegExp, byRegDer, bins[: byRegExp.bin_id.max() + 2] + + +def combine_binned_expected( + binned_exp, + binned_exp_slope=None, + der_smooth_function_combined=lambda x: numutils.robust_gauss_filter(x, 1.3), + spread_funcs="logstd", + spread_funcs_slope="std", + minmax_drop_bins=2, + concat_original=False, +): """ + Combines by-region log-binned expected and slopes into + Parameters ---------- binned_exp: dataframe binned expected as outputed by logbin_expected binned_exp_slope : dataframe or None - If provided, estimates spread of slopes as well + If provided, estimates spread of slopes. + Is necessary if concat_original is True spread_funcs: "minmax", "std", "logstd" or a function (see below) A way to estimate the spread of the P(s) curves between regions. @@ -1181,47 +1206,65 @@ def combine_binned_expected(binned_exp, """ - scal = numutils.weighted_groupby_mean(binned_exp.select_dtypes(np.number), "bin_id", "n_valid", mode="mean") + scal = numutils.weighted_groupby_mean( + binned_exp.select_dtypes(np.number), "bin_id", "n_valid", mode="mean" + ) - if spread_funcs == "minmax": + if spread_funcs == "minmax": byRegVar = binned_exp.copy() - byRegVar = byRegVar.loc[byRegVar.index.difference(byRegVar.groupby('region') - ['n_valid'].tail(minmax_drop_bins).index)] - low_err = byRegVar.groupby("bin_id")["Pc"].min() + byRegVar = byRegVar.loc[ + byRegVar.index.difference( + byRegVar.groupby("region")["n_valid"].tail(minmax_drop_bins).index + ) + ] + low_err = byRegVar.groupby("bin_id")["Pc"].min() high_err = byRegVar.groupby("bin_id")["Pc"].max() elif spread_funcs == "std": - var = numutils.weighted_groupby_mean(binned_exp[["Pc", "bin_id","n_valid"]], "bin_id", "n_valid", mode="std")["Pc"] + var = numutils.weighted_groupby_mean( + binned_exp[["Pc", "bin_id", "n_valid"]], "bin_id", "n_valid", mode="std" + )["Pc"] low_err = scal["Pc"] - var high_err = scal["Pc"] + var elif spread_funcs == "logstd": - var = numutils.weighted_groupby_mean(binned_exp[["Pc", "bin_id","n_valid"]], "bin_id", "n_valid", mode="logstd")["Pc"] + var = numutils.weighted_groupby_mean( + binned_exp[["Pc", "bin_id", "n_valid"]], "bin_id", "n_valid", mode="logstd" + )["Pc"] low_err = scal["Pc"] / var - high_err = scal["Pc"] * var - + high_err = scal["Pc"] * var + else: low_err, high_err = spread_func(binned_exp, scal) - + scal["low_err"] = low_err scal["high_err"] = high_err - + f = der_smooth_function_combined slope = np.diff(f(np.log(scal.Pc.values))) / np.diff(f(np.log(scal.x.values))) valid = np.minimum(scal.n_valid.values[:-1], scal.n_valid.values[1:]) mids = np.sqrt(scal.x.values[:-1] * scal.x.values[1:]) - slope_df = pd.DataFrame({"x":mids, "slope":slope, "n_valid":valid, "bin_id":scal.index.values[:-1]}) + slope_df = pd.DataFrame( + {"x": mids, "slope": slope, "n_valid": valid, "bin_id": scal.index.values[:-1]} + ) slope_df = slope_df.set_index("bin_id") - if binned_exp_slope is not None: - if spread_funcs_slope == "minmax": + if spread_funcs_slope == "minmax": byRegDer = binned_exp_slope.copy() - byRegDer = byRegDer.loc[byRegDer.index.difference(byRegDer.groupby('region') - ['n_valid'].tail(minmax_drop_bins).index)] - low_err = byRegDer.groupby("bin_id")["slope"].min() + byRegDer = byRegDer.loc[ + byRegDer.index.difference( + byRegDer.groupby("region")["n_valid"].tail(minmax_drop_bins).index + ) + ] + low_err = byRegDer.groupby("bin_id")["slope"].min() high_err = byRegDer.groupby("bin_id")["slope"].max() elif spread_funcs_slope == "std": - var = numutils.weighted_groupby_mean(binned_exp_slope[["slope", "bin_id","n_valid"]], "bin_id", "n_valid", mode="std")["slope"] + var = numutils.weighted_groupby_mean( + binned_exp_slope[["slope", "bin_id", "n_valid"]], + "bin_id", + "n_valid", + mode="std", + )["slope"] low_err = slope_df["slope"] - var high_err = slope_df["slope"] + var @@ -1229,14 +1272,16 @@ def combine_binned_expected(binned_exp, low_err, high_err = spread_funcs_slope(binned_exp_slope, scal) slope_df["low_err"] = low_err slope_df["high_err"] = high_err - - slope_df= slope_df.reset_index() + + slope_df = slope_df.reset_index() scal = scal.reset_index() - + if concat_original: scal["region"] = "combined" slope_df["region"] = "combined" scal = pd.concat([scal, binned_exp], sort=False).reset_index(drop=True) - slope_df = pd.concat([slope_df, binned_exp_slope], sort=False).reset_index(drop=True) - + slope_df = pd.concat([slope_df, binned_exp_slope], sort=False).reset_index( + drop=True + ) + return scal, slope_df From 192cd1863ee2c15ec4667c537b53b217bbb5c75b Mon Sep 17 00:00:00 2001 From: Maksim Imakaev Date: Wed, 4 Mar 2020 08:47:00 -0400 Subject: [PATCH 12/71] added black --- cooltools/expected.py | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index 10b4cec3..212429e8 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -281,14 +281,7 @@ def count_bad_pixels_per_block(clr, supports, weight_name="weight", bad_bins=Non raise KeyError("Balancing weight {weight_name} not found!") # bad bins are ones with the weight vector being NaN n_bad = [ - np.sum( - clr - .bins()[weight_name] - .fetch(region) - .isnull() - .astype(int) - .values - ) + np.sum(clr.bins()[weight_name].fetch(region).isnull().astype(int).values) for region in supports ] else: @@ -299,9 +292,7 @@ def count_bad_pixels_per_block(clr, supports, weight_name="weight", bad_bins=Non for i in range(n): for j in range(i + 1, n): blocks[supports[i], supports[j]] = ( - n_tot[i] * n_bad[j] + - n_tot[j] * n_bad[i] - - n_bad[i] * n_bad[j] + n_tot[i] * n_bad[j] + n_tot[j] * n_bad[i] - n_bad[i] * n_bad[j] ) return blocks From 6ebb1b43eddd821326ad3e9fa631bf38e51d7244 Mon Sep 17 00:00:00 2001 From: Anton Goloborodko Date: Wed, 1 Apr 2020 21:59:54 +0200 Subject: [PATCH 13/71] expected: rename regions->supports --- cooltools/expected.py | 102 +++++++++++++++++++++--------------------- 1 file changed, 51 insertions(+), 51 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index baf01856..3df316e3 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -201,7 +201,7 @@ def count_all_pixels_per_diag(n): return np.arange(n, 0, -1) -def count_all_pixels_per_block(clr, supports): +def count_all_pixels_per_block(clr, regions): """ Calculate total number of pixels per rectangular block of a contact map defined as a paired-combination of genomic "support" regions. @@ -210,7 +210,7 @@ def count_all_pixels_per_block(clr, supports): ---------- clr : cooler.Cooler Input cooler - supports : list + regions : list list of genomic support regions Returns @@ -218,18 +218,18 @@ def count_all_pixels_per_block(clr, supports): blocks : dict dictionary with total number of pixels per pair of support regions """ - n = len(supports) + n = len(regions) x = [clr.extent(region)[1] - clr.extent(region)[0] - for region in supports] + for region in regions] blocks = {} for i in range(n): for j in range(i + 1, n): - blocks[supports[i], supports[j]] = x[i] * x[j] + blocks[regions[i], regions[j]] = x[i] * x[j] return blocks -def count_bad_pixels_per_block(clr, supports, weight_name="weight", bad_bins=None): +def count_bad_pixels_per_block(clr, regions, weight_name="weight", bad_bins=None): """ Calculate number of "bad" pixels per rectangular block of a contact map defined as a paired-combination of genomic "support" regions. @@ -244,7 +244,7 @@ def count_bad_pixels_per_block(clr, supports, weight_name="weight", bad_bins=Non ---------- clr : cooler.Cooler Input cooler - supports : list + regions : list a list of genomic support regions weight_name : str name of the weight vector in the "bins" table, @@ -260,7 +260,7 @@ def count_bad_pixels_per_block(clr, supports, weight_name="weight", bad_bins=Non blocks : dict dictionary with the number of "bad" pixels per pair of support regions """ - n = len(supports) + n = len(regions) if bad_bins is not None: raise NotImplementedError("providing external list \ @@ -268,7 +268,7 @@ def count_bad_pixels_per_block(clr, supports, weight_name="weight", bad_bins=Non # Get the total number of bins per region n_tot = [] - for region in supports: + for region in regions: lo, hi = clr.extent(region) n_tot.append(hi - lo) @@ -276,7 +276,7 @@ def count_bad_pixels_per_block(clr, supports, weight_name="weight", bad_bins=Non if weight_name is None: # ignore bad bins # useful for unbalanced data - n_bad = [0 for region in supports] + n_bad = [0 for region in regions] elif isinstance(weight_name, str): if weight_name not in clr.bins().columns: raise KeyError("Balancing weight {weight_name} not found!") @@ -290,7 +290,7 @@ def count_bad_pixels_per_block(clr, supports, weight_name="weight", bad_bins=Non .astype(int) .values ) - for region in supports + for region in regions ] else: raise ValueError("`weight_name` can be `str` or `None`") @@ -299,7 +299,7 @@ def count_bad_pixels_per_block(clr, supports, weight_name="weight", bad_bins=Non blocks = {} for i in range(n): for j in range(i + 1, n): - blocks[supports[i], supports[j]] = ( + blocks[regions[i], regions[j]] = ( n_tot[i] * n_bad[j] + n_tot[j] * n_bad[i] - n_bad[i] * n_bad[j] @@ -557,7 +557,7 @@ def trans_expected(clr, chromosomes, chunksize=1000000, use_dask=False): # trans_expected is simply a wrapper around new blocksum_pairwise # but it preserved the interface of the original trans_expected trans_records = blocksum_pairwise(clr, - supports=chrom_supports, + regions=chrom_supports, transforms=balanced_transform, chunksize=chunksize) @@ -590,7 +590,7 @@ def trans_expected(clr, chromosomes, chunksize=1000000, use_dask=False): ################### -def make_diag_tables(clr, supports, weight_name="weight", bad_bins=None): +def make_diag_tables(clr, regions, weight_name="weight", bad_bins=None): """ For every support region infer diagonals that intersect this region and calculate the size of these intersections in pixels, both "total" and @@ -606,7 +606,7 @@ def make_diag_tables(clr, supports, weight_name="weight", bad_bins=None): ---------- clr : cooler.Cooler Input cooler - supports : list + regions : list a list of genomic support regions weight_name : str name of the weight vector in the "bins" table, @@ -648,7 +648,7 @@ def make_diag_tables(clr, supports, weight_name="weight", bad_bins=None): where = np.flatnonzero diag_tables = {} - for region in supports: + for region in regions: # parse region if str if isinstance(region, str): region = bioframe.parse_region(region) @@ -683,27 +683,27 @@ def make_diag_tables(clr, supports, weight_name="weight", bad_bins=None): return diag_tables -def _diagsum_symm(clr, fields, transforms, supports, span): +def _diagsum_symm(clr, fields, transforms, regions, span): lo, hi = span bins = clr.bins()[:] pixels = clr.pixels()[lo:hi] pixels = cooler.annotate(pixels, bins, replace=False) - pixels["support1"] = assign_supports(pixels, supports, suffix="1") - pixels["support2"] = assign_supports(pixels, supports, suffix="2") - pixels = pixels[pixels["support1"] == pixels["support2"]].copy() + pixels["region1"] = assign_supports(pixels, regions, suffix="1") + pixels["regiont2"] = assign_supports(pixels, regions, suffix="2") + pixels = pixels[pixels["region1"] == pixels["region2"]].copy() pixels["diag"] = pixels["bin2_id"] - pixels["bin1_id"] for field, t in transforms.items(): pixels[field] = t(pixels) - pixelgroups = dict(iter(pixels.groupby("support1"))) + pixelgroups = dict(iter(pixels.groupby("region1"))) return { int(i): group.groupby("diag")[fields].sum() for i, group in pixelgroups.items() } -def _diagsum_asymm(clr, fields, transforms, contact_type, supports1, supports2, span): +def _diagsum_asymm(clr, fields, transforms, contact_type, regions1, regions2, span): lo, hi = span bins = clr.bins()[:] pixels = clr.pixels()[lo:hi] @@ -718,17 +718,17 @@ def _diagsum_asymm(clr, fields, transforms, contact_type, supports1, supports2, for field, t in transforms.items(): pixels[field] = t(pixels) - pixels["support1"] = assign_supports(pixels, supports1, suffix="1") - pixels["support2"] = assign_supports(pixels, supports2, suffix="2") + pixels["region1"] = assign_supports(pixels, regions1, suffix="1") + pixels["region2"] = assign_supports(pixels, regions2, suffix="2") - pixel_groups = dict(iter(pixels.groupby(["support1", "support2"]))) + pixel_groups = dict(iter(pixels.groupby(["region1", "region2"]))) return { (int(i), int(j)): group.groupby("diag")[fields].sum() for (i, j), group in pixel_groups.items() } -def _blocksum_asymm(clr, fields, transforms, supports1, supports2, span): +def _blocksum_asymm(clr, fields, transforms, regions1, regions2, span): lo, hi = span bins = clr.bins()[:] pixels = clr.pixels()[lo:hi] @@ -738,11 +738,11 @@ def _blocksum_asymm(clr, fields, transforms, supports1, supports2, span): for field, t in transforms.items(): pixels[field] = t(pixels) - pixels["support1"] = assign_supports(pixels, supports1, suffix="1") - pixels["support2"] = assign_supports(pixels, supports2, suffix="2") + pixels["region1"] = assign_supports(pixels, regions1, suffix="1") + pixels["region2"] = assign_supports(pixels, regions2, suffix="2") pixels = pixels.dropna() - pixel_groups = dict(iter(pixels.groupby(["support1", "support2"]))) + pixel_groups = dict(iter(pixels.groupby(["region1", "region2"]))) return { (int(i), int(j)): group[fields].sum() for (i, j), group in pixel_groups.items() } @@ -750,7 +750,7 @@ def _blocksum_asymm(clr, fields, transforms, supports1, supports2, span): def diagsum( clr, - supports, + regions, transforms=None, weight_name="weight", bad_bins=None, @@ -766,7 +766,7 @@ def diagsum( ---------- clr : cooler.Cooler Cooler object - supports : sequence of genomic range tuples + regions : sequence of genomic range tuples Support regions for intra-chromosomal diagonal summation transforms : dict of str -> callable, optional Transformations to apply to pixels. The result will be assigned to @@ -794,21 +794,21 @@ def diagsum( """ spans = partition(0, len(clr.pixels()), chunksize) fields = ["count"] + list(transforms.keys()) - dtables = make_diag_tables(clr, supports, weight_name=weight_name, bad_bins=bad_bins) + dtables = make_diag_tables(clr, regions, weight_name=weight_name, bad_bins=bad_bins) for dt in dtables.values(): for field in fields: agg_name = "{}.sum".format(field) dt[agg_name] = 0 - job = partial(_diagsum_symm, clr, fields, transforms, supports) + job = partial(_diagsum_symm, clr, fields, transforms, regions) results = map(job, spans) for result in results: for i, agg in result.items(): - support = supports[i] + region = regions[i] for field in fields: agg_name = "{}.sum".format(field) - dtables[support][agg_name] = dtables[support][agg_name].add( + dtables[region][agg_name] = dtables[region][agg_name].add( agg[field], fill_value=0 ) @@ -824,8 +824,8 @@ def diagsum( def diagsum_asymm( clr, - supports1, - supports2, + regions1, + regions2, contact_type="cis", transforms=None, weight_name="weight", @@ -842,7 +842,7 @@ def diagsum_asymm( ---------- clr : cooler.Cooler Cooler object - supports : sequence of genomic range tuples + regions : sequence of genomic range tuples Support regions for intra-chromosomal diagonal summation transforms : dict of str -> callable, optional Transformations to apply to pixels. The result will be assigned to @@ -870,7 +870,7 @@ def diagsum_asymm( """ spans = partition(0, len(clr.pixels()), chunksize) fields = ["count"] + list(transforms.keys()) - areas = list(zip(supports1, supports2)) + areas = list(zip(regions1, regions2)) dtables = make_diag_tables(clr, areas, weight_name=weight_name, bad_bins=bad_bins) for dt in dtables.values(): @@ -879,16 +879,16 @@ def diagsum_asymm( dt[agg_name] = 0 job = partial( - _diagsum_asymm, clr, fields, transforms, contact_type, supports1, supports2 + _diagsum_asymm, clr, fields, transforms, contact_type, regions1, regions2 ) results = map(job, spans) for result in results: for (i, j), agg in result.items(): - support1 = supports1[i] - support2 = supports2[j] + region1 = regions1[i] + region2 = regions2[j] for field in fields: agg_name = "{}.sum".format(field) - dtables[support1, support2][agg_name] = dtables[support1, support2][ + dtables[region1, region2][agg_name] = dtables[region1, region2][ agg_name ].add(agg[field], fill_value=0) @@ -904,7 +904,7 @@ def diagsum_asymm( def blocksum_pairwise( clr, - supports, + regions, transforms=None, weight_name="weight", bad_bins=None, @@ -918,7 +918,7 @@ def blocksum_pairwise( ---------- clr : cooler.Cooler Cooler object - supports : sequence of genomic range tuples + regions : sequence of genomic range tuples Support regions for summation. Blocks for all pairs of support regions will be used. transforms : dict of str -> callable, optional @@ -944,18 +944,18 @@ def blocksum_pairwise( """ - blocks = list(combinations(supports, 2)) - supports1, supports2 = list(zip(*blocks)) + blocks = list(combinations(regions, 2)) + regions1, regions2 = list(zip(*blocks)) spans = partition(0, len(clr.pixels()), chunksize) fields = ["count"] + list(transforms.keys()) - n_tot = count_all_pixels_per_block(clr, supports) - n_bad = count_bad_pixels_per_block(clr, supports, weight_name=weight_name, bad_bins=bad_bins) + n_tot = count_all_pixels_per_block(clr, regions) + n_bad = count_bad_pixels_per_block(clr, regions, weight_name=weight_name, bad_bins=bad_bins) records = {(c1, c2): defaultdict(int) for (c1, c2) in blocks} for c1, c2 in blocks: records[c1, c2]["n_valid"] = n_tot[c1, c2] - n_bad[c1, c2] - job = partial(_blocksum_asymm, clr, fields, transforms, supports1, supports2) + job = partial(_blocksum_asymm, clr, fields, transforms, regions1, regions2) results = map(job, spans) for result in results: for (i, j), agg in result.items(): @@ -963,6 +963,6 @@ def blocksum_pairwise( agg_name = "{}.sum".format(field) s = agg[field].item() if not np.isnan(s): - records[supports1[i], supports2[j]][agg_name] += s + records[regions1[i], regions2[j]][agg_name] += s return records From c0e42db84ae3fd6aeee0140412b2fb5caac76562 Mon Sep 17 00:00:00 2001 From: Anton Goloborodko Date: Tue, 7 Apr 2020 17:22:40 +0200 Subject: [PATCH 14/71] common.py: add assign_regions_to_bins --- cooltools/lib/common.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/cooltools/lib/common.py b/cooltools/lib/common.py index 0c71f114..3b5c4296 100644 --- a/cooltools/lib/common.py +++ b/cooltools/lib/common.py @@ -49,3 +49,21 @@ def assign_supports(features, supports, labels=False, suffix=""): supp_col = supp_col.map(lambda i: supports[int(i)], na_action="ignore") return supp_col + + + +def assign_regions_to_bins(bin_ids, regions_span): + + regions_binsorted = (regions_span[(regions_span['bin_start']>=0) + &(regions_span['bin_end']>=0) ] + .sort_values(['bin_start', 'bin_end']) + .reset_index()) + + bin_reg_idx_lo = regions_span['bin_start'].searchsorted(bin_ids,'right')-1 + bin_reg_idx_hi = regions_span['bin_end'].searchsorted(bin_ids,'right') + mask_assigned = (bin_reg_idx_lo == bin_reg_idx_hi) & (bin_reg_idx_lo>=0) + + region_ids = pd.array([pd.NA]*len(bin_ids)) + region_ids[mask_assigned] = regions_span['name'][bin_reg_idx_lo[mask_assigned]] + + return region_ids \ No newline at end of file From 379ab784ed455fab62612c6ab1351078bede534c Mon Sep 17 00:00:00 2001 From: Anton Goloborodko Date: Tue, 14 Apr 2020 13:10:53 +0200 Subject: [PATCH 15/71] expected.py: bugfix; rename diag->dist --- cooltools/expected.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index 3df316e3..3253f1f7 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -689,11 +689,11 @@ def _diagsum_symm(clr, fields, transforms, regions, span): pixels = clr.pixels()[lo:hi] pixels = cooler.annotate(pixels, bins, replace=False) - pixels["region1"] = assign_supports(pixels, regions, suffix="1") - pixels["regiont2"] = assign_supports(pixels, regions, suffix="2") + pixels["region1"] = assign_supports(pixels['bin1_id'], regions) + pixels["region2"] = assign_supports(pixels['bin2_id'], regions) pixels = pixels[pixels["region1"] == pixels["region2"]].copy() - pixels["diag"] = pixels["bin2_id"] - pixels["bin1_id"] + pixels["dist"] = pixels["bin2_id"] - pixels["bin1_id"] for field, t in transforms.items(): pixels[field] = t(pixels) @@ -714,16 +714,16 @@ def _diagsum_asymm(clr, fields, transforms, contact_type, regions1, regions2, sp elif contact_type == "trans": pixels = pixels[pixels["chrom1"] != pixels["chrom2"]].copy() - pixels["diag"] = pixels["bin2_id"] - pixels["bin1_id"] + pixels["dist"] = pixels["bin2_id"] - pixels["bin1_id"] for field, t in transforms.items(): pixels[field] = t(pixels) - pixels["region1"] = assign_supports(pixels, regions1, suffix="1") - pixels["region2"] = assign_supports(pixels, regions2, suffix="2") + pixels["region1"] = assign_supports(pixels['bin1_id'], regions1) + pixels["region2"] = assign_supports(pixels['bin2_id'], regions2) pixel_groups = dict(iter(pixels.groupby(["region1", "region2"]))) return { - (int(i), int(j)): group.groupby("diag")[fields].sum() + (int(i), int(j)): group.groupby("dist")[fields].sum() for (i, j), group in pixel_groups.items() } From 285136767922adf9c45ad53cbbe6f3c172fb0957 Mon Sep 17 00:00:00 2001 From: Ilya Flyamer Date: Tue, 14 Apr 2020 20:49:42 +0100 Subject: [PATCH 16/71] Allow regions in expected CLI (#146) * Make saddle strength work with NaNs * Allow regions in CLI for expected * Fix region_names without regions --- cooltools/cli/compute_expected.py | 85 ++++++++++++++++++------------- 1 file changed, 51 insertions(+), 34 deletions(-) diff --git a/cooltools/cli/compute_expected.py b/cooltools/cli/compute_expected.py index c6fc83ab..90b7c68a 100644 --- a/cooltools/cli/compute_expected.py +++ b/cooltools/cli/compute_expected.py @@ -5,6 +5,7 @@ import click from . import cli +from . import util # might be relevant to us ... # https://stackoverflow.com/questions/46577535/how-can-i-run-a-dask-distributed-local-cluster-from-the-command-line @@ -12,12 +13,7 @@ @cli.command() -@click.argument( - "cool_path", - metavar="COOL_PATH", - type=str, - nargs=1 -) +@click.argument("cool_path", metavar="COOL_PATH", type=str, nargs=1) @click.option( "--nproc", "-p", @@ -52,22 +48,22 @@ "--contact-type", "-t", help="compute expected for cis or trans region of a Hi-C map." - "Ignored when genomic-regions are provided", + "Ignored when genomic-regions are provided", type=click.Choice(["cis", "trans"]), default="cis", show_default=True, ) @click.option( - "--genomic-regions", - help="Path to a BED or BEDPE file containing genomic regions " - "for which expected will be calculated. [Not Implemented]", + "--regions", + help="Path to a BED file containing genomic regions " + "for which expected will be calculated.", type=click.Path(exists=True), required=False, ) @click.option( "--balance/--no-balance", help="Apply balancing weights to data before calculating expected." - "Bins masked in the balancing weights are ignored from calcualtions.", + "Bins masked in the balancing weights are ignored from calcualtions.", is_flag=True, default=True, show_default=True, @@ -82,8 +78,8 @@ @click.option( "--blacklist", help="Path to a 3-column BED file containing genomic regions to mask " - "out during calculation of expected. Overwrites inference of " - "'bad' regions from balancing weights. [Not Implemented]", + "out during calculation of expected. Overwrites inference of " + "'bad' regions from balancing weights. [Not Implemented]", type=click.Path(exists=True), required=False, ) @@ -101,7 +97,7 @@ def compute_expected( output, hdf, contact_type, - genomic_regions, + regions, balance, weight_name, blacklist, @@ -118,24 +114,41 @@ def compute_expected( """ - if genomic_regions is not None: - raise NotImplementedError( - "Custom genomic regions for calculation of expected are not implemented in CLI," - "use `cooltools.expected.blocksum/diagsum` functions." - ) + # if regions is not None: + # raise NotImplementedError( + # "Custom genomic regions for calculation of expected are not implemented in CLI," + # "use `cooltools.expected.blocksum/diagsum` functions." + # ) if blacklist is not None: raise NotImplementedError( "Custom genomic regions for masking from calculation of expected" "are not implemented." - ) + ) # use blacklist-ing from cooler balance module # https://github.com/mirnylab/cooler/blob/843dadca5ef58e3b794dbaf23430082c9a634532/cooler/cli/balance.py#L175 - - clr = cooler.Cooler(cool_path) - supports = [(chrom, 0, clr.chromsizes[chrom]) for chrom in clr.chromnames] + if regions is None: + regions = [(chrom, 0, clr.chromsizes[chrom]) for chrom in clr.chromnames] + region_names = [chrom for chrom in clr.chromnames] + else: + regions_buf, names = util.sniff_for_header(regions) + if names is not None: + regions = pd.read_csv(regions_buf, skiprows=1, sep="\t", header=None) + else: + regions = pd.read_csv(regions_buf, sep="\t", header=None) + if regions.shape[1] not in (3, 4): + raise ValueError( + "The region file does not have three or four tab-delimited columns." + "We expect a bed file with columns chrom, start, end, and optional name" + ) + if regions.shape[1] == 4: + region_names = regions[:, 3] + regions = regions[:, :3] + else: + region_names = list(regions.apply(lambda x: "{}:{}-{}".format(*x), axis=1)) + regions = [tuple(row)[:3] for i, row in regions.iterrows()] # define transofrms - balanced and raw ('count') for now if balance: @@ -159,38 +172,42 @@ def compute_expected( if contact_type == "cis": tables = expected.diagsum( clr, - supports, + regions, transforms=transforms, weight_name=weight_name, bad_bins=None, chunksize=chunksize, ignore_diags=ignore_diags, - map=map_ + map=map_, ) result = pd.concat( - [tables[support] for support in supports], - keys=[support[0] for support in supports], - names=["chrom"], + [tables[region] for region in regions], + keys=[name for name in region_names], + names=["region"], ) result = result.reset_index() elif contact_type == "trans": records = expected.blocksum_pairwise( clr, - supports, + regions, transforms=transforms, weight_name=weight_name, bad_bins=None, chunksize=chunksize, - map=map_ + map=map_, ) result = pd.DataFrame( [ - {"chrom1": s1[0], "chrom2": s2[0], **rec} - for (s1, s2), rec in records.items() + { + "region1": region_names[regions.index(r1)], + "region2": region_names[regions.index(r2)], + **rec, + } + for (r1, r2), rec in records.items() ], - columns=["chrom1", "chrom2", "n_valid", "count.sum"] + \ - [ k+".sum" for k in transforms.keys() ] + columns=["region1", "region2", "n_valid", "count.sum"] + + [k + ".sum" for k in transforms.keys()], ) finally: if nproc > 1: From 21cec77ad4115b8bb95ea31d0397d902214f010c Mon Sep 17 00:00:00 2001 From: Sergey Venev Date: Tue, 5 May 2020 14:42:42 -0400 Subject: [PATCH 17/71] merge latest from master to develop (#155) * More docstring edits * Mock out imports directly * Apply suggestions from code review Co-Authored-By: Sergey Venev * Restore numpy to docs requirements * Fix trans bad pixel counting * fixed typo, added scalar extraction from array * Update cooltools/expected.py Co-Authored-By: Nezar Abdennur * Set default zoom order to 1 Somehow default zoom order was set to 3 instead of a much better default of 1! Goes against the docstring too. * Change to new bioframe function names (#149) * updated bioframe.slice_bedframe to bioframe.bedslice in line 337 * updated bioframe.bisect_bedframe to bioframe.bedbisect in line 356 * Update license * Bump to dev version * Revert changes to bioframe functions * Pin dependency of cooltools 0.3 to bioframe 0.0 * Release v0.3.2 Co-authored-by: Nezar Abdennur Co-authored-by: Ilya Flyamer Co-authored-by: Maksim Imakaev Co-authored-by: Sameer Abraham --- CHANGELOG.md | 16 +++++++++++++++- LICENSE | 2 +- cooltools/__init__.py | 7 +++---- cooltools/lib/numutils.py | 2 +- requirements.txt | 2 +- 5 files changed, 21 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 677c2817..b5f229fc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,20 @@ # Release notes -## [v0.3.0](https://github.com/mirnylab/cooltools/compare/v0.2.0...HEAD) +## [Upcoming release](https://github.com/mirnylab/cooltools/compare/v0.3.2...HEAD) + +## [v0.3.2](https://github.com/mirnylab/cooltools/compare/v0.3.0...v0.3.2) + +Date: 2020-05-05 + +Updates and bug fixes +* Error checking for vmin/vmax in compute-saddle +* Various updates and fixes to expected and dot-caller code + +Project health +* Added docs on RTD, tutorial notebooks, code formatting, linting, and contribution guidelines. + + +## [v0.3.0](https://github.com/mirnylab/cooltools/compare/v0.2.0...v0.3.0) Date: 2019-11-04 diff --git a/LICENSE b/LICENSE index 95fdbf7b..7578775d 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2017 mirnylab +Copyright (c) 2017 Cooltools developers Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/cooltools/__init__.py b/cooltools/__init__.py index be08b2fc..5a72e095 100644 --- a/cooltools/__init__.py +++ b/cooltools/__init__.py @@ -5,14 +5,13 @@ The tools for your .cool's. -:copyright: (c) 2017 Massachusetts Institute of Technology -:author: Mirny Lab -:license: BSD +:author: Cooltools developers +:license: MIT """ import logging -__version__ = "0.3.0" +__version__ = "0.3.2" from . import io from . import lib diff --git a/cooltools/lib/numutils.py b/cooltools/lib/numutils.py index a19e6b2b..16602a7f 100644 --- a/cooltools/lib/numutils.py +++ b/cooltools/lib/numutils.py @@ -1099,7 +1099,7 @@ def zoom_array( in_array, final_shape, same_sum=False, - zoom_function=partial(zoom, order=3), + zoom_function=partial(zoom, order=1), **zoom_kwargs ): """Rescale an array or image. diff --git a/requirements.txt b/requirements.txt index 90b1a499..7a7a6590 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,4 @@ -bioframe +bioframe<0.1.0 click>=7 cooler>=0.8.5 cython From a129acf81ee2e6b32677716de9ebfaa03c5abccb Mon Sep 17 00:00:00 2001 From: Nezar Abdennur Date: Tue, 5 May 2020 14:46:57 -0400 Subject: [PATCH 18/71] Bump again to 0.4.0-dev --- cooltools/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cooltools/__init__.py b/cooltools/__init__.py index 5a72e095..b2ff3d17 100644 --- a/cooltools/__init__.py +++ b/cooltools/__init__.py @@ -11,7 +11,7 @@ """ import logging -__version__ = "0.3.2" +__version__ = "0.4.0-dev" from . import io from . import lib From 32be1c51f06ee323b6cbb8c1518b71eb7772db63 Mon Sep 17 00:00:00 2001 From: Nezar Abdennur Date: Tue, 5 May 2020 14:47:22 -0400 Subject: [PATCH 19/71] Start using CliRunner for testing cli commands --- tests/test_compartments_saddle.py | 62 +++++++++++++++++-------------- 1 file changed, 34 insertions(+), 28 deletions(-) diff --git a/tests/test_compartments_saddle.py b/tests/test_compartments_saddle.py index 0d69abf6..1206c7bd 100644 --- a/tests/test_compartments_saddle.py +++ b/tests/test_compartments_saddle.py @@ -4,20 +4,22 @@ import numpy as np import pandas as pd +from click.testing import CliRunner +from cooltools.cli import cli def test_compartment_cli(request, tmpdir): in_cool = op.join(request.fspath.dirname, "data/sin_eigs_mat.cool") out_eig_prefix = op.join(tmpdir, "test.eigs") - try: - subprocess.check_output( - f"python -m cooltools call-compartments -o {out_eig_prefix} {in_cool}", - shell=True, - ).decode("ascii") - except subprocess.CalledProcessError as e: - print(e.output) - print(sys.exc_info()) - raise e + runner = CliRunner() + result = runner.invoke( + cli, [ + 'call-compartments', + '-o', out_eig_prefix, + in_cool, + ] + ) + assert result.exit_code == 0 test_eigs = pd.read_table(out_eig_prefix + ".cis.vecs.tsv", sep="\t") gb = test_eigs.groupby("chrom") for chrom in gb.groups: @@ -36,15 +38,15 @@ def test_saddle_cli(request, tmpdir): out_expected = op.join(tmpdir, "test.expected") out_saddle_prefix = op.join(tmpdir, "test.saddle") - try: - subprocess.check_output( - f"python -m cooltools call-compartments -o {out_eig_prefix} {in_cool}", - shell=True, - ).decode("ascii") - except subprocess.CalledProcessError as e: - print(e.output) - print(sys.exc_info()) - raise e + runner = CliRunner() + result = runner.invoke( + cli, [ + 'call-compartments', + '-o', out_eig_prefix, + in_cool + ] + ) + assert result.exit_code == 0 try: subprocess.check_output( @@ -56,16 +58,20 @@ def test_saddle_cli(request, tmpdir): print(sys.exc_info()) raise e - try: - subprocess.check_output( - f"python -m cooltools compute-saddle -o {out_saddle_prefix} --range -0.5 0.5 " - + f"--n-bins 30 --scale log {in_cool} {out_eig_prefix}.cis.vecs.tsv {out_expected}", - shell=True, - ).decode("ascii") - except subprocess.CalledProcessError as e: - print(e.output) - print(sys.exc_info()) - raise e + runner = CliRunner() + result = runner.invoke( + cli, [ + "compute-saddle", + "-o", out_saddle_prefix, + "--range", "-0.5", "0.5", + "--n-bins", "30", + "--scale", "log", + in_cool, + f"{out_eig_prefix}.cis.vecs.tsv", + out_expected + ] + ) + assert result.exit_code == 0 log2_sad = np.log2(np.load(out_saddle_prefix + ".saddledump.npz")["saddledata"]) bins = np.load(out_saddle_prefix + ".saddledump.npz")["binedges"] From 34b46813fb3c5d63e780ae9a9120fbfd4cb3091b Mon Sep 17 00:00:00 2001 From: Nezar Abdennur Date: Tue, 5 May 2020 14:49:29 -0400 Subject: [PATCH 20/71] Develop (#156) * Bump again to 0.4.0-dev * Start using CliRunner for testing cli commands --- cooltools/__init__.py | 2 +- tests/test_compartments_saddle.py | 62 +++++++++++++++++-------------- 2 files changed, 35 insertions(+), 29 deletions(-) diff --git a/cooltools/__init__.py b/cooltools/__init__.py index 5a72e095..b2ff3d17 100644 --- a/cooltools/__init__.py +++ b/cooltools/__init__.py @@ -11,7 +11,7 @@ """ import logging -__version__ = "0.3.2" +__version__ = "0.4.0-dev" from . import io from . import lib diff --git a/tests/test_compartments_saddle.py b/tests/test_compartments_saddle.py index 0d69abf6..1206c7bd 100644 --- a/tests/test_compartments_saddle.py +++ b/tests/test_compartments_saddle.py @@ -4,20 +4,22 @@ import numpy as np import pandas as pd +from click.testing import CliRunner +from cooltools.cli import cli def test_compartment_cli(request, tmpdir): in_cool = op.join(request.fspath.dirname, "data/sin_eigs_mat.cool") out_eig_prefix = op.join(tmpdir, "test.eigs") - try: - subprocess.check_output( - f"python -m cooltools call-compartments -o {out_eig_prefix} {in_cool}", - shell=True, - ).decode("ascii") - except subprocess.CalledProcessError as e: - print(e.output) - print(sys.exc_info()) - raise e + runner = CliRunner() + result = runner.invoke( + cli, [ + 'call-compartments', + '-o', out_eig_prefix, + in_cool, + ] + ) + assert result.exit_code == 0 test_eigs = pd.read_table(out_eig_prefix + ".cis.vecs.tsv", sep="\t") gb = test_eigs.groupby("chrom") for chrom in gb.groups: @@ -36,15 +38,15 @@ def test_saddle_cli(request, tmpdir): out_expected = op.join(tmpdir, "test.expected") out_saddle_prefix = op.join(tmpdir, "test.saddle") - try: - subprocess.check_output( - f"python -m cooltools call-compartments -o {out_eig_prefix} {in_cool}", - shell=True, - ).decode("ascii") - except subprocess.CalledProcessError as e: - print(e.output) - print(sys.exc_info()) - raise e + runner = CliRunner() + result = runner.invoke( + cli, [ + 'call-compartments', + '-o', out_eig_prefix, + in_cool + ] + ) + assert result.exit_code == 0 try: subprocess.check_output( @@ -56,16 +58,20 @@ def test_saddle_cli(request, tmpdir): print(sys.exc_info()) raise e - try: - subprocess.check_output( - f"python -m cooltools compute-saddle -o {out_saddle_prefix} --range -0.5 0.5 " - + f"--n-bins 30 --scale log {in_cool} {out_eig_prefix}.cis.vecs.tsv {out_expected}", - shell=True, - ).decode("ascii") - except subprocess.CalledProcessError as e: - print(e.output) - print(sys.exc_info()) - raise e + runner = CliRunner() + result = runner.invoke( + cli, [ + "compute-saddle", + "-o", out_saddle_prefix, + "--range", "-0.5", "0.5", + "--n-bins", "30", + "--scale", "log", + in_cool, + f"{out_eig_prefix}.cis.vecs.tsv", + out_expected + ] + ) + assert result.exit_code == 0 log2_sad = np.log2(np.load(out_saddle_prefix + ".saddledump.npz")["saddledata"]) bins = np.load(out_saddle_prefix + ".saddledump.npz")["binedges"] From 2fbb2ebac89e412d0119335ae0ddbffe22b76631 Mon Sep 17 00:00:00 2001 From: mimakaev Date: Thu, 7 May 2020 14:01:43 -0400 Subject: [PATCH 21/71] fixed saddle code to accept bedslice --- cooltools/saddle.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/cooltools/saddle.py b/cooltools/saddle.py index 6427233d..676fdf49 100644 --- a/cooltools/saddle.py +++ b/cooltools/saddle.py @@ -105,7 +105,7 @@ def digitize_track(binedges, track, regions=None): regions = [bioframe.parse_region(reg) for reg in regions] grouped = track.groupby("chrom") track = pd.concat( - bioframe.bedslice(grouped, chrom, st, end) for (chrom, st, end) in regions + bioframe.bedslice(grouped, region) for region in regions ) # histogram the signal @@ -296,6 +296,7 @@ def make_saddle( """ digitized_df, name = digitized + digitized_df = digitized_df[["chrom","start","end",name]] if regions is None: regions = [ @@ -305,12 +306,10 @@ def make_saddle( else: regions = [bioframe.parse_region(reg) for reg in regions] - digitized_tracks = { - reg: bioframe.bedslice(digitized_df.groupby("chrom"), reg[0], reg[1], reg[2])[ - name - ] - for reg in regions - } + digitized_tracks = {} + for reg in regions: + track = bioframe.bedslice(digitized_df, reg) + digitized_tracks[reg] = track[name] if contact_type == "cis": supports = list(zip(regions, regions)) From 093b28d30dc565dedfccfe507214d645a76639d9 Mon Sep 17 00:00:00 2001 From: mimakaev Date: Fri, 8 May 2020 19:57:21 -0400 Subject: [PATCH 22/71] refactored diagsum --- cooltools/expected.py | 83 +++++++++++++++++++++++------------------ cooltools/lib/common.py | 2 +- 2 files changed, 48 insertions(+), 37 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index 3253f1f7..dcaa9c10 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -590,7 +590,7 @@ def trans_expected(clr, chromosomes, chunksize=1000000, use_dask=False): ################### -def make_diag_tables(clr, regions, weight_name="weight", bad_bins=None): +def make_diag_tables(clr, regions, regions2=None, weight_name="weight", bad_bins=None): """ For every support region infer diagonals that intersect this region and calculate the size of these intersections in pixels, both "total" and @@ -627,7 +627,10 @@ def make_diag_tables(clr, regions, weight_name="weight", bad_bins=None): raise NotImplementedError("providing external list \ of bad bins is not implemented.") - + regions = bioframe.region.normalize_regions(regions, clr.chromsizes).values + if regions2 is not None: + regions2 = bioframe.region.normalize_regions(regions2, clr.chromsizes).values + bins = clr.bins()[:] if weight_name is None: # ignore bad bins @@ -648,26 +651,14 @@ def make_diag_tables(clr, regions, weight_name="weight", bad_bins=None): where = np.flatnonzero diag_tables = {} - for region in regions: - # parse region if str - if isinstance(region, str): - region = bioframe.parse_region(region) - # unpack region(s) into chroms,starts,ends - if len(region) == 1: - chrom, = region - start1, end1 = 0, clr.chromsizes[chrom] - start2, end2 = start1, end1 - elif len(region) == 2: - chrom, start1, end1 = region[0] - _, start2, end2 = region[1] - elif len(region) == 3: - chrom, start1, end1 = region - start2, end2 = start1, end1 - elif len(region) == 5: - chrom, start1, end1, start2, end2 = region + for i in range(len(regions)): + chrom,start1,end1,name1 = regions[i] + if regions2 is not None: + chrom2,start2, end2,name2 = regions2[i] + assert chrom2==chrom else: - raise ValueError("Regions must be sequences of length 1, 3 or 5") - + start2, end2 = start1, end1 + # translate regions into relative bin id-s: lo1, hi1 = clr.extent((chrom, start1, end1)) lo2, hi2 = clr.extent((chrom, start2, end2)) @@ -678,7 +669,10 @@ def make_diag_tables(clr, regions, weight_name="weight", bad_bins=None): hi2 -= co bad_mask = bad_bin_dict[chrom] - diag_tables[region] = make_diag_table(bad_mask, [lo1, hi1], [lo2, hi2]) + newname = name1 + if regions2 is not None: + newname = (name1, name2) + diag_tables[newname] = make_diag_table(bad_mask, [lo1, hi1], [lo2, hi2]) return diag_tables @@ -688,9 +682,10 @@ def _diagsum_symm(clr, fields, transforms, regions, span): bins = clr.bins()[:] pixels = clr.pixels()[lo:hi] pixels = cooler.annotate(pixels, bins, replace=False) + print(pixels.columns) - pixels["region1"] = assign_supports(pixels['bin1_id'], regions) - pixels["region2"] = assign_supports(pixels['bin2_id'], regions) + pixels["region1"] = assign_supports(pixels[["chrom1","start1","end1",'bin1_id']], regions.values, suffix="1") + pixels["region2"] = assign_supports(pixels[["chrom2","start2","end2",'bin2_id']], regions.values, suffix="2") pixels = pixels[pixels["region1"] == pixels["region2"]].copy() pixels["dist"] = pixels["bin2_id"] - pixels["bin1_id"] @@ -698,9 +693,12 @@ def _diagsum_symm(clr, fields, transforms, regions, span): pixels[field] = t(pixels) pixelgroups = dict(iter(pixels.groupby("region1"))) - return { - int(i): group.groupby("diag")[fields].sum() for i, group in pixelgroups.items() - } + + values = {} + for i,group in pixelgroups.items(): + values[int(i)] = group.groupby("dist")[fields].sum() + + return values def _diagsum_asymm(clr, fields, transforms, contact_type, regions1, regions2, span): @@ -718,8 +716,8 @@ def _diagsum_asymm(clr, fields, transforms, contact_type, regions1, regions2, sp for field, t in transforms.items(): pixels[field] = t(pixels) - pixels["region1"] = assign_supports(pixels['bin1_id'], regions1) - pixels["region2"] = assign_supports(pixels['bin2_id'], regions2) + pixels["region1"] = assign_supports(pixels[["chrom","start","end",'bin1_id']], regions.values) + pixels["region2"] = assign_supports(pixels[["chrom","start","end",'bin2_id']], regions.values) pixel_groups = dict(iter(pixels.groupby(["region1", "region2"]))) return { @@ -736,10 +734,10 @@ def _blocksum_asymm(clr, fields, transforms, regions1, regions2, span): pixels = pixels[pixels["chrom1"] != pixels["chrom2"]].copy() for field, t in transforms.items(): - pixels[field] = t(pixels) + pixels[field] = t(pixels) - pixels["region1"] = assign_supports(pixels, regions1, suffix="1") - pixels["region2"] = assign_supports(pixels, regions2, suffix="2") + pixels["region1"] = assign_supports(pixels, regions1.values, suffix="1") + pixels["region2"] = assign_supports(pixels, regions2.values, suffix="2") pixels = pixels.dropna() pixel_groups = dict(iter(pixels.groupby(["region1", "region2"]))) @@ -794,6 +792,10 @@ def diagsum( """ spans = partition(0, len(clr.pixels()), chunksize) fields = ["count"] + list(transforms.keys()) + + regions = bioframe.region.normalize_regions(regions, clr.chromsizes) + rval = regions.values + dtables = make_diag_tables(clr, regions, weight_name=weight_name, bad_bins=bad_bins) for dt in dtables.values(): @@ -805,12 +807,13 @@ def diagsum( results = map(job, spans) for result in results: for i, agg in result.items(): - region = regions[i] + region = regions.loc[i,"name"] for field in fields: agg_name = "{}.sum".format(field) dtables[region][agg_name] = dtables[region][agg_name].add( agg[field], fill_value=0 ) + if ignore_diags: for dt in dtables.values(): @@ -818,8 +821,13 @@ def diagsum( agg_name = "{}.sum".format(field) j = dt.columns.get_loc(agg_name) dt.iloc[:ignore_diags, j] = np.nan - - return dtables + + result = [] + for i,dtable in dtables.items(): + dtable = dtable.reset_index() + dtable.insert(0,"region", i) + result.append(dtable) + return pd.concat(result).reset_index(drop=True) def diagsum_asymm( @@ -871,7 +879,10 @@ def diagsum_asymm( spans = partition(0, len(clr.pixels()), chunksize) fields = ["count"] + list(transforms.keys()) areas = list(zip(regions1, regions2)) - dtables = make_diag_tables(clr, areas, weight_name=weight_name, bad_bins=bad_bins) + regions1 = bioframe.region.normalize_regions(regions1, clr.chromsizes) + regions2 = bioframe.region.normalize_regions(regions2, clr.chromsizes) + + dtables = make_diag_tables(clr, regions1, regions2, weight_name=weight_name, bad_bins=bad_bins) for dt in dtables.values(): for field in fields: diff --git a/cooltools/lib/common.py b/cooltools/lib/common.py index 3b5c4296..4bc18fc0 100644 --- a/cooltools/lib/common.py +++ b/cooltools/lib/common.py @@ -29,7 +29,7 @@ def assign_supports(features, supports, labels=False, suffix=""): for i, region in enumerate(supports): # single-region support - if len(region) == 3: + if len(region) in [3,4]: sel = (features[c] == region[0]) & (features[e] > region[1]) if region[2] is not None: sel &= features[s] < region[2] From da8bfb9fcbd8b5abf705b8b8fb3b8b7ce14f6e6a Mon Sep 17 00:00:00 2001 From: sergpolly Date: Sat, 9 May 2020 01:08:28 -0400 Subject: [PATCH 23/71] implement bad_bins in make_diag_tables --- cooltools/expected.py | 29 +++++++++++++++++++++-------- 1 file changed, 21 insertions(+), 8 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index baf01856..9fb06ddc 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -613,9 +613,11 @@ def make_diag_tables(clr, supports, weight_name="weight", bad_bins=None): if weight_name is None returns 0 for each block. Balancing weight are used to infer bad bins. bad_bins : array-like - a list of bins to ignore per support region. - Overwrites inference of bad bins from balacning - weight [to be implemented]. + a list of bins to ignore. Indexes of bins must + be absolute, as in clr.bins()[:], as opposed to + being offset by chromosome start. + "bad_bins" will be combined with the bad bins + masked by balancing if there are any. Returns ------- @@ -623,11 +625,6 @@ def make_diag_tables(clr, supports, weight_name="weight", bad_bins=None): dictionary with DataFrames of relevant diagonals for every support. """ - if bad_bins is not None: - raise NotImplementedError("providing external list \ - of bad bins is not implemented.") - - bins = clr.bins()[:] if weight_name is None: # ignore bad bins @@ -646,6 +643,22 @@ def make_diag_tables(clr, supports, weight_name="weight", bad_bins=None): else: raise ValueError("`weight_name` can be `str` or `None`") + # combine custom "bad_bins" with "bad_bin_dict": + if bad_bins is not None: + # check if "bad_bins" are legit: + try: + bad_bins_chrom = bins.iloc[bad_bins].reset_index(drop=False) + except IndexError: + raise ValueError("Provided `bad_bins` are incorrect or out-of-bound") + # group them by observed chromosomes only + bad_bins_grp = bad_bins_chrom[["index","chrom"]].groupby("chrom",observed=True) + # update "bad_bin_dict" with "bad_bins" for each chrom: + for chrom, bin_ids in bad_bins_grp["index"]: + co = clr.offset(chrom) + # adjust by chromosome offset + bad_bin_dict[chrom][bin_ids.values - co] = True + + where = np.flatnonzero diag_tables = {} for region in supports: From 5daacd442b2edabde43e1cad1373577bdfdb5081 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Sat, 9 May 2020 01:09:54 -0400 Subject: [PATCH 24/71] deprecate/remove cis_/trans_expected --- cooltools/expected.py | 218 ------------------------------------------ 1 file changed, 218 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index 9fb06ddc..9cc27ef5 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -372,224 +372,6 @@ def _sum_diagonals(df, field): return reduced -def cis_expected( - clr, regions, field="balanced", chunksize=1000000, use_dask=True, ignore_diags=2 -): - """ - Compute the mean signal along diagonals of one or more regional blocks of - intra-chromosomal contact matrices. Typically used as a background model - for contact frequencies on the same polymer chain. - - Parameters - ---------- - clr : cooler.Cooler - Input Cooler - regions : iterable of genomic regions or pairs of regions - Iterable of genomic region strings or 3-tuples, or 5-tuples for pairs - of regions - field : str, optional - Which values of the contact matrix to aggregate. This is currently a - no-op. *FIXME* - chunksize : int, optional - Size of dask chunks. - - Returns - ------- - Dataframe of diagonal statistics, indexed by region and diagonal number - - """ - warnings.warn( - "`cooltools.expected.cis_expected()` is deprecated in 0.3.2, will be removed subsequently. " - "Use `cooltools.expected.diagsum()` and `cooltools.expected.diagsum_asymm()` instead.", - category=FutureWarning, - stacklevel=2, - ) - - def _bg2slice_frame(bg2, region1, region2): - """ - Slice a dataframe with columns ['chrom1', 'start1', 'end1', 'chrom2', - 'start2', 'end2']. Assumes no proper nesting of intervals. - - [Warning] this function does not follow the same logic as - cooler.matrix.fetch when start/end are at the edges of the bins. - """ - chrom1, start1, end1 = region1 - chrom2, start2, end2 = region2 - if end1 is None: - end1 = np.inf - if end2 is None: - end2 = np.inf - out = bg2[ - (bg2["chrom1"] == chrom1) - & (bg2["start1"] >= start1) - & (bg2["end1"] < end1) - & (bg2["chrom2"] == chrom2) - & (bg2["start2"] >= start2) - & (bg2["end2"] < end2) - ] - return out - - import dask.dataframe as dd - from cooler.sandbox.dask import read_table - - if use_dask: - pixels = read_table(clr.uri + "/pixels", chunksize=chunksize) - else: - pixels = clr.pixels()[:] - pixels = cooler.annotate(pixels, clr.bins(), replace=False) - pixels = pixels[pixels.chrom1 == pixels.chrom2] - - named_regions = False - if isinstance(regions, pd.DataFrame): - named_regions = True - chroms = regions["chrom"].values - names = regions["name"].values - regions = regions[["chrom", "start", "end"]].to_records(index=False) - else: - chroms = [region[0] for region in regions] - names = chroms - cis_maps = {chrom: pixels[pixels.chrom1 == chrom] for chrom in chroms} - - diag_tables = [] - data_sums = [] - - for region in regions: - if len(region) == 1: - chrom, = region - start1, end1 = 0, clr.chromsizes[chrom] - start2, end2 = start1, end1 - elif len(region) == 3: - chrom, start1, end1 = region - start2, end2 = start1, end1 - elif len(region) == 5: - chrom, start1, end1, start2, end2 = region - else: - raise ValueError("Regions must be sequences of length 1, 3 or 5") - - bins = clr.bins().fetch(chrom).reset_index(drop=True) - bad_mask = np.array(bins["weight"].isnull()) - lo1, hi1 = clr.extent((chrom, start1, end1)) - lo2, hi2 = clr.extent((chrom, start2, end2)) - co = clr.offset(chrom) - lo1 -= co - lo2 -= co - hi1 -= co - hi2 -= co - - dt = make_diag_table(bad_mask, [lo1, hi1], [lo2, hi2]) - sel = _bg2slice_frame( - cis_maps[chrom], (chrom, start1, end1), (chrom, start2, end2) - ).copy() - sel["diag"] = sel["bin2_id"] - sel["bin1_id"] - sel["balanced"] = sel["count"] * sel["weight1"] * sel["weight2"] - agg = _sum_diagonals(sel, field) - diag_tables.append(dt) - data_sums.append(agg) - - # run dask scheduler - if len(data_sums) and isinstance(data_sums[0], dd.Series): - data_sums = dd.compute(*data_sums) - - # append to tables - for dt, agg in zip(diag_tables, data_sums): - dt[agg.name] = 0 - dt[agg.name] = dt[agg.name].add(agg, fill_value=0) - dt.iloc[:ignore_diags, dt.columns.get_loc(agg.name)] = np.nan - - # merge and return - if named_regions: - dtable = pd.concat( - diag_tables, keys=zip(names, chroms), names=["name", "chrom"] - ) - else: - dtable = pd.concat(diag_tables, keys=list(chroms), names=["chrom"]) - - # the actual expected is balanced.sum/n_valid: - dtable["balanced.avg"] = dtable["balanced.sum"] / dtable["n_valid"] - return dtable - - -def trans_expected(clr, chromosomes, chunksize=1000000, use_dask=False): - """ - Aggregate the signal in intrachromosomal blocks. - Can be used as abackground for contact frequencies between chromosomes. - - Parameters - ---------- - clr : cooler.Cooler - Cooler object - chromosomes : list of str - List of chromosome names - chunksize : int, optional - Size of dask chunks - use_dask : bool, optional - option to use dask - - Returns - ------- - pandas.DataFrame that stores total number of - interactions between a pair of chromosomes: 'balanced.sum', - corresponding number of bins involved - in the inter-chromosomal interactions: 'n_valid', - and a ratio 'balanced.avg = balanced.sum/n_valid', that is - the actual value of expected for every interchromosomal pair. - - """ - warnings.warn( - "`cooltools.expected.trans_expected()` is deprecated in 0.3.2, will be removed subsequently. " - "Use `cooltools.expected.blocksum_pairwise()` instead.", - category=FutureWarning, - stacklevel=2, - ) - - if use_dask: - # pixels = daskify(clr.filename, clr.root + '/pixels', chunksize=chunksize) - raise NotImplementedError("To be implemented once dask supports MultiIndex") - - # turn chromosomes into supports: - chrom_supports = [ (chrom, 0, None) for chrom in chromosomes ] - # use balaned transformation only: - balanced_transform = { - "balanced": \ - lambda pixels: pixels["count"] * pixels["weight1"] * pixels["weight2"] - } - - # trans_expected is simply a wrapper around new blocksum_pairwise - # but it preserved the interface of the original trans_expected - trans_records = blocksum_pairwise(clr, - supports=chrom_supports, - transforms=balanced_transform, - chunksize=chunksize) - - # trans_records are inter-chromosomal only, - # changing trans_records keys to reflect that: - # region[0] for a region = (chrom, start, stop) - trans_records = { - ( region1[0], region2[0] ): val for ( region1, region2 ), val in trans_records.items() - } - - # turn trans_records into a DataFrame with - # MultiIndex, that stores values of 'balanced.sum' - # and 'n_valid' values for each pair of chromosomes: - trans_df = pd.DataFrame.from_dict( trans_records, orient="index" ) - trans_df.index.rename( ["chrom1","chrom2"], inplace=True ) - # an alternative way to get from records to DataFrame, as in CLI expected: - # result = pd.DataFrame( - # [ - # {"chrom1": s1[0], "chrom2": s2[0], **rec} - # for (s1, s2), rec in trans_records.items() - # ], - # columns=["chrom1", "chrom2", "n_valid", "count.sum", "balanced.sum"], - # ) - - # the actual expected is balanced.sum/n_valid: - trans_df["balanced.avg"] = trans_df["balanced.sum"] / trans_df["n_valid"] - return trans_df - - -################### - - def make_diag_tables(clr, supports, weight_name="weight", bad_bins=None): """ For every support region infer diagonals that intersect this region From 28efb3d1b986dcc5cf1711c2ab820f1eab5080e6 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Sat, 9 May 2020 03:03:39 -0400 Subject: [PATCH 25/71] implement bad_bins in count_bad_pixels_per_block --- cooltools/expected.py | 45 ++++++++++++++++++++++++------------------- 1 file changed, 25 insertions(+), 20 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index 9cc27ef5..c25f2183 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -251,9 +251,11 @@ def count_bad_pixels_per_block(clr, supports, weight_name="weight", bad_bins=Non if weight_name is None returns 0 for each block. Balancing weight are used to infer bad bins. bad_bins : array-like - a list of bins to ignore per support region. - Overwrites inference of bad bins from balacning - weight [to be implemented]. + additional list of bad bins. Bin indices must + be absolute, as in clr.bins()[:], as opposed to + being offset by chromosome start. + "bad_bins" will be combined with the bad bins + masked by balancing if there are any. Returns ------- @@ -262,36 +264,39 @@ def count_bad_pixels_per_block(clr, supports, weight_name="weight", bad_bins=Non """ n = len(supports) - if bad_bins is not None: - raise NotImplementedError("providing external list \ - of bad bins is not implemented.") + if bad_bins is None: + bad_bins = np.asarray([]).astype(int) + else: + bad_bins = np.asarray(bad_bins).astype(int) # Get the total number of bins per region + # and relative indices of bad_bins per region: n_tot = [] + bad_bins_dict = {} for region in supports: lo, hi = clr.extent(region) n_tot.append(hi - lo) + bad_bins_reg = bad_bins[(bad_bins>=lo)&(bad_bins Date: Sat, 9 May 2020 03:07:05 -0400 Subject: [PATCH 26/71] fix bad_bins docstrings in diag and block-sums --- cooltools/expected.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index c25f2183..c3e5f4bf 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -578,8 +578,8 @@ def diagsum( Use `None` to avoid masking "bad" pixels. bad_bins : array-like a list of bins to ignore per support region. - Overwrites inference of bad bins from balacning - weight [to be implemented]. + Combines with the list of bad bins from balacning + weight. chunksize : int, optional Size of pixel table chunks to process ignore_diags : int, optional @@ -654,8 +654,8 @@ def diagsum_asymm( Use `None` to avoid masking "bad" pixels. bad_bins : array-like a list of bins to ignore per support region. - Overwrites inference of bad bins from balacning - weight [to be implemented]. + Combines with the list of bad bins from balacning + weight. chunksize : int, optional Size of pixel table chunks to process ignore_diags : int, optional @@ -731,8 +731,8 @@ def blocksum_pairwise( Use `None` to avoid masking "bad" pixels. bad_bins : array-like a list of bins to ignore per support region. - Overwrites inference of bad bins from balacning - weight [to be implemented]. + Combines with the list of bad bins from balacning + weight. chunksize : int, optional Size of pixel table chunks to process map : callable, optional From 8e957d3108e735c38a85e533d40fc865107b69c9 Mon Sep 17 00:00:00 2001 From: mimakaev Date: Sat, 9 May 2020 06:35:46 -0400 Subject: [PATCH 27/71] changes in saddle and expected to accept new expected format --- cooltools/expected.py | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index c6912541..387003f3 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -686,7 +686,6 @@ def _diagsum_symm(clr, fields, transforms, regions, span): bins = clr.bins()[:] pixels = clr.pixels()[lo:hi] pixels = cooler.annotate(pixels, bins, replace=False) - print(pixels.columns) pixels["region1"] = assign_supports(pixels[["chrom1","start1","end1",'bin1_id']], regions.values, suffix="1") pixels["region2"] = assign_supports(pixels[["chrom2","start2","end2",'bin2_id']], regions.values, suffix="2") @@ -1107,15 +1106,6 @@ def logbin_expected( from cooltools.lib.numutils import logbins - exp = ( - pd.concat( - [i.reset_index() for i in exp.values()], - keys=map(repr, exp.keys()), - names=["region"], - ) - .reset_index(level=0) - .reset_index(drop=True) - ) exp = exp[~pd.isna(exp["balanced.sum"])] exp["x"] = exp.pop("diag") diagmax = exp["x"].max() From f648a5cd8f62a3ecabdc1164534c90ac30470737 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Sat, 9 May 2020 11:30:49 -0400 Subject: [PATCH 28/71] fix silly changes brought from master --- cooltools/expected.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index 0e431a21..9bce493a 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -218,8 +218,8 @@ def count_all_pixels_per_block(clr, regions): dictionary with total number of pixels per pair of support regions """ - n = len(supports) - x = [clr.extent(region)[1] - clr.extent(region)[0] for region in supports] + n = len(regions) + x = [clr.extent(region)[1] - clr.extent(region)[0] for region in regions] blocks = {} for i in range(n): From 590ac084f1b984ef9247a6002623afbe43d6c7c0 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Sat, 9 May 2020 11:32:18 -0400 Subject: [PATCH 29/71] now actually fixed --- cooltools/__init__.py | 2 +- requirements.txt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/cooltools/__init__.py b/cooltools/__init__.py index 5a72e095..b2ff3d17 100644 --- a/cooltools/__init__.py +++ b/cooltools/__init__.py @@ -11,7 +11,7 @@ """ import logging -__version__ = "0.3.2" +__version__ = "0.4.0-dev" from . import io from . import lib diff --git a/requirements.txt b/requirements.txt index 7a7a6590..90b1a499 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,4 @@ -bioframe<0.1.0 +bioframe click>=7 cooler>=0.8.5 cython From 2d64f9a4a511f9031201a30183b1e4ba8a0043b9 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Sat, 9 May 2020 12:01:32 -0400 Subject: [PATCH 30/71] minimize diffs for Max, resolve new bioframe --- cooltools/eigdecomp.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cooltools/eigdecomp.py b/cooltools/eigdecomp.py index 86b8ecf8..979124c4 100644 --- a/cooltools/eigdecomp.py +++ b/cooltools/eigdecomp.py @@ -334,7 +334,7 @@ def _each(region): 'No column "{}" in the bin table'.format(phasing_track_col) ) phasing_track = ( - bioframe.slice_bedframe(bins, region)[phasing_track_col].values + bioframe.bedslice(bins, region)[phasing_track_col].values if phasing_track_col else None ) @@ -353,7 +353,7 @@ def _each(region): eigvals_per_reg, eigvecs_per_reg = zip(*map(_each, regions)) for region, eigvecs in zip(regions, eigvecs_per_reg): - lo, hi = bioframe.bisect_bedframe(bins, region) + lo, hi = bioframe.bedbisect(bins, region) for i, eigvec in enumerate(eigvecs): eigvec_table.iloc[ lo:hi, eigvec_table.columns.get_loc("E" + str(i + 1)) From a9043efc21a219943db76e914b9b64aeb2ae7511 Mon Sep 17 00:00:00 2001 From: mimakaev Date: Sat, 9 May 2020 13:25:24 -0400 Subject: [PATCH 31/71] saddles tentatively working --- cooltools/eigdecomp.py | 39 +++++++++------------------------------ cooltools/saddle.py | 16 ++++++++-------- 2 files changed, 17 insertions(+), 38 deletions(-) diff --git a/cooltools/eigdecomp.py b/cooltools/eigdecomp.py index 979124c4..0a317901 100644 --- a/cooltools/eigdecomp.py +++ b/cooltools/eigdecomp.py @@ -298,24 +298,11 @@ def cooler_cis_eig( clip_percentile=99.9, sort_metric=None, ): - # Perform consitency checks. - if regions is None: - chroms_not_in_clr = [ - chrom for chrom in bins["chrom"].unique() if chrom not in clr.chromsizes - ] - - if len(chroms_not_in_clr) > 0: - raise ValueError( - "The following chromosomes are found in the bin table, but not " - "in the cooler: " + str(chroms_not_in_clr) - ) - - if regions is None: - regions = ( - [(chrom, 0, clr.chromsizes[chrom]) for chrom in bins["chrom"].unique()] - if regions is None - else [bioframe.parse_region(r) for r in regions] - ) + + if regions is None: # normalize_regins will fill in the rest + regions = list(bins["chrom"].unique()) # and check consistency + + regions = bioframe.region.normalize_regions(regions, clr.chromsizes, force_UCSC_names=True) ignore_diags = ( clr._load_attrs("bins/weight").get("ignore_diags", 2) @@ -328,7 +315,7 @@ def cooler_cis_eig( eigvec_table["E" + str(i + 1)] = np.nan def _each(region): - A = clr.matrix(balance=balance).fetch(region) + A = clr.matrix(balance=balance).fetch(region[:3]) if phasing_track_col and (phasing_track_col not in bins): raise ValueError( 'No column "{}" in the bin table'.format(phasing_track_col) @@ -350,26 +337,18 @@ def _each(region): return eigvals, eigvecs - eigvals_per_reg, eigvecs_per_reg = zip(*map(_each, regions)) + eigvals_per_reg, eigvecs_per_reg = zip(*map(_each, regions.values)) - for region, eigvecs in zip(regions, eigvecs_per_reg): + for region, eigvecs in zip(regions.values, eigvecs_per_reg): lo, hi = bioframe.bedbisect(bins, region) for i, eigvec in enumerate(eigvecs): eigvec_table.iloc[ lo:hi, eigvec_table.columns.get_loc("E" + str(i + 1)) ] = eigvec - region_strs = [ - ( - chrom - if (start == 0 and end == clr.chromsizes[chrom]) - else "{}:{}-{}".format(chrom, start, end) - ) - for chrom, start, end in regions - ] eigvals = pd.DataFrame( - index=region_strs, + index=regions["name"], data=np.vstack(eigvals_per_reg), columns=["eigval" + str(i + 1) for i in range(n_eigs)], ) diff --git a/cooltools/saddle.py b/cooltools/saddle.py index 676fdf49..88a6d543 100644 --- a/cooltools/saddle.py +++ b/cooltools/saddle.py @@ -139,11 +139,11 @@ def make_cis_obsexp_fetcher(clr, expected, weight_name="weight"): """ expected, name = expected - expected = {k: x.values for k, x in expected.groupby("chrom")[name]} + expected = {k: x.values for k, x in expected.groupby("region")[name]} def _fetch_cis_oe(reg1, reg2): obs_mat = clr.matrix(balance=weight_name).fetch(reg1) - exp_mat = toeplitz(expected[reg1[0]][: obs_mat.shape[0]]) + exp_mat = toeplitz(expected[reg1][: obs_mat.shape[0]]) return obs_mat / exp_mat return _fetch_cis_oe @@ -303,18 +303,18 @@ def make_saddle( (chrom, df.start.min(), df.end.max()) for chrom, df in digitized_df.groupby("chrom") ] - else: - regions = [bioframe.parse_region(reg) for reg in regions] + regions = bioframe.region.normalize_regions(regions) + digitized_tracks = {} - for reg in regions: + for reg in regions.values: track = bioframe.bedslice(digitized_df, reg) - digitized_tracks[reg] = track[name] + digitized_tracks[reg[3]] = track[name] # 3 = name if contact_type == "cis": - supports = list(zip(regions, regions)) + supports = list(zip(regions["name"], regions["name"])) elif contact_type == "trans": - supports = list(combinations(regions, 2)) + supports = list(combinations(regions["name"], 2)) else: raise ValueError( "The allowed values for the contact_type " "argument are 'cis' or 'trans'." From 7f2250a84df18799b3bd63d807ba105093002135 Mon Sep 17 00:00:00 2001 From: mimakaev Date: Sun, 17 May 2020 13:04:41 -0400 Subject: [PATCH 32/71] renamed normalize_regions --- cooltools/eigdecomp.py | 2 +- cooltools/expected.py | 10 +++++----- cooltools/saddle.py | 2 +- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/cooltools/eigdecomp.py b/cooltools/eigdecomp.py index 0a317901..ab2c5394 100644 --- a/cooltools/eigdecomp.py +++ b/cooltools/eigdecomp.py @@ -302,7 +302,7 @@ def cooler_cis_eig( if regions is None: # normalize_regins will fill in the rest regions = list(bins["chrom"].unique()) # and check consistency - regions = bioframe.region.normalize_regions(regions, clr.chromsizes, force_UCSC_names=True) + regions = bioframe.parse_regions(regions, clr.chromsizes, force_UCSC_names=True) ignore_diags = ( clr._load_attrs("bins/weight").get("ignore_diags", 2) diff --git a/cooltools/expected.py b/cooltools/expected.py index 9bce493a..901d52ae 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -412,9 +412,9 @@ def make_diag_tables(clr, regions, regions2=None, weight_name="weight", bad_bins dictionary with DataFrames of relevant diagonals for every support. """ - regions = bioframe.region.normalize_regions(regions, clr.chromsizes).values + regions = bioframe.parse_regions(regions, clr.chromsizes).values if regions2 is not None: - regions2 = bioframe.region.normalize_regions(regions2, clr.chromsizes).values + regions2 = bioframe.parse_regions(regions2, clr.chromsizes).values bins = clr.bins()[:] if weight_name is None: @@ -593,7 +593,7 @@ def diagsum( spans = partition(0, len(clr.pixels()), chunksize) fields = ["count"] + list(transforms.keys()) - regions = bioframe.region.normalize_regions(regions, clr.chromsizes) + regions = bioframe.parse_regions(regions, clr.chromsizes) rval = regions.values dtables = make_diag_tables(clr, regions, weight_name=weight_name, bad_bins=bad_bins) @@ -679,8 +679,8 @@ def diagsum_asymm( spans = partition(0, len(clr.pixels()), chunksize) fields = ["count"] + list(transforms.keys()) areas = list(zip(regions1, regions2)) - regions1 = bioframe.region.normalize_regions(regions1, clr.chromsizes) - regions2 = bioframe.region.normalize_regions(regions2, clr.chromsizes) + regions1 = bioframe.parse_regions(regions1, clr.chromsizes) + regions2 = bioframe.parse_regions(regions2, clr.chromsizes) dtables = make_diag_tables(clr, regions1, regions2, weight_name=weight_name, bad_bins=bad_bins) diff --git a/cooltools/saddle.py b/cooltools/saddle.py index 88a6d543..33add076 100644 --- a/cooltools/saddle.py +++ b/cooltools/saddle.py @@ -304,7 +304,7 @@ def make_saddle( for chrom, df in digitized_df.groupby("chrom") ] - regions = bioframe.region.normalize_regions(regions) + regions = bioframe.parse_regions(regions) digitized_tracks = {} for reg in regions.values: From bd55d24146bc7a4768401d01708cd3fc634d4b47 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Tue, 19 May 2020 14:26:23 -0400 Subject: [PATCH 33/71] bad_bins masking for diagsum_symm --- cooltools/expected.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/cooltools/expected.py b/cooltools/expected.py index 9bce493a..12c6fede 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -488,6 +488,7 @@ def _diagsum_symm(clr, fields, transforms, regions, span): pixels["region2"] = assign_supports(pixels[["chrom2","start2","end2",'bin2_id']], regions.values, suffix="2") pixels = pixels[pixels["region1"] == pixels["region2"]].copy() + # working on a deep copy of pixels chunk, ok to modify, "disposable": pixels["dist"] = pixels["bin2_id"] - pixels["bin1_id"] for field, t in transforms.items(): pixels[field] = t(pixels) @@ -598,6 +599,28 @@ def diagsum( dtables = make_diag_tables(clr, regions, weight_name=weight_name, bad_bins=bad_bins) + # combine masking with existing transforms and add a "count" transform: + if bad_bins is not None: + # turn bad_bins into a mask of size clr.bins: + mask_size = len(clr.bins()) + bad_bins_mask = np.ones(mask_size, dtype=int) + bad_bins_mask[bad_bins] = 0 + # + masked_transforms = {} + bin1 = "bin1_id" + bin2 = "bin2_id" + for field in fields: + if field in transforms: + # combine masking and transform, minding the scope: + t = transforms[field] + masked_transforms[field] = lambda p,t=t: t(p) * mask[p[bin1]] * mask[p[bin2]] + else: + # presumably field == "count", mind the scope as well: + masked_transforms[field] = lambda p,f=field: p[f] * mask[p[bin1]] * mask[p[bin2]] + # substitute transforms to the masked_transforms: + transforms = masked_transforms + + for dt in dtables.values(): for field in fields: agg_name = "{}.sum".format(field) From 1a508125f1cea4f111eb18f27fc081b26b926e35 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Tue, 19 May 2020 14:32:19 -0400 Subject: [PATCH 34/71] mask var name fix --- cooltools/expected.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index 12c6fede..8710e7b4 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -613,10 +613,10 @@ def diagsum( if field in transforms: # combine masking and transform, minding the scope: t = transforms[field] - masked_transforms[field] = lambda p,t=t: t(p) * mask[p[bin1]] * mask[p[bin2]] + masked_transforms[field] = lambda p,t=t,m=bad_bins_mask: t(p) * m[p[bin1]] * m[p[bin2]] else: # presumably field == "count", mind the scope as well: - masked_transforms[field] = lambda p,f=field: p[f] * mask[p[bin1]] * mask[p[bin2]] + masked_transforms[field] = lambda p,f=field,m=bad_bins_mask: p[f] * m[p[bin1]] * m[p[bin2]] # substitute transforms to the masked_transforms: transforms = masked_transforms From 6dbdb33e59bd0e9fc193561208a108eb4ca707ea Mon Sep 17 00:00:00 2001 From: sergpolly Date: Tue, 19 May 2020 18:41:26 -0400 Subject: [PATCH 35/71] added compose masking and transforms to diagsum_asymm and blocksum --- cooltools/expected.py | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/cooltools/expected.py b/cooltools/expected.py index 8710e7b4..f737c214 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -707,6 +707,27 @@ def diagsum_asymm( dtables = make_diag_tables(clr, regions1, regions2, weight_name=weight_name, bad_bins=bad_bins) + # combine masking with existing transforms and add a "count" transform: + if bad_bins is not None: + # turn bad_bins into a mask of size clr.bins: + mask_size = len(clr.bins()) + bad_bins_mask = np.ones(mask_size, dtype=int) + bad_bins_mask[bad_bins] = 0 + # + masked_transforms = {} + bin1 = "bin1_id" + bin2 = "bin2_id" + for field in fields: + if field in transforms: + # combine masking and transform, minding the scope: + t = transforms[field] + masked_transforms[field] = lambda p,t=t,m=bad_bins_mask: t(p) * m[p[bin1]] * m[p[bin2]] + else: + # presumably field == "count", mind the scope as well: + masked_transforms[field] = lambda p,f=field,m=bad_bins_mask: p[f] * m[p[bin1]] * m[p[bin2]] + # substitute transforms to the masked_transforms: + transforms = masked_transforms + for dt in dtables.values(): for field in fields: agg_name = "{}.sum".format(field) @@ -786,6 +807,27 @@ def blocksum_pairwise( n_tot = count_all_pixels_per_block(clr, regions) n_bad = count_bad_pixels_per_block(clr, regions, weight_name=weight_name, bad_bins=bad_bins) + # combine masking with existing transforms and add a "count" transform: + if bad_bins is not None: + # turn bad_bins into a mask of size clr.bins: + mask_size = len(clr.bins()) + bad_bins_mask = np.ones(mask_size, dtype=int) + bad_bins_mask[bad_bins] = 0 + # + masked_transforms = {} + bin1 = "bin1_id" + bin2 = "bin2_id" + for field in fields: + if field in transforms: + # combine masking and transform, minding the scope: + t = transforms[field] + masked_transforms[field] = lambda p,t=t,m=bad_bins_mask: t(p) * m[p[bin1]] * m[p[bin2]] + else: + # presumably field == "count", mind the scope as well: + masked_transforms[field] = lambda p,f=field,m=bad_bins_mask: p[f] * m[p[bin1]] * m[p[bin2]] + # substitute transforms to the masked_transforms: + transforms = masked_transforms + records = {(c1, c2): defaultdict(int) for (c1, c2) in blocks} for c1, c2 in blocks: records[c1, c2]["n_valid"] = n_tot[c1, c2] - n_bad[c1, c2] From 02159cf44fe75fffabeedb8300c810286010f9fd Mon Sep 17 00:00:00 2001 From: sergpolly Date: Thu, 21 May 2020 15:55:22 -0400 Subject: [PATCH 36/71] column names fix in new _diagsum_asymm --- cooltools/expected.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index f737c214..d1bfcbfb 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -517,8 +517,8 @@ def _diagsum_asymm(clr, fields, transforms, contact_type, regions1, regions2, sp for field, t in transforms.items(): pixels[field] = t(pixels) - pixels["region1"] = assign_supports(pixels[["chrom","start","end",'bin1_id']], regions.values) - pixels["region2"] = assign_supports(pixels[["chrom","start","end",'bin2_id']], regions.values) + pixels["region1"] = assign_supports(pixels[["chrom1","start1","end1",'bin1_id']], regions.values) + pixels["region2"] = assign_supports(pixels[["chrom2","start2","end2",'bin2_id']], regions.values) pixel_groups = dict(iter(pixels.groupby(["region1", "region2"]))) return { From e87f8a561505cb83aba7c877a2f04936db2ec455 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Thu, 21 May 2020 15:59:28 -0400 Subject: [PATCH 37/71] more var names fixing in _diagsum_asymm --- cooltools/expected.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index d1bfcbfb..45e9a584 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -517,8 +517,8 @@ def _diagsum_asymm(clr, fields, transforms, contact_type, regions1, regions2, sp for field, t in transforms.items(): pixels[field] = t(pixels) - pixels["region1"] = assign_supports(pixels[["chrom1","start1","end1",'bin1_id']], regions.values) - pixels["region2"] = assign_supports(pixels[["chrom2","start2","end2",'bin2_id']], regions.values) + pixels["region1"] = assign_supports(pixels[["chrom1","start1","end1",'bin1_id']], regions1.values) + pixels["region2"] = assign_supports(pixels[["chrom2","start2","end2",'bin2_id']], regions2.values) pixel_groups = dict(iter(pixels.groupby(["region1", "region2"]))) return { From 2cfe933df2318f891474d9103bf726e16743db0e Mon Sep 17 00:00:00 2001 From: sergpolly Date: Fri, 29 May 2020 19:28:43 -0400 Subject: [PATCH 38/71] attempt to unify block/diagsum API --- cooltools/expected.py | 80 ++++++++++++++++++++++++++++++------------- 1 file changed, 57 insertions(+), 23 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index 45e9a584..dccfd97a 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -229,7 +229,7 @@ def count_all_pixels_per_block(clr, regions): -def count_bad_pixels_per_block(clr, supports, weight_name="weight", bad_bins=None): +def count_bad_pixels_per_block(clr, regions, weight_name="weight", bad_bins=None): """ Calculate number of "bad" pixels per rectangular block of a contact map @@ -527,18 +527,24 @@ def _diagsum_asymm(clr, fields, transforms, contact_type, regions1, regions2, sp } -def _blocksum_asymm(clr, fields, transforms, regions1, regions2, span): +def _blocksum_asymm(clr, fields, transforms, contact_type, regions1, regions2, span): lo, hi = span bins = clr.bins()[:] pixels = clr.pixels()[lo:hi] pixels = cooler.annotate(pixels, bins, replace=False) - pixels = pixels[pixels["chrom1"] != pixels["chrom2"]].copy() + if contact_type == "cis": + pixels = pixels[pixels["chrom1"] == pixels["chrom2"]].copy() + elif contact_type == "trans": + pixels = pixels[pixels["chrom1"] != pixels["chrom2"]].copy() + for field, t in transforms.items(): pixels[field] = t(pixels) - pixels["region1"] = assign_supports(pixels, regions1.values, suffix="1") - pixels["region2"] = assign_supports(pixels, regions2.values, suffix="2") + pixels["region1"] = assign_supports(pixels, regions1, suffix="1") + pixels["region2"] = assign_supports(pixels, regions2, suffix="2") + # might be incorrect for raw-counts, because raw counts + # are going dropped when "weight" is NaN: [keep it for now] pixels = pixels.dropna() pixel_groups = dict(iter(pixels.groupby(["region1", "region2"]))) @@ -595,7 +601,6 @@ def diagsum( fields = ["count"] + list(transforms.keys()) regions = bioframe.region.normalize_regions(regions, clr.chromsizes) - rval = regions.values dtables = make_diag_tables(clr, regions, weight_name=weight_name, bad_bins=bad_bins) @@ -637,14 +642,14 @@ def diagsum( agg[field], fill_value=0 ) - if ignore_diags: for dt in dtables.values(): for field in fields: agg_name = "{}.sum".format(field) j = dt.columns.get_loc(agg_name) dt.iloc[:ignore_diags, j] = np.nan - + + # returning dataframe for API consistency result = [] for i,dtable in dtables.items(): dtable = dtable.reset_index() @@ -673,8 +678,10 @@ def diagsum_asymm( ---------- clr : cooler.Cooler Cooler object - regions : sequence of genomic range tuples - Support regions for intra-chromosomal diagonal summation + regions1 : sequence of genomic range tuples + "left"-side support regions for diagonal summation + regions2 : sequence of genomic range tuples + "right"-side support regions for diagonal summation transforms : dict of str -> callable, optional Transformations to apply to pixels. The result will be assigned to a temporary column with the name given by the key. Callables take @@ -739,8 +746,8 @@ def diagsum_asymm( results = map(job, spans) for result in results: for (i, j), agg in result.items(): - region1 = regions1[i] - region2 = regions2[j] + region1 = regions1.loc[i,"name"] + region2 = regions2.loc[j,"name"] for field in fields: agg_name = "{}.sum".format(field) dtables[region1, region2][agg_name] = dtables[region1, region2][ @@ -752,9 +759,18 @@ def diagsum_asymm( for field in fields: agg_name = "{}.sum".format(field) j = dt.columns.get_loc(agg_name) + # this ignores whatever "ignore_diags" diagonals, + # not necessarily short-range genomic interactions dt.iloc[:ignore_diags, j] = np.nan - return dtables + # returning a dataframe for API consistency: + result = [] + for (i,j), dtable in dtables.items(): + dtable = dtable.reset_index() + dtable.insert(0,"region1", i) + dtable.insert(1,"region2", j) + result.append(dtable) + return pd.concat(result).reset_index(drop=True) def blocksum_pairwise( @@ -798,14 +814,20 @@ def blocksum_pairwise( dict of support region -> (field name -> summary) """ - - blocks = list(combinations(regions, 2)) + regions_df = bioframe.region.normalize_regions(regions, clr.chromsizes) + # turn sanitized regions into tuple-based regions for compatibility + # with previous API: + regions_vals = [tuple(r) for r in regions_df[["chrom","start","end"]].values] + # establish a region -> name mapping: + reg_to_name = {(c,s,e):n for c,s,e,n in regions_df.values} + + blocks = list(combinations(regions_vals, 2)) regions1, regions2 = list(zip(*blocks)) spans = partition(0, len(clr.pixels()), chunksize) fields = ["count"] + list(transforms.keys()) - n_tot = count_all_pixels_per_block(clr, regions) - n_bad = count_bad_pixels_per_block(clr, regions, weight_name=weight_name, bad_bins=bad_bins) + n_tot = count_all_pixels_per_block(clr, regions_vals) + n_bad = count_bad_pixels_per_block(clr, regions_vals, weight_name=weight_name, bad_bins=bad_bins) # combine masking with existing transforms and add a "count" transform: if bad_bins is not None: @@ -828,11 +850,13 @@ def blocksum_pairwise( # substitute transforms to the masked_transforms: transforms = masked_transforms - records = {(c1, c2): defaultdict(int) for (c1, c2) in blocks} + records = {(reg_to_name[c1], reg_to_name[c2]): defaultdict(int) for (c1, c2) in blocks} for c1, c2 in blocks: - records[c1, c2]["n_valid"] = n_tot[c1, c2] - n_bad[c1, c2] + n1 = reg_to_name[c1] + n2 = reg_to_name[c2] + records[n1, n2]["n_valid"] = n_tot[c1, c2] - n_bad[c1, c2] - job = partial(_blocksum_asymm, clr, fields, transforms, regions1, regions2) + job = partial(_blocksum_asymm, clr, fields, transforms, contact_type, regions1, regions2) results = map(job, spans) for result in results: for (i, j), agg in result.items(): @@ -840,9 +864,19 @@ def blocksum_pairwise( agg_name = "{}.sum".format(field) s = agg[field].item() if not np.isnan(s): - records[regions1[i], regions2[j]][agg_name] += s - - return records + n1i = reg_to_name[regions1[i]] + n2j = reg_to_name[regions2[j]] + records[n1i, n2j][agg_name] += s + + # returning a dataframe for API consistency: + return pd.DataFrame( + [ + {"region1": n1, "region2": n2, **rec} + for (n1, n2), rec in records.items() + ], + columns=["region1", "region2", "n_valid", "count.sum"] + \ + [ k+".sum" for k in transforms.keys() ] + ) def logbin_expected( From 1a02bc93ad38221677056d8cb1d738c3549f11cb Mon Sep 17 00:00:00 2001 From: sergpolly Date: Fri, 29 May 2020 19:42:08 -0400 Subject: [PATCH 39/71] quick fixes, add contact-type docstrings --- cooltools/expected.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index dccfd97a..6d2659b1 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -517,8 +517,8 @@ def _diagsum_asymm(clr, fields, transforms, contact_type, regions1, regions2, sp for field, t in transforms.items(): pixels[field] = t(pixels) - pixels["region1"] = assign_supports(pixels[["chrom1","start1","end1",'bin1_id']], regions1.values) - pixels["region2"] = assign_supports(pixels[["chrom2","start2","end2",'bin2_id']], regions2.values) + pixels["region1"] = assign_supports(pixels, regions1.values, suffix="1") + pixels["region2"] = assign_supports(pixels, regions2.values, suffix="2") pixel_groups = dict(iter(pixels.groupby(["region1", "region2"]))) return { @@ -682,6 +682,8 @@ def diagsum_asymm( "left"-side support regions for diagonal summation regions2 : sequence of genomic range tuples "right"-side support regions for diagonal summation + contact_type : str + select trans or cis contacts for diagonal summation transforms : dict of str -> callable, optional Transformations to apply to pixels. The result will be assigned to a temporary column with the name given by the key. Callables take @@ -776,6 +778,7 @@ def diagsum_asymm( def blocksum_pairwise( clr, regions, + contact_type="trans", transforms=None, weight_name="weight", bad_bins=None, @@ -792,6 +795,8 @@ def blocksum_pairwise( regions : sequence of genomic range tuples Support regions for summation. Blocks for all pairs of support regions will be used. + contact_type : str + select trans or cis contacts for block summation transforms : dict of str -> callable, optional Transformations to apply to pixels. The result will be assigned to a temporary column with the name given by the key. Callables take From 5a2b4959cc188d4a24844691fa1f17354a526d84 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Fri, 29 May 2020 19:51:50 -0400 Subject: [PATCH 40/71] typo fix bad_bins_dict --- cooltools/expected.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index 6d2659b1..792b47bd 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -295,7 +295,7 @@ def count_bad_pixels_per_block(clr, regions, weight_name="weight", bad_bins=None for region in regions: combined_bad_bins = clr.bins()[weight_name].fetch(region).isnull().values # using relative indices mark exta bad_bins as null - bad_bins_reg = bad_bin_dict[region] + bad_bins_reg = bad_bins_dict[region] combined_bad_bins[bad_bins_reg] = True n_bad.append( combined_bad_bins.astype(int).sum() ) else: From be5186c9898e71b8dc0c49b4832e72fc7348a42c Mon Sep 17 00:00:00 2001 From: sergpolly Date: Fri, 29 May 2020 20:37:43 -0400 Subject: [PATCH 41/71] change transforms default to empty dict --- cooltools/expected.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index 792b47bd..f5dbb0df 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -556,7 +556,7 @@ def _blocksum_asymm(clr, fields, transforms, contact_type, regions1, regions2, s def diagsum( clr, regions, - transforms=None, + transforms={}, weight_name="weight", bad_bins=None, chunksize=10000000, @@ -663,7 +663,7 @@ def diagsum_asymm( regions1, regions2, contact_type="cis", - transforms=None, + transforms={}, weight_name="weight", bad_bins=None, chunksize=10000000, @@ -779,7 +779,7 @@ def blocksum_pairwise( clr, regions, contact_type="trans", - transforms=None, + transforms={}, weight_name="weight", bad_bins=None, chunksize=1000000, From 4cf029961fcbb2df1f6ebc99cdd1d5d839cd0dfa Mon Sep 17 00:00:00 2001 From: mimakaev Date: Wed, 3 Jun 2020 22:14:57 -0400 Subject: [PATCH 42/71] fixed some bugs so more tests pass --- cooltools/cli/compute_expected.py | 7 +------ cooltools/dotfinder.py | 7 +++---- requirements.txt | 2 +- 3 files changed, 5 insertions(+), 11 deletions(-) diff --git a/cooltools/cli/compute_expected.py b/cooltools/cli/compute_expected.py index 90b7c68a..d55858e0 100644 --- a/cooltools/cli/compute_expected.py +++ b/cooltools/cli/compute_expected.py @@ -170,7 +170,7 @@ def compute_expected( # using try-clause to close mp.Pool properly try: if contact_type == "cis": - tables = expected.diagsum( + result = expected.diagsum( clr, regions, transforms=transforms, @@ -180,11 +180,6 @@ def compute_expected( ignore_diags=ignore_diags, map=map_, ) - result = pd.concat( - [tables[region] for region in regions], - keys=[name for name in region_names], - names=["region"], - ) result = result.reset_index() elif contact_type == "trans": diff --git a/cooltools/dotfinder.py b/cooltools/dotfinder.py index 5ef1ca88..762cab40 100644 --- a/cooltools/dotfinder.py +++ b/cooltools/dotfinder.py @@ -16,8 +16,7 @@ from .lib.numutils import LazyToeplitz, get_kernel -from bioframe.io import formats - +import bioframe # these are the constants from HiCCUPS, that dictate how initial histogramms # for lambda-chunking are computed: W1 is the # of logspaced lambda bins, @@ -1373,7 +1372,7 @@ def scoring_step( # ########################################### elif output_mode == "parquet": print("parquet output ...") - formats.to_parquet( + bioframe.to_parquet( chunks, output_path, # # use defaults first ... @@ -1464,7 +1463,7 @@ def histogramming_step( # read number of groups # still don't know how to control that # maybe: - # "formats.to_parquet(... row_group_size = chunksize...)" ?!? + # "bioframe.to_parquet(... row_group_size = chunksize...)" ?!? tiles = range(pf.num_row_groups) # gg.read_row_group(i, columns=None, # nthreads=None, use_threads=True, diff --git a/requirements.txt b/requirements.txt index 7a7a6590..90b1a499 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,4 @@ -bioframe<0.1.0 +bioframe click>=7 cooler>=0.8.5 cython From a102478e3a8caac476611146e1cf9b71ae0a12d4 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Tue, 16 Jun 2020 14:13:29 -0400 Subject: [PATCH 43/71] blocksum and diagsum with arbitraty regions --- cooltools/expected.py | 350 +++++++++++++++++++++--------------------- 1 file changed, 179 insertions(+), 171 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index f5dbb0df..ee238597 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -200,117 +200,52 @@ def count_all_pixels_per_diag(n): return np.arange(n, 0, -1) -def count_all_pixels_per_block(clr, regions): +def count_all_pixels_per_block(x, y): """ - Calculate total number of pixels per rectangular block of a contact map - defined as a paired-combination of genomic "support" regions. + Calculate total number of pixels in a rectangular block Parameters ---------- - clr : cooler.Cooler - Input cooler - regions : list - list of genomic support regions + x : int + block width in pixels + y : int + block height in pixels Returns ------- - blocks : dict - dictionary with total number of pixels per pair of support regions + number_of_pixels : int + total number of pixels in a block """ + return x*y - n = len(regions) - x = [clr.extent(region)[1] - clr.extent(region)[0] for region in regions] - - blocks = {} - for i in range(n): - for j in range(i + 1, n): - blocks[regions[i], regions[j]] = x[i] * x[j] - return blocks - - - -def count_bad_pixels_per_block(clr, regions, weight_name="weight", bad_bins=None): - +def count_bad_pixels_per_block(x, y, bad_bins_x, bad_bins_y): """ Calculate number of "bad" pixels per rectangular block of a contact map - defined as a paired-combination of genomic "support" regions. "Bad" pixels are inferred from the balancing weight column `weight_name` or provided directly in the form of an array `bad_bins`. - Setting `weight_name` and `bad_bins` to `None` yields 0 bad pixels per - combination of support regions. + Setting `weight_name` and `bad_bins` to `None` yields 0 bad pixels in a block. Parameters ---------- - clr : cooler.Cooler - Input cooler - regions : list - a list of genomic support regions - weight_name : str - name of the weight vector in the "bins" table, - if weight_name is None returns 0 for each block. - Balancing weight are used to infer bad bins. - bad_bins : array-like - additional list of bad bins. Bin indices must - be absolute, as in clr.bins()[:], as opposed to - being offset by chromosome start. - "bad_bins" will be combined with the bad bins - masked by balancing if there are any. + x : int + block width in pixels + y : int + block height in pixels + bad_bins_x : int + number of bad bins on x-side + bad_bins_y : int + number of bad bins on y-side Returns ------- - blocks : dict - dictionary with the number of "bad" pixels per pair of support regions + number_of_pixes : int + number of "bad" pixels in a block """ - n = len(regions) - if bad_bins is None: - bad_bins = np.asarray([]).astype(int) - else: - bad_bins = np.asarray(bad_bins).astype(int) - - # Get the total number of bins per region - # and relative indices of bad_bins per region: - n_tot = [] - bad_bins_dict = {} - for region in regions: - lo, hi = clr.extent(region) - n_tot.append(hi - lo) - bad_bins_reg = bad_bins[(bad_bins>=lo)&(bad_bins=lo1)&(bad_bins=lo2)&(bad_bins callable, optional Transformations to apply to pixels. The result will be assigned to a temporary column with the name given by the key. Callables take @@ -698,21 +727,20 @@ def diagsum_asymm( weight. chunksize : int, optional Size of pixel table chunks to process - ignore_diags : int, optional - Number of intial diagonals to exclude from statistics map : callable, optional Map functor implementation. Returns ------- - dict of support region -> dataframe of diagonal statistics + DataFrame with summary statistic of every diagonal of every block: + region1, region2, diag, n_valid, count.sum """ spans = partition(0, len(clr.pixels()), chunksize) fields = ["count"] + list(transforms.keys()) areas = list(zip(regions1, regions2)) - regions1 = bioframe.region.normalize_regions(regions1, clr.chromsizes) - regions2 = bioframe.region.normalize_regions(regions2, clr.chromsizes) + regions1 = bioframe.region.normalize_regions(regions1, clr.chromsizes) + regions2 = bioframe.region.normalize_regions(regions2, clr.chromsizes) dtables = make_diag_tables(clr, regions1, regions2, weight_name=weight_name, bad_bins=bad_bins) @@ -743,28 +771,19 @@ def diagsum_asymm( dt[agg_name] = 0 job = partial( - _diagsum_asymm, clr, fields, transforms, contact_type, regions1, regions2 + _diagsum_asymm, clr, fields, transforms, regions1, regions2 ) results = map(job, spans) for result in results: - for (i, j), agg in result.items(): + for i, agg in result.items(): region1 = regions1.loc[i,"name"] - region2 = regions2.loc[j,"name"] + region2 = regions2.loc[i,"name"] for field in fields: agg_name = "{}.sum".format(field) dtables[region1, region2][agg_name] = dtables[region1, region2][ agg_name ].add(agg[field], fill_value=0) - if ignore_diags: - for dt in dtables.values(): - for field in fields: - agg_name = "{}.sum".format(field) - j = dt.columns.get_loc(agg_name) - # this ignores whatever "ignore_diags" diagonals, - # not necessarily short-range genomic interactions - dt.iloc[:ignore_diags, j] = np.nan - # returning a dataframe for API consistency: result = [] for (i,j), dtable in dtables.items(): @@ -775,10 +794,10 @@ def diagsum_asymm( return pd.concat(result).reset_index(drop=True) -def blocksum_pairwise( +def blocksum_asymm( clr, - regions, - contact_type="trans", + regions1, + regions2, transforms={}, weight_name="weight", bad_bins=None, @@ -786,17 +805,16 @@ def blocksum_pairwise( map=map, ): """ - Summary statistics on inter-chromosomal rectangular blocks. + Summary statistics on rectangular blocks of genomic regions. Parameters ---------- clr : cooler.Cooler Cooler object - regions : sequence of genomic range tuples - Support regions for summation. Blocks for all pairs of support regions - will be used. - contact_type : str - select trans or cis contacts for block summation + regions1 : sequence of genomic range tuples + "left"-side support regions for diagonal summation + regions2 : sequence of genomic range tuples + "right"-side support regions for diagonal summation transforms : dict of str -> callable, optional Transformations to apply to pixels. The result will be assigned to a temporary column with the name given by the key. Callables take @@ -816,23 +834,19 @@ def blocksum_pairwise( Returns ------- - dict of support region -> (field name -> summary) + DataFrame with entries for each blocks: region1, region2, n_valid, count.sum """ - regions_df = bioframe.region.normalize_regions(regions, clr.chromsizes) - # turn sanitized regions into tuple-based regions for compatibility - # with previous API: - regions_vals = [tuple(r) for r in regions_df[["chrom","start","end"]].values] - # establish a region -> name mapping: - reg_to_name = {(c,s,e):n for c,s,e,n in regions_df.values} - - blocks = list(combinations(regions_vals, 2)) - regions1, regions2 = list(zip(*blocks)) + + regions1 = bioframe.region.normalize_regions(regions1, clr.chromsizes) + regions2 = bioframe.region.normalize_regions(regions2, clr.chromsizes) + spans = partition(0, len(clr.pixels()), chunksize) fields = ["count"] + list(transforms.keys()) - n_tot = count_all_pixels_per_block(clr, regions_vals) - n_bad = count_bad_pixels_per_block(clr, regions_vals, weight_name=weight_name, bad_bins=bad_bins) + # similar with diagonal summations, pre-generate a block_table listing + # all of the rectangular blocks and "n_valid" number of pixels per each block: + records = make_block_table(clr, regions1, regions2, weight_name=weight_name, bad_bins=bad_bins) # combine masking with existing transforms and add a "count" transform: if bad_bins is not None: @@ -855,23 +869,17 @@ def blocksum_pairwise( # substitute transforms to the masked_transforms: transforms = masked_transforms - records = {(reg_to_name[c1], reg_to_name[c2]): defaultdict(int) for (c1, c2) in blocks} - for c1, c2 in blocks: - n1 = reg_to_name[c1] - n2 = reg_to_name[c2] - records[n1, n2]["n_valid"] = n_tot[c1, c2] - n_bad[c1, c2] - - job = partial(_blocksum_asymm, clr, fields, transforms, contact_type, regions1, regions2) + job = partial(_blocksum_asymm, clr, fields, transforms, regions1.values, regions2.values) results = map(job, spans) for result in results: - for (i, j), agg in result.items(): + for i, agg in result.items(): for field in fields: agg_name = "{}.sum".format(field) s = agg[field].item() if not np.isnan(s): - n1i = reg_to_name[regions1[i]] - n2j = reg_to_name[regions2[j]] - records[n1i, n2j][agg_name] += s + n1 = regions1.loc[i,"name"] + n2 = regions2.loc[i,"name"] + records[n1, n2][agg_name] += s # returning a dataframe for API consistency: return pd.DataFrame( From 2f0d4622ee6d23ceeb88e6da2c49274ef58a3829 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Fri, 19 Jun 2020 00:25:04 -0400 Subject: [PATCH 44/71] minor fix in diagsum_asymm --- cooltools/expected.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index 8b078a58..e5df8a31 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -738,7 +738,6 @@ def diagsum_asymm( """ spans = partition(0, len(clr.pixels()), chunksize) fields = ["count"] + list(transforms.keys()) - areas = list(zip(regions1, regions2)) regions1 = bioframe.parse_regions(regions1, clr.chromsizes) regions2 = bioframe.parse_regions(regions2, clr.chromsizes) @@ -771,7 +770,7 @@ def diagsum_asymm( dt[agg_name] = 0 job = partial( - _diagsum_asymm, clr, fields, transforms, regions1, regions2 + _diagsum_asymm, clr, fields, transforms, regions1.values, regions2.values ) results = map(job, spans) for result in results: From b92199b90ad7f61f48f5df3893427043b398ae04 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Fri, 19 Jun 2020 00:25:04 -0400 Subject: [PATCH 45/71] minor fix in diagsum_asymm --- cooltools/expected.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index 8b078a58..e5df8a31 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -738,7 +738,6 @@ def diagsum_asymm( """ spans = partition(0, len(clr.pixels()), chunksize) fields = ["count"] + list(transforms.keys()) - areas = list(zip(regions1, regions2)) regions1 = bioframe.parse_regions(regions1, clr.chromsizes) regions2 = bioframe.parse_regions(regions2, clr.chromsizes) @@ -771,7 +770,7 @@ def diagsum_asymm( dt[agg_name] = 0 job = partial( - _diagsum_asymm, clr, fields, transforms, regions1, regions2 + _diagsum_asymm, clr, fields, transforms, regions1.values, regions2.values ) results = map(job, spans) for result in results: From f7fea841282b90cef45276111c3d47d901b85dcf Mon Sep 17 00:00:00 2001 From: mimakaev Date: Sun, 21 Jun 2020 11:00:01 -0400 Subject: [PATCH 46/71] cis eig rewritten; added mp.Pool.map to it --- cooltools/eigdecomp.py | 35 ++++++++++++++++++----------------- 1 file changed, 18 insertions(+), 17 deletions(-) diff --git a/cooltools/eigdecomp.py b/cooltools/eigdecomp.py index ab2c5394..ebf76508 100644 --- a/cooltools/eigdecomp.py +++ b/cooltools/eigdecomp.py @@ -297,6 +297,7 @@ def cooler_cis_eig( ignore_diags=None, clip_percentile=99.9, sort_metric=None, + map=map ): if regions is None: # normalize_regins will fill in the rest @@ -312,7 +313,8 @@ def cooler_cis_eig( eigvec_table = bins.copy() for i in range(n_eigs): - eigvec_table["E" + str(i + 1)] = np.nan + eigvec_table[f"E{i+1}"] = np.nan + eig_columns = [f"E{i+1}" for i in range(n_eigs)] def _each(region): A = clr.matrix(balance=balance).fetch(region[:3]) @@ -320,11 +322,15 @@ def _each(region): raise ValueError( 'No column "{}" in the bin table'.format(phasing_track_col) ) - phasing_track = ( - bioframe.bedslice(bins, region)[phasing_track_col].values - if phasing_track_col - else None - ) + + # mask to determin bins belonging to the region + subindex = clr.bins().fetch(region[:3]).index + subregion = bins.loc[subindex].copy() + + if phasing_track_col: + phasing_track = subregion[phasing_track_col].values + else: + phasing_track = None eigvals, eigvecs = cis_eig( A, @@ -334,22 +340,17 @@ def _each(region): clip_percentile=clip_percentile, sort_metric=sort_metric, ) + + return eigvals, eigvecs, subregion.index - return eigvals, eigvecs - - eigvals_per_reg, eigvecs_per_reg = zip(*map(_each, regions.values)) - - for region, eigvecs in zip(regions.values, eigvecs_per_reg): - lo, hi = bioframe.bedbisect(bins, region) - for i, eigvec in enumerate(eigvecs): - eigvec_table.iloc[ - lo:hi, eigvec_table.columns.get_loc("E" + str(i + 1)) - ] = eigvec + results = list(map(_each, regions.values)) + for region, eigvecs, index in results: + eigvec_table.at[index, eig_columns] = eigvecs.T eigvals = pd.DataFrame( index=regions["name"], - data=np.vstack(eigvals_per_reg), + data=np.vstack([i[0] for i in results]), columns=["eigval" + str(i + 1) for i in range(n_eigs)], ) From 3a89d28105b78fbb639c5f9787f969140c1764f8 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Mon, 22 Jun 2020 20:11:15 -0400 Subject: [PATCH 47/71] allow symmetric diagsum to handle overlapping regions --- cooltools/expected.py | 27 ++++++++++++++++----------- 1 file changed, 16 insertions(+), 11 deletions(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index e5df8a31..416207ee 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -505,27 +505,32 @@ def make_block_table(clr, regions1, regions2, weight_name="weight", bad_bins=Non def _diagsum_symm(clr, fields, transforms, regions, span): + """ + calculates diagonal summary for a collection of + square symmteric regions defined by regions. + returns a dictionary of DataFrames with diagonal + sums as values, and 0-based indexes of square + genomic regions as keys. + """ lo, hi = span bins = clr.bins()[:] pixels = clr.pixels()[lo:hi] pixels = cooler.annotate(pixels, bins, replace=False) - pixels["region1"] = assign_supports(pixels[["chrom1","start1","end1",'bin1_id']], regions.values, suffix="1") - pixels["region2"] = assign_supports(pixels[["chrom2","start2","end2",'bin2_id']], regions.values, suffix="2") - pixels = pixels[pixels["region1"] == pixels["region2"]].copy() - - # working on a deep copy of pixels chunk, ok to modify, "disposable": + # this could further expanded to allow for custom groupings: pixels["dist"] = pixels["bin2_id"] - pixels["bin1_id"] for field, t in transforms.items(): pixels[field] = t(pixels) - pixelgroups = dict(iter(pixels.groupby("region1"))) - - values = {} - for i,group in pixelgroups.items(): - values[int(i)] = group.groupby("dist")[fields].sum() + diag_sums = {} + # r define square symmetric block i: + for i, r in enumerate(regions): + r1 = assign_supports(pixels, [r], suffix="1") + r2 = assign_supports(pixels, [r], suffix="2") + # calculate diag_sums on the spot to allow for overlapping blocks: + diag_sums[i] = pixels[(r1==r2)].groupby("dist")[fields].sum() - return values + return diag_sums def _diagsum_asymm(clr, fields, transforms, regions1, regions2, span): From e6d9f095a5c524258ed351476d797c10f4819303 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Mon, 22 Jun 2020 20:15:26 -0400 Subject: [PATCH 48/71] fix diagsum regions casting to ndarray --- cooltools/expected.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cooltools/expected.py b/cooltools/expected.py index 416207ee..85752985 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -669,7 +669,7 @@ def diagsum( agg_name = "{}.sum".format(field) dt[agg_name] = 0 - job = partial(_diagsum_symm, clr, fields, transforms, regions) + job = partial(_diagsum_symm, clr, fields, transforms, regions.values) results = map(job, spans) for result in results: for i, agg in result.items(): From f9ec065904d03fdd7d01ab5c64b03e6652d2616b Mon Sep 17 00:00:00 2001 From: sergpolly Date: Tue, 23 Jun 2020 14:58:23 -0400 Subject: [PATCH 49/71] docstrings regarding regions2 touchedup in expected --- cooltools/expected.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/cooltools/expected.py b/cooltools/expected.py index 85752985..a7d48d61 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -324,12 +324,20 @@ def make_diag_tables(clr, regions, regions2=None, weight_name="weight", bad_bins Setting `weight_name` and `bad_bins` to `None` yields 0 "bad" pixels per diagonal per support region. + When `regions2` are provided, all intersecting diagonals are reported for + each rectangular and asymmetric block defined by combinations of matching + elements of `regions` and `regions2`. + Otherwise only `regions`-based symmetric square blocks are considered. + Only intra-chromosomal regions are supported. + Parameters ---------- clr : cooler.Cooler Input cooler regions : list a list of genomic support regions + regions2 : list + a list of genomic support regions for asymmetric regions weight_name : str name of the weight vector in the "bins" table, if weight_name is None returns 0 for each block. @@ -391,6 +399,7 @@ def make_diag_tables(clr, regions, regions2=None, weight_name="weight", bad_bins chrom,start1,end1,name1 = regions[i] if regions2 is not None: chrom2,start2, end2,name2 = regions2[i] + # cis-only for now: assert chrom2==chrom else: start2, end2 = start1, end1 @@ -710,6 +719,11 @@ def diagsum_asymm( Diagonal summary statistics. + Matchings elements of `regions1` and `regions2` define + asymmetric rectangular blocks for calculating diagonal + summary statistics. + Only intra-chromosomal blocks are supported. + Parameters ---------- clr : cooler.Cooler From 8a2a70671982055cddf8ae830de532316b3cb60b Mon Sep 17 00:00:00 2001 From: sergpolly Date: Tue, 23 Jun 2020 17:48:14 -0400 Subject: [PATCH 50/71] initial tests for newer expected --- tests/test_expected.py | 185 ++++++++++++++++++++++++++++++++++++----- 1 file changed, 166 insertions(+), 19 deletions(-) diff --git a/tests/test_expected.py b/tests/test_expected.py index 75990daf..252e3ef5 100644 --- a/tests/test_expected.py +++ b/tests/test_expected.py @@ -1,42 +1,189 @@ import os.path as op import pandas as pd +from numpy import testing + import bioframe import cooler import cooltools.expected +from itertools import combinations + +# setup new testing infrasctructure for expected ... + +# rudimentary expected functions for dense matrices: +def _diagsum_dense(matrix, ignore_diags=2, bad_bins=None): + """ + function returning a diagsum list + for a square symmetric and dense matrix + it starts from the main diagonal and goes + until the upper right element - the furthermost diagonal. + """ + mat = matrix.copy().astype(float) + if bad_bins is not None: + mat[bad_bins,:] = np.nan + mat[:,bad_bins] = np.nan + + # diagonal, starting from main one + # all the way to the upper right element + diags = range(len(mat)) + + return [ np.nanmean(mat.diagonal(i)) if (i > ignore_diags) else np.nan for i in diags] + + +def _diagsum_asymm_dense(matrix, bad_bin_rows=None, bad_bin_cols=None): + """ + function returning a diagsum list + for an arbitrary dense matrix, with no + assumptions on symmetry. + + it starts from the bottom left element, goes + through the "main" diagonal and to the upper + right element - the frther most diagonal. + """ + mat = matrix.copy().astype(float) + if bad_bin_rows is not None: + mat[bad_bins_rows,:] = np.nan + elif bad_bin_cols is not None: + mat[:,bad_bins_cols] = np.nan + + (mrows, mcols) = mat.shape + + # diagonals of an arbitrary rectangle matrix + # negative diagonals are below the "main" one + diags = range(-mrows+1, mcols) + + return [ np.nanmean(mat.diagonal(i)) for i in diags ] + # flatexp_tomat = lambda e,m_like: toeplitz(e[m_like.shape[0]-1::-1],e[m_like.shape[0]-1:]) + + +def _blocksum_asymm_dense(matrix, bad_bin_rows=None, bad_bin_cols=None): + """ + function returning a blocksum-based average + for an arbitrary dense matrix, with no + assumptions on symmetry. + """ + mat = matrix.copy().astype(float) + if bad_bin_rows is not None: + mat[bad_bins_rows,:] = np.nan + elif bad_bin_cols is not None: + mat[:,bad_bins_cols] = np.nan + + return np.nanmean(mat) + + +# numpy.testing.assert_allclose(actual, desired, rtol=1e-07, atol=0, equal_nan=True, err_msg='', verbose=True) + + +# common parameters: +ignore_diags = 2 +weight_name = "weight" +bad_bins = None +chunksize = 10_000 # keep it small to engage chunking +weight1 = weight_name + "1" +weight2 = weight_name + "2" +transforms = {"balanced": lambda p: p["count"] * p[weight1] * p[weight2]} + + chromsizes = bioframe.fetch_chromsizes("mm9") chromosomes = list(chromsizes.index) supports = [(chrom, 0, chromsizes[chrom]) for chrom in chromosomes] +# test the most frequent use cases, balancing applied, no bad bins, etc. + +common_regions = [] +for i in range(4): + chrom = chromosomes[i] + halfway_chrom = int(chromsizes[chrom]/2) + reg1 = (chrom, 0, halfway_chrom) + reg2 = (chrom, halfway_chrom, chromsizes[chrom]) + common_regions.append(reg1) + common_regions.append(reg2) def test_diagsum(request): + # perform test: clr = cooler.Cooler(op.join(request.fspath.dirname, "data/CN.mm9.1000kb.cool")) - tables = cooltools.expected.diagsum( + res = cooltools.expected.diagsum( clr, - supports, - transforms={"balanced": lambda p: p["count"] * p["weight1"] * p["weight2"]}, - chunksize=10000000, + regions=common_regions, + transforms=transforms, + weight_name=weight_name, + bad_bins=bad_bins, + ignore_diags=ignore_diags, + chunksize=chunksize, ) - pd.concat( - [tables[support] for support in supports], - keys=[support[0] for support in supports], - names=["chrom"], + # calculate average: + res["balanced.avg"] = res["balanced.sum"] / res["n_valid"] + # check results for every "region" + grouped = res.groupby("region") + for name, group in grouped: + matrix = clr.matrix(balance=weight_name).fetch(name, name) + testing.assert_allclose( + actual = group["balanced.avg"].values, + desired = _diagsum_dense(matrix, ignore_diags=2), + # rtol=1e-07, + # atol=0, + equal_nan=True + ) + + +def test_diagsum_asymm(request): + # perform test: + clr = cooler.Cooler(op.join(request.fspath.dirname, "data/CN.mm9.1000kb.cool")) + cis_pairwise_regions = [(r1,r2) for (r1,r2) in combinations(common_regions, 2) if (r1[0]==r2[0])] + regions1, regions2 = list(zip(*cis_pairwise_regions)) + res = cooltools.expected.diagsum_asymm( + clr, + regions1=regions1, + regions2=regions2, + transforms=transforms, + weight_name=weight_name, + bad_bins=bad_bins, + chunksize=chunksize, ) + # calculate average: + res["balanced.avg"] = res["balanced.sum"] / res["n_valid"] + # check results for every block, defined as region1/2 + grouped = res.groupby(["region1","region2"]) + for (name1, name2), group in grouped: + matrix = clr.matrix(balance=weight_name).fetch(name1, name2) + testing.assert_allclose( + actual = group["balanced.avg"].values, + desired = _diagsum_asymm_dense(matrix), + # rtol=1e-07, + # atol=0, + equal_nan=True + ) + + def test_blocksum(request): + # perform test: clr = cooler.Cooler(op.join(request.fspath.dirname, "data/CN.mm9.1000kb.cool")) - records = cooltools.expected.blocksum_pairwise( + all_pairwise_regions = combinations(common_regions, 2) + regions1, regions2 = list(zip(*all_pairwise_regions)) + res = cooltools.expected.blocksum_asymm( clr, - supports, - transforms={"balanced": lambda p: p["count"] * p["weight1"] * p["weight2"]}, - chunksize=10000000, - ) - pd.DataFrame( - [ - {"chrom1": s1[0], "chrom2": s2[0], **rec} - for (s1, s2), rec in records.items() - ], - columns=["chrom1", "chrom2", "n_valid", "count.sum", "balanced.sum"], + regions1=regions1, + regions2=regions2, + transforms=transforms, + weight_name=weight_name, + bad_bins=bad_bins, + chunksize=chunksize, ) + # calculate average: + res["balanced.avg"] = res["balanced.sum"] / res["n_valid"] + # check results for every block , defined as region1/2 + # should be simplified as there is 1 number per block only + grouped = res.groupby(["region1","region2"]) + for (name1, name2), group in grouped: + matrix = clr.matrix(balance=weight_name).fetch(name1, name2) + testing.assert_allclose( + actual = group["balanced.avg"].values, + desired = _blocksum_asymm_dense(matrix), + # rtol=1e-07, + # atol=0, + equal_nan=True + ) + From 2eb417c775d2ab7c35f96e95b881569e208d38a6 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Tue, 23 Jun 2020 18:03:53 -0400 Subject: [PATCH 51/71] minor test expected fixes, names and typos --- tests/test_expected.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/test_expected.py b/tests/test_expected.py index 252e3ef5..80f83490 100644 --- a/tests/test_expected.py +++ b/tests/test_expected.py @@ -1,6 +1,7 @@ import os.path as op import pandas as pd +import numpy as np from numpy import testing import bioframe @@ -28,7 +29,7 @@ def _diagsum_dense(matrix, ignore_diags=2, bad_bins=None): # all the way to the upper right element diags = range(len(mat)) - return [ np.nanmean(mat.diagonal(i)) if (i > ignore_diags) else np.nan for i in diags] + return [ np.nanmean(mat.diagonal(i)) if (i >= ignore_diags) else np.nan for i in diags] def _diagsum_asymm_dense(matrix, bad_bin_rows=None, bad_bin_cols=None): From 68931f96719cb612eef57e4b9165cbd31be8b97c Mon Sep 17 00:00:00 2001 From: sergpolly Date: Wed, 24 Jun 2020 15:15:00 -0400 Subject: [PATCH 52/71] fixing requirements conflict: conda vs pip, travis please work --- environment.yml | 4 ---- 1 file changed, 4 deletions(-) diff --git a/environment.yml b/environment.yml index 480bf843..a55d8476 100644 --- a/environment.yml +++ b/environment.yml @@ -4,11 +4,7 @@ channels: dependencies: - cython - h5py - - matplotlib - - numba - - numpy - pip - pytables - - scikit-learn - pip: - -r requirements-dev.txt From b69befd687368bd13ed87634955ccb82bcb1782f Mon Sep 17 00:00:00 2001 From: sergpolly Date: Thu, 25 Jun 2020 12:39:44 -0400 Subject: [PATCH 53/71] remove pytables fron conda-env in favor of tables in pip-reqs --- environment.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/environment.yml b/environment.yml index a55d8476..aa5e3e44 100644 --- a/environment.yml +++ b/environment.yml @@ -5,6 +5,5 @@ dependencies: - cython - h5py - pip - - pytables - pip: - -r requirements-dev.txt From fb4bfbe9626d16a9c5e0e7ddf35d644a9cf65847 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Fri, 26 Jun 2020 11:34:27 -0400 Subject: [PATCH 54/71] drop conda-environment-yaml, update travis-config --- .travis.yml | 7 ++++--- environment.yml | 9 --------- 2 files changed, 4 insertions(+), 12 deletions(-) delete mode 100644 environment.yml diff --git a/.travis.yml b/.travis.yml index a7ef1ad3..38ae9fa6 100644 --- a/.travis.yml +++ b/.travis.yml @@ -16,9 +16,10 @@ before_install: # Useful for debugging any issues with conda - conda info -a install: - # Create test environment and install deps - - conda env create -n test-environment python=$TRAVIS_PYTHON_VERSION -f environment.yml - - source activate test-environment + # Create test environment and install deps, prefer defaults, use bioconda when needed + - conda create -n testenv -c defaults -c bioconda python=$TRAVIS_PYTHON_VERSION numpy cython h5py + - conda activate testenv + - pip instal -r requirements-dev.txt - python setup.py install build_ext --inplace script: - pytest diff --git a/environment.yml b/environment.yml deleted file mode 100644 index aa5e3e44..00000000 --- a/environment.yml +++ /dev/null @@ -1,9 +0,0 @@ -channels: - - defaults - - bioconda -dependencies: - - cython - - h5py - - pip - - pip: - - -r requirements-dev.txt From f54dc9b934fd71a5c2fdeaab6b43271e9f00be1a Mon Sep 17 00:00:00 2001 From: sergpolly Date: Fri, 26 Jun 2020 11:38:45 -0400 Subject: [PATCH 55/71] travis fix: source activate instead of conda activate --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 38ae9fa6..eea08987 100644 --- a/.travis.yml +++ b/.travis.yml @@ -18,7 +18,7 @@ before_install: install: # Create test environment and install deps, prefer defaults, use bioconda when needed - conda create -n testenv -c defaults -c bioconda python=$TRAVIS_PYTHON_VERSION numpy cython h5py - - conda activate testenv + - source activate testenv - pip instal -r requirements-dev.txt - python setup.py install build_ext --inplace script: From 125d1eacf550a2cfedefd6ada8f2c4bb72e3979b Mon Sep 17 00:00:00 2001 From: sergpolly Date: Fri, 26 Jun 2020 11:42:59 -0400 Subject: [PATCH 56/71] typo fix --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index eea08987..9a20e83a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -19,7 +19,7 @@ install: # Create test environment and install deps, prefer defaults, use bioconda when needed - conda create -n testenv -c defaults -c bioconda python=$TRAVIS_PYTHON_VERSION numpy cython h5py - source activate testenv - - pip instal -r requirements-dev.txt + - pip install -r requirements-dev.txt - python setup.py install build_ext --inplace script: - pytest From 40c2c4be97c5ff92b3c40b9de08eebbc915de6ec Mon Sep 17 00:00:00 2001 From: Nezar Abdennur Date: Fri, 26 Jun 2020 11:58:52 -0400 Subject: [PATCH 57/71] Update .travis.yml --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 9a20e83a..6127fa90 100644 --- a/.travis.yml +++ b/.travis.yml @@ -17,7 +17,7 @@ before_install: - conda info -a install: # Create test environment and install deps, prefer defaults, use bioconda when needed - - conda create -n testenv -c defaults -c bioconda python=$TRAVIS_PYTHON_VERSION numpy cython h5py + - conda create -n testenv python=$TRAVIS_PYTHON_VERSION numpy cython h5py - source activate testenv - pip install -r requirements-dev.txt - python setup.py install build_ext --inplace From 16686a11e42499050d17db32423352488aeda547 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Fri, 26 Jun 2020 15:53:46 -0400 Subject: [PATCH 58/71] temporarily use bioframe-develop, make travis go --- .travis.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.travis.yml b/.travis.yml index 6127fa90..d3c8f163 100644 --- a/.travis.yml +++ b/.travis.yml @@ -20,6 +20,8 @@ install: - conda create -n testenv python=$TRAVIS_PYTHON_VERSION numpy cython h5py - source activate testenv - pip install -r requirements-dev.txt + # temporary bioframe reinstall, until relevant changes merged are released + - pip install --no-deps --force-reinstall git+https://github.com/mirnylab/bioframe.git@develop#egg=bioframe - python setup.py install build_ext --inplace script: - pytest From 6a90aeff67428143ed1f8e7d12514367ac0519f9 Mon Sep 17 00:00:00 2001 From: Maksim Imakaev Date: Tue, 30 Jun 2020 13:23:22 -0300 Subject: [PATCH 59/71] Restore bioframe>=0.1.0 requirement --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 7a7a6590..0e889304 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,4 @@ -bioframe<0.1.0 +bioframe>=0.1.0 click>=7 cooler>=0.8.5 cython From f54b6295c52deadcbb957c4687ebf72151e6de1f Mon Sep 17 00:00:00 2001 From: Maksim Imakaev Date: Tue, 30 Jun 2020 13:26:15 -0300 Subject: [PATCH 60/71] typo in bioframe requirement --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 0e889304..3510d344 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,4 @@ -bioframe>=0.1.0 +bioframe>=0.0.10 click>=7 cooler>=0.8.5 cython From 6cc2adfe864bc71c027791f6494e193ec88cb5de Mon Sep 17 00:00:00 2001 From: Nezar Abdennur Date: Tue, 8 Sep 2020 21:09:36 -0400 Subject: [PATCH 61/71] Update formatting --- cooltools/eigdecomp.py | 70 +++--- cooltools/expected.py | 485 +++++++++++++++++++++-------------------- 2 files changed, 299 insertions(+), 256 deletions(-) diff --git a/cooltools/eigdecomp.py b/cooltools/eigdecomp.py index ebf76508..86b8ecf8 100644 --- a/cooltools/eigdecomp.py +++ b/cooltools/eigdecomp.py @@ -297,13 +297,25 @@ def cooler_cis_eig( ignore_diags=None, clip_percentile=99.9, sort_metric=None, - map=map ): - - if regions is None: # normalize_regins will fill in the rest - regions = list(bins["chrom"].unique()) # and check consistency - - regions = bioframe.parse_regions(regions, clr.chromsizes, force_UCSC_names=True) + # Perform consitency checks. + if regions is None: + chroms_not_in_clr = [ + chrom for chrom in bins["chrom"].unique() if chrom not in clr.chromsizes + ] + + if len(chroms_not_in_clr) > 0: + raise ValueError( + "The following chromosomes are found in the bin table, but not " + "in the cooler: " + str(chroms_not_in_clr) + ) + + if regions is None: + regions = ( + [(chrom, 0, clr.chromsizes[chrom]) for chrom in bins["chrom"].unique()] + if regions is None + else [bioframe.parse_region(r) for r in regions] + ) ignore_diags = ( clr._load_attrs("bins/weight").get("ignore_diags", 2) @@ -313,24 +325,19 @@ def cooler_cis_eig( eigvec_table = bins.copy() for i in range(n_eigs): - eigvec_table[f"E{i+1}"] = np.nan - eig_columns = [f"E{i+1}" for i in range(n_eigs)] + eigvec_table["E" + str(i + 1)] = np.nan def _each(region): - A = clr.matrix(balance=balance).fetch(region[:3]) + A = clr.matrix(balance=balance).fetch(region) if phasing_track_col and (phasing_track_col not in bins): raise ValueError( 'No column "{}" in the bin table'.format(phasing_track_col) ) - - # mask to determin bins belonging to the region - subindex = clr.bins().fetch(region[:3]).index - subregion = bins.loc[subindex].copy() - - if phasing_track_col: - phasing_track = subregion[phasing_track_col].values - else: - phasing_track = None + phasing_track = ( + bioframe.slice_bedframe(bins, region)[phasing_track_col].values + if phasing_track_col + else None + ) eigvals, eigvecs = cis_eig( A, @@ -340,17 +347,30 @@ def _each(region): clip_percentile=clip_percentile, sort_metric=sort_metric, ) - - return eigvals, eigvecs, subregion.index - results = list(map(_each, regions.values)) + return eigvals, eigvecs + + eigvals_per_reg, eigvecs_per_reg = zip(*map(_each, regions)) - for region, eigvecs, index in results: - eigvec_table.at[index, eig_columns] = eigvecs.T + for region, eigvecs in zip(regions, eigvecs_per_reg): + lo, hi = bioframe.bisect_bedframe(bins, region) + for i, eigvec in enumerate(eigvecs): + eigvec_table.iloc[ + lo:hi, eigvec_table.columns.get_loc("E" + str(i + 1)) + ] = eigvec + + region_strs = [ + ( + chrom + if (start == 0 and end == clr.chromsizes[chrom]) + else "{}:{}-{}".format(chrom, start, end) + ) + for chrom, start, end in regions + ] eigvals = pd.DataFrame( - index=regions["name"], - data=np.vstack([i[0] for i in results]), + index=region_strs, + data=np.vstack(eigvals_per_reg), columns=["eigval" + str(i + 1) for i in range(n_eigs)], ) diff --git a/cooltools/expected.py b/cooltools/expected.py index a7d48d61..0939caa6 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -216,7 +216,8 @@ def count_all_pixels_per_block(x, y): number_of_pixels : int total number of pixels in a block """ - return x*y + return x * y + def count_bad_pixels_per_block(x, y, bad_bins_x, bad_bins_y): """ @@ -306,12 +307,6 @@ def _make_diag_table(n_bins, bad_locs): return diags.astype(int) -def _sum_diagonals(df, field): - reduced = df.groupby("diag")[field].sum() - reduced.name = field + ".sum" - return reduced - - def make_diag_tables(clr, regions, regions2=None, weight_name="weight", bad_bins=None): """ For every support region infer diagonals that intersect this region @@ -358,7 +353,7 @@ def make_diag_tables(clr, regions, regions2=None, weight_name="weight", bad_bins regions = bioframe.parse_regions(regions, clr.chromsizes).values if regions2 is not None: regions2 = bioframe.parse_regions(regions2, clr.chromsizes).values - + bins = clr.bins()[:] if weight_name is None: # ignore bad bins @@ -385,25 +380,25 @@ def make_diag_tables(clr, regions, regions2=None, weight_name="weight", bad_bins except IndexError: raise ValueError("Provided `bad_bins` are incorrect or out-of-bound") # group them by observed chromosomes only - bad_bins_grp = bad_bins_chrom[["index","chrom"]].groupby("chrom",observed=True) + bad_bins_grp = bad_bins_chrom[["index", "chrom"]].groupby( + "chrom", observed=True + ) # update "bad_bin_dict" with "bad_bins" for each chrom: for chrom, bin_ids in bad_bins_grp["index"]: co = clr.offset(chrom) # adjust by chromosome offset bad_bin_dict[chrom][bin_ids.values - co] = True - - where = np.flatnonzero diag_tables = {} for i in range(len(regions)): - chrom,start1,end1,name1 = regions[i] + chrom, start1, end1, name1 = regions[i] if regions2 is not None: - chrom2,start2, end2,name2 = regions2[i] + chrom2, start2, end2, name2 = regions2[i] # cis-only for now: - assert chrom2==chrom + assert chrom2 == chrom else: start2, end2 = start1, end1 - + # translate regions into relative bin id-s: lo1, hi1 = clr.extent((chrom, start1, end1)) lo2, hi2 = clr.extent((chrom, start2, end2)) @@ -414,13 +409,14 @@ def make_diag_tables(clr, regions, regions2=None, weight_name="weight", bad_bins hi2 -= co bad_mask = bad_bin_dict[chrom] - newname = name1 + newname = name1 if regions2 is not None: newname = (name1, name2) diag_tables[newname] = make_diag_table(bad_mask, [lo1, hi1], [lo2, hi2]) return diag_tables + def make_block_table(clr, regions1, regions2, weight_name="weight", bad_bins=None): """ Creates a table that characterizes a set of rectangular genomic blocks @@ -469,7 +465,7 @@ def make_block_table(clr, regions1, regions2, weight_name="weight", bad_bins=Non # should we check for nestedness here, or that each region1 is < region2 ? block_table = {} - for r1,r2 in zip(regions1,regions2): + for r1, r2 in zip(regions1, regions2): chrom1, start1, end1, name1 = r1 chrom2, start2, end2, name2 = r2 # translate regions into relative bin id-s: @@ -479,8 +475,8 @@ def make_block_table(clr, regions1, regions2, weight_name="weight", bad_bins=Non x = hi1 - lo1 y = hi2 - lo2 # get "regional" bad_bins for each of the regions - bx = bad_bins[(bad_bins>=lo1)&(bad_bins=lo2)&(bad_bins= lo1) & (bad_bins < hi1)] - lo1 + by = bad_bins[(bad_bins >= lo2) & (bad_bins < hi2)] - lo2 # now we need to combine it with the balancing weights if weight_name is None: @@ -507,8 +503,8 @@ def make_block_table(clr, regions1, regions2, weight_name="weight", bad_bins=Non n_bad = count_bad_pixels_per_block(x, y, bad_bins_x, bad_bins_y) # fill in "block_table" with number of valid pixels: - block_table[name1,name2] = defaultdict(int) - block_table[name1,name2]["n_valid"] = n_tot - n_bad + block_table[name1, name2] = defaultdict(int) + block_table[name1, name2]["n_valid"] = n_tot - n_bad return block_table @@ -537,69 +533,11 @@ def _diagsum_symm(clr, fields, transforms, regions, span): r1 = assign_supports(pixels, [r], suffix="1") r2 = assign_supports(pixels, [r], suffix="2") # calculate diag_sums on the spot to allow for overlapping blocks: - diag_sums[i] = pixels[(r1==r2)].groupby("dist")[fields].sum() - - return diag_sums - - -def _diagsum_asymm(clr, fields, transforms, regions1, regions2, span): - """ - calculates diagonal summary for a collection of - rectangular regions defined as combinations of - regions1 and regions2. - returns a dictionary of DataFrames with diagonal - sums as values, and 0-based indexes of rectangular - genomic regions as keys. - """ - lo, hi = span - bins = clr.bins()[:] - pixels = clr.pixels()[lo:hi] - pixels = cooler.annotate(pixels, bins, replace=False) - - # this could further expanded to allow for custom groupings: - pixels["dist"] = pixels["bin2_id"] - pixels["bin1_id"] - for field, t in transforms.items(): - pixels[field] = t(pixels) - - diag_sums = {} - # r1 and r2 define rectangular block i: - for i,(r1,r2) in enumerate(zip(regions1,regions2)): - r1 = assign_supports(pixels, [r1], suffix="1") - r2 = assign_supports(pixels, [r2], suffix="2") - # calculate diag_sums on the spot to allow for overlapping blocks: - diag_sums[i] = pixels[(r1==r2)].groupby("dist")[fields].sum() + diag_sums[i] = pixels[(r1 == r2)].groupby("dist")[fields].sum() return diag_sums -def _blocksum_asymm(clr, fields, transforms, regions1, regions2, span): - """ - calculates block summary for a collection of - rectangular regions defined as combinations of - regions1 and regions2. - returns a dictionary of with block sums as values, - and 0-based indexes of rectangular genomic regions - as keys. - """ - lo, hi = span - bins = clr.bins()[:] - pixels = clr.pixels()[lo:hi] - pixels = cooler.annotate(pixels, bins, replace=False) - - for field, t in transforms.items(): - pixels[field] = t(pixels) - - block_sums = {} - # r1 and r2 define rectangular block i: - for i,(r1,r2) in enumerate(zip(regions1,regions2)): - r1 = assign_supports(pixels, [r1], suffix="1") - r2 = assign_supports(pixels, [r2], suffix="2") - # calculate sum on the spot to allow for overlapping blocks: - block_sums[i] = pixels[(r1==r2)][fields].sum() - - return block_sums - - def diagsum( clr, regions, @@ -646,9 +584,9 @@ def diagsum( """ spans = partition(0, len(clr.pixels()), chunksize) fields = ["count"] + list(transforms.keys()) - - regions = bioframe.parse_regions(regions, clr.chromsizes) - + + regions = bioframe.parse_regions(regions, clr.chromsizes) + dtables = make_diag_tables(clr, regions, weight_name=weight_name, bad_bins=bad_bins) # combine masking with existing transforms and add a "count" transform: @@ -665,14 +603,17 @@ def diagsum( if field in transforms: # combine masking and transform, minding the scope: t = transforms[field] - masked_transforms[field] = lambda p,t=t,m=bad_bins_mask: t(p) * m[p[bin1]] * m[p[bin2]] + masked_transforms[field] = ( + lambda p, t=t, m=bad_bins_mask: t(p) * m[p[bin1]] * m[p[bin2]] + ) else: # presumably field == "count", mind the scope as well: - masked_transforms[field] = lambda p,f=field,m=bad_bins_mask: p[f] * m[p[bin1]] * m[p[bin2]] + masked_transforms[field] = ( + lambda p, f=field, m=bad_bins_mask: p[f] * m[p[bin1]] * m[p[bin2]] + ) # substitute transforms to the masked_transforms: transforms = masked_transforms - for dt in dtables.values(): for field in fields: agg_name = "{}.sum".format(field) @@ -682,13 +623,13 @@ def diagsum( results = map(job, spans) for result in results: for i, agg in result.items(): - region = regions.loc[i,"name"] + region = regions.loc[i, "name"] for field in fields: agg_name = "{}.sum".format(field) dtables[region][agg_name] = dtables[region][agg_name].add( agg[field], fill_value=0 ) - + if ignore_diags: for dt in dtables.values(): for field in fields: @@ -698,13 +639,43 @@ def diagsum( # returning dataframe for API consistency result = [] - for i,dtable in dtables.items(): + for i, dtable in dtables.items(): dtable = dtable.reset_index() - dtable.insert(0,"region", i) + dtable.insert(0, "region", i) result.append(dtable) return pd.concat(result).reset_index(drop=True) +def _diagsum_asymm(clr, fields, transforms, regions1, regions2, span): + """ + calculates diagonal summary for a collection of + rectangular regions defined as combinations of + regions1 and regions2. + returns a dictionary of DataFrames with diagonal + sums as values, and 0-based indexes of rectangular + genomic regions as keys. + """ + lo, hi = span + bins = clr.bins()[:] + pixels = clr.pixels()[lo:hi] + pixels = cooler.annotate(pixels, bins, replace=False) + + # this could further expanded to allow for custom groupings: + pixels["dist"] = pixels["bin2_id"] - pixels["bin1_id"] + for field, t in transforms.items(): + pixels[field] = t(pixels) + + diag_sums = {} + # r1 and r2 define rectangular block i: + for i, (r1, r2) in enumerate(zip(regions1, regions2)): + r1 = assign_supports(pixels, [r1], suffix="1") + r2 = assign_supports(pixels, [r2], suffix="2") + # calculate diag_sums on the spot to allow for overlapping blocks: + diag_sums[i] = pixels[(r1 == r2)].groupby("dist")[fields].sum() + + return diag_sums + + def diagsum_asymm( clr, regions1, @@ -757,10 +728,12 @@ def diagsum_asymm( """ spans = partition(0, len(clr.pixels()), chunksize) fields = ["count"] + list(transforms.keys()) - regions1 = bioframe.parse_regions(regions1, clr.chromsizes) - regions2 = bioframe.parse_regions(regions2, clr.chromsizes) + regions1 = bioframe.parse_regions(regions1, clr.chromsizes) + regions2 = bioframe.parse_regions(regions2, clr.chromsizes) - dtables = make_diag_tables(clr, regions1, regions2, weight_name=weight_name, bad_bins=bad_bins) + dtables = make_diag_tables( + clr, regions1, regions2, weight_name=weight_name, bad_bins=bad_bins + ) # combine masking with existing transforms and add a "count" transform: if bad_bins is not None: @@ -776,10 +749,14 @@ def diagsum_asymm( if field in transforms: # combine masking and transform, minding the scope: t = transforms[field] - masked_transforms[field] = lambda p,t=t,m=bad_bins_mask: t(p) * m[p[bin1]] * m[p[bin2]] + masked_transforms[field] = ( + lambda p, t=t, m=bad_bins_mask: t(p) * m[p[bin1]] * m[p[bin2]] + ) else: # presumably field == "count", mind the scope as well: - masked_transforms[field] = lambda p,f=field,m=bad_bins_mask: p[f] * m[p[bin1]] * m[p[bin2]] + masked_transforms[field] = ( + lambda p, f=field, m=bad_bins_mask: p[f] * m[p[bin1]] * m[p[bin2]] + ) # substitute transforms to the masked_transforms: transforms = masked_transforms @@ -794,8 +771,8 @@ def diagsum_asymm( results = map(job, spans) for result in results: for i, agg in result.items(): - region1 = regions1.loc[i,"name"] - region2 = regions2.loc[i,"name"] + region1 = regions1.loc[i, "name"] + region2 = regions2.loc[i, "name"] for field in fields: agg_name = "{}.sum".format(field) dtables[region1, region2][agg_name] = dtables[region1, region2][ @@ -804,14 +781,42 @@ def diagsum_asymm( # returning a dataframe for API consistency: result = [] - for (i,j), dtable in dtables.items(): + for (i, j), dtable in dtables.items(): dtable = dtable.reset_index() - dtable.insert(0,"region1", i) - dtable.insert(1,"region2", j) + dtable.insert(0, "region1", i) + dtable.insert(1, "region2", j) result.append(dtable) return pd.concat(result).reset_index(drop=True) +def _blocksum_asymm(clr, fields, transforms, regions1, regions2, span): + """ + calculates block summary for a collection of + rectangular regions defined as combinations of + regions1 and regions2. + returns a dictionary of with block sums as values, + and 0-based indexes of rectangular genomic regions + as keys. + """ + lo, hi = span + bins = clr.bins()[:] + pixels = clr.pixels()[lo:hi] + pixels = cooler.annotate(pixels, bins, replace=False) + + for field, t in transforms.items(): + pixels[field] = t(pixels) + + block_sums = {} + # r1 and r2 define rectangular block i: + for i, (r1, r2) in enumerate(zip(regions1, regions2)): + r1 = assign_supports(pixels, [r1], suffix="1") + r2 = assign_supports(pixels, [r2], suffix="2") + # calculate sum on the spot to allow for overlapping blocks: + block_sums[i] = pixels[(r1 == r2)][fields].sum() + + return block_sums + + def blocksum_asymm( clr, regions1, @@ -864,7 +869,9 @@ def blocksum_asymm( # similar with diagonal summations, pre-generate a block_table listing # all of the rectangular blocks and "n_valid" number of pixels per each block: - records = make_block_table(clr, regions1, regions2, weight_name=weight_name, bad_bins=bad_bins) + records = make_block_table( + clr, regions1, regions2, weight_name=weight_name, bad_bins=bad_bins + ) # combine masking with existing transforms and add a "count" transform: if bad_bins is not None: @@ -880,14 +887,20 @@ def blocksum_asymm( if field in transforms: # combine masking and transform, minding the scope: t = transforms[field] - masked_transforms[field] = lambda p,t=t,m=bad_bins_mask: t(p) * m[p[bin1]] * m[p[bin2]] + masked_transforms[field] = ( + lambda p, t=t, m=bad_bins_mask: t(p) * m[p[bin1]] * m[p[bin2]] + ) else: # presumably field == "count", mind the scope as well: - masked_transforms[field] = lambda p,f=field,m=bad_bins_mask: p[f] * m[p[bin1]] * m[p[bin2]] + masked_transforms[field] = ( + lambda p, f=field, m=bad_bins_mask: p[f] * m[p[bin1]] * m[p[bin2]] + ) # substitute transforms to the masked_transforms: transforms = masked_transforms - job = partial(_blocksum_asymm, clr, fields, transforms, regions1.values, regions2.values) + job = partial( + _blocksum_asymm, clr, fields, transforms, regions1.values, regions2.values + ) results = map(job, spans) for result in results: for i, agg in result.items(): @@ -895,18 +908,15 @@ def blocksum_asymm( agg_name = "{}.sum".format(field) s = agg[field].item() if not np.isnan(s): - n1 = regions1.loc[i,"name"] - n2 = regions2.loc[i,"name"] + n1 = regions1.loc[i, "name"] + n2 = regions2.loc[i, "name"] records[n1, n2][agg_name] += s # returning a dataframe for API consistency: return pd.DataFrame( - [ - {"region1": n1, "region2": n2, **rec} - for (n1, n2), rec in records.items() - ], - columns=["region1", "region2", "n_valid", "count.sum"] + \ - [ k+".sum" for k in transforms.keys() ] + [{"region1": n1, "region2": n2, **rec} for (n1, n2), rec in records.items()], + columns=["region1", "region2", "n_valid", "count.sum"] + + [k + ".sum" for k in transforms.keys()], ) @@ -919,118 +929,127 @@ def logbin_expected( min_count=50, ): """ - Logarithmically bins expected as produced by diagsum method - See description below + Logarithmically bins expected as produced by diagsum method. Parameters ---------- + exp : dict + {region: expected_df} produced by diagsum - exp: dict - {region:expected_df} produced by diagsum - bins_per_order_magnitude : int (optional) - How many bins per order of magnitude. Default of 10 has a ratio of neighboring bins of about 1.25 - + How many bins per order of magnitude. Default of 10 has a ratio of + neighboring bins of about 1.25 + bin_layout : "fixed", "longest_region", or array - "fixed" means that bins are exactly the same for different datasets, + "fixed" means that bins are exactly the same for different datasets, and only depend on bins_per_order_magnitude - - "longest_region" means that the last bin will end at size of the longest region. - GOOD: the last bin will have as much data as possible. - BAD: bin edges will end up different for different datasets, you can't divide them by each other - - array: provide your own bin edges. Can be of any size, and end at any value: bins exceeding the size - of the largest region will be simply ignored. - - der_smooth_function_by_reg: callable - A smoothing function to be applied to log(P(s)) and log(x) + + "longest_region" means that the last bin will end at size of the + longest region. + GOOD: the last bin will have as much data as possible. + BAD: bin edges will end up different for different datasets, you + can't divide them by each other + + array: provide your own bin edges. Can be of any size, and end at any + value. Bins exceeding the size of the largest region will be simply + ignored. + + der_smooth_function_by_reg : callable + A smoothing function to be applied to log(P(s)) and log(x) before calculating P(s) slopes for by-region data - - der_smooth_function_combined: callable + + der_smooth_function_combined : callable A smoothing function for calculating slopes on combined data - - min_nvalid: int - For each region, throw out bins (log-spaced) that have less than min_nvalid valid pixels - This will ensure that each entree in Pc_by_region has at least n_valid valid pixels - Don't set it to zero, or it will introduce bugs. Setting it to 1 is OK, but not recommended. - - min_count: int - If counts are found in the data, then for each region, throw out bins (log-spaced) - that have more than min_counts of counts.sum (raw Hi-C counts). - This will ensure that each entree in Pc_by_region has at least min_count raw Hi-C reads + min_nvalid : int + For each region, throw out bins (log-spaced) that have less than + min_nvalid valid pixels + This will ensure that each entree in Pc_by_region has at least n_valid + valid pixels + Don't set it to zero, or it will introduce bugs. Setting it to 1 is OK, + but not recommended. + + min_count : int + If counts are found in the data, then for each region, throw out bins + (log-spaced) + that have more than min_counts of counts.sum (raw Hi-C counts). + This will ensure that each entree in Pc_by_region has at least + min_count raw Hi-C reads - Returns + Returns ------- - (Pc, slope, bins) - - * Pc: dataframe of contact probabilities and spread across regions - * slope: slope of Pc(s) on a log-log plot and spread across regions - * bins: an array of bin edges used for calculating P(s) - - - Description - ----------- - + Pc : DataFrame + dataframe of contact probabilities and spread across regions + slope : ndarray + slope of Pc(s) on a log-log plot and spread across regions + bins : ndarray + an array of bin edges used for calculating P(s) + + Notes + ----- For main Pc and slope, the algorithm is the following - 1. concatenate all the expected for all regions into a large dataframe. + 1. concatenate all the expected for all regions into a large dataframe. 2. create logarithmically-spaced bins of diagonals (or use provided) 3. pool together n_valid and balanced.sum for each region and for each bin 4. calculate the average diagonal for each bucket, weighted by n_valid 5. divide balanced.sum by n_valid after summing for each bucket (not before) 6. calculate the slope in log space (for each region) - - - X values are not midpoints of bins - ---------------------------------- - - In step 4, we calculate the average diag index weighted by n_valid. This seems counter-intuitive, but - it actually is justified. - - Let's take the worst case scenario. Let there be a bin from 40MB to 44MB. Let there be a - region that is exactly 41 MB long. The midpoint of the bin is at 42MB. But the only part - of this region belonging to this bin is actually between 40MB and 41MB. Moreover, - the "average" read in this little triangle of the heatmap is actually not coming even from 40.5 MB - because the triangle is getting narrower towards 41MB. The center of mass of a triangle is 1/3 of the way up, - or 40.33 MB. So an average read for this region in this bin is coming from 40.33. - - - Consider the previous bin, say, from 36MB to 40MB. The heatmap there is a trapezoid with a long side of 5MB, - the short side of 1MB, and height of 4MB. The center of mass of this trapezoid is at 36 + 14/9 = 37.55MB, - and not at 38MB. So the last bin center is definitely mis-assigned, and the second-to-last bin center is - off by some 25%. - - In presence of missing bins, this all becomes more complex, but this kind of averaging should take care of everything. - It follows a general principle: when averaging the y values with some weights, one needs to average the x values with - the same weights. The y values here are being added together, so per-diag means are - effectively averaged with the weight of n_valid. - Therefore, the x values (diag) should be averaged with the same weights. - + + X values are not midpoints of bins + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + In step 4, we calculate the average diag index weighted by n_valid. This + seems counter-intuitive, but it actually is justified. + + Let's take the worst case scenario. Let there be a bin from 40MB to 44MB. + Let there be a region that is exactly 41 MB long. The midpoint of the bin + is at 42MB. But the only part of this region belonging to this bin is + actually between 40MB and 41MB. Moreover, the "average" read in this + little triangle of the heatmap is actually not coming even from 40.5 MB + because the triangle is getting narrower towards 41MB. The center of mass + of a triangle is 1/3 of the way up, or 40.33 MB. So an average read for + this region in this bin is coming from 40.33. + + Consider the previous bin, say, from 36MB to 40MB. The heatmap there is a + trapezoid with a long side of 5MB, the short side of 1MB, and height of + 4MB. The center of mass of this trapezoid is at 36 + 14/9 = 37.55MB, + and not at 38MB. So the last bin center is definitely mis-assigned, and + the second-to-last bin center is off by some 25%. + + In presence of missing bins, this all becomes more complex, but this kind + of averaging should take care of everything. It follows a general + principle: when averaging the y values with some weights, one needs to + average the x values with the same weights. The y values here are being + added together, so per-diag means are effectively averaged with the weight + of n_valid. Therefore, the x values (diag) should be averaged with the + same weights. + Other considerations - -------------------- - - steps #3 and #5 are important because the ratio of sums does not equal to the sum of ratios, and - the former is more correct (the latter is more susceptible to noise). - It is generally better to divide at the very end, rather than dividing things for each diagonal. - - Here we divide at the end twice: first we divide balanced.sum by n_valid for each region, - then we effectively multiply it back up and divide it for each bin when combining - different regions (see weighted average in the next function). - + ~~~~~~~~~~~~~~~~~~~~ + Steps #3 and #5 are important because the ratio of sums does not equal to + the sum of ratios, and the former is more correct (the latter is more + susceptible to noise). It is generally better to divide at the very end, + rather than dividing things for each diagonal. + + Here we divide at the end twice: first we divide balanced.sum by n_valid + for each region, then we effectively multiply it back up and divide it for + each bin when combining different regions (see weighted average in the + next function). + Smoothing P(s) for the slope - ---------------------------- - - For calcuating the slope, we apply smoothing to the P(s) to ensure the slope is not too noisy. - There are several caveats here: the P(s) has to be smoothed in logspace, and both P and s have - to be smoothed. It is discussed in detail here https://gist.github.com/mimakaev/4becf1310ba6ee07f6b91e511c531e73 - + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + For calcuating the slope, we apply smoothing to the P(s) to ensure the + slope is not too noisy. There are several caveats here: the P(s) has to + be smoothed in logspace, and both P and s have to be smoothed. It is + discussed in detail here + + https://gist.github.com/mimakaev/4becf1310ba6ee07f6b91e511c531e73 + Examples -------- - For example, see this gist: https://gist.github.com/mimakaev/e9117a7fcc318e7904702eba5b47d9e6 - """ + """ from cooltools.lib.numutils import logbins exp = exp[~pd.isna(exp["balanced.sum"])] @@ -1088,7 +1107,6 @@ def logbin_expected( "bin_id": subdf.bin_id.values[:-1], } ) - newdf["region"] = reg byRegDer.append(newdf) byRegDer = pd.concat(byRegDer).reset_index(drop=True) @@ -1105,53 +1123,58 @@ def combine_binned_expected( concat_original=False, ): """ - Combines by-region log-binned expected and slopes into - + Combines by-region log-binned expected and slopes into + Parameters ---------- binned_exp: dataframe binned expected as outputed by logbin_expected - + binned_exp_slope : dataframe or None - If provided, estimates spread of slopes. + If provided, estimates spread of slopes. Is necessary if concat_original is True - + spread_funcs: "minmax", "std", "logstd" or a function (see below) A way to estimate the spread of the P(s) curves between regions. * "minmax" - use the minimum/maximum of by-region P(s) * "std" - use weighted standard deviation of P(s) curves (may produce negative results) - * "logstd" (recommended) weighted standard deviation in logspace (as seen on the plot) - + * "logstd" (recommended) weighted standard deviation in logspace (as seen on the plot) + spread_funcs_slope: "minmax", "std" or a funciton Similar to spread_func, but for slopes rather than P(s) - + concat_original: bool (default = False) Append original dataframe, and put combined under region "combined" - - Calculating errorbars/spread - ---------------------------- - - 1. Take all by-region P(s) - 2. For "minmax", remove the last var_drop_last_bins bins for each region - (by default two. They are most noisy and would inflate the - spread for the last points). Min/max are most susceptible to this. - 3. Groupby P(s) by region - 4. Apply spread_funcs to the pd.GroupBy object - Options are: minimum and maximum ("minmax"), weighted standard deviation ("std"), - weighted standard deviation in logspace ("logstd", default) or two custom functions - We do not remove the last bins for "std" / "logstd" because we are doing weighted - standard deviation. Therefore, noisy "ends" of regions would contribute very little to this. - 5. Append them to the P(s) for the same bin. - - NOTE as a result, by for minmax, we do not estimate spread for the last two bins - This is because there are often very few chromosomal arms there, and different arm - measurements are noisy. For other methods, we do estimate the spread there, and noisy - last bins are taken care of by the weighted standard deviation. However, the spread - in the last bins may be noisy, and may become a 0 if only one region is contributing to the last pixel. + Returns + ------- + scal, slope_df + + Notes + ----- + Calculating errorbars/spread - + 1. Take all by-region P(s) + 2. For "minmax", remove the last var_drop_last_bins bins for each region + (by default two. They are most noisy and would inflate the + spread for the last points). Min/max are most susceptible to this. + 3. Groupby P(s) by region + 4. Apply spread_funcs to the pd.GroupBy object. Options are: + * minimum and maximum ("minmax"), + * weighted standard deviation ("std"), + * weighted standard deviation in logspace ("logstd", default) or two custom functions + We do not remove the last bins for "std" / "logstd" because we are + doing weighted standard deviation. Therefore, noisy "ends" of regions + would contribute very little to this. + 5. Append them to the P(s) for the same bin. + As a result, by for minmax, we do not estimate spread for the last + two bins. This is because there are often very few chromosomal arms there, + and different arm measurements are noisy. For other methods, we do + estimate the spread there, and noisy last bins are taken care of by the + weighted standard deviation. However, the spread in the last bins may be + noisy, and may become a 0 if only one region is contributing to the last + pixel. """ scal = numutils.weighted_groupby_mean( binned_exp.select_dtypes(np.number), "bin_id", "n_valid", mode="mean" @@ -1180,7 +1203,7 @@ def combine_binned_expected( high_err = scal["Pc"] * var else: - low_err, high_err = spread_func(binned_exp, scal) + low_err, high_err = spread_funcs(binned_exp, scal) scal["low_err"] = low_err scal["high_err"] = high_err From 4cd1e8b52d1c4324b99cb2c588ec28b5400a5f9c Mon Sep 17 00:00:00 2001 From: Nezar Abdennur Date: Tue, 8 Sep 2020 21:12:12 -0400 Subject: [PATCH 62/71] Update formatting --- cooltools/cli/compute_expected.py | 19 +-- cooltools/lib/common.py | 28 ++--- cooltools/lib/numutils.py | 203 +++++++++++++++--------------- cooltools/saddle.py | 4 +- 4 files changed, 131 insertions(+), 123 deletions(-) diff --git a/cooltools/cli/compute_expected.py b/cooltools/cli/compute_expected.py index d55858e0..4b8b6b54 100644 --- a/cooltools/cli/compute_expected.py +++ b/cooltools/cli/compute_expected.py @@ -13,26 +13,28 @@ @cli.command() -@click.argument("cool_path", metavar="COOL_PATH", type=str, nargs=1) +@click.argument( + "cool_path", + metavar="COOL_PATH", + type=str, + nargs=1 +) @click.option( - "--nproc", - "-p", + "--nproc", "-p", help="Number of processes to split the work between." "[default: 1, i.e. no process pool]", default=1, type=int, ) @click.option( - "--chunksize", - "-c", + "--chunksize", "-c", help="Control the number of pixels handled by each worker process at a time.", type=int, default=int(10e6), show_default=True, ) @click.option( - "--output", - "-o", + "--output", "-o", help="Specify output file name to store the expected in a tsv format.", type=str, required=False, @@ -45,8 +47,7 @@ default=False, ) @click.option( - "--contact-type", - "-t", + "--contact-type", "-t", help="compute expected for cis or trans region of a Hi-C map." "Ignored when genomic-regions are provided", type=click.Choice(["cis", "trans"]), diff --git a/cooltools/lib/common.py b/cooltools/lib/common.py index 4bc18fc0..1ce85e38 100644 --- a/cooltools/lib/common.py +++ b/cooltools/lib/common.py @@ -29,7 +29,7 @@ def assign_supports(features, supports, labels=False, suffix=""): for i, region in enumerate(supports): # single-region support - if len(region) in [3,4]: + if len(region) in [3, 4]: sel = (features[c] == region[0]) & (features[e] > region[1]) if region[2] is not None: sel &= features[s] < region[2] @@ -51,19 +51,19 @@ def assign_supports(features, supports, labels=False, suffix=""): return supp_col - def assign_regions_to_bins(bin_ids, regions_span): - regions_binsorted = (regions_span[(regions_span['bin_start']>=0) - &(regions_span['bin_end']>=0) ] - .sort_values(['bin_start', 'bin_end']) - .reset_index()) + regions_binsorted = ( + regions_span[(regions_span["bin_start"] >= 0) & (regions_span["bin_end"] >= 0)] + .sort_values(["bin_start", "bin_end"]) + .reset_index() + ) + + bin_reg_idx_lo = regions_span["bin_start"].searchsorted(bin_ids, "right") - 1 + bin_reg_idx_hi = regions_span["bin_end"].searchsorted(bin_ids, "right") + mask_assigned = (bin_reg_idx_lo == bin_reg_idx_hi) & (bin_reg_idx_lo >= 0) + + region_ids = pd.array([pd.NA] * len(bin_ids)) + region_ids[mask_assigned] = regions_span["name"][bin_reg_idx_lo[mask_assigned]] - bin_reg_idx_lo = regions_span['bin_start'].searchsorted(bin_ids,'right')-1 - bin_reg_idx_hi = regions_span['bin_end'].searchsorted(bin_ids,'right') - mask_assigned = (bin_reg_idx_lo == bin_reg_idx_hi) & (bin_reg_idx_lo>=0) - - region_ids = pd.array([pd.NA]*len(bin_ids)) - region_ids[mask_assigned] = regions_span['name'][bin_reg_idx_lo[mask_assigned]] - - return region_ids \ No newline at end of file + return region_ids diff --git a/cooltools/lib/numutils.py b/cooltools/lib/numutils.py index eb7fec82..3bb62a55 100644 --- a/cooltools/lib/numutils.py +++ b/cooltools/lib/numutils.py @@ -1360,84 +1360,91 @@ def _expand(ar, counts=None): return ar_next -def robust_gauss_filter(ar, - sigma=2, - functon=scipy.ndimage.filters.gaussian_filter1d, - kwargs = None): +def robust_gauss_filter( + ar, + sigma=2, + functon=scipy.ndimage.filters.gaussian_filter1d, + kwargs=None +): """ - Implements an edge-handling mode for gaussian filter that basically ignores the edge, and also handles NANs. - - Available edge-handling modes in ndimage.filters attempt to somehow "extrapolate" the edge value and then - apply the filter (see https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.convolve.html). - That's likely because convolve uses fast fourier transform, which requires the kernel to be constant. - Here we design a better edge-handling for the gaussian smoothing. - - In a gaussian-filtered array, a pixel away from the edge is a mean of nearby pixels with gaussian weights. - With this mode, pixels near start/end are also a mean of nearby pixels with gaussian weights. That's it. - If we encounter NANs, we also simply ignore them, following the same definition: mean of nearby valid pixels. - Yes, it rases the weights for the first/last pixels, because now only a part of the whole gaussian is being used - (up to 1/2 for the first/last pixel and large sigma). But it preserves the "mean of nearby pixels" definition. - It is different from padding with zeros (it would drag the first pixel down to be more like zero). - It is also different from "nearest" - that gives too much weight to the first/last pixel. - - - To achieve this smoothing, we preform regular gaussian smoothing using mode="constant" - (pad with zeros). Then we takes an array of valid pixels and smooth it the same way. - This calculates how many "average valid pixels" contributed to each point of a smoothed array. - Dividing one by the other achieves the desired result. + Implements an edge-handling mode for gaussian filter that basically ignores + the edge, and also handles NaNs. Parameters ---------- - ar: array-like + ar : array-like Input array - sigma: float - sigma to be passed to the filter - function: callable + sigma : float + sigma to be passed to the filter + function : callable Filter to use. Default is gauusian_filter1d - kwargs: dict + kwargs : dict Additional args to pass to the filter. Default:None - + + Notes + ----- + Available edge-handling modes in ndimage.filters attempt to somehow + "extrapolate" the edge value and then apply the filter (see + https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.convolve.html). + That's likely because convolve uses fast fourier transform, which requires + the kernel to be constant. Here we design a better edge-handling for the + gaussian smoothing. + + In a gaussian-filtered array, a pixel away from the edge is a mean of nearby + pixels with gaussian weights. With this mode, pixels near start/end are + also a mean of nearby pixels with gaussian weights. That's it. If we + encounter NANs, we also simply ignore them, following the same definition: + mean of nearby valid pixels. Yes, it rases the weights for the first/last + pixels, because now only a part of the whole gaussian is being used (up to + 1/2 for the first/last pixel and large sigma). But it preserves the "mean of + nearby pixels" definition. It is different from padding with zeros (it + would drag the first pixel down to be more like zero). It is also different + from "nearest" - that gives too much weight to the first/last pixel. + + To achieve this smoothing, we preform regular gaussian smoothing using + mode="constant" (pad with zeros). Then we takes an array of valid pixels + and smooth it the same way. This calculates how many "average valid pixels" + contributed to each point of a smoothed array. Dividing one by the other + achieves the desired result. """ - if kwargs == None: - kwargs = {} + if kwargs is None: + kwargs = {} ar = np.asarray(ar, dtype=float) mask = np.isfinite(ar) - ar[~mask] = 0 + ar[~mask] = 0 a = functon(ar, sigma=sigma, mode="constant", **kwargs) b = functon(1. * mask, sigma=sigma, mode="constant", **kwargs) - return a/b - - + return a / b + + def weighted_groupby_mean(df, group_by, weigh_by, mode="mean"): """ - Weighted mean, std, and std in log space for a dataframe.groupby - + Weighted mean, std, and std in log space for a dataframe.groupby + Parameters ---------- - df : dataframe + df : dataframe Dataframe to groupby group_by : str or list - Columns to group by + Columns to group by weight_by : str - Column to use as weights + Column to use as weights mode : "mean", "std" or "logstd" - Do the weighted mean, the weighted standard deviaton, - or the weighted std in log-space from the mean-log value + Do the weighted mean, the weighted standard deviaton, + or the weighted std in log-space from the mean-log value (useful for P(s) etc.) - - """ if type(group_by) == str: group_by = [group_by] gr = df.groupby(group_by) - if mode == "mean": + if mode == "mean": def wstd(x): return np.average(x, weights=df.loc[x.index, weigh_by]) wm = wstd elif mode == "std": def wstd(x): wm = np.average(x, weights=df.loc[x.index, weigh_by]) - dev = x - wm + dev = x - wm res = np.sqrt(np.average(dev**2, weights=df.loc[x.index, weigh_by])) return res wm = wstd @@ -1445,14 +1452,13 @@ def wstd(x): def wstd(x): x = np.log(x) wm = np.average(x, weights=df.loc[x.index, weigh_by]) - dev = x - wm - res = np.sqrt(np.average(dev**2, weights=df.loc[x.index, weigh_by])) + dev = x - wm + res = np.sqrt(np.average(dev**2, weights=df.loc[x.index, weigh_by])) return np.exp(res) wm = wstd else: raise NotImplementedError - - + f = {} for i in df.columns: if i in group_by: @@ -1461,68 +1467,69 @@ def wstd(x): f[i] = ['sum'] else: f[i] = [wm] - agg = gr.agg(f) + agg = gr.agg(f) agg.columns = [i[0] for i in agg.columns] - return agg + return agg def persistent_log_bins(end=10, bins_per_order_magnitude=10): """ - Creates most nicely looking log-spaced integer bins starting at 1, - with the defined number of bins per order of magnitude. This is not a replacement for logbins, - and it has a different purpose (see note below). - + Creates most nicely looking log-spaced integer bins starting at 1, with the + defined number of bins per order of magnitude. + Parameters ---------- - - end : number (int recommended) - log10 of the last value. It is safe to put a large value here and select your range of bins later. - - bins_per_order_magnitude : int >0 - how many bins per order of magnitude - - + end : number (int recommended) log10 of the last value. It is safe to put a + large value here and select your range of bins later. + + bins_per_order_magnitude : int >0 how many bins per order of magnitude + + Notes + ----- + This is not a replacement for logbins, and it has a different purpose. + Difference between this and logbins - ----------------------------------- - - Logbins creates bins from lo to hi, spaced logarithmically with an appriximate ratio. Logbins - makes sure that the last bin is large (i.e. hi/ratio ... hi), and will not allow the last - bin to be much less than ratio. It would slightly adjust the ratio to achieve that. - As a result, by construciton, logbins bins are different for different lo or hi. - - This function is designed to create exactly the same bins that only depend on one parameter, - bins_per_order_magnitude. The goal is to make things calculated for different datasets/organisms/etc. - comparable. For example, if these bins are used, it would allow us to divide P(s) for two different organisms - by each other because it was calculated for the same bins. - - The price you pay for such versatility is that the last bin can be much less than others in real application. - For example, if you have 10 bins per order of magnitude (ratio of 1.25), but your data ends at 10500, then - the only points in the last bin would be 10000..10500, 1/5 of what could be. This may make the last point noisy. - - The main part is done using np.logspace and rounding to the nearest integer, followed by unique. - The gaps are then re-sorted to ensure that gaps are strictly increasing. The re-sorting of - gaps was essential, and produced better results than manual adjustment. - + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + Logbins creates bins from lo to hi, spaced logarithmically with an + appriximate ratio. Logbins makes sure that the last bin is large (i.e. + hi/ratio ... hi), and will not allow the last bin to be much less than + ratio. It would slightly adjust the ratio to achieve that. As a result, by + construciton, logbins bins are different for different lo or hi. + + This function is designed to create exactly the same bins that only depend + on one parameter, bins_per_order_magnitude. The goal is to make things + calculated for different datasets/organisms/etc. comparable. For example, if + these bins are used, it would allow us to divide P(s) for two different + organisms by each other because it was calculated for the same bins. + + The price you pay for such versatility is that the last bin can be much less + than others in real application. For example, if you have 10 bins per order + of magnitude (ratio of 1.25), but your data ends at 10500, then the only + points in the last bin would be 10000..10500, 1/5 of what could be. This may + make the last point noisy. + + The main part is done using np.logspace and rounding to the nearest integer, + followed by unique. The gaps are then re-sorted to ensure that gaps are + strictly increasing. The re-sorting of gaps was essential, and produced + better results than manual adjustment. + Alternatives that produce irregular bins - ---------------------------------------- - - Using np.unique(np.logspace(a,b,N,dtype=int)) can be sub-optimal - For example, np.unique(np.logspace(0,1,11,dtype=int)) = [ 1, 2, 3, 5, 6, 7, 10] - Note the gaps jump from 1 to 2 back to 1 + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + Using np.unique(np.logspace(a,b,N,dtype=int)) can be sub-optimal For + example, np.unique(np.logspace(0,1,11,dtype=int)) = [ 1, 2, 3, 5, 6, 7, + 10] Note the gaps jump from 1 to 2 back to 1 Similarly using np.unique(np.rint(np.logspace..)) can be suboptimal - np.unique(np.array(np.rint(np.logspace(0,1,9)),dtype=int)) = [ 1, 2, 3, 4, 6, 7, 10] + np.unique(np.array(np.rint(np.logspace(0,1,9)),dtype=int)) = [ 1, 2, 3, + 4, 6, 7, 10] - for bins_per_order_of_magnitude=16, 10 is not in bins. Other than that, 10, 100, 1000, etc. are always included. - - + for bins_per_order_of_magnitude=16, 10 is not in bins. Other than that, 10, + 100, 1000, etc. are always included. """ - if end > 50: raise ValueError("End is a log10(max_value), not the max_value itself") - bin_float = np.logspace(0, end, end * bins_per_order_magnitude + 1) bin_int = np.array(np.rint(bin_float), dtype=int) # rounding to the nearest int - bins = np.unique(bin_int) # unique bins - bins = np.cumsum(np.sort(np.r_[1,np.diff(bins)])) #re-ordering gaps (important step) + bins = np.unique(bin_int) # unique bins + bins = np.cumsum(np.sort(np.r_[1, np.diff(bins)])) # re-ordering gaps (important step) return bins diff --git a/cooltools/saddle.py b/cooltools/saddle.py index 33add076..2b874576 100644 --- a/cooltools/saddle.py +++ b/cooltools/saddle.py @@ -296,7 +296,7 @@ def make_saddle( """ digitized_df, name = digitized - digitized_df = digitized_df[["chrom","start","end",name]] + digitized_df = digitized_df[["chrom", "start", "end", name]] if regions is None: regions = [ @@ -305,7 +305,7 @@ def make_saddle( ] regions = bioframe.parse_regions(regions) - + digitized_tracks = {} for reg in regions.values: track = bioframe.bedslice(digitized_df, reg) From 977a03f0e6a0ca55117077152bf164eab5f25db5 Mon Sep 17 00:00:00 2001 From: Nezar Abdennur Date: Tue, 8 Sep 2020 21:28:48 -0400 Subject: [PATCH 63/71] Install bioframe from github develop branch --- .travis.yml | 2 -- requirements.txt | 2 +- setup.py | 4 ++-- 3 files changed, 3 insertions(+), 5 deletions(-) diff --git a/.travis.yml b/.travis.yml index d3c8f163..6127fa90 100644 --- a/.travis.yml +++ b/.travis.yml @@ -20,8 +20,6 @@ install: - conda create -n testenv python=$TRAVIS_PYTHON_VERSION numpy cython h5py - source activate testenv - pip install -r requirements-dev.txt - # temporary bioframe reinstall, until relevant changes merged are released - - pip install --no-deps --force-reinstall git+https://github.com/mirnylab/bioframe.git@develop#egg=bioframe - python setup.py install build_ext --inplace script: - pytest diff --git a/requirements.txt b/requirements.txt index 90b1a499..edbb1ff1 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,4 @@ -bioframe +-e git+https://github.com/mirnylab/bioframe.git@develop#egg=bioframe click>=7 cooler>=0.8.5 cython diff --git a/setup.py b/setup.py index 41f375d2..ba013e89 100644 --- a/setup.py +++ b/setup.py @@ -47,7 +47,7 @@ def get_requirements(path): return [ req for req in content.split("\n") - if req != '' and not req.startswith('#') + if req != '' and not (req.startswith('#') or req.startswith('-')) ] @@ -96,7 +96,7 @@ def get_requirements(path): install_requires=install_requires, entry_points={ 'console_scripts': [ - 'cooltools = cooltools.cli:cli', + 'cooltools = cooltools.cli:cli', ] } ) From 19f755f5daf4d9f957a645649d389c6ed4a7c5b8 Mon Sep 17 00:00:00 2001 From: Nezar Abdennur Date: Tue, 8 Sep 2020 22:15:42 -0400 Subject: [PATCH 64/71] Fix eigdecomp and saddle to work with new bioframe --- cooltools/cli/compute_saddle.py | 78 ++++++++++++++++----------------- cooltools/eigdecomp.py | 8 ++-- cooltools/saddle.py | 5 +-- tests/test_expected.py | 58 ++++++++++++------------ 4 files changed, 75 insertions(+), 74 deletions(-) diff --git a/cooltools/cli/compute_saddle.py b/cooltools/cli/compute_saddle.py index 4d2d4e50..2b8b3dec 100644 --- a/cooltools/cli/compute_saddle.py +++ b/cooltools/cli/compute_saddle.py @@ -219,41 +219,41 @@ def compute_saddle( # it's contact_type dependent: if contact_type == "cis": # that's what we expect as column names: - expected_columns = ["chrom", "diag", "n_valid", expected_name] + expected_columns = ["region", "diag", "n_valid", expected_name] # what would become a MultiIndex: - expected_index = ["chrom", "diag"] + expected_index = ["region", "diag"] # expected dtype as a rudimentary form of validation: expected_dtype = { - "chrom": np.str, + "region": np.str, "diag": np.int64, "n_valid": np.int64, expected_name: np.float64, } - # unique list of chroms mentioned in expected_path: - get_exp_chroms = lambda df: df.index.get_level_values("chrom").unique() - # compute # of bins by comparing matching indexes: - get_exp_bins = lambda df, ref_chroms, _: ( - df.index.get_level_values("chrom").isin(ref_chroms).sum() - ) + # # unique list of chroms mentioned in expected_path: + # get_exp_chroms = lambda df: df.index.get_level_values("region").unique() + # # compute # of bins by comparing matching indexes: + # get_exp_bins = lambda df, ref_chroms, _: ( + # df.index.get_level_values("chrom").isin(ref_chroms).sum() + # ) elif contact_type == "trans": # that's what we expect as column names: - expected_columns = ["chrom1", "chrom2", "n_valid", expected_name] + expected_columns = ["region1", "region2", "n_valid", expected_name] # what would become a MultiIndex: - expected_index = ["chrom1", "chrom2"] + expected_index = ["region1", "region2"] # expected dtype as a rudimentary form of validation: expected_dtype = { - "chrom1": np.str, - "chrom2": np.str, + "region1": np.str, + "region2": np.str, "n_valid": np.int64, expected_name: np.float64, } - # unique list of chroms mentioned in expected_path: - get_exp_chroms = lambda df: np.union1d( - df.index.get_level_values("chrom1").unique(), - df.index.get_level_values("chrom2").unique(), - ) - # no way to get bins from trans-expected, so just get the number: - get_exp_bins = lambda _1, _2, correct_bins: correct_bins + # # unique list of chroms mentioned in expected_path: + # get_exp_chroms = lambda df: np.union1d( + # df.index.get_level_values("region1").unique(), + # df.index.get_level_values("region2").unique(), + # ) + # # no way to get bins from trans-expected, so just get the number: + # get_exp_bins = lambda _1, _2, correct_bins: correct_bins else: raise ValueError( "Incorrect contact_type: {}, ".format(contact_type), @@ -322,25 +322,25 @@ def compute_saddle( track_bins, track_path, cool_bins, cool_path, track_chroms ), ) - # EXPECTED vs TRACK: - # validate expected a bit as well: - expected_chroms = get_exp_chroms(expected) - # do simple column-name validation for now: - if not set(track_chroms).issubset(expected_chroms): - raise ValueError( - "Chromosomes in {} must be subset of ".format(track_path) - + "chromosomes in expected {}".format(expected_path) - ) - # and again bins are supposed to match up: - # only for cis though ... - expected_bins = get_exp_bins(expected, track_chroms, track_bins) - if not (track_bins == expected_bins): - raise ValueError( - "Number of bins is not matching: ", - "{} in {}, and {} in {} for chromosomes {}".format( - track_bins, track_path, expected_bins, expected_path, track_chroms - ), - ) + # # EXPECTED vs TRACK: + # # validate expected a bit as well: + # expected_chroms = get_exp_chroms(expected) + # # do simple column-name validation for now: + # if not set(track_chroms).issubset(expected_chroms): + # raise ValueError( + # "Chromosomes in {} must be subset of ".format(track_path) + # + "chromosomes in expected {}".format(expected_path) + # ) + # # and again bins are supposed to match up: + # # only for cis though ... + # expected_bins = get_exp_bins(expected, track_chroms, track_bins) + # if not (track_bins == expected_bins): + # raise ValueError( + # "Number of bins is not matching: ", + # "{} in {}, and {} in {} for chromosomes {}".format( + # track_bins, track_path, expected_bins, expected_path, track_chroms + # ), + # ) ############################################# # CROSS-VALIDATION IS COMPLETE. ############################################# diff --git a/cooltools/eigdecomp.py b/cooltools/eigdecomp.py index 86b8ecf8..a0a35011 100644 --- a/cooltools/eigdecomp.py +++ b/cooltools/eigdecomp.py @@ -43,7 +43,7 @@ def _phase_eigs(eigvals, eigvecs, phasing_track, sort_metric=None): eigvec[mask] ) else: - raise ValueError("Unknown sorting metric: {}".format(sort_by)) + raise ValueError("Unknown sorting metric: {}".format(sort_metric)) corrs.append(corr) @@ -353,11 +353,9 @@ def _each(region): eigvals_per_reg, eigvecs_per_reg = zip(*map(_each, regions)) for region, eigvecs in zip(regions, eigvecs_per_reg): - lo, hi = bioframe.bisect_bedframe(bins, region) + idx = bioframe.select(bins, region).index for i, eigvec in enumerate(eigvecs): - eigvec_table.iloc[ - lo:hi, eigvec_table.columns.get_loc("E" + str(i + 1)) - ] = eigvec + eigvec_table.loc[idx, "E" + str(i + 1)] = eigvec region_strs = [ ( diff --git a/cooltools/saddle.py b/cooltools/saddle.py index 2b874576..efd24c64 100644 --- a/cooltools/saddle.py +++ b/cooltools/saddle.py @@ -103,9 +103,8 @@ def digitize_track(binedges, track, regions=None): # subset and re-order chromosome groups if regions is not None: regions = [bioframe.parse_region(reg) for reg in regions] - grouped = track.groupby("chrom") track = pd.concat( - bioframe.bedslice(grouped, region) for region in regions + bioframe.select(track, region) for region in regions ) # histogram the signal @@ -308,7 +307,7 @@ def make_saddle( digitized_tracks = {} for reg in regions.values: - track = bioframe.bedslice(digitized_df, reg) + track = bioframe.select(digitized_df, reg) digitized_tracks[reg[3]] = track[name] # 3 = name if contact_type == "cis": diff --git a/tests/test_expected.py b/tests/test_expected.py index 80f83490..e7e6e9e4 100644 --- a/tests/test_expected.py +++ b/tests/test_expected.py @@ -1,5 +1,5 @@ import os.path as op -import pandas as pd +# import pandas as pd import numpy as np from numpy import testing @@ -13,6 +13,8 @@ # setup new testing infrasctructure for expected ... # rudimentary expected functions for dense matrices: + + def _diagsum_dense(matrix, ignore_diags=2, bad_bins=None): """ function returning a diagsum list @@ -22,14 +24,16 @@ def _diagsum_dense(matrix, ignore_diags=2, bad_bins=None): """ mat = matrix.copy().astype(float) if bad_bins is not None: - mat[bad_bins,:] = np.nan - mat[:,bad_bins] = np.nan + mat[bad_bins, :] = np.nan + mat[:, bad_bins] = np.nan # diagonal, starting from main one # all the way to the upper right element diags = range(len(mat)) - return [ np.nanmean(mat.diagonal(i)) if (i >= ignore_diags) else np.nan for i in diags] + return [ + np.nanmean(mat.diagonal(i)) if (i >= ignore_diags) else np.nan for i in diags + ] def _diagsum_asymm_dense(matrix, bad_bin_rows=None, bad_bin_cols=None): @@ -44,17 +48,17 @@ def _diagsum_asymm_dense(matrix, bad_bin_rows=None, bad_bin_cols=None): """ mat = matrix.copy().astype(float) if bad_bin_rows is not None: - mat[bad_bins_rows,:] = np.nan + mat[bad_bin_rows, :] = np.nan elif bad_bin_cols is not None: - mat[:,bad_bins_cols] = np.nan + mat[:, bad_bin_cols] = np.nan (mrows, mcols) = mat.shape # diagonals of an arbitrary rectangle matrix # negative diagonals are below the "main" one - diags = range(-mrows+1, mcols) + diags = range(-mrows + 1, mcols) - return [ np.nanmean(mat.diagonal(i)) for i in diags ] + return [np.nanmean(mat.diagonal(i)) for i in diags] # flatexp_tomat = lambda e,m_like: toeplitz(e[m_like.shape[0]-1::-1],e[m_like.shape[0]-1:]) @@ -66,9 +70,9 @@ def _blocksum_asymm_dense(matrix, bad_bin_rows=None, bad_bin_cols=None): """ mat = matrix.copy().astype(float) if bad_bin_rows is not None: - mat[bad_bins_rows,:] = np.nan + mat[bad_bin_rows, :] = np.nan elif bad_bin_cols is not None: - mat[:,bad_bins_cols] = np.nan + mat[:, bad_bin_cols] = np.nan return np.nanmean(mat) @@ -80,7 +84,7 @@ def _blocksum_asymm_dense(matrix, bad_bin_rows=None, bad_bin_cols=None): ignore_diags = 2 weight_name = "weight" bad_bins = None -chunksize = 10_000 # keep it small to engage chunking +chunksize = 10_000 # keep it small to engage chunking weight1 = weight_name + "1" weight2 = weight_name + "2" transforms = {"balanced": lambda p: p["count"] * p[weight1] * p[weight2]} @@ -95,12 +99,13 @@ def _blocksum_asymm_dense(matrix, bad_bin_rows=None, bad_bin_cols=None): common_regions = [] for i in range(4): chrom = chromosomes[i] - halfway_chrom = int(chromsizes[chrom]/2) + halfway_chrom = int(chromsizes[chrom] / 2) reg1 = (chrom, 0, halfway_chrom) reg2 = (chrom, halfway_chrom, chromsizes[chrom]) common_regions.append(reg1) common_regions.append(reg2) + def test_diagsum(request): # perform test: clr = cooler.Cooler(op.join(request.fspath.dirname, "data/CN.mm9.1000kb.cool")) @@ -120,18 +125,20 @@ def test_diagsum(request): for name, group in grouped: matrix = clr.matrix(balance=weight_name).fetch(name, name) testing.assert_allclose( - actual = group["balanced.avg"].values, - desired = _diagsum_dense(matrix, ignore_diags=2), + actual=group["balanced.avg"].values, + desired=_diagsum_dense(matrix, ignore_diags=2), # rtol=1e-07, # atol=0, - equal_nan=True + equal_nan=True, ) def test_diagsum_asymm(request): # perform test: clr = cooler.Cooler(op.join(request.fspath.dirname, "data/CN.mm9.1000kb.cool")) - cis_pairwise_regions = [(r1,r2) for (r1,r2) in combinations(common_regions, 2) if (r1[0]==r2[0])] + cis_pairwise_regions = [ + (r1, r2) for (r1, r2) in combinations(common_regions, 2) if (r1[0] == r2[0]) + ] regions1, regions2 = list(zip(*cis_pairwise_regions)) res = cooltools.expected.diagsum_asymm( clr, @@ -145,20 +152,18 @@ def test_diagsum_asymm(request): # calculate average: res["balanced.avg"] = res["balanced.sum"] / res["n_valid"] # check results for every block, defined as region1/2 - grouped = res.groupby(["region1","region2"]) + grouped = res.groupby(["region1", "region2"]) for (name1, name2), group in grouped: matrix = clr.matrix(balance=weight_name).fetch(name1, name2) testing.assert_allclose( - actual = group["balanced.avg"].values, - desired = _diagsum_asymm_dense(matrix), + actual=group["balanced.avg"].values, + desired=_diagsum_asymm_dense(matrix), # rtol=1e-07, # atol=0, - equal_nan=True + equal_nan=True, ) - - def test_blocksum(request): # perform test: clr = cooler.Cooler(op.join(request.fspath.dirname, "data/CN.mm9.1000kb.cool")) @@ -177,14 +182,13 @@ def test_blocksum(request): res["balanced.avg"] = res["balanced.sum"] / res["n_valid"] # check results for every block , defined as region1/2 # should be simplified as there is 1 number per block only - grouped = res.groupby(["region1","region2"]) + grouped = res.groupby(["region1", "region2"]) for (name1, name2), group in grouped: matrix = clr.matrix(balance=weight_name).fetch(name1, name2) testing.assert_allclose( - actual = group["balanced.avg"].values, - desired = _blocksum_asymm_dense(matrix), + actual=group["balanced.avg"].values, + desired=_blocksum_asymm_dense(matrix), # rtol=1e-07, # atol=0, - equal_nan=True + equal_nan=True, ) - From 0c83037919b5f395717d6689d1d06c3295cbef63 Mon Sep 17 00:00:00 2001 From: Nezar Abdennur Date: Tue, 8 Sep 2020 22:15:52 -0400 Subject: [PATCH 65/71] Formatting --- cooltools/lib/_numutils.pyx | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/cooltools/lib/_numutils.pyx b/cooltools/lib/_numutils.pyx index 872983ae..17e77b99 100644 --- a/cooltools/lib/_numutils.pyx +++ b/cooltools/lib/_numutils.pyx @@ -30,11 +30,11 @@ def logbins(lo, hi, ratio=0, N=0, version=2): N : int The target number of bins. The resulting number of bins is not guaranteed. Either ratio or N must be specified. - - version : int - version=1 is a legacy mirnylib version - - version=2 fixes ordering of bin gaps for some values, making sure + + version : int + version=1 is a legacy mirnylib version + + version=2 fixes ordering of bin gaps for some values, making sure that bin gaps are always increasing (2/2/2020) """ @@ -49,10 +49,10 @@ def logbins(lo, hi, ratio=0, N=0, version=2): data10 = np.logspace(np.log10(lo), np.log10(hi), N) data10 = np.array(np.rint(data10), dtype=int) data10 = np.sort(np.unique(data10)) - + if version > 1: data10 = np.cumsum(np.r_[data10[0], np.sort(np.diff(data10))]) - + assert data10[0] == lo assert data10[-1] == hi @@ -257,8 +257,8 @@ class MatVec(object): y_full = ( split(self.clr, map=self.map, chunksize=self.chunksize) - .pipe(_matvec_product, x_full) - .reduce(add, np.zeros(n)) + .pipe(_matvec_product, x_full) + .reduce(add, np.zeros(n)) ) y = y_full[mask] From 409fb103125dc2491caad712b7a08a0066025528 Mon Sep 17 00:00:00 2001 From: Phlya Date: Tue, 13 Oct 2020 14:49:45 +0100 Subject: [PATCH 66/71] logbin-expected cli --- cooltools/cli/__init__.py | 1 + cooltools/cli/logbin_expected.py | 149 +++++++++++++++++++++++++++++++ cooltools/expected.py | 14 +-- 3 files changed, 157 insertions(+), 7 deletions(-) create mode 100755 cooltools/cli/logbin_expected.py diff --git a/cooltools/cli/__init__.py b/cooltools/cli/__init__.py index f60ac962..4a407748 100644 --- a/cooltools/cli/__init__.py +++ b/cooltools/cli/__init__.py @@ -57,6 +57,7 @@ def _excepthook(exc_type, value, tb): dump_cworld, diamond_insulation, compute_expected, + logbin_expected, compute_saddle, call_dots, call_compartments, diff --git a/cooltools/cli/logbin_expected.py b/cooltools/cli/logbin_expected.py new file mode 100755 index 00000000..720b3865 --- /dev/null +++ b/cooltools/cli/logbin_expected.py @@ -0,0 +1,149 @@ +import pandas as pd +from .. import expected + +import click +from . import cli + +@cli.command() +@click.argument( + "expected_path", + metavar="EXPECTED_PATH", + type=str, + nargs=1 +) + +@click.argument( + "output_prefix", + metavar="OUTPUT_PREFIX", + type=str, + nargs=1 +) + +@click.option( + "--bins-per-order-magnitude", + metavar="bins_per_order_magnitude", + help="How many bins per order of magnitude. " + "Default of 10 has a ratio of neighboring bins of about 1.25", + type=int, + nargs=1, + default=10, + show_default=True +) + +@click.option( + "--bin-layout", + metavar="bin_layout", + help="'fixed' means that bins are exactly the same for different datasets, " + "and only depend on bins_per_order_magnitude " + "'longest_regio' means that the last bin will end at size of the longest region. " + "\nGOOD: the last bin will have as much data as possible. " + "\nBAD: bin edges will end up different for different datasets, " + "you can't divide them by each other", + type=click.Choice(["fixed", "longest_region"]), + nargs=1, + default='fixed', + show_default=True +) + +@click.option( + "--min-nvalid", + metavar="min_nvalid", + help="For each region, throw out bins (log-spaced) that have less than min_nvalid " + "valid pixels. This will ensure that each entree in Pc by region has at least " + "n_valid valid pixels. " + "Don't set it to zero, or it will introduce bugs. Setting it to 1 is OK, but " + "not recommended.", + type=int, + nargs=1, + default=200, + show_default=True +) + +@click.option( + "--min-count", + metavar="min_count", + help="If counts are found in the data, then for each region, throw out bins " + "(log-spaced) that have more than min_counts of counts.sum (raw Hi-C counts). " + "This will ensure that each entree in P(s) by region has at least min_count " + "raw Hi-C reads", + type=int, + nargs=1, + default=50, + show_default=True +) + +@click.option( + "--spread-funcs", + metavar="spread_funcs", + help="A way to estimate the spread of the P(s) curves between regions. " + "* 'minmax' - the minimum/maximum of by-region P(s)\n" + "* 'std' - weighted standard deviation of P(s) curves (may produce negative results)\n " + "* 'logstd' (recommended) weighted standard deviation in logspace", + type=click.Choice(["minmax", "std", "logstd"]), + default='logstd', + show_default=True, + nargs=1, +) + +@click.option( + "--spread-funcs-slope", + metavar="spread_funcs_slope", + help="Same as spread-funcs, but for slope (derivative) ratehr than P(s)", + type=click.Choice(["minmax", "std", "logstd"]), + default='std', + show_default=True, + nargs=1, +) + +@click.option( + "--resolution", + metavar="resolution", + help="Data resolution in bp. If provided, additonal column of separation in bp " + "(s_bp) will be added to the outputs", + type=int, + nargs=1, +) + +def logbin_expected( + expected_path, + output_prefix, + bins_per_order_magnitude, + bin_layout, + min_nvalid, + min_count, + spread_funcs, + spread_funcs_slope, + resolution +): + """ + Logarithmically bin expected values generated using compute_expected for cis data. + + This smoothes the data, resulting in clearer plots and more robust analysis results. + Also calculates derivative after gaussian smoothing. + For a very detailed escription, see + https://github.com/open2c/cooltools/blob/51b95c3bed8d00a5f1f91370fc5192d9a7face7c/cooltools/expected.py#L988 + + EXPECTED_PATH : The paths to a .tsv file with output of compute_expected. + + OUTPUT_PREFIX: Output file name prefix to store the logbinned expected + (prefix.log.tsv) and derivative (prefix.der.tsv) in the tsv format." + """ + + cvd = pd.read_csv(expected_path, sep='\t') + lb_cvd, lb_slopes, lb_distbins = expected.logbin_expected(cvd, + bins_per_order_magnitude=bins_per_order_magnitude, + bin_layout=bin_layout, + min_nvalid=min_nvalid, + min_count=min_count) + lb_cvd_agg, lb_slopes_agg = expected.combine_binned_expected(lb_cvd, + binned_exp_slope=lb_slopes, + spread_funcs=spread_funcs, + spread_funcs_slope=spread_funcs_slope + ) + if resolution is not None: + lb_cvd_agg['s_bp'] = lb_cvd_agg['x'] * resolution + lb_slopes_agg['s_bp'] = lb_slopes_agg['x'] * resolution + + lb_cvd_agg.to_csv(f'{output_prefix}.log.tsv', sep="\t", index=False, na_rep="nan") + lb_cvd_agg.to_csv(f'{output_prefix}.der.tsv', sep="\t", index=False, na_rep="nan") + \ No newline at end of file diff --git a/cooltools/expected.py b/cooltools/expected.py index 0939caa6..7bb9c3e8 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -579,7 +579,7 @@ def diagsum( Returns ------- - dict of support region -> dataframe of diagonal statistics + Dataframe of diagonal statistics for all regions """ spans = partition(0, len(clr.pixels()), chunksize) @@ -933,8 +933,8 @@ def logbin_expected( Parameters ---------- - exp : dict - {region: expected_df} produced by diagsum + exp : DataFrame + DataFrame produced by diagsum bins_per_order_magnitude : int (optional) How many bins per order of magnitude. Default of 10 has a ratio of @@ -958,9 +958,6 @@ def logbin_expected( A smoothing function to be applied to log(P(s)) and log(x) before calculating P(s) slopes for by-region data - der_smooth_function_combined : callable - A smoothing function for calculating slopes on combined data - min_nvalid : int For each region, throw out bins (log-spaced) that have less than min_nvalid valid pixels @@ -1133,7 +1130,10 @@ def combine_binned_expected( binned_exp_slope : dataframe or None If provided, estimates spread of slopes. Is necessary if concat_original is True - + + der_smooth_function_combined : callable + A smoothing function for calculating slopes on combined data + spread_funcs: "minmax", "std", "logstd" or a function (see below) A way to estimate the spread of the P(s) curves between regions. * "minmax" - use the minimum/maximum of by-region P(s) From 557e31ee8492472c3d7c2045b1dd4a5b21252e40 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Tue, 20 Oct 2020 09:55:57 -0400 Subject: [PATCH 67/71] innocent update to Ilya's PR --- cooltools/cli/logbin_expected.py | 15 ++++----------- 1 file changed, 4 insertions(+), 11 deletions(-) diff --git a/cooltools/cli/logbin_expected.py b/cooltools/cli/logbin_expected.py index 720b3865..0e4c40d2 100755 --- a/cooltools/cli/logbin_expected.py +++ b/cooltools/cli/logbin_expected.py @@ -11,14 +11,12 @@ type=str, nargs=1 ) - @click.argument( "output_prefix", metavar="OUTPUT_PREFIX", type=str, nargs=1 ) - @click.option( "--bins-per-order-magnitude", metavar="bins_per_order_magnitude", @@ -29,7 +27,6 @@ default=10, show_default=True ) - @click.option( "--bin-layout", metavar="bin_layout", @@ -44,7 +41,6 @@ default='fixed', show_default=True ) - @click.option( "--min-nvalid", metavar="min_nvalid", @@ -58,7 +54,6 @@ default=200, show_default=True ) - @click.option( "--min-count", metavar="min_count", @@ -71,7 +66,6 @@ default=50, show_default=True ) - @click.option( "--spread-funcs", metavar="spread_funcs", @@ -84,7 +78,6 @@ show_default=True, nargs=1, ) - @click.option( "--spread-funcs-slope", metavar="spread_funcs_slope", @@ -94,7 +87,6 @@ show_default=True, nargs=1, ) - @click.option( "--resolution", metavar="resolution", @@ -103,7 +95,6 @@ type=int, nargs=1, ) - def logbin_expected( expected_path, output_prefix, @@ -130,12 +121,14 @@ def logbin_expected( """ cvd = pd.read_csv(expected_path, sep='\t') - lb_cvd, lb_slopes, lb_distbins = expected.logbin_expected(cvd, + lb_cvd, lb_slopes, lb_distbins = expected.logbin_expected( + cvd, bins_per_order_magnitude=bins_per_order_magnitude, bin_layout=bin_layout, min_nvalid=min_nvalid, min_count=min_count) - lb_cvd_agg, lb_slopes_agg = expected.combine_binned_expected(lb_cvd, + lb_cvd_agg, lb_slopes_agg = expected.combine_binned_expected( + lb_cvd, binned_exp_slope=lb_slopes, spread_funcs=spread_funcs, spread_funcs_slope=spread_funcs_slope From c2969e2e4bec9b65b53adeb592f27b10bae6ea42 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Tue, 20 Oct 2020 11:55:37 -0400 Subject: [PATCH 68/71] added csv validation and custom exp_summary_name --- cooltools/cli/logbin_expected.py | 52 +++++++++++++++++++++++++++----- cooltools/expected.py | 9 ++++-- 2 files changed, 51 insertions(+), 10 deletions(-) diff --git a/cooltools/cli/logbin_expected.py b/cooltools/cli/logbin_expected.py index 0e4c40d2..10ec1a37 100755 --- a/cooltools/cli/logbin_expected.py +++ b/cooltools/cli/logbin_expected.py @@ -2,6 +2,7 @@ from .. import expected import click +from .util import validate_csv from . import cli @cli.command() @@ -9,7 +10,7 @@ "expected_path", metavar="EXPECTED_PATH", type=str, - nargs=1 + callback=partial(validate_csv, default_column="balanced.sum"), ) @click.argument( "output_prefix", @@ -115,28 +116,63 @@ def logbin_expected( https://github.com/open2c/cooltools/blob/51b95c3bed8d00a5f1f91370fc5192d9a7face7c/cooltools/expected.py#L988 EXPECTED_PATH : The paths to a .tsv file with output of compute_expected. + Must include a header. Use the '::' syntax to specify a summary column name. OUTPUT_PREFIX: Output file name prefix to store the logbinned expected (prefix.log.tsv) and derivative (prefix.der.tsv) in the tsv format." """ - cvd = pd.read_csv(expected_path, sep='\t') + # unpack expected path and name as generated by click's callback to validate_csv: + expected_path, exp_summary_name = expected_path + # that's what we expect as column names: + expected_columns = ["region", "diag", "n_valid", exp_summary_name] + # expected dtype as a rudimentary form of validation: + expected_dtype = { + "region": np.str, + "diag": np.int64, + "n_valid": np.int64, + exp_summary_name: np.float64, + } + + # use 'usecols' as a rudimentary form of validation, + # and dtype. Keep 'comment' and 'verbose' - explicit, + # as we may use them later: + cvd = pd.read_csv( + expected_path, + usecols=expected_columns, + dtype=expected_dtype, + comment=None, + sep='\t', + verbose=False, + ) + lb_cvd, lb_slopes, lb_distbins = expected.logbin_expected( cvd, + exp_summary_name=exp_summary_name, bins_per_order_magnitude=bins_per_order_magnitude, bin_layout=bin_layout, min_nvalid=min_nvalid, - min_count=min_count) + min_count=min_count + ) lb_cvd_agg, lb_slopes_agg = expected.combine_binned_expected( lb_cvd, binned_exp_slope=lb_slopes, spread_funcs=spread_funcs, spread_funcs_slope=spread_funcs_slope - ) + ) if resolution is not None: lb_cvd_agg['s_bp'] = lb_cvd_agg['x'] * resolution lb_slopes_agg['s_bp'] = lb_slopes_agg['x'] * resolution - - lb_cvd_agg.to_csv(f'{output_prefix}.log.tsv', sep="\t", index=False, na_rep="nan") - lb_cvd_agg.to_csv(f'{output_prefix}.der.tsv', sep="\t", index=False, na_rep="nan") - \ No newline at end of file + + lb_cvd_agg.to_csv( + f'{output_prefix}.log.tsv', + sep="\t", + index=False, + na_rep="nan", + ) + lb_cvd_agg.to_csv( + f'{output_prefix}.der.tsv', + sep="\t", + index=False, + na_rep="nan", + ) diff --git a/cooltools/expected.py b/cooltools/expected.py index 7bb9c3e8..00267f55 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -922,6 +922,7 @@ def blocksum_asymm( def logbin_expected( exp, + exp_summary_name="balanced.sum", bins_per_order_magnitude=10, bin_layout="fixed", der_smooth_function_by_reg=lambda x: numutils.robust_gauss_filter(x, 2), @@ -936,6 +937,10 @@ def logbin_expected( exp : DataFrame DataFrame produced by diagsum + exp_summary_name : str (optional) + Name of the column of exp-DataFrame to use as a diagonal summary. + Default is "balanced.sum". + bins_per_order_magnitude : int (optional) How many bins per order of magnitude. Default of 10 has a ratio of neighboring bins of about 1.25 @@ -1049,7 +1054,7 @@ def logbin_expected( """ from cooltools.lib.numutils import logbins - exp = exp[~pd.isna(exp["balanced.sum"])] + exp = exp[~pd.isna(exp[exp_summary_name])] exp["x"] = exp.pop("diag") diagmax = exp["x"].max() @@ -1078,7 +1083,7 @@ def logbin_expected( byRegExp = byRegExp.reset_index() byRegExp = byRegExp[byRegExp["n_valid"] > min_nvalid] # filtering by n_valid - byRegExp["Pc"] = byRegExp["balanced.sum"] / byRegExp["n_valid"] + byRegExp["Pc"] = byRegExp[exp_summary_name] / byRegExp["n_valid"] byRegExp = byRegExp[byRegExp["Pc"] > 0] # drop bins with 0 counts if min_count: if "count.sum" in byRegExp: From 51f36703c43298b4731be1674c81844a13667ae8 Mon Sep 17 00:00:00 2001 From: sergpolly Date: Tue, 20 Oct 2020 13:02:53 -0400 Subject: [PATCH 69/71] added simple CLI test for logbin expected --- tests/test_expected.py | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/tests/test_expected.py b/tests/test_expected.py index e7e6e9e4..3f4e5b27 100644 --- a/tests/test_expected.py +++ b/tests/test_expected.py @@ -6,6 +6,7 @@ import bioframe import cooler +from click.testing import CliRunner import cooltools.expected from itertools import combinations @@ -192,3 +193,36 @@ def test_blocksum(request): # atol=0, equal_nan=True, ) + +def test_logbin_expected_cli(request, tmpdir): + # CLI compute-expected for chrom-wide cis-data + in_cool = op.join(request.fspath.dirname, "data/CN.mm9.1000kb.cool") + binsize = 1_000_000 + out_cis_expected = op.join(tmpdir, "cis.exp.tsv") + runner = CliRunner() + result = runner.invoke( + cli, [ + 'compute-expected', + '--weight-name', weight_name, + '-o', out_cis_expected, + in_cool, + ] + ) + assert result.exit_code == 0 + + logbin_prefix = "logbin_prefix" + runner = CliRunner() + result = runner.invoke( + cli, [ + 'logbin-expected', + '--resolution', binsize, + out_cis_expected, + logbin_prefix, + ] + ) + assert result.exit_code == 0 + # make sure logbin output is generated: + out_logbin_Pc = op.join(tmpdir, f"{logbin_prefix}.log.tsv") + out_logbin_der = op.join(tmpdir, f"{logbin_prefix}.log.tsv") + assert os.path.isfile(out_logbin_Pc) + assert os.path.isfile(out_logbin_der) From fa8b5515658c945494d82cd3f88f73c7b98306ea Mon Sep 17 00:00:00 2001 From: sergpolly Date: Tue, 20 Oct 2020 13:38:06 -0400 Subject: [PATCH 70/71] final minor fixes - imports,flake8,test pass --- cooltools/cli/logbin_expected.py | 2 ++ tests/test_expected.py | 14 ++++++-------- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/cooltools/cli/logbin_expected.py b/cooltools/cli/logbin_expected.py index 10ec1a37..48ac9c94 100755 --- a/cooltools/cli/logbin_expected.py +++ b/cooltools/cli/logbin_expected.py @@ -1,4 +1,6 @@ import pandas as pd +import numpy as np +from functools import partial from .. import expected import click diff --git a/tests/test_expected.py b/tests/test_expected.py index 06eb2c1e..99ce4504 100644 --- a/tests/test_expected.py +++ b/tests/test_expected.py @@ -9,7 +9,6 @@ import cooler from click.testing import CliRunner import cooltools.expected -from click.testing import CliRunner from cooltools.cli import cli from itertools import combinations @@ -197,6 +196,7 @@ def test_blocksum(request): equal_nan=True, ) + def test_expected_cli(request, tmpdir): # CLI compute-expected for chrom-wide cis-data in_cool = op.join(request.fspath.dirname, "data/CN.mm9.1000kb.cool") @@ -211,7 +211,6 @@ def test_expected_cli(request, tmpdir): ] ) assert result.exit_code == 0 - clr = cooler.Cooler(in_cool) cis_expected = pd.read_table(out_cis_expected, sep="\t") grouped = cis_expected.groupby("region") @@ -305,6 +304,7 @@ def test_trans_expected_regions_cli(request, tmpdir): equal_nan=True, ) + def test_logbin_expected_cli(request, tmpdir): # test CLI logbin-expected for default chrom-wide output of compute-expected in_cool = op.join(request.fspath.dirname, "data/CN.mm9.1000kb.cool") @@ -319,10 +319,10 @@ def test_logbin_expected_cli(request, tmpdir): ] ) assert result.exit_code == 0 - + # consider adding logbin expected baswed on raw counts binsize = 1_000_000 - logbin_prefix = "logbin_prefix" + logbin_prefix = op.join(tmpdir, "logbin_prefix") runner = CliRunner() result = runner.invoke( cli, [ @@ -334,7 +334,5 @@ def test_logbin_expected_cli(request, tmpdir): ) assert result.exit_code == 0 # make sure logbin output is generated: - out_logbin_Pc = op.join(tmpdir, f"{logbin_prefix}.log.tsv") - out_logbin_der = op.join(tmpdir, f"{logbin_prefix}.log.tsv") - assert os.path.isfile(out_logbin_Pc) - assert os.path.isfile(out_logbin_der) \ No newline at end of file + assert op.isfile(f"{logbin_prefix}.log.tsv") + assert op.isfile(f"{logbin_prefix}.der.tsv") From ef28860ca8bd56d3958a7943b5dc9e91bffaf56c Mon Sep 17 00:00:00 2001 From: sergpolly Date: Wed, 21 Oct 2020 17:52:10 -0400 Subject: [PATCH 71/71] logbin expected refactor: renamings,consistency,newlines --- cooltools/cli/logbin_expected.py | 12 ++- cooltools/expected.py | 132 +++++++++++++++++++------------ 2 files changed, 92 insertions(+), 52 deletions(-) diff --git a/cooltools/cli/logbin_expected.py b/cooltools/cli/logbin_expected.py index 48ac9c94..d71a017f 100755 --- a/cooltools/cli/logbin_expected.py +++ b/cooltools/cli/logbin_expected.py @@ -148,6 +148,12 @@ def logbin_expected( verbose=False, ) + # name of the column with Probability of contacts is + # based on the name of the column with the diagonal-summary + # stats in the input expected DataFrame: + exp_summary_base, *_ = exp_summary_name.split(".") + Pc_name = f"{exp_summary_base}.avg" + lb_cvd, lb_slopes, lb_distbins = expected.logbin_expected( cvd, exp_summary_name=exp_summary_name, @@ -156,15 +162,17 @@ def logbin_expected( min_nvalid=min_nvalid, min_count=min_count ) + # combine Probabilities of contact for the regions: lb_cvd_agg, lb_slopes_agg = expected.combine_binned_expected( lb_cvd, + Pc_name=Pc_name, binned_exp_slope=lb_slopes, spread_funcs=spread_funcs, spread_funcs_slope=spread_funcs_slope ) if resolution is not None: - lb_cvd_agg['s_bp'] = lb_cvd_agg['x'] * resolution - lb_slopes_agg['s_bp'] = lb_slopes_agg['x'] * resolution + lb_cvd_agg['s_bp'] = lb_cvd_agg['diag.avg'] * resolution + lb_slopes_agg['s_bp'] = lb_slopes_agg['diag.avg'] * resolution lb_cvd_agg.to_csv( f'{output_prefix}.log.tsv', diff --git a/cooltools/expected.py b/cooltools/expected.py index 00267f55..93a927e6 100644 --- a/cooltools/expected.py +++ b/cooltools/expected.py @@ -1054,70 +1054,84 @@ def logbin_expected( """ from cooltools.lib.numutils import logbins + raw_summary_name = "count.sum" + exp_summary_base, *_ = exp_summary_name.split(".") + Pc_name = f"{exp_summary_base}.avg" + diag_name = "diag" + diag_avg_name = f"{diag_name}.avg" + exp = exp[~pd.isna(exp[exp_summary_name])] - exp["x"] = exp.pop("diag") - diagmax = exp["x"].max() + exp[diag_avg_name] = exp.pop(diag_name) # "average" or weighted diagonals + diagmax = exp[diag_avg_name].max() + # create diag_bins based on chosen layout: if bin_layout == "fixed": - bins = numutils.persistent_log_bins( - 10, bins_per_order_magnitude=bins_per_order_magnitude + diag_bins = numutils.persistent_log_bins( + 10, + bins_per_order_magnitude=bins_per_order_magnitude ) elif bin_layout == "longest_region": - bins = logbins(1, diagmax + 1, ratio=10 ** (1 / bins_per_order_magnitude)) + diag_bins = logbins( + 1, + diagmax + 1, + ratio=10 ** (1 / bins_per_order_magnitude) + ) else: - bins = bin_layout + diag_bins = bin_layout - if bins[-1] < diagmax: - raise ValueError("Bins end is less than the size of the largest region") + if diag_bins[-1] < diagmax: + raise ValueError("Genomic separation bins end is less than the size of the largest region") - exp["bin_id"] = np.searchsorted(bins, exp["x"], side="right") - 1 - exp = exp[exp["bin_id"] >= 0] + # assign diagonals in exp DataFrame to diag_bins, i.e. give them ids: + exp["diag_bin_id"] = np.searchsorted(diag_bins, exp[diag_avg_name], side="right") - 1 + exp = exp[exp["diag_bin_id"] >= 0] # constructing expected grouped by region byReg = exp.copy() - # this averages x with the weight equal to n_valid, and sums everything else - byReg["x"] *= byReg["n_valid"] - byRegExp = byReg.groupby(["region", "bin_id"]).sum() - byRegExp["x"] /= byRegExp["n_valid"] + # this averages diag_avg with the weight equal to n_valid, and sums everything else + byReg[diag_avg_name] *= byReg["n_valid"] + byRegExp = byReg.groupby(["region", "diag_bin_id"]).sum() + byRegExp[diag_avg_name] /= byRegExp["n_valid"] byRegExp = byRegExp.reset_index() byRegExp = byRegExp[byRegExp["n_valid"] > min_nvalid] # filtering by n_valid - byRegExp["Pc"] = byRegExp[exp_summary_name] / byRegExp["n_valid"] - byRegExp = byRegExp[byRegExp["Pc"] > 0] # drop bins with 0 counts + byRegExp[Pc_name] = byRegExp[exp_summary_name] / byRegExp["n_valid"] + byRegExp = byRegExp[byRegExp[Pc_name] > 0] # drop diag_bins with 0 counts if min_count: - if "count.sum" in byRegExp: - byRegExp = byRegExp[byRegExp["count.sum"] > min_count] + if raw_summary_name in byRegExp: + byRegExp = byRegExp[byRegExp[raw_summary_name] > min_count] else: - warnings.warn(RuntimeWarning("counts not found")) + warnings.warn(RuntimeWarning(f"{raw_summary_name} not found in the input expected")) - byRegExp["bin_start"] = bins[byRegExp["bin_id"].values] - byRegExp["bin_end"] = bins[byRegExp["bin_id"].values + 1] - 1 + byRegExp["diag_bin_start"] = diag_bins[byRegExp["diag_bin_id"].values] + byRegExp["diag_bin_end"] = diag_bins[byRegExp["diag_bin_id"].values + 1] - 1 byRegDer = [] for reg, subdf in byRegExp.groupby("region"): - subdf = subdf.sort_values("bin_id") - valid = np.minimum(subdf.n_valid.values[:-1], subdf.n_valid.values[1:]) - mids = np.sqrt(subdf.x.values[:-1] * subdf.x.values[1:]) + subdf = subdf.sort_values("diag_bin_id") + valid = np.minimum(subdf["n_valid"].values[:-1], subdf["n_valid"].values[1:]) + mids = np.sqrt(subdf[diag_avg_name].values[:-1] * subdf[diag_avg_name].values[1:]) f = der_smooth_function_by_reg - slope = np.diff(f(np.log(subdf.Pc.values))) / np.diff(f(np.log(subdf.x.values))) + slope = np.diff(f(np.log(subdf[Pc_name].values))) / np.diff(f(np.log(subdf[diag_avg_name].values))) newdf = pd.DataFrame( { - "x": mids, + diag_avg_name: mids, "slope": slope, "n_valid": valid, - "bin_id": subdf.bin_id.values[:-1], + "diag_bin_id": subdf["diag_bin_id"].values[:-1], } ) newdf["region"] = reg byRegDer.append(newdf) byRegDer = pd.concat(byRegDer).reset_index(drop=True) - return byRegExp, byRegDer, bins[: byRegExp.bin_id.max() + 2] + return byRegExp, byRegDer, diag_bins[: byRegExp["diag_bin_id"].max() + 2] def combine_binned_expected( binned_exp, binned_exp_slope=None, + Pc_name="balanced.avg", der_smooth_function_combined=lambda x: numutils.robust_gauss_filter(x, 1.3), spread_funcs="logstd", spread_funcs_slope="std", @@ -1136,6 +1150,10 @@ def combine_binned_expected( If provided, estimates spread of slopes. Is necessary if concat_original is True + Pc_name : str + Name of the column with the probability of contacts. + Defaults to "balanced.avg". + der_smooth_function_combined : callable A smoothing function for calculating slopes on combined data @@ -1181,8 +1199,12 @@ def combine_binned_expected( noisy, and may become a 0 if only one region is contributing to the last pixel. """ + diag_avg_name = "diag.avg" scal = numutils.weighted_groupby_mean( - binned_exp.select_dtypes(np.number), "bin_id", "n_valid", mode="mean" + binned_exp.select_dtypes(np.number), + group_by="diag_bin_id", + weigh_by="n_valid", + mode="mean" ) if spread_funcs == "minmax": @@ -1192,21 +1214,26 @@ def combine_binned_expected( byRegVar.groupby("region")["n_valid"].tail(minmax_drop_bins).index ) ] - low_err = byRegVar.groupby("bin_id")["Pc"].min() - high_err = byRegVar.groupby("bin_id")["Pc"].max() + low_err = byRegVar.groupby("diag_bin_id")[Pc_name].min() + high_err = byRegVar.groupby("diag_bin_id")[Pc_name].max() elif spread_funcs == "std": var = numutils.weighted_groupby_mean( - binned_exp[["Pc", "bin_id", "n_valid"]], "bin_id", "n_valid", mode="std" - )["Pc"] - low_err = scal["Pc"] - var - high_err = scal["Pc"] + var + binned_exp[[Pc_name, "diag_bin_id", "n_valid"]], + group_by="diag_bin_id", + weigh_by="n_valid", + mode="std" + )[Pc_name] + low_err = scal[Pc_name] - var + high_err = scal[Pc_name] + var elif spread_funcs == "logstd": var = numutils.weighted_groupby_mean( - binned_exp[["Pc", "bin_id", "n_valid"]], "bin_id", "n_valid", mode="logstd" - )["Pc"] - low_err = scal["Pc"] / var - high_err = scal["Pc"] * var - + binned_exp[[Pc_name, "diag_bin_id", "n_valid"]], + group_by="diag_bin_id", + weigh_by="n_valid", + mode="logstd" + )[Pc_name] + low_err = scal[Pc_name] / var + high_err = scal[Pc_name] * var else: low_err, high_err = spread_funcs(binned_exp, scal) @@ -1215,13 +1242,18 @@ def combine_binned_expected( f = der_smooth_function_combined - slope = np.diff(f(np.log(scal.Pc.values))) / np.diff(f(np.log(scal.x.values))) - valid = np.minimum(scal.n_valid.values[:-1], scal.n_valid.values[1:]) - mids = np.sqrt(scal.x.values[:-1] * scal.x.values[1:]) + slope = np.diff(f(np.log(scal[Pc_name].values))) / np.diff(f(np.log(scal[diag_avg_name].values))) + valid = np.minimum(scal["n_valid"].values[:-1], scal["n_valid"].values[1:]) + mids = np.sqrt(scal[diag_avg_name].values[:-1] * scal[diag_avg_name].values[1:]) slope_df = pd.DataFrame( - {"x": mids, "slope": slope, "n_valid": valid, "bin_id": scal.index.values[:-1]} + { + diag_avg_name: mids, + "slope": slope, + "n_valid": valid, + "diag_bin_id": scal.index.values[:-1], + } ) - slope_df = slope_df.set_index("bin_id") + slope_df = slope_df.set_index("diag_bin_id") if binned_exp_slope is not None: if spread_funcs_slope == "minmax": @@ -1231,13 +1263,13 @@ def combine_binned_expected( byRegDer.groupby("region")["n_valid"].tail(minmax_drop_bins).index ) ] - low_err = byRegDer.groupby("bin_id")["slope"].min() - high_err = byRegDer.groupby("bin_id")["slope"].max() + low_err = byRegDer.groupby("diag_bin_id")["slope"].min() + high_err = byRegDer.groupby("diag_bin_id")["slope"].max() elif spread_funcs_slope == "std": var = numutils.weighted_groupby_mean( - binned_exp_slope[["slope", "bin_id", "n_valid"]], - "bin_id", - "n_valid", + binned_exp_slope[["slope", "diag_bin_id", "n_valid"]], + group_by="diag_bin_id", + weigh_by="n_valid", mode="std", )["slope"] low_err = slope_df["slope"] - var