"
- ]
- },
- "metadata": {
- "tags": []
- },
- "output_type": "display_data"
- }
- ],
- "source": [
- "umap_df = pd.DataFrame(embedding, columns=('x', 'y'))\n",
- "umap_df['color'] = umap_ECG.membership\n",
- "\n",
- "ecg_colormap = [sns.color_palette(\"husl\", len(set(umap_ECG.membership)))[i] for i in umap_ECG.membership]\n",
- "\n",
- "f, arr = plt.subplots(1,figsize=[15,12])\n",
- "\n",
- "arr.scatter(umap_df['x'].tolist(), umap_df['y'].tolist(), \n",
- " marker='o',c=ecg_colormap, s=10, edgecolor='w',\n",
- " linewidth=0.25)\n",
- "\n",
- "arr.spines['top'].set_visible(False)\n",
- "arr.spines['left'].set_visible(False)\n",
- "arr.spines['right'].set_visible(False)\n",
- "arr.spines['bottom'].set_visible(False)\n",
- "\n",
- "arr.set_xticks([])\n",
- "arr.set_yticks([])"
- ]
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/kenjilee/opt/anaconda3/envs/WaveMAP_Paper_Test_2/lib/python3.8/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+ " from .autonotebook import tqdm as notebook_tqdm\n"
+ ]
},
{
- "cell_type": "markdown",
- "metadata": {
- "id": "-9C8rbqIf-DF"
- },
- "source": [
- "## Here we construct an interactive WaveMAP plot with Bokeh"
- ]
- },
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Requirement already satisfied: networkx==2.4 in /Users/kenjilee/opt/anaconda3/envs/WaveMAP_Paper_Test_2/lib/python3.8/site-packages (2.4)\n",
+ "Requirement already satisfied: decorator>=4.3.0 in /Users/kenjilee/opt/anaconda3/envs/WaveMAP_Paper_Test_2/lib/python3.8/site-packages (from networkx==2.4) (5.1.1)\n",
+ "Requirement already satisfied: python-igraph==0.8.2 in /Users/kenjilee/opt/anaconda3/envs/WaveMAP_Paper_Test_2/lib/python3.8/site-packages (0.8.2)\n",
+ "Requirement already satisfied: texttable>=1.6.2 in /Users/kenjilee/opt/anaconda3/envs/WaveMAP_Paper_Test_2/lib/python3.8/site-packages (from python-igraph==0.8.2) (1.6.7)\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install umap-learn==0.5.3\n",
+ "from umap import umap_ as umap\n",
+ "\n",
+ "!pip install networkx==2.4\n",
+ "import networkx as nx\n",
+ "\n",
+ "!pip install python-igraph==0.8.2\n",
+ "import igraph as ig"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "jqA7vl9Uz3z-"
+ },
+ "source": [
+ "## ECG needs to be defined and added manually to iGraph"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "id": "alie_AJHp1ym",
+ "tags": [],
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "def community_ecg(self, weights=None, ens_size=16, min_weight=0.05):\n",
+ " W = [0]*self.ecount()\n",
+ " ## Ensemble of level-1 Louvain \n",
+ " for i in range(ens_size):\n",
+ " p = np.random.permutation(self.vcount()).tolist()\n",
+ " g = self.permute_vertices(p)\n",
+ " l = g.community_multilevel(weights=weights, return_levels=True)[0].membership\n",
+ " b = [l[p[x.tuple[0]]]==l[p[x.tuple[1]]] for x in self.es]\n",
+ " W = [W[i]+b[i] for i in range(len(W))]\n",
+ " W = [min_weight + (1-min_weight)*W[i]/ens_size for i in range(len(W))]\n",
+ " ## Force min_weight outside 2-core\n",
+ " core = self.shell_index()\n",
+ " ecore = [min(core[x.tuple[0]],core[x.tuple[1]]) for x in self.es]\n",
+ " w = [W[i] if ecore[i]>1 else min_weight for i in range(len(ecore))]\n",
+ " part = self.community_multilevel(weights=w)\n",
+ " part.W = w\n",
+ " part.CSI = 1-2*np.sum([min(1-i,i) for i in w])/len(w)\n",
+ " return part\n",
+ "\n",
+ "ig.Graph.community_ecg = community_ecg"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "d4xmDNue0CUd"
+ },
+ "source": [
+ "## Loading Fashion MNIST data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "id": "imFWrVmXrfbg",
+ "tags": [],
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
{
- "cell_type": "code",
- "execution_count": 9,
- "metadata": {
- "id": "ZNAZHUrP153g",
- "vscode": {
- "languageId": "python"
- }
- },
- "outputs": [],
- "source": [
- "def embeddable_image(data,color=None):\n",
- " fig, ax = plt.subplots()\n",
- " fig.set_figheight(0.5)\n",
- " fig.set_figwidth(0.5)\n",
- " ax.imshow(data.reshape(28,28))\n",
- " ax.axis('off')\n",
- " fig.canvas.draw()\n",
- " img_data = np.array(fig.canvas.renderer.buffer_rgba())\n",
- " image = Image.fromarray(img_data, mode='RGBA')\n",
- " buffer = BytesIO()\n",
- " image.save(buffer, format='png')\n",
- " for_encoding = buffer.getvalue()\n",
- " plt.close()\n",
- " \n",
- " return 'data:image/png;base64,' + base64.b64encode(for_encoding).decode()\n",
- "\n",
- "\n",
- "def rgb2hex(rgb):\n",
- " rgb = tuple([int(x*256) for x in rgb])\n",
- " return '#%02x%02x%02x' % rgb"
- ]
- },
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/kenjilee/opt/anaconda3/envs/WaveMAP_Paper_Test_2/lib/python3.8/site-packages/sklearn/datasets/_openml.py:932: FutureWarning: The default value of `parser` will change from `'liac-arff'` to `'auto'` in 1.4. You can set `parser='auto'` to silence this warning. Therefore, an `ImportError` will be raised from 1.4 if the dataset is dense and pandas is not installed. Note that the pandas parser may return different data types. See the Notes Section in fetch_openml's API doc for details.\n",
+ " warn(\n"
+ ]
+ }
+ ],
+ "source": [
+ "fmnist = datasets.fetch_openml('Fashion-MNIST', as_frame=False)\n",
+ "np.random.shuffle(fmnist.data)\n",
+ "fmnist_subset = fmnist.data[:150,:]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "kY__FJxk0E66"
+ },
+ "source": [
+ "## Compute UMAP step of WaveMAP\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "KRYvqF20psn3",
+ "tags": [],
+ "vscode": {
+ "languageId": "python"
+ }
+ },
+ "outputs": [
{
- "cell_type": "code",
- "execution_count": 16,
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "id": "KgwO0RWowmhz",
- "outputId": "01dfebfc-0541-4c4d-d15f-b5f0fdfe6b3b",
- "vscode": {
- "languageId": "python"
- }
- },
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/usr/local/lib/python3.7/dist-packages/bokeh/models/mappers.py:147: UserWarning: Palette length does not match number of factors. ['17'] will be assigned to `nan_color` gray\n",
- " warnings.warn(\"Palette length does not match number of factors. %s will be assigned to `nan_color` %s\" % (extra_factors, self.nan_color))\n"
- ]
- }
- ],
- "source": [
- "umap_df['data'] = list(fmnist_subset)\n",
- "umap_df['image'] = list(map(embeddable_image, umap_df.data))\n",
- "datasource = ColumnDataSource(umap_df)\n",
- "\n",
- "plot_figure = figure(\n",
- " title='WaveMAP of dataset',\n",
- " plot_width=900,\n",
- " plot_height=900,\n",
- " tools=('pan, wheel_zoom, reset')\n",
- ")\n",
- "\n",
- "plot_figure.add_tools(HoverTool(tooltips=\"\"\"\n",
- "\n",
- "
\n",
- "
\n",
- "
\n",
- "
\n",
- " Index:\n",
- " @index\n",
- "
\n",
- "
\n",
- "
\n",
- "
\n",
- "
\n",
- "
\n",
- " Index:\n",
- " @index\n",
- "
\n",
- "
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " Index:\n",
+ " @index\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ " Index:\n",
+ " @index\n",
+ "
\n",
+ "
![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "PFVwe-_fLdRb"
+ },
+ "source": [
+ "# Step 1: Download various data files by cloning the paper's Git repo.\n",
+ "\n",
+ "---\n",
+ "*Note to reviewers: PLEASE DO NOT STAR OR FORK THE REPO WHICH IS DEANONYMIZING. The Github repository helps clone important files necessary for analysis.*\n",
+ "\n",
+ "This git repository has various data files Which we clone below to allow you to run the google colab. There is no need to go to the original git repository the process of running this code leads to the files being downloaded and attached to this notebook."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "z16uiX0wj2ni",
+ "outputId": "edb7653a-4037-43bb-df05-d02ff8a62db7"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "fatal: destination path 'WaveMAP_Paper' already exists and is not an empty directory.\n"
+ ]
+ }
+ ],
+ "source": [
+ "!git clone https://github.com/EricKenjiLee/WaveMAP_Paper.git"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "0m-cBuzkMyYN"
+ },
+ "source": [
+ "## Step 1a: Importing packages\n",
+ "\n",
+ "Here are imported standard packages."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "id": "KbP0Q7Z3biq_"
+ },
+ "outputs": [],
+ "source": [
+ "# Importing packages \n",
+ "# --- Importing matplotlib, seaborn, etc.\n",
+ "\n",
+ "import os\n",
+ "import random\n",
+ "\n",
+ "import matplotlib as mpl\n",
+ "from matplotlib import pyplot as plt\n",
+ "from matplotlib.lines import Line2D\n",
+ "from mpl_toolkits.mplot3d import Axes3D\n",
+ "from matplotlib.gridspec import GridSpec\n",
+ "import seaborn as sns\n",
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "import scipy\n",
+ "from scipy import io\n",
+ "import pickle as pkl\n",
+ "import h5py\n",
+ "import xml.etree.ElementTree as ET"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "VaM9ETbvM38B"
+ },
+ "source": [
+ "These non-standard packages are pinned for compatibility reasons. Google Colab's default versions for import change frequenetly."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "SvvK4nfZmFtn",
+ "outputId": "ef809541-bf39-4545-f31a-5a5da153c7c1"
+ },
+ "outputs": [
+ {
+ "ename": "ModuleNotFoundError",
+ "evalue": "No module named 'cylouvain'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m--------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mModuleNotFoundError\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 13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0;31m# !pip install cylouvain==0.2.2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mcylouvain\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0;31m# !pip install shap==0.35\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'cylouvain'"
+ ]
+ }
+ ],
+ "source": [
+ "# !pip install networkx==2.4\n",
+ "# import networkx as nx\n",
+ "\n",
+ "# !pip install scikit-learn==0.22.2.post1\n",
+ "from sklearn.model_selection import train_test_split, GridSearchCV\n",
+ "from sklearn.metrics import confusion_matrix\n",
+ "\n",
+ "# !pip install xgboost\n",
+ "# import xgboost as xgb\n",
+ "\n",
+ "# !pip install umap-learn==0.5.0\n",
+ "from umap import umap_ as umap\n",
+ "\n",
+ "# !pip install cylouvain==0.2.2\n",
+ "import cylouvain\n",
+ "\n",
+ "# !pip install shap==0.35\n",
+ "import shap\n",
+ "\n",
+ "# !pip install python-igraph==0.8.2\n",
+ "import igraph as ig"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Sj0vY7akb92a"
+ },
+ "source": [
+ "#Step 2: Colormap selection for clusterings\n",
+ "\n",
+ "---\n",
+ "\n",
+ "The clusterings get clustered in a random order so although these colors reflect those used in the manuscript, they may need to be permuted to match what is found in our figures."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 233
+ },
+ "id": "R8Nkf7EOb1jE",
+ "outputId": "1bef0f02-3c63-4dd6-a033-2f9e0b22b191"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAggAAABICAYAAACTOw0mAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAACaUlEQVR4nO3aPWpUURzG4XM1aIQRIkSLNOnESgTdg4XYWNjYWAR34QLcgpUIrsFSbCWlTbCwSrCIX4hf1bEV3kQcyeHMPT5Pe4fh/VfzG2amWmsBAPjdqd4DAIDVIxAAgCAQAIAgEACAIBAAgCAQAICwtsyL19c36mKx1WpLd+83v/We0NT16bD3hKZ+vDnbe0Iz65e+957Q1P7mld4Tmnr3eezvYtdOf+09oamf55b6qJyVg4P98unjh+moZ0tdvVhslVu3n53MqhX0dGe394Smds886T2hqb2b270nNHP5weveE5p6eP9l7wlNPXp+vveEpl5svOo9oam3Vy/0ntDMvbt3jn02dtYCAP9EIAAAQSAAAEEgAABBIAAAQSAAAEEgAABBIAAAQSAAAEEgAABBIAAAQSAAAEEgAABBIAAAQSAAAEEgAABBIAAAQSAAAEEgAABBIAAAQSAAAEEgAABBIAAAQSAAAEEgAABBIAAAQSAAAEEgAABBIAAAQSAAAEEgAABBIAAAQSAAAEEgAABBIAAAQSAAAEEgAABBIAAAQSAAAEEgAABBIAAAQSAAAEEgAABBIAAAQSAAAEEgAABBIAAAQSAAAEEgAABBIAAAQSAAAEEgAABhqrX+/Yun6UspZa/dnO42SymHvUc0MvJtpbhv7tw3XyPfVsr4923XWi8e9WBtyTfaq7XeOIFBK2mapt1R7xv5tlLcN3fum6+Rbytl/Pv+xE8MAEAQCABAWDYQHjdZsTpGvm/k20px39y5b75Gvq2U8e871lJ/UgQA/g9+YgAAgkAAAIJAAACCQAAAgkAAAMIvjVNf9tZcDFAAAAAASUVORK5CYII=\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPEAAABICAYAAAAnDhO0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAABsklEQVR4nO3YMUodURiG4X+iN30gViJWaQJ2lm4j+7J2CxZuIRBLe2Md7MQUmioJxw1oyKCHc7/D87QzXL6/eGG4S2utgFzvRg8AXkfEEE7EEE7EEE7EEE7EEG53zcsfdnba/mbTa8tw3z+9Hz2hq6M/j6MndHX9+Hn0hG5+39/W318/l+eerYp4f7Op84ODt1m1hU4u5r2tqurr/eXoCV0dfzsfPaGbH6dfXnzmcxrCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCiRjCLa21/395WR6q6qbfnOE+VtXd6BGdzHxb1fz3HbbW9p57sLvyh25aa8dvMGgrLctyNet9M99WNf99/+JzGsKJGMKtjfisy4rtMfN9M99WNf99L1r1xxawfXxOQzgRQzgRQzgRQzgRQ7gn/iE36yjNxFIAAAAASUVORK5CYII=\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZgAAABICAYAAADLcuPOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAACE0lEQVR4nO3bMUpcURiG4XPNKA4iETSIBExvKYKQJbgm62wgnZWdVcA1pM4GbGzSRBgkMILFiCcbMOCF+Tgzh+dp7zB8f/XCHWaotRYAWLaN1gMA6JPAABAhMABECAwAEQIDQITAABAxGfPh3a2PdX96mNrS3OPGovWEqLr5ofWEqJedaesJMTtbf1tPiPq8mLWekPXUekDO7/miPD6/DG89GxWY/elhufz6fTmrVtDN9kPrCVGvR3utJ0TNzk9aT4g5Pb5tPSHq25/r1hOyfvb7f8OLH/f/feYVGQARAgNAhMAAECEwAEQIDAARAgNAhMAAECEwAEQIDAARAgNAhMAAECEwAEQIDAARAgNAhMAAECEwAEQIDAARAgNAhMAAECEwAEQIDAARAgNAhMAAECEwAEQIDAARAgNAhMAAECEwAEQIDAARAgNAhMAAECEwAEQIDAARAgNAhMAAECEwAEQIDAARAgNAhMAAECEwAEQIDAARAgNAhMAAECEwAEQIDAARAgNAhMAAECEwAEQIDAARAgNAhMAAECEwAEQMtdb3f3gY5qWUu9yc5g5KKbPWI0J6vq0U9607962vL7XWT289mIz8orta69kSBq2kYRh+9Xpfz7eV4r51574+eUUGQITAABAxNjBXkRWro+f7er6tFPetO/d1aNSP/ADwXl6RARAhMABECAwAEQIDQITAABDxD16vT/cuKcD8AAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "CUSTOM_PAL_SORT_3 = ['#5e60ce','#00c49a','#ffca3a','#D81159','#fe7f2d','#7bdff2','#0496ff','#efa6c9','#ced4da']\n",
+ "GMM_PAL = ['#d62424','#12db41','#f0c905','#248cd6']\n",
+ "\n",
+ "# In RGB form\n",
+ "coherence_colors = [[0.609, 0.283,\t0.724],\n",
+ "[0.259,\t0.314, 0.635],\n",
+ "[0.251,\t0.412, 0.698],\n",
+ "[0.176,\t0.631, 0.859],\n",
+ "[0.369,\t0.749, 0.549],\n",
+ "[0.898,\t0.654, 0.169],\n",
+ "[0.898,\t0.41, 0.165]]\n",
+ "sns.palplot(CUSTOM_PAL_SORT_3)\n",
+ "sns.palplot(GMM_PAL)\n",
+ "sns.palplot(coherence_colors)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "A4kW4JO8d4hh"
+ },
+ "source": [
+ "# Step 3: Setting of parameters\n",
+ "\n",
+ "---\n",
+ "\n",
+ "This sets various global parameters like sampling rate, U-probe depths, and random seed state. Setting the random seed at the level of the Python kernel, Numpy, and random packages is essential to produce the same qualitative WaveMAP projection across instances. Note that qualitatively, the results be the same no matter the seed because it affects the projection step of the algorithm and note the graph construction (the latter is what is used in clustering)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "id": "LAC7l7TNb8N1"
+ },
+ "outputs": [],
+ "source": [
+ "#These are the depths that the V-probe channels are located at\n",
+ "DEPTHS = [0.15,0.3,0.45,0.60,0.75,0.9,1.05,1.20,1.35,1.50,1.65,1.80,1.95,2.1,2.25,2.4]\n",
+ "\n",
+ "#This converts time points to real time. There are 48 samples per waveform colleted at 30 kilosamples\n",
+ "SAMP_RATE_TO_TIME = 1/(48/30000) \n",
+ "\n",
+ "#Setting of random seed across Python kernel and packages to ensure reproducibility \n",
+ "RAND_STATE=42\n",
+ "np.random.seed(RAND_STATE)\n",
+ "os.environ['PYTHONHASHSEED'] = str(RAND_STATE)\n",
+ "random.seed(RAND_STATE)\n",
+ "\n",
+ "#UMAP Parameters\n",
+ "#The number of neighbors considered when constructing the high-d graph. \n",
+ "#Made more global-information preserving by increasing it from 15 to 20.\n",
+ "N_NEIGHBORS = 20 \n",
+ "\n",
+ "#The minimum distance between points in the projected space.\n",
+ "#Used for visualization but doesn't affect clustering.\n",
+ "MIN_DIST = 0.1\n",
+ "\n",
+ "#Louvain Clustering Parameters\n",
+ "RESOLUTION = 1.5\n",
+ "\n",
+ "# BLUE COLOR\n",
+ "BlueCol = '\\033[94m'"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "W0-CCJCAeLOx"
+ },
+ "source": [
+ "# Step 4: Loading of processed waveform data\n",
+ "\n",
+ "---\n",
+ "\n",
+ "This cell loads varous files including the 250 Hz high-pass 4th order Butterworth-filtered waveforms, the GMM features, BIC values used for selecting number of GMM clusters, and other waveform info."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "b7A2Qlu4exDE",
+ "outputId": "80b5e856-0fd9-4165-cac2-6ca70b0fcd96"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[94mLoading data\n",
+ "/Users/kenjilee/Documents/GitRepos/waveformAnalysis/notebooks/exploration\n",
+ "/Users/kenjilee/Documents/GitRepos/waveformAnalysis/notebooks/exploration/WaveMAP_Paper/data/full_data.npy\n",
+ "/Users/kenjilee/Documents/GitRepos/waveformAnalysis/notebooks/exploration/WaveMAP_Paper/data/waveformsClassified_250hz_refiltered.mat\n",
+ "/Users/kenjilee/Documents/GitRepos/waveformAnalysis/notebooks/exploration/WaveMAP_Paper/data/gmm_features.mat\n",
+ "/Users/kenjilee/Documents/GitRepos/waveformAnalysis/notebooks/exploration/WaveMAP_Paper/data/BIC_list.mat\n",
+ "/Users/kenjilee/Documents/GitRepos/waveformAnalysis/notebooks/exploration/WaveMAP_Paper/data/8_class_GMM.mat\n",
+ "/Users/kenjilee/Documents/GitRepos/waveformAnalysis/notebooks/exploration/WaveMAP_Paper/data/filt_full_df.pkl\n",
+ "/Users/kenjilee/Documents/GitRepos/waveformAnalysis/notebooks/exploration/WaveMAP_Paper/data/full_data_df.pkl\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(BlueCol + 'Loading data')\n",
+ "\n",
+ "rel_path = os.getcwd()\n",
+ "fullDataPath = os.path.join(rel_path,'WaveMAP_Paper/data/full_data.npy');\n",
+ "GMMclasslabelpath = os.path.join(rel_path,\n",
+ "'WaveMAP_Paper/data/waveformsClassified_250hz_refiltered.mat')\n",
+ "GMMfeaturepath = os.path.join(rel_path,\n",
+ "'WaveMAP_Paper/data/gmm_features.mat')\n",
+ "BICpath = os.path.join(rel_path,\n",
+ "'WaveMAP_Paper/data/BIC_list.mat')\n",
+ "eightclassGMMpath = os.path.join(rel_path,'WaveMAP_Paper/data/8_class_GMM.mat');\n",
+ "filtfulldfPath = os.path.join(rel_path,'WaveMAP_Paper/data/filt_full_df.pkl');\n",
+ "\n",
+ "print(rel_path)\n",
+ "print(fullDataPath);\n",
+ "print(GMMclasslabelpath)\n",
+ "print(GMMfeaturepath)\n",
+ "print(BICpath)\n",
+ "print(eightclassGMMpath)\n",
+ "print(filtfulldfPath)\n",
+ "\n",
+ "full_data = np.load(fullDataPath)\n",
+ "allDataDFPath = os.path.join(rel_path,'WaveMAP_Paper/data/full_data_df.pkl');\n",
+ "\n",
+ "GMM_class_labels = scipy.io.loadmat(GMMclasslabelpath)['classifies'].T\n",
+ "gmm_features_data = scipy.io.loadmat(GMMfeaturepath)['features']\n",
+ "\n",
+ "GMM_class_labels = GMM_class_labels[~np.isnan(GMM_class_labels)]\n",
+ "GMM_class_df = pd.DataFrame(GMM_class_labels,columns=['Class'])\n",
+ "gmm_feat_data_nonan = gmm_features_data[~np.isnan(gmm_features_data)].reshape(len(GMM_class_df),3)\n",
+ "\n",
+ "BIC_list = scipy.io.loadmat(BICpath)['BIC_list'][0]\n",
+ "\n",
+ "eight_GMM_classes = scipy.io.loadmat(eightclassGMMpath)['classifies']\n",
+ "\n",
+ "all_data_df = pkl.load(open(allDataDFPath,'rb'))\n",
+ "filt_full_df = pkl.load(open(filtfulldfPath,\"rb\"))\n",
+ "\n",
+ "print(allDataDFPath)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "BF50mJmCz5cQ"
+ },
+ "source": [
+ "# Step 5: Loading of processed firing rate data.\n",
+ "\n",
+ "---\n",
+ "\n",
+ "Raw data is too large to be hosted and processed given Colab I/O speeds and file size storage limits; therefore, processed data is used here. Please contact the corresponding author for access to raw data (cchandr1@bu.edu)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "id": "4yCjav9sZsR7"
+ },
+ "outputs": [],
+ "source": [
+ "def read_pkl(pkl_file_loc):\n",
+ " return pkl.load(open(pkl_file_loc,'rb'))\n",
+ "\n",
+ "FR_trace_loc = 'WaveMAP_Paper/data/FR_traces'\n",
+ "FR_traces = os.listdir(FR_trace_loc)\n",
+ "\n",
+ "UMAP_FR_traces = [x for x in FR_traces if not x.startswith('GMM')]\n",
+ "GMM_FR_traces = [x for x in FR_traces if x.startswith('GMM')]\n",
+ "\n",
+ "UMAP_traces_df = pd.DataFrame(columns = ['clust','PREF','NONPREF','PREF_UPPER_BOUND','PREF_LOWER_BOUND',\n",
+ " 'NONPREF_UPPER_BOUND','NONPREF_LOWER_BOUND'])\n",
+ "GMM_traces_df = pd.DataFrame(columns = ['clust','PREF','NONPREF','PREF_UPPER_BOUND','PREF_LOWER_BOUND',\n",
+ " 'NONPREF_UPPER_BOUND','NONPREF_LOWER_BOUND'])\n",
+ "\n",
+ "for i in range(0,8):\n",
+ " traces = sorted([x for x in UMAP_FR_traces if str(i) in x],key=len)\n",
+ " trace_arr = []\n",
+ " \n",
+ " trace_arr.append(i)\n",
+ " for trace in traces:\n",
+ " if 'pref_'+str(i)+'.pkl' == trace:\n",
+ " trace_arr.append(read_pkl(os.path.join(FR_trace_loc,trace)))\n",
+ " elif 'nonpref_'+str(i)+'.pkl' == trace:\n",
+ " trace_arr.append(read_pkl(os.path.join(FR_trace_loc,trace)))\n",
+ " elif 'pref_bounds_'+str(i)+'.pkl' == trace:\n",
+ " upper_bound, lower_bound = read_pkl(os.path.join(FR_trace_loc,trace))\n",
+ " trace_arr.append(upper_bound)\n",
+ " trace_arr.append(lower_bound)\n",
+ " elif 'nonpref_bounds_'+str(i)+'.pkl' == trace:\n",
+ " upper_bound, lower_bound = read_pkl(os.path.join(FR_trace_loc,trace))\n",
+ " trace_arr.append(upper_bound)\n",
+ " trace_arr.append(lower_bound)\n",
+ " \n",
+ " trace_series = pd.Series(trace_arr,index=UMAP_traces_df.columns)\n",
+ " UMAP_traces_df = UMAP_traces_df.append(trace_series,ignore_index=True)\n",
+ "\n",
+ "for i in range(1,5):\n",
+ " traces = sorted([x for x in GMM_FR_traces if str(i) in x],key=len)\n",
+ " trace_arr = []\n",
+ " \n",
+ " trace_arr.append(i)\n",
+ " for trace in traces:\n",
+ " if 'GMM_pref_'+str(i)+'.pkl' == trace:\n",
+ " trace_arr.append(read_pkl(os.path.join(FR_trace_loc,trace)))\n",
+ " elif 'GMM_nonpref_'+str(i)+'.pkl' == trace:\n",
+ " trace_arr.append(read_pkl(os.path.join(FR_trace_loc,trace)))\n",
+ " elif 'GMM_pref_bounds_'+str(i)+'.pkl' == trace:\n",
+ " upper_bound, lower_bound = read_pkl(os.path.join(FR_trace_loc,trace))\n",
+ " trace_arr.append(upper_bound)\n",
+ " trace_arr.append(lower_bound)\n",
+ " elif 'GMM_nonpref_bounds_'+str(i)+'.pkl' == trace:\n",
+ " upper_bound, lower_bound = read_pkl(os.path.join(FR_trace_loc,trace))\n",
+ " trace_arr.append(upper_bound)\n",
+ " trace_arr.append(lower_bound)\n",
+ " \n",
+ " trace_series = pd.Series(trace_arr,index=GMM_traces_df.columns)\n",
+ " GMM_traces_df = GMM_traces_df.append(trace_series,ignore_index=True) "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Obep1YIAZnAx"
+ },
+ "source": [
+ "# Step 6: Loading of decision-related functional activity"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "WAd35wPqP1Es"
+ },
+ "source": [
+ "Processed data calculated from behavioral trials is loaded here. Raw data is not provided for the same reasons as in the previous step."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "id": "jxLKNL3XKJ0-"
+ },
+ "outputs": [],
+ "source": [
+ "FR_stats_loc = 'WaveMAP_Paper/data/FR_stats'\n",
+ "decision_dynamics_loc = os.path.join(rel_path,'WaveMAP_Paper/data/decisionDynamics.mat');\n",
+ "\n",
+ "\n",
+ "baseline_FR_df = pkl.load(open(os.path.join(FR_stats_loc,'baseline_FR_df.pkl'),'rb'))\n",
+ "max_FR_df = pkl.load(open(os.path.join(FR_stats_loc,'max_FR_df.pkl'),'rb'))\n",
+ "GMM_baseline_FR_df = pkl.load(open(os.path.join(FR_stats_loc,'GMM_baseline_FR_df.pkl'),'rb'))\n",
+ "GMM_max_FR_df = pkl.load(open(os.path.join(FR_stats_loc,'GMM_max_FR_df.pkl'),'rb'))\n",
+ "\n",
+ "dynamic_range_FR = np.subtract(max_FR_df['max_FR'],baseline_FR_df['baseline_FR'])\n",
+ "dynamic_range_FR_df = pd.DataFrame({'dynamic_range_FR': dynamic_range_FR, \n",
+ " 'dbscan_color': baseline_FR_df['dbscan_color']})\n",
+ "\n",
+ "GMM_dynamic_range_FR = np.subtract(GMM_max_FR_df['max_FR'],GMM_baseline_FR_df['baseline_FR'])\n",
+ "GMM_dynamic_range_FR_df = pd.DataFrame({'dynamic_range_FR': dynamic_range_FR, \n",
+ " 'dbscan_color': baseline_FR_df['dbscan_color']}) \n",
+ "\n",
+ "with h5py.File(decision_dynamics_loc,\"r\") as f:\n",
+ " diffV_list = []\n",
+ " for i in range(8):\n",
+ " diffV_list.append(np.array(f[f['forKenjiDat']['diffV'][i][0]]))\n",
+ "\n",
+ " coherences = []\n",
+ " for i in range(7):\n",
+ " coherences.append(f['metaData']['coherences'][0][i])\n",
+ "\n",
+ " dec_dyn_data = []\n",
+ " dec_dyn_data_err = []\n",
+ " \n",
+ " for i in range(8):\n",
+ " dec_dyn_data.append(np.array(f[f['forKenjiDat']['timeSlope'][i][0]]))\n",
+ " dec_dyn_data_err.append(np.array(f[f['forKenjiDat']['timeSlopeE'][i][0]]))\n",
+ " \n",
+ " for i,x in enumerate(dec_dyn_data):\n",
+ " dec_dyn_data[i] = [val for sublist in x for val in sublist]\n",
+ " \n",
+ " for i,x in enumerate(dec_dyn_data_err):\n",
+ " dec_dyn_data_err[i] = [val for sublist in x for val in sublist]\n",
+ "\n",
+ " dec_dyn_slope = []\n",
+ " \n",
+ " for i in range(8):\n",
+ " dec_dyn_slope.append(np.array(f[f['forKenjiDat']['slopeAsfCoh'][i][0]]))\n",
+ " \n",
+ " for i,x in enumerate(dec_dyn_slope):\n",
+ " dec_dyn_slope[i] = [val for sublist in x for val in sublist]\n",
+ "\n",
+ "discrim_data_path = 'WaveMAP_Paper/data/discrimination_times.pkl'\n",
+ "discrim_file = pkl.load(open(discrim_data_path,'rb'))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "id": "9-LNNSLOZ-wT"
+ },
+ "outputs": [],
+ "source": [
+ "masterArray = scipy.io.loadmat(os.path.join(rel_path,'WaveMAP_Paper/data/masterArray.mat'))['masterArray']\n",
+ "\n",
+ "uprobeMask = scipy.io.loadmat(os.path.join(rel_path,'WaveMAP_Paper/data/uprobeMask.mat'))['uprobeMask']\n",
+ "uprobeMask = [i[0] for i in uprobeMask]\n",
+ "\n",
+ "ch_depth = scipy.io.loadmat(os.path.join(rel_path,'WaveMAP_Paper/data/allChansUprobe.mat'))['allChansUprobe']\n",
+ "ch_depth = [i[0] for i in ch_depth]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "UgFaghmrlqyo"
+ },
+ "source": [
+ "# Figure 1E Bottom (Plots all the waveforms used in the analysis). \n",
+ "\n",
+ "The normalized and filtered average single-unit waveforms are plotted on top of each other here with transparency."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "45Htregu1CV8"
+ },
+ "source": [
+ "### We plot all normalized single unit waveforms together"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 276
+ },
+ "id": "DDwk8jADeLez",
+ "outputId": "88583a91-996e-40bc-c774-7446ceff17b1"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[94mPlotting: 625 Waveforms\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# This plots all the normalized single unit waveforms together. The total waveform length is 48 points at 30000 samples/s\n",
+ "# 14, 28, 42 are the 0.5 ms, 1.0 ms, and 1.5 ms\n",
+ "\n",
+ "# Generate subplots\n",
+ "f, arr = plt.subplots(1,figsize=[4.5,3.4])\n",
+ "\n",
+ "print(BlueCol + \"Plotting: \" + str(full_data.shape[0]) + \" Waveforms\")\n",
+ "for i in range(0,full_data.shape[0]):\n",
+ " arr.plot(full_data[i].T, c = 'k', alpha = 0.03,linewidth=2.);\n",
+ " \n",
+ "arr.tick_params(direction='out',colors='k', axis='both')\n",
+ " \n",
+ "# Set various x and y axes and labels etc.\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "\n",
+ "arr.spines['left'].set_bounds(-1,1)\n",
+ "arr.spines['bottom'].set_bounds(0,48)\n",
+ "\n",
+ "arr.set_xlabel('Time (ms)', fontsize=24);\n",
+ "arr.set_xticks([0,14,28,42,48])\n",
+ "arr.set_xticklabels(['0','0.5','1.0','1.5',''],fontsize=24)\n",
+ "\n",
+ "arr.set_ylabel('Amplitude (a.u.)', fontsize=24)\n",
+ "arr.set_yticks([-1.0,0.0,1.0]);\n",
+ "arr.set_yticklabels([-1.0,0.0,1.0], fontsize=24);\n",
+ "\n",
+ "arr.set_title('Figure 1E', fontsize=18)\n",
+ "\n",
+ "# Plot the data\n",
+ "plt.tight_layout()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "6amI4WSZeKkm"
+ },
+ "source": [
+ "# Figure 2: WaveMAP on of waveforms using UMAP and Louvain Clustering."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "mY0jVoHj0XfK"
+ },
+ "source": [
+ "## Figure 2A: Computation of WaveMAP clusters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "FjVdH1Ferdv0"
+ },
+ "source": [
+ "### First we construct the high-dimensional graph with UMAP\n",
+ "\n",
+ "---\n",
+ "\n",
+ "This function computes the UMAP graph construction and projection. Note the important parameters are N_NEIGHBORS and RAND_STATE. N_NEIGHBORS determines the balance between weighing global vs. local information and has been set higher than defaults (more globally-attentive). Random seed is set for qualitative reasons but produces no quantitative differences (see Figure S2) as this is used in the stochastic gradient descent in the force-directed layout procedure of the projection step in UMAP---we generate clusterings before this step."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "id": "ZvUkLtpSrbnF"
+ },
+ "outputs": [],
+ "source": [
+ "reducer = umap.UMAP(n_neighbors = N_NEIGHBORS, min_dist=MIN_DIST, \n",
+ " random_state=RAND_STATE)\n",
+ "mapper = reducer.fit(full_data)\n",
+ "embedding = reducer.transform(full_data)\n",
+ "\n",
+ "umap_df = pd.DataFrame(embedding, columns=('x', 'y'))\n",
+ "umap_df['waveform'] = list(full_data)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 23,
+ "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.scatter(umap_df.x,umap_df.y)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 75,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from numpy.random import normal\n",
+ "\n",
+ "noise = np.zeros(full_data.shape)\n",
+ "for i,row in enumerate(noise):\n",
+ " noise[i,:] = np.random.normal(0,0.11,full_data.shape[1])\n",
+ "\n",
+ " \n",
+ "noisy_data = full_data+noise"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 83,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "2.3266666666666667"
+ ]
+ },
+ "execution_count": 83,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "0.349/0.15"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 77,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.3490391240013654"
+ ]
+ },
+ "execution_count": 77,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "np.mean(np.std(full_data,axis=1))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 78,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "f,arr = plt.subplots(1)\n",
+ "arr.plot(noisy_data.T,c='k',alpha=0.05);\n",
+ "f.tight_layout()\n",
+ "arr.spines['left'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['bottom'].set_visible(False)\n",
+ "# plt.savefig('waveforms_02.pdf')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 79,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "reducer_noise = umap.UMAP(n_neighbors = N_NEIGHBORS, min_dist=MIN_DIST, \n",
+ " random_state=RAND_STATE)\n",
+ "mapper_noise = reducer.fit(noisy_data)\n",
+ "embedding_noise = reducer.transform(noisy_data)\n",
+ "\n",
+ "umap_df_noise = pd.DataFrame(embedding_noise, columns=('x', 'y'))\n",
+ "umap_df_noise['waveform'] = list(noisy_data)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 80,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 80,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "f,arr = plt.subplots(1)\n",
+ "\n",
+ "f.tight_layout()\n",
+ "arr.spines['left'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['bottom'].set_visible(False)\n",
+ "arr.scatter(umap_df_noise.x,umap_df_noise.y,s=15,c='k')\n",
+ "# plt.savefig('waveforms_scatter_02.pdf')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "xKKPxxUVrlem"
+ },
+ "source": [
+ "### Next we apply Louvain clustering to the high-dimensional UMAP graph\n",
+ "\n",
+ "---\n",
+ "\n",
+ "This is the graph clustering that operates on the high-dimensional graph found by UMAP and occurs before the projection is computed."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {
+ "id": "TuXXBsLbeKxP"
+ },
+ "outputs": [],
+ "source": [
+ "G = nx.from_scipy_sparse_matrix(mapper.graph_)\n",
+ "clustering = cylouvain.best_partition(G, resolution = RESOLUTION)\n",
+ "clustering_solution = list(clustering.values())\n",
+ "umap_df['color'] = clustering_solution\n",
+ "\n",
+ "cluster_colors = [CUSTOM_PAL_SORT_3[i] for i in clustering_solution]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "9CpooetSruMn"
+ },
+ "source": [
+ "### This yields our UMAP graph colored by Louvain cluster\n",
+ "\n",
+ "---\n",
+ "\n",
+ "Shown is a plot of the UMAP projected space with clusters colored according to high-dimensional graph clusters found in the previous step by Louvain clustering."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 355
+ },
+ "id": "edO6Ch3peIcI",
+ "outputId": "55d0721b-a733-4c79-b82d-c093c7184271"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "f,arr = plt.subplots(1,figsize=[7,4.5],tight_layout = {'pad': 0});\n",
+ "f.tight_layout()\n",
+ "arr.scatter(umap_df['x'].tolist(), umap_df['y'].tolist(), \n",
+ " marker='o', c=cluster_colors, s=32, edgecolor='w',\n",
+ " linewidth=0.5)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['bottom'].set_visible(False)\n",
+ "arr.spines['left'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.set_xticks([]);\n",
+ "arr.set_yticks([]);\n",
+ "arr.set_xlim(-4,12)\n",
+ "arr.set_ylim(0,12)\n",
+ "\n",
+ "arr.arrow(-3,0.8,0,1.5, width=0.05, shape=\"full\", ec=\"none\", fc=\"black\")\n",
+ "arr.arrow(-3,0.8,1.2,0, width=0.05, shape=\"full\", ec=\"none\", fc=\"black\")\n",
+ "\n",
+ "arr.text(-3,0.3,\"UMAP 1\", va=\"center\")\n",
+ "arr.text(-3.5,1.0,\"UMAP 2\",rotation=90, ha=\"left\", va=\"bottom\")\n",
+ "\n",
+ "N_CLUST = len(set(clustering_solution))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "id": "v-MwbFeHrCk5"
+ },
+ "outputs": [],
+ "source": [
+ "# Defines a nice function that plots all the waveforms in long column.\n",
+ "def plot_group(label_ix, labels, groups_df, colors, mean_only=False, detailed=False):\n",
+ " group_ixs = [i for i,x in enumerate(labels) if x == label_ix-1]\n",
+ " group_waveforms = groups_df.iloc[group_ixs]['waveform'].tolist()\n",
+ " \n",
+ " f, arr = plt.subplots()\n",
+ " f.set_figheight(1.8*0.65)\n",
+ " f.set_figwidth(3.0*0.65)\n",
+ " if not mean_only:\n",
+ " for i,_ in enumerate(group_waveforms):\n",
+ " plt.plot(group_waveforms[i],c=colors[label_ix-1],alpha=0.3,linewidth=1.5)\n",
+ " \n",
+ " if not mean_only:\n",
+ " plt.plot(np.mean(group_waveforms,axis=0),c='k',linestyle='-')\n",
+ " else:\n",
+ " plt.plot(np.mean(group_waveforms,axis=0),c=colors[label_ix-1],linestyle='-')\n",
+ "\n",
+ " arr.spines['right'].set_visible(False)\n",
+ " arr.spines['top'].set_visible(False)\n",
+ "\n",
+ " if detailed:\n",
+ " \n",
+ " avg_peak = np.mean([np.argmax(x) for x in group_waveforms[14:]])\n",
+ " arr.axvline(avg_peak,color='k',zorder=0)\n",
+ " \n",
+ " arr.set_ylim([-1.3,1.3])\n",
+ " arr.set_yticks([])\n",
+ " arr.set_xticks([0,7,14,21,28,35,42,48])\n",
+ " arr.tick_params(axis='both', which='major', labelsize=12)\n",
+ " arr.set_xticklabels([0,'',0.5,'',1.0,'',1.5,''])\n",
+ " arr.spines['left'].set_visible(False)\n",
+ " arr.grid(False)\n",
+ " arr.set_xlim([0,48])\n",
+ "\n",
+ " if not detailed:\n",
+ " arr.set(xticks=[],yticks=[])\n",
+ "\n",
+ " if not mean_only:\n",
+ " x,y = 2.1,0.7\n",
+ " ellipse = mpl.patches.Ellipse((x,y), width=9.0, height=0.72, facecolor='w',\n",
+ " edgecolor='k',linewidth=1.5)\n",
+ " label = arr.annotate(str(label_ix), xy=(x-0.25, y-0.15),fontsize=12, color = 'k', ha=\"center\")\n",
+ " arr.add_patch(ellipse)\n",
+ "\n",
+ " if i != -1:\n",
+ " x, y = 23,-0.7\n",
+ " n_waveforms = plt.text(x, y, \n",
+ " 'n = '+str(len(group_waveforms))+\n",
+ " ' ('+str(round(len(group_waveforms)/len(groups_df)*100,2))+'%)'\n",
+ " , fontsize=10)\n",
+ " \n",
+ " return f, arr"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "IWfn2ph106IF"
+ },
+ "source": [
+ "### Lastly we plot the waveforms for each cluster together along with their average waveform"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 665
+ },
+ "id": "3P802ziWshvW",
+ "outputId": "de9680c0-2e5b-4455-b109-cc5ccd4b157a"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJUAAABRCAYAAADb2+TtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAdqklEQVR4nO2deXQc1b3nP7eqel+074sly5YtZBtveIGwGLM9TExgIAmQECALAc5LyDY5L+TM5CXkZTnvwCRjEg95TMAhLwmQiUkygQTwEIjBgLG84k22JNtau1vqVm/V1VV154+WhR15tyzbpD/n1LHcde+tqu5v/+7v/u7v3hZSSvLkGU+Us30DeT545EWVZ9zJiyrPuJMXVZ5xJy+qPONOXlR5xp2TEtV1110ngfxxfh0TjnYyhcPh8AmXNU2TwcFBYrEYHo+HkpISPB7PSd9gnvOPce/+9uzZw9e+9jUqKyupqKigubmZuro6gsEgt956K2vWrCEfcP1gc1KW6lj09vbymc98hj/96U+oqspHPvIRlixZQkFBAel0mvfee49Vq1bx3HPPMW3aNFasWMFVV101XpfPcy4hpTzhY968efJIbN++XdbX10ufzyf/9V//VXZ3dx+xXDqdlqtWrZLTp0+XmqbJp5566ojl8owrJ/UZj8dx2qLq7u6W9fX1sqKiQm7YsOGEnjIWi8mlS5dKRVHk888/f8LvTp5T4vwT1Y033ij9fv8JC+ogiURCXnTRRTIQCMhYLHZSdfOcFBMuqtNy1Lu6uvjDH/7AF77wBebMmXPYuRUrVjB//nxcLhd33XXXmLo+n48VK1YQj8f5xS9+cTq3kecc47REtXLlSgDuvffeMeeqq6v55je/yT333HPU+gsWLGD+/Pk89thjH6gRYTZrE4tlCYcN+vp0+vszhMIZhoezZDL22b69M84pj/6klDzxxBMsX76c+vr6MedvvvlmANavX8+BAweO2s4DDzzA3XffzZtvvsnFF198qrdz1slmbSIRg6FoFl0/tnA0TeD3aQSDGgUFGpr2wZrYOGVRpVIpQqEQixYtOq0bOFi/s7PzvBSVaUr6+3VCYQMpwe9Tqa5y4/OpOF0Kmipy5SyJkbHRdZtk0iSeMInGsoj9EAhoFBU7KCxwoCjiLD/R6XPKokokEgAEAoHTuoGD9ePx+Gm1M5FIKbEsSSJhsn+/jmlJiosdVJS7cLvVI9ZxKgKnQ8Hvh9JSJwCplEU0lmVo0KCry+SAqlNU6KC01InHc+R2zgdOWVR+vx84fTEcrH+64hxPbFui6zaKkuuqNE3ByNoMRgyi0Sxp3SISyRKLZfF6VZqafBQWOHA6FSxLoiggxPEtjter4vWqVFW6SCQsIhGDyKBBOGLg96lUVLgIBh0T8MTjyymLyuv1UlJSwjvvvHNaN7B+/XqAI/plZxLTlMRiWYbjJooAh0PBNCXJZJZMRuZmY2XOGkXCBsMJE5dTwedTSCQs0rqNx62iqrBpUwwhBG63QkmxE7dHRVUFTofA5VLxeBS8XhWfT0NVx4pNCEEgoBEIaJimTSSSJRzOsGdvCq9XpbbGjc83bpMfZ5xTvlMhBHfffTePPvoo3d3d1NTUHHbeNE1M08SyLCzLQtd1NE1D0w6/5GOPPUZzc/OE+lOxWJbOzhS2BKdDkDUlPT066bSF26VQWenC49EIhTN0d+vouo3brSAldO3TAUFpsYNAUENRBF6vwMjamKYkGstS5hQUFbqwLEk6neviAIQAn1clWJDzn1yusQ66pilUVLgoK3MyNJSlr09n9+4k5RUuKitc54XPdVrDjvvuuw/btnn88cfHnHv44YfxeDx8//vf5+mnn8bj8fDwww8fVmbDhg2sW7eO+++/H0WZmBFQPG7S0ZnC5VZpbvYxtdmP06FQVeVi7txCpkz10ddv0LYxSkdHEq9Xoa7OjeaASMRAT1s4NJByxML4VXw+lUBAQ1MFkYjBu+9G+etrYbq6UsRiWQzDJpU0GRw02N2e5K23h3jllRCv/y3Cjh1xotEspnl4SEVRBCUlTqZNC1Bc7KC/P5P7ItjnfuhFnEx8aP78+fJgd3WQG264gddff521a9cyY8aME24rnU5z1VVXsWnTJg4cOEBhYeEJ1z1VMhmLHTsTOJ0KU6f4kBJ27U5imjaT6j3EExbtuxP0DWTo680QG84JQhECW+bSk1RVoKqCbFZiZm0k4HQqqIpA1cC2BWbWIpW2cTgExUVOyitcuJwKDqeCy6mQNSyG4xaxWC5upSgCt0fF51Xx+lT8Xg1/QKWw0IHXq+F2KQzHTSKRLEVFGlOn+HG7lRPy24AJN22nLap9+/axePFihBC8+OKLJySsZDLJRz/6UV544QWeeeYZbrnllpO+8VNh794k8YRJS0sAhybYszfFcCyLP6DR16uze0+S/v4M0SEDPWPn/B8pyRgWhpFrQ0qwrIOWKvfvQXKOPTgcAkUB0wTLlKOZckKQS5sTufMOTUFRJUgBAhQh0BwCl1PB7VFwuVRcLmVEZBq2bZNO25SWOqis8DB9uv9EHPkJF9Vpe3/19fW8+OKLXHvttVxyySU89NBD3H333ZSVlY0pm81mWb16NQ8//DBbt25l5cqVEyaoRMIkNmxSVenC6VDo7tbZ25EkETfpH8hw4ECadNoklbSQgEMTZHSJnjl6m2Y2Q9ZMASCEgsPhxbYdGMbRv6hCgKZJbBtMy0JDweHMOfUgsCyJnrHImrmwhRAaSWGSzdq4XCoZ3WLPHpPeXoPBQYNrrik/5/ys07ZUB9m/fz933XUXa9aswel0cuutt47mU6VSKbZv386TTz5JX18fDQ0NrFixgmXLlo3XcxyXnbsSZLM2LdP97N+v8/bbQ0RjBvGERSyWIZm0c1MoUiAUSTJpY1m5urZtEgptYaC/jVBoC/HhfSQSPVjWWMU5HD48nlK8vnKCwUkUFDRSVNxMcXEzTmcARWHkEChK7r0XQqCq4Har+HwKliUwMjaWDU6nQNMEbpdKUZGD8jIXDqcgk5FEIgZz5hSweFHxsR79/Ov+/p5t27axcuVKVq1axfDw8PsXEoJly5Zx3333ce2116KqExfci8Wy7O1IUVPtJh432bZ9mHDIIGPYxOMmg4MZ0mkbaYNlW4zEdRkc3MWunc+xr+sVdH0IgGCwgcLCRvyBWlyuAjSHF4FASgvDSGBkYqTSYZKJXoaHuzCM9+N4wWADpWWtlJVdSGXlLErLmnA6HShKLnxhj8zuuJwKLrfAMgUScDkFlg2maaNpgoICjabJfvSMRSJhs/yGCurqvEd7/PNfVAfRdZ2BgQGi0Sher5eysjIKCgqOWUfKXNBxvKPJe/YkSaUtvB6F3t4M+7tTxKImiYTFQChDOm1i25JsVpLJQH9/G5vafkpf33o0zU1t7WVMariKisr5uN0nPqCQUpJOhxka3EUksp1weBvh0BZ0fRAAh8NPWfksKirmUFU9h+qqVtweF0gFBKiqwDQlmqaMWixdt8lmbVRVYUqTl1jMZM6cAq7/p8qj3cYHR1QnSyplsW9/mnTaommyd9wiyZmMxXvbE2gqZLOSgQGdvR1pMoZFb2+GZNLEMGwMAxKJHt5569/Zv/9VPJ5SWlrvYOrUm3C5guNyL3AwoNrNwMBGQv2bGBjYSDS6BwBFcVBa2kpZ+WwqKmZTWTUHrzeAw5GL7KuKitMlyBqStG7i9eaCqaWlLr72lSlHGw2ef476eDA8nGXv3hSqlhsVDUWz4yaqcNhA1y00TSBtSW9vhnQ6S19fhqEhk6yZ+6Dbd69m/TuPIKXNnLkP0HLB7Wja2NU/igJej6Cw0ElJSS4A6nQIpIR4PDfVEotlSaZyI8a//87moue1BAK1NDXdAICuRxkY2MhAfxsD/W28t+1ptm19EiEUiktaqK29lPr6KygsmorbLXA4BLYNsZiZC95mLbq6kjQ0+MflPTtdzrqobFuy/4CO06nQ3OynuydNNJqlrlae9qjGtiXhiIGu25SWOOnoTBIKZ+jtSxGNjozATJ033/gOHXtfoLJyPhdf8i38geoxbTmdUFHhZEZrgJkzCykucuJ2q7jdCpqW66Yyhj2SiWARGTTo7EzR1ZWkrz/D8LCJrstR5/9Q3O5C6uuvoL7+CgBMM004tI2+vnfo7X2bTRv/F5s2riQQrGfSpKVMnnw9RUVNSHLWN2NI1r45dM6I6qx3fz29On19OnW1HoqKnKRSJnv2pmhs9FJYcHrWanDIYOuWeC724xK89nqY3buTJJO5Z06nwqx55YtEItuZPed+Zs66ByEOj+w7ndDc7OPqpWVMnx48ahbC0ZBSkkpZhMM6+/bp7NwVp6MjRThikMmMtWRHIp0Ks3//q3R1vkJf33qktCgumc706R+ncfJ1qKqTggKFHz0660hd4D+WT5VOW7y3PU46bY1OmLrdCmndoqjQSWPDUUc0J0T7niQ7dsRpmORh/btR3lw3iK7nziWT/bz058+TSvVz6WXfo67+8sPqahpMm+blhmXVNE324nKN3+DhYCwqHNJp2xRj6+YY3b0ZdJ3REeDRSKcH6ex4kd27VhONtuPxljFv/oM0Nl7HtVcXc8cdDX9f5R9HVFJKNm8ZZt++NFVVbmpr3Egp6dqn43IJFCGYOTN4yl2gZUnWvjE44oSb/OGPfaRycUqSyT7+/MJnyWSiLL3qf1JeMfuwuiXFGjcsq2D+/KIJSz2JJ0w6OxO0bRymoyNFNGqQSFiY5pGFJqWkt2cdG9t+Sji8ldraS1m0+CGefebavy/6j+Go27Zk584E7e1Jqqvd1NV56O3RsWxJOJzB51UpLHKSSJin/KHGYrl8J9O0ee318KigMplhXnnpn8lkYlx97UpKS1tH66gqTJ3i4fbb6qmr80xopDrg15g5o5CZMwpzI9OeDHs74mzeEh/JlDAxs7k5yGxWYlmC6prFVFYtYMf2X9G24ScMDu0CxohqwpkQUeWW7uSmKIaiWfZ1pXOZAi5Bf7/Oxo1RjKwk4NcIBjSSKQunSyFjnPoigd4RX627J8XgYM47tiyDV9d8meHhLpZeveIwQbmcMGduAXfdOemsZ126nCoNDV4aGrzMn1fMX18Lc+CATiJpEh3Komcs0mkb07TJZlUuaP0EjZOvp672mJH1CeOMiMowbPYfSBEKGYTDBomESTJloqctMhmb4WGTeMIinc5i2+B2qVRUumhs8CAQRIYMenp0Jk06NZ/KMGw2bopxoDtFd/f7UynvvP3v9Pdv4NLLvkdV1YLR131ewSWXlHDrLTU4nefWIoRg0MGiRcVs356gv1+nz6WT1i2yhkRRBZoGfp+Gy13ElVeMnW89G4yrqNatC/PCi/0MhIzR7uZESKcthqIpOjpSNE/1UVbmZmgoy3AsCzUnv1PMjh3D7O1IEokYZHP5cezd+wK7dj5H64xP0Tj5/S6iuEhl6dIyZl9YeM4J6iBlpS6csxQSCS/ptIWu2xiGTTCoUVTkoOAcWzAxrqL6jyf2kzGyZLMpTFNHIBCKitMZQFWdx62fycCWrUmmTjEpKnbTP2BwwQUndw+RiMGGthjhUHY0dDAc62LdGw9TXj6bOXPvHy1bVqZy0021+Lwq5RWuk7vQBFNQkBPP+cC4imrP3ld5dc2Xj3jO4fARLGigqKiZ2rpLqa5ehKa5j9JOhlaPg6GhLFLKE01GI5OxaN+ToH1PkkzGxLZBSps33/gOiqJx2eXfR1FyH0xRkco9d0/CyEBpiROn49y0Uucj4yqqosLJzJ5zPw6HF3VEMLaVxTDi6Pog0egeujpfon3373A4fEybfiszZnwSl7vosCCgbUN/v05xkRPDsE84RjQwYLB1a5xEIjf9ArB71/+hv38Diy/5b3h95QAUFCjc+Yla/H4ng4Zxzlup841xFdWSK1sIrD/2qhjbztLf9y579z7P1i1PsXPHb7j08q8zefLy0exKgFDIpLIySzptnZCopJRsfW+YUDhDJmNjmpBKhXh3/Y+prFrAlCk3AuD1wLLrK5gxs5D33otTXJy3UuPNuIrqQ5eUYWQUEkkTVVWorHRSUqSxc2eSrv0pTBOEcFBds4ja2kUsWHAva//2fda8/C16L9jAxZc8RDab656khNCAzuBglsLC4/tj0WiW/fvS6Lo1mnnZtmEFlpVh8eKHRhPh5s0v5Kql5fT2ZUBCRXneSo034yqqObOLaGkJsqc9yYa2GP0DGZCCJVeW0tmZ5vW/DWKZNl6PJGOAx9vA9Tf8hLZ3H+ettx7H4fAxe87XRtuLDGYJhQ0mT/Yd99qbtwznlpPHs5gmDEZ2sqf9j1zQ+gkCwToApjR5uP3jdUgJkbBBUdGRl0nlOT3G/R11u1RaW4Pc9JEqLpxZQFq3aNswTHGxkyVXFKNqCoqaSzpTFDAMhQUL72fmrNvZvOlXdHW+NNqWYUBo4BhJ4iPousXu3QlUDaJRCykl69c/gstVwKxZnwEg4IfbbqvD69UIhQxsCeV5K3VGOGNfU79f4/IrSpg/twDNIdizN4nH66Cuzj26LPzgqpO0brP44gcpr5jJG2u/TTLZP9pOT1/6uNdqb0+STtvEhkxME3q636Cv9x1mzf4cTlduOf0NN1TS2ODDsiShsEFBUJuwyPmjjz5Ka2srM2bM4LbbbkMfmdXu6Ohg4cKFTJkyhY997GMYhzqVh7B69Wq+/e1vA/Daa68xd+5cNE3jueeeGy2zceNGFi9eTGtrK7NmzeI3v/nNEdsSQtQLIf6fEKJNCLFZCHH9yOuXjPx/vRBi6shrhUKIv4hDUjeEEC8LIYqO9bxn1PY7HQoLFhQzY0YBbpdKb49ObY0bj0dDEbl1dC5XLsFNSo0lV34X00yzc8czo23s35/GMI6QhHQIHV0pLNump09HSpu2DY/h99fQ3PxfAKiq0rhqaS7dNhw2sCxJReXEWKnu7m5+/OMfs379erZu3YplWfz6178G4Otf/zpf+tKXaG9vp6ioiCeeeOKIbfzwhz/k/vtz8bX6+nqefPJJbr/99sPKeL1eVq1axbZt23jxxRd58MEHiUajR2rum8AzUso5wMeBn4y8/hXgeuBB4POHlP03KeWh82W/AO7nGJxxh0JVBQsuKqTlggAS0HVJTY0bp0vFNMVImdy8oN9fS139ZbTvXo1l5b61oVCGoWj2qO2bpk1/f4Z02iKVknR1vcLg4A4unHMvqurA4YCPLK9G0wS2LRkIZQgENHzese5kZ2cnLS0tfPazn6W1tZVrrrmGdPr4lvJ4mKZJOp3GNE1SqRTV1dVIKVmzZs3oErVPfepTrF69ekzdXbt24XK5KC0tBaChoYFZs2aNWdHd3NzM1KlTgdyGc+Xl5YRCoSPdjgQO5kcXAD0jf2cB78iRFUI0AXVSylf/rv7vgduO9bwT4qUqimDB/EIunBkkk7FAQlWlczRjEglSCoSAadNuRdeH6Op8GYB0GvoH9KO23dOjE49n6e9PY9smm9p+SkHhZBob/wmASZNczJuXW6wQiRiYpjzmiG/37t088MADbNu2jcLCQn7729+OKfPLX/6S2bNnjzmOtIaxpqaGr371q9TX11NVVUVBQQHXXHMNkUiEwsLC0b0lamtr6e7uHlN/7dq1zJ079xjv7ljefvttDMOgqanpSKe/BXxCCHEA+BPwzyOvfw9YBfwLsAL4LjlLdRhSyiHAJYQoOdr1J2zoI4Rg3rxC5s4pRNdtHM7cOjYpxWharKoKqqoXEgzWH9YFdnUefSJx794k8WGToSFJx94XiMU6mT3nPhRFJRBQ+NAlZTgcKrYt6R/IjO57cDQaGxuZPTuXXzVv3jw6OzvHlLnjjjvYuHHjmONQH+cgQ0NDPP/883R0dNDT00MymeTpp58+4fett7f3iAtzj1X+k5/8JD//+c+Ptj/FbcCTUspact3dL4QQipRyo5RykZRyCTAZ6AWEEOI3QoinhRAVh7QxAIzNuR5hQsfTiiJYuLCIlpYAqZRNwK/hcikcfPaDy5Gap99CKLSZocFdAOxuTx6xPcuyOdCtMxTNYNtZNm36GcUl06mvvxJNg6pKN4sWjlipQYNsVlJ5nOi5y/X+eVVVMU1zTJmTsVQvv/wyjY2NlJWV4XA4uPnmm3njjTcoKSkhGo2Otn/gwIExO+cAeDyeUcf+eAwPD7Ns2TK++93vHmuHw08DzwBIKd8E3EDpwZMiNyf2TeA7wH8H/ivwM+ALh7ThBo7qF0x4kEYIwRWXF1NV4cbpUnA4RG5PAQWyWVAVaGpahhAqnZ1/AaCzM3nE3U5CIYOBAZ3BQZv29j+QiB9g9uz7EEIQDKrMnBHA43HkrFR/zkqNRybnyViq+vp61q1bRyqVQkrJK6+8QktLC0IIlixZMlrnqaee4sYbbxxTv6Wlhfb29uPek2EY3HTTTdx5553H20pgH7AUQAjRQk4ghzpfdwJ/klIOkvOv7JHDO1JHAJVA59EucFYif4GAk5YWP9WVboqLnEiZW2AAkDHA7S6isuoiOjteQkpJLCYZHh7rrPf06HR2pbEsgy2b/oPS0hnU1H4ItxtKS10sXJhLWguHT8xKnQkWLlzILbfcwty5c5k5cya2bfO5z30OgB/84Ac88sgjTJkyhUgkwqc//ekx9S+77DLa2tpGd29+5513qK2t5dlnn+Xee++ltTWXaPjMM8/w2muv8eSTT45azo0bNwIghPi2EGL5SJNfAT4rhNgE/Aq4S440LoTwAncBj42UfYSc3/U/gJUjr80D1kkpx5rwEc5ajvqB7jRbtgyj6ybr3hoiHs+SSr2/umT37t/x5trvsOzD/0lJyXS++uVGZs48fHXwz5/q5NVXh9i541neWvc9rrr6MaprFlNcrHLlknJuWFaBZcF72+N4vSpTmo4fmT8X+eIXv8iHP/zhU/0tn3FNtBJC/Aj4vZTylaOVOWtzFMGARmmpk4pyNzXVHvx+jUO3V6ivvwIh1NEI+5Ytw4fVTyRMtm1N5KzU5v9NWflsqqoX4XJBVZWbSz9UjBCCvn4d25LUVB85zeZ84Bvf+Aapk8l6PLNsPZag4CyKyu/XcDoUCgudNEzyUlbmJhh8X1Uu10gX2JnrAt9eHzms/ubNQ4TCWXbv+h2pVD8Xzr4XRREEgxqLFxVRWOgknbYIhwyKS87v3X4rKipYvnz58QtOAFLKnx2vzFkTlaLkNk+VwOQmH6XFTibVew6zVg0N15CIHyAc3srQEIf9KsQf/28flplh65afU14+m6qqBbjdMKM1yAUtBdi2pKsrlQtTTFD0PE+OszpFHww6MAyb+joP1TVuvF4H1VXvj84mNSxF0zzs2pkLQEYiOWe9bWOU7h6TnTufJZUa4MI5n0dRBDU1XmbMCFJU5MhtDKvbTJrkwZHPl5pQzuq7XVjoQFUFoZDBRfMLKSt1MmmSf9RaOZ0BJk++ns6OP5PJDPP0f3awa/cwj/+sg0wmxuZNP6O6ejFVVQsoLlZonuKjrtZLJGIQChuUlTnPy33Iz3fOqqg0TVBR4WI4buJwqLS0BCgpcR7WXTVPvxXLyrCn/fe0taX40Y/3kkrBls1PYBgJ5s3/IqoKdXU+mqb4yBi5gGhBUKO66vx1zs9nznq/UFbqxOkQdPfoNDZ6mdKU24baMWJgioubKSu/kJ07n0NKm0RCMji4ix3bf82UqcspKm6mrtZJfZ0XPZ370aHSEieNjd5zatnSPxJnXVSKIqiqdpNOW+xuT1Je7mLmzAAXtLy/Lc606R8lPryP1/76L/T0rOMvf74Xt7uY2XPux++HggIXUkqCBRqNDV7q6jwnvAInz/hz1venAigucqKpgv7+DL19GaQtqK72cKBbJxIxaWy8lmSil00bV9LV+RJ+fzVXX7sSr7eMqiovpWUuLrywgKbJvrx1Ogc4J0QFuZFgMOjAyOY2dJ082YsQsPaNQWIxmDnrHmpqLmHXrt8yY+bd+P1VVFU5mFTvYcFFhUxp8uWt0znCOSOqgxxcLuVyObn8slJSSZsNG4eIx22KS6axaPE3EAKqKh1MmuSjZXqA+npvXlDnEOecqA6lstLN8uUVICRbtw2TTNrYtqSs1EldvYcZrUFaW4PndbT8g8g5LSqAkhIXn/xEHTt2xtnXlaY/lKG8zMXkRh9NTb5zdlONf2TOeVFB7ufKZrQWMKO1YGSD+ryQzmXOu08nL6hzn5PKpxJChICuM3c7ec4AYSnldRN5wZMSVZ48J0K+L8kz7uRFlWfcyYsqz7iTF1WecScvqjzjTl5UecadvKjyjDt5UeUZd/KiyjPu/H/S1V0sBwLdIAAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "BSclass = [1, 6, 7]\n",
+ "NSclass = [2, 3, 4, 5, 8]\n",
+ "for i in BSclass:\n",
+ " plot_group(i,clustering_solution,umap_df,CUSTOM_PAL_SORT_3)\n",
+ "\n",
+ "for i in NSclass:\n",
+ " plot_group(i,clustering_solution,umap_df,CUSTOM_PAL_SORT_3)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "dMp537GB04g9"
+ },
+ "source": [
+ "## Figure 2B: Optimizing number of Louvain clusters\n",
+ "\n",
+ "This goes through resolution parameter from 0 to 10 in steps of 0.5 as a function of number of clusters and \"modularity\" (this is the cost function which Louvain optimizes; see Supplementary Methods)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "RFAnsidu15wr"
+ },
+ "source": [
+ "### We calculate the modularity score and number of Louvain clusters across a range of resolution parameters while randomly permuting the waveform order. \n",
+ "\n",
+ "---\n",
+ "\n",
+ "**THIS CELL CAN TAKE 20 MIN**; skip it and run the next cell to read cached values of the plot.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "IF8dr-bZ2PoI",
+ "outputId": "c677dffd-fdcc-4f1f-a0f7-6b517ef6b4d8"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "\u001b[94m0.0\n",
+ "\n",
+ "\u001b[94m0.5\n",
+ "\n",
+ "\u001b[94m1.0\n",
+ "\n",
+ "\u001b[94m1.5\n",
+ "\n",
+ "\u001b[94m2.0\n",
+ "\n",
+ "\u001b[94m2.5\n",
+ "\n",
+ "\u001b[94m3.0\n",
+ "\n",
+ "\u001b[94m3.5\n",
+ "\n",
+ "\u001b[94m4.0\n",
+ "\n",
+ "\u001b[94m4.5\n"
+ ]
+ }
+ ],
+ "source": [
+ "resolution_list = np.linspace(0,10,21)\n",
+ "modularity_dict = {}\n",
+ "n_clusts_dict = {}\n",
+ "\n",
+ "subsets=[100]\n",
+ "\n",
+ "for res in resolution_list:\n",
+ " print(\"\\n\" + BlueCol + str(res))\n",
+ " for frac in subsets:\n",
+ " rand_list = []\n",
+ " n_clusts = []\n",
+ " for i in list(range(1,25)):\n",
+ " reducer_rand_test = umap.UMAP(n_neighbors = N_NEIGHBORS, \n",
+ " min_dist=MIN_DIST, \n",
+ " random_state=random.randint(1,100000))\n",
+ " rand_data = np.random.permutation(full_data)[0:(int(len(full_data)*frac)),:]\n",
+ " mapper = reducer_rand_test.fit(rand_data)\n",
+ " embedding_rand_test = reducer_rand_test.transform(rand_data)\n",
+ "\n",
+ " umap_df_rand_test = pd.DataFrame(embedding_rand_test, columns=('x', 'y'))\n",
+ " G = nx.from_scipy_sparse_matrix(mapper.graph_)\n",
+ " clustering = cylouvain.best_partition(G, resolution = res)\n",
+ " modularity = cylouvain.modularity(clustering, G)\n",
+ " clustering_solution = list(clustering.values())\n",
+ " rand_list.append(modularity)\n",
+ " n_clusts.append(len(set(clustering_solution)))\n",
+ " modularity_dict.update({str(res): rand_list})\n",
+ " n_clusts_dict.update({str(res): n_clusts})"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "o5Ge1CrX38I8"
+ },
+ "source": [
+ "### And plot both on the same axis\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 205
+ },
+ "id": "dE4TxUfY2YFN",
+ "outputId": "f8c39074-c65d-4305-8d4b-533e4b81bade"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAC8CAYAAAC3xHgIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO2deZhT1fn4P28yw2XYQTZBZRFEEWuxVnBXUNG61RatC3HXb4221tre1tZabW0fvS7160/T1l2DdUMrVrEiX7QqosiidVcURQFBZQZhBu7MJOf3x7mBTCbLTWYySWbO53nyJPfk3HPfCbxnfRdRSmEwGLoegVILYDAYSoNRfoOhi2KU32DoohjlNxi6KEb5DYYuilF+g6GLUlWshkMR7gKOAdZFw0xI870A/wt8D2gAzoyGWVoseQwGQ0uKOfLfAxyZ5fujgLHe63zgr0WUxWAwpFA05Y+GeQFYn6XK8cB90TAqGuYVoF8owvbFksdgMLSklGv+4cBnSdefe2UGg6EDKNqavz0JRTgfvTTAquI7d5xfYoEMhjS4tv2V5TiDSi2HX0qp/KuAHZOud/DKWhENcxtwG8A5t2GcEQzlSo9SC5APpVT+J4CLQhEeBCYBG6Jh1pRQHoOhS1HMo74HgEOAgaEInwO/B6oBomH+BsxBH/MtRx/1nVUsWQwGQ2uKpvzRMKfk+F4BFxbr+QaDITvGws9g6KIY5TcYuiidWvmb584ttQgGQ9lSEef8+RJbtozY/PmotWuJv/kmwSlTCE6cWGqxDIayotMpf2zZMpqfeYbq6dORUaNQK1bQNGsWgOkADIYkOt20PzZ/PtXTpxMYMwYJBgmMGUP19OnE5s8vtWgGQ1nR6UZ+tW4dMmpUizIZNQq1bl2JJDIYtuHa9lZXd8txJiSV/wR99B0DnrIcx86jzRogbjmOm48snW7kl8GDUStWtChTK1YggweXSCKDoQX3kOLq7tr2oWgv1z0tx9kduD5bA65tX+/a9j7e56PR3rO1rm0fm48gnU75g1Om0DRrFvHly1GxGPHly2maNYvglCmlFs1gwHKcdK7uFwDXJEZuy3FyTVNPA97yPl8BzACOA/6cjyydbtqf2NRrnj0btXYtMngwVdOmmc0+QzmzC3Cga9t/ArYAv7Ac57Us9XtYjtPg2vZ2wGjLcR4FcG17RD4P7XTKD7oDCE6ciOs4BKdONYpv6CiqXNtenHR9m+U4t/m5DxgATAa+Czzs2vZoy3EyebB+4Nr2acAY4FkA17YHApvzEjafypVG1YEHEn//faP8ho6i2XKcvQu473PgMU/ZF7m2HQcGAl9mqB9Gx79sBM7xyqYBeVm1dWrlD4wbR/Ozz6LicSTQ6bY3DJ2Hx4FDgedc294F6AZ8la6ia9tBYA9giuU4WxLlluPcD9yfz0M7tUbIgAFITQ1q9epSi2IwAODa9gPAQmCca9ufu7Z9DnAXMNq17beAB4EzMk35LceJATcmK36hdOqRH/ToH//gAwI77FBqUQwGLMfJ5Oo+I49m/uXa9rGW4/yrLbJ0CeVvnj8fzFGfofPQHZjl2vZCdBDcrbMEy3FO99tIp1d+GT0aFY2iNm9GampKLY7B0B68xbZz/oLp/MpfXY2MHEl8+XKCe+xRanEMhjZjOc5V7dFOUZU/FOFI9JFEELgjGuaalO93Au4F+nl1fh0NM6e95Qjsuqs+8jPKb+gkuLZ9OHAyMNhynGNd294b6GM5jm8PtqLt9ociBIFb0Wm5xgOnhCKMT6l2OfBwNMxE9B8SKYYsgV12If7++yhlon4bKh/PCeivwIfAQV7xZuDqfNop5lHfPsDyaJiPo2Ea0UcYx6fUUUAf73NfoChncjJoEAQCqLVri9G8wdDR/Aw4zHKca4C4V/YeMC6fRoqp/H7ScV0JzPBCe88BflIMQUREH/m9/34xmjcYOprebNOtxHS2Gm3x5xtfyh+KcEAoouPqhyIMCkUYlesen5wC3BMNswM6hn80FGktUyjC+aEIi0MRFsfirdrwReK832DoBLwA/Dql7KfAc/k0knPDLxTh98De6CnF3egeZiawf45b/aTjOgfPtzkaZmEoQne0TXMLl8b2SNcV2Hlnmh94AOW6iGUBsPBDmL0EVtfCsP5w/Hdg37GFtG4wdCg/QRv6nAf0dm37fWAjOkiIb/zs9p8ATASWAkTDrA5F6O3jvteAsd4sYRV6Q+/UlDorganAPaEIu6GNFzI5M7QJ6d4d2XFH4h99RHD8eBZ+CI+8CuceCrsMhQ++gDu8fjO1AzCdhKGcsBxnjWvb30V7AI5ALwEWWY6T17zYj/I3RsOoUESPuKEIPf00HA3THIpwEfAM+hjvrmiYt0MR/gAsjoZ5ArgUuD0U4RL02uVML5NPm8ikrImpf3D8eGYv0Yo/3tuFGD9cX9/3YkvFzqeTyPZsg6G9cG17tuU4xwOLvFei/DHLcX7gtx0/yv9wKMLfgX6hCOcBZwO3+2ncO7Ofk1J2RdLnd8i9fMiLdMp6+3z47GvYKTiOsW/cx/01sHq9/j6ZXYbq8uuehH49oG8PePkDOH9q7k4i07PNbMJQBA7NUH5IPo1kVf5QBAEeAnYFvkGv+6+IhnUAgXIk3Yh+3hS45RmYOGIou8UaOWC7r1j51UA++GJbPdDKOrgvHD4B6hpgQwOs35S9kxjQE/r3hAG94F9LizObMBgAXNv+g/exW9LnBKOBT/NpL6vye9P9OdEwe0D5Knwyq2vTK+smF86bKjR9PY493fdx9xnIHc+1VsATJ8G3R267d+FysnYS6+uhth4+/AK+/CZzR3HDU9DTgl7dYdFH8OPD/M0mDIYkEhvoAVpupiv0uv/KfBrzM+1fGorw3WiYbDHFyoZh/dMr67D++nNg3DjiS5aw7/56tXHfi9um3idOaq18x38HX50EwEfrMncUh+4O9Vt0J1RXn7mTWLsBhvRt+Z1ZIhgALMc5C8C17Zctx/G19M6GH+WfBJwWivApUA8IoKJhvtXWhxeD478Dt/2fXqenKitAYOxYmmfNQjU1se/Y6pxKlPg+VyeReHamjmKvkdvq/efd9J1Enx5w9T/BqoZv7aRf3zTA40vMEsHQggWubQ+xHGeta9u9gF+iLf2usxynwW8jfpR/WqESloJ9x8KHa+DWubBxS2tllR49kKFDdSz/XXbx3aYfRfPbUWTqJE7bHyaPgZVfw39XwpPL4NMv4ZLv+d9w9DtDMLOJiuYB4CRgLTrG/zh01N+/AyG/jeRU/miYT0MR9gQO9IpejIZ5I29xO5BBffR/5BkHpP8+Yeob8Kn8+eCno8jVSYwYqF/H7gWn/zXzEuHO52FYP9i+H3yxAeb+F86d4u+kwWw4VjQjLcd537VtAX6AdpzbDKzIfltL/Fj4XQycBzzmFc0MRbgtGub/5Slwh1FbD/2yWCMExo2j+eGHO06gNPidTWTawxjUR3cQa2rhzc/go7Vw8VGtZwh/m6f3GHpY0KObfn90kb9TCShshvDYIvjBPv5/C0PebHFtuzda6VdajvOVa9tVaCM53/iZ9p8DTIqGqQcIRbgWHYCwbJW/rkErRiZk+HDUpk2o2lqkf/+OE6wAsu0jJCthphlCXT18vQk+Ww+bXahvhHUbMs8m3lsNOw6Ant0LN3BatR4WfWyWEkXkH8B8tIPPLV7ZXrT3yI/e4IslXce8srIl18gvgQCBsWO1td+kSR0nWAH43UfIeMoxoPXy59cPZt5wfHChVt6abtAcg4umtZ4h3PMfmLADVFdBtyoIiFlKdCSW41zi2vYRQJPlOAlnnjhwST7t+FH+u4FXQxH+6V1/H7gzn4d0NHX12vAmG4Fx44i//TbBSZNonjuXqiOO6BjhCsDPEiHbDMFv3dP218+JK/jqG/jFP9LPEL6oA/sf0BiDpmYIBqA6CD/zuTFpaDuW48xNuV6cqW4m/Gz43RiK8DyQGD/OioZZlu+DOgql9MifU/l32UXn84vFiM2bV9bK74d8jiRz1Q2Itk3INpu45mR9rRQ0xeDc2zMsJWrb9++sdNKl6HZt+zrgWLQ//kfAWZbj1GVp40VI7wNjOc5B6crT4WfDbzLwdjSsvfpCEfqEIkyKhnnV70M6ki1N+r17dfZ60rs3st12qE/zsogsa/xuIvqt62c2IaKn/pk6ippquPpx+N6e2igqsUSYvUTvMQwb0OU2Ee9Br9PvSyp7FrjMcpxm17avBS4DfpWljTtSroei9+Zm5iOIn2n/X9GbCQk2pSkrGxKjvvjYlTDRfbLTYobgKWq+Bk6hA/Wy4PHF8MBC/d27q/wdSUL+m4jl3klYjvOCa9sjU8qSp/CvANNztHFvaplr24+il+ipNv8Z8bXhl+xmGw0TD0XKN+R3rs2+FgQCxBYsAKDxhhsITpliknqmUJCBU5qOYvIYfZJwy1y48Ig0ewMvtI89wj8X+1f+InQUhWbpTeZstDNdvqyC/Kxu/Sjxx6EIP0WP9qAzhH6cp2Adhp/NPoDYsmXEli6lOhRCRo1CrVhB06xZAKYDKJBsHYUI7DZcW12m2xtYVQvn3qaXa1a1fl9fDz9Jc9qQzR4B9GmGn6VEPh2FTwrN0guAa9u/BZrJkXDTte2zU4p6oI19XsnneX6U/8fAzegw2wDzgPPzeUhHUtugffFzEZs/n+rp0wmMGQOAjBlD9fTpNM+ebZS/iGTaGxjeH66crvdstjTq9ytmZbZHeHQR7DoMdh4Cyz4pzB4B/HcUxca17TPRG4FTMyXpTCLVhLceeBn4Sz7P9LPbvw4dgqsiqKuH7XrlrqfWrUNGtYxDKqNGodaty3CHoT3ItonY3Rvx8TrvbNaNzTE9bf/0K21vkM8ModzsEVzbPhKwgYP9OOZYjpMpmEdeZFR+L2rP89EwH3pBPe4EfogOGHBmYve/3Kit16NBLmTwYO3c4438gL4ePLiI0hnaYxMxuX5jc5ZjxvVwxSPQuwZ6d9fvi5bD/5QwloKXovsQYKBr258Dv0fv7lvAs65tA7xiOc6PU+4b7ad9y3F8L8mzjfwXo48lQIfY3hMdLWQiOgXXgelvKy1+1/zBKVNomjWL6unTW6z5q6ZVlBNjRVLIJuKq9TA8TUeR7ZhxaD844yDYuFnvNWzcogeHUtojZEjR7cdobjn6bD/bOZZCx8v0RTblb46G8U7NOQa4Lxrma2BeKILjp/Fcufq8OiehI5Ao4I1ouFWE37yoa/Cp/N66vnn2bJ3Jx7IIHnWUWe+XGYmOItvOfLYZQuos8IX3sgd7SUc5HB9ajtPuCXayNRgPRdjei6U/Fb3RlyBnrms/ufpCEcaipzz7R8Psjk5DVDAJ676+Pjb8QHcA3S69VH/ee2/YsKEtjzcUkWzKt+9Yrej3vQhn/V2/51pKvLNK7xu8swoiz0LPbtDgpm//n3kbzhYH17ZrXNuekOG7Ca5t5+XVl035rwAWA58AT0TDvA0QinAw/o76/OTqOw+4NRqmFrZuLhZMg6ttzHNZ96UjeMABxF59FdWYV8YjQ5mw79htJsfXnJx5WZGuozhpEuw4EH77sLZFKGNstCVfOs5CR/TxTcZpfzTMk6EII4DeCeX0WAz8yEfb6XL1pbqZ7AIQirAAvTS4Mhrm36kNhSKcj3e8GMzSXfk95kuHbLcdgVGjiC9eTHC//QprxFARJJYSoci2DuOg3eD1T3QEqAPGwQ/3gSrfq+cO40fA4Rm+uxFtJvxHv41lXUdEwzSnKD7RMPXRMJv8PiAHVcBY9O7nKegEHv3SyHFbNMze0TB7Z1X+fKz7kggedph+P+ggYi+9hIoXmBDQUHJOKNjERvseXH2SNji68lF4apm2AwD9vvDD9Pct/FB/70p1gUOPb4ZbjpOa8g4Arzw1EW5Wipml10+uvs/RS4qmaJgVwAfozqAg/O70p5Lw6JORI8GyiL/3XqEiGEpMPhtz6TqKvj3gkqNg5CB4+nU4/UC4+3/0+yOvtu4AEnYDpx8IVvGN3utd294x3Reube8E+A7eCf4s/ArFT66+x9Ej/t2hCAPRy4CCTYcLHfkTiIge/V94geD48blvMFQ0mToKEVi+FsJpfBBunatDpvWp0a8nkhK1ZNgvbE/mAH8mfZDOPwJP5dOYH5fex9DnkE9Hw/ieD/vM1fcMcEQowjvoCEG/9I4TC6KuAYb0KfRuTeBb36J5zhziq1YRGJ7XLMrQiciU/GXjZm1B+s1mnWPhqzSJWorI5cBC17bfQMfUXANsj06m2wfIa7PKz8gfQe8k3hyK8AhwdzSMLz9YH7n6FPBz79Vmauth3PZta0OCQYL77UfsxRcJnFwxVs2GdiZbIJOjvr2tLF2ilmJhOc4Xrm3vhU5weySwHfA18C/gRstx8jJV8mPbPw9t2NMXPUWfF4rwGTpZ58wkQ6CSU+iaP5XgpEk0XnstasMGpG/f3DcYOh1+w6Il19u5A+TyFPxytjnaFYyvNX8ownbADPRaYxna5fAA4AzyzAxaTNq65k8gPXoQmDiR2MKFVB15ZNsbNFQcfkyLU+v9plkb6FcKftb8/0RnBIkCx0bDrPG+eigUoUxsn3TQybo2nPOnEtx/f5oiEYJTpiDdurVPo4aKIp09QLZ67tKmvHbbS42fkf92b+2+lVAEKxrGjYZpw6lq+7Jpi44X162dzi8CgwYRGDGC+JIlBPfdt30aNRjKCD/n/FenKVvY3oK0lfaa8icTPPBAY/RjaJPhUHvh2vYrSZ9/3x5tZvPnH4q2GKoJRZjINlfCPmwNt1A+tNdmXzIyejRUVxN//32Cu+3Wvo0bKoZSe/R57OLadnfLcbagd/uvamuD2SbJ04Az0ZZ5NyaVbwR+09YHtzfFGPlFRI/+L75olN9QamYDH7i2/QlQ49r2C+kqtUvc/miYe4F7QxF+GA3zaL6SdjR1DdC/CPORwJ570vz008RXryb+1lsVn9zDUJlYjnOWa9sHACOB79IOWbOyTftnRMPMBEaGIq2NcKLhFrOBklNXr49j2hupqtJGPy+9RHzxYqP8hpJhOc5LwEuubXdLF7s/X7JN+xOTaB/hMEtPbQNMSOvy0A706EH8zTcBE9/fUHosx7nLte1DgNPR+3KrgGhS0k5fZJv2/92LxvNNNJxfSOBSUFfffmf8ycSWLSP2/PNUn3GGie9vKAtc2z4X7eBzB/AqsBPwgGvbv7Mc53a/7WQ9FY+GiYUinEKe8cBLQTE2/MDE9zeUJTZwuOU4byQKXNt+CHgUbXbvCz8mMQtCEW5BpxCqTxSWU+jueFx7WRVj5Dfx/Q3tiWvblwDnogPWvonOyLslz2a2A95JKXsfyGvXy4+Rz7eB3dEJAG/wXtfn85Bi880W6GEVJ+xSIr5/MmrFCmTQoPZ/mKFT49r2cOCnwN5eeu4ghSXEeQm40bXtHl67PYHr0Fl7fOPHq69dsoMUk7r64hzzQYb4/g8+iPTqhYrFkGD5BXozlDVV6HP6JrSxXCEhQ3+MnolvcG17PXrEfxntdZuXIDkJRTgaPfpvDQ0cDftPBVxsirXeh9bx/WXIEIJHHUX89ddpfuwxqqZPR/zkAzd0BbJm6bUcZ5Vr29cDK4HNwNyU9Ny+sBxnDXCQa9s7AMOA1ZbjfJ63sLkqhCL8Dd1DHYreXZwOLMr3QcWktgimvckEJ04kOHEizXPnbj3nVxMm0HTbbcTmzjVZfgwJsmbpdW27Pzp8/SigDnjEte0ZluPMLORhnsLnrfQJ/Kz594uGOR2ojYa5CtgXL+R2uVAMu/50JBv4iGVRfdZZxN94g9jLeS21DF2Xw4AVluN8aTlOEzoUV8nixPuZ9m/23htCEYahwwb5CpblJ12XV++HwCzgu9Fw/jECahtg5MB872o70qsX1eeeS2MkAr17E9xjj44XwlBJrAQmext1m9GZsEoWE8PPyP+kF0v/OmApOoPPA7lu8pOuy6vXG50U9FX/Yreko0b+dMiAAVSfdRbNjz1G/ONtgYeb5+a9lDN0cizHeRU9yC1FH/MFgNuy3pSCa9sB17anuLbd5ggzfnb7ExlAHg1FeBLoHg3jJ6nd1nRdAKHI1nRdqeeTfwSuJc9UQ8kUc8PPD4Hhw6k+9VSaZs4keOCBxJcuRa1dS/zNN40psKEFluP8Hp2Wu9D7465tz7Ycp3dbZcnm2PODLN8RDfNYjrZzpusKRdgL2DEa5qlQJLPy50rXVcqRP0Fg7FgC3/oWsZdeovqUU4wpsKGYvODa9mTLcV7JXTUz2Ub+Y7N8pyCn8mclFCGAjhNwZq660TC34U2PzrkNlfxdLA6bXJ1AodSojz6i+pRT8jIFTj5BMBh88inwtGvbs9ED7FadsBzniox3pZDNseesNomXO11Xb2AC8HwoAsBQ4IlQhOPy2fTb0AC9u2dP4NlRZDMFjn/5JTJw4FabgNiyZcTmzzfLA0Mh1KCzXYHWq4Lwc86ftifxYeSTNV2Xt2+wdY8+FOF54Bf57vaXw5Q/QcIUWLyRH7QpMD170nT77dDcTGDUKFR1NWrFCqpPPNEsDwx5YzlOWwdmwN9RX33S5+7AMcC7uW7yma6rzdQ2lHazL5m0psCzZlF17LEEJ05E1dYSX7GC5qeeynt5YDAk49r2rsCJwBDLcS5ybXscYFmO81+/bfjZ7b8h+ToU4Xq0QuckV7qulPJD/LSZSm0R7frzJZ0pcNW0aVvLpX9/gv370/zQQ8ZT0FAwrm2fiE6j9yh6Nn0Rehl9DdqQyBeFrJR70IZ1RntTVw99y2TkB90BdLv0UoKHHabf04zkmTwFGVCEOGSGzsgfgMMsx/kxOsEtwBvAnvk04mfN/ybbdhODwCDv4WVBbT2M6bgsqb7JtoOfdnnw8MOweTOxhQtNkhBDLgYDiem9SnpX6aunx8+a/5ikz83A2miY5nweUkyKFbW3mKRdHhx1FIGddqLp7rtR69YRPOYY4y5syMQSdN7M+5LKTiZPh7tsRj6JOejGlK/6eEY+6/N5ULEotXVfoaTzFASovvBCmmbOJH7PPVSfeipSs82AwdgEGDx+Csx1bfscoKdr28+gne3y+s+Rbc2/BO10sAT4EvgA+ND7vKQQiYtBOR31FUKqMktNDdVnn40MGEBTJIJav62Pjc2b19HiGcoQy3HeA3ZF+85cDtwN7GE5zof5tJNR+aNhRkXDjAbmobPzDoyG2Q69DCgLr5WmGDQ0Qu8ysO5rTyQYpPqEEwhOnkzjrbfS/OyzNN6gD10ab7iB2LJlJZbQUGosx2kAFgDPAy9ajrMp3zb8rPknR8Ocl7iIhnk6FMHJ90HFYEMD9K2BQCcNpBPcf3/Uhg3EFi7USwBjEGQAXNveCbgfmAzUAv29RJ4zLMf51G87fpR/dSjC5UAi2shpFBZ3rN2p1PV+PsTffZfqU09tbRD0+OOtlH+ryfC6dcjgwcZkuPNyL3rpfaTlOPWubfdCe8feC/7tZfwo/yloF8R/etcvkGegwGJR6et9P2TzF2i86SYCo0bp6/p6Yv/5TyvrQkg/QzAdRUXzHeAILxoQluNscm37V+hAO77xY+G3HrjYC7qhomHyXlsUi64w8mfyF5AhQ6g64QTiK1YQX7yY+IoVVJ9xhi+T4diyZTQ/84zvjsJQdryCjpexIKlsb2BhPo34MfLZA32eOMC7/go4IxrmrXweVAzKybS3WGT0F5g2jcCIEQRGjIBDDsH91a/SzxDWrsX94x+R/v23vmKvv071SScZ1+MKwrXtZMO6j4A5rm0/hXbp3RH4HvCPfNr0M+3/O/DzaJjnAEIRDkH71pcs8GCCugbYbVippSguufwFEmSbIVSfcw6qtla/6upgw4aMSwnV2Ih02xYhqhDXY9NRFIXUNLSJeBqDARe9LO9OHvhR/p4JxQeIhnk+FKEsJttdYdoPmQ2CWtTJMkOQfv2Qfv3AU/j4smXpXY9rami86ipk2DDteqwU8f/+17frsYlRUDzay403GT/K/3Eowu+AqHc9A/g4S/0Oo66h82/4JZPVXyB5huBt4qWbIUCWjuL44wnsvjtq5Uq9l/Dyy1Sfdlqr5UHTI4/ozqRXL6RXL+jeXScxMfsIHYYXAXgM0Cu53HIc33Hk/Sj/2cBVbJtmvOiVlZy6LjLy+yUxQ/BTDzJ3FDJmDIExY4jNm5d2eUBdHc1z5qA2bYKNG3Wm1Koqqk8/3cQo6ABc2z4duAVoZFtofdCOPTv5bcfPbn8t2pa4rGhs1q9eVqklqUz8dBQZ9xEGD6bbhRduK2tspPF3vzMxCnzi2nYQbTq/ynKcY3LVT4MD/NBynGfbIkc2x56skXaiYY5ry4PbSl099O0BJk1e8ci2j5CMdOuWOYRZt240P/EEwQMOQEy8ggQXo6Nh9Snw/ka0WW+byDby74s+RngAnVCjrNSstgH6dfJjvlLj96QBMncUwSOPhLo6Gm++mcDYsQQPOgj11Ve+DYw6mzGSl1zzaOBPwM8LbOZ36BTdV1mO81WhsmRT/qHA4WhrvlOBp4AHomHe9tt4rnRdoQg/B85Fxwn4Ejg7GsaXbXJXsO4rB/ycNCTqQeaOIjh1KrFFi2i6804IBn3lNijEGKkCjhlvAmx02K1C+QAdUCfs2naiTABlOY7vIBDZQnfHgH8D/w5FsNCdwPOhCFdFw9ySq+GkdF2HoxN2vBaK8EQ03CJjzzJg72iYhlCEC9BrmR/5EbyrHPOVC34UKltHId27U3XQQcRfe02fKqSeIESjxObPh6oq/aquRq1Zk/a0IZPVYhnYI2RN0e3a9jHAOstxlri2fUgbnhNFG949RMsNv7zIuuHnKf3RaMUfCdzMNhv/XORM15VsP4A2WZzhV/Bip+U2FE42hcrkq8CWLVRdcAE0NUEsBk1NNN1xR0arxcZbb0W2357A9tujNm0itnhxOdgjZE3RDewPHOfa9vfQBjl9XNueaTmO7//3HtsBV1iOk1fYrlSybfjdh06qMQe4qgBz3pzpulI4B3jab+N19bCj2T+qOLKdIASGDvVdt+rII1FffEF81Srib71F9YwZ6e0R+vfXNgl9+iCBQEn9GizHuQy4DMAb+X9RgOKDDt6RGsYrb7KN/DPQMfsvBn7qZS/DDJ4AAAxrSURBVNUBb20RDRe8U9mKUIQZaMeEgzN83ypXXznF6zf4x+8JQq66gZ13hp13Jgi4r72W2R7hySdRtbXQ0AB9+oDrpu0oKsweYR/gIte2fwusTf7CcpyD/DaSbc3f1gRYudJ1ARCKcBjwW+DgaBg3gyytcvWZDb/KJC9LRJ91s9ojXHSRvm5qgg0baLzuusx+DZs3t4iZWMyTBstxnqfw47rbvVeb8GPhVyhZ03UBhCJMRDsOHRkNk5c1iNnwq1z8WiL6retnNiHV1TBwYGZ7hB49aPzTn5CddiIwfjwoRWzBAl/Lg0Qngc5pUXQsx7m3PdopmvL7TNd1Hdo2+RFvWbHSj/HQ5kaIK+jRLVdNQ1egXfwajjuOwPjxxD/8kPg77+h9hHTmyikRlJL3EJqfeqpD/l7XtjOa11uOc5ffdoo58udM1xUN+08tlEydZ+BjrPsMCQrya0hnjzBhAsEJE3CXLMm4PHAvvxx690Z69UJ9/XWLMGsdRCjleiiwMzq4R3kof7Ew631DW/BjuJQ1PkI4rJ2aNm2i6W9/a9VJFBvLcQ5NLfNmA7vl004ZZLXPH7PeN7QHflKqxZcvR8VixJcv1+bKU6YgNTUEBg3S8RPT5F0sEfegj8t9U5kjfxfz4zd0PH73EZL3EDoK17ZTB+0e6KP5unzaqUzlrzdOPYbi4+ukIWUPoYNopnVSzlWwLb+GHypS+WvrYeSgUkthMGgSnYRr2w0d9MjUTYb6Qrz7KlP5jXWfoQuTT1aebFSk8td1gZDdBkMqrm0/R+vpfjLKcpypfturSOU3u/2GLsrMDOXD0aH28hoSK1L5AwI1xrrP0MWwHOfO5GvXtrdDewmeh/bt/0O6+zJRccqvFPTrlbuewdBZcW27D/BL4CLgSWAvy3E+yredylN+zHrf0DVxbbsG+BlwKdoj8ADLcXyH1Uul4pQfZdb7hi7LJ2irXAcd+nuIa9tDkitYjjPfb2MVp/wKY91n6LJsRqvABRm+V8Bov41VnvKbkd/QRbEcZ2R7tleRjj1mzW8wtJ2KU36lzLTfYGgPKk/5MdN+g6E9qDjlB+PRZzC0B0Xd8PORrstCxx7/DvA18KNomE9ytWtVt7+sBkNH4Np2C52wHOeaHLcUjaKN/Enpuo4CxgOnhCKMT6l2DlAbDTMG+AtwrZ+2f/0gLPywPaU1GIqPl5q7hU64tp2qEx1GMaf9W9N1RcM0wtZ0XckcDyTCEM8CpoYi2bMBd6uC0w+ER141HYCh4tgHWG45zseW42TSiQ6jmMqfLl3X8Ex1omGagQ3oPGRZGT8czj0UZi9pJ0kNho7Bj050GBVh5JOcruuZ6/el5yX/BcBthmtPaeio6Cn5UoUOt1TuGDnbiQN22KHHPG12m6BFlt5yo5jK7yddV6LO56EIVUBf9MZfC5LTdcmFryxWSmXLhFoWiIiRsx2pBDlFZHGOLL2+Uth1FCVN1wU8AZwBLASmA/Oj4ayRSgyGSuY1YKxr29l0osMo2prfW8Mn0nW9CzycSNcVimxNyXUnsF0ownLg58CviyWPwVBqLMdppRNtccltK6JUZQ20InK+Uqps11EJjJztSyXIWQkyJlNxym8wGNqHijTvNRgMbaeilF9EjhSR90VkuYiU3f6AiOwoIs+JyDsi8raIXFxqmbIhIkERWSYiT5ZalkyISD8RmSUi74nIuyKyb6llSoeIXOL9m78lIg+ISPdSy5SLilF+EWllGikiJTONzEAzcKlSajwwGbiwDGVM5mL0xlM587/Av5VSuwJ7UobyikgidPbeSqkJaLv9k0srVW4qRvnxTCOVUh8rpUpuGpkOpdQapdRS7/NG9H/UkllwZUNEdgCOBu4otSyZEJG+wEHoUyGUUo1KqbySUXYgVUCNiFSh4+evLrE8Oakk5S8r08hciMhIYCLwamklychNgA3ESy1IFkYBXwJ3e8uTO0Sk7KI5KKVWAdcDK4E1wAal1NzSSpWbSlL+ikFEegGPAj9TSn1TanlSEZFjgHVKqXL3jqgC9gL+qpSaCNRThrYgItIfPQsdBQwDeorIjNJKlZtKUv6yMo3MhIhUoxX/fqXUY6WWJwP7A8eJyCfo5dMUEcmUCqqUfA58rpRKzJ5moTuDcuMwYIVS6kulVBPwGLBfiWXKSSUp/2vAWBEZJSLd0BsqT5RYphaIiKDXp+8qpW4stTyZUEpdppTaQSk1Ev07zldKld1IpZT6AvhMRMZ5RVOBd0ooUiZWApNFpIf3f2AqZbgxmUpFePUBKKWaRSRhGhkE7lJKlcw0MgP7AyHgTRF53Sv7jVJqTgllqnR+AtzvdfgfA2eVWJ5WKKVeFZFZwFL0ic8yPEe0csZY+BkMXZRKmvYbDIZ2xCi/wdBFMcpvMHRRjPIbDF0Uo/wGQxfFKH8HIyIjRUR5NuCF3H+aiJS96aih/Onyyi8in4jIZhHZJCJfiMg9nnluyUnXUSil7ldKHVGEZx0iInHvd9jouU6X3Zl6KiJyZZlaJ5Y9XV75PY5VSvUCvo12xrmsxPKUitXe79AH+BVwe74uyYXOaEpFpcnbnhjlT8IzJ30G3QkAICKTReRlEakTkTdE5JCk784UkY+9kXKFiJzmlQdE5HIR+VRE1onIfZ57aiu8mcdhSdfJI9kL3nudNyLv6z3zpaT6+4nIayKywXvfL+m750XkjyKywJNxrogM9PE7KKXU40AtMF5Ejva86r4Rkc9E5MqkZyRmJ+eIyEpgvlf+iDeT2iAiL4jI7kn33CMiERF52vu7FojIUBG5SURqvcAdE5PqDxORR0XkS+93/qlXfiTwG+BHXjtveOV9ReROEVkjIqtE5GrR8SAS/2YLROQvIvI1sPVv6WoY5U9CtI/7UcBy73o48BRwNTAA+AXwqIgM8lxLbwaOUkr1RjtyJEx6z/RehwKjgV7ALQWIdJD33k8p1UsptTBF3gGefDejMx3dCDwlIslZj05Fm8QOBrp5f0NWvM7rBKAf8Cbam+507/po4AIR+X7KbQcDuwHTvOungbHec5cC96fUPwm4HBgIuOjw7Uu961ne34KIBIB/AW+gXbinAj8TkWlKqX8DfwYe8n6fPb2270Gb2Y5Bz+SOAM5NevYktKnwEOBPuX6PTotSqku/gE+ATcBGQAH/h1Y20FPfaEr9Z9C5BnoCdcAPgZqUOv8HhJOuxwFNaF+Kkd5zqpKef1hS3SuBmd7nFnW9sjOBl7zPIWBRyrMXAmd6n58HLk/6LoyOipPudzgE7dtfB6xHd2QnZ6h7E/CXFBlHZ/mN+3l1+nrX9wC3J33/E7QzVOJ6D6DO+zwJWJnS3mXA3am/l3c9BN2Z1CSVnQI8l/T7rcwka1d6ddn1TgrfV0rNE5GDgX+gR586YARwoogcm1S3Gv0fqV5EfoQeSe8UkQXoEF7voX26P02651O04g9pZ7lTn5N4VnKQky+SPjegZyGZWK2U2iG1UEQmAdcAE9CzBwt4JKXaZ0n1g+gR9URgENsChgxE52MEWJt07+Y01wk5RwDDRCQ5gk8QeDHD3zAC/W+0RjvYAXqGmxwI5rPUm7oiZtqfhFLqP+hR6Xqv6DP0yN8v6dVTKXWNV/8ZpdThwPbAe8Dt3n2r0f8JE+yEnoYm/wdPUI8O+5RgaLJIOUROfU7iWe0d5+AfaPfpHZVSfYG/QatsysmynooObnEYOgXbSK88awbmDHyG9pVP/jforZT6XprnJuq7wMCk+n2UUrsn1THebBjlT8dNwOEisicwEzhWRKaJjnTb3TsS20FEhojI8d7a30UvHRIj3APAJaJjD/Ri27o0XaLJ14GTRaRaRPZGpy1L8KXX5ugMss4BdhGRU0WkypuJjAfaOxpvb2C9UmqLiOxD7hRTvdG/ydfoju3PbXj2ImCjiPxKRGq8f4cJIvJd7/u1wEhvbwCl1BpgLnCDiPTx9i929mZ1hiSM8qeglPoSuA+4Qin1GXoE+w1aET8Dfon+3QLoFGOr0Wvkg4ELvGbuAqLo3foVwBb0ujYdvwN2Ru+sX4UeZROyNKCnzwu804bJKbJ+DRwDXIpWNBs4Rin1VeG/QFrCwB9EZCNwBfBwjvr3oZcfq9DBN14p9MFKqRj6b/w2+rf8Ch10NHF6klh+fC0iS73Pp6OXJ++gf9dZ6NmZIQnjz28wdFHMyG8wdFGM8hsMXRSj/AZDF8Uov8HQRTHKbzB0UYzyGwxdFKP8BkMXxSi/wdBFMcpvMHRR/j9fw8zvDsni8AAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "resolution_list = np.linspace(0,10,21)\n",
+ "\n",
+ "if 'n_clusts_dict' not in list(locals().keys()):\n",
+ " n_clusts_dict = pkl.load(open('WaveMAP_Paper/data/n_clusts_dict.pkl','rb'))\n",
+ "\n",
+ "if 'modularity_dict' not in list(locals().keys()):\n",
+ " modularity_dict = pkl.load(open('WaveMAP_Paper/data/modularity_dict.pkl','rb'))\n",
+ "\n",
+ "avg_n_clusts = []\n",
+ "for k in list(n_clusts_dict.keys()):\n",
+ " avg_n_clusts.append(np.mean(n_clusts_dict[k]))\n",
+ " \n",
+ "std_n_clusts = []\n",
+ "for k in list(n_clusts_dict.keys()):\n",
+ " std_n_clusts.append(np.std(n_clusts_dict[k]))\n",
+ " \n",
+ "std_modularity = []\n",
+ "for k in list(modularity_dict.keys()):\n",
+ " std_modularity.append(np.std(modularity_dict[k]))\n",
+ " \n",
+ "avg_modularity = []\n",
+ "for k in list(modularity_dict.keys()):\n",
+ " avg_modularity.append(np.mean(modularity_dict[k]))\n",
+ "\n",
+ "f, ax1 = plt.subplots(figsize=[3,2.5])\n",
+ "\n",
+ "ax1.errorbar(resolution_list,avg_modularity,yerr=std_modularity,\n",
+ " c = '#5c95ff', marker='o', fillstyle='full', markerfacecolor='w', \n",
+ " linewidth=1, markeredgewidth=1)\n",
+ "ax1.set_ylabel('Modularity Score')\n",
+ "ax1.set_xlabel('Resolution Parameter',fontsize=12)\n",
+ "ax1.set_xlim([0,8])\n",
+ "ax1.set_xticks([0,2,4,6,8])\n",
+ "ax1.yaxis.label.set_color('#5c95ff')\n",
+ "ax1.tick_params(axis='y',colors='#5c95ff')\n",
+ "ax1.set_ylim(0,1.0)\n",
+ "ax1.set_yticks([0,0.2,0.4,0.6,0.8,1.0])\n",
+ "# ax1.set_yticklabels([0.0,'',0.2,'',0.4,'',0.6,'',0.8,'',1.0],fontsize=12)\n",
+ "ax1.spines['top'].set_visible(False)\n",
+ "ax1.spines['right'].set_color('#f87575')\n",
+ "ax1.spines['left'].set_color('#5c95ff')\n",
+ "\n",
+ "ax2 = ax1.twinx()\n",
+ "ax2.errorbar(resolution_list[1:],avg_n_clusts[1:],yerr=std_n_clusts[1:],\n",
+ " c = '#f87575', marker='o', fillstyle='full', markerfacecolor='w', linewidth=1, markeredgewidth=1)\n",
+ "ax2.set_ylabel('Number of Clusters',fontsize=12,c='#f87575')\n",
+ "# ax2.spines['left'].set_color('b')\n",
+ "ax2.tick_params(axis='y',colors='#f87575')\n",
+ "ax2.set_ylim([0,18])\n",
+ "ax2.set_yticks([0,4,8,12,16]);\n",
+ "ax2.spines['top'].set_visible(False)\n",
+ "ax2.spines['right'].set_color('#f87575')\n",
+ "ax2.spines['left'].set_color('#5c95ff')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "8lx6iIIZ1NPA"
+ },
+ "source": [
+ "## Figure 2C: Classifier performance on clustering"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Kl0JCjku1VR-"
+ },
+ "source": [
+ "### First we create a 70/30 test-train split of the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {
+ "id": "91XymkZ9smsf"
+ },
+ "outputs": [],
+ "source": [
+ "testSize = 0.3;\n",
+ "\n",
+ "UMAP_X = np.stack(umap_df['waveform'].to_numpy().tolist(), axis=0)\n",
+ "UMAP_y = umap_df['color'].to_numpy()\n",
+ "\n",
+ "unclassified_ixs = [ix for ix,clust in enumerate(UMAP_y) if clust == -1]\n",
+ "\n",
+ "UMAP_X = np.delete(UMAP_X,unclassified_ixs,axis=0)\n",
+ "UMAP_y = np.delete(UMAP_y,unclassified_ixs,axis=0)\n",
+ "\n",
+ "UMAP_X_train, UMAP_X_test, UMAP_y_train, UMAP_y_test = train_test_split(UMAP_X, UMAP_y, test_size=testSize, random_state=RAND_STATE)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "zmkb1S7U1cdU"
+ },
+ "source": [
+ "### Next we use XGBoost to train a hyperparameter optimized random forest classifier on the WaveMAP clusters"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "21efwyEus9jt",
+ "outputId": "086f7a98-ec64-4133-9f1b-e03e3dfac307"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 2 concurrent workers.\n",
+ "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 2.3s\n",
+ "[Parallel(n_jobs=-1)]: Done 3 out of 5 | elapsed: 2.8s remaining: 1.9s\n",
+ "[Parallel(n_jobs=-1)]: Done 5 out of 5 | elapsed: 3.2s remaining: 0.0s\n",
+ "[Parallel(n_jobs=-1)]: Done 5 out of 5 | elapsed: 3.2s finished\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "array([[22, 0, 0, 0, 0, 1, 0, 0],\n",
+ " [ 0, 26, 3, 0, 1, 0, 0, 0],\n",
+ " [ 0, 0, 28, 1, 0, 0, 0, 0],\n",
+ " [ 0, 0, 1, 18, 0, 0, 0, 0],\n",
+ " [ 0, 0, 1, 0, 28, 0, 0, 0],\n",
+ " [ 1, 0, 0, 0, 2, 24, 1, 0],\n",
+ " [ 0, 0, 1, 2, 0, 0, 7, 0],\n",
+ " [ 0, 0, 0, 0, 1, 0, 0, 19]])"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "numCV = 5\n",
+ "\n",
+ "UMAP_model = xgb.XGBClassifier()\n",
+ "UMAP_param_dist = {\"max_depth\": [4],\n",
+ " \"min_child_weight\" : [2.5],\n",
+ " \"n_estimators\": [100],\n",
+ " \"learning_rate\": [0.3],\n",
+ " \"seed\": [RAND_STATE]}\n",
+ "UMAP_grid_search = GridSearchCV(UMAP_model, param_grid=UMAP_param_dist, \n",
+ " cv = numCV, \n",
+ " verbose=10, n_jobs=-1)\n",
+ "UMAP_grid_search.fit(UMAP_X_train, UMAP_y_train)\n",
+ "\n",
+ "confusion_matrix(UMAP_y_test,UMAP_grid_search.predict(UMAP_X_test))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "V2le2oqP1rS7"
+ },
+ "source": [
+ "### Lastly we plot a confusion matrix for the test accuracy of the classifier"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 259
+ },
+ "id": "Wb7rtQkztL9Q",
+ "outputId": "fc9fda81-b9a8-4e71-b201-65c868ec8704"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "findfont: Font family ['Arial'] not found. Falling back to DejaVu Sans.\n",
+ "findfont: Font family ['Arial'] not found. Falling back to DejaVu Sans.\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "confusion_mat_counts = confusion_matrix(UMAP_y_test,UMAP_grid_search.predict(UMAP_X_test))\n",
+ "\n",
+ "conf_mat_row_list = []\n",
+ "\n",
+ "for row in confusion_mat_counts:\n",
+ " row_sum = np.sum(row)\n",
+ " \n",
+ " row_percent = []\n",
+ " \n",
+ " for val in row:\n",
+ " row_percent.append(val/row_sum)\n",
+ " \n",
+ " conf_mat_row_list.append(row_percent)\n",
+ "\n",
+ "conf_mat = np.array(conf_mat_row_list)\n",
+ "\n",
+ "colormap = mpl.cm.YlGnBu\n",
+ "colormap.set_under('white')\n",
+ "\n",
+ "eps = np.spacing(0.0)\n",
+ "f, arr = plt.subplots(1,figsize=[4,3])\n",
+ "mappable = arr.imshow(conf_mat,cmap=colormap,vmin=eps,vmax=1.)\n",
+ "color_bar = f.colorbar(mappable, ax=arr, extend='min')\n",
+ "color_bar.set_label('P (Predicted | True)',fontsize=12,labelpad=15,fontname=\"Arial\")\n",
+ "color_bar.ax.tick_params(size=3,labelsize=12)\n",
+ "\n",
+ "#Specify label behavior of the main diagonal\n",
+ "for i in range(0,N_CLUST):\n",
+ " if int(conf_mat[i,i]*100) == 100:\n",
+ " arr.text(i-0.38,i+0.17,int(round(conf_mat[i,i]*100)),fontsize=10,c='white',fontname=\"Arial\")\n",
+ " else:\n",
+ " arr.text(i-0.34,i+0.16,int(round(conf_mat[i,i]*100)),fontsize=10,c='white',fontname=\"Arial\")\n",
+ " \n",
+ "#Specify label behavior of the off-diagonals\n",
+ "for i in range(0,N_CLUST):\n",
+ " for j in range(0,N_CLUST):\n",
+ " if conf_mat[i,j] < 0.1 and conf_mat[i,j] != 0:\n",
+ " arr.text(j-0.2,i+0.15,int(round(conf_mat[i,j]*100)),fontsize=10,c='k',fontname=\"Arial\")\n",
+ " elif conf_mat[i,j] >= 0.1 and conf_mat[i,j] < 0.5 and conf_mat[i,j] != 0:\n",
+ " arr.text(j-0.4, i+0.15,int(round(conf_mat[i,j]*100)),fontsize=10,c='k',fontname=\"Arial\")\n",
+ "\n",
+ "arr.set_xticks(range(0,N_CLUST))\n",
+ "arr.set_xticklabels(range(1,N_CLUST+1),fontsize=12);\n",
+ "arr.set_yticks(range(0,N_CLUST))\n",
+ "arr.set_yticklabels(range(1,N_CLUST+1),fontsize=12);\n",
+ "arr.set_xlabel('Predicted Class',fontsize=12);\n",
+ "arr.set_ylabel('True Class',fontsize=12);\n",
+ "plt.tight_layout()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "smNYVaGpCfJo"
+ },
+ "source": [
+ "# Figure 3: Evaluates the solutions obtained from GMM clustering and shows that it is much poorer than the ones obtained by WAVEMAP\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4KjFpBbooqNr"
+ },
+ "source": [
+ "## Figure 3B: GMM clustering in a 3-D feature space"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "1_LxFk8-pSHP"
+ },
+ "source": [
+ "### We first set up a pandas dataframe with the specified feature values"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "id": "yrOHmzfUgDo-"
+ },
+ "outputs": [],
+ "source": [
+ "UMAP_and_GMM = pd.concat([umap_df,pd.DataFrame(gmm_feat_data_nonan,columns=['troughToPeak','prePostHyper','FWHM1'])],axis=1)\n",
+ "UMAP_and_GMM['dbscan_hex'] = cluster_colors\n",
+ "UMAP_and_GMM['gmm_labels'] = GMM_class_labels\n",
+ "\n",
+ "UMAP_and_GMM['troughToPeak_abs'] = UMAP_and_GMM['troughToPeak'].divide(SAMP_RATE_TO_TIME)\n",
+ "UMAP_and_GMM['FWHM1_abs'] = UMAP_and_GMM['FWHM1'].divide(SAMP_RATE_TO_TIME)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "MT5A7R4VpePj"
+ },
+ "source": [
+ "### and then plot the points in this space by cluster identity (clustering done in MATLAB)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 211
+ },
+ "id": "h8U6KoclndYf",
+ "outputId": "78c908b1-5219-457f-a485-12b2ff57e758"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(0.0, 0.6)"
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fig = plt.figure(figsize=[3.8,3])\n",
+ "ax = fig.add_subplot(111, projection='3d')\n",
+ "\n",
+ "for i in [int(x) for x in np.unique(UMAP_and_GMM['gmm_labels'])]:\n",
+ " to_plot_df = UMAP_and_GMM[UMAP_and_GMM['gmm_labels'] == i]\n",
+ " x = to_plot_df['troughToPeak_abs']\n",
+ " y = to_plot_df['prePostHyper']\n",
+ " z = to_plot_df['FWHM1_abs']\n",
+ " ax.scatter(x,y,z,c=GMM_PAL[i-1],marker='o',alpha=0.75,s=20,linewidth=0.75,edgecolor='w',depthshade=True)\n",
+ " \n",
+ " ax.plot(x, z, '.', c=[0.825,0.825,0.825], alpha=0.4, zdir='y', zs=1.6)\n",
+ " ax.plot(y, z, '.', c=[0.825,0.825,0.825], alpha=0.4, zdir='x', zs=1.4)\n",
+ " ax.plot(x, y, '.', c=[0.825,0.825,0.825], alpha=0.4, zdir='z', zs=0.)\n",
+ "\n",
+ "ax.tick_params(pad=-1)\n",
+ "\n",
+ "ax.set_xlabel('Trough to peak ($\\mu$s)',fontsize=12,labelpad=5)\n",
+ "ax.set_ylabel('Peak ratio',fontsize=12,labelpad=5)\n",
+ "ax.set_zlabel('AP width ($\\mu$s)',fontsize=12,labelpad=0)\n",
+ "ax.view_init(elev=20, azim=220)\n",
+ "\n",
+ "ax.set_xticks([0,0.7,1.4])\n",
+ "ax.set_xticklabels(['',0.7,1.4],fontsize=12)\n",
+ "ax.set_yticks([0,0.5,1,1.5])\n",
+ "ax.set_yticklabels([0,0.5,1.0,1.5],fontsize=12)\n",
+ "ax.set_zticks([0,0.3,0.6])\n",
+ "ax.set_zticklabels([0,0.3,0.6],fontsize=12)\n",
+ "\n",
+ "ax.set_xlim([0,1.4])\n",
+ "ax.set_ylim([0,1.6])\n",
+ "ax.set_zlim([0.,0.6])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ZuyPbtAmplYJ"
+ },
+ "source": [
+ "## Figure 3C: Optimal GMM cluster number"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Ff6Ck19grZeI"
+ },
+ "source": [
+ "### We use Bayesian information criterion to calculate the 'elbow' in a BIC vs. cluster number"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 181
+ },
+ "id": "zQnMYPFdpl3s",
+ "outputId": "62e8ed64-97b8-48ff-b799-47ac9de69f58"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "f, arr = plt.subplots()\n",
+ "f.set_size_inches(3., 2.)\n",
+ "\n",
+ "arr.plot(BIC_list,c='k',\n",
+ " marker='o',fillstyle='full',markerfacecolor='w',linewidth=1,markeredgewidth=1)\n",
+ "\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.set_xlabel('# of Clusters', fontsize=12)\n",
+ "arr.set_xticks([0,2,4,6,8,9])\n",
+ "arr.set_xticklabels([1,3,5,7,9,''],fontsize=12)\n",
+ "arr.set_ylabel('BIC', fontsize=12)\n",
+ "arr.set_yticks([12500,13000,13500,14000,14500])\n",
+ "arr.set_yticklabels(['1.25','1.3','1.35','1.4','1.45'],fontsize=12)\n",
+ "arr.spines['left'].set_bounds(12500,14500)\n",
+ "arr.spines['bottom'].set_bounds(0,9)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "w6guLtZu3hEm"
+ },
+ "source": [
+ "## Figure 3D: Classifier trained on GMM classes"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "PrXIt6zT-4Uf"
+ },
+ "source": [
+ "### Now we train a random forest classifier on the GMM classes"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "id": "qU-00XSv3hoY"
+ },
+ "outputs": [],
+ "source": [
+ "X = np.stack(UMAP_and_GMM['waveform'].to_numpy().tolist(), axis=0)\n",
+ "y = UMAP_and_GMM['gmm_labels'].to_numpy()\n",
+ "\n",
+ "unclassified_ixs = [ix for ix,clust in enumerate(y) if clust == -1]\n",
+ "\n",
+ "X = np.delete(X,unclassified_ixs,axis=0)\n",
+ "y = np.delete(y,unclassified_ixs,axis=0)\n",
+ "\n",
+ "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=RAND_STATE)\n",
+ "\n",
+ "data_dmatrix = xgb.DMatrix(data=X,label=y)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "0eUK4fub3jDL"
+ },
+ "source": [
+ "### and show a confusion matrix of the five-fold cross-validated test accuracy"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "TC4VHCk_3jlq",
+ "outputId": "746a1345-4365-493c-dd0b-3a4cd94da793"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 2 concurrent workers.\n",
+ "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 1.2s\n",
+ "[Parallel(n_jobs=-1)]: Done 3 out of 5 | elapsed: 2.5s remaining: 1.6s\n",
+ "[Parallel(n_jobs=-1)]: Done 5 out of 5 | elapsed: 3.3s remaining: 0.0s\n",
+ "[Parallel(n_jobs=-1)]: Done 5 out of 5 | elapsed: 3.3s finished\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "array([[65, 4, 1, 0],\n",
+ " [10, 57, 0, 1],\n",
+ " [ 5, 0, 28, 1],\n",
+ " [ 0, 2, 5, 9]])"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "model = xgb.XGBClassifier()\n",
+ "param_dist = {\"max_depth\": [10],\n",
+ " \"min_child_weight\" : [2.5],\n",
+ " \"n_estimators\": [110],\n",
+ " \"learning_rate\": [0.05],\n",
+ " \"seed\": [RAND_STATE]}\n",
+ "grid_search = GridSearchCV(model, param_grid=param_dist, \n",
+ " cv = 5, \n",
+ " verbose=10, n_jobs=-1)\n",
+ "grid_search.fit(X_train, y_train)\n",
+ "\n",
+ "confusion_matrix(y_test,grid_search.predict(X_test))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 225
+ },
+ "id": "9RfN6ebs_Kpy",
+ "outputId": "d21ca253-929a-4ac7-cc42-36d04dec6117"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "confusion_mat_counts = confusion_matrix(y_test,grid_search.predict(X_test))\n",
+ "\n",
+ "conf_mat_row_list = []\n",
+ "\n",
+ "for row in confusion_mat_counts:\n",
+ " row_sum = np.sum(row)\n",
+ " row_percent = []\n",
+ " \n",
+ " for val in row:\n",
+ " row_percent.append(val/row_sum)\n",
+ " \n",
+ " conf_mat_row_list.append(row_percent)\n",
+ "\n",
+ "conf_mat = np.array(conf_mat_row_list)\n",
+ "colormap = mpl.cm.YlGnBu\n",
+ "colormap.set_under('white')\n",
+ "\n",
+ "f, arr = plt.subplots()\n",
+ "f.set_size_inches(3, 3)\n",
+ "plt.tight_layout()\n",
+ "mappable = arr.imshow(conf_mat,cmap=colormap,vmin=0.,vmax=1.)\n",
+ "color_bar = f.colorbar(mappable, ax=arr)\n",
+ "color_bar.set_label('P (Predicted | True)',fontsize=12,labelpad=15)\n",
+ "color_bar.ax.tick_params(size=3,labelsize=12)\n",
+ "arr.set_xticks([0,1,2,3])\n",
+ "arr.set_xticklabels([1,2,3,4],fontsize=12);\n",
+ "arr.set_yticks([0,1,2,3])\n",
+ "arr.set_yticklabels([1,2,3,4],fontsize=12);\n",
+ "arr.set_xlabel('Predicted Class',fontsize=12)\n",
+ "arr.set_ylabel('True Class',fontsize=12)\n",
+ "\n",
+ "for i in range(0,4):\n",
+ " if int(conf_mat[i,i]*100) == 100:\n",
+ " arr.text(i-0.35,i+0.15,int(conf_mat[i,i]*100),fontsize=12,c='white')\n",
+ " else:\n",
+ " arr.text(i-0.25,i+0.15,int(conf_mat[i,i]*100),fontsize=12,c='white')\n",
+ " \n",
+ "for i in range(0,4):\n",
+ " for j in range(0,4):\n",
+ " if conf_mat[i,j] < 0.1 and conf_mat[i,j] != 0:\n",
+ " arr.text(j-0.15,i+0.15,int(conf_mat[i,j]*100),fontsize=12,c='k')\n",
+ " elif conf_mat[i,j] >= 0.1 and conf_mat[i,j] <= 0.5:\n",
+ " arr.text(j-0.2,i+0.15,int(conf_mat[i,j]*100),fontsize=12,c='k')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "kzkrWPTjmVio"
+ },
+ "source": [
+ "## Figure 3E: GMM labels in UMAP space"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "-FuCclNKpJHH"
+ },
+ "source": [
+ "### We take the GMM cluster labels as shown previously and display these in UMAP space"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 297
+ },
+ "id": "tYd7v_4xCfZ3",
+ "outputId": "ed4d1d03-b430-450f-af1b-94d418428621"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydeViU5frHPzPMsA6L7CCbKIoiZhqioUJaaqBp5pLb0eqUlkdPaVZHc0lazOx30qwsW1yOlXYsccm0U4pa5JqpKYqpLAIurDNss/7+QN4YmAE0QcTnc11cXPO8y3PPOzPv/T73cz/3V2YymRAIBAKBoLkhv9UGCAQCgUBgCeGgBAKBQNAsEQ5KIBAIBM0S4aAEAoFA0CwRDkogEAgEzRJFPdtFip9AIBAIGhuZpUYxghIIBAJBs0Q4KIFAIBA0S4SDEggEAkGzRDgogUAgEDRLhIMSCAQCQbOkviw+qxQXF3P58mV0Ot3NtEcgEFwHSqUSb29vXFxcbrUpAsFN54YcVHFxMZcuXaJ169Y4ODggk1nMEBQIBI2IyWSirKyMixcvAggnJWhx3FCI7/Lly7Ru3RpHR0fhnASCW4RMJsPR0ZHWrVtz+fLlW22OQHDTuSEHpdPpcHBwuNm2CASCG8DBwUGE2gUtkhtOkhAjJ4GgeSB+iwJLaIylpFacR2MsvdWm3DA3nCQhEAgEguaHxljKDyUHWFO0jd3lhwlXBrPIazp9HO++1aZdNyLNvAWxbt06BgwYIL2WyWScPXvW4r4qlYpz5841ih0nT57knnvu4WapNb/77ru8+OKLN+VcAkFLRGMs5UT5Wb4q/p7+mU/z+KWFnNNf5H7HaFJ16bx05d3bciTVIh1USEgI3t7elJSUSG0ff/wxcXFxt86oBlJYWMjjjz+Or68vzs7OtG/fnkWLFjXo2HHjxrFz584G7avRaAgNDf0rplpl7ty5PP/881LoqSGfR1JSEl27dsXFxQVPT0/69evH+fPnAXjyySdZt26dSAQQCCywt/RXnr/8b+ZceZ/X8z/jrC4TgAx9Lme06YQqW5Oqu0CW/vb7/TS5gzIZjRhKSsz+NwYGg4GlS5felHPp9Xqz1yaTCWMj2f3cc8+h0Wg4deoURUVFbN68mXbt2jVKX41BTk4Ou3btYtiwYWbtdX0eZ8+e5W9/+xtvv/02RUVFnD9/nqlTp2JjYwOAvb09Dz74IGvWrGl0+wWC2wmNsZRl+V9woPwkyCudUnUy9Ln4K7xorwwiQOF9i6y8cZrUQZmMRgx5eWRNnkxqRARZkydjyMtrFCc1a9YslixZQmFhocXt//znPwkMDMTFxYXu3buzd+9eaduCBQsYMWIE48ePx8XFhVWrVhEXF8ecOXOIiYnB0dGRc+fO8fPPPxMVFYWrqytRUVH8/PPPAOzatYvIyEjpfA888ABRUVHS6z59+rBp0yaLdh08eJCxY8fSqlUr5HI54eHhjBgxQtouk8lYtmwZoaGheHp6MmvWLMlZrlq1it69e1s87759+wgMDGT37t3SearCf5MmTWLq1KkkJCTg7OxMdHQ0f/zxh3Tszp076dChA66urjzzzDPExsby8ccfW+zn+++/p1u3btjb25u11/V5HD16lDZt2tC/f39kMhnOzs488sgjBAUFSfvExcWxbds2i30KBHcqWbpLaGV60vU5yEwwxKkPocrW0vY2itaEK0J41fMZVHLHW2jpjdGkDspYVsbF556jdP9+0Osp3b+fi889h7Gs7Kb3dc899xAXF8eSJUssbo+KiuLo0aPk5+czduxYRo4cSXl5ubQ9KSmJESNGUFhYyLhx4wBYu3YtH330EWq1GmdnZxISEpg+fTp5eXnMmDGDhIQE8vLy6NmzJ2lpaVy9ehWdTsexY8fIzs5GrVZTVlbGoUOH6NOnj0W7evbsyZw5c/jss89IS0uzuM8333zDoUOHOHLkCElJSXz66ad1XovvvvuOMWPGsHHjRqthzi+//JL58+dTUFBAu3btmDNnDgBXr15lxIgRvPHGG+Tl5dGhQwfJEVvi+PHjdOjQoVZ7XZ9Ht27dSE1N5bnnnmPXrl1oNJpa+3Ts2JHffvutzvcpENxpBCh98JN7MsN1LBF2bSk0qDGYjNzvGE2Iwp9u9uEklx8h2qHzrTb1hmhSByV3cKD08GGzttLDh5E30pqqhQsX8u6773LlypVa28aPH4+HhwcKhYKZM2dSUVHB6dOnpe29evVi2LBhyOVyac3XpEmTiIiIQKFQsHPnTsLCwpgwYQIKhYIxY8YQHh7Oli1bcHBwICoqij179nD48GHuuusuYmJi+Omnn/jll18ICwvDw8PDos3vvvsu48aNY/ny5XTq1Il27dqxfft2s31efPFF3N3dCQoK4tlnn+WLL76weg2++uorJk+ezPbt2+nRo4fV/R5++GF69OiBQqFg3LhxHD16FIBvv/2WiIgIhg8fjkKhYPr06fj6+lo9T2FhIc7Ozha3Wfs8QkND2b17NxcvXmTUqFF4enoyadIkM0fl7OxMUVGR1X4FgjsRldyRu+zC2FiyixVFG8nQX+J+xx6c114k3vFeNmp+IE2XcVvOP8EtGEE5du9u1ubYvXujjKAAOnfuzODBgy0mGSxZsoSOHTvi6uqKm5sbRUVFXL16VdoeGBhY65jqbdnZ2QQHB5ttDw4OlsrOxMbGsnv3bvbs2UNsbCxxcXEkJyeTnJxMbGwsUJl1p1KpUKlUPPjgg0DlosvZs2dz+PBh8vLyGDVqFCNHjiQ/P9+iHcHBwWRnZ1u9Bu+88w6jRo2ic+e6n6CqOx1HR0fJOWRnZ5v1J5PJCAgIsHqeVq1aoVarLW6r6/Po2bMnGzZs4MqVK+zdu5c9e/bw2muvSdvVajWurq51vgeB4E7jsj6flcWbSNfnAJCuz+F/pQfwV3hyTFcZwr9d55/gFoygWv/73zhGR4NCgWN0NK3//e9GG0EBvPLKK6xcuVJyHAB79+5l8eLFbNiwgYKCAgoLC3F1dTVLi7a0+LF6m7+/P+np6WbbMzIyaN26Mv5b00HFxsbWclDjxo1Do9Gg0WhqjZKgsrba7NmzKSkpkTLaADIzM8369Pf3t/r+v/rqKzZt2nTDCSN+fn5kZWVJr00mk9nrmnTp0oUzZ85Y3W7p86hJVFQUw4cP58SJE1LbqVOnuOuuu67TeoGgZXOq4pzknKpI1+fQ2a4d2forhCj8btv5J2hiByWTy7Hx8CDgww8J//13Aj78EBsPD2TyxjOjXbt2jB49mmXLlkltarUahUKBl5cXer2ehQsXUlxcfF3njY+P58yZM3z++efo9XrWr1/PyZMnGTx4MAD33nsvp0+f5sCBA/To0YOIiAjS09PZv38/ffv2tXrexMREDh48iFarpby8nKVLl+Lm5mY2r/PWW29RUFBAZmYmS5cuZfTo0VbP5+/vzw8//MDSpUv54IMPrus9AiQkJHD8+HE2bdqEXq/nvffeIzc31+r+DzzwAEeOHDGbz6uOpc9j3759rFy5UkojT01NZfPmzfTs2VPaJzk5WRplCgSCStooA2ijaG3WFqzww1Fmz922HXjH63n6O1kP7Td3mjzNXCaXY+PkZPa/sZk3b57ZGpyBAwcyaNAg2rdvT3BwMPb29hZDenXh4eHB1q1befvtt/Hw8GDx4sVs3boVT09PAJycnOjWrRsRERHY2toClfNawcHBeHtbH27LZDIee+wxPD098ff35/vvv2fbtm2oVCppn6FDh9K9e3e6du1KQkICTzzxRJ22BgUF8cMPP7Bo0SKr2XfW8PT05KuvvuKFF17Aw8NDWoRrZ2dncX8fHx/69etHUlKS1XPW/Dzc3NzYvHkzkZGRqFQqBg0axMMPP8wLL7wAQHl5Od9++y0TJ068LtsFgpbM3tJfeTTnX7S1DSBY4QdUOqdnW41luEs//s9nBn2cbr/qEdWR1bPa3+LGU6dO0bFjx8axSFAnMpmMtLS0W7Y2ymg0EhAQwLp167jvvvss7nPy5EkmTpzIgQMHbkqduHfffZfMzEwWL178l8/VUhG/yTsLjbGUfhlT+ENfGW4PVbbmLtsw5nk8RZCt9SSmZozFG4WoxSeolx07dhAdHY2DgwNvvfUWJpPJLPxWk06dOnHw4MGb1v+0adNu2rkEgtsZjbGULN0l8g3FknMCOKe7yDndRSa7jSCI29JBWaRFljoS3FxSUlJo27Ytnp6ebNmyhU2bNgm5FYGgidlb+isDM6cSk/kER8pPSWG9KoIUvpQaLc/93q6IEJ9A0AIQv8mWjcZYysDMqaTq0hmu6odK5oDGWMahipNk6HNpo/DnbrtwXvN6Bm+F+60290YQIT6BQCC4HcnSXSJVl86jqoFk6nI5ZLhEhj6XUGVrejt0xWQ0MdCx5+3qnKwiHJRAIBA0cwKUPvSzv4cSUykyuYyMisqlHlVzTwCLHf55K01sFMQclEAgEDRzVHJHJroN4XftOTxlbrWKwoYrQ27bahF1IUZQAoFAcBsQ59id3SXdSC47wjn9RYIVftzvGE26LptFXtNu22oRdSEclEAgENwG/Fp2mh/LDpnV3bNBzv95zrgt5dwbggjxNQIhISH873//a5RzV5dqnzRpEi+//LLF/aZMmUJiYmKj2AAQExPDr7/++pfPU1FRQXh4uMWK8wKBoBKNsZS1xdtq1d07p7/IWvW221LOvSG0SAcVEhKCg4MDKpWKVq1akZCQYFZg9VbzySefEB4ejrOzMz4+PsTHx1utAF6Thkq1r1ixgrlz5/5VUy2yZcsWnJ2dufvuyqe2BQsWoFQqpcrsHTt2ZOPGjdL+dcnY29nZ8fjjjzdY1l4guNPQGEs5XHaSX7WnCVKYL8Jto/DnV+3p21ZOoz6a3EEZTUY0xlKz/43Bli1b0Gg05OTk4OPjU2c1AoPB0Cg2WCI5OZnZs2fzxRdfoFarOXXqVJ3FXpsjK1asYMKECWZto0ePliqzv/POO4wfP55Lly4B9cvYjx07ltWrV1NRUdGk70MgaO5ULc59/upSDCYj7W2DJScVrPCjm31HbFG2yAQJaGo9KJORq4ZCxuW8jN8fAxmX8zJXDYWN5qQA7O3tGTFiBCdPnpTaJk2axNNPP018fDxOTk7s2rWLU6dOERcXh5ubGxEREWzevFnaf9u2bdx99924uLgQGBjIggULzPpYu3YtwcHBeHh4mGkYWeLgwYP06tVLGn24u7szceJESeRv0qRJTJkyhQceeABnZ2diY2PNZD2qS7VXR61Wc9999zF9+nRMJpNZ+G/37t0EBATw9ttv4+3tjZ+fH5999pl0bF5eHkOGDMHFxYWoqChefvllq9LxWq2WH3/8UZIMscTAgQNxdnaWZOPrk7EPCAigVatW/PLLL3VeO4HgTkJjLOWlK8tI1aVzTneRMNsg/tBmopDZ8JBTLPfad+H3ij9abIIENLGDKjWV8+SlV9lXdhQ9BvaVHeXJS69Samq88hylpaWsX7++Vu24zz//nDlz5qBWq4mOjmbIkCEMGDCAy5cvS6q2VQq7Tk5OrFmzhsLCQrZt28YHH3zApk2bgMrCqE8//TRr164lOzubvLy8OvWSoqOj2bFjB/Pnz+enn36yOGpYt24dc+fO5erVq3Tt2lWSnLdGXl4e/fv3JyYmhmXLllks0Jqbm0tRUREXL17kk08+YerUqRQUFAAwdepUnJycyM3NZfXq1axevdpqX2lpacjlcquihSaTiW3btqHVaunUqRPQMBl7IekuEJhTtTi3ChMm/Gw88Vd4oTZoeMApmh2By1tsggQ0sYNylNnzS9lxs7Zfyo7jKLO/6X0NGzYMNzc3XF1d+f7775k1a5bZ9qFDhxITE4NcLufo0aNoNBpeeuklbG1t6devH4MHD5ak1OPi4oiMjEQul9OlSxfGjBlDcnIyAP/9738ZPHgwffv2xc7OjsTEROR1SIj06dOHr7/+miNHjpCQkICHhwczZswwCzMmJCRI53vttddISUmxOoeWnZ1NbGwsI0eO5NVXX7Xar1KpZN68eSiVSuLj41GpVJw+fRqDwcDGjRt55ZVXcHR0pFOnTnXKWliTdN+wYQNubm6oVCoeeughZs+ejZubG9AwGXtnZ2cKCwut9isQ3GkEKH0IV1aqdocqW5OmzeDnimPsKzvKrvLDLL7yWT1nuP1p8hFUT4dIs7aeDpGNMoLatGkThYWFlJeXs3z5cmJjY82E9mrKtwcGBpo5lury7fv37+e+++7Dy8sLV1dXVqxYIcnD15REd3JywsPDQ3pdlTigUqnIyMgA4MEHH2TLli3k5+eTlJTEqlWrzHSaqp9PpVLh7u5uVdZ927ZtlJWVMWXKlDqvh4eHBwrFn6sKqmTdr1y5gl6vN+uzLm0sa5Luo0aNorCwkJKSEv744w/WrFnDhx9+CDRMxl6tVksOTSAQVC7OXeQ1nXBlMP4KLzL05kKhqcZMMjXNJ/mrMWjyEdRKn5fp7dAVBTb0dujKSp+XG2UEVYWNjQ3Dhw/HxsaGffv2Se015dszMzMxGv+cC6su3z527FgeeughMjMzKSoqYsqUKZI8vJ+fn9noprS0lLy8POl1VeKARqMhKCjIzDa5XE7//v3p16+fmbx59fNpNBry8/Otyro/+eSTDBo0iPj4eDMRwIbi5eWFQqEwC0vWlfHYrl07TCZTnZLtISEhkhOuiTUZeyHpLhDUpo/j3ewIfI9XDCMJM5pn8LXXeeOd27ITi5rUQcllcjxt3Fjn9yo5bXewzu9VPG3ckMsazwyTyURSUhIFBQVWqz1HR0fj6OjI4sWL0el07N69my1btvDoo48ClU/37u7u2Nvbc+DAAT7//HPp2BEjRrB161b27duHVqtl3rx5Zo6uJklJSXz55ZcUFBRgMpk4cOAAycnJZnNk3377rXS+uXPn0rNnzzpHNcuXL6dDhw4MGTKEsrKy67o+VQ58wYIFlJaWkpqaypo1a6zub2try/333y+FOC2RlZXFd999R0REBFC/jP3FixfJz8+vU2NKILhTUckd6VDixpyfgmivr8zWa6/zZvYvITgZlLfYusalydPM5TI5Krmj2f/GYMiQIahUKlxcXJgzZw6rV6+Wbpg1sbW1ZcuWLWzfvh1PT0+eeeYZ1qxZQ3h4OADvv/8+8+bNw9nZmYULFzJq1Cjp2IiICN577z3Gjh2Ln58frVq1sppAAJUhspUrVxIWFoaLiwvjx49n1qxZZokQY8eO5ZVXXsHd3Z3Dhw/zn//8p873KpPJ+OijjwgICGDo0KGUl19fyHT58uUUFRXh6+vLhAkTGDNmjFVJd4DJkyezdu1as7b169dLocyoqChiYmKYP3++ZF9dMvaff/45EydOrLNPgeBOxjYwkG6/6/nkLQUbPw3mkyUKuv2uR1nHg2tLQOhBNTMmTZpEQEBAnQkPjc2LL74oZfRZIyYmhuXLl0vp8jdKRUUFd911F3v27MHbu2Wu5WgKxG+y5VOSksLVjz4CnQ6ZUonHU0/h1KvXrTbrZiH0oASWSU1NRavVEhkZycGDB/nkk0/MkjYs8dNPP92Uvu3s7EhNTb0p5xIIWjJOvXphHxmJPicHhZ8fNtciEC0Z4aAEqNVqxowZQ3Z2Nj4+PsycOZOhQ4fearMEAsE1DBoNupwclH5+2IWF3WpzmgwR4hMIWgDiN9lyKUlJITcxEW1aGrZhYfjOnduSQntVWAzxtchisQKBQNASMGg0knNSBgejcHcn76OPMGg0t9q0JkE4KIFAIGim6HJy0Kal4dS3LxgMlO7fj/bCBTR7995q05oE4aAEAoGgmaL088Oxd2+0586hu7aYXpeVxdV3370jRlHCQQkEAkEzxUalotWjj0rOqQptWhr6nBwrR7UchIMSCASCZoxTTAy21fTTAOzCwlD4+d0ii5oO4aBaEOvWrWPAgAHSa2vaUWAuHX+riIiIYPfu3Q3aNyQkhP/97383tf+a1+t62LFjB8OGDbup9ljj2LFj3HvvvU3Sl6D5YaNS4TtvHrbX0svtwsLwmTv3jlgHhclkquvPIidPnrS2qVkQHBxs8vLyMmk0Gqlt5cqVptjY2FtnVAMpKCgwPfbYYyYfHx+TSqUyhYWFmd54440bOhdgSktLu8kWWmfy5MkmJycnk5OTk0mpVJoUCoX0etCgQX/p3MHBwabvv//+Jln61+nevbspJSVFeg2YOnfubDIYDFLbnDlzTBMnTpRef/zxx6YOHTqYVCqVydvb2/Tggw+aiouLTYMGDZKuk0KhMCmVSun15MmTTSaTyfTggw+aNm/ebNWe5v6bFPx19Gq1SXPkiEm9b5+p4vLlW23OzcaiD2ryEZTJZMRkUJv9bwwMBgNLly69KefS6/Vmr00mU50FYf8K9cmjN2dWrFghVW6fPXu2mQx8df2nmtfzduPgwYMUFRXVKm6bnZ3Nl19+afGY5ORkZs+ezRdffIFarebUqVOMHj0agO3bt0vXady4cbzwwgvS6xUrVgAwbtw4Sb5EcGei3rGDnJkzyZw0iYzRoyn8+utbbVKj06QOymQyYtJdpuTMcIoPqSg5MxyT7nKjOKlZs2axZMkSqyJ4//znPwkMDMTFxYXu3buzt1ra5oIFCxgxYgTjx4/HxcWFVatWERcXx5w5c4iJicHR0ZFz587x888/ExUVhaurK1FRUfz8888A7Nq1i8jIP3WvHnjgAaKioqTXffr0kRR5a1KfPLpMJmPZsmWEhobi6enJrFmzJGe5atUqq1Lt+/btIzAwUAqpVQ//TZo0ialTp5KQkICzszPR0dGSXDvAzp076dChA66urjzzzDPExsbWWwqpJiEhIbz55pt06dIFJycn9Hq9Wdiu6pqPHj0aZ2dnunXrVkth9+jRo3Tp0gVXV1dGjx4tFcUtKChg8ODBeHl50apVKwYPHmwmH7Jq1SpCQ0NxdnamTZs2rFu3zuL1+v3333nggQdwd3fHx8eH119/3eJ72b59u0XJ+xdeeIH58+dbdMAHDx6kV69eUu1Cd3d3Jk6caFH80RJxcXH88MMPFhWYBS0HjbGU1IrzaIylZu3aK1e4+t576K5J4egyM7m6fDnaK1duhZlNRtOOoIwllP4xAYM6GUx6DOpkSv+YAMbr1zGqj3vuuYe4uDiWLFlicXtUVBRHjx4lPz+fsWPHMnLkSLMq4ElJSYwYMYLCwkKp0vjatWv56KOPUKvVODs7k5CQwPTp08nLy2PGjBkkJCSQl5dHz549SUtL4+rVq+h0Oo4dO0Z2djZqtZqysjIOHTpEnz59LNrVEHn0b775hkOHDnHkyBGSkpL49NNP67wW3333HWPGjGHjxo3ExcVZ3OfLL79k/vz5FBQU0K5dO+bMmQPA1atXGTFiBG+88QZ5eXl06NBBcsTXyxdffMG2bdsoLCw0E0+sIikpSRIyHDt2LMOGDUOn00nbN2zYwHfffcf58+c5duwYq1atAsBoNPLYY4+Rnp5ORkYGDg4O/OMf/wCgpKSE6dOns337dtRqNT///DNdu3at1bdareb+++9n0KBBZGdnc/bsWfr372/xfRw/flySCqnO8OHDpQeamkRHR7Njxw7mz5/PTz/9dN2OpnXr1iiVSk6fPn1dxwmaD9acTxV7S39lYOZUYjKfYGDmVPaW/ipt0545g9LfH9N9vbg0sjf68BB0mZlordwjWgpN66DkThg05kVGDZqfQO7UKN0tXLiQd999lysWnjLGjx8vqczOnDmTiooKsx9/r169GDZsGHK5HAcHB6BypBEREYFCoWDnzp2EhYUxYcIEFAoFY8aMITw8nC1btuDg4EBUVBR79uzh8OHD3HXXXcTExPDTTz/xyy+/EBYWZqa6W52GyKO/+OKLuLu7ExQUxLPPPitJ01viq6++YvLkyWzfvp0ePXpY3e/hhx+mR48eKBQKxo0bx9GjR4FKbaqIiAiGDx+OQqFg+vTp+Pr6Wj1PXUyfPp3AwEDpetake/fujBgxAqVSyYwZMygvL+eXX34xO97f3x93d3eGDBki2ejh4cEjjzyCo6Mjzs7OzJkzx0yvSi6Xc+LECcrKyvDz87Mou7J161Z8fX2ZOXMm9vb20kjSEtZk72UyGYmJiSQmJqLVas229enTh6+//pojR46QkJCAh4cHM2bMwGAw1H/hruHs7Gw1IiBo3lhzPlVO67I+n5euLCNVlw5Aqi6dl668i8ZYSklKCpdefZVfe7jwxEwdjzyezlNveXB29ggpcaKl0uQjKBtVjFmTjSqmUUZQAJ07d2bw4MEsWrSo1rYlS5bQsWNHXF1dcXNzo6ioSJJxB8uy5zVl4oODg822V5eJj42NZffu3ezZs4fY2Fji4uJITk4mOTlZCg+tW7dO0lB68MEHgYbJo1e3Izg42KocPMA777zDqFGj6Ny5c53XqrrTqZKDr3qf1fuTyWR16l3VRV2iizW3y+VyAgICzN6bNRtLS0uZPHkywcHBuLi40LdvXwoLCzEYDDg5ObF+/XpWrFiBn58fCQkJFqunZ2Zm0rZt2wa9D2uy9wDx8fEEBARYnC+qUhnOz88nKSmJVatWXVeoVK1W4+bm1uD9Bc0DjbHUovPZW/Kn0xp6cQYBSvMHv1TdBTI1meQmJlKq0PPmgHz09gp6O3RF76BkUexFtB6N83DfXGjyEZRj27XYOMeCTIGNcyyObdc22ggK4JVXXmHlypVmEuV79+5l8eLFbNiwgYKCAgoLC3F1dZVk3MFcEt5Sm7+/P+np6Wbbq8vE13RQsbGxtRzUuHHjLCYRVGFNHr26JHtGRoZVOXioHEFt2rTphhNG/Pz8zOZzTCaT2evrwdI1rU7192U0GsnKyqrzvVXx9ttvc/r0afbv309xcTF79uyRbAUYOHAg33//PTk5OYSHh/Pkk0/WOkdgYGCD0+67dOnCmTNnrG5/7bXXeP311ykttRzKkcvl9O/fn379+nHixIkG9Xnx4kW0Wq3F0KKgeZOluyQ5pypSdRdYW7xNaj+jy+CsNoNQZWtpn3BlCD75JrRpaeRFBhDoEoLeZGBf2VH0JgMB9q3J0l9u0vfS1DSpg5LJ5MiU3ji1/xqXe/jU6WsAACAASURBVDQ4tf8amdIbWSNKvrdr147Ro0ezbNkyqU2tVqNQKPDy8kKv17Nw4UKKi4uv67zx8fGcOXOGzz//HL1ez/r16zl58iSDBw8G4N577+X06dMcOHCAHj16EBERQXp6Ovv376dv375Wz1ufPDrAW2+9RUFBAZmZmSxdulTKBrOEv78/P/zwA0uXLuWDDz64rvcIkJCQwPHjx9m0aRN6vZ733nuP3Nzc6z5PQzh8+DBff/01er2ed955Bzs7uwbJwKvVahwcHHBzcyM/P59XXnlF2nbp0iWSkpIoKSnBzs4OlUqFXF77+zZ48GBycnJ45513qKioQK1Ws3//fov9xcfH1yl5HxcXR+fOnc0EH5OSkvjyyy8pKCjAZDJx4MABkpOTGyxzn5ycTL9+/YTq8G1IgNKHcKV5tCVM5s+vWvP5xAv6HO62rfydhytDWOQ1DVfPAGzDwnArNnK2IpMMfeVvL0Ofy1ltBu5yl6Z5E7eIJk8zl8nkyGyczf43NvPmzaOk5M8w4sCBAxk0aBDt27cnODgYe3v7esNPNfHw8GDr1q28/fbbeHh4sHjxYrZu3YqnpycATk5OdOvWjYiICGxtbYHKea3g4OA6lWPrk0cHGDp0KN27d6dr164kJCTwxBNP1GlrUFAQP/zwA4sWLbru7DtPT0+++uorXnjhBTw8PDh58iT33HNPo9wohw4dyvr162nVqhVr167l66+/RqlU1nvcs88+S1lZGZ6envTs2ZNBgwZJ24xGI//3f/8nzV0lJydbdNTOzs58//33bNmyBV9fX8LCwti1a5fF/rp164arq6tVBwbw6quvmoVlW7VqxcqVKwkLC8PFxYXx48cza9YsKQGnPtatW8eUKVMatK+geaGSO/KG29O0N1aG8NrrvHkxJRBFhfn8Y7gyhFe9nuGnoE/ZEbicPo53Vy7SnTsXdTsf0g3mpY0u6HPIN17fg/XthtCDus2QyWSkpaXdsrVRRqORgIAA1q1bx3333XfTzrtgwQLOnj3Lf/7zn5t2zsZk586dvP/++1aXC9xMjh07xuTJk0lJSbG6j/hNNm/K09JIm/EMeZEBeBzPQpF6gTPTBvDmkBJOGzKkEVMfx7stHl+syWPQlZmcNmRIbeHKELaYXsDVM6AlVJUQelCCG2PHjh0UFhZSUVHB66+/jslkanBoqqUyYMCAJnFOUDnnVZdzEjR/tH7uFPa/W3JOAJHfnec7r7fNRkzWcFF58KbPP6VQYbg8kH/t8efSA0O4MGoUJS30+yEk3wX1kpKSwtixY9FqtXTq1IlNmzZZTRUXCATm7C39lZfylpE6OJ328b689F17Ir87j8/cuTipPHDB8pKTmvRxvJsdge+RqcmEfy2GneuBysrmlxITCd6woSWMpMwQIT6BoAUgfpPNE42xlIGZU82y+MJtgtju9TYuqoY5ppqUp6VxPj6+Vnvot99id/uuixIhPoFAIGhKLKaYGzLItv1zHV19FSZqovTzwzY01KzNtm3bFim/IRyUQCAQNBKWUszDlSEEKCozeesqb1QX9pGRKK8tmFcGBGBfz0L82xXhoAQCgaCRUMkdWeQ1/c/khmvZeiq5o9UKE/WNpHQ5ORQnJYGNDY7R0WBjQ3FSUotU2BVJEgKBQNCIVCU3ZOkvE6DwRiV3BKxXmMjUZNLmkhyln59Z0oNBo0GXk4PczQ3bsDC0aWnorlWzsW2hCrtiBCUQCASNjEruSLhtiOScwEr4Tx4I/1rM+fh4s/TxkpQULowaxfn4eDInTsTj73+X5qGUAQHYd+pE+fHjTfeGmgjhoBqBxpAnr6K6VPukSZN4+eWXLe43ZcoUEhMTG8WGhvL666/z97//vUH7LliwgPHjx990G25U2r6iooJOnTqR0wRhk0ceecRiLUZBy8ah1Mhrigl0qBb++9dPgbCzspZkVfq49soVchMTJWkNbVoaxVu2oPD3NwvxXUpMxHCtgHJLoUU6qJCQEBwcHFCpVLRq1YqEhASzQqS3mk8++YTw8HCcnZ3x8fEhPj7eanXsmmg0GkJrZPBYYsWKFcydO/evmmrG3r17perrTk5OyGQy6bVKpSIjI8Ns/9mzZ193aaWbTUOvV00++ugj+vbti9+1sMmkSZOwtbVFpVLh7OxM9+7dzerxZWVl8cgjj+Dp6YmrqyudO3dm1apVDbpmL774otUHDUHLpGpE5BM3mU8Wy9mln8sW0wu0XbjebL+KtDS01/6qY9LpKN23j9L9+6UwX0VaWoubh2pyB2U0mSjRGsz+NwZbtmxBo9GQk5ODj48P06ZNs7rv9Wjy/FXqkv5u7vTp00eqvv77778DldpIVW1BQUHSvre7rPuKFSuYMGGCWVuVFHtxcTFPP/00w4cPl747EyZMIDAwkPT0dPLy8li7di0+Pj4NumY9evSguLiYQ4cONfn7FDQ+Bo2G8rQ0aXRj0Gi4+tFHKNzdUQYHw849qGa8hcrJo5a+k11YGLbX/qojUyqxrVHuzK4FzkM1qYMymkzklRqYvCmLiHdSmbwpi7zSxnNSAPb29owYMYKTJ09KbZMmTeLpp58mPj4eJycndu3axalTp4iLi8PNzY2IiAg2b94s7b9t2zbuvvtuXFxcCAwMZMGCBWZ9rF27luDgYDw8PHjttdfqtKc+6e9JkyYxZcoUHnjgAZydnYmNjTWT9agu1V4dtVrNfffdx/Tp0zGZTGbhv927dxMQEMDbb7+Nt7c3fn5+fPbZZ9KxeXl5DBkyBBcXF6Kionj55ZetSsdbo0qyffz48ZKqbPWw3YULF5DJZHz00Uf4+/vj5+dXS+1Yq9Xyt7/9DWdnZyIiIsxu2IsWLaJt27Y4OzvTqVMnvvnmG2nb2bNniY2NxdXVFU9PTzOHX/16lZWVMXPmTIKDg3F1daV3796UlZXVei8ZGRmcO3fOqmChTCZj7Nix5Ofnc+nSJaDyc500aRJOTk4oFAruvvtuSeOrIcTFxbFt27YG7y+4Pag+d1Q1p6TZuxfdhQuU7t8PBgNOsbEYtVq0Z87g/dJLkjOyCwvD66WXMBYW4jN3rlm7x1NP4Ttvnlmbz9y5La6SRJM6qDKdkee2XWR/Zil6I+zPLOW5bRcp0xkbrc/S0lLWr19fq3bc559/zpw5c1Cr1URHRzNkyBAGDBjA5cuXJVXbKoVdJycn1qxZQ2FhIdu2beODDz6Q6rCdPHmSp59+mrVr15KdnU1eXl6dekkNkf5et24dc+fO5erVq3Tt2rXeitd5eXn079+fmJgYli1bZlF3KTc3l6KiIi5evMgnn3zC1KlTKSgoAGDq1Kk4OTmRm5vL6tWrzWQiroekpCRGjBhBYWGhVZt37dpFWloaO3fu5M033zSbq9u8eTOPPvoohYWFPPTQQ5JsO0Dbtm3Zu3cvRUVFzJ8/n/Hjx0vzQ3PnzmXAgAEUFBSQlZVldbT8/PPPc/jwYX7++Wfy8/NZvHixRemN48ePExoaalGWHipH3GvWrKFNmzb4+PgA0LNnT6ZOncqXX35ZK9TZEDp27Mhvv/123ccJmi8GjabW3FFuYiKFGzagu3aP0GVlYSwvxyE6mtz587m8aBE+c+cS+u23eM+dy+VFizgfH8+lxES8X3qJ0G+/JXjDBpx69cKpVy9CNmwwa2tpNKmDclDKOXzRPMf/8MVSHJQ334xhw4bh5uaGq6sr33//PbNmzTLbPnToUGJiYpDL5Rw9ehSNRsNLL72Era0t/fr1Y/DgwZKUelxcHJGRkcjlcrp06cKYMWOk+Yf//ve/DB48mL59+2JnZ0diYqLFm14VDZH+TkhIkM732muvkZKSYnUOLTs7m9jYWEaOHMmrr75qtV+lUsm8efNQKpXEx8ejUqk4ffo0BoOBjRs38sorr+Do6EinTp2YOHFig69zdXr16sWwYcOQy+VWa/XNnz8fJycnIiMjeeyxx8zk6nv37k18fDw2NjZMmDDB7IY9cuRI/P39kcvljB49mrCwMA4cOCC9t/T0dLKzs7G3t7c4+jMajXz66acsXbqU1q1bY2Njw7333mtRNsSapPuSJUtwc3NDpVLx7LPPkpiYiI2NDVApDNmnTx8SExNp06YNXbt25eDBgw2+dkLOveWhy8kxmzvSh4eQ2dUHrW8rqc2pb1/0Fy9SvGEDGAwo/f25nJiIzM2tMkGimnO7smgRihqp5zYqFXZhYS1u5FRFk4+gurd2NGvr3tqxUUZQmzZtorCwkPLycpYvX05sbKyZ0F5N+fbAwEAzx1Jdvn3//v3cd999eHl54erqyooVKyR5+JqS6E5OTnh4/Fljy1ISQX3S39XPp1KpcHd3tyrrvm3bNsrKyurVCvLw8DAbEVRJpl+5cgW9Xm/W5/VqY13PcXXJ1deUdC8vL5fmstasWUPXrl1xc3PDzc2NEydOSJ/B4sWLMZlMkjDkp59+Wqvfq1evUl5e3iBZd2uS7s8//zyFhYWUlpZy6NAhZs2aJWXftWrVikWLFvH7779z6dIlunbtyrBhw6in1qWEkHNveSj9/KQQ3OlpD/DUWx488ng6f3v8EmemDUAZHIz23Dmz0ZT2jz+Qe3hQduRIrcSIlpgEUR9NPoL6d0JrogMdUcghOtCRfye0bpQRVBU2NjYMHz4cGxsb9u3bJ7XXlG/PzMzEaPzTUVaXbx87diwPPfQQmZmZFBUVMWXKFOnG4+fnZza6KS0tJS8vT3pdNRleM4kArEt/Vz+fRqMhPz/fqvT5k08+yaBBg4iPjzcTZWwoXl5eKBQKs7DkjWY81ifpXvPc9cnVV5Gens6TTz7J8uXLycvLo7CwkM6dO0ufga+vLytXriQ7O5sPP/yQZ555ptY8naenJ/b29vzxxx/19telSxfOnz9vNdFDJpPRuXNnYmJiLM4beXp68vzzz5OdnW0mWlgXp06d4q677mrQvoLmS/WEiCqxQQb05c0B+ZxRVMqzn5Hl8ObAAkxRXSTnVIUuKwsbNzeuvPUWyhoPfC0xCaI+mtRByWUyPBxt+HBYAL8/G86HwwLwcLRB3oAb241iMplISkqioKDAarXn6OhoHB0dWbx4MTqdjt27d7NlyxYeffRRoPLp1t3dHXt7ew4cOMDnn38uHTtixAi2bt3Kvn370Gq1zJs3z8zR1aQh0t/ffvutdL65c+fSs2fPOkcny5cvp0OHDgwZMsTipH9dVDnwBQsWUFpaSmpqKmvWrLmuc1wPiYmJlJaW8vvvv/PZZ581KIOxpKQEmUyGl5cXAJ999pmZQ//qq68kB9uqVStkMlmtMKtcLufxxx9nxowZZGdnYzAYSElJsTgHGBAQQLt27aQQoiVSU1PZt28fERERALz44oucOHECvV6PWq3mgw8+oF27dmaj6bpITk6+rqQKQfPDUkKEU69emN54QXJOVZy2yaXi6VG1MvGUgYFUnDqFLj0d29BQyUm11CSI+mjyNHO5TIaTrY3Z/8ZgyJAhqFQqXFxcmDNnDqtXr5ZuJjWxtbVly5YtbN++HU9PT5555hnWrFlDeHg4AO+//z7z5s3D2dmZhQsXMmrUKOnYiIgI3nvvPcaOHYufnx+tWrUi4FoRR0s0RPp77NixvPLKK7i7u3P48OF6VWarsuMCAgIYOnQo5eXl13OpWL58OUVFRfj6+jJhwgTGjBnTKJLuALGxsbRr147+/fvz/PPPM2DAgHqP6dSpEzNnzqRXr174+Phw/PhxYmJipO0HDx4kOjoalUrFQw89xNKlSy2ufVqyZAmRkZFERUXh7u7Oiy++aPVhYvLkyaxdu9asbfHixdJ6pgEDBvDYY48xefJkoHLk/PDDD+Pm5kZoaCjp6elmmaB1cfDgQVQqFT169GjQ/oLmh6WEiKqFs0GqQIsFY0MCuphl4tm2bYttaKi0rqkkORnkcgJXr26xSRD1IfSgmhmTJk0iICCgzoSHxubFF1+UMvpuFhcuXKBNmzbodDqr2XHNiYqKCu6++25++OEHabFuY/HII4/wxBNPEG9B46ehiN/kraU+jaa9pb9KhWFryrsbNBr0OTnI3NzInDjRbO7JLiysRQoRWsDiSKX53ykEjU5qaiparZbIyEgOHjzIJ598cssrQNxq7OzszNbONSYbN25skn4EjUdVQkRN51I1Z2StYCxUZuLZXBtFeb/0Epdffx3tH3/csWG96rTIUkeC60OtVjN8+HCcnJwYPXo0M2fOZOjQobfaLIHgtqEqIaL6wlnvuXPR5eRIFSQsFYytTklKCpcXLcKk1+M8eDDec+fekWG96ogQn0DQAhC/yeZBVbhOm5PD5UWL0KalYRsWhm89zsag0XBh1Kg7NbwHQvJdIBAIGhcblQqFn5/knMA8YcIaNRf1wp257qkmN+yg6kqlFggETYf4LTYvtJmZfxaCvUZ1Z1OzeCyYL+qt4k5c91STG3JQTk5OXLx4Ea1W2+CV8gKB4OZiMpnQarVcvHgRJyenW23OHYvJoMFQehKTQUNJSgrZM2aYFYKFP52NpbVSYHkOqypBwpJDayyasq+GcENzUEajkatXr1JUVHTbyyoIBLczCoVCquJeVw1IQeOgK9pFWfqzmMpPIbPriPZwX6688Z20XRkQgG1ICB5PPYV9ZGS980xVc1hVNfdKUlKk9VW27drhOX06qj59GmVeqnpfjr170+rRR3GKiWmqOTCLc1A35KAEAoHgTsdk0KD+PQZT+alqjW24mhiA9vSfFe1DvvkGh86dKTt1isuvvYYuN1dajAt/rpWqiaXECWVAAMqQEDyfeuqmZvhV78upb1+pRqBtu3b4zpvXFNmEIklCIGhKNMZSUivOozGW1r+z4LbDWJFh7pwAZOexj/CUXtqFhWEbElJv6M8SlhIndFlZoNPddHn3qr6UwcEYy8qwv+suVA8+iKkR+roehIMSCBqBvaW/MjBzKjGZTzAwcyp7S3+91SYJbjJyuyBk9uap/TLbcAzqSqmZqnkkoDJ0dq2AcVXVcqfevetciGspcUIZEIAuN/emZ/hV9eXUsycKb2/Kf/sNzfbtYDKh8PdHe+GCtG9TzlOJEJ9AcJMp1uQx6MpMThv+DPOEK0PYEbjc6iJNwe2Jrmg3Zen/rJyDsu+Evf9bGK4EgMGAbUgINiqV1TJIVaG/uihJSSF34UK0Z89Wzme1bUtJcvJfXiNl0GjQ5eSgrKYvpUlJ4ep776G/eNGsyroyJASn2Fic+/fHWFxMwZdfUrpvX4PWd10HIsQnEDQ2JSkp/Pbxm2bOCSBVd4Es/WUrRwluV5SucThH/IQq8jdsDO+R+bd/c+Ghh7jwwb85kXUQjbG0cnRioWq5wYLmWBVVoxT7yEhCvvqK1u+9hzIkhJLkZGz/Ygkka5mECk9PFJ6eKFu3NkuR1124gFylInfuXC6/9RZyJydchg9v0Pquv4pwUALBTaKqonWhlx3BNubzCuHKEAIU3rfIMkFjIrNRgSGQ3DmvoU1L4/S0B3h8Wgn9FIkMyJxKcm4y9hERKK+pHCiDgrANDeWylZt7TQdSeuQImEzYeHigevBBHKOjbzi0VVfVdV1ODuXHj1fOkxmNuD36KMrgYByiolBv2YJtcDAYDGh27KDs4EFcBg9u9MXEwkEJBDcJbWYmxrvCef2ePwizCyJIUakQHKLwY6HnFBHea8FUJRnow0PMxAlP69J52bCO/NO/gY0NjtHRKHx80F64YPHmbtGBLFjA5bfeovzXX5Hb2FD4n/+QO2cO6j17btjO6lSkpaHLzOTyokXorql+6zIzKdm3D4WPD449eoBMZq7+m5lJ2bFjOPbu3aiLiYWDEghuAlVZWhdlBZyxyeV/pftRyGzo7dAVuUxOa2Xl6Km5LYQU3ByqkgzyIgMsihPmRQagS0+ndP9+yg4eROnrazGDz2LmXmYmSl9fdBkZlB09ijI4uNKhvPHGdX+PrFWsMBkMFjMGZTIZpQcOYNexY23134wM7Dp2pPz48euy4XoQDkog+ItIT71nz+JxPIv2+kpndE53kX1lR7FFSYDCu1boRr1nj3BWLYSqShA+RXLp86+ig8EHj+PVkg4CApAplRbnkerK3INKp6H0rRyZa8+eve7wmrWKFbYhIVb7LTt4EPvOnWtJ0CsDA9Hs3Nmo81Aii08g+IvUzNI6M20AiwbkcUZxWRKnu9cYVnvRZWAgyOXYd+2Kqk8fHO+9F9trsvaC2xODRsPeogPM1q3htD6D9jpv5qbeRftlOysXvoaF4TltWp3VIKpXdFAGBmIbGlqprkvld8a+SxfKT5xAbmtbK5PPUnaeNTurV6wAUO/ZI2lRVc8YVAYFgUyGQ2QkZceOocvIqGWXtcXG14GoJCEQNAaWVvzLBvTF9MYLBKoCUckdraYau0+ZgnrbtsowTmAgnv/4B4phg8jSXSJA6SPmrW5T8i+kcuyjN/E4noUi9QLK4GCUvr74zJmDfT2yKAaNBm1mJhgMGNRqLlWVOmrTBvuICIq3bpW+K27Dh0vHmZVFus4U8KpjTVot9hERKLy8KFi9GruwMNz//nfyVq5Ee/YsDj16YB8ZieZ//5OqYdwkWRDhoASCxqL6zaEqbFL95lCRlUXWE0+gPXdOanPo0QN9bq40MQ2Q9q9HWNQvl9P6DMKVwSzymi5JgwtuH25U38mSk7GPjER74QKX336b0n37zM4XsHo1xsJC5H9BLt5iSaWgILz/9S+cevaUCtaW/PwzBV98gczGpjJhIjPT4nf9BhEOSiBoTCyFTQAKN27k6nvvYRsaKv2wlYGBuAwZQt7770v76cNDeOotD7NJdrHA9/alvoeWmtTl1HQ5ORZH4M6DB6PeuhXbtm1RBgRIIbcqaobeLIUArY3unQcPxuOpp7ANDKxVzFbm5oapsLDWd/0vIByUQNDUaK9cIWP0aHSZmQAog4NR9e8PBgO6K1eoOH5c2nZpZG8eeTy91jl+CvqUcNuQpjRbcJOw9tBiCWuOIvTbb9FdvUrunDnSdwX+nMOsCrXVfF1zBGVtdFZx4QLZ//yn2UheGRAANjYofX3R5+ffzIoR1hCVJASCpkZ75kzliCk4uHINjJ8fmp070ezejUwmw3nIECk7yvuynvay1mbHiwW+ty9Vo5Uq51TfEgNrKeAyNzcuJSZiGxpaa7Fv9arousxM7CMjpeOqZwlWZZqatNrKhb5aLYUbN3Jh5EiuLFqEQ5cu0vewKkECkwldbm6TVIywhnBQAkEjUHUzUgYH45yQAAYDpfv3o8/OrqxkbTCg3rYN9ebNqO6/H/enn8bVzYfXTI/SQVlZZqYqA7A5hffEOq6GUXNJQeHGjRbLC1XHWgq4sbAQbVpaZfiuarGvv3+tdUl2YWF4z55N6LffErxhg9mIpyqsV/U9xGgEgwHt2bOVqeRHj+IQFYVq4EC4Nsfk0KWL5ABvlfy8CPEJ7kiqnm61fu5kK4tvasZcTZE5+06dKN68GagM8WE01grVtF62DNuQEMqPHyfjPx9zydWIT5GcoPF/bwotngbxV7LEoOEp0LcDdb2XmnNJlj7zuhIYaoYFrc1Neb30EpcXLWrQHFfNUDP8GcbTpafjFBuL9o8/wMYGu44dUfr4ULB6dYPsvUmIEJ9AAH8+3X63/d8MzJ72lyUxqo8qapWqOXuWsiNHpOKbSl9fs5sEVIZm5HZ2QKUsAzv34PPVPti555Zq8VRHe+UKBRs2UBHgyaWRvSm1uT6dIGsFSpuSmzX6q++91KwGYekzr2tEYqNSYRcWJjkDayMr5759CdmwweKIqSbGwsLa37tqi35LkpNR+Plh16kTFadO4dC9u0X5+aZGjKAEdxRVT6OlNrqbkjFXc1ThOW0a2dOn19rPMToaXW4udp06YcjLo+zAAWlbfZlagatX49ClS5PfIDRaAznFOlqdP0XR3H9xPD6UNwcWcMbmEu313ry004MB/Z5GZmdndVRk0GjQXrhA1vo1XDRckdYFXe8T+V8dfd3o6K/mSNtf58KVURNqjWaq0r2V10oX/ZURVF22NDThwtKxNUdhtm3bovDzo3TfPotSHsAN93cDWBxB2SxYsKCug+rcKBDcbmjT08l7910uPdqXFeF/mG27aixkpPP9eNq4NehcBo2GrGnTpB+9IT+firNnsevUyTwjKigIh7vuQnfhAuVHjiC3tcUpNpaK06elp1O7tm2R2dmh/vFHDPn5fx4bGIhm926Kvv4au9BQbGuUm2ksUjJKmLY5i3dT8th91YY2Ia1YNPC45NDz5CWkhiro/8V58v81F/WPP5rZZ9Bo0OzaRd6nn/KL3XmeG3CeD7pl8fP9XnT0jMRt+0Fchw5F4eFRry0lKSlkTZtG3rvv1uqnIVj6nMpPnMBl6FDktrb19vszqUzx+Ya31J/zXdl+2hu98Tjw53fHvnNnClavJm/5ctQ//oh9eDiq2FjKTpzAkJ+P0tsbjylT0KanY8jPN/vMrwe5rS0KD486ba7rWLvQUMkmu7AwfOfNw33SJOy7dEGblUXp3r1mtv2V/m6AVyw1ihGU4I7CoNHw7TdvsOpeNedsrpKhz5W2hdsEsdkwCzff4AY9MVpLC/Zftowrb71Vmb0XEIBDjx6UHToEMllluCc3F5mtLa3ffhtltTUmUHeZmyaYBwAqR06jPr9AWp5Wagt1gfz73uYc58z23fhpcGU4spp95cePk7twIUp/fzQyLU88rzMbqbbXefPZcifC3lx6Q4tIr/c61JW+ba08T10j7Q4GXz58/opUIcLa6AioNZfUhCMSi1izoRnYJuagBHcuGmMpqRXnybPX8kbvLHabTtDeNliSxGhv8uOFLU4UPPkPchcssDhHUqzJ43jWAYo1eYD1tGDbkBCQy3GMjgYbG/QXL1a2VWVQGQwo/f2RKRS1bgZOvXoRsmEDgatXg1xutvCyqTKpcop1Zs4J4FwxdKvoZtbWXudtVgS1SrYhMrdxIQAAIABJREFUNzERk06H9tw5LnsralX3PqO8jHba+AbdCK3JQ1zPdbD2OdUlE1HVr7Xq5IV9KpVw7cLDLc4vlR07JvVTfS6p+utbgTUbmoNtlhAOStBi0RhLOVF+lq3qvTyWvYCYzCd4+cr7nDZU3lCqS2K88W1r2r9bWdCz7PBh8j76yGwy/cez2xiYPY248pcYmD2NH89us14ZOjAQma0tpfv3o0tPxySToT1//k8tnawstOfOIXOzHEq0Ualw6NIFWY3QSn031ZuFn4uSMA/zvts5GXnoUD7tjZUOPVwZwpxD7VCkXjCzr0q2Qenriy4riwCFD+0NPmbnClcEE9o+ukG23IhzqYm1z6mum3FVvx7Hs2hvMu+rg8kfj7N5OEZHYygqsljlO3fevFuWDNKSEHNQghbJ3tJf+bQwiZ2lv/CV5n8UGNXcY9+JU7rzuMhVFBkrnU+BUY19mZHRH55DfrUQAGNxMUo/Pxy7d0fh4UGxJo/H1Is5I68MB+bJNBwznCfB/l4uB9jj+8gYvIYOx/3xx6XYffV4v2PXrpUhvmoYi4tp9cgjVudgLM0Z3Mi8xY1gayMn1N2OE5fKyC8zEOZhx7z7vIkJCGWM/yOMcn+Qqa1G0qbMpbZ9HTpQ9vvv2Li7Y9OqFcbfU+mgDOJUGzl58hI6GHxZWPEwIcUOyOzs6p3fuFnXwTYwENehQ3EdOlT6nBrSr+FUGu1l/pxsrSNPXkJ7nTdz9rch4I8SSlNSsHFwMJtfqgrLlv/2W4PnugSAmIMS3ClojKUsuPIhP5YdIl2fQ5DCl/a2waRpM7CRyQlVBpChy+GMLoNwZQj/SvajbeIG6XiHqCjswsLw+Mc/sPXyYvOlHTymftOsj/6OPcioyCbNkGW1qGv1umV/pZBn1TmqssSaKgxTmcWnx89FgcrWpk77quYuSlJSyF2wAO25c7R64gkKPvkEqKwzmBcZgMfxLNxCwqk4dQqZre11ZdPdijmSshMnuPDww2b2O5qM+L/zL+Q2/ii8gqT5pbJjx8idN8+sugPcFCmKOwFRi09wZ3Ci/CwTcxdwQZ8ttQUpfFHIbPBXeHFVX8g3rZeQbywmQOGNbP9v0k3VOSGB8uPH0WVkYBsWhsvr83ja82v+0GdJCRWhytYYjEbSDX/Og9SXon69hUOrU12n50YWyDYVFheogtkNu3qNt9L9+5ss8eNGqfme3Kf0wKHvYUymc8jsO+IQvBSla5zFfaHpEltaACJJQnBnUHYx08w5AWToc+ls2xZbk5JFXtPwVrgTbhuCSu5YmZiwcSPB//0vFampUoq4Ni2N07u/Zlf5IbOEigjbUDPnBJCqu0CW3nwyvTpVyQ8NWVRZHU1KCpcWLKhc5X/NpuayeLcmNRMadOnpOERG1q7xZjRi4+mJMjj4lpXQaSg2KhUef/97ZeiuQxAOfSqdE4Cp/BRl6c9iMmikfa93rktQN8JBCVoUBo0G1f/9h3Yy84ntYIUfD9ODz/znW9RXslGpkDs6So6gCtcffuU+226UmyoIVvjS26Er9lpZrYnzcJugeou6Xk+mlEGjoezUKQrXr7+uKgS3EksJDRWnT+Pzyis4Dx5cWePt/Hkc7roL9bZtYDDgMnRokyR+3CgGjYa8jz8GuRyXhO6YaqTZm8pPYtT++fnc6IOIwDLCQQlaFLqcHNi5h9nb3Ai7lnEWJvNnQWp3Oj+xHIdSo9VjLd1gL4zqQZbxMvvKjpKuz8XP2IoHk67w0nY32pv8CFW2Zrh9LG+4P3NTa/ldGDWKy6+9RvmJE1IF6yps27Vrljd1qyV5+vTBLzGR1u+8gzIwkOKtW4HKbMbyEydupcn1UjUq1KWnU7ztMNDGbLvMvhNyW/Msvuaasn07orjVBggENxOlnx8M6ItrbikrlikpdAnG+5IO2/RvqUhP5//ZO/PANupr339G0owkW3ac2I7t2JIdO06cQCBpICFko2EtpeQCJdzyHqUtfdy2rIW2LG1YS4EC97K3j3e70I1LeqGFSylrICQQzJIQkpDFS7wm3ldZlmc0mveHrIlWW17jZT5/kdGsCpmj8zvf8z2+o0cxxylYB1+wwVqRcM5a7l9dR5kvIA+v8TVg64Nr3mzG7vZxi+ssHjjxC15UtrJPreJBURzx9NtQLz8tPx9UNbAsRr93mtPJ7Ntum7Avv2AGESloMDscCFYrnvffD9tfrqgY8O/keBP80SKXlSEfrMG7bTn2tUJ/DWoR9vxHEcwT8+9iKmCIJAymFNs8u7il8VEOqrXM983m9h0FnPx+C3JVFfbFi8m8/XakzMwBzxFUjFVk+VnT9P2oz//+4snk9Fi54htVoz79NtL1INRl2r54MTM2bsQxSZeNVLebqksvRS4v17dNBhFBlMDlvp9iK5mFSXIawWn0iCmSMDIogymD2+/h1ubH9UbcQ5Ym7l9l5g+HnVBZSdcrr+A9eHBQFZzZ4YCcHLJb6lgg5nNQqaZQzGWOJRNJNZPdLVCnNkY5DASFEiOZfhv6ix0CLtOpGzaQeuGFWBcuHDS4DoXxHn/h3bMH2wknoHm9KHV1SEVFk0JEEC8rNBh7jBqUwZShTmnkgBLeg3LQdJSGNFUXGiSiggvWgBrP/hq3v5fLpcln4tNUtvd+Rq3WRO2V68jqNDHfFy6KGI3pt5F1nNQNG/Du2UPdVVdRe+WVo+ZMMB7jL2KNIel66SV96J6Yk6NPgJ3oGHWl44MRoAwmHUFfPbffE/bnWeYZlPRPow1SYnYx453PwrYNpIKLnOeUv7mU3e4v9B6oMqWWTeIL5D74S+5PuZpiS6BA7rJkc5J1Hru8B0f8fMFf7HNffhnvvn3IlQHlWLzgGvl9DEbUzKoxkK5HBkD3tm369ZTqajylpfRs3z4h1YgGEwcjQBlMKrZ5dnFu7TX6kMHnOl/T/3xR/c1cm3aZHqRKxALun/UDklRRP95XUkDrNRfRlzMr5vkje3laF+dxSIjueToidXNKzmk4LVmsti/BIpjZ7H6LW5ufiAqciQSO0H2DS28ahNVrIDq4Rn4fiQxdHA0D1oGQm5tpuPvusADY8sQTJK1eHbbfeHkLGkxejBqUwaQhWGMKLuPJ+Hio/Y9U+wIv1gNKNU92bOZvuY/oLhEOUxI9/cq8PecV8OB5HRwyfUJJ6494wBRtTxRZA0rfU8d8f7buwwfHlvLqlEa2eMM99oJ1qGZfu36voVZIseo+2zy79H0XmJ3cvt1J0T3PI82bR+qGDYFlsX5CX+qR38cBpZpbm58YVKgR+YyR5x0JPTt20L55c1Q/mVxWRuaNN+JrbAxz0zCWzAwGwsigDCYNkTWmOZZMPTgFOaBU0ebv0l0iILBklrn5j/zyax490ARf5pHZTWQNKFkVuc/0v8Kysgcyr8NhSmKOkqq7ewdZoGaTJltjBo7mzz6MqvtEBpmDai2/WF6J5etfQ1MUvHv36plH5Es9Vs1tMEeLWM84WsEiuHTo3bMnqnfLWlxM8umnG02sBkPCyKAMJg15YhYlYr7+Uj7iaybfkhMWpOIJFY6IXRxUa8K2xVPdRaq2Ch0Olvu/TJ2vSc/KAKSjbdz62kweOMfPIUsT85XZ3PLmTFouro0ZOA6++yLpEXUf73/9R7Sww9xAvWAlT1URCwrIvPFGTLffHqUgi/w+Bnr+SMZCmRa6dJi8bl1gW10d0rx5YQFwovY8GUw8jAzKYFJxW/p3WG87BQAJkR/PvCJmdhNJ8GUeykAv80jVlsOUFJaVQWCp7MTXDvPMj1t54bf5PPOTVha/dhhXWlFsscbb4fWhvrIystu0qH2DgwCDc6PMWVkxFWQOUxIPZF6f0PMn8owjJdSJo2frVjCbSb3gApx/+IORLRkMCyNAGUwKgmKAKxvupF5t5rdZd/C680m+MeM8Xnc+xfuu3/K688m4Tg6xXub3Wf73gNZHgxFcKktSRbL+up1kVSRr0yZSHelR14oUa0Bg2WtGRl7YvvOV2dz6Zro+CFCprUXr6Ih7D2uSlvLP9IfZanuQf6Y/NGIni5EQuXRokiTSNm5EyswMk5wbxMf4nsIxnCQMJjxuv4dza6+JWsoajmtDl7uVyrJSrP/vv+HNbUjz5pFx/fU41qwZciYRFDyY0tLQOjqilsrcfk/YsmDHiy/S8uSTKLW1iE4nGddeS9rFF+v7VhwqRXz4twhbP9TPMZjTQqjLwXBHcYx2w27MGVEjvMfpwDT/nox5UAaTkwN9h1lVe1XU9vddvx2Sa0PzZx9y6NO3mPnBAYT3SvXtYl4eYkEBGVdfnfALYagvk+CsIE2WA+PQGxowSZIefIKfi3PmIFdU6L57WXffjZidHTN4jMb8oVjPYVu8eNQC1nSZkaSpbvx9NZisrmHZH02X72kAjHlQBpOTodaPYrG1s5QLkx7nwnVbuOrHPg5dd47+mVJXB4qScLPqcBpdQ12xPaWlKNXV9JWVodTW4i0rQ66tRS4r02s3SStWYDv5ZJruuy+u28NI+5lCn0PMz8cyaxZd//wnVZdeOmoOE2PdczURUDrfoXvfKtx7l9C9bxVK57tDPodcW4tl1ix9yCNMve9pOBgBymDCM1IxgNvv4ba2X+kS80OWJh44uxVfSQEQyKCUhoaEXwjDeenGGuWRumED9TfdxOHzz+fITTeRumFD4PzV1SgNDXh37x5wUGHoOcX8fJJWrCB59eqE+5mCz5G8di2oKkpDAz3bt+vNwYkEXrm5Gff77yM3Nyf83KLTidLSktA9TnQ01R0YWujdH/hzxBDDgY5TPV+gqW56duzgyE034SktBVXVFZBGI7MRoAwmCWuSliYkhohFndIYJTE/JDbRujhPn/KqVFfHfCHEKlrHeukO9jKJ6q9avRrvnj3HgkF5eVjPk33x4kEHFZodDrI2bWLmt74Ffn8gMztyBO+ePYN+J6rbjebzkbR6NXJlZWBJMTsbIUkg9eIvIS1wxbxmKB0vv0zjPffQcOed1Fx2GR0vvhjzuWffemv4VN3CQpom6FTgoeLvq9GDU5DIIYaRhGVce1fRu/8v+v8HSl0dckUFyatXG43MGAHKYBIRS+qdCLGWCBf4c5i/7iLEggJ6tm6N2awaz1B1uI2uodNWM2++WffYCyJXVDD75psDn99+e9wgGLRFav7sQ1qfeYa2yv3UnZaPr6QAubIyYTPcqn6HdKWuDjE/n5SLC8i8sx7HJX8j4446Zn1vedzA27VlCy2PPor7tdcCM6sKC2l58smYmZSYkwMmE0krVoDZTM/WrVNm+cpkdSHYFoZtizXEMEhUxtW3H/GEN/QfBBAIUpk33zydBBJxMUQSBtOCUDuhErOL+2f9gLUzlkcpzoIkUrSOd2wiJHL+qDlEmzax82Sb/hzz/dl8r2c1v7a/F2gU9s3m1jfSmf/EGxS++irWGA2xkdcV8/OxLV6Mv7OBGd/bCRzW9xUoxCz+huSlq6LPccklYQFWzMsDs5nse+7BcfrpQ37WyYzS+S691TegefdjSjkba9b/QZxxVkyxhOr5AvfeJVHb3S9cRNeLO4Gp9d0MAUMkYTB9CVsizH+atTOWA/GbVROpM42k0TWRLCw048rfvBltxclhtkg+q5nH0t7X51IFa2vCOWvjLjfGei7v559jzvQTGpwANCqxlUSb6ipHj0Zlf0pdHdaFCxFdrqgl0bGyVpooiDPOIOWE97EXPYem1NFbvjGuWCJmxiWVoHbbgan33YwUI4MyMIjBeP3qH0oWFim3X21fwvbez6L2e8e3iZNKvhz3eqHPlbRiBZ7SUqQFLjLuqCMyg0pauBVLSlbcc4j5+YjZ2WiaRupXvkL7X/4SV3o/koxzoqOpbrr3rQqrRwm2RaScsD0qkwrNuIJj403mU6bsd5MgRgZlYJAo4/WrfyhZWGQt7YivmXxzeKZUIhZQOH/FgNcLfS5BFJEKC5EP1uDddgowt3/PQnq3LUNt6Ip7jpQNG0BV8ZSWIogi7X/8Y0zpfVBoAsR81snknhCqvgtlKGKJYMaVVFyKlPIXTOZTjIGIcTAyKAODAZhov/rDamliAdemfp0nOjZzUK3R5feJKBxDn8u7Zw8N99yDXF5O8ppTsJ9eRNffdyD4rXEzRtXtpurSS3X1WTATiyT3qadofvTRuFnVZHJPUDrf0QUOgq0Eu+sRxLSzAfDLjbgPnI3mPaDvL9gW4Sh5Hc3XGtXAO5mee5wwnCQMDKYCkRZKkX8eDqrbTc8HH9D+3HN4tm/XM8Z4L01vWRmHzz9f/7OYnx/opaqr07dJxcVYsrLwbN+ubwtdJp1M4omYS3hSIbaCXyEI4D3yEBbbPHy9X+B3v4dgW4Q15yb6jj7SH9AWYs9/DHHGGcN67tG2o5qAGAHKwMBgYBLNGGO9ZFM3bAiMqC8vx1pcTPp113Hk+uujjg0qDCODXOTnE4l46jtL5r+Bvxu1+wM0uQpBmotl5oVYs66l59CFMWtSfZVHh/Tc0yTbMmpQBgYGA5NoLSRWjS7tkkso+OtfddWhY82aARuah9PwfLwwWV0I1vlh2wSpAE0w6cEJQJMP42t/CdVbEbcmNZTnHo6t1lTCCFAGBgbDIlIGn7xyZViAG0xoMpnk55ragyVlLYIUEJEIUgFmewmCpurBSd9XrsJkTo7bwDuU55arqqa8l+FAGEt8BgaTlONVlxjqdQdbNlTdbuSqKjCbkZzOCRmglM638Rz8Cpb0b6Kp3Wi9e9A0H+Lsf0Np/h1a3yF9X8FaQsqJH+BzfxIlJxdnnKHvN9j30rNjB+0vvIB35056k820Ls4jfU8d9h4V1/PPI2VmjsejjxdGDcrAYKqQSF0idF6Vv6NjVALZWNRDJkONxS834v5iLZp8GJN1HoKUi6ZpCJgRrHNQe3bGDESa6sYv12KSnLqKL5EAH6zxWWbNYu/FJ/DzEz7nkLmR+WoWm744iTNP/PqEq9ONECNAGRhMBYZqkyQ6nUiFhShHjozo5T8WqrvJpOTra/4DffX3ocmHA2KItPNQmn4FQPIJnyCYxLBAFItEg3FQQKJ9eSVX3axwyNyof7ZAzea13CdIdaSP/kMePwyRhIHBVCCWXZFflundvVtvjA0trCu1tcgVFWiyPKIC+1jMdppM86Ksmd8kueQNxOwfYpIK9OAk2BZhthViti8cMDipbneg3ywBwUNQSNGUYQ4LTgAHzQ3U+6fGuJLBMAKUgcEkI1IFlrx2Lfj91H7rW1Rt3Ih727aol35wnEasl3+iTg5jobqbTEo+ALMtH3HGV/D7ArPFgkt6iUzR7Xn/fb2xOUi8YBwUUmR1mpjvCx/MOV+ZDbf9csTDJCcD5rvuumugzwf80MDAYPwxSRLWwkJ69+7FlJKC2t6uz45S29roKy/HumgRgh2S1xWh+UVM9hT8Hg/i7NnM+s53MEkSEFhyqrvuOlqfeILuLVuwFhYiOWOPigi9rtrWpqvPrEVFo/Iso3XOscZsK0DKuAIx43JsOT/EbJ8/6DGq203TQw+B34+/65h9lOh0krRyZczvXHI6mbXuTIq1bHZTRau/k/nKbG59M53057bg3buX1A0b9L/LSc7dsTYaNSgDg0mK6nbTu3s3td/6VtRnrv++HVV+EE2rRKAQX9VFdPx+d5g7RKIjRSIL+mNh/zTRLKVGm2BNKfWCC+jdvRultlYfluk7cmTQmltb1QE+f+ZB0vfUYTlQpW+fiE3Nw8SoQRkYTCXMDgf2k0+OWiJznL0KlUfRtMBIDI1KLPNfxfX878IK8oPVfwYa2DjaxqZT3Sw1uJTpa24e1vDGGRl5OD9rDAtOE3kpdLQwApSBwSQmsulTmjePWd+7GK0vwsVA3o9gaQvbNlD9Z7o7GIyUyLpe8O8JUdQd4JXqwFyvRALNZGpqHk2MJT4DgymAe8cOOjZvxrtnD9L8PNKu/gRNjm4ejSzmx5ram7xy5aTyyZtoDCQlV91u3Nu20fL44wH3+NWrSfvXfyV51SrdQHegHqkpvBRq9EEZGExFImtJ0gIX2Y/MQe0t7TcwLcCcsoqkgidijyGP8dKbTP1JE4lEv7fIQCUVF5N+1VW0/uY3gcBWVETmT36C5HROZQfzUIwalIHBVCSylmQ7IQNf5/MIggVzyjoEwYKv9c8xh+dB7PrPdF1SGinx6npyVVXUvi1PPKHLzjVZpuWpp44tqVZU0PTzn1P3/e+H1f+mG0aAMjCY5ETWkrz7WhCEQvx95ajdW/H3lSPYFiGYZ8WcBhuPWGawoUymSbjjRay6npiXR9Mjj4QFmchAJmZn660C+j61tYjZ2dO6/mcEKAODSU7UGHe/FUvKHbqbdnB4nvvAObj3LqF73yqUzncTPncsdV08hd90R/+7mDcPQJeSe7ZvDwsykYFMaWhAjOiFEvPyUBoCDcET1V1jrDFqUAYGU4TIWlLQqFQwz8J94JyYw/MScUCIdZ3jVZ+aDM7nAL3799N0330oDQ26Wg/CRSaRApWZ3/kOrU8/DSYT1oULMSUl0fXii0BgOnHB1K7/xaxBWcb7LgwMDMYGs8OBOeRXuWB2YLYvDCzrxRme12vNp05pJE/Mwu7xJzRGY6D+KfMYKvx6duyg4a67kCsrEfPysC9bRtoll0w453MIuED42trCglOknDy4hBr8UeHds4cZl1xC54sv4n7tNUSnk+R165ArKsi47rqpHJziYgQoA4MpjsnqQrAtjMqgavpq+W3bX/H46mkRkrl0axJF9zwfUxodGriCy1ORGVS8Xp7RmFulG61WBpqPlbq6wPbWVmyLF0+4l3dwqS9Swh95n8EfFarbTcszz6BUV+u1KKW2FgQB+7JlONasOR6PcdwxApSBwRRHMDuw5z92bHietQRz8hJmHbqAH0tzMdsX4O49xD9Xf5X8kgI4ECjK5/f3VcXq6Unk5QuB/qzuN97A19qKv7ubjKuvHlbGoxw9qivexPz8gKigoQFNUcY8cxsukRnSYFkpihItlKipYfYtt0y4ADxeGDUoA4Npgqa6UXvL6K39Kf7ut/TtglSAIFjoQ+Po7m9gufePABT87W8c+clP4taa4vVPBbMlz86ddL74It7duwNu6i4X9qVLyb7rriG/cFW3m6pLL0WcMwe5sjJwPqeT5DVrmP3jH0/6F7jqdlN33XUoVVV6dgjTovYUxKhBGRhMZwSzA8FkDQtOAJpchSllHWL3Vuaeup+e7y2n5+12MJsHrDVF1rxC3SwEUSR51So9OEEgG0DTUGprMS9cOKR7NzscZN1xBw0//emx89XW4iktHc5XMe4MtsxpdjjIuPpqOl54AQgsYUpFRWRP894zI0AZGEwjYtajpAI0uR5BKgCtjeTzZ5G85kbMGRkJ15q633uPxrvu0l26xYKCgIItJBuAQFDRVHVY927JyIhaApMrKgZc4huN+tdISXSKbvLKldgWL9a/I6mgYFoHJzD6oAwMphXBepTeIyUVYraXoGk+LDPOwy8fRu1+Ab/5err+5x7Sv/vdMCPazFtvjXppqm43Tb/4xbHifl0dckUFamcnossVtq9UVIRUUDCsex/qcMOJ0Ks1VNNds8OBbeFC7CeeOO2DExgBysBg2iHOOIOUE97HsXg3ySWvo5lnYJLm4ut8DU2uAkBTKxFPeIPut14ma9MmUi64AE1RaHrggagXvXL0KHJFRfi2ujos6ekkr16NmJcHgFRYSPaddw77xTsU+6WJ4sY+mUbaT0QMkYSBwTRH6XyXvub/RG3bHPWZ+4WL0OQ5dL/yir4t1lDDyMZd0ekk+777sIcsWZmzsvB3dIx4uS0RR++J4sZumO4mjGEWa2BgEI044wySXI8gWEvCP9DmonbZ8e7ZE7Y5MgOINZMq6667cKxcqS9Z+ZVO2v5wN/U//N6Ql9tizVYabLjhUJcDx4pEsz7D1zA2RgY1CXH7PXr3v8OUdLxvx2CKoHS+S+/h69HkA6DNRdl3DtZ5l9L0wAMJZQDxMhu55Q28h6/vn/A7F++2U+h5u528Z58dNKNKVGAQvH6oICJUVWiSpLBx9+PNQFlf5DPOvvVWxJyc6TJmI4gxD2oqsM2zi1ubH+eAUk2JmM8DmdezJmnp8b4tgymCprrxdZXh77BiyXRhdjhiDjVMWr4Yf18NmpqOr6Er7stUU9107zk9EPT6MUlr6dkyD5Rs2v/zz3EDT7zlMdfzv0MwtwYUif1egj07dgScJsrLkebNI/273w2brTT79ttJWbt2jL614RNveRSTCUGSBgzIUwwjQE123H4P59ZewwHlmL9XiVjA/826nQJpzoiyKSMrMxiI0AzAr36M98hDCChoMnjemo377fbYQcbzBe69S/Q/W2aci9p7MDBIkUJ6ty2j7dcfxczKYtWRZn1vOfYz96DJBxBsC7HnP4bJfApVl1yi2yCJ+fng94dJ0idq3SderSxpxQo8paUT9r7HAKMGNdmpUxrDghPAAaWKn7Y+zbm117DNs2tI53P7PRzoO8y2nl2cW3sNq2qvinue4L5uv2dEz2AwOQnWfUx2kFueReufNaVp1Ti+ZkacmxZTJRfsuwr89zw9OAFoVGJfu5PkM5bHVLZF1pGkBS7saz/VszHNu5/e6huR68v14ASxZytNVOVcvPlR033MRhAjQE0i8sQsSsT8sG0uSzZHfM0cUKr5SfNjNPnaEjrXNs+xoHRD88PkidkAHFCqubX5ibBAtK1nFzc1/jtXNNwxrEBoMHVQeytQuz84FmTkKlTPh8z64SySz5wZ9TIN7bsSpFz9uCCaVoFU6CB1wwZdwBAUDABhAgPHlxf217FCjvd+AVK7LmWH2LOVjodAIhEiRRSi04lUVKS7oE/U+x4vjAA1iXCYkngg83o9SLks2cyX8qlU6gE4pNTws+anBw0gbr9Hr2MBVPuOckiuplDMBQJZWZVyhAN9h3nd/QE3ND/Mrp4qTvKuYqlfCU9mAAAgAElEQVTl5KgAZjCdUKODjFyFoLVhX7sTc3Zq1BHBvisp6xcIpqKITwuRK9149+4FoptrAX2qb/rVm/RsLIhgW4SYsQj7smXHgpSqknL22frQwIk+rj50cnH2ffehHDkCBO579qZNKEePTlt1n1GDmoS4/R4q5Dp+3vKfbPF+om93WbKxCGYkRF53Phm3lnSg7zCraq+K2r4h+Qxa/R0sFOfyXu9OFHyomp+FnWdS/+lp1LcL5M2ERcv3cN385ZRIBWP1iAYTFE110733NLS+Q/o2QSpEEEz4+8pxLN6N2R7bZ89bVkbny3dhW/MJcBi0uXi3n4J3l4CntHRQc1roVxoGXdlti7DnP4o44wzcO3bQ9dpr+Ds78Xd2kn711dgWL07ISXwojId1kq+7EbVtP0qjQONdDyakYJwCGGaxUwWHKYmTbfO5ftY38Ldp+AQVv99PktnOW56AeWadryluAAkuFYbWswotuTT72vig73NqlUaKJRderQ+Tz8rRnSupbw/sV9cOpo8Xkz4vc9D7NIQXUw/B7EDK+hFyw4NocgWCNBezfT6+ztcQbIswSc64x4o5Objfbsf9Th62E5bg3deC1nMEzOZA8+wg5rQQyMYsJ7yPX67FJDkRzAGVYWNQpt2v2Au+yAcbwzGUgDMUyftwUTrfobf6xkAAFgpxnLmMtrJjThjTRDChYyzxTWJkTaFebWJ772fUq8369hKxgDzL7LjHRS4V5ltyWGJdwAd9nwPHlvxKxALSvQXURpS1atqgwz3wb5vQGpdRt5qYDKc5VFPdyE3/gSAISJnfR5DyAsFJKsGe/+iAI+SD9Rb8Vrpe3Inm0ZCKivQeJcnpTKi5NjgpWDA78HU30v3Bn8HUBwTMY5sfeCChZxqKV994WCdpqlsPTgCaVolt9SdICwJ+htNRMGEs8U1StvXs4obmh6n2Hfsf1mXJZp7FyfWz/nXA3qhgZjPLPIOjvhae63yN/9f9dwrFXOZYMjnia6ZSqedryWvY11NP8ns3Ud9+LAMvTrey+fJ8HJI55vmbfG1sqL+JQ0qNvq1ELOB155MARlY1ARhuNuBz78Zb+yM0uR5/Xzkm6zwEKReb6xEsyScldO2gZF1IS0Pr6AhbgovVcxXvvpTOd+g9fEO/qi/QANz264+AwS2NhmpBNB7WSZGS/CDuFy6i68WdU11ybizxTRXcfg9/7PpHWHACqPE18PvsuzjZNj/usbEafb/qWEOLv5NP+/azvfczXJZsLkk+k13yASqp57xlH0J/DWpeusim9Vlxg9M2zy7+0b2N2ZZZ+FB1AccBpYq3ej7iobZnjSbj40y8bGCwl1/Y8pNUgGXGeYHsSZAw2woHvWboUpq+9JYZvlSc6BRaPdvQG4APY1sN0jsuBL91UOXbQCausZYFhzrmfjh4D7YjCIVhSkVBKMK7r2XCCz3GCmOJbxJSpzSySz6Iy5Idtn2+6KJIyotzVLR6LygpX2DNZ49cTo0v0HtR42vgc/kQLnPg/K8l/4metf/OWV97nz/8aw4rXclxz//nrld5o7eU7b2f4dNUzkpaAcB626n8qfNVMiwzKRRzY8rZDcaH4ThsRy0/yVWovQcwpZw96NLeUMdeJOK15++rCZtpBYBwGMeXFw3ocB5c0hyqV99QnNSHg+p20/DT++h9b9kxpaM2F3nPWWRc8yPyN2+eygKJuBgZ1CQkSbBjxkRhfzCq8TVQYMnh5xk/CFs2ixQpxGv03S8fplwJb2wsU2rZlP5/aGht4YBSjST6uTxzGZm22MEJoEo+Qql3X1igAzjDtoyvpqzmsfbnqPE14LJkc1bSCt7ylA4o5jAYG4aTDcQKCJpcRdK857E44mfBw83WBiP24MWFpF/9MywpWVH7h0377bcQyt60KWw5MfPWW1GOHoU4mVui2d1wCP5o6Jbz6du3BHPmSXj3tSAffA1rcQWONWtG7VqTCSNATRKCwWavt4JftP+OU2yL2Ondj0Uwc0nyeq5I/Sprko+9KGIt5S21LYhS75WIBSyU5sbcvi7pS6xL+hJ1vibyLLMHrRmpqHpQClLja+DXs2/nh82PRAWu9bZTBxRzGIwNwWwgstYz0As3ZkCwLcJsH7j+MtSltEQJNgBHSs5jBaeoab9z5uhBMhhwlJaWY0rAAWpykWPuR4KmuvH31WCyuvQfDZZZs+jZFj7GfjS+r8mKscQ3Cdjm2cU5/Yq4+9t/z5lJy/nYuw9BEDhRKuLrKWeFBad4S3lAmHqvRCzggczrmG2ZFXO7w5SEw5REiVSQkKChSHJSLIbLjItFFw1qCwcjMrcaXwPfSvuaIZQ4ToQ2h0YuH2mqG9XzBZp6TKEWNYm3PyAMtLQHYzv2InTwYsoJ2zGZT4lSJcab9uuX5cBL3+HAkpOjBycYn+GGSuc7dO9bhXvvErr3rcKvfhJQOIripHHBGA8MFd8EJVRpd2H9DynrX4IrFHNRNX+YQKJYdPGW82n9ZR+vEfd9128pkQoC546RFcXbPhS2eXZxS/PjHFQCMvUHMq7j8fbnKPfVhWVXC8R8nsn66YhNbg1GlzAhRL8ZqzjjDP1zTXWH9SAlwlCUecOlZ8cOWp55BhQFRJGM/kbd3t27abjzTt06KEjqBReQfe+9mB2OcR9uqKluuvetispGU07Yjvv9nXS9/DK9n36KUleHVFRE9p13Tof6k6HimyyELs9dnLxeD04AS6wLaFLbMAsmXSFXptSE1XJiNeKG9kYFs6JI4m0fCmuSlvKG8yk90NUpjWzxfqKLJYI1qDOTTmVd3dWGmm8CESWE6DdjtZywXQ9GwR6koTCWtRsIZEntL7yAUlWFUleHmJeH+9139fEbotNJ8rp19GzdCgT87mZs3Kjfx3go9EKJWc/zfoGvq4y23/0OFAVLXh5ibi6CKGJbvHhM7mMyYCzxTTAil+c+kw+Sbwn8QzkzaTmfevdHKeQiG3MjG3FDl+zGg9BlwWCwfMtTikUws9q+BJc5i9c8ASWXoeabOMR7cfrl2jhHJE4iyrzh0ldVheb1grm/9cFspvvNN5HLywFQamuRKysR8/MRnU4ybroJe8hLf6wVepGEOrwHEWyL8O5pQqmqwlNaiq+uDsFmo2f79mnXnBuKscQ3wYi1PHdW0gq8ah81akPYMtlgjbkjXbKLVAEO17ooNCOcL7pwiTm6JVOQ912/pVjOGHOfM4P4DLT0lOhy3njTs2MHDXffjVxRgZiXh1RUhOb14iktjdp3xmWX4fnwQ8TsbHxtbVFCiIGm3o42kZ6CtjkPUXvFv+tBFQJjN6SCAnKfeGI6/HswBhZOBmINJSwWXXwlaSWPdz4ftf+WvF8P2Jg7XLZ5dvF423PIgg9Js3Bxynqe7Hh+2E22QYNbVfNxf+vvw0xuS8QC/t5+NV233zNdjDEnLPHMWEeDUNXaaAS8mNNo8/Kw5OXhq68Pmwkl5uUFMixVBbMZpbr6uDszhNbz+iqPxqyD5T71FKnnnHMc7m7cMQYWTgZiLc89lHkD3595KfNFV9i+JWIBOZaMUR8kGGy4LffVsb33Myp89XzmPTSiJttd3oP8oPF+zq6/llq1kY2Os/RnuD/te3pwgvFRURnEJlIZN1rBKVK1pnS+O+JzylVVURJ2pa4OS0YG6ddei1QUaHgNzlhCVcNmLY22t10s9eNAhHoKijk5SIXhbhxSYSHJp58+avc3GTFEEhOQNUlLeT1EaBBcTvtl5g38uPlRypRaXJZsFluLuLPl12x2vzWqYoPIhtt5kpM3e0up9h0dVpNtZF2tTKnFjJmtzmcoEOdgqajn8Bj0yhgMj+EIIQYiEfHFUAmq9sS8PJS6On27VFSEY/16Wp9+Gs3nI+WCC5hx8cVYZs6k6ZFHdKEERAshhjNKI5gVqn31eGtvRvMeiKl+TATb4sVosqwLPaazOCKIkUFNUGL1Hy21LcBpzmK1fQkWwcxf3W/zoXdvWFbT5GsbcUYV2nBbKOZSJtfosvYaXwOH5OohNdnGc7CwCBYcpqSYvTLCOWupyPIb4okpwGiLL4LuFJ7t25GKivRBhVJhIcmrV9Py74FajlJdTfcrr9B8//1IBQVkXH11lBDCZA+YtPbsen9IdkwQnhV6q6/FbC3of7ZAAE40k4JAQ3PXSy+B2UzSihVgNtP10kvTWiABRoCaVAQl29t7P9Ml5jW+BuZYAoabB5Qqftb89IhHXIQ23M6xZMZ0h4jVZOv2e2IGx1ij6kOVh5EqqvI7NvKdH/lY0/R9Y1THFCCeam2g2VEDEepO0bN1K5jNzLjsMpJWrkRpagrLqOBYNh7ZnCwt8uoBRvVdhePMmUBiS8zR3oSHA96E1sAU36EG4OCPNKW6Gk9pqV4jm64NukGMADWJiPWid1myOeILzIIqtOSySz4IMKKMymFK4qHMG1kg5nPE16zL3IMEbZBCCZ3/9O0jd/GKe5t+zURk78GXR9ab/8P9a49wUK0New4jk5q8DNeFIh6RGbeUn49nxw46/vxn1JYWRFd4rTb0RR+Uu5vsjGj2UjxvQkHK7X/GhUMOwBnXXTdpxtSPF0aAmkREvugLLbmcYl1IpVKPy5LNEmu4mi9XnM2G+puGnVHlmjOZY8nkTPupekYVK7iE1pjOTFpOua+OKxvu5JyQawbrau+7fsvrzidj1srMDgdNOdYoW6QDShV1vqYh3bvBxGI0xRehGbeYn498+DBKTWD2WO/HH2M/6STdLkgqKor5oo/nhm47IQMYvFE3ZlYozUWT6xGkQuyuh4fktFG1cSNHrr8eS3Y2uU89Rf7mzdgWLx7yQMmphiEzn4S4/R4+7d3Pj1oeBdCHDAKsti1hu/czgChLpODQwMF6mGJJ3dfbTuVnGVfp4zxC+6EO9B3mioY7WCzNo9nXrk/mHco1B7p2iVjA/2g/YUZG3rT/RTnVGIowIXJf1e2md/duar/1rah9Z3zjGwhmM0pVVcw+olg9X1BIyz25CH5rQnZMSue79FbdgNa3H0EqxOJYjh8NKeM7SGlfTvj5Yw1OzLz1VpoeeGA6tV0YMvOpgsOUxDL7QiQsVCr1bO/9jLn9Hn1/6P4HPk3lq0mrowYaJpqJxBI1bPF+jNUksct7MGqUe72vGVXz81LPVurUJt3hYijXDH22sOVAk5Pb3ptD49lfS7h4bTA5GMqcqFj7mh0O7CefHCWwEV0u5MOH6fjTn+I6McRcdix8grz/+HXCs5fkL6x0/N+luF+4CPcr5yP0XUby3F/FDU6h86iCxHJ798syTb/4hdF2gZFBTTpC3Rx2eQ9ya/PjyPiisqX1tlOpV5vClstGkkGViAX8LfdhLqq/OSqz0tBQBJ8+Kt5lycYimKlU6oecQYXeQ627Fm77JbzxHr6SAloX55HdaaL4wcdi/toe7UZQg7FjKCPXB9u3Z8eOY757LhfS3Lm6nHywZtzhmN/GuyepuJg5jzyC5HRGXS/UMDc0I4p1ntQLLqDrlVeirjn35ZfBYpmqTitGBjXZCRUinFt7DQCvO5/i4cwbo7KlLd6PuWXWlcPy44snamhTO6MyqzxxNhX9Db1Bf0CLYGa1bQnrbacOyQMwVAXoMCUxt9EEb7zHwevO5uqH0rnkO9V8+7oetnV+FHXsWDSCGowdQ5nqm8i+luxsklasQHQ6MaelAYkJDUKbZUd6/3JZGU333ReVDcYb2thXV0fv7t1kRfgAJq9fHzVyI3XDBupvuimQQV566bRZSTAadScJ8WY8ve58kmW2hTHdy89MXs6ZycuH5ccXq1nY7few3nYKcn+2BLCtd1fYIMJl1oVomsYfuv/BggjF4UBefrEGLJ6eUwznrOXBc9o4ZAksEx6yNPFT35943X+afo5Iya/HZ6G66l3mzj8Fh33K/dKcEgzFQXygfSNf/hDIZOa+/HIgWI1RphHrnsS8PJSGBpTqan0goskOSnspyWfNBVMf8sGAmMN+6qnUfvObgSGKTifpP/gBSSefjJCWRu2VVwZcJTQNpa4O+/LleD//HPnwYQDk8nIa7r6bgv/+76mYSYVhZFCThHjNrnW+pgFl3EMZOBhJ5LG7vAepVRv1bOmrSas57Dui718o5vJp335928EQiXhk9heqKIwXfHuTTMjX/W89OEU+d5BQRdZn2s/49q7fc/Fbl7HxvxrYUdMz5Oc2GHsScRAPWgeZ7MTdN14mI1gsY/ryjrz/oFFtqI2S0vIm3XtX0nf0KyStf5PsR+Yw63vLsZ92Gj3bth0bolhbS+vTTyOkpeHv6EAuK9P7u1K++lVsJ5ygByf9GSsqkKuqxuz5JgpGDWqSEK8uFFrfGY2Bg0O5fmSda7V9Cdt7P4s6dkver/lB4/1x732gAYt5ltmcU3vNgLW0oCLL47Pw7V2/p7zj2MJAcbqVzZfn45DMI/8SDEadeA7isQYnmsynRO07lFrWWN2/XFVF0yOP4Nm+Xd/uOHsVM/5tF1pfiDO8VIBJOhX1yCpaHn1Bz6aCOJ99FvtJJ+nPk7x2LXJlZcDk1u+PMr/Ne/ppbAtHz5LqOGPUoCYziTS7jiRbGox4yr7QOpekicyLGPk+X3ShaVrc7A8GdppwmJJ4cJDnDiqyms0XhAUngLLWPo52+RJ6xsHMPodqBmowOLHmRMXz7jPZidp3vGc5xbp/+4knRtkoZVzz9bDgBGC2L8AvfwqpN5J5Rz2zvrdc/0x0OpH6ny170yaSVq9GrqxEqatDqa5GKizU61JiXh72Zcui6lRTESODmmSMZZY02HXjZXAAdb4mmpV2/tL9Tz707qXG10C+JYdiyUWt0sDJ1mI2u9+KOtbu8aMcPcpHs9u5reNX/TWoQBAKbeZN5LndvW42/lcDZW2Kvi3RDGqwUeeDfW4weqieL3DvXRK13bF4t25iG6nYHM9ZTvEI3oM5OxWEBjyV39SDrMk6D01T0eTQpbpA35Xm0ci49lrSLr5Y/6R3716qLroo7Pxifj5Jp52Gr76e9Kuvnmp9UcY8KIORES5kCA8ioQFsjW0JaeYU9smVumdgsejCaZ7NFu8n+rFf2u0Nk96m/uIOWhdljyj47qjp4d4tDZS1yhSnW9m0PouVruQBBRqDDerTVDfde1ei9R089rm1hJQTPzDk7GPAYH8fE/nHQui9WdIvR3WXovVVYE67CLXjb1H7i0kvYslagZSZGba9e9s2Gu+8M3xZz+kk9/HHkQoKpqI4wghQBiMnXiYTWkcaqBZlNUnkWWZj9/ijagfCOWvx3/8TXA7niLJDt6xytMtHTqoFh2SOqRAMzc4G+8Xu6/6Qnv1roz5PXlSKxTHy8SYG0cQbnDiRp/7GujeTYx1mWzF+k4i/47WwDCrefatuN1Vf/zpiXh5yRUVg/IbTif3kk8n4wQ+wTs0RNEYNymDkxKtzhdaR8sxZFFjmhH1eIhZQJOXpx0aqrw5edzbfvq7nmIN5z65hjw1xSGaKM6w4JHNchWDoeSN91Xoti6mx3k4vTpTOd/C2PocQMfdKkArw+9qNetQYEc+7b7RHd4wmau+hqHvzu7fi93ejNv0Kc8rpCNYFwMCGucrRo8gVFbqSL2nFCjAFXtXTzd3cCFAGCRFvlEaQoIhjve0U+jSZL1kX4LJkAwFT23syvhcW1EIdqX0lBWG9TrliFjc0PzzisSEA1Z4WsjwLKeTYtNJImXqo7c1n2s/49md/CMjUn2/kvcoGDnemIDsu1oOUIBVgTl5BX/W1RlPwGBKriXa0R3eMFkrnO/TW/iz6h4xtEUmuh3Es3k1SwROknLgjrmFu0ArJlJam/9sIjt/A72fGxo1TcWlvQIwlPoNBGWyJLJSdvV9wVePPqfE1UCjmMseSid/v5/7Z13Ji/6ycIEH7l9olWVzynUCGUyjm4tPUsBlUw7VL2lHTwz1bGihvlcmdqXHCsv0clSowJ7n5nfPW6HlWMUQWzlQLJpOAKCjctnQHX7I9h6YJmMw2fJ2vARNniWm6EG/573gRurRnmXEeau+BwOiNAe4t0vg20gop/bvfpfU//zPw53nzmH3bbaSsjV5mnkIYNSiDoZNI/1Uou70HWV/3/ajtr+U+yan2RYFzyipHuxRyUkXsci+dLXVcIDzIQaU6bv3qfddvExovr9+3rLLxL1WUtcrkp4lkp4hofj+NPSpmk8ZdZ85hpSs57JiyFi/nP3s46lwrnEmU1noonCnwp7XPYpd3orrfCdsnVGFmMPYM10NvLIisYZqs8xCkXGyuR7AknxS1f2Qwmh3iXB7EWlxM3rPPonV0HFdl4jhi1KAMhs5ADhaxCJ3GG8RlyebB1t/zUve7vFfdwca/VHH+s4fZ+JcqPmoTmFVQovc6xRuQmOh4+SBHuxTKWmXWFiSj+qG01sORbpWVrmQq23zcu6URt6yGHZOTKlKcLoVty0sVaegOZFSV7RoN4hX4IyYMT4QlpunGcD30xoLIZUd/Xzl+pRmzrTBq31i+fE33348my2H79ZWVoXV0RPV9TTeMAGUwIIONa48kdBovBILTfCmfd7yf8JvWf3L3lqOUtQb+MZa1ynqgCHr//THnXh7KvGFYJreh5KSKrM5PorJNpq4rEGDquhR21PSQnybGbOB1SGY2rc/Wg5QzVaQoXaK6I3B8XqqIxVaY8HRYt6yyv7GXvQ29UcHQYOowlInBMa2ZysuxLV4cts0Y9x7AWOIzGJSB+p/isddbzk9bn9ZHcACsU85jz6tfi9r31SsLKc6whm0bjYbkVw92csMrR6K2f2W+g/JWJW4Dr1tWqWqX+fu+Tt6ucFPXpZCXKrIs185dZ2XjkMyDLjHtqOnhhb3tfFrvpa5LoXCmxF1nZUctK05nptp4lESWHeNZM83etInG/swq6IYxxRpxB8OoQRkMn6EGjFi1q1WWU+ne8i3q2o/tN5Zeefsbe7nm5Xpqu46JHvJSRc6Y6+DL85LJcYjkpIpxr72jpodnPmpB8YNoErh6eXqg6TekhhZ6bHB7mt3ET/55lKp2Rc/eAs8q8chX5uCcKU17b8CxaLadLAEvtAYVGowmghvGccQIUAbjyzbPLm5pfpyDSrW+1GdpLubopyupbSfM6WEscMsqd73VwKf1vWFZ0CUnzuDeLY39bhMSm9bHz2wim37DnSqOHRu6/YIFKTR7VEproyX5K5xJtHl8A15zqjMWzbYT2V0iFtM8GMXCCFAGw2cgq6CY+wezCYfKR75d/L7jZd3m6MGZPyJLLtJf+mNJZBb07VNm8sC7TXodDBLP4kKVgaHHPntpHlf+tVbfnp8mkpVs4Ui3LyyDyksVMZugukOZ1i7rQ1W9DcZEdpcwSJiYAcoYWGgwKEPpg4JwP7yiWRK3f/lkfuf60nExuV3pSmZxtk3PgoLqvlCCgonijIGDRbxjDzXLyKrGCmcSDd0K1R0KBTMlluXaAfTsrShdYuvhniFdcyoSVL0F+obORe09iL97K56KK4aV+QzkLmFI/yc3hopvnBnMkWGikYhVkFtWKWvx4pZV3LKqByeAijaZu95sZE+df8xGgQxGqPVRLCl5cbqVnNTBf6vFOnZ1fjLNPT40LSBlV/2wbm4yR7p83LIuk0cvmMNvLsqjYKaoB6ehXHMqElS9mVLOQu09iCZXAcfGagzVPmoiuEsYo1jGBiNAjSMDTZWdaAQDaYVcO2Af1I6anrC+pvere6KyjNouhc2fd04IqXWklDxYB0tkqS3y2A0LU9E0jcc+aKGm85iUvbJVZtOXZ1LeqnDb60e56m91pCeZKEwLrGIUz1T56Sp5Wi7vBRFnnIHd+XM9OAUZqq9eUBhhcz6KedbGwHLhADLvsUDpfIfufatw711C975VyC1v4i0rQ3UbwWqkGDWoEZJobWYwR4ah1njGktAlvfW2U6hVGylTjr009DlQPisb/1KFrGpkpwQaWp0zJI52K1S0HQtSwdrLrzY4o+Tkx4tI8cNQj61tV7jpn/WkJ1liiiGeP3cLP/34LMrb/Pq21S6B78/fgqS1kCPuYXbJ76Z1jWSktaMwYYQ0F7N9AWpfFXbXI4hpZ4/lrevEeobgnCf8VrKnn1x8uBhOEqPNUDKigRwZxjuzGmiZMXJJb4v3E5ZaS/TG29DG2aNdCjkpou7UoPrBbIJrV2bgTBUB9NqLZDZNqCWt0GW/4RxrMUN5q0xDd6C+FErxTAWTr5XyNj/5aSIrnEnkp4lsr9F4ruY8Ln37Ur714R18WN02Wo8zKRlKg2skUVN35cOovQcQNB+9NT8et6W2WPUvqMR2QgZyWRmN995rZFIjwAhQwySR2kwo8RwZZplSh3SekTJYMIwVSDe73+SZ7J/yvuu3vO58UhdIpNlNHI5waqhslVnhtHPfudlcsCAFswmOdPkSXkabLATrUdUdCkXpkh6k5s1UueXEl8j2v8SGEjv+/uDt98MFC1LY0xTIqMo7LNz7njIhlj2PJ/HGagxGTGGEXIUg5Y7r+A2T1YVgjRBiaHPx7msBApZFvqNHx+VepiJGgBomiXrUBbMVgAf6/ebgWCbSpnYOyetuJCQSVOMF0gJxTpTIoaPXH9YEC4F6U0evxkqXg3vPyeFXG5xsvjx/yvX8hNajth7uoWCmyGNfruV3S65kCfcC8HmDrH8/tV0Kexq9Yecoa5Wj7JamI8Px1YspjJAK0OT6cRVIeD7ag6/qIgRz0Km/EO/2U5AP1gCGZdFImThrLpOM4Is8sqYU6lEXS579uvOpMLm12+8Z9DyjRZV8hAzLTAoJvBTnWDI54mumztekO4UH5zpFWhvFqoul2U04U8WwIOVMFUmzB5aTA8toUydrimSlK5nNlxfotSxr72F6q31oPjhiuYLDHeHZUXWHwlfmO3Rvv+ms5BspweVBfeyGVIjZPh+1r2bcBBKq2033u+/ifvM9hKQckletQcxbhvutwGj3oEuE0Yg7fIx/HcNksDAw+KoAABb3SURBVBd5vGzldeeTYWMjhhIQRkKoq8NcyxyWWhfwYs875FtyqFeawu4paNw6WN9SR6+fwnQJjWO9PoXpEh29Gpn9CVM8W6BQEtlnohIWhKUzsJzwPkrn25gaOshLFaMaddPtgX9yQ1EPGsRGnBH4vv1yLYJ5FprapvvgjYftUV9VFe4330SpDSwnygdrEJ1lzPmP/8CclGS4RIwChopvhMTzqDvQd5hVtVdF7R9vrtFomKMOdI/n1F7DQaWaQgpxKvPx2Vs5KhyhUqkf9kDAoLOCrGosmm3FJAh0ev08cWEuANsOu3l8RwvlA1gKxbMOmuy4e93c9U5nlM3SLesy6ejVxsVFYzKRSEBJNOiMl+1R99at1H33u1Hb837zm6k+XHAsMFR8Y4HDlBSzATVWLWe9uBpfZ3rMwni884wG73o+5aBSzXk9/xvHezez59Wv0b3lW6zvuQyIX/MKbcCNRbAOc7ormX2NffzjYDdHuhTeONTNdS/X8cv3mimPMVoj9PyhTb2x9pmsOOwOLjkxjYKZARVfwUyJS05MIzNZGrZ6cKoS2UekdL47rH0ghrqvv/nXLzeOeiOtddEiRGd4rUt0OrEuNNwrRgsjQI0RwaW7YJC63PsDurZcwUV/qGPjX6rYUdMzyBlGB7ffw7Md/8Mqy6k07FypO4nXtcMnpUUUUhiz5hXZgPteVXecYKXR7vEh9P/+qWyXeXJHCylWU9jyFhA1g2kg26GpwEpXMk9cmMed67N54sLcKZEZjjbxAoqmunV3Br/cGHefSOLZHnlqfjRocBsqUmYmGddeqwcp0ekk49prkTIzR+X8BsYS35jj9nuo7m3lR3+V9WwCxnbMRCjBpcabTD/k93+bF/X5v53fzmm5aaxOXXTsnmOYojpTRUwmkMyCvgz33uFu7n67kZrOaK+5ry5IYfdRb8S4ifBnjme+Ol1NVKcjkcaxQezzNuOtuxPNux/zrI2obZuj9nEs3h3ltRez+VcqRBBM+PvKA38ehpGs6najNNdgTvNiSZ0fdqzc3KyPbzeC07CZXEt8gy0vTRYcpiSk3syw4ATjlykElxqrpf3kzgz83gg2jy7PtfHaB7P5xYvWsIwuVmZT26WQnSLqy3DNPTK/eLcpzOKnolUmP03ENUNkb6M3rD8oUF8KFwWMxHbIYGoQ20dvIX2NzxzLmHp2IkhzI/aJLSWPbv5diNk+Xw9OMHQ7pZ4dO2jffCt9zRfhKTuN7j2nh2VhUmYmjtNPN4LTGDDuASoRs9TI5aXBlsOOtwHrYNe3JXnImxm+zTkL0hxjH6CCS43ttLDw1D2cX5KsOz80uFUKZkpRtZ9Ypqh5qQErIzjm4B1qZwSBILUww8o1p6UjmYX+/iCJpy7MZfPlBTGXuIJS7VevLJyS/VIGA6MHFKkksEGbC91fR0DBZA1k/P6+csz2BQi2wD6DOU6ENv86St5A7QvvM0y0T0pT3SjtO+l8+6+IJ74JBPoZNfnAsExtDYbOuMjMgz5zzb4Obm0ZeGxD7MJ5Aw99XSQ/KSNKRDDUURCjzUDXd/s9vNXzEf9wb2fR8vkIHy+mtg1yZ/rJ+VIprSY7mYz9C3lN0lKW2hawNXkv//5xD3Vdge01nQp+LZBRhY5/CGY2wb8HZ798PLh8V5xuZX6mRHG6FJZpuWaIXL50JitdDs6Zn5qw191U75cyGBiT+RQ6nvkS5pSFWBdmIZ3wZ9TuSgSpAMuM8/B1vobaV4Oj5M0wKflABJt/lc53MCcvRfX3BpwmrCUJ9UmFKgFTL7kYtftw2OfGOI/xYcxrUMEXuIyPE6UikgU7z7lfB4gpby5r8XL+s4ejznPi+f9DU9L+qAAwkAHrWDPQ9Xd5D/Jc52t48DLLlMq7vTsx++ycpJ6C3eFll+/zcbvPIPG+28CUVzWq9hM0VG3xKCETaI9NwQ2ViM+bJXHbl2eztiBl3J7HYGrgLSvj8PnnIy1wkXFHHcFMBQLuEIK1GFvOjZik3CH1NYXWo4JDETUkHPOfH/AcfrkRT83NaD078feVY7LOQ9NUNDnkvoyBiKPN+A8sDDar5opZlMk1vNzzHvmWHC5xnMkL7rc5oFTxae9+ltkX6i/qNIeKcybUth87T+5MP3XiISqVah5v+y+SBStmIfAijWUTFHnOsSKe3VGFXMefu17l4779mAQBVfNT7Qv4cVWaK8lXcngs80djen+xml+DS3ehWU9eqohoEmLWfoKZTTFWNl9uj8qIIp0UjNqRwXAQc3KQiouxnZACbAv7TJOrsDl/SW/Nj/S+JmvOTYgzzsMkZQ143lBFn7+vHPrrUANlPoHM6QY074GwDM4y4zxUVUBTKxGkxLIwg5EzphnUgb7DXNFwBz5NpcbXoG+fa8llqW0BTUorR/wtSFj0zOhA32HuPfAO9Z+eRn27QO5MP7nLSnkt+U+cmbScVCGZT/v2U+NrYJ3tS9T6Gqn01evnzrfkYBZMYeccCkMZexEvg3pq9i18u/FuanwNrLYvYXvvZ1HHxmvYHQ0Gan6N/Oy6lRmsmeswgovBcaVnxw463/4rjgv+EZ6pSIUI1kL83W+FbCtAkFxImd/EmvnNuOcc6jiP2ArAAgTBgiZIWNOexZTix5JabASn0SdmBjWmAcrt93BD48P8vefdqM9W25dQrzRRJDl5y1N6bMYQcG7tNciKmSX+U2mUKnnf9zGFYi7ZpnTq1KawYHdx8no+7dtPte8o+ZYciiUXb3lKgaEv9w2nnhV+TMCmKNWUxPq67wNQKOZGBeixXIZMRLo9kllIBgZjhdK+E7npLtTeA/3O5AVYZm7A7/kMTa4PU+KZU9bh76vFsWjrgJmU0vnuMb++fnFF0FUi0plCbvs7veUbo85hnnUZ1syrxsSNwkDn+MjMZ5tnkW8Jd/N1WbIRNMgVZ+NReykUc3U3g6DqTBJVXjQ9T64tjWLRyRxLJtliBi4xm0IxVz/Xiz1bWGZbyDdTv4pZMOnBCYbmCj7U8RlB1iQt5W+5j/BizkP8Lfdh1iQtpUv1UGgJ3GOlUs98KV//DsbKay9IIs2vI5mFZGAwUjTVjc+9G597Z5gSzpI6H7WvGkGwYE5ZhzllDb72/0Ht3oqm+bDMOA845lquyZWovV8MeK144zyinCk63qSv8RmEiFUNwbaQJNfDRnA6ToxpDapOaeSZrhe5xHEmglegyncElyWbs5NW8KanlBpfAy5LNl+2n4KEqLsZRJqVArzZU8p9rb/hcP85zkpawVueUuaJTjp8XXymHkTV/GHXH4or+EDjMwZaiovMuu7J+D53tPyKNfal+HoDmdMhuZpVtpNxqlncl/EDTrRGN8yOFrHqTIZrtsF4EM/0NzRT8bk/Rm55FrX7g35V3QLsBU8gzjgDwezA5noUueU3IDejdm/Xl/s0uQoVMDnWYDIn4/eWY067BJO1cND7Cir6Qu8nypmi5kcImoLZXoIKegZny71j0FqXwdgx5kt8wRpNoZjLYqkYkybwqbw/bMmryJLHI5k/ZE1y7OW0WLUelyUblzmbOWImd2f8G23+LuqVJu5o+VXYcluiNajhKAKbfG38rPlpdskHqVQCdbD5ogsfgX6ibFM6JpOJI77mEZmyDpXwOtMx1Z2BwVigqW52VLXx823KsbrnGpHTCmbhc38cZtxqTj0TteMVNLlKPz5YFwrdN557hCXjKlDqUHsPocmHdTNYi+MU1N5DgBmzvShujcnfV4Pm99LzxWlRn5tnXYba9vyQFH8Go8b4L/GF+tFVKvV8IVdSJOWFBSeACl8dbf6uuA2vsbKbGl8D6ZY0NrvfpM3fRYlUwJnJy3nd+VTU5Neh3isMvhS3zbOLDfU38ULPFnyayllJKwA4pNSwVFpApVLPQutcapVGKpV68i05XJu2cVxk5Ubzq8F4oXS+Q9OBb3Pvu53hvYtbO2gu+wlttU9SpZxGr2Uxmnd//9JcVdg5NO8XqL1ltNU9re/bqyRT63iMvqTz9f0E2yKs2T9E9VYdy6y8++mtuh73wUvp+eI0POWX4qm6NspvL3RJr7f2ZwjWBWGfC7ZFSBnfQbAtxN9Xjl9pxjbnx0ZwOs6MixdfcJTELFMq1zQ8QKXvCFW+I/rnLks2Z9iXscP7OWVKrb5UlmvJJE8MpNexMiiLYEZCHNWsJJGxF/EyuuD9PJBxHY+3P0e5rw6LYNYHAw7nXifzrCSDqU1Q9ValnMYl794Y9fl96638dlcfFe0wL83HrYv/zpesz6FpfjS5Ut9PsC1ib/LfuPddN+UdFgpnmlicZeOlAx7mzVS57Uu7WGJ6BHv+o5jE2TG9+8wp61C7twbOJxVgcqzCmvUDBFQ0zHjr7gxTAlrS/xdqz84o8YSmuvHLtQk1AxuMKuOv4ovFNs8u3ujZwSs92/Ua1Crbybzv3R2WWRVYcjCFyMUBvdZTYMlhnuSiTmkcdBlvKLLxRPePN+vpkuT1XDHjq6xJWspu70FdyRfKUOTlU3VWksHUIGj02mtZzLd3/Z7yjmN1TtcMkSyHhY/re/VtxTMVfrf8HlKSc/B1vq47O2jO/+QbL6dH9eeZTYEpxMUzVTZfloUjOXNAKXioyk+cfS2+/qVEQSrEnHwK+Lvwdb6m75N8wicIJtEIRhODiRGgIFC7+V7DL1AFP0d8zcyxZMbsFQr2EIVK0IOZWJu/K2xsepV8BBWVIsmpB5ZQAcMCMZ9bZl3JmcnLB1y2S0Rmvq1nFzc0P6w330Kg9vRS7r+TZLJRpzSSJNj5lyM3h+1TYMnhn3lPMNsya9DvyHD6NpjohAaLz9jEA3v+hfIOC85UkVUFyfzX5x1Rx7xymcr8nAJUbyVoKmZ7MeXtlrgOJ6W1geX+Vy5PYkFOYPk9UjpuTl6Cr/Uv+nEmx1o0uTain2ougpQHylH8feWGE8TEY+IEKIC3ez7ix82PUe07yunWkziqtiAIgr4c5tNULIJZFx/Eyzy2eXbx565XKfXuo8bXQLHo5KHMG1lqWxBzGW6eJY/rZ30j2gMwQZFEcL88MZtDcjU1vgYKLDn8MvMGJEHUA9wlyetBEPjUux+Tz6ZbHF2b+S8JZVDxbIlevbKQ4gzroMcbGIwHocHCm7yBXcIveXhHQCSk+okYtyKx+fKCqB9YsX6MRWVQ3yjAYT8WTEKX4nzuT+itug6t7yCCVIg44xzk5l9H3as5ZR0AfqU5rB/KYEIwscZtrLCfyMXJZ3Bh8loa/K2cm7wSVfOzvfczVM3P2Ukr9OAUTy7u9nt4rO05PTgBlCm13Nr8BFXykZjCClnwxexvGkhmHmu/tzylWAQzq+1LMAkmMsxpYX1UmgCfeL9ghftCUrfdzHuvrOOL18+l6WhaQt9Pmt2Es39URRBnqkiaPebfo4HBcSG0z2h2ye9Ylp+L3x8ILNHjVrJjZv+RY1eKZoosmyPqwemnayxhwQmOSccFsyNwDyfuIHlRKfZ5f8HXWxbdzyTNRUPC5nokrB/KYGJz3Jpj6pRGPpb3c8TXzBLrAv7Z84G+HFbtO8rbno8oFHMDooM4arp3PZ+iCL4oVeABpQoVPyViflQGFZR8R/Y3BecmRWZQkYExdL9KpV6Xj5sx6ccWirl84v0Ciy+JLz76/+3dXWxbZx3H8W/ic07qNM3qJllenDhR1iawdVPaQdZBJbiY0MaEBIhJ2zo2IQESLypsSIC0Xuyy0qYJptGLXSDQJKATSIMLxiZaVkHWsaSr2FR1zbqsceokbV6cjcZ1fI5tLhwfjt9ip1ubU/h97vLi5OQi+ed5nt/z/+8kttpXcCoOB/+2yO4HtxR1dSgNQSxdztDfYpEl919o92pH8aXLWdp0DCU+4r1n1LYZvn9nK88en+fY+8sMh4N8d08L9ww2r7k1XdzXkfRlvrUbwltbSopTpWcwmnaRTV+ivqEdzBbPfaZ+AlvuxGp9BGPzbR/Xjy3XwIatoLrNdqysgZNNczG9WHBWA3DOmeGptkcrxsXzo8wzmQwRo6PgY58w+7jJ6uZg234GV2PjEaODAavXLSjFhadSzBwoiL5X+rw+q8t9X5fRRtSZpcceIBYvXPF4uzqsNfeqs9lk+kObQH1uLz5QD9P5X14RH/vqzq0cfjDCr7/Ww8++1MV9t4ZqOjf1djhpCjYx2NlbU3HyyqxEcRZ+QybxJvVNw5it36S+6VM0dDyqVdN1aENHvufPj2L2XEmPvWqXWvNJursa76C5rpGx1Qay280enmr7YcFIjmOJN/nV0p84mhyreoHXGzM/mTyz5qyn4jh6PmTRFggRCjSzlFohfuTrBUUqH3QAqoYgdOFWZH3W2yBWfMNfIQnI/ZH/xvQTbDWauTGwjZeWR5h0ZmrqAhFNzbopuX4zzFDDIE0E+V7oPrY3RNyvn4+MA1XvNxU/23o6S+S/16Q9wxMLzzFuR+k1Orkn8RDHX+9jKk5Bkak1BKHGriLrs1aDWPGtaz8Pqprz9gWOJsfct/vNMHuDQ1X71V3KJPjXyjif2XQb2WSWCTuGk00zYPUSS8+znUjVyHilaLr32WrtzecdypjOZgg4QT5n380U4xzdfJgX7n+aD/4dJAD0hHIHwbX2zNO0WZH1MW/4PMYtI7pw+z9gQwtUcTBhwo5hYdJndlV8jbfw9BqdfHrTLUTSufDD2VSUT1p9FTuT51c/f18+yZHEG5xInua1lbfcaLq3gNUamsh/rxQOezcNcXE2ROzEHt6O1xEOZQnf/jpvZZL84li85MKtd6x6fnWlVZLIR1fcIFauTxu6xQfl5ymtdT5UvO2WH1CYzmb4UWgf+274YsVODyORXxKzL/KTuWfcrugDVi9/TfyTQbOX59ofp8/qcldTR5bf4MD8IcbtaMmzXXQWOb0yQVNdI4cvvcLplXMYmSBLRx7mvGcacGQbRLY08o/J/8bavWdN2sITEfHhFh+UjtZY63yo3LbbpDPDY1v3MZo8xe3Bm4HS1U+/GWaXNUgjmzgwf4j3V/sA5kMZ/WaYM/Ykjy8cYt6Jc7BtP6mszYH5Qzikcy2Mmu91i9NvP/gLT8afZ7vVw9nUFJPODBGjg7vTX+b38YLHI7oInUW5hnySb0drQFt4IiIVbHiBglx0u5buCuW23SJGBy8uv1owTyofBf/p3DOEzXbOpqb4w/JRINdt3Cs/lj2dzbh3pP58aYSXE8fd6PuEHeNUaoKXg8+SyCR5Mv48gbp63k1F3SIXdWY5ZZygO3RrwQpqR4uFWRTm13wmEZHqNuwe1JUovoPUZ3QyYPWWvcybn3Q7Zc+6heZk6kzZ6b5kYIcVYcKO0W+GmUnPldzLesc+x+TlBcYuzBNwgu5dJ68RZ5ThPe/RE8q9nTtX6uDbw63uLXmdNYmI1GbDz6CuhHd8h7dpbLFyZ1F3Nd5B1J5h3I4yYEZ4LPQQL3z4ipsm3BsccnsBegvQA8nv8N7Ybs4upOgOwc3Db/Na04sFn5Pr9dfDD5ofoT11U8G5ks6aREQq8ucZ1JXwbgneSOXO4OW2BM/bF/hj+OmCwtZhtDA9N8c79iRW1iRAPf1WN7C6BWgM8+7oEBOLuUj4+TgwupPPfmGaOkbdu1s/3vZwxW7pOmsSEVmf63IFtR61pgTLdZBI4bDLGuQrmfvZ/zu75DU/f8BgZ+sWEiRrvgAsIiIl/NdJ4lqpZUruWq/BadBsJhGRq+f/t0B9HNQXT0TkqlGB+qgUdBARuSpUoERExJf8NVFXRERkLSpQIiLiSypQIiLiSypQIiLiSypQIiLiSypQIiLiSypQIiLiS9WaxZbNpouIiFxtWkGJiIgvqUCJiIgvqUCJiIgvqUCJiIgvqUCJiIgvqUCJiIgv/QeEILWceHgRpgAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "GMM_class_labels = GMM_class_labels[~np.isnan(GMM_class_labels)]\n",
+ "GMM_class_df = pd.DataFrame(GMM_class_labels,columns=['Class'])\n",
+ "\n",
+ "full_data_df = pd.DataFrame({'Waveform': full_data.tolist()})\n",
+ "data_classified_df = pd.concat([umap_df,full_data_df,GMM_class_df],axis=1)\n",
+ "\n",
+ "f, arr = plt.subplots()\n",
+ "\n",
+ "class_labels = [x for x in np.unique(data_classified_df['Class']) if str(x) != 'nan']\n",
+ "\n",
+ "for ix in np.unique(class_labels):\n",
+ " filt_df = data_classified_df[data_classified_df['Class']==ix]\n",
+ " arr.scatter(filt_df['x'],filt_df['y'], s=30,marker='o', linewidth=0.25, \n",
+ " edgecolors='white', alpha=1, c=GMM_PAL[int(ix-1)])\n",
+ "\n",
+ "ns = Line2D(xdata=[], ydata=[], marker='o', markerfacecolor=GMM_PAL[0], \n",
+ " color='w', label='Narrow-Spiking (NS)')\n",
+ "bs = Line2D(xdata=[], ydata=[], marker='o', markerfacecolor=GMM_PAL[1], \n",
+ " color='w', label='Broad-Spiking (BS)')\n",
+ "nst = Line2D(xdata=[], ydata=[], marker='o', markerfacecolor=GMM_PAL[2], \n",
+ " color='w', label='Narrow-Spiking Triphasic (NST)')\n",
+ "bst = Line2D(xdata=[], ydata=[], marker='o', markerfacecolor=GMM_PAL[3], \n",
+ " color='w', label='Broad-Spiking Triphasic (BST)')\n",
+ "\n",
+ "arr.legend(handles=[ns,bs,nst,bst],fontsize=12)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['bottom'].set_visible(False)\n",
+ "arr.spines['left'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.set_xticks([]);\n",
+ "arr.set_yticks([]);\n",
+ "plt.tight_layout()\n",
+ "f.set_size_inches(6, 4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "0CPLlCn2Kj1N"
+ },
+ "source": [
+ "### Here we also show all the single units per GMM cluster with the averaged waveform in black"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 42,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 489
+ },
+ "id": "kVwRMJ5JKj8I",
+ "outputId": "7f375b67-27ba-4119-afb4-9761de1e76ae"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIgAAAB2CAYAAAATIts7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAdqUlEQVR4nO2deZQdV33nP79a3tpv6eW1Wt2tfbE2S1hGBuOVzU4Ah4TNCcwAZ0JOQgKeZCZzDiaQQ3DIMmFmwpCEmUxInAQnQMwesGOzGMvGIXiV3bZsa+1Wq9X767fXdu/8UU+iLbufuqWWuhXX55x7zut+Vff+qupb997f73ernmitiYiYC2OpDYhY3kQCiWhJJJCIlkQCiWhJJJCIllgL3D5yeS4+5Fx2jnqQiJZEAoloSSSQiJZEAoloSSSQiJZEAoloSSSQiJZEAoloSSSQiJZEAoloSSSQiJZEAoloSSSQiJZEAoloyULT/S9LHF9R8xQNT4NAyjZI2gYx85wy6RcFssBV7S+b9SCOrxit+JSdgIRlkIoZJC0Djabuaaquwg00hbRJV9rCkGUrlnMy7GUnEMdXVFxF1VVA2BukY2GPABAozWDRxQk0vRmbbMKcsy6lNRNVn7GqTyFtsaLNbtm20nophBQJZD74SnN4ygWBXDzsEQDqnqbiBNQ8Tc1TKK3ZWki0FMbpaK0ZrfhM1nxW52Nk4uYLvpuoBYxX/RdcqVTMoJC2SNnnfRoYCeRMTNV8jpc91rXHSTeFobRmsupzbMZjuuGTsMILFreEsqNoi5n0ZCzi1vwvYKA0h6ddDIG17bEX9C6FWcNQoDQnKh7DMx4lR2EakIubpGIGhoCIYBuCbQoxU0hYQsIysM9uznPxCuTZ8Qa+0qxos9BAId26iz4bSo2A42WPS7riSPMCjVc8Hj5eIxMz6UyZHJhwmGwEJC2DXSuT5BMmGk3FUXgKutMWnSnz1P6tUFpzcNJhYKzBtu4EmzrDdkuNsBdxAo0pkImbGKIBwQ005YZP3de0J01WZmKIgBdo3EDT8BV1X+MH4ek3BNIxg7aYSVvcwDJa2nVxCsTxAr7zbJmutMXAaINAK37lisKiegY1N+CZcQet9am7b2C0znRDsaUrhqdgshrwyv4kfbkYoyWfJ07UuXptCieAihMOOb4Kh4q2uEnSFrwA6l44h9H6pxfx2IxHw9fkEiZtcWGk5OH40Ju16ctaZOMmjuLUhY6ZQso2EAGlwVOaqZrPSMnDNIWeNot8wqItbpCJm6fOjdLhJLnsKCpuQBCaQso2aIsbtMWM2T3fxSmQHw1WmKwG7OpNsH+0zh1PFPn463rY2JlYcF0nj2H2HX685PKTYzVyCZNC2uLZsTqPjNRZl4+RiRmM1wPKjqI3Y5GwDUwRBGj4ihkn4Pr1mdB7sYWJasBw2WOy6uEFkLCEuGUQt8Ayhbqr8JWwsi28mBVXUaz7eIFmouZzeMrDNgXLFGwT4pZBNm5QSNvkEiaZmEGseUE1Gi/Q1D3FSNmj4WkyCZOEGQ45SdsknzBYkbHJxo1Tx6y1puZpKm54XF5ThFu7ExeXQLTWHJxs8GcPTdLwA3atSGKYwn2HKly9OsUHXlVY0LgPcHDSoeYp+rI2Y1WfihNwvOTTn7UYq3r88/4ZckmLV69K8Ny4RyZuEujwQk/VAspOQD1QxEwhbgrFuqLuB3QmLRAhbTfFYAiBAgOFYRhM1wPqvmZVziaXsBiv+oxUPEoNBVoTs4RMzCQTN6i7ings7BUMEUqOotgIqLvhMJawhLaYQXvSIp80aE/a5JImtkCx4VN2FLYZxl4qbkCxHlD3NDFb6EnbrMpbFNI2HSnr9CHn4hLIT4Yq/POzJYr1gFVZm/sOV1ibs6n6ivakxcZCgl/a2U57cn4xPMdXPD/hkIkb3H+kClpjGMKhyTpDRZ/hiseanI0GjhU9gsCn5gttcehMWqTjFnHTwFeamYbPdN2n4mhKDYUYkLQFDSilMQ3BEI0lBrZl0J40iBmKqbqm4UHMFrpSFqvyNvmERcwUDMAQA8MIh7yJehhXSVgGmZiQTVjYZjjsVFxFww97ENsE0xBipkHCFrJNV9wNwvlHX86mt81CBI4WPQZnPGbqATUvFHomYdCdtnj16raLQyBKax46WuVL+6Y4OOnwxg1tPDLSoO741APwlWJPfxudaZvr1qXZ3ZeeV73PTzh4gSIZM1BK89BgjafHagwXXaqe5urVKfaNOYAmaRsU6wrLUMw0oOEptFZYlklCu9RGjzAxfAS3NI6qTFAqVag1GhB4iAiGCIZpoMUkwCIQCzEtTMvGisXDkkgRT6ZJtmXJ5XJk8nmSqSzxdA4rbhMzTdxAkbRM8snmECGC0hoLMEwD2zg5bAqBBjfQBFpjaMEwNGjwm1ejLW7Qn7FZkbEppC26UiZx26DqakbKLlevzSx/gVSdgDufKnK81ODxEYfthRjPTXp0pg20gvGaIhcXfK157foMpmHwi7s6zlhv3VMMzbjUXIVtClM1n+GSy0jJ54eHy+zuTTEw3mBHdwJLYGjGY0UmxpbuGNWaz/f27mXgR/dy9LG9lI4fItHZR2f/ejoKPcRzXZjxJNqMERgxQFOq+zTcAKV8DBVgEGDho3wP5bkEbh23UcerV3BrZYJ6haBeQjUqBPUyWmsSbTkS2Q7imXasTCepfBfZzh4ynSvIdq0g3ywdne0kTBMkdHVNERCNaAE0AeD4mmpzzlHzNCdvgnTMJGEJ6ZjBb1294pwEcl5zMVM1n8PTLg8eKTNUdHn8RAPbgEPTPtmEQT5h8chwnSvXpCjWFM9POnSmLZ4aceZV/2DRJZcIe4WVbRYPHq3S8BQHJutc0pWg2FDcsCnNwckAxwu4vD9NQU/xuc/8JQ984wt0FVaw5dWv57Lf/CN6Nm7DtOIcmmpwaNrHURA3hbQFnoJAw6akQUfSJpMw6ExboDTFRkDZVbh+6H6apmA3YxmeUlQdRclRVD1Fo1HHrcygakVUdQpdmcYtTTA2Mc7I4f04xTEaM+M4xXF8p04s20E8WyCe6yKWK5DIdRHLdJLMdZDOdpDp6CDX3k22o4tcOkbSMnGDpofTUBwPzt2nWFAPMl71dD5htQzYNLyAYyWPR4ZrPDPuMFZyGC75NIKASl2xc2WS0aqPXxyldPhxUhv20NXZRd0PI5nv2tXBgQmH227obWmL0prnJhwEcALN/rEGcVPz4NEqJUdhGQav35Dm+UmXkhOwNulxz9/8Cd++8x/Y88ZfYM/PvZdU7ybGa4qkqQkQirUAN1Cszse4ek2Kp8caHJ72USqgocDzFd1pC8swcVQYlzCMMJAVekCamuvjafAViG4OFSL4CnwVgNa4AXi+xldhQcLjEREs0ZimgOeiqtO4pXHc0iTuzBhOaQKnNEWjWZzyFF55Cr9SxIinsNrasdLtWOk8ViqLlc5x4gd/d+F6kMeG63QmTTAEQ8JZfdUJGK16jFUCZhyfkZKP4yu0hu60yVg1oOQofKXJVw5y3199laFHvotXr5Do2YQ7+Qe87r/+GTMdW0nHDI5NN6i5wRltqXmKuCnUfcVE1afhBxwvBRQbCkGxKhtj/7hL3NaoJ+/iI3/8Mfp2v56b/+z75LsKbCnEmKoFxEyDQEF/1mak4tGft/F8zd3PVzCMMKC1piNBb8YmUMJo2aXiKTpTJu0JC1OgEWi01vhKEehwbuMGYY/iK0FpRaAENwioOIrpekDJDWh4ipoX4HgarYVAaRwlBK5GtI2yu5FCN0Fn82IpsIGTswqRcL2G1gpdL+HXpvEr0wTVIl51Br9WWqAcXsyCBPKTYxWGyz4xM4wMztR9VNNAx4dACRqNUmHgqNRQNAafpLb/fsoD38erlSlccRNrf/mz5Po2kU/ZjDx6Lz/8k19h5Zv/MzvecDMHp1xMQ86Y2Kq6CicIA2DPjDXYWojzxMgMddenM2URoOmIC9/8i0/y6N57uOHWv2L3K19Jd9omFxfufr5CyhI2FxJ0JE1GqwE7V8T4ybAb5mO6E2zsTLCtOxEGprwwtrCxM4bja4ZmXCbrAQ1fYUo4mQwChSLsDfwA6r7CCxS+Bq3AD6cJZOIm7emfuqNahcG2mheKrOaEwql4CqVDEZyMd/gqvNmUFnwNSimUNgiMPEY6j9W1jgBINNs6VxYkkAePVjAFqg2femmaanGM2swUulEjcCr41RmCWjEcS0cO4IweINbRS37H9fT8wu+Q37ibjrRF0jLIJiwycWHPW9/Kj9dewr0f+3k2XPtzaMsgG7OYafi0J+cOvVddheMrEraBrwIOTjmU6z5lV7OtJ4Zfr/IXH/8gynX4+T/6Om/c0U8YhtLcc6BCb5vFFavTxEyDI9MOIzMOz41rNnXFuLwvzeV9qRfFY7TW4QUTeNXq+XlZ80Xp0L2VZsBOBLQO3fjxqs9I2cP1NdmEScxqTlqBQGu0BsMAq7mvaQjhrXruLEgg93z4SpRXR/suRiKDlevGTLdjxNNhSeUw0+3Yq3eR2fN2Uj0biaezxG1Ixw1SlkEmaeAGmi2FBP15m68NlNi9fTMP9V/C0L5/Y90rr8c3FSfKXkuB1D1F3DLYP1YnbpqcKPtM1H1yCRMLxRc++au0dxXY+f5P8fZXFBgte5wohYGsTR02u3rbAHh4uMpExSOftLhmXYrr1mdOpf5PR0Q4X2uEDBHi1osrt02TtrjJuo44SmtmGgHT9QDHDy9/2g7jJFbTDUdCt1jpMIN9rixIIBt/++uInSCVipNPx7AtQcQAAUMLtqlJWAaWAR1Jk4RtUkjbtCctkjZ4QXhHVN1QALmUydVrk+wfd2jfcS0TT97H2suuxfENBqc9tnbPbUvd0xTSBgcnPWKWZrrmUHEUm7qSfOdzn0QFPq/4T5/irds72Xe8TsVR+FqTtE2uXJtF0Dx8rMp0PaAnE+PtO3Ksbl94mP9CYojQnrReEERseKGHVPMUDV+dyvMsFgsSyO5L+ujPxYhbYVIoGw/DyKlYmCuI2830tBmut7AMwTTCu840hBVt4bi7f6zOsxMODx2tsro9zJUUdl7Hvj//MA1fIaZmsOTNaYfSocdTdUGjGC15HCsHWIZw6Ptf5Jl//R5v++Ovcc36PHuP1LAMyCZMJmoBt1zZyYlqwANHyhwtemzrjvOunZ1z9hrLnYRtkLANOs9T/QsSyOffsZbhkocXaFZmbPLJ+S+qmc3WFUkQodgIeHq0zqpcjO41W1CBx9SxQ3Ss3sh4ZW5PptbMpD474dCRsHh2tMFULSBXO8Z3/t8f8Mt/+g26Ojt4dKROb8YmZQkjlYAPX9nF8YrHT4ZqPDfh8PoNbbzpkjxm63T5y5oF3TZJ22BjZ5xNXXHKbsDAaJ3xqr/wRkW4pJDgkq44nhKStpBLWWS3Xcv0wP3Ufc1Ede5gWc0N8w1Hpj0agWKiHk7gnrzjU1zzrl8nuWIdE/WA9e0xulI2o9WAd12aZ6oW8OPBGk+PObxlS5abtrZH4jgDZ9WvWoawKhdjW3cCP9AMjNYpO2eOXZxex46eFP05i6PTLp0pm9z265ge+CENTzPTmHssrTgBELp7R4suEzWF99wPmR45ysrXvQ/bhNXZcI3ocMljT3/okTw4WOHApMNNW3O8YWPubA79Zcc5DbwiwsqszZZCgvGqz4FJB7WAyGwuYbK5Kw4SZj07t7yKytEnaVQqVB0f7+RKmNOYaSiKdUXCEkZLLuVqnf3/+Adc/r6PszKfRCtY35XgaNGlJ2OyqTPO3sNlDky43LAxx+s2ZM7lsF9WLMrMzDSE9R1xupurwxbSm7xqVZpC2gqX22XTpNftpvLsj6i4iqn6Sw9fVU8xUvJo+IrJms/E/V+gY80lFC69lmxC6M3GmHECbFPY3ZvikeEaB6cdXtmX5I2bI3EshEWdumcTJtu6E5wo+wzNuPPapycTI5ewsETRnrRp2/gqqkcepeZpRsov9mSU1tR9xVQ94PiMy3jZYfz+O1h/04dY3x4nYdvkkgbTdcXWQoLBostzkw3W5OK8Y+eZM8QRL2TRfTvTEDZ1xYmbwsBoA3cefvkrepPYtoVlGaTXbKc+9BQ1XzE4/WKR1T2NCdS9gLGqx4nHvk+ys4/N23dQSJsImqEZj/XtMZSG5yYcMjGT915+vhzBf9+cN+e/u81mQ0eMZ8cbVM6QfLt0RYL2hIkKFNlV23CO76fh+gyXXjzEVN0AJwhXfE1WXMb3/gPr3/AfaE/GSNoGI2Wf7YUEMcvg4JRDw9d8YE/nmVZ+R8zBeY0OJWyDbd0JhooeEy3cYcs02FKIozTk2vOYbZ1Ujh9huPRiV3e6HjBVDZ9lGTz4PM7YYS699k0U0hbDMx7bCnFcBRNVnxMlnw/s6SQVW96PIN9+++2YpklbW9upct999536fu3atSSTyVPf3XDDDRfMtvMePjQNYWt3gmIjYLI2t0h296UxjPAxyET/dqrHBpiovHj7qVrAVD1gsuox8sN/YNW17yIRjxMzNb4OPaOKE3Bk2uXdr2in6zw8a3M+uPLKK6lUKqfK9ddf/4Lvv/Wtb5367p577rlgdl2w+PKGjhhjzYehX4rV+Rg9WQvTgET/durHBhiv+C9ym6ueougEDI1OU3r8Lrbf+B56MhZFR7OpM8bgjMdYLeBnL8mysevccytr167l05/+NDt37iSXy3HzzTfTaDTOud6LhQsmEBHhkkKco0UXx39xfCNuGezpSxNoIdW/HWdogJKrGJr5qSfj+Iq6FzBa9hl6+F7aNu4hV+jBMISOZJjRNQzN1kKcPf2Ll47/8pe/zN13383hw4fZt28ft99++0tu98ADD5DP5+csDzzwwJxtPPbYY3R1dbF582Zuu+02fP+Fved73vMeCoUCN9xwA0888cSiHduZuKCDsyHC5q4Ez0+EjyWe/ijjzpUpvrRvkvZ12xgc2U+p4XFgosGafAwIH6NseIrnxuuUHvs2a657JykrfGRzsuqRT9mkbIM3b1ncKOktt9xCb2+4BPKmm27i8ccff8ntrr76aorF4oLrv/baa3nqqadYs2YNAwMD3HzzzViWxa233grAHXfcwe7du9Fa85nPfIYbb7yR/fv3k8/nz/6g5skFT2HGTKEnY7+gZzjJqpxNT1uMtmwOK9NFcegQ+8d/OlEdKXsMFT1Gjo/iHBug77LXsaEjjiGaWrNXeseO/KK/YqGnp+fU51QqRaVSWdT6169fz7p16zAMg0svvZTf/d3f5c477zz1/VVXXUUymSSVSnHrrbeSz+fZu3fvotowF0uS4+5MWTT8n76j4ySZuMHl/WliJsT7t1MaHGB45qcCeXrMYaLucuLRu0lvu57eQpZk3OLglEtvm83PbMrQFj+7DPNisHfv3hd4IqeX+V5UEaHVYvIzfb+YLJn/t649zrMTDbbPGmpEhN19Ke561iDet436sQGGZzxm6j5FR1Fq+AxOuZQf+zYrb/wN1uVsZhoB+YTJ9p4U68/iud7F5Jprrjmr3uWuu+5i9+7drFixgv3793Pbbbfxzne+E4DBwUGGhobYs2cPSik++9nPMjExwVVXXbXY5r8kS7ZKxjaFnjab4+UXTsZW52P0ZRIk+7fjHBvgSNHh3gMlVHOx7r79B/Enj7F1z2twVbiId1XO5uq1bUt0JOfO9773PXbu3Ek6neZNb3oTb3vb2/joRz8KQLlc5oMf/CDt7e309fVx9913c9ddd9HZeWEiw0v+ApmB0Qabu+KnnrVRWvO3j07y6bsP8swnX8tl//1f+bUrV/LaDRn+9wOj3PF//idBaZy3fOg2XtGXwvXhQ68pkE0s72DYEnJx/2bduo4YR2blXAwR9vSlKHRlSazZxfCD3+SJ4RKHJhweODBN6cd30rnn5+jP2YxXFb+wIx+J4zyy5AJJ2eFrl2YH0NZ1JNjQmaTjxg8zee9f8NCRCt94ZprBH3yBeO8W1m3dhWmaXLEqyZbC8l5ofLGz5AIBWNMe42jRPTUzT8cMruhP0bn+MmI9mxjceyf3Dwwz/YPPs/Km32ZdZ5z2pMlbtuTn9VqoiLNnWfTNliGsaE5Y+7Jh7uS69RkePFpm5mc+zLG//g3c4WfI7H4zu7ZsIJO0ePcrOhb8opmIhbNsznAhbVFqBKfC8Ju6EqzrTPG21+0hsWYXlX33sOHNv053Ns5NW/L0ZmNLbPHLg2UjEID1HTEOToUTVtMQ3rEjTy5hs+btH6H3fX/KJat7eP3GDNdcxC7txcayGGJOErcM2pMmByYd1nfEuLQnSdwUhmfWcbS/n7duz/OWrXksc1np+t81Sx4HeSlKjYDBGZeeNpvpRsC/DVZoBJp37+q4aJ+AW0KW/yuozgalNSfKPh1JE8uAmqcX9HrsiFP8+xRIxKJxcUdSI5Y3kUAiWhIJJKIlkUAiWhIJJKIlC/JiROQpYDmt+e8CJpbaiNNYbjYltNY7znbnhUZSG1rrV55tY4uNiDy8nOyB5WeTiDx8LvtHQ0xESyKBRLRkoQL5y/Nixdmz3OyB5WfTOdmz0FB7xMuMaIiJaEkkkIiWRAKJaMm8BCIiHSLyNRGpishREXn3+TZsoW2LyCdExBORyqyy/jzY8yEReVhEHBG5/Qzb/paInBCRkoj8tYjEl8oeEXm/iASnnZ/rz1T/fHuQPwdcYAXwHuBzIrJ9nvueKwtp+0ta67ZZ5dB5sOc48PvAX7faSERuBD4CvB5YA6wHfm+p7Gny0Gnn574z7XBGgYhIGng78HGtdUVr/QDwTeA/zsOgc2Ip254LrfVXtdZfBybPsOn7gM9rrQe01tPAbcD7l9Ces2I+PchmwNdaPzfrf08AF6IHWWjbN4nIlIgMiMgHz795LdlOaOtJngBWiMhSvo/zMhGZEJHnROTjInLGVMt8cjFtwOk/fjYDXIhXFi+k7S8TBoVGgVcBXxGRotb6H8+viXPSRmjrSU5+znCe7vYzcD+wAzhKKN4vEf787h+22mk+PUgFyJ72vyxQXriNC2bebWutn9ZaH9daB1rrHwGfAd5xAWyci9NtP/n5Qpy3F6G1PqS1Pqy1VlrrJ4FPMo/zMx+BPAdYIrJp1v92AQNnZ+qCOJe2w5+uXjoGCG09yS5gVGu9FL3HSzGv83NGgWitq8BXgU+KSFpErgLeCvz9OZu4iG2LyFtFpF1CrgBuAb6x2DaJiCUiCcAETBFJzDGW/x3wyyKyTUTywMeA25fKHhH5WRFZ0fy8Bfg48zk/WuszFqAD+DpQBQaBd89nv8Uoc7UNXANUZm33j4RjewXYD9xynuz5BOHdN7t8AljdbHv1rG3/C+GcqAT8DRBfKnuATzdtqQKHCIcY+0z1R8m6iJZEofaIlkQCiWhJJJCIlkQCiWhJJJCIlkQCiWjJRSWQZhLu+gvU1rbmOotFjcaKyFdE5GcXs87zybKKg4jI7BedpwAHOPkC1V/VWt9xAW35CvBPWusvLnK9VwCf01pfvpj1ni+WlUBmIyJHgA9orb+7BG2vJMyl9GqtF/1RUxF5HvglrfU5PfV2IbjYhpgjIvKG5udPiMg/icgXRKQsIk+KyGYRuVVExkRkSERumLVvTkQ+LyIjIjIsIr8vInO90+qNwKOzxdFs+7+JyL7m8sfPi8gKEbmr2f53RaS9uW2iadekiBRF5Ccn8yBN7gPevOgn6DxwUQnkJbiJMHHXDjwG/AvhMfUR5hr+76xtbydc/7ARuAy4AfjAHPVeCjz7Ev9/O6F4Njfbvgv4KFBotntLc7v3ATlgFdAJ/BpQn1XPM7ww07tsudgFsldr/S9aax/4J8IL9Udaaw/4IrBWRPLNu/dNwG9qrata6zHgfwG/OEe9eV563cZntdajWuthYC/wY631Y82e5muEwgPwCIWxsbk+5RGt9eyFT+VmG8ueZfWe1LNgdNbnOjChtQ5m/Q3hyq5ewAZGZjklBjA0R73TvPSqtdPbO/3vk2/4/XvC3uOLzVT/F4DfaQqXZt0L/3G7JeBi70HmyxChR9Sltc43S1ZrPdfa1n2Ew8hZobX2tNa/p7XeBrwGeAvw3lmbbOWF61WXLS8LgWitR4B7gP8hIlkRMURkg4hcN8cu9wK7mwtxFoyIvFZELm1OgkuEQ87sH+i7jnD+sux5WQikyXuBGPA04RByJ7DypTbUWo8C3ydcvXY29DTrLxFOSH9IcxWciOwhXOj0b2dZ9wVl2cZBlhoR2Qb8LXCFXsST1AzAfV5r/Z3FqvN8EgkkoiUvpyEm4iyIBBLRkkggES2JBBLRkkggES2JBBLRkkggES35/2ncYsgIEGalAAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "for i in np.unique(GMM_class_labels):\n",
+ " f, arr = plt.subplots()\n",
+ " f.set_size_inches(2, 1.75)\n",
+ " GMM_cluster = data_classified_df[data_classified_df['Class']==i]\n",
+ " \n",
+ " for _,row in GMM_cluster.iterrows():\n",
+ " plt.plot(row['Waveform'],alpha=.3,linewidth=.6,c=GMM_PAL[int(i-1)])\n",
+ " \n",
+ " plt.plot(np.nanmean(GMM_cluster['Waveform'].tolist(),axis=0),c='k',linewidth=1.)\n",
+ "\n",
+ " arr.spines['right'].set_visible(False)\n",
+ " arr.spines['top'].set_visible(False)\n",
+ " arr.set_ylim([-1.4,1.1])\n",
+ " arr.set_xticks([0,14,28,42])\n",
+ " arr.set_xticklabels(['0','0.5','1.0','1.5'])\n",
+ " arr.set_xlabel('Time (ms)',fontsize=12)\n",
+ " arr.set_xlim([0,42])\n",
+ " arr.set_yticks([])\n",
+ " arr.tick_params(axis='both', which='major', labelsize=12)\n",
+ " \n",
+ " arr.spines['left'].set_visible(False)\n",
+ " \n",
+ " x, y = 23,-0.8\n",
+ "\n",
+ " n_waveforms = plt.text(x, y, 'n = '+str(len(GMM_cluster))\n",
+ " , fontsize=12)\n",
+ " plt.tight_layout()\n",
+ " plt.margins(0,0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "njq5UwqpAzsE"
+ },
+ "source": [
+ "# Figure 4: Interpretable Machine Learning on WaveMAP"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4ZTxMJZLA_su"
+ },
+ "source": [
+ "## Figure 4A: Inverse mapping of WaveMAP"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7ZOMRpSNBFA6"
+ },
+ "source": [
+ "### We use UMAP's inverse transform function to produce waveforms found on a grid of test points tiling the manifold\n",
+ "\n",
+ "---\n",
+ "\n",
+ "Note that this *is* sensitive to the stochasticity in projection and likely will look incorrectly aligned to the grid. This is because the projection of the high-dimensional graph uses a force directed layout algorithm using stochastic gradient descent. Although the stochastic gradient descent can be made deterministic through setting a seed, the seed will vary at the level of the CPU OS itself and cannot be set from within Colab. Since Colab spins up a new instance every session, this can look different day-to-day if you let your session expire. You can change the location of the corners of the grid in the `corners` variable to try to produce a good fit."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 411
+ },
+ "id": "HStjBK5Ptill",
+ "outputId": "f48bbada-9f3c-42cd-8248-8118070c2f09"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def find_nearest_color(embedding, test_coord, threshold_dist=0.3):\n",
+ " x_array, y_array = embedding[:,0], embedding[:,1]\n",
+ " \n",
+ " # Take coordinates of test point to calculate an array of each point's distance to test then return index\n",
+ " # where the minimum value is found\n",
+ " dist_array = np.array(np.abs(x_array-test_coord[0])+np.abs(y_array-test_coord[1]))\n",
+ " idx = dist_array.argmin()\n",
+ " \n",
+ " if dist_array[idx] <= threshold_dist:\n",
+ " return cluster_colors[idx]\n",
+ " \n",
+ " else:\n",
+ " return (0.8,0.8,0.8)\n",
+ "\n",
+ "\n",
+ "corners = np.array([\n",
+ " [6.7, 10.2], # top-left\n",
+ " [9.6, 10.5], # top-right\n",
+ " [-3.3, 2.], # bottom-left\n",
+ " [8, 2], # bottom-right\n",
+ "])\n",
+ "\n",
+ "test_pts = np.array([\n",
+ " (corners[0]*(1-x) + corners[1]*x)*(1-y) +\n",
+ " (corners[2]*(1-x) + corners[3]*x)*y\n",
+ " for y in np.linspace(0, 1, 10)\n",
+ " for x in np.linspace(0, 1, 10)\n",
+ "])\n",
+ "\n",
+ "inv_transformed_points = reducer.inverse_transform(test_pts)\n",
+ "\n",
+ "# Set up the grid\n",
+ "fig = plt.figure(figsize=(4.5,7))\n",
+ "gs = GridSpec(20, 10, fig)\n",
+ "gs.update(wspace=0.05, hspace=0.05)\n",
+ "scatter_ax = fig.add_subplot(gs[:10, :10])\n",
+ "waveform_axes = np.zeros((10, 10), dtype=object)\n",
+ "for i in range(10):\n",
+ " for j in range(10):\n",
+ " waveform_axes[i, j] = fig.add_subplot(gs[10+ i,j])\n",
+ "\n",
+ "scatter_ax.scatter(reducer.embedding_[:, 0], reducer.embedding_[:, 1],\n",
+ " c=cluster_colors, s=30,linewidth=0.25,edgecolor='white',zorder=1)\n",
+ "scatter_ax.scatter(test_pts[:, 0], test_pts[:, 1], marker='x', \n",
+ " c='k',\n",
+ " s=30, zorder=2, alpha=1)\n",
+ "\n",
+ "# Plot each of the generated waveforms\n",
+ "for i in range(10):\n",
+ " for j in range(10):\n",
+ " waveform_axes[i, j].plot(inv_transformed_points[i*10 + j], \n",
+ " c = find_nearest_color(reducer.embedding_,\n",
+ " test_pts[i*10 + j]),\n",
+ " linewidth=1.0)\n",
+ " \n",
+ " waveform_axes[i, j].set(xticks=[], yticks=[])\n",
+ " waveform_axes[i, j].spines['right'].set_visible(False)\n",
+ " waveform_axes[i, j].spines['top'].set_visible(False)\n",
+ " waveform_axes[i, j].spines['left'].set_visible(False)\n",
+ " waveform_axes[i, j].spines['bottom'].set_visible(False)\n",
+ " \n",
+ "scatter_ax.set(xticks=[], yticks=[])\n",
+ "scatter_ax.spines['right'].set_visible(False)\n",
+ "scatter_ax.spines['top'].set_visible(False)\n",
+ "scatter_ax.spines['left'].set_visible(False)\n",
+ "scatter_ax.spines['bottom'].set_visible(False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "G6Eh0SoWlIfb"
+ },
+ "source": [
+ "## Figure 4B: SHAP Values"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "syORYQJDlU1F"
+ },
+ "source": [
+ "### First we plot the SHAP values at the top-10 time points broken down by their \"informativeness\" per waveform cluster"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 275
+ },
+ "id": "KSEsNopQvgCy",
+ "outputId": "cae35f6c-0568-4b1f-88d3-1c7a7febcee1"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Setting feature_perturbation = \"tree_path_dependent\" because no background data was given.\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "n_bars = 10\n",
+ "X = np.stack(UMAP_and_GMM['waveform'].to_numpy().tolist(), axis=0)\n",
+ "y = UMAP_and_GMM['gmm_labels'].to_numpy()\n",
+ "\n",
+ "unclassified_ixs = [ix for ix,clust in enumerate(y) if clust == -1]\n",
+ "\n",
+ "X = np.delete(X,unclassified_ixs,axis=0)\n",
+ "y = np.delete(y,unclassified_ixs,axis=0)\n",
+ "\n",
+ "UMAP_model = xgb.XGBClassifier(UMAP_grid_search.best_params_)\n",
+ "UMAP_model.fit(UMAP_X_train,UMAP_y_train)\n",
+ "explainer = shap.TreeExplainer(UMAP_model)\n",
+ " \n",
+ "shap_values = explainer.shap_values(X)\n",
+ "\n",
+ "clust_colors = []\n",
+ "SHAP_REORDERING = [2,5,7,4,1,0,3,6] #Need to do this so the UMAP colormap aligns with the SHAP color order\n",
+ "for i in SHAP_REORDERING:\n",
+ " clust_colors.append(UMAP_and_GMM[UMAP_and_GMM['color']==i]['dbscan_hex'].iloc[0])\n",
+ "\n",
+ "umap_cmap = mpl.colors.ListedColormap(clust_colors, name='umap_cmap')\n",
+ "\n",
+ "fig = plt.figure();\n",
+ "\n",
+ "shap.summary_plot(shap_values[:], X, [str(np.round(x*(1/30000)*1000,2)) for x in pd.DataFrame(X).columns.tolist()],\n",
+ " plot_type='bar',show=False,color=umap_cmap,\n",
+ " max_display = n_bars)\n",
+ "\n",
+ "ax = fig.gca();\n",
+ "ax.set_xlabel('Mean Abs. SHAP Value',size=12,fontname='Arial')\n",
+ "ax.set_ylabel('Time Point (ms)',size=12,fontname='Arial')\n",
+ "ax.get_legend().remove()\n",
+ "ax.set_xlim([0,3.5])\n",
+ "ax.set_xticks([0.0,3.5])\n",
+ "ax.set_xticklabels([0,3.5],fontsize=12,fontname='Arial')\n",
+ "fig.set_size_inches(4,3.5);\n",
+ "\n",
+ "ytick_labels = [round(np.float(i.get_text())/(1000/30000)) for i in ax.get_yticklabels()][::-1]\n",
+ "bar_heights = []\n",
+ "\n",
+ "for j in range(n_bars):\n",
+ "\n",
+ " bar_height = ax.patches[j].get_width()\n",
+ " bar_heights.append(bar_height)\n",
+ "\n",
+ "bar_heights = bar_heights[::-1]\n",
+ "percent_total_height = [x/sum(bar_heights) for x in bar_heights]\n",
+ "for k,label in enumerate(ytick_labels):\n",
+ " arr.axvline(label,color='k',alpha=percent_total_height[k])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7gzYoWFJletv"
+ },
+ "source": [
+ "### And show where these time points are located with their relative importance encoded by opacity"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 149
+ },
+ "id": "DU36L7jw2hnz",
+ "outputId": "3d5bf86f-53f5-4104-f6c9-e3a1c2eff146"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "f, arr = plt.subplots(1,figsize=[2,1.5])\n",
+ "\n",
+ "for i in range(0,full_data.shape[0]):\n",
+ " arr.plot(full_data[i].T, c = 'k', alpha = 0.025,linewidth=1.5);\n",
+ " \n",
+ "arr.tick_params(direction='out',colors='k', axis='both')\n",
+ " \n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.spines['left'].set_visible(False)\n",
+ "\n",
+ "arr.set_xlabel('Time (ms)', fontsize=12,fontname='Arial');\n",
+ "arr.set_xticks([0,14,28,42])\n",
+ "arr.set_xticklabels(['0','0.5','1.0','1.5'],fontsize=12,fontname='Arial')\n",
+ "\n",
+ "arr.set_yticks([]);\n",
+ "\n",
+ "for i,t in enumerate(ytick_labels):\n",
+ " arr.axvline(t,alpha=percent_total_height[i]*20,\n",
+ " color='goldenrod',lw=2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "mZdlpLuFljEd"
+ },
+ "source": [
+ "## Figure 4C: SHAP values broken down by WaveMAP cluster"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "jK57eQSCpe0H"
+ },
+ "source": [
+ "### We plot each WaveMAP class with their top-three individually informative time points in a SHAP-sense. We also use bar plots to show the relative importance of these three locations which is also encoded as opacity in the lines."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000
+ },
+ "id": "t_gAGTHCRD1E",
+ "outputId": "b43cfbdd-d59c-40ce-d1c9-ecb8c6abc7a0"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFcAAABVCAYAAAA8AHhnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAE50lEQVR4nO2cb2iVVRzHP1Pb5tLS7M8w1FYgkg6b/KIQFAmCerECNVDKWb1wRm96Ef2D6kUhCkEQGCnUWL0YvQgGl4pVZi/6A/k1c0gklZQrEdOaRrQt5u3F81y53HZ3n1vn7N5zOR8Yz+55fud5fvvu7Hd+5/ecPU35fJ6IH2bV2oFGJorrkSiuR6K4HonieiQocXO5XB6oh69MBCVuaERxPRLF9UgU1yNRXI9EcT0SxfVIFNcjTSGVHLc/dKQunO3v62rKYhdHrkfmZDEysy3Ao8BqoE1S2X5mdjvwLGBAK/A98IKkwfT8UuCbkm7NwJikK6r+CeqYTOICvwOvAnOB/RVsrwLeBrYDvwH3AANmtl7SIUkngXnFHczsM+BoNY6HQCZxJQ0BmNmGDLbvlTQNmtlRYB1wqNTezFYBa4FHsvgSEt5jrpm1AyspPzJ3Al9IGvbty0zjVVwzuxx4B3hX0oEpzrcBDwD7fPpRK7yJa2bzgfeBM0BPGbMtwEWSGN1weBHXzBYBB4BTwH2SJsqY7gT6JY358KPWZE3FZgOXkaRMmFlrempcUr7Eth34CDgMPCxpssw1u4BbgW3/zfX6J2sqtg3oK/r8V3rsMLMlJH/+N6dpVi/JBNYBbDKzQp9dknYVXaMX+ETS8azObt74M93d3VnNa05Qy99cLpevE3Hj8rfWRHE9ElRYcFUV6+/r+r+XyBQWsk5o01JlYWcu8CZwC3AT8JykF134UW+4CguFws5jGWzzwOfADuBLR/evS5yM3CoLO2PAy6l9Qy4eCsQJzSNRXI9EcT0SxfWIq1Qsc2EnPd9CkivOAuak9pOS/nbhT73gRFyqK+wAHAeWpd+vA54H+oEHp7tJLNx4JBZuIpeI4nokqLDgonDjoGgDMSzUHlfZQiEd200y47cCHwC9ks5OYbsBOAj8WdQ8LGmtK3/qAWfiAk8B9wK3AeeAN4C3gLvL2E9KmlfmXEPgMizsAPZIOiHpPPAEcJeZLavQr2FxtUJbACwleZwOgKQfzOwCSQH9pym6zTazEZKV3WHgGUkNtRnP1cidnx7Pl7SPAlNtC/2W5ElEB7ACGAY+NrPFjvypC1zF3D/S45Ul7QuAC6XGkk4Dp9OPo8DTZraZJD6/7sinmuNk5EoaBU4CawptZnYjyajNunvxIhnzx1BwmS3sB540s4Mk2cIeYEjSj6WGZnYHyS/jBNAGPA5cBww59KfmuBR3N7CQZINzC/AhyfZQzOx+YF9R6rWapIp2NUmu+xVwp6SR6W4Qq2IeiVWxyCWiuB6J4nokiuuRKK5HorgeieJ6JKg8t6Wl5djExETNN+81Nze3jo+Pr6pk53KF5p3Ozs4xSVbZ0i9mpix2MSx4JIrrkdDErfQ6gpkikx9BTWihEdrIDYoorkeCScXMbDnJNtNFJE86eiR9N8M+vARsAm4AOiUdm84+pJH7GrBX0nJgL7V5AcYgsJ6ptwr8iyDENbNrSR5+DqRNA8AaM7tmJv2Q9GmlR1HFBCEusAT4pfDuhvR4Km2vW0IRN0hCEXcEuD7dSVnYUbk4ba9bghBX0hnga2Br2rQVOCLp19p5VZlgVmhmtoIkFVtI8o/cPdW8wsWRD68AG4F24CxwTtLKcvbBiBsiQYSFUInieiSK65EorkeiuB6J4nokiuuRfwC2f5bMLmsLqAAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGIAAABECAYAAAB6UOAlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAH0UlEQVR4nO2ca2xT5xmAn+Nr7DhOnDgmTgnEJEAuBNqkDRNBhYCUtEWbxO3Hpq3QTZu0dVvLpl1YpanTNDFNa6d109aK8WPdn3UoHetKILSbCkuhCgkQyIVAIPebc7edxHfvR8pWICEJ+Bwfx35+2v6OX/vJ937feb/XEUKhEHEijyLSAcSZJS5CJsRFyIS4CJkQFyETVAs8L9mW6tatWwDk5ORI9Za0t7cDkJubO+9rjhw5AsDhw4fD8ZbCfE/EZ4RMWGhGRDVOp58rjZPcbJ/CPuTB4fQTCoFGI2BK0QCDWK0JmExe0tI0EY11WYroH3Bz4sQA9Q2TBAIh9HolmZkJZKzQolAIuD0Bhkc83GwbwxcIUX1KiTVDS3FxMqVPmVi9WocgzJtFRGFZifD6glRV9XPmg2E0GgU7d5jZWpZKVpYOheL+L7atTcWQ3cPMjIXGRgena+ycrLZjzdCyZUsqZVtSJYt92YgYHvbwxu866O6ZoXx7Gnt2WzEa1Q8co1QKZFoTyM21UFlhweXyU98wwcfnx6h6d4B3/z6AfXAUm02P3x9EpRJvSV0WIrq6pnnt9Vv4AyEOvbyGxzclP9R1DAYV27eZ2b7NjN3uofbjMV57zc+FT8Z5+XvNlG1JZdvTaWRmJoT5EywDET09M/zyV+0kJCj48Y/Whu1Lsli07Nlt5XqrhcEhD2vXGfjgQzuna+zkrNGzo9xM6WYTGnV4ZklUixgZ8fLr19vRaBS8cngdZnP4dz6CIGDNSOA7L9pwOHycvzDO2XOjHD3WzfGqfr7w+Qy2PZ32yGkrakX4fEHe+P1tvJ4Qr/wkVxQJ92I0qnmm0kJlRTotLU5OvDfI23/p5dRpO/v3ZlJamvLQu62oFfHXd/ro6prhpe+uYeVKnaTvLQgChYVGCgqSuNbk5Pjxfv7wZif//sjAweezsFqXnh6j8s76WpODD/81QmVFOsVPPNzCHA4EQWBjkZGfvbqegwey6OmZ4aevtlFbO7rka0WdCI8nyJ/f7sGaoWX/vsxIhwOAQiFQvt3ML36ezxqbnqPHuqk+NbS0a4gUm2j8470Bhoe9HDy4CnWYdizhwmRS88Mf5LK5NIV3/tbPR2dHFj1WXp9kAYZHPNScGWbr1lTy1hsiHc6cKJUC3/j6ajYWGak5M4zPF1zUuKharKuqBhAE2LvbGulQHohKpeDbL9rweAKLnrVRI6Kre5oLn4yz67kVpKZGtlK6GLRaBVrt4hNO1KSmf74/hF6nZNcuS6RDEYWoEDE05KG+foLycjOJ+qiZxEsiKkScOj2ESilQUZEe6VBEY9F/XiMjXsbHvUxNBQBQaxSkmtRYLFqUSvEOUVwuP7W1Y5SVpZKS/OCydjSzaBFvHe3kxo2p+x7X65Rs2JDEc8+uwGbThzU4gPMXxvD5Q+zcuXxnAyxBxN7dVry+EImJShSCgNsdYHTUS9uNKRouTVB3cYKyLakceH4lWq0yLMGFQiHOnp09mFmVJW09SWoWLSIvL2nOx7duTeNLX3yM908OcbJ6iO6eaQ69lBOWw/jbt6fp7XNz8EDWI19L7oRlsdbplOzfl8n3D+UwMuLlN7+9hccTeOTrnvvPKBqNgs9tNoUhSnkT1l1TUZGRb33TRm+vmz8d6+ZRWv79/hAX6ycoKU5GpwtPqpMzYd++biwysnePlbqLE7S0uh76Os0tDqamApSWLv/ZACLdR1RWWkg2qqiuXlop+LPU1U2g1ykp2jD32rTcEEWERq2goiKdpmYnXV3TSx7v8wVpuDRBcUmy7ErdYiHapywvN5OQoKDmzPCSxzY3O5mZCVL6VIoIkckT0UQk6lU88Xgy15ocS1606xtm01JhQWykJRC51pSfn4TD4aev373oMYFAiMtXJtm0yShqZ53cEFdE3uwpWusSdk83brhwuQKUlMROWgKRRaSnazCnabh+3bnoMQ2XJlGrBTYWxU5aApFFCIJAXr6B1usugsGF14lQKERDwwQbCo1hq1dFC6In4fw8A1NTAXp7ZxZ8bW+fm7FxHyUlketVihSii1j/abfFzfb7S+j30tzsQBB46G7uaEZ0EeY0DUkGFZ2dC9/YNTc7Wb/OQFLS8jwOfRCiixAEgWybjo4FRIyOehgc9FBcHHuzASQ6s15jS6Svz43HM3+zVVPz7BY3kr2skUQSEdnZeoJB6O6ef1a0tDixWrWkp2ulCEl2SCLClj17lj1fenK5/HR0TlEQQyWNe5FEhMmkJiVFRUfH3CIarzoIBaEgPy5CdGzZifOKuHx5kiSjWvIfnMgJyUTk5OgZGPTgcPjuetznC3KtyUFhgWHO30LHCpKJuNNG33ZPb9S1Jidud5DCwthNSyBlarIlotUqaG29uwBYVzdOYqKS3Bx5/t5BKiQToVIJrFubSOv1/5fEvd4gl69M8mRJCipV7KYlkLgJOS/PQH+/+3/rxNWrDtzuIJtLY+vsYS4kFZH/abfgnVlxrnaUJINq3i7CWELS6lp2th69XsnpGjuhEDQ2Oti31ypqN3m0IOmMUCoFvvbVVXR0TPPHNztZ+VgCzz6zQsoQZIvkp/NPlqTwlS+vRKdT8MILq2J+kb5DRAr/O3eks32bOZ6SPkPE+lXiEu5GiP+TdnkQOx1cMicuQibERciEuAiZEBchE+IiZMJ/AevebLFiuf7gAAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFcAAABVCAYAAAA8AHhnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAFI0lEQVR4nO2cXYhVVRiGn3GmmaEyx6QYi6yJkkgny76oCCuCLgqGMAkaKpGyFLrppp+bCjLErJsCQw2KKBAvJoeGLDOJsIjw7WdCkimtVDIwrSmhnKE6Xax9YjqMc5bTXmfvNawHhj1nnW/t856XtdfPt9fZTZVKhUQYphUtYCqTzA1IMjcgydyAJHMDEpW5AwMDFaAMf15EZW5sJHMDkswNSDI3IMncgCRzA5LMDUgyNyBNMaUcmz56qSFiK9fdX1eKz3lSyw1Ii0+QmTUDa4BlQDvwLrBC0pFxYhcBzwMXAM3APuBpSW+Mef/tmmrtwFeSLpvUtygpXuYCjwG3AVcDR4GXgdeAW8aJHQIWAwey14uAd8zsSkl7JO0ETq8Gm9k04Dvg9Ul9gxLja+4DwFOSvgUws0eAvWZ2vqT9YwMlHa7+nxn3N677uQjYM865bwU6gVdOXn65qdvnmlkHMAf4tFomaR/wG7BggnrDwAiwE/gE15WMx0qgT9JP/rLjwGdAm54df60pHwbOOFElSR24y38xsBX4szbGzObgupYNPmJjw8fcY9lxRk15B671nhBJI5L6gRuA5eOELAeGJH3goSM66poraRg3OC2slpnZhbhW+6Xn57QAF48tMLMW4D6maKsF/wFtI/Comb2Pmy08A2yT9H1toJktAb7GDV4twD3ATcCzNaE9wEzg1UkpjwBfc9fgjNgFtAHbgbsBzOwuYIOk6vRqdhY/GxjFTc16JW2vOecKYHN2ZXjx5s+d9PT0+IYXTlTL34GBgUpJzE3L36JJ5gYkqm7h/2bFPLJd3lJ8gnwHtAkxszuBB3ErtlMlnfC8ZnYN8DhguITNXmBVNh+eUuTVLfwCvAg85BF7JrAZmIebgawCNpnZVTlpKQ25tFxJ2wDM7EaP2K01Rf1mNojLnu3KQ09ZKHxAM7NOXCseLFpL3hRqrpmdBvQBb0naUaSWEBRmrplNx92ROAwsLUpHSAox18xmATuAQ8AdkkaL0BGavKZizcApQGv2uj17a0RSpSa2E3gPl3y/V9JfeWgoI7mYi8t8jb1N80d27DKz83CX/6WSDuASNvOALmCJmVXrrJa0eqIPSYmbgKTETeJfkrkBiapbmEziJsdkzX+k+ASllhuQhmfFsnjDJXrmAz8CT0qacjtuGp4VM7MZuKlZHy4rthJYb2bX5qSlNDQ8KwbcDvwOrM0WGNvNbAtuy9THeegpC0X0uQuAz2tWbp8xwdaoWCnC3Omc5NaoWCnC3GNMYmtUjBRh7iBweU3ZFUzBZHnDs2LAFmCtmT2M24G+CDfI3ZyHljKRywrNzJYx/ublLqA2K0Z2M3Id0I2b5z7hM8+NLXET1fI3NnPT8jcgydyAJHMDkswNSDI3IMncgCRzAxLVPLetrW336Ojo8aJ1tLa2to+MjMyvF5fXvoWG0N3dfVyS1Y8Mi5nJJy51CwFJ5gYkNnM3Fi0gw0tHVANabMTWcqMimRuQKKZiZjYX9wPsWbgfdi+V9E2DNTwHLME9u6db0u56dWJpueuBdZLm4u5gFPEYgX7gemB/vcAqpTfXzM7GPethU1a0CVhoZmc1UoekDyUdPJk6pTcXdw/uh+r2/ux4KCsvNTGYGy0xmHsQODe7fV+9jX9OVl5qSm9u9pyyL4DerKgXt9es9I/KimKFZmaX4KZiM3HbVZdKGmqwhhdwm1c6gSPAUUnzJqoThbmxUvpuIWaSuQFJ5gYkmRuQZG5AkrkBSeYG5B94FK4Cw47zjAAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFcAAABVCAYAAAA8AHhnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAFRElEQVR4nO2bbYgVVRjHf6bsLrSuWhmh+YLUJtQqbY9USH2IApOWyPqyGBZUbkaQ9OJLGUFYadgXw8rozbJEShNuIFkgsRWBf+3NAimlso3KldSQ3AXbPszcZbs79+7c3TnunOX84HLZc59z5rn/e/bMmf88M6qnp4eAG84a7gRGMkFchwRxHRLEdUgQ1yFeiVsoFHqAPLxS4ZW4vhHEdUgQ1yFBXIcEcR0SxHVIENchQVyHjPLKctwzN/tk53w2mF6j0gSFmeuQMVkMYmajgTXAnUAdsAtok9RZJn4e8BwwAzgIPChpVxa55ImsZu4K4GbgSuDCuO2tpEAzmwFsB54BxsXv75vZ9IxyyQ1ZibsYWCvpkKTjwDJgnplNS4i9A9grabOkbklvA/vi9hHFkMU1s/HAVGBvsU3SQeAEMDuhy+y+sTH7ysR6TRYzd2z8fryk/RjQUCY+bazXZCHu3/H7uJL28USzNyk+bazXDFlcSceAX4DmYlt80moAvkno8nXf2JjL4/YRRSZbMeBlYLmZ7QaOAmuBDyX9lBD7JvCImbUC7wG3AVcAizLKJTdkJe4aYAKwB6gFPgJuBzCzhcBGSfUQnezMbAHRPvc14BBwS5kf4n8Ufl9BS0tLRim7x6vL30Kh0JMTccPl73ATxHWIV8uCb65YqhNatcZMn35LgBeAxyWtjtvOAXYAM+OxjgCvA09J8uiXHpi0y0JqY6ZI7Cs8BHxb8tFJYAkwWVIDcD2wELgnZS7ekHYrthh4UtIhADNbBvxoZtMk/Vymz6vAY0RC9iKpC/iuJPZf4JLUWXvCgDN3EMYMZtYGnJS0tcK4H5jZP0T73LHAxupSzz9ploWqjBkzmwqsAu6rNKikm4B64GqiJabi+u0jacSt1ph5BVgtqWOggSWdlvQF0Q+3IUUuXjGguIMwZm4AnjazTjPrBOYCK82svcJhxgAXV5O4D6Q9oVVjzEwp+ftdoJ3IS8DMrgLOBj4HuonEfyA+xogirbjVGDO/9u1oZl3ACUl/xE01wLNAI1GtawewPj5GRYJx45Bg3AR6CeI6xKtlYcjGzeBMmiTCsjDcZO6Kmdl84GFgFjAa2A88Kqk9/vwaYGdJtzrge0mzBvc18okLV2wC8DxwETAReAfYaWZTACS1S6ovvoguRjqAzYP7Cvklc1csLk/qy4tm9gQwBzicMPZ84AIiT3dE4cQVK+nfBJxHf1+3yL3ANklH0iTsE2lmbrXlSr2Y2fnANmCdpB8SPp8K3AhclyIP73DhigFgZpOA3UQnv5Vlwu4GDkj6JEUe3uHCFSOutW0Hdkq6P+nemJmNAe5iBJrkRTJ3xcxsJvAx8IakVRXGbCHaWWyqKmOPyNwVA5YDk4GlZra0zxhtJTuJNmBr/J+RiuCKOSS4YoFegrgOCeI6JIjrkCCuQ4K4DgniOsSrfW5tbe3+7u7uU8OdR01NTV1XV9dlA8Vl9cDJGaGpqemUJBvuPMxMaeLCsuCQIK5DfBM3L/VkqfLw6oTmG77NXK8I4jrEi62YmTUS3bE4l+hOyKKkG56Oc1gH3ApMB5ok7R+ojy8z9yVgg6RGovL+4bjvtgO4Fij39FI/ci9ufHu+GdgSN20Bms1s4pnMQ9KnkpKKWsqSe3GJHgPokHQaoodUgN/o/3hA7vBBXG/xQdzDwOS40rJYcTmJ5LqzXJF7cSX9CXwFtMZNrcCXPtSWeXGFFheabCKqnfiLaCt24AznsB5YQFSR2QkclXRppT5eiOsruV8WfCaI65AgrkOCuA4J4jokiOuQIK5D/gOSMQYfn3hESwAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFcAAABVCAYAAAA8AHhnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAFlElEQVR4nO2cbYgVVRjHf5u6K+RbZhJaKlFq1GbYAxVCEBX0ISsKBbVEirT6EkZofSizCDSTQFA0orIsi6KEVcoXsA+VQf9IRSPT7MXsxbdcw3I37fbhnJXtend37vWevXOW84Nh9p55ZuaZ/577zDnPPHfqCoUCiTCcU2sHejJJ3IAkcQOSxA1IEjcgUYnb1NRUAPKwZCIqcWMjiRuQJG5AkrgBSeIGJIkbkCRuQJK4AamLKeW4a/DU4M6OOfJWFrO6LEap5wakdxYjM+sFLABmAH2BDcAsSYc6sH8MeAgYCvwGvChpmd82GFgDjPXHOgi8CjwnKZ6vUQay9tzHgTuAa4GLfNsbpQzN7HZgPjBNUn9gOrDIzG7xJsdxwg+XNAC4GZgGPFDRFeSYrOLOBBZK2iupGZgD3GpmI0vYXgpsk/Q5gKQtwHZgnP/cImmnpH/a7fMvMKbSi8grXYYFMxsEjAC+bGuT9J2ZHcMJ9mPRLm8D95nZBGALMAEYDXxUdNy1wE240LAPWFH5ZeSTLD23v183F7UfBQaUsD8AvAdsBlr9ep6kHe2NJN0G9AOux4WYkvE7ZrKI+6dfDyxqHwQcK2H/JDAVuBrog+vds83s/mJDSad8+GgGlmZ1Oha6FFfSUeAnYHxbm5ldguu120vscg3wgaSvJRUk7cSNDiZ2cprewGXlOB4DmYZiwEvAXDPbDBwGFgLrJf1QwvZTYIaZvSxpt5ldDtwJvAZgZtcB5wKf4cLGBOARf44eRVZxFwDnAV8ADcBG4B4AM5sGrJDUz9suwoWQjWY2BDgCvOuPAVAPPI+7yRWA/cCSdts75NuVU5g4sbMvQL6Iavrb1NRUyIm4afpba5K4AYkqLFSSFcuY5SqXTGEh6w2tUypI7DwIPAoMA3YDsyV9XA1f8kS1wkI5iZ1JwLPAZNyoYgWwzsxGVMmX3FAtcctJ7EwCVkna6mdoy3FT5hlV8iU3nLW4HSV2cFPjcSV2qePMmFWHmy73KKoRc8tN7KwFFpvZKmAbMAv3z9lTBV9yRTXELTex8zpwIfAmMASXd9iEm8n1KM5aXElHzawtsbMVOk/s+Ec5C/2CmdUD3+Nucj2KqgzFKCOxY2YDcUOwb3A9dwEupKyski+5oVrilpPYGYBL5IzCZcXWATdK+rurk6TETUBS4iZxmiRuQKIKC1kTN4GSNe1JYaHWVL2cycyGA8tw09kRwL2SVhXZrAeuwj1La8aNHp6Q1FLxleSQqpcz4apnNuAer//cgc1cYJQvZzLcE+N5GX2Jhqzj3JnAM5L2ApjZHGCPmY2U9L+KG0m/4msQzOxUqYNJ2lrU1CPLmbrsuRVkvTJhZsvM7DiuCnIcsLjSY+WVEOVMmZD0MK6cqRFYTschJFpClDNlxlfk7MAlfN45m2PlkRDlTJWQypkyljNhZn39n3VAH//5pKSTZjYWV1W+CfgLF2+fAj6s+CpySohyJoD2Ga5X/DIfeBon+Bxc7Vgv4Hfgfb+9U1JWLCApK5Y4TRI3IEncgCRxA5LEDUgSNyBJ3IBENc5taGjY0draeqLWftTX1/dtaWm5siu7atUtdAuNjY0nJFmt/TAzZbFLYSEgSdyAxCZuXn4ImMmPqG5osRFbz42KJG5AohiKmdloXP3u+bgnIdMl7e5mH14A7saVvjYWvz+iFLH03OXAUkmjcTURtXiryBrgBs58M0qH5F5cMxuKezi62jetBsab2QXd6YekTyTtK2ef3IsLXAzsl3QK3NtFgF98e66JQdxoiUHcfcBwX2nZVnE5zLfnmtyLK+kAriJnim+aAnwl6WDtvMpGFDM0X0iyElc78QduKLarm31YAtyF+4HiIeCwpCs62ycKcWMl92EhZpK4AUniBiSJG5AkbkCSuAFJ4gbkP/eqFvYGPEhQAAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAGIAAABECAYAAAB6UOAlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAGyUlEQVR4nO2cW4wbVxmAv7l5fNndrPeazWbvShRokzRVygNqRaG0D+EiodIgEA/QfUICqRII0ZagKqkqcZFA8MQlogmopSBVIm0lAiq0RVSUbChpUrElJBvvbgtre9d7sb22xzOHh9nEdXaddWB9ZoTne/OZ8cxvf/r/f+bYZxQhBAHeo3odQIBLIMInBCJ8QiDCJwQifIK+yfZNL6kmJycB2LNnz1bE819z/PhxAMbHxwGYmJgA4ODBg57FtAFKrQ1BRvgE34lIPnyS+e+d8joM6WxWmqSSe+k8mR/+BgC1LUL8wXs9jkgevskI4TikHnsafaCL2H0HSH71SVZf+4fXYUnDNyKyz09QfOMKXY8eZsdPvoTeGyf5yEmE43gdmhR8I2L1zEUU06Dt/vejtoTpOnKYwuuXWf7Vn7wOTQq+EWFNpzAGu1A0N6S2w3cSPjBK+ugvsJfzHkfXePwjYiaFMdhz7bWiqvR8+/OU5xZJPfa0h5HJoeEiRNkm9+I5hH3jWm8lUuiDXVVjkdvHiH/hEEtPvkjulTcbGabnNFSENTvPzMeOMfvAN1l59tWa+9nLeZxMFmOwe922roc/SWhXH/8a/z6lK3ONDNdTGiai+NbbJO49QuHNaRTTYPXspZr7lmfTABgD60WoUZP+p76CsB3e/vR3KCeXGhWypzRERO7lC8x8/BgIwdDpo4RvG6F4bqrm/tZ0CmDDjAAIjfXRf+IhrOkU0/d9g+LkbCPC9pQtE1GamiPz49NMf/Qos594AjViMnDq65jv2Ym5f4TC+UTNPmEl1kQMbSwCIHrXLQw8dwSnUCLxoUeZ/+6vcYrWVoXvOXVPcayc+gvCKmPeMgiAnV6mdHmO1G//SOHsRZQ5GwBjbDvdj3+W9gc/jBoOARDeP8Lij05TuvgO5p6d645tTadQIiG0rrYbxhC5fYzhPzzB3NdOkD72DIvHf0fHFz9C22c+UPcH9it1i1j4wfMUzv5z3XguahG5bZSeL99D7IN7CY31rdsnvH8EgMK5qY1FzKQxBrpRlJqzxJWA++L0n3iI3Evnmf/WsyQf+Rmpx3/J4kgR89Yhyocy6H3xej+Wb6hbxOALbm0uTs6iaCpaRyvGaC9OLo2iqsRv8HtEaPcOlEiI4t+m4FN3rdt+9WbuZojdvZfY3XspvH6ZxZO/p/TUzyn89RKXnkmg7+jg371g7Owic+c8xkAXen8nek87ansM1TRu6lzXI8o2diaLs5THyRVwVkuIQgknX0TkizjZAk6ugBoL0/65e+o6Zt0ilJBOeN8w4X3D1eOTC5u/V9cwbx2iUKNhW4kkkTt21RtKFeEDo2w/MEr3ewXWTJru7fspvnEF58wZshcSJJ/bYOLQ0FDNEBgaiq6iRkwUUwd1rWU6AiEE2A7YDqJsu/3NdnBWi4hcsa7YjJHerRfxvxLeN7zhvJG9nMdZyqMP3FxGXI+iqoSGeugYPwTAjokJhBCMDe7CmklTfmeBcnIRZzmPky0gChbCthGlMqJQQhTL7pet4JZIVQFNRdFUFF0HzX2tRkzU1ghaZyvatihK1HRFRkKoURM1arpjrRHUWLju+KWJ0Hq24SznEaUySqhyWjvl3hfove1bfk5FUdB72xty7K1G2lyT1tEKgJ3JVo3b8ytV25sVeSLiLQDYC9eJWBOjdbTICsWXSMyINRGLNTKiM8gIKVQyYqVqPChNLvIz4vrStLDiXk62RmSF4kskZkTtZq11ttZ1V/3/jDQRSsxECek4GzTrZi9LIFOEoqB2tGzYIwIRkn+z1uKt2Iu5qjFXRHNfuoJ0EbH1GbGw0vSXriBbREdr1VWTcBzsTBY9KE2yM6Kl6qrJWcqDI4KMQHpGuM366krW4K66gvSMwLIR2QLwLhHxQIT0HgGV+aarjTvICMki1HgMqExzBCIqeJMRV0UEE37XkN8jqGSCvZBFMQ2UmCkzDF/iTUZkKhmhdbQ0/YQfeHBnDZXSVJ5fDsrSGlJFKIaO2hbFTrt/GCjPzqP3d8oMwbdIX6hiDHZjJVIIIbASyRv+37WZkC9iuAfryhzOYg5nZbXmP8CbDfkiRnqxEilKU+6iE2OoZ5N3NAfSRYRGehGlMqt/fguovSai2fCkNAHkX77gvg56BOBRaQLIv/p31G1RtG0x2SH4Evki+jtB1xC5YtAf3oV0EYquXVsLEfSHCp4seDeG3fIUiKjgiYjQWp8IGnUFjzLC7Q1Bj6jgiYjI+3ajRM1rK1QDPHqCWeSOXeye/akXp/Ytvnk6TbOjBA9p9wdBRviEQIRPCET4hECETwhE+IRAhE/4D0g+XscOgM7YAAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFcAAABVCAYAAAA8AHhnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAFF0lEQVR4nO2cW4hVVRjHf6M2I+WYZje1vESZUdOEfGAXtLCCioYwexErgkrrqR7CLvQUBlq9JAgpVISC9FAMjBQmpGGE0b/bZNlYTtZgiBcaFcmZcqaHtY8djjNz1ohr9l7H9YPhzKy19j7f/M86317rv79z6vr7+0mEYVTeAdQySdyAJHEDksQNSBI3IFGJ29bW1g8U4ceLqMSNjSRuQJK4AUniBiSJG5AkbkCSuAFJ4gakLibL8eW9xwoR7IoZjXU+49LMDcgYn0FmNhpYCTwGjAU+AZZJOjTA2DuArcDxsuZ2Sbdm/RcBrcDs7FwHgXeBVyUVYmaeLbzEBV4AHgDmAoeBd4D1wL2DjD8padwgfceBp4Hdkv4xs5nAR8ABYJ1v4DHgK+5S4BVJnQBmthz41cymS/p9OE8oqQf4saK5D7h2OOeJgarimtkEYBrwdalN0h4zOwo0AwOJO9rMuoDzsuNekvR9xXk3AXfiUkMXsPZM/4mi4nNBa8wej1S0dwPjBxj/M3ATMBOXV9uBT81sSvkgSfcD44BbcCnmtPwdOz5p4Vj2eGFF+wTgaOVgSfuB/dmf3cCLZvYQLj+/XTH2JLDDzOYDa4DF/qEXn6ozV1I38Acwp9RmZlfhZm275/P0AUOtDccA13ieKxp8L2jrgOfNbCtutbAK2Cxpb+VAM1uAezE6gfOB54DLgM1Z/83ABcAXQC9wG/AMNbZSAH9xVwITga+ABmAL8DCAmS0B1pYtvZpx69aLccuub4C7JXVl/fXAa8As3C2TfcDq7DmGZO4P22hpafEMOX+i2v62tbX1F0TctP3NmyRuQKJKC7G5YnkYN/OAjysOGwv8JOlGn3hiYcSNG0nbcTszAMxsFPAbsMEzlmjwzblLgVWSOiUdAZYD95jZ9LMQw33A5bjlW02Rm3FTxlPAB5IODjf4opObcQNgZtNwqaXmHDHI2bgBngA6JH3mHXFE5GbcmNkY4HFqdNZCDsZNGS04v+K9M4o8AvIwbkosA97P3hleJOMmIMm4SZwiiRuQqNJCCONmxYzG6oNOJ6WFvAnhis0D3gRmAKOBPcAKSR9m/edMOZPvzC13xa7I2tYPMrYDWAhMwu3ingU2mNl1WX+pnGmqpPHAXcAS4MlhR19wzno5k6QDpd8zO7EP9yJeDew6l8qZqs7cwVwxnK/QPMRx3UAPsB34EpdKyvs3mdnfuJ1cIzW4DQ7higEgaQLOFF+Iq2L8t6K/5suZfMQdlitWjqQeSa3A7TgHrLL/pKQduBdujUcsUTFSrli1cqVUzuTpii0CdgO7svM/AiwAXs/6UzlTBcNxxSZn4yfjxOsAFkvakvWncqYiklyxxCmSuAFJ4gYkiRuQJG5AkrgBSeIGJKp1bkNDw87e3t4TecdRX18/tqen54Zq43x3aIWgqanphCTLOw4zk8+4lBYCksQNSGziFsU584ojqgtabMQ2c6MiiRuQKJZiZjYLV8c7CXcn5FFJv4xwDG8Ai3DFLk2SdlY7JpaZ+xawRtIs3I3MPG7DtwLzGfgDNgNSeHHN7FLczdGNWdNGYI6ZXTKScUj6fIAC7iEpvLjAlcC+7FtFSt8u8mfWXmhiEDdaYhC3C5iaVVqWKi6nZO2FpvDiZoV93/H/lwstBr6N4ROXUezQzGw2bik2EfgLtxTrGOEYVgMP4j6nfAg4LOn6oY6JQtxYKXxaiJkkbkCSuAFJ4gYkiRuQJG5AkrgB+Q+vpywYc2TyiAAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFcAAABVCAYAAAA8AHhnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAEtElEQVR4nO2bS2hdRRzGf2nSpGitqe8+tFU0VjRUyh984YOioGAQWzehKi60kpUupD6WotCqGwtFK6iIQnclcEWoBbtQRPHzFSpatcEaKsUaTBWxNzWJizm3hJjkniQzuTNxfhCSTGbO/fKd4X/mfGdO09jYGJkwLGq0gIVMNjcg2dyAZHMDks0NSFLmViqVMSCGr1IkZW5qZHMDks0NSDY3INncgGRzA5LNDUg2NyBNKUWOi18pv4APyakemsr0yzM3IC0+DmJmzcB24CFgCfA+8Kik3ybpezPwMrAWaAYOA89J2utDS0z4mrlPAfcA1wGri7a3p+h7CLgXOBdoBx4H3jGzqzxpiQYvMxfYCjwrqR/AzLYBP5rZGklHxneU9GvtZzNbBIziTvLlwLee9ETBnGeumbUDlwCf19okHQb+ANZPM24IqAIfAp/iSsmCwkdZOKv4fmJC+xCwbKpBktqBpbgS8R7wjwctUeHD3D+L72dPaG/Hzd4pkVSV1AvcCjzsQUtUzNlcSUPAz8CGWpuZXYabtX0lD9MCXDFXLbHh64L2GvCkmR0ABoEdwD5JP03saGabge9xF68W4AFgI/CiJy3R4Mvc7cBy4DOgDdgP3A9gZluA3ZKWFn1XFP1XAMO4pVm3pP31PmTv6gpdXV2eJIcnqdvfSqUyFom5+fa30WRzA5JUWZhNKnaqJ4SScmWh1AXNZzBjZucAvcC64ljHgTeB5yWlc6ZLULYs+Axm/gJ6gFWSlgG3A1uAR2asPnLKLsW8BTOSqsA3E44/Clw5u38hXurO3FDBjJm9a2Z/A/24fGL3LPRHTZmyECSYkXR38fcbcCXmP/U7dcqYGyyYkTQi6RPcidtVQktS1DV3noKZ/3Vw4y2YMbPrgTOBj3HZwk3AY8VnLCjKmuszmGkFXgA6cHtdjwI7izHTkoObgOTgJnOabG5AkioLMw1uAoU2kMtC42nEdqbbgAO4AKdGn6QbfWiJCV/P0ManZoPAG7hb2rum6D8ybum2YPFVFrYCOyT1SzoBbAPuNLM1no6fJHOeuVOlZmZWS82OTDKs2cwGgMXFuGckfT1XLbHRiO1M3wHXApfinkb0AR+Y2UoPWqLCR82dUWom6RhwrPh1CHjazO7D1efXPeiJhli2M41Scu2YEo3YzrQRdzL6gTOAJ4ALgX2etERDI7Yzrcc97T0Pt9b9ArhD0kC9D8mpWEByKpY5TTY3INncgGRzA5LNDUg2NyDZ3IAktc5ta2s7ODw8fLLROlpbW5dUq9Vr6vXzdYc2L3R2dp6UZI3WYWYq0y+XhYBkcwOSmrmx7CcrpSOpC1pqpDZzkyKbG5AklmJm1gG8hXtDaBB4UNIP86zhJWAz7hWwTkkH641JZea+CuyS1IHb3t+Il1N6gVuYfKvApERvrpldgHv4uado2gNsMLPz51OHpI/KPIoaT/TmAhcDRyWNgHtJBfilaI+aFMxNlhTMHQBWFTspazsqVxbtURO9ucXrrl8B3UVTN/ClpOONU1WOJO7QzGwdbim2HPgdtxQ7NM8adgKbgItwb3sOSrp6ujFJmJsq0ZeFlMnmBiSbG5BsbkCyuQHJ5gYkmxuQfwFdwOHVp/MLUgAAAABJRU5ErkJggg==\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFcAAABVCAYAAAA8AHhnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAEsklEQVR4nO2cXWgcVRTHf9GYjZrW1C/UGusHxqINSjhURRQFn0qDoC+GavXFilZQX1QQVEShfoBYqLS+WL8IvhVWkCrigyIS/6JIBUu12JYWtAbjF01W4vpwb0pNN9lp9t7s3HB/ECZz98zMyX8OZ86cezcd9XqdTBxOarcDi5ksbkSyuBHJ4kYkixuRpMStVqt1oAw/hUhK3NTI4kYkixuRLG5EsrgRyeJGJIsbkSxuRDpSajmOj4yWwtne4dUdRexy5EakM8RJzOxOYCNwNXCapFnPa2anAm8B1wCXAU9Jei6EH2UjVOT+BrwGPFLAtg58DmwARgNdv5QEiVxJOwHM7OYCthPAK95+IsT1y0rOuRHJ4kYkixuRLG5EQpViJwOnAF1+v9t/NCnpuMLfzCpAB+7mdnr7KUn/hPCnLAQRF7gbeOOY/SN+e4mZ9QEfAFdK2u/HdwMr/O83Ak8DbwL3znWRT3t+ZmhoKJDL8Unq9bdardZLIm5+/W03WdyIJJUWQnbFeodXt3J4obQQslrYhHsgdQMfAvdL+nUW+3OBl4C1uCpjL7BG0qEQ/pSFUGnhCeA24FrgQj/2diNDX3Z9DNSAK4BeYB3wVyBfSkOoUmwD8KykvQBm9hjwg5mtkLRvhu09OEEfPKau/S6QH6Wi5cg1s17gIuCr6TFJPwJ/4Pq7M7kF2ANsN7MxM/vezB5t1Y8yEiItLPHb32eMjwNLG9ifjRN4FDgfuAt40szWBfClVIRIC3/67Rkzxntx0dvI/qCkV/2+zOwdXM5+N4A/paHlyJU0DuwHBqfHzOxSXNR+2+CQb2i8UjCdmrAgoR5orwOPm9knwBjwArBT0k8NbLd7243AVmAVrlp4KJAvpSGUuJuAZcCXQAX4CJdL8bl0m6QeAEn7zGwNbqrnReAQ8Iyk95pdJDduIpIbN5mjZHEjklRaONHGTYvNmbnIaaHdFKoWQna9zOxMYAew0p/rMG6K6PlG820pUzRyQ3a9/gYeAJZLWgrc6j+/bx7+l5qidW6wrpekSY7vgv2LuxGLiqaRG6vrZWbvm9kRXMpYAmyb359QXoqkhShdL0lrgR7gelyKaZi/U6aIuPPuekmqSRIw3fX6H5KmJH2Bu3FbirudBk3FXaCuVydweTNfUqPoAy1Y18vMrgNOxy2ArgE3AA/7aywqioobsuvV5cf7cdF8ENjsrzEnuSsWkdwVyxwlixuRLG5EsrgRyeJGJIsbkSxuRJKqcyuVyq5ardb2b112dXV1T05OrmpmF2rdwoIwMDAwIcna7YeZqYhdTgsRyeJGJDVxy9I5K+RHUg+01EgtcpMiixuRJEoxM+vHfTf4LNxMyHpJexbYh5eBO4CLgQFJu5odk0rkbgW2SOrHTWS2Yxp+B3ATMHOdxqyUXly/NGoQGPFDI8CgmZ2zkH5I+kzSgRM5pvTiAn24qfopcNPxuHm5vrZ6VYAUxE2WFMQ9ACz3Ky2nV1xe4MdLTenFlfQLbqHJsB8aBr6WdLh9XhUjiTc0M1uJK8WW4f773npJuxfYh83A7cB5uHVtY5KumuuYJMRNldKnhZTJ4kYkixuRLG5EsrgRyeJGJIsbkf8AkgrLEd1N5ssAAAAASUVORK5CYII=\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "n_bars = 3\n",
+ "for i in range(len(shap_values)):\n",
+ " fig = plt.figure()\n",
+ " \n",
+ " clust_color = UMAP_and_GMM[UMAP_and_GMM['color']==i]['dbscan_hex'].iloc[0]\n",
+ " shap.summary_plot(shap_values[i], X, \n",
+ " [str(np.round(x*(1000/30000),2)) for x in pd.DataFrame(X).columns.tolist()],\n",
+ " plot_type=\"bar\", \n",
+ " max_display = n_bars, color = clust_color,show=False)\n",
+ " ytick_labels = [np.float(i.get_text())*0.05 for i in ax.get_yticklabels()][::-1]\n",
+ " \n",
+ " ax = fig.gca()\n",
+ " fig.set_size_inches(0.6,1.0)\n",
+ " ax.set_xlabel('',fontsize=12)\n",
+ " ax.set_ylabel('',fontsize=12)\n",
+ " ax.set_xlim(0,1)\n",
+ "\n",
+ " f, arr = plot_group(i+1,clustering_solution,UMAP_and_GMM,CUSTOM_PAL_SORT_3,mean_only=True)\n",
+ " ytick_labels = [round(np.float(i.get_text())/(1000/30000)) for i in ax.get_yticklabels()][::-1]\n",
+ " bar_heights = []\n",
+ " arr.spines['left'].set_visible(False)\n",
+ " arr.spines['right'].set_visible(False)\n",
+ " arr.spines['bottom'].set_visible(False)\n",
+ "\n",
+ " for j in range(n_bars):\n",
+ "\n",
+ " bar_height = ax.patches[j].get_width()\n",
+ " bar_heights.append(bar_height)\n",
+ "\n",
+ " bar_heights = bar_heights[::-1]\n",
+ " percent_total_height = [x/sum(bar_heights) for x in bar_heights]\n",
+ " for k,label in enumerate(ytick_labels):\n",
+ " arr.axvline(label,color='k',alpha=percent_total_height[k])\n",
+ " f.set_size_inches([1.5,1.0])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "TNQT2bTVpCY8"
+ },
+ "source": [
+ "# Figure 5"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "9TWRyR1FBOoF"
+ },
+ "source": [
+ "## Figure 5A,B: Average FR traces aligned to stimulus"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "0BoC8n5Yk9r0"
+ },
+ "source": [
+ "### We next plot the averaged FR traces for each WaveMAP cluster aligned to stimulus onset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 673
+ },
+ "id": "m8NciEo7pCvw",
+ "outputId": "dd603aaa-a801-412d-8584-ab723de07026"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "BS_ORDERING = [5,6,0]\n",
+ "NS_ORDERING = [7,1,2,3,4]\n",
+ "\n",
+ "f, arr = plt.subplots(3,figsize=[2,3.33])\n",
+ "\n",
+ "time = np.arange(-0.1,0.5,0.001)\n",
+ "\n",
+ "for i,ix in enumerate(BS_ORDERING):\n",
+ " PREF = UMAP_traces_df.iloc[ix]['PREF']\n",
+ " NONPREF = UMAP_traces_df.iloc[ix]['NONPREF']\n",
+ " PREF_UPPER = UMAP_traces_df.iloc[ix]['PREF_UPPER_BOUND']\n",
+ " PREF_LOWER = UMAP_traces_df.iloc[ix]['PREF_LOWER_BOUND']\n",
+ " NONPREF_UPPER = UMAP_traces_df.iloc[ix]['NONPREF_UPPER_BOUND']\n",
+ " NONPREF_LOWER = UMAP_traces_df.iloc[ix]['NONPREF_LOWER_BOUND']\n",
+ " arr[i].plot(time,PREF,color=CUSTOM_PAL_SORT_3[ix])\n",
+ " arr[i].plot(time,NONPREF,'--',color=CUSTOM_PAL_SORT_3[ix])\n",
+ " arr[i].fill_between(time,PREF_UPPER,PREF_LOWER,\n",
+ " color='gray',alpha=0.2)\n",
+ " arr[i].fill_between(time,NONPREF_UPPER,NONPREF_LOWER,\n",
+ " color='gray',alpha=0.2)\n",
+ " arr[i].set_ylim(5,30)\n",
+ " arr[i].set_xticks([-0.1,0.1,0.3,0.5])\n",
+ " arr[i].set_xlim(-0.1,0.5)\n",
+ " arr[i].set_yticks([5,30])\n",
+ " arr[i].spines['left'].set_position(('axes', -0.05))\n",
+ " arr[i].spines['top'].set_visible(False)\n",
+ " arr[i].spines['right'].set_visible(False)\n",
+ " arr[i].axvline(0,ymin=0.,ymax=30,linestyle='dashed',color='k')\n",
+ " f.tight_layout()\n",
+ "\n",
+ "f, arr = plt.subplots(5,figsize=[2,6])\n",
+ "\n",
+ "time = np.arange(-0.1,0.5,0.001)\n",
+ "\n",
+ "for i,ix in enumerate(NS_ORDERING):\n",
+ " PREF = UMAP_traces_df.iloc[ix]['PREF']\n",
+ " NONPREF = UMAP_traces_df.iloc[ix]['NONPREF']\n",
+ " PREF_UPPER = UMAP_traces_df.iloc[ix]['PREF_UPPER_BOUND']\n",
+ " PREF_LOWER = UMAP_traces_df.iloc[ix]['PREF_LOWER_BOUND']\n",
+ " NONPREF_UPPER = UMAP_traces_df.iloc[ix]['NONPREF_UPPER_BOUND']\n",
+ " NONPREF_LOWER = UMAP_traces_df.iloc[ix]['NONPREF_LOWER_BOUND']\n",
+ " arr[i].plot(time,PREF,color=CUSTOM_PAL_SORT_3[ix])\n",
+ " arr[i].plot(time,NONPREF,'--',color=CUSTOM_PAL_SORT_3[ix])\n",
+ " arr[i].fill_between(time,PREF_UPPER,PREF_LOWER,\n",
+ " color='gray',alpha=0.2)\n",
+ " arr[i].fill_between(time,NONPREF_UPPER,NONPREF_LOWER,\n",
+ " color='gray',alpha=0.2)\n",
+ " arr[i].set_ylim(5,30)\n",
+ " arr[i].set_xticks([-0.1,0.1,0.3,0.5])\n",
+ " arr[i].set_xlim(-0.1,0.5)\n",
+ " arr[i].set_yticks([5,30])\n",
+ " arr[i].spines['left'].set_position(('axes', -0.05))\n",
+ " arr[i].spines['top'].set_visible(False)\n",
+ " arr[i].spines['right'].set_visible(False)\n",
+ " arr[i].axvline(0,ymin=0.,ymax=30,linestyle='dashed',color='k')\n",
+ " f.tight_layout()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "sPazuw5flmIT"
+ },
+ "source": [
+ "## Figure 5C: Baseline WaveMAP cluster FRs"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "JieOh-3Rq5Ra"
+ },
+ "source": [
+ "### From these stimulus-aligned FR traces, we also calculated the baseline FR which is the FR averaged over the pre-stimulus period"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 191
+ },
+ "id": "hz1xZMyOt7fD",
+ "outputId": "e4722657-82fa-48f6-a788-0be27f86844a"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def bootstrap_median(data,iter_=5000):\n",
+ " median_list = []\n",
+ " \n",
+ " for i in range(iter_):\n",
+ " median_list.append(np.median(np.random.choice(data,len(data))))\n",
+ " \n",
+ " return np.mean(median_list), np.std(median_list)\n",
+ "\n",
+ "def get_baseline_FR_stats(df,clust_ix,conf=0.95,UMAP_clusts=True):\n",
+ " baseline_FR = baseline_FR_df[baseline_FR_df['dbscan_color']==str(clust_ix)]['baseline_FR'].tolist()\n",
+ " \n",
+ " if not UMAP_clusts:\n",
+ " GMM_baseline_FR = GMM_baseline_FR_df[GMM_baseline_FR_df['GMM_class']==str(clust_ix)]['baseline_FR'].tolist()\n",
+ " \n",
+ " n = len(baseline_FR)\n",
+ " m, se = np.median(baseline_FR), scipy.stats.sem(baseline_FR)\n",
+ " h = se * scipy.stats.t.ppf((1 + conf) / 2., n-1)\n",
+ " return m, se, m-h, m+h\n",
+ "\n",
+ "def get_baseline_FR(df,clust_ix,UMAP_clusts=True):\n",
+ " baseline_FR = baseline_FR_df[baseline_FR_df['dbscan_color']==str(clust_ix)]['baseline_FR'].tolist()\n",
+ " \n",
+ " if not UMAP_clusts:\n",
+ " GMM_baseline_FR = GMM_baseline_FR_df[GMM_baseline_FR_df['GMM_class']==str(clust_ix)]['baseline_FR'].tolist()\n",
+ " \n",
+ " return baseline_FR\n",
+ "\n",
+ "f, arr = plt.subplots(1)\n",
+ "f.set_size_inches(3,2.5)\n",
+ "\n",
+ "for i,clust_ix in enumerate([5,6,0]):\n",
+ " start_ix = 0 \n",
+ " \n",
+ " median, med_se = bootstrap_median(get_baseline_FR(baseline_FR_df,clust_ix))\n",
+ " \n",
+ " arr.bar(start_ix+i, median, \n",
+ " color=UMAP_and_GMM[UMAP_and_GMM['color']==clust_ix]['dbscan_hex'],\n",
+ " yerr=med_se)\n",
+ " \n",
+ "for i,clust_ix in enumerate([7,1,2,3,4]):\n",
+ " start_ix = 4\n",
+ " \n",
+ " median, med_se = bootstrap_median(get_baseline_FR(baseline_FR_df,clust_ix))\n",
+ " \n",
+ " arr.bar(start_ix+i, median, \n",
+ " color=UMAP_and_GMM[UMAP_and_GMM['color']==clust_ix]['dbscan_hex'],\n",
+ " yerr=med_se)\n",
+ "\n",
+ "arr.set_ylabel('Baseline FR (spikes/s)')\n",
+ "arr.set_xticks([1,6]);\n",
+ "arr.set_xticklabels(['Broad-Spiking','Narrow-Spiking'],fontsize=12,fontname='Arial')\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.set_ylim(0,15);"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "oFXG_47PT3y9"
+ },
+ "source": [
+ "## Figure 5D: Max WaveMAP cluster FRs"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "k2jcxJ7krDQK"
+ },
+ "source": [
+ "### And next calculate the max FR as the highest FR reached over the course of the entire post-stimulus trial."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 191
+ },
+ "id": "jsS17aRFUEQs",
+ "outputId": "2dc9b1cf-f44b-4cc5-a835-a76a41d393b6"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "f, arr = plt.subplots(1)\n",
+ "\n",
+ "f.set_size_inches(3,2.5)\n",
+ " \n",
+ "def get_max_FR_stats(df,clust_ix,conf=0.95,UMAP_clusts=True):\n",
+ " max_FR = max_FR_df[max_FR_df['dbscan_color']==str(clust_ix)]['max_FR'].tolist()\n",
+ " \n",
+ " if not UMAP_clusts:\n",
+ " max_FR = max_FR_df[max_FR_df['GMM_class']==str(clust_ix)]['max_FR'].tolist()\n",
+ " \n",
+ " n = len(max_FR)\n",
+ " m, se = np.median(max_FR), scipy.stats.sem(max_FR)\n",
+ " h = se * scipy.stats.t.ppf((1 + conf) / 2., n-1)\n",
+ " return m, se, m-h, m+h\n",
+ "\n",
+ "def get_max_FR(df,clust_ix, UMAP_clusts=True):\n",
+ " max_FR = max_FR_df[max_FR_df['dbscan_color']==str(clust_ix)]['max_FR'].tolist()\n",
+ " \n",
+ " if not UMAP_clusts:\n",
+ " max_FR = GMM_max_FR_df[GMM_max_FR_df['GMM_class']==str(clust_ix)]['max_FR'].tolist()\n",
+ " \n",
+ " return max_FR\n",
+ "\n",
+ "for i,clust_ix in enumerate([5,6,0]):\n",
+ " start_ix = 0 \n",
+ " \n",
+ " median, med_se = bootstrap_median(get_max_FR(max_FR_df,clust_ix))\n",
+ " \n",
+ " arr.bar(start_ix+i, median, \n",
+ " color=UMAP_and_GMM[UMAP_and_GMM['color']==clust_ix]['dbscan_hex'],\n",
+ " yerr=med_se)\n",
+ " \n",
+ "for i,clust_ix in enumerate([7,1,2,3,4]):\n",
+ " start_ix = 4\n",
+ " \n",
+ " median, med_se = bootstrap_median(get_max_FR(max_FR_df,clust_ix))\n",
+ " \n",
+ " arr.bar(start_ix+i, median, \n",
+ " color=UMAP_and_GMM[UMAP_and_GMM['color']==clust_ix]['dbscan_hex'],\n",
+ " yerr=med_se)\n",
+ "\n",
+ "arr.set_ylabel('Max FR (spikes/s)')\n",
+ "arr.set_xticks([1,6]);\n",
+ "arr.set_xticklabels(['Broad-Spiking','Narrow-Spiking'],fontsize=12,fontname='Arial')\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.set_ylim(0,40);"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "xKOQstlZUbuh"
+ },
+ "source": [
+ "## Figure 5E: Firing rate range for WaveMAP clusters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "E6CovcATrKa8"
+ },
+ "source": [
+ "### Taking the difference between the max FR and baseline FR, we have the FR Range."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 191
+ },
+ "id": "YltyClzbU0rR",
+ "outputId": "87724540-c234-47a6-d6ab-e2bfd28f87ea"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def get_dynamic_range_stats(clust_ix,max_FR_df,baseline_FR_df,conf=0.95,UMAP_clusts=True):\n",
+ " if UMAP_clusts:\n",
+ " max_FR = max_FR_df[max_FR_df['dbscan_color']==str(clust_ix)]['max_FR'].tolist()\n",
+ " baseline_FR = baseline_FR_df[baseline_FR_df['dbscan_color']==str(clust_ix)]['baseline_FR'].tolist()\n",
+ " \n",
+ " if not UMAP_clusts:\n",
+ " max_FR = max_FR_df[max_FR_df['GMM_class']==str(clust_ix)]['max_FR'].tolist()\n",
+ " baseline_FR = baseline_FR_df[baseline_FR_df['GMM_class']==str(clust_ix)]['baseline_FR'].tolist()\n",
+ " \n",
+ " dynamic_range_FR = np.subtract(max_FR,baseline_FR)\n",
+ " \n",
+ " n = len(dynamic_range_FR)\n",
+ " m, se = np.median(dynamic_range_FR), scipy.stats.sem(dynamic_range_FR)\n",
+ " h = se * scipy.stats.t.ppf((1 + conf) / 2., n-1)\n",
+ " \n",
+ " return m, se, m-h, m+h\n",
+ "\n",
+ "def get_dynamic_range(clust_ix,max_FR_df,baseline_FR_df,UMAP_clusts=True):\n",
+ " if UMAP_clusts:\n",
+ " max_FR = max_FR_df[max_FR_df['dbscan_color']==str(clust_ix)]['max_FR'].tolist()\n",
+ " baseline_FR = baseline_FR_df[baseline_FR_df['dbscan_color']==str(clust_ix)]['baseline_FR'].tolist()\n",
+ " \n",
+ " if not UMAP_clusts:\n",
+ " max_FR = GMM_max_FR_df[GMM_max_FR_df['GMM_class']==str(clust_ix)]['max_FR'].tolist()\n",
+ " baseline_FR = GMM_baseline_FR_df[GMM_baseline_FR_df['GMM_class']==str(clust_ix)]['baseline_FR'].tolist()\n",
+ " \n",
+ " return np.subtract(max_FR,baseline_FR)\n",
+ "\n",
+ "\n",
+ "f, arr = plt.subplots(1)\n",
+ "\n",
+ "f.set_size_inches(3,2.5)\n",
+ "\n",
+ "for i,clust_ix in enumerate([5,6,0]):\n",
+ " start_ix = 0 \n",
+ " \n",
+ " median, med_se = bootstrap_median(get_dynamic_range(clust_ix,max_FR_df,baseline_FR_df))\n",
+ " \n",
+ " arr.bar(start_ix+i, median, \n",
+ " color=UMAP_and_GMM[UMAP_and_GMM['color']==clust_ix]['dbscan_hex'],\n",
+ " yerr=med_se)\n",
+ " \n",
+ "for i,clust_ix in enumerate([7,1,2,3,4]):\n",
+ " start_ix = 4\n",
+ " \n",
+ " median, med_se = bootstrap_median(get_dynamic_range(clust_ix,max_FR_df,baseline_FR_df))\n",
+ " \n",
+ " arr.bar(start_ix+i, median, \n",
+ " color=UMAP_and_GMM[UMAP_and_GMM['color']==clust_ix]['dbscan_hex'],\n",
+ " yerr=med_se)\n",
+ "\n",
+ "arr.set_ylabel('FR Range (spikes/s)')\n",
+ "arr.set_xticks([1,6]);\n",
+ "arr.set_xticklabels(['Broad-Spiking','Narrow-Spiking'],fontsize=12,fontname='Arial')\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.set_ylim(0,25);"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "2T8r9cVvsL9D"
+ },
+ "source": [
+ "# Figure 6: Functional properties of WaveMAP clusters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "RLXBKjDdrUjE"
+ },
+ "source": [
+ "### Next we show the change in firing rate as a function of time against various stimulus coherences. We show this for an example BS and NS cluster."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "RKgU_7JdVhEQ"
+ },
+ "source": [
+ "## Figure 6A: Average FR change across coherence for WaveMAP cluster 6\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 213
+ },
+ "id": "7oZM8CpHVvrk",
+ "outputId": "e48a716e-070e-48dd-cd14-d4708acd249b"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def hex_to_rgb(hex_code):\n",
+ " h = hex_code.lstrip('#')\n",
+ " rgb_256 = tuple(int(h[i:i+2], 16) for i in (0, 2, 4))\n",
+ " rgb = tuple(x/256 for x in rgb_256)\n",
+ " return rgb\n",
+ "\n",
+ "def fr_by_coherence(ix,CLUST_IX):\n",
+ "\n",
+ " f, arr = plt.subplots(1,figsize=[3,2.5])\n",
+ " for i in range(diffV_list[ix].shape[1]):\n",
+ " arr.plot(np.linspace(-0.1,0.4,499),diffV_list[ix][:,i],c=coherence_colors[i],linewidth=3)\n",
+ " arr.spines['top'].set_visible(False)\n",
+ " arr.spines['right'].set_visible(False)\n",
+ " arr.spines['left'].set_position(['axes',-0.05])\n",
+ " arr.set_xlim(0.,0.4)\n",
+ "\n",
+ " arr.set_ylim(0,15)\n",
+ " arr.set_yticks([0,5,10,15])\n",
+ " arr.set_xlabel('Time Relative to \\nStimulus Onset (ms)')\n",
+ " arr.set_ylabel('Average Firing Rate \\n(spikes/s)')\n",
+ "\n",
+ " for i,slope in enumerate(dec_dyn_data[ix]):\n",
+ " interval = [0.175,0.325] #Interval that Chand did regression (don't change)\n",
+ " x = [interval[0],interval[1]]\n",
+ " y = [diffV_list[ix][274,i],diffV_list[ix][424,i]]\n",
+ "\n",
+ " arr.plot(x,y,color='k',linestyle='dashed',alpha=0.5,linewidth=3,zorder=10)\n",
+ " \n",
+ "fr_by_coherence(2,4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "c6Sg0GPBbB-Z"
+ },
+ "source": [
+ "## Figure 6B: Average FR change across coherence for WaveMAP cluster 1"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 213
+ },
+ "id": "qV-qJlDHbAwt",
+ "outputId": "5ef1b5a3-6cf8-4f10-f0a1-ec342527e3f8"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fr_by_coherence(7,4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "foV7Y1LabiYO"
+ },
+ "source": [
+ "## Figure 6C: FR rate of rise per coherence for BS WaveMAP clusters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "E-3JeUJVr4ja"
+ },
+ "source": [
+ "### We next show the FR rate of rise (how quickly it increases after stimulus presentation) versus coherences"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 209
+ },
+ "id": "Y4yc6UIDboV7",
+ "outputId": "89731aec-c434-4faf-d8cc-6738613dc7d8"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "f, arr = plt.subplots(1,figsize=[3,2.5])\n",
+ "\n",
+ "for i,clust_ix in enumerate([5,6,0]):\n",
+ " arr.errorbar(range(7),dec_dyn_data[i],yerr=dec_dyn_data_err[i], marker='o', fillstyle='full', markerfacecolor='w',\n",
+ " c=hex_to_rgb(UMAP_and_GMM[UMAP_and_GMM['color']==clust_ix]['dbscan_hex'].tolist()[0]),clip_on=False)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.spines['left'].set_position(['axes',-0.05])\n",
+ "arr.spines['bottom'].set_position(['axes',-0.05])\n",
+ "arr.set_xticks(np.arange(len(coherences)))\n",
+ "arr.set_xlim(0,len(coherences)-1)\n",
+ "arr.set_xticklabels([int(x) for x in np.round(coherences,0)])\n",
+ "arr.set_ylim(0,70)\n",
+ "arr.set_yticks([0,35,70])\n",
+ "arr.set_ylabel('FR Rate of Rise \\n(spikes/s/s)')\n",
+ "arr.set_xlabel('Coherence (%)')\n",
+ "arr.invert_xaxis()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "elIWdg6_b5yR"
+ },
+ "source": [
+ "## Figure 6D: FR rate of rise per coherence for NS WaveMAP clusters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "KJz0yfR0sEgz"
+ },
+ "source": [
+ "### and similarly we show this for NS clusters as well"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 209
+ },
+ "id": "Z2kwP3tfb400",
+ "outputId": "d587d9bc-1d53-44a5-cb75-e32b9ddcd799"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "f, arr = plt.subplots(1,figsize=[3,2.5])\n",
+ "offset=3\n",
+ "\n",
+ "for i,clust_ix in enumerate([7,1,2,3,4]):\n",
+ " arr.errorbar(range(7),dec_dyn_data[i+offset],yerr=dec_dyn_data_err[i+offset], marker='o', fillstyle='full', markerfacecolor='w',\n",
+ " c=hex_to_rgb(UMAP_and_GMM[UMAP_and_GMM['color']==clust_ix]['dbscan_hex'].tolist()[0]),clip_on=False)\n",
+ " \n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.spines['left'].set_position(['axes',-0.05])\n",
+ "arr.spines['bottom'].set_position(['axes',-0.05])\n",
+ "arr.set_xticks(np.arange(len(coherences)))\n",
+ "arr.set_xlim(0,len(coherences)-1)\n",
+ "arr.set_xticklabels([int(x) for x in np.round(coherences,0)])\n",
+ "arr.set_ylim(0,70)\n",
+ "arr.set_yticks([0,35,70])\n",
+ "arr.set_ylabel('FR Rate of Rise \\n(spikes/s/s)')\n",
+ "arr.set_xlabel('Coherence (%)')\n",
+ "arr.invert_xaxis()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "JQeBa4iKclat"
+ },
+ "source": [
+ "## Figure 6E: Coherence slope per WaveMAP cluster"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "RjtsY6l6sKHG"
+ },
+ "source": [
+ "### Now we take a slope of this FR rate of rise vs. coherence and pplot these differences. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 191
+ },
+ "id": "PIi4yNlzclyz",
+ "outputId": "3b179829-99ee-408a-a2a9-97e5ea017a7e"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "RT_bins = [12]\n",
+ "\n",
+ "offset=3\n",
+ "\n",
+ "f, arr = plt.subplots(1)\n",
+ "\n",
+ "f.set_size_inches(3,2.5)\n",
+ "\n",
+ "arr.set_ylabel('Coherence Slope \\n(spikes/s/s/coherence)',fontsize=12,fontname='Arial');\n",
+ "# arr.set_ylim(ymin=150,ymax=300)\n",
+ "\n",
+ "arr.set_ylim(ymin=-0.0,ymax=0.4)\n",
+ "arr.set_yticks([0, 0.2, 0.4]);\n",
+ "# arr.set_yticklabels([150,200,250,300],fontsize=12,fontname='Arial')\n",
+ "arr.set_xticks([1,6]);\n",
+ "arr.set_xticklabels(['Broad-Spiking','Narrow-Spiking'],fontsize=12,fontname='Arial')\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "\n",
+ "# discrim_GMM_dict = {}\n",
+ "\n",
+ "# for i,label in enumerate(GMM_class_df['Class'].to_numpy()):\n",
+ "# discrim_GMM_dict[label] = get_discrim(label,GMM_class_df['Class'].to_numpy(), vmIndex_df)\n",
+ " \n",
+ "for i,clust_ix in enumerate([5,6,0]):\n",
+ " \n",
+ " median, med_se = bootstrap_median(dec_dyn_slope[i])\n",
+ " \n",
+ " start_ix = 0\n",
+ " arr.bar(start_ix+i, median, \n",
+ " color=UMAP_and_GMM[UMAP_and_GMM['color']==clust_ix]['dbscan_hex'],\n",
+ " yerr=med_se)\n",
+ " \n",
+ "for i,clust_ix in enumerate([7,1,2,3,4]):\n",
+ " start_ix = 4\n",
+ " \n",
+ " median, med_se = bootstrap_median(dec_dyn_slope[i+offset])\n",
+ " \n",
+ " arr.bar(start_ix+i, median, \n",
+ " color=UMAP_and_GMM[UMAP_and_GMM['color']==clust_ix]['dbscan_hex'],\n",
+ " yerr=med_se)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "-LlF0DHXfOoB"
+ },
+ "source": [
+ "## Figure 6F: Discrimination Time "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rqcPrca7s3nW"
+ },
+ "source": [
+ "### We now calculate the discrimination time which is the earliest time point at which we can predict the reach direction by observing a given neuron. We do this for all WaveMAP clusters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 314
+ },
+ "id": "7ZAvkjWUgLNY",
+ "outputId": "645951d2-e3df-46bc-92a9-1e6c58a806a9"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def get_all_discrim(cluster_ix):\n",
+ " RT_bin = 12\n",
+ " clust_data = list(all_data_df[all_data_df.cluster_ix == cluster_ix]['disc'])\n",
+ " discrim_times = [x for x in clust_data if not np.isnan(x)]\n",
+ " return discrim_times\n",
+ "\n",
+ "RT_bins = [12]\n",
+ "\n",
+ "f, arr = plt.subplots(1)\n",
+ "\n",
+ "f.set_size_inches(3,2.5)\n",
+ "\n",
+ "arr.set_ylabel('Discrimination Time (ms)',fontsize=12,fontname='Arial');\n",
+ "# arr.set_ylim(ymin=150,ymax=300)\n",
+ "\n",
+ "arr.set_ylim(ymin=150,ymax=300)\n",
+ "arr.set_yticks([150, 200, 250, 300]);\n",
+ "arr.set_yticklabels([150,200,250,300],fontsize=12,fontname='Arial')\n",
+ "arr.set_xticks([1,6]);\n",
+ "arr.set_xticklabels(['Broad-Spiking','Narrow-Spiking'],fontsize=12,fontname='Arial')\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "\n",
+ "# discrim_GMM_dict = {}\n",
+ "\n",
+ "# for i,label in enumerate(GMM_class_df['Class'].to_numpy()):\n",
+ "# discrim_GMM_dict[label] = get_discrim(label,GMM_class_df['Class'].to_numpy(), vmIndex_df)\n",
+ " \n",
+ "for i,clust_ix in enumerate([5,6,0]):\n",
+ " start_ix = 0\n",
+ " \n",
+ " median, med_se = bootstrap_median(get_all_discrim(clust_ix))\n",
+ " \n",
+ " arr.bar(start_ix+i, median, \n",
+ " color=UMAP_and_GMM[UMAP_and_GMM['color']==clust_ix]['dbscan_hex'],\n",
+ " yerr=med_se)\n",
+ " arr.annotate(str(clust_ix+1), xy=(start_ix+i, 0.003),fontsize=12, fontname='Arial',color = 'white', ha=\"center\")\n",
+ " \n",
+ "for i,clust_ix in enumerate([7,1,2,3,4]):\n",
+ " start_ix = 4\n",
+ " \n",
+ " median, med_se = bootstrap_median(get_all_discrim(clust_ix))\n",
+ " \n",
+ " arr.bar(start_ix+i, median, \n",
+ " color=UMAP_and_GMM[UMAP_and_GMM['color']==clust_ix]['dbscan_hex'],\n",
+ " yerr=med_se)\n",
+ " arr.annotate(str(clust_ix+1), xy=(start_ix+i, 0.003),fontsize=12, fontname='Arial',color = 'white', ha=\"center\")\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "sFj_-b_jZYSk"
+ },
+ "source": [
+ "# Figure 7: Laminar distributions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "87V8W5vOlxWW"
+ },
+ "source": [
+ "### First we plot the laminar distributions of each WaveMAP cluster. Each bar corresponds to one of 16 channels along the U-probe located from the pial surface to 2.4 mm into cortex (the bottom of Layer VI in PMd)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 1000
+ },
+ "id": "ze2O18N-Y0gO",
+ "outputId": "ba14c3d5-b30d-4dc9-b328-56d4d4dad80e"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
+ "Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
+ "Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
+ "Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
+ "Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
+ "Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
+ "Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
+ "Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "ORDERING = [0, 1, 2, 3, 4, 5, 6, 7]\n",
+ "TIME_LENGTH = 1600\n",
+ "\n",
+ "for i,ix in enumerate(range(0,8)):\n",
+ " f, arr = plt.subplots(1, figsize = [3,2])\n",
+ " clust_color = UMAP_and_GMM[UMAP_and_GMM['color']==ix]['dbscan_hex'].iloc[0]\n",
+ "\n",
+ " g = sns.countplot(filt_full_df[filt_full_df['cluster_ix']==ix]['depth'].tolist(),\n",
+ " ax=arr, color=clust_color, order=DEPTHS)\n",
+ " sns.despine(ax=g)\n",
+ " \n",
+ " g.set_ylabel('Counts')\n",
+ "\n",
+ " g.set_xlim([-1,17])\n",
+ " g.set_xticks([3,7,11,15])\n",
+ " g.set_xticklabels(['0.6','1.2','1.8','2.4'],fontsize=12)\n",
+ " g.set_yticks([0,15])\n",
+ " g.set_yticklabels([0,15],fontsize=12)\n",
+ " arr.set_xlabel('Channel Depth (mm)',fontsize=12)\n",
+ " x,y = 15,13\n",
+ " ellipse = mpl.patches.Ellipse((x,y), width=2.0, height=3.1, facecolor='w',\n",
+ " edgecolor='k',linewidth=1.5)\n",
+ " label = arr.annotate(str(ORDERING[ix]+1), xy=(x-0.07, y-0.8),fontsize=12, color = 'k', ha=\"center\")\n",
+ " arr.add_patch(ellipse)\n",
+ " plt.tight_layout()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "SC3LqWpPl5MX"
+ },
+ "source": [
+ "### and compare that to the distributions of GMM clusters"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 649
+ },
+ "id": "LO6x9DdblE5p",
+ "outputId": "b6bc0394-8ba6-4007-a243-f2849ccc3771"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
+ "Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
+ "Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
+ "Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "for i,ix in enumerate(range(1,5)):\n",
+ " f, arr = plt.subplots(1, figsize = [3,2])\n",
+ " clust_color = GMM_PAL[i]\n",
+ "\n",
+ " g = sns.countplot(filt_full_df[filt_full_df['gmm_ix']==ix]['depth'].tolist(),\n",
+ " ax=arr, color=clust_color, order=DEPTHS)\n",
+ " sns.despine(ax=g)\n",
+ " \n",
+ " g.set_ylabel('Counts')\n",
+ "\n",
+ " g.set_xlim([-1,17])\n",
+ " g.set_xticks([3,7,11,15])\n",
+ " g.set_xticklabels(['0.6','1.2','1.8','2.4'],fontsize=12)\n",
+ " g.set_yticks([0,25])\n",
+ " g.set_yticklabels([0,25],fontsize=12)\n",
+ " arr.set_xlabel('Channel Depth (mm)',fontsize=12)\n",
+ " plt.tight_layout()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "R6zD1Vqb6raq"
+ },
+ "source": [
+ "# Figure 8: Laminar distribution of inhibitory subtypes"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "WkbPoDMztZv6"
+ },
+ "source": [
+ "### We first calculate the laminar distribution of the CB-, CR-, and PV-positive inhibitory cell types. The following code contains functions to read stereological hand counts done in FIJI (ImageJ)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 265
+ },
+ "id": "DUhkzznC6r0v",
+ "outputId": "a974ee0e-7381-4780-b480-b4b418012654"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "import xml.etree.ElementTree as ET\n",
+ "xml_files_path = 'WaveMAP_Paper/data/annotations/'\n",
+ "\n",
+ "SHRINKAGE_FACTOR_DICT = {'AM289': 1.2, \n",
+ " 'AM292': 1.3,\n",
+ " 'AM294': 1.1,\n",
+ " 'AM295': 1.1,\n",
+ " 'AM296': 1.3,\n",
+ " 'AM299': 1.2}\n",
+ "\n",
+ "def plot_stain_density(norm_anatomical_dict,stain, ylim = None, color = 'blue'):\n",
+ " nonan_norm_anat = [x for x in norm_anatomical_dict[stain] if not np.isnan(x).any()]\n",
+ " nonan_norm_anat_zip = list(zip(*nonan_norm_anat))\n",
+ "\n",
+ " nonan_norm_anat_mean = [np.mean(x) for x in nonan_norm_anat_zip]\n",
+ " nonan_norm_anat_err = [np.std(x)/len(x) for x in nonan_norm_anat_zip]\n",
+ " \n",
+ " f, arr = plt.subplots(1, figsize=[3.5,2])\n",
+ " arr.set_ylim(0,0.3)\n",
+ " arr.set_xticks([0,4,8,12,16])\n",
+ " arr.set_xticklabels([0.0,0.6,1.2,1.8,2.4])\n",
+ " arr.spines['top'].set_visible(False)\n",
+ " arr.spines['right'].set_visible(False)\n",
+ " arr.bar(range(16),nonan_norm_anat_mean,yerr=nonan_norm_anat_err,color = color)\n",
+ " arr.set_ylabel('Normalized Counts')\n",
+ " arr.set_xlabel('Depth from Surface (mm)')\n",
+ " arr.spines['bottom'].set_bounds(0.0,16)\n",
+ " return \n",
+ "\n",
+ "def point_to_line_dist(point_coords,line_coord_pair,shrinkage=None):\n",
+ " SCALE_FACTOR = 3.7313 #pixels/um\n",
+ " \n",
+ " [line_x1, line_x2], [line_y1, line_y2] = line_coord_pair\n",
+ " p1, p2 = point_coords\n",
+ " \n",
+ " distance = np.abs((line_y2-line_y1)*p1 - (line_x2-line_x1)*p2 + line_x2*line_y1 - line_y2*line_x1)/np.sqrt(np.power(line_y2-line_y1,2)+(np.power(line_x2-line_x1,2)))\n",
+ " \n",
+ " if shrinkage:\n",
+ " distance = distance*shrinkage\n",
+ " \n",
+ " return distance/SCALE_FACTOR\n",
+ "\n",
+ "def parse_annotation(xml_files_path):\n",
+ " marker_dict = {}\n",
+ " n_skip = 2 #empty items to skip past \n",
+ " for f in os.listdir(xml_files_path):\n",
+ " if f.endswith('.xml'):\n",
+ " marker_list = []\n",
+ " file = os.path.join(xml_files_path,f)\n",
+ " tree = ET.parse(file)\n",
+ " root = tree.getroot()\n",
+ "\n",
+ " for mark_ix in range(len(root[1][2])-2): \n",
+ " x = int(root[1][2][mark_ix+n_skip][0].text)\n",
+ " y = int(root[1][2][mark_ix+n_skip][1].text)\n",
+ " marker_list.append([x,y])\n",
+ " else:\n",
+ " continue\n",
+ " marker_dict[f] = marker_list\n",
+ "\n",
+ " return marker_dict\n",
+ "\n",
+ "def calc_densities(xml_files_path,shrinkage_factor=None):\n",
+ " marker_dict = parse_annotation(xml_files_path)\n",
+ " marker_dist_dict = {}\n",
+ " for f in list(marker_dict.keys()):\n",
+ " specimen_info_ix = f.find('AM')\n",
+ " if f.endswith('.xml'):\n",
+ " csv_file = f[specimen_info_ix:-4]+'.csv'\n",
+ " if os.path.exists(os.path.join(xml_files_path,csv_file)):\n",
+ " xml_files = list(parse_annotation(xml_files_path))\n",
+ " f_df = pd.read_csv(os.path.join(xml_files_path,xml_files[specimen_info_ix:-4]+'.csv'))\n",
+ " line_coords = [f_df['X'].tolist(), f_df['Y'].tolist()]\n",
+ " dist_list = []\n",
+ " for mark in marker_dict[f]:\n",
+ " for specimen in list(SHRINKAGE_FACTOR_DICT.keys()):\n",
+ " print(f)\n",
+ " if specimen in f:\n",
+ " shrinkage = SHRINKAGE_FACTOR_DICT[specimen]\n",
+ " dist = point_to_line_dist(mark,line_coords,shrinkage=shrinkage)\n",
+ " if shrinkage_factor:\n",
+ " dist = dist*shrinkage_factor\n",
+ " dist_list.append(dist)\n",
+ "\n",
+ " marker_dist_dict[f] = dist_list\n",
+ " else:\n",
+ " marker_dist_dict[f] = []\n",
+ " return marker_dist_dict\n",
+ "\n",
+ "def calc_densities(xml_files_path,shrinkage_factor=None):\n",
+ " \n",
+ " marker_dict = parse_annotation(xml_files_path)\n",
+ " marker_dist_dict = {}\n",
+ " for f in list(marker_dict.keys()):\n",
+ " specimen_info_ix = f.find('AM')\n",
+ " csv_file_suffix = f[specimen_info_ix:-4]+'.csv'\n",
+ "\n",
+ " csv_file = [s for s in os.listdir(xml_files_path) if csv_file_suffix in s][0]\n",
+ " f_df = pd.read_csv(os.path.join(xml_files_path,csv_file))\n",
+ "\n",
+ " line_coords = [f_df['X'].tolist(), f_df['Y'].tolist()]\n",
+ " dist_list = []\n",
+ " for mark in marker_dict[f]:\n",
+ " for specimen in list(SHRINKAGE_FACTOR_DICT.keys()):\n",
+ " if specimen in f:\n",
+ " shrinkage = SHRINKAGE_FACTOR_DICT[specimen]\n",
+ " else:\n",
+ " shrinkage = 1.0\n",
+ " dist_list.append(point_to_line_dist(mark,line_coords,shrinkage))\n",
+ " \n",
+ " marker_dist_dict[f] = dist_list\n",
+ " \n",
+ " return marker_dist_dict\n",
+ "\n",
+ "FILES_TO_SKIP = ['AM299 CB dPMC40x__2Merge','AM299 CB dPMC40x_1Merge']#these have sideways tissue that hasn't been converted to work yet.\n",
+ "def process_counts(xml_files_path):\n",
+ " marker_dist_dict = calc_densities(xml_files_path)\n",
+ " specimen_df = pd.DataFrame(columns=['Specimen_ID','PV','CR','CB','MAP2'])\n",
+ " density_dict = calc_densities(xml_files_path)\n",
+ " \n",
+ " specimen_list = []\n",
+ " for k in list(marker_dist_dict.keys()): \n",
+ " specimen_info_ix = k.find('AM') \n",
+ " specimen = k[specimen_info_ix:specimen_info_ix+5]\n",
+ " specimen_list.append(specimen)\n",
+ " \n",
+ " specimen_set = set(specimen_list)\n",
+ " for i,s in enumerate(specimen_set):\n",
+ " specimen_df.at[i,'Specimen_ID'] = s\n",
+ " \n",
+ " specimen_df = specimen_df.set_index('Specimen_ID')\n",
+ " \n",
+ " for k in list(marker_dist_dict.keys()):\n",
+ " if k not in FILES_TO_SKIP:\n",
+ " specimen_data = []\n",
+ "\n",
+ " for s in specimen_set:\n",
+ " if s in k:\n",
+ " specimen_data.append(k)\n",
+ "\n",
+ " for s in specimen_data:\n",
+ " specimen_info_ix = k.find('AM') \n",
+ " specimen = k[specimen_info_ix:specimen_info_ix+5]\n",
+ " if 'C1.xml' in s:\n",
+ " if np.isnan(specimen_df.at[specimen,'PV']).any():\n",
+ " specimen_df.at[specimen,'PV'] = density_dict[s]\n",
+ " else:\n",
+ " specimen_df.at[specimen,'PV'] = specimen_df.at[specimen,'PV']+density_dict[s]\n",
+ " elif 'C2.xml' in s:\n",
+ " if np.isnan(specimen_df.at[specimen,'CR']).any():\n",
+ " specimen_df.at[specimen,'CR'] = density_dict[s]\n",
+ " else:\n",
+ " specimen_df.at[specimen,'CR'] = specimen_df.at[specimen,'CR']+density_dict[s]\n",
+ " elif 'CB' in s:\n",
+ " if np.isnan(specimen_df.at[specimen,'CB']).any():\n",
+ " specimen_df.at[specimen,'CB'] = density_dict[s]\n",
+ " else:\n",
+ " specimen_df.at[specimen,'CB'] = specimen_df.at[specimen,'CB']+density_dict[s]\n",
+ " elif 'MAP2' in s:\n",
+ " if np.isnan(specimen_df.at[specimen,'MAP2']).any():\n",
+ " specimen_df.at[specimen,'MAP2'] = density_dict[s]\n",
+ " else:\n",
+ " specimen_df.at[specimen,'MAP2'] = specimen_df.at[specimen,'MAP2']+density_dict[s] \n",
+ " return specimen_df\n",
+ "\n",
+ "norm_anatomical_dict = {}\n",
+ "IHC_STAINS = ['PV','CR','CB','MAP2']\n",
+ "SPECIMENS_TO_SKIP = ['test']\n",
+ "anat_data = process_counts(xml_files_path)\n",
+ "\n",
+ "for stain in IHC_STAINS:\n",
+ " norm_anatomical_dict[stain] = []\n",
+ " \n",
+ "for s in list(anat_data.index):\n",
+ " for stain in IHC_STAINS:\n",
+ " counts, bins, bars = plt.hist(anat_data.at[s,stain],bins=16,range=[0,2400]);\n",
+ " if not np.isnan(anat_data.at[s,stain]).any():\n",
+ " n_points = len(anat_data.at[s,stain])\n",
+ " norm_counts = [x/n_points for x in counts]\n",
+ " norm_anatomical_dict[stain].append(norm_counts)\n",
+ " else:\n",
+ " continue"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "yHmNMav9Gcak"
+ },
+ "source": [
+ "## Figure 8C,D,E: Laminar distribution of each inhibitory subtype"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "VmzKfnigt1r4"
+ },
+ "source": [
+ "### Here we plot the distributions for the three types with 16 bins to match Figure 8."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 175
+ },
+ "id": "Nc3jy_boEp2P",
+ "outputId": "2f50e1da-be05-4315-ad6c-8bebb7ba3d55"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_stain_density(norm_anatomical_dict,'CB',color=hex_to_rgb('68cce1'))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 175
+ },
+ "id": "xLAWBPK4EyGn",
+ "outputId": "481ace31-44da-4a5d-9fdb-943c47615bc5"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_stain_density(norm_anatomical_dict,'CR',color = hex_to_rgb('f2db17'))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 175
+ },
+ "id": "f9-RMUo0E0JZ",
+ "outputId": "0bf41079-07b4-45a1-d3e5-2d13c6898349"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_stain_density(norm_anatomical_dict,'PV',color = hex_to_rgb('c4539f'))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "nYHyb-yQ4QMi"
+ },
+ "source": [
+ "# Figure S2: Stability analysis of WaveMAP"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "-Qn4UMb5oQpd"
+ },
+ "source": [
+ "## Figure S2A: WaveMAP across random seeds and resolutions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "M-FiTFXw0lsg"
+ },
+ "source": [
+ "### Here we apply WaveMAP across three random seeds and four resolution parameter values. \n",
+ "\n",
+ "---\n",
+ "\n",
+ "This demonstrates that the WaveMAP method is stable across random seeds (up to a nonlinear perturbation) and hierarchical across resolution parameters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 534
+ },
+ "id": "X2Lqp5iGoY0a",
+ "outputId": "6eeeb690-150d-4402-94cb-10cb450f6772"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[94m1.0\n",
+ "\u001b[94m1.5\n",
+ "\u001b[94m5.0\n",
+ "\u001b[94m10.0\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "n_plots = 12\n",
+ "n_rows = 3\n",
+ "n_cols = 4\n",
+ "resolutions = [1.0, 1.5, 5.0, 10.0]\n",
+ "f,arr = plt.subplots(nrows=n_rows, ncols=n_cols,figsize=[12,8])\n",
+ "\n",
+ "for i,res in enumerate(resolutions):\n",
+ " print(BlueCol + str(res));\n",
+ " for j in range(n_rows):\n",
+ " resolution = res\n",
+ " my_umap = umap.UMAP(n_neighbors=N_NEIGHBORS\n",
+ " ,min_dist=MIN_DIST,random_state=random.randint(0,10000), metric='euclidean')\n",
+ " my_umap.fit(full_data)\n",
+ " embedding = my_umap.transform(full_data)\n",
+ "\n",
+ "\n",
+ " G = nx.from_scipy_sparse_matrix(my_umap.graph_)\n",
+ " clustering = cylouvain.best_partition(G, resolution = resolution)\n",
+ " clustering_solution = list(clustering.values())\n",
+ "\n",
+ " umap_df = pd.DataFrame(embedding, columns=('x', 'y'))\n",
+ "\n",
+ " umap_df['dbscan_color'] = clustering_solution\n",
+ " husl_colors = [sns.color_palette('husl',len(set(clustering_solution)))[i] for i in clustering_solution]\n",
+ "\n",
+ " arr[j,i].scatter(umap_df['x'].tolist(), umap_df['y'].tolist(), \n",
+ " marker='o',c=husl_colors, s=30, edgecolor='w',\n",
+ " linewidth=0.25)\n",
+ "\n",
+ " arr[j,i].spines['top'].set_visible(False)\n",
+ " arr[j,i].spines['left'].set_visible(False)\n",
+ " arr[j,i].spines['right'].set_visible(False)\n",
+ " arr[j,i].spines['bottom'].set_visible(False)\n",
+ "\n",
+ " arr[j,i].set_xticks([])\n",
+ " arr[j,i].set_yticks([])\n",
+ "\n",
+ "plt.subplots_adjust(wspace=0, hspace=0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "brChZFr744Nm"
+ },
+ "source": [
+ "## Figure S2B: Random seed and random subsetting to check for robustness"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "iTTpUoaG5Ll5"
+ },
+ "source": [
+ "### We generate 100 random subsets over different random seeds across various percentages of the full dataset and apply WaveMAP to each\n",
+ "---\n",
+ "**WARNING: THIS CAN TAKE 45 MINS IN COLAB**; the final results of one run are cached as a data file but if you choose to run this cell, those results will be used for graphing"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 709
+ },
+ "id": "HHBe9HF32iBR",
+ "outputId": "dbaf8f56-fc07-453c-e3ea-1172fed16db8"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Exception ignored in: .remove at 0x7f3968c505f0>\n",
+ "Traceback (most recent call last):\n",
+ " File \"/usr/lib/python3.7/weakref.py\", line 109, in remove\n",
+ " def remove(wr, selfref=ref(self), _atomic_removal=_remove_dead_weakref):\n",
+ "KeyboardInterrupt\n"
+ ]
+ },
+ {
+ "ename": "KeyboardInterrupt",
+ "evalue": "ignored",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m_ctypes/callbacks.c\u001b[0m in \u001b[0;36m'calling callback function'\u001b[0;34m()\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/llvmlite/binding/executionengine.py\u001b[0m in \u001b[0;36m_raw_object_cache_notify\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0mffi\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLLVMPY_SetObjectCache\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_object_cache\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 171\u001b[0;31m \u001b[0;32mdef\u001b[0m \u001b[0m_raw_object_cache_notify\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\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 172\u001b[0m \"\"\"\n\u001b[1;32m 173\u001b[0m \u001b[0mLow\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mlevel\u001b[0m \u001b[0mnotify\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+ ]
+ },
+ {
+ "ename": "KeyboardInterrupt",
+ "evalue": "ignored",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mKeyboardInterrupt\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 11\u001b[0m random_state=random.randint(1,100000))\n\u001b[1;32m 12\u001b[0m \u001b[0mrand_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpermutation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfull_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mfrac\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\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---> 13\u001b[0;31m \u001b[0mmapper\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mreducer_rand_test\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrand_data\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 14\u001b[0m \u001b[0membedding_rand_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mreducer_rand_test\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrand_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/umap/umap_.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 2553\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform_mode\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"embedding\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2554\u001b[0m self.embedding_, aux_data = self._fit_embed_data(\n\u001b[0;32m-> 2555\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_raw_data\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_epochs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrandom_state\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;31m# JH why raw data?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2556\u001b[0m )\n\u001b[1;32m 2557\u001b[0m \u001b[0;31m# Assign any points that are fully disconnected from our manifold(s) to have embedding\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/umap/umap_.py\u001b[0m in \u001b[0;36m_fit_embed_data\u001b[0;34m(self, X, n_epochs, init, random_state)\u001b[0m\n\u001b[1;32m 2600\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutput_metric\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"euclidean\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"l2\"\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[1;32m 2601\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom_state\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-> 2602\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mverbose\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 2603\u001b[0m )\n\u001b[1;32m 2604\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/umap/umap_.py\u001b[0m in \u001b[0;36msimplicial_set_embedding\u001b[0;34m(data, graph, n_components, initial_alpha, a, b, gamma, negative_sample_rate, n_epochs, init, random_state, metric, metric_kwds, densmap, densmap_kwds, output_dens, output_metric, output_metric_kwds, euclidean_output, parallel, verbose)\u001b[0m\n\u001b[1;32m 1147\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mverbose\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1148\u001b[0m \u001b[0mdensmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdensmap\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1149\u001b[0;31m \u001b[0mdensmap_kwds\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdensmap_kwds\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 1150\u001b[0m )\n\u001b[1;32m 1151\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/usr/local/lib/python3.7/dist-packages/umap/layouts.py\u001b[0m in \u001b[0;36moptimize_layout_euclidean\u001b[0;34m(head_embedding, tail_embedding, head, tail, n_epochs, n_vertices, epochs_per_sample, a, b, rng_state, gamma, initial_alpha, negative_sample_rate, parallel, verbose, densmap, densmap_kwds)\u001b[0m\n\u001b[1;32m 369\u001b[0m \u001b[0mdens_R\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 370\u001b[0m \u001b[0mdens_mu\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 371\u001b[0;31m \u001b[0mdens_mu_tot\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 372\u001b[0m )\n\u001b[1;32m 373\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/dispatcher.py\u001b[0m in \u001b[0;36m_compile_for_args\u001b[0;34m(self, *args, **kws)\u001b[0m\n\u001b[1;32m 365\u001b[0m \u001b[0margtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtypeof_pyval\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\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[1;32m 366\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--> 367\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margtypes\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 368\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0merrors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mForceLiteralArg\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 369\u001b[0m \u001b[0;31m# Received request for compiler re-entry with the list of arguments\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/compiler_lock.py\u001b[0m in \u001b[0;36m_acquire_compile_lock\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_acquire_compile_lock\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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[1;32m 31\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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 33\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m_acquire_compile_lock\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/dispatcher.py\u001b[0m in \u001b[0;36mcompile\u001b[0;34m(self, sig)\u001b[0m\n\u001b[1;32m 817\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_cache_misses\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msig\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 818\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--> 819\u001b[0;31m \u001b[0mcres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compiler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturn_type\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 820\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0merrors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mForceLiteralArg\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 821\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfolded\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkws\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/usr/local/lib/python3.7/dist-packages/numba/core/dispatcher.py\u001b[0m in \u001b[0;36mcompile\u001b[0;34m(self, args, return_type)\u001b[0m\n\u001b[1;32m 76\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 77\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mcompile\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturn_type\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---> 78\u001b[0;31m \u001b[0mstatus\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compile_cached\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturn_type\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 79\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mstatus\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 80\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mretval\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/dispatcher.py\u001b[0m in \u001b[0;36m_compile_cached\u001b[0;34m(self, args, return_type)\u001b[0m\n\u001b[1;32m 90\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 91\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---> 92\u001b[0;31m \u001b[0mretval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compile_core\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturn_type\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 93\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0merrors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTypingError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_failed_cache\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/dispatcher.py\u001b[0m in \u001b[0;36m_compile_core\u001b[0;34m(self, args, return_type)\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturn_type\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mreturn_type\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 109\u001b[0m \u001b[0mflags\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mflags\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlocals\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlocals\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 110\u001b[0;31m pipeline_class=self.pipeline_class)\n\u001b[0m\u001b[1;32m 111\u001b[0m \u001b[0;31m# Check typing error if object mode is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mcres\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtyping_error\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mflags\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menable_pyobject\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/compiler.py\u001b[0m in \u001b[0;36mcompile_extra\u001b[0;34m(typingctx, targetctx, func, args, return_type, flags, locals, library, pipeline_class)\u001b[0m\n\u001b[1;32m 625\u001b[0m pipeline = pipeline_class(typingctx, targetctx, library,\n\u001b[1;32m 626\u001b[0m args, return_type, flags, locals)\n\u001b[0;32m--> 627\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mpipeline\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompile_extra\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\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 628\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 629\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/compiler.py\u001b[0m in \u001b[0;36mcompile_extra\u001b[0;34m(self, func)\u001b[0m\n\u001b[1;32m 361\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlifted\u001b[0m \u001b[0;34m=\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[1;32m 362\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlifted_from\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 363\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compile_bytecode\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 364\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 365\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mcompile_ir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfunc_ir\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlifted\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlifted_from\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\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/usr/local/lib/python3.7/dist-packages/numba/core/compiler.py\u001b[0m in \u001b[0;36m_compile_bytecode\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 423\u001b[0m \"\"\"\n\u001b[1;32m 424\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunc_ir\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 425\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compile_core\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 426\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 427\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_compile_ir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\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/usr/local/lib/python3.7/dist-packages/numba/core/compiler.py\u001b[0m in \u001b[0;36m_compile_core\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 394\u001b[0m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 395\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--> 396\u001b[0;31m \u001b[0mpm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstate\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 397\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcr\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\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[1;32m 398\u001b[0m \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/compiler_machinery.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, state)\u001b[0m\n\u001b[1;32m 330\u001b[0m \u001b[0mpass_inst\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_pass_registry\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpass_inst\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 331\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpass_inst\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCompilerPass\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--> 332\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_runPass\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpass_inst\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstate\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 333\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 334\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mBaseException\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Legacy pass in use\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/compiler_lock.py\u001b[0m in \u001b[0;36m_acquire_compile_lock\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_acquire_compile_lock\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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[1;32m 31\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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 33\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0m_acquire_compile_lock\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/compiler_machinery.py\u001b[0m in \u001b[0;36m_runPass\u001b[0;34m(self, index, pss, internal_state)\u001b[0m\n\u001b[1;32m 289\u001b[0m \u001b[0mmutated\u001b[0m \u001b[0;34m|=\u001b[0m \u001b[0mcheck\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_initialization\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minternal_state\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 290\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mSimpleTimer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mpass_time\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 291\u001b[0;31m \u001b[0mmutated\u001b[0m \u001b[0;34m|=\u001b[0m \u001b[0mcheck\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_pass\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minternal_state\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 292\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mSimpleTimer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mfinalize_time\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 293\u001b[0m \u001b[0mmutated\u001b[0m \u001b[0;34m|=\u001b[0m \u001b[0mcheck\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_finalizer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minternal_state\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/compiler_machinery.py\u001b[0m in \u001b[0;36mcheck\u001b[0;34m(func, compiler_state)\u001b[0m\n\u001b[1;32m 262\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 263\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mcheck\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcompiler_state\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--> 264\u001b[0;31m \u001b[0mmangled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcompiler_state\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 265\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmangled\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 266\u001b[0m msg = (\"CompilerPass implementations should return True/False. \"\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/typed_passes.py\u001b[0m in \u001b[0;36mrun_pass\u001b[0;34m(self, state)\u001b[0m\n\u001b[1;32m 440\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 441\u001b[0m \u001b[0;31m# TODO: Pull this out into the pipeline\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 442\u001b[0;31m \u001b[0mNativeLowering\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_pass\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate\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 443\u001b[0m \u001b[0mlowered\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'cr'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 444\u001b[0m \u001b[0msignature\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtyping\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msignature\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreturn_type\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/typed_passes.py\u001b[0m in \u001b[0;36mrun_pass\u001b[0;34m(self, state)\u001b[0m\n\u001b[1;32m 368\u001b[0m lower = lowering.Lower(targetctx, library, fndesc, interp,\n\u001b[1;32m 369\u001b[0m metadata=metadata)\n\u001b[0;32m--> 370\u001b[0;31m \u001b[0mlower\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower\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 371\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mflags\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mno_cpython_wrapper\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 372\u001b[0m \u001b[0mlower\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcreate_cpython_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mflags\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrelease_gil\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/lowering.py\u001b[0m in \u001b[0;36mlower\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerator_info\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[1;32m 135\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenlower\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 136\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower_normal_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfndesc\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 137\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 138\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenlower\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mGeneratorLower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/lowering.py\u001b[0m in \u001b[0;36mlower_normal_function\u001b[0;34m(self, fndesc)\u001b[0m\n\u001b[1;32m 188\u001b[0m \u001b[0;31m# Init argument values\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 189\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextract_function_arguments\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--> 190\u001b[0;31m \u001b[0mentry_block_tail\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower_function_body\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 191\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 192\u001b[0m \u001b[0;31m# Close tail of entry block\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/lowering.py\u001b[0m in \u001b[0;36mlower_function_body\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 214\u001b[0m \u001b[0mbb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mblkmap\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0moffset\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 215\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mposition_at_end\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 216\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower_block\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mblock\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 217\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpost_lower\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[1;32m 218\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mentry_block_tail\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/lowering.py\u001b[0m in \u001b[0;36mlower_block\u001b[0;34m(self, block)\u001b[0m\n\u001b[1;32m 228\u001b[0m with new_error_context('lowering \"{inst}\" at {loc}', inst=inst,\n\u001b[1;32m 229\u001b[0m loc=self.loc, errcls_=defaulterrcls):\n\u001b[0;32m--> 230\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower_inst\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minst\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 231\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpost_block\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mblock\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 232\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/lowering.py\u001b[0m in \u001b[0;36mlower_inst\u001b[0;34m(self, inst)\u001b[0m\n\u001b[1;32m 325\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minst\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mir\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mAssign\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[1;32m 326\u001b[0m \u001b[0mty\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtypeof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minst\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtarget\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 327\u001b[0;31m \u001b[0mval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower_assign\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mty\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minst\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 328\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstorevar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minst\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtarget\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 329\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/lowering.py\u001b[0m in \u001b[0;36mlower_assign\u001b[0;34m(self, ty, inst)\u001b[0m\n\u001b[1;32m 500\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 501\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mir\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mExpr\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--> 502\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower_expr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mty\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\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 503\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 504\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mir\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mVar\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/usr/local/lib/python3.7/dist-packages/numba/core/lowering.py\u001b[0m in \u001b[0;36mlower_expr\u001b[0;34m(self, resty, expr)\u001b[0m\n\u001b[1;32m 1001\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mlower_expr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mresty\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexpr\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[1;32m 1002\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mexpr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mop\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'binop'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1003\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower_binop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresty\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexpr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfn\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 1004\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mexpr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mop\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'inplace_binop'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1005\u001b[0m \u001b[0mlty\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtypeof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexpr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlhs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/lowering.py\u001b[0m in \u001b[0;36mlower_binop\u001b[0;34m(self, resty, expr, op)\u001b[0m\n\u001b[1;32m 627\u001b[0m \u001b[0msig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_call_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtyping_context\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msignature\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m{\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[1;32m 628\u001b[0m \u001b[0mimpl\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mop\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 629\u001b[0;31m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimpl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mlhs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrhs\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 630\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mcast_result\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 631\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/base.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, builder, args, loc)\u001b[0m\n\u001b[1;32m 1162\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1163\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuilder\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\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-> 1164\u001b[0;31m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_imp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_context\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuilder\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mloc\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 1165\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_context\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_linking_libs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'libs'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\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[1;32m 1166\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/base.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 1192\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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[1;32m 1193\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'loc'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# drop unused loc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1194\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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 1195\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1196\u001b[0m \u001b[0;31m# Copy the following attributes from the wrapped.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/cpython/numbers.py\u001b[0m in \u001b[0;36mreal_div_impl\u001b[0;34m(context, builder, sig, args)\u001b[0m\n\u001b[1;32m 597\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 598\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mreal_div_impl\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcontext\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuilder\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\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--> 599\u001b[0;31m \u001b[0;32mwith\u001b[0m \u001b[0mcgutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mif_zero\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\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 600\u001b[0m \u001b[0mcontext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0merror_model\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfp_zero_division\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"division by zero\"\u001b[0m\u001b[0;34m,\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[1;32m 601\u001b[0m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfdiv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/lib/python3.7/contextlib.py\u001b[0m in \u001b[0;36m__enter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 110\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 111\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--> 112\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgen\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 113\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mStopIteration\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 114\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"generator didn't yield\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numba/core/cgutils.py\u001b[0m in \u001b[0;36mif_zero\u001b[0;34m(builder, value, likely)\u001b[0m\n\u001b[1;32m 832\u001b[0m \u001b[0mExecute\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mgiven\u001b[0m \u001b[0mblock\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mscalar\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mzero\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 833\u001b[0m \"\"\"\n\u001b[0;32m--> 834\u001b[0;31m \u001b[0;32mwith\u001b[0m \u001b[0mbuilder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mif_then\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mis_scalar_zero\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbuilder\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlikely\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlikely\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 835\u001b[0m \u001b[0;32myield\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 836\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/lib/python3.7/contextlib.py\u001b[0m in \u001b[0;36m__enter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 110\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 111\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--> 112\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgen\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 113\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mStopIteration\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 114\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mRuntimeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"generator didn't yield\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/llvmlite/ir/builder.py\u001b[0m in \u001b[0;36mif_then\u001b[0;34m(self, pred, likely)\u001b[0m\n\u001b[1;32m 296\u001b[0m \u001b[0mbbif\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend_basic_block\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_label_suffix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'.if'\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[1;32m 297\u001b[0m \u001b[0mbbend\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend_basic_block\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_label_suffix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'.endif'\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--> 298\u001b[0;31m \u001b[0mbr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcbranch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpred\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbbif\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbbend\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 299\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlikely\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\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[1;32m 300\u001b[0m \u001b[0mbr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_weights\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m99\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlikely\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m99\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/usr/local/lib/python3.7/dist-packages/llvmlite/ir/builder.py\u001b[0m in \u001b[0;36mcbranch\u001b[0;34m(self, cond, truebr, falsebr)\u001b[0m\n\u001b[1;32m 816\u001b[0m \"\"\"\n\u001b[1;32m 817\u001b[0m br = instructions.ConditionalBranch(self.block, \"br\",\n\u001b[0;32m--> 818\u001b[0;31m [cond, truebr, falsebr])\n\u001b[0m\u001b[1;32m 819\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_set_terminator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 820\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mbr\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/llvmlite/ir/instructions.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, parent, opname, operands)\u001b[0m\n\u001b[1;32m 160\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 161\u001b[0m \u001b[0;32mclass\u001b[0m \u001b[0mTerminator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mInstruction\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--> 162\u001b[0;31m \u001b[0;32mdef\u001b[0m \u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparent\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mopname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moperands\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 163\u001b[0m super(Terminator, self).__init__(parent, types.VoidType(), opname,\n\u001b[1;32m 164\u001b[0m operands)\n",
+ "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+ ]
+ }
+ ],
+ "source": [
+ "subsets = [0.1,0.2,0.3,0.4,\n",
+ " 0.5,0.6,0.7,0.8,\n",
+ " 0.9,1.0]\n",
+ "\n",
+ "clust_rand_dict = {}\n",
+ "for frac in subsets:\n",
+ " rand_list = []\n",
+ " for i in list(range(1,100)):\n",
+ " reducer_rand_test = umap.UMAP(n_neighbors = N_NEIGHBORS, \n",
+ " min_dist=MIN_DIST, \n",
+ " random_state=random.randint(1,100000))\n",
+ " rand_data = np.random.permutation(full_data)[0:(int(len(full_data)*frac)),:]\n",
+ " mapper = reducer_rand_test.fit(rand_data)\n",
+ " embedding_rand_test = reducer_rand_test.transform(rand_data)\n",
+ "\n",
+ " umap_df_rand_test = pd.DataFrame(embedding_rand_test, columns=('x', 'y'))\n",
+ " G = nx.from_scipy_sparse_matrix(mapper.graph_)\n",
+ " clustering = cylouvain.best_partition(G, resolution = RESOLUTION)\n",
+ " clustering_solution = list(clustering.values())\n",
+ " rand_list.append(len(set(clustering_solution)))\n",
+ "\n",
+ " clust_rand_dict.update({str(frac): rand_list})\n",
+ "\n",
+ "subset_avg_rand_list = []\n",
+ "subset_std_rand_list = []\n",
+ "\n",
+ "for k,v in clust_rand_dict.items():\n",
+ " subset_avg_rand_list.append(np.average(v))\n",
+ " subset_std_rand_list.append(np.std(v))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "qj--ua1oo_Kd"
+ },
+ "source": [
+ "### We then plot the mean and standard deviation of the number of clusters per percentage of the full dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 189
+ },
+ "id": "xPGkKtwLhhue",
+ "outputId": "b6c0256e-86a9-461c-cfd9-51752971c5bf"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "subsets = [0.1,0.2,0.3,0.4,\n",
+ " 0.5,0.6,0.7,0.8,\n",
+ " 0.9,1.0]\n",
+ "\n",
+ "if 'subset_avg_rand_list' not in list(locals().keys()):\n",
+ " subset_avg_rand_list = pkl.load(open('WaveMAP_Paper/data/subset_avg_rand_list.pkl','rb'))\n",
+ "\n",
+ "if 'subset_std_rand_list' not in list(locals().keys()):\n",
+ " subset_std_rand_list = pkl.load(open('WaveMAP_Paper/data/subset_std_rand_list.pkl','rb'))\n",
+ "\n",
+ "f, arr = plt.subplots(1,figsize=[3,2.5])\n",
+ "arr.errorbar(np.array(subsets,dtype=np.float),subset_avg_rand_list,yerr=subset_std_rand_list,c = 'k', marker='o', fillstyle='full', markerfacecolor='w', linewidth=1, markeredgewidth=1)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.set_xlabel('% of Full Dataset', fontsize=12,fontname=\"Arial\")\n",
+ "arr.set_xticks([0.1,0.2,0.4,0.6,0.8,1.0])\n",
+ "arr.set_xticklabels(['','20','40','60','80','100'],fontsize=12,fontname=\"Arial\")\n",
+ "arr.set_ylabel('# of Louvain \\nCommunities', fontsize=12,fontname=\"Arial\")\n",
+ "arr.set_yticks([0,2,4,6,8,10])\n",
+ "arr.set_yticklabels([0,2,4,6,8,10],fontsize=12,fontname=\"Arial\")\n",
+ "arr.spines['left'].set_bounds(0,10)\n",
+ "arr.spines['bottom'].set_bounds(0.1,1)\n",
+ "arr.axhline(np.max(subset_avg_rand_list),color='k',linestyle='dashed')\n",
+ "plt.tight_layout()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rCChwvdapAvW"
+ },
+ "source": [
+ "## Figure S2C: Ensemble clustering on graphs"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "_157Y1P8uH8n"
+ },
+ "source": [
+ "### We use ECG (ensemble clustering on graphs) as an alternate clustering method to validate that the cluster we find with Louvain are robust to the method. ECG is an ensembled version of Louvain."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 265
},
+ "id": "ZAHhI8N04OBw",
+ "outputId": "0750432b-4a4e-4582-b921-d2d0c5f2013b"
+ },
+ "outputs": [
{
- "cell_type": "code",
- "execution_count": 183,
- "metadata": {
- "colab": {
- "base_uri": "https://localhost:8080/",
- "height": 191
- },
- "id": "fxNTfdaNwZFz",
- "outputId": "1c2fb31d-dad0-4d58-e02d-97743c5a8ade",
- "vscode": {
- "languageId": "python"
- }
- },
- "outputs": [
- {
- "data": {
- "image/png": "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",
- "text/plain": [
- ""
- ]
- },
- "metadata": {
- "needs_background": "light",
- "tags": []
- },
- "output_type": "display_data"
- }
+ "data": {
+ "text/html": [
+ "[]"
],
- "source": [
- "f, arr = plt.subplots(1)\n",
- "\n",
- "f.set_size_inches(3,2.5)\n",
- "\n",
- "for i,clust_ix in enumerate([1,2,3,4]):\n",
- " start_ix = 0 \n",
- " \n",
- " median, med_se = bootstrap_median(get_dynamic_range(clust_ix,max_FR_df,baseline_FR_df,UMAP_clusts=False))\n",
- " \n",
- " arr.bar(start_ix+i, median, \n",
- " color=GMM_PAL[clust_ix-1],\n",
- " yerr=med_se)\n",
- "\n",
- "arr.set_ylabel('FR Range (spikes/s)')\n",
- "arr.set_xticks([1.5]);\n",
- "arr.set_xticklabels(['GMM Clusters'],fontsize=12,fontname='Arial')\n",
- "arr.spines['right'].set_visible(False)\n",
- "arr.spines['top'].set_visible(False)\n",
- "arr.set_ylim(0,25);"
- ]
+ "text/plain": [
+ "[]"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# add ECG to the choice of community algorithms\n",
+ "def community_ecg(self, weights=None, ens_size=16, min_weight=0.05):\n",
+ " W = [0]*self.ecount()\n",
+ " ## Ensemble of level-1 Louvain \n",
+ " for i in range(ens_size):\n",
+ " p = np.random.permutation(self.vcount()).tolist()\n",
+ " g = self.permute_vertices(p)\n",
+ " l = g.community_multilevel(weights=weights, return_levels=True)[0].membership\n",
+ " b = [l[p[x.tuple[0]]]==l[p[x.tuple[1]]] for x in self.es]\n",
+ " W = [W[i]+b[i] for i in range(len(W))]\n",
+ " W = [min_weight + (1-min_weight)*W[i]/ens_size for i in range(len(W))]\n",
+ " ## Force min_weight outside 2-core\n",
+ " core = self.shell_index()\n",
+ " ecore = [min(core[x.tuple[0]],core[x.tuple[1]]) for x in self.es]\n",
+ " w = [W[i] if ecore[i]>1 else min_weight for i in range(len(ecore))]\n",
+ " part = self.community_multilevel(weights=w)\n",
+ " part.W = w\n",
+ " part.CSI = 1-2*np.sum([min(1-i,i) for i in w])/len(w)\n",
+ " return part\n",
+ "\n",
+ "ig.Graph.community_ecg = community_ecg\n",
+ "\n",
+ "def readGraph(fn, directed=False):\n",
+ " g = ig.Graph.Read_Ncol(fn+'.edgelist',directed=directed)\n",
+ " c = np.loadtxt(fn+'.community',dtype='uint8')\n",
+ " node_base = min([int(x['name']) for x in g.vs]) ## graphs have 1-based or 0-based nodes \n",
+ " comm_base = min(c) ## same for communities\n",
+ " comm = [c[int(x['name'])-node_base]-comm_base for x in g.vs]\n",
+ " g.vs['community'] = comm\n",
+ " g.vs['shape'] = 'circle'\n",
+ " pal = ig.RainbowPalette(n=max(comm)+1)\n",
+ " g.vs['color'] = [pal.get(int(i)) for i in comm]\n",
+ " g.vs['size'] = 10\n",
+ " g.es['width'] = 1\n",
+ " return g\n",
+ "\n",
+ "\n",
+ "rand_data = full_data[0:(int(len(full_data))),:]\n",
+ "my_umap = umap.UMAP(n_neighbors=20\n",
+ " ,min_dist=0.1, metric='euclidean',random_state=random.randint(0,10000))\n",
+ "my_umap.fit(rand_data)\n",
+ "my_umap_embedding = my_umap.transform(rand_data)\n",
+ "\n",
+ "G = nx.from_scipy_sparse_matrix(my_umap.graph_)\n",
+ "umap_igraph = ig.Graph(len(G), list(zip(*list(zip(*nx.to_edgelist(G)))[:2])))\n",
+ "\n",
+ "umap_ECG = umap_igraph.community_ecg(ens_size=10,min_weight=0.5)\n",
+ "\n",
+ "umap_df = pd.DataFrame(my_umap_embedding, columns=('x', 'y'))\n",
+ "\n",
+ "umap_df['dbscan_color'] = umap_ECG.membership\n",
+ "ecg_colormap = [sns.color_palette(\"husl\", len(set(umap_ECG.membership)))[i] for i in umap_ECG.membership]\n",
+ "\n",
+ "f, arr = plt.subplots(1,figsize=[5,4])\n",
+ "\n",
+ "arr.scatter(umap_df['x'].tolist(), umap_df['y'].tolist(), \n",
+ " marker='o',c=ecg_colormap, s=30, edgecolor='w',\n",
+ " linewidth=0.25)\n",
+ "\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['left'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.spines['bottom'].set_visible(False)\n",
+ "\n",
+ "arr.set_xticks([])\n",
+ "arr.set_yticks([])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Gsxw-y5c77H8"
+ },
+ "source": [
+ "# Figure S3: Comparison of UMAP and GMM in the specified feature space."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "_ZbeKAN37_qU"
+ },
+ "source": [
+ "## Figure S3A: WaveMAP labels in the 3-D feature space"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cPlT0of0ue6K"
+ },
+ "source": [
+ "### To demonstrate that WaveMAP locates structure that traditional methods cannot parse, we show the WaveMAP cluster labels in the 3 feature space used by traditional methods."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 211
+ },
+ "id": "NGadrhJo77Qz",
+ "outputId": "de7d55f0-c515-4888-9ae9-5c14d937d1fe"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 52,
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fig = plt.figure(figsize=[3.8,3])\n",
+ "ax = fig.add_subplot(111, projection='3d')\n",
+ "ax.set_xlim([0,1.4])\n",
+ "ax.set_ylim([0,1.6])\n",
+ "ax.set_zlim([0.,0.6])\n",
+ "ax.view_init(elev=20, azim=220)\n",
+ "ax.set_xticks([0,0.7,1.4])\n",
+ "ax.set_xticklabels(['',0.7,1.4],fontsize=12)\n",
+ "ax.set_yticks([0,0.5,1,1.5])\n",
+ "ax.set_yticklabels([0,0.5,1.0,1.5],fontsize=12)\n",
+ "ax.set_zticks([0,0.3,0.6])\n",
+ "ax.set_zticklabels([0,0.3,0.6],fontsize=12)\n",
+ "ax.tick_params(pad=-1)\n",
+ "\n",
+ "for i in [int(x) for x in np.unique(UMAP_and_GMM['gmm_labels'])]:\n",
+ " to_plot_df = UMAP_and_GMM[UMAP_and_GMM['gmm_labels'] == i]\n",
+ " x = to_plot_df['troughToPeak_abs']\n",
+ " y = to_plot_df['prePostHyper']\n",
+ " z = to_plot_df['FWHM1_abs']\n",
+ " ax.scatter(x,y,z,c=GMM_PAL[i-1],marker='o',alpha=0.75,s=20,linewidth=0.75,edgecolor='w',depthshade=True)\n",
+ " \n",
+ " ax.plot(x, z, '.', c=[0.825,0.825,0.825], alpha=0.4, zdir='y', zs=1.5)\n",
+ " ax.plot(y, z, '.', c=[0.825,0.825,0.825], alpha=0.4, zdir='x', zs=1.4)\n",
+ " ax.plot(x, y, '.', c=[0.825,0.825,0.825], alpha=0.4, zdir='z', zs=0)\n",
+ "\n",
+ "ax.tick_params(pad=-1)\n",
+ "\n",
+ "ax.set_xlabel('Trough to peak ($\\mu$s)',fontsize=12,labelpad=5)\n",
+ "ax.set_ylabel('Peak ratio',fontsize=12,labelpad=5)\n",
+ "ax.set_zlabel('AP width ($\\mu$s)',fontsize=12,labelpad=0)\n",
+ "ax.view_init(elev=20, azim=220)\n",
+ "\n",
+ "ax.scatter(UMAP_and_GMM['troughToPeak_abs'],UMAP_and_GMM['prePostHyper'],UMAP_and_GMM['FWHM1_abs'],\n",
+ " c=UMAP_and_GMM['dbscan_hex'],marker='o',alpha=0.75,s=20,linewidth=0.25,edgecolor='w',depthshade=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "irB9MlJI9PoD"
+ },
+ "source": [
+ "## Figure S3B: GMM with eight clusters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "qPIGMvwjvJKB"
+ },
+ "source": [
+ "### To verify that the quality of our clustering with WaveMAP was not just due to using more clusters, we train an eight cluster GMM model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "OqH3qfnC9cFt"
+ },
+ "outputs": [],
+ "source": [
+ "eight_GMM_classes = eight_GMM_classes[0,:].tolist()\n",
+ "eight_GMM_classes = [x for x in eight_GMM_classes if not np.isnan(x)]\n",
+ "\n",
+ "classifies_pal = sns.color_palette(\"husl\", 8)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 350
+ },
+ "id": "VsngCAgj9OG0",
+ "outputId": "40e1d276-61f6-4064-857f-025b3d73c8d4"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n",
+ "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n",
+ "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n",
+ "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n",
+ "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n",
+ "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n",
+ "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n",
+ "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
}
- ],
- "metadata": {
+ ],
+ "source": [
+ "fig = plt.figure(figsize=[3.8,3])\n",
+ "ax = fig.add_subplot(111, projection='3d')\n",
+ "ax.set_xlim([0,1.4])\n",
+ "ax.set_ylim([0,1.6])\n",
+ "ax.set_zlim([0.,0.6])\n",
+ "ax.view_init(elev=20, azim=220)\n",
+ "ax.set_xticks([0,0.7,1.4])\n",
+ "ax.set_xticklabels(['',0.7,1.4],fontsize=12)\n",
+ "ax.set_yticks([0,0.5,1,1.5])\n",
+ "ax.set_yticklabels([0,0.5,1.0,1.5],fontsize=12)\n",
+ "ax.set_zticks([0,0.3,0.6])\n",
+ "ax.set_zticklabels([0,0.3,0.6],fontsize=12)\n",
+ "ax.tick_params(pad=-1)\n",
+ "\n",
+ "classifies_df = UMAP_and_GMM\n",
+ "classifies_df['eight_gmm_classes'] = eight_GMM_classes\n",
+ "\n",
+ "for i in range(1,9):\n",
+ " to_plot_df = classifies_df[classifies_df['eight_gmm_classes'] == i]\n",
+ " x = to_plot_df['troughToPeak_abs']\n",
+ " y = to_plot_df['prePostHyper']\n",
+ " z = to_plot_df['FWHM1_abs']\n",
+ " ax.scatter(x,y,z,c=classifies_pal[i-1],marker='o',alpha=0.75,s=20,linewidth=0.75,edgecolor='w',depthshade=True)\n",
+ " \n",
+ " ax.plot(x, z, '.', c=[0.825,0.825,0.825], alpha=0.4, zdir='y', zs=1.5)\n",
+ " ax.plot(y, z, '.', c=[0.825,0.825,0.825], alpha=0.4, zdir='x', zs=1.4)\n",
+ " ax.plot(x, y, '.', c=[0.825,0.825,0.825], alpha=0.4, zdir='z', zs=0)\n",
+ "\n",
+ "ax.tick_params(pad=-1)\n",
+ "\n",
+ "ax.set_xlabel('Trough to peak ($\\mu$s)',fontsize=12,labelpad=5)\n",
+ "ax.set_ylabel('Peak ratio',fontsize=12,labelpad=5)\n",
+ "ax.set_zlabel('AP width ($\\mu$s)',fontsize=12,labelpad=0)\n",
+ "ax.view_init(elev=20, azim=220)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "LhElsHhpBMFX"
+ },
+ "source": [
+ "### We train a random forest classifier on the eight GMM cluster data with the same hyperparameters as the four cluster dataset and show it performs poorly"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
"colab": {
- "collapsed_sections": [],
- "name": "WaveMAP_Figures_Data.ipynb",
- "provenance": []
- },
- "kernelspec": {
- "display_name": "Python 3",
- "name": "python3"
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "X5mI5yYbBMfA",
+ "outputId": "ef81ed2f-b9ef-4dc0-c9c8-c03959efe9ec"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Fitting 5 folds for each of 1 candidates, totalling 5 fits\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 2 concurrent workers.\n",
+ "[Parallel(n_jobs=-1)]: Done 1 tasks | elapsed: 0.9s\n",
+ "[Parallel(n_jobs=-1)]: Done 3 out of 5 | elapsed: 1.8s remaining: 1.2s\n",
+ "[Parallel(n_jobs=-1)]: Done 5 out of 5 | elapsed: 2.3s remaining: 0.0s\n",
+ "[Parallel(n_jobs=-1)]: Done 5 out of 5 | elapsed: 2.3s finished\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 3, 1, 1, 0, 0, 0, 1, 0],\n",
+ " [ 0, 12, 2, 1, 2, 0, 0, 2],\n",
+ " [ 0, 2, 31, 4, 2, 0, 0, 0],\n",
+ " [ 0, 1, 5, 11, 7, 0, 0, 0],\n",
+ " [ 0, 0, 0, 2, 49, 0, 0, 2],\n",
+ " [ 0, 0, 0, 0, 2, 4, 4, 2],\n",
+ " [ 0, 1, 0, 0, 0, 4, 20, 1],\n",
+ " [ 0, 0, 0, 1, 3, 2, 0, 3]])"
+ ]
+ },
+ "execution_count": 55,
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "eight_classifies_nonan = [x for x in eight_GMM_classes if ~np.isnan(x)]\n",
+ "\n",
+ "X_train, X_test, y_train, y_test = train_test_split(full_data[~np.isnan(full_data).any(axis=1)], \n",
+ " eight_classifies_nonan, test_size=.3, random_state=RAND_STATE)\n",
+ "\n",
+ "model = xgb.XGBClassifier()\n",
+ "param_dist = {\"max_depth\": [4],\n",
+ " \"min_child_weight\" : [2.5],\n",
+ " \"n_estimators\": [100],\n",
+ " \"learning_rate\": [0.3],\n",
+ " \"seed\": [RAND_STATE]}\n",
+ "UMAP_grid_search = GridSearchCV(model, param_grid=param_dist, \n",
+ " cv = 5, \n",
+ " verbose=10, n_jobs=-1)\n",
+ "UMAP_grid_search.fit(X_train, y_train)\n",
+ "\n",
+ "confusion_matrix(y_test,UMAP_grid_search.predict(X_test))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "YQyMXRZlvu5N"
+ },
+ "source": [
+ "## Figure S3C: Confusion matrix for a random forest classifier on the 8 cluster GMM"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "SbEcU68b_hki"
+ },
+ "source": [
+ "### and show the performance as a confusion matrix of the 5-fold CV test accuracy"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 225
+ },
+ "id": "-P5Sco-R_iEW",
+ "outputId": "fcefd3a7-bcdf-4a4e-ac96-e66da649ea8b"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "confusion_mat_counts_eight_GMM = confusion_matrix(y_test,UMAP_grid_search.predict(X_test))\n",
+ "\n",
+ "conf_mat_row_list = []\n",
+ "\n",
+ "for row in confusion_mat_counts_eight_GMM:\n",
+ " row_sum = np.sum(row)\n",
+ " \n",
+ " row_percent = []\n",
+ " \n",
+ " for val in row:\n",
+ " row_percent.append(val/row_sum)\n",
+ " \n",
+ " conf_mat_row_list.append(row_percent)\n",
+ "\n",
+ "conf_mat = np.array(conf_mat_row_list)\n",
+ "\n",
+ "colormap = mpl.cm.YlGnBu\n",
+ "colormap.set_under('white')\n",
+ "\n",
+ "eps = np.spacing(0.0)\n",
+ "f, arr = plt.subplots(1,figsize=[4,3])\n",
+ "mappable = arr.imshow(conf_mat,cmap=colormap,vmin=eps,vmax=1.)\n",
+ "color_bar = f.colorbar(mappable, ax=arr, extend='min')\n",
+ "color_bar.set_label('P (Predicted | True)',fontsize=12,labelpad=15,fontname=\"Arial\")\n",
+ "color_bar.ax.tick_params(size=3,labelsize=12)\n",
+ "\n",
+ "n_classes = len(set(eight_classifies_nonan))\n",
+ "\n",
+ "#Specify label behavior of the main diagonal\n",
+ "for i in range(0,n_classes):\n",
+ " if int(conf_mat[i,i]*100) == 100:\n",
+ " arr.text(i-0.38,i+0.17,int(round(conf_mat[i,i]*100)),fontsize=10,c='white',fontname=\"Arial\")\n",
+ " else:\n",
+ " arr.text(i-0.34,i+0.16,int(round(conf_mat[i,i]*100)),fontsize=10,c='white',fontname=\"Arial\")\n",
+ " \n",
+ "#Specify label behavior of the off-diagonals\n",
+ "for i in range(0,n_classes):\n",
+ " for j in range(0,n_classes):\n",
+ " if conf_mat[i,j] < 0.1 and conf_mat[i,j] != 0:\n",
+ " arr.text(j-0.2,i+0.15,int(round(conf_mat[i,j]*100)),fontsize=10,c='k',fontname=\"Arial\")\n",
+ " elif conf_mat[i,j] >= 0.1 and conf_mat[i,j] < 0.4 and conf_mat[i,j] != 0:\n",
+ " arr.text(j-0.4, i+0.15,int(round(conf_mat[i,j]*100)),fontsize=10,c='k',fontname=\"Arial\")\n",
+ "\n",
+ "\n",
+ "arr.set_xticks(range(0,n_classes))\n",
+ "arr.set_xticklabels(range(1,n_classes+1),fontsize=12);\n",
+ "arr.set_yticks(range(0,n_classes))\n",
+ "arr.set_yticklabels(range(1,n_classes+1),fontsize=12);\n",
+ "arr.set_xlabel('Predicted Class',fontsize=12);\n",
+ "arr.set_ylabel('True Class',fontsize=12);\n",
+ "\n",
+ "plt.tight_layout()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "C2vBzAGUvoHI"
+ },
+ "source": [
+ "## Figure S3D: Eight GMM cluster waveforms"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "AATotmmr2HYj"
+ },
+ "source": [
+ "### Here we plot each of the eight GMM clusters and show that although they seem sensible to the eye, they represent a representation that is difficult to learn (as shown in the previous panel)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 961
+ },
+ "id": "LCGchIEv2Hyx",
+ "outputId": "f95d49f2-b203-4a94-a8c7-6390c523a30b"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIgAAAB2CAYAAAATIts7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAZFklEQVR4nO2deXwc1ZXvv6eqW91qqVuLJVneF7wbxzZmDTAhLCEQGAJheCEwSSYP3kuGNwTyCGSDISHzkhcgYSYvMMMAA8kAHhICBN6wDZhgw3xIDNgGm9hgyQuyrH3rVm9VdeaP25JlIzXaJez6fj71cbv69r2nq3597rn3nroSVcXHZyCsiTbAZ3LjC8QnL75AfPLiC8QnL75AfPISGGJ5f8hz+CL9nfQ9iE9efIH45MUXiE9efIH45MUXiE9efIH45MUXiE9efIH45MUXiE9efIH45MUXiE9efIH45MUXiE9efIH45MUXiE9ehpoP4jMOqKfguuB5qCo45jWuB5YgkkvdEAHLAtsy/wZsxBrd37wvkAlEsw6k0mgyjWayaCIJ3Uk0nUFcz6RnCRC0IVQABQVGBL0VKHhqhCICloBtQzBwQEQBGwkGoDiCFASHbKMM8bkYP6NsmKgqpDNGBKkM6rloKg3xpPEQgQBSXIhEiyASRkIFxjOIZbxJOmPKZ5wDlQZtJBxCC0NGUJksmsmaMj33NWCDLWgiiTVzGmIP6GH6zSjzBTIGqCrqupBIot0ptDsFyRS4nrnJqbTpLiJhKI8hoRAiYu6QiHEcfbuKnlunHPASPTfacdFUBoI2VqwYIoWIJb12kMlCMo3X0g62hT13xkBm+wIZbXq8Ask0Xk4EmkqD4xgxuC4qFrgOknVN+YIgUhJFQkETN4SCWLbdp1JQ9RA3d6kFCBUg4RCEQ+b/rme8juMYgWSzaDprBJlMmzhlSilWUSHEihHbQl0Pb/supDSKNb2yv6/jC2SkqCqk0nidCUh048WTSHcSdT3UtsyNcLxcWQ9xXASQSCFEI0hxEVIURhDU80zXkXUP6g4kXADhkOliOFiEmkqbYFXkgGgKQx8ITDXr4DW0QNYBAasshpREUVXcN97BWrEQ64PxyOQSiGYdEzxNUtRxoDuF19yOdsbRzi60M4FmXbAFK2RuDsURNBiArm4TXDpZcDwTEBZHjDgKAkhBARIJm24lEu71Gup6B0YsWcfEGpksuK658cEAUhQxcUku8FRPIdNXNHrA0xSGjcAsQdMZtLUD7UpAUQR7RhVeYwt0p7A+2NVMDoGo46LNbZBMI9VTzBeaJGjWQTu68Fo7oLUDz3HADmChqG2bmxQMoJYFmSxuUyv7a2rZV7+f/V0dNCYTtKS7ae1O0NHZSUe8i3Qmg+M4eJ6HKIgqtgi2bRMMBgkVhglHiiiOxYiVxigtK2NKRQUVpWVUlU+hqqyMqZEoAdeDYACrJAqlUSQSRvp0Ter1eJqUiUk0J5pwCAI23o7dWKuXgoC36U8Ejll26NefeIFoKo3X0IJVXQG2jTa1Yk3rtz8cV7QrgdvSDo2tqOdhlUbRcAhaO9DuNBIuoDXRxZtb3+aNbVvZ/Pbb/GlXDe/ur6M4XMj0yiqmVVZRWVZGRWkZ5dEYZaVlRKNRwsECgpaFFbChIIhXEMTFw0tnySRTpBMJkvE48a44Xd0JOroTtCTitMQ7aWxtpaGlmebWVioqKpg1Yyazp01jVkUVs6umMnf6DObMnctRy5cSrao0nqOPV+4rGvf9BkilsWZV47V2YM2dYWKUA0ysQNyWdrw33oGyEqypZYCJ1u3pVfmGXmOKpjO4+xrRhlbUc7Eqy818xNadxLsTvLhrO8++/gdeeWszexv3s3L2PFbNmsfKeQtYtmQJixcvIlZSaoaioiAWErCMy09n0IxjAklPwTJxh3hqug7bglABGjZdjxQUmIubyUBnwgyHsw54Ho561He2s7e9jbqONva0NLKnuZHd++vZtWcPtbt3UxItZv7M2SyYM5f58+ezcOFCFi9ZzOIVR1M8pRxU8bbVINMq8Nq7EMfBXjyv7+WYGIF4noe76U+QTGOtWIAVCuG9txsVQSwLa2oFUhYbarUjQlVx9zage+rQZBqrugINBHBq3+f5V9bzy5df4LnXX2PN/IV8esVq/mzeIlbMnEsgUgiFYYiEsAIB475tC8ndSBAz7xCwTXwSCiGFIfNdPTNPQcYBzzWxjJM13UHGMVfWFjMZVlyIFS0yMUyoAFTRrgTa3pWLOzKQzRjBIXii1Hd1UNO0n5r6emrq63i3bi87du/ivT27qZoyhZOOOZYrLriIP/v4yVglUXTXPuyTVh6YUBtvgajj4DW24u3cY4K2whAKaCaLVRoFBM06WOUx7Hkzh2LDiPC6Enjv1JhhaWEIQkHi7zfwwIO/4u+fe5KKWIwvnv0Z/uKTZzHFDuJZNhIJYcWiSPUUCAaR7hSaTBnvYFloQRBsQTwODD+zuaGu5xkPoh7q5uICsXKzn7lZUADPBcdDHRfpCVSzDrgu6ikSyM2QhkNQXIhGIljBAKginoeniroe4rpGcG7WNJvJUlNfz7Ob/8jdTz2GLRbf/suvcPEppxFYtZTA1Ck9l2b8BOI2teHt3IN2xsGykEghaokZ4nWn0XTGRO0FAaQ7gyycTWDO9KHYMWTUcXF37sHbuQcv44GlZF2Pf/zNw9z25KOcuOxovvmtGzhx0TK0oQXPU+ziQmRaBRIrhnS2VxBSVAhFhQcFiYOyoWeNJTd/geOauZJ0BhzHdEmulxPYAaF5WQfNZs1MadqBVApSmV4BgebWYiwIBCEYMJNp4aDxeAEbsi7anebFDb/n+489TCqV5O+u+jrnf/e6HvPGViDqunjvN+Dt2geZLFJVhhcrRlo6kPIY1sxqaGpDigrJxhN4m7ZDeyfWyiVY8QSBk1YNxY7BGet5kEji7tqHt6ceTz0z7BR46vcvcf3d/8DCaTP48c23sHz5Mqh5H09s7ICFlsewSqMHhqeFYfMrnkD6DonJvVbHRTMZvK5utCMO8W6028zg0p2E7jRks7kuUE13lXH4/5tfpz0W5oq7ftpT/egLRD1F4914tXvRlg7jsosi2KVRtCOOW9eANb2SVkt5a8OrbKupwYkn+G+nn0Xl/Lm4b2yDpfOxHZfACR8z7nMUUNdFW9rxEim0oQkQiBahrR201O/n2rt/zsZ3tvLzv7mOMy6/BNlWg5vKYIUKsKZVYM2ZgUSLeqesDwd6RzSptOnqAcIF2AemGUYuEKfmfSWdMb/K5ja0oRlcheJCJBQyLq4gSGdDExvf3c4rtTt47o//yfY9uzh63gKWzplLGnhq/Ut8+vQzuP2qayl/932so2YTOGYZVmXZCC8DuUmtBGoJuq8BYlEzmdTcxro/vMZf3f53XHTyJ7jl6v9NxLLxmlqQ0ij29GrshbOHteJ5mDBygaTuXKsAyVSava2N7I53UhdvZ39nO/taW9nV3EBtQz31ba2snL+AE5cs56yVazjluBMIRcJoaQyrIEBbYZBrrr2WKWXl/OSMz0I8QeDcUwnMHlkcou1deOm0ifQ742isGJpa0Y4EP137S+54dC33Xn8TZ574cUhnkKCNVRrDWjofK1L44Q0c3oxcIBXRmHalkgC9kzUzp1RSXVrO9LJy5k2bztzpM1iwcCEF4TBSGILyErNaiRo3Z1loUytNba2suPh8Xrn/Yea8vZvARWdhL5g15MCvB23rxMtkoL0LDQZRx4W6BlLZDFf84Hu8t7+etbfewZxp0404si7WotlYs6b1HeodyYxcIHvXPqklZSWEIkVY4bAZhRQEkYKAGf4V5CLoUIE5b4kZ0uWyoNRTtKEZiRXj7mvkhz+7nR1tTdy34jQ44yRCi+chpdEhfzNNZ8xydncKTwTaO9GWdtqcLJdc/3XKSkv51R2/ICSg7XEsy8JevTQ33PbJ0a9AhrRaVj11qqnHcSGZRFKAHYSAAIKqZ2ISz8NzD0TNeGaZm0ghVvUUaOtEZlRxzWcuZOkVX2DTnKNZtXMPOrN6WALxGlvMvIF6UN+KZrM0qsM5f/0VTl29hp9+92+xImHYvQ8rFiVwzDLj3Xw+lCEJxD7u6NwNz03+5IZYAmYdIFrUb5Cnqiawbe1Ea+tg4RykpZ3iubP41hVf5f+ue56HK2cYgQ0Rbe8ycxTpjJltzKRptuDsr36Fz55yGjd//VoTqO7YBRWlRhxHbiA6ZIa0CGIVR7CiRVglUayyGFZlGfaMqVgzpprJsLZOMxfS0m5igBwighRHCMyuxpo/E91bDyJIVTkXrziWdVvexImb5XLNZAdtj7oeXkubSZhp60Dj3bSELM7+H1/iz9ecyE3XfANKitEdtVDpi2M4jFpChhSGet22JlNoc5tZK6goO+imWNMq8Zra8JJpJJulasF85sycyca6XZzU1ok9tcJ0R4PAa203s4wNzSBCpjzGhV+5nDOXfIy//c53sINBvNp9UF5ihtFBXxxDZUyWUaUwjFVdgVSVmwmrxlYzgulpdPE8M9pIO8jsqZyxYjXr9u5E9+7HS6YG31BjK9raZbK4CsNc+YMbmVUY5f/cdCO2B15bFxIJEzhmuS+OYTKm6+wSCGBNq0SKI2hdg1lzAKxQEKksQ5NpJJnh9FVrWLfnPdjXBF3dg6pb4924nV2wvwmrqpwf/fohdm7bxj/f9EMCWHhZB8lksdcsxwoXjOXXPKwZl0QMiYSR6ZVoLn0PwJpSijgO6rqcsuY43tz1HonmFpPxPQi8/S14u+phwSx+v3ULd//LvTxyw/cprq5C1cOKd2OtWWZGLz7DZtwydcS2sWZUmYeEuhJQVAilUUgkKaooZ/XiZbxSsx0n/uEeRB0HZ+8+xBK6y6Nc8Y1r+MWX/5oZJxyDJpNIMoMsmYc9znkmhyPjnsplTZ2CxrtN4mwkDJksXlmU0z+2mhdrd6BNLQeNgPrDbWxFa/ZhHf8xrrvuOk5ftIxzLv4ctMdRFaSynMCs6nH6RsPjgQceYM2aNcRiMWbOnMn111+P4xx4KKq1tZULL7yQoqIi5syZw0MPPTQhdk5Irp9UV6AdXSavtryEQNbl9KNXsW7XdqhrNs925MHZvAOiEZ57+02ef+EFfnzlVVhBG0WxQoFDU+kmJd3d3dxxxx00Nzfz2muv8cILL3Dbbbf1vn/VVVdRUFBAQ0MDDz74IF/72tfYunXr+BuqqkM5Rg3PcdTZsUud5jbNvr5Vu//9JS0pKtLdN/1M3bqGAT/ndHZp8q61mqrbr0vnztdHr/6Opt54R9PPv6qZ17eq2xkfsW1z5szRW2+9VVesWKGxWEwvueQSTSaTI643H7fffrued955qqoaj8c1GAzq9u3be9+//PLL9YYbbhhLE/q95xO2/YPYNlJRBk1tJp1/ZjWnLF/JS++8heYZyTgbt0GsmId+9wSlgQLOPefTSFMrMnMq1pRSk8s5CjzyyCM888wz1NbWsmXLFu6///5+y23YsIHS0tIBjw0bNgyqvZdffpnly5cDsGPHDgKBAIsWLep9f+XKlRPiQSb0ySWrLIZT+z5UV2DFk5y2fCUvbdnCJU2t2IvnfqC819aJ1u3HWTKPm8+7gvu+dBUSiSBTYkgqbeZXRomrr76a6dNN+sH555/Ppk2b+i13yimn0N7ePqK27rvvPjZu3Mg999wDQDweJxY7OMAuKSmhq6trRO0MhwnfQEamVSKZLBLv5ow1x7Oudjvs2f+BcppK49Y1II7LPz/2G5ZNn8XJa47FCgaRVAZr6VGjumxfXX0gyI1EIsTj8VGruy+PP/443/72t3n66aepqKgAoLi4mM7OzoPKdXZ2Eo2O/+rzhAvEKovlHjiGZSeeQDKbpXbbVrzsgZGMpjNocxteWxeJUICf/OMvuPmzn0dKipGiENbMaqzQxEyGrV+/nuLi4gGP9evXD/jZZ555hiuvvJInn3ySFStW9J5ftGgRjuPw7rvv9p7bvHlzbxc0nkz4w7HS86CygO14nLZiFes2v8mirjiUlxhxNLZCaQyte4NfbljHsUctYuW8RVhTSsxs7YHU/XHn1FNPHZZ3efHFF7nssst47LHHOP744w96r6ioiIsuuoibbrqJe+65h02bNvHEE0/w6quvjpbZg2bCPQiYmVYNh9BUik+eeDLrarbjvrMTr64Rbe1AplfiNTSRbe/kZ79dy3VnXwCxQsQDa9HciTZ/WNxyyy10dHRw7rnn9nqbc845p/f9O++8k2QySVVVFZdeeil33XXXhHiQSbH9gyaS5qHp2n3UtDVxyucvYtdDTxL589MA8DJZMs+/wkNPPcUDLz/Pszf/BIkVETxhpZ8VNnpM4r9ZFwmbRKSyGPOmTiMaLmTrG6/j1jcBGG/S2Mbtz/yWb557IZJxsBbM9sUxDkwKgYiYbZWsGZWQSHL68pWs2/QGzmtv4TY04767h9+9tZECLM44/iQkGiEwd/we1zySmRQCAUy6oqdIJMwFZ57FneufZ39NLdktO9hXV8e1D/wTt176V0gmi/XxVRO2I8CRxuS5ypEw2p1E5s/krFXHcdmZn+Yv/uFHxGt38+U7b+fKT53HKauPQ0qjBCpG/oCVz+CYNAIRkd6n1yUc4sZrvsH8mbM45lt/gxW0ueGiz0NBAPvYoyfa1COKSTGK6a3cU3RfA16iG6+5nVRnnO/9vzu45oKLmbFqBVZnguCZJ46lCUcyE78F1aAacF3cvfVoQxteQGDn+2h1BXYwiFVdgT1vwH0+fUbGJB7m9kFsG3taFVJVhtWRQJYuwFJFqsqxxngPEZ8PMuk8SF/ctg6819/BWjIXe+bkzhA7DPhodDEfaNDTw2qfjknMR6OLORRfHBPLpBeIz8TiC8QnL75AfPLiC8QnL0MaxYjI28AQnq4eUyqA5ok2gsljB4zMlrCqfmAdY6gphylVPXaYBowqIrJxMtgyWeyAkdkiIhv7O+93MT558QXik5ehCuTuMbFieEwWWyaLHTAyW/r97FCn2n2OMPwuxicvvkB88uILxCcvgxKIiJSLyGMikhCR3SLyhbE2bLBtisjNIpIVkXifY/4o2vG/RGSjiKRF5P4PKXutiOwXkU4RuU9ERnU758HaIiJfFhH3kGty2nDaHKwH+QWQAaYClwF3ichYPwc4lDb/TVWL+xw1o2jHPuCHwH35ConI2cC3gDOAOcB84PujaMegbcnxn4dck5eG0+CHCkREioDPATeqalxVNwC/A/5yOA0OholocyBU9beq+jjQ8iFFvwTcq6pbVbUNuAX48gTZMmoMxoMsAhxV3dHn3GZgLD3IUNs8X0RaRWSriHxtDO3Kx3KMjT1sBqaKyERtPbBaRJpFZIeI3Cgiw9rJYTAfKgY6DznXAYzlg7FDafMRzCRPA3AC8KiItKvqw2NoX38UY2zsoed1lHH8xed4GTga2I0R7r8BDvCjoVY0GA8SBw7dcDQGjOV+SINuU1W3qeo+VXVV9VXg74GLx9C2gTjU5p7X475vlKrWqGqtqnqq+hbwA4Z5TQYjkB1AQEQW9jm3EhjLHdVG0qYyQALuGLMVY2MPK4EGVR1v79Efw74mHyoQVU0AvwV+ICJFInIycAHwq+E0OBiG0qaIXCAiZWI4HrgaeGK0bBGRgIiEARuwRSQ8QH/+S+C/i8gyESkFvgfcP1p2DMUWETlHRKbmXi8BbmS412Sg/TH7HkA58DiQAPYAXxjM50ZyDNQmcCoQ71PuYUwfHwf+BFw9ynbcDL1/SbTnuBmYnWtzdp+y38DEQp3AvwChibAFuC1nRwKowXQxweG06S/W+eTFn2r3yYsvEJ+8+ALxyYsvEJ+8+ALxyYsvEJ+8fOQFklugO22c2lqWy8cY1ZlaEXlURM758JLjz6SfBxGRvhuhR4A00LPT//9U1QfH0ZZHgV+r6tpRrvd44C5VXTOa9Y4Gk14gfRGRXcAVqvofE9D2NMx6y3RVHfXHT0XkXeBSVe33CbeJ4nDoYnaJyJm51zeLyK9F5F9FpEtE3hKRRSLybRFpFJG9IvKpPp8tEZF7RaReROpE5IciYg/Q1FnAG33FkWv7myKyJZcaea+ITBWRp3Pt/4eIlOXKhnN2tYhIu4j8sWe9JMdLwGdG/QKNkI+8QPrhfMyiXhnwJvAs5nvOwKxJ/FOfsvdj8iQWAKuBTwFXDFDvCmB7P+c/hxHPolzbTwPfASpz7V6dK/cloASYBUwBvgok+9TzDgevBk8KDkeBrFfVZ1XVAX6NuVE/VtUssBaYKyKluV/vucA1qppQ1UbgZ8DnB6i3lP5zO36uqg2qWgesB15T1TdznuYxjPAAshhhLMjlrryuqn2TorpybUwqJvwPCo0BDX1eJ4FmVXX7/B9M9td0IAjU9xmUWMDeAepto/+MtkPbO/T/xbnXv8J4j7W5dIB/Bb6bEy65ukf2x+/GgMPRgwyWvZgRUYWqluaOmKoOlPe6BdONDAtVzarq91V1GfBx4Dzgi32KLOXgnNZJwRErEFWtB54DbheRmIhYInKUiHxigI88DxyTS9gZMiLySRFZkQuCOzFdjtenyCcw8cuk4ogVSI4vAgXANkwX8htgWn8FVbUBeBGT2TYcqnP1d2IC0t+Ty5ATkeMwSVB/GGbdY8ZHah5kohGRZcADwPE6ihcuNwF3r6r++2jVOVr4AvHJy5Hexfh8CL5AfPLiC8QnL75AfPLiC8QnL75AfPLiC8QnL/8FUabDWUHnOXYAAAAASUVORK5CYII=\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "for i in range(1,9):\n",
+ " f, arr = plt.subplots()\n",
+ " f.set_size_inches(2, 1.75)\n",
+ " GMM_cluster = classifies_df[classifies_df['eight_gmm_classes']==i]\n",
+ " \n",
+ " for _,row in GMM_cluster.iterrows():\n",
+ " plt.plot(row['waveform'],alpha=.3,linewidth=.6,c=classifies_pal[int(i-1)])\n",
+ " \n",
+ " plt.plot(np.nanmean(GMM_cluster['waveform'].tolist(),axis=0),c='k',linewidth=1.)\n",
+ "\n",
+ " arr.spines['right'].set_visible(False)\n",
+ " arr.spines['top'].set_visible(False)\n",
+ " arr.set_ylim([-1.4,1.1])\n",
+ " arr.set_xticks([0,14,28,42,48])\n",
+ " arr.set_xticklabels(['0','0.5','1.0','1.5',''])\n",
+ " arr.set_xlabel('Time (ms)',fontsize=12)\n",
+ " arr.set_xlim([0,48])\n",
+ " arr.set_yticks([])\n",
+ " arr.tick_params(axis='both', which='major', labelsize=12)\n",
+ " \n",
+ " arr.spines['left'].set_visible(False)\n",
+ " \n",
+ " x, y = 23,-0.8\n",
+ "\n",
+ " n_waveforms = plt.text(x, y, 'n = '+str(len(GMM_cluster))\n",
+ " , fontsize=12)\n",
+ " plt.tight_layout()\n",
+ " plt.margins(0,0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "wIHRl6qSLCIo"
+ },
+ "source": [
+ "# Figure S4: WaveMAP implicitly captures specified features"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "YQr7cn4fv-4o"
+ },
+ "source": [
+ "## Figure S4B,C,D: Here we show in WaveMAP space each waveform's feature values across the three specified features used."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "SGnerw78LDM6"
+ },
+ "outputs": [],
+ "source": [
+ "gmm_feat_df = pd.DataFrame(gmm_feat_data_nonan,\n",
+ " columns=['trough_to_peak','peak_ratio','trough_fwhm'])\n",
+ "\n",
+ "GMM_class_df = pd.DataFrame(GMM_class_labels,columns=['Class'])\n",
+ "full_data_df = pd.DataFrame({'Waveform': full_data.tolist()})\n",
+ "data_classified_df = pd.concat([umap_df,full_data_df,GMM_class_df,gmm_feat_df],axis=1)\n",
+ "data_classified_df.loc[data_classified_df['Class']==1,'color'] = GMM_PAL[0]\n",
+ "data_classified_df.loc[data_classified_df['Class']==2,'color'] = GMM_PAL[1]\n",
+ "data_classified_df.loc[data_classified_df['Class']==3,'color'] = GMM_PAL[2]\n",
+ "data_classified_df.loc[data_classified_df['Class']==4,'color'] = GMM_PAL[3]\n",
+ "\n",
+ "data_classified_df['trough_to_peak_abs'] = data_classified_df['trough_to_peak'].divide(SAMP_RATE_TO_TIME)\n",
+ "data_classified_df['trough_fwhm_abs'] = data_classified_df['trough_fwhm'].divide(SAMP_RATE_TO_TIME)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "_rivsSqeLDUY"
+ },
+ "source": [
+ "### We plot the specified feature values of each waveform in UMAP space"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 917
+ },
+ "id": "6GO3iwuJLCPA",
+ "outputId": "e39bb6a2-a746-43ec-da76-225b8e7c5ef8"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS4AAAEsCAYAAAB9iF5IAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd5hcxZmv36oTOk2eUc4CCSGEAAlhBJhssE10xDmCjdPe3fX1Xa9ZX9t317te53X2OrFOYBwINmByjhJJEggJ5SyNNLnTCVX3j9M90z3dLUZIk3C9z9Og6ZPq9Mz59VdffUForTEYDIbxhBztARgMBsOhYoTLYDCMO4xwGQyGcYcRLoPBMO4wwmUwGMYdRrgMBsO4wz4C5zDxFAaDYTgQtTYYi8tgMIw7jHAZDIZxhxEug8Ew7jDCZTAYxh1GuAwGw7jjSKwqGgyGGvgHOtn1o1+RfnoNSEn9qScw5ap3Yzc0jPbQxjXiCFSHMOEQBkMVgu4e1n/o0+B7CAuEADQooO11J9H24auRsfhoD3MsY8IhDIaRZt9vb4bAQ1rRz1pBqAAFHXc/Q8e1PxnV8Y1njHAZDMNEz2MrETKakgR+ZDxYFkgLlIKuR1ai0unRHeQ4xQiXwTBMyHgMgDAEx9UIGU0XhQApIeiD7KYtozvIcYoRLoNhmJj8wSsic0tH1pYo8dhEAqbZ9tUfEqYzozPAcYwRLoNhmGhYvhTZ1IiQtdevbL+bzZ//Kvlt2+m59wHSz65CKzWCoxyfmFVFg2EYCXp6ePE9n8K2yy2uCI0V04BA4yJtQEisVIppX7oGZ0LbyA94bGFWFQ2G0cCqryc5tZHIPij9jtcgoidTWpow56PzHjqXI+joYM+3vz86Ax4nGOEyGIYRIQSTrv4wTgqEhILTC2GB7WqEiMIkQBMGhYO0xtu6laCra7SGPeYxwmUwDDOpE0+g+Y2vx3Y1Tjx62Y7unzrqEECgdRQmAYAQaD+ocUaDES6DYQRwJk9GxGIV75eJVQlWUxN2W+sIjGx8YoTLYBgBUstOhioLYUKAnRIgoykkUiDiMSZ98mpEpTffUMAIl8EwAlj19Uz42NUIx4neKGiSTIDUmnidJl4P8WktzPjal0kcM2/0BjsOMOEQBsMIkl21kv0//R4AKgzRVTJ+7ImTmPafXzMWlwmHMBjGBsH+Xdh1ErtOomsEzAf79pJZ8fjIDmycYYTLYBhBrIYmcAtO+oPMVbpu/N3IDGicYoTLYBhB4scvQxTr3BxkJqj6ulAZUzmiFka4DIYRRMYStF71T1htk7Fb3Jr7CReC9t0jOLLxhXHOGwyjRNC5n/0//zG51S8OvCnBaZAIS4AUxBedRPN7P4mQf5M2hnHOGwxjCa0U3pbtOBNnYk9swUoInGaJ22xFogWgNLlVT5N57L7RHewYxDTLMBhGGOV57PnKV/C2bUPn8+Da2AkQsrqB0Xv/raROP2+ERzm2McJlMIwwPffcg7d1K9rzABBhcNCYLZ3NjtTQxg1mqmgwjDDphx/uFy2IqkNoVdtV7MycOxLDGlcY4TIYRhrLKv9Zg8rVEC8haHzz+0ZmXOMII1wGwwhTf845FZUilAdK14GbQGsGXiF0/OS/UGa6WIYRLoNhhKk/6ywSxx+PcF1wHEQ8jkylmPTpz+LOOgbtAaFC2CAcTdi5m71f/nv83dtHe+hjBhPHZTCMEvktW8itW4fV2EhyyRKElOz8+yuBEJm0Kh32AmJLltN02XuRscSojHmEqbliYYTLYBgjaM9j5z9chXBBOKL6SqMELIumt3yI+OJTENarOjDACJfBMB7Y+9UvEuzZjHRqeHEk/e2CRCpJw/lvJvmac0dugCOLiZw3GMYDLe+9CoRTrVhqBTqXofeuP5B74anhH9gYwwiXwTCGcKZMY+I1X0Em6yo3CgaaM0qBEBICn56//OZvrpKEES6DYQyhsmk6r/0GWvvlEyUJFFKChCWiV+FnlenlwI++hMrnRn7Ao4QRLoNhDNF75x8JO/eD70VCZRVepY56We64F0DY00n3X3418gMeJYxwGQxjiOyqFRCGtXeo4a4WQH71ClS2Rj3oVxlGuAyGsYTWoHTVVmaFVtg1Dovam/XccQPayx/5YakQb8cGvG3r0YF/xM9/qJhwCINhDKB9j47/+S7ehhfKO8RagGXhzJ5P3fLzyO/YTO7Je9CBXzZd7H+ObRu7qY2Wq65Bxg8vSFX7Hr1330BuzRMQBpFZZzsI26Hhkg8Sm7vosM4/BEwcl8Ewlum++TdknngABlsztoVsaKTt6muwmloAyL3wNF03/CgqK1EF4bikzryIujMvesXj0YHPgf/+Aqqns8oFADdG61VfRNguOvDQQPbZe9FensTC5TiTZ7/iaw+6UvUNRrgMhtEhv2kjPXfcSrBvH8H+nVgxXVlM0LKZ/K8/RNjlEfK999xI+qHbK8SraIXZU2bR+tF/ecVj6779l+Sfe6z2DpYE24pmr5bsX/EsYk+fR/OlH3/F1y9QU7he1fkCBsNYJf3UCjp+9qOyulxBDuyGktLNACrsL4MT9naTX78aYVkkTz2f9Ip7oaRqRNlKYzz5isemfY/86oOIFhQi+DUgKkQLINjxEtkXHiOxcPkrHsfBMMJlMIwwWik6f31tmWhFGyDMKuy6SKi0Bqu5FSEE6cfvoff23yOkjKY4YQiOrJHPKA8rDSjz3MMV86jBMzOhAaXRjqxpFmVXPWCEy2B4tRB2dqBz1YNFtR8JRFEorAkzCNp303v77yHwy/UkBO0KhC6XDqtlAvEFJx7yuLztG+n+w/fRuUJIhYj+U63AoQ4UwpYHdRTpMDjkMQwVI1wGwwgjE0l0Dcc6AlSgQIHyNbnVa0hPmRhNGauhiFYeizgxUmddcshjCrv20/Xbb5ZfR4OupUxKo5VGeAHY1ftDxueffMjjGComjstgGGFkMkli8UlgV9oNQoLOa5SnInEIfLzNG6PYrooTWZH/S0oQAuHGsCdNJ3bskkMeU/bpB6uL48GW3gphGzqsIsKxBImlrzvkcQwVI1wGwyjQ+qGriB9zbFQBNZGIBMiO/Fda6ciSCgE/QGU8sK3Kk2hF4zs+SWzhyYi6FNiCsGs3nb/4Mv6+HYc0nmD/rld+M16ADsJCEjjgONSd8w6krDLmI4QJhzAYRpHgwH7Crk601uz/9n9WOuylxJk/H7VnA8Iu8WWJKF/RPf5kgl3rwC+PlhexBK1XfxkZiw9pHOlH/0r6gZsZ/DgfVB5sGYVvyCiXUiQchGUj61tofvtnEIcvXKYel8EwFrFb24gdNY/40fNxps+qnD5Kidq/Be0pVC4EVagOYQuEK/E3Pov2Kh39Winy654e8jgSJ56BqCJywpIkTr0ABldalYUGtkVp0RqERWzeUpou/7sjIVoHxQiXwTBGmPB3n458X5Ydpe5MnIQ7oxVBwfekQCQsRNHSoaQd0GD8PKqva8jXlsk6Wq78PO5RiyLfmZRYE6eRPPMS8msfA0sPVKpwJMKx+i0tALQmecrF1J99BfIwYsiGipkqGgxjDJXPoT0fWVfHvi9/EpXPoXoDsAVWnUNF6JYAYnZ5TJfj0vSmq3FnLwAg/9Iq0o/fgerrxp05j9TpF2E1tR10HPlNq+n+y88H0pCKCeClgtU/BkHTmz+BO2vB4d38oLPW2mDCIQyGMYaMxaEwbbMnTsXfsRmZtKLsnmqPsgbyAcSd6EetsZsm4MyaD0Bm5X30PXBTVOMLyK3pJL/+OVo+eA1WU2vNcaQfva08d1IUrLzoImXiZTVNwJk5/5Xe8iFjpooGwxim/oK3gWUjpEC6ora3XEd+LV2wisLOdsL2Xahcht77B0Qr2lehvTzpx24/6LXD7gOVb1olkqEBIXCPPoHmK/4hKiU9QhiLy2AYo2itya56AkIdiUTIwU2NUEcWmSXQfp6O676DzvSBCiM7qbRyqlb429Yf9Pr2hKn4OzZUbhAC4nEa3/hB3JkLht0RXw1jcRkMYxRv/RqyzzwW1cIqoirzBoGCYEmwCuIUKnRfd3lQqdLRsYWXljZ9D/+Z7AtPVi0OWHfGpWA7ldeyLVJLzyc2+7hRES0wznmDYczSed0Pya9ZWbnBKTTNKHWQx+z+kjhaawhUQaAoTOkohDAMslWKnYMsC9k2BSEk8WOXkjzxLIQbw9uxgb6HbiLYvwsZTxKbdyKpUy5EJuuH45YHY+pxGQzjjc7ffJ/8CzVisexCl59UI/gZRInho5WGIIr5qnrc4BXBYlkaQZQ+ZDtYzZNoec9nRrtTtglANRjGG4mTllefqgGEOjKo+rrROQ/th5HfXlrguLXNibBazmOxplZBJwKfsGvfIQWwjjRGuAyGMUpswYm4cxdEsz0d+af6qzVIURZ8qr0QnfFQuYC2q75ITWNFV/GRiUJcVukhvoe3Ze0RvqMjhxEug2GMIqSMKj0EhaRrpcEvEa+qjYBswp7OyhSd0n1Kp4ql4Q1lvRstZH3z4d3AMGKEy2AYo/g7ttBz828GItYVheawEhCRcA3yY+kwwGpsIX7cyf0ln8sofeKliISrahVVi8Txpx25mznCGOEyGMYo6cfvK49cL+QKRgHsJeZWUbxsh9i847Hqm6i/8ArstikINxb5ySyrsHoowJbgWOWlcgalCzVeeuXLpgSNJiYA1WAYo6jennKBsqqsCBaxLWLzF9H05isBkPEkLR/5PP6WdXg7NkbpO1pHxxdfgxECEUvSetWXkLHD68k43BiLy2AYo8SPOwnhxIa0r0y5+DvXcuBnXyLs6wEiX5Y7ZwFWYzPCKUnCrlFRwpo4nZb3/tOYFy0wwmUwjFkSJy3HmjApCm84GIXpoxAClemm67dfK9ss3Fi5paZKyuFICxFLUPe6d9L63s9iNdZOuh5LmKmiwTBGEY5D2yeuIfPkg+RWryTo3IfO9FTuFx94jIUQhH1dBAd2Y7dOASB21PH0Dg6PUBpsi8bLP4o78xhENUf+GMZYXAbDGEY4LqnTz6fhTe9B59JV99HB4KVFTeaZh/vjtYTj0vi2TyBiCYQbR7hxsB3qX/cuYnMWjjvRApPyYzCMeXrv/Qu9d92EsKr71LEEVuNA2WWtNToQ1J3zJlLLBhrD6jDA27oeQh9n5vzx4MsyKT8Gw3jE27GF3rtuAT+gmo1Q7Aqk8kF/dD2BgsAn/dBfyvo3CssmNnchsXknjAfROijG4jIYxjBdN/2GzCN3R6EMriyvqUUhfaeYf2gLRMJGFA0Vy8KeMAksm8TiM0iccPqolaF5hRiLy2AYlwR+ST6iKiRXD7zKGsUGGnJhtL8tERaEHXsJ23fS98CNdN/ys1G6iSOPES6DYQyTOOGUKPq9gPYVOh+iAz1QGbUEHarqzSyCKGna37ttBEY9/BjhMhjGMO7RxxJfvGxAvKQE20ZYtR5dgbCs6k58rfB3bhquoY4oJo7LYBjDCCFouuLDeKe8ltyapxBOjPiS19Dx46+gs5nK/eN2ZI4M6sIDICwLWdc4QiMfXoxz3mAYh+S3rKfjv79S/vRZAlnvFvIRqRSuRB1tH/03RK3ihGMPU7rZYHi14e3YTNf130f19YAtkTEXUFGDjMGFAS2blvd/Drt18mgN95VgVhUNhlcb7vQ5NL/nU8j6BNK1IfQhDAvBXSWNMrTAnXPceBOtg2J8XAbDOEX7Hl3Xf6e82Wv/RgbsFdsmtfwNIzm0YccIl8EwTum68cfoXKWDvhSrdTL151+BM3nmCI1qZDDCZTCMQ4LOdvztL9XcLusaaf34v1f2UXyVYITLYBiHhF37C7XnK9GAPWUOPTf/EqQkceJy3FnzRnaAw4xZVTQYxhFhZzuZpx4k2L8Lf/uLA400CujCf3ReQRBEq4u2Q3L5+TRc8JZRG/crxIRDGAzjnfymtXRd/71o5VCFEHfKQ7V01LhM93mVT6Xt0PbJL2G3TRrBER82JhzCYBjPaK3ovumnoANwBcQs8AJ0aZK1EOh8UMOU0OTXrxqp4Q47RrgMhnFAsG8nWuUgbiMcK2ovlnQgVKBA2DGQNjLZEOUzDkIIWZasPd4xznmDYRyQ37gKxEAX6uL/ddwGt4nUmW/EmTILYcfY/53Pgyov56yB+MIlIz3sYcP4uAyGMYLKpsk9/wRhTyfu9KNwjz6+v/Bfx/XfJNhVWdlBB2FU8VQDQpA88zKsVCM9N/+yv5a8VoqmK64mvuCEkbydI4FxzhsMYxl/91a6rv82WoUQ+AgnhtUykeZ3fRrhxui68Yd4m58vO0b7BdEahHv08TRc9D68zS8ihMSdtwgZi1fsNxitNd729eTWPEGweyvCcUmc+Frii04drXgwI1wGw1hFa82B//4Cqqu9fINlk1z+eupOv4j8pjV03/rz/vQerTXkgprnTCw7j4YL3j7kMYTdB+i44b/QnfvLm8U6LrGjjqfxsisP6Z6OEGZV0TA20VqTW7eOvkcewdu5c7SHMyqong5UX1flhjAg//wTAMTmLiJ50tlg2eDEQBy8dnz2mYfQYW1hG0z3Tf+N7jpQ2eHa98hvWI2/b8eQzzUSGOe8YdQIu7vZ85V/JzjQEb2hFInFxzPh459E2H9Df5pCVApG/7YBgao741ISJ56Jv2sTKt1H722/qX1OrdD5HCJZ97KX93Zvwd+zHZRCyCpGjlb42zfgTJz+sucaKYzFZRg19n3vO/i7dqHzuejle2RXr6bnjr+O9tBGFKuhBatlIhUzI9shfsLp5fvWNRGfv4TkSWciG1trnlPGk4hE8mWvrX2P7ht+AEHUZKOa60hYFjJVP6R7GSmMcBlGBW/ndvLr11e8rz2P3nvvHYURjS6Nl12FSNZFsVbSAsfFnTGP5NJzah7TeuW/YLVVqbHluNS97m2IGrmMpeSeX4HKZ6MfanmrLZvY0YuHcBcjx9+QPW4YK/h7d7D/h1+uuV3lcyM4muFDhyGZp+4l+9zDEPjE5p9E6rQ3IBOV0ze7dTJtH/sy+Q2rUL1dOFPnYE+dU9ZDcTAynqTto1/C27KOvodvJTywB6t5AqkzLiI2d+GQxujt2FhezyvU6MLsVAiBbGyl6S0fG3Plno1wGUYU7eXp+s030dlcZO9XruYTmz9/xMc1HHTf8lO8LWuj3ohA9tmHyG9cTesH/wXhuBX7C9shvmDpIV/HnX0MLbOPqbk96NhL5sl7CQ7sxpl2FMmTz8YqNM2wWyeD7fSPEYjanlkWdeddQWLpmQPBrlrjbV5Nds2D6HwWd87xJI4/a1S6YhvhMowo+fXPolWAsARWUhD2DZqfSGi6/PLRGdwRJGjfWSZaAKgQleklt3YlicWnjcg4vG0v0fm770IYgFL42zeSfep+Wj98DVZTG4nFy0k/ciu6dJxCYjW0kFj62jKLL/3kreSefwSCyELLdu4lt+YhGi/7O+zmkU3eNj4uw4ii0t0QBMiUg7QFdoNAxkA4IOPgTm8kNnP2aA/zsPH3bKtsygrge/g7NozYOHpu+3U0FSymAKkQ7WXpvuXnAMhUPc3v/d/YE6dHvjVp4c5eQPN7P1PmIwv7usiteqBftCI02svR9cdv4O/dMmL3BMbiMowwzvR5YFlIV0GTS9jjYRWW4EXMIn7cPLpvvxYdBMTmLiK+YFl/6spYwd+7k97bb8Df+hIiniR1+gUkTzu/LLrcamiuLlyWjWyaMCLjVLlMVHCwQOlwgp2b8HdvxZkyC2fSDFqv+jwqmy78biqj7HsfuB50QfwGO/HDkN77r6P57Z89qE/uSGKEyzCi2FNn485egLdhDTJuIWJxdBg9CTIVI2zfQrg3RAPexlX03nUdiZPOJnnS2ZEYDAM6DPG2voT28riz5yPjkc9Ga01mxYOk7/8zqrcHe+JUkmdcSO8tv0Z70QKC9vL03n0jYWc7DZe8u/+czsz5yGQ9yvcHHnhASGvEpomlDvVqepJ5/A4a3/QRtNZkn3uQzBN3oDK9WC2TqT/7zbizjgVAZfsIdhfyJGusPKqeDnS2F5FsONK3URWT8mMYcbQKyay4l8wjt6Fy0VK8SCQQMizfr1jds9CxRiTrsZrbsBrasOonYLdNITbveIT1yr9//Z1b6Lj2W5EPCIEOAxoufQ/JpWfQ9+Dt9N17S/mqm5AgNLhyIOwq0KAlE//pG8iSgM+wt4ueW6/F37UJEFgNLTS88X04U+e84vEeKh2//Tb+1her5s7Yk2bQ8qFrSD95J+nH/1o+DbQdmt78CdzpR+Pv20b3rT8GP3fQpz25/HKSi197JIdvchUNYxPt5cmuWUHffdcj7IGplh5Ukrj/vVzQn1gsnBg4Li0f/Ax225RDv3bgs+8rn0Zn0+UbHIfWj/wzHT/9KnpQaIZGgyXQvgYJMm5HooogvuRM6s+5HJlIlR2jsml0GCBTDSM2lSoSdHfQ8YNrqHhMhSS+eDnWxGmkH745qqg6CGfqXJrf8Y+oXJqO3/5rtNBQ42nXWoMWNLzufcSOPmJVKEyuomGMYjv03fGHCpGqmgLjq7JqCNrPozO9dF3/g6oR3y9HfsMLVR9YgpD0o/egAy96QkRxSBqVU6ieAJ0No7ruQkQvKcg99zD7f/QFwu4DZaeTiRRWXeOIixaA3dhCYvkFUchDKVqRe+Fx0g/dHJWCrkLQsRcAGU8Rm7cUqoRwlB8QkH781iMx7JfFCJdhVFE9nSgvj8755eJTTYf86g9Y2NNB2LHvkK+tc9nqgqcVufXPRYMoiBKWiHxx4cD+Vr2LkGJAkLRGZ/vouesGtKoSoDZCaK3Jr3uGzt9+i45f/DvCjZNYdu6Ao0sCRet2kHCXiqtsHlhEqDv9LSRPOBeqVFEttY7Dno4jezM1MM55w2GjgwB/1w4Qkvy23eggIHni8diN1R21Wmu8LevJb1iLdF10GEai5AQQL/xJCg7BCSEKPqpDw517THWLy7Igl654W/uDxMiubkF5659j33c/Td3yN5Bc9roRt7T67vsT2ZX39X8mwd7tYLtgldgpxSFpDaXiSyReGrAbJ6CyaWQihZCS5JLXkVzyOjLPP0r6oT/S/wtSut8Stprahv8GMcJlOEzSTzxC53X/Q5gNyR+I2mEJxwWlmPDBd9J04Xll+2ul6Pz19/A2rkV7+WgKE4aQsCAfRMXxXGvA0ikpV4wtwasUGmE7WBMO3cdlNTRTd9ZFpB+8HV10wNsuaP/gBw6FdJa+R24DIUktO//wzzdEwt4usk/eXT7V1hrt5yMfYjUR1brifQF4655i/9qnSZ16IanT39i/zZ00i3SgQYcVXy7J5RcfwbupjZkqGl4x3tZNdP7m5yC8SLQ0oDQ6n0f7Pu3XXoe3Y1fZMdnnnsDb8EIkWlBw+Gp0JhiYcuQCyPqQ9sALBzrZJGywqjx4MU3Q/spqedWdeynN7/974otfQ2zBCcSOWVT94QaEU/64lFspA69+fI/ME3e8Iv/bKyW/7umq/sGiFTVUtNaRJRz6pJ+8k/zG1f3bss89FIV4DD6hZWMlRqaKhBEuwyum9947EXaIUrLq+o8OQ3oefLTsvezTjwxYNxUHVHnPCyHjR70CFYjmBKTcqD1XwkY0xRFS03Pbz1+xQLhzjqHpio/Q/N6/QyZTNWtjCVeCU3KjhX/WnAkqjc5nX9E09pUS7N9TXaAONlut9bEVPwffI7PyPrQKya5dQW7d01V9eMKyUZneQxzxK8NMFQ2HjMpmyDx5L7kXnkGmbFSPrv7HHypU3iNo30XmiXvw9u7A31LZ8GFIJB1kQwJyHiJmQ6z8T1dl+wg792G3HF7OnHvUQrJrVkDRIixBWAK73kVj4cw4hrBzGzqfqdyvWBdQCmSqMapaOkIoL1v1fa0iX1YFlo09aQbB3q3lgq3Kf6dh9wH2f/+zZaEj2pYIeyCrQYcBzuSZh30PQ8EIl+GQyGzZxs5vfxOhcsTsPJZ0sOsrHwhhgdMsUTuf4MCPHoxy5EJdu9In1LYKGmJY9YVo9oNWCz3Em6lC/NglpB+6nWD/noEEactGJJIIHSIbmqk782Lix52M376Tjp/+a+2TOQ6psy4fUee8cGK1P4ZARWJTHI/jEp+/BJJ1BLs2A1EsVtnna0lwZGU9/OL5pIhSnYQksfjMqK/jCGCEyzBktvz0Rnb+7q7IKQsIEWPygpBkmyA2ySK/N3LWyhikjoraw4sgskg0OnK0uxIU6ECVhRaIlIMIS6YfBcc8AH0eOuYikgnii08lt+bR8qoLgIglCA7sRfv+YZUYFrZNy5WfJfP4PeRWP4lwHJLLziZ+wvKKTjfOhGnEjz+N/JrHyh52DcimZhoueMeRDMYcErHZx5B/cQU6N8hiLH62Tn+xLRovvRJnxjF0/vbrhZ0KS7nFFV1bRvsPjrErJVDR9FnoqEPRCGEi5w1DonPFC7zwue+hw3LfhrQ1c05TCAEqq8l3hsRaJdIpX2LX6ArLQ0O0FJ9KEjtqIflnVxROWhCt0v2lpOntH8edfSzdt/w4qkbg+2jbBi8ApRG2g9YKu2UyTW/5eNWCfUcarUJ677ye3LOPRA5rAdbMuTRf/jFkcuTLHeswoOOXXyHs3BeVqlH0hzxQtLakRezoE2i8+EOkH7ud9BN3lH8RFDUh7kRO/UBFn3GRwQskVuG8tkvbx/6zvxfkEcBEzhsOj+0//k20yjQIHUJ2f7ScLpM2iSk2lisrREpU+RsURCt1Qgc0XPRBZH1TyYZB+2tN9rnHEJZN4+Ufp/GSj5I45ULs5mmRRaDCKPHZ9wjad9Jz+y+P0J2/DGFIfs86qI9BfRwaEqiefXTe+J0RtUCKCMum+d3/m+RrLsRunYw9aSqyqTnKBbXtqF9jYyv150Wty7KrHqmwXgeWSAvyUCpUVsnyafGlCrXqw6C8rtcwYqaKhiHh791L1T8XAUEmxJ4yF2El8DevKQ90PBgayIVoaSOAugveRs/N14KusgqnNeH+PdElhUA4CTKP3g1hvvJ7WYV4W9eh8tlhrc6ptab7jl+iO0qixS2JdqLFAm/bi8RmHzds16+FdOPUnX4RdadfVBinwtv6YlTauWUS7qxj+6e9OqixwgtRPJ6fj6wuR1ZtPtuPBpmsi/JHRwBjcRlelqgaXLQAACAASURBVLCnm1R9gBDV0mMgHg9xJs+m/tyL0VpWDUvQRN/KxVcpQkuE7ZBYdAoNl3+wenyBkNjToqoKWmu6fv8DdDYd+c6qIQTar1wZ7B9PGJBb9yTdt/+Ennt+hbfr0Iv7ZZ97CG/DqvI3QxV1zAkDwq5DT0MaDoSQxGYvJLn0XGJzjivz1cXmHl/7OGlHAbmAcGywLWrO3rQmdfplI7YQYYTL8PJISaohJJYIS8RLI4SmZWIe6UD2yQdxZsyh8e0fAWGhNf0ipZRC5QJUjx+9ev2y9BmdHajAkDhuGYlTzqtI6BWOQ+q01wNRWWSV6Ys2qOottWSqIQpFqIJWId23/oi+x27C37keb/Mqeu78BZmn7z6kjyXz5J0DlUVLCRRaWtgtVTrwjDFSr720RsFDic5lSJ36RmRdEwiB1dQSpUNVQbZNJX7ssmEe7QBmqmioirdzF8G+fbgzpmO3tSFsh4nT8uQyFpk+C2lp6hoCbCcq86LCAJ3Lkly8jMSipeReWkPPjT9H9/Wi82HZCiIaVCZAJm2ELRGx8ulF/flvxWpqI/PEXehsGmf60dSf9xbsYtJvGA5EggcKXAutS5z/tkPDhe+u+e2f37SKoGN3uW8n8Mg8dw/xBa8ZslO9IthSlZTiyYfIxolDOs9oYtU1IpuaUd2dA6k/UiAsCRZkVt6BO+tYUssvwaprpuuWn+BtXlNWUUIk62l5x6dHdNxGuAxlqGyWPV//JvmNm6Jv1yAgecrJaGkhhE8iFZJIFf5odWEhTYtIQAr+JCEliWMWE5x8Nn0P3lYzclzlQ6QlwC5vXCqEJLXsXFLLzq16nD1pevk3vxdG1RukAASpJWfjzqzd9cbbumZQ7fQC0sLfs4nY3KGFMMhUI6q34N8KB6XAZDN0XvsftHzwc1gNLUM632iRWPxaMk+WrCxasrCyG0238xufw9uxgZZ3fZbUaRcRduwm7NwX+bUmTqP58k8gq1SNGE7MVNFQRvvPryX30ga056GzWbTvk1mxEp3LRzm1qvwFFFYBJd661WXnSi0/D+kcxDmuNNpTBLv3ocIQf+cW/F1bX7YkjJAWdee8ufzNUEf1usKQ3PMryT2/sqzeetnx8bqq0yMBiCr11mvhzpgXWSmqSt6e1mgvS98DNw35fKNFcsl5UZlm24mm6HJQMnYhSTu76iG6//gdVM8BhGUhbAvd1U73zT9EqXBES/mYOC5DPzoI2PyhqyAot5BkPIqErzbxEjGBFYu+/5JnvI7GS66g+y9/Iv3wveh8DnvGLNS+bRW+IF38jybyn7Q1IMIQ0IhYnKZ3fRJ3xtyq4wzad+NtWU/Pfb9HBMFA3JEkEi8EODFQIfHjT6HhkveVdawJDuyi65bvQTgoiDVeR8u7/qVmHJLK9OLteglhu7jTj8Hb+iLdN/80Os9BnoL4wlOof+P7KgJYxxpBxx6yqx8it35lZYgEYDVPjuqeDd5WkkokGlppvvRqrCPTEMSUbja8PCqbZctVV1eIjJWsnUhs1ReW1bWIajFpCDs7ysRPxOyosoI/8Aevi6IFiJhExsojtEUszoTPfL2/cQVEHa47f/td/O2bEJY1UFa5tPTN4HE6LvUXXkFy6Zllb2fXrSD96I2RdQFgOSQWnk64dyvCjRNfuBxnyoBwZp67j8yK26MLSIGQFvUXfpjev15HeGBP9bpeRWyH1GkXkTr1gtr7jBH8vVvpuuWHlVNpy8ZqmEC4b0f5+5IK6wwtaH73Px923igHES7ri1/84uGe/LBPYBgbCMeh77EnUL3lTmfp1BYuGRNoL3JK63QanUlXXWlz5swDFDqXQyP6G2BgC6zmGMK1ouleUbukRHlZdCaDTNYhY3G6b74Wb/2ayGdWzW9WKmBFVEjYdYDksrPLx9M2jcSiM5CxeoIdO9G9+/F3bUB1txN27Ca/8RlA4kyZi7fzJfruu25gfqwUhAHe5tU0veN/QxgQ7NlWO4dSKcKOvSSXnVd9+xhCphrxNq9G5dJl9yNsh9ixpxLs2Tog0oNFi+LPmvzG1SRPOudwh/OlmuM83DMbXl1MuOpD0Spf0flt21EEdTWfUMxCqyHE7YRRysjk//stpnzjFzjT2pANDlZzDLstjiykjIhYyRQt8Mk++QDdt/yS9m99lt67byS36snqlo0mSm2pweCGF/3v+z59d/2BsGPXQNpKyfUzT92ByvbS9/Cfqsem+TmCvVuoP/ettH3qazhzFtYeg1d9DGMNIQSNl1yNO/u4qEGskFht02i87BMkTzgz8gGKl5cNne7ur1k/HJhVRUMZVl2ctve+ley6DQQHeonPP5rkyUvY/71vor08Op9HxOJYLS20vv9D7P/+19HUDvQEQFo4M2YDBYsozGKlnCr7DRLBEssq/cidlPYnPBRUrg9v20u4M+eVvZ997pEoRcUCnfWjaADXKsvp83duJOxur1E4VBei4xchY3Ga3vRR2n94DWT7Bu0pcGcf+4rGPhrIWJLGCz+ADgNQYVk0fPMVnyb98E3kt7wAqnbUPUKic33AYU8Xq2KEywCA9jwO/Ozb+Jtfivw+WuNMnkbTJRchE0mmfuVbZJ96kqB9H87MWSSOPzFaWUokUPlcZPEUvogH5yUKx6b+3NcP/JxIofp6ijtXTu+qqUTgV/d4lBpCCrSsTOZG+XTd8F3aPvZvyNRA2ZVg347ovCVGnA7CqCpC0kWoMFpp0zWSxLUm99JqcmtWRqWRhYR8bmCKJQpTYsem7qzLqwx+bCMsu6KWmFXfRMMbPgBAdv1T9N31q/KDdHG6HyIbh6/+vJkqGgDo+euf8DatR/seOp9De3n8ndvo/mP0hyldl9TyM2i89M0kT1yKKEwl3dnzICASriB66RInuz15GhP+/hrstmiVKezuQPsSnfYHXqGKAkhxsCZOrRmdXUFFCAKAFR0viCw4p2A9KU129WNlu8vGlupiGKhoehsG9D74R2RrVCanOF3sT1vK+uiuA+hML/heYTqoB4rw6UKgWxBG1surjMT8pSRPu6zkXkt8lEKSfe6BYbu2ES4DAJknHqxc5g4Dss8+WTM+J+zuIvvsM5UbFGABNggH3JmzAdBK0fHT/0R1lfQd1KAzAe6c45nwf/4Ld+5xUa7fYGwHWdcwMJ2slaIoLXBthGNFUflCRM9T4KN6uwcuq3XU/aYG2g8jgUp3Y9c1RvekdCTKmihlqVZhRFkoxlcUMKXIrX2q/PxaE+zfhd++fVRbmR0u8XlLIl9YySoxAFqRX//0sF3XTBUNEX6NciSqEHVa5Tsu++xTNf1OOtRIRxLs2432PYTj4m16EZXuq1x1tGyciTNQPV1kHr0n2l5o/RUJj47G1zIx0oR0b6GxxqBrIpH1Ewn2bQepsRJONOxCrJi/azMq3YNMNZB74Un8nQdJrC5O83SIv30djZd/ku5bfhR9HkKArJ3czeBkdK3LFhX89h303PYzVD4NCITl0HDh+3Gnl/vgxgNB5+7aNfWPXF2uylMP25kN44rYguOr+pacWUdFvo4qHNRSKLp5bIuwYOmE3R3oakIXBgQd7Xib1kUVCYp9+ooWjtIQKsK9u9EyFvnFpIisukKn6cgSUqienciYRLoWuni8iAoT+ru3sP/n/4FWisyKuw8ee+VY/daUViHulLm0XfkfNL7xSurOfhvCrbK4AOXTpSK2TeyYk6LNvkf3Td9H9XWC74GfR+f66L71JyPWaOJIoXJpem7/RfWNlk184anDdm0jXAYAGi5/JyKZGqjKYDuIeIKmt3+w5jGJE06qGeAlihaTY6P6ekg//kA0Baw2tXJiuLPnIxLJcp+TprxpQxigOtqjbsoiqnUuLImwZbQiWKi6WtpdWmiiPo2uBY5Eez303PkbdLYvGnu12mExu9z1JTQq24ewLNxZxxKbvShqEmHXeHxKSx3bDoml5+BMmgFAfvPq6uKtFbl1K6ufb4yhtSZo30Hf47dG1lZ/xVoGfn/SOhJxXDUxU0UDAHbLBCZ97qukn3gQf+tGnKkzSC4/G6u+emmY6Jg2mt50BV1/vK58+mdHwiXiMWR9Ewe+/5X+apnCEdFKXX9Cr4VV30Bi8WtARnW5asVdRUQR+mFne/85tGUj3cpVPwH9uUWlKT/5tU/iTJ+H2l4IW7BkiVOZckESApGI4+14kfi8kwFQnodOB1H37cI+xfO4847DnbIAf/cWZF0j8QVLyzrfqGxfWWWFfsIAlek5yH2PDcK+Lrpv+RFhT0fBjTDoM4DoMww9dD6LGKby1Ua4DP3IZIr6c95wSMfUn/96YgsX0fOXG8lvWofQeQQhsq4Be+os8uueL3P6a09iTZyAdG104BM/7mTqzr4oqrYJtHzkM3T87JvRtKmKZWK1TqT1w/9M+pG/kl39eFQkb/Fy0vffXHuQVcpAC9tBuPGox2O/30pAwkbaUTgIUva3py/mL6p8ls5f/ic6mxkQO63BsbAmT6D+3HdiJWuLvTP1qOg6g2/NcXGmz0Nrhb/9JcKeDuyJMw6r8cdw0HPrTwuVIQo3cJD44zCXGba6+0a4DIeNO3U6bR/5VMX7e//t05UrlVoR7j/AhP/3HWQiVXGMM2UGEz/3DXIvPEv3H34WhREEPkgLYdk0vfkDCDdG3TmXUXfOZf3HZVc8iEp3VokJqxInRrTK2PK+z5FZeTfejg1YTW3E559IesXNFcnXaI0zfQEAuTWPRWEPg6e8IdSf+Z6DihaAM2E6sdmLyG95fiAf0HZwJszAbp1Cxy+/XBDtaJnOmXY0jRdfWdPPOJKEXe0EnXuHHAhs1R38szgcRv/TMLxq0UHt2CVdLeShgJCSxKIlxObMI/3E/fhbN2BNmELqtHOxW6oX52t+7/+i47//Fa3CgZVIBCJeZWXLdojNOwGroZn6c99Wtknle8muuqc4ENCaujPf0V+73t+5uWotL2HZUe/BadUrWpRSf8F7cdetJPvCYxCGxBacQmLhqXTf/GNUT0eZMPg7N5B56h5Sp1z4sucdblQ+ixAWmtKOQFS3umyn34oeDoxwGYaN+OKTyTx2f8VyudU6Aav+5RuHylQ99edeMqRrOZOmMeEfv0rfA7fibd+IO3UWyVPPp+fePxLsfHFgR9vBamwjcdzyqudJnnAuVtNUeu/8HeGBvch4En/HdtwZC6PFgGR9tMw/aEVSw5BLuQghiS84hfiCU/rfU/kc/q6N5daMLYGQ7JqHy4RLBz75jc/g7ViPrGsiseA1WI1HpIzMQbHbpjLUYjCyobXMr3ikMWVtDMOGSvfR/q0voPp60V4++ha2LFo/9k+4M1/eMjlSeDs3kn32QVS2j9jRJ2BPnEHf/Tfj79iEjMWxWiej8lnspjZii06h95Zry5OibZfYsSehM334218acEgXkRZW2xRa3v/PhQoS+pCndiqb5sDPPh8JoiXAjY7XWiMChdU6nboz34rdOonuP3+PsK8rsvyEBGnRcO67cWfWTvIejFYhubWPk1v3BDoMiR11IsnjzyqzkpSXI7fuKcL2HVhtU4kfczL5zavpu//30ZeR1lESvhq0WiwEuC7Nl30Ke8Jh+ehMPS7D6KC8PLlnniC/aR32hMkkT3ktVkPT8F83k6bv/jvIrnkamaqn7qwLSCw6iaCznY6f/ltlB6D+/MJCxOrg50IIsO0ofxHo7/0oBO7Ri6k7+3IyK27D2/YCaI09cRZ1Z70du2noScYdv/4Pwo49kCg2Yg3RmZJpqWVjtU1BeV0D4ygOL5ak5V2fH3Iz1u67rsXf9VLJ6q6N1TiBpsv+DiEtwt5OOn8fJdYTeGC7CNuh+W3/gMplyD73ICrdBWiCfVvKqmcIIcCySZ16CYlFZwz5/qtghMvwt4PKZtj3tc8T9nT1FzQUrkvdeRejwx5yzz1W6WAeynMgRWXIRaqRtk/+O12//xphz4HyUAc3Tsu7rkHGkgwFf992uv/0HbRVCHztrRIWIgQi4UTtwkqxXZou/jh269SXvU6wfwddf/lh5SKE7VJ/5tuJzVlM920/i5piDLKknOnzaLrs4/1vRQUW/1oZPe/EqD/nncTm1G5/NgRMJ2vD3w7px+5H9fYMVGG1BMIOST/yZ3LPP33wiPlDxY98U2G6qyI+S+ez9N73O1Q+O6RTORNnUHfuFdE0M6yxcqc1Oh9U1gfTesjOcH/fNqraG4GHv2cTAN7WtZVirjX+jpfKAmjj80+uUp9LIGwHd+bwlfIxwmV41ZF74bkoPosomt6qtxGujDoKZfqidKJDmWkUYr6qld9xZi1A9ewvExqtNdoLIB/grXuGAz+5hr6HbqpajHAwsTmLa+f4FWPNANJ5dM5HewE61FgNrVgNQysjI5MN1a9h2chUU/EmaoyhkGNVIL/lhQqfn2xso+nSTw5rCIdZVTS86rCaWgpJ0jrq3VgtLSlUhc7MlD+k0sKeNAMdeIT7d4Nlk1h8GrGFS+n+ww8iK06rKK7Mcak7981oL1M+9QzC8rSfMCC76mFkfTPJE8866NiF49Jw7rvpvvtXUOrfkgNJ52XXif6BdOrQWvWv5IXpHjJP3Ym3dS0iniS5+Cxi85cihMCdsSDKUPA9yiwvIYnPO5kw01MSEV++i6xr6h+D376d9CM3VliaKp+m++5r0fk+ZMNEZLwOYVnE5p6IO2vhEVltNDXnDa86rKYWsisfBR0i41Z14ZKy0D+wYEG4sSikoaG1ULYmIHHCGTS+7WoSxy6NVhwXLI3ixByX+LFLaLj4A9iNrQgnTvaFx9GhH4mgX2Wap0LCA7tJLnn5/D2rcQKJBaeiCQn2bI/GVyOQtkjY14XV2IbdNhWVS9N5w9cJ9mxB5zPoTC/e9nXofBZ3xjEIKYnNXIi/eyPaz4FlIZMNNJz/AeymifQ9+EfC/TsHDKuSHEQtLVJLon6XfQ/+AdU1qDyzFIBC5zNRjbK+LlTXPsLOPXibnsPfvo7YMcsOei8l1Kw5bywuw6sOd+ZcGt/+Abr/8D/UWjuyWifTetU1YNloL0/QvpPe+27F37wWVKFcdGc7uReeou1jX0A4LnbLRBoufGf/ObTW9D16K5mVd0edn+XBI8pVLj2k8WutkYk66s98CwQB2TWPlltw1fA9cs8/RvyYpWRXP4z2suW+vMAju+Zhkieeg0zWYzVOoPnN/0jY1wkqRNa3DlhS29fXvIxwY6hcmmDvVvztayt36K+XVqVKBpqgfRvplXdQt+zQUssGY4TL8Koktex0kiedQuev/wt/x4by6YzjoC1o/8b/ipza9U3kehqws5vK/cxBQNjTSXbVEySXvrbiGrnnHyez8h4IfHQwqEVaFYvCnjAdHYYgBd7WdYQde7HbpuDMmIcQktyLT9H34M2o7gPIuiZiC5eRXf1IIYFdVC0fXUYh0d3btrZmjaz00/eQWnZB/0qnVddcsY+IxaFUY4v3ozWQo/OPXylU7SidQ5YUeOyvhqqrfg65NQ8dtnCZcAjDqxqVz9J9w4/wtr2EsGx06EcdmEO/XwS01lH5aE9Fdb4GETvuZJrffnW0r++Re/Fpws52ss8/isr0ROcRgyrtl4lXwVFkWQUHu4P2fVAKIS1kUxvJJefSe9d1A3FVxdLTg6kSkgGA7VJ39lvw920mv/6p2haa4yCkReMbr8KZPKfqLtk1j9D3yE3RWFy7vOGrLCkFFCrwwoHtpeMqVgupkuCOELRe+dWh+LpMHJfhb5uwaz9hdwfe3m2k7/lDxROhQlXdNyUkyeXn03Dh2wk62+n8n6+iCgUAo+0g4nZFg5Bom0Ck6qNuNyWbo14SJdezbRA2lEbrV+tZWLhe0edVelKZrEdOm4Xa81JUPDGoPm0tCrNI1NHy3i9UFQ+tFb33/Y78xqcLQjloBxkJdf8ihCUHLDJVYm1R5R60hliKtvf/v6rjq3a31TBTRcPfBFZTG1ZTG5kV91SdwggpCrOcQdMxrdBhjs4bvo23bTN4gyPuoebzpTVahRVTRwFoSxbCMohWKkUQpfpAVMv+YARhoa5/QcCURqV70NvWRiV4AC2pLJ1TeluBT7h/J/aEGRWnF0JSf9bb8Latqh7zpnRkUQmiSrHQX9sfKQbqlBU+g8GkTj78jt5GuMYQWmtyGzcTHOgkfvQc7JZmVDaHjMcQ0oTcHQkOmgjtWggvLHQpEggLRNwhv/ZJkEUvUxW0LtYrjChdAfSyte2GongVDytWtbBE1QceotQeHWaBYEDgLBlZfaXiqEFbhbivUEUVWwXRMS/n6Ae0CmrHcumS65Zeszh+W5aLV9kNQHzh6S97/ZfDCNcYIejsYvuXvorfvh8hBMrzUdrCy4GMxZj49jcw8W1vRAhBdv0mep98BuE6NJ55Ku7k6qVeDJUkz3gDmRV3l1lWRXeJkAJiNr0bPernu1FZ6OKDqYhEwJIDwaYF15UO1SArDbTQWK1TUOn9tQVADjqmMCZdw6mNZVN31lvoveO3Zb0gB4tW//tKD0zrCr4xLXRByFystmk1PyfpxJF1Tajejpr7VEMIUTBCa4hvsm6ooRAHxQjXGGHXN76Pt2PXwLc3IHSIhSTMKPZd95fIdXCgnc57HkZ50V/u3t/exOQPvYO2Sw/f/P5bwIqnaHzrx+n+/ffLI9mF6BeNurnxqArqYDSF+vYaEbMLwqWrT+00JE99PX0P3QD5yk7f0XSu+gMcPfyV4QSyrp74wmX03XV9+aaiNV7ma1IDx1sDsWxRArRF3dlX1HSOaz9PzwO/RAWZaqN+Wa+2sF1Eaxtq346CdVcQYtsheeL5Bz94iJj5xxgg6Owiu25DxTdU1AU++nZXeY/2G/5Mx90Po7yA/r+eULHnJ9eR275rhEc9fonPW0zDZR+OujQXVwSLD7YtseIHfyxE3C5ryNHfU3DQq+++P2FPnD4gcNXCBGoYH8KyIv9RsSmHY6FzfaieDvTg1mhaRftKMfCyCyuY/Y78EtwY/q4X6brjB3Td+UOyG56MfHEF0s/8leDADgQKYk5/oK5sbC0fcLExbulQgMSis0gtPi9aRbVk4f8Wsq6J+ILTDvrZDhVjcY0gPc++yP47HkEHIa3nvobG1xyPkBKvvbMw3ah+XP/fuZcveFlKd4z+vfvHv6b14vMQjo1dl0KHIfGj5yDd4atCOZ5JHHcKOtNH+uG/RA+t1sj6RlS2p3oziyKDVvNq+4s0uq+b+NGXk96/B50bbL3079Z/3mI5mKLjW4jy1UPhxMlvXIWwJDruFLomAbZVaB05KCzBLvZuG3TNwCO/5VmK881M9z78Xeuof+17EEJE2wpCJqTorw2m8r0I2x2oVRZG/rj+OYIQyGQT+S2rUM/eFem1GBBOnU/jb11FbO5JNT6zoWOEaxjxejKkd+0nOamZfX+4g/Y/30c+4+Mrwd6HnqNx0VymvPMicpu3V43V0xo8f+DbX9j2QMWDQaRXrSX/0gZEEE1LhJQIx2bSJ6+i4bRTqh7zt05y2bkklpyFSncjE3VgWeTWrqD37uurf86CyCFd9l5h+lSNUBHs20nTW/6ezt99vbLkcxgtFliTZhLu3w5KE19wMlpHVU/L6vXbDvHjB5zapYJSOhWsStn3XFFFgoF/hz7+3k0EHTuwW6b3Zw5UO49WquQcesDfJy2c6fMJ9m5CpwfGPRDKJiLB3PjM+BcurdSrcrVMK8Xq797IlpsfQTo2yvNJaI+E9LEFuEITegH7Vm7gwOofYKmAmOVQl4x+4aUhMXlP4lgaiSDIhf0xjJXXpGCRDYxBhB57vv0j4rNm4E6bMmL3P54QloXV0NL/c+K4U3GnH0XHH76D7u7s1yTZNpX6c95KsPMlMk/dU7t7cxENSIlV34jdNJHmt/0j6cdvxd+9CZmoI7HkPOI1cvZ0GKJyfeRfeqYQNBsQO+pEUqe8AdXXSfrx2yhaS1prhB5shfffHdixqHGuEFHAqxtHq2zlH5FSBO1bcVpnYE+cQ7B3M+WCLHAnH4VMTSC3+oHCWyXTXdci7NhRWeNrMEeou/WoBKBmnllJ1x+vI9y/D1lXT8MbLqXu3AuPyGrDWGDD9fey9qe3EeYKpVXQTIjly2IKi6lceWUhAcdSWFIRc0Ok1ASBGBAtMXCclKrolumn6IsFgRjU/t1xFa0Xv46JH37PMN/1qwutNUHHblRfN86UuQjHRfV2obws3X/6XjT10wodqhrO+cj/0/axf8dqKE+r0Sokt+5Jci8+AVoRO3oJiYWnI+zy7tgq00vY3Y7VOKGszVfmmftIP3ZrFH0fhFEYR9KtWNmEKHyi+YrPobr3ItwE3p4NZJ67o2oRwbqllxCbcxJhz3667/xRFBIRBmDZCMuh8YKPkl37KLl1j0WWlqYQSyYQlgPeoGoTpQgRFSp87RW4M48b4m9hDAWgZp9fRcfPf9hfL0n19dL5+9/Qt3IlEz/5D1ipypZV440N19/XL1oAcSusSF8rzjAkGoUoiI8kmytaoBopold5JoVAFp2zxUWesiDI8t+170lyW7cf0fv7W0AIgdM6FVqn4u/dTs+tvyDs7QStsZracKYdhb9rE0LaqI79FcdHcV2iqoXRc8+v8Heu758KZp66E2/zahov+UTZDEQm66v2JUyedA5282S6/vSD6A0vhLiumiKk/RyqtwO7LQo0jcWSZFbdWeV+Je6MSFCshjaaLv4HchtXEnbuwmqZSvyok5GxFDKWjOpsiUF+QCEj/1wti8tyiM09CWfG0OviH4wRm6fpIKDjnkfZ+4PvEaQ9ggyE+YLjGfA3rWPnv/xf/J6+aB49jvF6yh2xttBV086g+Lcm8FTRV1J8gRSq4jvHcjR1LQHJxoBEfUCiMagsQDmYxPA05fxbQGXTdN3wX1ET1MCHMCA8sBdv2wZaP/hFUqe8fmDnQSuHwraRqbqy8/nt28tEC4DQJ+jcg7f9RYZK9vnHy1ehay0SKBVVZy0grx3C+AAAIABJREFUY0kazv4AIlEPtguWg0w10XDuhxD2wEKOjKdIHncW9We8k+TCs5CxyKCIHbWEan9wUUu5s6Iu5aVIC+eoJTRe/Cnqlr/piM2qRsTi0mHIxs99g8yGLSScHDooGbyEeJMGCTue72Xz5f8HGXOYevlZzL3ysmhZeJzRsmg2+59+qf9nX0mUDquK18Dfm0ABTsJFFa01y6I00lAITV1TQahKauClmgN699vU8nO4M8dWN+TxRG7tirJQgQgNgUf60dvwtq6j4LWONpUkVjuzjqmIlQr2bqkuMoGHv3sjsVlDs0iCvVvLR5QPKiLZi4Rdu2HGgv6fnbaZNF/6GcLufSAkVsOEIQuKVddC3elvo+/RPxScsSAsm/pz3ofdOg2EIPv8gxAGCCdGYsmFJI45dUjnPhRGRLi6H3uG7Iat2EEGXWU52esV2PUa3486rKicx64b7ydM55j/j+8aiSEeURZ96k089PFvo7wAHSpy2qKBICpLUthH6ygYWxXmewKIzZrGzCtex54b7yHsy9K4bCG99z2KykUrhU680hItTjmdmMbPV4mejrnULTpmuG71VU/Y01HZjRvQnlcoaTPISV9YHha2Rf3Zl1ccJxP10RfS4JU7aR1Su3pZV0/YWTJF9UPwArQ7KIrelhW+M4imhnbT5CFfr5TYzEW4044haN8WVYxtm9k/xU2eeD6Jxeeg/Xyh3PXwTOpGRLh6nngWlcvhxKDSKhAoX9PRbhMoEfl7AJn9/+2dd7xdRbX4v2vvfdrtuekhvRCSQEjoiECkKgiCT56Kgv4ECyqKYEEpFhBBH4jtwUPUPEUE9dFEeq+hhYQQQki76f32e0/ZZX5/zD79nJub25Ib9vfzOZ97z+zZe2b2nL32zJo1azlsefglRp32AaqnjRtUI6+6aWOZ94fv8N6fH6N5+XqqJ46iZtwwtt71MGFfN5BwDTpdkwrD0wp4y2DK1z9F3dzpDD8la6TXcdJRrPnpf+O2dmCYZaaFAojCU/lOBSQSomL6ZCpnH1DiJHDbO9h+132kNm+j8uBZ1J92gja5CMgQ3m8K8bdezHqDyKByXCfn4AuJquM+hjW8eEtNeMIs5KV7i1TYynXpfPMZIlPmYlbuOnR9bM7x2JvW5dmcqbi/Kl0RJm14KiKEx/cq0k5JxAwRGjWl9DHDRLoZ2ajH5Q/EquLG2+5i4z1PUhVLUXInhYINjTFclXbErwgZCgMwoyGMcIip3zqXEfMO7W1d9whOPMkjZ3wfL1n45lZERFFXZ3HAdRdTe+DUkucrzyPRsJHkindpueduVMEWEoXQ3FxBqt3FtBSW4WFVRRn6keMZ+dn/wCgMZQW0v7mEtT+8Ka/3jIoI+33xdJJLFyKmRcVR84gdcvQ+abLSXZTn0njHL3S8w7QJhGFqgVFCFxueOpvqUz6NWVVe+DiNW2j51+/wUjnRf2wXEEJj96fuzK90q14tD99Gav0qSKa08WcsBEUjLhOjqp6aky7ArNi1QOwJbttO3LadgOBs11PY8ISDdiumZBnKzl8HxOd8eNgQVtzzIoIiYnlFS/kpR2hNhDP1DPtCS0RvYPVSNo0L3mbIYTOIDOv/YKJ9zfY3lrPpiYUlFh30W3H8J05g1ClHlRUQIkJoSC2RyZPoXLwIr70t89BIOEx05ixqT/8ozsb1WF6cihqbaDSFt6kBCVlE98+fKnquy+qvX6GX8rOTVypHOThr38VrbcJtbiT53lKcrZuJzT6sb2/IIELEIDrjcADctmaMiipCYybraVphbEbTInbwMUQmdh2Wy4hV0fn6E3oU53k5EYIUXnsjFXM/tMvAriIGkamHYETCuJ1btW99y8j6BRMyS2/KTmBvayA69fDdbH3XKCdF23N30Ln4UVJr3yLV8CbOtjU429aSXPUGiBAaMbE3Rfy43IEBeZVGJ+yHa4RIJS1cTzIvKs/TesotrbGs3Ymv7ymyj0vZbPjHEwNR3T7HsKwyoan06tOmfz7B4i9czc5nXsNLlTfgE8Ng1Pe+T93ZHye0336Exo1nyH9+ipGXXErNpGFUmTuoqk5gWfq6KpWi+b57cXbuzJboeWz/zc/w/De8rp8iVutC0sXrSLt1AZVKEn/7DezN729zCiMcoeqYjzLswh8x9AtXU3PquaWtgEWIHLAbs4LsAnJBWvdmQc7WNcSXPps1QUiHL0t/MkaDHm7zlrzVxb6gY+FD2FvX6JFo3gKGB65NfMlT/kis7xmwOUAsYqKU0Ngaoa0zRHvcYlt7hJU7qul0LOKeWeS0MeUJ6+Ih3mmPsLwtxLJn3uW+06/g3lO/z6vX3UmiqX2gqt8r6mdPLrtqYxkKy0uR2ryNNb/4I4s+/R06V5UXFPa61TgbVxKqDVF1+MFUHnkkYpp0vPF6xjYuFxEhvmRx5nvy3UWkNmZXpKywS6zGxbAAF7y4wmn2MsILFKnVy3vU7n0VI1ZF7dlf0srn9CcUofbMC7ucIuYSmVIqfqJgjZyAaGXwLul4/cFdW6pnLm2gnGIvFT1FeR7JNYuKFxlyraOVIlUqoEYfMGCa2FDYxI0DCImURZMdyllj09jKwPDjudkerOiIZIwBKk1FqtNGfAXkmodfY9PLyzj9H1cSinavo/cEbjzJW5feRKWkaCtor4UiangZvZ+yHVzb4b2rfsPBd1xfNHXsWPAcLf/8S0ZA2Vs30frss8j0DxJfthKVNAiF3PzBgEhehOP4269jWg6GqTAsl0hlicGDB27cw6o0tU/0qpq+uh37DJFJMxn29RtIrV8BShEeN63bkaQBKo/6KKkNK1DxdpSdBCuMWBbVJ356l+d6yTipje9pc4ZuIqaFWd2FE8XdRXkUBoItLlSyLnf6mAETXJGRQ+hobkMEUkqvHHqZ6WH24bE9A0tcttuWL7QESxRWwTYXXI/4jlbmn/VT/nP+t6gdVRytZG9g3R0P0bFmI5ZyqTXBQXCUEBJFxHQJFbooAdyOTjpXrqdy/wmZNOXYtNx7Z96oKt7o0rolAcue0jdTTKyQUD3Eyd4rpYjNyW5qNSIxPFuwwqrkbCdTXhxUhUJMk+jMOb2+D/siYoWITOqZJbgRq6L+3O+TXLUYZ/sGzLrhRKYdghGOdnleYtVCOhbcW9IINI/0rn3/b2zWh/p0kUVMC7N2lLYRKyw35yedtsbvawZsqpiMZ4eUrie0OgaN/qfJMUj5e+02pYTHm0x2pAzCogiLwpLSlvSGgNPYwl8v/n2v62dv20H7G2+R2rSl19fKZdvjr+hw7OiXT30sxajKJEMrUkTMMq5sRPDs/CmAs3Vznu5DedC6xdTbSnxnbYJCOdDZauFKBAmHGf7Vr+dto4od+kFSzb4Oq4t6KwWeHWHYVy7frZFEQPcR0yK6/6FUHfMxYrM+sEuh5bY3aaHlOsWeJnJJC4/078VT2JtX9l3FfSqP+FhxuTl/Y7NP7JZpR08YsBFXsrkD1zMIGx7bbYuUEtLKYQ9odQ1qcNlmQ41lMDQEae1luYGBpyDlQdv6HWxbtYURU3bfoE45Dhtvvo32V95EQhbKcaiYNZ2xl1+MEemDKWgXilYRVbDPMJ0uVE6fmJdmVFbpmHw+qU7J8Y6rMHM2X3s2xJuFEZ85m4o5+S5EwmMnIaEqoAWUaF2WUbxpG8DtdLBGBF4l9haSaxbn/57KedRJ/zByjrnNfftCBggNHZtfh/T/hl4tNyKxPi8zzYCNuKqnjsVD6HANkl7aXiufuGsQ92BipMziSE5HpPul2REM0yTeWsZR2y7Y8c9/0f7qIpRt43XGUSmbzrffZcvtd/boeoWMOOlIJMeOKuUYubEG/LugE8QyMSJhJl9+IUaBIahZV094/KTsPcjbsK2KPUbYDtvuvB+3PT96cqphNaqzLfM9ra/N3WaXwfO0B4KAvQLlpLKrd2n9imnkPyzp7wWYtX2o38olUuHXhfxVTREkvA8IrqkXnokRDfubiUshKIFRoZIR6rRODO1uRClIeNCQ0Jb2nusy+oDyjv+7ounhp1Cp/GG3sh1an3mxTzZ7jz//NComjMKI6dGbE4rhGRYSDmFEQoSrwkSHVjP0pKMY/anTOPD2n1B35OyS16o48Wxc29CeeqNZCVPoQSLnAB1Ls3smlVLsvO3XWBGX3Nek7wC0CGvYcIxY//34AnaP8LgZYPrbd/JcZUn+al7xznxis0/MfFVK4ezcSLLhbdzdDIZRSOWBJ5YsEsMiPKb/tpoN2FSxdsYEDr3pG7x1w51sX769ZJ5YxKAy5JWJbKTYbsMOWzDFt/YSCEVDnPrtswjHejat8+Kll4iV46JcN0+h6bS20/z0S6S2bKdixlRqjj60pFV6LmYsytxbfkDjq2/T/t46oqOGMvTYuSTXbSK+ah3hUcOonjMTMXf9DomMH098hwUqhWFAyHJJpcyMOqPIg2oiybb//h0td1dTfcIJVMyZjdfRjmFCpBbsDkXa5ZKVe/tEkFCIoZ/7/C7rFDBwhIaNIzJ5jp4yOimtK/GnZYC/RzJCZOJckitfR9kJjJrhVB5+BqHheqHHS3bS8sjtmQ3WeA6RiQdRdewne6S8dzub/HBq5AgvQ3ugsPpPN7pHHAk+8s1b2bgg3zYoXBXlQ1ecg0JYcO2def6sQI+2XmlXxJWisjrGmBF1TNh/P4769LGMnzu5x5Vfd81NdCxcUjTkiEwez+SbstF24ysbWHPFz7VAS6WQaITw8Hom/+JKzMr+3ZeVy6bf/YnW515GJfX9UQpcfD/leW3QozAzrEjZJoZlUDGsAtXWDCjMCFjR/Gm48rRZjoQtRlx8GbFZBw5YuwK6h1IKZ8sqkmsWo0QwYlXYm97FS3QQGjmFioNPwqzSHl1LeRhuefxP2q1OrsGoGaLi0FOpOPC4bpWP5yKmRWLNQjpeu7coj0QqqP/Y93vXUP9S5Q4MyJafQqacegjR+iqa12xFTINJJxzMCT/7PMMOmkzNxFG0rN5M28YdKNfTgtwyaUgqtiRdlFIkEzatHUmOOfc4Djqh9LSqu0SnTqTl6Rf1M+95eGLS6URQ46ZidyapHDcSI2Sx5oqf4+xsym5qdVy8eAJlO1TNHbgHvOrQ2aiUTbJhPcp2iE4ax/jvXkTirddxOuysglTAdg06O8M4tomdFDqbHEzDwzS0Al+5YPojLQkBJogL4nl0vv4KiWXvEJs9p28WKQL6BBHBrK4nPG4mkXEzCI+aQnTakcRmHEtk/CyMHL1SodGzspO0v/h/xdGplYfbsoPYrA+WLVcpj/jSJ2lfcBeJd54huW4RyU3LSxvAujahkVP7Ym9k2S0/e2TEtSseuPUhXvz9owwXl7C/CSjuKTanPNpz1E5VQ6r45fM/w+ilfYrd2ETTg0/Q8uYyNr29XZsjpByMaJhQdQUHX/8VGr5zDcou9jNuDRvC9D/euEfcTue+Ubf89MfE31tJvMXEtX2VvxJs18B2s4shIoohdQl/pKWI1IHhCy2vcH3DNAlPmMSoH/xwoJoU0I948XYa7/5pjoLfV6R7ColUMPTc8v3csejfJBvezBNUyi2vA6445HRiU3vth6vsQ7XXbfvfubmRB255mK2dKUKIbxphMD4iHF9rcvoQg2NrDIZZ0NHSweN/fZZUogublm4Qqh/CiPPPoSUewbNdP24heIkUqcY21t75WFnxnNrexKLzfkDTgrd6VYeekDsNqDntDJLxkC+09EdE+7K3jOwPTClwnHQAUVP7Ew8LqtQtdF1S6xpIrlnVr+0IGBgkWolR5TspSL9oPQWmIJEwyrFRyiO5bgmtz86n5Zk/kmh4Ey8ZJ7lmYfe3FwGh4ZP6oQVZ9jrB9faLyzBMgxEhg1rLwBLBEo8KQ+sATRGGWMIR1Qb1orj7pnu59NSradq6+xtIvZRNfMtO3GQKN56kfUXxHkHluux8ZRnRKeOLlpnTQiC1ZScrr7mN1iUris4fCNz2Trb860VSHVBsE6aV+KbhaVfQkAmoIaEwVSd/BLO6pry5meOw/Vc/pXPxa/3XgIAeYW9fS8tTt9N4z3U0P3YLqU1d7ykVEcITZxev4rgKL95O55InaH/1Htpfuxd76yqcbWvoeONftL34Vx0fsZAy/siN2pFYtb12adMle53XuHAsTEiEetOi2TaIGB6jwr5hpYJ2V3AVxEyYEROeaE1hpxz+fN3f+eavvgRoBWLb2m14rkvtpFFFCkqlFGvueIS1dz6ulY0Kxn7s2LJzXglZjPvORaz+3nV4nXHcTh0Q0/UE2x+9eMkUG//8L2p+cWm/3Zs0bkcHjXf/g/aXXwGBRDKG3dhesLIDoB36GwLRsD+KVOhgG4aBVT+EIWefA2d9guZ7/0Hb44+Uidvo0PSX/yEyZTpmsG9xr8De3kDrs3/WoyClcLe10/bEfMy6UVTMOYnQuJkl1RepVW/mJ4hAyAClSKx6HUTlj6xcG6dpU/GkzY8vqTzlR/zRP77QmOlUH3VOXze3iL1OcNWEQozx0notIekJo8OKhAcbk3o3vQLEgahhAA6e6/HmM0sAaF61iRcuv53ETr0v0qqI8oFrPs/wOVlvjRvuf56Gvz6W9e0ObHjgeaKjh5HavDPPQt0Ihxj9kaMJjxzG9Nt/TuOjz7P21rtwEy5ejvU/QGLD1v68NYAeAW68+ifY27aB4+C5kGr3g8CWOSf392sKuI5JxcwpjL7ka4gI9rYteC2NJY25JKzf1OLZdL70DNWnnAmAl4ijEnGM2iH7TFi5wUTnokczQoukk+k7t3ETbc/dRWTqYVQd9bGi87zOluyXsIlEckWAU1ol4tqYw8bjtW7VZZrZrRZiaqNXZYaoO+USzH40Os1lr5oqeq7HY9f9E4OsQPDQI6zNSdPfjaePpQVbvaWFmWEIbtLm6a//ho6NO3ETKZx4isTOVp677FYSja2Zchr++mie0AKtz0o2tREZPRQzFsGIhDGiYSonj8F1Pd69+W4aF62k7sQP4HohPFVg/S9QMXVcP98h6Fj4Jk5jY2Zk5GUMeiVjz5VrXV9Kpnge1J12KuaQOlINq9h23VXE31iAiOsHDwVMMGKCGTXSMRGIL30TL97Bzj/8ii1Xfp2t136HrT/8BollA6/fe7/jtPgvSa9wuwM6YvSKV0v6wjKqfGcEhiAR7S01+6H028+wiOw3k4qDToYy+ylFKZzN3Y9S1Fv2qhHXjtVbSHUWGoQK21I6Ak4xwjDLokXgyI8cysYX3vYd5OXjuR4Nj7zOAeeeAECqqa0oD4DbmeCI+66ndclq2tduoWX5OrY9+TrNKzaA67H5kQUMPWoWo/7zFLb8I3/EZoTDjD3/zJ41fDdINaxFJRLZcs08E+pMQI5SBqkZlGLzr29lyIdPxNu0HJXyR2wCYoKEpWgUJYDX1szO22/GbliZ8cDqtbXSeNuN1J33VSoOObLvGhrQJUasBq99Z4731KIc2FtWY1YPzUutOOwjtD93NxLqYpRcuAdShMj42RixalIbl+I0bSg+x3PwUj3bdtcT9qoRV7gyWlLwtLhGWf2TYRiMnjiSz15+DomdrXglAhh4KYf49uwQuWrymJLXio0ZjhkKsX3pOhbefA+bH16AZzuZH4ebSLH9+cVIXR3jv3wO4ZH1GJEQVQdO5YBfXErltPG73+jdJDRyJJJjV2UYOlp1Fsk41hSjlItNjUrZtDz6JMk1a/IPdLHLyayqwV6/psjXulKKpr/cipfqO0d1AV0TmzUvu/2nBGIIRrjYMFqlEl36yBLDQqyIjrloRZBQlOpjztXRiQCndXvp/WEKrNqB25C/VwmuujH1KMsocnNcajQM2jD1sHOP42f3X0llTQXDD56CGFK0WdiKRRhx6LTM9/2/+h8YkfxONyIhpn/9E2x8+k2W3f5vzKJYehrlerz3679TMW0Cc/96PYf/+3fMuvm7VM/sufX+7lB55OFacOWMiMIVimh9yF/lURiGIhxxMTO+vnL/KkzTD59uGChVYtDtlhB3oTDRgw4tKQfF90aQWPRGb5sX0E2iE+dQcfApECuza0MMQmPz9wqm1i+j49V/gWOjSu+rA6Di8LMxItWQSqKU4DZtRikP5Tk6VJvj6eAeaaW8/7AZtT0Ld9YT9irBBTD9zCPwRPCUwlNKb3EA4koQ08BI67RCJhMOn8qpl5yZMUCNDa9FYjFcBBdwlF4RrJ0ymtFHZx2+DZkzjUNv+ib1hx1AuL6GuoOnMfeGr1E5bRxv3nCXb7Ffdp4Frseq3/6jf29EGYxIhLE/uZro9P19OyyT2IzpTL75WiZe9XXCYRfL8jICxjCV7z3C3wJk+p4kfBVd9MCDocjfloU1fDRYFhKOINEYtWedS8VRx+eFw0qjlEJ54La1Fh0L6D9i046i/uNXUHHMORCKaJfPVhipqKHm1C8hZv5LqXPxU9kYkZ6ClOs7LVD6B2FYRKYeTcdL/8Rr3eEr/jvpXPIUHYseo+35O/L731NaiHkeRs1IzH4OSZbLXqXjAjjtkjN475X3aNvSjJeyUZYJIYvPXvcZHrjmH6iWTgRFMp5i/XNLcX5xD6d/9TQqayp44uLfkWxNu3HRgsdVcMRVn8XwNzEnGltZe/9LNC9fj+1ZpEaMJDxiOB3NHTx36Y9RKUfrc7rYD2CgaHu3oV/vQ1eERo5kvx9eiZdIgEhmS46xegN5e37SSxlmrhhWGaW9SiYJjx+JVX0Y8YWvaX9ktkPskCMYct4XUYk4Xkc7Zv2wTLzFyIzZJJYuytnj6NuEiUFk/66j2xTitreSeOtlvNYmQhOnE9l/9i6j2wTkI4ZBbNphRCfPwdm+DrFCmEP3w23ZSmrjO5i1ozJ7F72CYBkq6eiRUzhEbOZRRKYeQccb/y42NHVtkiteRkIhiiIbAVgRqg//eH81sSR75ZYfO2mz6LFFrHp9JUP3G8oRZx/J3T+4gw2vaaVwo+vS4vlvC/RDOH7WOGbsaMYoiF1ohExmnHsCc75yOq2rN/H8RTrCtGc7+D74SIpgoTILaplzRfuEh6zRpoF2I23VVvGB+37R100vi1KK1kXLaXxpMUYswoiTjyI2Ljs0V57Hii9cgttcOOrxBYup7dUMv5FiQHSEYFaYhKfNQqLDaX/hZbx4nPDEiQz97GeJTi2O8+i5LtuuvRy3aZu+tgsYIaIHzaXuE+eiUknMYSN36WkgtW4FzXf8CqU8cGwkHMEcNpr6z38n8LjaC7xUnLYX78BtTXt/cAmN3p+qw/+DtmfvIrW22KGAhKLUn3s1Ypg0PXAjXkdT8YUtK/MMFBKdcTwVs07oj+aUXUHYKwVXIXYixQ+P/h4hTxFXHltsu6hQTykiBpxYW7xcO+5DB3Pcdf+P5758E01LG/KOKf/ZE/I9hOTkwBJFhelmYj0akTDjPnMqE847rddtU0oRX7mW1NYdxKaMJzJ6RMk87117O00L3tIrmaaBmCajTpxDhDihkcOJHnQgG3/2m6JgsaCV9LGhHuJHfhcTzDoDwzC0HVezg9ue7zFTwmFGX301kQkTiuvjOLS/+AzxBS/oqercw0m88yrOlg2IYSDhCLXnXED0gOwGeK+jnc7XXsDZtglr7EQ6X/o3qqNAyFohquZ9jMpjTu35DX2f0/bK37E3L8/fSG1YhMbMxGvchr2lIV9wmRbhibOJ7X841shJtD33F+xN7xVf2DT1iKtwNGaGqZx7GpGJc4vP6T1lBddeN1UsR1rYt7huaW+1QLPt0Oq41FjZ6YYZDTFizmQ8x6XpnbXF5wmYCrxis/PMlZUhWCEtsDzbZsTJRzD+3A/3uk1Oazurr7yJ5IbNWlHuuNQePZdxl36BlkXv0basgciIIVgVEZoWLMmaX7geyvXY/PCr1Ncm8JSJe/ejGf1VyZujwDAlGxGrQ0G1tnx224rvqLJtmu+/n5Hf+Ebx5SyL6uNPovr4k1BKsf3GH+Du3KY9pgIqlaT5jt8x7Js/who+GnvrJnb8+hqU44CdgtBL4NgYVSEkd9uIY5N46+VAcPUQ5drFQgvAc0itXwwJW2u1laE1BlYIhYe9aRn2pmWYFbXEDvuoHysxR0CJgVTWQbI4HKCIEN6vZwFDesOgEFyhaJjRM8ex/Z31ZQKr6sGCaRl0GgbVKm2TZBCurmDK6UdqAztDUG7p89PeEhT5HlgVipEfOoyDL/k4iU07iO03nFBtVZ+0a/0v/0i8YQPkmHA0v/wm28+/GrutEy+exIhG9ANfcisOJJImWhYJSil/OJ/fglBUgYd/PK2cApXy9NJ4od0OgFKk1hYL+kJSa1dib92GF0/500YwogaG4dDx8lPUnvkZmu+6HRXPsfHx3UF7CQezomBJ3wx0XD1FlXNlC/oHXhFGXA/itp5GiocoTzslNAS3cyftL99FeMJBONvXagU9AC6qfSeEwogYmXiQRqSSqqM/2e04kH3JoBBcAJ/++fn85szrqDIt4k7xLnUBqk2T+tpq2ps7EIGR08Zw8o1fJFQZpXNHK3EXIgWGmUqBgzYY14+8KnqGI8NqCNdVE66r7rP2uPEEbW+8TSKpsD2TmOlhGYpkp4vdltUxeIkkaSV7qTZ7nvhmDwrPFUxL5QRzBTOiMMNlhL0DRoyyk/3QmNL2brm0P/0YXlsqa//lgmd7UOngNu1E2Slt+1UKu7jg2CG7dmYXUBojFMWoGorXVuxhWABEUKYB0VD2Zan8lZq0HsRNkVq/RCvh05bMHr5NUhIVDhOdcjjRiYdgVA/bY9u99jpziHIMHTuMz/76iwwJmUREMiOv9HKuieLQWIRkc4efDjsatrHwT48DsPrJRbRjYSvdB2nbMBdwDBNrSE1Gx5X3MQ2GzSlWUveW+LYmVjZFWN0aY317jOUtlWzpDOO43e8SBYQtD9NSmJbSpg+WIlLtEa7yiNZ6RCr96aNR7FgOQxsqmlXFyj0Jhxly9tldlu+lksQM1uWfAAAgAElEQVTffL2k0arX4WHUDdNv9jKCUSmF53rZJXkMYocc293mB5Sg6tAzSY++8/D7V0T0htVsQlZopXFtPSr28vWeuApcF2f7Gsya4Xt0j+qgEVwAU445gEPOPpppNdWMDIXwlEfS82h3bKZEw0WNcRI27z7wCsm2OHYiheuqTCzHVldodIRG22BHAtZsjdOUMrJBOYC4J0TGjmD00X0b1LJt9UYWf+16xkYSjIymiJoOHrAjEcYrN7YyDCRk6T2UYQtEURWz9UxPsh83qe+CaaVXEP3NsIVja8PAqAgh0RjWsCiRSWOQqF7YCI0ezchvfYvI5K6Nat3GHWWn3gBtTzxG459vQSqrix6ktFcOUv5fV2GNnkjHiw8TX/QiXjJR8poBXWPVjyM8YS7pHRQAeRGXc9Ny/+biemVfNrguYu75Vd9BM1UE/bY47cpzOPjMI5j/7T+yfcN2oiZETZNq0yj5BjBCJu1bmhj/gZm8cftjuK6Ho8BR2sI+5Y+8DIE2TNpdg5Bo41VbhMrRY7oVyKI7eK7Hy9f/HXn6KSwUKzpixF0DD/0G8YBm26S+QvK9rQrEJo5hxrVfpfm1peApdsz/C6bnkfvLS4fT62wysaIeVkgRnjyJUd/4Cs1/vo3UhnWIIUiskvrPfZnQqNE42zdjDRuJWTfU9yfuId3UM5m1Q4q2/+ThuMSXLCS03wS8tuZ84ZV+Q6SN5hTYOzfgPL9W61Ke/CdDzruM0Iix3b6/AZqKmfNIrV+CUnaxwMrEoaP0MnpBPMYixCAy5fA+rvHuM6gEF2jhNfbgiWxt7cy7vx2eImIojIKOSrYn+ftVd/LJn3+OCfNms/zxRXiOi4XfdyittM+WgO0fEw9WP78Uz/UyBqw9xY6nWPKXJ9nyxCuMtRRbEyE6XSOjvdKPv2KrHWXc1BF0rtmIl7T1CCtkMf3KC4mOHMqojx7Hxr89hGMbGIYUv0hFj7SUY2BjUr3/LMIjRzPiOz/EbW5CpVKYw4Zn7KzM2iF593Z3lONGrILIATNJLl1aOoMArovX2pS1OdHNzB5PF2cIony9i51CAU1/u5nKoz9C9KCjMGM6Grfb1kLH84+TWrMCa+Roqo47NQhaW4ARq6H2pK/QtuDveG35rpaUUnrKZ/Zsmhfa7wDCY/d8EJVBYcdVistOvIJtm7Ix4SoMYXZFGDPnSfaUos2FJkf3U23E0mYVrpux26oyFUmv2BuCPh88ES5+6eeYodIPtHI9/dCVme83bdjBfVffxYbFaxhteQwP24yKJlnWVkHKKyUMFQeONzFb21FiUHPQVKZd/WVCNdmVzGXfvpHOJcuIRZ3yHiAAiYSZ/KtrCY8qtg3rKzw7xcZLvgyF/vgNfF9NIKEwZv0w3K2bcioHUmnpEaAhEDGz91AAy783ot3qVB5zBpH9D2Hbf10FqUTW/YVhMfRL3yYy9YB+a+NgJrVtNR0LH0B1NulFm/Snq0jLThlfLBW11J/9vQGodbbIcgcGlY4rlxM/fXxeqzo9xdLOFB2+stdViiYbWhw9rBQFbUmXeErvIBY/NmObKzg5/eYpRbujaLQVrY6iesKIkkKrZeVGnvvKL3lg3rd48MTLWPTzv+EUxGi0Eyn+cP6vWL9otR61AYm0sCq3ag3Q3IaBh6kcOt9dxcrrfo/TEc/kiYwaSqdrknSNvK1Jmd9fOIQ1pJZxP/hmvwotACMUZsj5F0DYyq5oWL7QyuZi2BcvgWgsxzOBgYr7K1bhAqFlCOIp/6OX+DteepDG+TdDMkdoKQWuTdPdfyhrJvN+JzxiMpWzTkUlgYTv6aQw7Hnu93R07EIMk9qTvzQgde4Og26qmObk8z/E8w+8wqZVW/B8PUubp1iX8IiZegexQXrBJNtJNmAoyAnihIfyp/aKJidvZZ9N63fy/J+e5Nj/dyKdO9tY/Ldn2PDSMsIbN2Xc3Xgph/WPvEbHhh0c8+uLM1d+54nF2IlUxjwhpRTiGiRcg7qQw/ZUqMDQQRExPEJG9iFUKZu2he/wzFmXM/as45l+0VlsSYRZ2RbDbI9iGYqY6TGqMkHNkAom/+w7SChEaNRwEstX0vrMC0QmTyQyvv90RZVHHIO9ZhUdzz+Zf8AAFESmH4g1YhSjrriB9uceJ9WwktDosXgdjaRWvKUNV8XQIy8piGSu8CWywuvYnl7X18d84eU17UB1diCVfWNfN9hxGjfR9uI/cZs3Z+5p5g3n6ntZWmHvLz+bvn2f67/kq4ZQe8IFmFVD2FsYtIIrFA7x439czksPvMKrj75JOBqi6e0N2I3tGcFTKLTSJBVEc4wxlQJPtHvowkGyk7R55tZHmTlvFvd/6bekOpJUeklCZn6/eymHpqUNtK7eTM1krXNp2rCTVGfa2aCi0lA4CGs6owwL20QNj6Rn5NV3YmXxlh2lQGyb9fe/QDzhsOLRhVj+A+wpocMxWNlcxWHnn0nru+tpf3cV3pLXUfF4RvldMXsmY759MbKLyNs9QUQY8qnPYQ4dTusDf/cttwWUIGaI2o9pH+RmbR21Z2T9kccXvoi9ZinK9RBLK4pLTn09BSHBqIrgtdn5O+BFW88G+xs1blsjzQ/dAjg5OsWC0ajrFesyRTAq6ohOPRq3sxkzWolEq7GGjO73wBc9YdAKLoBwJMS8cz7IvHN0IMu7vj2fpY8vzmy+3h1MPNwCH/KZYyGT5379L5JtcZTr6VlRiQdMLJP29dsygmvU9P0IV0RIdSapMrWezUJhK2FHKowoCBsKTwkppagKJYkYxfoFAVwlqGSKFQ++ivj6pMLR/sLfPsDkOo9qq5WQlb/9p/OtpTTe/xBDP5HvpdWzHTb/+T52PPQsXjxJ5YwpjP3auVRM3n031DUnn0Z4v3G0Pnw/buNOwlP2p+ajZxMaUdpPU+TAw+CB+XrVNmz4o4EuEDCqw3gt+cLdqKtHwoHgUp5H28v3Zyzh86LwFO6OsD0dJMP/kZhD9qP66E/2RRDXAWFQC65CjrvgJN57/h1UPJX1AloiX+5ITCmlzRFEERI9Gis8y3NcGt/dkAmAmVJCWKmi6Eye41I9KfuQ7n/sTGpH1dG4fgch5WQWBCIFu+wbPWEjYWKuySQrrndC+1mUgmTu6mPKRiheTUy3xUkkCNUV71lUKZuWx54uElwNN9xG66tLUCm9G6Fj6QpWXHYDM279MeGR+W5/u0N05kFEZx7UrbxihfQSqIWeIkqZpXjJLn4YUStfcIlQ9x+f3+167mt48TaaH/gdXru/YOXq6aDK1R/monwlfSxMeMwMqg//xMBWuJcMWuV8KcbMGMtnfn0hwyaOwLRMQiEzfxMvAIqoQdZJoYIWx2NdymVtyil6bgzTYNikkdQMz76JOtzsFDOTL2wx/JBpVI/PDqsNy+QL87/JIR8/GhWLlpSiVkWE0645j0vv+R7ffeZ6Zt9yJTWHHYgSHSSk0zXpdLPvl/qx9V3eg65WuZWdv1UqtXVnntBK49k22+59vMty+gIxDCIHzCFzY8qZnIR0ulIK5SokHIFQCEyL6lPPJjpjdunz3ic4OzbQfO/NWaGVRpG/QpieUBiiF0TCIUJDx1M1t/9jJfQ1g9YcYlek4imssMW2VVu49+o72fzuRrTOW5FCmw95gIOi0bZxgXA0zDEnzWXdC8u0FbrjMWr6GD510xfYsnAlT19zN47vocESRW1IC8FQZZTxZxzNjC+ejhku7QdcKcXTF/+WxqVrcX2fYUbIonrccE6Z/52MZ9c0OxcuZ+Hlt+KlbNJOx8xIiLk/v4hHLvodnlc4XVXEDJfRUZu66iSWWdAtpknNvGMY9dULMkmtbyxlzXW34uWsWKapPHAa+/9X/y99ex1t7Pzj9ahUS3ZvXHo0YGi7svTLRylF5ICjiUyYhZeIE5lyAGZNXb/XcW8mte4dWh+fn11pLYFE/RefIVkdp2FSceiZRCfMGZiK9oyyr+F9VnAVsmbBchb86SnatjUz9pApTDrmAKJ1Vbz92nssfvotaoZWc/J5JzDjqOnYSZttKzdTUVfJkP30dEkpxWu3PcKbf3kK07JwHZeRs8bzkf+6gEh192LJuSmH5Xc+xeoHF6Bcl/GnHMrM808hVFk65FPL8nWs/vMjtDdsoWb/sUw+78NUTx7D2vue59Ub/49kjh1HxIRRUQdTOVimR01VKrNwJJEwZlUl43/+Y6y67MgxuWUHy750VdGIC8tk2OnzGHfRp3fvJvcQ5Xm0PvY3ku+8nE0sM/oadtHPMcqEyHq/YTdtoeWfN+oN0YZRXnBFfFOVcAgxLSQUpWLuaUTG9u1Wtn4gEFx9RbItzs6Vm6gcXkvt2GF7rB7bFixl5V8epX1LE8PnTmXquSez6vo/kNi0HeW4GJZBRZVQf8hUKmbPovb4YzBixQ/86p/8jtbX384TXkYswgG3/JjIqIFtX9tTfyf+9stZv+hpyev7RB/yycsIjZ4woHXaW1GOzc6/XQtx30dWOcFliJ5q2y5m/URqTzkPiVZq9zR7P4Hgej+Qdu/cuWYT0bEjqDt05i73WXopm03z72Hnw8/jJZJUzpjM2K9+hoqp/R9qrRT25jUklr+O29aM19qEl+gkNHoilUd9BKt+71uW31Mk17xF23N3a4PcNKWEV9jUSvqER+URp1Ex+/iBrWjvCARXwK7JczQYsFcTX/oCHa8+BHaB3Z/4ZhCGAZY2jFNJDyNaw5BzLhts0+yyP8Z9yhwioHcEQmvwYI2YkBVQOR46lFLaRku5YAhGRS2xOUcTO/CDg01odUkguAICBiGh4eMIjZ6KvXml1gkqBYaJUVGDNXQ8ZqyK6MyjsOoHLkjrQBJMFQMCBinKc0ksW0Bi+SugPCJTDyE264OItc/sIgh0XAEBAYOOfc+tTUBAwPuXQHAFBAQMOgLBFRAQMOgIBFdAQMCgIxBcAQEBg46+sOMKrBYDAgIGlGDEFRAQMOgIBFdAQMCgIxBcAQEBg45AcAUEBAw6AsEVEBAw6AgEV0BAwKAjEFwBAQGDjkBwBQQEDDoCwRUQEDDoCARXQEDAoCMQXAEBAYOOQHAFBAQMOrrcZH3iIdPUztaObEI5J82l3D8XJakuzi/zZXfKK1NmWc/UpdK7fd3y5ZVt5u7Uo4uqdOUoW59TsOdddfm15PV0UvF1uvLRXfqYdL/bu7xOTroq3tPfo+uUvHbPr9Fleld91hfXL5PQdf7ioz0vN7+Te9ff2ZSW5M5HlVIfLnWtLgXXztZOnvqvL+s7r8j8zfipL0jXf3P+T9fDT1el8mbqmk1XhdcqKiunHmXKKr5WqevkXiP/OqqobTlpeWX5pxV+z+TJrQf5+Sn4nr58F3myfyXTnPw8km1KTr5M01VWmOTnL86XvSVScAslp8skp+mS3xU5gkvlXCNb5dy0/OOFZZX6XtSleXUpf528n1u6niXOK32d9P9dlbXr6xTnUyXuT+nzFapkWXR5HVVwLVWiziqvjPz2FhxX+Xnz+11l/1elysq/Tn5bs9//veqPZUOpB1PFgICAQUcguAICAgYdgeAKCAgYdASCKyAgYNARCK6AgIBBRyC4AgICBh2B4AoICBh0SMYmq9RBkUeAsrYUu8EwYEcfXGdvJ2jnvsP7oY2wd7dzRzkD1C4FV18hIq8rpQ7r94L2MEE79x3eD22EwdvOYKoYEBAw6AgEV0BAwKBjoATXbQNUzp4maOe+w/uhjTBI2zkgOq6AgICAviSYKgYEBAw6ui24RGSciPxTRFpEpFVE7hGR8d047zARuU1E3hWRThFZJyJ/FZFJJfI2iIgq8TlrdxvWE3raRv/cUvVWIjKnIJ8hIt/325oQkcUi8h/906Kyde1pX/6oi3YmCvLu6b4cKyK/EZGX/d+dEpGJ3Ty3230kIl/0f9tJEVkuIl/py3Z0o649aqeI7C8ivxKRt0SkXUQ2i8gDInJwibzPlOnLS/qjTd2hS39caUSkAngKSAKfQ7vLuRZ4WkRmK6U6ujj9U8As4NfAUmA/4CrgdRGZo5RaX5D/UeBHBWnLu1PP3tDLNqaZD/xPQdp7Bd+vAb4NXAG8gb4//xCRjyqlHup5C7pHL9t5O/BIQVqln/ZAifx7pC99pgL/ib7HzwOn7Ma53eojEfkiur9/BjwBnAj8t4iIUuqWPmnFrulpO08BPgT8L7AQqAO+CywQkQ8qpd4oyP8W8OWCtIYe1rn3KKV2+QG+CbjA1Jy0SYADXLqLc4eXSJsAeMBPCtIbgDu6U6e+/vSmjX5eBVy7izwj0ALjxwXpTwJvDYZ2lrjeeX7bT99b+tIv38j5/0K/jhO7cV63+gj90t8G/G9Bvj+iDTpDe3k7h+HruHPSaoEm4M8F6c8AL+ypviz16e5U8UxggVJqZTpBKbUGeBH4WFcnKqW2l0hbC2xHj772Fnrcxt3gVCAM3FGQfgdwUKnpcz/Q1+38HLAVPbraa1BKeT08tbt9dDQwvES+vwBDgQ/2sPzdoqftVErtUL5UyklrQc8Q9qbnsiTdFVyzgLdLpC8FZu5uoSIyA/1mW1bi8Bn+XD0pIgsGSidC37TxIr/enSLylIgcW6KMJLCyIH2p/3e372UP6LO+FJFx6OnGX5VSTokse6ove0N3+2iW/7fwXg5kX/YpIlIPHEjp53KurxO1fb3YBQNcvTy6K7jq0UPIQhqBIbtToIhYwK3oEdcfCg7/C7gY/db7DJAA7hWRz+5OGT2kt228A/gqcBLwJfRb9ykRmVdQRnPhm84vI328v+mzvgQ+i/4N/W+JY3uyL3tDd/so/bfwXg5kX/Y1v0FHSbm5IP054BL0aP0TwArgdhG5cmCrl6Vbyvk+5rfAB9A6kbxOV0pdnPtdRO4FFqCVn4VD8r0KpdR5OV+fF5H70W/jaxmgacMe4HzgTaXUW4UHBnNfvh8Rke8D5wIX5KoRAJRSVxdkv9/vzytE5GalVPtA1TNNd0dcTZR+G5d7e5dERK5Hj0a+oJR6bFf5lVIu8A9grIiM7m45PaRP2phGKdUG/Bs4vKCMOhEpjLGVfjs30v/0VV8eARxA6dFWEQPcl72hu32UvleF93Ig+7JP8E04rgOuVEr9sZun/Q2IAgf1W8W6oLuCaynZOX0uM4F3unMBEbkC+B7wDaXUX7pZbi79beLf6zaWIbfeS4EIMKVEGfSynO7SV+38HGADd/agDnvzdo3u9lFal1V4LweyL3uNiJwH/Ddwo1Lqpz24xJ7py24uuV6CXi6fnJM2Ef3Dvawb53/Db+APdnOp10Lbp6zt7+XV3raxxPVqgHXAczlpI4AU8MOCvE8AS/q7jX3VTvSq207g/r2xL0uUvbvmELvsIyCE1tP+qSDf7f69Ce/N7fTzn+3/Fm7rQVn3A51A5UC3UynVbcFViV5lWYJeMj8TWAysBqpy8k3wb8TVOWmfQttsPQwcVfCZmZPv08BdaL3Jh/zznvc74lMD0Om9aeO3gd+jdQTz0KORJf4DcGxBOdejFdWX+nlv8e/PRwfox93jduYc+7jfLx8vU8Ye7cucenzC/9zil32R//34nDwO8Iee9BHwFT/9Wj/fT/zvXxuoNva0ncBxfhvfQOucc5/LuTn5jkWrPC5AG9h+HC20FPC9gWxnXpt34+aMB/4PaAXagPsokOzoN7cCfpSTNp/CQLzZzzM5+Y5CW3RvRb/9m9FvuVMH8AfQ0zaegbaD2uHXfSfakvyIEmWYwJXAWvSy+1vAJwb4h96jduYcu58uRhV7Q1/69ejO704B83vaR2hr8vf8fCuArw5kG3vaTvSOhnLnNeTkm4oedGz029gOvAR8eqDbmfsJvEMEBAQMOgLvEAEBAYOOQHAFBAQMOgLBFRAQMOgIBFdAQMCgIxBcAQEBg45AcAUEBAw6AsEVEBAw6AgEV0BAwKAjEFwBAQGDjkBwBQQEDDoCwRUQEDDoCARXQEDAoON9I7hE5Pd+EMtfljmeDnY6IO6sRWSeX968Hpx7lohc2od1KRfws/Azsa/K7C0iMtGv04U9PP8SEfl4H9epMGBus4i8KiKf6ctyCspsEJH3nSvsPeFzfsARkRg6aCbAuSLyHVU6Ks1g4Sx0UI6b+uh6X0U7PkxzFdrl9JkF+Tb3UXl7A5cALwD39MO1P4iOXVkPfBG4Q0QiqvtukQN2wftCcKEf9BrgIeA04MPAg3u0RnsRSqk8N8Mish1IKaUWdHWe/zAm+7Vyg5NX0i9GEXkMHe7rEnSw2IA+4P0yVfwcOrjB54G4/70cM0TkaT8e4GYR+YmIZO6TiFSJyG9EZJ0fL3CbiDwhIgfk5KkRkd+KyCY/z3IR+VaJAAx5+MP++SXSlYj8yP9/vl///XKmJA05eYeLyK0istEv+10R+dKub1HX+NPJF0TkDBF5U0SS6JEaInKEfw/aRaRDRJ70g2kUnv9Md9osIif5ZSREZKWIXCgi83PbmYPp99Fmf2r2LxEZu4u2NKA9vH4m5x7Ozzn+YRF5WUTiomMJ3ici07t1owrwBdibaId86esf79+jNv9+PSoiBxbU8RQRechvV6eIvC0il4mIuYu2mSJym4i0ishJPanzYGCfH3GJyBj0tOr3SqntInIf8HERGaIKwqP53Id+M/4MHRPwKrQ73h/5x3+JnkL9AO3xcihwDFDnl2egXd0eAlyNdpF8OnpaN9w/rzdc418ndyqX9MuuQU9/Yn591/htuMUfHf2ml2XvD/zar8NqoFFEZgPPooNDfB7tQfNy4FkROUoptXh3ChCRmej79yra5XMY3Qe16H4o5Ptoj5xfQPuLvxEd/mxeF8WcjR59Lybbr9v98j/sl/8U8EmgCu2S+QURmaOU2rg77fGZhPYCi4icjvYg+290XErQQWSeF5HZSqn1ftpk4El0rMMEcJhf1+Ho+1uErxL5GzrK9jyl1MIe1HVwsCfdrw6QW9vvoh+mo/3vp/rfv1KQ70d++uUF6b9Huzeu87+/DdzURXkf9a/z+YL029ECZpj/fZ6fb15OngYK3AirrNvdH+V8nw9sKJHvKvSPfFqJNuwArG7es6LrA8+gBcecgvR/oh/Kupy0GnR4rnsKzn+mRFl5bUZHDdoOVOSkjfbb1ZCTNpEC98R++rf99DG7aGMDcEeJ9NfRLyQrJ20S2gV12X4v+A1F0IOCEcAP/bSb/TwrgScLzqvx++fmMtcV/3pXoGcORmE70GHSXgBWAVP29HPX35/3w1Txc8AKpdTL/vcngE2Uny7+veD7Xei3bnoo/xrweRH5gYgcVmLofhz6AS8M23UHevRw9O43odt8GHgFWCMiVvoDPIoeGfY2LHyDUmpRQdpxwINKqeZ0glKqFe1z//gelHEU8JBSqjPnepvRo6pSPFTwfYn/d/zuFiwileiR8t0qZ/FGKbUGHVOgu+1JoAXdVvQI+2bgchGZhg579teC/ukEXkbfy3RdRovI/4jIWnTQFRsdlKMOLRBzGYMWWhXAB5RSq3av5YOPfXqqKCKHoR/WG0SkLufQPcDXRWR/pdR7BadtLfN9P//vxcAW9NTkp+jp0p+BK/yHrR5oVEqlCq6zxf/bn6HZR6B1KXaZ40N7ef1Sq4r1ZdK3UDrw7K4YDWwrkb4VPX0qpDDwanqxINqDsoegRzfl2jOhm9c5Cr2q2ASsU0rZACKSFjh/8D+FrPPzGWjBPwY9insXrZs9Cz3qKmzbbHTfXq6UKvz97pPs04KL7Kjqe/6nkPPR0VxyGYnW3+R+Bx3lBKXDjX8f+L6ITECHgboe/Vb8HvpBqheRcIHwGuX/7SrCcQI9KssgIrsjbHaiH/pvljm+fDeuVYpSkVUaybYtl1HkR8ZOkG9ykaZQkG+meEQB2X7oT5rQbSzXnu5Gp35DlTa32en//T565F9I+vcyBa3TOk8plbHREpEzypT3CFpfd4OIJJRSv+pmPQct++xUUUTC6Ph+r6Bj+xV+FgHnlVjp+8+C759Ch2RaUpCOUmqtUupG/1h6Kvks+r6eU5D9M+gf5suUZ23OddKcXiJfEq2AL+QR4AD0W/71Ep+2LsruKc8Cp4lIdTrB//8MtF4rzVpgf79f0vmOA6rJZ4F/vYqcfKPRCyB9SdE9VEp1oOMMnpOrAvBfUB8gvz09YTlaJzWrTP+85edLtz0zchaREPo3VBKl1C/Q+r2bReRbvaznXs++POI6HT18vkwp9UzhQRH5H3QAzXnA0zmHvugP1V9DK/IvRCvGW/zzXkYP45egBdrxwMHA//rnP4zWN9wqIsPRodpP86/zM6XUji7qfBfwR9HW/Q/61/18iXzvoEd1F6GVyQml1BL0iucn0StUv0Q/KJVoYXasUupjXZTdU65BL0g8KSI34AcKRT98Pylo25fQ7ZuPVnhfCrQUXO9a9Cj2URH5L7Si+yr0VLHUqmJPeQc4VkQ+ip4G7lBKNfhl/Rt4UET+G63f/LFfzxt7U6BSSonI14D7fQH+d7RSfiRaMK5TSt2EtvtaC/xURFy0ANulMFJK3eTn/6WIGP5Ldd9kT68O9NcHbdbQSs7qVMHxWrRSdL7KXxE6EC3I4ugf9DXkr+LcgLbLaQE60ALsGwXXrgF+i572pNABQ78FOo6ln2cexauKBtqEYq1ft0fR04bCVcVK9LJ3emrTkHNsCFqArfHL3oaOIn3Jbty7+ZReVXyhTP4j0VOfdv+ePEnpYLhfRq/YxdHK9kMpsZIKnIweESfR0/YvA/cCb+bkmei3/cKCc4vua5k6H+Dfl06Kg6V+GD0yjvv9fD8wvRv3Lf0b6nL1Fr1A86Dffwn/HtyFv/Lt55mDfgF2AhvQL4EL/etPzMnXQMHqKPA1tJD/7p5+DvvrEwSEDdjrEZEqtBnBv5VSF+zp+gTsefblqWLAIEVEfoMekW1Cr6x9Ez2S3OeVzgHdIxBcAXsjUfSUfCR6uvsqcJLKKq8D3ucEU8WAgIBBx9ltHRgAAAAzSURBVD5rDhEQELDvEgiugICAQUcguAICAgYdgeAKCAgYdASCKyAgYNARCK6AgIBBx/8HS6vidwqckyoAAAAASUVORK5CYII=\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "def feature_scatter(feature_name,cmap='mako',save=False):\n",
+ " cmap = sns.color_palette(cmap, as_cmap=True)\n",
+ "\n",
+ " fig, ax = plt.subplots()\n",
+ " fig.set_size_inches(5, 4)\n",
+ " scat = ax.scatter(data_classified_df['x'],data_classified_df['y'],c=data_classified_df[feature_name],cmap=cmap)\n",
+ " cax = fig.add_axes([0.1, 0.05, 0.8, 0.03])\n",
+ " cbar = fig.colorbar(scat, cax=cax, orientation='horizontal')\n",
+ " \n",
+ " \n",
+ " if feature_name == 'trough_to_peak_abs':\n",
+ " feature_label = 'Absolute Trough to Peak'\n",
+ " \n",
+ " elif feature_name == 'trough_fwhm_abs':\n",
+ " feature_label = 'Absolute Trough FWHM'\n",
+ " \n",
+ " elif feature_name == 'peak_ratio':\n",
+ " feature_label = 'Peak Ratio'\n",
+ " \n",
+ " cbar.set_label(feature_label,labelpad=10,fontsize=16)\n",
+ " cbar.ax.tick_params(labelsize=16)\n",
+ " ax.spines['left'].set_visible(False)\n",
+ " ax.spines['right'].set_visible(False)\n",
+ " ax.spines['bottom'].set_visible(False)\n",
+ " ax.spines['top'].set_visible(False)\n",
+ " ax.set_xticks([]);\n",
+ " ax.set_yticks([]);\n",
+ " \n",
+ " if save:\n",
+ " plt.savefig('Feature_'+feature_name+'.pdf',format='pdf') \n",
+ " \n",
+ " return None\n",
+ "\n",
+ "feature_scatter('trough_fwhm_abs',cmap='crest',save=True)\n",
+ "feature_scatter('trough_to_peak_abs',cmap='flare',save=True)\n",
+ "feature_scatter('peak_ratio',cmap=\"ch:start=.2,rot=.5\",save=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Yem2TivfEdGZ"
+ },
+ "source": [
+ "# Figure S5: Effect of normalizations on WaveMAP structure"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "MK57BCasEhqx"
+ },
+ "source": [
+ "## Figure S5A: Number of clusters across random seed and subsets with -1 to +1 normalization"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "oz3MNtcYwTR0"
+ },
+ "source": [
+ "### We show the waveforms after a -1 to +1 normalization (this is used in the paper)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 274
+ },
+ "id": "24xDxxg0PpaW",
+ "outputId": "ea47edc7-9e5a-4ee8-b152-52ad2cbc9f9f"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[94mPlotting: 625 Waveforms\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "f, arr = plt.subplots(1,figsize=[4.5,3.4])\n",
+ "\n",
+ "print(BlueCol + \"Plotting: \" + str(full_data.shape[0]) + \" Waveforms\")\n",
+ "for i in range(0,full_data.shape[0]):\n",
+ " arr.plot(full_data[i].T, c = 'k', alpha = 0.03,linewidth=2.);\n",
+ " \n",
+ "arr.tick_params(direction='out',colors='k', axis='both')\n",
+ " \n",
+ "# Set various x and y axes and labels etc.\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "\n",
+ "arr.spines['left'].set_bounds(-1,1)\n",
+ "arr.spines['bottom'].set_bounds(0,48)\n",
+ "\n",
+ "arr.set_xlabel('Time (ms)', fontsize=24);\n",
+ "arr.set_xticks([0,14,28,42,48])\n",
+ "arr.set_xticklabels(['0','0.5','1.0','1.5',''],fontsize=24)\n",
+ "\n",
+ "arr.set_ylabel('Amplitude (a.u.)', fontsize=24)\n",
+ "arr.set_yticks([-1.0,0.0,1.0]);\n",
+ "arr.set_yticklabels([-1.0,0.0,1.0], fontsize=24);\n",
+ "\n",
+ "# Plot the data\n",
+ "arr.set_title('-1 to +1 Normalization',fontsize=24)\n",
+ "plt.tight_layout()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "dmfqQmaowa-O"
+ },
+ "source": [
+ "## Figure S5A: Cluster number vs. data subset proportion"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "tsLGUduJwjIg"
+ },
+ "source": [
+ "### Just as in Figure S2B, we show the number of clusters vs. data subset proportion"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 189
+ },
+ "id": "ediq-GkSEsnN",
+ "outputId": "96c6cd71-fe3b-43df-8016-cf29bcd658e6"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "if 'subset_avg_rand_list' not in list(locals().keys()):\n",
+ " subset_avg_rand_list = pkl.load(open('WaveMAP_Paper/data/subset_avg_rand_list.pkl','rb'))\n",
+ "\n",
+ "if 'subset_std_rand_list' not in list(locals().keys()):\n",
+ " subset_std_rand_list = pkl.load(open('WaveMAP_Paper/data/subset_std_rand_list.pkl','rb'))\n",
+ "\n",
+ "f, arr = plt.subplots(1,figsize=[3,2.5])\n",
+ "arr.errorbar(np.array(subsets,dtype=np.float),subset_avg_rand_list,yerr=subset_std_rand_list,c = 'k', marker='o', fillstyle='full', markerfacecolor='w', linewidth=1, markeredgewidth=1)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.set_xlabel('% of Full Dataset', fontsize=12,fontname=\"Arial\")\n",
+ "arr.set_xticks([0.1,0.2,0.4,0.6,0.8,1.0])\n",
+ "arr.set_xticklabels(['','20','40','60','80','100'],fontsize=12,fontname=\"Arial\")\n",
+ "arr.set_ylabel('# of Louvain \\nCommunities', fontsize=12,fontname=\"Arial\")\n",
+ "arr.set_yticks([0,2,4,6,8,10])\n",
+ "arr.set_yticklabels([0,2,4,6,8,10],fontsize=12,fontname=\"Arial\")\n",
+ "arr.spines['left'].set_bounds(0,10)\n",
+ "arr.spines['bottom'].set_bounds(0.1,1)\n",
+ "arr.axhline(np.max(subset_avg_rand_list),color='k',linestyle='dashed')\n",
+ "plt.tight_layout()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ZCP0LifbFebf"
+ },
+ "source": [
+ "## Figure S5B: WaveMAP plot with -1 to +1 normalized average waveforms"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "4fN3gPPKws1w"
+ },
+ "source": [
+ "### and next show the WaveMAP clustering and projection of this normalization (same as in paper)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 355
+ },
+ "id": "77d8DuFUFhwD",
+ "outputId": "a9cb45ef-ff3d-41ae-f2ed-3787f3c120cd"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "reducer = umap.UMAP(n_neighbors = N_NEIGHBORS, min_dist=MIN_DIST, \n",
+ " random_state=RAND_STATE)\n",
+ "mapper = reducer.fit(full_data)\n",
+ "embedding = reducer.transform(full_data)\n",
+ "\n",
+ "umap_df = pd.DataFrame(embedding, columns=('x', 'y'))\n",
+ "\n",
+ "f,arr = plt.subplots(1,figsize=[7,4.5],tight_layout = {'pad': 0});\n",
+ "f.tight_layout()\n",
+ "\n",
+ "arr.scatter(umap_df['x'].tolist(), umap_df['y'].tolist(), \n",
+ " marker='o', c=cluster_colors, s=32, edgecolor='w',\n",
+ " linewidth=0.5)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['bottom'].set_visible(False)\n",
+ "arr.spines['left'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.set_xticks([]);\n",
+ "arr.set_yticks([]);"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "zXpz0x46J9kz"
+ },
+ "source": [
+ "## Figure S5C: Number of clusters across random seed and subsets with trough normalization"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "kyTA8ffqwycs"
+ },
+ "source": [
+ "### We compare the -1 to +1 normalization by using the other commonly used trough normalization (entire waveform aligned and mean-centered and divided by the negative amplitude of the trough). Here we show all the waveforms and note that the heights of the waveforms no longer \"cap\" at +1."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 274
+ },
+ "id": "UoK6IB1AN43b",
+ "outputId": "e20ad9e9-2ab5-4e84-8240-11e6a54135b1"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\u001b[94mPlotting: 625 Waveforms\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "trough_normalizedWaveforms = np.load('WaveMAP_Paper/data/trough_normalizedWaveforms.npy')\n",
+ "\n",
+ "f, arr = plt.subplots(1,figsize=[4.5,3.4])\n",
+ "\n",
+ "print(BlueCol + \"Plotting: \" + str(trough_normalizedWaveforms.shape[0]) + \" Waveforms\")\n",
+ "for i in range(0,trough_normalizedWaveforms.shape[0]):\n",
+ " arr.plot(trough_normalizedWaveforms[i].T, c = 'k', alpha = 0.03,linewidth=2.);\n",
+ " \n",
+ "arr.tick_params(direction='out',colors='k', axis='both')\n",
+ " \n",
+ "# Set various x and y axes and labels etc.\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "\n",
+ "arr.spines['left'].set_bounds(-1,1)\n",
+ "arr.spines['bottom'].set_bounds(0,48)\n",
+ "\n",
+ "arr.set_xlabel('Time (ms)', fontsize=24);\n",
+ "arr.set_xticks([0,14,28,42,48])\n",
+ "arr.set_xticklabels(['0','0.5','1.0','1.5',''],fontsize=24)\n",
+ "\n",
+ "arr.set_ylabel('Amplitude (a.u.)', fontsize=24)\n",
+ "arr.set_yticks([-1.0,0.0,1.0]);\n",
+ "arr.set_yticklabels([-1.0,0.0,1.0], fontsize=24);\n",
+ "arr.set_title('Trough Normalization',fontsize=24)\n",
+ "# Plot the data\n",
+ "plt.tight_layout()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "OHmSivAgKDwM"
+ },
+ "source": [
+ "## Figure S5C: Cluster number vs. data subset proportion on trough normalized waveforms\n",
+ "\n",
+ "---\n",
+ "\n",
+ "**THIS CELL CAN TAKE 40 MIN**; skip it and run the next cell to read cached values of the plot."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "yVu2sdyfKQ4Q",
+ "outputId": "df7cf806-18c0-426b-ec31-1657519332d9"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0.1\n",
+ "0.2\n",
+ "0.3\n",
+ "0.4\n",
+ "0.5\n",
+ "0.6\n",
+ "0.7\n",
+ "0.8\n",
+ "0.9\n",
+ "1.0\n"
+ ]
+ }
+ ],
+ "source": [
+ "subsets = [0.1,0.2,0.3,0.4,\n",
+ " 0.5,0.6,0.7,0.8,\n",
+ " 0.9,1.0]\n",
+ "\n",
+ "renorm_clust_rand_dict = {}\n",
+ "for frac in subsets:\n",
+ " print(frac)\n",
+ " rand_list = []\n",
+ " for i in list(range(1,100)):\n",
+ " reducer_rand_test = umap.UMAP(n_neighbors = N_NEIGHBORS, \n",
+ " min_dist=MIN_DIST, \n",
+ " random_state=random.randint(1,100000))\n",
+ " rand_data = np.random.permutation(trough_normalizedWaveforms)[0:(int(len(full_data)*frac)),:]\n",
+ " mapper = reducer_rand_test.fit(rand_data)\n",
+ " embedding_rand_test = reducer_rand_test.transform(rand_data)\n",
+ "\n",
+ " umap_df_rand_test = pd.DataFrame(embedding_rand_test, columns=('x', 'y'))\n",
+ " G = nx.from_scipy_sparse_matrix(mapper.graph_)\n",
+ " clustering = cylouvain.best_partition(G, resolution = RESOLUTION)\n",
+ " clustering_solution = list(clustering.values())\n",
+ " rand_list.append(len(set(clustering_solution)))\n",
+ "\n",
+ " renorm_clust_rand_dict.update({str(frac): rand_list})\n",
+ "\n",
+ "renorm_subset_avg_rand_list = []\n",
+ "renorm_subset_std_rand_list = []\n",
+ "\n",
+ "for k,v in renorm_clust_rand_dict.items():\n",
+ " renorm_subset_avg_rand_list.append(np.average(v))\n",
+ " renorm_subset_std_rand_list.append(np.std(v))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 189
+ },
+ "id": "GGRMNgd6Yutg",
+ "outputId": "9b7ff898-84a8-4b99-a9bd-b3d8360260ac"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "subsets = [0.1,0.2,0.3,0.4,\n",
+ " 0.5,0.6,0.7,0.8,\n",
+ " 0.9,1.0]\n",
+ "\n",
+ "if 'renorm_subset_avg_rand_list' not in list(locals().keys()):\n",
+ " renorm_subset_avg_rand_list = pkl.load(open('WaveMAP_Paper/data/renorm_subset_avg_rand_list.pkl','rb'))\n",
+ "\n",
+ "if 'renorm_subset_std_rand_list' not in list(locals().keys()):\n",
+ " renorm_subset_std_rand_list = pkl.load(open('WaveMAP_Paper/data/renorm_subset_std_rand_list.pkl','rb'))\n",
+ "\n",
+ "f, arr = plt.subplots(1,figsize=[3,2.5])\n",
+ "arr.errorbar(np.array(subsets,dtype=np.float),renorm_subset_avg_rand_list,yerr=renorm_subset_std_rand_list,c = 'k', marker='o', fillstyle='full', markerfacecolor='w', linewidth=1, markeredgewidth=1)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.set_xlabel('% of Full Dataset', fontsize=12,fontname=\"Arial\")\n",
+ "arr.set_xticks([0.1,0.2,0.4,0.6,0.8,1.0])\n",
+ "arr.set_xticklabels(['','20','40','60','80','100'],fontsize=12,fontname=\"Arial\")\n",
+ "arr.set_ylabel('# of Louvain \\nCommunities', fontsize=12,fontname=\"Arial\")\n",
+ "arr.set_yticks([0,2,4,6,8,10])\n",
+ "arr.set_yticklabels([0,2,4,6,8,10],fontsize=12,fontname=\"Arial\")\n",
+ "arr.spines['left'].set_bounds(0,10)\n",
+ "arr.spines['bottom'].set_bounds(0.1,1)\n",
+ "arr.axhline(np.max(renorm_subset_avg_rand_list),color='k',linestyle='dashed')\n",
+ "plt.tight_layout()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "J2yCZEenyhf3"
+ },
+ "source": [
+ "## Figure S5D: WaveMAP plot with trough normalization\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "VJHReVG8yj90"
+ },
+ "source": [
+ "### We next apply WaveMAP to waveforms with the trough normalization. Note the similarities between the two types or normalization."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 355
+ },
+ "id": "_UCnKNbffXkT",
+ "outputId": "8fb7cfdb-a5fa-407e-cb39-cc00c3ba5d59"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "reducer = umap.UMAP(n_neighbors = N_NEIGHBORS, min_dist=MIN_DIST, \n",
+ " random_state=RAND_STATE)\n",
+ "mapper = reducer.fit(trough_normalizedWaveforms)\n",
+ "embedding = reducer.transform(trough_normalizedWaveforms)\n",
+ "\n",
+ "umap_df = pd.DataFrame(embedding, columns=('x', 'y'))\n",
+ "\n",
+ "f,arr = plt.subplots(1,figsize=[7,4.5],tight_layout = {'pad': 0});\n",
+ "f.tight_layout()\n",
+ "\n",
+ "arr.scatter(umap_df['x'].tolist(), umap_df['y'].tolist(), \n",
+ " marker='o', c=cluster_colors, s=32, edgecolor='w',\n",
+ " linewidth=0.5)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.spines['bottom'].set_visible(False)\n",
+ "arr.spines['left'].set_visible(False)\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.set_xticks([]);\n",
+ "arr.set_yticks([]);"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rjqcjprTwl_x"
+ },
+ "source": [
+ "# Figure S6: GMM Clusters lack the physiological and functional diversity of WaveMAP classes"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "13v0A7WEwoUb"
+ },
+ "source": [
+ "## Figure S6A: FR traces for GMM clusters"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "r-5MWzIPwsui"
+ },
+ "source": [
+ "### As in Figure 5A,B, we plot the stim-aligned trial-averaged FR traces but this time for GMM clusters"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 369
+ },
+ "id": "tIG6qHgVi_8i",
+ "outputId": "aa9b7f7c-aba6-4c59-e74d-a40c2f41db71"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "f, arr = plt.subplots(4,figsize=[2,5])\n",
+ "\n",
+ "time = np.arange(-0.1,0.5,0.001)\n",
+ "\n",
+ "for i,ix in enumerate([0,1,2,3]):\n",
+ " PREF = GMM_traces_df.iloc[ix]['PREF']\n",
+ " NONPREF = GMM_traces_df.iloc[ix]['NONPREF']\n",
+ " PREF_UPPER = GMM_traces_df.iloc[ix]['PREF_UPPER_BOUND']\n",
+ " PREF_LOWER = GMM_traces_df.iloc[ix]['PREF_LOWER_BOUND']\n",
+ " NONPREF_UPPER = GMM_traces_df.iloc[ix]['NONPREF_UPPER_BOUND']\n",
+ " NONPREF_LOWER = GMM_traces_df.iloc[ix]['NONPREF_LOWER_BOUND']\n",
+ " arr[i].plot(time,PREF,color=GMM_PAL[ix])\n",
+ " arr[i].plot(time,NONPREF,'--',color=GMM_PAL[ix])\n",
+ " arr[i].fill_between(time,PREF_UPPER,PREF_LOWER,\n",
+ " color='gray',alpha=0.2)\n",
+ " arr[i].fill_between(time,NONPREF_UPPER,NONPREF_LOWER,\n",
+ " color='gray',alpha=0.2)\n",
+ " arr[i].set_ylim(5,30)\n",
+ " arr[i].set_xticks([-0.1,0.1,0.3,0.5])\n",
+ " arr[i].set_xlim(-0.1,0.5)\n",
+ " arr[i].set_yticks([5,30])\n",
+ " arr[i].spines['left'].set_position(('axes', -0.05))\n",
+ " arr[i].spines['top'].set_visible(False)\n",
+ " arr[i].spines['right'].set_visible(False)\n",
+ " arr[i].axvline(0,ymin=0.,ymax=30,linestyle='dashed',color='k')\n",
+ " f.tight_layout()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 191
+ },
+ "id": "icazrrtefKj9",
+ "outputId": "4ca4c369-6367-4cb6-f7fd-a380b7680a73"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
}
+ ],
+ "source": [
+ "f, arr = plt.subplots(1)\n",
+ "f.set_size_inches(3,2.5)\n",
+ "\n",
+ "for i,clust_ix in enumerate([1,2,3,4]):\n",
+ " start_ix = 0 \n",
+ " \n",
+ " median, med_se = bootstrap_median(get_baseline_FR(baseline_FR_df,clust_ix,UMAP_clusts=False))\n",
+ " \n",
+ " arr.bar(start_ix+i, median, \n",
+ " color=GMM_PAL[clust_ix-1],\n",
+ " yerr=med_se)\n",
+ " \n",
+ "arr.set_ylabel('Baseline FR (spikes/s)')\n",
+ "arr.set_xticks([1.5]);\n",
+ "arr.set_xticklabels(['GMM Clusters'],fontsize=12,fontname='Arial')\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.set_ylim(0,15);"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 403
+ },
+ "id": "NNLI4S6jta6H",
+ "outputId": "cce4be8e-6893-48e4-ef09-2d6589b71a1d"
+ },
+ "outputs": [
+ {
+ "ename": "NameError",
+ "evalue": "ignored",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mNameError\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 5\u001b[0m \u001b[0mstart_ix\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mmedian\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmed_se\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbootstrap_median\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mget_max_FR\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmax_FR_df\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mclust_ix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mUMAP_clusts\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m arr.bar(start_ix+i, median, \n",
+ "\u001b[0;31mNameError\u001b[0m: name 'get_max_FR' is not defined"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "f, arr = plt.subplots(1)\n",
+ "f.set_size_inches(3,2.5)\n",
+ "\n",
+ "for i,clust_ix in enumerate([1,2,3,4]):\n",
+ " start_ix = 0 \n",
+ " \n",
+ " median, med_se = bootstrap_median(get_max_FR(max_FR_df,clust_ix,UMAP_clusts=False))\n",
+ " \n",
+ " arr.bar(start_ix+i, median, \n",
+ " color=GMM_PAL[clust_ix-1],\n",
+ " yerr=med_se)\n",
+ " \n",
+ "arr.set_ylabel('Max FR (spikes/s)')\n",
+ "arr.set_xticks([1.5]);\n",
+ "arr.set_xticklabels(['GMM Clusters'],fontsize=12,fontname='Arial')\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.set_ylim(0,40);"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 403
+ },
+ "id": "fxNTfdaNwZFz",
+ "outputId": "fc9edbe0-235d-4007-e3fc-06338c19a3f2"
+ },
+ "outputs": [
+ {
+ "ename": "NameError",
+ "evalue": "ignored",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mNameError\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 6\u001b[0m \u001b[0mstart_ix\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mmedian\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmed_se\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbootstrap_median\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mget_dynamic_range\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclust_ix\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_FR_df\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mbaseline_FR_df\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mUMAP_clusts\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m arr.bar(start_ix+i, median, \n",
+ "\u001b[0;31mNameError\u001b[0m: name 'get_dynamic_range' is not defined"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light",
+ "tags": []
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "f, arr = plt.subplots(1)\n",
+ "\n",
+ "f.set_size_inches(3,2.5)\n",
+ "\n",
+ "for i,clust_ix in enumerate([1,2,3,4]):\n",
+ " start_ix = 0 \n",
+ " \n",
+ " median, med_se = bootstrap_median(get_dynamic_range(clust_ix,max_FR_df,baseline_FR_df,UMAP_clusts=False))\n",
+ " \n",
+ " arr.bar(start_ix+i, median, \n",
+ " color=GMM_PAL[clust_ix-1],\n",
+ " yerr=med_se)\n",
+ "\n",
+ "arr.set_ylabel('FR Range (spikes/s)')\n",
+ "arr.set_xticks([1.5]);\n",
+ "arr.set_xticklabels(['GMM Clusters'],fontsize=12,fontname='Arial')\n",
+ "arr.spines['right'].set_visible(False)\n",
+ "arr.spines['top'].set_visible(False)\n",
+ "arr.set_ylim(0,25);"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "id": "XQUIAJhiNnAw"
+ },
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "colab": {
+ "collapsed_sections": [],
+ "include_colab_link": true,
+ "name": "WaveMAP_Figures_Data.ipynb",
+ "provenance": []
+ },
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
},
- "nbformat": 4,
- "nbformat_minor": 0
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.8"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
}
diff --git a/poetry.lock b/poetry.lock
index dac025b..be1faa0 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -1,3 +1,19 @@
+[[package]]
+name = "aiofiles"
+version = "22.1.0"
+description = "File support for asyncio."
+category = "main"
+optional = false
+python-versions = ">=3.7,<4.0"
+
+[[package]]
+name = "aiosqlite"
+version = "0.18.0"
+description = "asyncio bridge to the standard sqlite3 module"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
[[package]]
name = "anyio"
version = "3.6.2"
@@ -81,17 +97,19 @@ test = ["astroid", "pytest"]
[[package]]
name = "attrs"
-version = "22.1.0"
+version = "22.2.0"
description = "Classes Without Boilerplate"
category = "main"
optional = false
-python-versions = ">=3.5"
+python-versions = ">=3.6"
[package.extras]
-dev = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "mypy (>=0.900,!=0.940)", "pytest-mypy-plugins", "zope.interface", "furo", "sphinx", "sphinx-notfound-page", "pre-commit", "cloudpickle"]
-docs = ["furo", "sphinx", "zope.interface", "sphinx-notfound-page"]
-tests = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "mypy (>=0.900,!=0.940)", "pytest-mypy-plugins", "zope.interface", "cloudpickle"]
-tests_no_zope = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "mypy (>=0.900,!=0.940)", "pytest-mypy-plugins", "cloudpickle"]
+cov = ["attrs", "coverage-enable-subprocess", "coverage[toml] (>=5.3)"]
+dev = ["attrs"]
+docs = ["furo", "sphinx", "myst-parser", "zope.interface", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier"]
+tests = ["attrs", "zope.interface"]
+tests-no-zope = ["hypothesis", "pympler", "pytest (>=4.3.0)", "pytest-xdist", "cloudpickle", "mypy (>=0.971,<0.990)", "pytest-mypy-plugins"]
+tests_no_zope = ["hypothesis", "pympler", "pytest (>=4.3.0)", "pytest-xdist", "cloudpickle", "mypy (>=0.971,<0.990)", "pytest-mypy-plugins"]
[[package]]
name = "babel"
@@ -114,7 +132,7 @@ python-versions = "*"
[[package]]
name = "beautifulsoup4"
-version = "4.11.1"
+version = "4.11.2"
description = "Screen-scraping library"
category = "main"
optional = false
@@ -129,7 +147,7 @@ lxml = ["lxml"]
[[package]]
name = "bleach"
-version = "5.0.1"
+version = "6.0.0"
description = "An easy safelist-based HTML-sanitizing tool."
category = "main"
optional = false
@@ -141,7 +159,6 @@ webencodings = "*"
[package.extras]
css = ["tinycss2 (>=1.1.0,<1.2)"]
-dev = ["build (==0.8.0)", "flake8 (==4.0.1)", "hashin (==0.17.0)", "pip-tools (==6.6.2)", "pytest (==7.1.2)", "Sphinx (==4.3.2)", "tox (==3.25.0)", "twine (==4.0.1)", "wheel (==0.37.1)", "black (==22.3.0)", "mypy (==0.961)"]
[[package]]
name = "bokeh"
@@ -183,18 +200,15 @@ pycparser = "*"
[[package]]
name = "charset-normalizer"
-version = "2.1.1"
+version = "3.0.1"
description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet."
category = "main"
optional = false
-python-versions = ">=3.6.0"
-
-[package.extras]
-unicode_backport = ["unicodedata2"]
+python-versions = "*"
[[package]]
name = "cloudpickle"
-version = "2.2.0"
+version = "2.2.1"
description = "Extended pickling support for Python objects"
category = "main"
optional = false
@@ -224,21 +238,21 @@ test = ["pytest"]
[[package]]
name = "contourpy"
-version = "1.0.6"
+version = "1.0.7"
description = "Python library for calculating contours of 2D quadrilateral grids"
category = "main"
optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
[package.dependencies]
numpy = ">=1.16"
[package.extras]
-bokeh = ["bokeh", "selenium"]
-docs = ["docutils (<0.18)", "sphinx (<=5.2.0)", "sphinx-rtd-theme"]
-test = ["pytest", "matplotlib", "pillow", "flake8", "isort"]
-test-minimal = ["pytest"]
-test-no-codebase = ["pytest", "matplotlib", "pillow"]
+bokeh = ["bokeh", "chromedriver", "selenium"]
+docs = ["furo", "sphinx-copybutton"]
+mypy = ["contourpy", "docutils-stubs", "mypy (==0.991)", "types-pillow"]
+test = ["matplotlib", "pillow", "pytest"]
+test-no-images = ["pytest"]
[[package]]
name = "cycler"
@@ -263,7 +277,7 @@ scipy = "*"
[[package]]
name = "debugpy"
-version = "1.6.4"
+version = "1.6.6"
description = "An implementation of the Debug Adapter Protocol for Python"
category = "main"
optional = false
@@ -285,14 +299,6 @@ category = "main"
optional = false
python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
-[[package]]
-name = "entrypoints"
-version = "0.4"
-description = "Discover and load entry points from installed packages."
-category = "main"
-optional = false
-python-versions = ">=3.6"
-
[[package]]
name = "executing"
version = "1.2.0"
@@ -355,7 +361,7 @@ python-versions = ">=3.5"
[[package]]
name = "importlib-metadata"
-version = "5.1.0"
+version = "6.0.0"
description = "Read metadata from Python packages"
category = "main"
optional = false
@@ -365,13 +371,13 @@ python-versions = ">=3.7"
zipp = ">=0.5"
[package.extras]
-docs = ["sphinx (>=3.5)", "jaraco.packaging (>=9)", "rst.linker (>=1.9)", "furo", "jaraco.tidelift (>=1.4)"]
+docs = ["sphinx (>=3.5)", "jaraco.packaging (>=9)", "rst.linker (>=1.9)", "furo", "sphinx-lint", "jaraco.tidelift (>=1.4)"]
perf = ["ipython"]
testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "flake8 (<5)", "pytest-cov", "pytest-enabler (>=1.3)", "packaging", "pyfakefs", "flufl.flake8", "pytest-perf (>=0.9.2)", "pytest-black (>=0.3.7)", "pytest-mypy (>=0.9.1)", "pytest-flake8", "importlib-resources (>=1.3)"]
[[package]]
name = "importlib-resources"
-version = "5.10.1"
+version = "5.12.0"
description = "Read resources from Python packages"
category = "main"
optional = false
@@ -381,12 +387,12 @@ python-versions = ">=3.7"
zipp = {version = ">=3.1.0", markers = "python_version < \"3.10\""}
[package.extras]
-docs = ["sphinx (>=3.5)", "jaraco.packaging (>=9)", "rst.linker (>=1.9)", "furo", "jaraco.tidelift (>=1.4)"]
+docs = ["sphinx (>=3.5)", "jaraco.packaging (>=9)", "rst.linker (>=1.9)", "furo", "sphinx-lint", "jaraco.tidelift (>=1.4)"]
testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "flake8 (<5)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-black (>=0.3.7)", "pytest-mypy (>=0.9.1)", "pytest-flake8"]
[[package]]
name = "ipykernel"
-version = "6.19.2"
+version = "6.21.2"
description = "IPython Kernel for Jupyter"
category = "main"
optional = false
@@ -395,27 +401,28 @@ python-versions = ">=3.8"
[package.dependencies]
appnope = {version = "*", markers = "platform_system == \"Darwin\""}
comm = ">=0.1.1"
-debugpy = ">=1.0"
+debugpy = ">=1.6.5"
ipython = ">=7.23.1"
jupyter-client = ">=6.1.12"
+jupyter-core = ">=4.12,<5.0.0 || >=5.1.0"
matplotlib-inline = ">=0.1"
nest-asyncio = "*"
packaging = "*"
psutil = "*"
-pyzmq = ">=17"
+pyzmq = ">=20"
tornado = ">=6.1"
traitlets = ">=5.4.0"
[package.extras]
cov = ["coverage", "curio", "matplotlib", "pytest-cov", "trio"]
-docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinxcontrib-github-alt"]
-lint = ["black (>=22.6.0)", "mdformat (>0.7)", "ruff (>=0.0.156)"]
+docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "trio"]
+pyqt5 = ["pyqt5"]
+pyside6 = ["pyside6"]
test = ["flaky", "ipyparallel", "pre-commit", "pytest-asyncio", "pytest-cov", "pytest-timeout", "pytest (>=7.0)"]
-typing = ["mypy (>=0.990)"]
[[package]]
name = "ipython"
-version = "8.7.0"
+version = "8.10.0"
description = "IPython: Productive Interactive Computing"
category = "main"
optional = false
@@ -430,13 +437,13 @@ jedi = ">=0.16"
matplotlib-inline = "*"
pexpect = {version = ">4.3", markers = "sys_platform != \"win32\""}
pickleshare = "*"
-prompt-toolkit = ">=3.0.11,<3.1.0"
+prompt-toolkit = ">=3.0.30,<3.1.0"
pygments = ">=2.4.0"
stack-data = "*"
traitlets = ">=5"
[package.extras]
-all = ["black", "ipykernel", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "docrepr", "matplotlib", "stack-data", "pytest (<7)", "typing-extensions", "pytest (<7.1)", "pytest-asyncio", "testpath", "nbconvert", "nbformat", "ipywidgets", "notebook", "ipyparallel", "qtconsole", "curio", "matplotlib (!=3.2.0)", "numpy (>=1.20)", "pandas", "trio"]
+all = ["black", "ipykernel", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "docrepr", "matplotlib", "stack-data", "pytest (<7)", "typing-extensions", "pytest (<7.1)", "pytest-asyncio", "testpath", "nbconvert", "nbformat", "ipywidgets", "notebook", "ipyparallel", "qtconsole", "curio", "matplotlib (!=3.2.0)", "numpy (>=1.21)", "pandas", "trio"]
black = ["black"]
doc = ["ipykernel", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "docrepr", "matplotlib", "stack-data", "pytest (<7)", "typing-extensions", "pytest (<7.1)", "pytest-asyncio", "testpath"]
kernel = ["ipykernel"]
@@ -446,7 +453,7 @@ notebook = ["ipywidgets", "notebook"]
parallel = ["ipyparallel"]
qtconsole = ["qtconsole"]
test = ["pytest (<7.1)", "pytest-asyncio", "testpath"]
-test_extra = ["pytest (<7.1)", "pytest-asyncio", "testpath", "curio", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.20)", "pandas", "trio"]
+test_extra = ["pytest (<7.1)", "pytest-asyncio", "testpath", "curio", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.21)", "pandas", "trio"]
[[package]]
name = "ipython-genutils"
@@ -507,7 +514,7 @@ python-versions = ">=3.7"
[[package]]
name = "json5"
-version = "0.9.10"
+version = "0.9.11"
description = "A Python implementation of the JSON5 data format."
category = "main"
optional = false
@@ -552,28 +559,27 @@ format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-
[[package]]
name = "jupyter-client"
-version = "7.4.8"
+version = "8.0.3"
description = "Jupyter protocol implementation and client libraries"
category = "main"
optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
[package.dependencies]
-entrypoints = "*"
-jupyter-core = ">=4.9.2"
-nest-asyncio = ">=1.5.4"
+importlib-metadata = {version = ">=4.8.3", markers = "python_version < \"3.10\""}
+jupyter-core = ">=4.12,<5.0.0 || >=5.1.0"
python-dateutil = ">=2.8.2"
pyzmq = ">=23.0"
tornado = ">=6.2"
-traitlets = "*"
+traitlets = ">=5.3"
[package.extras]
-doc = ["ipykernel", "myst-parser", "sphinx-rtd-theme", "sphinx (>=1.3.6)", "sphinxcontrib-github-alt"]
-test = ["codecov", "coverage", "ipykernel (>=6.12)", "ipython", "mypy", "pre-commit", "pytest", "pytest-asyncio (>=0.18)", "pytest-cov", "pytest-timeout"]
+docs = ["ipykernel", "myst-parser", "pydata-sphinx-theme", "sphinx-autodoc-typehints", "sphinx (>=4)", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"]
+test = ["codecov", "coverage", "ipykernel (>=6.14)", "mypy", "paramiko", "pre-commit", "pytest", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"]
[[package]]
name = "jupyter-core"
-version = "5.1.0"
+version = "5.2.0"
description = "Jupyter core package. A base package on which Jupyter projects rely."
category = "main"
optional = false
@@ -585,37 +591,40 @@ pywin32 = {version = ">=1.0", markers = "sys_platform == \"win32\" and platform_
traitlets = ">=5.3"
[package.extras]
-docs = ["myst-parser", "sphinxcontrib-github-alt", "traitlets"]
+docs = ["myst-parser", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "traitlets"]
test = ["ipykernel", "pre-commit", "pytest", "pytest-cov", "pytest-timeout"]
[[package]]
name = "jupyter-events"
-version = "0.5.0"
+version = "0.6.3"
description = "Jupyter Event System library"
category = "main"
optional = false
python-versions = ">=3.7"
[package.dependencies]
-jsonschema = {version = ">=4.3.0", extras = ["format-nongpl"]}
-python-json-logger = "*"
-pyyaml = "*"
-traitlets = "*"
+jsonschema = {version = ">=3.2.0", extras = ["format-nongpl"]}
+python-json-logger = ">=2.0.4"
+pyyaml = ">=5.3"
+rfc3339-validator = "*"
+rfc3986-validator = ">=0.1.1"
+traitlets = ">=5.3"
[package.extras]
cli = ["click", "rich"]
-test = ["click", "coverage", "pre-commit", "pytest-asyncio (>=0.19.0)", "pytest-console-scripts", "pytest-cov", "pytest (>=6.1.0)", "rich"]
+docs = ["jupyterlite-sphinx", "myst-parser", "pydata-sphinx-theme", "sphinxcontrib-spelling"]
+test = ["click", "coverage", "pre-commit", "pytest-asyncio (>=0.19.0)", "pytest-console-scripts", "pytest-cov", "pytest (>=7.0)", "rich"]
[[package]]
name = "jupyter-server"
-version = "2.0.1"
+version = "2.3.0"
description = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications."
category = "main"
optional = false
python-versions = ">=3.8"
[package.dependencies]
-anyio = ">=3.1.0,<4"
+anyio = ">=3.1.0"
argon2-cffi = "*"
jinja2 = "*"
jupyter-client = ">=7.4.4"
@@ -635,14 +644,28 @@ traitlets = ">=5.6.0"
websocket-client = "*"
[package.extras]
-docs = ["docutils (<0.20)", "ipykernel", "jinja2", "jupyter-client", "jupyter-server", "mistune (<1.0.0)", "myst-parser", "nbformat", "prometheus-client", "pydata-sphinx-theme", "send2trash", "sphinxcontrib-github-alt", "sphinxcontrib-openapi", "sphinxemoji", "tornado"]
-lint = ["black (>=22.6.0)", "mdformat (>0.7)", "ruff (>=0.0.156)"]
+docs = ["docutils (<0.20)", "ipykernel", "jinja2", "jupyter-client", "jupyter-server", "mistune (<1.0.0)", "myst-parser", "nbformat", "prometheus-client", "pydata-sphinx-theme", "send2trash", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-openapi", "sphinxcontrib-spelling", "sphinxemoji", "tornado"]
test = ["ipykernel", "pre-commit", "pytest-console-scripts", "pytest-jupyter[server] (>=0.4)", "pytest-timeout", "pytest (>=7.0)", "requests"]
-typing = ["mypy (>=0.990)"]
+
+[[package]]
+name = "jupyter-server-fileid"
+version = "0.8.0"
+description = ""
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+jupyter-events = ">=0.5.0"
+jupyter-server = ">=1.15,<3"
+
+[package.extras]
+cli = ["click"]
+test = ["jupyter-server[test] (>=1.15,<3)", "pytest", "pytest-cov"]
[[package]]
name = "jupyter-server-terminals"
-version = "0.4.2"
+version = "0.4.4"
description = "A Jupyter Server Extension Providing Terminals."
category = "main"
optional = false
@@ -653,12 +676,43 @@ pywinpty = {version = ">=2.0.3", markers = "os_name == \"nt\""}
terminado = ">=0.8.3"
[package.extras]
-docs = ["jinja2", "jupyter-server", "mistune (<2.0)", "myst-parser", "nbformat", "packaging", "pydata-sphinx-theme", "sphinxcontrib-github-alt", "sphinxcontrib-openapi", "sphinxemoji", "tornado"]
-test = ["coverage", "jupyter-server (>=2.0.0rc8)", "pytest-cov", "pytest-jupyter[server] (>=0.5.3)", "pytest-timeout", "pytest (>=7.0)"]
+docs = ["jinja2", "jupyter-server", "mistune (<3.0)", "myst-parser", "nbformat", "packaging", "pydata-sphinx-theme", "sphinxcontrib-github-alt", "sphinxcontrib-openapi", "sphinxcontrib-spelling", "sphinxemoji", "tornado"]
+test = ["coverage", "jupyter-server (>=2.0.0)", "pytest-cov", "pytest-jupyter[server] (>=0.5.3)", "pytest-timeout", "pytest (>=7.0)"]
+
+[[package]]
+name = "jupyter-server-ydoc"
+version = "0.6.1"
+description = "A Jupyter Server Extension Providing Y Documents."
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+jupyter-server-fileid = ">=0.6.0,<1"
+jupyter-ydoc = ">=0.2.0,<0.4.0"
+ypy-websocket = ">=0.8.2,<0.9.0"
+
+[package.extras]
+test = ["coverage", "jupyter-server[test] (>=2.0.0a0)", "pytest-cov", "pytest-timeout", "pytest-tornasync", "pytest (>=7.0)"]
+
+[[package]]
+name = "jupyter-ydoc"
+version = "0.2.2"
+description = "Document structures for collaborative editing using Ypy"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+importlib-metadata = {version = ">=3.6", markers = "python_version < \"3.10\""}
+y-py = ">=0.5.3,<0.6.0"
+
+[package.extras]
+test = ["pre-commit", "pytest", "pytest-asyncio", "websockets (>=10.0)", "ypy-websocket (>=0.3.1,<0.4.0)"]
[[package]]
name = "jupyterlab"
-version = "3.5.1"
+version = "3.6.1"
description = "JupyterLab computational environment"
category = "main"
optional = false
@@ -669,16 +723,17 @@ ipython = "*"
jinja2 = ">=2.1"
jupyter-core = "*"
jupyter-server = ">=1.16.0,<3"
-jupyterlab-server = ">=2.10,<3.0"
+jupyter-server-ydoc = ">=0.6.0,<0.7.0"
+jupyter-ydoc = ">=0.2.2,<0.3.0"
+jupyterlab-server = ">=2.19,<3.0"
nbclassic = "*"
notebook = "<7"
packaging = "*"
-tomli = "*"
+tomli = {version = "*", markers = "python_version < \"3.11\""}
tornado = ">=6.1.0"
[package.extras]
-test = ["check-manifest", "coverage", "jupyterlab-server", "pre-commit", "pytest (>=6.0)", "pytest-cov", "pytest-console-scripts", "pytest-check-links (>=0.5)", "requests", "requests-cache", "virtualenv"]
-ui-tests = ["build"]
+test = ["check-manifest", "coverage", "jupyterlab-server", "pre-commit", "pytest (>=6.0)", "pytest-cov", "pytest-console-scripts", "pytest-check-links (>=0.5)", "pytest-jupyter (>=0.5.3)", "requests", "requests-cache", "virtualenv"]
[[package]]
name = "jupyterlab-pygments"
@@ -690,7 +745,7 @@ python-versions = ">=3.7"
[[package]]
name = "jupyterlab-server"
-version = "2.16.5"
+version = "2.19.0"
description = "A set of server components for JupyterLab and JupyterLab like applications."
category = "main"
optional = false
@@ -701,17 +756,15 @@ babel = ">=2.10"
importlib-metadata = {version = ">=4.8.3", markers = "python_version < \"3.10\""}
jinja2 = ">=3.0.3"
json5 = ">=0.9.0"
-jsonschema = ">=3.0.1"
+jsonschema = ">=4.17.3"
jupyter-server = ">=1.21,<3"
packaging = ">=21.3"
requests = ">=2.28"
[package.extras]
docs = ["autodoc-traits", "docutils (<0.20)", "jinja2 (<3.2.0)", "mistune (<3)", "myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-copybutton", "sphinxcontrib-openapi"]
-lint = ["black[jupyter] (>=22.6.0)", "mdformat-gfm (>=0.3.5)", "mdformat (>0.7)", "ruff (>=0.0.156)"]
-openapi = ["openapi-core (>=0.14.2)", "ruamel-yaml"]
-test = ["codecov", "ipykernel", "openapi-core (>=0.14.2,<0.15.0)", "openapi-spec-validator (<0.6)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter[server] (>=0.6)", "pytest-timeout", "pytest (>=7.0)", "requests-mock", "ruamel-yaml", "strict-rfc3339"]
-typing = ["mypy (>=0.990)"]
+openapi = ["openapi-core (>=0.16.1)", "ruamel-yaml"]
+test = ["codecov", "ipykernel", "jupyterlab-server", "openapi-spec-validator (>=0.5.1)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter[server] (>=0.6.2)", "pytest-timeout", "pytest (>=7.0)", "requests-mock", "sphinxcontrib-spelling", "strict-rfc3339", "werkzeug"]
[[package]]
name = "kiwisolver"
@@ -731,7 +784,7 @@ python-versions = ">=3.7"
[[package]]
name = "markupsafe"
-version = "2.1.1"
+version = "2.1.2"
description = "Safely add untrusted strings to HTML/XML markup."
category = "main"
optional = false
@@ -739,7 +792,7 @@ python-versions = ">=3.7"
[[package]]
name = "matplotlib"
-version = "3.6.2"
+version = "3.7.0"
description = "Python plotting package"
category = "main"
optional = false
@@ -749,11 +802,12 @@ python-versions = ">=3.8"
contourpy = ">=1.0.1"
cycler = ">=0.10"
fonttools = ">=4.22.0"
+importlib-resources = {version = ">=3.2.0", markers = "python_version < \"3.10\""}
kiwisolver = ">=1.0.1"
-numpy = ">=1.19"
+numpy = ">=1.20"
packaging = ">=20.0"
pillow = ">=6.2.0"
-pyparsing = ">=2.2.1"
+pyparsing = ">=2.3.1"
python-dateutil = ">=2.7"
setuptools_scm = ">=7"
@@ -770,7 +824,7 @@ traitlets = "*"
[[package]]
name = "mistune"
-version = "2.0.4"
+version = "2.0.5"
description = "A sane Markdown parser with useful plugins and renderers"
category = "main"
optional = false
@@ -778,8 +832,8 @@ python-versions = "*"
[[package]]
name = "nbclassic"
-version = "0.4.8"
-description = "A web-based notebook environment for interactive computing"
+version = "0.5.2"
+description = "Jupyter Notebook as a Jupyter Server extension."
category = "main"
optional = false
python-versions = ">=3.7"
@@ -806,7 +860,7 @@ traitlets = ">=4.2.1"
[package.extras]
docs = ["sphinx", "nbsphinx", "sphinxcontrib-github-alt", "sphinx-rtd-theme", "myst-parser"]
json-logging = ["json-logging"]
-test = ["pytest", "coverage", "requests", "testpath", "nbval", "pytest-playwright", "pytest-cov", "pytest-tornasync", "requests-unixsocket"]
+test = ["pytest", "coverage", "requests", "testpath", "nbval", "pytest-playwright", "pytest-cov", "pytest-jupyter", "pytest-tornasync", "requests-unixsocket"]
[[package]]
name = "nbclient"
@@ -829,7 +883,7 @@ test = ["ipykernel", "ipython", "ipywidgets", "nbconvert (>=7.0.0)", "pytest-asy
[[package]]
name = "nbconvert"
-version = "7.2.6"
+version = "7.2.9"
description = "Converting Jupyter Notebooks"
category = "main"
optional = false
@@ -855,16 +909,16 @@ traitlets = ">=5.0"
[package.extras]
all = ["nbconvert"]
-docs = ["ipykernel", "ipython", "myst-parser", "nbsphinx (>=0.2.12)", "pydata-sphinx-theme", "sphinx (==5.0.2)"]
+docs = ["ipykernel", "ipython", "myst-parser", "nbsphinx (>=0.2.12)", "pydata-sphinx-theme", "sphinx (==5.0.2)", "sphinxcontrib-spelling"]
qtpdf = ["nbconvert"]
qtpng = ["pyqtwebengine (>=5.15)"]
serve = ["tornado (>=6.1)"]
-test = ["ipykernel", "ipywidgets (>=7)", "pre-commit", "pyppeteer (>=1,<1.1)", "pytest", "pytest-dependency"]
+test = ["ipykernel", "ipywidgets (>=7)", "pre-commit", "pytest", "pytest-dependency"]
webpdf = ["pyppeteer (>=1,<1.1)"]
[[package]]
name = "nbformat"
-version = "5.7.0"
+version = "5.7.3"
description = "The Jupyter Notebook format"
category = "main"
optional = false
@@ -877,7 +931,8 @@ jupyter-core = "*"
traitlets = ">=5.1"
[package.extras]
-test = ["check-manifest", "pep440", "pre-commit", "pytest", "testpath"]
+docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"]
+test = ["pep440", "pre-commit", "pytest", "testpath"]
[[package]]
name = "nest-asyncio"
@@ -970,7 +1025,7 @@ python-versions = ">=3.8"
[[package]]
name = "packaging"
-version = "22.0"
+version = "23.0"
description = "Core utilities for Python packages"
category = "main"
optional = false
@@ -978,18 +1033,14 @@ python-versions = ">=3.7"
[[package]]
name = "pandas"
-version = "1.5.2"
+version = "1.5.3"
description = "Powerful data structures for data analysis, time series, and statistics"
category = "main"
optional = false
python-versions = ">=3.8"
[package.dependencies]
-numpy = [
- {version = ">=1.20.3", markers = "python_version < \"3.10\""},
- {version = ">=1.21.0", markers = "python_version >= \"3.10\""},
- {version = ">=1.23.2", markers = "python_version >= \"3.11\""},
-]
+numpy = {version = ">=1.20.3", markers = "python_version < \"3.10\""}
python-dateutil = ">=2.8.1"
pytz = ">=2020.1"
@@ -1037,14 +1088,14 @@ python-versions = "*"
[[package]]
name = "pillow"
-version = "9.3.0"
+version = "9.4.0"
description = "Python Imaging Library (Fork)"
category = "main"
optional = false
python-versions = ">=3.7"
[package.extras]
-docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-issues (>=3.0.1)", "sphinx-removed-in", "sphinxext-opengraph"]
+docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-issues (>=3.0.1)", "sphinx-removed-in", "sphinxext-opengraph"]
tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"]
[[package]]
@@ -1057,19 +1108,19 @@ python-versions = ">=3.6"
[[package]]
name = "platformdirs"
-version = "2.6.0"
+version = "3.0.0"
description = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"."
category = "main"
optional = false
python-versions = ">=3.7"
[package.extras]
-docs = ["furo (>=2022.9.29)", "proselint (>=0.13)", "sphinx-autodoc-typehints (>=1.19.4)", "sphinx (>=5.3)"]
-test = ["appdirs (==1.4.4)", "pytest-cov (>=4)", "pytest-mock (>=3.10)", "pytest (>=7.2)"]
+docs = ["furo (>=2022.12.7)", "proselint (>=0.13)", "sphinx-autodoc-typehints (>=1.22,!=1.23.4)", "sphinx (>=6.1.3)"]
+test = ["appdirs (==1.4.4)", "covdefaults (>=2.2.2)", "pytest-cov (>=4)", "pytest-mock (>=3.10)", "pytest (>=7.2.1)"]
[[package]]
name = "prometheus-client"
-version = "0.15.0"
+version = "0.16.0"
description = "Python client for the Prometheus monitoring system."
category = "main"
optional = false
@@ -1080,11 +1131,11 @@ twisted = ["twisted"]
[[package]]
name = "prompt-toolkit"
-version = "3.0.36"
+version = "3.0.37"
description = "Library for building powerful interactive command lines in Python"
category = "main"
optional = false
-python-versions = ">=3.6.2"
+python-versions = ">=3.7.0"
[package.dependencies]
wcwidth = "*"
@@ -1119,14 +1170,6 @@ python-versions = "*"
[package.extras]
tests = ["pytest"]
-[[package]]
-name = "py"
-version = "1.11.0"
-description = "library with cross-python path, ini-parsing, io, code, log facilities"
-category = "main"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
-
[[package]]
name = "pycparser"
version = "2.21"
@@ -1137,7 +1180,7 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
[[package]]
name = "pygments"
-version = "2.13.0"
+version = "2.14.0"
description = "Pygments is a syntax highlighting package written in Python."
category = "main"
optional = false
@@ -1174,7 +1217,7 @@ diagrams = ["railroad-diagrams", "jinja2"]
[[package]]
name = "pyrsistent"
-version = "0.19.2"
+version = "0.19.3"
description = "Persistent/Functional/Immutable data structures"
category = "main"
optional = false
@@ -1193,15 +1236,15 @@ six = ">=1.5"
[[package]]
name = "python-json-logger"
-version = "2.0.4"
+version = "2.0.7"
description = "A python library adding a json log formatter"
category = "main"
optional = false
-python-versions = ">=3.5"
+python-versions = ">=3.6"
[[package]]
name = "pytz"
-version = "2022.6"
+version = "2022.7.1"
description = "World timezone definitions, modern and historical"
category = "main"
optional = false
@@ -1217,7 +1260,7 @@ python-versions = "*"
[[package]]
name = "pywinpty"
-version = "2.0.9"
+version = "2.0.10"
description = "Pseudo terminal support for Windows from Python."
category = "main"
optional = false
@@ -1233,7 +1276,7 @@ python-versions = ">=3.6"
[[package]]
name = "pyzmq"
-version = "24.0.1"
+version = "25.0.0"
description = "Python bindings for 0MQ"
category = "main"
optional = false
@@ -1241,11 +1284,10 @@ python-versions = ">=3.6"
[package.dependencies]
cffi = {version = "*", markers = "implementation_name == \"pypy\""}
-py = {version = "*", markers = "implementation_name == \"pypy\""}
[[package]]
name = "requests"
-version = "2.28.1"
+version = "2.28.2"
description = "Python HTTP for Humans."
category = "main"
optional = false
@@ -1253,7 +1295,7 @@ python-versions = ">=3.7, <4"
[package.dependencies]
certifi = ">=2017.4.17"
-charset-normalizer = ">=2,<3"
+charset-normalizer = ">=2,<4"
idna = ">=2.5,<4"
urllib3 = ">=1.21.1,<1.27"
@@ -1282,7 +1324,7 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
[[package]]
name = "scikit-learn"
-version = "1.2.0"
+version = "1.2.1"
description = "A set of python modules for machine learning and data mining"
category = "main"
optional = false
@@ -1302,19 +1344,19 @@ tests = ["matplotlib (>=3.1.3)", "scikit-image (>=0.16.2)", "pandas (>=1.0.5)",
[[package]]
name = "scipy"
-version = "1.9.3"
+version = "1.10.1"
description = "Fundamental algorithms for scientific computing in Python"
category = "main"
optional = false
-python-versions = ">=3.8"
+python-versions = "<3.12,>=3.8"
[package.dependencies]
-numpy = ">=1.18.5,<1.26.0"
+numpy = ">=1.19.5,<1.27.0"
[package.extras]
-test = ["pytest", "pytest-cov", "pytest-xdist", "asv", "mpmath", "gmpy2", "threadpoolctl", "scikit-umfpack"]
-doc = ["sphinx (!=4.1.0)", "pydata-sphinx-theme (==0.9.0)", "sphinx-panels (>=0.5.2)", "matplotlib (>2)", "numpydoc", "sphinx-tabs"]
-dev = ["mypy", "typing-extensions", "pycodestyle", "flake8"]
+test = ["pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "asv", "mpmath", "gmpy2", "threadpoolctl", "scikit-umfpack", "pooch"]
+doc = ["sphinx (!=4.1.0)", "pydata-sphinx-theme (==0.9.0)", "sphinx-design (>=0.2.0)", "matplotlib (>2)", "numpydoc"]
+dev = ["mypy", "typing-extensions", "pycodestyle", "flake8", "rich-click", "click", "doit (>=0.36.0)", "pydevtool"]
[[package]]
name = "send2trash"
@@ -1331,7 +1373,7 @@ win32 = ["pywin32"]
[[package]]
name = "setuptools-scm"
-version = "7.0.5"
+version = "7.1.0"
description = "the blessed package to manage your versions by scm tags"
category = "main"
optional = false
@@ -1339,7 +1381,7 @@ python-versions = ">=3.7"
[package.dependencies]
packaging = ">=20.0"
-tomli = ">=1.0.0"
+tomli = {version = ">=1.0.0", markers = "python_version < \"3.11\""}
typing-extensions = "*"
[package.extras]
@@ -1398,11 +1440,11 @@ python-versions = ">=3.7"
[[package]]
name = "soupsieve"
-version = "2.3.2.post1"
+version = "2.4"
description = "A modern CSS selector implementation for Beautiful Soup."
category = "main"
optional = false
-python-versions = ">=3.6"
+python-versions = ">=3.7"
[[package]]
name = "stack-data"
@@ -1495,7 +1537,7 @@ telegram = ["requests"]
[[package]]
name = "traitlets"
-version = "5.7.0"
+version = "5.9.0"
description = "Traitlets Python configuration system"
category = "main"
optional = false
@@ -1503,13 +1545,11 @@ python-versions = ">=3.7"
[package.extras]
docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"]
-lint = ["black (>=22.6.0)", "mdformat (>0.7)", "ruff (>=0.0.156)"]
-test = ["pre-commit", "pytest"]
-typing = ["mypy (>=0.990)"]
+test = ["argcomplete (>=2.0)", "pre-commit", "pytest", "pytest-mock"]
[[package]]
name = "typing-extensions"
-version = "4.4.0"
+version = "4.5.0"
description = "Backported and Experimental Type Hints for Python 3.7+"
category = "main"
optional = false
@@ -1548,7 +1588,7 @@ dev = ["mypy", "flake8 (<4.0.0)", "flake8-annotations", "flake8-bugbear", "flake
[[package]]
name = "urllib3"
-version = "1.26.13"
+version = "1.26.14"
description = "HTTP library with thread-safe connection pooling, file post, and more."
category = "main"
optional = false
@@ -1561,7 +1601,7 @@ socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"]
[[package]]
name = "wcwidth"
-version = "0.2.5"
+version = "0.2.6"
description = "Measures the displayed width of unicode strings in a terminal"
category = "main"
optional = false
@@ -1585,7 +1625,7 @@ python-versions = "*"
[[package]]
name = "websocket-client"
-version = "1.4.2"
+version = "1.5.1"
description = "WebSocket client for Python with low level API options"
category = "main"
optional = false
@@ -1598,7 +1638,7 @@ test = ["websockets"]
[[package]]
name = "xgboost"
-version = "1.7.2"
+version = "1.7.4"
description = "XGBoost Python Package"
category = "main"
optional = false
@@ -1618,30 +1658,56 @@ scikit-learn = ["scikit-learn"]
[[package]]
name = "xyzservices"
-version = "2022.9.0"
+version = "2023.2.0"
description = "Source of XYZ tiles providers"
category = "main"
optional = false
python-versions = ">=3.7"
+[[package]]
+name = "y-py"
+version = "0.5.9"
+description = "Python bindings for the Y-CRDT built from yrs (Rust)"
+category = "main"
+optional = false
+python-versions = "*"
+
+[[package]]
+name = "ypy-websocket"
+version = "0.8.2"
+description = "WebSocket connector for Ypy"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+
+[package.dependencies]
+aiofiles = ">=22.1.0,<23"
+aiosqlite = ">=0.17.0,<1"
+y-py = ">=0.5.3,<0.6.0"
+
+[package.extras]
+test = ["mypy", "pre-commit", "pytest", "pytest-asyncio", "websockets (>=10.0)"]
+
[[package]]
name = "zipp"
-version = "3.11.0"
+version = "3.14.0"
description = "Backport of pathlib-compatible object wrapper for zip files"
category = "main"
optional = false
python-versions = ">=3.7"
[package.extras]
-docs = ["sphinx (>=3.5)", "jaraco.packaging (>=9)", "rst.linker (>=1.9)", "furo", "jaraco.tidelift (>=1.4)"]
+docs = ["sphinx (>=3.5)", "jaraco.packaging (>=9)", "rst.linker (>=1.9)", "furo", "sphinx-lint", "jaraco.tidelift (>=1.4)"]
testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "flake8 (<5)", "pytest-cov", "pytest-enabler (>=1.3)", "jaraco.itertools", "func-timeout", "jaraco.functools", "more-itertools", "pytest-black (>=0.3.7)", "pytest-mypy (>=0.9.1)", "pytest-flake8"]
[metadata]
lock-version = "1.1"
-python-versions = "^3.8"
-content-hash = "edd3a58b03317af84e0d4061a95f75f99781eb6b30ef223b3389a3928b5b5496"
+python-versions = "3.8"
+content-hash = "248b02276978686f43adade3ab7812aa13edbb3ab7aad97f1ad6d1b78e75d4af"
[metadata.files]
+aiofiles = []
+aiosqlite = []
anyio = []
appnope = [
{file = "appnope-0.1.3-py2.py3-none-any.whl", hash = "sha256:265a455292d0bd8a72453494fa24df5a11eb18373a60c7c0430889f22548605e"},
@@ -1682,14 +1748,8 @@ backcall = [
{file = "backcall-0.2.0-py2.py3-none-any.whl", hash = "sha256:fbbce6a29f263178a1f7915c1940bde0ec2b2a967566fe1c65c1dfb7422bd255"},
{file = "backcall-0.2.0.tar.gz", hash = "sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e"},
]
-beautifulsoup4 = [
- {file = "beautifulsoup4-4.11.1-py3-none-any.whl", hash = "sha256:58d5c3d29f5a36ffeb94f02f0d786cd53014cf9b3b3951d42e0080d8a9498d30"},
- {file = "beautifulsoup4-4.11.1.tar.gz", hash = "sha256:ad9aa55b65ef2808eb405f46cf74df7fcb7044d5cbc26487f96eb2ef2e436693"},
-]
-bleach = [
- {file = "bleach-5.0.1-py3-none-any.whl", hash = "sha256:085f7f33c15bd408dd9b17a4ad77c577db66d76203e5984b1bd59baeee948b2a"},
- {file = "bleach-5.0.1.tar.gz", hash = "sha256:0d03255c47eb9bd2f26aa9bb7f2107732e7e8fe195ca2f64709fcf3b0a4a085c"},
-]
+beautifulsoup4 = []
+bleach = []
bokeh = []
certifi = []
cffi = [
@@ -1779,10 +1839,6 @@ defusedxml = [
{file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"},
{file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"},
]
-entrypoints = [
- {file = "entrypoints-0.4-py3-none-any.whl", hash = "sha256:f174b5ff827504fd3cd97cc3f8649f3693f51538c7e4bdf3ef002c8429d42f9f"},
- {file = "entrypoints-0.4.tar.gz", hash = "sha256:b706eddaa9218a19ebcd67b56818f05bb27589b1ca9e8d797b74affad4ccacd4"},
-]
executing = []
fastjsonschema = []
fonttools = []
@@ -1810,7 +1866,10 @@ jupyter-client = []
jupyter-core = []
jupyter-events = []
jupyter-server = []
+jupyter-server-fileid = []
jupyter-server-terminals = []
+jupyter-server-ydoc = []
+jupyter-ydoc = []
jupyterlab = []
jupyterlab-pygments = [
{file = "jupyterlab_pygments-0.2.2-py2.py3-none-any.whl", hash = "sha256:2405800db07c9f770863bcf8049a529c3dd4d3e28536638bd7c1c01d2748309f"},
@@ -1819,48 +1878,7 @@ jupyterlab-pygments = [
jupyterlab-server = []
kiwisolver = []
llvmlite = []
-markupsafe = [
- {file = "MarkupSafe-2.1.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:86b1f75c4e7c2ac2ccdaec2b9022845dbb81880ca318bb7a0a01fbf7813e3812"},
- {file = "MarkupSafe-2.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f121a1420d4e173a5d96e47e9a0c0dcff965afdf1626d28de1460815f7c4ee7a"},
- {file = "MarkupSafe-2.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a49907dd8420c5685cfa064a1335b6754b74541bbb3706c259c02ed65b644b3e"},
- {file = "MarkupSafe-2.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10c1bfff05d95783da83491be968e8fe789263689c02724e0c691933c52994f5"},
- {file = "MarkupSafe-2.1.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b7bd98b796e2b6553da7225aeb61f447f80a1ca64f41d83612e6139ca5213aa4"},
- {file = "MarkupSafe-2.1.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:b09bf97215625a311f669476f44b8b318b075847b49316d3e28c08e41a7a573f"},
- {file = "MarkupSafe-2.1.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:694deca8d702d5db21ec83983ce0bb4b26a578e71fbdbd4fdcd387daa90e4d5e"},
- {file = "MarkupSafe-2.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:efc1913fd2ca4f334418481c7e595c00aad186563bbc1ec76067848c7ca0a933"},
- {file = "MarkupSafe-2.1.1-cp310-cp310-win32.whl", hash = "sha256:4a33dea2b688b3190ee12bd7cfa29d39c9ed176bda40bfa11099a3ce5d3a7ac6"},
- {file = "MarkupSafe-2.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:dda30ba7e87fbbb7eab1ec9f58678558fd9a6b8b853530e176eabd064da81417"},
- {file = "MarkupSafe-2.1.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:671cd1187ed5e62818414afe79ed29da836dde67166a9fac6d435873c44fdd02"},
- {file = "MarkupSafe-2.1.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3799351e2336dc91ea70b034983ee71cf2f9533cdff7c14c90ea126bfd95d65a"},
- {file = "MarkupSafe-2.1.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e72591e9ecd94d7feb70c1cbd7be7b3ebea3f548870aa91e2732960fa4d57a37"},
- {file = "MarkupSafe-2.1.1-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6fbf47b5d3728c6aea2abb0589b5d30459e369baa772e0f37a0320185e87c980"},
- {file = "MarkupSafe-2.1.1-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:d5ee4f386140395a2c818d149221149c54849dfcfcb9f1debfe07a8b8bd63f9a"},
- {file = "MarkupSafe-2.1.1-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:bcb3ed405ed3222f9904899563d6fc492ff75cce56cba05e32eff40e6acbeaa3"},
- {file = "MarkupSafe-2.1.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:e1c0b87e09fa55a220f058d1d49d3fb8df88fbfab58558f1198e08c1e1de842a"},
- {file = "MarkupSafe-2.1.1-cp37-cp37m-win32.whl", hash = "sha256:8dc1c72a69aa7e082593c4a203dcf94ddb74bb5c8a731e4e1eb68d031e8498ff"},
- {file = "MarkupSafe-2.1.1-cp37-cp37m-win_amd64.whl", hash = "sha256:97a68e6ada378df82bc9f16b800ab77cbf4b2fada0081794318520138c088e4a"},
- {file = "MarkupSafe-2.1.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e8c843bbcda3a2f1e3c2ab25913c80a3c5376cd00c6e8c4a86a89a28c8dc5452"},
- {file = "MarkupSafe-2.1.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0212a68688482dc52b2d45013df70d169f542b7394fc744c02a57374a4207003"},
- {file = "MarkupSafe-2.1.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e576a51ad59e4bfaac456023a78f6b5e6e7651dcd383bcc3e18d06f9b55d6d1"},
- {file = "MarkupSafe-2.1.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b9fe39a2ccc108a4accc2676e77da025ce383c108593d65cc909add5c3bd601"},
- {file = "MarkupSafe-2.1.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:96e37a3dc86e80bf81758c152fe66dbf60ed5eca3d26305edf01892257049925"},
- {file = "MarkupSafe-2.1.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:6d0072fea50feec76a4c418096652f2c3238eaa014b2f94aeb1d56a66b41403f"},
- {file = "MarkupSafe-2.1.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:089cf3dbf0cd6c100f02945abeb18484bd1ee57a079aefd52cffd17fba910b88"},
- {file = "MarkupSafe-2.1.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:6a074d34ee7a5ce3effbc526b7083ec9731bb3cbf921bbe1d3005d4d2bdb3a63"},
- {file = "MarkupSafe-2.1.1-cp38-cp38-win32.whl", hash = "sha256:421be9fbf0ffe9ffd7a378aafebbf6f4602d564d34be190fc19a193232fd12b1"},
- {file = "MarkupSafe-2.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:fc7b548b17d238737688817ab67deebb30e8073c95749d55538ed473130ec0c7"},
- {file = "MarkupSafe-2.1.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:e04e26803c9c3851c931eac40c695602c6295b8d432cbe78609649ad9bd2da8a"},
- {file = "MarkupSafe-2.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b87db4360013327109564f0e591bd2a3b318547bcef31b468a92ee504d07ae4f"},
- {file = "MarkupSafe-2.1.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:99a2a507ed3ac881b975a2976d59f38c19386d128e7a9a18b7df6fff1fd4c1d6"},
- {file = "MarkupSafe-2.1.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:56442863ed2b06d19c37f94d999035e15ee982988920e12a5b4ba29b62ad1f77"},
- {file = "MarkupSafe-2.1.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3ce11ee3f23f79dbd06fb3d63e2f6af7b12db1d46932fe7bd8afa259a5996603"},
- {file = "MarkupSafe-2.1.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:33b74d289bd2f5e527beadcaa3f401e0df0a89927c1559c8566c066fa4248ab7"},
- {file = "MarkupSafe-2.1.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:43093fb83d8343aac0b1baa75516da6092f58f41200907ef92448ecab8825135"},
- {file = "MarkupSafe-2.1.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8e3dcf21f367459434c18e71b2a9532d96547aef8a871872a5bd69a715c15f96"},
- {file = "MarkupSafe-2.1.1-cp39-cp39-win32.whl", hash = "sha256:d4306c36ca495956b6d568d276ac11fdd9c30a36f1b6eb928070dc5360b22e1c"},
- {file = "MarkupSafe-2.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:46d00d6cfecdde84d40e572d63735ef81423ad31184100411e6e3388d405e247"},
- {file = "MarkupSafe-2.1.1.tar.gz", hash = "sha256:7f91197cc9e48f989d12e4e6fbc46495c446636dfc81b9ccf50bb0ec74b91d4b"},
-]
+markupsafe = []
matplotlib = []
matplotlib-inline = []
mistune = []
@@ -1906,10 +1924,6 @@ pure-eval = [
{file = "pure_eval-0.2.2-py3-none-any.whl", hash = "sha256:01eaab343580944bc56080ebe0a674b39ec44a945e6d09ba7db3cb8cec289350"},
{file = "pure_eval-0.2.2.tar.gz", hash = "sha256:2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3"},
]
-py = [
- {file = "py-1.11.0-py2.py3-none-any.whl", hash = "sha256:607c53218732647dff4acdfcd50cb62615cedf612e72d1724fb1a0cc6405b378"},
- {file = "py-1.11.0.tar.gz", hash = "sha256:51c75c4126074b472f746a24399ad32f6053d1b34b68d2fa41e558e6f4a98719"},
-]
pycparser = [
{file = "pycparser-2.21-py2.py3-none-any.whl", hash = "sha256:8ee45429555515e1f6b185e78100aea234072576aa43ab53aefcae078162fca9"},
{file = "pycparser-2.21.tar.gz", hash = "sha256:e644fdec12f7872f86c58ff790da456218b10f863970249516d60a5eaca77206"},
@@ -1965,10 +1979,7 @@ pyyaml = [
{file = "PyYAML-6.0.tar.gz", hash = "sha256:68fb519c14306fec9720a2a5b45bc9f0c8d1b9c72adf45c37baedfcd949c35a2"},
]
pyzmq = []
-requests = [
- {file = "requests-2.28.1-py3-none-any.whl", hash = "sha256:8fefa2a1a1365bf5520aac41836fbee479da67864514bdb821f31ce07ce65349"},
- {file = "requests-2.28.1.tar.gz", hash = "sha256:7c5599b102feddaa661c826c56ab4fee28bfd17f5abca1ebbe3e7f19d7c97983"},
-]
+requests = []
rfc3339-validator = []
rfc3986-validator = []
scikit-learn = []
@@ -1988,10 +1999,7 @@ slicer = [
{file = "slicer-0.0.7.tar.gz", hash = "sha256:f5d5f7b45f98d155b9c0ba6554fa9770c6b26d5793a3e77a1030fb56910ebeec"},
]
sniffio = []
-soupsieve = [
- {file = "soupsieve-2.3.2.post1-py3-none-any.whl", hash = "sha256:3b2503d3c7084a42b1ebd08116e5f81aadfaea95863628c80a3b774a11b7c759"},
- {file = "soupsieve-2.3.2.post1.tar.gz", hash = "sha256:fc53893b3da2c33de295667a0e19f078c14bf86544af307354de5fcf12a3f30d"},
-]
+soupsieve = []
stack-data = []
terminado = []
threadpoolctl = [
@@ -2012,10 +2020,7 @@ umap-learn = [
]
uri-template = []
urllib3 = []
-wcwidth = [
- {file = "wcwidth-0.2.5-py2.py3-none-any.whl", hash = "sha256:beb4802a9cebb9144e99086eff703a642a13d6a0052920003a230f3294bbe784"},
- {file = "wcwidth-0.2.5.tar.gz", hash = "sha256:c4d647b99872929fdb7bdcaa4fbe7f01413ed3d98077df798530e5b04f116c83"},
-]
+wcwidth = []
webcolors = []
webencodings = [
{file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"},
@@ -2024,4 +2029,6 @@ webencodings = [
websocket-client = []
xgboost = []
xyzservices = []
+y-py = []
+ypy-websocket = []
zipp = []
diff --git a/pyproject.toml b/pyproject.toml
index e255685..8a3d048 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,11 +1,11 @@
[tool.poetry]
name = "wavemap_paper"
-version = "0.1.0"
+version = "0.1.11"
description = ""
authors = ["Eric Kenji Lee "]
[tool.poetry.dependencies]
-python = "^3.8"
+python = "3.8"
cylouvain = "^0.2.2"
matplotlib = "^3.6.2"
scikit-learn = "^1.2.0"
diff --git a/requirements.txt b/requirements.txt
index eb7933d..116e047 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,346 +1,129 @@
+aiofiles==22.1.0; python_version >= "3.7" and python_version < "4.0"
+aiosqlite==0.18.0; python_version >= "3.7"
anyio==3.6.2; python_full_version >= "3.6.2" and python_version >= "3.8"
-appnope==0.1.3; platform_system == "Darwin" and python_version >= "3.8" and sys_platform == "darwin" \
- --hash=sha256:265a455292d0bd8a72453494fa24df5a11eb18373a60c7c0430889f22548605e \
- --hash=sha256:02bd91c4de869fbb1e1c50aafc4098827a7a54ab2f39d9dcba6c9547ed920e24
-argon2-cffi-bindings==21.2.0; python_version >= "3.8" \
- --hash=sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3 \
- --hash=sha256:ccb949252cb2ab3a08c02024acb77cfb179492d5701c7cbdbfd776124d4d2367 \
- --hash=sha256:9524464572e12979364b7d600abf96181d3541da11e23ddf565a32e70bd4dc0d \
- --hash=sha256:b746dba803a79238e925d9046a63aa26bf86ab2a2fe74ce6b009a1c3f5c8f2ae \
- --hash=sha256:58ed19212051f49a523abb1dbe954337dc82d947fb6e5a0da60f7c8471a8476c \
- --hash=sha256:bd46088725ef7f58b5a1ef7ca06647ebaf0eb4baff7d1d0d177c6cc8744abd86 \
- --hash=sha256:8cd69c07dd875537a824deec19f978e0f2078fdda07fd5c42ac29668dda5f40f \
- --hash=sha256:f1152ac548bd5b8bcecfb0b0371f082037e47128653df2e8ba6e914d384f3c3e \
- --hash=sha256:603ca0aba86b1349b147cab91ae970c63118a0f30444d4bc80355937c950c082 \
- --hash=sha256:b2ef1c30440dbbcba7a5dc3e319408b59676e2e039e2ae11a8775ecf482b192f \
- --hash=sha256:e415e3f62c8d124ee16018e491a009937f8cf7ebf5eb430ffc5de21b900dad93 \
- --hash=sha256:3e385d1c39c520c08b53d63300c3ecc28622f076f4c2b0e6d7e796e9f6502194 \
- --hash=sha256:2c3e3cc67fdb7d82c4718f19b4e7a87123caf8a93fde7e23cf66ac0337d3cb3f \
- --hash=sha256:6a22ad9800121b71099d0fb0a65323810a15f2e292f2ba450810a7316e128ee5 \
- --hash=sha256:f9f8b450ed0547e3d473fdc8612083fd08dd2120d6ac8f73828df9b7d45bb351 \
- --hash=sha256:93f9bf70084f97245ba10ee36575f0c3f1e7d7724d67d8e5b08e61787c320ed7 \
- --hash=sha256:3b9ef65804859d335dc6b31582cad2c5166f0c3e7975f324d9ffaa34ee7e6583 \
- --hash=sha256:d4966ef5848d820776f5f562a7d45fdd70c2f330c961d0d745b784034bd9f48d \
- --hash=sha256:20ef543a89dee4db46a1a6e206cd015360e5a75822f76df533845c3cbaf72670 \
- --hash=sha256:ed2937d286e2ad0cc79a7087d3c272832865f779430e0cc2b4f3718d3159b0cb \
- --hash=sha256:5e00316dabdaea0b2dd82d141cc66889ced0cdcbfa599e8b471cf22c620c329a
-argon2-cffi==21.3.0; python_version >= "3.8" \
- --hash=sha256:d384164d944190a7dd7ef22c6aa3ff197da12962bd04b17f64d4e93d934dba5b \
- --hash=sha256:8c976986f2c5c0e5000919e6de187906cfd81fb1c72bf9d88c01177e77da7f80
+appnope==0.1.3; platform_system == "Darwin" and python_version >= "3.8" and sys_platform == "darwin"
+argon2-cffi-bindings==21.2.0; python_version >= "3.8"
+argon2-cffi==21.3.0; python_version >= "3.8"
arrow==1.2.3; python_version >= "3.7"
asttokens==2.2.1; python_version >= "3.8"
-attrs==22.1.0; python_version >= "3.7"
+attrs==22.2.0; python_version >= "3.7"
babel==2.11.0; python_version >= "3.7"
-backcall==0.2.0; python_version >= "3.8" \
- --hash=sha256:fbbce6a29f263178a1f7915c1940bde0ec2b2a967566fe1c65c1dfb7422bd255 \
- --hash=sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e
-beautifulsoup4==4.11.1; python_full_version >= "3.6.0" and python_version >= "3.8" \
- --hash=sha256:58d5c3d29f5a36ffeb94f02f0d786cd53014cf9b3b3951d42e0080d8a9498d30 \
- --hash=sha256:ad9aa55b65ef2808eb405f46cf74df7fcb7044d5cbc26487f96eb2ef2e436693
-bleach==5.0.1; python_version >= "3.8" \
- --hash=sha256:085f7f33c15bd408dd9b17a4ad77c577db66d76203e5984b1bd59baeee948b2a \
- --hash=sha256:0d03255c47eb9bd2f26aa9bb7f2107732e7e8fe195ca2f64709fcf3b0a4a085c
+backcall==0.2.0; python_version >= "3.8"
+beautifulsoup4==4.11.2; python_full_version >= "3.6.0" and python_version >= "3.8"
+bleach==6.0.0; python_version >= "3.8"
bokeh==3.0.3; python_version >= "3.8"
certifi==2022.12.7; python_version >= "3.7" and python_version < "4"
-cffi==1.15.1; implementation_name == "pypy" and python_version >= "3.8" \
- --hash=sha256:a66d3508133af6e8548451b25058d5812812ec3798c886bf38ed24a98216fab2 \
- --hash=sha256:470c103ae716238bbe698d67ad020e1db9d9dba34fa5a899b5e21577e6d52ed2 \
- --hash=sha256:9ad5db27f9cabae298d151c85cf2bad1d359a1b9c686a275df03385758e2f914 \
- --hash=sha256:b3bbeb01c2b273cca1e1e0c5df57f12dce9a4dd331b4fa1635b8bec26350bde3 \
- --hash=sha256:e00b098126fd45523dd056d2efba6c5a63b71ffe9f2bbe1a4fe1716e1d0c331e \
- --hash=sha256:d61f4695e6c866a23a21acab0509af1cdfd2c013cf256bbf5b6b5e2695827162 \
- --hash=sha256:ed9cb427ba5504c1dc15ede7d516b84757c3e3d7868ccc85121d9310d27eed0b \
- --hash=sha256:39d39875251ca8f612b6f33e6b1195af86d1b3e60086068be9cc053aa4376e21 \
- --hash=sha256:285d29981935eb726a4399badae8f0ffdff4f5050eaa6d0cfc3f64b857b77185 \
- --hash=sha256:3eb6971dcff08619f8d91607cfc726518b6fa2a9eba42856be181c6d0d9515fd \
- --hash=sha256:21157295583fe8943475029ed5abdcf71eb3911894724e360acff1d61c1d54bc \
- --hash=sha256:5635bd9cb9731e6d4a1132a498dd34f764034a8ce60cef4f5319c0541159392f \
- --hash=sha256:2012c72d854c2d03e45d06ae57f40d78e5770d252f195b93f581acf3ba44496e \
- --hash=sha256:dd86c085fae2efd48ac91dd7ccffcfc0571387fe1193d33b6394db7ef31fe2a4 \
- --hash=sha256:fa6693661a4c91757f4412306191b6dc88c1703f780c8234035eac011922bc01 \
- --hash=sha256:59c0b02d0a6c384d453fece7566d1c7e6b7bae4fc5874ef2ef46d56776d61c9e \
- --hash=sha256:cba9d6b9a7d64d4bd46167096fc9d2f835e25d7e4c121fb2ddfc6528fb0413b2 \
- --hash=sha256:ce4bcc037df4fc5e3d184794f27bdaab018943698f4ca31630bc7f84a7b69c6d \
- --hash=sha256:3d08afd128ddaa624a48cf2b859afef385b720bb4b43df214f85616922e6a5ac \
- --hash=sha256:3799aecf2e17cf585d977b780ce79ff0dc9b78d799fc694221ce814c2c19db83 \
- --hash=sha256:a591fe9e525846e4d154205572a029f653ada1a78b93697f3b5a8f1f2bc055b9 \
- --hash=sha256:3548db281cd7d2561c9ad9984681c95f7b0e38881201e157833a2342c30d5e8c \
- --hash=sha256:91fc98adde3d7881af9b59ed0294046f3806221863722ba7d8d120c575314325 \
- --hash=sha256:94411f22c3985acaec6f83c6df553f2dbe17b698cc7f8ae751ff2237d96b9e3c \
- --hash=sha256:03425bdae262c76aad70202debd780501fabeaca237cdfddc008987c0e0f59ef \
- --hash=sha256:cc4d65aeeaa04136a12677d3dd0b1c0c94dc43abac5860ab33cceb42b801c1e8 \
- --hash=sha256:a0f100c8912c114ff53e1202d0078b425bee3649ae34d7b070e9697f93c5d52d \
- --hash=sha256:04ed324bda3cda42b9b695d51bb7d54b680b9719cfab04227cdd1e04e5de3104 \
- --hash=sha256:50a74364d85fd319352182ef59c5c790484a336f6db772c1a9231f1c3ed0cbd7 \
- --hash=sha256:e263d77ee3dd201c3a142934a086a4450861778baaeeb45db4591ef65550b0a6 \
- --hash=sha256:cec7d9412a9102bdc577382c3929b337320c4c4c4849f2c5cdd14d7368c5562d \
- --hash=sha256:4289fc34b2f5316fbb762d75362931e351941fa95fa18789191b33fc4cf9504a \
- --hash=sha256:173379135477dc8cac4bc58f45db08ab45d228b3363adb7af79436135d028405 \
- --hash=sha256:6975a3fac6bc83c4a65c9f9fcab9e47019a11d3d2cf7f3c0d03431bf145a941e \
- --hash=sha256:2470043b93ff09bf8fb1d46d1cb756ce6132c54826661a32d4e4d132e1977adf \
- --hash=sha256:30d78fbc8ebf9c92c9b7823ee18eb92f2e6ef79b45ac84db507f52fbe3ec4497 \
- --hash=sha256:198caafb44239b60e252492445da556afafc7d1e3ab7a1fb3f0584ef6d742375 \
- --hash=sha256:5ef34d190326c3b1f822a5b7a45f6c4535e2f47ed06fec77d3d799c450b2651e \
- --hash=sha256:8102eaf27e1e448db915d08afa8b41d6c7ca7a04b7d73af6514df10a3e74bd82 \
- --hash=sha256:5df2768244d19ab7f60546d0c7c63ce1581f7af8b5de3eb3004b9b6fc8a9f84b \
- --hash=sha256:a8c4917bd7ad33e8eb21e9a5bbba979b49d9a97acb3a803092cbc1133e20343c \
- --hash=sha256:0e2642fe3142e4cc4af0799748233ad6da94c62a8bec3a6648bf8ee68b1c7426 \
- --hash=sha256:e229a521186c75c8ad9490854fd8bbdd9a0c9aa3a524326b55be83b54d4e0ad9 \
- --hash=sha256:a0b71b1b8fbf2b96e41c4d990244165e2c9be83d54962a9a1d118fd8657d2045 \
- --hash=sha256:320dab6e7cb2eacdf0e658569d2575c4dad258c0fcc794f46215e1e39f90f2c3 \
- --hash=sha256:1e74c6b51a9ed6589199c787bf5f9875612ca4a8a0785fb2d4a84429badaf22a \
- --hash=sha256:a5c84c68147988265e60416b57fc83425a78058853509c1b0629c180094904a5 \
- --hash=sha256:3b926aa83d1edb5aa5b427b4053dc420ec295a08e40911296b9eb1b6170f6cca \
- --hash=sha256:87c450779d0914f2861b8526e035c5e6da0a3199d8f1add1a665e1cbc6fc6d02 \
- --hash=sha256:4f2c9f67e9821cad2e5f480bc8d83b8742896f1242dba247911072d4fa94c192 \
- --hash=sha256:8b7ee99e510d7b66cdb6c593f21c043c248537a32e0bedf02e01e9553a172314 \
- --hash=sha256:00a9ed42e88df81ffae7a8ab6d9356b371399b91dbdf0c3cb1e84c03a13aceb5 \
- --hash=sha256:54a2db7b78338edd780e7ef7f9f6c442500fb0d41a5a4ea24fff1c929d5af585 \
- --hash=sha256:fcd131dd944808b5bdb38e6f5b53013c5aa4f334c5cad0c72742f6eba4b73db0 \
- --hash=sha256:7473e861101c9e72452f9bf8acb984947aa1661a7704553a9f6e4baa5ba64415 \
- --hash=sha256:6c9a799e985904922a4d207a94eae35c78ebae90e128f0c4e521ce339396be9d \
- --hash=sha256:3bcde07039e586f91b45c88f8583ea7cf7a0770df3a1649627bf598332cb6984 \
- --hash=sha256:33ab79603146aace82c2427da5ca6e58f2b3f2fb5da893ceac0c42218a40be35 \
- --hash=sha256:5d598b938678ebf3c67377cdd45e09d431369c3b1a5b331058c338e201f12b27 \
- --hash=sha256:db0fbb9c62743ce59a9ff687eb5f4afbe77e5e8403d6697f7446e5f609976f76 \
- --hash=sha256:98d85c6a2bef81588d9227dde12db8a7f47f639f4a17c9ae08e773aa9c697bf3 \
- --hash=sha256:40f4774f5a9d4f5e344f31a32b5096977b5d48560c5592e2f3d2c4374bd543ee \
- --hash=sha256:70df4e3b545a17496c9b3f41f5115e69a4f2e77e94e1d2a8e1070bc0c38c8a3c \
- --hash=sha256:d400bfb9a37b1351253cb402671cea7e89bdecc294e8016a707f6d1d8ac934f9
-charset-normalizer==2.1.1; python_version >= "3.7" and python_version < "4" and python_full_version >= "3.6.0"
-cloudpickle==2.2.0; python_version >= "3.6"
+cffi==1.15.1; implementation_name == "pypy" and python_version >= "3.8"
+charset-normalizer==3.0.1; python_version >= "3.7" and python_version < "4"
+cloudpickle==2.2.1; python_version >= "3.6"
colorama==0.4.6; python_version >= "3.8" and python_full_version < "3.0.0" and platform_system == "Windows" and sys_platform == "win32" or python_full_version >= "3.7.0" and platform_system == "Windows" and sys_platform == "win32" and python_version >= "3.8"
comm==0.1.2; python_version >= "3.8"
-contourpy==1.0.6; python_version >= "3.8"
-cycler==0.11.0; python_version >= "3.8" \
- --hash=sha256:3a27e95f763a428a739d2add979fa7494c912a32c17c4c38c4d5f082cad165a3 \
- --hash=sha256:9c87405839a19696e837b3b818fed3f5f69f16f1eec1a1ad77e043dcea9c772f
-cylouvain==0.2.2 \
- --hash=sha256:714ee713b605d6d9cb2a26a9a842c5d4c0a8a8f79e8f0f9357dab179ad4ee55b
-debugpy==1.6.4; python_version >= "3.8"
-decorator==5.1.1; python_version >= "3.8" \
- --hash=sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186 \
- --hash=sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330
-defusedxml==0.7.1; python_version >= "3.8" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.8" \
- --hash=sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61 \
- --hash=sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69
-entrypoints==0.4; python_version >= "3.8" \
- --hash=sha256:f174b5ff827504fd3cd97cc3f8649f3693f51538c7e4bdf3ef002c8429d42f9f \
- --hash=sha256:b706eddaa9218a19ebcd67b56818f05bb27589b1ca9e8d797b74affad4ccacd4
+contourpy==1.0.7; python_version >= "3.8"
+cycler==0.11.0; python_version >= "3.8"
+cylouvain==0.2.2
+debugpy==1.6.6; python_version >= "3.8"
+decorator==5.1.1; python_version >= "3.8"
+defusedxml==0.7.1; python_version >= "3.8" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.8"
executing==1.2.0; python_version >= "3.8"
fastjsonschema==2.16.2; python_version >= "3.8"
fonttools==4.38.0; python_version >= "3.8"
fqdn==1.5.1; python_version >= "3.7" and python_version < "4"
idna==3.4; python_full_version >= "3.6.2" and python_version >= "3.8" and python_version < "4"
-importlib-metadata==5.1.0; python_version < "3.9" and python_version >= "3.8"
-importlib-resources==5.10.1; python_version < "3.9" and python_version >= "3.7"
-ipykernel==6.19.2; python_version >= "3.8"
-ipython-genutils==0.2.0; python_version >= "3.7" \
- --hash=sha256:72dd37233799e619666c9f639a9da83c34013a73e8bbc79a7a6348d93c61fab8 \
- --hash=sha256:eb2e116e75ecef9d4d228fdc66af54269afa26ab4463042e33785b887c628ba8
-ipython==8.7.0; python_version >= "3.8"
+importlib-metadata==6.0.0; python_version < "3.9" and python_version >= "3.8"
+importlib-resources==5.12.0; python_version < "3.9" and python_version >= "3.8"
+ipykernel==6.21.2; python_version >= "3.8"
+ipython-genutils==0.2.0; python_version >= "3.7"
+ipython==8.10.0; python_version >= "3.8"
isoduration==20.11.0; python_version >= "3.7"
jedi==0.18.2; python_version >= "3.8"
-jinja2==3.1.2; python_version >= "3.8" \
- --hash=sha256:6088930bfe239f0e6710546ab9c19c9ef35e29792895fed6e6e31a023a182a61 \
- --hash=sha256:31351a702a408a9e7595a8fc6150fc3f43bb6bf7e319770cbc0db9df9437e852
+jinja2==3.1.2; python_version >= "3.8"
joblib==1.2.0; python_version >= "3.8"
-json5==0.9.10; python_version >= "3.7"
+json5==0.9.11; python_version >= "3.7"
jsonpointer==2.3; python_version >= "3.7" and python_full_version < "3.0.0" or python_version >= "3.7" and python_full_version >= "3.4.0"
jsonschema==4.17.3; python_version >= "3.8"
-jupyter-client==7.4.8; python_full_version >= "3.7.0" and python_version >= "3.8"
-jupyter-core==5.1.0; python_full_version >= "3.7.0" and python_version >= "3.8"
-jupyter-events==0.5.0; python_version >= "3.8"
-jupyter-server-terminals==0.4.2; python_version >= "3.8"
-jupyter-server==2.0.1; python_version >= "3.8"
-jupyterlab-pygments==0.2.2; python_version >= "3.8" \
- --hash=sha256:2405800db07c9f770863bcf8049a529c3dd4d3e28536638bd7c1c01d2748309f \
- --hash=sha256:7405d7fde60819d905a9fa8ce89e4cd830e318cdad22a0030f7a901da705585d
-jupyterlab-server==2.16.5; python_version >= "3.7"
-jupyterlab==3.5.1; python_version >= "3.7"
+jupyter-client==8.0.3; python_full_version >= "3.7.0" and python_version >= "3.8"
+jupyter-core==5.2.0; python_full_version >= "3.7.0" and python_version >= "3.8"
+jupyter-events==0.6.3; python_version >= "3.8"
+jupyter-server-fileid==0.8.0; python_version >= "3.7"
+jupyter-server-terminals==0.4.4; python_version >= "3.8"
+jupyter-server-ydoc==0.6.1; python_version >= "3.7"
+jupyter-server==2.3.0; python_version >= "3.8"
+jupyter-ydoc==0.2.2; python_version >= "3.7"
+jupyterlab-pygments==0.2.2; python_version >= "3.8"
+jupyterlab-server==2.19.0; python_version >= "3.7"
+jupyterlab==3.6.1; python_version >= "3.7"
kiwisolver==1.4.4; python_version >= "3.8"
llvmlite==0.39.1; python_version >= "3.7"
-markupsafe==2.1.1; python_version >= "3.8" \
- --hash=sha256:86b1f75c4e7c2ac2ccdaec2b9022845dbb81880ca318bb7a0a01fbf7813e3812 \
- --hash=sha256:f121a1420d4e173a5d96e47e9a0c0dcff965afdf1626d28de1460815f7c4ee7a \
- --hash=sha256:a49907dd8420c5685cfa064a1335b6754b74541bbb3706c259c02ed65b644b3e \
- --hash=sha256:10c1bfff05d95783da83491be968e8fe789263689c02724e0c691933c52994f5 \
- --hash=sha256:b7bd98b796e2b6553da7225aeb61f447f80a1ca64f41d83612e6139ca5213aa4 \
- --hash=sha256:b09bf97215625a311f669476f44b8b318b075847b49316d3e28c08e41a7a573f \
- --hash=sha256:694deca8d702d5db21ec83983ce0bb4b26a578e71fbdbd4fdcd387daa90e4d5e \
- --hash=sha256:efc1913fd2ca4f334418481c7e595c00aad186563bbc1ec76067848c7ca0a933 \
- --hash=sha256:4a33dea2b688b3190ee12bd7cfa29d39c9ed176bda40bfa11099a3ce5d3a7ac6 \
- --hash=sha256:dda30ba7e87fbbb7eab1ec9f58678558fd9a6b8b853530e176eabd064da81417 \
- --hash=sha256:671cd1187ed5e62818414afe79ed29da836dde67166a9fac6d435873c44fdd02 \
- --hash=sha256:3799351e2336dc91ea70b034983ee71cf2f9533cdff7c14c90ea126bfd95d65a \
- --hash=sha256:e72591e9ecd94d7feb70c1cbd7be7b3ebea3f548870aa91e2732960fa4d57a37 \
- --hash=sha256:6fbf47b5d3728c6aea2abb0589b5d30459e369baa772e0f37a0320185e87c980 \
- --hash=sha256:d5ee4f386140395a2c818d149221149c54849dfcfcb9f1debfe07a8b8bd63f9a \
- --hash=sha256:bcb3ed405ed3222f9904899563d6fc492ff75cce56cba05e32eff40e6acbeaa3 \
- --hash=sha256:e1c0b87e09fa55a220f058d1d49d3fb8df88fbfab58558f1198e08c1e1de842a \
- --hash=sha256:8dc1c72a69aa7e082593c4a203dcf94ddb74bb5c8a731e4e1eb68d031e8498ff \
- --hash=sha256:97a68e6ada378df82bc9f16b800ab77cbf4b2fada0081794318520138c088e4a \
- --hash=sha256:e8c843bbcda3a2f1e3c2ab25913c80a3c5376cd00c6e8c4a86a89a28c8dc5452 \
- --hash=sha256:0212a68688482dc52b2d45013df70d169f542b7394fc744c02a57374a4207003 \
- --hash=sha256:8e576a51ad59e4bfaac456023a78f6b5e6e7651dcd383bcc3e18d06f9b55d6d1 \
- --hash=sha256:4b9fe39a2ccc108a4accc2676e77da025ce383c108593d65cc909add5c3bd601 \
- --hash=sha256:96e37a3dc86e80bf81758c152fe66dbf60ed5eca3d26305edf01892257049925 \
- --hash=sha256:6d0072fea50feec76a4c418096652f2c3238eaa014b2f94aeb1d56a66b41403f \
- --hash=sha256:089cf3dbf0cd6c100f02945abeb18484bd1ee57a079aefd52cffd17fba910b88 \
- --hash=sha256:6a074d34ee7a5ce3effbc526b7083ec9731bb3cbf921bbe1d3005d4d2bdb3a63 \
- --hash=sha256:421be9fbf0ffe9ffd7a378aafebbf6f4602d564d34be190fc19a193232fd12b1 \
- --hash=sha256:fc7b548b17d238737688817ab67deebb30e8073c95749d55538ed473130ec0c7 \
- --hash=sha256:e04e26803c9c3851c931eac40c695602c6295b8d432cbe78609649ad9bd2da8a \
- --hash=sha256:b87db4360013327109564f0e591bd2a3b318547bcef31b468a92ee504d07ae4f \
- --hash=sha256:99a2a507ed3ac881b975a2976d59f38c19386d128e7a9a18b7df6fff1fd4c1d6 \
- --hash=sha256:56442863ed2b06d19c37f94d999035e15ee982988920e12a5b4ba29b62ad1f77 \
- --hash=sha256:3ce11ee3f23f79dbd06fb3d63e2f6af7b12db1d46932fe7bd8afa259a5996603 \
- --hash=sha256:33b74d289bd2f5e527beadcaa3f401e0df0a89927c1559c8566c066fa4248ab7 \
- --hash=sha256:43093fb83d8343aac0b1baa75516da6092f58f41200907ef92448ecab8825135 \
- --hash=sha256:8e3dcf21f367459434c18e71b2a9532d96547aef8a871872a5bd69a715c15f96 \
- --hash=sha256:d4306c36ca495956b6d568d276ac11fdd9c30a36f1b6eb928070dc5360b22e1c \
- --hash=sha256:46d00d6cfecdde84d40e572d63735ef81423ad31184100411e6e3388d405e247 \
- --hash=sha256:7f91197cc9e48f989d12e4e6fbc46495c446636dfc81b9ccf50bb0ec74b91d4b
+markupsafe==2.1.2; python_version >= "3.8"
matplotlib-inline==0.1.6; python_version >= "3.8"
-matplotlib==3.6.2; python_version >= "3.8"
-mistune==2.0.4; python_version >= "3.8"
-nbclassic==0.4.8; python_version >= "3.7"
+matplotlib==3.7.0; python_version >= "3.8"
+mistune==2.0.5; python_version >= "3.8"
+nbclassic==0.5.2; python_version >= "3.7"
nbclient==0.7.2; python_full_version >= "3.7.0" and python_version >= "3.8"
-nbconvert==7.2.6; python_version >= "3.8"
-nbformat==5.7.0; python_full_version >= "3.7.0" and python_version >= "3.8"
+nbconvert==7.2.9; python_version >= "3.8"
+nbformat==5.7.3; python_full_version >= "3.7.0" and python_version >= "3.8"
nest-asyncio==1.5.6; python_version >= "3.8"
networkx==2.8.8; python_version >= "3.8"
notebook-shim==0.2.2; python_version >= "3.7"
notebook==6.5.2; python_version >= "3.7"
numba==0.56.4; python_version >= "3.7"
-numpy==1.23.5
-packaging==22.0; python_version >= "3.8"
-pandas==1.5.2; python_version >= "3.8"
-pandocfilters==1.5.0; python_version >= "3.8" and python_full_version < "3.0.0" or python_full_version >= "3.4.0" and python_version >= "3.8" \
- --hash=sha256:33aae3f25fd1a026079f5d27bdd52496f0e0803b3469282162bafdcbdf6ef14f \
- --hash=sha256:0b679503337d233b4339a817bfc8c50064e2eff681314376a47cb582305a7a38
-parso==0.8.3; python_version >= "3.8" \
- --hash=sha256:c001d4636cd3aecdaf33cbb40aebb59b094be2a74c556778ef5576c175e19e75 \
- --hash=sha256:8c07be290bb59f03588915921e29e8a50002acaf2cdc5fa0e0114f91709fafa0
-pexpect==4.8.0; sys_platform != "win32" and python_version >= "3.8" \
- --hash=sha256:0b48a55dcb3c05f3329815901ea4fc1537514d6ba867a152b581d69ae3710937 \
- --hash=sha256:fc65a43959d153d0114afe13997d439c22823a27cefceb5ff35c2178c6784c0c
-pickleshare==0.7.5; python_version >= "3.8" \
- --hash=sha256:9649af414d74d4df115d5d718f82acb59c9d418196b7b4290ed47a12ce62df56 \
- --hash=sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca
-pillow==9.3.0; python_version >= "3.8"
+numpy==1.23.5; python_version >= "3.8" and python_version < "3.10"
+packaging==23.0; python_version >= "3.8"
+pandas==1.5.3; python_version >= "3.8"
+pandocfilters==1.5.0; python_version >= "3.8" and python_full_version < "3.0.0" or python_full_version >= "3.4.0" and python_version >= "3.8"
+parso==0.8.3; python_version >= "3.8"
+pexpect==4.8.0; sys_platform != "win32" and python_version >= "3.8"
+pickleshare==0.7.5; python_version >= "3.8"
+pillow==9.4.0; python_version >= "3.8"
pkgutil-resolve-name==1.3.10; python_version < "3.9" and python_version >= "3.7"
-platformdirs==2.6.0; python_version >= "3.8"
-prometheus-client==0.15.0; python_version >= "3.8"
-prompt-toolkit==3.0.36; python_full_version >= "3.6.2" and python_version >= "3.8"
+platformdirs==3.0.0; python_version >= "3.8"
+prometheus-client==0.16.0; python_version >= "3.8"
+prompt-toolkit==3.0.37; python_full_version >= "3.7.0" and python_version >= "3.8"
psutil==5.9.4; python_version >= "3.8" and python_full_version < "3.0.0" or python_full_version >= "3.4.0" and python_version >= "3.8"
-ptyprocess==0.7.0; sys_platform != "win32" and python_version >= "3.8" and os_name != "nt" \
- --hash=sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35 \
- --hash=sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220
-pure-eval==0.2.2; python_version >= "3.8" \
- --hash=sha256:01eaab343580944bc56080ebe0a674b39ec44a945e6d09ba7db3cb8cec289350 \
- --hash=sha256:2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3
-py==1.11.0; python_version >= "3.8" and python_full_version < "3.0.0" and implementation_name == "pypy" or implementation_name == "pypy" and python_version >= "3.8" and python_full_version >= "3.5.0" \
- --hash=sha256:607c53218732647dff4acdfcd50cb62615cedf612e72d1724fb1a0cc6405b378 \
- --hash=sha256:51c75c4126074b472f746a24399ad32f6053d1b34b68d2fa41e558e6f4a98719
-pycparser==2.21; python_version >= "3.8" and python_full_version < "3.0.0" and implementation_name == "pypy" or implementation_name == "pypy" and python_version >= "3.8" and python_full_version >= "3.4.0" \
- --hash=sha256:8ee45429555515e1f6b185e78100aea234072576aa43ab53aefcae078162fca9 \
- --hash=sha256:e644fdec12f7872f86c58ff790da456218b10f863970249516d60a5eaca77206
-pygments==2.13.0; python_version >= "3.8"
+ptyprocess==0.7.0; sys_platform != "win32" and python_version >= "3.8" and os_name != "nt"
+pure-eval==0.2.2; python_version >= "3.8"
+pycparser==2.21; python_version >= "3.8" and python_full_version < "3.0.0" and implementation_name == "pypy" or implementation_name == "pypy" and python_version >= "3.8" and python_full_version >= "3.4.0"
+pygments==2.14.0; python_version >= "3.8"
pynndescent==0.5.8
-pyparsing==3.0.9; python_full_version >= "3.6.8" and python_version >= "3.8" \
- --hash=sha256:5026bae9a10eeaefb61dab2f09052b9f4307d44aee4eda64b309723d8d206bbc \
- --hash=sha256:2b020ecf7d21b687f219b71ecad3631f644a47f01403fa1d1036b0c6416d70fb
-pyrsistent==0.19.2; python_version >= "3.7"
-python-dateutil==2.8.2; python_version >= "3.8" and python_full_version < "3.0.0" or python_full_version >= "3.3.0" and python_version >= "3.8" \
- --hash=sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86 \
- --hash=sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9
-python-json-logger==2.0.4; python_version >= "3.8"
-pytz==2022.6; python_version >= "3.8"
+pyparsing==3.0.9; python_full_version >= "3.6.8" and python_version >= "3.8"
+pyrsistent==0.19.3; python_version >= "3.7"
+python-dateutil==2.8.2; python_version >= "3.8" and python_full_version < "3.0.0" or python_full_version >= "3.3.0" and python_version >= "3.8"
+python-json-logger==2.0.7; python_version >= "3.8"
+pytz==2022.7.1; python_version >= "3.8"
pywin32==305; sys_platform == "win32" and platform_python_implementation != "PyPy" and python_version >= "3.8"
-pywinpty==2.0.9; os_name == "nt" and python_version >= "3.8"
-pyyaml==6.0; python_version >= "3.8" \
- --hash=sha256:d4db7c7aef085872ef65a8fd7d6d09a14ae91f691dec3e87ee5ee0539d516f53 \
- --hash=sha256:9df7ed3b3d2e0ecfe09e14741b857df43adb5a3ddadc919a2d94fbdf78fea53c \
- --hash=sha256:77f396e6ef4c73fdc33a9157446466f1cff553d979bd00ecb64385760c6babdc \
- --hash=sha256:a80a78046a72361de73f8f395f1f1e49f956c6be882eed58505a15f3e430962b \
- --hash=sha256:f84fbc98b019fef2ee9a1cb3ce93e3187a6df0b2538a651bfb890254ba9f90b5 \
- --hash=sha256:2cd5df3de48857ed0544b34e2d40e9fac445930039f3cfe4bcc592a1f836d513 \
- --hash=sha256:daf496c58a8c52083df09b80c860005194014c3698698d1a57cbcfa182142a3a \
- --hash=sha256:897b80890765f037df3403d22bab41627ca8811ae55e9a722fd0392850ec4d86 \
- --hash=sha256:50602afada6d6cbfad699b0c7bb50d5ccffa7e46a3d738092afddc1f9758427f \
- --hash=sha256:48c346915c114f5fdb3ead70312bd042a953a8ce5c7106d5bfb1a5254e47da92 \
- --hash=sha256:98c4d36e99714e55cfbaaee6dd5badbc9a1ec339ebfc3b1f52e293aee6bb71a4 \
- --hash=sha256:0283c35a6a9fbf047493e3a0ce8d79ef5030852c51e9d911a27badfde0605293 \
- --hash=sha256:07751360502caac1c067a8132d150cf3d61339af5691fe9e87803040dbc5db57 \
- --hash=sha256:819b3830a1543db06c4d4b865e70ded25be52a2e0631ccd2f6a47a2822f2fd7c \
- --hash=sha256:473f9edb243cb1935ab5a084eb238d842fb8f404ed2193a915d1784b5a6b5fc0 \
- --hash=sha256:0ce82d761c532fe4ec3f87fc45688bdd3a4c1dc5e0b4a19814b9009a29baefd4 \
- --hash=sha256:231710d57adfd809ef5d34183b8ed1eeae3f76459c18fb4a0b373ad56bedcdd9 \
- --hash=sha256:c5687b8d43cf58545ade1fe3e055f70eac7a5a1a0bf42824308d868289a95737 \
- --hash=sha256:d15a181d1ecd0d4270dc32edb46f7cb7733c7c508857278d3d378d14d606db2d \
- --hash=sha256:0b4624f379dab24d3725ffde76559cff63d9ec94e1736b556dacdfebe5ab6d4b \
- --hash=sha256:213c60cd50106436cc818accf5baa1aba61c0189ff610f64f4a3e8c6726218ba \
- --hash=sha256:9fa600030013c4de8165339db93d182b9431076eb98eb40ee068700c9c813e34 \
- --hash=sha256:277a0ef2981ca40581a47093e9e2d13b3f1fbbeffae064c1d21bfceba2030287 \
- --hash=sha256:d4eccecf9adf6fbcc6861a38015c2a64f38b9d94838ac1810a9023a0609e1b78 \
- --hash=sha256:1e4747bc279b4f613a09eb64bba2ba602d8a6664c6ce6396a4d0cd413a50ce07 \
- --hash=sha256:055d937d65826939cb044fc8c9b08889e8c743fdc6a32b33e2390f66013e449b \
- --hash=sha256:e61ceaab6f49fb8bdfaa0f92c4b57bcfbea54c09277b1b4f7ac376bfb7a7c174 \
- --hash=sha256:d67d839ede4ed1b28a4e8909735fc992a923cdb84e618544973d7dfc71540803 \
- --hash=sha256:cba8c411ef271aa037d7357a2bc8f9ee8b58b9965831d9e51baf703280dc73d3 \
- --hash=sha256:40527857252b61eacd1d9af500c3337ba8deb8fc298940291486c465c8b46ec0 \
- --hash=sha256:b5b9eccad747aabaaffbc6064800670f0c297e52c12754eb1d976c57e4f74dcb \
- --hash=sha256:b3d267842bf12586ba6c734f89d1f5b871df0273157918b0ccefa29deb05c21c \
- --hash=sha256:68fb519c14306fec9720a2a5b45bc9f0c8d1b9c72adf45c37baedfcd949c35a2
-pyzmq==24.0.1; python_version >= "3.8"
-requests==2.28.1; python_version >= "3.7" and python_version < "4" \
- --hash=sha256:8fefa2a1a1365bf5520aac41836fbee479da67864514bdb821f31ce07ce65349 \
- --hash=sha256:7c5599b102feddaa661c826c56ab4fee28bfd17f5abca1ebbe3e7f19d7c97983
-rfc3339-validator==0.1.4; python_version >= "3.7" and python_full_version < "3.0.0" or python_version >= "3.7" and python_full_version >= "3.5.0"
-rfc3986-validator==0.1.1; python_version >= "3.7" and python_full_version < "3.0.0" or python_version >= "3.7" and python_full_version >= "3.5.0"
-scikit-learn==1.2.0; python_version >= "3.8"
-scipy==1.9.3; python_version >= "3.8"
-send2trash==1.8.0; python_version >= "3.8" \
- --hash=sha256:f20eaadfdb517eaca5ce077640cb261c7d2698385a6a0f072a4a5447fd49fa08 \
- --hash=sha256:d2c24762fd3759860a0aff155e45871447ea58d2be6bdd39b5c8f966a0c99c2d
-setuptools-scm==7.0.5; python_version >= "3.8"
+pywinpty==2.0.10; os_name == "nt" and python_version >= "3.8"
+pyyaml==6.0; python_version >= "3.8"
+pyzmq==25.0.0; python_version >= "3.8"
+requests==2.28.2; python_version >= "3.7" and python_version < "4"
+rfc3339-validator==0.1.4; python_version >= "3.8" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.8"
+rfc3986-validator==0.1.1; python_version >= "3.8" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.8"
+scikit-learn==1.2.1; python_version >= "3.8"
+scipy==1.10.1; python_version >= "3.8" and python_version < "3.12"
+send2trash==1.8.0; python_version >= "3.8"
+setuptools-scm==7.1.0; python_version >= "3.8"
shap==0.41.0
-six==1.16.0; python_version >= "3.8" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.8" \
- --hash=sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254 \
- --hash=sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926
-slicer==0.0.7; python_version >= "3.6" \
- --hash=sha256:0b94faa5251c0f23782c03f7b7eedda91d80144059645f452c4bc80fab875976 \
- --hash=sha256:f5d5f7b45f98d155b9c0ba6554fa9770c6b26d5793a3e77a1030fb56910ebeec
+six==1.16.0; python_version >= "3.8" and python_full_version < "3.0.0" or python_full_version >= "3.5.0" and python_version >= "3.8"
+slicer==0.0.7; python_version >= "3.6"
sniffio==1.3.0; python_full_version >= "3.6.2" and python_version >= "3.8"
-soupsieve==2.3.2.post1; python_full_version >= "3.6.0" and python_version >= "3.8" \
- --hash=sha256:3b2503d3c7084a42b1ebd08116e5f81aadfaea95863628c80a3b774a11b7c759 \
- --hash=sha256:fc53893b3da2c33de295667a0e19f078c14bf86544af307354de5fcf12a3f30d
+soupsieve==2.4; python_full_version >= "3.6.0" and python_version >= "3.8"
stack-data==0.6.2; python_version >= "3.8"
terminado==0.17.1; python_version >= "3.8"
-threadpoolctl==3.1.0; python_version >= "3.8" \
- --hash=sha256:8b99adda265feb6773280df41eece7b2e6561b772d21ffd52e372f999024907b \
- --hash=sha256:a335baacfaa4400ae1f0d8e3a58d6674d2f8828e3716bb2802c44955ad391380
+threadpoolctl==3.1.0; python_version >= "3.8"
tinycss2==1.2.1; python_version >= "3.8"
-tomli==2.0.1; python_version >= "3.8" \
- --hash=sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc \
- --hash=sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f
+tomli==2.0.1; python_version < "3.11" and python_version >= "3.8"
tornado==6.2; python_version >= "3.8"
tqdm==4.64.1; python_version >= "2.7" and python_full_version < "3.0.0" or python_full_version >= "3.4.0"
-traitlets==5.7.0; python_full_version >= "3.7.0" and python_version >= "3.8"
-typing-extensions==4.4.0; python_version >= "3.8"
-umap-learn==0.5.3 \
- --hash=sha256:dbd57cb181c2b66d238acb5635697526bf24c798082daed0cf9b87f6a3a6c0c7
+traitlets==5.9.0; python_full_version >= "3.7.0" and python_version >= "3.8"
+typing-extensions==4.5.0; python_version >= "3.8"
+umap-learn==0.5.3
uri-template==1.2.0; python_version >= "3.7"
-urllib3==1.26.13; python_version >= "3.7" and python_full_version < "3.0.0" and python_version < "4" or python_version >= "3.7" and python_version < "4" and python_full_version >= "3.6.0"
-wcwidth==0.2.5; python_full_version >= "3.6.2" and python_version >= "3.8" \
- --hash=sha256:beb4802a9cebb9144e99086eff703a642a13d6a0052920003a230f3294bbe784 \
- --hash=sha256:c4d647b99872929fdb7bdcaa4fbe7f01413ed3d98077df798530e5b04f116c83
+urllib3==1.26.14; python_version >= "3.7" and python_full_version < "3.0.0" and python_version < "4" or python_version >= "3.7" and python_version < "4" and python_full_version >= "3.6.0"
+wcwidth==0.2.6; python_full_version >= "3.7.0" and python_version >= "3.8"
webcolors==1.12; python_version >= "3.7"
-webencodings==0.5.1; python_version >= "3.8" \
- --hash=sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78 \
- --hash=sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923
-websocket-client==1.4.2; python_version >= "3.8"
-xgboost==1.7.2; python_version >= "3.8"
-xyzservices==2022.9.0; python_version >= "3.8"
-zipp==3.11.0; python_version < "3.9" and python_version >= "3.7"
+webencodings==0.5.1; python_version >= "3.8"
+websocket-client==1.5.1; python_version >= "3.8"
+xgboost==1.7.4; python_version >= "3.8"
+xyzservices==2023.2.0; python_version >= "3.8"
+y-py==0.5.9; python_version >= "3.7"
+ypy-websocket==0.8.2; python_version >= "3.7"
+zipp==3.14.0; python_version < "3.9" and python_version >= "3.8"