{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Experiment: Flashed gratings" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Initialization" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Imports" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%matplotlib inline\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "import scipy\n", "import scipy.stats as sts\n", "import pickle as pkl\n", "import ipywidgets as widgets\n", "from mpl_toolkits import mplot3d\n", "from mpl_toolkits.mplot3d import Axes3D\n", "from scipy import sparse\n", "import sys\n", "from matplotlib import cm\n", "sys.path.insert(0, '../model/')\n", "\n", "# color maps\n", "cmap_hot = cm.get_cmap('hot')\n", "cmap_viridis = cm.get_cmap('viridis')\n", "cmap_jet = cm.get_cmap('jet')" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "\n", "data_folder = \"../data/\"\n", "stim_file = \"Stiminfo_PVCre_2021_0012_s06_e14.csv\"\n", "spike_times_file = \"Spiketimes_PVCre_2021_0012_s06_e14.npy\"\n", "\n", "key_symbol = {'pair':'$(\\\\theta,\\phi)$', 'orientation':'$\\\\theta$', 'phase':'$\\phi$'}" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dict_keys(['data_folder', 'stim_file', 'spike_times_file', 'key_symbol', 'stim', 'num_trial', 'stim_val', 'trial_stim_id', 'key_list', 'stim_id_trial', 'num_stim', 'key', 'pair_id', 'trial_pair_id', 'pair_val', 'pair_trial_id', 'spike_times', 'num_unit', 'num_spike', 'spike_count_rate', 'avg_firing_rate', 'firing_rate', 'stim_num_trial', 'stim_hist', 'optimal_avg_firing_rate', 'latest_spike_time', 'dt', 'exp_time', 'B_stim', 'trials', 't_on', 't_off', 'B_spike', 'trial_range', 'units', 'orientation', 'phase', 'trial_spike_times', 'delta_t_on', 'delta_t_off', 'subseq_trials', 'subseq_spike_times', 'subseq_spike_times_locked', 'time_range', 'unit_id_2', 'p1', 'p2', 'delta_t', 'time_range_smoothing', 'period_1_dist', 'period_2_dist', 'period_3_dist', 'num_units', 'max_p_1', 'max_p_2', 'max_p_3', 'delta_2', 'delta_3', 't_p1', 't_p2', 'subseq_spike_times_locked_2', 'B_spike_fixed', 'B_stim_original', 'B_spike_smooth', 'B_stim_total', 'R', 'R_pair_smoothed', 'Rp', 'firing_rates_noise_red', 'firing_rates_flat', 'firing_rates_in_trials', 'avg_firing_rates'])\n" ] } ], "source": [ "file = open(\"dump.pkl\", 'rb')\n", "pair_id = None\n", "data = pkl.load(file)\n", "print(data.keys())\n", "for key, value in data.items():\n", " globals()[key] = value\n", "file.close()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Load the stimulus data\n", "**Stimulus data layout:**\n", "```\n", "stim_val = {'pair': [(or1, ph1), (or2, ph2), ...], 'orientation': [...], 'phase': [...]}\n", "stim_id_trial = {'pair': [id1, id2, ...], 'phase': [..], ...} # corresponding trials\n", "pair_trial_id[orientation_id][phase_id] = [Trial ids]\n", "```" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Stimulus DataFrame\n", "stim = pd.read_csv(data_folder + stim_file)\n", "num_trial = len(stim)\n", "stim_val = {}\n", "trial_stim_id = {}\n", "# 50 trials per orientation-phase pair\n", "stim_val['pair'], trial_stim_id['pair'] = np.unique(stim[['grat_orientation', 'grat_phase']], return_inverse=True, axis=0) \n", "# 1000 trials per orientation\n", "stim_val['orientation'], trial_stim_id['orientation'] = np.unique(stim['grat_orientation'], return_inverse=True) \n", "# 1000 trials per phase\n", "stim_val['phase'], trial_stim_id['phase'] = np.unique(stim['grat_phase'], return_inverse=True) \n", "key_list = ['pair', 'orientation', 'phase']\n", "stim_id_trial = {}\n", "num_stim = {}\n", "for key in key_list:\n", " stim_id_trial[key] = [np.where(trial_stim_id[key] == i)[0] for i in range(len(stim_val[key]))]\n", " num_stim[key] = len(stim_val[key])\n", "\n", "def pair_id(i):\n", " return (int(i//num_stim['orientation']), i%num_stim['orientation'])\n", "\n", "trial_pair_id = np.array([pair_id(i) for i in trial_stim_id['pair']], dtype=object)\n", "pair_val = stim_val['pair'].reshape(num_stim['orientation'], num_stim['phase'],2)\n", "\n", "# for each (orientation_id = i, phase_id = j) find the trial indices\n", "pair_trial_id = np.ndarray((num_stim['orientation'], num_stim['phase']), dtype=object)\n", "for i in range(num_stim['pair']):\n", " pair_trial_id[pair_id(i)] = stim_id_trial['pair'][i]" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
Unnamed: 0grat_orientationgrat_phasestimvalsstim_ontimestim_offtime
0045.036.01022.50052.5839
110.018.012.61952.7028
22162.0288.03762.70302.7863
330.054.032.78652.8699
44108.036.02422.87002.9534
\n", "
" ], "text/plain": [ " Unnamed: 0 grat_orientation grat_phase stimvals stim_ontime \\\n", "0 0 45.0 36.0 102 2.5005 \n", "1 1 0.0 18.0 1 2.6195 \n", "2 2 162.0 288.0 376 2.7030 \n", "3 3 0.0 54.0 3 2.7865 \n", "4 4 108.0 36.0 242 2.8700 \n", "\n", " stim_offtime \n", "0 2.5839 \n", "1 2.7028 \n", "2 2.7863 \n", "3 2.8699 \n", "4 2.9534 " ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "stim.head()" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "pair, orientation, phase\n", "(400, 2)\n", "(20,) (20,)\n" ] } ], "source": [ "print(', '.join(stim_val.keys()))\n", "print(stim_val['pair'].shape)\n", "print(stim_val['orientation'].shape, stim_val['phase'].shape)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 82 482 1021 1421 1821 2183 2645 3045 3445 3643 4357 4757\n", " 5014 5493 5893 6293 6693 6965 7365 7652 8052 8513 9116 9203\n", " 9603 10003 10628 10849 11512 11912 12312 12535 12947 13347 13666 14248\n", " 14682 14857 15257 15657 16393 16793 17193 17262 17906 18146 18546 19050\n", " 19450 19904]\n" ] } ], "source": [ "print(stim_id_trial['pair'][0])" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 82, 482, 1021, 1421, 1821, 2183, 2645, 3045, 3445,\n", " 3643, 4357, 4757, 5014, 5493, 5893, 6293, 6693, 6965,\n", " 7365, 7652, 8052, 8513, 9116, 9203, 9603, 10003, 10628,\n", " 10849, 11512, 11912, 12312, 12535, 12947, 13347, 13666, 14248,\n", " 14682, 14857, 15257, 15657, 16393, 16793, 17193, 17262, 17906,\n", " 18146, 18546, 19050, 19450, 19904])" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pair_trial_id[0][0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Stimulus data layout:**\n", "```\n", "stim_val = {'pair': [(or1, ph1), (or2, ph2), ...], 'orientation': [...], 'phase': [...]}\n", "stim_id_trial = {'pair': [id1, id2, ...], 'phase': [..], ...} # corresponding trials\n", "pair_trial_id[orientation_id][phase_id] = [Trial ids]\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Load the spike data and correlations\n", "```\n", "Loaded: spike_count_rate, avg_firing_rate, sem_firing_rate, firing_rate, stim_num_trial, C_r_fphi_theta, theta_hist, phase_hist, pair_hist\n", "Loaded: corr_stim_unit, optimal_avg_firing_rate, stim_hist, stim_hist_caution\n", "```" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(40,)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "spike_times_file = \"Spiketimes_PVCre_2021_0012_s06_e14.npy\"\n", "spike_times = np.load(data_folder+spike_times_file, allow_pickle=True)\n", "active = [len(spike_times[i]) > 0 for i in range(len(spike_times))]\n", "spike_times = spike_times[np.where(active)]\n", "num_unit = len(spike_times)\n", "spike_times.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Sort spikes by firing rate**" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "\n", "num_spike = list(map(len, spike_times))\n", "spike_times = spike_times[np.argsort(num_spike)[::-1]]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Load a lot of variables out of a `.pkl` file**" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Loaded: spike_count_rate, avg_firing_rate, sem_firing_rate, firing_rate, stim_num_trial, C_r_fphi_theta, theta_hist, phase_hist, pair_hist\n", "Loaded: corr_stim_unit, optimal_avg_firing_rate, stim_hist, stim_hist_caution\n" ] } ], "source": [ "# yeah...\n", "files = ['spike_data.pkl', 'corr_data.pkl']\n", "for file_name in files:\n", " file = open(file_name, 'rb')\n", " data = pkl.load(file)\n", " print('Loaded:', ', '.join(data.keys()))\n", " for key, value in data.items():\n", " globals()[key] = value\n", "\n", " file.close()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Spike and stimulus preprocessing\n", "\n", "```\n", "B_stim = {'pair': [mat_stim_1, mat_stim_2, ..], 'orientation': .., ...}\n", "```\n", "\n", "`mat_stim_i` is a matrix of shape `(1, M)` such that `mat[0][t] = 1` if there was stimuli at time $t$ and $0$ if not\n", "\n", "```\n", "B_spike = [unit_1_spikes, unit_2_spikes, ..]\n", "unit_1_spikes[t] = 1 if there was a spike, 0 if not\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Read the data" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# reverse correlation time offset range \n", "max_delay = 300 # dt\n", "tau_id_range = np.arange(max_delay)\n", "\n", "# experiment duration\n", "latest_spike_time = max([np.max(s) for s in spike_times if len(s)])\n", "latest_stim_offtime = list(stim['stim_offtime'])[-1]\n", "experiment_dur = max([latest_spike_time, latest_stim_offtime])\n", "\n", "dt = 0.001 # 1 ms\n", "exp_time = np.arange(0, experiment_dur, dt)\n", "M = len(exp_time)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "B_stim = {}\n", "for key in key_list:\n", " B_stim[key] = []\n", " for stim_id, trials in enumerate(stim_id_trial[key]):\n", " B_stim[key].append([])\n", " s = []\n", " for trial_id in trials:\n", " t_on, t_off = stim['stim_ontime'][trial_id], stim['stim_offtime'][trial_id]\n", " s += list(np.arange(int(t_on//dt), int(t_off//dt)))\n", "\n", " B_stim[key][stim_id] = sparse.coo_matrix((np.ones(len(s)), (np.zeros(len(s), dtype=int), s)), shape=(1, M))\n", "s = spike_times//dt\n", "B_spike = []\n", "for unit_id in range(num_unit):\n", " B_spike.append(sparse.coo_matrix((np.ones(len(s[unit_id])), (np.zeros(len(s[unit_id]), dtype=int), np.int0(s[unit_id]))), shape=(1, M)))" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "sorted_spike_num = np.sort(num_spike)[::-1]\n", "cutoff_num_spike = 1000\n", "num_unit = np.sum(sorted_spike_num > cutoff_num_spike)\n", "for key in key_list:\n", " stim_hist[key] = stim_hist[key][:num_unit]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Some plots" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This graph shows for unit 0 at a particular moment:\n", "- One stimulus duration (blue)\n", "- The second stimulus (red)\n", "\n", "And spike events" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "stim_id = 10\n", "trial_id = stim_id_trial['phase'][stim_id][0]\n", "unit_id = 0\n", "t_on, t_off = stim['stim_ontime'][trial_id], stim['stim_offtime'][trial_id]\n", "t0, t1 = t_off-0.2, t_off+0.1\n", "stim_prev_id = trial_stim_id['phase'][trial_id-1]\n", "t_prev_on, t_prev_off = stim['stim_ontime'][trial_id-1], stim['stim_offtime'][trial_id-1]\n", "spikes = spike_times[unit_id][np.where((t0 < spike_times[unit_id]) & (spike_times[unit_id] < t1))]\n", "plt.axvspan(t_on, t_off, color=cmap_jet(1-np.abs(stim_id-10)/10), alpha=0.3)\n", "plt.axvspan(t_prev_on, t_prev_off, color=cmap_jet(1-np.abs(stim_prev_id-10)/10), alpha=0.3)\n", "plt.eventplot(spikes)\n", "plt.xlim([t0, t1])\n", "plt.title('Spikes for unit 0')\n", "plt.xlabel('Time')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from matplotlib import gridspec\n", "\n", "fig, ax = plt.subplots(3,1,figsize=(7,7))\n", "gs0 = gridspec.GridSpec(3, 3, figure=fig, hspace=0, wspace=0)\n", "\n", "stim_id = 10\n", "trial_id = stim_id_trial['phase'][stim_id][0]\n", "unit_id = 0\n", "t_on, t_off = stim['stim_ontime'][trial_id], stim['stim_offtime'][trial_id]\n", "t0, t1 = t_off-0.2, t_off+0.1\n", "stim_prev_id = trial_stim_id['phase'][trial_id-1]\n", "t_prev_on, t_prev_off = stim['stim_ontime'][trial_id-1], stim['stim_offtime'][trial_id-1]\n", "spikes = spike_times[unit_id][np.where((t0 < spike_times[unit_id]) & (spike_times[unit_id] < t1))]\n", "\n", "ax0 = fig.add_subplot(gs0[0, :-1])\n", "ax1 = fig.add_subplot(gs0[1, :-1])\n", "ax2 = fig.add_subplot(gs0[2, :-1])\n", "ax3 = fig.add_subplot(gs0[:, -1])\n", "\n", "ax0.axvspan(t_on, t_off, color=cmap_jet(1-np.abs(stim_id-10)/10), alpha=0.3, label='preferred')\n", "ax0.axvspan(t_prev_on, t_prev_off, color=cmap_jet(1-np.abs(stim_prev_id-10)/10), alpha=0.3, label='non-preferred')\n", "ax0.eventplot(spikes)\n", "ax0.set_xlim([t0, t1])\n", "ax0.legend(loc='upper left')\n", "\n", "ax1.axvspan(t_on, t_off, color=cmap_jet(1-np.abs(stim_id-10)/10), alpha=0.3)\n", "ax1.axvspan(t_prev_on, t_prev_off, color=cmap_jet(1-np.abs(stim_prev_id-10)/10), alpha=0.3)\n", "ax1.eventplot(spikes-0.05)\n", "ax1.set_xlim([t0, t1])\n", "\n", "ax2.axvspan(t_on, t_off, color=cmap_jet(1-np.abs(stim_id-10)/10), alpha=0.3)\n", "ax2.axvspan(t_prev_on, t_prev_off, color=cmap_jet(1-np.abs(stim_prev_id-10)/10), alpha=0.3)\n", "ax2.eventplot(spikes-0.15)\n", "ax2.set_xlim([t0, t1])\n", "\n", "ax3.plot(np.sin(np.pi*tau_id_range/300), np.arange(300))\n", "ax3.set_xticks([])\n", "ax3.set_yticks([])\n", "ax3.set_title('reverse correlation')\n", "# ax2.legend()\n", "for ax in fig.get_axes():\n", " ax.tick_params(bottom=False, labelbottom=False, left=False, labelleft=False)\n", "\n", "ax2.tick_params(bottom=True, labelbottom=True)\n", "ax2.set_xlabel('t/s')\n", "plt.tight_layout()\n", "fig.suptitle('subspace reverse correlation', size=16, y=1.05)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# subspace reverese correlation\n", "stim_id = 13\n", "ref_trial_id = stim_id_trial['phase'][stim_id][0]\n", "stim_prev_id = trial_stim_id['phase'][ref_trial_id-1]\n", "past_trials = 3\n", "future_trials = 10\n", "trial_range = np.arange(-past_trials, future_trials+1) + ref_trial_id\n", "\n", "units = np.arange(num_unit)\n", "orientation, phase, t_on = np.array(stim[['grat_orientation', 'grat_phase','stim_ontime']].iloc[trial_range]).T\n", "spikes = [\n", " spike_times[unit_id][\n", " # Where the spike occurs during the stimulus period in one of the right trials\n", " np.where((t_on[0] < spike_times[unit_id]) & (spike_times[unit_id] < t_on[-1]))\n", " ]\n", " for unit_id in units]\n", "\n", "fig, ax = plt.subplots(2,1,figsize=(7,7))\n", "plt.subplots_adjust(hspace=0)\n", "s = 1\n", "ax[0].eventplot(spikes, linelength=s, lineoffsets=s)\n", "\n", "ref_id = list(trial_range).index(ref_trial_id)\n", "# ax[0].axvspan(t_on[ref_id], t_on[ref_id]+0.08, color=cmap_jet(1-np.abs(stim_id-10)/10), alpha=0.3)\n", "# ax[0].axvspan(t_on[ref_id-1], t_on[ref_id-1]+0.08, color=cmap_jet(1-np.abs(stim_prev_id-10)/10), alpha=0.3)\n", "ax[0].set(ylabel='unit')\n", "ax[0].invert_yaxis()\n", "ax[1].step(t_on, phase, 'b', where='post', alpha=0.5, label='phase')\n", "ax[1].set(xlabel='t / s', xlim=[t_on[0], t_on[-1]], ylim=[0, 360], ylabel='phase')\n", "ax[1].legend(loc='upper left')\n", "ax2 = ax[1].twinx()\n", "ax2.step(t_on, orientation, 'r', where='post', alpha=0.5, label='orientation')\n", "ax2.set(ylim=[0, 180], ylabel='orientation')\n", "ax2.legend()\n", "ax[0].set_title('Spikes in units')\n", "ax[1].set_title('Phase and orientation')\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "afc70624cbfe4a5f8838bce9ae0c0ebc", "version_major": 2, "version_minor": 0 }, "text/plain": [ "interactive(children=(IntSlider(value=0, description='delay/ms', max=299), IntSlider(value=0, description='uni…" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "@widgets.interact(key=widgets.RadioButtons(options=key_list[1:],\n", " description='stimulus:',\n", " disabled=False), tau_id=widgets.IntSlider(0, min=0, max=max_delay-1, description='delay/ms'), unit_id=widgets.IntSlider(0, min=0, max=num_unit-1))\n", "\n", "def PSSH(tau_id, unit_id, key):\n", " fig, ax = plt.subplots(1, 1, figsize=(7,6))\n", " prob = stim_hist[key][unit_id, tau_id]\n", " n = sorted_spike_num[unit_id]\n", " confidence_interval = np.sqrt(prob/n)\n", " plt.errorbar(stim_val[key], stim_hist[key][unit_id, tau_id], yerr=confidence_interval)\n", " ymin = np.min(stim_hist[key][unit_id])*0.95\n", " ymax = np.max(stim_hist[key][unit_id])*1.05\n", " ax.set_ylabel('$\\mathcal{P}($'+key_symbol[key]+'$|\\\\tau)$')\n", " ax.set_xlabel(key_symbol[key])\n", " plt.ylim([ymin, ymax])\n", " plt.suptitle('Distribution of stimulus at time $\\\\tau$ before a spike of unit: %d'%unit_id)\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Problem with the data\n", "\n", "The picture a couple of cells below clearly shows that there is a shift in the stimulus presentation times. Let's fix it!" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3.10/site-packages/pandas/core/roperator.py:13: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", " return right - left\n" ] } ], "source": [ "trial_spike_times = np.ndarray((num_unit, num_trial), dtype=object)\n", "delta_t_on = 0.2 # 200ms\n", "delta_t_off = 0.3\n", "for trial_id in range(num_trial):\n", " t_on, t_off = stim['stim_ontime'][trial_id]-delta_t_on, stim['stim_offtime'][trial_id]+delta_t_off\n", " for unit_id in range(num_unit):\n", " trial_spike_times[unit_id, trial_id] = spike_times[unit_id][np.where((spike_times[unit_id] < t_off) & (spike_times[unit_id] > t_on))]\n", "subseq_trials = 5\n", "subseq_spike_times = np.ndarray(num_unit, dtype=object)\n", "for unit_id in range(num_unit):\n", " subseq_spike_times[unit_id] = [np.concatenate(trial_spike_times[unit_id][i:i+subseq_trials]) for i in range(num_trial-subseq_trials)]\n", "\n", "subseq_spike_times_locked = {}\n", "subseq_spike_times_locked['ontime'] = [subseq_spike_times[unit_id] - stim['stim_ontime'][:-subseq_trials] for unit_id in range(num_unit)]\n", "subseq_spike_times_locked['offtime'] = [subseq_spike_times[unit_id] - stim['stim_offtime'][:-subseq_trials] for unit_id in range(num_unit)]" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "time_range = np.arange(0, stim['stim_ontime'].max(), np.array(sorted(np.diff(stim['stim_ontime'], n=1))[10:-10]).mean())" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "((28, 19995), (28, 19995), 0.7671829999999886)" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "subseq_spike_times_len = len(subseq_spike_times[0])\n", "subseq_spike_times_locked['ontime'] = np.array(subseq_spike_times_locked['ontime'])\n", "subseq_spike_times_locked['offtime'] = np.array(subseq_spike_times_locked['offtime'])\n", "from itertools import chain\n", "subseq_spike_times_locked['ontime'].shape, subseq_spike_times_locked['offtime'].shape, max(chain(*subseq_spike_times_locked['ontime'].flatten()))" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "unit_id = 1\n", "unit_id_2 = 3\n", "\n", "fig, ax = plt.subplots(1,3, figsize=(20,10))\n", "ax[0].plot(np.diff(stim['stim_ontime'], n=2), np.arange(20000-2))\n", "ax[0].invert_yaxis()\n", "ax[0].set_xlabel('$\\Delta^2[t_{on}]=\\Delta$ trial duration / s', size=20)\n", "ax[0].set(ylabel='trials')\n", "ax[1].eventplot(subseq_spike_times_locked['ontime'][unit_id], lineoffsets=1, linelengths=0.8)\n", "ax[1].set(title='unit %d'%unit_id, yticks=[], xlabel='t/s (locked to trial onsets)')\n", "ax[1].invert_yaxis()\n", "ax[2].eventplot(subseq_spike_times_locked['ontime'][unit_id_2], lineoffsets=1, linelengths=0.8)\n", "ax[2].set(title='unit %d'%(unit_id_2), yticks=[], xlabel='t/s (locked to trial ends)')\n", "ax[2].invert_yaxis()\n", "plt.subplots_adjust(wspace=0)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "_Whaaat?_\n", "\n", "Ok, we've gotta fix it.\n", "\n", "Let's take the \"bad\" times, identify the periods we want to calibrate - and align everything" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2280 2286 2291 2292 2295 2298 2301 2307 2377 2378 2380 2383 2386 2464 2467 2469 2472 2475 2478 15300 15306 15312 15315 15316 15318 15327 15329 15333 15336 15338 15342 15344 15348 15349 15402 15403 15405 15408\n" ] } ], "source": [ "stim_2diffs = np.diff(stim['stim_ontime'], n=2)\n", "print(*[i for i in range(len(stim_2diffs)) if stim_2diffs[i] > 0.01])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Periods:\n", "$[0, 2350)$, $[2350, 15350)$, $[15350, 20000]$" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_4135643/175591453.py:20: DeprecationWarning: Please use `gaussian_filter1d` from the `scipy.ndimage` namespace, the `scipy.ndimage.filters` namespace is deprecated.\n", " period_1_dist = scipy.ndimage.filters.gaussian_filter1d(period_1_dist, sigma=10)\n", "/tmp/ipykernel_4135643/175591453.py:21: DeprecationWarning: Please use `gaussian_filter1d` from the `scipy.ndimage` namespace, the `scipy.ndimage.filters` namespace is deprecated.\n", " period_2_dist = scipy.ndimage.filters.gaussian_filter1d(period_2_dist, sigma=10)\n", "/tmp/ipykernel_4135643/175591453.py:22: DeprecationWarning: Please use `gaussian_filter1d` from the `scipy.ndimage` namespace, the `scipy.ndimage.filters` namespace is deprecated.\n", " period_3_dist = scipy.ndimage.filters.gaussian_filter1d(period_3_dist, sigma=10)\n" ] } ], "source": [ "p1, p2 = 2350, 15350\n", "delta_t = 0.002\n", "time_range_smoothing = np.arange(0, 0.8, delta_t)\n", "period_1_dist = np.zeros(len(time_range_smoothing) - 1)\n", "period_2_dist = np.zeros(len(time_range_smoothing) - 1)\n", "period_3_dist = np.zeros(len(time_range_smoothing) - 1)\n", "num_units = subseq_spike_times_locked['ontime'].shape[0]\n", "for i in range(num_units):\n", " for j, row in enumerate(subseq_spike_times_locked['ontime'][i]):\n", " hist = np.histogram(row, bins=time_range_smoothing)[0]\n", " if j < p1:\n", " period_1_dist += hist\n", " elif j < p2:\n", " period_2_dist += hist\n", " else:\n", " period_3_dist += hist\n", "period_1_dist /= num_units\n", "period_2_dist /= num_units\n", "period_3_dist /= num_units\n", "period_1_dist = scipy.ndimage.filters.gaussian_filter1d(period_1_dist, sigma=10)\n", "period_2_dist = scipy.ndimage.filters.gaussian_filter1d(period_2_dist, sigma=10)\n", "period_3_dist = scipy.ndimage.filters.gaussian_filter1d(period_3_dist, sigma=10)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(3, 1, figsize=(10,20))\n", "ax[0].plot(time_range_smoothing[:-1], period_1_dist, label='period 1')\n", "ax[1].plot(time_range_smoothing[:-1], period_2_dist, label='period 2')\n", "ax[2].plot(time_range_smoothing[:-1], period_3_dist, label='period 3')\n", "ax[0].set(xlabel='t/s', ylabel='spike count', title='1st part')\n", "ax[1].set(xlabel='t/s', ylabel='spike count', title='2nd part')\n", "ax[2].set(xlabel='t/s', ylabel='spike count', title='3rd part')\n", "ax[0].eventplot([0.2], linelengths=0.8)\n", "ax[1].eventplot([0.2], linelengths=0.8)\n", "ax[2].eventplot([0.2], linelengths=0.8)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "100" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list(time_range_smoothing).index(0.2)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.2 0.162 0.194\n" ] } ], "source": [ "max_p_1 = time_range_smoothing[np.argmax(period_1_dist[:120])]\n", "max_p_2 = time_range_smoothing[np.argmax(period_2_dist[:100])]\n", "max_p_3 = time_range_smoothing[np.argmax(period_3_dist[:120])]\n", "delta_2 = max_p_1 - max_p_2\n", "delta_3 = max_p_1 - max_p_3\n", "print(max_p_1, max_p_2, max_p_3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we'll fix the times" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "t_p1, t_p2 = stim['stim_offtime'][p1], stim['stim_offtime'][p2]\n", "fix_time = lambda t: t - delta_2 * ((t < t_p2) & (t >= t_p1)) - delta_3 * ((t >= t_p2))" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0 2.5839\n", "1 2.7028\n", "2 2.7863\n", "3 2.8699\n", "4 2.9534\n", " ... \n", "19990 1671.6389\n", "19991 1671.7224\n", "19992 1671.8059\n", "19993 1671.8894\n", "19994 1671.9730\n", "Name: stim_offtime, Length: 19995, dtype: float64" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fix_time(stim['stim_offtime'][:-subseq_trials])" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3.10/site-packages/pandas/core/roperator.py:13: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n", " return right - left\n" ] } ], "source": [ "subseq_spike_times_locked_2 = {}\n", "subseq_spike_times_locked_2['ontime'] = [subseq_spike_times[unit_id] - fix_time(stim['stim_ontime'][:-subseq_trials]) for unit_id in range(num_unit)]\n", "subseq_spike_times_locked_2['offtime'] = [subseq_spike_times[unit_id] - fix_time(stim['stim_offtime'][:-subseq_trials]) for unit_id in range(num_unit)]" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "unit_id = 1\n", "\n", "fig, ax = plt.subplots(1,3, figsize=(20,10))\n", "ax[0].plot(np.diff(stim['stim_ontime'], n=2), np.arange(20000-2))\n", "ax[0].invert_yaxis()\n", "ax[0].set_xlabel('$\\Delta^2[t_{on}]=\\Delta$ trial duration / s', size=20)\n", "ax[0].set(ylabel='trials')\n", "ax[1].eventplot(subseq_spike_times_locked_2['ontime'][unit_id], lineoffsets=1, linelengths=0.8)\n", "ax[1].set(title='unit %d'%unit_id, yticks=[], xlabel='t/s (locked to trial onsets)')\n", "ax[1].invert_yaxis()\n", "ax[2].eventplot(subseq_spike_times_locked_2['ontime'][unit_id_2], lineoffsets=1, linelengths=0.8)\n", "ax[2].set(title='unit %d'%(unit_id_2), yticks=[], xlabel='t/s (locked to trial ends)')\n", "ax[2].invert_yaxis()\n", "plt.subplots_adjust(wspace=0)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "s = np.array([np.array(list(map(fix_time, spike_times[unit_id]))) for unit_id in range(len(spike_times))], dtype=object)//dt\n", "B_spike_fixed = []\n", "for unit_id in range(num_unit):\n", " B_spike_fixed.append(sparse.coo_matrix((np.ones(len(s[unit_id])), (np.zeros(len(s[unit_id]), dtype=int), np.int0(s[unit_id]))), shape=(1, M)))" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "from copy import deepcopy\n", "B_stim_original = deepcopy(B_stim)" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "B_stim = {}\n", "for key in key_list:\n", " B_stim[key] = []\n", " for stim_id, trials in enumerate(stim_id_trial[key]):\n", " B_stim[key].append([])\n", " s = []\n", " for trial_id in trials:\n", " t_on, t_off = fix_time(stim['stim_ontime'][trial_id]), fix_time(stim['stim_offtime'][trial_id])\n", " s += list(np.arange(int(t_on//dt), int(t_off//dt)))\n", "\n", " B_stim[key][stim_id] = sparse.coo_matrix((np.ones(len(s)), (np.zeros(len(s), dtype=int), s)), shape=(1, M))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Calculate some matrices" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "get_trial_index = lambda t: fix_time(stim['stim_ontime'][t])//dt" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [], "source": [ "B_spike_smooth = list()\n", "for unit_id in range(len(B_spike)):\n", " B_spike_smooth.append(scipy.ndimage.gaussian_filter(B_spike[unit_id].toarray()[0], sigma=50))\n", "B_spike_smooth = np.array(B_spike_smooth)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(B_spike_smooth[0][:5000]) # ~10 trials" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Reverse correlation\n", "\n", "TL;DR: We find the reverse correlation matrices. When we plot them they look meh, but if we plot them smoothed, they look awesome. However, we shouldn't use this smoothing when decoding parameters because it uses our (parameter-defined) notion of distance between points." ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [], "source": [ "B_stim_total = np.sum(B_stim['phase'])" ] }, { "cell_type": "code", "execution_count": 100, "metadata": {}, "outputs": [], "source": [ "R = dict()\n", "for key in key_list:\n", " R[key] = list()\n", " for i in range(len(B_stim[key])):\n", " item = []\n", " for u in range(len(B_spike_smooth)):\n", " item.append(B_stim[key][i].dot(np.roll(B_spike_smooth[u], 80)))\n", " R[key].append(item)\n", " R[key] = np.array(R[key])" ] }, { "cell_type": "code", "execution_count": 104, "metadata": {}, "outputs": [], "source": [ "R['pair'] = R['pair'].reshape((20, 20, 40))\n", "Rp = R['pair']" ] }, { "cell_type": "code", "execution_count": 102, "metadata": {}, "outputs": [], "source": [ "R_pair_smoothed = np.array([scipy.ndimage.gaussian_filter(R['pair'][:, :, i], sigma=2) for i in range(40)])" ] }, { "cell_type": "code", "execution_count": 103, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, axs = plt.subplots(4, 4, figsize=(12, 13))\n", "fig.tight_layout(w_pad=2)\n", "for i, ax in enumerate(axs.flatten()):\n", " ax.imshow(R['pair'][:, :, i], extent=(0, 360, 0, 180), aspect=2)\n", " ax.set(xlabel=\"phase\", ylabel=\"orientation\", title=f\"Unit {i}\")" ] }, { "cell_type": "code", "execution_count": 98, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, axs = plt.subplots(4, 4, figsize=(12, 13))\n", "fig.tight_layout(w_pad=2)\n", "for i, ax in enumerate(axs.flatten()):\n", " ax.imshow(R_pair_smoothed[i], extent=(0, 360, 0, 180), aspect=2)\n", " ax.set(xlabel=\"phase\", ylabel=\"orientation\", title=f\"Unit {i}\")" ] }, { "cell_type": "code", "execution_count": 113, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Topological noise reduction: 100%|██████████| 100/100 [01:57<00:00, 1.18s/it]\n" ] } ], "source": [ "res = top_noise_reduction(pd.DataFrame(Rp.reshape((400, 40)))).to_numpy()" ] }, { "cell_type": "code", "execution_count": 121, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "128.81601674915015" ] }, "execution_count": 121, "metadata": {}, "output_type": "execute_result" } ], "source": [ "res[0][0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Intermission: save variables to a file" ] }, { "cell_type": "code", "execution_count": 132, "metadata": {}, "outputs": [], "source": [ "import pickle\n", "with open('dump.pkl', 'wb') as f:\n", " pickle.dump({k: globals()[k] for k in [\n", " 'data_folder', 'stim_file', 'spike_times_file', 'key_symbol', \n", " 'stim', 'num_trial', 'stim_val', 'trial_stim_id', 'key_list', 'stim_id_trial', 'num_stim', 'key', 'pair_id', 'trial_pair_id', 'pair_val', 'pair_trial_id',\n", " 'spike_times', 'num_unit', 'num_spike', 'spike_count_rate', 'avg_firing_rate', 'firing_rate', 'stim_num_trial', 'stim_hist', 'optimal_avg_firing_rate',\n", " 'latest_spike_time', 'dt', 'exp_time', 'B_stim', 'trials', 't_on', 't_off', 'B_spike', 'trial_range', 'units', 'orientation', 'phase', 'trial_spike_times',\n", " 'delta_t_on', 'delta_t_off', 'subseq_trials', 'subseq_spike_times', 'subseq_spike_times_locked', 'time_range', 'unit_id_2', 'p1', 'p2', 'delta_t', 'time_range_smoothing',\n", " 'period_1_dist', 'period_2_dist', 'period_3_dist', 'num_units', 'max_p_1', 'max_p_2', 'max_p_3', 'delta_2', 'delta_3', 't_p1', 't_p2', 'subseq_spike_times_locked_2',\n", " 'B_spike_fixed', 'B_stim_original', 'B_spike_smooth', 'B_stim_total', 'R', 'R_pair_smoothed', 'Rp'\n", " ]}, f)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dict_keys(['data_folder', 'stim_file', 'spike_times_file', 'key_symbol', 'stim', 'num_trial', 'stim_val', 'trial_stim_id', 'key_list', 'stim_id_trial', 'num_stim', 'key', 'pair_id', 'trial_pair_id', 'pair_val', 'pair_trial_id', 'spike_times', 'num_unit', 'num_spike', 'spike_count_rate', 'avg_firing_rate', 'firing_rate', 'stim_num_trial', 'stim_hist', 'optimal_avg_firing_rate', 'latest_spike_time', 'dt', 'exp_time', 'B_stim', 'trials', 't_on', 't_off', 'B_spike', 'trial_range', 'units', 'orientation', 'phase', 'trial_spike_times', 'delta_t_on', 'delta_t_off', 'subseq_trials', 'subseq_spike_times', 'subseq_spike_times_locked', 'time_range', 'unit_id_2', 'p1', 'p2', 'delta_t', 'time_range_smoothing', 'period_1_dist', 'period_2_dist', 'period_3_dist', 'num_units', 'max_p_1', 'max_p_2', 'max_p_3', 'delta_2', 'delta_3', 't_p1', 't_p2', 'subseq_spike_times_locked_2', 'B_spike_fixed', 'B_stim_original', 'B_spike_smooth', 'B_stim_total', 'R', 'R_pair_smoothed', 'Rp', 'firing_rates_noise_red', 'firing_rates_flat', 'firing_rates_in_trials', 'avg_firing_rates'])\n" ] } ], "source": [ "file = open(\"dump.pkl\", 'rb')\n", "data = pkl.load(file)\n", "print(data.keys())\n", "for key, value in data.items():\n", " globals()[key] = value\n", "file.close()" ] }, { "cell_type": "code", "execution_count": 131, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "__name__ __doc__ __package__ __loader__ __spec__ __builtin__ __builtins__ _ih _oh _dh In Out get_ipython exit quit _ __ ___ os sys __vsc_ipynb_file__ _i _ii _iii _i1 np plt pd scipy sts pkl widgets mplot3d Axes3D sparse cm cmap_hot cmap_viridis cmap_jet _i2 data_folder stim_file spike_times_file key_symbol _i3 stim num_trial stim_val trial_stim_id key_list stim_id_trial num_stim key pair_id trial_pair_id pair_val pair_trial_id i _i4 _4 _i5 _i6 _i7 _7 _i8 spike_times active num_unit _8 _i9 num_spike _i10 files file_name file data value spike_count_rate avg_firing_rate sem_firing_rate firing_rate stim_num_trial C_r_fphi_theta theta_hist phase_hist pair_hist corr_stim_unit optimal_avg_firing_rate stim_hist stim_hist_caution _i11 max_delay tau_id_range latest_spike_time latest_stim_offtime experiment_dur dt exp_time M _i12 B_stim stim_id trials s trial_id t_on t_off B_spike unit_id _i13 sorted_spike_num cutoff_num_spike _i14 t0 t1 stim_prev_id t_prev_on t_prev_off spikes _i15 gridspec fig ax gs0 ax0 ax1 ax2 ax3 _i16 ref_trial_id past_trials future_trials trial_range units orientation phase ref_id _i17 PSSH _i18 trial_spike_times delta_t_on delta_t_off subseq_trials subseq_spike_times subseq_spike_times_locked _i19 time_range _i20 subseq_spike_times_len chain _20 _i21 unit_id_2 _i22 stim_2diffs _i23 p1 p2 delta_t time_range_smoothing period_1_dist period_2_dist period_3_dist num_units j row hist _i24 _24 _i25 _25 _i26 max_p_1 max_p_2 max_p_3 delta_2 delta_3 _i27 t_p1 t_p2 fix_time _i28 _28 _i29 subseq_spike_times_locked_2 _i30 _i31 B_spike_fixed _i32 deepcopy B_stim_original _i33 _i34 get_trial_index _i35 B_spike_smooth _i36 _36 _i37 _37 _i38 _38 _i39 _39 _i40 _40 _i41 _41 _i42 B_stim_total _i43 _i44 R _i45 item u _i46 _i47 _i48 _i49 _i50 _i51 _51 _i52 _52 _i53 _53 _i54 _54 _i55 _i56 _56 _i57 _57 _i58 _58 _i59 _59 _i60 _60 _i61 _61 _i62 _62 _i63 _63 _i64 _64 _i65 _65 _i66 _66 _i67 R_pair_smoothed _i68 axs _i69 _i70 _i71 _i72 _i73 _i74 _i75 _i76 _i77 _i78 _i79 _i80 _i81 _i82 _i83 _i84 _i85 _i86 _i87 _i88 _i89 _i90 _i91 _i92 _i93 _i94 _i95 _i96 _i97 _i98 _i99 _i100 R1 item1 _i101 _i102 _i103 _i104 Rp _i105 _i106 _i107 _i108 _i109 top_noise_reduction _i110 _i111 _i112 _i113 res _i114 _114 _i115 _115 _i116 _116 _i117 _117 _i118 _118 _i119 _i120 _120 _i121 _121 _i122 pickle _i123 f _i124 _i125 _i126 _i127 _i128 _128 _i129 _129 _i130 _130 _i131\n" ] } ], "source": [ "print(*globals().keys())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Forward correlation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "firing_rates_in_trials = [] # by pair, then by trial, then by neuron\n", "firing_rates_flat = []\n", "\n", "for trial_ids in stim_id_trial['pair']:\n", " row = []\n", " for trial_id in trial_ids:\n", " ind = round(get_trial_index(trial_id))\n", " rr = []\n", " for u in range(len(B_spike_smooth)):\n", " rr.append(np.mean(B_spike_smooth[u][ind + 50:ind + 90]))\n", " row.append(np.array(rr))\n", " firing_rates_flat.append(np.array(rr))\n", " firing_rates_in_trials.append(np.array(row))" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(400, (50, 40))" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "firing_rates_flat = np.array(firing_rates_flat)\n", "len(firing_rates_in_trials), firing_rates_in_trials[0].shape" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "avg_firing_rates = np.array([np.mean(fr_pair, axis=0) for fr_pair in firing_rates_in_trials]).reshape((20, 20, 40))" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, axs = plt.subplots(4, 4, figsize=(12, 13))\n", "fig.tight_layout(w_pad=2)\n", "for i, ax in enumerate(axs.flatten()):\n", " ax.imshow(avg_firing_rates[:, :, i], extent=(0, 360, 0, 180), aspect=2)\n", " ax.set(xlabel=\"phase\", ylabel=\"orientation\", title=f\"Unit {i}\")" ] }, { "cell_type": "code", "execution_count": 111, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "62c650b11477402aa0a9dfe412b6209f", "version_major": 2, "version_minor": 0 }, "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", " \n", "
\n", " " ], "text/plain": [ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "avg_fr_blur = np.array([scipy.ndimage.gaussian_filter(avg_firing_rates[:, :, i], sigma=2) for i in range(40)])\n", "fig, axs = plt.subplots(4, 4, figsize=(12, 13))\n", "fig.tight_layout(w_pad=2)\n", "for i, ax in enumerate(axs.flatten()):\n", " ax.imshow(avg_fr_blur[i], extent=(0, 360, 0, 180), aspect=2)\n", " ax.set(xlabel=\"phase\", ylabel=\"orientation\", title=f\"Unit {i}\")\n", "avg_fr_blur = avg_fr_blur.swapaxes(0, 2).reshape((40, 400))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Topological noise reduction (not used)" ] }, { "cell_type": "code", "execution_count": 109, "metadata": {}, "outputs": [], "source": [ "import sys\n", "sys.path.insert(0, '../model')\n", "from noisereduction import top_noise_reduction" ] }, { "cell_type": "code", "execution_count": 149, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Topological noise reduction: 100%|██████████| 100/100 [31:33<00:00, 18.93s/it]\n" ] } ], "source": [ "firing_rates_noise_red = top_noise_reduction(pd.DataFrame(firing_rates_flat[::5]))" ] }, { "cell_type": "code", "execution_count": 150, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(400, 40)" ] }, "execution_count": 150, "metadata": {}, "output_type": "execute_result" } ], "source": [ "firing_rates_noise_red.shape" ] }, { "cell_type": "code", "execution_count": 151, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Topological noise reduction: 100%|██████████| 100/100 [3:44:17<00:00, 134.57s/it] \n" ] } ], "source": [ "firing_rates_noise_red = top_noise_reduction(pd.DataFrame(firing_rates_flat))" ] }, { "cell_type": "code", "execution_count": 166, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(2000, 40)" ] }, "execution_count": 166, "metadata": {}, "output_type": "execute_result" } ], "source": [ "firing_rates_noise_red = firing_rates_noise_red.to_numpy()\n", "firing_rates_noise_red.shape" ] }, { "cell_type": "code", "execution_count": 167, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 167, "metadata": {}, "output_type": "execute_result" } ], "source": [ "firing_rates_noise_red[0] in firing_rates_flat" ] }, { "cell_type": "code", "execution_count": 169, "metadata": {}, "outputs": [], "source": [ "import pickle\n", "with open('dump.pkl', 'wb') as f:\n", " pickle.dump({k: globals()[k] for k in [\n", " 'data_folder', 'stim_file', 'spike_times_file', 'key_symbol', \n", " 'stim', 'num_trial', 'stim_val', 'trial_stim_id', 'key_list', 'stim_id_trial', 'num_stim', 'key', 'pair_id', 'trial_pair_id', 'pair_val', 'pair_trial_id',\n", " 'spike_times', 'num_unit', 'num_spike', 'spike_count_rate', 'avg_firing_rate', 'firing_rate', 'stim_num_trial', 'stim_hist', 'optimal_avg_firing_rate',\n", " 'latest_spike_time', 'dt', 'exp_time', 'B_stim', 'trials', 't_on', 't_off', 'B_spike', 'trial_range', 'units', 'orientation', 'phase', 'trial_spike_times',\n", " 'delta_t_on', 'delta_t_off', 'subseq_trials', 'subseq_spike_times', 'subseq_spike_times_locked', 'time_range', 'unit_id_2', 'p1', 'p2', 'delta_t', 'time_range_smoothing',\n", " 'period_1_dist', 'period_2_dist', 'period_3_dist', 'num_units', 'max_p_1', 'max_p_2', 'max_p_3', 'delta_2', 'delta_3', 't_p1', 't_p2', 'subseq_spike_times_locked_2',\n", " 'B_spike_fixed', 'B_stim_original', 'B_spike_smooth', 'B_stim_total', 'R', 'R_pair_smoothed', 'Rp', 'firing_rates_noise_red', 'firing_rates_flat', 'firing_rates_in_trials', 'avg_firing_rates'\n", " ]}, f)" ] }, { "cell_type": "code", "execution_count": 168, "metadata": {}, "outputs": [], "source": [ "from decoding import cohomological_parameterization" ] }, { "cell_type": "code", "execution_count": 171, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Decoding... done\n" ] } ], "source": [ "param = cohomological_parameterization(pd.DataFrame(firing_rates_noise_red[::5, ::5]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### PCA" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "from sklearn.decomposition import PCA\n", "import seaborn as sns" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fr_df = pd.DataFrame(firing_rates_flat)\n", "sns.heatmap(fr_df.corr())" ] }, { "cell_type": "code", "execution_count": 112, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123456
0-0.0018400.005584-0.001724-0.0001570.0016940.0000520.001786
10.005321-0.001193-0.0026060.004470-0.000058-0.0002470.001285
2-0.0011540.005865-0.001700-0.0003990.001506-0.0000390.001431
30.005685-0.001241-0.0019950.0041830.000222-0.0005100.000970
40.0000540.006228-0.001699-0.0008580.001188-0.0002360.000801
\n", "
" ], "text/plain": [ " 0 1 2 3 4 5 6\n", "0 -0.001840 0.005584 -0.001724 -0.000157 0.001694 0.000052 0.001786\n", "1 0.005321 -0.001193 -0.002606 0.004470 -0.000058 -0.000247 0.001285\n", "2 -0.001154 0.005865 -0.001700 -0.000399 0.001506 -0.000039 0.001431\n", "3 0.005685 -0.001241 -0.001995 0.004183 0.000222 -0.000510 0.000970\n", "4 0.000054 0.006228 -0.001699 -0.000858 0.001188 -0.000236 0.000801" ] }, "execution_count": 112, "metadata": {}, "output_type": "execute_result" } ], "source": [ "N_COMP = 7\n", "pca = PCA(n_components=N_COMP)\n", "pca.fit(avg_fr_blur)\n", "data_pca = pca.transform(avg_fr_blur)\n", "data_pca = pd.DataFrame(data_pca)\n", "data_pca.head()" ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(400, 50, 7)" ] }, "execution_count": 69, "metadata": {}, "output_type": "execute_result" } ], "source": [ "firing_rates_in_trials_pca = []\n", "for trials in firing_rates_in_trials:\n", " firing_rates_in_trials_pca.append(pca.transform(pd.DataFrame(trials)))\n", "firing_rates_in_trials_pca = np.array(firing_rates_in_trials_pca)\n", "firing_rates_in_trials_pca.shape" ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [], "source": [ "avg_firing_rates_pca = np.mean(firing_rates_in_trials_pca, axis=1).reshape((20, 20, N_COMP))" ] }, { "cell_type": "code", "execution_count": 113, "metadata": {}, "outputs": [ { "ename": "InvalidIndexError", "evalue": "(slice(None, None, None), slice(None, None, None), 0)", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mInvalidIndexError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m/home/ennucore/dev/amgen/exp/ProcessExp.ipynb Cell 91\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m fig\u001b[39m.\u001b[39mtight_layout(w_pad\u001b[39m=\u001b[39m\u001b[39m2\u001b[39m)\n\u001b[1;32m 3\u001b[0m \u001b[39mfor\u001b[39;00m i, ax \u001b[39min\u001b[39;00m \u001b[39menumerate\u001b[39m(axs\u001b[39m.\u001b[39mflatten()[:\u001b[39m7\u001b[39m]):\n\u001b[0;32m----> 4\u001b[0m ax\u001b[39m.\u001b[39mimshow(data_pca[:, :, i], extent\u001b[39m=\u001b[39m(\u001b[39m0\u001b[39m, \u001b[39m360\u001b[39m, \u001b[39m0\u001b[39m, \u001b[39m180\u001b[39m), aspect\u001b[39m=\u001b[39m\u001b[39m2\u001b[39m)\n\u001b[1;32m 5\u001b[0m ax\u001b[39m.\u001b[39mset(xlabel\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mphase\u001b[39m\u001b[39m\"\u001b[39m, ylabel\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39morientation\u001b[39m\u001b[39m\"\u001b[39m, title\u001b[39m=\u001b[39m\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mUnit \u001b[39m\u001b[39m{\u001b[39;00mi\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m)\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/pandas/core/frame.py:3505\u001b[0m, in \u001b[0;36mDataFrame.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3503\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcolumns\u001b[39m.\u001b[39mnlevels \u001b[39m>\u001b[39m \u001b[39m1\u001b[39m:\n\u001b[1;32m 3504\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_getitem_multilevel(key)\n\u001b[0;32m-> 3505\u001b[0m indexer \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mcolumns\u001b[39m.\u001b[39;49mget_loc(key)\n\u001b[1;32m 3506\u001b[0m \u001b[39mif\u001b[39;00m is_integer(indexer):\n\u001b[1;32m 3507\u001b[0m indexer \u001b[39m=\u001b[39m [indexer]\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/pandas/core/indexes/range.py:388\u001b[0m, in \u001b[0;36mRangeIndex.get_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 386\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mValueError\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n\u001b[1;32m 387\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mKeyError\u001b[39;00m(key) \u001b[39mfrom\u001b[39;00m \u001b[39merr\u001b[39;00m\n\u001b[0;32m--> 388\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_check_indexing_error(key)\n\u001b[1;32m 389\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mKeyError\u001b[39;00m(key)\n\u001b[1;32m 390\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39msuper\u001b[39m()\u001b[39m.\u001b[39mget_loc(key, method\u001b[39m=\u001b[39mmethod, tolerance\u001b[39m=\u001b[39mtolerance)\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/pandas/core/indexes/base.py:5637\u001b[0m, in \u001b[0;36mIndex._check_indexing_error\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 5633\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_check_indexing_error\u001b[39m(\u001b[39mself\u001b[39m, key):\n\u001b[1;32m 5634\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m is_scalar(key):\n\u001b[1;32m 5635\u001b[0m \u001b[39m# if key is not a scalar, directly raise an error (the code below\u001b[39;00m\n\u001b[1;32m 5636\u001b[0m \u001b[39m# would convert to numpy arrays and raise later any way) - GH29926\u001b[39;00m\n\u001b[0;32m-> 5637\u001b[0m \u001b[39mraise\u001b[39;00m InvalidIndexError(key)\n", "\u001b[0;31mInvalidIndexError\u001b[0m: (slice(None, None, None), slice(None, None, None), 0)" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c09d95fca9cf47deb73bfbb32c0ea7bf", "version_major": 2, "version_minor": 0 }, "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", " \n", "
\n", " " ], "text/plain": [ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "fig, axs = plt.subplots(2, 3, figsize=(12, 12))\n", "fig.tight_layout(w_pad=2)\n", "for i, ax in enumerate(axs.flatten()[:7]):\n", " ax.imshow(avg_firing_rates_pca[:, :, i], extent=(0, 360, 0, 180), aspect=2)\n", " ax.set(xlabel=\"phase\", ylabel=\"orientation\", title=f\"Unit {i}\")" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "\n", "fig, axs = plt.subplots(2, 3, figsize=(12, 13))\n", "fig.tight_layout(w_pad=2)\n", "for i, ax in enumerate(axs.flatten()):\n", " ax.imshow(scipy.ndimage.gaussian_filter(avg_firing_rates_pca[:, :, i], sigma=2), extent=(0, 360, 0, 180), aspect=2)\n", " ax.set(xlabel=\"phase\", ylabel=\"orientation\", title=f\"Unit {i}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Point Cloud Simplification" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [], "source": [ "def radial_distance(X, eps, random_state=None):\n", " \"\"\"\n", " point cloud simplification using radial distance (euclidean metric). \n", " Start with the first point in in X and mark it as a key point. All consecutive points that have a distance less than a predetermined distance eps to the key point are removed. The first point that have a distance greater than eps to the key point is marked as the new key point. The process repeates itself from this new key point, and continues until it reaches the end of the point cloud.\n", " \n", " Parameters\n", " ----------\n", " X: pandas DataFrame (n_datapoints, n_features):\n", "\n", " eps: max radial distance - cutoff distance\n", "\n", " random_state: seed of random generator used for choosing the inital point\n", "\n", " Returns\n", " -------\n", " X.iloc[ind_reduced]: dataframe with chosen datapoints \n", " \"\"\"\n", " if random_state is not None:\n", " np.random.seed(random_state)\n", " \n", " ix0 = np.random.choice(X.shape[0])\n", " x0 = X.iloc[ix0]\n", " xt = x0\n", " ixt = ix0\n", " X_temp = X\n", " ind_reduced = [ix0]\n", "\n", " while True:\n", " dist = np.linalg.norm(X_temp.to_numpy() - xt.to_numpy(), axis=1)\n", " cond = dist < eps\n", "\n", " X_temp = X_temp.drop(X_temp.index[np.where(cond)])\n", " if len(X_temp)==0:\n", " break\n", "\n", " where_not_cond = np.where(np.logical_not(cond))\n", " w = np.argmin(dist[where_not_cond]) \n", " ixt = X_temp.index[w]\n", " xt = X.iloc[ixt]\n", " ind_reduced.append(ixt)\n", "\n", " return X.iloc[ind_reduced], ind_reduced \n" ] }, { "cell_type": "code", "execution_count": 107, "metadata": {}, "outputs": [], "source": [ "from tqdm import trange\n", "from noisereduction import compute_gradient\n", "def top_noise_reduction(X, n=100, omega=0.2, fraction=0.1, plot=False):\n", " \"\"\"\n", " Topological denoising algorithm as in arxiv:0910.5947\n", " \n", " Parameters\n", " ----------\n", " X: dataframe(n_datapoints, n_features):\n", " Dataframe containing the data\n", " n: int, optional, default 100\n", " Number of iterations\n", " omega: float, optional, default 0.2\n", " Strength of the repulsive force between datapoints\n", " fraction: float between 0 and 1, optional, default 0.1\n", " The fraction of datapoints from which the denoised dataset is\n", " constructed\n", " plot: bool, optional, default False\n", " When true plot the dataset and homology each iteration\n", " \"\"\"\n", " N = X.shape[0]\n", " inds = np.random.choice(N, round(fraction*N), replace=False)\n", " S = X.iloc[inds]\n", " sigma = X.stack().std()\n", " c = 0.02*np.max(scipy.spatial.distance.cdist(X, X, metric='euclidean'))\n", " \n", " iterator = trange(0, n, position=0, leave=True)\n", " iterator.set_description(\"Topological noise reduction\")\n", " for i in iterator:\n", " gradF = compute_gradient(S.to_numpy(), X.to_numpy(), sigma, omega)\n", " \n", " if i == 0:\n", " maxgradF = np.max(np.sqrt(np.square(gradF).sum(axis=1)))\n", " S = S + c* gradF/maxgradF\n", " \n", " if plot:\n", " fig = pyplot.figure()\n", " ax = Axes3D(fig)\n", " ax.scatter(X[0],X[1],X[2],alpha=0.1)\n", " ax.scatter(S[0],S[1],S[2])\n", " pyplot.show()\n", " return S, inds" ] }, { "cell_type": "code", "execution_count": 108, "metadata": {}, "outputs": [ { "ename": "KeyboardInterrupt", "evalue": "", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", "\u001b[1;32m/home/ennucore/dev/amgen/exp/ProcessExp.ipynb Cell 96\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m fr_pca_simpl, inds_simpl \u001b[39m=\u001b[39m top_noise_reduction(pd\u001b[39m.\u001b[39;49mDataFrame(firing_rates_in_trials_pca\u001b[39m.\u001b[39;49mreshape((\u001b[39m400\u001b[39;49m \u001b[39m*\u001b[39;49m \u001b[39m50\u001b[39;49m, \u001b[39m-\u001b[39;49m\u001b[39m1\u001b[39;49m))))\n\u001b[1;32m 2\u001b[0m fr_pca_simpl_np \u001b[39m=\u001b[39m fr_pca_simpl\u001b[39m.\u001b[39mto_numpy()\n\u001b[1;32m 3\u001b[0m fr_pca_simpl\u001b[39m.\u001b[39mshape\n", "\u001b[1;32m/home/ennucore/dev/amgen/exp/ProcessExp.ipynb Cell 96\u001b[0m in \u001b[0;36mtop_noise_reduction\u001b[0;34m(X, n, omega, fraction, plot)\u001b[0m\n\u001b[1;32m 23\u001b[0m S \u001b[39m=\u001b[39m X\u001b[39m.\u001b[39miloc[inds]\n\u001b[1;32m 24\u001b[0m sigma \u001b[39m=\u001b[39m X\u001b[39m.\u001b[39mstack()\u001b[39m.\u001b[39mstd()\n\u001b[0;32m---> 25\u001b[0m c \u001b[39m=\u001b[39m \u001b[39m0.02\u001b[39m\u001b[39m*\u001b[39mnp\u001b[39m.\u001b[39mmax(scipy\u001b[39m.\u001b[39;49mspatial\u001b[39m.\u001b[39;49mdistance\u001b[39m.\u001b[39;49mcdist(X, X, metric\u001b[39m=\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39meuclidean\u001b[39;49m\u001b[39m'\u001b[39;49m))\n\u001b[1;32m 27\u001b[0m iterator \u001b[39m=\u001b[39m trange(\u001b[39m0\u001b[39m, n, position\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m, leave\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m 28\u001b[0m iterator\u001b[39m.\u001b[39mset_description(\u001b[39m\"\u001b[39m\u001b[39mTopological noise reduction\u001b[39m\u001b[39m\"\u001b[39m)\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/scipy/spatial/distance.py:2947\u001b[0m, in \u001b[0;36mcdist\u001b[0;34m(XA, XB, metric, out, **kwargs)\u001b[0m\n\u001b[1;32m 2945\u001b[0m \u001b[39mif\u001b[39;00m metric_info \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 2946\u001b[0m cdist_fn \u001b[39m=\u001b[39m metric_info\u001b[39m.\u001b[39mcdist_func\n\u001b[0;32m-> 2947\u001b[0m \u001b[39mreturn\u001b[39;00m cdist_fn(XA, XB, out\u001b[39m=\u001b[39;49mout, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 2948\u001b[0m \u001b[39melif\u001b[39;00m mstr\u001b[39m.\u001b[39mstartswith(\u001b[39m\"\u001b[39m\u001b[39mtest_\u001b[39m\u001b[39m\"\u001b[39m):\n\u001b[1;32m 2949\u001b[0m metric_info \u001b[39m=\u001b[39m _TEST_METRICS\u001b[39m.\u001b[39mget(mstr, \u001b[39mNone\u001b[39;00m)\n", "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], "source": [ "fr_pca_simpl, inds_simpl = radial_distance(pd.DataFrame(firing_rates_in_trials_pca.reshape((400 * 50, -1))), 0.025)\n", "fr_pca_simpl.shape" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 97, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(926, 2)" ] }, "execution_count": 97, "metadata": {}, "output_type": "execute_result" } ], "source": [ "param_corr = stim_val['pair'][np.array(inds_simpl) // 50]\n", "param_corr.shape" ] }, { "cell_type": "code", "execution_count": 104, "metadata": {}, "outputs": [], "source": [ "avg_firing_rates_pca_ = avg_firing_rates_pca.reshape((-1, N_COMP))" ] }, { "cell_type": "code", "execution_count": 106, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "ncomp_disp = 5\n", "fig = plt.figure(figsize=(8,8))\n", "for j in range(ncomp_disp):\n", " for i in range(j+1):\n", " ax = fig.add_subplot(ncomp_disp,ncomp_disp, j + ncomp_disp*i + 1)\n", " if i == j:\n", " ax.scatter(\n", " # param_corr[:, 0],\n", " stim_val['pair'].reshape((-1, 2))[:, 0],\n", " avg_firing_rates_pca_[:, i], s=1)\n", " ax.set(xlabel='stim', ylabel='PC%d'%i)\n", " else:\n", " ax.scatter(avg_firing_rates_pca_[:, j], avg_firing_rates_pca_[:, i], s=1, c=stim_val['pair'].reshape((-1, 2))[:, 0], cmap='hsv')\n", " \n", " ax.set(xticks=[], yticks=[])\n", " \n", " if i==0 and j>0:\n", " ax.set(xlabel='PC%d'%j)\n", " ax.xaxis.set_label_position('top') \n", "\n", " if j==ncomp_disp-1 and i\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m ncomp_umap \u001b[39m=\u001b[39m \u001b[39m5\u001b[39m\n\u001b[0;32m----> 2\u001b[0m embed \u001b[39m=\u001b[39m UMAP(n_components\u001b[39m=\u001b[39;49mncomp_umap, n_neighbors\u001b[39m=\u001b[39;49m\u001b[39m5\u001b[39;49m, metric\u001b[39m=\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39meuclidean\u001b[39;49m\u001b[39m'\u001b[39;49m)\u001b[39m.\u001b[39;49mfit_transform(fr_pca_simpl)\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/umap/umap_.py:2772\u001b[0m, in \u001b[0;36mUMAP.fit_transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 2742\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mfit_transform\u001b[39m(\u001b[39mself\u001b[39m, X, y\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[1;32m 2743\u001b[0m \u001b[39m\"\"\"Fit X into an embedded space and return that transformed\u001b[39;00m\n\u001b[1;32m 2744\u001b[0m \u001b[39m output.\u001b[39;00m\n\u001b[1;32m 2745\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 2770\u001b[0m \u001b[39m Local radii of data points in the embedding (log-transformed).\u001b[39;00m\n\u001b[1;32m 2771\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 2772\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfit(X, y)\n\u001b[1;32m 2773\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtransform_mode \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39membedding\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[1;32m 2774\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39moutput_dens:\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/umap/umap_.py:2684\u001b[0m, in \u001b[0;36mUMAP.fit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m 2681\u001b[0m \u001b[39mprint\u001b[39m(ts(), \u001b[39m\"\u001b[39m\u001b[39mConstruct embedding\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 2683\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mtransform_mode \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39membedding\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[0;32m-> 2684\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39membedding_, aux_data \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_fit_embed_data(\n\u001b[1;32m 2685\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_raw_data[index],\n\u001b[1;32m 2686\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mn_epochs,\n\u001b[1;32m 2687\u001b[0m init,\n\u001b[1;32m 2688\u001b[0m random_state, \u001b[39m# JH why raw data?\u001b[39;49;00m\n\u001b[1;32m 2689\u001b[0m )\n\u001b[1;32m 2690\u001b[0m \u001b[39m# Assign any points that are fully disconnected from our manifold(s) to have embedding\u001b[39;00m\n\u001b[1;32m 2691\u001b[0m \u001b[39m# coordinates of np.nan. These will be filtered by our plotting functions automatically.\u001b[39;00m\n\u001b[1;32m 2692\u001b[0m \u001b[39m# They also prevent users from being deceived a distance query to one of these points.\u001b[39;00m\n\u001b[1;32m 2693\u001b[0m \u001b[39m# Might be worth moving this into simplicial_set_embedding or _fit_embed_data\u001b[39;00m\n\u001b[1;32m 2694\u001b[0m disconnected_vertices \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39mgraph_\u001b[39m.\u001b[39msum(axis\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m))\u001b[39m.\u001b[39mflatten() \u001b[39m==\u001b[39m \u001b[39m0\u001b[39m\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/umap/umap_.py:2717\u001b[0m, in \u001b[0;36mUMAP._fit_embed_data\u001b[0;34m(self, X, n_epochs, init, random_state)\u001b[0m\n\u001b[1;32m 2713\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_fit_embed_data\u001b[39m(\u001b[39mself\u001b[39m, X, n_epochs, init, random_state):\n\u001b[1;32m 2714\u001b[0m \u001b[39m\"\"\"A method wrapper for simplicial_set_embedding that can be\u001b[39;00m\n\u001b[1;32m 2715\u001b[0m \u001b[39m replaced by subclasses.\u001b[39;00m\n\u001b[1;32m 2716\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 2717\u001b[0m \u001b[39mreturn\u001b[39;00m simplicial_set_embedding(\n\u001b[1;32m 2718\u001b[0m X,\n\u001b[1;32m 2719\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mgraph_,\n\u001b[1;32m 2720\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mn_components,\n\u001b[1;32m 2721\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_initial_alpha,\n\u001b[1;32m 2722\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_a,\n\u001b[1;32m 2723\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_b,\n\u001b[1;32m 2724\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mrepulsion_strength,\n\u001b[1;32m 2725\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mnegative_sample_rate,\n\u001b[1;32m 2726\u001b[0m n_epochs,\n\u001b[1;32m 2727\u001b[0m init,\n\u001b[1;32m 2728\u001b[0m random_state,\n\u001b[1;32m 2729\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_input_distance_func,\n\u001b[1;32m 2730\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_metric_kwds,\n\u001b[1;32m 2731\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mdensmap,\n\u001b[1;32m 2732\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_densmap_kwds,\n\u001b[1;32m 2733\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moutput_dens,\n\u001b[1;32m 2734\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_output_distance_func,\n\u001b[1;32m 2735\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_output_metric_kwds,\n\u001b[1;32m 2736\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49moutput_metric \u001b[39min\u001b[39;49;00m (\u001b[39m\"\u001b[39;49m\u001b[39meuclidean\u001b[39;49m\u001b[39m\"\u001b[39;49m, \u001b[39m\"\u001b[39;49m\u001b[39ml2\u001b[39;49m\u001b[39m\"\u001b[39;49m),\n\u001b[1;32m 2737\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mrandom_state \u001b[39mis\u001b[39;49;00m \u001b[39mNone\u001b[39;49;00m,\n\u001b[1;32m 2738\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mverbose,\n\u001b[1;32m 2739\u001b[0m tqdm_kwds\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtqdm_kwds,\n\u001b[1;32m 2740\u001b[0m )\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/umap/umap_.py:1066\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, tqdm_kwds)\u001b[0m\n\u001b[1;32m 1063\u001b[0m n_epochs \u001b[39m=\u001b[39m default_epochs\n\u001b[1;32m 1065\u001b[0m \u001b[39mif\u001b[39;00m n_epochs \u001b[39m>\u001b[39m \u001b[39m10\u001b[39m:\n\u001b[0;32m-> 1066\u001b[0m graph\u001b[39m.\u001b[39mdata[graph\u001b[39m.\u001b[39mdata \u001b[39m<\u001b[39m (graph\u001b[39m.\u001b[39;49mdata\u001b[39m.\u001b[39;49mmax() \u001b[39m/\u001b[39m \u001b[39mfloat\u001b[39m(n_epochs))] \u001b[39m=\u001b[39m \u001b[39m0.0\u001b[39m\n\u001b[1;32m 1067\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 1068\u001b[0m graph\u001b[39m.\u001b[39mdata[graph\u001b[39m.\u001b[39mdata \u001b[39m<\u001b[39m (graph\u001b[39m.\u001b[39mdata\u001b[39m.\u001b[39mmax() \u001b[39m/\u001b[39m \u001b[39mfloat\u001b[39m(default_epochs))] \u001b[39m=\u001b[39m \u001b[39m0.0\u001b[39m\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/numpy/core/_methods.py:40\u001b[0m, in \u001b[0;36m_amax\u001b[0;34m(a, axis, out, keepdims, initial, where)\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_amax\u001b[39m(a, axis\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, out\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, keepdims\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m,\n\u001b[1;32m 39\u001b[0m initial\u001b[39m=\u001b[39m_NoValue, where\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m):\n\u001b[0;32m---> 40\u001b[0m \u001b[39mreturn\u001b[39;00m umr_maximum(a, axis, \u001b[39mNone\u001b[39;49;00m, out, keepdims, initial, where)\n", "\u001b[0;31mValueError\u001b[0m: zero-size array to reduction operation maximum which has no identity" ] } ], "source": [ "ncomp_umap = 5\n", "embed = UMAP(n_components=ncomp_umap, n_neighbors=5, metric='euclidean').fit_transform(fr_pca_simpl)" ] }, { "cell_type": "code", "execution_count": 109, "metadata": {}, "outputs": [ { "ename": "ValueError", "evalue": "'c' argument has 926 elements, which is inconsistent with 'x' and 'y' with size 913.", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/axes/_axes.py:4350\u001b[0m, in \u001b[0;36mAxes._parse_scatter_color_args\u001b[0;34m(c, edgecolors, kwargs, xsize, get_next_color_func)\u001b[0m\n\u001b[1;32m 4349\u001b[0m \u001b[39mtry\u001b[39;00m: \u001b[39m# Is 'c' acceptable as PathCollection facecolors?\u001b[39;00m\n\u001b[0;32m-> 4350\u001b[0m colors \u001b[39m=\u001b[39m mcolors\u001b[39m.\u001b[39;49mto_rgba_array(c)\n\u001b[1;32m 4351\u001b[0m \u001b[39mexcept\u001b[39;00m (\u001b[39mTypeError\u001b[39;00m, \u001b[39mValueError\u001b[39;00m) \u001b[39mas\u001b[39;00m err:\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/colors.py:385\u001b[0m, in \u001b[0;36mto_rgba_array\u001b[0;34m(c, alpha)\u001b[0m\n\u001b[1;32m 384\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 385\u001b[0m rgba \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray([to_rgba(cc) \u001b[39mfor\u001b[39;00m cc \u001b[39min\u001b[39;00m c])\n\u001b[1;32m 387\u001b[0m \u001b[39mif\u001b[39;00m alpha \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/colors.py:385\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 384\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 385\u001b[0m rgba \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray([to_rgba(cc) \u001b[39mfor\u001b[39;00m cc \u001b[39min\u001b[39;00m c])\n\u001b[1;32m 387\u001b[0m \u001b[39mif\u001b[39;00m alpha \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/colors.py:206\u001b[0m, in \u001b[0;36mto_rgba\u001b[0;34m(c, alpha)\u001b[0m\n\u001b[1;32m 205\u001b[0m \u001b[39mif\u001b[39;00m rgba \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m: \u001b[39m# Suppress exception chaining of cache lookup failure.\u001b[39;00m\n\u001b[0;32m--> 206\u001b[0m rgba \u001b[39m=\u001b[39m _to_rgba_no_colorcycle(c, alpha)\n\u001b[1;32m 207\u001b[0m \u001b[39mtry\u001b[39;00m:\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/colors.py:284\u001b[0m, in \u001b[0;36m_to_rgba_no_colorcycle\u001b[0;34m(c, alpha)\u001b[0m\n\u001b[1;32m 283\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m np\u001b[39m.\u001b[39miterable(c):\n\u001b[0;32m--> 284\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mInvalid RGBA argument: \u001b[39m\u001b[39m{\u001b[39;00morig_c\u001b[39m!r}\u001b[39;00m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 285\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mlen\u001b[39m(c) \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m [\u001b[39m3\u001b[39m, \u001b[39m4\u001b[39m]:\n", "\u001b[0;31mValueError\u001b[0m: Invalid RGBA argument: 9.0", "\nThe above exception was the direct cause of the following exception:\n", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m/home/ennucore/dev/amgen/exp/ProcessExp.ipynb Cell 104\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 9\u001b[0m fig, ax \u001b[39m=\u001b[39m plt\u001b[39m.\u001b[39msubplots(\u001b[39m1\u001b[39m, \u001b[39m1\u001b[39m, figsize\u001b[39m=\u001b[39m(\u001b[39m8\u001b[39m, \u001b[39m6\u001b[39m))\n\u001b[1;32m 10\u001b[0m ax \u001b[39m=\u001b[39m fig\u001b[39m.\u001b[39madd_subplot(\u001b[39m1\u001b[39m, \u001b[39m1\u001b[39m, \u001b[39m1\u001b[39m, projection\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39m3d\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m---> 11\u001b[0m ax\u001b[39m.\u001b[39;49mscatter3D(x, y, z, c\u001b[39m=\u001b[39;49mparam_corr[:, \u001b[39m0\u001b[39;49m], cmap\u001b[39m=\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39mhsv\u001b[39;49m\u001b[39m'\u001b[39;49m)\n\u001b[1;32m 12\u001b[0m ax\u001b[39m.\u001b[39mset(xlabel\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mU0\u001b[39m\u001b[39m\"\u001b[39m, ylabel\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mU1\u001b[39m\u001b[39m\"\u001b[39m, zlabel\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mU2\u001b[39m\u001b[39m\"\u001b[39m, xticks\u001b[39m=\u001b[39m[], yticks\u001b[39m=\u001b[39m[], zticks\u001b[39m=\u001b[39m[])\n\u001b[1;32m 13\u001b[0m fig\u001b[39m.\u001b[39msuptitle(\u001b[39m'\u001b[39m\u001b[39mUMAP 3D\u001b[39m\u001b[39m'\u001b[39m)\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/mpl_toolkits/mplot3d/axes3d.py:2416\u001b[0m, in \u001b[0;36mAxes3D.scatter\u001b[0;34m(self, xs, ys, zs, zdir, s, c, depthshade, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2413\u001b[0m \u001b[39mif\u001b[39;00m np\u001b[39m.\u001b[39mmay_share_memory(zs_orig, zs): \u001b[39m# Avoid unnecessary copies.\u001b[39;00m\n\u001b[1;32m 2414\u001b[0m zs \u001b[39m=\u001b[39m zs\u001b[39m.\u001b[39mcopy()\n\u001b[0;32m-> 2416\u001b[0m patches \u001b[39m=\u001b[39m \u001b[39msuper\u001b[39;49m()\u001b[39m.\u001b[39;49mscatter(xs, ys, s\u001b[39m=\u001b[39;49ms, c\u001b[39m=\u001b[39;49mc, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 2417\u001b[0m art3d\u001b[39m.\u001b[39mpatch_collection_2d_to_3d(patches, zs\u001b[39m=\u001b[39mzs, zdir\u001b[39m=\u001b[39mzdir,\n\u001b[1;32m 2418\u001b[0m depthshade\u001b[39m=\u001b[39mdepthshade)\n\u001b[1;32m 2420\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_zmargin \u001b[39m<\u001b[39m \u001b[39m0.05\u001b[39m \u001b[39mand\u001b[39;00m xs\u001b[39m.\u001b[39msize \u001b[39m>\u001b[39m \u001b[39m0\u001b[39m:\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/__init__.py:1361\u001b[0m, in \u001b[0;36m_preprocess_data..inner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1358\u001b[0m \u001b[39m@functools\u001b[39m\u001b[39m.\u001b[39mwraps(func)\n\u001b[1;32m 1359\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39minner\u001b[39m(ax, \u001b[39m*\u001b[39margs, data\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m 1360\u001b[0m \u001b[39mif\u001b[39;00m data \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m-> 1361\u001b[0m \u001b[39mreturn\u001b[39;00m func(ax, \u001b[39m*\u001b[39;49m\u001b[39mmap\u001b[39;49m(sanitize_sequence, args), \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 1363\u001b[0m bound \u001b[39m=\u001b[39m new_sig\u001b[39m.\u001b[39mbind(ax, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m 1364\u001b[0m auto_label \u001b[39m=\u001b[39m (bound\u001b[39m.\u001b[39marguments\u001b[39m.\u001b[39mget(label_namer)\n\u001b[1;32m 1365\u001b[0m \u001b[39mor\u001b[39;00m bound\u001b[39m.\u001b[39mkwargs\u001b[39m.\u001b[39mget(label_namer))\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/axes/_axes.py:4516\u001b[0m, in \u001b[0;36mAxes.scatter\u001b[0;34m(self, x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, edgecolors, plotnonfinite, **kwargs)\u001b[0m\n\u001b[1;32m 4513\u001b[0m \u001b[39mif\u001b[39;00m edgecolors \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 4514\u001b[0m orig_edgecolor \u001b[39m=\u001b[39m kwargs\u001b[39m.\u001b[39mget(\u001b[39m'\u001b[39m\u001b[39medgecolor\u001b[39m\u001b[39m'\u001b[39m, \u001b[39mNone\u001b[39;00m)\n\u001b[1;32m 4515\u001b[0m c, colors, edgecolors \u001b[39m=\u001b[39m \\\n\u001b[0;32m-> 4516\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_parse_scatter_color_args(\n\u001b[1;32m 4517\u001b[0m c, edgecolors, kwargs, x\u001b[39m.\u001b[39;49msize,\n\u001b[1;32m 4518\u001b[0m get_next_color_func\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_get_patches_for_fill\u001b[39m.\u001b[39;49mget_next_color)\n\u001b[1;32m 4520\u001b[0m \u001b[39mif\u001b[39;00m plotnonfinite \u001b[39mand\u001b[39;00m colors \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 4521\u001b[0m c \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mma\u001b[39m.\u001b[39mmasked_invalid(c)\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/axes/_axes.py:4356\u001b[0m, in \u001b[0;36mAxes._parse_scatter_color_args\u001b[0;34m(c, edgecolors, kwargs, xsize, get_next_color_func)\u001b[0m\n\u001b[1;32m 4354\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 4355\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m valid_shape:\n\u001b[0;32m-> 4356\u001b[0m \u001b[39mraise\u001b[39;00m invalid_shape_exception(c\u001b[39m.\u001b[39msize, xsize) \u001b[39mfrom\u001b[39;00m \u001b[39merr\u001b[39;00m\n\u001b[1;32m 4357\u001b[0m \u001b[39m# Both the mapping *and* the RGBA conversion failed: pretty\u001b[39;00m\n\u001b[1;32m 4358\u001b[0m \u001b[39m# severe failure => one may appreciate a verbose feedback.\u001b[39;00m\n\u001b[1;32m 4359\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[1;32m 4360\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m'\u001b[39m\u001b[39mc\u001b[39m\u001b[39m'\u001b[39m\u001b[39m argument must be a color, a sequence of colors, \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 4361\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mor a sequence of numbers, not \u001b[39m\u001b[39m{\u001b[39;00mc\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m) \u001b[39mfrom\u001b[39;00m \u001b[39merr\u001b[39;00m\n", "\u001b[0;31mValueError\u001b[0m: 'c' argument has 926 elements, which is inconsistent with 'x' and 'y' with size 913." ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c30c2e1b938147c8bd27657deb0d3f42", "version_major": 2, "version_minor": 0 }, "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAYAAABB4NqyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAACwNklEQVR4nOz9eXhjZ33+j99Hi23JtrzJq7zbs9kz9nibSZp+QihLYEomQ0P4hFJSSMN2hRJ+QEtKf6SBT2lpobS0obRAWFpIAlkgAcJAoA2lLDOZMN738b5qt61dOjrfP4bniSRvkn0kHdnv13XlujIzmqPHskfn1nu5b0GSJBAEQRAEQRwmVOk+AEEQBEEQRKohAUQQBEEQxKGDBBBBEARBEIcOEkAEQRAEQRw6SAARBEEQBHHoIAFEEARBEMShgwQQQRAEQRCHDhJABEEQBEEcOkgAEQRBEARx6CABRBAEQRDEoYMEEEEQBEEQhw4SQARBEARBHDpIABEEQRAEceggAUQQBEEQxKGDBBBBEARBEIcOEkAEQRAEQRw6SAARBEEQBHHoIAFEEARBEMShgwQQQRAEQRCHDhJABEEQBEEcOkgAEQRBEARx6CABRBAEQRDEoYMEEEEQBEEQhw4SQARBEARBHDpIABEEQRAEceggAUQQBEEQxKGDBBBBEARBEIcOEkAEQRAEQRw6SAARBEEQBHHoIAFEEARBEMShgwQQQRAEQRCHDhJABEEQBEEcOkgAEQRBEARx6CABRBAEQRDEoYMEEEEQBEEQhw4SQARBEARBHDpIABEEQRAEceggAUQQBEEQxKGDBBBBEARBEIcOEkAEQRAEQRw6SAARBEEQBHHoIAFEEARBEMShgwQQQRAEQRCHDhJABEEQBEEcOkgAEQRBEARx6CABRBAEQRDEoYMEEEEQBEEQh44DI4AEQfiKIAhmQRAGt/lzQRCEfxYEYVIQhH5BEDpTfUaCIAiCIJTBgRFAAL4G4HU7/PnrARz57X/vAvCFFJyJIAiCIAgFcmAEkCRJ/wPAvsNDbgfwH9J1fg2gUBCEytScjiAIgiAIJXFgBFAcmADMR/x64be/RxAEQRDEIUOT7gMoEUEQ3oXrbTLk5uZ2HT9+PM0nSh1XrlxJ9xEIgiAURXd3d7qPkFJeeuklqyRJpek+R7I5TAJoEUBNxK+rf/t7m5Ak6YsAvggA3d3dEokCgiCIw8thuwcIgjCb7jOkgsPUAnsWwN2/3Qa7AcCaJEnL6T4UQRAEQRCp58BUgARBeAzALQCMgiAsAPgrAFoAkCTp3wA8B+AcgEkAHgDvSM9JCYIgCIJINwdGAEmS9JZd/lwCcF+KjkMQBEEQhII5TC0wgiAIgiAIACSACIIgCII4hJAAIgiCIAji0EECiCAIgiCIQwcJIIIgCIIgDh0kgAiCIAiCOHSQACIIgiAI4tBBAoggCIIgiEMHCSCCIAiCIA4dJIAIgiAIgjh0kAAiCIIgCOLQQQKIIAiCIIhDBwkggiAIgiAOHSSACIIgCII4dJAAIgiCIAji0EECiCAIgiCIQwcJIIIgCIIgDh0kgAiCIAiCOHSQACIIgiAI4tBBAoggiE2Ew2EEg0FIkpTuoxAEQSQFTboPQBCEcpAkCaIowu/3w+/3Q6VSQaVSQa1WIzs7G2q1GoIgpPuYBEEQ+4YqQARBALgufiwWC9bX1yEIAtRqNVQqFcLhMH7961/D5XJhbW0NGxsb8Pl8CIVCVCEiCCJjoQoQQRAIh8MIBAJYXV1FQUEBFzpFRUUwGAxcEEmShHA4DK/XyytBGo2G/0cVIoIgMgUSQARxiJEkCaFQCKFQiAuXubk5aDQaFBcXY2VlBePj4/B6vZiZmUFRURHy8/Oh0Wj43xdFEcFgMEoQabVaqNVqEkQEQSgWEkAEcUiRJAmBQADhcBiCIMDlcmFxcRFlZWU4fvw4gsEgKisrAQCXLl1CdnY2lpaWsLGxgezsbBQVFaGoqAh5eXmbBFEoFOLPwwSRRqOBSqUiQUQQhCIgAUQQh5BQKIRgMMh/PT8/j8XFRVRUVKCwsHCTSFGpVKisrOSCyOv1wuFwYG5uDi6XCzqdjgui3NxcqFTXxwtjBZEgCFEtMxJEBEGkCxJABHGIiG15hUIhDA4OIisrC2fOnMHc3Fxcg806nQ46nQ5VVVWQJIkLopmZGbjdbuj1ei6I9Hp9lCCKFF8kiAiCSBckgAjikMC8fVjLy+l0Ynh4GE1NTaioqACAPYkPQRCg1+uh1+thMpkgSRI8Hg8cDgempqbg8XiQm5vLBZFOp4sSRMFgcJMgYjNEJIgIgkgWJIAI4oATOagMXBcZU1NTsFqt6OzshE6n2/T4/SAIAnJzc5Gbm4vq6mpIkgS32w2Hw4HJyUl4vV7k5eVFCaLI544VRGx+iAQRQRByQgKIIA4wTFCIoghBEOD3+zEwMICCggL09PTwSgxDpVLJ7u0jCALy8vKQl5eHmpoaSJIEl8sFh8OB8fFx+P3+KEGUk5MTdf5AIAC/34/l5WWUlZVBr9fzlpkgCCSICILYEySACOKAwrx9JEmCIAiwWCyYmJjA8ePHUVJSsu3fS7a5oSAIyM/PR35+PmpraxEOh7kgGh0dRSAQgMFgQGFhIYqKipCdnQ0AcDqdMBqNXBAx8aPVannLjAQRQRDxQgKIIA4YW3n7jI6OwuPxoKenB1lZWdv+XUEQUu7urFKpYDAYYDAYUFdXh3A4jI2NDdjtdiwvLyMYDKKgoAB+vx/BYJC3zNg5A4EAAoEAv1bsDBFBEMRWkAAiiANErLePx+PBwMAAKioqcPz48V2rI4IgIBwOp+i0W6NSqVBQUICCggIA1ytZa2trvGUmSRIKCgpQVFSEwsJCaLVaACSICIJIDBJABHFAYFUf1vJaXl7GzMwMWltbuZjYjcgKkFJaSSqVivsLNTc3IysriwsitrYfKYgiTRkBEkQEQWwNCSCCyHBiW17hcBjDw8MAgDNnznBBEA/paIElilqtRnFxMYqLiwFcF35MEM3MzAAAnx8qKCiIEkSsQhYpiGK3zAiCOByQACKIDCbW22djYwODg4Ooq6uDyWRK+HpKqfokgkajQUlJCR/sDoVCcDqdsNvtmJ6ehiAIUYJIrVYDeFkQ+f1++P1+ANfFFasOsS0zgiAOJiSACCIDYd4+4+PjqKmpgVarxezsLJaXl9He3o7c3Nw9XTcTKkC7odFoYDQaYTQaAQDBYBBOpxNWqxXXrl2DWq3eVhCFw2H4fD5+LSaIKOmeIA4eJIAIIsOI9PZxOBwoKyvD4OAgdDodzp49u+82DhNAbJYo09FqtSgtLUVpaSmA6zNBTqcTZrMZk5OT0Gg0XBAZDAYSRARxSCABRBAZRKy3TzAYRG9vL44dO4aysrJ9Xz/SCPGg3tyzsrJQVlbGXy+/3w+Hw4GVlRWMj48jKysrKuk+VhBduXIFR48eRVZWFgkigshgSAARRAYQGWfBbrKTk5PweDzo7OxEUVGRrM91mG7k2dnZqKio4HloPp8PDocDi4uL2NjYQHZ2dpQgkiSJD0yHw2F4vV7+epEgIojMgQQQQSicWG8fn8+HgYEBvgm1k7FhohyEGaD9kpOTg8rKSlRWVgIAT7qfm5uDy+VCIBDA0tISjEYjcnNzo7bMSBARROZAAoggFAyr+rCqDJtbOXHiBIqLi9HX1yerYNlJAB22yhBDp9NBp9OhqqoKkiThpZdeglqtxszMDNxuN/R6Pa8QsZwyYGtBFOlBRIKIINILCSCCUCCx3j6SJGF0dBQ+ny8qzkLuis1212O/f9hv2IIgQKVSobKykge7ejweOBwOTE1NwePxIDc3NyrpPlIQiaKIUCjEr8cEkUajoaR7gkgxJIAIQmHEevu43W4MDAygqqoKJ06ciLpJsjkUuaAW2O5ECkFBEJCbm4vc3FxUV1dDkiS43W44HA5MTk7C6/VGJd2zHDN2nUhBJAgCT7knQUQQyYcEEEEohMhBZ8bi4iLm5uZw8uRJGAyGTX8nGRWg7X6fhNF1dqqECYKAvLw85OXl8QoRS7ofHx+H3+9Hfn4+X7vPycmJum4oFOLffxJEBJFcSAARhAKIbXmJooihoSGoVKod4ywi19blPEssJID2hiAIyM/PR35+PmpraxEOh7kgGh0dRSAQgMFg4IIoOzub/10SRASRXEgAEUSaifX2WV9fx9DQEOrr61FVVbXj35U7vZ2Ezu7sZxZKpVLBYDDAYDCgrq4O4XAY6+vrcDgcWF5eRjAYjAp2jdzwYwaYTBAxgcTcrEkQEURikAAiiDQR6+0jCAJmZmawurqK06dPQ6/X73qNVA9BE9eRS2ioVCoUFhaisLAQwPWtPyaIFhYWIIpilCDSarX87/r9foyMjODUqVP854cNVLMcMxJEBLE9JIAIIg3EevsEAgEMDg4iNzcXZ86ciTvOIllD0GazGbOzsygoKOCp6ySAko9areYD08B1QcSS7ufm5iBJEhdEOp2Oh7YCL/9MsWBXlnTP1u5JEBFENCSACCLFxLa87HY7RkdHcfToUZ5XFS9yV2YkSYLT6UQgEMCRI0fgcrmwtLTE23JGoxFFRUXIzc2lm2kKUKvV3PASuJ50zwTR1NQUfD4fJicnebBrpBgCrueeBQIBANcFUaQP0X4z4wgi0yEBRBApInbQGQAmJiawtraGrq6uqI2geJFTAHm9Xj543dHRgWAwiNzcXJSXlyMQCKC+vh5ut5sbAObm5qK4uHjTejeRPDQaDUpKSlBSUgKPx4PJyUkUFhbCbrdjenoagiBsm3QPkCAiiEhIABFECpAkCSsrK8jNzUVWVha8Xi8GBgZgNBrR3d29r6FaOVpgFosF4+PjaGxsxOrq6qbzCIKA7OxsFBQUcEdk5ncTud5dVFQkezwHsTXhcBgajQZGoxFGoxEAEAwG4XQ6YbVace3aNajVahJEBLENJIAIIsmwVeaFhQXU1dXB4XDg2rVraGlp2XeI6X4rQOFwGBMTE3C5XOjp6UEoFMLq6uquzxPrdxMOh7GxsQGHw4GhoSG+nVRcXIzCwsJt1/iJvbPVNppWq0VpaSlvpQYCATidTh6hotFo+IxRfn5+lCBiM0SRgigyx4wEEXHQoHclgkgSsS0vQRAwNTUFADhz5kzURs9e2Y8A8vl86O/vh9FoRGdnJwRBQCgU2tP1VCoVCgoKUFBQgPr6+qjh3ZmZGd6aKS4uhsFg4DdeYu+Ew+FdRUlWVhbKyspQVlYG4PrmGFu5HxsbQ1ZWVlTSfawg8vv9fKiaDVxHbpkRRCZDAoggkkBsnIXL5YLFYoHJZMLRo0dlXaPeSwuMtbxYqCpDrjX42OFd1pqxWCxRlYji4mLk5+fTzXQP7MWPKDs7GxUVFaioqABwXQSzlXuXy4Xs7OwoQcQEFgt2jRVElHRPZDIkgAhCRmLjLARBwMLCAubn5/mshpw3ikSNEMPhMCYnJ7G+vo7u7u4o52F2vWT4AMW2Zlglgt14c3Jy+EC1Xq+nm2kcxFMB2o2cnBxUVlaisrISwPVBeLZy73K5oNPpuCDKzc3dJIh8Ph+/lsfjQVFRUdTaPUEomQMlgARBeB2AzwFQA/iyJEmfivnzWgBfB1D428c8IEnSc6k+J3EwYU69oijydtLQ0BA0Gg3Onj2La9euyerZAyQmTFjLq6SkBF1dXVveoFJleBhZiZAkid94p6am4PV6ozbM9rIddxjYjyP1duh0Ouh0Oj7ozr4vbPNPr9dzQaTX66ME0djYGNrb26lCRGQMB0YACYKgBvB5AK8BsADgRUEQnpUkaTjiYf9/AN+WJOkLgiC0AHgOQH3KD0scOGK9fdbW1jA0NISmpibebpDbtDCRa1qtVoyNjeH48eMoKSnZ9nHpcIIWBAF6vR56vR4mkykqQJTlZRUUFMDv9yMYDNLK/W9JhgCKZKvvi8fj4ULV4/EgNzeXCyJRFPlsEKsQeb1efkYSRITSODACCMAZAJOSJE0BgCAIjwO4HUCkAJIAsEjtAgBLKT0hceDYatB5enoaFosFHR0dUXEWyQgu3U2YSJKEyclJOJ3OLVte8V4vlVEYWwWIsniIsbGxKK+bwsLCQztQLUcLLBEEQUBubi5yc3NRXV0dZYUwOTkJr9eLkZER/r3R6XSbWmYkiAglcZAEkAnAfMSvFwCcjXnMQwB+LAjCnwLIBfDq1ByNOIhsFWfR39+PgoIC9PT0bLo5yR1cyq65nTDx+/3o7+9HUVFR3F5DSsz8YnlZubm5aG5uhlarxdraGjf/U6lUvAphMBgOzbp2sitAuxFrhXDp0iXU1NRs8oZigignJ2dHQRS5YUaCiEgFB0kAxcNbAHxNkqR/EAThRgD/KQjCSUmSou5KgiC8C8C7AKC2tjYNxySUDqv6sJuQ1WrF+Pg4jh07xk3pYkllC8xms2F0dHTXllcskTed2P9XijCKdEMGXva6WVlZwfj4+KZNpoN6I011BWg3tqrcMW8o1so0GAxcEGVnZ0cJIlEUEQqF+PWYKaNGo6GkeyIpHCQBtAigJuLX1b/9vUj+BMDrAECSpF8JgpADwAjAHPkgSZK+COCLANDd3a2Md31CEWwVZzE+Po6NjY1dW0zJEECxwkSSJFy7dg0Oh2NP8RpKaIElSqzXjc/ng91u55tMer0+KrLjoNxI010BiiX2LJHeUACiWpnLy8sIBoNRSfeR7uGxgkgQhKiWGQkiQg4OkgB6EcARQRAacF343AXgD2MeMwfgVQC+JgjCCQA5ACwpPSWRscR6+3i9XvT396O8vHzbrapIVCoVX4+Xi0hhwlpehYWF6Orq2nN1YDsBlCnk5OSgqqqKbzKxwd3JyUn4fD7k5eVxQbTbTJSSUVoFaDdYK7OwsBDA9aR7JogWFhYgimKUIIo0Ct1KEEW2zEgQEXvhwAggSZJCgiC8D8CPcH3F/SuSJA0JgvAJAFckSXoWwIcAfEkQhP8frg9Ev11S6sdaQjHEevuoVCosLy9jenoaLS0t/A19N5LZArPb7RgZGdmxBRcPO1V6MvGfylaDuxsbG7Db7RgeHuaRHVvddJWOkipAe/nZUKvVvFUJIMo9fG5uDpIkRX1vIuNUWCU20m+LBBGRKAdGAAHAbz19nov5vQcj/n8YwE2pPheRucR6+4iiiKGhIYiiiDNnziSUcZWMLTAAWFtbg8vl2nOifCSRN43IG6ySW2CJIAgCDAYDDAYDj+xYX1/nLTNJkvhNOTI8VIkoSQDJUY2KdQ8PhUJRcSoAtt3+Y/9OIwWRKIrIzc0lQURsy4ESQAQhJ7HePi6XCwMDA6itrYXJZEr4DVXuLbBAIICxsTGEw2GcPXs2qe2QgyKAYomtQoRCoag09djwUCXdRJXUAkvGWWKH3dn3hm3/RdohxIpVSZLQ19eHtrY2vlH2b//2b/jIRz4i6xmJzIYEEEHEENnyYt4+c3NzWFpaQltbG/Ly8vZ0XTlbYA6HA8PDw6ipqYHT6VTMjTDT0Wg0PLIEuC4y7XY7lpaWsLGxgezsbAQCAbhcLuTm5qZVECmpAiSKYtKrZbHfG5Yvx8SqWq2OEkSSJEGr1fIPHo8//njCAuiee+7B97//fZSVlWFwcHDTn0uShPvvvx/PPfcc9Ho9vva1r6Gzs1OWr5dIPiSACCICSZJgt9uxvr6OyspKBINBDA0NITs7G2fOnNnXm7wcAkiSJG602NnZCVEU4XA49nXN3Z6PicCDWAHajaysrKjwULfbjb6+Ph4NkZeXxytEqXaoPugVoN2IzZdjdghmsxmTk5PweDyYnZ1FOByG0WhMqF3NePvb3473ve99uPvuu7f88x/+8IeYmJjAxMQELl26hPe+9724dOnSvr4uInWQACKI38JaXn6/H06nEzqdDsPDw2hubkZ5efm+r79fARQIBDAwMIC8vDxutOh2u5MiTGJFz2EVQLHk5OQgOzsbJ0+e5E7IdrudG/8ZDAYuiCLXupOBkipAShBjsXYIv/71r5GTk4OvfvWr+Pa3vw2v14u/+7u/wytf+Up0dnbGJYhuvvlmPn+0Fc888wzuvvtuCIKAG264AU6nE8vLyzxcllA2JICIQ0+st49arYbT6YTL5UJnZ6dsn+z3I4BYy+vIkSP8DX6/1yT2R6QTcqTxn91ux+LiIkRRjBra3UsFYieUIDoYSjoLQ6VSoaKiAn/xF3+BP/qjP8Kf/umforKyEl/4whegUqnwyCOP7Ps5FhcXUVPzsv1cdXU1FhcXSQBlCCSAiENNrLeP3+/HyMgIwuEwuru7ZX1T38sWmCRJmJmZgdls3lKMpaoyQxWg6+xUdYk0/mtoaIAoinA6nXyLSRCEqA2z/f5sKakCJIqiogRQ7M+q2+2G0WjE3XffvW07izh8kAAiDiWx3j6CIMBisWBiYgL19fWwWCyyv6EnugUWDAYxMDAAnU63ZbYYuyYJoNSRiOhQq9VRW0zBYBAOhwNmsxkTExPQarXckHEvG2ZKqroo6SzA9fNEzuu53W7k5ubK/jwmkwnz8y9HUC4sLMBkMsn+PERyIAFEHDpiW16SJGF0dBQejwc9PT0Ih8NYWVmR/XkTaVc5nU4MDQ3tOn9ELbDMQavVRs2o+P1+2O12LCwsYGNjA3q9nleI9Hr9roJISRWgWMGRbmIrUi6Xa8/bmztx/vx5PPzww7jrrrtw6dIlFBQUUPsrgyABRBwqYlteHo8HAwMDqKiowPHjx3mqezJERTxiRZIkzM7OYmVlBR0dHdDr9Ts+PlmVGUmSYLVakZOTw9e9qQIkr+jIzs5GZWUlKisrIUkSvF4v7HY7pqam4PF4kJ+fzwXRVgaXShNASqoAxa7ls429RHnLW96CF154AVarFdXV1fj4xz/Oq8bvec97cO7cOTz33HNobm6GXq/HV7/6Vdm+BiL5kAAiDgWx3j4qlQqLi4uYnZ1Fa2srD2wEkldV2e26wWAQg4ODyMnJwZkzZ+K6oSTDXZqZyAHXbyQejwcqlYpvOCV7u0nJJEt0CIIAvV4PvV7PIztcLhfsdjtPUmexEEVFRdBqtYoSHUo6C7C1ANpLC+yxxx7b8c8FQcDnP//5hK9LKAMSQMSBR5IkXtVhFvnDw8MAsGWchVqthiiKsp9jJwG0traGoaEhNDY2cs+ZeJDbXdrlcsHtdqOhoQFGo5GLKxYkOjg4yLebiouLN0USHAZSUXURBAH5+fnIz89HXV0dwuEwj4WYn5/n0Q9OpxNZWVlp/x4oTQBtNQOUjBYYkdmQACIONLFxFuvr6xgaGkJdXd22w4rJusFt1UaSJAlzc3NYXl7G6dOnd215bXVNuVhaWsLMzAx0Oh2qqqoQCAT4c+Tk5CAvLw+VlZV8u4m1a1hcRHFxseLiIuQmXW1AlUq1KbLjN7/5DdbW1rC4uBj15waDIeViJBwOy77mvx9CoVCUAHK5XLJ4eREHC+X8xBKEjMQOOguCwGdr2tvbk7IRshux7SrmMp2VlYWenp60fYoPh8MYHR2F3+/HmTNncPny5U2PiRRvsdtNfr8fDocjapiXhVqm2h052Shl7kaj0UCr1aKpqQlarRaBQAAOhwMrKysYHx9HdnY2F0R5eXlJP7MoisjOzk7qcyRCbAXI4/Gk5d88oWxIABEHjtiWF1sn1+v1cc/WJJv19XUMDg6ioaEhrVsjPp8PfX19KCsrw4kTJ7a9Ue40BJ2dnc3jIiRJgsfj2eSOzNa9tVptMr+cpKMUAQREt52ysrJQXl7OqxxerxcOhwNzc3M8tywyskPur0FpLTC5hqCJgw0JIOJAEQqForx92BBprINyumAtr8XFxbRVohg2mw2jo6M4ceIEiouLN/35Xja/BEFAbm4ucnNzUVNTs2l2BQCfH5LDDPAws5MY0+l0vJXJIjscDgef5YrcMJOjckMCiMhESAARB4KtvH0mJyfhdDrR1dW15RpxqgmFQvB6vVhfX993sOp+YIGqVqt129cmVvjsddg6dnaFDe4yM0DWqikuLk57uno8KKkCFO9ZIiM7mCjd2Njg8SqhUChqw2wvszxKFECRX4fH4yEBRGyCBBCR8cR6+/h8PgwMDKCkpATd3d2KuGGxlpdWq8XJkyfTdo7IduB2UR9bVX7k8gGKTfBmrRqWrs4qE8XFxYqaKWEoSQABexuCj4zsqK+vhyiKvEo3NzcHADzDrKCgIC6hrkQBFPnzkywnaCKzIQFEZCyxcRYqlQqrq6uYnJxES0sLrzrsBVbxkCOvaWFhAQsLC2hra0N/f/++rrcfmAjbbdU+laaHsa0a5n3DKhORYaJEclCr1XxoHXi5Sme1WnHt2jW+5cciO7b6N6G0LLDYFpjL5UJ+fn4aT0QoERJAREYiSRLsdjuysrK4Kdzw8DD8fj96enr2bdbHPHv286YeCoUwPDwMlUqV1pYXcD21em5uDm1tbbu2ApJZAdrteSO9byLDRKenp+Hz+bCwsICysjIYDIa0VGKUVgFKBrFVOrblt7S0hI2NDeTk5HBBxNqWSozCiJ0BIgFExEICiMg4mLfPtWvX0NDQgEAggIGBAZhMph03mRJBrVbvy2BwY2MDAwMDW/oNpfImKooiRkZGIIoienp69uzVko4ojNh1+76+PuTk5GBpaQljY2PQ6XR8uywZm01bcRgEUCyxW36xbcu8vDx4PB4EAgHF2B7ECiCv15uwxxZx8CEBRGQMsYPOarUaKysrsFqtOHXqlKyf8FQq1Z7doBcWFjA/P79ltYUJiVTcRD0eD/r7+1FZWYna2tq4nzMZ8RpyoFKpYDQaUVNTE7VuzzabUrFufxgFUCSRkR0mk4m3LQcHBzE1NYVgMMgjU9IZmxIrgJRWoSKUAQkgIiOI9fYJhUJwOBzQ6XRbxlnsl73kgbGWF4Btqy1ytNa2IvbGbLFYMD4+jtbW1j3Nz8ReT2lhqFut26+vr8Nut/OoCHYTLiwsVNR8ykGCtS2zsrLQ1tbG3dYdDgcWFxcRDof5hllhYWHK3KIjBZCSfm4JZUECiFA8rOrDbsosNys3NxfV1dVJeVNNtAXmcrkwMDCAmpoaVFdXb/u4ZFRXIqtKkev/e52F2qpKpTQBFItKpUJhYSEXe0wgs0FerVbLB333s25/2CtA28FEvSAI/PvQ0NAQNcc1MzMDQRC4ME2mD1RsBQhITYYbkVmQACIUy1ZxFjMzM1hdXUVHRwdWVlaSktoOJNYCY6ny8bTh5A4vZddkFbL+/n4YDIZ9rf8rXezEg0ajiRrk9fl8sNvtUXMrTBAlsm5PAmh7tnpdYue4gsEgHA4H94HKysqK2jCT67WN3ErL9J9lInmQACIUSay3Dxt0zs/P53EW+5nT2Y14WmAsVT4cDsfdhttLa203BEGA0+mUzfE6EytAu5GTk4Oqqqpt1+0LCgp4uv1O30elCKBM/V5otVqUlZXxn1Gfz7cpR44JIr1ev6/XmgmgQCCgSE8pIv2QACIUxVbePlarFWNjYzh69Cj/RA9c/3SZTAG007VZy6u6uhrV1dUJDRjLKYBY5WdsbAwdHR2ybLocRAEUyVbr9mtra7xCxNyrWbq9EueHlCLE9ktOTg4qKytRWVnJB9sdDgempqbg8Xj2bIwZ+bPKstAIIhYSQIRikCQJwWAQoijyG+7Y2BjW19fR3d296Q1QrVbD7/cn5Sw7zQAtLS1hZmYGJ0+ehMFgSOi6cgogURQxNDSEUCiErq4u2dZ82Wt/UATPbsQaAbJk9UjfG/bnrCKZbg6KAIokcrC9uroakiRFRXYEg8GoyI54N/0oB4zYDhJAhCJg3j7sjd3r9WJgYAClpaXbzrMkuwIUK1SYp04oFNrz5plcAsjtdqO/vx/V1dUIhUJJ2SqL5CBVgHYjMlmd+d6wdXuXywWNRoO8vLy0rnkrLXoiGQiCAIPBAIPBgLq6uk3BupIkRTmFb7fmTjEYxHaQACLSSmTLSxAEqFQqrKys4Nq1a7uucKeyBcYEh8lkQk1NzZ4/fcuxBcbiPk6ePImCggJYrVZZ22pbfW2HSQBFEul7U11dDYvFAovFAo/Hw9e8I9PtU+U1o6QKUKp+LmKDdUOhEJxOJ+x2O6ampqBWq7eMTdmrALp48SLuv/9+iKKIe++9Fw888EDUn8/NzeGP//iP4XQ6IYoiPvWpT+HcuXN7/vqI1EMCiEgbsd4+4XA4qsKyW4k7mQIosgW2vLyM6enpPbW8YtnPFlg4HMbExARcLlfUirvc4iTyekq60SoFnU6HhoYGNDQ08JtwZG4Wa5fl5eUl7bWTJEkxFaB0VaM0Gg2MRiOMRiOAl1uXy8vL8Hq96Ovrw9WrVxEOhxMWQKIo4r777sPzzz+P6upq9PT04Pz582hpaeGP+eu//mu8+c1vxnvf+14MDw/j3LlzmJmZkfNLJJIMCSAiLcS2vGJ9dOK5cew3rmInVCoV/H5/VL6YHO7Ce22B+f1+9Pf3o6ioCJ2dnVGvj9zeQunKAssEYgVh7E2YbTXNzc3x4VsmiHJycmQ7h1JmkQDltONY67KwsBDBYBBHjx7Fr3/9a3z3u9/FxMQEVldX8apXvQqvf/3rd/TqAoDLly+jubkZjY2NAIC77roLzzzzTJQAYqaPALC2toaqqqrkfXFEUiABRKSUrbx95ufnsbi4mHCcRTLX4EOhEObm5tDQ0CBbvhiwNwHEhkCPHTvGb7SRyO0tRAJo78RuNbndbtjtdoyOjiIQCPB1+6Kion0ZeCqpMqcUAcRgJog6nQ7vfve7UVhYCLPZjNtuuw0//elP8dJLL+0qgBYXF1FTU8N/XV1djUuXLkU95qGHHsJrX/ta/Mu//Avcbjd+8pOfJOXrIZIHCSAiZcR6+4RCIQwODiIrK2tPaenJaoGtrKxgZmYGJSUlqKurk/XaiQggSZIwOzuLlZUVdHZ2bhs0mcwWWOTvEYkJD0EQkJeXh7y8PNTW1vIhXrvdjtnZWe6KXFxcDIPBkJCIUJLoUNJZgO2T4E+dOoVTp07J9jyPPfYY3v72t+NDH/oQfvWrX+Ftb3sbBgcHFfVaEDtDAohIOrHePsy4b3h4GE1NTaioqNjTdeUWQOFwGKOjo/D7/Th27BjW1tZkuzYjXgHExKFWq+XGj/u9ZrwwAbS+vg6/38+HTqkCtL/KS+wQL3NFXllZwfj4OHJycrgg2s0EkCpA2xMrgFwuF0wmU0LXMJlMmJ+f579eWFjYdI1HHnkEFy9eBADceOON8Pl8sFqt+zYiJVIHCSAiqcS2vABgamoKVqt1x6pGPMgpgFhyekVFBU6cOAGn05mU+aJ4qjUulwv9/f2oq6uL6407Ge2p5eVlrK+vQ6/X8+HecDgMj8cDnU6nmJtvqpFTeMS6Im9lAsjmh2LX7ZUkOiJjJ5RArADyer0JD0H39PRgYmIC09PTMJlMePzxx/Hoo49GPaa2thY//elP8fa3vx0jIyPw+XxRRq2E8iEBRCSNcDiMpaUllJSUQBAE+P1+DAwMoKCgAD09Pft+05Sr8sHWyiPX7pM1X7TbmVdWVjA1NZXQPJScAkgURdhsNuj1enR1dfGbm9VqxczMDCYnJ+Hz+WSbZSFehq3bm0wmbgJot9sxODgIURSj0u2VVgFK1fp/PGxVAUrUCFGj0eDhhx/GrbfeClEUcc8996C1tRUPPvgguru7cf78efzDP/wD3vnOd+If//EfIQgCvva1rynme0LEB71zEbIT2fKamJiA0WiE1WrF+Pg4jh8/zoMR98t+32zC4TDGxsbg9Xo3JacnI7OLXXcrYcXO4vP5Et44k2sI2uPxoK+vDzk5Oaivr486a05ODvR6PVpaWhAOh7G+vg6bzcZnWYqLi1FSUiJroKUSSZXwiDQBrK+v3+R5I0kS1Go11tfX0/6aK6kaBWw9A7QXJ+hz585t8vX5xCc+wf+/paUFv/jFL/Z+UCLtkAAikgJrealUKoyMjMDr9W4ZZ5EuvF4v+vv7UVZWhuPHj2+6gSRrxV6lUvFZKIbP50NfXx9KS0u3PEs819xvBYjlrbW2tmJ1dXXHLTCVSoXCwkJeLWP+KyzQMlmr30ogXZWX2HX7lZUVrK6uRr3mbH5oP23lvaB0AeTxeMgJmtgSEkCE7DDh43K54HK5UFJSIusq+X4xm82YmJhAS0sLH0iNJVUtMLvdjpGRkX1VxvbTApMkCTMzM7BYLFygms3mhNbgY6MjIle/g8Egd0reKa6ASAyNRoP8/Hw0Njby19zhcGB8fBx+vz8q3V4O/6qdUKIAivya2RYYQcRCAohICktLS5ienkZBQQFMJpMixE84HMb4+DjcbvemllcsyWyBsaDRmZkZmM1mdHV17atSstcKENs0y87ORnd3N7+J7UdQxa5+i6IY1brRaDQoKSlBcXExcnNzFfFzkQhKcWCOFB2Rr3lNTU3Uuv3c3BwA8PmhgoIC2c+v9CHovcwAEYcDEkBEUmBxFizaIpnE05ZgLa/S0lIcO3Zs18cnqwXG/I96e3uRk5MjyzD4XmaA2LxPbW3tpk0zOY0Q1Wo1SkpKeHXL5/PBbrdjZmaGfzLfbtNJiShl+Hinc2y3bs8qn9nZ2XyAXQ4RqvQhaKoAEdtBAohICiy9WaPRJM2tGXh5FX6nTSSLxYLx8fEdW16xJKsF5vP5sLS0hBMnTqCyslKWayYqTtjrwcJU47meXJtmOTk5qKqqQlVVFd90stlsGBwcRDgc5nMsyahUHCQSaTvFrtuzdPtYEVpUVLSnGT3271wpxAogn8+X8rkoIjNQzk8tcSBRq9VJrQDtJIBYeOjGxsauLa9YkvEpf2lpiTtMyyV+gPhbYJIkYWpqCna7fcfXY7s0eLmJ3HRiwaKRlYqcnBxeHdLr9bI//17IhArQbuh0OphMpk3r9sPDwwiFQgnPbClxBijyPEppWxLKgwQQkVSSmdi+0/V9Ph/6+/tRUlKCrq6utK8Jj4yMIBgMorW1FUtLS7JeP54WWCgUwsDAAHQ6Hbq6una8IWx3vWQ7QWs0GpSWlnIzOY/HA7vdzr2HQqEQ7HY7ysvL01ZxUIoAkkt0xK7bx85sqdVqLkK3W7dXogBiwo3cy4mdIAFEJAX2RqnRaJJeAYq9WbMWz4kTJ1BcXJy0544HNntUXl6Ouro6uFwu2WeLdhNAzFm6oaFhz5WndIShMmPA6upqhMNhXL16FS6XC8vLy3zOJdXeQ0oRQMk6R+zMViAQgN1u5+v2er2eCyLWVlKyAGIo4XtGKA8SQERSSXYFKHJWR5IkTE5Owul0KsJziHnrRM4eJUNIbOUtxDCbzZicnNyTs3TkTSPdafAqlQpZWVmora2FTqfbdGNm3kMlJSVp/76nglQJsaysLFRUVKCiogKSJPGqHFu3NxgM8Pl8MBgMST9LvFAFiIgXEkBEUtFoNAgEAkm7PhNYPp8PAwMDKCoqQnd3d1o/8UXO2sQKsWSs128lTpgYXFtbQ3d3d8LzT0q/ccTemJn30F7nWOJFKRWgdFRdBEFAbm4ucnNz+br9+vo6xsfHMT09jdnZWUUMsUfO/NAANLETJICIpMBuEqkYgnY4HPs2E9yORG94gUAAAwMDyMvL23LWJhUCKBgMor+/H/n5+Xuaf0rmFlgy2M17SKvV8rbNfte+lSKAlHAO5gjOXvecnJyoIfasrCzZXvdEiHxtXC4XuUAT20ICiEgqyVyDlyQJTqcTgUAAPT09src+tmoF7cTa2hoGBwfR3NyM8vLyLR+TDAEUeU0279PY2IiKioo9XS/TBFAsO3kPxaasJ+qSrAThAShr7oadJXaI3ev1wuFw8HX7vLw8/rqnqk3pdrtJABHbQgKISCrJqgD5/X709/dDEATU19cn5Q2VCYt4bjQLCwuYn5/H6dOnd3zDTWYFaC9J8ttdLxkmkOliO++hxcVF7j1UUlICg8GgGFGxG0oRYsD2Ykyn00Gn0/HX3eVyRbUpI+M6krXVRwKI2AkSQERSiGyByV0BstlsGB0dxbFjx+D1epN2s47HZFEURQwPD0OSJJw5c2bXeZNkRWzYbDbud7Tf7KdMrwDtxHbeQysrKxgfH+feQyUlJVvOjihFeCipArTV1lUsgiAgPz8f+fn5qKurgyiKPK5jZmaGb/Wxdfu9fm2x35+9JsEThwMSQERSkbMFxoaLbTYbz89aWlpK2pD1bmKFxUmYTCbU1NTEdWOUW0gEAgFMTk4CADo7O2W5OW9nhHgQBFAskW0bSZK4S/LExAR8Ph+vUhQVFUGj0ShGACnlHMDexFikvxBw/efY4XBgaWkJGxsb0Ol0Uen28X6tsWehHDBiJ0gAEUlFrhaY3+/HwMAADAZDVHBnsiIr2LW3E0Bs0HO7OIntkPOmtbGxgYGBAVRUVMDn88l67YModnZDEIRN3kOsSjE7O8sdt/V6PQoLC9NurqmUCpAcZ8nKykJ5eTnKy8v5ur3D4eAmmPHObcVWozweD7XAiG0hAUQkBTlbYHa7HSMjIzh69CgfsGQk02doK5NFSZIwMTGB9fX1hOM15GR5eRnT09Noa2tDKBTC4uKibNfergV22IgNFQ0EAhgeHobFYsHCwgJyc3N5sn2qvYeUVAEC5P35iFy3Z0KUxXUsLCxAkiRuc1BQUBAleCgJnkgEEkBEUtnvyvHU1BSsVitvecWSTAEUW10KBALo6+tDYWFh2uI1wuEwxsfH4fV6cebMGWg0Gqyvr8s6V3RQ2137JSsrCzqdDhUVFTAYDHC73bDZbFHeQyUlJZtuyslAaQIomahUKhQUFKCgoIDPbTmdTlitVly7dg1arZa3ywBsSoJPVABdvHgR999/P0RRxL333osHHnhg02O+/e1v46GHHoIgCGhvb8ejjz66vy+SSAskgAhFEumn09PTs22JPdkCiAkLp9OJoaGhLatQqYIJsOLiYhw7dozfAOUWLJHXOyw32UQQBCHKe4gN9cbelNkwtV6vl/11VFILLNVoNBoYjUYYjUYAL9sczM3NYW1tDYIgYGlpCaIowu12JxSHI4oi7rvvPjz//POorq5GT08Pzp8/j5aWFv6YiYkJ/O3f/i1+8YtfoKioCGazWfavkUgNB0oACYLwOgCfA6AG8GVJkj61xWPeDOAhABKAPkmS/jClhzwk7OcN3+FwYHh4GEeOHEFZWdmOj012CywUCmFubg5LS0vo6OhIWyo58xjaSoAlUwAR0Wz3umznPTQ9Pb1v76HtzkHi9DqRNgc2mw2rq6vw+Xx497vfjZWVFZw4cQJFRUW45ZZbdo3suHz5Mpqbm9HY2AgAuOuuu/DMM89ECaAvfelLuO+++3hrdLf3KEK5HJiPEIIgqAF8HsDrAbQAeIsgCC0xjzkC4C8A3CRJUiuAD6T6nIeVeG6okiRhenoa4+Pj6OzsjOuNZas5HTmZnp7m8z7pEj+Li4sYHh5GR0fHltUnuVfrSQBtT7zCg92UT548iZ6eHlRVVcHj8aC/vx8vvfQSpqam4HQ69/x9O8wVoJ0Ih8PQ6XRobGzE888/j3PnzuGWW27Br371K9x666345S9/uePfX1xcRE1NDf91dXX1pvm68fFxjI+P46abbsINN9yAixcvJuVrIZLPQaoAnQEwKUnSFAAIgvA4gNsBDEc85p0APi9JkgMAJEmi2mUSYTdSJlJ2motgLa/c3NwdW16xJMto0e12Y2lpCaWlpWhtbZX9+vEQDocxOjrKna638yNKVgVoYWEBKysrvJVDomhvlRdBEKJmWILB4CbvITZMHW9ulVIqQEr7mYgdgvb7/fjd3/1d3HTTTbI9RygUwsTEBF544QUsLCzg5ptvxsDAAAoLC2V7DiI1HCQBZAIwH/HrBQBnYx5zFAAEQfgFrrfJHpIkieR7kmEiZTsBxOZr4ml5xZIMY0HmqFxZWZm0FdrdbmB+vx99fX0oLS3FiRMndnys3AJIkiRYrVbk5eXhyJEjWFtbw9TUFDweD0ZHR1FSUsJ9cYjE0Wq1KCsrQ1lZGfcestlsPGG9oKAAJSUlOzokK6UCpBQhxhBFMep1SXQN3mQyYX7+5dvIwsICTCZT1GOqq6tx9uxZaLVaNDQ04OjRo5iYmEBPT8/+vwAipRy2dzANgCMAbgFQDeB/BEE4JUmSM/JBgiC8C8C7AKC2tjbFRzx4bDenI0kSZmZmsLq6uuf5GjlngNiGlcfjQU9PD1ZWVpLSXmOibTdBeOzYMT7oGc/15CAQCGB8fBwajQYnT55EKBRCbm4uqqqqcPnyZVRUVMBms3FfHFa5yMvLU9SNMFnIfcOP9B5iCetra2uw2WzcIZnNDuXn5/PnVorwUIoQY4iiGDVj5Xa7E4qF6enpwcTEBKanp2EymfD4449v2vC6cOECHnvsMbzjHe+A1WrF+Pg4nxkiMouDJIAWAdRE/Lr6t78XyQKAS5IkBQFMC4IwjuuC6MXIB0mS9EUAXwSA7u5uZdV4MwhWmdjKDToYDGJgYAA6nQ5nzpzZ85uoXDcBVnEpKSlBR0cHBEGASqVCMBiU5fqR7FSxYZliiQhCuSpA6+vrGBgYQGVlJfx+/6bviSAIKCws5KV+v9/PTQLdbjcMBoOsg75KJNnCYyvvIeZ/s7GxwQNFRVFUjABK9sp/IoiiGGWXkegavEajwcMPP4xbb70VoijinnvuQWtrKx588EF0d3fj/PnzuPXWW/HjH/8YLS0tUKvV+PSnP82H34nM4iAJoBcBHBEEoQHXhc9dAGI3vL4L4C0AvioIghHXW2JTqTzkYSR2Tiee1PRUwowWjx8/HvVGplar4fP5ZH++rSo24XAYIyMjEEUxrkyxSOQQQKztd/r0aQQCASwvL+/6d7Kzs1FZWYnKykpIkoT19XXYbDYsLCwAAJ8diqxcEImRlZWFiooKVFRURAWK+nw+XLlyhfvfpMJ7aCtiW07pJlaQ7cUI8dy5czh37lzU733iE5/g/y8IAj772c/is5/97P4OS6SdAyOAJEkKCYLwPgA/wvX5nq9IkjQkCMInAFyRJOnZ3/7ZawVBGAYgAvgzSZJs6Tv14YBVgCRJwuzsLFZWVtK6Us5g51ldXd3SaDFZwaWx1/X5fOjr60N5eTnq6uoSFgv7OackSZicnOSbblqtFsFgMGFBFTnoC2xduWDtsnS5Z8tBOltPkYGiZrMZnZ2dcDgcsFqtmJycRFZWFn+Nk+E9tBVKbIHFDkFvZaBKEMABEkAAIEnScwCei/m9ByP+XwLwwd/+RySZyDgMn8+H3t5eZGdn76vlJRehUAgDAwPIzs7edussFQKIeR6dOHEiIcO2SPZaAQqFQujv70dubm5UkKocFaXYygWLMhgYGIAkSbw6ZDAYMqo6pJTZG+D6v6tIQ0AW5Do1NQWv14v8/Hw+sJ6slqTSBRAARZ2PUBYHSgARyiQYDGJ+fh7Hjx9HRUVFUp4jkRsTCxGtr69HVVXVto9Llskii9hgBoudnZ1xrz9vxV5uyB6PB729vVu+BslYqzcYDDAYDKivr+dr4EtLSxgdHU1rplaiKEkAxaLT6WAymWAymXh+ls1m41tNrF1mMBhkEwVKFkBKW9EnlAcJICJpRLaYTCZT0sTPbltVkSwtLWFmZganTp3adTskWRUgQRAwMTEBrVaLnp6elM9u2Gw2jI6Obptkn2wjxNg1cJapNTQ0hHA4jKKiIl4dUtLNNZOIzM8CsMl7SKfT8YH1/YhvJQsghlIFK5F+SAARSWNmZgYulwvNzc3w+/1Jex5WqdlJSDBTQb/fz0NEdyMZAsjr9cJqtcJkMuHo0aMpfXOOFKTd3d3bVltSeabYTK1QKLTpRs2qQ0pAyRWgnYgVnR6PB3a7nXsPsXT1nbyHtkJpQ9CR7wPhcDgjv1dE6iABRCSN+vp6hMNhWCwWeDyepD3Pbq0qNmRcVla2q6lgItdNFLZtVlRUhLKyspS+OYfDYQwNDQFAXE7b6WofaDQalJaWorS0lN+obTYbRkZGsLGxgdnZWZSVlaGwsDAtN95MFUCRCIKA3Nxc5Obmcu8hp9MJu90e5T1UUlKyq7+TEtfg2Xm8Xm/aFy0IZUMCiEgaka2pZMRVMHYSKqzds5chY7kqQLHbZjMzM0nNL4vF7/ejt7cXFRUVqK2t3fUGrpQssMgbdW1tLfr7+2EwGPjWU05ODr9R76eNkwhKeF3kJtJsEXjZ32lubo6vkbM/j60aKq0FFilQXS5X0pzciYMBCSAi6SQzsX2760uShKmpKdhsth3bPTshhwASRRFDQ0NQq9W88pKs2aKtYJ5LsR5HO6EUARSLIAgoKiriQ9usOsTaOGzIt7CwMKlViXRXgJL9vYn1d2LeQ8PDwxBFMapdpjQBFEmiMRjE4YMEEJE02I1Co9GktALEXKb1ej26u7v3/Aa936R5j8eDvr4+VFdXRyVMp0oALS0tYXZ2NmHPJaUKoFgiIyREUeRtnKmpKWRlZfHqkJxtECW0wFJ5hkjvITaj5XQ6eRVOkiTk5uaiqKgoZd5D8UIVIGI3SAARSSfZFSC2Vg5cj3MYHBxEY2PjvrfOIq+bKFarFWNjY2htbd2UEq1SqZIqMCRJwvj4ONxu944p8tuxkwBSggDYCrVajZKSEl7lYp44k5OT8Pl8PGC0qKhoX9UhJXz96TyDRqOJ8h66du0aAoFASr2H4iXRGAzi8EECiEg6qagAhcNhLCwsYG5uDm1tbbK88e3lJsMCXi0Wy7atN0EQklYBCgaDfFaGZZolynYCiP1+ugVAPMR64rCA0enpaWg0Gi6WlFa1iAcltZ1UKhWMRiNKS0u39R5icSjJPnPs60IVIGI3SAARSSPSCTqZFSBBEDA7O8tdphOteMhFKBTC4OAgsrOzd2y9JasF5na70dfXt+/qV6a0wOIlNmDU5/NFOSYbDAZetdjtZ0cJAlAJZ2BEio7tvIeWlpawsbEhm/fQdsRaYXg8HqoAETtCAohIOsl8s/Z4PFhYWEBBQQHa2trSdmNwu93o7+9HbW0tTCbTjo9NhgAKhULo7e3FqVOnYDAYZL0246AIo5ycHFRVVaGqqgrhcJiHuM7OzkKlUnHfoe1WwNMtPiRJUkwFaKdqVLzeQ/ttSzJiBdBeglCJwwUJICJjsVgsGB8fR1VVFbRabdpuTOwc2zkrx6JSqRAMBmV5btZy8/v9+D//5//IEvy43YzSQRFAkahUKhQWFvI5LbYCPjs7C7fbHVUdSvdMC0NJBn/xtuNivYdEUcTa2hrsdjtvS7Lq0G7eQ9sRa8pIM0DEbpAAIpJGst6kWYK50+lET08P7HY73G53Up5rt3NMTU3Bbrejp6cn7pRzuSpAkSv2+fn5st6gD5rQiZfYFXBWHWIzLX6/H+vr68jPz0+bCFFqCywR1Gr1rt5DrBIX77+r2AqQ2+1GWVlZwmcjDg8kgIiUIccbdyAQ4EO+3d3dEAQh6TNGW52bpcnrdDp0dXUldBOQYwvM5/Oht7cXVVVVqK2txeXLl2Vz5d1tCPqwIAhC1ExLIBDAlStXsLCwgI2NDeTn5/ObeLw3aTlQ0hC0XFEYW3kP2Ww2DA4OIhwOo7CwECUlJSgoKNj2+WgGiEgUEkBEUmE3zUQCS7eDmfodOXIk6pPdftbVd2OrzSeXy4X+/n40NDSgsrJyT9fcTwXI6XRiaGgoyt1aTnFCAmhrsrKyoNVq0dLSAkmSsLGxAbvdzm/SzHfIYDAktUKjtAqQ3KaTkd5D9fX13HvIYrFgYmIC2dnZXHhGbvHFnoVaYMRukAAiUoJGo9k1sHQ7JEnC/Pw8FhcXtzT1269h4U6wa7NPnWazGRMTE/saNt5PC2xhYQHz8/Po7OyM2qSR01toJwFEXEcQBBgMBhgMBtTX10dtPI2OjiI3N5e3cPbiQr4TSqoApeIssd5DzOMpcouvuLh4yyHoRNfgL168iPvvvx+iKOLee+/FAw88sOXjnnrqKbzpTW/Ciy++iO7u7r1/cURaIQFEpASWB5Zoq4DNuQiCgDNnzmwpoJLZAmPVJbVajcnJSaytrSU077PdNRMVQOFwGGNjY/D7/VuaG8rpLRQpdGJFz2GuAO1E7MaT2+2GzWbD0NAQwuEw98MxGAz7FgxKqwClWozFejytr6/DbrdjdXUVkiTB6/VieXk54QqQKIq477778Pzzz6O6uho9PT04f/48Wlpaoh63sbGBz33uczh79qzcXxqRYpTxMYI4sOzHC8jtduPy5csoLi7GqVOntq0eJVsABQIB/OY3v4EkSejq6tr3vEeiAog9f1ZWFtrb27f0qklGeyoQCODatWuwWCwIhUKHvgUWL4IgIC8vD3V1dejs7MTp06dhMBiwsrKCK1euYGBgAEtLS/D5fHu6/mGrAO0E2+JrbGxETU0NT7f/yle+gp///Od44IEH8KUvfQlzc3O7Xuvy5ctobm5GY2MjsrKycNddd+GZZ57Z9LiPfexj+MhHPiLLxiWRXpTxr4g48CTqBr26uore3l60tLSgurp6x8cmUwCFw2H09vbCZDLh6NGjsnzyTkQAbWxs4MqVK6itrUVTU9O2zy+3u7Qoirhy5Qp0Oh3W19fR29uLtbU1LC4uwu12kxBKAI1Gg9LSUhw/fhw9PT1obGxEKBTCyMgIXnzxRUxOTsJut8f9/VNSBUhJnkSiKCIrKwutra34xje+gWPHjuGjH/0o3G433vOe92B9fX3Hv7+4uBiV2VddXY3FxcWox/zmN7/B/Pw8fv/3fz8pXwORWqgFRqSEeEVKOBzGxMQEXC5X3K2mZAmglZUVrK2tobW1dd+5YpHEO6/D5o3a2tqQn58vyzXjwWw2w+v14sYbb+Sr9U1NTejt7YVareazF2wzJ9np6weJSD+c2tpaiKIIh8MBi8WCyclJ5OTk8Nmh7dySlSSAlMRWW2BdXV343d/9XXzgAx/Y9/XD4TA++MEP4mtf+9q+r0UoAxJARFKJTITfTaT4/X709/ejqKgInZ2dcb/Jy70FJkkSJiYmsLGxgbKyMtlL3btVa/biLyRHe4qZKlqtVuTm5kKv18Pv90OSJIRCIajVahiNRtTX1yMcDsPpdMJms/H0dZavlYyYg4MKe03ZgK/H44HNZsP4+DgCgQB3S44UmeluOymVWAEUCAQSGkA3mUzc7wm4vnAQ6eq+sbGBwcFB3HLLLQCuf0A6f/48nn32WRqEzlBIABEpgQ1Bb4fD4cDw8DCOHTvGbwbxIufNgPkMFRQUoLOzE6Ojo7JvmO3UAovME0vEX2i/FaBwOIzh4WEAQGdnJ37xi19gfX2dD5HabDZ4PJ4oF+uCggIUFhZCpVLB6/VG3bjZ0O9Ovi3EZvR6PfR6PXdLdjqdfOMpKysLxcXFVAHahq22TBN5nXp6ejAxMYHp6WmYTCY8/vjjePTRR/mfFxQUwGq18l/fcsst+MxnPkPiJ4MhAUSkhO0qQJIkYXZ2FisrK5tWu1PN+vo6BgYGonyGktFe204Aeb1e9Pb2oqamZte5p1j2MwMUCATQ29uLsrIy1NbWIhwOo6mpCdPT0/B4PNBqtfD7/Th9+jR0Oh3C4TD/D3h59qKqqgrV1dW8rcNaeDqdjleH5F4JP8io1Wr+ugEvr38vLi4iEAjA5/PxmA5qQUYLoL18GNBoNHj44Ydx6623QhRF3HPPPWhtbcWDDz6I7u5unD9/Xu4jE2mGBBCRVCK3wGLzr1i1Q6vV4syZM2mtFCwtLWFmZgbt7e1Rq7PJCC7d6pp2ux0jIyNoaWnhqeWJsNcWGDN1PHLkCIxGI0RRhCRJKC8vR3l5OSYmJrC2tgaj0YiBgQFkZ2fzlg0TM6IockHExGJxcTGMRiMPwbTZbBgeHoYoiigqKoLRaEy6YeBBg61/C4IAURSRl5cHm83Gs7SYWIo0BzxM7LcCBADnzp3DuXPnon7vE5/4xJaPfeGFFxK6NqE8SAARKSG2BcZuvHV1dbumpyeTcDiM8fFxeL1enDlzZtOKeTJMFmPbVczksaura8/zRntpgTFn3ba2Nuh0Or7qrlKpuDjNy8vjkSPA9SqE1WrFyMgIAoEAFzosTJSJIPYfcD19vbq6GrW1tQiFQrDb7dwwcC+ZT4cd5nhcVFTExbLP59tkDsiqQ1vZJsh1DiURKYDkiuggDjYkgIiUELkGv7y8jOnpaZw6dWrX7aZESHQ2IhAIoK+vD8XFxTh27NiWfzcZMRusXRUOhzE6OopgMIienp59tTESaYGxtqPZbEZXVxc0Gg1PGBcEAT6fD/39/aipqdkU9aHT6bjfiiiK3IBubGwMer0epaWlKCkpQVZWFiRJiqoKiaIIQRBgNBq5YSDLfBoYGADwcuVor4ngh4Gtfs5zcnJQVVWFqqoqbg5os9kwOzsLlUrFq0O5ubmyva7JiMHYD5ECyOPxJOwCTRw+SAARSSWyBca8T3w+H3p6emRNL080a4zlih09ehSlpaW7XldOmKi6cuUKSktLceLEiX3flOJtgYXDYYyMjCAcDqOrq4v/HhM/a2trGB4exokTJ3hVZzvUajVKS0tRWlrK3Y+tVisGBgYQDodRUlLCW12SJPH2GqsOSZIEvV6P3NxcHidhs9l4IjirYhQXFyetipGJ7Cb0mTkg+/6xpPWZmRm43e6o6tB+/g0qbRst8nVxuVybInMIIhZ6VyFSQigUgsViQUNDA44fPy77p3s2rByPAFpcXMTc3BxOnz6966dEtVqNQCAg1zEBXF+n9Xg8OHbs2I7iKxHiaYGxipfRaERdXR3C4TC/aQiCgJWVFczOzvJh50Rg7sd5eXlczNjtdiwsLGB9fR35+fkwGo1R1SE2OwS8XB0qKytDRUUFJEniVYy5uTm+febxeJCTk3Ooq0OJCo/YpHX2urKVbyYy8/PzE3pdlSaAgJc/cFESPBEPJICIpMMGYHU6HRoaGpLyHPHM6rCWUyAQ2DJPayvkboGtrKxgamoKOp1ONvED7N4CYzNXzc3NKC0t5RUYdsOYmprC2toab4ntF61Wywep2U3XarVyMVNSUoLS0lLk5uZuWR0CgLy8POTn56OxsZF7RM3Pz+PatWsoKChI+QaUUtyv97MGLwgCCgoKUFBQAOC6KGZCdWNjA/n5+TxpfbeZLKUJoMjvj8vlIgFE7AoJICKpbGxsYHJyEh0dHdxnJhnsJlT8fj/6+voSbjnJ1QKTJAmTk5NYX19HT08PXnzxxX1fM5KdWmBWqxVjY2Noa2uDXq+PGnYWRRHDw8PIysrC6dOnk1JZibzpNjU1we/3cwNFt9uNwsJCGI1G3uqKrQ4xE8bs7GwcOXIE2dnZWFtb4xtQWq02agPqoCOn8MjKykJFRQWvum1sbETNZEWGuMb+bChNAEWylyR44vBBAohIKgaDAWfOnOE3tWSxk1+P0+nE0NDQnkwW5dgCC4VCGBgYgF6vT8jhOhG2qwDNzc1heXkZXV1d0Gq1UfM+rKpSWVmZsO/QfsjOzo4a2I10lNZqtXzNXq/X8yFqv98Pj8fDf20wGLjJIjNhnJiYgN/v5zdtZtIoF0oxIEzWOQRBgMFggMFgQENDA4LBIBwOB9/Yy83N5UIzKytLUUPQsa+J2+0mAUTsCgkgIumwG24yWwjbCaCFhQXMz8+jo6NjT9WB/bbAPB4P+vr6UFdXh6qqqj1fZzdiZ4BYuy8UCnGn2kjxs7GxgaGhIRw5coQb7aUDlUrFWy7Ay2v2Y2NjXMzk5+djdnYWR44c4aIocn4p1oTR6XTCarVGZWuVlJTsO9JEKQIoVZUXrVaLsrIyvrHndrths9kwODiIcDgMnU7HN/3SXQmKPYPH45F1w5Q4mJAAIg4EsQKIbTuFQiGcOXNmz59U99MCs9lsGB0dxcmTJ/nMRbKIFJjBYJCv97PcrshhZ4vFgmvXruHUqVOK+5Qcu2Y/Pz+P8fFxaLVaLC8vIxgMwmg0Rq3Zs/9CoRBUKhWvAEmSxKtD7GehuLiYt3TSfdPeK+kQYpFD7nV1dQiFQpibm4PVasWVK1e423dxcbHs2XnxELsAQRUgIh5IABFJJVVv1JECyOfzoa+vD+Xl5airq9vXGfbSApMkCXNzc1hZWdnR3FDOGxnbknK73ejr60NTUxPKyso2DTvPzs7CarWis7NT8caDNpsNq6urOHv2LHJycvia/eDgIERR5J5BBQUFUZ5DkYPU2dnZMJlMqKmpQSgUgsPhwMrKCsbGxja1dHbjsFWAdkKj0fCtsfr6eu72zYRmqrPgYgWQy+WiChCxKySAiJSSrJsIE0AsVPX48eOytHYSbYGxUFFJktDT07Ptmz+r2Mj1WgiCALfbjcXFRW4wGTnszFpiANDR0ZH2G+huRAo15lUTuWYfCoVgs9mwuLiIkZER5Ofnc98htVq9rQkj2z6L9C0aHByEJEm8OrTdOrhSBJBSzsGEmCAIyM3NRW5uLmprazdlwbE2ZHFxcdKy/raqACWz5UwcDEgAEUmH3ezZnEoy3rxVKhUsFgu8Xq+soaqJtMD8fj96e3vjqjyx68olROx2O2w2G86ePQutVsvFjyAICAaD6O/vh9FoRG1trSJuntshSRLGxsYQCoV2FGoajSZqzX5jYwNWqxW9vb0AwAep8/LytjVh1Ol0qK2t3eRbxNbB2U1bTsNOOVCKANoubkKtVvPXHwCvDo2Pj/O5ruLiYhQWFso2RB0rgMgHiIgHEkBEymBu0HK3XkRRxPLyMiRJ2te8z1bEK4CYs3S8m2Z7ye7ainA4jLGxMbjdblRWVm7a9HK73RgYGEBTU5OsvkPJQBRFDAwMID8/f9tokq2I3F5qbGxEIBCA1WrF9PQ03G43CgoKdlyzZ9Wh0tLSTYJqfn6e+xYZDIZkfvlxo4QWGDtHPP/W9Ho99Ho9n+tyOp08tywrK4tX3vZjYbBVBYgEELEbJICIlKHRaGRfhfd6vejr60Nubi70er3sa7k7rdczWJJ8IptmiWR3bQer7BQWFqKurg5OpzNK/NjtdoyNjeHkyZOKn4dgLtUmk2nfrQu2FcbW7NfW1rgg2m7NPnJ+CAByc3ORl5fHBRVzpF5fX8fo6GjSg0Z3glVT0004HE7461er1XzuCrj+79dut2NychI+nw+FhYUoLi5O2OCShqCJvUACiEg6rAUWmwi/X+x2O0ZGRtDS0oJgMIi1tTXZrs3YqQIkSRLGx8fhdru3TJLf63XjwePxoLe3F42NjSgvL4fb7cb8/DwuX77MN6CcTic6OzuRnZ295+dJBaxKlYyVfLYVFpmabrVaMT4+Dp/Ph6KiIhiNRv7nW1WH1Go1ysvLUVxcjNHRUVRUVMBms2FmZgYajYZHfKTKhJGJ3HQjRyVKp9PBZDLBZDJxTyi73Y7p6WloNJoog8udvmaqABF7gQQQkTLkqgCxNPPV1VW+ZWWz2ZJitLjdmy6rvhgMBnR0dCR8Q9qPAGLC7+TJkzAYDAiFQsjOzkZnZyeCwSAGBwfhdruhUqkwMTHBb9BKm2UBAIfDwa0CUlGlysnJQXV1NfcMcjgcsFgsfFiXVYdycnKiqkPhcBh+vx8AeLutqakJPp8PNpstqoLBTBiTZRKolBkguVtxsZ5QPp+Pt8q8Xm9UiGvsh42tBJDSq55E+iEBRKSMeNpJuyGKIgYHB6HRaKK2rOS4drywVfPGxkZUVFTs6Rp7FUALCwtYWFjga+yRw86hUAiDg4MwGAw4ffo0gOtRJBaLBXNzc1HDqUpoD6ysrGBubg4dHR1p8Y6JfD0kSYLH44HVasXQ0BBCoRDfKisoKIDf78fExARMJlPUZplWq0VlZWVUBcNms+HatWuymjBGoqQZoGSeIycnJ6qVyUJcZ2dn+VxWSUkJcnNzIYpi1GzhXlpgFy9exP333w9RFHHvvffigQceiPrzz372s/jyl78MjUaD0tJSfOUrX0FdXZ0sXyuRHkgAEUmHfVrdbwuMuSpXV1ejpqYm6s9SJYAsFgvGx8dx6tSpfQ3FJiqA2HaUz+dDd3c3nyFi4sfr9aK/vx91dXVRoiy2WmG1WjExMcHbP6WlpbJHRsTztczOzsJut6OzszMtczSxRK5yM6M/u92OpaUlDA0NIRAIoLq6GqWlpXyQOtKEkQ1SsxkW4OXtp9HRUQSDQdm8cZRUAUpVFIZKpUJhYSEKCwsBXN+4tNvtmJmZgdvthiAIKC4uRjAYhFarTbgFJooi7rvvPjz//POorq5GT08Pzp8/j5aWFv6Yjo4OXLlyBXq9Hl/4whfw53/+5/jWt74l95dKpJD0v/MQh4b9tMBYPEJrayt/E4xEjsyunZAkCTMzM7BYLOju7t73XE0iW2ChUAh9fX0wGAxoa2vjN18mfpxOJ5+F2slxeqv2z+rqKjcFLC0tjdsUcK+wrTVJknD69GlFVDK2QqPRoKysDDqdDmtrazh27Bg32ATAq0P5+flRc0PbmTDGeuMw5+SSkpKEf5aUIoC2W4NPBdnZ2aisrERlZSUkScLw8DD8fj/+4z/+A1/96lchSRIGBwfR2dkZ1xkvX76M5uZmNDY2AgDuuusuPPPMM1EC6JWvfCX//xtuuAHf+MY35P/CiJRCAohIGXupAMUrPPab2bXbGQYGBqBWq9Hd3S3Lm368W2Cs6lVfX4+KioooZ2dBELC8vIz5+XmcPn06Ie+j2PaPy+WC1WrlN3ij0YjS0lLk5ubKdrNlobCFhYWor69XxE18JxwOB8bGxtDW1sbbKZFbYbOzs3C5XFFr9kzYbrVmz5yrI3O1hoaGEA6HoyI64nldlPDaKaUVJwgCNBoNKioq8Cd/8ic4d+4cLly4gH/+539Gb28vbrrpJnzhC1/Y8RqLi4tRVeXq6mpcunRp28c/8sgjeP3rXy/b10CkBxJARNKJbIGxQdJ4YDMtWVlZuwqPZLXAfD4fPB4PampqUFtbK9t142mBMVfr1tZWFBQUcPHIbrLXrl3DxsbGvttIgiAgPz8f+fn5aGho4D46U1NTcLvdUZtSe215+P1+9PX1oaamBpWVlXs+a6owm83c2iBWdGdlZUVVHyLX7NlWGFuz38mEsaamZlO7bXR0FHl5ebw6pMTBdYZSBBAQPQRdUVEBrVaLr3/965AkCdPT07I+1ze+8Q1cuXIFP/vZz2S9LpF6SAARKUOj0cDtdsf1WLfbjf7+ftTW1sJkMu36+GQIIKfTiaGhId46kpPdBNDi4iLm5ubQ1dW1ydlZFEV+rvb2dtmrAbE+Og6HIypdvbS0FEajMe7WjcvlwuDgII4ePcrnY5TMwsICVldX0dHRsasAYXM/hYWFaG5u3jRnVVhYyMXjViaMLMDVaDTy1PWNjQ3YbDb09/cDABdDeXl5iqj8MJQmgGLPwv69NDU17fr3TSYT5ufn+a8XFha2fN/5yU9+gk9+8pP42c9+pnh7CWJ3SAARKSNekcIGjRNJUZfLWZnBBEhHRwcGBweTsvK7lQCSJAkTExNwu9286hU57+P3+9Hf34+qqqq4hKEc52Q3YLYpZbFYMDAwgHA4zLO1tsvPstvt/HupdF8WSZIwNTUFl8uF06dP76naFTlnFSses7OzuXiMXbPfyoSRVePsdjvm5ubgcrlgMBgQDAYRCoXSPjyezhmgWERR5K/HXl6bnp4eTExMYHp6GiaTCY8//jgeffTRqMdcvXoV7373u3Hx4kWUlZXJdnYifZAAIpIOuzHuNgTNbkB2ux09PT1pSSsPh8MYHx+H1+tFT08PNBoNny+S84azlWBjMzK5ublob2/fNOy8sbHB4zbSUUmJ3JRi+VmxszClpaUoLi6GWq3m80lbtZGUhiRJPCy2ra1NlkpLpHgEwOd+hoeHEQwGo9Ls2Rm2MmEsKytDRUUFwuEwrw719vZGuSrvZhSYDFK5BbYbkWJsLyvwGo0GDz/8MG699VaIooh77rkHra2tePDBB9Hd3Y3z58/jz/7sz+ByuXDnnXcCAGpra/Hss8/K/rUQqYMEEJEydhqCZjd/nU6Hrq6utHyyDAaD6OvrQ2FhIU6fPh01uyT3hlnsELTX60Vvby/q6upQWVm5adjZbDZjamoqaiA33Wi1WlRUVPCbM5uFuXbtGh/8bW9vV7z4Yd5SbAYqWUIiMjGdzf0sLy9jdHQUubm5fHaICf9IE0b2wSE/Px/Z2dno7u6G3++HzWbjRoEFBQXcKDAVwkQp22hAtBhzuVx7+jdy7tw5nDt3Lur3PvGJT/D//8lPfrK/QxKKgwQQkTK2qwC5XC709/ejvr5+3zlQe4WdoampCeXl5VF/lowNs8gWGJs1amlpQWFh4aZh55mZGdhsNj4PpERY5ERBQQECgQDC4TAMBgPGxsYQDAajTAWVctMEXnb0Li8vl33OayfYmj2b+4ncwpMkKaq1yCqBoijC7XZDkiQEg0G++cRmtZgJ4/T0NLKysnh1KJHtwERR0veSnYWS4Il4IQFEJJ2djBCZL8p+jQX3AztDW1vblvb5+83t2gomqpaWljA7O7uls3M4HMbIyAgEQUBHR4di5i22IxQKob+/H8XFxairq4MgCHzLyWazYXFxESMjI8jPz+eeQ+mcY2GbafX19Wmd6YjdwmOtxbm5OWxsbMBgMPC5oZGRERw/fjxqnm4rE0av1wubzYbx8XEEAoGoiA6l/xzthch2ssvlIgFExAUJICJlRL5pS5KEyclJrK2tyTbvw0RDvG/w8c4cJasFZjabo7yFIud9AoEABgYGUFpaipqaGkV90t4Kn8/Ht/Zi40E0Gg3Ky8tRXl4OSZKwvr4Oi8XCw0TZYHCqwkSBlwNYjx07xoNQlUJka5Gt2S8uLmJlZQV5eXlYW1uDVqtFbm7utmv2bJOPmV46nU4+jL0fE8ZMwOVypfRnichcSAARKYO1dFjbIT8/H11dXbLd3JnAikcAiaKIgYEBZGdn7zpzJHcLTBRFzM3NQaVSoauri9+8VCoVBEHgN+empiaUlpbK9rzJgg1nnzhxYkuX7kgEQUBBQQEKCgqi1sbHxsbg9/tRXFyM0tLSfcdF7MTa2hpGRkbQ2tqq+MBMQRD4avyNN94IlUrFs8Y8Hk+UR9NWa/asOsRiONgmHxvGFkUxKqJD6UJ7OyLPTUnwRLyQACJSiiiKePHFF/cVJLodTADtNifDBo5ramrimvuQswXm8/nQ29uLwsJCaDQahMNhSJLExY/NZsPExERGrI0D4Ofd63B2bDxH5GBwXl4eHwyWa/aJnbe9vT2pszFywYbKT58+zQNVTSZTVPiqxWLha/bs9dLpdHxuKLY6xF5zNoztcDiwvLyMsbExbsJYXFycli3MvcAqpwyaASLihQQQkXTYm9PKygq8Xi9uvPHGpHzyjsdniLkrt7S0xN36kEsAra2tYXBwEC0tLQgGg1hcXITf70d2djYEQcD8/DxWVlb4PJDSWVxcxNLSkmznVavVKC0tRWlpKR8MtlgsuHr1KjcLZEn2e6lULC8vY2FhIWNe39XVVczOzqKjo2PL86pUKhQXF0eFr1qtVoyMjCAQCPA1e1aV286EkQ1cs9fcZrNhYGAAAHhER6zPk5yeW/sl0gUaoAoQET8kgIikI0kSxsfHsbGxgdzc3KS1HXab1Zmfn8fi4iI6OzsTzs3abwtseXk5KlohGAxifX2d32gkSYJWq0VHR0faDe52g8VwuN1udHZ2JmXlOnIwuLGxEX6/n1dDvF5vVOsnnlbZ7OwsbDZbRry+ALC0tMTFZbzn1ev1qK2tRW1tLa+mRYbdGo1GlJSU7GjCqNfrN/k8zc/Pw+VyIT8/n2eeCYKgmGHqWAHkcrkywnGcSD/KfycgDgR5eXk4cuQIfv3rXyfNQn87oRIOhzE6OopgMIienp6Eb9j7qQAxsbC2thY17KzRaNDQ0IDq6mr09/fzM125ciUlczB7JRwOY3h4GFqtVjbDwHhgyeqs9eNwOLhjuF6v54PUsZUSNmzv9/sVnT4fydzcHBdrexWXsdU0t9u9ycHbaDTCYDDwNXv2H/P3UalU3ISRDa+z7TQ2qM88d9I5O7RVBUjO3D7i4HKgBJAgCK8D8DkAagBfliTpU9s87g4ATwLokSTpSgqPeCgRBAEmkwmSJEGj0SAUCiWlBbHVsHIgEEBfXx9KSkpw4sSJPb1R71UAsUHrnJwcdHR0bHJ29nq93P+IeQ/FzsEoZWUceNkzp7S0NK03mNh4DrfbDavViv7+/igPHb1ej5GREWRlZaG1tVXxA74suNPlcqG9vV02sSYIAvLy8ni8RmRlZ2Njg1d2SkpKkJWVtUkQMWuG/Px8FBQUoLGxERsbGxgeHsbMzAw8Hk/KTRgjiRVANANExMuBEUCCIKgBfB7AawAsAHhREIRnJUkajnlcPoD7AVxK/SkPL2ybJVmp7cDmCtDGxgb6+/tx5MiRffm8qNVqBAKBhP4OG3Y2mUx8wDfS2dnpdGJkZAQtLS1ReWexn9w3Njb4yrhWq+WVjlQP8DKx1tDQoKgcpMibe319PQKBAHdHttlsyMvLQ3l5uaJiG7aCZcAFg0GcOnUqqWItds1+fX0dVquVbyZGzlpFmjBGtsoEQYBer8fJkye5CzgzYdRqtVERHclmqwqQUtzSCWVzYAQQgDMAJiVJmgIAQRAeB3A7gOGYx/0/AH8H4M9SezwC2D0PbD9ECqDV1VVcu3YN7e3t+/40mOgaPJvtOX78OIqLizeJn6WlJSwsLKCjo4Nv9myFIAgwGAwwGAxoamqC1+vlQ67MXbm0tBQGgyGpN8z19XXuVB1vOG26YA7ICwsLOH78OHJycvjsUGwYqVKQJAkjIyNQq9VoaWlJaaUq0pagqamJx2uwNXuWZs/mfpggstls0Gq1CAaD/BpsqcDn88Fms2FychI+n4+v2SfLhJGGoIm9cpAEkAnAfMSvFwCcjXyAIAidAGokSfqBIAgkgNLATnlgcl17cnISTqcTPT09sqxPJ9ICW1lZwdTUFE6fPg2dTrcp1mJychJutxtdXV0JVyR0Oh1qampQU1PD3ZVZGyM2iFQuLBYLF5KZYC7HKlVNTU0wGo0AwAdiWatsaGgIoihGzcGkqz0WDocxODiI3NxcNDY2pr1Nl52djaqqqqh4DSYgs7KyYDQaEQqF4HQ6cerUKQDYtGav1WpRWVkJk8m0yYQxJyeHV4fkEqFbDUGTACLi4SAJoB0RBEEF4LMA3h7HY98F4F0AaJhOZpLZAgOuD5CWlJTIbrC4mwBirtIOhwPd3d3862RVHxa4qdfrZRkejnRXZi0IJlZ0Ot22Q8GJsLCwkFFr+S6XCwMDA9tWqlgYaV1dHYLBIOx2OxeQBoOBC8hUzVqJohgVHaI0YtfsvV4vJiYmYLfbkZOTg+np6R3X7GNNGAFwE0a2lMC2+QwGw56rQ1vNACnd4JJQBgdJAC0CqIn4dfVvf4+RD+AkgBd+e/OpAPCsIAjnYwehJUn6IoAvAkB3d7dyDC8yGHbDT1YLzOPxYHZ2FgaDAcePH5f12ru1wJi4ycrKQkdHBwBEDTuzmIjq6uqkhL2yINKioiLu9GuxWNDX1wcAMBqNKC0tjXtbh1WqvF7vvjaRUonD4cDY2FjchoxarTYqnoMl2bMZFvaaJWvWKhQKoa+vDxUVFTCZTEl5Drkxm80Ih8O4+eabIUlS1Jq9Xq/ns0M7rdmzbT5WxXQ4HFhZWeGr+qw6lIjgphYYsVcOkgB6EcARQRAacF343AXgD9kfSpK0BsDIfi0IwgsAPkxbYKklGS0w9omypqYmKeJqpxaY3+9Hb28vKisrUVNTwzdnmPhh8zPHjx9PSeaUIAi80sGGgmP9c0pLS7edx2AtGZ1Ol/RhXLkwm82YmZmJcktOBBYkWlhYiObm5qhZq0AgwGet5IqKYJuJtbW1fPtP6czMzGBtbQ1tbW385yZ2zd5qtfI1e2bCWFBQAEmStjRhVKvVUSaMbrcbNpsNg4ODUdeINWGMRRTFqEwzGoIm4uXACCBJkkKCILwPwI9wfQ3+K5IkDQmC8AkAVyRJeja9JyQAeStAkiRhbm4OKysr6Orq4i62crNdC2y3YefV1VXMzMykdX6GhWJWVVVBFEU4HA7+qT0vL4+3yjQaDYLBIPr6+lBeXo6amprdL64AFhcXsby8jI6ODtniMiJnrURRhM1mw9LSEk+yZyvje3k+JpgjZ5SUztTUFFwuF06dOrWlaI7dxGPtxcXFxU2vWWx1iP0/cN2EUa/XR7UoFxYW+Ko+i+iIfd1j8//C4bBsPwvEwebACCAAkCTpOQDPxfzeg9s89pZUnIm4DvsEp1ar4ff79309ZsgnSRKfufF6vUmrAMVe12w2Y3JyEqdPn4Zer9807Dw9PQ2Hw4HOzk7FvBmr1WrepohcsWfGdl6vF01NTRnRkmGv8cbGRlLbdGq1GmVlZSgrK9v0mkW+nvFUHLxeL/r6+hSZQL8VbK7N4/Hg5MmTcc/oxLYXI9fsBUHgr1leXl6U51DkBwiVSoXS0lJ+jY2NDT70z2aT2OseaXHAqk2JcPHiRdx///0QRRH33nsvHnjggag/9/v9uPvuu/HSSy+hpKQE3/rWt1BfX5/QcxDK5EAJIEL5aDQaeDyefV3D7/ejr68PZWVlqKurixJXyW6BsRuvzWbjwosZxQmCwIWZRqNRtPNw5Iq90WjE4OAgKisrsbq6ioWFhZSt2O8FSZIwNjaGcDicUjfqWFsCv98Pi8WCiYkJvu69XXtxtwFtpcEczP1+P06ePLnn1zh2zZ61ZKenp+F2u1FQUMCrQyzNPtKEkQ1S5+XlwWAwoKGhgXs9zczMwO12IxwOIysrC/n5+VwIxXteURRx33334fnnn0d1dTV6enpw/vx5tLS08Mc88sgjKCoqwuTkJB5//HF85CMfwbe+9a09vR6EsiABRKSU/c4AsbbTsWPHNrUQkiWAWAssHA5jaGgIKpUKnZ2dAKKHnQOBAPr7+zOqhWQ2mzE9PR2Vj5aqFfu9oKS18ezs7Kgke4fDAbPZHJW9ZTQa4fP5MDQ0hFOnTmXEcC4bgg8Gg7L7EkW2ZNn2YuzwudFohF6v33aQWq1Wo7y8HJWVlQiHw+jr64PX68WnP/1p/PjHP0YoFML4+DiOHDmy69kvX76M5uZmNDY2AgDuuusuPPPMM1EC6JlnnsFDDz0EAHjTm96E973vfbxSRWQ2JICIlCBHlWZ5eRnT09M4ffr0li2HZFaAgsEgrly5gvLyctTW1m4adna5XBgcHERzc3PGzHbMzc3BYrFsatPttGKfk5PD54YiB09TAducKisrU5zAjG0vulwuWK1WvPTSS/B6vaiurgYAxd84WXBxOBzec3RMvERuLwLgw+djY2Pw+/1RgbfsbFut2atUKtTX1+Mv/uIv8MY3vhFve9vb8JGPfAQzMzN461vfig9/+MPbnmFxcTHqZ6m6uhqXLl3a9jEajQYFBQWw2WwZ8++c2B4SQERK2csQNIsJ2NjYwJkzZ7b1aYnHr2cvuN1uuFwudHZ2oqSkZNOwMzN5O3nyZMZ8wh8fH0cwGERHR8eObbrYm1RkqKYkSQmv2O8V1vasq6tT/OYUy83y+/0wm83o7u6Gy+XC1NQU3G531I093RW1SFhrEQCOHz+ecqEWO3weGXir0+m2XLP3+/3weDyQJAmBQABGoxHl5eX4zne+A7/fj8XFxd2fmDi0kAAiUkqiLTD2qT8/Px+dnZ07viknowLEhp11Oh1KSkqihp2B61UUs9mcMWaBzLMoNzcXR48eTfgmt58V+73i8XjQ39+Po0ePclM+pbO6uorZ2Vl0dHQgKysLBoMhyl3ZYrFwZ+R0VdQiYXEcGo0mrtZRsomtqHk8Hu7iHQqFUFJSgoKCAly7dg3Hjx+HTqeDKIp4/vnnuejJzs7mra3tMJlMmJ9/OUBgYWFh0xIAe0x1dTVCoRDW1ta4sSOR2ZAAIlLCXlpgbrcbfX19aGhoQGVlZVzPIVcFSJIkzMzMwGKxoKurC1euXEEwGIRKpeLPMzY2BlEU0dnZqdhh50iY/0xVVZUsm17xrNjvdV2cwXyUTp48mTHuvktLS1heXkZnZ+emamWsu3JkRS0cDvPh8928b+REkiQMDw8jKysLzc3NaRc/sUR6W9XV1SEUCsFsNmNoaAhqtRq//OUvsby8jPLycnzxi1/EL37xi7iv3dPTg4mJCUxPT8NkMuHxxx/Ho48+GvWY8+fP4+tf/zpuvPFGPPnkk/i93/s9xb1GxN4gAUSkFI1GE1cFiM0CnDp1CgaDIa5ry/WmxDa5AKCrqwsAUFBQgMuXL/Ob19zcHIqLi1FfX58Rb4ZutxsDAwNJm1HaacU+MuE+EWdlm82GiYkJnquWCczNzcFms+H06dNxtbciK2rBYBA2mw2zs7NwuVxRG1LJapVJkoShoSHodLq0D5XHiyRJWFhYQGtrK4xGI0ZGRvCDH/wAP/7xj9HQ0IBHHnkEb3jDG9DW1rbrtTQaDR5++GHceuutEEUR99xzD1pbW/Hggw+iu7sb58+fx5/8yZ/gbW97G5qbm1FcXIzHH388BV8lkQqERD0TDhvd3d3SlStkFr1fWI8eAH75y1/id37nd7Z93OzsLMxmM9rb2xNuC+x07XgIBALo7e1FWVkZamtr+VouS8JeXl7GxMQE1Go1ioqKUFZWltQblBw4nU6MjIykrYri8/lgsVhgsVjiTrFfWVnB/Pw82tvbM6K1yDxz3G53Qp452xG5IWW323kQqdFolE0Msq1GtlGXCYRCIVy9ehV1dXUoKysDAPzqV7/Chz/8YXzve99DTk4OfvSjH2Fqagof+9jH0nzazEUQhJckSepO9zmSDVWAiJQQzydLURT5mnl3d3fK20oulwv9/f04cuQIjEbjpmFnp9OJubk5dHZ2Ij8/H+vr6zCbzZiamuKzHKWlpYq6YTM36o6ODtnStxMlJycnoRT7ubk5WK1WdHR0pCyYdD+woXJRFGWLD4kdPmczMCMjI1xEsqiJvTxfOBzGwMAA99bJBEKhEHp7e1FbW8vFz5UrV/DBD34Qzz77LN+0e+tb35rOYxIZhPLfXYhDgc/nQ19fH8/USnUpnm2btLW1IS8vb9Ow89LSEhYWFqKEBDN4O3LkCJ/l6OvrgyAIXAylKwKDVdLsdrui3KgjV+wlSeIDwWzFPhwOQ6VSKdpEMhI2PKxWq5O6Nq7X61FbW4va2lqEQqFNURNs3ioewcjET2FhoSJT6LdCFEX09fWhurqabwH29vbiT//0T/Gd73wnY74OQlmQACJSBmsjxbK2tobBwUEcP35839sVbEA53psnyxNbXV1FT0/PJmdnZgrn8XjQ1dW1basrcpaDOQSPjY1FhWmmylWZrTOLoqhoISEIAq9ysJsyM7x76aWXUrZiv1fSZcqo0Wii4jnW19dhsVgwOzvL562YmeBWZ+7r60NJSQlqa2tTct79IooiDxyuqKgAAAwODuI973kPnnzyyYxp3xHKgwQQkXIiRcrS0hJfF5ajWsJiK+K56YfDYYyMjCAcDvNh50hzw1AohMHBQeTl5SUUuRDpEBzb8mGr4kVFRUkRJqIoRrU2lCgcYhFFEf39/SgqKuLRJpEr9h6PB8XFxUlZsd/vmdMtJCKjJoDrldRIM0GWmVVYWAhJktDf3w+j0ag4I8ntYJWfiooKVFVVAQBGRkZw77334vHHH8fRo0fTfEIikyEBRKQcVmWZmpqC1+tFT0+PbLMebM1+t+uxlXCj0Yi6ujruMsvW3H0+H/r7+1FTUxPXCv52xLoqR5q7xaax7xe/34/+/n6YTCZ+s1A6LIGerdMzYiMT7Ha77Cv2e4V5U1VUVCguODYnJycqniPydWNGgayKonTC4TD6+/tRVlbGX+fx8XG84x3vwDe+8Y2ouAqC2AskgIiUwVpKKpUKvb29KC4uxunTp2WtUsTjM8T8hZqbm1FaWsqHnZn4WVtbw/DwME6cOIHCwkLZzqZSqVBSUoKSkpKoVfHZ2VlotVqUlZWhtLR0T4Z4LIojk8wC2dxXY2MjSktLt32cSqWSfcV+r7AtwUxwpGavTVFREd9sFAQBV69ejXpNldhiZOLHaDTy4ebp6Wncfffd+NrXvhbXijtB7AYJICKluFwuOJ1ONDc3o76+Xvbr7yaAbDYbRkdH+bBzpPgBrq9fz87OJt17JjZZ3Ov1wmw2R0VMlJWVbZl5Fovdbsf4+HjGRHEALwu248ePJyQyY183tmIfuR2VrHkrJtiampoyJgeKbU6ZTCZeyWxsbITf74fNZuMtxmS3ZhOBzYMVFRXxVt3c3Bz+8A//EF/+8pd5EDFB7BfyAdoF8gGSj8XFRYyNjUGv16OxsZHPLcjJ0NAQTCbTljfVubk5LC8v4/Tp09BoNFHzPpIkYXp6Gmtrazh16lRa16/Z/IvFYoHX6+U39a1WnpeXl7lfTjqjFBLB6XRidHRUdsHG5q0sFovsKfZerxd9fX04duwYX01XOsFgEL29vaipqdmx7RXZmnU4HNDr9bw1m2pLBzZYbjAY+AekxcVF3Hnnnfj85z+Pm266KaXnOawcFh8gEkC7QAJIPmZnZ1FcXIypqSk+wyE3o6Ojm64dDocxOjqKUCiElpYWPoTNxI8oijwK4MiRI2n/BByJKIr8pr6+vs5v6kVFRZifn4fT6Uy7YEsEi8WCqakptLe3J9WXSJIknmJvs9n2lbnlcrkwMDCA1tbWuF3J0w0TP7W1tQm16iRJgtvthtVqhdVqRTgc5tt4eXl5SW2VMVdq9gEJuF6RveOOO/CP//iPuOWWW5L23EQ0h0UAZca7JnEgMJlMEEUxKaGljNhEeDZkW1RUhOPHj0c5OwuCwAeHKyoqFLkZo1aro1aenU5nVA5SY2PjltYCSmRxcZFnZCV7eFkQBBQWFqKwsDDKp4llbrG5od3mX1gW2alTpzKmvcjmlOrr67lhYLwIgoC8vDzk5eXxeA6r1YqZmRm4XC4UFhbCaDTKUlWLhOWRsUgO4HoQ8Z133olPf/rTJH6IpEACiEg58eaB7QWVSsXFFRt2bmxsRHl5+SZn542NDQwNDeHIkSMZke4sCALy8/MxMzOD2tpalJaWwmKx4OrVqykfBk4EFiy7traGjo6OtMSGxKbY22w2Hl2x3Yq9w+HA2NhYRmWRMfHT0NCw42B5vGi1WlRWVqKyspIn2TN7guzsbF5V2081j5lJZmVlcfFjtVpx55134q//+q/x6le/et9fB0FsBQkgIuUkuwLE2kajo6M4deoU8vPzN4kf5j586tSpuAaNlQBbza+treUzHfn5+WhsbIwaBg6FQigpKUFZWVnS2xa7wUwZw+Ew2traFNFezMrKirqpOxwOmM1mjI2NITc3F6WlpRAEgQ/DpytCJFECgQCuXr2K5ubmpAj62CR7j8cDi8WCoaEh/jOX6AA6+/nQaDQ8id7hcODOO+/Exz72Mbz+9a/f97nvuecefP/730dZWRkGBwe3PMP999+P5557Dnq9Hl/72tdo0PqQQAKISBnsTVGj0fBgVLlRq9WwWq3wer3o6uqCVqvlzs4qlYpHRFitVnR2dioqt2sn2BzK8ePHtxzCjczbYm2L6enpHSscyYYNtOr1ejQ1NSlu1RrYbE3gcrkwPT0Nq9WK/Px8mM3mbV2VlYTf70dvb2/SxM9W6PV61NXVoa6uDsFgEHa7nRt+GgwGPoC+3Xway1ATBAFHjhzhFhR33nkn/vzP/xznz5+X5Zxvf/vb8b73vQ933333ln/+wx/+EBMTE5iYmMClS5fw3ve+F5cuXZLluQllQwKISDnMCFFuJEnC6uoq/H4/zp49u2nYmQ1DS5KEjo4ORVQj4sFms2FiYgJtbW1xVati2xaRZnj5+fkpSbAPhULo7+9HaWmpImertkIQBKyvryMYDOLmm29GKBTirsqBQIALyb0GkCYLn8+H3t7etHpAabXaqIw3lmQ/PT0NrVbLB6lZK1GSJExMTCAcDuP48eO8Jf3mN78Z73//+3HHHXfIdrabb74ZMzMz2/75M888g7vvvhuCIOCGG26A0+nE8vLyvgxQicyABBCRcpLRAmPuvFqtlt+gIsVPMBjk0QUsbiETWFpawuLiIjo6Ova05h5rIpiKBPtMMguMhIXHnj59Gmq1GhqNJirSJDKAlFU4ki0kd4Ot5yfqp5RMIgfQm5ub4fV6YbVaMTo6yuM5AoEABEHgW5lutxt33XUX3vnOd+Kuu+5K6XkXFxejRHp1dTUWFxdJAB0CSAARKSOyBSanAPJ4POjt7UVjYyPUajVWV1ejYi3cbjcGBgbQ2NiY8FZMupAkCVNTU9jY2EBnZ6csN9nI3KitEuyZ+eJ+2j0ejwf9/f0Z5UjNXmu324329vYtK4OxAaRsxX5qaooPA+/VxXuvKFH8bIVOp+PtWVEUMTQ0hI2NDahUKjzwwANoaGjA97//ffzRH/3Rtm0qgkgGJICIlCNnC8xut2NkZAQnT56EwWCA1+tFMBjE5cuXUVxcjJycHCwuLvJh6EyAhbSq1Wq0t7cnrVq1XYK93+/nLYtEBlrZyngm+eWwORRRFHHq1Km4vtatVuytVitfsU+Fb47H40FfXx9aWlqSYiiaLObm5iAIAn7nd34HwPXZpU996lNYWFjAN7/5TTidTrz5zW9OadvUZDJhfn6e/3phYUFxGW9EciABRKQcuSpACwsLWFhYQFdXF7KzsxEKhZCVlYW2tjaEw2GMj49jZmYGGo0G8/PzKCsrQ3FxsaJnf4LBIAYGBnjKeKpadTsl2BcWFqKsrGzHmAQWx9He3q74gWEG857RarU4ceLEnl9rJiTZMHDkAHoyIibcbjf6+/szSmgCwMzMDDY2NnDy5EkIgoBAIIB//dd/xR133IH3v//9WFlZwXPPPYf5+fmUCqDz58/j4Ycfxl133YVLly6hoKCA2l+HBHKC3gVygpYPSZIQCAR4EntPT8+erzM+Pg6v18vfTGNjLSYmJuDz+dDa2gqVSsUNBO12O/Ly8vggsJIclFnWVH19vWJmZ5j3i9lshsPh2DLBfmVlBXNzcxkVx8E21PLy8tDQ0JAUoRkbMcFW7I1G456NINk24MmTJzOmoglcr/w4HA6cOnUKKpUKwWAQ73jHO3DjjTfiwx/+cFKF/lve8ha88MILsFqtKC8vx8c//nEEg0EAwHve8x5IkoT3ve99uHjxIvR6Pb761a+iu/vAmyDvyGFxgiYBtAskgOSDCaBwOIzLly/jhhtuSPgabLsoPz8fTU1Nm5ydQ6EQBgYGYDAY0NjYuOmNlaWJm81mWK1W5OTk8BT2ZLsT78TGxgYGBwdlT6CXk8gkdqvVCq1Wyy0NWL5aJiCKIh+Ir62tTclzshV79tqp1WreKou3YsbETya5UgPA/Pw8bDYb94EKhUK499570d7ejo9+9KMZs5BwmCABRAAgASQnTABJkoRf/epXfA4gXrxeL98uYivekeLH6/Wiv78fdXV1O4Y/RuJ2u2E2m2GxWHjsRGlpaUrN76xWKyYnJ9HW1pZR7aPR0VGsra3xYNl44yXSCdsWrKioSOuch8/n44G3fr9/x8Bb4GWBHK8VglJYWFiAxWLhw+WiKOK9730vGhsb8fGPf1yxPyeHncMigDLjIxtxIGBvdnt503M4HBgeHkZraysKCgo2OTs7nU6MjIwkXEHJzc1FQ0MDGhoa4PP5YDabMTg4yG/oZWVlSb3hLCws8HysTDFlZH5KKpWK+y2xBPtr167B6/WiuLgYZWVlivLMUdJ6fk5ODp+5Ys7l263Ys+HyTBM/S0tLMJvNUeLn/e9/P6qrq/HQQw8p5ueCOLyQACIUz+LiIubm5tDZ2YmcnBy+QcaGSpeXlzE3N7fvzKacnBzU1taitrYWgUAAFosF4+PjfCuqrKwM+fn5srxxS5KEa9euwe12y7bmngpEUcTAwAAKCgpQX1/PX4usrCxUVVWhqqoKoihGeeawBHu5AzQTgc1XNTU1wWg0puUM2xEbeBu5Yq9Wq+H1ejMqsgW4/m9yeXmZeyqFw2F86EMfQmFhIf7mb/5G0YsIxOGBBBCRUtiQcjywYWa3243u7m4+PxA57Dw1NYX19XV0dXXJOoOSlZUFk8kEk8nEHYFnZmZ4tERZWRkKCwv3JIbC4TCGhoaQnZ2Ntra2jPkkHAwG0dfXh8rKyh3bR5HBrCzBnmWv6XQ6lJWV7WsQOFGYN9GxY8e2jBFREpEr9qWlpRgeHkZVVRWuXbuWshX7/bKyssLNO5n4eeCBB6DVavEP//APJH4IxUACiEgLbHNruzdDNsycm5uL9vb2TcPOzFAtJycHp0+fTurNQKPRoKKiAhUVFby6sbS0hNHRURQUFCS0Xs8cqcvKyjImIgJ4uYLS2NiYUMq4IAgoKipCUVERJEniM1epSrBng8OZtjLOkuhZ1RNASlbs98vq6irm5+ejxM9f/dVfwe/349///d8Vc06CAEgAEWmCxWFs9YbIhp1ra2tRVVW1adjZ7/ejv78flZWVqK6uTvm52U2brYhbLBZMTEzw9Xqj0bhlq4cNaTc0NGSMIzUA7qS9X8dhQRCQl5eHvLy8TQn2wWCQtxnlqm6w2ZlM25pinkqxSfSxGW9sxX58fFyWFfv9YjabeStao9FAkiR88pOfhNVqxVe+8hUSP4TiIAFEpBTWumICKPbN2ul0YmhoCC0tLSgsLNw07My2YY4dO5b2qAWVSoXi4mIUFxdHrddPT09vWq9fW1vD8PBwxjn3Op1OjI6O4uTJk7KLiNgEe5vNJluCPaug7HcuLNXYbDZMTk7umv22VYq9xWLB1atXoVKpuEhP1VahxWLBzMwMOjo6oNVqIUkS/v7v/x6zs7P4j//4j4yZcSMOF7QGvwu0Bi8vwWAQ4XCYD6RG3lSXlpYwOzvLP/nGDjuzEM9MGAiNXK8XRRHBYBBtbW2K9fjZCjaI297enlJbAJZgb7FY4HQ6E06wZ9top0+fzhhjRuDlc3d0dOxrI5DFmsS7Yr9fbDYbPzcTP5/73Ofwm9/8Bo899lha/bWIvUFr8ASRRCIT4SVJwuTkJNbX19HT08MNDSOHnWdnZ2Gz2dDV1ZURb6hsvV6j0WB5eRkVFRV8kDXSL0epLC0tYWlpCZ2dnSl/vXdKsM/OzuaVta1EwsrKCp9ByRRbAeC62Jyenpbl3JGxJrut2O8Xu93OK1ZM/HzhC1/A5cuX8e1vfzsj/q0ShxeqAO0CVYDkJRQKQRRFjIyMoLy8HAUFBRgYGIBOp8ORI0c2DTuzYFBBEHD8+PGMmSNgG2x+v5/HcQDg6/Vms5mv15eXlytmq4eJTafTiVOnTimudcES7C0WCwBwrya9Xo/FxUWsrKygvb09Y1ypgeuVzcj2UbKIXLG32Ww8xd5oNO6pwudwOPisUnZ2NiRJwiOPPIIf/ehHePrpp2Wpvl28eBH3338/RFHEvffeiwceeCDqz+fm5vDHf/zHcDqdEEURn/rUp3Du3Ll9P+9h57BUgEgA7QIJIHlhAmhiYgI6nQ4LCwuorq6GyWTaNOwcCAQwMDAAo9GY0mDQ/cI21HQ6HZqbm7c9N1uvN5vNsqzX7xeWsRYKhXDixAnFi83IVs/GxgZUKhVaW1vT9vrthdXVVT44nOpqicfj4dEcoigmtGLPZsMiZ5W+9rWv4ZlnnsF3v/tdWeauRFHE0aNH8fzzz6O6uho9PT147LHH0NLSwh/zrne9Cx0dHXjve9+L4eFhnDt3DjMzM/t+7sPOYRFAmfMxiThQBINBLC4uoq2tDUVFRZuGndnmUVNTU0Jr1+kmEAigv78fFRUVu26oyblev1+YN1FOTg5aWloyQkBkZ2fDZDLB7/dDEARUVFRgcXERo6OjcSXYp5uVlRUsLCygo6MjLRUrvV6Purq6hFPs19bWMDo6GjVj9c1vfhNPPfUUvve978k2dH758mU0NzejsbERAHDXXXfhmWeeiRJAgiBgfX2dn6uqqkqW5yYOBySAiJQiCAJWVlZgNptRW1uLoqKiTcPONpsNExMTaG1tzajEa2a419zcnLDb8Fbr9WazOa71+v3CAmZZpS1TYBUrURTR3t7ORVDk68dWxNnrp5TW2PLyMhYXFxUTIhvvir3X68XIyEjUYPwTTzyBb3zjG/jBD34g69bZ4uJilFdWdXU1Ll26FPWYhx56CK997WvxL//yL3C73fjJT34i2/MTB5/0/8sjDhWLi4tYXFxEY2MjQqFQ1LAzcD05emVlJaOysQDwLDI5DPdi1+vX19f5kKzc6fWBQAB9fX2oqamJO0BWCUiShOHhYWi1Wpw4cSKqYhX7+rlcLpjNZszOzkKr1XKhmcrNtkjYrBIzC1Qa263Yv/TSS/B4PKitrYXNZkN1dTW++93v4ktf+hJ+8IMfpMVr6bHHHsPb3/52fOhDH8KvfvUrvO1tb8Pg4KBiq36EsiABRKSU8vJyGI1G7neSlZWF0tJSqFQqjI+PIxgMZlQ2FgDu/ZMMzxlBEFBQUICCggI0NzdvclLeT3q91+tFX18fjhw5gpKSElnPnUzC4TAGBweRl5eHhoaGHdt1giAgPz8f+fn5aGpqgtfrhcViwdDQEERRTHmC/cLCAsxmM8/IUjrs9RMEAaurq+js7ITL5cIHP/hBDA8PIxgM4otf/GJSxI/JZML8/Dz/9cLCwqYIlkceeQQXL14EANx4443w+XywWq0ZZTRKpA+SyURKYW/6BQUFaGlpgcfjwZUrV/Dzn/8cPp8Px44dy4gbA2N2dhbz8/Po7OxMieEeW68/c+YMWlpaIEkSBgcH8eKLL2JmZgYejyeu62xsbKC3txctLS0ZJX5EUURfXx8KCwvR2NiYsGjR6XSora1FV1cXn2G5du0aLl26hPHxcTidzriz6hJlfn4eFosF7e3tGfUzzuJEmI9VdXU17r33XpSVleFTn/oUnn76aXR0dOCZZ56R9Xl7enowMTGB6elpBAIBPP744zh//nzUY2pra/HTn/4UADAyMgKfz5dRM4NEeqEtsF2gLTB5+fM//3NYLBbcfvvtuOWWWzA1NYUf/ehHeOMb3whRFGGxWKDRaHg6tlLbYJIkYWxsDKFQCC0tLWkvuUeu1wcCgR1jJVjUQltbW8qcguUgFAqht7eXp87LCRtCN5vNWF9fh8Fg4EPocoiVubk52O12tLW1pf1nJRHcbjf6+/uj4kT++7//G3/1V3+F5557jldawuEwfD6f7D9Pzz33HD7wgQ9AFEXcc889+Mu//Es8+OCD6O7uxvnz5zE8PIx3vvOdcLlcEAQBf//3f4/Xvva1sp7hMHJYtsBIAO0CCSB5CYVC+J//+R888cQT+NGPfoRAIIA//dM/xTvf+U7exvF6vVhdXYXFYoFKpdpXmycZiKLIWzB7qUIkm63W65nnEpuFaW9vzyiX5EAggN7eXtTV1aG8vDypz8X8csxmM+x2O3Q6HW+V7WXuamZmBmtrazh16lRGiR+Px4O+vj6cPHmSLyP8/Oc/x0c/+lF8//vfR2VlZZpPSCQLEkAEABJAyeI///M/8fnPfx4f+tCH8L//+7/4r//6L7S0tODChQt4zWtewz9J+nw+mM1mmM1mSJLEK0PpyndiQ8MmkykjVm4jKxs2mw0AcOzYMT53lQmwJPqmpqaEt+v2C0uwZ35DiSbYT09PY2NjAydPnsyY1xt4OZA4Uvz86le/woc//GF873vfS3kIMZFaSAARAEgAJYONjQ18+MMfxj/8wz/wsno4HMbly5fx5JNP4sc//jGOHDmCCxcu4LWvfS1/A/b7/VwMiaLIxVCq2jjMmyjThoYlScLU1BRcLheqq6thsVjgcDiSvl4vB8xa4NixYygqKkr3cXiCvcVi2TXB/tq1a/B4PFFO4JkAG45vaWnhG41XrlzB+9//fjzzzDOoq6tL8wmJZEMCiABAAigdhMNh9Pb24oknnsAPf/hD1NbW4vbbb8e5c+d4kjqbeVldXUUwGOSRCMlaxXU4HDwVPZO8iSRJwsjICFQqFY4dO8Zv0pHr9VarVfb1ejlgw7dyWAskA5ZgH9lqZKGj09PT8Pl8aG1tVVyLdCd8Ph96e3tx4sQJ/m+tt7cX73nPe/Dd736XmxISBxsSQAQAEkDphm05PfHEE3juuedQWlqK22+/HW94wxtQXFwMANzFdnV1FT6fT/Z8rZWVFczNzaGtrU0xc0jxwGaV8vPzd10XZ14vrM2T7rmrtbU1DA8PRw3fKpnIBPvV1VVoNBocOXJE0dW1WPx+P65evYrjx4+jsLAQADA4OIh7770XTz75JI4ePZreAxIpgwQQAYAEkJKQJAmjo6N48skn8f3vfx8GgwHnz5/HbbfdhtLSUp4izwaAPR4PSkpKUFZWBoPBkLAYYsGgbHtHCY698RIMBtHX1xdXJEcszCuHzV1FBo6mAral1t7enrZZr70Q6UxdVVUFq9UKq9W6a4K9EvD7/ejt7cXRo0d5q3FkZATveMc78Pjjj0fFTxAHHxJABAASQEpFkiRcu3YNTz75JJ599llkZ2fjtttuw+23346KigoIggBRFGGz2bC6ugqXyxW1DbWbGAqHwxgbG4MkSRmVQg+8PDTc0NCwb0O4RNbr5cBisWBqaioqZyoTYLYIAKJajcDWCfbMfFEJBAIBXL16FUeOHOFV1fHxcdx999345je/iVOnTqX5hESqIQFEACABlAmwSs3TTz+N73znO5AkCbfddhsuXLiA6upqCIKAcDjM5zXW19dRVFTEwzJjb+ShUAgDAwMoLCxEfX19Rs1wsEHtyDaGXMSu17PqWjyCMh5WVlYwPz+flmT0/cDmrNRqNY4ePbrja+H3+/lr6Pf7eQL7XiqUchAMBnH16lU0NTXxwf7p6Wm85S1vwde//nV0dHSk/ExE+iEBRAAgAZRpSJKE5eVlPPXUU3j66afh8/nwhje8Abfffjufg2Fhj6urq1hbW0NBQQHKy8tRVFTEW0c1NTUZ53OytraGkZERnDx5MulzM7HGgZGv4V6qZQsLC1hdXUV7e3tGtRpZJllWVhaam5sTEjGhUAg2mw0WiwUbGxsoLCxEaWkpiouLU1JxZOKnoaGBuyfPzc3h//7f/4svf/nL6OnpSfoZCGVCAogAQAIok5EkCWazGd/5znfw9NNPw+Fw4Pd///dx++2380/qkiTB4XBwn5xAIID6+nrU1dVlVNvLarXi2rVraGtrS/ncTGT6usPhQH5+Pk8Pj2cAOHLOKlMGhoHrP19DQ0PIyclBU1PTvio47DW0WCyw2+08wb6kpCQp1bBQKISrV6+irq6Ot0kXFxdx55134vOf/zxuuukm2Z+TyBxIABEASAAdJGw2G7773e/iqaeewurqKl73utfhwoULOHHiBH74wx/C6/Xipptuwvr6Oux2O/Ly8lBeXo6SkhJF35iXlpawuLiI9vb2tA/ZsvV6Jih3Wq9n/kRutzvjjALD4TCGhoaQm5sr+2p4ZIK9zWaDRqORNcGeiZ/a2lruqr2ysoI77rgD//RP/4RXvOIV+34OIrMhAZSBCILwOgCfA6AG8GVJkj4V8+cfBHAvgBAAC4B7JEma3emaJIAOJk6nE88++yyefvppDA0NAQA+85nP4FWvehVUKtWmG7ler+emgUpq0czMzMDhcCi2erLVej3LeGMbUydOnMioOSuWRs/sBZIN28qzWCz7TrAXRRFXr15FdXU1KioqAABmsxl33HEH/u7v/g6vfvWrZTnzxYsXcf/990MURdx777144IEHNj3m29/+Nh566CEIgoD29nY8+uijsjw3sX9IAGUYgiCoAYwDeA2ABQAvAniLJEnDEY95JYBLkiR5BEF4L4BbJEn6vztdlwTQwUWSJHzyk5/EL3/5S9x555147rnnMDY2hle96lW4cOECurq6uBhin8gtFosiTAMlScLExAQCgYAiwljjIXK93u12Q6/Xo6WlRTHbUPEQDocxMDCAgoIC1NfXp/z5g8EgF0Ner5ebLxYWFu4qhkRR5GGybL7NarXijjvuwP/7f/8Pr3vd62Q5oyiKOHr0KJ5//nlUV1ejp6cHjz32WNQq/cTEBN785jfjv/7rv1BUVASz2bzvjUVCPg6LAFLOR9n9cwbApCRJUwAgCMLjAG4HwAWQJEn/HfH4XwP4o5SekFAUQ0NDMJvNePbZZ6HRaPCOd7wDHo8HP/zhD/Hv//7v6O/vxy233IILFy7g7NmzaGpqQlNTExdDv/nNb6DValFeXp5Sj5dwOIzh4WFkZ2dnlNOwTqdDdXU1HA4HqqqqoNPpMD4+npL1ejkIh8Po7+9HcXExamtr03IGrVaLqqoqVFVV8UH0paUljI6O7phgL4oi94Vi4sfhcODOO+/Egw8+KJv4AYDLly+jubmZtwbvuusuPPPMM1EC6Etf+hLuu+8+7jlE4odIBwdJAJkAzEf8egHA2R0e/ycAfpjUExGK5uTJk/jnf/7nqN/T6/W44447cMcdd8Dn8+H555/Hf/zHf+ADH/gAbrrpJly4cAE33XQTGhsb0djYCI/HA7PZjN7e3qgWT7I8bNiKfnFxccZlMomiiP7+fpSUlHABUV1dzdfrp6enk7JeLwfs7EajETU1Nek+DgBEBbNGJthfu3aNJ9izlm1/fz/KyspgMpkAXN8YvPPOO/GRj3wEt912m6znWlxcjHqNqqurcenSpajHjI+PAwBuuukmiKKIhx56SFYRRhDxcJAEUNwIgvBHALoBbDntJwjCuwC8C0DaPukR6ScnJwe33XYbbrvtNgQCAfzXf/0XnnzySXz4wx/GDTfcgNtvvx0333wz6uvrUV9fD6/XC7PZjP7+fgiCwMWQXHESLIm+uro641b0mb0Aq15EotFoUFFRgYqKCl7VWFxcxMjICAoLC7lfU7rafKx6UlZWptgUdEEQUFhYiMLCwqgE+97eXng8HhQVFXFfqI2NDbz5zW/G/fffjz/4gz9Iy3lDoRAmJibwwgsvYGFhATfffDP33iKIVHGQBNAigMiPZtW//b0oBEF4NYC/BPAKSZL8W11IkqQvAvgicH0GSP6jHjx2G3r0+/24++678dJLL6GkpATf+ta30jJDsVeysrLwute9Dq973esQCoXws5/9DE888QQ++tGPorOzE7fffjt+7/d+D3V1dairq+PJ9UNDQwiHwygtLUV5efmeV9RZQnemJdED14Vbb28v6urq+NbRdkRWNSLX68fHxxNer5cDNjdTWVm5SbgpFUEQkJeXB71ej/X1dRQXFyM7Oxuf+cxn8L3vfQ9ZWVl405vehDe/+c1JeX6TyYT5+ZeL8QsLC7zyxKiursbZs2eh1WrR0NCAo0ePYmJigryHiJRykIagNbg+BP0qXBc+LwL4Q0mShiIe0wHgSQCvkyRpIp7r0hD07sQz9Piv//qv6O/vx7/927/h8ccfx3e+8x1861vfSuOp5UEURfzv//4vnnrqKfz3f/83WltbceHCBbz61a/m2VmBQABmsxlmsxmhUIhna8U7/LuxsYHBwUG0tLTwhO5MgcVyNDc370u4JbJeLxehUAi9vb0wmUwZV3Fjm2oGg4F/0PB6vbjrrrvQ1NSE9fV1DA0N4cKFC/j4xz8u63OHQiEcPXoUP/3pT2EymdDT04NHH30Ura2t/DEXL17EY489hq9//euwWq3o6OhAb29vxon7gwoNQWcYkiSFBEF4H4Af4foa/FckSRoSBOETAK5IkvQsgE8DyAPwxG9nC+YkSTqftkMfEOIZenzmmWfw0EMPAQDe9KY34X3vex8kSVLMjMdeUavVeMUrXoFXvOIVCIfDuHTpEp588kn8zd/8DY4cOYI3vvGNeO1rX4vq6mpUV1fzLZ7I4d/y8vJtV5odDgfGxsbQ1taWUdtSAODxeNDf3y9LLIcgCCgoKEBBQQGOHDnCB9GvXr2alNkr5pVTU1PD18UzBeZOnZ+fz8WPz+fDW9/6VvzBH/wB3vOe90AQBAQCAUxMxPU5MCE0Gg0efvhh3HrrrRBFEffccw9aW1vx4IMPoru7G+fPn8ett96KH//4x2hpaYFarcanP/1pEj9EyjkwFaBkQRWg3XnyySdx8eJFfPnLXwYA/Od//icuXbqEhx9+mD/m5MmTuHjxIp+haGpqwqVLl2A0GtNy5mQTDodx9epVPPHEE7h48SLq6upw/vx5nDt3jldxQqEQXwv3er18Eyo/Px+CIMBsNmNmZgbt7e0ZFQwKXPf/GRgYQGtrKwwGQ1KfS+70+mAwiN7e3iijwEyBiR/mTg1cr0D+0R/9EV7zmtfg/e9/f8Z/6CCSD1WACILYMyqVCl1dXejq6sLf/M3fYHBwEE888QTe8IY3oLy8HOfPn8cb3vAGVFZWorKyEqIowmq1YmZmBm63G1lZWQiFQujo6Ei7u3OirK2tYXh4OGVVK51Oh9raWtTW1vL0+rGxsT2t17N8rPr6+oxbzWahrNnZ2bwaGwwG8Y53vAOveMUrSPwQRAwkgIh9E8/QI3sMW3teW1s7NCVvlUqFtrY2tLW14ROf+ARGRkbw5JNP4g/+4A9QWFiI8+fP47bbbuMzLT/96U9RUFAAvV6Pl156CUVFRSgvL4/L7C7d2O12jI+P4/Tp0ynPJAOuD6ubTCaYTKaE1+vZsHZkOGimIEkSRkdHodFoeC5ZKBTCvffei+7ubnz4wx9W/M8OQaQaaoHtArXAdieeocfPf/7zGBgY4EPQTz/9NL797W+n8dTpR5IkTE5O4sknn8T3vvc9ZGdnQxAElJaW4pFHHoFKpUI4HOap62tra4pYC98Oi8WCqakpnD59WnEtu9j0+tjXMRAI4OrVq2hqasq4tqwkSdxXh4X8iqKI9773vWhqauJxEwQRL4elBUYCaBdIAMXHc889hw984AN86PEv//Ivo4YefT4f3va2t+Hq1asoLi7G448/LnuIZCbj9Xq5J8v6+jpUKhVuu+02XLhwASaTCYIg8LXw1dVVOJ1OGAwGlJeXo7i4OO1iaGVlBfPz8zh9+nTa4kHiJTa9Xq/XY2NjA8eOHcvIys/ExAREUcTx48e5+Hn/+9+P8vJy/O3f/i2JHyJhSAARAEgAEanhrW99K26++Wa8+93vhiRJWFpawlNPPYXvfOc78Pv9eMMb3oDbb78d9fX1EAQBkiTxm7jdbkd+fj7KysrSkly/sLCA1dVVtLe3KyooNh68Xi9+85vfwGAwwO12cwfldOa8xYskSbh27RoCgQAPlA2Hw/jgBz+IvLw8fOYzn0m7MCYyExJABAASQERqcLlcyMvL2/T7kiTBbDbj6aefxtNPP421tTWcO3cOFy5cwJEjR7gYWl9fx+rqKmw2G3Jzc1FeXp4Sw0Clp9HvBDOXjFzTZ+v1VqsVGo2Gb5QpraUHANeuXYPP50NLSwsXP8yA9J//+Z9J/BB7hgQQAYAEEKEsrFYrvvvd7+Lpp5+G2WzG6173Oly4cIFXACRJwsbGBr+J63Q6PlwtZ3WGVR+8Xi9aW1sz7ma7lfjZ6jFyrtfLCRvsZmG44XAYf/VXf4WNjQ3827/9W8Z9PwhlQQKIAEACiFAuDocDzz77LJ5++mnMzc3hNa95Dd74xjfi1KlTUKlUPBNqdXUVVqsVWVlZPLl+P+0dSZIwNjaGcDjMhVcmwQwaT5w4EbezNnPztlgsaU+vn5mZwfr6Ok6ePMm/z3/913+N5eVlPPLIIxlXiSOUBwkgAgAJoExjt0yyz372s/jyl7/M2xtf+cpXMi5VfSvW19fx/e9/H08//TQmJibwqle9ChcuXEBnZyevBrjdbn4T12g03D05EZ+hcDiMkZERZGVlobm5OePEj9vtRn9//74MGtl6vdlshsfjQXFxccrS62dnZ+F0OqNE7t///d9jcnISX//61zNuBotQJiSACAAkgDKJeDLJ/vu//xtnz56FXq/HF77wBbzwwgsHIpMsEo/Hg+eeew5PPfUUBgcHccstt+D222/H2bNneXXA6/VidXUVFosFKpWKt8l2Sq4Ph8MYGBjg+VKZKn5OnjyJ/Px8Wa6523q9nMzPz8Nms6GtrY2Ln3/6p39Cb28vHn30UcUPbROZw2ERQNQoJg4MkZlkWVlZPJMskle+8pV8huOGG27AwsJCOo6aVPR6Pd70pjfhsccew4svvojXvOY1+PrXv44bb7wRH/zgB/E///M/0Gq1qK+vR09PD1pbWyFJEgYHB/Hiiy9idnYWXq836posFb2oqAgNDQ0ZJ35cLhf6+/tx6tQp2cQP8HJ6fWtrK86ePYvy8nJYLBZcunQJg4ODMJvNEEVx38+zsLAAq9UaJX7+9V//FS+++CK++c1vyiZ+Ll68iGPHjqG5uRmf+tSntn3cU089BUEQQB8OiUyG6qXEgWFxcRE1NTX819XV1bh06dK2j3/kkUfw+te/PhVHSxs5OTk4f/48zp8/j0AggJ/+9Kd44okn8KEPfQg33HADLly4gJtvvplHSfj9flgsFgwPD0MURZSWlqK4uBgTExOoqqpCVVVVur+khNnY2MDg4GDSozlUKhWKi4tRXFwclV4/NTXFh9GNRmPCYmVxcRFmsxnt7e1c/DzyyCN44YUX8PTTT8sWlSKKIu67776oCur58+ejKqjA9dfzc5/7HM6ePSvL8xJEuiABRBxKvvGNb+DKlSv42c9+lu6jpIysrCy8/vWvx+tf/3oEg0H87Gc/w5NPPokHHngAXV1duHDhAl75ylfy5PpAIICVlRX85je/gVarhc/n23ZdX6msr69jaGgoZblkjMj0+ubmZj5/dfXq1YTW65eXl7GysoLTp0/z9uXXv/51/OAHP8Azzzwj63p+ZAUVAK+gxgqgj33sY/jIRz6CT3/607I9N0GkAxJAxIEhnkwyAPjJT36CT37yk/jZz36mSH+XVKDVavHqV78ar371qyGKIn7+85/jqaeewoMPPohTp07hwoULaG5uxl/8xV/gy1/+MgoKCmC1WjE5OQmfzwej0Yjy8vK0bEHFy9raGkZGRtDe3p7W1XVBEJCXl4e8vDw0NjbC6/XCbDZjYGBgx/X6lZUVLC0tRYmfb37zm3jqqafwve99b8d5rf+vvbuPqrrK9zj+3kEPloSAiGk+5CBZPoHpVVdrEvMO4+ORStCa8eFqz2XWbZyyZrqucqZuTrWW1moqbereMg10rkz4MKNJWaMWCmbiKDYoaslJRBQVENj3jwNnxFCOBufI+X1ea7HWgfNbnC8bFnzYv73390L4MoO6ZcsW9u3bx6hRoxSApMVTAJKgMWDAAPLz8ykoKKBjx44sXryYRYsW1bsmJyeH++67j1WrVrW4bt/NJSQkhMTERBITE6murmbjxo0sXLiQ+++/nyFDhrB+/Xp+9rOfeTvXn9lktG5L+NVXX33RhKEjR47wj3/8g759+wakKeu5tGrVii5dutClSxfv9vozu9cfP36c/fv31ws/aWlpvPfee2RmZgYk0NWdMv3OO+/4/bVFmoMCkASN0NBQXn31VX7+8597e5L17NmzXk+ymTNnUlZWRkpKCgCdO3cmIyMjwJVfPEJCQggPD2fLli2sWbMGay1paWm8+OKLXHfddbhcLkaOHEn79u1p37491dXVFBcXs2/fPo4dO0ZkZCQxMTF+2RJ+NiUlJezcuZP4+PgmnyVpapdddpn3lmNdsNyxYwdlZWV06NCB7du306tXL/7yl7+wYMECPvroo2a7BdnYDGrdWqrExETAM0PlcrnIyMigf/+g3zAkQUjb4BuhbfDiNIsWLaJfv3706NHD+7G6LfBpaWmsXLmS9u3b43K5GD16NBEREd5riouLvVvCIyIivFvC/RWGDh8+zK5du1pE+GnI999/T0FBAX369OHYsWPMmjWLv//971RVVTF//nxGjx7dbNvdq6qqiIuLY+3atXTs2JEBAwawaNEievbs2eD1iYmJ/OEPf1D4CULaBi8ijnTXXXfVCz/g2eHUt29f5syZQ3Z2NnPnzqWoqIjbbruN5ORk/vSnP1FcXFxvS3h0dDQHDx5k48aN5OXlUVxcTE1NTbPVXVxcTH5+PgkJCS0y/NTdVqyrPzo6mtTUVGJiYpg/fz4ff/wxN910EwsXLmyW1z99BvWGG24gNTXVO4OqWVIJRpoBaoRmgETOzlrL7t27SU9PJyMjg1atWnm33cfExHj7k5WUlOB2uykpKeHqq6/2dq5vqsMCDx06xDfffENCQkKTbQv3p+LiYnbv3l2v/nXr1jF79mwyMzO969VqamooKyu74FOsRXzhlBkgBaBGKADJhWqsLUedpUuXMm7cOL788ssWfTvBWsuePXtYunQpf/7znwkJCWHMmDEkJyfToUMHbxgqLS3F7XZTXFxM69atvefjXGgPq7rbRvHx8S0y/Bw+fNg7c1VX//r163nqqafIzMykffv2Aa5QnEYBSAAFILkwvrTlAM/C0lGjRlFZWcmrr77aogPQ6ay1HDhwwBuGKisrGTNmDGPHjqVLly71OtcXFRVRXFxMq1atiImJoW3btj73tHK73ezZs4eEhIQW2QqibrdaQkKC90iGDRs28Ktf/YqPPvqowWMcRJqbUwKQ1gCJNANf2nLAvw6Va4lrVs7FGMO1117LjBkzWLduHcuWLSM8PJxHHnmEoUOHMnfuXHbv3k1YWBjdu3dn4MCBdOvWjePHj5OdnU1ubi7ffvstp06dOutrFBUVsXfv3hYffuLj473hJzs7m8cff5zly5cr/Ig0MwUgkWbQ0KFyBw4cqHfN6YfKBTNjDO3bt+fBBx9kzZo1ZGZm0qFDB5588kmGDBnC888/z44dO2jdujU/+clPGDRoEN27d6e8vJycnBy2bNnCgQMHqKys9H7OgwcPUlhY2GLDT2lpqfecorrwm5uby/Tp01m2bBmdO3cOcIUiwU/nAIkEgJMPlYuOjuaee+7hnnvuoaSkhOXLl/Pss8+yb98+kpKSuO222+jVqxfdunWjW7dunDhxArfbzdatW7nkkku4/PLLOXHiBP369fP5VtnF5OjRo+Tl5REfH+89pPHrr7/m/vvvJz093duKQkSal2aARJrB+Rwq17VrVzZu3IjL5XJcd+2IiAimTJlCRkYGWVlZ9OnTh7lz53LzzTfz29/+ls2bN3PFFVd4O9e3atWK0tJSjDHk5uZSWFhIeXl5oL8Mnx07dozt27fXO6F6x44d3H333SxevJi4uLgAVyjiHFoE3QgtgpYLoUPlfpyysjJWrlxJeno6eXl5DB06FGMMO3fuJC0tjZCQECoqKnC73bjdbmpqaoiOjiYmJuaia31Rp6ysjG3bttVrzLpr1y4mTZrE+++/T+/evQNcoYiHFkGLyAXToXI/TuvWrUlJSWHJkiV88cUXVFRUkJGRwbfffsuvf/1rPv30U0JCQujUqRM33XQTffv2JTQ0lB07dvDFF194+5RdLI4fP862bdvo3bu3N/wUFBQwefJk3n33XYUfkQDQDFAjNAMkElivvfYaf/3rX/nwww8BWLt2Lenp6WzatInBgweTnJzMT3/6U+9i6FOnTvH999/jdrupqKjwdq6/6qqrAtKf7MSJE2zdupXevXt7+3gVFhYyfvx4FixYwIABA/xek8i5OGUGSAGoEQpAIoGVnZ1Nnz59fnDI4alTp8jKymLp0qWsX7+e/v37k5ycTGJiondbeV2D0aKiIk6ePElUVBQxMTGEhYX5JQydPHmS3NxcevXqRVhYGODZIZiSksLrr7/O4MGDm70GkfOlACSAApBIS1BVVcVnn31Genq6dzF1cnIyw4YN864Jqq6u5tChQ7jdbsrKyoiKiqJdu3bN1rn+5MmTbN26lRtvvNHbuuLgwYOMGzeOV155hSFDhjT5a4o0BQUgARSARFqa6upqNmzYwNKlS1mzZg09evQgOTmZpKQk7/qb6upqDh8+TFFREceOHSMiIoKYmBjatGnTJGGovLyc3NxcbrjhBsLDwwHPqdV33HEHL774IsOGDfvRrwGNt1t5+eWXWbBgAaGhoURHR/P222/TpUuXJnltCV4KQAIoAElw8KUv2Ycffsjs2bMxxtC3b18WLVoUgEqbVk1NDZs3byYtLY3Vq1fTrVs3XC4XI0aM8M7K1NTUcPjwYdxuN6WlpbRp04Z27doRERFxQc1aKyoqyMnJoUePHrRp0wbwNGu94447eO655xg+fHiTfG2+tFtZt24dAwcO5Morr+T1118nKyuLJUuWNMnrS/BSABJAAUhaPl/+UObn55OamsrHH39MREQEbrfb24E8WNTU1PDVV1+RlpbGypUr6dChAy6Xi1GjRhEREeG95siRI/U618fExBAZGelTGKoLP9dff733c5aUlHD77bfzm9/8hjFjxjTZ17NhwwZmz57N6tWrAXj++ecBmDVrVoPX5+Tk8PDDD/P55583WQ0SnJwSgFreMaoicl5O70sGePuSnR6A3nrrLR566CHvH+1gCz8Al1xyCfHx8cTHxzNnzhzy8vJIT08nOTmZyMhIxo4dy+jRo2nbti2RkZHezvVFRUXk5+cTFhZGu3btiIqKarBzfWVlJbm5ucTFxXnHsbS0lJSUFJ544okmDT/QcLuVTZs2nfX6hQsXMmLEiCatQaQlUwASCXK+/KHctWsXADfffDPV1dXMnj27yW7VXIyMMfTs2dN7NlN+fj7p6emMHz+eVq1aMXbsWMaMGeNdF2St5ejRo7jdbr755huuuuoqYmJiiIqKIjQ01Bt+YmNjiYyMBDynPqempjJjxgxuv/32gH697733HtnZ2XzyyScBrUPkYqIAJCJUVVWRn59PVlYW+/fv55ZbbmHbtm3eNSzBzBhDXFwcTz31FLNmzaKgoIClS5cyceJEQkJCcLlcJCcnc8011xAeHk5sbCxlZWUUFRVRUFDA5ZdfzvHjx4mNjSUqKgrwHHw4YcIE7r33XsaPH98sdTfWbqXOmjVr+N3vfscnn3ziPR5ARHQStEjQ8+UP5bXXXovL5eLSSy/luuuuIy4ujvz8fH+XGnDGGLp168bMmTP57LPPeP/99wkNDWXatGkkJSUxb9489u7dS+vWrYmNjaV79+4cO3aM8PBw9u7dy+TJk3nllVcYP348EydOZOLEic1W64ABA8jPz6egoIDKykoWL16My+Wqd01OTg733XcfGRkZQXlbU+THUAASCXK+/KFMTk4mKysL8OxY2rVrl+O7khtj6NSpE48++ihZWVmkp6cTFhbG9OnTufXWW/n973/PyJEjOXLkCL1792bgwIHMmDGDv/3tb+zdu5clS5bwxhtvUFRU1Cz1+dJuZebMmZSVlZGSkkJ8fPwPvu8iTqZdYI3QLjAJBitWrODRRx+lurqaqVOn8vTTT/PMM8/Qv39/XC4X1loef/xxVq1aRUhICE8//TQTJkwIdNkXrT179jB8+HDatm1LRUUFI0aMYNSoUTz33HMkJSUxffp0CgsLWbZsGeHh4UydOjXQJYv4zCm7wBSAGqEAJCKnKy8vZ8yYMUyZMoVf/OIXHD58mIyMDObNm0dCQgILFiwISM8xkaaiACSAApCI1GetZdOmTQwaNCjQpYg0C6cEIK0BEhE5D8YYhR+RIKAAJCIiIo6jACQifrdq1Squv/56YmNjeeGFF37wfGFhIUOHDiUhIYE+ffqwYsWKAFQpIsFMAUhE/Kq6upqHHnqIlStXkpeXxwcffEBeXl69a+bMmUNqaio5OTksXryYBx98MEDVikiwUgASEb86vTfZZZdd5u1NdjpjDEePHgU8/bQ6dOgQiFJFJIipFYaI+JUvvclmz55NUlIS8+fP5/jx46xZs8bfZYpIkNMMkIhcdD744AOmTJnC/v37WbFiBRMnTqSmpibQZYlIEFEAEhG/8qU32cKFC0lNTQVg8ODBlJeXc+jQIb/WKSLBTQFIRPzKl95knTt3Zu3atQDs2LGD8vJyoqOjA1GuiAQpBSAR8Stfmni+9NJLvPXWW/Tt25c777yTd955R+0lRKRJqRVGI9QKQ0Sa0qpVq5gxYwbV1dXcfffdPPnkk/Wer6ioYNKkSWzevJmoqCiWLFlC165dA1OsOJJaYYiISJPy5QykhQsXEhERwe7du3nsscd44oknAlStSHBTABIR8RNfzkBavnw5kydPBmDcuHGsXbsWzdSLND0FIBERP2noDKQDBw6c9ZrQ0FDCw8MpLi72a50iTqAAJCKON3XqVNq1a0evXr0afN5ayyOPPEJsbCx9+vRhy5Ytfq5QRJpaUAUgY8xwY8xOY8xuY8yTDTx/uTFmSe3zm4wxXQNQpohcZKZMmcKqVavO+vzKlSvJz88nPz+fN998kwceeOCCXseXM5BOv6aqqorS0lKioqIu6PVE5OyCJgAZY0KA14ARwI3AncaYG8+4bBpQYq2NBV4B/tu/VYrIxeiWW24hMjLyrM8vX76cSZMmYYxh0KBBHDlyhO++++68X8eXM5BcLhfvvvsuAOnp6dx66606AkCkGQRNAAL+Ddhtrf2ntbYSWAyMPeOascC7tY/TgWFGv1lEpBG+rN3xhS9nIE2bNo3i4mJiY2N5+eWXeeGFF5rs6xCRfwmmZqgdgX2nvb8fGHi2a6y1VcaYUiAK0Bn7IuIXI0eOZOTIkfU+9uyzz3ofX3HFFaSlpfm7LBHHCaYA1GSMMfcC99a+W2GM+TqQ9ThAWxRC/UHjfG6XAd2NMdsbeK5LZmbmMeBw7fu9BgwYsBM4dcZ1GuPmpzFuftcHugB/CKYAdADodNr719Z+rKFr9htjQoFw4Af7S621bwJvAhhjsp1wImYgaYz9Q+N8brWbIj5qaIyMMaOAh4GReGaW51lr/62B6zTGzUxj3PyMMY5ofxBMAehLPP+9XYcn6EwA7jrjmgxgMrABGAd8bHXCmIjjGWM+ABKBtsaY/cB/AZcCWGv/CKzAE352AyeA/whMpSLSVIImANWu6XkYWA2EAG9ba7cbY54Fsq21GcBC4H+NMbvxTGVPCFzFInKxsNbe2cjzFnjIT+WIiB8ETQACsNauwPOf2ukfe+a0x+VAynl+2jeboDQ5N42xf2icm5/GuPlpjJufI8ZY3eBFRETEcYLpHCARERERnygA1VIbjebnwxj/pzEmzxjzlTFmrTGmSyDqbMkaG+PTrrvDGGONMdpNcwF8GWdjTGrtz/N2Y8wif9fY0vnw+6KzMWadMSan9nfGyIY+j5ydMeZtY4z7bEe9GI95td+Dr4wx/fxdY7Oy1jr+Dc+i6W+AbnjOAtkK3HjGNQ8Cf6x9PAFYEui6W9Kbj2M8FLiy9vEDGuOmH+Pa68KAT4GNQP9A193S3nz8We4O5AARte+3C3TdLenNxzF+E3ig9vGNwJ5A193S3oBbgH7A12d5fiSwEjDAIGBToGtuyjfNAHmojUbza3SMrbXrrLUnat/diOcsJ/GdLz/HAM/h6YNX7s/igogv43wP8Jq1tgTAWuv2c40tnS9jbIGrax+HA9/6sb6gYK39lH8d7tmQscD/WI+NQBtjzDX+qa75KQB5NNRGo+PZrrHWVgF1bTTEN76M8emm4fnPQ3zX6BjXTmF3stZm+rOwIOPLz3IcEGeM+dwYs9EYM9xv1QUHX8Z4NvDL2nObVgDT/VOao5zv7+0WJai2wUtwMMb8EugPDAl0LcHEGHMJ8DIwJcClOEEonttgiXhmMj81xvS21h4JZFFB5k7gHWvtS8aYwXjOeOtlra0JdGHSMmgGyON82mhwrjYacla+jDHGmH8HngZc1toKP9UWLBob4zCgF5BljNmD555+hhZCnzdffpb3AxnW2lPW2gJgF55AJL7xZYynAR8CWGs3AFfg6RMmTcen39stlQKQh7eNhjHmMjyLnDPOuKaujQaojcaFaHSMjTEJwBt4wo/WTJy/c46xtbbUWtvWWtvVWtsVzzorl7XWEX1/mpAvvy/+D8/sD8aYtnhuif3TjzW2dL6McSEwDMAYcwOeAPS9X6sMfhnApNrdYIOAUmvtd4EuqqnoFhhqo+EPPo7xXKA1kFa7vrzQWusKWNEtjI9jLD+Sj+O8GkgyxuQB1cBMa61mjH3k4xg/DrxljHkMz4LoKfqn9Pw4vQeeToIWERERx9EtMBEREXEcBSARERFxHAUgERERcRwFIBEREXEcBSARERFxHAUgERERcRwFIBEREXEcBSARERFxHAUgERERcRwFIBEREXEcBSARERFxHAUgERERcRwFIBEREXEcBSARERFxHAUgERERcRwFIBEREXEcBSARERFxHAUgERERcRwFIBEREXEcBSARERFxHAUgERERcRwFIBEREXEcBSARERFxHAUgERERcRwFIBEREXEcBSARERFxHAUgERERcRwFIBEREXEcBSARERFxHAUgERERcRwFIBEREXEcBSARERFxHAUgERERcRwFIBEREXEcBSARERFxHAUgERERcRwFIBEREXEcBSARERFxnP8HrL0RkLyR8bQAAAAASUVORK5CYII=", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", " \n", "
\n", " " ], "text/plain": [ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from mpl_toolkits import mplot3d\n", "from mpl_toolkits.mplot3d import Axes3D\n", "\n", "%matplotlib inline\n", "%matplotlib widget\n", "\n", "x, y, z = embed[:,0], embed[:,1], embed[:,2]\n", "\n", "fig, ax = plt.subplots(1, 1, figsize=(8, 6))\n", "ax = fig.add_subplot(1, 1, 1, projection='3d')\n", "ax.scatter3D(x, y, z, c=param_corr[:, 0], cmap='hsv')\n", "ax.set(xlabel=\"U0\", ylabel=\"U1\", zlabel=\"U2\", xticks=[], yticks=[], zticks=[])\n", "fig.suptitle('UMAP 3D')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Decoding" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "import decoding" ] }, { "cell_type": "code", "execution_count": 80, "metadata": {}, "outputs": [ { "ename": "NotImplementedError", "evalue": "Axes3D currently only supports the aspect argument 'auto'. You passed in 'equal'.", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNotImplementedError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m/home/ennucore/dev/amgen/exp/ProcessExp.ipynb Cell 103\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[39m# param = decoding.cohomological_parameterization(pd.DataFrame(firing_rates_in_trials_pca.reshape((400*50, -1))[::41]))\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m param \u001b[39m=\u001b[39m decoding\u001b[39m.\u001b[39;49mcohomological_parameterization(fr_pca_simpl)\n", "File \u001b[0;32m~/dev/amgen/exp/../model/decoding.py:95\u001b[0m, in \u001b[0;36mcohomological_parameterization\u001b[0;34m(X, cocycle_number, coeff, weighted)\u001b[0m\n\u001b[1;32m 93\u001b[0m idx \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39margsort(dgm1[:, \u001b[39m1\u001b[39m] \u001b[39m-\u001b[39m dgm1[:, \u001b[39m0\u001b[39m])[\u001b[39m-\u001b[39mcocycle_number]\n\u001b[1;32m 94\u001b[0m cocycle \u001b[39m=\u001b[39m cocycles[\u001b[39m1\u001b[39m][idx]\n\u001b[0;32m---> 95\u001b[0m persistence(X, homdim\u001b[39m=\u001b[39;49m\u001b[39m1\u001b[39;49m, coeff\u001b[39m=\u001b[39;49mcoeff, show_largest_homology\u001b[39m=\u001b[39;49m\u001b[39m0\u001b[39;49m,\n\u001b[1;32m 96\u001b[0m Nsubsamples\u001b[39m=\u001b[39;49m\u001b[39m0\u001b[39;49m, save_path\u001b[39m=\u001b[39;49m\u001b[39mNone\u001b[39;49;00m, cycle\u001b[39m=\u001b[39;49midx)\n\u001b[1;32m 97\u001b[0m thresh \u001b[39m=\u001b[39m dgm1[idx, \u001b[39m1\u001b[39m] \u001b[39m-\u001b[39m EPSILON\n\u001b[1;32m 99\u001b[0m \u001b[39m# Compute connectivity\u001b[39;00m\n", "File \u001b[0;32m~/dev/amgen/exp/../model/decorators.py:19\u001b[0m, in \u001b[0;36mmulti_input..wrapper\u001b[0;34m(data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[39mreturn\u001b[39;00m output_data\n\u001b[1;32m 18\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m---> 19\u001b[0m \u001b[39mreturn\u001b[39;00m f(data, \u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n", "File \u001b[0;32m~/dev/amgen/exp/../model/persistence.py:97\u001b[0m, in \u001b[0;36mpersistence\u001b[0;34m(X, homdim, coeff, threshold, show_largest_homology, distance_matrix, Nsubsamples, alpha, cycle, save_path)\u001b[0m\n\u001b[1;32m 94\u001b[0m result \u001b[39m=\u001b[39m ripser\u001b[39m.\u001b[39mripser(X, maxdim\u001b[39m=\u001b[39mhomdim, coeff\u001b[39m=\u001b[39mcoeff, do_cocycles\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m,\n\u001b[1;32m 95\u001b[0m distance_matrix\u001b[39m=\u001b[39mdistance_matrix, thresh\u001b[39m=\u001b[39mthreshold)\n\u001b[1;32m 96\u001b[0m diagrams \u001b[39m=\u001b[39m result[\u001b[39m'\u001b[39m\u001b[39mdgms\u001b[39m\u001b[39m'\u001b[39m]\n\u001b[0;32m---> 97\u001b[0m plot_diagrams(diagrams, show\u001b[39m=\u001b[39;49m\u001b[39mFalse\u001b[39;49;00m)\n\u001b[1;32m 98\u001b[0m \u001b[39mif\u001b[39;00m (Nsubsamples\u001b[39m>\u001b[39m\u001b[39m0\u001b[39m):\n\u001b[1;32m 99\u001b[0m conf \u001b[39m=\u001b[39m confidence(X, alpha, Nsubsamples, homdim, \u001b[39m2\u001b[39m)\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/persim/visuals.py:157\u001b[0m, in \u001b[0;36mplot_diagrams\u001b[0;34m(diagrams, plot_only, title, xy_range, labels, colormap, size, ax_color, diagonal, lifetime, legend, show, ax)\u001b[0m\n\u001b[1;32m 155\u001b[0m ax\u001b[39m.\u001b[39mset_xlim([x_down, x_up])\n\u001b[1;32m 156\u001b[0m ax\u001b[39m.\u001b[39mset_ylim([y_down, y_up])\n\u001b[0;32m--> 157\u001b[0m ax\u001b[39m.\u001b[39;49mset_aspect(\u001b[39m'\u001b[39;49m\u001b[39mequal\u001b[39;49m\u001b[39m'\u001b[39;49m, \u001b[39m'\u001b[39;49m\u001b[39mbox\u001b[39;49m\u001b[39m'\u001b[39;49m)\n\u001b[1;32m 159\u001b[0m \u001b[39mif\u001b[39;00m title \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 160\u001b[0m ax\u001b[39m.\u001b[39mset_title(title)\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/mpl_toolkits/mplot3d/axes3d.py:323\u001b[0m, in \u001b[0;36mAxes3D.set_aspect\u001b[0;34m(self, aspect, adjustable, anchor, share)\u001b[0m\n\u001b[1;32m 270\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 271\u001b[0m \u001b[39mSet the aspect ratios.\u001b[39;00m\n\u001b[1;32m 272\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 320\u001b[0m \u001b[39mmpl_toolkits.mplot3d.axes3d.Axes3D.set_box_aspect\u001b[39;00m\n\u001b[1;32m 321\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 322\u001b[0m \u001b[39mif\u001b[39;00m aspect \u001b[39m!=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mauto\u001b[39m\u001b[39m'\u001b[39m:\n\u001b[0;32m--> 323\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mNotImplementedError\u001b[39;00m(\n\u001b[1;32m 324\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mAxes3D currently only supports the aspect argument \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 325\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m'\u001b[39m\u001b[39mauto\u001b[39m\u001b[39m'\u001b[39m\u001b[39m. You passed in \u001b[39m\u001b[39m{\u001b[39;00maspect\u001b[39m!r}\u001b[39;00m\u001b[39m.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 326\u001b[0m )\n\u001b[1;32m 328\u001b[0m \u001b[39mif\u001b[39;00m share:\n\u001b[1;32m 329\u001b[0m axes \u001b[39m=\u001b[39m {\u001b[39m*\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_shared_x_axes\u001b[39m.\u001b[39mget_siblings(\u001b[39mself\u001b[39m),\n\u001b[1;32m 330\u001b[0m \u001b[39m*\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_shared_y_axes\u001b[39m.\u001b[39mget_siblings(\u001b[39mself\u001b[39m),\n\u001b[1;32m 331\u001b[0m \u001b[39m*\u001b[39m\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_shared_z_axes\u001b[39m.\u001b[39mget_siblings(\u001b[39mself\u001b[39m),\n\u001b[1;32m 332\u001b[0m }\n", "\u001b[0;31mNotImplementedError\u001b[0m: Axes3D currently only supports the aspect argument 'auto'. You passed in 'equal'." ] } ], "source": [ "# param = decoding.cohomological_parameterization(pd.DataFrame(firing_rates_in_trials_pca.reshape((400*50, -1))[::41]))\n", "param = decoding.cohomological_parameterization(fr_pca_simpl)\n" ] }, { "cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(788,)" ] }, "execution_count": 63, "metadata": {}, "output_type": "execute_result" } ], "source": [ "param_corr[:, 0].shape" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "ename": "ValueError", "evalue": "'c' argument must be a color, a sequence of colors, or a sequence of numbers, not decoding\n0 5.648858e-10\n1 8.865429e-01\n2 8.865876e-01\n3 8.864820e-01\n4 8.867152e-01\n.. ...\n641 8.865732e-01\n642 8.861918e-01\n643 8.865706e-01\n644 8.865345e-01\n645 8.863632e-01\n\n[646 rows x 1 columns]", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/axes/_axes.py:4350\u001b[0m, in \u001b[0;36mAxes._parse_scatter_color_args\u001b[0;34m(c, edgecolors, kwargs, xsize, get_next_color_func)\u001b[0m\n\u001b[1;32m 4349\u001b[0m \u001b[39mtry\u001b[39;00m: \u001b[39m# Is 'c' acceptable as PathCollection facecolors?\u001b[39;00m\n\u001b[0;32m-> 4350\u001b[0m colors \u001b[39m=\u001b[39m mcolors\u001b[39m.\u001b[39;49mto_rgba_array(c)\n\u001b[1;32m 4351\u001b[0m \u001b[39mexcept\u001b[39;00m (\u001b[39mTypeError\u001b[39;00m, \u001b[39mValueError\u001b[39;00m) \u001b[39mas\u001b[39;00m err:\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/colors.py:385\u001b[0m, in \u001b[0;36mto_rgba_array\u001b[0;34m(c, alpha)\u001b[0m\n\u001b[1;32m 384\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 385\u001b[0m rgba \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray([to_rgba(cc) \u001b[39mfor\u001b[39;00m cc \u001b[39min\u001b[39;00m c])\n\u001b[1;32m 387\u001b[0m \u001b[39mif\u001b[39;00m alpha \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/colors.py:385\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 384\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 385\u001b[0m rgba \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray([to_rgba(cc) \u001b[39mfor\u001b[39;00m cc \u001b[39min\u001b[39;00m c])\n\u001b[1;32m 387\u001b[0m \u001b[39mif\u001b[39;00m alpha \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/colors.py:206\u001b[0m, in \u001b[0;36mto_rgba\u001b[0;34m(c, alpha)\u001b[0m\n\u001b[1;32m 205\u001b[0m \u001b[39mif\u001b[39;00m rgba \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m: \u001b[39m# Suppress exception chaining of cache lookup failure.\u001b[39;00m\n\u001b[0;32m--> 206\u001b[0m rgba \u001b[39m=\u001b[39m _to_rgba_no_colorcycle(c, alpha)\n\u001b[1;32m 207\u001b[0m \u001b[39mtry\u001b[39;00m:\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/colors.py:277\u001b[0m, in \u001b[0;36m_to_rgba_no_colorcycle\u001b[0;34m(c, alpha)\u001b[0m\n\u001b[1;32m 276\u001b[0m \u001b[39mreturn\u001b[39;00m c, c, c, alpha \u001b[39mif\u001b[39;00m alpha \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39melse\u001b[39;00m \u001b[39m1.\u001b[39m\n\u001b[0;32m--> 277\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mInvalid RGBA argument: \u001b[39m\u001b[39m{\u001b[39;00morig_c\u001b[39m!r}\u001b[39;00m\u001b[39m\"\u001b[39m)\n\u001b[1;32m 278\u001b[0m \u001b[39m# turn 2-D array into 1-D array\u001b[39;00m\n", "\u001b[0;31mValueError\u001b[0m: Invalid RGBA argument: 'decoding'", "\nThe above exception was the direct cause of the following exception:\n", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m/home/ennucore/dev/amgen/exp/ProcessExp.ipynb Cell 98\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m plt\u001b[39m.\u001b[39;49mscatter(param_corr[:, \u001b[39m0\u001b[39;49m], param_corr[:, \u001b[39m1\u001b[39;49m], c\u001b[39m=\u001b[39;49mparam, cmap\u001b[39m=\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39mRdBu\u001b[39;49m\u001b[39m'\u001b[39;49m)\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/pyplot.py:3068\u001b[0m, in \u001b[0;36mscatter\u001b[0;34m(x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, edgecolors, plotnonfinite, data, **kwargs)\u001b[0m\n\u001b[1;32m 3063\u001b[0m \u001b[39m@_copy_docstring_and_deprecators\u001b[39m(Axes\u001b[39m.\u001b[39mscatter)\n\u001b[1;32m 3064\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mscatter\u001b[39m(\n\u001b[1;32m 3065\u001b[0m x, y, s\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, c\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, marker\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, cmap\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, norm\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m,\n\u001b[1;32m 3066\u001b[0m vmin\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, vmax\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, alpha\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, linewidths\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m,\n\u001b[1;32m 3067\u001b[0m edgecolors\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, plotnonfinite\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m, data\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[0;32m-> 3068\u001b[0m __ret \u001b[39m=\u001b[39m gca()\u001b[39m.\u001b[39;49mscatter(\n\u001b[1;32m 3069\u001b[0m x, y, s\u001b[39m=\u001b[39;49ms, c\u001b[39m=\u001b[39;49mc, marker\u001b[39m=\u001b[39;49mmarker, cmap\u001b[39m=\u001b[39;49mcmap, norm\u001b[39m=\u001b[39;49mnorm,\n\u001b[1;32m 3070\u001b[0m vmin\u001b[39m=\u001b[39;49mvmin, vmax\u001b[39m=\u001b[39;49mvmax, alpha\u001b[39m=\u001b[39;49malpha, linewidths\u001b[39m=\u001b[39;49mlinewidths,\n\u001b[1;32m 3071\u001b[0m edgecolors\u001b[39m=\u001b[39;49medgecolors, plotnonfinite\u001b[39m=\u001b[39;49mplotnonfinite,\n\u001b[1;32m 3072\u001b[0m \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49m({\u001b[39m\"\u001b[39;49m\u001b[39mdata\u001b[39;49m\u001b[39m\"\u001b[39;49m: data} \u001b[39mif\u001b[39;49;00m data \u001b[39mis\u001b[39;49;00m \u001b[39mnot\u001b[39;49;00m \u001b[39mNone\u001b[39;49;00m \u001b[39melse\u001b[39;49;00m {}), \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 3073\u001b[0m sci(__ret)\n\u001b[1;32m 3074\u001b[0m \u001b[39mreturn\u001b[39;00m __ret\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/__init__.py:1361\u001b[0m, in \u001b[0;36m_preprocess_data..inner\u001b[0;34m(ax, data, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1358\u001b[0m \u001b[39m@functools\u001b[39m\u001b[39m.\u001b[39mwraps(func)\n\u001b[1;32m 1359\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39minner\u001b[39m(ax, \u001b[39m*\u001b[39margs, data\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m 1360\u001b[0m \u001b[39mif\u001b[39;00m data \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m-> 1361\u001b[0m \u001b[39mreturn\u001b[39;00m func(ax, \u001b[39m*\u001b[39;49m\u001b[39mmap\u001b[39;49m(sanitize_sequence, args), \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m 1363\u001b[0m bound \u001b[39m=\u001b[39m new_sig\u001b[39m.\u001b[39mbind(ax, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m 1364\u001b[0m auto_label \u001b[39m=\u001b[39m (bound\u001b[39m.\u001b[39marguments\u001b[39m.\u001b[39mget(label_namer)\n\u001b[1;32m 1365\u001b[0m \u001b[39mor\u001b[39;00m bound\u001b[39m.\u001b[39mkwargs\u001b[39m.\u001b[39mget(label_namer))\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/axes/_axes.py:4516\u001b[0m, in \u001b[0;36mAxes.scatter\u001b[0;34m(self, x, y, s, c, marker, cmap, norm, vmin, vmax, alpha, linewidths, edgecolors, plotnonfinite, **kwargs)\u001b[0m\n\u001b[1;32m 4513\u001b[0m \u001b[39mif\u001b[39;00m edgecolors \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 4514\u001b[0m orig_edgecolor \u001b[39m=\u001b[39m kwargs\u001b[39m.\u001b[39mget(\u001b[39m'\u001b[39m\u001b[39medgecolor\u001b[39m\u001b[39m'\u001b[39m, \u001b[39mNone\u001b[39;00m)\n\u001b[1;32m 4515\u001b[0m c, colors, edgecolors \u001b[39m=\u001b[39m \\\n\u001b[0;32m-> 4516\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_parse_scatter_color_args(\n\u001b[1;32m 4517\u001b[0m c, edgecolors, kwargs, x\u001b[39m.\u001b[39;49msize,\n\u001b[1;32m 4518\u001b[0m get_next_color_func\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_get_patches_for_fill\u001b[39m.\u001b[39;49mget_next_color)\n\u001b[1;32m 4520\u001b[0m \u001b[39mif\u001b[39;00m plotnonfinite \u001b[39mand\u001b[39;00m colors \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m 4521\u001b[0m c \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mma\u001b[39m.\u001b[39mmasked_invalid(c)\n", "File \u001b[0;32m/usr/lib/python3.10/site-packages/matplotlib/axes/_axes.py:4359\u001b[0m, in \u001b[0;36mAxes._parse_scatter_color_args\u001b[0;34m(c, edgecolors, kwargs, xsize, get_next_color_func)\u001b[0m\n\u001b[1;32m 4356\u001b[0m \u001b[39mraise\u001b[39;00m invalid_shape_exception(c\u001b[39m.\u001b[39msize, xsize) \u001b[39mfrom\u001b[39;00m \u001b[39merr\u001b[39;00m\n\u001b[1;32m 4357\u001b[0m \u001b[39m# Both the mapping *and* the RGBA conversion failed: pretty\u001b[39;00m\n\u001b[1;32m 4358\u001b[0m \u001b[39m# severe failure => one may appreciate a verbose feedback.\u001b[39;00m\n\u001b[0;32m-> 4359\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[1;32m 4360\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m'\u001b[39m\u001b[39mc\u001b[39m\u001b[39m'\u001b[39m\u001b[39m argument must be a color, a sequence of colors, \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m 4361\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mor a sequence of numbers, not \u001b[39m\u001b[39m{\u001b[39;00mc\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m) \u001b[39mfrom\u001b[39;00m \u001b[39merr\u001b[39;00m\n\u001b[1;32m 4362\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 4363\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mlen\u001b[39m(colors) \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m (\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m, xsize):\n\u001b[1;32m 4364\u001b[0m \u001b[39m# NB: remember that a single color is also acceptable.\u001b[39;00m\n\u001b[1;32m 4365\u001b[0m \u001b[39m# Besides *colors* will be an empty array if c == 'none'.\u001b[39;00m\n", "\u001b[0;31mValueError\u001b[0m: 'c' argument must be a color, a sequence of colors, or a sequence of numbers, not decoding\n0 5.648858e-10\n1 8.865429e-01\n2 8.865876e-01\n3 8.864820e-01\n4 8.867152e-01\n.. ...\n641 8.865732e-01\n642 8.861918e-01\n643 8.865706e-01\n644 8.865345e-01\n645 8.863632e-01\n\n[646 rows x 1 columns]" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.scatter(param_corr[:, 0], param_corr[:, 1], c=param, cmap='RdBu')" ] }, { "cell_type": "code", "execution_count": 67, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 67, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.scatter(param_corr[:, 1], param)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/lib/python3.10/site-packages/seaborn/distributions.py:2619: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n", " warnings.warn(msg, FutureWarning)\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAGdCAYAAADzOWwgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAABJKklEQVR4nO3de1xUdf4/8NdcmBluMwjCAAFK3im1NMPZbmvxFY22i7qb5aaV2epi39Svaf62r7XWZlvfMruotZXYt+zifs1KSyO8VeKNQk0TbyQmDKDIDNcBZj6/P4Y5OooXEDgzc17Px2MewjmfOfP+qDO8+JzP5xyVEEKAiIiISMHUchdAREREJDcGIiIiIlI8BiIiIiJSPAYiIiIiUjwGIiIiIlI8BiIiIiJSPAYiIiIiUjwGIiIiIlI8rdwF+AOXy4Xi4mKEh4dDpVLJXQ4RERFdAiEEqqqqEB8fD7X6wmNADESXoLi4GImJiXKXQURERG1w7NgxJCQkXLANA9ElCA8PB+D+CzUajTJXQ0RERJfCbrcjMTFR+jl+IQxEl8BzmsxoNDIQERER+ZlLme7CSdVERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHhauQsgIpLb8m1FF9x/f2pSJ1VCRHLhCBEREREpHgMRERERKR4DERERESkeAxEREREpnqyBqHv37lCpVOc8MjMzAQD19fXIzMxEVFQUwsLCMHr0aJSWlnodo6ioCBkZGQgJCUFMTAyeeOIJNDU1ebXZuHEjBg0aBL1ej549eyIrK6uzukhERER+QNZAtGPHDpSUlEiP7OxsAMAf//hHAMD06dPx5ZdfYsWKFdi0aROKi4sxatQo6flOpxMZGRloaGjAli1bsGzZMmRlZWHu3LlSm8LCQmRkZGDYsGHIz8/HtGnT8Mgjj2DdunWd21kiIiLyWSohhJC7CI9p06Zh9erVOHjwIOx2O6Kjo7F8+XKMGTMGALB//37069cPubm5GDp0KL7++mvccccdKC4uhtlsBgAsWbIEs2fPRnl5OXQ6HWbPno01a9bg559/ll5n7NixqKysxNq1ay+pLrvdDpPJBJvNBqPR2P4dJyJZcdk9UWBqzc9vn5lD1NDQgA8++AAPP/wwVCoV8vLy0NjYiLS0NKlN3759kZSUhNzcXABAbm4u+vfvL4UhAEhPT4fdbsfevXulNmcew9PGc4yWOBwO2O12rwcREREFLp8JRKtWrUJlZSUefPBBAIDVaoVOp0NERIRXO7PZDKvVKrU5Mwx59nv2XaiN3W5HXV1di7XMnz8fJpNJeiQmJl5u94iIiMiH+UwgevfddzFy5EjEx8fLXQrmzJkDm80mPY4dOyZ3SURERNSBfOLWHUePHsW3336LlStXSttiY2PR0NCAyspKr1Gi0tJSxMbGSm22b9/udSzPKrQz25y9Mq20tBRGoxHBwcEt1qPX66HX6y+7X0REROQffGKEaOnSpYiJiUFGRoa0bfDgwQgKCkJOTo60raCgAEVFRbBYLAAAi8WCPXv2oKysTGqTnZ0No9GIlJQUqc2Zx/C08RyDiIiISPZA5HK5sHTpUkyYMAFa7ekBK5PJhIkTJ2LGjBnYsGED8vLy8NBDD8FisWDo0KEAgOHDhyMlJQUPPPAAdu3ahXXr1uGpp55CZmamNMIzefJkHDlyBLNmzcL+/fuxaNEifPrpp5g+fbos/SUiIiLfI/sps2+//RZFRUV4+OGHz9m3YMECqNVqjB49Gg6HA+np6Vi0aJG0X6PRYPXq1ZgyZQosFgtCQ0MxYcIEzJs3T2qTnJyMNWvWYPr06Vi4cCESEhLwzjvvID09vVP6R0RERL7Pp65D5Kt4HSKiwMbrEBEFJr+8DhERERGRXBiIiIiISPEYiIiIiEjxGIiIiIhI8RiIiIiISPEYiIiIiEjxGIiIiIhI8RiIiIiISPEYiIiIiEjxGIiIiIhI8RiIiIiISPEYiIiIiEjxGIiIiIhI8RiIiIiISPEYiIiIiEjxGIiIiIhI8RiIiIiISPEYiIiIiEjxGIiIiIhI8RiIiIiISPEYiIiIiEjxGIiIiIhI8RiIiIiISPEYiIiIiEjxGIiIiIhI8RiIiIiISPEYiIiIiEjxGIiIiIhI8RiIiIiISPEYiIiIiEjxGIiIiIhI8RiIiIiISPEYiIiIiEjxGIiIiIhI8RiIiIiISPEYiIiIiEjxGIiIiIhI8RiIiIiISPFkD0THjx/Hn//8Z0RFRSE4OBj9+/fHzp07pf1CCMydOxdxcXEIDg5GWloaDh486HWMiooKjBs3DkajEREREZg4cSKqq6u92uzevRs33XQTDAYDEhMT8eKLL3ZK/4iIiMj3yRqITp06hRtuuAFBQUH4+uuvsW/fPrz88svo0qWL1ObFF1/Ea6+9hiVLlmDbtm0IDQ1Feno66uvrpTbjxo3D3r17kZ2djdWrV2Pz5s149NFHpf12ux3Dhw9Ht27dkJeXh5deegnPPPMM3n777U7tLxEREfkmlRBCyPXiTz75JH744Qd89913Le4XQiA+Ph7/9V//hZkzZwIAbDYbzGYzsrKyMHbsWPzyyy9ISUnBjh07cN111wEA1q5di9tvvx2//fYb4uPjsXjxYvztb3+D1WqFTqeTXnvVqlXYv3//Reu02+0wmUyw2WwwGo3t1Hsi8hXLtxVdcP/9qUmdVAkRtafW/PyWdYToiy++wHXXXYc//vGPiImJwbXXXot//etf0v7CwkJYrVakpaVJ20wmE1JTU5GbmwsAyM3NRUREhBSGACAtLQ1qtRrbtm2T2tx8881SGAKA9PR0FBQU4NSpU+fU5XA4YLfbvR5EREQUuGQNREeOHMHixYvRq1cvrFu3DlOmTMF//ud/YtmyZQAAq9UKADCbzV7PM5vN0j6r1YqYmBiv/VqtFpGRkV5tWjrGma9xpvnz58NkMkmPxMTEdugtERER+SpZA5HL5cKgQYPw/PPP49prr8Wjjz6KSZMmYcmSJXKWhTlz5sBms0mPY8eOyVoPERERdSxZA1FcXBxSUlK8tvXr1w9FRe7z+bGxsQCA0tJSrzalpaXSvtjYWJSVlXntb2pqQkVFhVeblo5x5mucSa/Xw2g0ej2IiIgocMkaiG644QYUFBR4bTtw4AC6desGAEhOTkZsbCxycnKk/Xa7Hdu2bYPFYgEAWCwWVFZWIi8vT2qzfv16uFwupKamSm02b96MxsZGqU12djb69OnjtaKNiIiIlEnWQDR9+nRs3boVzz//PA4dOoTly5fj7bffRmZmJgBApVJh2rRpeO655/DFF19gz549GD9+POLj43H33XcDcI8ojRgxApMmTcL27dvxww8/YOrUqRg7dizi4+MBAPfffz90Oh0mTpyIvXv34pNPPsHChQsxY8YMubpOREREPkQr54sPGTIEn332GebMmYN58+YhOTkZr776KsaNGye1mTVrFmpqavDoo4+isrISN954I9auXQuDwSC1+fDDDzF16lTcdtttUKvVGD16NF577TVpv8lkwjfffIPMzEwMHjwYXbt2xdy5c72uVURERETKJet1iPwFr0NEFNh4HSKiwOQ31yEiIiIi8gUMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4sgaiZ555BiqVyuvRt29faX99fT0yMzMRFRWFsLAwjB49GqWlpV7HKCoqQkZGBkJCQhATE4MnnngCTU1NXm02btyIQYMGQa/Xo2fPnsjKyuqM7hEREZGfkH2E6KqrrkJJSYn0+P7776V906dPx5dffokVK1Zg06ZNKC4uxqhRo6T9TqcTGRkZaGhowJYtW7Bs2TJkZWVh7ty5UpvCwkJkZGRg2LBhyM/Px7Rp0/DII49g3bp1ndpPIiIi8l1a2QvQahEbG3vOdpvNhnfffRfLly/HrbfeCgBYunQp+vXrh61bt2Lo0KH45ptvsG/fPnz77bcwm8245ppr8Oyzz2L27Nl45plnoNPpsGTJEiQnJ+Pll18GAPTr1w/ff/89FixYgPT09E7tKxEREfkm2UeIDh48iPj4eFx55ZUYN24cioqKAAB5eXlobGxEWlqa1LZv375ISkpCbm4uACA3Nxf9+/eH2WyW2qSnp8Nut2Pv3r1SmzOP4WnjOUZLHA4H7Ha714OIiIgCl6yBKDU1FVlZWVi7di0WL16MwsJC3HTTTaiqqoLVaoVOp0NERITXc8xmM6xWKwDAarV6hSHPfs++C7Wx2+2oq6trsa758+fDZDJJj8TExPboLhEREfkoWU+ZjRw5Uvp6wIABSE1NRbdu3fDpp58iODhYtrrmzJmDGTNmSN/b7XaGIiIiogAm+ymzM0VERKB37944dOgQYmNj0dDQgMrKSq82paWl0pyj2NjYc1adeb6/WBuj0Xje0KXX62E0Gr0eREREFLh8KhBVV1fj8OHDiIuLw+DBgxEUFIScnBxpf0FBAYqKimCxWAAAFosFe/bsQVlZmdQmOzsbRqMRKSkpUpszj+Fp4zkGERERkayBaObMmdi0aRN+/fVXbNmyBffccw80Gg3uu+8+mEwmTJw4ETNmzMCGDRuQl5eHhx56CBaLBUOHDgUADB8+HCkpKXjggQewa9curFu3Dk899RQyMzOh1+sBAJMnT8aRI0cwa9Ys7N+/H4sWLcKnn36K6dOny9l1IiIi8iGyziH67bffcN999+HkyZOIjo7GjTfeiK1btyI6OhoAsGDBAqjVaowePRoOhwPp6elYtGiR9HyNRoPVq1djypQpsFgsCA0NxYQJEzBv3jypTXJyMtasWYPp06dj4cKFSEhIwDvvvMMl90RERCRRCSGE3EX4OrvdDpPJBJvNxvlERAFo+baiC+6/PzWpkyohovbUmp/fPjWHiIiIiEgODERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHgMRERERKR4DERERESkeAxEREREpHhtCkRHjhxp7zqIiIiIZNOmQNSzZ08MGzYMH3zwAerr69u7JiIiIqJO1aZA9OOPP2LAgAGYMWMGYmNj8Ze//AXbt29v79qIiIiIOkWbAtE111yDhQsXori4GO+99x5KSkpw44034uqrr8Yrr7yC8vLy9q6TiIiIqMNc1qRqrVaLUaNGYcWKFfjnP/+JQ4cOYebMmUhMTMT48eNRUlLSXnUSERERdZjLCkQ7d+7EX//6V8TFxeGVV17BzJkzcfjwYWRnZ6O4uBh33XVXe9VJRERE1GG0bXnSK6+8gqVLl6KgoAC333473n//fdx+++1Qq935Kjk5GVlZWejevXt71kpERETUIdoUiBYvXoyHH34YDz74IOLi4lpsExMTg3ffffeyiiMiIiLqDG06ZZadnY3Zs2efE4aEECgqKgIA6HQ6TJgw4ZKP+cILL0ClUmHatGnStvr6emRmZiIqKgphYWEYPXo0SktLvZ5XVFSEjIwMhISEICYmBk888QSampq82mzcuBGDBg2CXq9Hz549kZWV1boOExERUUBrUyDq0aMHTpw4cc72iooKJCcnt/p4O3bswFtvvYUBAwZ4bZ8+fTq+/PJLrFixAps2bUJxcTFGjRol7Xc6ncjIyEBDQwO2bNmCZcuWISsrC3PnzpXaFBYWIiMjA8OGDUN+fj6mTZuGRx55BOvWrWt1nURERBSY2hSIhBAtbq+urobBYGjVsaqrqzFu3Dj861//QpcuXaTtNpsN7777Ll555RXceuutGDx4MJYuXYotW7Zg69atAIBvvvkG+/btwwcffIBrrrkGI0eOxLPPPos333wTDQ0NAIAlS5YgOTkZL7/8Mvr164epU6dizJgxWLBgQVu6TkRERAGoVXOIZsyYAQBQqVSYO3cuQkJCpH1OpxPbtm3DNddc06oCMjMzkZGRgbS0NDz33HPS9ry8PDQ2NiItLU3a1rdvXyQlJSE3NxdDhw5Fbm4u+vfvD7PZLLVJT0/HlClTsHfvXlx77bXIzc31OoanzZmn5s7mcDjgcDik7+12e6v6RERERP6lVYHop59+AuAeIdqzZw90Op20T6fTYeDAgZg5c+YlH+/jjz/Gjz/+iB07dpyzz2q1QqfTISIiwmu72WyG1WqV2pwZhjz7Pfsu1MZut6Ourg7BwcHnvPb8+fPx97///ZL7QURERP6tVYFow4YNAICHHnoICxcuhNFobPMLHzt2DI8//jiys7NbfZqto82ZM0caDQPcI0SJiYkyVkREREQdqU1ziJYuXXpZYQhwnxIrKyvDoEGDoNVqodVqsWnTJrz22mvQarUwm81oaGhAZWWl1/NKS0sRGxsLAIiNjT1n1Znn+4u1MRqNLY4OAYBer4fRaPR6EBERUeC65BGiUaNGISsrC0aj0WulV0tWrlx50ePddttt2LNnj9e2hx56CH379sXs2bORmJiIoKAg5OTkYPTo0QCAgoICFBUVwWKxAAAsFgv+8Y9/oKysDDExMQDclwQwGo1ISUmR2nz11Vder5OdnS0dg4iIiOiSA5HJZIJKpZK+vlzh4eG4+uqrvbaFhoYiKipK2j5x4kTMmDEDkZGRMBqNeOyxx2CxWDB06FAAwPDhw5GSkoIHHngAL774IqxWK5566ilkZmZCr9cDACZPnow33ngDs2bNwsMPP4z169fj008/xZo1ay67D0RERBQYLjkQLV26tMWvO9KCBQugVqsxevRoOBwOpKenY9GiRdJ+jUaD1atXY8qUKbBYLAgNDcWECRMwb948qU1ycjLWrFmD6dOnY+HChUhISMA777yD9PT0TukDERER+T6VON9FhS6grq4OQghp2f3Ro0fx2WefISUlBcOHD2/3IuVmt9thMplgs9k4n4goAC3fVnTB/fenJnVSJUTUnlrz87tNk6rvuusuvP/++wCAyspKXH/99Xj55Zdx1113YfHixW05JBEREZFs2hSIfvzxR9x0000AgH//+9+IjY3F0aNH8f777+O1115r1wKJiIiIOlqbAlFtbS3Cw8MBuG+fMWrUKKjVagwdOhRHjx5t1wKJiIiIOlqbAlHPnj2xatUqHDt2DOvWrZPmDZWVlXGODREREfmdNgWiuXPnYubMmejevTtSU1Ola/p88803uPbaa9u1QCIiIqKO1qpbd3iMGTMGN954I0pKSjBw4EBp+2233YZ77rmn3YojIiIi6gxtCkSA+5YYnttjeFx//fWXXRARERFRZ2tTIKqpqcELL7yAnJwclJWVweVyee0/cuRIuxRHRERE1BnaFIgeeeQRbNq0CQ888ADi4uKkW3oQERER+aM2BaKvv/4aa9aswQ033NDe9RARERF1ujatMuvSpQsiIyPbuxYiIiIiWbQpED377LOYO3cuamtr27seIiIiok7XplNmL7/8Mg4fPgyz2Yzu3bsjKCjIa/+PP/7YLsURERERdYY2BaK77767ncsgIiIikk+bAtHTTz/d3nUQERERyaZNc4gAoLKyEu+88w7mzJmDiooKAO5TZcePH2+34oiIiIg6Q5tGiHbv3o20tDSYTCb8+uuvmDRpEiIjI7Fy5UoUFRXh/fffb+86iYiIiDpMm0aIZsyYgQcffBAHDx6EwWCQtt9+++3YvHlzuxVHRERE1BnaFIh27NiBv/zlL+dsv+KKK2C1Wi+7KCIiIqLO1KZApNfrYbfbz9l+4MABREdHX3ZRRERERJ2pTYHozjvvxLx589DY2AgAUKlUKCoqwuzZszF69Oh2LZCIiIioo6mEEKK1T7LZbBgzZgx27NiB6upqxMfHw2q1wmKx4KuvvkJoaGhH1Cobu90Ok8kEm80Go9EodzlE1M6Wbyu6rOffn5rUTpUQUXtqzc/vNq0yM5lMyM7Oxg8//IBdu3ahuroagwYNQlpaWpsKJiIiIpJTqwORy+VCVlYWVq5ciV9//RUqlQrJycmIjY2FEAIqlaoj6iQiIiLqMK2aQySEwJ133olHHnkEx48fR//+/XHVVVfh6NGjePDBB3HPPfd0VJ1EREREHaZVI0RZWVnYvHkzcnJyMGzYMK9969evx9133433338f48ePb9ciiYiIiDpSq0aIPvroI/y///f/zglDAHDrrbfiySefxIcffthuxRERERF1hlYFot27d2PEiBHn3T9y5Ejs2rXrsosiIiIi6kytCkQVFRUwm83n3W82m3Hq1KnLLoqIiIioM7UqEDmdTmi15592pNFo0NTUdNlFEREREXWmVk2qFkLgwQcfhF6vb3G/w+Fol6KIiIiIOlOrAtGECRMu2oYrzIiIiMjftCoQLV26tKPqICLyGU1OF8qqHDAEaRAZqpO7HCLqBG26dQcRUSCqa3Dik51FOFRWDZcAgjQqPHZrL3QNa3maABEFjjbd7Z6IKBB9d6gcB0rdYUitAhqdAl/vKZG7LCLqBAxERERwjw7lHj4JAPjTdYn4z9t6Qa0CfrFW4WBZlczVEVFHYyAiIgKQe+QkHE0uxITrMSDBhJhwAyxXRgEA1uwugdMlZK6QiDoSAxERKZ6j0YkfDp0AAAzrEwO1SgUAuLWvGSE6DcqqHPj5uE3OEomog8kaiBYvXowBAwbAaDTCaDTCYrHg66+/lvbX19cjMzMTUVFRCAsLw+jRo1FaWup1jKKiImRkZCAkJAQxMTF44oknzrk45MaNGzFo0CDo9Xr07NkTWVlZndE9IvITeUWnUNfoRFSoDv0TTNL2YJ0GQ7pHAgAKSnnajCiQyRqIEhIS8MILLyAvLw87d+7Erbfeirvuugt79+4FAEyfPh1ffvklVqxYgU2bNqG4uBijRo2Snu90OpGRkYGGhgZs2bIFy5YtQ1ZWFubOnSu1KSwsREZGBoYNG4b8/HxMmzYNjzzyCNatW9fp/SUi31RgdYed1ORIaXTIo7c5HABwoLQKLsHTZkSBSiWEb73DIyMj8dJLL2HMmDGIjo7G8uXLMWbMGADA/v370a9fP+Tm5mLo0KH4+uuvcccdd6C4uFi6x9qSJUswe/ZslJeXQ6fTYfbs2VizZg1+/vln6TXGjh2LyspKrF279pJqstvtMJlMsNlsMBqN7d9pIpJNfaMTVz+9Dk0ugcdv6wWz0eC13+kSeG7NPjiaXPjr73sgoUvIOce4PzWps8ololZozc9vn5lD5HQ68fHHH6OmpgYWiwV5eXlobGxEWlqa1KZv375ISkpCbm4uACA3Nxf9+/f3uuFseno67Ha7NMqUm5vrdQxPG88xWuJwOGC3270eRBSYdv56Ck0uAaNBi5jwc683pFGr0CM6DIB7lIiIApPsgWjPnj0ICwuDXq/H5MmT8dlnnyElJQVWqxU6nQ4RERFe7c1mM6xWKwDAarV6hSHPfs++C7Wx2+2oq6trsab58+fDZDJJj8TExPboKhH5oO8OlQMAekSHQXXW6TKPPtJps+pOq4uIOpfsgahPnz7Iz8/Htm3bMGXKFEyYMAH79u2TtaY5c+bAZrNJj2PHjslaDxF1nO8PuleX9TKHnbeNZ9+xilrUNTg7pS4i6lyy37pDp9OhZ8+eAIDBgwdjx44dWLhwIe699140NDSgsrLSa5SotLQUsbGxAIDY2Fhs377d63ieVWhntjl7ZVppaSmMRiOCg4NbrEmv10Ov56X6iQLdyWoH9ha7T4l7Tou1JCJEh5hwPcqqHDhUXo3+V5jO25aI/JPsI0Rnc7lccDgcGDx4MIKCgpCTkyPtKygoQFFRESwWCwDAYrFgz549KCsrk9pkZ2fDaDQiJSVFanPmMTxtPMcgIuX6vvnaQ7FGA8INQRds61ltdpDziIgCkqwjRHPmzMHIkSORlJSEqqoqLF++HBs3bsS6detgMpkwceJEzJgxA5GRkTAajXjsscdgsVgwdOhQAMDw4cORkpKCBx54AC+++CKsViueeuopZGZmSiM8kydPxhtvvIFZs2bh4Ycfxvr16/Hpp59izZo1cnadiHyA53RZz5jzjw55dI8KwfeHgOOVLc89JCL/JmsgKisrw/jx41FSUgKTyYQBAwZg3bp1+I//+A8AwIIFC6BWqzF69Gg4HA6kp6dj0aJF0vM1Gg1Wr16NKVOmwGKxIDQ0FBMmTMC8efOkNsnJyVizZg2mT5+OhQsXIiEhAe+88w7S09M7vb9E5Ft2Hj0FAOgRHXrRtvER7lPspfZ6NDpdCNL43AA7EV0Gn7sOkS/idYiIAo+9vhEDnvkGAPC32/shVH/h3w+FEPjHV7+gtsF5zvWIeB0iIt/kl9chIiLqTHuPuydTXxERfNEwBAAqlQpXNI8S8bQZUeBhICIiRdpzvBIAWrVizHParJiBiCjgMBARkSLtaR4hOvNmrhdzOhDVd0hNRCQfBiIiUqSfj9sAAFe3YoTIc8rMaq9Hk8vVIXURkTwYiIhIcez1jSg8UQOgdafMuoQEIThIA6dLoMzu6KjyiEgGDEREpDie0aErIoIRGaq75OepVCrERxgAcGI1UaBhICIixfEEogGtmD/kwYnVRIGJgYiIFMczobo184c8uPSeKDAxEBGR4nhGiNpyk9Y40+krVrt4XVuigMFARESKUu1okiZUt2WEKDJUB41ahUangK22sb3LIyKZMBARkaIcaL5bvdmob9WEag+NWoWuYe7nlVXxekREgYKBiIgU5YDVHYh6m8PbfIzocPdKs7IqLr0nChQMRESkKAXNI0R9LiMQxYTrAQDlDEREAYOBiIgU5WBpNYDLGyHyBCKOEBEFDgYiIlIUzwhR79jLOWXmCUT1EFxpRhQQGIiISDEqahqk01y9YsLafJyuYXqoANQ3ulDlaGqn6ohITgxERKQYnhVmiZHBCNVr23ycII1aWqHGeUREgYGBiIgU46DndFlM20+XeXAeEVFgYSAiIsVoj/lDHtLSezuvRUQUCBiIiEgxDljdK8wuZ8m9B5feEwUWBiIiUgQhBA6UuUeIepnbPqHaI8bIQEQUSBiIiEgRyqscqKxthFoF9Ii+/EAUHeYORFWOJt7TjCgAMBARkSJ45g91jwqFIUhz2cfTB2lgCg4CABwqr77s4xGRvBiIiEgRDpW5Q0t7nC7ziGpeev/riZp2OyYRyYOBiIgUwROIel7GBRnPFtV82uzXkwxERP6OgYiIFMETiNpj/pBH1zD3CFEhR4iI/B4DEREpwuHy9h8h6soRIqKAwUBERAGvsrYBJ6obALTvCNHpOUS1vMkrkZ9jICKigOcZHYo3GS7rHmZniwzVQQWg2tGE8mpej4jInzEQEVHAk+YPtePpMgDQatSICHEvvf/1RG27HpuIOhcDEREFvI6YUO0hrTTjxGoiv8ZAREQBryOW3HtIK804sZrIrzEQEVHAO1zuDisdEYiiQjlCRBQIGIiIKKDVNzpx7JR7fk+HjhAxEBH5NQYiIgpoR8prIARgCg6Slsm3pzOvVu1ycek9kb9iICKigHbojAsyqlSqdj9+lxAdNGoV6htdKK2qb/fjE1HnYCAiooB22DOhugNWmAGARq1CUmQIAJ42I/JnDEREFNAOdcAtO87WPcodiHgtIiL/JWsgmj9/PoYMGYLw8HDExMTg7rvvRkFBgVeb+vp6ZGZmIioqCmFhYRg9ejRKS0u92hQVFSEjIwMhISGIiYnBE088gaamJq82GzduxKBBg6DX69GzZ09kZWV1dPeIyAd4RoiOnarF8m1FLT4uV/euoQB4TzMifyZrINq0aRMyMzOxdetWZGdno7GxEcOHD0dNzekPlenTp+PLL7/EihUrsGnTJhQXF2PUqFHSfqfTiYyMDDQ0NGDLli1YtmwZsrKyMHfuXKlNYWEhMjIyMGzYMOTn52PatGl45JFHsG7duk7tLxF1LqdL4EjzaayYcEOHvU5ycyA6Us5AROSvVMKH7khYXl6OmJgYbNq0CTfffDNsNhuio6OxfPlyjBkzBgCwf/9+9OvXD7m5uRg6dCi+/vpr3HHHHSguLobZbAYALFmyBLNnz0Z5eTl0Oh1mz56NNWvW4Oeff5Zea+zYsaisrMTatWsvWpfdbofJZILNZoPRaOyYzhNRuzt6sga3vLQReq0a/31HCtQdMKkaABK6BGP8e9vRMyYM3864pUNeg4harzU/v31qDpHNZgMAREZGAgDy8vLQ2NiItLQ0qU3fvn2RlJSE3NxcAEBubi769+8vhSEASE9Ph91ux969e6U2Zx7D08ZzjLM5HA7Y7XavBxH5H88Vqq+MDuuwMAScHiEqOlkLJ5feE/klnwlELpcL06ZNww033ICrr74aAGC1WqHT6RAREeHV1mw2w2q1Sm3ODEOe/Z59F2pjt9tRV1d3Ti3z58+HyWSSHomJie3SRyLqXKfvYRbaoa8THxEMnUaNBqcLxZXnfqYQke/zmUCUmZmJn3/+GR9//LHcpWDOnDmw2WzS49ixY3KXRERt0JH3MDuTRq1CkmelGSdWE/klnwhEU6dOxerVq7FhwwYkJCRI22NjY9HQ0IDKykqv9qWlpYiNjZXanL3qzPP9xdoYjUYEBwefU49er4fRaPR6EJH/6Ywl9x7do9yjULwWEZF/kjUQCSEwdepUfPbZZ1i/fj2Sk5O99g8ePBhBQUHIycmRthUUFKCoqAgWiwUAYLFYsGfPHpSVlUltsrOzYTQakZKSIrU58xieNp5jEFHgEUKcvihjJwSi5K68OCORP5M1EGVmZuKDDz7A8uXLER4eDqvVCqvVKs3rMZlMmDhxImbMmIENGzYgLy8PDz30ECwWC4YOHQoAGD58OFJSUvDAAw9g165dWLduHZ566ilkZmZCr3ffY2jy5Mk4cuQIZs2ahf3792PRokX49NNPMX36dNn6TkQdq7zaAXt9E9Sq06M3HUm6FhEDEZFfkjUQLV68GDabDb///e8RFxcnPT755BOpzYIFC3DHHXdg9OjRuPnmmxEbG4uVK1dK+zUaDVavXg2NRgOLxYI///nPGD9+PObNmye1SU5Oxpo1a5CdnY2BAwfi5ZdfxjvvvIP09PRO7S8RdR7P/KHEyBAYgjQd/nrJ0sUZebVqIn+klfPFL+USSAaDAW+++SbefPPN87bp1q0bvvrqqwse5/e//z1++umnVtdIRP6po+9hdjZPIDpWUYtGpwtBGp+YoklEl4jvWCIKSIebrxrdGfOHAMAcboAhSI0ml8Bvp7j0nsjfMBARUUCSrkHUSYFIrVZJc5U4j4jI/zAQEVFAOlhWBQDo0UmnzAAuvSfyZwxERBRwbHWNKLU7AAC9zJ0XiJKjedd7In/FQEREAedgqXt0KM5kgNEQ1Gmvm8wRIiK/xUBERAHnQKl7/lAvc3invq50LSKOEBH5HQYiIgo4nvlDvTtpQrVH9+arVR8/VQdHk7NTX5uILg8DEREFnIPNI0S9O3mEKDpMj1CdBi7hvh4REfkPBiIiCjgHmucQdeaEagBQqVTSxOrCEwxERP6EgYiIAoqtthFlVZ4VZp07QgSA1yIi8lMMREQUUA40zx+6IiIYYfrOvzuR5xYehZxYTeRXGIiIKKDIdbrMQ7o4YzkDEZE/YSAiooDimVDdq5NXmHlw6T2Rf2IgIqKAcnqEqPPnDwHAlc2BqMRWj7oGLr0n8hcMREQUUA7ItOTeo0uoDqZg99Wxj1ZwlIjIXzAQEVHAOFXTgBPVzSvMZDplBpxx2owrzYj8BgMREQWMX6x2AEBiZDBCZVhh5pEc5b5i9REGIiK/wUBERAHjlxL3/KF+sUZZ6+AIEZH/YSAiooDxS4l7hCglXt5AlCwFIl6tmshfMBARUcDYV+wORP3ifCMQ8eKMRP6DgYiIAkKj04VDZe4VZik+EojKqxyw1zfKWgsRXRoGIiIKCIfLq9HgdCFcr0VCl2BZawk3BMFs1AOAFNKIyLcxEBFRQPDMH+obFw6VSiVzNUDP5mX/DERE/oGBiIgCgrTCTObTZR49o92B6DADEZFfYCAiooAgrTDzlUDUfKVsjhAR+QcGIiLye0IIn1lh5uEZITrIQETkFxiIiMjvlVc5cLKmAWoV0CdWnnuYnc0zh+jYqVrUN/Imr0S+joGIiPzevubTZcldQ2EI0shcjVvXMPdNXoUAjpTzekREvo6BiIj83s/HbQCAq+JNMldymkqlOr3SrJynzYh8HQMREfm9/GPuQDQwMULeQs7imUfEidVEvo+BiIj8mhACu36rBAAMTPCdESLg9DwiLr0n8n0MRETk16z2epRXOaBRq3zqlBnAizMS+RMGIiLya7uOVQIA+pjDEazzjQnVHp5AdORENZqcLpmrIaILYSAiIr/mq/OHAOCKiGAYgtRodAoUVdTKXQ4RXQADERH5td0+On8IANTq0yvNDpRWyVwNEV0IAxER+S2XS2D3b747QgQA/WLdV87eV8JAROTLGIiIyG8dOVGNakcTgoM06NU8EuNr+jbfSsRzrzUi8k0MRETktzzzh/pfYYJW45sfZ/3i3LcS2W9lICLyZbJ+gmzevBl/+MMfEB8fD5VKhVWrVnntF0Jg7ty5iIuLQ3BwMNLS0nDw4EGvNhUVFRg3bhyMRiMiIiIwceJEVFd7L3HdvXs3brrpJhgMBiQmJuLFF1/s6K4RUSfwrDAb4IPzhzxSmkeIjlXUoaq+UeZqiOh8ZA1ENTU1GDhwIN58880W97/44ot47bXXsGTJEmzbtg2hoaFIT09HfX291GbcuHHYu3cvsrOzsXr1amzevBmPPvqotN9ut2P48OHo1q0b8vLy8NJLL+GZZ57B22+/3eH9I6KOtb2wAgAwuFsXmSs5v4gQHeJMBgDAfivnERH5Kq2cLz5y5EiMHDmyxX1CCLz66qt46qmncNdddwEA3n//fZjNZqxatQpjx47FL7/8grVr12LHjh247rrrAACvv/46br/9dvzP//wP4uPj8eGHH6KhoQHvvfcedDodrrrqKuTn5+OVV17xCk5E5F8qahpQ0Lxy6/rkSJmrubB+cUaU2OrxS4kdQ7r7dq1ESuWbJ90BFBYWwmq1Ii0tTdpmMpmQmpqK3NxcAEBubi4iIiKkMAQAaWlpUKvV2LZtm9Tm5ptvhk6nk9qkp6ejoKAAp06davG1HQ4H7Ha714OIfMv2wpMAgN7mMESF6WWu5sI884g4sZrId/lsILJarQAAs9nstd1sNkv7rFYrYmJivPZrtVpERkZ6tWnpGGe+xtnmz58Pk8kkPRITEy+/Q0TUrrYecZ8uS02OkrmSi+sb61lpxlNmRL7KZwORnObMmQObzSY9jh07JndJRHSWbc3zh1Kv9P1TUP2aJ1YXWKvgdAmZqyGilvhsIIqNjQUAlJaWem0vLS2V9sXGxqKsrMxrf1NTEyoqKrzatHSMM1/jbHq9Hkaj0etBRL6jsrZBWsbu6/OHACC5aygMQWrUNTpx9GSN3OUQUQt8NhAlJycjNjYWOTk50ja73Y5t27bBYrEAACwWCyorK5GXlye1Wb9+PVwuF1JTU6U2mzdvRmPj6eWu2dnZ6NOnD7p08d2VKUR0ftsLKyAE0CM6FDHhBrnLuSiNWoU+Zs88Ip42I/JFsgai6upq5OfnIz8/H4B7InV+fj6KioqgUqkwbdo0PPfcc/jiiy+wZ88ejB8/HvHx8bj77rsBAP369cOIESMwadIkbN++HT/88AOmTp2KsWPHIj4+HgBw//33Q6fTYeLEidi7dy8++eQTLFy4EDNmzJCp10R0uaT5Q1f6/vwhD89ps73FNpkrIaKWyLrsfufOnRg2bJj0vSekTJgwAVlZWZg1axZqamrw6KOPorKyEjfeeCPWrl0Lg+H0b4Qffvghpk6dittuuw1qtRqjR4/Ga6+9Ju03mUz45ptvkJmZicGDB6Nr166YO3cul9wT+bFtzSvMUv3gdJnHwMQIfLzjGPKbLyZJRL5FJYTgDL+LsNvtMJlMsNlsnE9EJLMyez2uf959Kn3732675FNmy7cVdVhN96cmXbTNfqsdI179DqE6DXY/kw6NWtVh9RCRW2t+fvvsHCIiopZsKHAvpBiYYPKL+UMevWLCEarToKbBiUNl1Rd/AhF1KgYiIvIrOb+4A9Gtfc0XaelbNGoVBiREAAB+Kmr5orBEJB8GIiLyG/WNTnx38AQA4LZ+MRdp7XuuTYoAAPxUVClrHUR0LgYiIvIbW4+cRF2jE2ajHlfF+998vmuT3Jf6+OkYR4iIfA0DERH5jfX7T58uU6n8b1LyNYkRAICDZdWoqm+8cGMi6lQMRETkF4QQ0vyh2/r63+kyAIgO1yOhSzCEAHb/xusREfkSBiIi8gt7i+04XlkHvVaNG3p2lbucNpNOm3FiNZFPYSAiIr+w6qfjANyTqYN1Gpmrabtrm0+b/ciJ1UQ+RdYrVRMRXYompwur8osBAPdcm9Bim4688GJ7GtLdfXXt7YUVaHK6oNXw91IiX8B3IhH5vO8PncCJage6hAThlt7RcpdzWVLijYgICUK1owm7fquUuxwiasZAREQ+b+WP7tNldw6Mh07r3x9bGrUKN/Rwz4HyXFOJiOTn358sRBTwquob8c0+KwDgnkEtny7zNzf2cgeiHw4xEBH5CgYiIvJpa3aXoL7RhSujQzEwwSR3Oe3ixuZVcj8VVaLa0SRzNUQEMBARkQ8TQuDd7wsBAPdel+iXF2NsSWJkCLpFhaDJJbD18Em5yyEiMBARkQ/beKAcB8uqEabX4r7UJLnLaVeeUaLvedqMyCcwEBGRz/rX5iMAgHuHJMJoCJK5mvZ1Uy8GIiJfwkBERD7p5+M2bDl8Ehq1Cg/d0F3uctqd5cqu0KhVOFRWjV9P1MhdDpHiMRARkU9avOkwACCjfxwSuoTIXE37M4UE4Xc9ogAAq3cXy1wNETEQEZHP+bHoFNbsLoFKBUy+pYfc5XSYPwyMBwB8uatE5kqIiLfuoHNc6BYI9wfYxFbyPUIIPLd6HwBgzKAEpMQbpX3+cnuOS5V+VSz+9tkeFJRW4UBpFXqbw+UuiUixOEJERD7lqz1W/FhUieAgDWam95G7nA5lCj59K5LVu3jajEhODERE5DOqHU14/qtfAAB/ueVKmI0GmSvqeNJps90lEELIXA2RcvGUGRH5jOdW78PxyjpcERGMR2++Uu5yLtnlnGa+rZ8Zeq0ahSdqsOe4DQMSItq5OiK6FAxEROQTsveV4uMdx6ACcHv/OKz6SRmnkML0WqRfFYsvdhUj64df8cq918hdEpEi8ZQZEcnOaqvHk/+3G4D7xqfJXUNlrqhzTbwxGQDwxa5iWG31MldDpEwMREQkqxpHEyYu24GTNQ2INRrwH/3McpfU6QYmRuD67pFocglkbflV7nKIFImBiIhk43QJPP5xPvYW2xEVqsOfh3aDVqPMj6VHbnKPEi3fdhQ1jiaZqyFSHmV+8hCR7Jwugdn/txvf/lIKnVaNt8dfh8hQndxlySatnxnJXUNhr2/CR9sD63pLRP6AgYiIOl2j04XHP/4J/877DWoVsOBP12Bwty5ylyUrtVqFybe4V9YtzDmI8iqHzBURKQsDERF1KlttIx5ZthOrd5cgSKPCm/cPQsaAOLnL8gljBidiQIIJVfVNmP/1L3KXQ6QoDERE1Gn2W+24883vselAOfRaNd56YDBG9mcY8tCoVXj2rquhUgErfzyO7YUVcpdEpBgMRETU4Zwugbc2Hcadb/yAoydrcUVEMP5vyu9wa1/lrSi7mIGJERg7xH0xx9n/txu2ukaZKyJSBgYiIupQPxadwqjFWzD/6/1oaHLhlt7R+PKxG3H1FSa5S/NZs0f0QbzJgMITNXjso5/Q5HTJXRJRwOOVqomoXXluY1Fqr0fO/jL8fNwGADAEqTHvzqvxx+sSoFKp5CyxU13oth5Ay7f2iAjR4V8TrsOYxbnYfKAc//jqF8y9I0VRf2/UPi7ntjJKw0BERO3G6RI4UFqF3MMnUVBaBQBQARiU1AX/kWLGn4YkylugH7kq3oRX/jQQUz78EUt/+BUNTS78/c6rFHudJqKOxkCkYLa6RuwvsePYqTocP1UHe30j6hudOFBaDYNWDX2QBl1CghAVpofZqIdeq5G7ZPJBTpfAj0WnkL2vFJ/nH0ep3b1cXAUgJd6IW/vGIM4ULG+Rfmpk/zjMu+sqPP3FXny4rQgltnos+NM1MIUEyV0aUcBhIFIQW20jvj90ApsPlGNr4UkcPVl7yc9VAYgzGbDfasfgbl0wuFsXJHQJ6bhiyWedqmnAgdIq7C22Y1vhSWwvrMCp2tMTf4ODNLgmMQK/6xGFqDC913MvdvpIiS52SmO8pTtiwg14/OOfsH5/GW57ZROe/kMK7hgQx1NoRO1IJYQQchfh6+x2O0wmE2w2G4xGo9zlXDKnS2D3b5XYdKAcmw+UI/9YJVxn/WtfERGMK6NDEW8KRpdQHQxBauw5bkNDowu1DU5U1DbgZLUD9vpzbyXQLSoEN/Tsiht7dsXvekQhIkS5Vxn2d0II1DU6UdvgRK3DCXt9I8qrHCirqkeZ3YHSqnoUnqhBgbUaJ6rPvWCg0aDFsL4xGHFVLMqrHDyt007OnOOx61gl/mvFLhwqqwYAXJsUgb/c3AP/kWKGRs1gRC1T+hyi1vz8VlQgevPNN/HSSy/BarVi4MCBeP3113H99ddf9Hn+FIh+O1WLLYdPYvOBcnx/6AQqa72X7PaMCcPNvaJxU++uuCYhAl1auFVCS28gW10jiipqERykQV7RKfx83AbnGelKpQL6X2HCDT27YuiVURhwhanFY1P7aHK6UO1ogr2uCfb6RtjrG1FV34Tq+ibUNjShtsGJmgYn6hqamv90osbRhLpG95/FlfVocLrQ0OR+NDpdaM0HQUKXYPQxh2Nw9y5ITY7EgIQIBDWHII4CtZ+zf2A5mpxYsvEI3tx4CA1N7pVncSYDbu8fhxFXx2JgQgR0WoZROu1870eXEBiXmhTwo4wMRC345JNPMH78eCxZsgSpqal49dVXsWLFChQUFCAmJuaCz/XVQORocqLwRA3yjp7CjsIKbC+sQLGt3qtNuEGLG3t2xc29o3Fz72hcEXHxuRyX8htFVX0jthdW4PtDJ/DDoRM4UFp9TtukyBAMSDBhQIIJyV3DkBQZgsTIYITolH2mtqHJhRpHE6odTahpaEKNowlV9e6HJ9jY6xq9vj57X02Ds8Pq02nU0GvVCDNoEW7QwmgIQrhBiy4hOpiNBky9tSdC9ef/N2Qgaj/n+w2+vMqBZVt+xf9uPep1naLgIA2uTYpA31gjesaEoZc5DD2jw3zmlxOXS6DB6YJLCGjUKgSp1VBzdOuyCSFgr2tCaVU9Su31KLWfHt3d8WsFqurdvyQ1en4JcrrgdAmoVECQRg29Rg2dVo0QvQZRoXp0DdMhKlSPqDAdYsL1MBsNMJsMiDUaEB2ul3758QcMRC1ITU3FkCFD8MYbbwAAXC4XEhMT8dhjj+HJJ5+84HM7OxAJ4f7QqG9wSaesTlQ7UF7dgOLKOhwqq8bhsmocraj1GqUB3Fe6vfoKE27p5Q5B1yRGtPr0RVuGWEvt9dhy+AS+O3gCPxVVovBEzXmPERWqQ6zJAFNwEEzBQTAagmAM1kKv1bg/JDUqaNTq5j9V0KpV0uiFEO6/H9H8NYDmr0//PQgBCIjmP8/ddrqdOOsY3m1E8xNbOobTJeBoHllxP9z/Zo1NZ33vdKGuwekOP44m1DicaGjHa8oEaVQIDtLA0PzQa90fbHqt2v1Bp1UjSKuGrvkDT3fGNr2m+U+tBkEaFfRaDbQaFdQX+Y3xYsPsDETt52J/18u2/IqDpdXYc7wSB8uqUXueoBym17p/yIW5f9hFhuoQHKSFIUgNQ5AGwUEaqNUqCCHgdAm4hHsEwdX8daPTJY0oOppcKLDa0eQSaHK62ze5XGhyNX/tFAjRa6TRR8/7oqH5fXE2tQrQqtXQNr/fnS53WNKo3N9r1CpoNSpo1Wpo1CokRoY0/39Wnf5/rVVDp9Gc8bVK+v+u02qgVZ8+luczxXNcjVotvZZW473/9Nfq089Rq6A+8xjNdXm2t4cmpws1zaeubWf8QmSvc39fVuWA1VYPq90TgOpR39g516pSqYCoUD1iTXrEGg2IMbqDUqzRgMhQHcINWvcvU/oghBm0CNNrZR21ZCA6S0NDA0JCQvDvf/8bd999t7R9woQJqKysxOeff+7V3uFwwOE4PU/CZrMhKSkJx44da9dAVF5Vj7/8bx7qG52ob3TB0eSEo/kD51L/VcL0GqTEmTCoeaLzgATTBX97vxSf7jx23n1/uu7Cy6Y9z61vcKLYVo+SyloU2xw4Vetonpty7lwkpdJp1dCqAb3W/UHuCTWG5q/1QWoYtO6QYwjSwKDTwKBp3t78g4y/XZOHEAInqhpw7FQtTlQ5cKLGgRqHEyVnjRpTx/IEI40aUKtUUKkAjcr9i4ZaBaia/1SrVHAJd4BsbA6UTU6gyXXpn/9nMwVrERNuQNdwPWLC9YgO0+P4qVqEGYIQotdC1/yLZpBWBa1GjTsGxJ0OrU4XquubUFHbiFM1DahofnhGmsqqHCivcqDp7Imol8AdVN0jglLI1Jz+3hMsI8OCsOTP17Wt8+dht9uRmJiIyspKmEwXvhisIs5dnDhxAk6nE2az920CzGYz9u/ff077+fPn4+9///s52xMTffMaKr8A+L9Oeq1JnfQ6RETUOuf/VbZl0zqiiMv0UWbHHLeqqoqBqC3mzJmDGTNmSN+7XC5UVFQgKipKERPQEhMT2300zB+w7+y70voOKLv/7Hvg910IgaqqKsTHx1+0rSICUdeuXaHRaFBaWuq1vbS0FLGxsee01+v10Ou9r58SERHRkSX6HKPRGNBvkgth39l3JVJy/9n3wO77xUaGPPxnqvhl0Ol0GDx4MHJycqRtLpcLOTk5sFgsMlZGREREvkARI0QAMGPGDEyYMAHXXXcdrr/+erz66quoqanBQw89JHdpREREJDPFBKJ7770X5eXlmDt3LqxWK6655hqsXbv2nInWSqfX6/H000+fc8pQCdh39l2JlNx/9l2ZfT8fRSy7JyIiIroQRcwhIiIiIroQBiIiIiJSPAYiIiIiUjwGIiIiIlI8BiI/9uabb6J79+4wGAxITU3F9u3bL9j+1VdfRZ8+fRAcHIzExERMnz4d9fWn73PkdDrx3//930hOTkZwcDB69OiBZ5991uvGqQ8++CBUKpXXY8SIEV6vU1FRgXHjxsFoNCIiIgITJ05EdXV1+3Yevtv/7t27n9PmhRde8Pu+A8Avv/yCO++8EyaTCaGhoRgyZAiKik7fzLW+vh6ZmZmIiopCWFgYRo8efc4FUQO177///e/P+XefPHmy3/f97D55Hi+99JLUJpDf85fS/0B9z1dXV2Pq1KlISEhAcHAwUlJSsGTJEq/X6Yz3fKcR5Jc+/vhjodPpxHvvvSf27t0rJk2aJCIiIkRpaWmL7T/88EOh1+vFhx9+KAoLC8W6detEXFycmD59utTmH//4h4iKihKrV68WhYWFYsWKFSIsLEwsXLhQajNhwgQxYsQIUVJSIj0qKiq8XmvEiBFi4MCBYuvWreK7774TPXv2FPfdd59i+t+tWzcxb948rzbV1dV+3/dDhw6JyMhI8cQTT4gff/xRHDp0SHz++ederzt58mSRmJgocnJyxM6dO8XQoUPF7373O0X0/ZZbbhGTJk3y+ne32Wx+3/cz+1NSUiLee+89oVKpxOHDh6U2gfyev5T+B+p7ftKkSaJHjx5iw4YNorCwULz11ltCo9GIzz//XGrT0e/5zsRA5Keuv/56kZmZKX3vdDpFfHy8mD9/fovtMzMzxa233uq1bcaMGeKGG26Qvs/IyBAPP/ywV5tRo0aJcePGSd9PmDBB3HXXXeeta9++fQKA2LFjh7Tt66+/FiqVShw/fvyS+nYpfLX/Qrg/HBcsWHCJPWk9ufp+7733ij//+c/nrauyslIEBQWJFStWSNt++eUXAUDk5uZeWucuwlf7LoQ7ED3++OOX2pVWk6vvZ7vrrru8jhvo7/mznd1/IQL3PX/VVVeJefPmebUZNGiQ+Nvf/iaE6Jz3fGfiKTM/1NDQgLy8PKSlpUnb1Go10tLSkJub2+Jzfve73yEvL08aZj1y5Ai++uor3H777V5tcnJycODAAQDArl278P3332PkyJFex9q4cSNiYmLQp08fTJkyBSdPnpT25ebmIiIiAtddd520LS0tDWq1Gtu2bbv8zsO3++/xwgsvICoqCtdeey1eeuklNDU1XXa/Afn67nK5sGbNGvTu3Rvp6emIiYlBamoqVq1aJR0jLy8PjY2NXrX17dsXSUlJ560tUPru8eGHH6Jr1664+uqrMWfOHNTW1l52v+Xs+9lKS0uxZs0aTJw4UdqmhPe8R0v99wi097ynzRdffIHjx49DCIENGzbgwIEDGD58OICOf893OrkTGbXe8ePHBQCxZcsWr+1PPPGEuP7668/7vIULF4qgoCCh1WoFADF58mSv/U6nU8yePVuoVCqh1WqFSqUSzz//vFebjz76SHz++edi9+7d4rPPPhP9+vUTQ4YMEU1NTUII9zBs7969z3nt6OhosWjRorZ22Ysv918IIV5++WWxYcMGsWvXLrF48WIRERHhNVR9OeTqe0lJiQAgQkJCxCuvvCJ++uknMX/+fKFSqcTGjRuFEO5hep1Od85rDxkyRMyaNetyui2E8O2+CyHEW2+9JdauXSt2794tPvjgA3HFFVeIe+6557L7LWffz/bPf/5TdOnSRdTV1UnbAv09f6aW+i9EYL7nhRCivr5ejB8/XgAQWq1W6HQ6sWzZMml/R7/nOxsDkR9qyxtkw4YNwmw2i3/9619i9+7dYuXKlSIxMdFrOPSjjz4SCQkJ4qOPPhK7d+8W77//voiMjBRZWVnnreXw4cMCgPj222+FEL774dhZ/W/Ju+++K7Raraivr29lT88lV989r3v2vJA//OEPYuzYsUII3wxEndX3luTk5AgA4tChQ23tssRX/s/36dNHTJ061Wubkt7zLfW/JYHwnhdCiJdeekn07t1bfPHFF2LXrl3i9ddfF2FhYSI7O1sIwUBEPsDhcAiNRiM+++wzr+3jx48Xd955Z4vPufHGG8XMmTO9tv3v//6vCA4OFk6nUwghREJCgnjjjTe82jz77LOiT58+F6yna9euYsmSJUII9wdBRESE1/7Gxkah0WjEypUrL9q3S+HL/W/Jzz//LACI/fv3X/A4l0KuvjscDqHVasWzzz7r1WbWrFnSBEpPADh16pRXm6SkJPHKK6+0qp8t8eW+t6S6uloAEGvXrr2k/l2IL/yf37x5swAg8vPzvbYr5T1/vv63JBDe87W1tSIoKEisXr3aq83EiRNFenq6EKLj3/OdjXOI/JBOp8PgwYORk5MjbXO5XMjJyYHFYmnxObW1tVCrvf+5NRoNAEjLLM/XxuVynbeW3377DSdPnkRcXBwAwGKxoLKyEnl5eVKb9evXw+VyITU1tRW9PD9f7n9L8vPzoVarERMTc+GOXQK5+q7T6TBkyBAUFBR4tTlw4AC6desGABg8eDCCgoK8aisoKEBRUdF5a2sNX+57S/Lz8wHggv83LpUv/J9/9913MXjwYAwcONBru1Le8+frf0sC4T3f2NiIxsbGC7bp6Pd8p5MxjNFl+Pjjj4VerxdZWVli37594tFHHxURERHCarUKIYR44IEHxJNPPim1f/rpp0V4eLj46KOPxJEjR8Q333wjevToIf70pz9JbSZMmCCuuOIKaRnmypUrRdeuXaWhz6qqKjFz5kyRm5srCgsLxbfffisGDRokevXq5TU0PGLECHHttdeKbdu2ie+//1706tWrQ5bg+mL/t2zZIhYsWCDy8/PF4cOHxQcffCCio6PF+PHj/brvQgixcuVKERQUJN5++21x8OBB8frrrwuNRiO+++47qc3kyZNFUlKSWL9+vdi5c6ewWCzCYrEEfN8PHTok5s2bJ3bu3CkKCwvF559/Lq688kpx8803+33fhRDCZrOJkJAQsXjx4hZrC9T3/KX0P5Df87fccou46qqrxIYNG8SRI0fE0qVLhcFg8DoV2tHv+c7EQOTHXn/9dZGUlCR0Op24/vrrxdatW6V9t9xyi5gwYYL0fWNjo3jmmWdEjx49hMFgEImJieKvf/2r11Cn3W4Xjz/+uEhKShIGg0FceeWV4m9/+5twOBxCCPcQ6vDhw0V0dLQICgoS3bp1E5MmTZLelB4nT54U9913nwgLCxNGo1E89NBDoqqqShH9z8vLE6mpqcJkMgmDwSD69esnnn/++XaZSyBn3z3effdd0bNnT2EwGMTAgQPFqlWrvPbX1dWJv/71r6JLly4iJCRE3HPPPaKkpCTg+15UVCRuvvlmERkZKfR6vejZs6d44okn2vU6RHL2/a233hLBwcGisrKyxboC9T3vcaH+B/J7vqSkRDz44IMiPj5eGAwG0adPH/Hyyy8Ll8sltemM93xnUQlx1uVYiYiIiBSGc4iIiIhI8RiIiIiISPEYiIiIiEjxGIiIiIhI8RiIiIiISPEYiIiIiEjxGIiIiIhI8RiIiIiISPEYiIiIiEjxGIiIiIhI8RiIiIiISPEYiIiIiEjx/j/Su+VR1ZfF7AAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "sns.distplot(param.clip(0.885, 0.888))" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3.10.5 64-bit", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.5" }, "orig_nbformat": 4, "vscode": { "interpreter": { "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a" } } }, "nbformat": 4, "nbformat_minor": 2 }