{ "cells": [ { "cell_type": "markdown", "id": "168173a0-7826-407b-9d23-3295b98e36e3", "metadata": {}, "source": [ "# Informative distances and summary statistics" ] }, { "cell_type": "markdown", "id": "2c2a72cb-7ef4-49a0-bea6-159a41ede8d1", "metadata": {}, "source": [ "Approximate Bayesian computation (ABC) relies on the efficient comparison of relevant features in simulated and observed data, via distance metrics and potentially summary statistics. Separately, methods have been developed to adaptively scale-normalize the distance metric, and to semi-automatically derive informative, low-dimensional summary statistics.\n", "\n", "In the notebook on \"Adaptive distances\" we demonstrated how distances adjusting weights to normalize scales are beneficial for heterogeneous, including outlier-corrupted, data. However, when parts of the data are uninformative, it is desirable to further concentrate the analysis on informative data points. Various methods have been developed to capture information of data on parameters in a low-dimensional summary statistics representation, see e.g. [Blum et al. 2013](https://doi.org/10.1214/12-STS406) for a review. A particular approach constructs summary statistics as outputs of regression models of parameters on data, see the similar work by [Fearnhead and Prangle 2012](https://doi.org/10.1111/j.1467-9868.2011.01010.x). In this notebook, we illustrate the use of regression methods to construct informative summary statistics and sensitivity distance weights in pyABC." ] }, { "cell_type": "raw", "id": "e57d2012-08c7-4c34-af75-5f0c9d0ba1cb", "metadata": { "raw_mimetype": "text/restructuredtext", "tags": [] }, "source": [ "The notebook can be downloaded :download:`here `." ] }, { "cell_type": "code", "execution_count": 1, "id": "df5d57e9-6819-4d6a-bdbb-8639f315602a", "metadata": {}, "outputs": [], "source": [ "# install if not done yet\n", "!pip install pyabc[plotly] --quiet" ] }, { "cell_type": "code", "execution_count": 2, "id": "b349ef1d-50b0-47cb-b1e5-90c2f9f8ed75", "metadata": {}, "outputs": [], "source": [ "import logging\n", "import tempfile\n", "from functools import partial\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import scipy as sp\n", "from IPython.display import SVG, display\n", "\n", "import pyabc\n", "from pyabc.distance import *\n", "from pyabc.predictor import *\n", "from pyabc.sumstat import *\n", "from pyabc.util import EventIxs, ParTrafo, dict2arrlabels\n", "\n", "pyabc.settings.set_figure_params(\"pyabc\") # for beautified plots\n", "\n", "# for debugging\n", "for logger in [\"ABC.Distance\", \"ABC.Predictor\", \"ABC.Sumstat\"]:\n", " logging.getLogger(logger).setLevel(logging.DEBUG)" ] }, { "cell_type": "markdown", "id": "e9282480-7216-407d-99c0-cff5143d34cd", "metadata": {}, "source": [ "## Simple illustration example" ] }, { "cell_type": "markdown", "id": "fe411468-d16f-4460-9866-bbe47b13527a", "metadata": {}, "source": [ "To illustrate informativeness of data points, we consider a simple test problem. It consists of a single model output $y_1$ informative of parameter $p_1$, and uninformative model outputs $y_2$." ] }, { "cell_type": "code", "execution_count": 3, "id": "0c4b0043-ec4e-4f49-8112-c4916bdb452e", "metadata": {}, "outputs": [], "source": [ "# problem definition\n", "\n", "sigmas = {\"p1\": 0.1}\n", "\n", "\n", "def model(p):\n", " return {\n", " \"y1\": p[\"p1\"] + 1 + sigmas[\"p1\"] * np.random.normal(),\n", " \"y2\": 2 + 0.1 * np.random.normal(size=3),\n", " }\n", "\n", "\n", "gt_par = {\"p1\": 3}\n", "\n", "data = {\"y1\": gt_par[\"p1\"] + 1, \"y2\": 2 * np.ones(shape=3)}\n", "\n", "prior_bounds = {\"p1\": (0, 10)}\n", "\n", "prior = pyabc.Distribution(\n", " **{\n", " key: pyabc.RV(\"uniform\", lb, ub - lb)\n", " for key, (lb, ub) in prior_bounds.items()\n", " },\n", ")" ] }, { "cell_type": "markdown", "id": "97a1f495-c928-47ea-8a21-30b8bca993eb", "metadata": {}, "source": [ "We employ three approaches to perform inference on this problem.\n", "\n", "Firstly, we use a distance adaptively scale-normalizing all statistics by their respective in-sample median absolute deviations (MAD), as introduced in the \"Adaptive distances\" notebook (\"L1+Ada.+MAD\").\n", "\n", "Secondly, we employ an approach similar to [Fearnhead and Prangle 2012](https://doi.org/10.1111/j.1467-9868.2011.01010.x), using a linear regression model, trained after 40% of the total sample budget, as summary statistic, with a simple L1 distance (\"L1+StatLR\").\n", "\n", "Thirdly, we complement the MAD scale-normalizing weights by sensitivity weights, derived via normalized sensitivities of a linear regression model trained similarly to the second approach. This method thus accounts for informativeness by re-weighting of model outputs, without explicitly employing a low-dimensional summary statistics representation." ] }, { "cell_type": "raw", "id": "47ae3e1b-53e6-4883-90fb-8c1164652ada", "metadata": { "raw_mimetype": "text/restructuredtext", "tags": [] }, "source": [ "The approaches use as distance a :class:`PNormDistance `, :class:`AdaptivePNormDistance ` for scale normalization, or :class:`InfoWeightedPNormDistance ` additionally defining regression-based sensitivity weights. Regression models are derived from the basic :class:`Predictor ` class in the corresponding module. Summary statistics that can be combined with all above distances are derived from the :class:`Sumstat ` class, in particular regression-based ones via :class:`PredictorSumstat `." ] }, { "cell_type": "code", "execution_count": 4, "id": "230f8e13-5584-4084-892b-8e7bb1cd64ba", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "ABC.Distance DEBUG: Fit scale ixs: \n", "ABC.Sumstat DEBUG: Fit model ixs: \n", "ABC.Distance DEBUG: Fit scale ixs: \n", "ABC.Distance DEBUG: Fit info ixs: \n" ] } ], "source": [ "# analysis definition\n", "\n", "pop_size = 100\n", "total_sims = 3000\n", "fit_sims = 0.4 * total_sims\n", "\n", "YPredictor = LinearPredictor\n", "# YPredictor = MLPPredictor\n", "\n", "distances = {\n", " \"L1+Ada.+MAD\": AdaptivePNormDistance(\n", " p=1,\n", " # adaptive scale normalization\n", " scale_function=mad,\n", " ),\n", " \"L1+StatLR\": PNormDistance(\n", " p=1,\n", " # regression-based summary statistics\n", " sumstat=PredictorSumstat(\n", " # regression model used\n", " predictor=YPredictor(),\n", " # when to fit the regression model\n", " fit_ixs=EventIxs(sims=fit_sims),\n", " ),\n", " ),\n", " \"L1+Ada.+MAD+SensiLR\": InfoWeightedPNormDistance(\n", " p=1,\n", " # adaptive scale normalization\n", " scale_function=mad,\n", " # regression model used to define sensitivity weights\n", " predictor=YPredictor(),\n", " # when to fit the regression model\n", " fit_info_ixs=EventIxs(sims=fit_sims),\n", " ),\n", "}\n", "\n", "colors = {distance_id: f\"C{i}\" for i, distance_id in enumerate(distances)}" ] }, { "cell_type": "markdown", "id": "b44ae7da-0c67-40be-8e3a-bc53ec249a0f", "metadata": {}, "source": [ "We perform the analysis using all above distance functions and summary statistics. Additionally, below we specify various logging files to capture relevant information for further analysis." ] }, { "cell_type": "code", "execution_count": 5, "id": "c341b9a1-5696-4f9d-8b17-1d9aae08342d", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "ABC.Sampler INFO: Parallelize sampling on 4 processes.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "L1+Ada.+MAD\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "ABC.History INFO: Start \n", "ABC INFO: Calibration sample t = -1.\n", "ABC.Distance DEBUG: Scale weights[0] = {'y1': 4.1696e-01, 'y2:0': 1.4194e+01, 'y2:1': 1.4542e+01, 'y2:2': 1.1623e+01}\n", "ABC.Population INFO: Recording also rejected particles: True\n", "ABC INFO: t: 0, eps: 4.62946034e+00.\n", "ABC INFO: Accepted: 100 / 189 = 5.2910e-01, ESS: 1.0000e+02.\n", "ABC.Distance DEBUG: Scale weights[1] = {'y1': 4.1132e-01, 'y2:0': 1.5028e+01, 'y2:1': 1.2665e+01, 'y2:2': 1.5191e+01}\n", "ABC INFO: t: 1, eps: 3.50413868e+00.\n", "ABC INFO: Accepted: 100 / 360 = 2.7778e-01, ESS: 8.7731e+01.\n", "ABC.Distance DEBUG: Scale weights[2] = {'y1': 5.5391e-01, 'y2:0': 1.4445e+01, 'y2:1': 1.4380e+01, 'y2:2': 1.3888e+01}\n", "ABC INFO: t: 2, eps: 3.07090591e+00.\n", "ABC INFO: Accepted: 100 / 459 = 2.1786e-01, ESS: 9.1323e+01.\n", "ABC.Distance DEBUG: Scale weights[3] = {'y1': 5.7254e-01, 'y2:0': 1.4952e+01, 'y2:1': 1.4680e+01, 'y2:2': 1.3888e+01}\n", "ABC INFO: t: 3, eps: 2.59302288e+00.\n", "ABC INFO: Accepted: 100 / 522 = 1.9157e-01, ESS: 9.1287e+01.\n", "ABC.Distance DEBUG: Scale weights[4] = {'y1': 8.7880e-01, 'y2:0': 1.5887e+01, 'y2:1': 1.5671e+01, 'y2:2': 1.6205e+01}\n", "ABC INFO: t: 4, eps: 2.60156160e+00.\n", "ABC INFO: Accepted: 100 / 1035 = 9.6618e-02, ESS: 8.0667e+01.\n", "ABC.Distance DEBUG: Scale weights[5] = {'y1': 1.1388e+00, 'y2:0': 1.5340e+01, 'y2:1': 1.5152e+01, 'y2:2': 1.5268e+01}\n", "ABC INFO: t: 5, eps: 2.28604105e+00.\n", "ABC INFO: Accepted: 100 / 1206 = 8.2919e-02, ESS: 9.3241e+01.\n", "ABC.Distance DEBUG: Scale weights[6] = {'y1': 1.3174e+00, 'y2:0': 1.5479e+01, 'y2:1': 1.5188e+01, 'y2:2': 1.5372e+01}\n", "ABC INFO: Stop: Total simulations budget.\n", "ABC.History INFO: Done \n", "ABC.Sampler INFO: Parallelize sampling on 4 processes.\n", "ABC.History INFO: Start \n", "ABC INFO: Calibration sample t = -1.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "L1+StatLR\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "ABC.Population INFO: Recording also rejected particles: True\n", "ABC INFO: t: 0, eps: 2.94366175e+00.\n", "ABC INFO: Accepted: 100 / 203 = 4.9261e-01, ESS: 1.0000e+02.\n", "ABC INFO: t: 1, eps: 1.66536767e+00.\n", "ABC INFO: Accepted: 100 / 175 = 5.7143e-01, ESS: 9.9290e+01.\n", "ABC INFO: t: 2, eps: 1.01567662e+00.\n", "ABC INFO: Accepted: 100 / 193 = 5.1813e-01, ESS: 9.9368e+01.\n", "ABC INFO: t: 3, eps: 6.20967359e-01.\n", "ABC INFO: Accepted: 100 / 226 = 4.4248e-01, ESS: 9.9646e+01.\n", "ABC INFO: t: 4, eps: 3.85565817e-01.\n", "ABC INFO: Accepted: 100 / 259 = 3.8610e-01, ESS: 9.5384e+01.\n", "ABC INFO: t: 5, eps: 2.94100337e-01.\n", "ABC INFO: Accepted: 100 / 417 = 2.3981e-01, ESS: 9.7841e+01.\n", "ABC.Predictor INFO: Fitted in 0.00s\n", "ABC.Predictor INFO: Pearson correlations: 0.898\n", "ABC.Predictor DEBUG: Linear regression coefficients (n_target, n_feature):\n", "[[ 0.89692715 0.00324766 -0.001746 -0.02353367]]\n", "ABC INFO: t: 6, eps: 2.27047591e-01.\n", "ABC INFO: Accepted: 100 / 404 = 2.4752e-01, ESS: 9.4596e+01.\n", "ABC INFO: t: 7, eps: 1.26808917e-01.\n", "ABC INFO: Accepted: 100 / 571 = 1.7513e-01, ESS: 7.7628e+01.\n", "ABC INFO: t: 8, eps: 7.37053186e-02.\n", "ABC INFO: Accepted: 100 / 933 = 1.0718e-01, ESS: 7.5607e+01.\n", "ABC INFO: Stop: Total simulations budget.\n", "ABC.History INFO: Done \n", "ABC.Sampler INFO: Parallelize sampling on 4 processes.\n", "ABC.History INFO: Start \n", "ABC INFO: Calibration sample t = -1.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "L1+Ada.+MAD+SensiLR\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "ABC.Distance DEBUG: Scale weights[0] = {'y1': 3.8736e-01, 'y2:0': 1.3394e+01, 'y2:1': 1.5512e+01, 'y2:2': 1.9479e+01}\n", "ABC.Population INFO: Recording also rejected particles: True\n", "ABC.Population INFO: Recording also rejected particles: True\n", "ABC INFO: t: 0, eps: 4.60879843e+00.\n", "ABC INFO: Accepted: 100 / 222 = 4.5045e-01, ESS: 1.0000e+02.\n", "ABC.Distance DEBUG: Scale weights[1] = {'y1': 3.9304e-01, 'y2:0': 1.4688e+01, 'y2:1': 1.4903e+01, 'y2:2': 1.4876e+01}\n", "ABC INFO: t: 1, eps: 3.22709995e+00.\n", "ABC INFO: Accepted: 100 / 443 = 2.2573e-01, ESS: 9.5363e+01.\n", "ABC.Distance DEBUG: Scale weights[2] = {'y1': 5.2186e-01, 'y2:0': 1.4188e+01, 'y2:1': 1.4905e+01, 'y2:2': 1.3964e+01}\n", "ABC INFO: t: 2, eps: 2.70962535e+00.\n", "ABC INFO: Accepted: 100 / 550 = 1.8182e-01, ESS: 9.1834e+01.\n", "ABC.Distance DEBUG: Scale weights[3] = {'y1': 7.2399e-01, 'y2:0': 1.3541e+01, 'y2:1': 1.4226e+01, 'y2:2': 1.4469e+01}\n", "ABC.Predictor INFO: Fitted in 0.00s\n", "ABC.Predictor INFO: Pearson correlations: 0.999\n", "ABC.Predictor DEBUG: Linear regression coefficients (n_target, n_feature):\n", "[[ 0.99835555 0.00106467 -0.00180873 0.00178089]]\n", "ABC.Distance DEBUG: Optimal FD delta: [0.1 0.1 0.1 0.1]\n", "ABC.Distance DEBUG: Info weights[3] = {'y1': 9.9563e-01, 'y2:0': 1.0150e-03, 'y2:1': 1.7085e-03, 'y2:2': 1.6436e-03}\n", "ABC INFO: t: 3, eps: 6.57635045e-01.\n", "ABC INFO: Accepted: 100 / 231 = 4.3290e-01, ESS: 9.9434e+01.\n", "ABC.Distance DEBUG: Scale weights[4] = {'y1': 9.5460e-01, 'y2:0': 1.4551e+01, 'y2:1': 1.6221e+01, 'y2:2': 1.4333e+01}\n", "ABC INFO: t: 4, eps: 4.73707012e-01.\n", "ABC INFO: Accepted: 100 / 176 = 5.6818e-01, ESS: 9.8122e+01.\n", "ABC.Distance DEBUG: Scale weights[5] = {'y1': 2.6570e+00, 'y2:0': 1.4511e+01, 'y2:1': 1.1904e+01, 'y2:2': 1.3900e+01}\n", "ABC INFO: t: 5, eps: 6.22117846e-01.\n", "ABC INFO: Accepted: 100 / 253 = 3.9526e-01, ESS: 9.9050e+01.\n", "ABC.Distance DEBUG: Scale weights[6] = {'y1': 3.6227e+00, 'y2:0': 1.6931e+01, 'y2:1': 1.5359e+01, 'y2:2': 1.6303e+01}\n", "ABC INFO: t: 6, eps: 4.70729296e-01.\n", "ABC INFO: Accepted: 100 / 256 = 3.9062e-01, ESS: 9.7525e+01.\n", "ABC.Distance DEBUG: Scale weights[7] = {'y1': 5.5853e+00, 'y2:0': 1.5594e+01, 'y2:1': 1.7064e+01, 'y2:2': 1.4924e+01}\n", "ABC INFO: t: 7, eps: 3.40709003e-01.\n", "ABC INFO: Accepted: 100 / 349 = 2.8653e-01, ESS: 8.1211e+01.\n", "ABC.Distance DEBUG: Scale weights[8] = {'y1': 9.2987e+00, 'y2:0': 1.4565e+01, 'y2:1': 1.4281e+01, 'y2:2': 1.4820e+01}\n", "ABC INFO: t: 8, eps: 2.65949576e-01.\n", "ABC INFO: Accepted: 100 / 708 = 1.4124e-01, ESS: 9.2487e+01.\n", "ABC.Distance DEBUG: Scale weights[9] = {'y1': 9.6240e+00, 'y2:0': 1.4199e+01, 'y2:1': 1.4983e+01, 'y2:2': 1.4280e+01}\n", "ABC INFO: Stop: Total simulations budget.\n", "ABC.History INFO: Done \n" ] } ], "source": [ "# runs\n", "\n", "db_file = tempfile.mkstemp(suffix=\".db\")[1]\n", "\n", "scale_log_file = tempfile.mkstemp()[1]\n", "info_log_file = tempfile.mkstemp()[1]\n", "info_sample_log_file = tempfile.mkstemp()[1]\n", "\n", "hs = []\n", "for distance_id, distance in distances.items():\n", " print(distance_id)\n", " if isinstance(distance, AdaptivePNormDistance):\n", " distance.scale_log_file = f\"{scale_log_file}_{distance_id}.json\"\n", " if isinstance(distance, InfoWeightedPNormDistance):\n", " distance.info_log_file = f\"{info_log_file}_{distance_id}.json\"\n", " distance.info_sample_log_file = f\"{info_sample_log_file}_{distance_id}\"\n", "\n", " abc = pyabc.ABCSMC(model, prior, distance, population_size=pop_size)\n", " h = abc.new(db=\"sqlite:///\" + db_file, observed_sum_stat=data)\n", " abc.run(max_total_nr_simulations=total_sims)\n", " hs.append(h)" ] }, { "cell_type": "markdown", "id": "4433f3fb-d582-46bc-a245-979ff04ad6ad", "metadata": {}, "source": [ "The comparison of the obtained posterior approximations with the true posterior reveals that L1+Ada.+MAD gave a worse fit compared to the other approaches. This is because it only applies scale-normalization, but does not account for informativeness of data, and thus spends a lot of time on fitting $y_2$." ] }, { "cell_type": "code", "execution_count": 6, "id": "933a4514-f9fd-4d6e-aeae-e16f5de8da2c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# plot ABC posterior approximations\n", "\n", "fig, axes = plt.subplots(ncols=len(prior_bounds), figsize=(6, 4))\n", "if len(prior_bounds) == 1:\n", " axes = [axes]\n", "\n", "# plot ground truth\n", "\n", "\n", "def unnorm_1d_normal_pdf(p, y_obs, sigma, p_to_y=None):\n", " \"\"\"Non-normalized 1-d normal density.\n", "\n", " Parameters\n", " ----------\n", " p: Parameter to evaluate at.\n", " y_obs: Observed data.\n", " sigma: Noise standard deviation.\n", " p_to_y: Function to deterministically transform p to simulated data.\n", "\n", " Returns\n", " -------\n", " pd: Probability density/densities at p.\n", " \"\"\"\n", " if p_to_y is None:\n", " p_to_y = lambda p: p\n", " y = p_to_y(p)\n", " pd = np.exp(-((y - y_obs) ** 2) / (2 * sigma**2))\n", " return pd\n", "\n", "\n", "for i_par, par in enumerate(gt_par.keys()):\n", " # define parameter-simulation transformation\n", " p_to_y = lambda p: p + 1\n", " # observed data corresponding to parameter\n", " y_obs = p_to_y(gt_par[par])\n", " # bounds\n", " xmin, xmax = prior_bounds[par]\n", " # standard deviation\n", " sigma = sigmas[par]\n", "\n", " # pdf as function of only p\n", " pdf = partial(\n", " unnorm_1d_normal_pdf,\n", " y_obs=y_obs,\n", " sigma=sigma,\n", " p_to_y=p_to_y,\n", " )\n", "\n", " # integrate density\n", " norm = sp.integrate.quad(pdf, xmin, xmax)[0]\n", "\n", " # plot density\n", " xs = np.linspace(xmin, xmax, 300)\n", " axes[i_par].plot(\n", " xs,\n", " pdf(xs) / norm,\n", " linestyle=\"dashed\",\n", " color=\"grey\",\n", " label=\"ground truth\",\n", " )\n", "\n", "# plot ABC approximations\n", "\n", "for i_par, par in enumerate(prior_bounds.keys()):\n", " for distance_id, h in zip(distances.keys(), hs):\n", " pyabc.visualization.plot_kde_1d_highlevel(\n", " h,\n", " x=par,\n", " xname=par,\n", " xmin=prior_bounds[par][0],\n", " xmax=prior_bounds[par][1],\n", " ax=axes[i_par],\n", " label=distance_id,\n", " numx=500,\n", " )\n", "\n", "# prettify\n", "for ax in axes[1:]:\n", " ax.set_ylabel(None)\n", "fig.tight_layout(rect=(0, 0.1, 1, 1))\n", "axes[-1].legend()" ] }, { "cell_type": "markdown", "id": "472ddc82-fae8-4661-83c7-d3c184547e5b", "metadata": {}, "source": [ "Via the log files, we can further examine the employed weights, firstly scale-normalizing weights based on MAD, and secondly sensitivity weights quantifying informativeness. Indeed, while both L1+Ada.+MAD and L1+Ada.+MAD+SensiLR assign large weights to $y_2$, the additional sensitivity weights employed by L1+Ada.+MAD+SensiLR counteract this by assigning a large weight to $y_1$." ] }, { "cell_type": "code", "execution_count": 7, "id": "024b2905-cb78-4850-9a6b-37335032daed", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# plot weights\n", "\n", "fig, axes = plt.subplots(nrows=2, ncols=len(gt_par), figsize=(4, 8))\n", "\n", "# scale weights\n", "\n", "scale_distance_ids = [\n", " distance_id\n", " for distance_id in distances.keys()\n", " if \"Ada.\" in distance_id and \"Stat\" not in distance_id\n", "]\n", "scale_log_files = []\n", "for i_dist, distance_id in enumerate(scale_distance_ids):\n", " scale_log_files.append(f\"{scale_log_file}_{distance_id}.json\")\n", "\n", "pyabc.visualization.plot_distance_weights(\n", " scale_log_files,\n", " labels=scale_distance_ids,\n", " colors=[colors[distance_id] for distance_id in scale_distance_ids],\n", " xlabel=\"Model output\",\n", " title=\"Scale weights\",\n", " ax=axes[0],\n", " keys=dict2arrlabels(data, keys=data.keys()),\n", ")\n", "\n", "# info weights\n", "\n", "info_distance_ids = [\n", " distance_id for distance_id in distances.keys() if \"Sensi\" in distance_id\n", "]\n", "info_log_files = []\n", "for i_dist, distance_id in enumerate(info_distance_ids):\n", " info_log_files.append(f\"{info_log_file}_{distance_id}.json\")\n", "\n", "pyabc.visualization.plot_distance_weights(\n", " info_log_files,\n", " labels=info_distance_ids,\n", " colors=[colors[distance_id] for distance_id in info_distance_ids],\n", " xlabel=\"Model output\",\n", " title=\"Sensitivity weights\",\n", " ax=axes[1],\n", " keys=dict2arrlabels(data, keys=data.keys()),\n", ")\n", "\n", "fig.tight_layout()" ] }, { "cell_type": "markdown", "id": "06ed26e9-23b2-4493-9b6c-df5a623cc07d", "metadata": {}, "source": [ "To further understand the employed sensitivity matrix, we can visualize the connections between model outputs and parameters (in this case a single one) via a \"Sankey\" flow diagram. In this case, this gives no further information beyond the above weight diagram." ] }, { "cell_type": "code", "execution_count": 8, "id": "a821a491-5276-4f1c-bc7b-8b9c73ee98b4", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "ABC.Predictor INFO: Fitted in 0.00s\n", "ABC.Predictor INFO: Pearson correlations: 0.999\n", "ABC.Predictor DEBUG: Linear regression coefficients (n_target, n_feature):\n", "[[ 0.99835555 0.00106467 -0.00180873 0.00178089]]\n", "ABC.Distance DEBUG: Optimal FD delta: [0.1 0.1 0.1 0.1]\n" ] }, { "data": { "image/svg+xml": [ "y1y2:0y2:1y2:2p1Data-parameter sensitivities" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# plot flow diagram\n", "\n", "fig = pyabc.visualization.plot_sensitivity_sankey(\n", " info_sample_log_file=f\"{info_sample_log_file}_L1+Ada.+MAD+SensiLR\",\n", " t=f\"{info_log_file}_L1+Ada.+MAD+SensiLR.json\",\n", " h=hs[-1],\n", " predictor=LinearPredictor(),\n", ")\n", "\n", "# here just showing a non-interactive plot to reduce storage\n", "img_file = tempfile.mkstemp(suffix=(\".svg\"))[1]\n", "fig.write_image(img_file)\n", "display(SVG(img_file))" ] }, { "cell_type": "markdown", "id": "27e864e7-e44e-4f90-94e2-f6ab024d614b", "metadata": {}, "source": [ "## Challenging problem features" ] }, { "cell_type": "markdown", "id": "daec319b-b31c-46f2-bf2e-765dfa954b7e", "metadata": {}, "source": [ "Now, we turn to a slightly more challenging problem:\n", "\n", "* $y_1\\sim\\mathcal{N}(\\theta_1,0.1^2)$ is informative of $\\theta_1$, with a relatively wide corresponding prior $\\theta_1\\sim U[-7, 7]$,\n", "* $y_2\\sim\\mathcal{N}(\\theta_2,100^2)$ is informative of $\\theta_2$, with corresponding prior $\\theta_2\\sim U[-700, 700]$,\n", "* $y_3\\sim\\mathcal{N}(\\theta_3, 4 \\cdot 100^2)^{\\otimes 4}$ is a four-dimensional vector informative of $\\theta_3$, with corresponding prior $\\theta_3\\sim U[-700, 700]$,\n", "* $y_4\\sim\\mathcal{N}(\\theta_4^2, 0.1^2)$ is informative of $\\theta_4$, with corresponding symmetric prior $\\theta_4\\sim U[-1, 1]$, however is quadratic in the parameter, resulting in a bimodal posterior distribution for $y_{\\text{obs},4}\\neq 0$,\n", "* $y_5\\sim\\mathcal{N}(0, 10)^{\\otimes 10}$ is an uninformative 10-dimensional vector.\n", "\n", "The problem encompasses multiple challenging features established methods have problems with:\n", "\n", "* A substantial part of the data, $y_5$, is uninformative, such that approaches not accounting for informativeness of data may converge slower.\n", "* Both data and parameters are on different scales, such that approaches comparing data, or, via regression-based summary statistics, parameters, without normalization may be biased towards large-scale variables. Further, e.g. the prior of $\\theta_1$ is relatively wide, such that pre-calibrated weighting is sub-optimal, as discussed in \\citet{Prangle2017}.\n", "* $y_4$ is quadratic in $\\theta_4$ and symmetric over the prior, such that the inverse first-order regression approaches as in FearnheadPra2012} cannot capture a meaningful relationship.\n", "* While the distributions of $y_3$ and $y_4$ are such that the posterior distributions of $\\theta_3$, $\\theta_4$ are identical, in solely scale-normalized approaches such as [Fearnhead and Prangle 2012](https://doi.org/10.1111/j.1467-9868.2011.01010.x), the impact of $y_4$ on the distance value is roughly four times as high as that of $y_3$, leading to potentially uneven convergence." ] }, { "cell_type": "code", "execution_count": 9, "id": "597c5a35-8ef8-4357-b4dc-95a215f413ae", "metadata": {}, "outputs": [], "source": [ "# problem definition\n", "\n", "sigmas = {\"p1\": 1e-1, \"p2\": 1e2, \"p3\": 1e2, \"p4\": 1e-1}\n", "\n", "\n", "def model(p):\n", " return {\n", " \"y1\": p[\"p1\"] + sigmas[\"p1\"] * np.random.normal(),\n", " \"y2\": p[\"p2\"] + sigmas[\"p2\"] * np.random.normal(),\n", " \"y3\": p[\"p3\"]\n", " + np.sqrt(4 * sigmas[\"p3\"] ** 2) * np.random.normal(size=4),\n", " \"y4\": p[\"p4\"] ** 2 + sigmas[\"p4\"] * np.random.normal(),\n", " \"y5\": 1e1 * np.random.normal(size=10),\n", " }\n", "\n", "\n", "prior_bounds = {\n", " \"p1\": (-7e0, 7e0),\n", " \"p2\": (-7e2, 7e2),\n", " \"p3\": (-7e2, 7e2),\n", " \"p4\": (-1e0, 1e0),\n", "}\n", "\n", "prior = pyabc.Distribution(\n", " **{\n", " key: pyabc.RV(\"uniform\", lb, ub - lb)\n", " for key, (lb, ub) in prior_bounds.items()\n", " },\n", ")\n", "\n", "gt_par = {\"p1\": 0, \"p2\": 0, \"p3\": 0, \"p4\": 0.5}\n", "data = {\n", " \"y1\": 0,\n", " \"y2\": 0,\n", " \"y3\": 0 * np.ones(4),\n", " \"y4\": 0.5**2,\n", " \"y5\": 0 * np.ones(10),\n", "}" ] }, { "cell_type": "markdown", "id": "2e590cd1-4a6e-4101-a4b7-d650a317b7a8", "metadata": {}, "source": [ "To tackle these problems, we suggest to firstly consistently employ scale normalization, both on the raw model outputs and on the level of summary statistics. Secondly, we suggest to instead of only inferring a mapping $s: y \\mapsto \\theta$, we target augmented parameter vectors, $s: y \\mapsto \\lambda(\\theta)$, with e.g. $\\lambda(\\theta) = (\\theta^1,\\ldots,\\theta^4)$. This practically allows to break symmetry, e.g. if only $\\theta^2$ can be expressed as a function of the data. Conceptually, this further allows to obtain a more accurate description of the posterior distribution, as the summary statistics may be regarded as approximations to $s(y) = \\mathbb{E}[\\lambda(\\theta)|y]$, using which as summary statistics preserves the corresponding posterior moments, i.e.\n", "\n", "$$\\lim_{\\varepsilon\\rightarrow 0}\\mathbb{E}_{\\pi_{\\text{ABC},\\varepsilon}}[\\lambda(\\Theta)|s(y_\\text{obs})] = \\mathbb{E}[\\lambda(\\Theta)|Y=y_\\text{obs}].$$\n", "\n", "Methods employing scale normalization, accounting for informativeness, and augmented regression targets, are L1+Ada.+MAD+StatLR+P4, which uses regression-based summary statistics, and L1+Ada.+MAD+SensiLR+P4, which uses sensitivity weights.\n", "For comparison, we consider L1+Ada.+MAD only normalizing scales, and L1+StatLR, using non-scale normalised summary statistics, as well as L1+Ada.+MAD+StatLR and L1+Ada.+MAD+SensiLR using only a subset of methods." ] }, { "cell_type": "code", "execution_count": 10, "id": "cbc550e8-04b4-465d-8be0-01c5e15afda9", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "ABC.Distance DEBUG: Fit scale ixs: \n", "ABC.Sumstat DEBUG: Fit model ixs: \n", "ABC.Sumstat DEBUG: Fit model ixs: \n", "ABC.Distance DEBUG: Fit scale ixs: \n", "ABC.Sumstat DEBUG: Fit model ixs: \n", "ABC.Distance DEBUG: Fit scale ixs: \n", "ABC.Distance DEBUG: Fit scale ixs: \n", "ABC.Distance DEBUG: Fit info ixs: \n", "ABC.Distance DEBUG: Fit scale ixs: \n", "ABC.Distance DEBUG: Fit info ixs: \n" ] } ], "source": [ "# analysis definition\n", "\n", "pop_size = 1000\n", "total_sims = 100000\n", "par_trafos = [\n", " lambda x: x,\n", " lambda x: x**2,\n", " lambda x: x**3,\n", " lambda x: x**4,\n", "]\n", "trafo_ids = [\"{par_id}^\" + str(i + 1) for i in range(4)]\n", "fit_sims = 0.4 * total_sims\n", "\n", "YPredictor = LinearPredictor\n", "# YPredictor = MLPPredictor\n", "\n", "distances = {\n", " \"L1+Ada.+MAD\": AdaptivePNormDistance(\n", " p=1,\n", " scale_function=mad,\n", " ),\n", " \"L1+StatLR\": PNormDistance(\n", " p=1,\n", " sumstat=PredictorSumstat(\n", " predictor=YPredictor(\n", " normalize_features=False, normalize_labels=False\n", " ),\n", " fit_ixs=EventIxs(sims=fit_sims),\n", " ),\n", " ),\n", " \"L1+Ada.+MAD+StatLR\": AdaptivePNormDistance(\n", " p=1,\n", " scale_function=mad,\n", " sumstat=PredictorSumstat(\n", " predictor=YPredictor(),\n", " fit_ixs=EventIxs(sims=fit_sims),\n", " ),\n", " ),\n", " \"L1+Ada.+MAD+StatLR+P4\": AdaptivePNormDistance(\n", " p=1,\n", " scale_function=mad,\n", " sumstat=PredictorSumstat(\n", " predictor=YPredictor(),\n", " fit_ixs=EventIxs(sims=fit_sims),\n", " par_trafo=ParTrafo(trafos=par_trafos, trafo_ids=trafo_ids),\n", " ),\n", " ),\n", " \"L1+Ada.+MAD+SensiLR\": InfoWeightedPNormDistance(\n", " p=1,\n", " scale_function=mad,\n", " predictor=YPredictor(),\n", " fit_info_ixs=EventIxs(sims=fit_sims),\n", " feature_normalization=\"mad\",\n", " ),\n", " \"L1+Ada.+MAD+SensiLR+P4\": InfoWeightedPNormDistance(\n", " p=1,\n", " scale_function=mad,\n", " predictor=YPredictor(),\n", " fit_info_ixs=EventIxs(sims=fit_sims),\n", " feature_normalization=\"mad\",\n", " par_trafo=ParTrafo(trafos=par_trafos, trafo_ids=trafo_ids),\n", " ),\n", "}\n", "\n", "colors = {distance_id: f\"C{i}\" for i, distance_id in enumerate(distances)}" ] }, { "cell_type": "markdown", "id": "c82b9b01-9ab2-4208-89cf-d9c05d43e9c7", "metadata": {}, "source": [ "For the analysis, we suggest the use of sufficiently large population sizes, as the process model is more complex." ] }, { "cell_type": "code", "execution_count": 11, "id": "a44da266-8980-4606-b857-84e8b744b568", "metadata": { "tags": [] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "ABC.Sampler INFO: Parallelize sampling on 4 processes.\n", "ABC.History INFO: Start \n", "ABC INFO: Calibration sample t = -1.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "L1+Ada.+MAD\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "ABC.Distance DEBUG: Scale weights[0] = {'y1': 2.9903e-01, 'y2': 2.8508e-03, 'y3:0': 2.8734e-03, 'y3:1': 2.7775e-03, 'y3:2': 2.8285e-03, 'y3:3': 2.8304e-03, 'y4': 4.9034e+00, 'y5:0': 1.4995e-01, 'y5:1': 1.5096e-01, 'y5:2': 1.4396e-01, 'y5:3': 1.5448e-01, 'y5:4': 1.5084e-01, 'y5:5': 1.5618e-01, 'y5:6': 1.5170e-01, 'y5:7': 1.5049e-01, 'y5:8': 1.5569e-01, 'y5:9': 1.4825e-01}\n", "ABC.Population INFO: Recording also rejected particles: True\n", "ABC INFO: t: 0, eps: 1.94111297e+01.\n", "ABC INFO: Accepted: 1000 / 2166 = 4.6168e-01, ESS: 1.0000e+03.\n", "ABC.Distance DEBUG: Scale weights[1] = {'y1': 2.7884e-01, 'y2': 2.8670e-03, 'y3:0': 2.7673e-03, 'y3:1': 2.7863e-03, 'y3:2': 2.6965e-03, 'y3:3': 2.8352e-03, 'y4': 4.6091e+00, 'y5:0': 1.4676e-01, 'y5:1': 1.5150e-01, 'y5:2': 1.5204e-01, 'y5:3': 1.4841e-01, 'y5:4': 1.5419e-01, 'y5:5': 1.4403e-01, 'y5:6': 1.4776e-01, 'y5:7': 1.5315e-01, 'y5:8': 1.4297e-01, 'y5:9': 1.4573e-01}\n", "ABC INFO: t: 1, eps: 1.64619227e+01.\n", "ABC INFO: Accepted: 1000 / 3039 = 3.2906e-01, ESS: 7.8425e+02.\n", "ABC.Distance DEBUG: Scale weights[2] = {'y1': 3.4183e-01, 'y2': 3.3534e-03, 'y3:0': 3.5982e-03, 'y3:1': 3.6601e-03, 'y3:2': 3.5481e-03, 'y3:3': 3.5396e-03, 'y4': 5.6202e+00, 'y5:0': 1.4201e-01, 'y5:1': 1.5040e-01, 'y5:2': 1.4600e-01, 'y5:3': 1.4591e-01, 'y5:4': 1.5085e-01, 'y5:5': 1.4724e-01, 'y5:6': 1.4962e-01, 'y5:7': 1.5093e-01, 'y5:8': 1.4958e-01, 'y5:9': 1.4961e-01}\n", "ABC INFO: t: 2, eps: 1.61270195e+01.\n", "ABC INFO: Accepted: 1000 / 4442 = 2.2512e-01, ESS: 6.6259e+02.\n", "ABC.Distance DEBUG: Scale weights[3] = {'y1': 3.6011e-01, 'y2': 3.4257e-03, 'y3:0': 4.1717e-03, 'y3:1': 4.2160e-03, 'y3:2': 4.1158e-03, 'y3:3': 4.2058e-03, 'y4': 6.0246e+00, 'y5:0': 1.4671e-01, 'y5:1': 1.4989e-01, 'y5:2': 1.4962e-01, 'y5:3': 1.4915e-01, 'y5:4': 1.4510e-01, 'y5:5': 1.4583e-01, 'y5:6': 1.5134e-01, 'y5:7': 1.4732e-01, 'y5:8': 1.5020e-01, 'y5:9': 1.4796e-01}\n", "ABC INFO: t: 3, eps: 1.54480347e+01.\n", "ABC INFO: Accepted: 1000 / 6222 = 1.6072e-01, ESS: 6.2204e+02.\n", "ABC.Distance DEBUG: Scale weights[4] = {'y1': 3.9063e-01, 'y2': 3.7227e-03, 'y3:0': 4.8907e-03, 'y3:1': 4.9644e-03, 'y3:2': 4.9102e-03, 'y3:3': 4.9302e-03, 'y4': 6.2074e+00, 'y5:0': 1.5319e-01, 'y5:1': 1.5103e-01, 'y5:2': 1.4754e-01, 'y5:3': 1.5241e-01, 'y5:4': 1.5008e-01, 'y5:5': 1.4875e-01, 'y5:6': 1.4883e-01, 'y5:7': 1.5209e-01, 'y5:8': 1.4942e-01, 'y5:9': 1.5341e-01}\n", "ABC INFO: t: 4, eps: 1.51452899e+01.\n", "ABC INFO: Accepted: 1000 / 10680 = 9.3633e-02, ESS: 6.0607e+02.\n", "ABC.Distance DEBUG: Scale weights[5] = {'y1': 4.1023e-01, 'y2': 3.8337e-03, 'y3:0': 5.2679e-03, 'y3:1': 5.2907e-03, 'y3:2': 5.2068e-03, 'y3:3': 5.3311e-03, 'y4': 6.1898e+00, 'y5:0': 1.4419e-01, 'y5:1': 1.4795e-01, 'y5:2': 1.4716e-01, 'y5:3': 1.4681e-01, 'y5:4': 1.5100e-01, 'y5:5': 1.4792e-01, 'y5:6': 1.4748e-01, 'y5:7': 1.4848e-01, 'y5:8': 1.4408e-01, 'y5:9': 1.4874e-01}\n", "ABC INFO: t: 5, eps: 1.42231150e+01.\n", "ABC INFO: Accepted: 1000 / 15273 = 6.5475e-02, ESS: 5.8159e+02.\n", "ABC.Distance DEBUG: Scale weights[6] = {'y1': 4.3083e-01, 'y2': 4.0665e-03, 'y3:0': 5.7448e-03, 'y3:1': 5.6721e-03, 'y3:2': 5.6564e-03, 'y3:3': 5.6503e-03, 'y4': 6.1348e+00, 'y5:0': 1.4929e-01, 'y5:1': 1.4905e-01, 'y5:2': 1.4909e-01, 'y5:3': 1.4710e-01, 'y5:4': 1.4997e-01, 'y5:5': 1.4902e-01, 'y5:6': 1.4838e-01, 'y5:7': 1.4795e-01, 'y5:8': 1.4877e-01, 'y5:9': 1.4908e-01}\n", "ABC INFO: t: 6, eps: 1.36601651e+01.\n", "ABC INFO: Accepted: 1000 / 25872 = 3.8652e-02, ESS: 2.2490e+02.\n", "ABC.Distance DEBUG: Scale weights[7] = {'y1': 4.6938e-01, 'y2': 4.2968e-03, 'y3:0': 5.9625e-03, 'y3:1': 5.9273e-03, 'y3:2': 5.9491e-03, 'y3:3': 5.9452e-03, 'y4': 6.3012e+00, 'y5:0': 1.4817e-01, 'y5:1': 1.4906e-01, 'y5:2': 1.4856e-01, 'y5:3': 1.4769e-01, 'y5:4': 1.4862e-01, 'y5:5': 1.4796e-01, 'y5:6': 1.4879e-01, 'y5:7': 1.4898e-01, 'y5:8': 1.4958e-01, 'y5:9': 1.4840e-01}\n", "ABC INFO: t: 7, eps: 1.30550884e+01.\n", "ABC INFO: Accepted: 1000 / 46778 = 2.1378e-02, ESS: 2.6316e+02.\n", "ABC.Distance DEBUG: Scale weights[8] = {'y1': 4.9279e-01, 'y2': 4.9823e-03, 'y3:0': 5.5964e-03, 'y3:1': 5.5968e-03, 'y3:2': 5.6035e-03, 'y3:3': 5.5883e-03, 'y4': 6.0601e+00, 'y5:0': 1.4959e-01, 'y5:1': 1.4996e-01, 'y5:2': 1.4843e-01, 'y5:3': 1.4722e-01, 'y5:4': 1.4830e-01, 'y5:5': 1.4732e-01, 'y5:6': 1.4858e-01, 'y5:7': 1.4828e-01, 'y5:8': 1.4909e-01, 'y5:9': 1.4880e-01}\n", "ABC INFO: Stop: Total simulations budget.\n", "ABC.History INFO: Done \n", "ABC.Sampler INFO: Parallelize sampling on 4 processes.\n", "ABC.History INFO: Start \n", "ABC INFO: Calibration sample t = -1.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "L1+StatLR\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "ABC.Population INFO: Recording also rejected particles: True\n", "ABC INFO: t: 0, eps: 1.90073547e+03.\n", "ABC INFO: Accepted: 1000 / 1939 = 5.1573e-01, ESS: 1.0000e+03.\n", "ABC INFO: t: 1, eps: 1.31242141e+03.\n", "ABC INFO: Accepted: 1000 / 2229 = 4.4863e-01, ESS: 8.6586e+02.\n", "ABC INFO: t: 2, eps: 1.04364953e+03.\n", "ABC INFO: Accepted: 1000 / 2866 = 3.4892e-01, ESS: 7.3923e+02.\n", "ABC INFO: t: 3, eps: 8.61095576e+02.\n", "ABC INFO: Accepted: 1000 / 4138 = 2.4166e-01, ESS: 7.2489e+02.\n", "ABC INFO: t: 4, eps: 7.36415669e+02.\n", "ABC INFO: Accepted: 1000 / 5928 = 1.6869e-01, ESS: 5.7328e+02.\n", "ABC INFO: t: 5, eps: 6.22306047e+02.\n", "ABC INFO: Accepted: 1000 / 9777 = 1.0228e-01, ESS: 4.8916e+02.\n", "ABC INFO: t: 6, eps: 5.51735039e+02.\n", "ABC INFO: Accepted: 1000 / 15557 = 6.4280e-02, ESS: 2.4570e+02.\n", "ABC.Predictor INFO: Fitted in 0.01s\n", "ABC.Predictor INFO: Pearson correlations: 1.000 0.900 0.767 0.111\n", "ABC.Predictor DEBUG: Linear regression coefficients (n_target, n_feature):\n", "[[ 9.99432199e-01 9.39633441e-06 9.55159460e-06 -7.59615180e-06\n", " 2.92146205e-06 5.71472629e-06 -1.09706500e-03 2.70151331e-05\n", " -1.71054160e-04 -4.64265954e-05 -7.72835999e-05 3.90842094e-05\n", " 1.06955781e-04 -3.84259920e-06 7.54826153e-05 1.65503443e-05\n", " 4.34150663e-06]\n", " [ 1.25998627e+00 8.01458146e-01 3.83746278e-03 5.33655187e-03\n", " 7.40670980e-03 2.80437140e-04 -1.39199692e+00 -2.16441449e-03\n", " 2.81230580e-02 3.72724481e-02 1.43726173e-02 -1.09845403e-01\n", " -7.05272626e-02 1.09475130e-02 3.09149659e-02 3.17397280e-02\n", " -2.91388764e-02]\n", " [-5.03069382e-01 1.03216101e-02 1.46573794e-01 1.47547322e-01\n", " 1.47889552e-01 1.44883701e-01 -1.54612660e+00 -1.63031991e-01\n", " 5.57474815e-02 -7.45239703e-02 1.23409469e-01 1.09327576e-03\n", " -5.35254693e-02 6.22323435e-02 -9.21821712e-03 1.04238807e-02\n", " 1.26242483e-01]\n", " [ 4.80207377e-03 7.42641330e-05 -8.54115598e-05 -9.35763651e-05\n", " -8.28161305e-05 -6.21100196e-05 -4.07461891e-02 -4.95200504e-05\n", " -1.66255825e-04 2.99811623e-04 6.75650937e-04 -3.26470949e-04\n", " 4.94428214e-04 -1.79189483e-05 6.36720992e-04 -4.86577427e-04\n", " -9.84227938e-04]]\n", "ABC INFO: t: 7, eps: 9.03589291e+01.\n", "ABC INFO: Accepted: 1000 / 6257 = 1.5982e-01, ESS: 1.5990e+02.\n", "ABC INFO: t: 8, eps: 6.61361600e+01.\n", "ABC INFO: Accepted: 1000 / 10706 = 9.3406e-02, ESS: 5.3293e+02.\n", "ABC INFO: t: 9, eps: 4.76701345e+01.\n", "ABC INFO: Accepted: 1000 / 17514 = 5.7097e-02, ESS: 1.2118e+02.\n", "ABC INFO: t: 10, eps: 3.27874437e+01.\n", "ABC INFO: Accepted: 1000 / 41389 = 2.4161e-02, ESS: 5.9247e+02.\n", "ABC INFO: Stop: Total simulations budget.\n", "ABC.History INFO: Done \n", "ABC.Sampler INFO: Parallelize sampling on 4 processes.\n", "ABC.History INFO: Start \n", "ABC INFO: Calibration sample t = -1.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "L1+Ada.+MAD+StatLR\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "ABC.Distance DEBUG: Scale weights[0] = {'y1': 2.7740e-01, 'y2': 2.9350e-03, 'y3:0': 2.9481e-03, 'y3:1': 2.8059e-03, 'y3:2': 2.6870e-03, 'y3:3': 2.5650e-03, 'y4': 4.4857e+00, 'y5:0': 1.5030e-01, 'y5:1': 1.5961e-01, 'y5:2': 1.4499e-01, 'y5:3': 1.4444e-01, 'y5:4': 1.5222e-01, 'y5:5': 1.6019e-01, 'y5:6': 1.3794e-01, 'y5:7': 1.4617e-01, 'y5:8': 1.4959e-01, 'y5:9': 1.4944e-01}\n", "ABC.Population INFO: Recording also rejected particles: True\n", "ABC.Population INFO: Recording also rejected particles: True\n", "ABC INFO: t: 0, eps: 1.90890472e+01.\n", "ABC INFO: Accepted: 1000 / 2011 = 4.9727e-01, ESS: 1.0000e+03.\n", "ABC.Distance DEBUG: Scale weights[1] = {'y1': 2.8655e-01, 'y2': 2.9998e-03, 'y3:0': 2.8583e-03, 'y3:1': 2.8170e-03, 'y3:2': 2.8404e-03, 'y3:3': 2.8071e-03, 'y4': 4.3381e+00, 'y5:0': 1.4700e-01, 'y5:1': 1.5099e-01, 'y5:2': 1.4352e-01, 'y5:3': 1.5116e-01, 'y5:4': 1.5607e-01, 'y5:5': 1.4533e-01, 'y5:6': 1.5055e-01, 'y5:7': 1.5209e-01, 'y5:8': 1.4187e-01, 'y5:9': 1.4566e-01}\n", "ABC INFO: t: 1, eps: 1.65554756e+01.\n", "ABC INFO: Accepted: 1000 / 2976 = 3.3602e-01, ESS: 7.3306e+02.\n", "ABC.Distance DEBUG: Scale weights[2] = {'y1': 3.4367e-01, 'y2': 3.4848e-03, 'y3:0': 3.6549e-03, 'y3:1': 3.7046e-03, 'y3:2': 3.7519e-03, 'y3:3': 3.7943e-03, 'y4': 5.7393e+00, 'y5:0': 1.4871e-01, 'y5:1': 1.5122e-01, 'y5:2': 1.4834e-01, 'y5:3': 1.4695e-01, 'y5:4': 1.4520e-01, 'y5:5': 1.4712e-01, 'y5:6': 1.4338e-01, 'y5:7': 1.5197e-01, 'y5:8': 1.5195e-01, 'y5:9': 1.4897e-01}\n", "ABC INFO: t: 2, eps: 1.62761321e+01.\n", "ABC INFO: Accepted: 1000 / 4484 = 2.2302e-01, ESS: 7.1380e+02.\n", "ABC.Distance DEBUG: Scale weights[3] = {'y1': 3.6275e-01, 'y2': 3.5032e-03, 'y3:0': 4.2611e-03, 'y3:1': 4.4184e-03, 'y3:2': 4.3637e-03, 'y3:3': 4.2507e-03, 'y4': 5.9359e+00, 'y5:0': 1.4773e-01, 'y5:1': 1.5038e-01, 'y5:2': 1.5235e-01, 'y5:3': 1.5143e-01, 'y5:4': 1.5439e-01, 'y5:5': 1.4706e-01, 'y5:6': 1.4729e-01, 'y5:7': 1.4911e-01, 'y5:8': 1.4508e-01, 'y5:9': 1.5073e-01}\n", "ABC INFO: t: 3, eps: 1.56618757e+01.\n", "ABC INFO: Accepted: 1000 / 6350 = 1.5748e-01, ESS: 7.3764e+02.\n", "ABC.Distance DEBUG: Scale weights[4] = {'y1': 3.6942e-01, 'y2': 3.6436e-03, 'y3:0': 4.8543e-03, 'y3:1': 4.9473e-03, 'y3:2': 4.9029e-03, 'y3:3': 4.8655e-03, 'y4': 6.1607e+00, 'y5:0': 1.5114e-01, 'y5:1': 1.4759e-01, 'y5:2': 1.5429e-01, 'y5:3': 1.4943e-01, 'y5:4': 1.4672e-01, 'y5:5': 1.4716e-01, 'y5:6': 1.5130e-01, 'y5:7': 1.5001e-01, 'y5:8': 1.4950e-01, 'y5:9': 1.4723e-01}\n", "ABC INFO: t: 4, eps: 1.48050303e+01.\n", "ABC INFO: Accepted: 1000 / 10622 = 9.4144e-02, ESS: 5.9561e+02.\n", "ABC.Distance DEBUG: Scale weights[5] = {'y1': 4.0584e-01, 'y2': 4.0947e-03, 'y3:0': 5.3349e-03, 'y3:1': 5.3433e-03, 'y3:2': 5.4532e-03, 'y3:3': 5.2179e-03, 'y4': 6.3040e+00, 'y5:0': 1.4880e-01, 'y5:1': 1.5016e-01, 'y5:2': 1.4834e-01, 'y5:3': 1.4874e-01, 'y5:4': 1.4767e-01, 'y5:5': 1.4637e-01, 'y5:6': 1.5000e-01, 'y5:7': 1.4701e-01, 'y5:8': 1.4916e-01, 'y5:9': 1.4870e-01}\n", "ABC INFO: t: 5, eps: 1.41383700e+01.\n", "ABC INFO: Accepted: 1000 / 17487 = 5.7185e-02, ESS: 1.9548e+02.\n", "ABC.Predictor INFO: Fitted in 0.01s\n", "ABC.Predictor INFO: Pearson correlations: 1.000 0.952 0.858 0.100\n", "ABC.Predictor DEBUG: Linear regression coefficients (n_target, n_feature):\n", "[[ 9.99527667e-01 2.77857512e-04 5.36876059e-04 -1.68168917e-04\n", " 9.69310087e-05 -2.05926422e-04 -3.42453359e-05 -3.84918591e-04\n", " -1.30413605e-04 1.40054597e-04 3.65928537e-04 7.19093022e-05\n", " 2.33989326e-04 -4.13467674e-04 1.57383685e-04 -1.40151970e-04\n", " 1.33729847e-04]\n", " [-4.31930024e-03 9.51459762e-01 3.06195289e-03 3.69854817e-04\n", " 1.66411240e-03 4.88186617e-03 3.21282619e-03 -1.08077935e-03\n", " 1.38752338e-03 7.83199668e-04 -4.20321959e-05 3.34944988e-03\n", " -7.87894002e-04 -2.21970135e-03 -2.78464110e-03 -1.88726674e-03\n", " -3.66002190e-03]\n", " [-2.02147953e-02 2.17961067e-02 2.85439014e-01 2.95077432e-01\n", " 2.88521977e-01 2.80940280e-01 2.69106385e-03 -3.57860026e-03\n", " -2.09958258e-03 -7.63777867e-03 -3.48141307e-03 -3.52275828e-03\n", " 1.85912656e-03 -9.30106640e-03 -3.34854476e-03 1.19108322e-03\n", " 4.89654548e-04]\n", " [-4.32315645e-02 -4.54547394e-02 -4.10164233e-03 2.27187728e-02\n", " 1.50613743e-02 -3.77747609e-03 6.91002451e-02 1.07832973e-03\n", " -7.73794797e-03 1.10017483e-02 -5.14681986e-03 -6.30359097e-03\n", " -3.90858296e-03 1.32229437e-02 -1.04124795e-02 -7.31994650e-06\n", " -1.16847157e-03]]\n", "ABC.Distance DEBUG: Scale weights[6] = {'s_p1': 1.3968e+00, 's_p2': 1.4649e+00, 's_p3': 1.7281e+00, 's_p4': 1.4842e+01}\n", "ABC INFO: t: 6, eps: 3.56026862e+00.\n", "ABC INFO: Accepted: 1000 / 3212 = 3.1133e-01, ESS: 4.7024e+02.\n", "ABC.Distance DEBUG: Scale weights[7] = {'s_p1': 1.4682e+00, 's_p2': 1.5160e+00, 's_p3': 1.6948e+00, 's_p4': 1.5711e+01}\n", "ABC INFO: t: 7, eps: 2.98109037e+00.\n", "ABC INFO: Accepted: 1000 / 3956 = 2.5278e-01, ESS: 8.0031e+02.\n", "ABC.Distance DEBUG: Scale weights[8] = {'s_p1': 2.0374e+00, 's_p2': 1.9748e+00, 's_p3': 1.6233e+00, 's_p4': 1.7408e+01}\n", "ABC INFO: t: 8, eps: 2.89987216e+00.\n", "ABC INFO: Accepted: 1000 / 4663 = 2.1445e-01, ESS: 6.1422e+02.\n", "ABC.Distance DEBUG: Scale weights[9] = {'s_p1': 2.5535e+00, 's_p2': 2.2357e+00, 's_p3': 1.8566e+00, 's_p4': 1.9539e+01}\n", "ABC INFO: t: 9, eps: 2.80289548e+00.\n", "ABC INFO: Accepted: 1000 / 4973 = 2.0109e-01, ESS: 6.9491e+02.\n", "ABC.Distance DEBUG: Scale weights[10] = {'s_p1': 3.9393e+00, 's_p2': 2.3730e+00, 's_p3': 1.9666e+00, 's_p4': 2.0336e+01}\n", "ABC INFO: t: 10, eps: 2.67588839e+00.\n", "ABC INFO: Accepted: 1000 / 6451 = 1.5501e-01, ESS: 6.3239e+02.\n", "ABC.Distance DEBUG: Scale weights[11] = {'s_p1': 5.2674e+00, 's_p2': 2.7002e+00, 's_p3': 1.9823e+00, 's_p4': 1.9937e+01}\n", "ABC INFO: t: 11, eps: 2.48366508e+00.\n", "ABC INFO: Accepted: 1000 / 7633 = 1.3101e-01, ESS: 4.8692e+02.\n", "ABC.Distance DEBUG: Scale weights[12] = {'s_p1': 7.6135e+00, 's_p2': 2.9702e+00, 's_p3': 2.0205e+00, 's_p4': 2.0528e+01}\n", "ABC INFO: t: 12, eps: 2.39778162e+00.\n", "ABC INFO: Accepted: 1000 / 9812 = 1.0192e-01, ESS: 5.9664e+02.\n", "ABC.Distance DEBUG: Scale weights[13] = {'s_p1': 1.0522e+01, 's_p2': 2.9627e+00, 's_p3': 1.9834e+00, 's_p4': 2.0199e+01}\n", "ABC INFO: t: 13, eps: 2.17302874e+00.\n", "ABC INFO: Accepted: 1000 / 12583 = 7.9472e-02, ESS: 5.6421e+02.\n", "ABC.Distance DEBUG: Scale weights[14] = {'s_p1': 1.4501e+01, 's_p2': 3.1206e+00, 's_p3': 2.0128e+00, 's_p4': 1.9761e+01}\n", "ABC INFO: t: 14, eps: 1.99101473e+00.\n", "ABC INFO: Accepted: 1000 / 16972 = 5.8921e-02, ESS: 4.5603e+02.\n", "ABC.Distance DEBUG: Scale weights[15] = {'s_p1': 1.9828e+01, 's_p2': 3.2828e+00, 's_p3': 2.1231e+00, 's_p4': 2.0252e+01}\n", "ABC INFO: Stop: Total simulations budget.\n", "ABC.History INFO: Done \n", "ABC.Sampler INFO: Parallelize sampling on 4 processes.\n", "ABC.History INFO: Start \n", "ABC INFO: Calibration sample t = -1.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "L1+Ada.+MAD+StatLR+P4\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "ABC.Distance DEBUG: Scale weights[0] = {'y1': 2.7301e-01, 'y2': 2.8598e-03, 'y3:0': 2.8602e-03, 'y3:1': 2.7538e-03, 'y3:2': 2.9544e-03, 'y3:3': 2.8587e-03, 'y4': 4.5365e+00, 'y5:0': 1.4590e-01, 'y5:1': 1.5560e-01, 'y5:2': 1.4777e-01, 'y5:3': 1.4560e-01, 'y5:4': 1.5037e-01, 'y5:5': 1.4025e-01, 'y5:6': 1.4648e-01, 'y5:7': 1.5637e-01, 'y5:8': 1.5794e-01, 'y5:9': 1.4908e-01}\n", "ABC.Population INFO: Recording also rejected particles: True\n", "ABC.Population INFO: Recording also rejected particles: True\n", "ABC INFO: t: 0, eps: 1.89369290e+01.\n", "ABC INFO: Accepted: 1000 / 2151 = 4.6490e-01, ESS: 1.0000e+03.\n", "ABC.Distance DEBUG: Scale weights[1] = {'y1': 2.8968e-01, 'y2': 2.8892e-03, 'y3:0': 2.8432e-03, 'y3:1': 2.7813e-03, 'y3:2': 2.8680e-03, 'y3:3': 2.8110e-03, 'y4': 4.5767e+00, 'y5:0': 1.5001e-01, 'y5:1': 1.5527e-01, 'y5:2': 1.4435e-01, 'y5:3': 1.4876e-01, 'y5:4': 1.4710e-01, 'y5:5': 1.4302e-01, 'y5:6': 1.4970e-01, 'y5:7': 1.4820e-01, 'y5:8': 1.4631e-01, 'y5:9': 1.5175e-01}\n", "ABC INFO: t: 1, eps: 1.64852309e+01.\n", "ABC INFO: Accepted: 1000 / 3005 = 3.3278e-01, ESS: 7.4528e+02.\n", "ABC.Distance DEBUG: Scale weights[2] = {'y1': 3.4557e-01, 'y2': 3.3545e-03, 'y3:0': 3.8228e-03, 'y3:1': 3.6598e-03, 'y3:2': 3.8026e-03, 'y3:3': 3.6251e-03, 'y4': 5.5368e+00, 'y5:0': 1.5246e-01, 'y5:1': 1.4430e-01, 'y5:2': 1.5403e-01, 'y5:3': 1.5308e-01, 'y5:4': 1.4364e-01, 'y5:5': 1.4518e-01, 'y5:6': 1.4606e-01, 'y5:7': 1.4537e-01, 'y5:8': 1.4799e-01, 'y5:9': 1.5178e-01}\n", "ABC INFO: t: 2, eps: 1.63290007e+01.\n", "ABC INFO: Accepted: 1000 / 4413 = 2.2660e-01, ESS: 7.7998e+02.\n", "ABC.Distance DEBUG: Scale weights[3] = {'y1': 3.5896e-01, 'y2': 3.4710e-03, 'y3:0': 4.1708e-03, 'y3:1': 4.1406e-03, 'y3:2': 4.2032e-03, 'y3:3': 4.1327e-03, 'y4': 5.8933e+00, 'y5:0': 1.4684e-01, 'y5:1': 1.4973e-01, 'y5:2': 1.4611e-01, 'y5:3': 1.4659e-01, 'y5:4': 1.4848e-01, 'y5:5': 1.5063e-01, 'y5:6': 1.5018e-01, 'y5:7': 1.5276e-01, 'y5:8': 1.4972e-01, 'y5:9': 1.5006e-01}\n", "ABC INFO: t: 3, eps: 1.54057968e+01.\n", "ABC INFO: Accepted: 1000 / 6850 = 1.4599e-01, ESS: 5.7495e+02.\n", "ABC.Distance DEBUG: Scale weights[4] = {'y1': 3.6718e-01, 'y2': 3.6559e-03, 'y3:0': 4.9476e-03, 'y3:1': 5.0767e-03, 'y3:2': 5.0433e-03, 'y3:3': 4.9906e-03, 'y4': 5.8281e+00, 'y5:0': 1.4814e-01, 'y5:1': 1.4396e-01, 'y5:2': 1.4800e-01, 'y5:3': 1.5039e-01, 'y5:4': 1.4888e-01, 'y5:5': 1.4729e-01, 'y5:6': 1.4752e-01, 'y5:7': 1.4578e-01, 'y5:8': 1.4882e-01, 'y5:9': 1.4958e-01}\n", "ABC INFO: t: 4, eps: 1.48215051e+01.\n", "ABC INFO: Accepted: 1000 / 10667 = 9.3747e-02, ESS: 6.9717e+02.\n", "ABC.Distance DEBUG: Scale weights[5] = {'y1': 4.0169e-01, 'y2': 3.7610e-03, 'y3:0': 5.2485e-03, 'y3:1': 5.1891e-03, 'y3:2': 5.3267e-03, 'y3:3': 5.2498e-03, 'y4': 5.9238e+00, 'y5:0': 1.5100e-01, 'y5:1': 1.4852e-01, 'y5:2': 1.5031e-01, 'y5:3': 1.5294e-01, 'y5:4': 1.4890e-01, 'y5:5': 1.4915e-01, 'y5:6': 1.4684e-01, 'y5:7': 1.4759e-01, 'y5:8': 1.4931e-01, 'y5:9': 1.4833e-01}\n", "ABC INFO: t: 5, eps: 1.41767456e+01.\n", "ABC INFO: Accepted: 1000 / 15784 = 6.3355e-02, ESS: 6.1544e+02.\n", "ABC.Predictor INFO: Fitted in 0.02s\n", "ABC.Predictor INFO: Pearson correlations: 1.000 0.953 0.855 0.074 0.080 0.040 0.189 0.920 0.876 0.828 0.681 0.079 0.076 0.052 0.221 0.869\n", "ABC.Predictor DEBUG: Linear regression coefficients (n_target, n_feature):\n", "[[ 9.99510768e-01 -4.60738685e-04 1.08625808e-04 1.58691810e-04\n", " -1.98663652e-04 1.53535344e-04 -3.86133701e-05 1.87568095e-04\n", " 3.02111648e-04 -1.73577437e-04 3.68225536e-04 8.32443061e-05\n", " -2.30071573e-05 -1.99091970e-04 3.61359436e-05 -1.25270152e-04\n", " 5.30494681e-04]\n", " [-2.71651931e-03 9.52676069e-01 6.05641758e-03 -6.48824790e-03\n", " 3.35541527e-03 -1.74615352e-03 -1.56981984e-03 8.08272033e-04\n", " 4.59887190e-03 3.64368195e-03 -3.85431682e-03 1.09284542e-03\n", " 1.48778343e-03 1.19918108e-04 -1.76965296e-03 2.21681897e-03\n", " 4.38477781e-06]\n", " [ 9.55890113e-03 -1.00455529e-02 2.95898110e-01 2.82928588e-01\n", " 2.79904779e-01 2.86633945e-01 -2.39756035e-03 5.08740517e-03\n", " -1.31256846e-04 2.56362437e-03 6.97985539e-03 5.52809853e-03\n", " 4.79922298e-03 5.20053926e-03 1.79696177e-04 -3.68929696e-03\n", " -9.17605856e-03]\n", " [ 1.55306028e-03 -4.48347840e-02 -4.13360255e-03 1.15973150e-02\n", " 2.10992272e-03 2.65642118e-02 4.24285803e-02 -8.73863838e-04\n", " -5.35031385e-03 -7.02477676e-03 2.04264402e-03 -9.43458929e-03\n", " 4.96108657e-03 -1.37339651e-02 3.48955093e-03 -3.76988253e-03\n", " -1.08385414e-02]\n", " [-1.70605121e-02 -1.27341583e-02 1.33222883e-02 2.00364433e-02\n", " 1.64097986e-02 5.61843314e-04 6.16404605e-02 -2.30958667e-03\n", " -8.08117853e-03 8.13189780e-03 -1.35364334e-02 4.68372814e-04\n", " 1.29031331e-02 -3.44619473e-03 5.76340530e-03 1.36955172e-02\n", " -6.67887987e-03]\n", " [ 1.72303944e-02 1.77755568e-02 -3.70042159e-03 5.74465016e-03\n", " 1.55238336e-02 1.68778619e-03 -4.04296507e-03 -7.43196496e-03\n", " 9.71264800e-04 1.01714125e-02 3.95506992e-03 -9.15925486e-03\n", " -2.00936965e-03 7.25733448e-03 1.08787867e-02 1.18587833e-02\n", " -9.58381352e-03]\n", " [ 2.87629241e-02 9.09732075e-03 -5.79602784e-02 -6.42016620e-02\n", " -6.36871296e-02 -4.82742391e-02 -6.38538030e-02 -1.90528926e-03\n", " 9.37107175e-03 -3.43178045e-03 -8.12701939e-03 -6.67535713e-03\n", " -1.86426045e-02 -8.66684852e-03 2.43254929e-03 -4.36882962e-03\n", " 8.32521525e-03]\n", " [-6.25800699e-04 -1.96334806e-03 -2.66840166e-03 -3.30753519e-03\n", " 1.14286573e-04 1.42988276e-03 9.20154633e-01 -3.83632241e-04\n", " 5.46510882e-04 1.47669643e-05 3.47002210e-03 7.60685270e-04\n", " 8.14322877e-04 1.75581191e-03 2.02053714e-04 4.49624018e-03\n", " 1.14995481e-03]\n", " [ 8.76314523e-01 1.30352656e-03 -4.69437902e-03 7.49942526e-04\n", " -1.48872719e-03 -6.03239254e-03 -2.39451275e-03 -2.19554384e-03\n", " -2.01688359e-04 2.31708774e-04 -2.44563009e-03 8.29519086e-03\n", " -2.62431774e-03 -2.92991287e-03 1.47890186e-03 2.79280019e-03\n", " 6.80411424e-03]\n", " [ 5.96778951e-03 8.27451435e-01 1.77694286e-02 -3.71081787e-03\n", " 1.62718929e-02 3.85922880e-03 -5.82495968e-03 -1.90075288e-03\n", " 9.06013609e-03 -6.87577774e-04 3.02224131e-03 8.21232872e-03\n", " -4.77693034e-03 2.06468373e-03 -4.13968304e-03 -7.57001501e-03\n", " -5.20581926e-03]\n", " [ 1.27199175e-02 -7.30998753e-03 2.32044136e-01 2.33487791e-01\n", " 2.22610332e-01 2.23465981e-01 1.35978016e-02 3.39062449e-03\n", " -1.58535378e-03 -1.17487462e-03 4.37696249e-03 1.31478691e-02\n", " 1.53600241e-02 6.38439244e-03 8.18357619e-03 -1.60247368e-03\n", " -2.01272116e-02]\n", " [ 1.33973198e-02 -3.91112176e-02 -8.21646648e-03 1.12698430e-02\n", " 9.95368929e-04 2.71698773e-02 5.45530264e-02 5.57162223e-03\n", " -4.27513577e-03 -2.72563490e-03 5.49279283e-03 -1.00586833e-02\n", " -3.28606415e-03 -1.47122086e-02 7.35787206e-03 -3.41086081e-03\n", " -7.42568943e-03]\n", " [-1.39739981e-02 -8.94928206e-03 1.32888438e-02 1.46829964e-02\n", " 1.68172673e-02 -1.24626527e-03 6.17375206e-02 -2.97136398e-03\n", " -5.77341470e-03 3.33107486e-03 -1.14728614e-02 1.30632635e-03\n", " 1.02864363e-02 -3.34803612e-03 8.80772550e-03 1.40247213e-02\n", " -5.18279102e-03]\n", " [ 2.68656764e-02 2.45820570e-02 -9.76984045e-04 1.13583035e-02\n", " 1.41258982e-02 2.46462949e-03 -3.76243932e-03 -5.85395000e-03\n", " 1.03532290e-03 8.16963711e-03 6.26811076e-03 -8.60308436e-03\n", " -6.37585666e-03 8.49752609e-03 1.01030555e-02 1.60698751e-02\n", " -1.22366322e-02]\n", " [ 1.71741385e-02 4.95248890e-03 -7.15597051e-02 -7.82607234e-02\n", " -7.32612181e-02 -6.02245586e-02 -5.54288381e-02 -2.24264410e-03\n", " 8.93001781e-03 -3.12149040e-04 -9.52643686e-03 -7.98770418e-03\n", " -2.14061739e-02 -8.38043420e-03 -3.88531504e-03 -1.45558399e-03\n", " 1.58920242e-02]\n", " [-1.06294074e-03 -2.65078230e-03 -2.84533633e-03 -5.82971025e-03\n", " 1.97754633e-03 6.40923888e-03 8.68422108e-01 1.61949398e-04\n", " -2.34579792e-03 -7.58774828e-04 7.82382684e-04 1.10468113e-03\n", " -2.00109223e-03 2.79841331e-03 -3.45871951e-03 5.57442247e-03\n", " 2.77604751e-03]]\n", "ABC.Distance DEBUG: Scale weights[6] = {'s_p1^1': 1.3690e+00, 's_p2^1': 1.4478e+00, 's_p3^1': 1.6919e+00, 's_p4^1': 2.0158e+01, 's_p1^2': 1.8840e+01, 's_p2^2': 3.6457e+01, 's_p3^2': 7.6750e+00, 's_p4^2': 1.7680e+00, 's_p1^3': 1.5612e+00, 's_p2^3': 1.6691e+00, 's_p3^3': 2.1190e+00, 's_p4^3': 1.9001e+01, 's_p1^4': 2.0079e+01, 's_p2^4': 2.8146e+01, 's_p3^4': 6.5311e+00, 's_p4^4': 1.8716e+00}\n", "ABC INFO: t: 6, eps: 1.37234275e+01.\n", "ABC INFO: Accepted: 1000 / 3691 = 2.7093e-01, ESS: 1.2819e+02.\n", "ABC.Distance DEBUG: Scale weights[7] = {'s_p1^1': 1.5625e+00, 's_p2^1': 1.4516e+00, 's_p3^1': 1.7657e+00, 's_p4^1': 1.9478e+01, 's_p1^2': 1.9394e+01, 's_p2^2': 3.8006e+01, 's_p3^2': 7.8179e+00, 's_p4^2': 1.9016e+00, 's_p1^3': 1.7850e+00, 's_p2^3': 1.6766e+00, 's_p3^3': 2.2346e+00, 's_p4^3': 1.8747e+01, 's_p1^4': 2.1135e+01, 's_p2^4': 2.9855e+01, 's_p3^4': 6.7159e+00, 's_p4^4': 2.0246e+00}\n", "ABC INFO: t: 7, eps: 1.23640875e+01.\n", "ABC INFO: Accepted: 1000 / 6659 = 1.5017e-01, ESS: 7.0947e+02.\n", "ABC.Distance DEBUG: Scale weights[8] = {'s_p1^1': 1.7313e+00, 's_p2^1': 1.6197e+00, 's_p3^1': 1.4878e+00, 's_p4^1': 2.0500e+01, 's_p1^2': 1.7966e+01, 's_p2^2': 3.6743e+01, 's_p3^2': 6.8386e+00, 's_p4^2': 1.6877e+00, 's_p1^3': 1.9756e+00, 's_p2^3': 1.8514e+00, 's_p3^3': 1.8647e+00, 's_p4^3': 1.8922e+01, 's_p1^4': 1.9282e+01, 's_p2^4': 2.8572e+01, 's_p3^4': 5.8604e+00, 's_p4^4': 1.7863e+00}\n", "ABC INFO: t: 8, eps: 1.01883360e+01.\n", "ABC INFO: Accepted: 1000 / 7433 = 1.3454e-01, ESS: 5.6557e+02.\n", "ABC.Distance DEBUG: Scale weights[9] = {'s_p1^1': 1.9133e+00, 's_p2^1': 1.8905e+00, 's_p3^1': 1.9246e+00, 's_p4^1': 2.2856e+01, 's_p1^2': 2.0931e+01, 's_p2^2': 4.1685e+01, 's_p3^2': 8.7301e+00, 's_p4^2': 1.8820e+00, 's_p1^3': 2.1923e+00, 's_p2^3': 2.1916e+00, 's_p3^3': 2.4190e+00, 's_p4^3': 2.1628e+01, 's_p1^4': 2.1949e+01, 's_p2^4': 3.3985e+01, 's_p3^4': 7.4372e+00, 's_p4^4': 1.9971e+00}\n", "ABC INFO: t: 9, eps: 1.03225060e+01.\n", "ABC INFO: Accepted: 1000 / 9692 = 1.0318e-01, ESS: 6.5811e+01.\n", "ABC.Distance DEBUG: Scale weights[10] = {'s_p1^1': 2.4984e+00, 's_p2^1': 2.1868e+00, 's_p3^1': 1.9821e+00, 's_p4^1': 2.4080e+01, 's_p1^2': 2.1430e+01, 's_p2^2': 4.2256e+01, 's_p3^2': 8.8317e+00, 's_p4^2': 1.9412e+00, 's_p1^3': 2.8393e+00, 's_p2^3': 2.5081e+00, 's_p3^3': 2.4766e+00, 's_p4^3': 2.2385e+01, 's_p1^4': 2.2458e+01, 's_p2^4': 3.3949e+01, 's_p3^4': 7.5083e+00, 's_p4^4': 2.0618e+00}\n", "ABC INFO: t: 10, eps: 9.94845850e+00.\n", "ABC INFO: Accepted: 1000 / 17522 = 5.7071e-02, ESS: 6.5216e+02.\n", "ABC.Distance DEBUG: Scale weights[11] = {'s_p1^1': 2.5797e+00, 's_p2^1': 2.3304e+00, 's_p3^1': 1.6310e+00, 's_p4^1': 2.3434e+01, 's_p1^2': 1.9444e+01, 's_p2^2': 4.1726e+01, 's_p3^2': 7.4219e+00, 's_p4^2': 1.7194e+00, 's_p1^3': 2.9249e+00, 's_p2^3': 2.6776e+00, 's_p3^3': 2.0471e+00, 's_p4^3': 2.1381e+01, 's_p1^4': 2.0473e+01, 's_p2^4': 3.4299e+01, 's_p3^4': 6.3034e+00, 's_p4^4': 1.8240e+00}\n", "ABC INFO: t: 11, eps: 8.46651838e+00.\n", "ABC INFO: Accepted: 1000 / 14909 = 6.7074e-02, ESS: 6.1217e+02.\n", "ABC.Distance DEBUG: Scale weights[12] = {'s_p1^1': 3.8851e+00, 's_p2^1': 2.4552e+00, 's_p3^1': 2.0971e+00, 's_p4^1': 2.5210e+01, 's_p1^2': 2.1455e+01, 's_p2^2': 4.3251e+01, 's_p3^2': 9.4128e+00, 's_p4^2': 1.8732e+00, 's_p1^3': 4.4449e+00, 's_p2^3': 2.8282e+00, 's_p3^3': 2.6400e+00, 's_p4^3': 2.2642e+01, 's_p1^4': 2.2430e+01, 's_p2^4': 3.6190e+01, 's_p3^4': 7.9923e+00, 's_p4^4': 1.9853e+00}\n", "ABC INFO: Stop: Total simulations budget.\n", "ABC.History INFO: Done \n", "ABC.Sampler INFO: Parallelize sampling on 4 processes.\n", "ABC.History INFO: Start \n", "ABC INFO: Calibration sample t = -1.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "L1+Ada.+MAD+SensiLR\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "ABC.Distance DEBUG: Scale weights[0] = {'y1': 3.0150e-01, 'y2': 2.7824e-03, 'y3:0': 2.7615e-03, 'y3:1': 2.9441e-03, 'y3:2': 2.8034e-03, 'y3:3': 2.8899e-03, 'y4': 4.5520e+00, 'y5:0': 1.4869e-01, 'y5:1': 1.5296e-01, 'y5:2': 1.5816e-01, 'y5:3': 1.4395e-01, 'y5:4': 1.5551e-01, 'y5:5': 1.4295e-01, 'y5:6': 1.4652e-01, 'y5:7': 1.5257e-01, 'y5:8': 1.4990e-01, 'y5:9': 1.4121e-01}\n", "ABC.Population INFO: Recording also rejected particles: True\n", "ABC.Population INFO: Recording also rejected particles: True\n", "ABC INFO: t: 0, eps: 1.92772734e+01.\n", "ABC INFO: Accepted: 1000 / 1975 = 5.0633e-01, ESS: 1.0000e+03.\n", "ABC.Distance DEBUG: Scale weights[1] = {'y1': 2.8377e-01, 'y2': 2.9485e-03, 'y3:0': 2.7075e-03, 'y3:1': 2.8474e-03, 'y3:2': 2.8313e-03, 'y3:3': 2.8522e-03, 'y4': 4.3678e+00, 'y5:0': 1.5383e-01, 'y5:1': 1.4529e-01, 'y5:2': 1.5591e-01, 'y5:3': 1.4766e-01, 'y5:4': 1.5196e-01, 'y5:5': 1.4831e-01, 'y5:6': 1.5933e-01, 'y5:7': 1.5182e-01, 'y5:8': 1.4658e-01, 'y5:9': 1.4724e-01}\n", "ABC INFO: t: 1, eps: 1.68839789e+01.\n", "ABC INFO: Accepted: 1000 / 2930 = 3.4130e-01, ESS: 8.2233e+02.\n", "ABC.Distance DEBUG: Scale weights[2] = {'y1': 3.2800e-01, 'y2': 3.5557e-03, 'y3:0': 3.6778e-03, 'y3:1': 3.6777e-03, 'y3:2': 3.5765e-03, 'y3:3': 3.6011e-03, 'y4': 5.1697e+00, 'y5:0': 1.5209e-01, 'y5:1': 1.5091e-01, 'y5:2': 1.4854e-01, 'y5:3': 1.4277e-01, 'y5:4': 1.4625e-01, 'y5:5': 1.5492e-01, 'y5:6': 1.4560e-01, 'y5:7': 1.4210e-01, 'y5:8': 1.4691e-01, 'y5:9': 1.4825e-01}\n", "ABC INFO: t: 2, eps: 1.61392223e+01.\n", "ABC INFO: Accepted: 1000 / 4488 = 2.2282e-01, ESS: 6.8232e+02.\n", "ABC.Distance DEBUG: Scale weights[3] = {'y1': 3.4553e-01, 'y2': 3.6582e-03, 'y3:0': 4.0849e-03, 'y3:1': 4.2980e-03, 'y3:2': 4.2035e-03, 'y3:3': 4.2421e-03, 'y4': 5.7293e+00, 'y5:0': 1.4560e-01, 'y5:1': 1.4869e-01, 'y5:2': 1.4653e-01, 'y5:3': 1.4306e-01, 'y5:4': 1.5172e-01, 'y5:5': 1.4930e-01, 'y5:6': 1.5290e-01, 'y5:7': 1.4766e-01, 'y5:8': 1.4528e-01, 'y5:9': 1.4781e-01}\n", "ABC INFO: t: 3, eps: 1.55209850e+01.\n", "ABC INFO: Accepted: 1000 / 6284 = 1.5913e-01, ESS: 7.6418e+02.\n", "ABC.Distance DEBUG: Scale weights[4] = {'y1': 3.8963e-01, 'y2': 3.6697e-03, 'y3:0': 4.7152e-03, 'y3:1': 4.6414e-03, 'y3:2': 4.6223e-03, 'y3:3': 4.7370e-03, 'y4': 6.0951e+00, 'y5:0': 1.5133e-01, 'y5:1': 1.5027e-01, 'y5:2': 1.4847e-01, 'y5:3': 1.4562e-01, 'y5:4': 1.4481e-01, 'y5:5': 1.5238e-01, 'y5:6': 1.5083e-01, 'y5:7': 1.5144e-01, 'y5:8': 1.4729e-01, 'y5:9': 1.4924e-01}\n", "ABC INFO: t: 4, eps: 1.50008507e+01.\n", "ABC INFO: Accepted: 1000 / 9432 = 1.0602e-01, ESS: 4.4768e+02.\n", "ABC.Distance DEBUG: Scale weights[5] = {'y1': 4.2876e-01, 'y2': 4.0297e-03, 'y3:0': 5.2911e-03, 'y3:1': 5.2451e-03, 'y3:2': 5.3291e-03, 'y3:3': 5.4409e-03, 'y4': 5.9510e+00, 'y5:0': 1.4590e-01, 'y5:1': 1.5094e-01, 'y5:2': 1.4937e-01, 'y5:3': 1.4755e-01, 'y5:4': 1.4817e-01, 'y5:5': 1.4640e-01, 'y5:6': 1.4594e-01, 'y5:7': 1.4589e-01, 'y5:8': 1.4631e-01, 'y5:9': 1.4482e-01}\n", "ABC INFO: t: 5, eps: 1.44154487e+01.\n", "ABC INFO: Accepted: 1000 / 15471 = 6.4637e-02, ESS: 5.3378e+02.\n", "ABC.Distance DEBUG: Scale weights[6] = {'y1': 4.2999e-01, 'y2': 4.0846e-03, 'y3:0': 5.3919e-03, 'y3:1': 5.3642e-03, 'y3:2': 5.3249e-03, 'y3:3': 5.3809e-03, 'y4': 6.4527e+00, 'y5:0': 1.4656e-01, 'y5:1': 1.4889e-01, 'y5:2': 1.4897e-01, 'y5:3': 1.4938e-01, 'y5:4': 1.4779e-01, 'y5:5': 1.4796e-01, 'y5:6': 1.4813e-01, 'y5:7': 1.4685e-01, 'y5:8': 1.4725e-01, 'y5:9': 1.5146e-01}\n", "ABC.Predictor INFO: Fitted in 0.01s\n", "ABC.Predictor INFO: Pearson correlations: 1.000 0.955 0.890 0.078\n", "ABC.Predictor DEBUG: Linear regression coefficients (n_target, n_feature):\n", "[[ 9.99505960e-01 5.06331385e-04 1.98724232e-04 6.49224356e-04\n", " -9.27269004e-05 5.82686633e-05 3.31357444e-04 -1.79866552e-04\n", " 2.84368115e-04 1.19795829e-04 -8.35634747e-05 1.97516381e-04\n", " -2.11504669e-04 -1.04215601e-04 -1.41961315e-04 9.57926735e-05\n", " 2.97832771e-05]\n", " [ 7.97678398e-05 9.53973936e-01 -2.14726363e-03 -2.68573550e-03\n", " -4.36075109e-03 -2.48727609e-03 -1.57920770e-03 4.47055467e-03\n", " -6.51982765e-04 1.42307469e-03 4.29395830e-03 1.09203904e-05\n", " -4.50272110e-03 3.04646042e-03 -1.05339461e-03 9.99928306e-04\n", " -5.35562693e-05]\n", " [ 1.03822406e-02 -2.36336729e-02 2.89615388e-01 2.83093363e-01\n", " 2.81648079e-01 2.75534880e-01 -9.87834276e-03 -3.76521626e-05\n", " 1.45724359e-03 -2.16436282e-03 -6.86677212e-03 -3.90985077e-04\n", " 3.93469411e-03 -4.24750038e-03 3.95140603e-03 6.06811872e-03\n", " 1.88138504e-03]\n", " [-6.62215494e-03 3.40491371e-02 9.69950851e-03 2.59583742e-02\n", " 1.73689401e-03 2.90470203e-02 -2.32474569e-03 7.79645306e-03\n", " 2.69902759e-02 1.16379453e-02 -1.01635698e-02 -2.75373936e-02\n", " -5.03465669e-04 7.95753133e-03 -1.73128732e-02 -5.38443607e-03\n", " 9.27345913e-03]]\n", "ABC.Distance DEBUG: Optimal FD delta: [0.1 0.1 0.1 0.01 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1\n", " 0.1 0.1 0.1 ]\n", "ABC.Distance DEBUG: Info weights[6] = {'y1': 1.0370e+00, 'y2': 1.1459e+00, 'y3:0': 2.8091e-01, 'y3:1': 3.4582e-01, 'y3:2': 2.4562e-01, 'y3:3': 3.5396e-01, 'y4': 1.8043e-02, 'y5:0': 3.7897e-02, 'y5:1': 1.1608e-01, 'y5:2': 5.1964e-02, 'y5:3': 5.2608e-02, 'y5:4': 1.1653e-01, 'y5:5': 9.8349e-03, 'y5:6': 4.0609e-02, 'y5:7': 7.7841e-02, 'y5:8': 2.9043e-02, 'y5:9': 4.0342e-02}\n", "ABC INFO: t: 6, eps: 3.41013611e+00.\n", "ABC INFO: Accepted: 1000 / 3945 = 2.5349e-01, ESS: 6.2250e+02.\n", "ABC.Distance DEBUG: Scale weights[7] = {'y1': 4.8149e-01, 'y2': 4.1963e-03, 'y3:0': 5.7683e-03, 'y3:1': 5.8005e-03, 'y3:2': 5.6042e-03, 'y3:3': 5.7032e-03, 'y4': 6.3354e+00, 'y5:0': 1.4814e-01, 'y5:1': 1.4868e-01, 'y5:2': 1.5187e-01, 'y5:3': 1.4827e-01, 'y5:4': 1.4769e-01, 'y5:5': 1.4542e-01, 'y5:6': 1.4911e-01, 'y5:7': 1.4657e-01, 'y5:8': 1.4387e-01, 'y5:9': 1.4754e-01}\n", "ABC INFO: t: 7, eps: 3.08936405e+00.\n", "ABC INFO: Accepted: 1000 / 3571 = 2.8003e-01, ESS: 7.2115e+02.\n", "ABC.Distance DEBUG: Scale weights[8] = {'y1': 9.2029e-01, 'y2': 6.8780e-03, 'y3:0': 5.2832e-03, 'y3:1': 5.3990e-03, 'y3:2': 5.4486e-03, 'y3:3': 5.2554e-03, 'y4': 5.4432e+00, 'y5:0': 1.5054e-01, 'y5:1': 1.4689e-01, 'y5:2': 1.4756e-01, 'y5:3': 1.4784e-01, 'y5:4': 1.5015e-01, 'y5:5': 1.5320e-01, 'y5:6': 1.4733e-01, 'y5:7': 1.4586e-01, 'y5:8': 1.4476e-01, 'y5:9': 1.4680e-01}\n", "ABC INFO: t: 8, eps: 3.25680313e+00.\n", "ABC INFO: Accepted: 1000 / 3967 = 2.5208e-01, ESS: 7.1272e+02.\n", "ABC.Distance DEBUG: Scale weights[9] = {'y1': 1.3387e+00, 'y2': 8.0504e-03, 'y3:0': 5.7341e-03, 'y3:1': 5.7367e-03, 'y3:2': 5.5893e-03, 'y3:3': 5.5547e-03, 'y4': 5.5734e+00, 'y5:0': 1.5191e-01, 'y5:1': 1.4728e-01, 'y5:2': 1.5207e-01, 'y5:3': 1.4980e-01, 'y5:4': 1.4617e-01, 'y5:5': 1.4725e-01, 'y5:6': 1.4786e-01, 'y5:7': 1.5477e-01, 'y5:8': 1.4939e-01, 'y5:9': 1.4476e-01}\n", "ABC INFO: t: 9, eps: 3.20569742e+00.\n", "ABC INFO: Accepted: 1000 / 4924 = 2.0309e-01, ESS: 5.4541e+02.\n", "ABC.Distance DEBUG: Scale weights[10] = {'y1': 1.9327e+00, 'y2': 8.4124e-03, 'y3:0': 5.6746e-03, 'y3:1': 5.7413e-03, 'y3:2': 5.5302e-03, 'y3:3': 5.6135e-03, 'y4': 5.4430e+00, 'y5:0': 1.4433e-01, 'y5:1': 1.5127e-01, 'y5:2': 1.4593e-01, 'y5:3': 1.5161e-01, 'y5:4': 1.5110e-01, 'y5:5': 1.4552e-01, 'y5:6': 1.5001e-01, 'y5:7': 1.4830e-01, 'y5:8': 1.5105e-01, 'y5:9': 1.4678e-01}\n", "ABC INFO: t: 10, eps: 2.98950818e+00.\n", "ABC INFO: Accepted: 1000 / 6007 = 1.6647e-01, ESS: 5.0535e+02.\n", "ABC.Distance DEBUG: Scale weights[11] = {'y1': 2.9024e+00, 'y2': 9.3798e-03, 'y3:0': 5.5734e-03, 'y3:1': 5.3665e-03, 'y3:2': 5.5896e-03, 'y3:3': 5.4790e-03, 'y4': 5.1359e+00, 'y5:0': 1.4794e-01, 'y5:1': 1.4645e-01, 'y5:2': 1.4794e-01, 'y5:3': 1.4766e-01, 'y5:4': 1.4778e-01, 'y5:5': 1.5242e-01, 'y5:6': 1.4822e-01, 'y5:7': 1.5010e-01, 'y5:8': 1.4679e-01, 'y5:9': 1.4820e-01}\n", "ABC INFO: t: 11, eps: 2.83424965e+00.\n", "ABC INFO: Accepted: 1000 / 7445 = 1.3432e-01, ESS: 6.0355e+02.\n", "ABC.Distance DEBUG: Scale weights[12] = {'y1': 4.5457e+00, 'y2': 8.9210e-03, 'y3:0': 5.6495e-03, 'y3:1': 5.6173e-03, 'y3:2': 5.7553e-03, 'y3:3': 5.5339e-03, 'y4': 5.3425e+00, 'y5:0': 1.5017e-01, 'y5:1': 1.4725e-01, 'y5:2': 1.4874e-01, 'y5:3': 1.4501e-01, 'y5:4': 1.4321e-01, 'y5:5': 1.4677e-01, 'y5:6': 1.4888e-01, 'y5:7': 1.4672e-01, 'y5:8': 1.5033e-01, 'y5:9': 1.4516e-01}\n", "ABC INFO: t: 12, eps: 2.68180644e+00.\n", "ABC INFO: Accepted: 1000 / 9886 = 1.0115e-01, ESS: 6.0227e+02.\n", "ABC.Distance DEBUG: Scale weights[13] = {'y1': 6.3874e+00, 'y2': 9.2961e-03, 'y3:0': 5.7875e-03, 'y3:1': 5.6329e-03, 'y3:2': 5.7978e-03, 'y3:3': 5.8240e-03, 'y4': 5.4496e+00, 'y5:0': 1.4906e-01, 'y5:1': 1.4630e-01, 'y5:2': 1.4846e-01, 'y5:3': 1.4924e-01, 'y5:4': 1.4633e-01, 'y5:5': 1.4622e-01, 'y5:6': 1.4883e-01, 'y5:7': 1.4429e-01, 'y5:8': 1.4710e-01, 'y5:9': 1.5105e-01}\n", "ABC INFO: t: 13, eps: 2.55883444e+00.\n", "ABC INFO: Accepted: 1000 / 14493 = 6.8999e-02, ESS: 4.7837e+02.\n", "ABC.Distance DEBUG: Scale weights[14] = {'y1': 7.8777e+00, 'y2': 9.9930e-03, 'y3:0': 5.8969e-03, 'y3:1': 5.8393e-03, 'y3:2': 5.8364e-03, 'y3:3': 5.7734e-03, 'y4': 5.4041e+00, 'y5:0': 1.4911e-01, 'y5:1': 1.4758e-01, 'y5:2': 1.4736e-01, 'y5:3': 1.4716e-01, 'y5:4': 1.4780e-01, 'y5:5': 1.4812e-01, 'y5:6': 1.4770e-01, 'y5:7': 1.4886e-01, 'y5:8': 1.4654e-01, 'y5:9': 1.5054e-01}\n", "ABC INFO: t: 14, eps: 2.39374197e+00.\n", "ABC INFO: Accepted: 1000 / 22574 = 4.4299e-02, ESS: 2.5037e+02.\n", "ABC.Distance DEBUG: Scale weights[15] = {'y1': 9.2921e+00, 'y2': 9.8073e-03, 'y3:0': 6.0602e-03, 'y3:1': 6.0103e-03, 'y3:2': 6.0713e-03, 'y3:3': 5.9636e-03, 'y4': 5.5552e+00, 'y5:0': 1.4657e-01, 'y5:1': 1.4723e-01, 'y5:2': 1.4786e-01, 'y5:3': 1.4790e-01, 'y5:4': 1.4593e-01, 'y5:5': 1.4750e-01, 'y5:6': 1.4739e-01, 'y5:7': 1.4779e-01, 'y5:8': 1.4746e-01, 'y5:9': 1.4869e-01}\n", "ABC INFO: Stop: Total simulations budget.\n", "ABC.History INFO: Done \n", "ABC.Sampler INFO: Parallelize sampling on 4 processes.\n", "ABC.History INFO: Start \n", "ABC INFO: Calibration sample t = -1.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "L1+Ada.+MAD+SensiLR+P4\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "ABC.Distance DEBUG: Scale weights[0] = {'y1': 3.0537e-01, 'y2': 2.8441e-03, 'y3:0': 2.8437e-03, 'y3:1': 2.5888e-03, 'y3:2': 2.7542e-03, 'y3:3': 2.8230e-03, 'y4': 4.8179e+00, 'y5:0': 1.4825e-01, 'y5:1': 1.4457e-01, 'y5:2': 1.5298e-01, 'y5:3': 1.4922e-01, 'y5:4': 1.4718e-01, 'y5:5': 1.4664e-01, 'y5:6': 1.4813e-01, 'y5:7': 1.4736e-01, 'y5:8': 1.5168e-01, 'y5:9': 1.4919e-01}\n", "ABC.Population INFO: Recording also rejected particles: True\n", "ABC.Population INFO: Recording also rejected particles: True\n", "ABC INFO: t: 0, eps: 1.92658228e+01.\n", "ABC INFO: Accepted: 1000 / 2052 = 4.8733e-01, ESS: 1.0000e+03.\n", "ABC.Distance DEBUG: Scale weights[1] = {'y1': 2.8694e-01, 'y2': 2.8590e-03, 'y3:0': 2.7455e-03, 'y3:1': 2.6707e-03, 'y3:2': 2.8282e-03, 'y3:3': 2.7406e-03, 'y4': 4.5965e+00, 'y5:0': 1.4733e-01, 'y5:1': 1.5229e-01, 'y5:2': 1.4179e-01, 'y5:3': 1.4988e-01, 'y5:4': 1.4262e-01, 'y5:5': 1.4545e-01, 'y5:6': 1.4481e-01, 'y5:7': 1.4590e-01, 'y5:8': 1.5127e-01, 'y5:9': 1.4650e-01}\n", "ABC INFO: t: 1, eps: 1.65432416e+01.\n", "ABC INFO: Accepted: 1000 / 2805 = 3.5651e-01, ESS: 8.2051e+02.\n", "ABC.Distance DEBUG: Scale weights[2] = {'y1': 3.2767e-01, 'y2': 3.4156e-03, 'y3:0': 3.6100e-03, 'y3:1': 3.5093e-03, 'y3:2': 3.6095e-03, 'y3:3': 3.5531e-03, 'y4': 5.7057e+00, 'y5:0': 1.5678e-01, 'y5:1': 1.4765e-01, 'y5:2': 1.4942e-01, 'y5:3': 1.4357e-01, 'y5:4': 1.4967e-01, 'y5:5': 1.4921e-01, 'y5:6': 1.5103e-01, 'y5:7': 1.5058e-01, 'y5:8': 1.4552e-01, 'y5:9': 1.5508e-01}\n", "ABC INFO: t: 2, eps: 1.63761812e+01.\n", "ABC INFO: Accepted: 1000 / 4243 = 2.3568e-01, ESS: 7.7280e+02.\n", "ABC.Distance DEBUG: Scale weights[3] = {'y1': 3.5603e-01, 'y2': 3.6163e-03, 'y3:0': 4.2498e-03, 'y3:1': 4.1430e-03, 'y3:2': 4.2602e-03, 'y3:3': 4.3458e-03, 'y4': 5.8988e+00, 'y5:0': 1.4953e-01, 'y5:1': 1.5370e-01, 'y5:2': 1.4384e-01, 'y5:3': 1.4341e-01, 'y5:4': 1.5126e-01, 'y5:5': 1.5254e-01, 'y5:6': 1.4732e-01, 'y5:7': 1.4856e-01, 'y5:8': 1.4938e-01, 'y5:9': 1.4586e-01}\n", "ABC INFO: t: 3, eps: 1.54018211e+01.\n", "ABC INFO: Accepted: 1000 / 6935 = 1.4420e-01, ESS: 6.4810e+02.\n", "ABC.Distance DEBUG: Scale weights[4] = {'y1': 3.9915e-01, 'y2': 3.7827e-03, 'y3:0': 4.7571e-03, 'y3:1': 4.8260e-03, 'y3:2': 4.7792e-03, 'y3:3': 4.8713e-03, 'y4': 6.2252e+00, 'y5:0': 1.5107e-01, 'y5:1': 1.4890e-01, 'y5:2': 1.4624e-01, 'y5:3': 1.4770e-01, 'y5:4': 1.4854e-01, 'y5:5': 1.4669e-01, 'y5:6': 1.4648e-01, 'y5:7': 1.5307e-01, 'y5:8': 1.4702e-01, 'y5:9': 1.4776e-01}\n", "ABC INFO: t: 4, eps: 1.46632824e+01.\n", "ABC INFO: Accepted: 1000 / 10959 = 9.1249e-02, ESS: 6.2475e+02.\n", "ABC.Distance DEBUG: Scale weights[5] = {'y1': 4.2331e-01, 'y2': 3.9298e-03, 'y3:0': 5.3554e-03, 'y3:1': 5.3350e-03, 'y3:2': 5.3235e-03, 'y3:3': 5.3094e-03, 'y4': 6.4311e+00, 'y5:0': 1.4832e-01, 'y5:1': 1.4896e-01, 'y5:2': 1.4839e-01, 'y5:3': 1.4820e-01, 'y5:4': 1.4770e-01, 'y5:5': 1.5282e-01, 'y5:6': 1.4834e-01, 'y5:7': 1.4746e-01, 'y5:8': 1.4865e-01, 'y5:9': 1.4801e-01}\n", "ABC INFO: t: 5, eps: 1.41605699e+01.\n", "ABC INFO: Accepted: 1000 / 16573 = 6.0339e-02, ESS: 4.8160e+02.\n", "ABC.Distance DEBUG: Scale weights[6] = {'y1': 4.5506e-01, 'y2': 4.1339e-03, 'y3:0': 5.7586e-03, 'y3:1': 5.7424e-03, 'y3:2': 5.8308e-03, 'y3:3': 5.6785e-03, 'y4': 6.1080e+00, 'y5:0': 1.4924e-01, 'y5:1': 1.4785e-01, 'y5:2': 1.4912e-01, 'y5:3': 1.4667e-01, 'y5:4': 1.4854e-01, 'y5:5': 1.4818e-01, 'y5:6': 1.4686e-01, 'y5:7': 1.5071e-01, 'y5:8': 1.4947e-01, 'y5:9': 1.4931e-01}\n", "ABC.Predictor INFO: Fitted in 0.02s\n", "ABC.Predictor INFO: Pearson correlations: 0.999 0.953 0.850 0.124 0.081 0.077 0.082 0.925 0.867 0.827 0.683 0.121 0.079 0.086 0.094 0.875\n", "ABC.Predictor DEBUG: Linear regression coefficients (n_target, n_feature):\n", "[[ 9.99467799e-01 -6.08456786e-05 -5.96816711e-05 -9.77668494e-05\n", " 2.39617680e-04 -8.92999377e-05 4.22410927e-05 1.69655282e-04\n", " -4.44860924e-05 1.86195873e-04 5.05596525e-04 3.79109863e-04\n", " 1.75463461e-04 -7.70261189e-05 4.95800243e-04 -1.72393054e-04\n", " -2.52460553e-04]\n", " [-3.94005909e-03 9.52625808e-01 -1.51758187e-03 -1.29099679e-03\n", " 2.78521627e-03 -7.00666584e-03 1.34386758e-04 -1.61199310e-03\n", " 2.52300175e-03 5.72280693e-03 -3.80291728e-03 6.88461560e-04\n", " -2.19637490e-03 -2.95666180e-05 3.04181510e-03 6.69539045e-03\n", " 3.15937444e-05]\n", " [ 1.50406124e-02 -1.19775493e-02 2.94759912e-01 2.89398576e-01\n", " 2.83188362e-01 2.84292226e-01 -1.79451966e-03 3.10644248e-03\n", " -7.93030482e-03 -5.34238685e-03 3.36709745e-03 -5.27885998e-04\n", " 1.33833095e-03 -4.90404382e-03 4.91586834e-03 2.48544435e-03\n", " 6.65773906e-03]\n", " [-4.29727247e-02 6.78809588e-02 -3.75164640e-02 -2.73419876e-02\n", " -2.94059185e-02 -2.33241195e-02 6.92171987e-03 5.98383634e-03\n", " -7.92166171e-03 -7.71487811e-03 -4.53864121e-03 -1.02870134e-02\n", " 2.72949986e-03 -1.61452844e-03 -1.35030681e-03 -5.27953011e-03\n", " 8.75565996e-03]\n", " [-5.46831600e-02 -3.89667658e-02 4.51058656e-03 1.49600678e-03\n", " 3.59513775e-02 4.19507023e-04 2.17130079e-02 7.94630106e-03\n", " -2.38982129e-03 6.63414175e-03 7.16806574e-03 -1.08874688e-02\n", " -4.08254398e-03 -5.91218983e-03 -9.18105497e-04 2.66562589e-03\n", " -1.11885793e-02]\n", " [-4.33170926e-02 -5.84786903e-02 1.48555950e-02 -6.83098761e-03\n", " -1.52933134e-02 1.51730784e-03 -3.75059409e-03 8.90618583e-05\n", " -1.00873073e-02 -4.43976636e-03 -6.69733662e-03 2.65948070e-03\n", " 3.08437689e-03 -9.78588767e-03 -5.56294130e-03 2.38408934e-03\n", " -1.15231963e-02]\n", " [-6.87404238e-02 2.61986061e-02 -1.28884618e-02 -4.03627600e-03\n", " -1.42847406e-02 1.63582062e-03 6.37321997e-03 4.91841683e-03\n", " 5.33362087e-03 -6.48723330e-03 5.54300308e-03 -3.21128457e-03\n", " 9.90302942e-03 2.87963380e-04 -1.66737282e-03 -1.72875830e-03\n", " -6.80467921e-03]\n", " [ 1.42623400e-03 -2.56332770e-03 3.46320867e-03 -6.06217730e-03\n", " -9.62905690e-04 2.54571955e-03 9.24946371e-01 -3.42009163e-03\n", " 3.31886338e-04 1.49397518e-03 2.69706465e-03 -2.81370032e-03\n", " -2.28303040e-03 -3.92370621e-03 4.12718816e-03 3.91637455e-03\n", " -6.37193916e-04]\n", " [ 8.67776728e-01 1.76252848e-02 -1.59609770e-02 -1.10021771e-03\n", " -7.97046781e-03 -2.19411708e-03 1.67970973e-02 8.36228086e-03\n", " -3.09691241e-04 -3.52425528e-03 -1.67665097e-03 5.33739631e-03\n", " -3.20494515e-03 2.49444727e-03 6.48756694e-03 9.21098220e-04\n", " 2.02104810e-03]\n", " [ 1.09887225e-02 8.26910701e-01 3.43621313e-03 -1.17949386e-03\n", " -1.13712786e-03 5.32917668e-04 1.57859662e-02 4.16087998e-04\n", " 3.24019382e-03 8.08376849e-03 -8.69719681e-04 -2.08583364e-03\n", " 2.57782439e-03 -5.88183165e-03 1.34058318e-03 9.40357644e-04\n", " 1.49951536e-03]\n", " [ 9.26484417e-03 -2.28874913e-02 2.31666085e-01 2.36306181e-01\n", " 2.31689570e-01 2.23534208e-01 -2.67149060e-02 4.46423506e-03\n", " -1.52495534e-03 -6.65712901e-03 7.22358909e-04 -1.07947284e-03\n", " 6.94144197e-04 -7.03428292e-03 -3.75406598e-03 -2.87239767e-03\n", " 3.08042348e-03]\n", " [-5.30008965e-02 6.90398917e-02 -3.46661020e-02 -1.86209478e-02\n", " -2.68786349e-02 -2.19446837e-02 3.65099894e-03 5.90193471e-03\n", " -5.48885782e-03 -3.09419571e-03 -3.62972114e-03 -7.84707926e-03\n", " 1.03394692e-03 -1.00174257e-03 -2.03988489e-03 -5.74044890e-04\n", " 1.06075451e-02]\n", " [-5.15345592e-02 -4.19702203e-02 1.21489375e-03 4.20093667e-03\n", " 3.64183975e-02 -2.70566105e-03 1.76865186e-02 -4.32720328e-04\n", " 1.83833456e-03 6.71729366e-03 3.78006425e-03 -1.29479534e-02\n", " -6.70705751e-03 -4.27785521e-03 -7.21097946e-03 4.21828780e-03\n", " -1.14203158e-02]\n", " [-4.48414873e-02 -6.87463587e-02 1.35411494e-02 -6.93410175e-03\n", " -1.49342063e-02 -1.33310349e-03 -5.32773253e-03 2.47821474e-03\n", " -9.93593523e-03 -2.46717612e-04 -9.68411133e-03 4.67410859e-03\n", " 2.55456077e-03 -9.86139778e-03 -4.56848597e-03 7.08141059e-03\n", " -1.07708475e-02]\n", " [-7.07037518e-02 4.26174467e-02 -1.38803772e-02 -2.92668410e-03\n", " -1.30301447e-02 -1.01603196e-02 9.75524943e-03 3.74548101e-03\n", " 3.88866090e-03 -9.72738112e-03 4.86491845e-03 -3.37795309e-03\n", " 1.56065048e-02 1.12536529e-04 1.58877810e-03 -2.32148916e-03\n", " -1.62344213e-03]\n", " [-7.99673387e-04 -6.88926811e-03 5.91311630e-03 -1.21272789e-02\n", " 2.71141710e-03 -1.96249299e-03 8.74733027e-01 -2.78978613e-03\n", " 3.25261770e-03 1.44845562e-03 2.53036895e-03 -5.09965067e-03\n", " -2.33374550e-03 -1.03569847e-03 6.06843672e-03 4.24396614e-03\n", " -2.57304341e-03]]\n", "ABC.Distance DEBUG: Optimal FD delta: [0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1]\n", "ABC.Distance DEBUG: Info weights[6] = {'y1': 3.9726e+00, 'y2': 3.8846e+00, 'y3:0': 1.0378e+00, 'y3:1': 7.8093e-01, 'y3:2': 1.2633e+00, 'y3:3': 7.1563e-01, 'y4': 2.2445e+00, 'y5:0': 1.5802e-01, 'y5:1': 2.2227e-01, 'y5:2': 2.3051e-01, 'y5:3': 2.2248e-01, 'y5:4': 2.5606e-01, 'y5:5': 2.2768e-01, 'y5:6': 1.7441e-01, 'y5:7': 1.4169e-01, 'y5:8': 1.3541e-01, 'y5:9': 3.3218e-01}\n", "ABC INFO: t: 6, eps: 1.42162817e+01.\n", "ABC INFO: Accepted: 1000 / 4370 = 2.2883e-01, ESS: 4.7835e+02.\n", "ABC.Distance DEBUG: Scale weights[7] = {'y1': 5.0399e-01, 'y2': 4.1726e-03, 'y3:0': 5.8194e-03, 'y3:1': 5.8915e-03, 'y3:2': 5.7821e-03, 'y3:3': 5.7917e-03, 'y4': 6.6940e+00, 'y5:0': 1.4639e-01, 'y5:1': 1.4925e-01, 'y5:2': 1.4917e-01, 'y5:3': 1.4544e-01, 'y5:4': 1.4720e-01, 'y5:5': 1.5076e-01, 'y5:6': 1.4693e-01, 'y5:7': 1.4707e-01, 'y5:8': 1.4493e-01, 'y5:9': 1.4968e-01}\n", "ABC INFO: t: 7, eps: 1.31240624e+01.\n", "ABC INFO: Accepted: 1000 / 3994 = 2.5038e-01, ESS: 7.5321e+02.\n", "ABC.Distance DEBUG: Scale weights[8] = {'y1': 9.0430e-01, 'y2': 6.0646e-03, 'y3:0': 5.3165e-03, 'y3:1': 5.3546e-03, 'y3:2': 5.2800e-03, 'y3:3': 5.1171e-03, 'y4': 6.4189e+00, 'y5:0': 1.4621e-01, 'y5:1': 1.4882e-01, 'y5:2': 1.5259e-01, 'y5:3': 1.4952e-01, 'y5:4': 1.4771e-01, 'y5:5': 1.4516e-01, 'y5:6': 1.5138e-01, 'y5:7': 1.4365e-01, 'y5:8': 1.4591e-01, 'y5:9': 1.4701e-01}\n", "ABC INFO: t: 8, eps: 1.33303433e+01.\n", "ABC INFO: Accepted: 1000 / 4567 = 2.1896e-01, ESS: 7.5763e+02.\n", "ABC.Distance DEBUG: Scale weights[9] = {'y1': 1.2052e+00, 'y2': 6.9590e-03, 'y3:0': 5.5645e-03, 'y3:1': 5.4895e-03, 'y3:2': 5.3951e-03, 'y3:3': 5.5151e-03, 'y4': 6.8727e+00, 'y5:0': 1.5124e-01, 'y5:1': 1.4969e-01, 'y5:2': 1.4966e-01, 'y5:3': 1.4703e-01, 'y5:4': 1.4538e-01, 'y5:5': 1.4690e-01, 'y5:6': 1.4796e-01, 'y5:7': 1.4861e-01, 'y5:8': 1.4932e-01, 'y5:9': 1.4850e-01}\n", "ABC INFO: t: 9, eps: 1.29931588e+01.\n", "ABC INFO: Accepted: 1000 / 4872 = 2.0525e-01, ESS: 6.8956e+02.\n", "ABC.Distance DEBUG: Scale weights[10] = {'y1': 1.8756e+00, 'y2': 8.2983e-03, 'y3:0': 5.4316e-03, 'y3:1': 5.4255e-03, 'y3:2': 5.4896e-03, 'y3:3': 5.3516e-03, 'y4': 6.6145e+00, 'y5:0': 1.4891e-01, 'y5:1': 1.4981e-01, 'y5:2': 1.4863e-01, 'y5:3': 1.4950e-01, 'y5:4': 1.5153e-01, 'y5:5': 1.4800e-01, 'y5:6': 1.4474e-01, 'y5:7': 1.4879e-01, 'y5:8': 1.4695e-01, 'y5:9': 1.4912e-01}\n", "ABC INFO: t: 10, eps: 1.26075916e+01.\n", "ABC INFO: Accepted: 1000 / 6034 = 1.6573e-01, ESS: 4.1603e+02.\n", "ABC.Distance DEBUG: Scale weights[11] = {'y1': 2.7631e+00, 'y2': 8.9946e-03, 'y3:0': 5.2964e-03, 'y3:1': 5.3974e-03, 'y3:2': 5.3363e-03, 'y3:3': 5.3291e-03, 'y4': 6.6998e+00, 'y5:0': 1.4870e-01, 'y5:1': 1.4891e-01, 'y5:2': 1.4816e-01, 'y5:3': 1.5172e-01, 'y5:4': 1.5236e-01, 'y5:5': 1.5108e-01, 'y5:6': 1.4806e-01, 'y5:7': 1.4726e-01, 'y5:8': 1.4946e-01, 'y5:9': 1.4760e-01}\n", "ABC INFO: t: 11, eps: 1.19787516e+01.\n", "ABC INFO: Accepted: 1000 / 8894 = 1.1244e-01, ESS: 7.2872e+02.\n", "ABC.Distance DEBUG: Scale weights[12] = {'y1': 4.2505e+00, 'y2': 8.7372e-03, 'y3:0': 5.0485e-03, 'y3:1': 5.2558e-03, 'y3:2': 5.0977e-03, 'y3:3': 5.0384e-03, 'y4': 6.3470e+00, 'y5:0': 1.4950e-01, 'y5:1': 1.4874e-01, 'y5:2': 1.4968e-01, 'y5:3': 1.4879e-01, 'y5:4': 1.4772e-01, 'y5:5': 1.5010e-01, 'y5:6': 1.4699e-01, 'y5:7': 1.4370e-01, 'y5:8': 1.5178e-01, 'y5:9': 1.4991e-01}\n", "ABC INFO: t: 12, eps: 1.10735248e+01.\n", "ABC INFO: Accepted: 1000 / 9583 = 1.0435e-01, ESS: 3.1046e+02.\n", "ABC.Distance DEBUG: Scale weights[13] = {'y1': 6.0975e+00, 'y2': 9.5923e-03, 'y3:0': 5.5449e-03, 'y3:1': 5.4214e-03, 'y3:2': 5.4842e-03, 'y3:3': 5.4284e-03, 'y4': 6.8227e+00, 'y5:0': 1.4732e-01, 'y5:1': 1.4950e-01, 'y5:2': 1.4835e-01, 'y5:3': 1.4972e-01, 'y5:4': 1.4826e-01, 'y5:5': 1.4887e-01, 'y5:6': 1.4885e-01, 'y5:7': 1.5098e-01, 'y5:8': 1.4742e-01, 'y5:9': 1.4688e-01}\n", "ABC INFO: t: 13, eps: 1.08800857e+01.\n", "ABC INFO: Accepted: 1000 / 17057 = 5.8627e-02, ESS: 6.3732e+02.\n", "ABC.Distance DEBUG: Scale weights[14] = {'y1': 7.5116e+00, 'y2': 8.9793e-03, 'y3:0': 5.2835e-03, 'y3:1': 5.2556e-03, 'y3:2': 5.2562e-03, 'y3:3': 5.2838e-03, 'y4': 6.7129e+00, 'y5:0': 1.5036e-01, 'y5:1': 1.4885e-01, 'y5:2': 1.4743e-01, 'y5:3': 1.4917e-01, 'y5:4': 1.4989e-01, 'y5:5': 1.4812e-01, 'y5:6': 1.4792e-01, 'y5:7': 1.4949e-01, 'y5:8': 1.4977e-01, 'y5:9': 1.5026e-01}\n", "ABC INFO: Stop: Total simulations budget.\n", "ABC.History INFO: Done \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 4min 20s, sys: 20.9 s, total: 4min 41s\n", "Wall time: 11min 23s\n" ] } ], "source": [ "%%time\n", "\n", "# runs\n", "\n", "db_file = tempfile.mkstemp(suffix=\".db\")[1]\n", "\n", "scale_log_file = tempfile.mkstemp()[1]\n", "info_log_file = tempfile.mkstemp()[1]\n", "info_sample_log_file = tempfile.mkstemp()[1]\n", "\n", "hs = []\n", "for distance_id, distance in distances.items():\n", " print(distance_id)\n", " if isinstance(distance, AdaptivePNormDistance):\n", " distance.scale_log_file = f\"{scale_log_file}_{distance_id}.json\"\n", " if isinstance(distance, InfoWeightedPNormDistance):\n", " distance.info_log_file = f\"{info_log_file}_{distance_id}.json\"\n", " distance.info_sample_log_file = f\"{info_sample_log_file}_{distance_id}\"\n", "\n", " abc = pyabc.ABCSMC(model, prior, distance, population_size=pop_size)\n", " h = abc.new(db=\"sqlite:///\" + db_file, observed_sum_stat=data)\n", " abc.run(max_total_nr_simulations=total_sims)\n", " hs.append(h)" ] }, { "cell_type": "markdown", "id": "59f2c1d4-436c-45e1-956b-149361c694e2", "metadata": {}, "source": [ "While overall all approaches would benefit from a continued analysis, the approaches L1+Ada.+MAD+StatLR+P4 and L1+Ada.+MAD+SensiLR+P4 employing scale normalization, accounting for informativeness, and using augmented regression targets, approximate the true posterior distribution best.\n", "Using only scale normalization captures the overall dynamics, however gives large uncertainties, as unnecessary emphasis is put on $y_5$.\n", "Approaches only using $\\theta$ as regression targets however fail to capture the dynamics of $\\theta_4$, as the regression model cannot unravel a meaningful relationship between data and parameters." ] }, { "cell_type": "code", "execution_count": 12, "id": "22aeae10-4dd4-4212-afe3-71ba2f20bb87", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "ABC.Transition INFO: Best params: {'scaling': 0.2875}\n", "ABC.Transition INFO: Best params: {'scaling': 0.05}\n", "ABC.Transition INFO: Best params: {'scaling': 0.05}\n", "ABC.Transition INFO: Best params: {'scaling': 0.05}\n", "ABC.Transition INFO: Best params: {'scaling': 0.05}\n", "ABC.Transition INFO: Best params: {'scaling': 0.2875}\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, axes = plt.subplots(ncols=len(prior_bounds), figsize=(16, 4))\n", "\n", "# plot ground truth\n", "\n", "for i_par, par in enumerate(gt_par.keys()):\n", " # define parameter-simulation transformation\n", " p_to_y = lambda p: p\n", " if par == \"p4\":\n", " p_to_y = lambda p: p**2\n", " # observed data corresponding to parameter\n", " y_obs = p_to_y(gt_par[par])\n", " # bounds\n", " xmin, xmax = prior_bounds[par]\n", " # standard deviation\n", " sigma = sigmas[par]\n", "\n", " # pdf as function of only p\n", " pdf = partial(\n", " unnorm_1d_normal_pdf,\n", " y_obs=y_obs,\n", " sigma=sigma,\n", " p_to_y=p_to_y,\n", " )\n", "\n", " # integrate density\n", " norm = sp.integrate.quad(pdf, xmin, xmax)[0]\n", "\n", " # plot density\n", " xs = np.linspace(xmin, xmax, 300)\n", " axes[i_par].plot(\n", " xs,\n", " pdf(xs) / norm,\n", " linestyle=\"dashed\",\n", " color=\"grey\",\n", " label=\"ground truth\",\n", " )\n", "\n", "# plot ABC approximations\n", "\n", "for i_par, par in enumerate(prior_bounds.keys()):\n", " for distance_id, h in zip(distances.keys(), hs):\n", " pyabc.visualization.plot_kde_1d_highlevel(\n", " h,\n", " x=par,\n", " xname=par,\n", " xmin=prior_bounds[par][0],\n", " xmax=prior_bounds[par][1],\n", " ax=axes[i_par],\n", " label=distance_id,\n", " kde=pyabc.GridSearchCV() if par == \"p4\" else None,\n", " numx=500,\n", " )\n", "\n", "# prettify\n", "for ax in axes[1:]:\n", " ax.set_ylabel(None)\n", "fig.tight_layout(rect=(0, 0.1, 1, 1))\n", "axes[-1].legend(\n", " bbox_to_anchor=(1, -0.2), loc=\"upper right\", ncol=len(distances) + 1\n", ")" ] }, { "cell_type": "markdown", "id": "0e007295-f9f2-4bed-b6c3-9b6fe6be7ba4", "metadata": {}, "source": [ "While the scale weights accurately depict the scales the various model output types vary on, the sensitivity weights are high for $y_1$ through $y_4$, with low weights assigned to $y_5$. Very roughly, the sum of sensitivity weights for the four model outputs $y_3$ is roughly equal to e.g. the sensitivity weight assigned to $y_2$, as desirable. However, the weights assigned are now completely homogeneous, indicating that an increased training sample or more complex regression model may be preferable." ] }, { "cell_type": "code", "execution_count": 13, "id": "e6f9fadb-f8fe-439f-9f0d-e754f7f06179", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAI4CAYAAABndZP2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAADNHElEQVR4nOzdeXiV1bnw/++deSbDDpCRBCQMGQmjiqi1ilarAj0iWiv1VK2t7fHUoVp9LVXRtlZf27e+P0U9J8ehgYKvFJWK1gpanABBCCBTBpKQkBkykWmv3x97YGeeR+7PdeVi7+dZz7PW3gnZd9a611pijEEppZRSaixxG+4GKKWUUkoNNA1wlFJKKTXmaICjlFJKqTFHAxyllFJKjTka4CillFJqzNEARymllFJjjgY4SqkhJyIrReRfw1j/r0Tk5R6WXSUirw92m5RSA0sDHKVUl0RkoYh8KiKnRKRCRLaLyNzhbld/GGOeNMb8aCDuJSK5IvLtgbiXUmrgeAx3A5RSI5eIBAHvAHcBfwW8gIuAhuFsl1JKdUd7cJRSXUkAMMZkGmNajDH1xpj3jTF7HQVE5HYROSgi1SJyQETS7ccfFJFjLseXdFaJiEwXkQ/sPUSHROSGTspdKiL7XJ5/ICI7XJ5/IiLX2x9HisibIlIqIjki8nOXcq2GnUTkByKSJyLlIvK/OuiV8RKRV+2vZb+IzLFf9xoQC7wtIjUi8oCI+IjI6/Z7VYnIDhGZ0NM3XCk1MDTAUUp15TDQIiL/IyJXiUiI60kR+TdgFfADIAi4Fii3nz6GrbdnHPAb4HURiWhbgYj4Ax8AfwHGAzcC/1dEZnbQns+BqSJiERFPIAWIFJFAEfEF5gCfiIgb8DbwNRAFXAbcIyKLO6h/JvB/gZuBCHt7o9oUuxZYCwQDm4A/AxhjbgGOA981xgQYY34P3Gq/RwwQBvwYqO/gtSilBpEGOEqpThljTgMLAQO8BJSKyCaXHokfAb83xuwwNkeNMXn2a9cbY04YY6zGmHXAEWBeB9VcA+QaY/7bGNNsjNkNvAn8WwftqQd2AIuA2dgCmO3AhcAC4IgxphyYC4QbYx4zxjQaY7Lt7b+xg/q/B7xtjPmXMaYReNT+el39yxiz2RjTArwGpHbxtjVhC2zOs/d67bK/j0qpIaQ5OEqpLhljDgIrwTaUBLwOPAeswNZLcayj60TkB8AvgDj7oQDA0kHRScB8EalyOeaBLZDoyDbgEqDA/rgSuBhbXtA2l3tGtrmnO/BJB/eLBPIdT4wxdSJS3qZMscvjOsBHRDyMMc0d3O81bO/LWhEJxvZ+PWyMaerk9SilBoH24CileswY8w2QASTZD+UDU9qWE5FJ2HpM7gbCjDHBQBYgHdw2H9hmjAl2+QowxtzVSTMcAc4i++Nt2AKcizkb4OQDOW3uGWiM+U4H9ysCol3a7outB6anWvX2GGOajDG/McbMBC7A1kP1g17cTyk1ADTAUUp1yp78e6+IRNufx2DrufncXuRl4D4RmS0259mDG39sH/yl9ut+yNmgqK13gAQRuUVEPO1fc0VkRiflPwWmYRvu+tIYsx97LxDwsb3Ml0C1iPxSRHxFxF1EkjqZ3r4B+K6IXCAiXthyijoKxDpzEpjseGJPhE4WEXfgNLYhK2sv7qeUGgAa4CilulKNLXD4QkRqsQU2WcC9YMuzAVZjSxCuBjYCocaYA8AzwGfYAoBkbLky7RhjqoErsOXHnMA2HPQ7wLuT8rXAV8B+e84M9nryjDEl9jIt2HpO0oAcoAxbMDaug/vtB36GLYm4CKgBSuj5VPingEfsM6buAyZiC5pOAwex9Sp1NtymlBokYkzbXDqllDp3iUgAUAVMNcbkDHNzlFJ9pD04Sqlznoh8V0T87FPW/wDsA3KHt1VKqf7QAEcppeA6bMNjJ4CpwI1Gu7eVGtV0iEoppZRSY4724CillFJqzBkzC/1deeWV5r333hvuZiillFJqaHW4rMOY6cEpKysb7iYopZRSaoQYMwGOUkoppZSDBjhKKaWUGnM0wFFKKaXUmDNmkoyVUkp1rKmpiYKCAs6cOTPcTVGqz3x8fIiOjsbT07NH5TXAUUqpMa6goIDAwEDi4uIQ6c0+okqNDMYYysvLKSgoID4+vkfX6BCVUkqNcWfOnCEsLEyDGzVqiQhhYWG96oXUAEepMeaFbcf49FjrZRM+PVbGC9uODVOL1EigwY0a7Xr7M6wBjlJjTEr0OO7+y24+PlxKc4uVT4+VcfdfdpMSPW64m6aUUkNGAxylxpgLplj4802zuC1jB9f+eTt3/2U3f75pFhdMsQx309Q5LCAgoN2xjz/+mPT0dDw8PNiwYUOv71lWVoanpycvvPBCp2VWrVrFH/7wh17fuytxcXFcdNFFrY6lpaWRlJTU6tg999xDVFQUVqvVeSwjI4Pw8HBmzZrF1KlTWbx4MZ9++umAtk/ZaICj1Bh0/uQwBDhQdJrvz4/V4Eb12FAOccbGxpKRkcFNN93UaZmMjAxWrVrV4bn169ezYMECMjMzB7xtYAuOMjIyOjxXXV1Nfn4+AAcPHmx33mq18tZbbxETE8O2bdtanVu+fDm7d+/myJEjPPjggyxdurTDe6j+0QBHqTHovaximqwGd4HXPz/e7gNLqc44hjgdPzODOcQZFxdHSkoKbm59+yjKzMzkmWeeobCwkIKCAufx1atXk5CQwMKFCzl06JDz+EsvvcTcuXNJTU1l2bJl1NXV9bntN9xwA+vWrXO2Y8WKFa3Ob926lcTERO66664uA7BLL72UO+64gzVr1vS5LapjOk1cqTHm02Nl/PLNvQC0GFh1XaIOUymn37y9nwMnTndZZnygNz945UsmBHlz8nQD540P4I//OMIf/3Gkw/IzI4P49XcTB6O5ncrPz6eoqIh58+Y5g417772XXbt2sXbtWvbs2UNzczPp6enMnj0bgKVLl3L77bcD8Mgjj/DKK6/ws5/9rE/1L1u2jB/+8Ifcd999vP3227zxxhu89tprzvOOoOe6667jV7/6FU1NTZ2u35Kens6LL77Yp3aozmkPjlJjzN6CU6yYF+t8HurnxZ9vmsXeglPD2Co1mozz9WRCkDeFVWeYEOTNON+eLaw2UMrLy0lLSyMtLY1HH32UF154wfl83759AKxbt44bbrgBgBtvvNHZS/LJJ5+wZMkS/Pz8CAoK4tprr3XeNysri4suuojk5GTeeOMN9u/f367uffv2Oet64YUXePTRR53Py8vLneXCwsIICQlh7dq1zJgxAz8/P+e5xsZGNm/ezPXXX09QUBDz589ny5Ytnb5eY0z/3jDVIe3BUWqM+fHFU/jDlrPd8jnltdyyYJL23iiAHvW0OIalfv6t83j9i+P8x7enDunPT1hYGHv27AFsOTi5ubnt8nAyMzMpLi7mjTfeAODEiRMcOdJxD5PDypUr2bhxI6mpqWRkZLB169Z2ZZKTk511r1q1iri4OFauXNnh/ZYvX85Pf/rTdnk6W7ZsoaqqiuTkZADq6urw9fXlmmuu6fA+u3fvZsaMGV22XfWe9uAoNQbllNcSE+qLj6cbuWW1w90cNYo4gps/3zSLX1wxjT/fNKtVTs5IcPjwYWpqaigsLCQ3N5fc3FweeughMjMzWbRoERs3bqS+vp7q6mrefvtt53XV1dVERETQ1NTkDIz6Y8mSJTzwwAMsXry41fHMzExefvllZ9tycnL44IMPOsz52bZtG2vWrHEOnamBowGOUmNQXnkt8ZYA4sL8NcBRvbK34FSrfC3HsgP9HeKsq6sjOjra+fXss8+yY8cOoqOjWb9+PXfeeSeJiT3L48nMzGTJkiWtji1btozMzEzS09NZvnw5qampXHXVVcydO9dZ5vHHH2f+/PlceOGFTJ8+3Xl806ZNPProo71+TYGBgfzyl7/Ey8ur1et87733uPrqq53H/P39WbhwoTPYWrduHWlpaSQkJPDkk0/y5ptvag/OIJCxMvY3Z84cs3PnzuFuhlLDzhhDyqr3WZoeRUl1A4eKq/nnfZcMd7PUMDp48KB+gKoxoZOf5Q6XONYeHKXGmPLaRqobmpkU5k+cxZ/jFXU0t1i7v1AppcYQDXCUGmPyym1DUnEWP+LD/Gm2Ggqr6oe5VUopNbSGJcARkStF5JCIHBWRBzs4/79FZI/967CIVA1DM5UalXLKbImMcWH+xIf7A5CteThKqXPMkE8TFxF34HngcqAA2CEim4wxBxxljDH/6VL+Z8CsoW6nUqNVXnktbgLRIX4E+tjWL8ktq4Vpw9wwpZQaQsPRgzMPOGqMyTbGNAJrgeu6KL8CGJyNRpQag3LL64gO8cPLww1LgBcB3h46k0opdc4ZjgAnCsh3eV5gP9aOiEwC4oF/DkG7lBoTcstqmRRmW1VVRIiz+JFT3vc9d5RSajQa6UnGNwIbjDEtHZ0UkTtEZKeI7CwtLR3ipik18hhjyC2vJS7M33ks3hJATlnNMLZKKQgICGh37OOPPyY9PR0PDw82bNjQ63uWlZXh6enJCy+80GmZVatW8Yc//KHX9+5KXFwcF110UatjaWlpJCUltTp2zz33EBUVhdV6dhZjRkYG4eHhzJo1i6lTp7J48WI+/fTTHtddV1fHzTffTHJyMklJSSxcuJCamoH7/71z505+/vOfO9t69913tysTFxdHcnIyKSkpXHzxxeTl5Q1Y/QNpOAKcQiDG5Xm0/VhHbqSL4SljzBpjzBxjzJzw8PABbKJSo1NFbSPVZ5qJs7gEOGF+FFbW09isU8VV977akkfBocpWxwoOVfLVloH/EIuNjSUjI4Obbrqp0zIZGRnttmlwWL9+PQsWLOhyt+7+WLVqVbttGByqq6vJz7cNRhw8eLDdeavVyltvvUVMTAzbtm1rdW758uXs3r2bI0eO8OCDD7J06dIO7xEXF9fu2B//+EcmTJjAvn37yMrK4pVXXul0E8++mDNnDn/605+6LffRRx+xd+9eLrnkEp544okBq38gDUeAswOYKiLxIuKFLYjZ1LaQiEwHQoDPhrh9So1aueWOGVRnN/6Ls/hjNXC8QoepVPfGxwWx5aUsZ5BTcKiSLS9lMT4uaMDriouLIyUlBTe3vn0UZWZm8swzz1BYWEhBQYHz+OrVq0lISGDhwoUcOnR2X7aXXnqJuXPnkpqayrJlyzrcOqGnHDuYO9qxYsWKVue3bt1KYmIid911V5cB2KWXXsodd9zBmjVrelRvUVERUVFnszqmTZuGt7c3AK+//jrz5s0jLS2NO++8k5YW2+BHQEAADz/8MKmpqSxYsICTJ08CtgAxKSmJ1NRUFi1a5Gx3Z3tmdeT888+nsLCzPorhNeSzqIwxzSJyN7AFcAf+yxizX0QeA3YaYxzBzo3AWjNWllpWagicXQPHdYjK9jinrJbzxrcfJlDnlk/+epiy/K6HNPzHefH2n/bgN86LulONhEz0Y8c7Oex4J6fD8paYAC66IWEwmtup/Px8ioqKmDdvnjPYuPfee9m1axdr165lz549NDc3k56ezuzZswFYunSpc8+nRx55hFdeeYWf/exnfap/2bJl/PCHP+S+++7j7bff5o033uC1115znncEPddddx2/+tWvaGpq6rSnJT09nRdffLFH9d52221cccUVbNiwgcsuu4xbb72VqVOncvDgQdatW8f27dvx9PTkJz/5CW+88QY/+MEPqK2tZcGCBaxevZoHHniAl156iUceeYTHHnuMLVu2EBUVRVVVVZ/eh/fee4/rr7++T9cOtmHZTdwYsxnY3ObYo22erxrKNik1FuSWOaaI+zqPOQIcnUmlesrbzxO/cV7UVDQQEOqNt9/ADYH0RHl5OZdddhkAFRUVNDY2snHjRgBee+01kpOTWbduHTfccAMAN954I7fddhv33nsvn3zyCUuWLMHPz9aLee211zrvm5WVxSOPPEJVVRU1NTXtNskE2LdvH7fccgsAxcXFeHl58dxzzwHw4YcfEhYWBth2PA8JCWHt2rXMmDHDWR9AY2Mjmzdv5tlnnyUwMJD58+ezZcuWTntGXP+OX716NevXrwdsO6SnpaUBcOGFF/L888+TlpZGdnY277//Pv/4xz+YO3cun332GR9++CG7du1y7r1VX1/P+PHjAfDy8nLWPXv2bD744APnPVeuXMkNN9zA0qVLu/2+uLr00kupqKggICCAxx9/vFfXDpVhCXCUUoMjt7yOyGBfvD3cnceC/bwI9vMkp1wDHEWPelocw1JzvhNH1seFzL0mnuhpIUPQOpuwsDD27NkD2HJwcnNz2+XhZGZmUlxc7NwV/MSJExw5cqTL+65cuZKNGzeSmppKRkYGW7dubVcmOTnZWfeqVauIi4tj5cqVHd5v+fLl/PSnP22Xp7NlyxaqqqpITk4GbInBvr6+nQY4u3fvdu6v9PDDD/Pwww8DtiE8R1tcBQQEsHTpUpYuXYqbmxubN2/Gy8uLW2+9laeeeqpdeU9PT0Rs2zW5u7vT3NwMwAsvvMAXX3zBu+++y+zZs9m1a1eH7evIRx99RHBwMDfffDO//vWvefbZZ3t87VAZ6bOolFK9kFte6+yxcaW7iquecgQ3i29PYv61k1l8e1KrnJyR4PDhw9TU1FBYWEhubi65ubk89NBDZGZmsmjRIjZu3Eh9fT3V1dXOHbzBlhgcERFBU1OTMzDqjyVLlvDAAw+06wnKzMzk5ZdfdrYtJyeHDz74oMOcn23btrFmzRrn0Fl3tm/fTmWl7XvR2NjIgQMHmDRpEpdddhkbNmygpKQEsPV8dTe76dixY8yfP5/HHnuM8PBwZ9J0T3l4ePDcc8/x6quvUlFR0atrh4IGOEqNEcYYclzWwHE12eJPjgY4qgdKck+z+PYkZ49N9LQQFt+eREnu6X7dt66ujujoaOfXs88+y44dO4iOjmb9+vXceeedJCYm9uhemZmZLFmypNWxZcuWkZmZSXp6OsuXLyc1NZWrrrrKOWQD8PjjjzN//nwuvPBCpk+f7jy+adMmHn20VZZEjwQGBvLLX/4SLy+vVq/zvffe4+qrr3Ye8/f3Z+HChc5ga926daSlpZGQkMCTTz7Jm2++2ePd3o8dO8bFF19McnIys2bNYs6cOSxbtoyZM2fyxBNPcMUVV5CSksLll19OUVFRl/e6//77ndPNL7jgAlJTU9uVycjIaPV9c03mBoiIiGDFihU8//zzPWr/UJKxksM7Z84cs3PnzuFuhlLDprK2kVmPf8AjV8/gRxdNbnXuTx8e4dkPDnPwsSvx9XLv5A5qrDp48GCPP0CVGsk6+VmWjspqD45SY4Qjx8Z1kT8Hx6yqvArtxVFKnRs0wFFqjDg7RbzjISqAnFINcJRS5wYNcJQaI3LK6hCBmND2AY6jB0dnUimlzhUa4Cg1RuSV1xI5rvUUcYcAbw8sAd46k0opdc7QAEepMSK3vK7DKeIO8RY/cst0uwal1LlBAxylxojcTqaIO8Rb/MnWHhyl1DlCAxylxoCqukZO1Td1OIPKIc7iT1lNA9VnmoawZUrZBAS03wft448/Jj09HQ8PDzZs2NDre5aVleHp6ckLL7zQaZlVq1bxhz/8odf37kpcXBwXXXRRq2NpaWkkJSW1OnbPPfcQFRWF1Wp1HsvIyCA8PJxZs2YxdepUFi9ezKefftrjuuvq6rj55pud69csXLiQmpqu9xbrjZ07d/Lzn//c2da77767XZm4uDiSk5NJSUnh4osv7nZBQVcrV64kPj6etLQ00tPT+eyz1vtpP/PMM4gIZWVl/XshaICj1JjgWMQvrqshKnvwk1euw1Sqc1/+bQPHs/a2OnY8ay9f/q33AUh3YmNjycjI4Kabbuq0TEZGRrttGhzWr1/PggULutytuz9WrVrVbhsGh+rqaufKvwcPHmx33mq18tZbbxETE8O2bdtanVu+fDm7d+/myJEjPPjggyxdurTDe8TFxbU79sc//pEJEyawb98+srKyeOWVVzrdxLMv5syZw5/+9Kduy3300Ufs3buXSy65hCeeeKLd+a1bt3a6xcXTTz/Nnj17+O1vf8udd97pPJ6fn8/7779PbGxsn9vvSgMcpcYAR9AS18UQlSP40WEq1ZWJUxJ457nfOoOc41l7eee53zJxysDvFh4XF0dKSgpubn37KMrMzOSZZ56hsLCw1Qq7q1evJiEhgYULF3Lo0CHn8Zdeeom5c+eSmprKsmXLOtw6oaccO5g72rFixYpW57du3UpiYiJ33XVXlwHYpZdeyh133MGaNWt6VG9RURFRUVHO59OmTcPb2xuA119/nXnz5pGWlsadd95JS0sLYOs9e/jhh0lNTWXBggWcPHkSsAWISUlJpKamsmjRIme7O9szqyPnn38+hYWFPS7vatGiRRw9etT5/D//8z/5/e9/79w3q790s02lxoDc8tpOp4g7OIavdCbVue2jjDWU5GV3WcY/NJQ3n/xf+IeEUltZQWh0DJ+9+Rc+e/MvHZYfP2kyl668YzCa26n8/HyKioqYN2+eM9i499572bVrF2vXrmXPnj00NzeTnp7O7NmzAVi6dKlzz6dHHnmEV155hZ/97Gd9qn/ZsmX88Ic/5L777uPtt9/mjTfe4LXXXnOedwQ91113Hb/61a9oamrqtKclPT2dF198sUf13nbbbVxxxRVs2LCByy67jFtvvZWpU6dy8OBB1q1bx/bt2/H09OQnP/kJb7zxBj/4wQ+ora1lwYIFrF69mgceeICXXnqJRx55hMcee4wtW7YQFRVFVVVVn96H9957j+uvv75P17799tvODUn/9re/ERUV1eF2EX2lAY5SY0BumW2KuI9n59sw+Hq5EzHORwMc1S0f/wD8Q0KpLisl0BKOj3/7/JnBVF5ezmWXXQbYNo1sbGxk48aNALz22mskJyezbt06brjhBgBuvPFGbrvtNu69914++eQTlixZgp+fLdi/9tprnffNysrikUceoaqqipqamnabZALs27ePW265BYDi4mK8vLx47rnnAPjwww8JCwsDbDueh4SEsHbtWmbMmOGsD2ybYG7evJlnn32WwMBA5s+fz5YtWzrtGXHdMmn16tWsX78esO2QnpaWBsCFF17I888/T1paGtnZ2bz//vv84x//YO7cuXz22Wd8+OGH7Nq1y7n3Vn19PePHjwfAy8vLWffs2bP54IMPnPdcuXIlN9xwA0uXLu32++Lq0ksvpaKigoCAAB5//HHn8fnz59PQ0EBNTQ0VFRXO9v/ud79zvt/3338/TzzxBOHh4bzyyivU1dXx5JNP8v777/eqDd3RAEepMSC3vK7LGVQOcWH+utjfOa4nPS2OYakFy27k6/c3c/6ym4hNShmC1tmEhYWxZ88ewJaDk5ub2y4PJzMzk+LiYueu4CdOnODIkSNd3nflypVs3LiR1NRUMjIy2Lp1a7syycnJzrpXrVpFXFxcp7kky5cv56c//Wm7PJ0tW7ZQVVXl7J2oq6vD19e30wBn9+7dzv2VHn74YR5++GHANoTnaIurgIAAli5dytKlS3Fzc2Pz5s14eXlx66238tRTT7Ur7+np6Rz2cXd3p7m5GYAXXniBL774gnfffZfZs2eza9euDtvXkY8++ojg4GBuvvlmfv3rX/Pss88C8MUXXwC2oa6MjIwOc5iefvppvve97zmf79u3j5ycHGfvTUFBAenp6Xz55ZdMnDixx21qS3NwlBoDcstru0wwdogP113FVdccwc019zzIhTd8n2vuebBVTs5IcPjwYWpqaigsLCQ3N5fc3FweeughMjMzWbRoERs3bqS+vp7q6mrnDt5gSwyOiIigqanJGRj1x5IlS3jggQfa9QRlZmby8ssvO9uWk5PDBx980GHOz7Zt21izZo1z6Kw727dvp7KyErD1FB04cIBJkyZx2WWXsWHDBkpKSgBbz1d3s5uOHTvG/PnzeeyxxwgPD3cmTfeUh4cHzz33HK+++ioVFRW9utZVcnIyJSUlzvcrOjqar776ql/BDWiAo9SoV1XXSFVdU5cJxg7xYf5U1TVRVdc4BC1To1HxscNcc8+Dzh6b2KQUrrnnQYqPHe7Xfevq6oiOjnZ+Pfvss+zYsYPo6GjWr1/PnXfeSWJiYo/ulZmZyZIlS1odW7ZsGZmZmaSnp7N8+XJSU1O56qqrnEM2AI8//jjz58/nwgsvZPr06c7jmzZt4tFHH+31awoMDOSXv/wlXl5erV7ne++9x9VXX+085u/vz8KFC53B1rp160hLSyMhIYEnn3ySN998s8e7vR87doyLL76Y5ORkZs2axZw5c1i2bBkzZ87kiSee4IorriAlJYXLL7+coqKiLu91//33O6ebX3DBBR3mv2RkZLT6vrkmcwNERESwYsUKnn/++R61fyiJ69jfaDZnzhyzc+fO4W6GUkPu6/wqrnt+Oy/eMpvFiV3/xfPBgZPc/upO3vrJBcyKDRmiFqrhdvDgwR5/gCo1knXys9zhtKth6cERkStF5JCIHBWRBzspc4OIHBCR/SLSceq+Uopce05NV9s0OMTbdxrXYSql1Fg35EnGIuIOPA9cDhQAO0RkkzHmgEuZqcBDwIXGmEoRGT/U7VRqtHDsLxXbxRRxh5hQP9xEp4orpca+4ejBmQccNcZkG2MagbXAdW3K3A48b4ypBDDGlAxxG5UaNXLLa4kc59PlFHEHbw93okJ8ydHVjM85YyUdQZ27evszPBwBThTgmqpdYD/mKgFIEJHtIvK5iFzZ0Y1E5A4R2SkiO0tLSwepuUqNbLnltUzqYg+qtuLC/LUH5xzj4+NDeXm5Bjlq1DLGUF5ejo+PT4+vGanr4HgAU4FLgGjgYxFJNsZUuRYyxqwB1oAtyXiI26jUiJBXXsfixAk9Lj/Z4s+bXxVijBmwJdHVyOaY/aJ/CKrRzMfHh+jo6B6XH44ApxCIcXkebT/mqgD4whjTBOSIyGFsAc+OoWmiUqPDqfomKmobu9xFvK04iz81Dc2U1TQSHug9iK1TI4Wnpyfx8fHD3QylhtRwDFHtAKaKSLyIeAE3ApvalNmIrfcGEbFgG7LqevMUpc5BefYZVL0aorLPtsrVFY2VUmPYkAc4xphm4G5gC3AQ+KsxZr+IPCYijk1DtgDlInIA+Ai43xhTPtRtVWqky7UnC/dkirhDvD0YyinVAEcpNXYNSw6OMWYzsLnNsUddHhvgF/avYfPVljzGxwURPe3sgmgFhyopyT1N+uJJw9gypWwcycI9mSLuEB3ii4eb6J5USqkxTbdq6ML4uCC2vJRFwSHbvh8FhyrZ8lIW4+OChrllStnkltcyMcgHX6/up4g7eLi7ERvqpzOplFJj2kidRTUiRE8L4fIfzuTvL+xl2vyJHNlZwuLbk1r16Cg1nHLLaomz9Lz3xiHOoptuKqXGNu3B6Ub4pEAa61vYt7WQpEVRGtyoESWvvK5XM6gc4i3+5JbXYrXq6gpKqbFJA5xulBfWgkBolD9ZHxc6h6uUGm6nzzRRXtvonBXVG3EWf840WTlZfWYQWqaUUsNPA5wuOHJuJsQFgYHFtye1yslRajjl2fegigvr/RCVcyaVDlMppcYoDXC6UJJ7msW3JxEzI5TK4jomxgex+PYkSnJPD3fTlHKuY9ObNXAc4nRXcaXUGKdJxl1wTAVvqG3CWA0VRbVETwvRPBw1IjhmQU3qQw9O5DhfvDzcdCaVUmrM0h6cHrDEBABQll8zzC1R6qzc8jomBHnj59X7v1Pc3IS4MD9yynRXcaXU2KQBTg8Ehfni5eNOWX71cDdFKae88to+zaByiAvz1+0alFJjlgY4PSBuQlh0AGUF2oOjRo7cfgY48eH+HC+vo0WniiulxiANcHrIEhNIWUENRj8M1AhQfaaJsppGJvVhkT+H+DB/GlusnKiqH8CWKaXUyKABTg9ZogNoamjhVJl+GKjhl+fYZLM/Q1QWnSqulBq7NMDpofCYQEATjdXI0J8p4g7xGuAopcYwDXB6KCTCDzc30URjNSI4enD6sg+Vw/hAb/y83DXAUUqNSRrg9JCHpzshEX6aaKxGhJyyWnuA0velrEREZ1IppcYsDXB6wRITqD04akTo7xRxh3iLvy72p5QakzTA6QVLdAC1pxqpO9043E1R57icsrp+DU85xFn8yK+sp6nFOgCtUkqpkUMDnF6w2BONy3WYSg2jmoZmymoa+pVg7BBvCaDFasiv0BWNlVJjy7AEOCJypYgcEpGjIvJgB+dXikipiOyxf/1oONrZliXatmVDaYEOU6nhk2fPmXHMguqPeHsvkObhKKXGmiEPcETEHXgeuAqYCawQkZkdFF1njEmzf708pI3shI+/JwGh3jpVXA2rXPv+UX3ZZLMtRx5PdqkGOEqpsWU4enDmAUeNMdnGmEZgLXDdMLSjTyzRmmishtdArIHjEOrvRZCPh/bgKKXGnOEIcKKAfJfnBfZjbS0Tkb0iskFEYjq6kYjcISI7RWRnaWnpYLS1HUtMAFUn62hqbBmS+pRqK7eslvBAbwK8+z5F3EFE7DOpNAdHKTW2jNQk47eBOGNMCvAB8D8dFTLGrDHGzDHGzAkPDx+ShoVHB2IMVBTqX7xqeOSV1xE3AMNTDnEWf13sTyk15gxHgFMIuPbIRNuPORljyo0xDfanLwOzh6ht3bLE2BKNyzTRWA2T/u4i3lZcmD8nTtVzpkl7JZVSY8dwBDg7gKkiEi8iXsCNwCbXAiIS4fL0WuDgELbP6cu/beB41t5WxyqLD2Oad2misRoWtQ3NlFQ3ODfKHAiTw/0xBo7rVHGl1Bgy5AGOMaYZuBvYgi1w+asxZr+IPCYi19qL/VxE9ovI18DPgZVD3U6AiVMSeOe53zqDnONZe3n3ud8RGhWvPThqWDj2oBqIGVQOjt4gHaZSSo0l/c9S7ANjzGZgc5tjj7o8fgh4aKjb1VZsUgpX/Pg/eOv3v2H6BRdzbOfnXHPPg+Qd8OHAv05gtRrc3GS4m6nOIY7ZTgM6RKW7iiulxqCRmmQ8YsQmpdDc0EDWR++TesV3iE1KwRIdSHOjlVMl2qWvhpYzwBnAIapxvp6E+XvpnlRKqTFFA5xuFB89gri5ERQ+ga/f38zxrL0uicaah6OGVl5ZHZaAgZki7kpnUimlxhoNcLpwPGsv7zz3WybPmkt99Wmu/o/7eee531JbcQw3d9FEYzXkcsprB3SKuENcmL8u9qeUGlM0wOlC8bHDXHPPgyScv5CmM/X4BQVzzT0PUpJ7lNBIf000VkMur7x2QFYwbive4sfJ0w3UNjQP+L2VUmo4DEuS8Wgx77rvAVBVXATAicMHSb3clodTXXWA4/srhrN56hxT19jMydMNzg0yB1K8xTbsmlteS2LkuAG/v1JKDTXtwemBcRMm4hs0jhOHv3Ees0QHUne6kdpTDV1cqdTAOTtFfOB7cOIcu4rrlg1KqTFCA5weEBEiE2ZQdMQlwNFEYzXE8uw5MvEDOIPK4exaOPrzrJQaGzTA6aHIhOlUFp2g7vQpACzR9gBHdxZXQyTH3rsSOwhJxv7eHkwI8nbWoZRSo50GOD0UOXU6gLMXx9vPk8AwH+3BUUMmr7yWMH8vgnw8B+X+OpNKKTWWaIDTQxOmnIebu3ubPJwAnSquhkxOWe2ALvDXVrzFXxf7U0qNGRrg9JCntw/hkyZz4vDZfT/DYwOpKqmjqUF3YVaDL6+8bkD3oGorzuJPeW0jp+qbBq0OpZQaKhrg9ELktOkUHzuCtcUW0FiiA8BAeaH24qjBVd/YQvHpM8T3YAbVl3/b4Nwg1uF41l6+/NuGLq9zJC9rL45SaizQAKcXIqdOp7mhgdK8HAAsMYGAzqRSgy+vwhZ0TOrBENXEKQm889xvnUGOY0XuiVMSurzOGeBoHo5Sagzo10J/IvI7Y8wvuzs2VkQmzABsC/5NmHweASHeePt5UKozqdQgc6xP05NtGmKTUrjmngfZ+PRjxKfNJn//Pq6550Fik1K6vi7UDxHILtUARyk1+vW3B+fyDo5d1c97jliBlnACQkKdicYigiVGE43V4HP0qvR0kb/omYm0NDdz+PPtpF7xnW6DGwAfT3cix/lqD45SakzoU4AjIneJyD5gmojsdfnKAfZ2d/1oJSJEJExvveBfdCDlhTVYW6zD2DI11uWV1xLq78U4355NEd/34ftYm237Su3Z8m67nJzO6EwqpdRY0dcenL8A3wU22f91fM02xnx/gNo2IkVOnc6pkpPUVlUCthWNW5qsVJXUD3PL1FiWW1bX413Ej2ftZdtrrzifp17xnVY5OV2Js/iRU1aLMabPbVVKqZGgTwGOMeaUMSbXGLMCKACaAAMEiEjsQDZwpImcdjYPByDcmWiseThq8OSW1zq3U+hO8bHDWGInMW7CRLx8/ag/fYpr7nmQ4mOHu702Lsyf02eaqaht7G+TlVJqWPUrB0dE7gZOAh8A79q/3unBdVeKyCEROSoiD3ZRbpmIGBGZ0592DqTx8efh7uHhzMMJnuiHm4doHo4aNGeaWig6dabH+TdzvruE8oJ8YpNSiZ6RSP7+vcQmpTDvuu91e+3kcJ1JpZQaG/qbZHwPMM0Yk2iMSbZ/dZnNKCLuwPPYkpFnAitEZGYH5QKB/wC+6GcbB5SHpyfj46c4Axx3dzfCIgN0qrgaNMcr7DOoLD0boirNzaGxvo6YxBRik1KpLDpBdXlZj649u+mm7kmllBrd+hvg5AOnennNPOCoMSbbGNMIrAWu66Dc48DvgDP9a+LAi0yYwcnsI7Q021Z8tW3ZUK15C2pQ5NiTfns6RJW/35ZrEzMjiZjElFbHuhMT6oe7m+iu4kqpUa+vs6h+ISK/ALKBrSLykOOY/XhXorAFRg4F9mOu908HYowx73bTjjtEZKeI7CwtLe3DK+mbyITptDQ1UZKbDdgSjeurm6g7pXkLauDllfcywDmwj5CIKAJCwwiPjcMnILDHs6g83d2ICfF1rrujlFKjVV97cALtX8ex5d94uRwL7E+DRMQNeBa4t7uyxpg1xpg5xpg54eHh/am2VyISbDuLnzhkG6ayRNtesi74pwZDTlkdIX6ejPPrfoq4taWFgoP7iZmZDIC4uREzM5nj+7/ucQ9jnMXf2WuklFKjVZ9WMjbG/KYfdRYCMS7Po+3HHAKBJGw9QwATgU0icq0xZmc/6h0wgaEWAi3hnDjyDbO5zrYnFbYtG+KSLcPcOjXW5JXX9jjBuCQ3m8b6OqITk53HYpJSOPLlp5wqOUnwhInd3iMuzJ8vcyowxmD/P6iUUqNOf7dqeBvb9HBXp4CdwIvGmI7yZ3YAU0UkHltgcyNwk+OkMeYU4IwSRGQrcN9ICW4cIqdOdyYae/l6EBTuqzOp1KDIK69jXnxoj8rmH9gH2PJvHGJd8nB6EuDEW/ypa2yhpLqBCUE+fWixUkoNv/4mGWcDNcBL9q/TQDWQYH/ejjGmGbgb2AIcBP5qjNkvIo+JyLX9bM+QiUyYTnV5qXN2Snh0gK6FowbcmaYWTpyqZ1IPF/krcMm/cQiNisFvXDDHs77u0T0cm27qMJVSajTrVw8OcIExZq7L87dFZIcxZq6I7O/sImPMZmBzm2OPdlL2kn62cVCc3XjzG6advxBLTADH9pTSeKYZL5/+vq1K2eRX1GHM2aCjK478m+kXLGp1XESITUol/8C+Hg07OXcVL6tlweSwLssqpdRI1d8enFYrF9sfB9ifjukpReFx8Xh4elF0xLaisSU6EAyU63o4agA5elF6koPjyL+Jccm/cYhJTKa2soKKEwXd3icy2BcvdzftwVFKjWr9DXDuBf4lIh/Zc2U+Ae4TEX/gf/rbuJHM3cOTCVPOOzuTKuZsorFSAyWv3L7IXw+GqBz5N9Ez2wc4sYmptjL793V7H3c3ISbUVwMcpdSo1q8Axz7UNBXbisb/gW1V43eNMbXGmOf637yRLTJhBidzjtHc2Ih/sDc+/p6U6VRxNYByy2sJ9vMk2M+r27L5+/cSEhlNQEj7hORxEyYSGBZOfo/zcAJ0uwal1KjW14X+vmX/dylwNTDF/vUd+7FzQkTCdKwtzZzMOYaIYInRLRvUwMrt4RRxa0sLhd/sJ2ZmUofnbXk4KRw/sA9jtXZ7v3iLH7nldVitujq3Ump06msPzsX2f7/bwdc1A9CuUSFyqn3Bv8OOPJwAygtrsbZ0/wGiVE/kltUR34PhqZKcYzTW1zsX+OtITGIKZ6pPU5af1+394iz+NDZbOXGqvlftVUqpkaKvC/392v7vDwe2OaOLf3AI4yZMpOiwIw8nkJZmK5Un6wiLDOjmaqW6dnaKeHS3ZbvKv3FwJB8fz9pL+KT4Lu93diZVHdEhPZuirpRSI0m/cnBEZIKIvCIif7c/nyki/z4wTRsdbAv+HcQYczbRWBf8UwOgoNI2Rbwnu4jnH9jXaf6NQ5BlPMETIsg/0P2+VM61cDQPRyk1SvV3FlUGtgX7Iu3PD2NLOD5nRCRMp7aqktOlJYRM8MPdw00TjdWAcGx42d0mm478m9gOpoe3FZOUQsGBLKzWli7LTQj0wcfTjVydSaWUGqX6G+BYjDF/BazgXKW469+cY4xzwb8j3+Dm7kZYlL8mGqsBkdvDXcQd+TeO4amvtuRRcKiyVZmCQ5V8tSWPmMQUGupqKcnJ7vKebm5CXJhuuqmUGr36G+DUikgY9v2oRGQBtr2ozhnhsXF4evuczcOJDqAsv6bHOzcr1Znc8lrG+XoS4t/1FPHj+21DTo4E4/FxQWx5KYv8g+VYrYaCQ5VseSmL8XFBzn2perJtQ7zFX3twlFKjVp+SjEXkHuBT4AHgb8BkEdkOhAP/NmCtGwXc3N2ZOGXq2ZlUMYEc2F5EbVUDASG6UaHqu9yyuh4t8FdwYB+hkdH4B4cAED0thMW3J/H2n/YQMtGP2lONLL49iehptvNh0bHk79/LvOu+1+V94yz+fHDgJM0tVjzc+/u3kFJKDa2+/taKBp4D3rPf4wNgLba9qXq2ktgYEjltBqV5OTQ1nMESrYnGamD0ZA0ca0sLBd8caLc9Q1CYD9YWQ3lhLTMvjHAGN2CbTVX4zQFampu6vHd8mD/NVkNBpU4VV0qNPn0KcIwx9xljLgAmAvcBXwCXAHtF5MDANW90iJg6HWtLCyePHSUsOgAE3Vlc9UtDcwsnquqJ62aTzZM5R2k6U99uevjuD447H+/bVtgqJyc2MZWmhjMUHz3S5b3jw3UmlVJq9Opvv7MvEASMs3+dwBbsnFMipk4DoPDwQbx8PBgX7qs9OKpf8ivqsZru96By7C3lusBfwaFKDvzrBAEh3vgEeDJ+ki0nxxHkRM9MAhHy93c9XdyR3Kx5OEqp0aivWzWssefcrAPOx5aP82/GmDnn4uJ/fkHjCImIouiII9E4kFKdKq76Ic8xg6qbHpyCA/sIjYpx5t8AFB6uxNpimH5+BPGpFkryTnP5D2dSknsaAN/AIMInxTuTkztjCfAiwNtDAxyl1KjU1x6cWMAbKAYKgQKgaoDaNCpFJkznxOFvnAv+nS47Q0N983A3S41SjunZXU0Rd+bfzGyffwMQn2phyqzxNJ1pwWo1pC+e5CwTm5jMicMHaW5s7PT+IkKcxY9sDXCUUqNQX3NwrgTmAn+wH7oX2CEi74vIbwaqcaNJxNTp1J8+RdXJImeicbmuh6P6KK+8jkAfD0L8PDst48i/aZtgnL2njIAQb8JjA4meHoKXjzvHdpe2KhOTmEpLUxMn7MsbdEZ3FVdKjVZ9zsExNlnAZuDvwHZsO4r/xwC1bVSJnGZb8K/o8DeExwQCmmis+i63vJZ4iz8i0mkZR/5N9IyzO4g3NbSQf7CC+LRwRAR3DzfiUizkfF3aahPY6BmJiLh1u21DfJgfhZX1NDSfU+t3KqXGgL7m4PxcRNaKyHFgG7YdxL8BlgKdb4Zz9vorReSQiBwVkQc7OP9jEdknIntE5F8iMrMv7RxKYdExePn6cuLwN/iN88I30FMTjVWf9WSKeH4H+TfHD5TT0mRlclq489iUWeNpqG2m8EiV85i3nz8TppzH8axuEo0t/lgN5FfU9e2FKKXUMOlrD04csB6Yb4yZYoy5xRjz/xljvjbGWLu6UETcgeeBq4CZwIoOApi/GGOSjTFpwO+BZ/vYziHj5ubOxPOmceLwQUQES0ygbtmg+qSx2UphZT3xXcygamluprCD/JvsPaV4+3sQed4457GYxFA8vNzI/qrtMFUKxUcP0Xim83VunJtulmmAo5QaXfqag/MLY8ybxpiiPlw+DzhqjMk2xjRiWyDwujb3P+3y1B/7VhAjXWTCDMqO59FYX4clOoDyEzW0tHQZ7ynVTn5lHVZDlz04JTnH2uXftLRYydtXTnyyBTeXlYc9vdyZlBhG9p5SjPXsf6XYxBSsLS2c+KbzpascAY7OpFJKjTbDsf56FJDv8rzAfqwVEfmpiBzD1oPz845uJCJ3iMhOEdlZWlraUZEhFZkwHWOsFB87giUmAGuzobJI//JVvXN2injnPTj5B9qvf3PicBUNdc3EuwxPOUxOD6fudCPF2We3iouaNhM3d48up4sH+3kR7Oepi/0ppUadEbvBjDHmeWPMFOCXwCOdlFljX3tnTnh4+1/qQy3iPNuCfycOHcQSrYnGqm9y7cNBXU0Rzz+wj7DoWPzGBTuP5ewpxcPTjZiZ7dPg4pIsuHkIx/ac/UPA08eHiKkJPVrwL6dUAxyl1OgyHAFOIRDj8jzafqwza4HrB7NBA8UnIICw6FhOHPmG4Al+eHi6aaKx6rXc8loCvT0I7WQXcUf+jev2DMZqyP66jJiZoXh6ube7xsvXg5gZoWR/Vdpqp/uYxFROZh+joa7zAGayxV+niiulRp3hCHB2AFNFJF5EvIAbgU2uBURkqsvTq4GuN80ZQSKmTqfoyCEEQ2hUgPbgqF7LLa8jrosp4iez7evfuAQ4Jcerqa1qYPKsznsyp8wKp7riDKXHz/5MxiYmY4yVgoNZnV4XZ/Gn6NQZ6ht1qrhSavQY8gDHGNMM3A1sAQ4CfzXG7BeRx0TkWnuxu0Vkv4jsAX4B3DrU7eyryGnTOVNTTUVRIZaYAMrya1r9xaxUd3LLapnUxQyqs/k3Z9e/yd5TirgJccmWTq+LTwlH3IRsl0X/IqZOx8PTq8vp4o7tIrQXRyk1mgxLDo4xZrMxJsE+xXy1/dijxphN9sf/YYxJNMakGWMuNcbsH4529kXk1NYL/jXUNVNT2TDMrVKjRWOzlYLKui7zbwo6yb+JnBqMj3/nKx/7BHgSlRDMsd1nh6k8vLyInDa9yzycyTqTSik1Co3YJOPRKjQyCm9/f04c+ca5ZUOZbrypeqiwyr6LeCebbHaUf1NZXEtlcR2T0zrvvXGYMiucqpN1rWb3xSSmUpqXQ93pUx1e42iLzqRSSo0mGuAMMHFzI3LqdE4cOkhYVAAIuuCf6rFc5yabHQ9Rncw+SlPDGWJd1r/J+boMgPjU7mcSxqeFg8Cx3SXOYzGJKYCtZ6gjAd4eWAK8tQdHKTWqaIAzCCISplNemE9Lcz3B4/1aJXUq1RVHnktni/w58m9c95/K3lNKeGwggaE+3d7ff5w3EZPHtdp8c+KUqXh6+3B8f8cBDkC8xc+5w7lSSo0GGuAMgsipM8AYio8csiUaaw+O6qHcslp7j0nHU8Tb5t/UVjVwMud0q72nujN5VjjlBTWcKrUNU7l7eBA1I5H8rK87vSbe4q/bNSilRhUNcAbBxPMSEHFz5uFUl5+hoa5puJulRoHc8jomhfl1OEXcuf9Uq+EpW09MrwIce1nXXpzYxBQqThRQU1nR4TVxFn/KahqoPqM/x0qp0UEDnEHg7eeHJSaWE4e/wRLjWNFYe3FU9/LKaztNMD6ZfYSmhjOt1r/J3lPKuPG+hER0Pq28rSCLL+Gxga2mi8cmpQJ0OpsqPswxk0p7cZRSo4MGOIMkIsG24J8lyvbBoCsaq+40tVjJr6zvNME4f3/r/JuGuiYKD1UxOS2800UBOzN5Vjgnc05TU3kGgPC4eLz9/TsPcMJ1JpVSanTRAGeQRCbMoLG+jvrTxfgFeemKxqpbhZX1tFhNlwnGrvk3ufvKsVpNr4anHKbYVzzOtu9N5ebmTvSM5E433pwUqmvhKKVGFw1wBklkwnQAWx6OJhqrHnD0jsR3METV0txM4aEDzindYMu/8QvyYkJcUK/rCpnoT2ikf+thqsRkTp0s5nRpSbvyvl7uRIzz0QBHKTVqaIAzSIInRuIbGMSJQ99giQ6k4kQtLc3W4W6WGsHyyhxTxNsPUZ3MPkJzQ4Mzwbi5sYW8/RXEp1oQt94NTzlMTgvnxJEq6qsbAYix5+F01osTF+ZPtgY4SqlRQgOcQSIiRCRMd/bgWFsMFUX64aA6l1teh7+XO+EB3u3Otc2/KfimkuaGlj4NTzlMSQ/HmLPDVJboWHwDgzqdLh4frruKK6VGDw1wBlHk1OlUniggIMS2748mGquu5JbXMims413E8w/swxIzCb+gcYAtKPHycSdqWkif6wuLCiDI4uMMcMTNjZjEFI4f2NfhBrHxYf5U1TVRWdvY5zqVUmqoaIAziBx5OLWVx/HwctNEY9WlvPI64izth6dampsoPHR2/ymr1ZCzt4xJyRbcPfr+X1hEmDJrPAXfVDrXaYpJTKGmvIyq4hPtyuueVEqp0UQDnEE0cUoC4uZG8dFDhEUFaA+O6lRzi5X8io53ES8+drRV/k3xsSrO1DQRn9r95prdmZwejrXFkLvXtp9VbJItiTm/g20b4u3BlyYaK6VGAw1wBpGnjw/hk+IpOnKQ8JhAygpqOuz6V6qwqp5mq+kwwClos/9U9p4y3DyESUlh/a53wqQg/IO9nasah0REERASyvEO8nBiQv1wEw1wlFKjgwY4gywyYTpFRw4TGuVLY30z1eVnhrtJagTKLbetENzRKsau+TfGGLL3lBIzPRQvH49+1ytuwuRZ4Rw/UEHjmWZEhJjEFPI7yMPx9nAnKsSXnHJdzVgpNfJpgDPIIhNm0NRwBg+PKkATjVXHHL0ibVcxduTfONa/KS+sobr8TL9mT7U1ZVY4LU1Wju+37UMVk5RC3akqyguOtysbF+ZPTpn+DCulRj4NcAaZI9G47tRxRKBUE41VB3LLa/Hzcic8sPUUcWf+jT3BOHt3KQjEpfQ//8Yh4rxgfAM9yd5tW+AvNtGRh9N+PZzJFn9yy+p0qFUpNeINS4AjIleKyCEROSoiD3Zw/hcickBE9orIhyIyaTjaORCCwifgNy6Yk9mHCJ7gpz04qkN55XUdThF35N9EzUgEIPvrMiKmjMMvyGvA6nZzE+JTw8ndV05zUwvjxk8kKHwCx7PaBzhxFn9qGpopq9Gp4kqpkW3IAxwRcQeeB64CZgIrRGRmm2K7gTnGmBRgA/D7oW3lwBERIhNmUGTfWVyniquO5JbVdrjJZv6BfVhi4/ALGsfpsnrKC2qITx244SmHybPCaWpooeBgJQAxickUHNiHsbZefds5VVwTjZVSI9xw9ODMA44aY7KNMY3AWuA61wLGmI+MMY5Mxs+B6CFu44CKTJhO1ckigsIMNRUNnKltGu4mqRGkucVKfmVduwRjZ/6NY3jKviDf5LSBG55yiJ4WgpevB8ccw1RJqZypraEkL6dVufgw3XRTKTU6DEeAEwXkuzwvsB/rzL8Dfx/UFg2yCHseDtYiAN14U7VyouoMTS2mXQ9O8dEjrfNv9pQSFuXPuPD2PT395e7hRnyKhZyvy2hpsTrX3Gm7bUN0iC8ebqKL/SmlRrwRnWQsIt8H5gBPd3L+DhHZKSI7S0tLOyoyIkyYfB5u7h7UnbLNSinL12EqdZZjf6dJbdbAyXfJv6k73UjxsVPED+DsqbYmzwqnoa6ZE4erCAy1EBIR5WyDg4e7G7GhftqDo5Qa8YYjwCkEYlyeR9uPtSIi3wYeBq41xjR0dCNjzBpjzBxjzJzw8MH7xd9fnl7ejI+fTGneEfzHeWmisWolzx7gxFvaBzjh9vyb3H1lGMOATg9vK3ZmKB7e7s5F/2ISkyk4mIW1paVVuTiLv+bgKKVGvOEIcHYAU0UkXkS8gBuBTa4FRGQW8CK24KZkGNo44CKnTqf42BHCovw00Vi1klNWh6+nO+Ndpoi3NDdx4tBBou1DRTl7SgkM9cESHTBo7fDwcmdSYhjZe0qxWg2xSak01tdzMvtoq3LxFtuu4larThVXSo1cQx7gGGOagbuBLcBB4K/GmP0i8piIXGsv9jQQAKwXkT0isqmT240akdNm0NzYgI//KSqL6mhuaun+InVOyCuvZVKYX6sp4sVHj9DcaMu/aTzTTP7BSianhXe40/hAmjIrnPrTjRRnn3Lm/rTdtiHO4s+ZJisnq3VVbqXUyDUsOTjGmM3GmARjzBRjzGr7sUeNMZvsj79tjJlgjEmzf13b9R1HvoiptkRj01KE1WqoLNLl7pVNTnltuz2o8l32nzq+v4KWZivxgzB7qq1JyWG4eQjZX5XiNy4YS8ykdnk4jplUOaU6TKWUGrlGdJLxWBJkCScgNIzaylwASjXRWAEtVkN+RR2TLK1nRuXv30t4bBy+gUFk7ynFJ8CTiCnjBr09Xj4exM4I5dieEowxxCSlUPjNAZqbzi5tEGdvq86kUkqNZBrgDKHIhBmUHT+Kp7e7ThVXAJyoqqepxTh7RQCam5o4cfgbohOTaWm2kpdVTlyKBTf3ofnvOnnWeGoqGig9Xk1MYgrNjQ0UHznkPB85zhcvDzedSaWUGtE0wBlCkQnTOV1WQvB4q04VV0DHU8SLjx125t8UHq6ksb55UGdPtRWfakHchGO7S4mZkQwiHHfZl8rNTYgL8yOnTIdZlVIjlwY4Q8iRh+PlXUZZQQ1GZ6Gc83LLbUGC6xTxgv37QITomclk7ynDw9udmOkhQ9YmH39PohKCyd5dire/P+PjJrfbeFN3FVdKjXQa4Ayh8fFTcPf0xNp8gqYzLZwurx/uJqlhlltWi4+nW6sp4o71b3z8Asj5upRJM0Px8HIf0nZNSR9P1ck6Kk7UEpuUStGRb2hqODtrKj7cn/yKelo0SFdKjVAa4AwhD09PJsSfR01FHoAu+KdsU8RD/XFzs03/duTfxMxM5mTuaepONQ7q6sWdiU+1gNi2h4hJTKaluZkTh745ez7Mn8YWKyeqNEhXSo1MGuAMsYiE6VQUZoO0aKKxIre8zjkrCc7m30QnJpPzdSlubsKkpLAhb5f/OG8ipozj2FelRE9PRNzcyD9wdpjKsTFotiYaK6VGKA1whlhUwgxampsJGHdaE43PcS1Ww/HyulZr4Djyb6KmJ5K9p4zIhGB8/D2HpX1TZo2nvLCGumqYOGVqqwX/HDlDOpNKKTVSaYAzxBw7i3t6l2oPzjmu6FQ9jS1WZ28IQP4B2/o3Z2rcqTpZN6Szp9pyLCyYvbuU2KRUio8dobHelhQ9PtAbPy933ZNKKTViaYAzxAJCQgkKH09zQyE1lQ3U1zQOd5PUMMm1T7OeFGYbompuauLEIVv+TfYe24aX8anDF+AEhfkyflKgbbp4YgrGaqXgm/0AiAhxYf7Oae5KKTXSaIAzDCITZlBTngtoovG5zBEcOIaoio8eormpkZjEFHL2lDI+LoiAEO+ubjHoJs8KpyT3NEHh8bh7eHA862weTrzuKq6UGsE0wBkGEVOnU3+6EmOt1gDnHJZXXou3hxsTg3wA+/5TIgRHTKEkr5rJQ7D3VHemzBoPwPEDp4lImN5qPZx4iz8FlfU0tViHq3lKKdUpDXCGQdS0GQB4eZdQVqCJxueqnLI6JoX5OaeIFxzYR/ikeIqONgAMa/6NQ/AEP0Ij/cneXUrMzBRKcrOpr7H9zMZZ/J17aSml1EijAc4wsMTG4eHljYenJhqfy/JcdhFvm38TPMGPkIn+3dxhaEyZFc6Jo1WMj58JxlBwMAuAeMemmzpMpZQagTTAGQbuHh5MnDKVpjOFVBbX0dzYMtxNUkPMajXkVdQ5Z1A58m8mTJlB4eGqEdF74zB51ngwUF8TjIeXN/n2PBxHcKYBjlJqJNIAZ5hEJkyntrIAa0sjFUX6AXGuKTp9hsZmq3MGlSP/pqV5IsZqRlSAExblz7hwX3L2VhE1faYzDyfU34sgHw+dSaWUGpE0wBkmEQkzMNYWTEuJJhqfg/LsvR7x9l6Q/P22/JuCQ/X4j/Ni/KTA4WxeKyLC5FnhFH5TScTURMry86itqkREiLf4O6e7K6XUSKIBzjCJnDoNAKGYUl3R+JyTY+/1mGTxp7mxkaLD3xA9PYnj+8uJTwtH7InHI8WUWeOxWg1unjGAvccJW6KxDlEppUYiDXCGid+4YIInRuDuflJ7cM5BeeV1eHm4ERHkQ/HRwzQ3NeIdEEdzo5XJw7i4X2fGxwUSEOJNxQk/vHx9ncNU8RZ/Tpyq50yT5pEppUaWYQlwRORKETkkIkdF5MEOzi8Ska9EpFlEvjccbRwKkVOn01hfSGlBNcZqhrs5agjllNUyKdQ2RdyRf1NzKhQvXw8ipwUPd/PaEREmp4WT/80pIhMSWwU4xsBxnSqulBphhjzAERF34HngKmAmsEJEZrYpdhxYCfxlaFs3tCISZtDcUE1TfSWnSuuHuzlqCOWV1zLJkX9zYB/jJ8VTcLCeuOQw3N1HZsfqlPRwWpqs+IdMprLoBNXlZc6ZVNmlOkyllBpZhuM36TzgqDEm2xjTCKwFrnMtYIzJNcbsBcb0EqmR9o03TfMJXQ/nHGK1GvLK64i3+Dnzb0IiEjhT2zSiZk+1NXFKML6BnpypnwBA/v69zmnuOpNKKTXSDEeAEwXkuzwvsB/rNRG5Q0R2isjO0tLSAWncULLETsLTxxfTUkSZJhqfM4pPn6Gh2cqkMH9n/o3VROLu4UbMzNDhbl6n3NyE+LRwTuZ64+0fwPH9exnn60mYvxe5mmislBphRmZfeA8ZY9YYY+YYY+aEh4/cv3w74+bmTsR5UxE5qT045xBHb0e8xZ/j+/eCCOXFQcTMDMXLx2OYW9e1KbPCaW60EhaV4MzD0ZlUSqmRaDgCnEIgxuV5tP3YOSkyYQZNDScpySsf7qaoIeJYN2ZSmB8FB/YRGjmJulNuxKcO/+aa3YlKCMHbzwPxiOF0aQmnSoqJC9MARyk18gxHgLMDmCoi8SLiBdwIbBqGdowIEQnTwVipqcin7nTjcDdHDYG88lq83N0I93XnxJFv8AmMRwTiU0Z+gOPu4UZcioVTZWEAHM/aS7zFj5LqBmobmoe5dUopddaQBzjGmGbgbmALcBD4qzFmv4g8JiLXAojIXBEpAP4NeFFE9g91O4dKxFRHonGR7ix+jsgtryU2zI+S7MO0NDVxpm48EecF4xvoNdxN65Eps8JpahyHt38Qx7O+Jt4SAGiisVJqZBmWHBxjzGZjTIIxZooxZrX92KPGmE32xzuMMdHGGH9jTJgxJnE42jkUfAMCCYmIwtpyQhf8O0fkltURF+ZH/n7b+je1p8JG9OyptmJmhOLp44HfuMnkH9jHpDBfQDfdVEqNLKM6yXisiJw2A9NSpFs2nANsu4jXEhfmT8GBfQSGRiNuPqMi/8bBw8uduKQwGs5MoLayguDGKgCdSaWUGlE0wOnCC9uO8emxslbHPj1Wxgvbjg1oPZEJ0zHWek5mHx/Q+6qR52T1Gc40WYkN9uLEkW8Qj2gsMQEEWXyHu2m9MnlWOM3NkQCUHTnAhCBvcnTTTaXUCKIBThdSosdx9192O4OcT4+VcfdfdpMSPW5A64lMmAFAVfExmhp1T5+xzDGDKqyuiJamJuprxxM/Avee6s6kpDA8vELx8g0mP+tr4sL8NQdHKTWiaIDThQumWPjzTbO449Vd/PbvB7n7L7v5802zuGDKwA4nhEXF4Onti7WpiPJCzcMZy/LsQYBb8TEQwc09alTl3zh4+XgQmxiGuEeTf2Af8WG+moOjlBpRNMDpRlSwLzUNzbywLZu0mGDmx4cNeB3i5sb4yQmaaHwOyLFPET+V/Q3e/hGMGx9MWJT/cDerT6bMCqfFGkV99Wli5TQVtY2cqm8a7mYppRSgAU63CqvqCfLxYGKQN//8poRL/7C1XV7OQIhNTMS0lHEyZ+DvrUaOvLI6JgV7UnzkEC0tEcSnhSMiw92sPolLseDhFQvAuFO2/DFNNFZKjRQa4HTBkXPzwi2z+eyhy/jZt86joLKOm176gttf3TmgXfKOjTdPHP5mwO6pRp7c8lqmu1XS0tyEuMWMyuEpBx9/T2ISJ+HuGYwpPALoVHGl1MihAU4X9haccubciAj3XjGN/1o5l0UJFj49WsYV/3sbj79zgFN1/e+Wj5g6DRCqirKxWk3/G69GHGMMueW1RNYXAoJfyCQmTh7YhPWhNjktHCSaiqMHccOqAY5SasQY2Tv7DbMfXzyl3bFLpo3nkmnjKak+wzNbDvNf23P4f18VcM+3E7hpfiye7n2LGb39/AkIi6TuVCGnSuoImTg68zJU50qqGzjTZMW/NpcWz/FMSYvGzW10Dk85TE4Lx80zhqbaLGZ4VetMKqXUiKE9OH00PtCH330vhXd+tpDpE4P49ab9XPncx3x0qKTP94yYOg1rSxGl+acHsKVqpMgpq8Xd2kxzcS7iFk38KB6ecvAL8iJiahIA06wnNQdHKTViaIDTT4mR4/jL7fNZc8tsWqyGH/73Dn7wX19y+GTvVyWOS0kC00D+/oFdSFCNDHnltUxsOIlpacbLdxLR00OGu0kDImHeZMQtlAmnjpNdVosxOsSqlBp+GuAMABHhisSJvP+fF/PI1TPYc7ySK5/7mIff2kd5TUOP7xM9YyYARUc00Xgsyi2vI7bhBCBMSk3Bw9N9uJs0ICbPsg1TeZTnUVvfQEVt43A3SSmlNMAZSF4ebvzooslsvf9SblkwibU78rnk6a28uO0YDc3dr1AcEhGFu6cflcXZQ9BaNdRyy2pJaChG3MczdW70cDdnwASG+hASkQAtjYxvKNU8HKXUiKABziAI9ffiN9clseWei5gTF8JTf/+Gy5/9mPeyirrsvhcRgidOpqmugNpTPe/5UaPD8ZJTBNYX4e4Vw6Sk0bO5Zk/URE4GYEpdIdmltgBnMPZtczVUe8VpnVqn1jk66mxLA5xBdN74QP77h/N49bZ5+Hi68ePXv+LGNZ+TVXiq02tsG29WcOLIySFsqRpsxhjOFGYjpoXxcTPw9h1bExhnXDgZcQ9ncv0JcstrB23fNldDtVec1ql1ap2jo862ZKwkBM6ZM8fs3LlzuJvRqeYWK2t35PPsB4eprGtkWXo09y+exoQgn1blju3cxcanf03y5T/hih99Z5haqwZayekzPHDvb0k+vYtv/eh/M+vy84a7SQPqy79t4PO/fUZj7VFenXo7dcaN830qGN9QSkn8Bc5yXf26MXR+srPrTtU3cai4monjfCg+dYZpEwMJ9vMEQLBNwW+7ULRj5WhxPqfN847PO45U1jWyt6CK6BA/CirrSI0OJizA6+z9OVuha92tHtPqSUcPne0IOvIJpd7j2Xp6HHEWP3LL6rgk6BThDSWcnnoRQKue4XZvlXF96FLO9XibMiFH/0WJz3g+qQkmJtSP/Io6LgqoYvyZEqrOu6jV7du/v528zi5eq+P1ltU0sCu3kkkWP/LK6kifFIwlwLv96zI9ez0dnXe9jzFQUdvIvsKz38/kqGBC/b3oTE8XHu+sWOixf1HiPZ5PaoOJCfEjv7KOi/yrGN9QQvmUha3Ktv+5N92cb//9N8Zgyd5Oic94Pq0LITLYlxNV9VzgV8n4MyWUTb6w89fQwxfbUamw7O2UeI9ne10wUcG+VNU38dQCX8LqTzLvuu/16L690GFDx9afkSOYh7sb318wie+mRvL8R0f57+05bN5XxI8vnsLtF03G18uWcBqTNBMQio9+A2iAM1bkltcx6cwJxH08CfNihrs5A666chwtDbkILYSfPoFfgCdJ32ymIvJaahuaW5Xt6pdmV79O2142Y/92TgVHUBkYQUFlPZHjfJhSmkdwVRH7Z9p+aTs++B2/9Nt9yHV63rR+bv931uHP8BgXwTi/ieSU1RLm70XY8aOEnS7mq6kL2gUKbappXbdL+9oed32SUjmOySffJC/6Sg6dnMg0azGTv36P4gnXsN+1N7ib4KGjc50FIwE1oSQceYuimKs4WDqBGeYkCfv+TunE77ZazLFtUNrZ6+zytdoPzM/+gvrAifj5RXDkZA3Bvp4EHDtMYHUxX0yZ30HbpYNj7V9PRz9ujmvTD3+G57gIjtu/n5YALyYUHCP0VBG7E85vd11PuwO66jgIdH1vy+zvbdbfKY34LvkVde3+f7T/Xnb93HZN64OWegszszdSHvsdssrHkyQlzDywmbKIaynvZFJAT/s+OvvDJLQulBnH3qI09ir2l0/g9iktHMv8b7wuvq1nNx4AGuAMsXG+nvzqOzO4eX4sT23+hmc/OEzml8f55ZXTuTY1Ei8fX3wCJnLqZM5wN1UNoOyiSgIbT+JrmYf/OO/hbs6Am3b+HA5+9h0aqt7iOzVf0FxSiW/AAr47N4KQCLeO/5J3+b3YPujp/C9/R/kc6wQOfPwWLSHzWJY6g5yvdzKp8ktmLLqOFSleHf+l3e6gad+2DsvZ5HhFsn/bW3iELiA+dSY5X+8hvuJzEi9ewq2zAtrcus2Hf9sPgrZP232i2J5XnIhl15b5fCv/Xa6ISaQ5fz++/hfwbxfEcGeEX6vSnQeIpoOTcvZcGxUx0ex6bx6X5L3Dt2MTaT6+H9+A81l6QTQ/imjd69z2rXK9W/v3tuPeLWMgxz+SA9s24hMyn/i0GeTs2UN85RfMvPh6VqYFdfrK+iPbK4ID2zbiHjKf+LSZ5OzZ7azzljS/1oXbfj/PRslt/u34qe2QoTIqml1b5nPJ8Xf4drT9+xlwPkvmR/HvEZ33HPVHxYRIvnp/HhflvM2lMTNpzj+Ab8D5XDcvkpCJ3YQBrXrGehL12MpUhkew+x9zWZTzDt+KmUnjP79BQq5j2vlz+v5CemlYhqhE5Ergj4A78LIx5rdtznsDrwKzgXJguTEmt6t7jvQhqs58nl3OE+8eIKvwNGkxwVyQ8yV+NYU0VGbz0//OxMfPmzdff5+C/Qf5j6f+Y1Da8MeH/kh04gyWff8K5zGtc2DrzK6uw23ryyR9+y5qfD0Htc7h8OmxMlb/126+dewVMDXD3Ryl1Ajj4ZfO+1EX8fAPbdsfDbCRMUQlIu7A88DlQAGwQ0Q2GWMOuBT7d6DSGHOeiNwI/A5YPtRtHQoLJoex6acLefOrAp7ecojP6gNYWHkMaCJn92EO5BSR885LxF9z+6C1ITpxBjnvvMSbwLLvX8Gbr7+vdQ5wnY0BcfggVDQ1UfhhxqDWORz2Fpzi7ot9OJRnxUgitBwjLO0qTnmMZ3ZscKuyZ3sy7L+TOum56Jzt/FfHqxgf6MXprM84fXI3QRNmEZR0ASXVZ5jVps6O62nVCpdinde/O7+K8YHetjpLviZofCpBSedTUt3ArJj2dXabw9BNz5UI7MqrYlxzKeVfbwG3eLDmEJZ6Jac8LaTHuiwWadr3inSm7alWPS0GvsqvJKiplIq974H7ZGjJJjTlSk57WpgVE9JF549xtrv1+9i+56zt8935VYwP8OH0/k85fXIPQRPSCEq0v7cdfT8HwO7j9u/n/s96Vme74aP23682F7S7xa7j9u/nnvfAbTJYs+3/VyzMmTQ4i3/uzKtkXHMZ5Xv+bvt+WrMJS72KU57hzHH9GepJyk0nw52ty8CO3EqCm0oo2/N3cJsCzYe4e9Hl7C04NRgBTsfNGOoeHBE5H1hljFlsf/4QgDHmKZcyW+xlPhMRD6AYCDddNHa09uC4qm1o5sVtx8j6f++RWPkB4Ak0Y9wCMOLl8tPU1S/Fjs+1euM6+KUqLQ24Wasw4oeYOlrcgsHdh0HVcgb3c6bOChB/DFbir7m9VS/SWHA8ay+bnnkKD/+rmXXFBex+/1Oaa9/l2nsfIjYpZdDq3fX37Wx79TmiZy6i4MDHXPyDe5h9VedJk6OxzuF4b/X7qd/PUVbnyOjBAaKAfJfnBcD8zsoYY5pF5BQQBrSaVC8idwB3AMTGxg5We4eMv7cHv7hiGgVzovnLz7NwbyrCuIdifC2dZyC6Pm83Jnz2sXM9gM7+WvbwxjQ0I9bTGLcg3LwD+/diesLD85yr0y1q0ZgLbgAOff41Hv5Xc83PriZ6WghR00J45//Yjg/WL1DHB5PjA2nX39PZ9upzAIP2ATUcdQ7He6vfT/1+jsY62xrVScbGmDXAGrD14AxzcwbMF5u349ZchUQtwpzYweRLrxz0D0XHcI2jzvhvX6d1DkKd1hM7ePP198dckBMWs4gZFwURPc3W3R09LYRrfnY1JbmDt3Hs8ayDrf7advx7POvgoH04DUedw/He6vdTv5+jsc62dIhqhHHNC2mbJzJYH4pa59iqUymlzjEjZohqBzBVROKBQuBG4KY2ZTYBtwKfAd8D/tlVcDOWFOw/2OrDb9n3r+BN+3EYnA9ErXNs1amUUmr4pol/B3gO2zTx/zLGrBaRx4CdxphNIuIDvAbMAiqAG40xXe5AOVZ6cJRSSinVKx324OhWDUoppZQazToMcHSzTaWUUkqNORrgKKWUUmrM0QBHKaWUUmOOBjhKKaWUGnPGTJKxiJQCeYNYhYU2KykPAa1T69Q6tU6tU+vUOrtWZoy5su3BMRPgDDYR2WmMGbp93rVOrVPr1Dq1Tq1T6+wzHaJSSiml1JijAY5SSimlxhwNcHpujdapdWqdWqfWqXVqnaOiTs3BUUoppdTYoz04SimllBpzNMBRSiml1JijAU4Pich7IlIlIu8MUX1pIvKZiOwXkb0isnyA7z9JRL4SkT32On7cSblQEflARI7Y/w0Zgjr/zX7eKiL9mlrYizqfFpFv7O/1WyISPAR1Pm6vb4+IvC8ikX2ts5v2BIlIgYj8eRDu3WJv/x4R2dRJGW8RWSciR0XkCxGJG4I6F9m/B80i8r3+1NeLOn8hIgfs39MPRWTSENX7YxHZZy/zLxGZOdh1upRdJiJmAP6f9uR1rhSRUpdyPxrsOu3lbrB/X/eLyF8Gu04R+d8uZQ6LSNUQ1BkrIh+JyG77z+93hqDOSfb/J3tFZKuIRPenzg4ZY/SrB1/AZcB3gXeGqL4EYKr9cSRQBAQP4P29AG/74wAgF4jsoNzvgQftjx8EfjcEdc4ApgFbgTlD9DqvADzsj383RK8zyOXxz4EXBuln6Y/AX4A/D8K9a3pQ5ieO1wbcCKwbgjrjgBTgVeB7Q/Q6LwX87I/v6u/r7EW9rj9H1wLvDXad9nKBwMfA5wPw/7Qnr3PlQP4M97DOqcBuIMT+fPxQvLcu5X8G/NcQvM41wF32xzOB3CGocz1wq/3xt4DXBup76/jyQLUiIo8BFcaY5+zPVwMlxpg/isglQ10ngDHmhIiUAOFA1UDfH/Cm896864BL7I//B1vQ8cvBrNMYc9B+TXfVDGSd77s8/Rzo0V/9/azztMtTf6DPGf+dtQP4FzABeA/o81/ZXdy/J64DVtkfbwD+LCJi7L/ZBqNOY0yu/RprD9s4EHV+5PL0c+D7Q1Rvn36O+vk9BXgc2x8D9/f0ggGos9f6WeftwPPGmEoAY0yPrhvA17kC+PUQ1GmAIPvjccCJIahzJvAL++OPgI09vK7nBjpiGu1f2P7y+8r+2A04BoTZn1/CIPTgdFWn/dg84CDgNpD3B2KAvUAd8FOX8i9j/4sMqHI5Lq7PB6tOl2Nb2x4b7Drtx98Gvj8UdQKrgXwgCwgf6J8h+3sYTT//+u3i/s3ATmwf6Ne7lH8MuNb+OAuIdjl3DLAMZp0uxzLoRQ/OQNRpP/5n4JGhqhf4qf2afOw9v4P8PU0H3uzt/9N+1rkSW0/2XmyBcswQ1LkRWy/2dnu5K4fq5wiYZH+97kPwOiOAfUABUAnMHoI6/wL8h/3xUmxBVlhP6u3x/6uBvNlY+QI+AGYBVwIbXI5fwiANUXVRZwRwCFgwGPe3n4sEvgQmdHBdVZvnlYNdp0uZrfSy63sA6nwYeAv7EgpDUae93EPAbwbyewzcDTxgP7eSfnbvd/Q6gSj7v5OxDcVN6eC6PgU4/anT5foMejlENQB1fh/bL3bvoazXXu4m4H8Gs05sH2RbgTj78179P+3Hz1EYZ4d+7wT+OQR1voPt94EnEI8tgAweop+jXwL/Zyh+hrD1pNxrf3w+cIAe/kHdjzojgf+HbQjwj9iCqx69tz390iGqjr2M7QNhIvBfw1WniAQB7wIPG2M+H+j7OxjbEFgWcBG2D0ZXJ0UkwhhTJCIR9K6bta919kef6xSRlcA1wGXG/j9wsOt08QawmR52R/ewHTcDF4nIT7DlAnmJSI0x5sEBuj/GmEL7v9kishXbL7pjba4rxNajVSAiHti6wMsHuc7+6HOdIvJtbEHyxcaYhqGq18Va4P8b5DoDgSRgq30YeSKwSUSuNcbsHKQ6McaUt7nH73v8Kvv+3hYAXxhjmoAcETmMLS9nxyDW6XAjtp653uhrnf+OLUDBGPOZiPhg2yCzJ7/v+/r9PIGt5wYRCQCWGWOqev5Se2Ago6Wx8oUtSfQQkI1L9yCD24PTqk778w+Bewbp/tGAr/1cCHAYSO7guqdpnWT8+8Gu0+X6rfS+B6evr/NKbH+19HqYqB91TnV5/DPa9P4M1M+t/dxK+t+D0/Z1hnD2L2oLcASY2cF1P6V1kvFfB7tOl+sz6H0PTl9fp+OXeI+GiAawXtefo+8CO4fq/bWX69X/0368zgiXx0uAz4egziux94jZy+XTw2GU/ry3wHRsPR897knu5+v8O7DS/ngGthycHtXdjzot2HuJsA3VP9aX/zddfWkPTgeMMY0i8hG24ZkWABH5BNsPXYCIFAD/bozZMlh1isgKYBEQZu9ZANsP4J4Buv8M4BkRMdhya/5gjNkHICIvY/tA2gn8FviriPw7kAfcMNh1isgS4P9gS6p+V0T2GGMWD/Lr/DO2hOAP7H+Vfm6M6XB69wDW+VsRmQZYsb23Paqvp+3oz716cn/763zRnsjrBvzWGHMAnMmHO40xm4BXgNdE5ChQgS3IGdQ6RWQutqGFEOC7IvIbY0ziIL/Op7H1lK23/wwdN8ZcO9ivFbjb3nPUhC1/4tYhqLPP+lHnz0XkWmz5HRXYgvbBrnMLcIWIHABagPtN656kwagTbP9H1hr7p/8QvM57gZdE5D+x5cKs7Gnd/ajzEuAp++/Jj+l9b1WPGqdf7SNLN2APffxLbCTWORZf07lc53C041x5b4fr+3muvFatU+scqq/Opgafs8S2SNZR4ENjzJGxUOdYfE3ncp3D0Y5z5b0dru/nufJatU6tcyjpZptKKaWUGnO0B0cppZRSY44GOEoppZQaczTAUUoppdSYowGOUqrfxLaj9Osuzz3EtvPzO728T66IWPpbpod1XS/92HlbRILtiygqpUYgDXCUUgOhFkgSEV/788uxrWA8kl2PbcO/vgrGtlO6UmoE0gBHKTVQNgNX2x+vADIdJ0QkVEQ2isheEflcRFLsx8NE5H0R2W9fBFFcrvm+iHwpIntE5EURce+qchFZISL7RCRLRH7ncrzG5fH3RCRDRC4ArgWett9/iohsFZE/2p9nicg8+zWrROQ+l3tkiUgctkUwp9jLP93nd00pNSg0wFFKDZS1wI1i28cmBfjC5dxvgN3GmBTgV8Cr9uO/Bv5lbKsMvwXEAthXQ10OXGiMScO2iuzNnVUsIpHA74BvAWnAXBG5vrPyxphPgU3YVqZNM8Y49snxs9f3E7rfh+5B4Jj9+vu7KauUGmK6VYNSakAYY/baezZWYOvNcbUQWGYv9097z00Qtu1IltqPvysilfbylwGzgR32bQ986Xrjv7nAVmNMKYCIvGG/98ZevoxMe1s+FpEgEQnu5fVKqRFCAxyl1EDaBPwB2z4zYf24j2Db5PChAWiT62qmPr0o63jeTOve7u7uoZQaAXSISik1kP4L+I2xby7q4hPsQ0wicglQZow5jW2TvZvsx6/CtjkmwIfA90RkvP1cqIhM6qLeL4GLRcRiz9VZAWyznzspIjNExA3bLtQO1UBgm/sst9e3EDhljDmFbVfndPvxdCC+i+uVUiOEBjhKqQFjjCkwxvypg1OrgNkishdbcq5jx+vfAItEZD+2oarj9vscAB4B3rdf8wEQ0UW9RdhyYj4CvgZ2GWP+Zj/9IPAO8ClQ5HLZWuB+EdktIlPsx86IyG7gBeDf7cfeBELtbbwbOGyvsxzYbk861iRjpUYY3YtKKaUAEdkK3GeM2TncbVFK9Z/24CillFJqzNEeHKWUUkqNOdqDo5RSSqkxRwMcpZRSSo05GuAopZRSaszRAEcppZRSY44GOEoppZQaczTAUUoppdSYowGOUkoppcYcDXCUUkopNeZogKOUUkqpMUcDHKWUUkqNORrgKKUGhYjUiMjkLs7vF5FLenCfm0Xk/YFsW39199ralDUict5gt0kp1ZoGOEqdA0RkoYh8KiKnRKRCRLaLyNzBrNMYE2CMybbXnyEiT7Q5n2iM2dqD+7xhjLnC8XwkBAyur60/RGSliPxrINqklGrNY7gboJQaXCISBLwD3AX8FfACLgIahrNdSik1mLQHR6mxLwHAGJNpjGkxxtQbY943xux1FBCR20TkoIhUisgWEZnkcs6IyI9F5IiIVInI8yIi9nPnicg2e89QmYisa3PdeSJyB3Az8IB9aOdt+/lcEfm2iESKSL2IhLpcO8t+P0/XXg4R+dhe5Gv7vZaLSJaIfNflWk/7tbPavhH2ti6zP77Q3sar7c8vE5E9vXhPzrM/DhORt0XktIjsEJEnOuiV+Xbb909EZgAvAOfbX0uV/X7fEZEDIlItIoUicl/332KlVFsa4Cg19h0GWkTkf0TkKhEJcT0pItcBvwKWAuHAJ0Bmm3tcA8wFUoAbgMX2448D7wMhQDTwf9pWboxZA7wB/N4+tPPdNudPAJ8By1wO3wRsMMY0tSm7yP4w1X6vdcCrwPddin0HKDLG7O7gvdgGXGJ/fDGQDSxyeb4NevyeODwP1AITgVvtX221e/+MMQeBHwOf2V9LsL3sK8CdxphAIAn4Zyf1KqW6oAGOUmOcMeY0sBAwwEtAqYhsEpEJ9iI/Bp4yxhw0xjQDTwJprj0WwG+NMVXGmOPAR0Ca/XgTMAmINMacMcb0NZ/kL8AKAHvv0I32Yz3xOvAd+1AcwC3Aa52U3YYtkAFbYPOUy3NngEPP3hNExB1bYPZrY0ydMeYA8D8d1NvZ+9eRJmCmiAQZYyqNMV91UVYp1QkNcJQ6B9g/qFcaY6Kx9QpEAs/ZT08C/mgfPqkCKgABolxuUezyuA4IsD9+wF72S/usqNv62MQ3sQ3VRGALPKzYek26Ze8B2g4sE5Fg4CpsPUYd+QxIsAd3adh6f2JExALMAxxDYD15T8DWu+MB5Lscy6e9zt6/jizD1guVZx9SO7+LskqpTmiSsVLnGGPMNyKSAdxpP5QPrDbGdBYUdHWvYuB2sM3UAv4hIh8bY462LdrNfSrFNhV8OTADWGuM6fKaNv4H+BG232mfGWMKO6mnTkR2Af8BZBljGkXkU+AXwDFjTJm9aE/fk1KgGdvw3GH7sZhetLvdazTG7ACuExFP4G5sieG9uadSCu3BUWrME5HpInKviETbn8dgGw763F7kBeAhEUm0nx8nIv/Ww3v/m+O+QCW2D2xrB0VPAt2tG/MX4AfA9+h6eKqje20E0rEFLq92U882bIGDYzhqa5vn0MP3xBjTAvw/YJWI+InIdPtr6KmTQLSIeNnr8RLbuj/j7PlHp+n4/VRKdUMDHKXGvmpgPvCFiNRiC2yygHsBjDFvAb8D1orIafu5q3p477n2+9YAm4D/6GR9mFew5ZVUicjGTu61CZgKFBtjvu6izlXA/9jvdYP9NdRjG+aKxxZwdGUbEMjZ4ai2z3v7ntwNjMM2DPUatmTknk7B/yewHygWEUfv0S1Arr3eH2ObgaaU6iXpXS+wUkqNTCLyKJBgjPl+t4UHtx2/AyYaYzqaTaWUGiLag6OUGvXsa+j8O7BmGOqeLiIp9rVt5tnb8dZQt0Mp1dqgBjgicqWIHBKRoyLyYAfnfywi+0Rkj4j8S0Rmupx7yH7dIRFZ3PZapZQCEJHbsSUF/90Y83F35QdBILZhsVpgHfAM8LdhaIdSysWgDVHZ14c4DFwOFAA7gBX2dSIcZYLsa3QgItcCPzHGXGkPdDKxTduMBP6Breu5ZVAaq5RSSqkxZTB7cOYBR40x2caYRmAtcJ1rAUdwY+fP2SmT12GbJtpgjMkBjtrvp5RSSinVrcFcByeK1gteFWCbydGKiPwU2xoUXsC3XK793KVYAe0X2EJse9zcATBz5szZ+/fvH5CGK6WUUmrUkI4ODnuSsTHmeWPMFOCXwCO9vHaNMWaOMWaOr6/v4DRQKaWUUqPOYAY4hbRefTPafqwza4Hr+3itUkoppZTTYAY4O4CpIhJvX6XzRmwLeTmJyFSXp1cDR+yPNwE3ioi3iMRjW/zry0Fsq1JKKaXGkEHLwTHGNIvI3cAWwB34L2PMfhF5DNhpjNkE3C0i38a2e24lcKv92v0i8lfgALZ9Xn6qM6iUUkop1VNjZiXjOXPmmJ07dw53M5RSasRpamqioKCAM2fODHdTlOozHx8foqOj8fT0bHuqwyRj3U1cKaXGuIKCAgIDA4mLi0Okw88CpUY0Ywzl5eUUFBQQHx/fo2uGfRaVau2rLXkUHKpsdazgUCVfbckbphYppUa7M2fOEBYWpsGNGrVEhLCwsF71QmqAM8KMjwtiy0tZziCn4FAlW17KYnxc0DC3TCk1mmlwo0a73v4M6xDVCBM9LYRv/3AGm//vXmYujODQFydZfHsS0dNChrtpSiml1KihPTgjTEneabZvOEZTQwtff1hA0qIoDW6UUqNeQEBAu2Mff/wx6enpeHh4sGHDhl7fs6ysDE9PT1544YVOy6xatYo//OEPvb53V+Li4rjoootaHUtLSyMpKanVsXvuuYeoqCisVqvzWEZGBuHh4cyaNYupU6eyePFiPv300x7XXVdXx80330xycjJJSUksXLiQmpqa/r0gFzt37uTnP/+5s6133313uzJxcXEkJyeTkpLCxRdfTF7eyEyh0ABnhGhptvLFpmw2/G4X9acbQSDI4kPWx4XtcnKUUmqwDGUeYGxsLBkZGdx0002dlsnIyGDVqlUdnlu/fj0LFiwgMzNzwNsGtuAoIyOjw3PV1dXk59t2Izp48GC781arlbfeeouYmBi2bdvW6tzy5cvZvXs3R44c4cEHH2Tp0qUd3iMuLq7dsT/+8Y9MmDCBffv2kZWVxSuvvNLRrKI+mzNnDn/605+6LffRRx+xd+9eLrnkEp544okBq38gaYAzApTmV7P+qZ3s3JxL9PRgwBA7M5SmhhYW/yixVU6OUkoNpqHMA4yLiyMlJQU3t759FGVmZvLMM89QWFhIQUGB8/jq1atJSEhg4cKFHDp0yHn8pZdeYu7cuaSmprJs2TLq6ur63PYbbriBdevWOduxYsWKVue3bt1KYmIid911V5cB2KWXXsodd9zBmjVrelRvUVERUVFnt2acNm0a3t7eALz++uvMmzePtLQ07rzzTlpabMvHBQQE8PDDD5OamsqCBQs4efIkYAsQk5KSSE1NZdGiRc52X3PNNT18F+D888+nsHBkbjSgOTjDqKXFylfv5bHz3Vx8Ajy5+icpVBTVkr44jooTNRzfX0HIRH8W355ESe5pHapSSvXbJ389TFl+10Ma/uO8ePtPe/Ab50XdqUZCJvqx450cdryT02F5S0wAF92QMBjN7VR+fj5FRUXMmzfPGWzce++97Nq1i7Vr17Jnzx6am5tJT09n9uzZACxdupTbb78dgEceeYRXXnmFn/3sZ32qf9myZfzwhz/kvvvu4+233+aNN97gtddec553BD3XXXcdv/rVr2hqauq0pyU9PZ0XX3yxR/XedtttXHHFFWzYsIHLLruMW2+9lalTp3Lw4EHWrVvH9u3b8fT05Cc/+QlvvPEGP/jBD6itrWXBggWsXr2aBx54gJdeeolHHnmExx57jC1bthAVFUVVVVWf3of33nuP66+/vk/XDjYNcIZJeWENH/7PQUqPVzN17gQW3ZiAj78ncSkWANzcbNnipfnVxCVbNLhRSg0Zbz9P/MZ5UVPRQECoN95+AzcE0hPl5eVcdtllAFRUVNDY2MjGjRsBeO2110hOTmbdunXccMMNANx4443cdttt3HvvvXzyyScsWbIEPz8/AK699lrnfbOysnjkkUeoqqqipqaGxYsXt6t737593HLLLQAUFxfj5eXFc889B8CHH35IWFgYAGFhYYSEhLB27VpmzJjhrA+gsbGRzZs38+yzzxIYGMj8+fPZsmVLpz0jrgvurl69mvXr1wNw4sQJ0tLSALjwwgt5/vnnSUtLIzs7m/fff59//OMfzJ07l88++4wPP/yQXbt2MXfuXADq6+sZP348AF5eXs66Z8+ezQcffOC858qVK7nhhhtYunRpt98XV5deeikVFRUEBATw+OOP9+raoaIBzhCztljZ/cFxvnwnB29fD668M4kps8a3KxcWbUvIKy+sIS7ZMtTNVEqNUT3paXEMS835ThxZHxcy95r4If0jKywsjD179gC2HJzc3Nx2eTiZmZkUFxfzxhtvALZg4MiRI3Rl5cqVbNy4kdTUVDIyMti6dWu7MsnJyc66V61aRVxcHCtXruzwfsuXL+enP/1puzydLVu2UFVVRXJyMmBLDPb19e00wNm9ezczZswA4OGHH+bhhx8GbEN4jra4CggIYOnSpSxduhQ3Nzc2b96Ml5cXt956K0899VS78p6ens4p1u7u7jQ3NwPwwgsv8MUXX/Duu+8ye/Zsdu3a1WH7OvLRRx8RHBzMzTffzK9//WueffbZHl87VDQHZwhVFtfy//7wFZ9vzCY+xcKKR+d3GNwAePt6EGTx6bYrWSmlBpIjuFl8exLzr53M4tuTRlwe4OHDh6mpqaGwsJDc3Fxyc3N56KGHyMzMZNGiRWzcuJH6+nqqq6t5++23nddVV1cTERFBU1OTMzDqjyVLlvDAAw+06wnKzMzk5ZdfdrYtJyeHDz74oMOcn23btrFmzRrn0Fl3tm/fTmWl7XvR2NjIgQMHmDRpEpdddhkbNmygpKQEsPV8dTe76dixY8yfP5/HHnuM8PBwZ9J0T3l4ePDcc8/x6quvUlFR0atrh4IGOEPAajXs+cdx1q3eQVVJHVf8KJEr70jGN9Cry+ss0YGUFWiAo5QaOiW5p1utvRU9LcSZB9gfdXV1REdHO7+effZZduzYQXR0NOvXr+fOO+8kMTGxR/fKzMxkyZIlrY4tW7aMzMxM0tPTWb58OampqVx11VXOIRuAxx9/nPnz53PhhRcyffp05/FNmzbx6KOP9vo1BQYG8stf/hIvr7O/y+vq6njvvfe4+uqrncf8/f1ZuHChM9hat24daWlpJCQk8OSTT/Lmm286e3C6c+zYMS6++GKSk5OZNWsWc+bMYdmyZcycOZMnnniCK664gpSUFC6//HKKioq6vNf999/vnG5+wQUXkJqa2q5MRkZGq++bazI3QEREBCtWrOD555/vUfuHkm62OciqSur456sHKTp6irgUC5fcPA3/cd49unbHuzl8+U4Ot//vRXj56GiiUqpvDh482OMPUKVGsk5+lnWzzaFkrIZ92wr57K2juHu48e2VM0iYP7FXS01bogPAQMWJWiZOHjeIrVVKKaXGFg1wBsHpsnr++dpBCg9VEZsYxqXfn05ASM96bVxZYgIBKCuo0QBHKaWU6gUNcAaQMYYD/zrB9g1HQeDSW6Yz44KIPm9yFxDijbefB2X51QPcUqWUUmps0wBngFRXnOGj178h/0AF0dND+NYPZhAY6tOve4oIlugATTRWSimlekkDnH4yxvDNZ8X866+HsRq4eEUCiYui+txr05YlOpD9nxRitRrn4n9KKaWU6poGOP1QW9XA1je+IXdfOZFTg/nWD2YwLtx3QOuwxATQ3GTlVEkdIRP9B/TeSiml1Fil6+D0gTGGQ18Uk/nYFxR8U8nCG6Zy/X/OGvDgBs6uaKzDVEqp0SwgIKDdsY8//pj09HQ8PDzYsGFDr+9ZVlaGp6cnL7zwQqdlVq1axR/+8Ide37srcXFxXHTRRa2OpaWlkZSU1OrYPffcQ1RUFFar1XksIyOD8PBwZs2axdSpU1m8eDGffvppj+uuq6vj5ptvdq5fs3DhQmpqBu7zYefOnfz85z93tvXuu+9uVyYuLo7k5GRSUlK4+OKLu11Q0NXKlSuJj48nLS2N9PR0Pvvss1bnn3nmGUSEsrKy/r0QNMDptbrTjbz3Yhb/+O8DhEz0Z/kj80j9VgwySMNHoRH+uLmLrmislBoSX/5tA8ez9rY6djxrL1/+rfcBSHdiY2PJyMjgpptu6rRMRkZGu20aHNavX8+CBQu63K27P1atWtVuGwaH6upq58q/Bw8ebHfearXy1ltvERMTw7Zt21qdW758Obt37+bIkSM8+OCDLF26tMN7xMXFtTv2xz/+kQkTJrBv3z6ysrJ45ZVXOt3Esy/mzJnDn/70p27LffTRR+zdu5dLLrmEJ554ot35rVu3drrFxdNPP82ePXv47W9/y5133uk8np+fz/vvv09sbGyf2+9KA5wufLUlr9Xy5Ed3lfD6o5+Rs7eMC5aex5L70gme4NfFHfrP3cONkAh/ygp0JpVSavBNnJLAO8/91hnkHM/ayzvP/ZaJUwZ+t/C4uDhSUlJwc+vbR1FmZibPPPMMhYWFrVbYXb16NQkJCSxcuJBDhw45j7/00kvMnTuX1NRUli1b1uHWCT3l2MHc0Y4VK1a0Or9161YSExO56667ugzALr30Uu644w7WrFnTo3qLioqIiopyPp82bRre3rZlSF5//XXmzZtHWload955Jy0tLYCt9+zhhx8mNTWVBQsWcPLkScAWICYlJZGamsqiRYuc7e5sz6yOnH/++RQWFva4vKtFixZx9OhR5/P//M//5Pe///2A5bBqDk4XxscFseWlLC79/jSO7Czh6M4SxE249OZpzLgwcsjaER4dwPEDI2+fD6XU6PNRxhpK8rK7LOMfGsqbT/4v/ENCqa2sIDQ6hs/e/AufvfmXDsuPnzSZS1feMRjN7VR+fj5FRUXMmzfPGWzce++97Nq1i7Vr17Jnzx6am5tJT09n9uzZACxdutS559MjjzzCK6+8ws9+9rM+1b9s2TJ++MMfct999/H222/zxhtv8NprrznPO4Ke6667jl/96lc0NTV12tOSnp7Oiy++2KN6b7vtNq644go2bNjAZZddxq233srUqVM5ePAg69atY/v27Xh6evKTn/yEN954gx/84AfU1tayYMECVq9ezQMPPMBLL73EI488wmOPPcaWLVuIioqiqqqqT+/De++9x/XXX9+na99++23nhqR/+9vfiIqK6nC7iL7SAKcL0dNCWPhvU/n7i1kAeHi58Z27komZETak7bDEBPLN58XUnW7EL6jr/auUUqq/fPwD8A8JpbqslEBLOD7+7fNnBlN5eTmXXXYZYNs0srGxkY0bNwLw2muvkZyczLp167jhhhsAuPHGG7ntttu49957+eSTT1iyZAl+frbe9WuvvdZ536ysLB555BGqqqqoqalpt0kmwL59+7jlllsAKC4uxsvLi+eeew6ADz/8kLAw2+//sLAwQkJCWLt2LTNmzHDWB7ZNMDdv3syzzz5LYGAg8+fPZ8uWLZ32jLhumbR69WrWr18P2HZIT0tLA+DCCy/k+eefJy0tjezsbN5//33+8Y9/MHfuXD777DM+/PBDdu3a5dx7q76+nvHjbZs5e3l5OeuePXs2H3zwgfOeK1eu5IYbbmDp0qXdfl9cXXrppVRUVBAQEMDjjz/uPD5//nwaGhqoqamhoqLC2f7f/e53zvf7/vvv54knniA8PJxXXnmFuro6nnzySd5///1etaE7GuB0I2HuBPZ+mE/J8WrSvh075MENuCYaVxM7c+jrV0qNHT3paXEMSy1YdiNfv7+Z85fdRGxSyhC0ziYsLIw9e/YAthyc3Nzcdnk4mZmZFBcXO3cFP3HiBEeOHOnyvitXrmTjxo2kpqaSkZHB1q1b25VJTk521r1q1Sri4uI6zSVZvnw5P/3pT9vl6WzZsoWqqipn70RdXR2+vr6dBji7d+927q/08MMP8/DDDwO2ITxHW1wFBASwdOlSli5dipubG5s3b8bLy4tbb72Vp556ql15T09P57CPu7s7zc3NALzwwgt88cUXvPvuu8yePZtdu3Z12L6OfPTRRwQHB3PzzTfz61//mmeffRaAL774ArANdWVkZHSYw/T000/zve99z/l837595OTkOHtvCgoKSE9P58svv2TixIk9blNbmoPTjcIjVZyuOMOc78SR9XFhq5ycoWJxBDiaaKyUGmSO4Oaaex7kwhu+zzX3PNgqJ2ckOHz4MDU1NRQWFpKbm0tubi4PPfQQmZmZLFq0iI0bN1JfX091dbVzB2+wJQZHRETQ1NTkDIz6Y8mSJTzwwAPteoIyMzN5+eWXnW3Lycnhgw8+6DDnZ9u2baxZs8Y5dNad7du3U1lp+xxqbGzkwIEDTJo0icsuu4wNGzZQUlIC2Hq+upvddOzYMebPn89jjz1GeHi4M2m6pzw8PHjuued49dVXqajoexpFcnIyJSUlzvcrOjqar776ql/BDWiA06WCQ5VseSmLxbcnMf/aySy+PYktL2UNeZDj4+9JQKi3ThVXSg264mOHueaeB509NrFJKVxzz4MUHzvcr/vW1dURHR3t/Hr22WfZsWMH0dHRrF+/njvvvJPExMQe3SszM5MlS5a0OrZs2TIyMzNJT09n+fLlpKamctVVVzmHbAAef/xx5s+fz4UXXsj06dOdxzdt2sSjjz7a69cUGBjIL3/5S7y8zqYO1NXV8d5773H11Vc7j/n7+7Nw4UJnsLVu3TrS0tJISEjgySef5M033+zxbu/Hjh3j4osvJjk5mVmzZjFnzhyWLVvGzJkzeeKJJ7jiiitISUnh8ssvp6ioqMt73X///c7p5hdccEGH+S8ZGRmtvm+uydwAERERrFixgueff75H7R9K4jr2N+A3F7kS+CPgDrxsjPltm/O/AH4ENAOlwG3GmDz7uRZgn73ocWPMtXRhzpw5ZufOnQPa/q+25DE+LojoaSHOYwWHKinJPU364kkDWld33v2/ezlVUsdNqxYMab1KqdHv4MGDPf4AVWok6+RnucNpV4OWgyMi7sDzwOVAAbBDRDYZYw64FNsNzDHG1InIXcDvgeX2c/XGmLTBal9PdBTERE8LaRXwDBVLdAB5+8pobmzBw8t9yOtXSimlRpPBHKKaBxw1xmQbYxqBtcB1rgWMMR8ZYxyDkp8D0YPYnl4bygWvumOJCcAYKD9RO+R1K6WUUqPNYAY4UYBrxlKB/Vhn/h34u8tzHxHZKSKfi8j1HV0gInfYy+wsLS3td4Pbcix4deSLTzHGDOqCV92xRAcCUJavC/4ppXpvMNMRlBoKvf0ZHhHTxEXk+8Ac4GKXw5OMMYUiMhn4p4jsM8Ycc73OGLMGWAO2HJyBbldsUgpX/uQe3vrdY7i5u2OMIWLqNLJ376CiMJ/gCRMZNzGCIMt43D0G960MCvPBy8ddE42VUr3m4+NDeXk5YWFhA7ZKrFJDyRhDeXk5Pj4+Pb5mMD+VC4EYl+fR9mOtiMi3gYeBi40xDY7jxphC+7/ZIrIVmAUca3v9YIuekcSk1HTyvv6K4ImRnKmpYc+Wd2hpanKWETc3gizhjJsQQfCEiQRPiCB4QgTjJkwkeMJEvHz7v52DuAlh0QE6VVwp1WuO2S+D0dOt1FDx8fEhOrrnmSyDGeDsAKaKSDy2wOZGoNWOaiIyC3gRuNIYU+JyPASoM8Y0iIgFuBBbAvKQKz52lJLso84Fr66550FiZiZRU1XBqeJiqk4WUXXS9u+pk0Uc/nw7Z2paDyP5Bo1zBj6uQdC4CRPxDw5p9RfVl3/bwMQpCa0W1TqetZfiY4exRKfwzWdFGKsZtM09lVJjj6enJ/Hx8cPdDKWG1KAFOMaYZhG5G9iCbZr4fxlj9ovIY8BOY8wm4GkgAFhv/5B3TAefAbwoIlZseUK/bTP7aki4LngVm5RCzMyUVs8DQy1Ez0xqd92Z2hpOnSxuFfhUnSym4Jv9HNy+DVzGET28vQkeP9EZ+FitVv72hye47N/vYsbCS8jfv89ZZ82pAJq2tnCqrJ7g8YO7yadSSik1mg3qOjhDaTDWwemqN2Xedd/r4srONTc1cbr0pD3wcQ2Cijl1spjmpkZn2bi02Zw8dsQZUJXknWb9UztZfHsS580e3+/Xp5RSSo0BQ7sOzljQURATm5TSrz1ZPDw9CY2MJjSy/TiisVqdQ19vPf0YuXt2sWDZjc76QiP9ETehrKBaAxyllFKqC7pVwwgibm4EhlqwWq20NDXh4eXN1+9vdq7F4+HpTshEP8p1JpVSSinVJQ1wRhhH3k/aFVfT3NjAJbf+qNVGd5boAJ0qrpRSSnVDA5wRxrHRXdIl3wbAWE2rje4s0YHUVDZQX9PY1W2UUkqpc5rm4IwwjrwfY7Xi5evHicMHufz2y5x5OJaYAADKCmqImR46bO1USimlRjLtwRmhxM2NyITpnDj8Tavjlmh7gKML/imllFKd0gBnBItMmEFZfh4NdWc32PQN9MJ/nJcmGiullFJd0ABnBItMmAHGUHTkUKvjlphAygp0002llFKqMxrgjGATz0tAxI0Thw+2Om6JDqCyqI7mppZhaplSSik1smmAM4J5+/lhiZ3UPg8nJhCr1VBZVDdMLVNKKaVGNg1wRrjIhBkUHfkGq/Vsb40z0ViHqZRSSqkOaYAzwkVNm0FjfT3l+cedx8aF++Lh7a4zqZRSSqlOaIAzwkVOmwHQKg9H3ARLlL+uaKyUUkp1QgOcES4ofAL+wSEUHmqbaBxIWX41Y2U3eKWUUmogaYAzwokIkQkz2s+kigmg8UwL1eVnhqllSiml1MilAc4oEJkwnVMni6mtqnQeC4s+u2WDUkoppVrTAGcU6CgPJywqABEoy9eZVEoppVRbGuCMAuPjz8Pdw6PVejieXu4ET/DTHhyllFKqAxrgjAIenp5MmDyVE+0SjQN0qrhSSinVAQ1wRonIaTM4mX2E5qYm5zFLTCDVFWc4U9vUxZVKKaXUuUcDnFEiMmE6Lc3NlOQcdR5zJBqXF2ovjlJKKeVKA5xRIjLBnmjsMkzl3LJBh6mUUkqpVjTAGSX8g0MYN2Fiq0Rj/3He+AZ56Z5USimlVBsa4IwijgX/XFcvDo8O0JlUSimlVBsa4IwiUdNmUFtVyenSk85jYdEBVBTV0tJsHcaWKaWUUiOLBjijSId5ODEBWJsNlcV1w9UspZRSasTRAGcUCYuJxcvXt9XGm5boQADNw1FKKaVcDGqAIyJXisghETkqIg92cP4XInJARPaKyIciMsnl3K0icsT+detgtnO0cHNzJ2Lq9FZbNgRP8MPD001nUimllFIuBi3AERF34HngKmAmsEJEZrYpthuYY4xJATYAv7dfGwr8GpgPzAN+LSIhg9XW0SQyYTplx/NoqLMNSbm5/f/t3Xl8VNXd+PHPdyb7vkJ2AiEJhB3CoqJoUZa6t7YuXbRPa9vH+vSxu12eLvbXVmsXuz9V62Nta23VVhQRRBBBkCVsIRACCQSysWQj+zKZ8/tjLjFAINssJPm+X69h7r1z7z3nJhPmO+d87zlCTHKYtuAopZRSPXiyBWceUGyMOWKM6QBeAG7tuYMx5m1jzNnkka1AirW8FFhrjKk1xtQBa4FlHqzrsJGUNRljnJwoPtS9Lc66k6rn3VVKKaXUaObJACcZKOuxXm5tu5hPA28M5FgR+ayI5IlI3unTp4dY3eEhMTMbRM7ppopLCaO92UFTXbsPa6aUUkpdPi6LJGMR+TiQCzw+kOOMMU8aY3KNMbnx8fGeqdxlJjAklLjUcecGOKlnE401D0cppZQCzwY4FUBqj/UUa9s5ROR64NvALcaY9oEcO1olZU2i8tBBjNM19k1scigIVJdpHo5SSikFng1wdgCZIjJeRAKAu4BXe+4gIrOAP+IKbk71eGkNsEREoq3k4iXWNoUrD6ejtYWa8uMABAT5ERkXTI224CillFKABwMcY4wDeBBXYFII/NMYs19EHhGRW6zdHgfCgBdFZI+IvGodWwv8EFeQtAN4xNqmgKRsa8C/HvNSxaWGcVoDHKWUUgoAP0+e3BizClh13rbv9li+/hLHPgM847naDV9RYxMJjoik8lAh06933VwWlxJOya7TdLQ6CAj26K9VKaWUuuxdFknGamBEpHvizbPiUsMAqK7QVhyllFJKA5xhKjl7MnVVlbQ0nAF6TNmgIxorpZRSGuAMV90Tb1p5OKFRAQSF+lOjIxorpZRSGuAMV2MnTMRm96Oy6ADg6raKSw3TsXCUUkopNMAZtvwCAhg7IeOCEY1rKppxdjl9WDOllFLK9zTAGcaSsiZzouQwXY5OwDWicZfDSd3Jlj6OVEoppUY2DXCGsaTsyXR1dnLq6BHA1YIDmmislFJKaYAzjCVlTgLo7qaKSgjB5ic6orFSSqlRTwOcYSwsJpaI+LFUFrkCHLvdRmxSGNV6J5VSSqlRTgOcYc418WYhxhjA1U1VXd7Uva6UUkqNRhrgDHNJ2ZNpqqulsfo04BrRuLWxk5YzHT6umVJKKeU7GuAMc2cH/Kuw8nC6E401D0cppdQopgHOMBeflo5/YFB3Hk7s2SkbNA9HKaXUKKYBzjBns9tJzMzqvpMqMNiPiLggvVVcKaXUqKYBzgiQlJ3D6WNH6WhrBVwTb2oXlVJKqdFMA5wRIClrMsbp5ETxYcCVaFx/qoXO9i4f10wppZTyDQ1wRoDEzGyA7ok3Y5PDwEBNhbbiKKWUGp00wBkBgkLDiE1J687DiUvVO6mUUkqNbhrgjBBJ2ZOpPHwQ43QSHhNEYIgf1WV6J5VSSqnRSQOcESIpazLtzc3UVpYjIt0jGiullFKjUb8CHBF5rD/blO90D/jXPR5OGDUVTTidOmWDUkqp0ae/LTg39LJtuTsrooYmOjGJoPCI9/NwUsJxdDg5c6rFxzVTSimlvM/vUi+KyH8CDwATRCS/x0vhwGZPVkwNjIhYE28eBM5NNI5OCPVl1ZRSSimvu2SAAzwPvAH8BHi4x/ZGY0ytx2qlBiUpazJHdm6npeEMMYnh2OxCdVkTmbljfV01pZRSyqsu2UVljDljjCk1xtwNlAOdgAHCRCTNGxVU/Zds5eFUHS7C7mcjOjFU56RSSik1KvU3yfhB4CSwFnjdeqz0YL3UIIzNmIjNbu+Rh6N3UimllBqd+uqiOushINsYU+PBuqgh8g8MYkz6hHMCnKKtJ2hp6CAkIsDHtVNKKaW8p793UZUBZwZ6chFZJiJFIlIsIg/38vo1IrJLRBwicsd5r3WJyB7r8epAyx6tkrJzOFF8mC6Hg7jUcADtplJKKTXq9HUX1ZetxSPABhF5HWg/+7ox5heXONYO/A7XLeblwA4RedUYc6DHbseB+4Cv9nKKVmPMzH5cg+ohKWsyu1at4PSxo8SlpANQXdZEWk6sbyumlFJKeVFfXVTh1vNx6xFgPfpjHlBsjDkCICIvALcC3QGOMabUes3Z/yqrS0nKmgS4Jt5MyMgkLDpQ83CUUkqNOpcMcIwxPxjCuZNxdW2dVQ7MH8DxQSKSBziAR40xr5y/g4h8FvgsQFqa3tQFEB4bR3hcPBWHDjL7g7cSlxquAY5SSqlRp19JxiLyGq7bw3s6A+QBfzTGtLm7YsA4Y0yFiEwA1ovIPmNMSc8djDFPAk8C5Obm6pwElqSsyVQUuRrK4lLCOLavGkdHF34Bdh/XTCmllPKO/iYZHwGagKesRwPQCGRZ672pAFJ7rKdY2/rFGFNhPR8BNgCz+nvsaJeUNZmmmmoaqk8TlxqGMVBT2ezraimllFJe09/bxK80xsztsf6aiOwwxswVkf0XOWYHkCki43EFNncB9/SnMBGJBlqMMe0iEgdcBfy0n3Ud9ZKzXQP+VR4qJDHT9WurLmtkbHqEL6ullFJKeU1/W3DOGbnYWg6zVjt6O8AY4wAeBNYAhcA/jTH7ReQREbnFOs9cESkHPgL8sUewNBnIE5G9wNu4cnAOXFiK6k1cWjp+gYFUHiokIjYI/yA7NZqHM2psX/ESxwvyz9l2vCCf7Ste8lGNlFLK+/rbgvMV4F0RKQEEGA88ICKhwJ8vdpAxZhWw6rxt3+2xvANX19X5x20BpvWzbuo8dj8/EjOyqCw6iNhERzQeZRIyslj5xKPc9NDDpE2dzvGC/O51pZQaLfoV4BhjVolIJjDJ2lTUI7H4CU9UTA1NUvZktq94ic62NuJSwjn4XhXGaRCb+LpqysPSpk7npoce5rVf/JicRR+gcNOG7mBHKaVGi0t2UYnIB6znDwE3AhnW44PWNnWZSsqajHE6OXHkMHGpYXS2d3GmutXX1VJekjwph66uLnatepUZSz6owY1SatTpKwdnkfV8cy+PmzxYLzVEiZnZAFQWFRKX4kqXqi7TbqrRYuu/XqCzzRXQ7lnz+gU5OUopNdJdMsAxxnzPev5UL4//8E4V1WAEh0cQk5RC5aFCYhJDEZtQU6EBzmhwvCCf7a+8iF9AIADTFi9l5ROPapCjlBpV+nUXlYiMFZE/icgb1nqOiHzas1VTQ5WUnUPloYPY/W1EJ4RQXaaTbo4GJXlbcXZ1ceVHP0ZYbBx1lRXc9NDDnCg55OuqKaWU1/T3NvFncd3unWStHwIe8kB9lBslZU+iramRuqoKvZNqFOnsaMcvIJBp1y0hY858SvN3kZiVzbxb7/B11ZRSymv6G+DEGWP+CTihe4ybLo/VSrlFUpZrwL+KogPEpYTTVNdOW1Onj2ulPKm1qZHCTRuYfPW1BIWFMTF3Po72do7v2+PrqimllFf1N8BpFpFYrPmoRGQBrrmo1GUsJjGZoLBwKosOvp9oXK7dVCPZ/rfX4uhoZ+aSGwFInTKNgOAQinds83HNlFLKu/q6TfwhEZkHfB1YAUwQkc3Ac8AXvVA/NQRis5GUNYnKQ4XEdgc42k01UjmdXexZu4rkSVMYkz4BALufP+Nn5XJk13acTm10VUqNHn214KTgGshvtbXvWuAFXHNT7fVs1ZQ7JGVNpraiDLG1ExoZoLeKj2Cle3Zx5uQJZi07dwSHibnzaTlTT9WhIh/VTCmlvK+v28S/aoy5EkgAvgpsA64F8kVE54YaBpKyXINPVx0+SFxquHZRjWC716wkNDqGiXOvOGf7+Fm52Ox+FOdt9VHNlFLK+/qbgxMMRACR1qMSV7CjLnMJGVmIzdadh1NX1UJXp9PX1VJuVldVQemency4fjl2v3NnYAkMCSV1yjRK8vRPVik1evSVg/OklXPzD+AKYAvwEWNMrjHmU96ooBoa/6AgxqRP6M7DcToNtVXNvq6WcrM9b67CZvdj+vXLen19Yu4C6qoqqKko83LNlFLKN/pqwUkDAoETQAVQDtR7uE7KzZKyJlNVXERsUgigd1KNNB1trRS8vZasBVcRGhXd6z4ZufMBKN6h3VRKqdGhrxycZcBc4GfWpq8AO0TkTRH5gacrp9wjKWsSjvZ22ltP4Bdo10TjEaZw09t0tLZckFzcU3hsHGMnTKRE83CUUqNEnzk4xqUAWAW8AWzGNaP4f3u4bspNkrJdA/6dOHyQuORQvVV8BDHGsHv1SsaMzyAxc9Il983InU9V8SGa6+u8VDullPKdvnJwvigiL4jIceAdXDOIHwQ+BMR4oX7KDcJj4wmLiaXy0EFiU8KpLm/CGOPraik3KD+wj5ry48xaehMicsl9J869AoyhZKcmGyulRr6+WnDSgReB+caYDGPMJ4wxfzDG7DXG6K04w4SIWBNvFhKXEkZHq4PGmjZfV0u5we41KwkKCyf7qmv63DcudRyRY8bq3VRKqVGhrxycLxtjXjbGVHmrQsozkrMm0XD6FCERHYCOaDwSNFSfpnjHVqZ9YAn+AYF97i8iZOQu4Ni+PXS0tXqhhkop5Tv9HQdHDXNnJ95sayxDBKrL9E6q4S7/rdUYY5hxwwf7fczE3Pl0dXZSuneXB2umlFK+pwHOKBGfPgG/gEBOHikiamyItuAMc47OTvLXrSZjzjwix4zt93HJk6YQFBZOid4urpQa4TTAGSXsfn4kZGR2D/inAc7wdui9TbQ2nGHW0psHdJzNbmfC7Lkc2bUDZ5dOvqmUGrk0wBlFkrImcepoCdEJATTWtNHe0unrKqlB2r1mJdFJKaRNmzHgYyfmLqCtuYnywv0eqJlSSl0eNMAZRZKyJ+Ps6sJmqwY00Xi4qiou4kTxIWYtvbHPW8N7M27GLOz+/jron1JqRNMAZxQ5OxBcW+NxAB3ReJjas+Z1/IOCyblm8aCODwgKZty0mRTnbdPxkJRSI5YGOKNISEQk0YnJVB8/THC4v85JNQy1NJyhaMtGpiz6AIEhIYM+T0buAhpOn6T6eKn7KqeUUpcRDXBGmaSsyVQWaaLxcLVv3Rq6HA5mLrn4vFP9kTFnHojo5JtKqRHLowGOiCwTkSIRKRaRh3t5/RoR2SUiDhG547zX7hWRw9bjXk/WczRJyp5Ea2MDYVFt1FY10+XQAamHC2dXF3vXvkHa1BnEpqQO6VyhUdEkZmZTrHk4SqkRymMBjojYgd8By4Ec4G4RyTlvt+PAfcDz5x0bA3wPmA/MA74nItGequtocnbAP5yVOB2GuhMtvq2Q6reSndtorDnNzEvMGj4QE3MXcOpoCQ3Vp91yPqWUupx4sgVnHlBsjDlijOkAXgBu7bmDMabUGJMPnN+MsBRYa4ypNcbUAWuBZR6s66gRm5xKYGgoLWesRGPNwxk2dq9eSXhcvKt7yQ0mzl0AoJNvKqVGJE8GOMlAWY/1cmub244Vkc+KSJ6I5J0+rd9C+0NsNpIyJ1FTXozd36Z3Ug0T1WXHKNufz8wlN2Kz2d1yzpikFKKTUjQPRyk1Ig3rJGNjzJPGmFxjTG58fLyvqzNsJGVNpqb8ONFj7JpoPEzsWfM6dn9/pl53g1vPOzF3PuUH9tHWrO8DpdTI4skApwLomQmZYm3z9LGqD0nZk8EYAkNrqC5v1LFQLnPtLc0c2LieSVcuIiQi0q3nzshdgLOri6N7drr1vEop5WueDHB2AJkiMl5EAoC7gFf7eewaYImIRFvJxUusbcoNEiZmIWLDOCppb3bQVNfu6yqpS9j/zjo629uY5abk4p4SM7MIiYzSyTeVUiOOxwIcY4wDeBBXYFII/NMYs19EHhGRWwBEZK6IlAMfAf4oIvutY2uBH+IKknYAj1jblBsEBAUTP248zfXHAJ2y4XJmnE72rHmdxMxsxk6Y6Pbz22x2MubM4+iePBydOjeZUmrk8GgOjjFmlTEmyxiTYYz5kbXtu8aYV63lHcaYFGNMqDEm1hgzpcexzxhjJlqP//NkPUejpOxJ1FaUYIyTGr2T6rJ1bN8e6qoqmLXU/a03Z2XkLqCjtZXy/fkeK0MppbxtWCcZq8FLyppMZ1sboRGNeieVB+1ac4zyorpztpUX1bFrzbF+Hb979WuEREaRuWChJ6oHQNq0GfgFBlKcp7eLK6VGDg1wRqmzA/4FBp/mtA+6qIb6wT9cjEmPYM1TBZQfrMU4DeVFdax5qoAx6RF9Hlt/8gRHducx/fpl+Pn7e6yO/gGBjJ8xh5KdOvmmUmrk0ABnlIqIH0NodAxdnVU0nG6lo9Xh1fK7P/itIGcgH/zDSUp2NDMWp7LiV3v45092sOapApbeP5WU7L4H5t67dhUiwvTrPT/GZUbufJpqazh5pNjjZSmllDf4+boCyjdEhKSsSVQUHQa5muqKJpImRnmt/JTsaK66YyKv/24v6dPiKC+q6/cH/3DR3tLJuy8e5uB7JxC7UF3WxNRFyf26xs72NgrWv0nmvCsJj4nzeF0nzJ6L2GwU79hKQkamx8tTSilP0xacUSwpazIt9acxziZqvNRN1eVwcjjvJK/8chfrni3E0eGkeOcpAkP8iIgL8kodvOHY/hr+/sh2iradJGveWAIC7YhA4eaqC7rmenNw80bamps8mlzcU3B4BMmTcijRyTeVUiOEBjij2Nk8HLvfKarLPHsnVf2pFrb8q5g/f3Mzbz69n4bqNiZdmUhgiB8pk6I5c6qVv31vK7vePEZX1/Cd4by91cH6vxSy8jd7CQj24+o7Mzl+oJZln5vGlGuScTqdrP7jvksGOcYYdq9ZSVxaOsmTp1x0P3ebmLuA6rJj1J884bUylVLKU7SLahQbMz4Du78/AQGnPTIWTpfDydG91ezfVEH5wTrEJqRPi2XKNcnYbcKaP+1n2eemkZIdzaEdJ1j3bCHv/auEQ9tOcu3HskmY4N5Rez2t7EAt6/9SSHN9O7OXjmPuTenkry/v7nqLiAviwKZKkrOiOFXacNGuqsqiQk6XHuGG+x9ERLxW/4zcBWx47mlK8rYy58bbvFauUkp5ggY4o5ifvz8JGZmcOV1BTUUzzi4nNvvQG/XOnG7lwLuVFL5XRWtDB2Exgcy7eTw5VyURGhUIuO6i6plzkzU3gZDwAA6+d4LyojpefnwnUxYmseC2DIJC3XMH0fYVL5GQkUXa1Ond244X5HOi5BDzbr1j0OftaHOw5eVi9m+qJDohhA99fQ4J413B2eyl47r3i4gNJmtBAsU7TrLonkkXPd/uNSsJDAll8sJrB12nwYgam0BcWjrFOzTAUUoNfxrgjHJJWZOpOrwC//AO6k+2EpMUOqjzdHU5Kc2vZv+mSsoKaxFg3LQ4plydRNqUWGy2c1sien7wn5UyKYaUSTF0tDnY/tpR8teXcWTPaRZ+JJPMuWOH3JqRkJHFyice5fr7v8D4mXOoOnyIlU88yk0PPTzoc5YfrGX9cwdprGtj5g1pzL95PH4BF5/te87ScRS9V8XedWVccXvGBa831dZweNtmZi27Cf8g7+ckTcydz7Z/v0hLwxm3z3ullFLepAHOKJeUNZkdr76M6TpJdXnjgAOchhqrtWZLFS1nOgiLDmTujePJuSqRsOjBfUAHBPmx8COZZM9PYMPfDrL2mQMUbqli0T3ZRI0JGdQ5AVKnTCNn0WJe+8VPCAoLB2O4+cvfOqdFp7862hy89+8SCt6pIHJMMB/66hwSM/oOCKLGhpAxZwz73iln1pK0C1qn8tetxul0MmPJjQOukztk5C5g67/+wdHdeUxZtNgndVBKKXfQAGeUS8pydZUYZxXVZU1kzev7GGeXk9J9NezfVMnxAzUAjJsay5Srkxk3JcYt3VwA8WnhfPgbuezfWMHWV0p44ZHtzFk+jtlLxmH3H1gZHa0trH3qdxzc/A7hsfE01pzGHhCAze/irS0XU3GojvXPFdJQ08aMxanMv3UC/pdotTnfnGXpFOedYt+GcubeOL57e5ejk/y3VjN+5hyiE5IGXC93GDthImExsRTv2KoBjlJqWNMAZ5QLiYwiKiGR9pZTVPcxJ1VjbRsHNldSuLmK5vp2QiMDyF2eTs7CJMJjPNOdYrMJ065NYcLMeN598TDbXzvKoe0nufaebJL7OWbOqdIjrHziMepPVDHl2us5snM7M5fcyN633uDFH3yTpQ98iZyrr+vzPJ3tXWx9pYT8t8uJiA/m9i/PJikzasDXFJcSRvr0OPauL2PG4lQCglx/hoe3baG5vs5rt4b3RkTIyF3A/nfeorOjHf+AQJ/VRSmlhkIDHEVS1mQObd3O6bJGjDHn5Lo4nYbjBTXs31TBsYIaDJCWE8s1d2WRPi3Wba01fQmNCmTp/VOZdGUNG/9exCu/3E32ggSu+vBEgsMDej3GGEP+W6t5+89PEhwWzqJP/Afb/v1PbnroYdKmTmfcjFm89ouf8MZvf05dZTlXfuRjiK3366ksrmfdnwtpON3K9OtSWHBbBv6BA2/9OWvO8nG8/Fg1+zdWMmtJGgC717xO1NhE0mfMHvR53WFi7nz2vvk6x/ftIWPOfJ/WRSmlBksDHIXDMQZHRxMtZ6ppaeggNDKQw3knKdxcSd2JFprq2gmJCGD2snHkXJVERFywz+o6bkosd313PnmrStnz5nFK91Vz5YcmMvmKRKRHInN7Swtrn/wNRe9tIn3GbJY/+BUK3l7bHdyAa9yX27/xPd594Tm2/usf1FZVsuyBh85ptejs6GLbiiPsXV9GRGwQt31pVr9bji4lYXwkKZOi2fPWcaZdl0xNeSmVRQe49pOfuWiQ5S2pU6YREBxC8Y5tGuAopYYtDXAU42dN59CWFzCOSvZtKKe8qI6TRxoASM2JYeFHM0mfHofdS601ffEPsHPFbRlkzRvLO88X8fZfDnLwPVcScmxSGCePlrDyiUc5c+okC+/6JPNuvQOx2Xq9FTx9xmzGTZ/FjldfZtPzz9J4+hS3fu07hEZFc+LIGdb9uZD6ky1MXZTMFbdndHcnucOc5ems+OVuCjdXUXnwdfwCA5my6Hq3nX+w7H7+jJ+Vy5Fd23E6u7DZBt9SpZRSviIjZfbg3Nxck5eX5+tqDEtOZxe/ue8ujMnEP/R6EMicM5b5t04gMt53rTX9YZyGwveq2PKvYjpaHCSMP86xva8QEhHJjf/9dVIm9X8k4MPbtrDqtz8nOCKS8XM+xeEdnYRFB/GBT04iZVKM++tuDP96fCeNNWeor/gdU675ADd89kG3lzMYBze/w+u/fpy7fvBTkifl+Lo6Sil1Kb2OIXJ5fCVXPmWz2UnOnoSf/ynANVbLks9MueyDGwCxCTlXJXHH16cRELCWoztfwi9gHNd96gcDCm4AMudfyfWf/Q7N9S3kr/klyVkN3PXdeR4JbsCV0DtneTpnTubR1dnBzGW+Sy4+3/hZudjsfhTr3FRKqWFKAxzF9hUvIbZQ2ptPMPOGsex/t5Kdb2xm+4qXfF21fjlRcpiXfvQ1Gk7tZ8YNdxKdehdrnznC6icLaK5v79c5ujqdvPfvEt55vo7IpHuJSkigZNsz7N/whkfrnpoThXHswz84jdiUCwc/9JXAkFBSp0yjJG+br6uilFKDojk4CntAIqV7/w5AcmYHQSE23nnuCRZ98iHfVqwPxhh2r17JO3/5E6FR0dz5/cdIzp5MV6eT3WuPkbfqGGUHaph/awZTFyVfMJryWaeONfDWs4XUVTWTc1UiV96Rici1vP7rx1n/f3+ktrKC6+69H5vd/bkopXt20tVZjy1gISW7TpGZO9btZQxWRu581j/zv9RUlBGbnOrr6iil1IBoDo5i15pjONpK2PT8LwgMDcPpcDDv9s8REJLV65QKl4O25ibe/N9fc3j7FibMmcey/3yI4PCIc/apP9XCxr8XUVZYx5hx4SRMiGT8zPju+a+6Op2s/0shh3acJDQykOs+PolxU2O7j3c6u9j41/9j5+uvMH7mHG78728QGDL4kZR789KP/oea8uOExn8WvwB/7vz2XK9OsHkpDdWneeoLn2Lh3fcy/7aP+Lo6Sil1Mb3+p6kBjur22hOPcei9TQDY/fzInH8V0xcvJSVn2mXzoQtQVVzEyid+SlNtNVffcx9zbrztovUzxnA47yTvvlhMa0MHdn8byz47ldDIQFY/uY+G6jZSc6JZ+pmpBIb0Pqnn3rVvsO6ZPxCbnMrt3/geEfFj3HIdtZXl/N+XPs9VH/04UUmLWPfnQm58YDrp0+Pccn53+Os3H8Jmt3PP//u5r6uilFIX0+sHgHZRKcA1q3ZZwV4WfPgudq9eSWrONI7uzuPg5neITkxi2uJlTFm02KcTMBpj2LVqBRv/9ixhMTHc+f3HuqeauBgRIWtuAuOmxLL1lSMUbKzg9d/ngwEE5t86gdzl6Zc8x4wblhM5NoGVv3yUv337y9z61e/0WW5/7HnzdWx2P6YtXkpQeCTbVx4l741Sxk2LvWwCyozc+Wx58Xma6+sIjRr6+D9KKeUtmmSsOF6Q3z2r9lUf/Ti3fPlbVBzczwe/+DWWPfAlgiOi2PjXZ/jj5+/ltSce49i+PRin06t1bG1qZMXP/h8bnnua8bNy+cSjvx5QkBEY4s+ie7L58NfnEBrpGvl45vWpfQY3Z6VPn8XdP/wZ/oGB/PORb3Jwy8bBXEa3jtYW9m9YR/YVCwmNisZutzF7SRonjzZQUVQ3pHO708TcBWAMJTs12VgpNbxoC47iRMmhc0b4TZs6nZseepgTJYeYd+sdTFm0mJry4+SvW8OBd9Zx6L1NRI1NZNripUxZtNjj3+wrDx1k5a8eo7mujuvuvZ9Zy28ZdAuHo9NJl8OQ+8F0CjZWMG5qXHdOTl9iU1K550e/YMXPfsTrv/opdVUVLPjQXYOqy4GNb9PR2sLMHvNOTboykR2rSsl745jHbk0fqLi0dCLHjKUkbxvTFy/zdXWUUqrfNAdHDYijo4PD2zaTv34N5QcKsNntZOTOZ/riZYybNtOt0wwYp5O811/h3b//mbCYOG5+6BskTMwa9PnKi+pY81QBS++fSkp29AXr/eXo7OTNP/6awk1vM/nq61jyuS/i5997/k5vjDE8+5UH8A8M5GM//uU5AdLutcfZ8nIxH/76HBIm+K47sKe3//wUe9eu4oGnnycg6PIfG0kpNepoDo4aOr+AACZffR2Tr76Omooy9q1/k/3vrOPwti1EjhnLtA8sZcq11xMWPbQWiNbGBlb//pcc2bWDzHlXsuTzXyQoNGxI5zxV2nBOMJOSHc3S+6dyqrRhQAGOn78/y7/wZaITk9jyz7/RcPokt3zl2/3OTyrbn09tRRnLHvjSBa0/U65OYufqUna+UcqNX5jR/4vzoIm589m1agWle3eRNf8qX1dHKaX6RVtw1JA5Ojsp3r6F/HVrKNufj9hsZMyZz/TrlzFu+swBz2VUUVTIyl89RuuZehZ94tPMXHrTZZN0e76DWzay+ve/JCwmltu/8b1+jRez4mc/ovzgfj73+2fxC7hwJvQdrx9l+2tHufM7c4lLCfdEtQfE2dXFHz77cSbMymX5g1/xdXWUUup83p+qQUSWiUiRiBSLyMO9vB4oIv+wXt8mIunW9nQRaRWRPdbjfz1ZTzU0fv7+TLpqER/97o/5jyf+SO5Nt1NRdIB//eR7/OmL9/Pey3+nsba6z/MYp5PtK17iH9//BnY/P+7+4c+Ytezmyza4AZh05TV89Ls/obOtjb9/56scy99zyf0bqk+58lk+sKTX4AZg2rUp+AfZ2fnGMQ/UeOBsdjsTZs/lyK4dOLu6fF0dpZTqF48FOCJiB34HLAdygLtF5PxZ+z4N1BljJgK/BB7r8VqJMWam9fi8p+qp3Cs6MZlrPvYpPveHZ7npoYeJSnB14zz1wH/wyuM/dH1IOrvYvuIljhfkdx/X0nCG57/zVTY9/yyZ867kE4/+irETJvrwSvovKWsS9/y/nxMWE8vLP/ku+W+tvui+e9e6pn6YccMHL7pPUKg/0xalULzrFHUnmt1e38GYmLuAtuYmygv3+7oqSinVL57MwZkHFBtjjgCIyAvArcCBHvvcCnzfWn4J+K1czl/XVb/Z/fzJvmIh2VcspP5EFfvefpOCt9dSkreN8Nh4UqdMZ8erL3Hzl76FzW5jxc9+RFtTI7OW38p1937msm616U3kmLHc/cOfsfJXj7H2qd9SW1nONR//1Dndc46ODvatW0NG7rw+BwucsTiV/PVl7FpzjMX3+n4273EzZmH396ckb2v33XZKKXU582QXVTJQ1mO93NrW6z7GGAdwBjg7Vv54EdktIu+IyNW9FSAinxWRPBHJO336tHtrr9wmKiGRq+++l8/+/llu+fK3iE1J5cCm9bQ1NfPyj/+Hf3z/Ydqbm7n+/gf5wH33D7vg5qzAkBBu//p3mbn0Jna+/gqv/vzHdLS1dr9e9N4mWhsbzrk1/GJCIgLIWZjEoW0naahp7XN/TwsICmbctJkU521jpOTtKaVGtst1oL8qIM0YMwv4MvC8iEScv5Mx5kljTK4xJjc+Pt7rlVQD45r+4Uo+/K1H+Myvn2bBhz6Kv3Xbce7NtzPj+uE/zorNbmfxf3ye6+77HEd27uCZhz5H0ZZN3RODxiSlgEi/ZmqftSQNBHa/edwLNe9bRu58Gk6fpPp4qa+ropRSffJkgFMB9LylJMXa1us+IuIHRAI1xph2Y0wNgDFmJ1ACDH4AFHXZiRwzltQpM7DZbCz48F0UvL32nJyc4W728pu57Rv/Q3tzEyt//VPe/vPTnDxymHEzZvH6E4+RkNH32zksOohJVyRSuLmK5jPtXqj1pWXMmQ8iFO/Y6uuqKKVUnzwZ4OwAMkVkvIgEAHcBr563z6vAvdbyHcB6Y4wRkXgrSRkRmQBkAkc8WFflZedPD3HTQw+z8olHR1SQM2HWXO750S8IDo9g9xsrsPn5UfjuhnNGje7L7KVpOLuc7HmrrO+dPSw0KprEzGyK8zTAUUpd/jwW4Fg5NQ8Ca4BC4J/GmP0i8oiI3GLt9icgVkSKcXVFnb2V/BogX0T24Eo+/rwxptZTdVXed6npIUaS+LR07n38t0SNTcTpcDBzyY0DStKNjA8hc+5YCjZW0NbU6cGa9s/E3AWcOlpCQ7XmvCmlLm8ezcExxqwyxmQZYzKMMT+ytn3XGPOqtdxmjPmIMWaiMWbe2TuujDEvG2OmWLeIzzbGvObJeirvm3frHRd80KdNnc68W+/wUY08p6a8jPaWZhZ8+C72vrlqwK1Us5eNw9Hexd63fd+Kk5E7H0An31RKXfYu1yRjpUYEd3TFxSaFMWFmPPveLqej1eHB2vajLsmpRCelaB6OUuqypwGOUh7krq64OcvH0d7ioGDj+Xn63jcxdz7lB/bR1tzk66oopdRFaYCjlAe5qytuzLgI0nJi2PPWcRwdvp0uISN3Ac6uLo7u2enTeiil1KVogKPUMDFneTqtjZ0c2Fzp03okZmYREhlFiXZTKaUuYxrgKDVMJGVGkTgxkt1vHqfL4fRZPWw2Oxlz5nF0Tx6OTt/f2aWUUr3RAEepYSR3eTpNde0UbTvh03pk5C6go7WV8v0jZ9wipdTIogGOUsNIak4M8Wnh7Fp9DGeX71px0qbNwC8wkOI8390uvmvNMcqL6s7ZVl5Ux641x3xUo5FDf7ZqJNAAR6lhRETIXZ7OmdOtFO865bN6+AcEkj59NiU7fTf55pj0CNY8VdD9QVxeVMeapwoYk37BtHVqgPRnq0YCP19XQCk1MONnxBGTFMrON46ROWcsYvPN7OsT5y6geMd7nDxSTEJGptfLT8mOZun9U1n95D6y5o7lcN4plt4/lZTsaK/XZaTp/tn+cR8Zs8ZwZO9p/dmqYUdbcJQaZsQmzF46jtrKZo7mV/usHhNmz0XE5rNB/+pONHPwvSramx3s21CBX4CN5vp2HJ2+vY1+uOvs6OLge1VsW3GE9hYHBzZXEhoZQFxKmK+rptSAiK+al90tNzfX5OXl+boaSnmFs8vJ3763laBQf+54OBcR37Ti/OMHD9PW2Mi9P/ud18qsLm9i5xulFO86hc0miE1ImBBB5aF6jIHAUD+y5yeQszCJ2CT9UO6v6vJG9m+q5ND2k3S0OgiNDqS9uZP41HCqSs4QGOrH4ntzGD89ztdVVep8vf4HqF1USg1DNruN2UvHseFvRZQV1pKWE+uTekzMXcCG556m/uQJosYmeLSsk0cbyHujlNL8avyD7GTmjuX4gRqWfXYaKdnRlBfW8saT+4hNDqPgnQry15eTmBFJzsIkMuaMwT/A7tH6DUcdbQ4O7zjJgXcrOXWsEbufjYzZ8cSnhbNz9TFu/MIMUrKjKdhYzsYXDrHq9/lkzRvL1R/NIijM39fVV+qStAVHqWGqq9PJX/7nPSLjg7n9K7N9Uof6kyf40xc/w7Wf/AxzbrzNI2VUHq4n741Syg7UEhjix4zFqUy7NoUD71YyJj3inLyQ8qI6TpU2MPnKRA5uPcGBdyupP9lCQPD7rTqjvavFGMOpY40ceLeSwztO0tneRUxSKDlXJZG9IIGgUH92rTl2wc/2+IEadr95nMpD9QSG+bPo7iwyZo3x4ZWoy9n2FS+RkJF1zkjuxwvyOVFyyBOTKvfagqMBjlLD2N51Zbz74mFu/+pskiZG+aQOf/7agwSFhnHn9x912zmNMZQX1pH3RimVh+sJDvdn5vVpTF2UTEBQ/xuejTFUHq7nwLuVlOw6TZfDydjxEeQsTCIzdyz+gaOnVae91cGhbSc4sLmS6rIm/PxtTMwdQ87CZBImRPS7m/N0WSPrnyukuqyJibljuObOLILDAzxc+5Gjt+DxbGA+e+k4H9bMvXpONJw2dfoF626mAY5SI01nRxd/+fYW4tPCufm/ZvqkDpv/8Re2/ftFPv/kXwiJiBzSuYwxlOZXk/fGMU6VNhAaFcisJWnkLEwachdTW1MnRdtOsP/dSuqqmvEPspM1L4EpC5OITwsf0rkvV8YYThxp4MC7FRTnncLR6SQuNYycq5LImp9AYPDgshS6upzsXnOMHa+XEhjix9V3ZjFxzhif5YINJ2dvuT97V9r56yPJ8YJ8Xvvlj0nKzqHq0EFPBTegAY5SI9PO1aVsfeUIH/lmLmPGeX+ckhMlh/nbt77Esge+xJRFiwd1DqfTcGT3afJWlVJT0UREXBCzl45j0oJE7P7uvdnTGMOJkjPsf7eS4p2n6Op0Ep8WzpSrk8icO3ZALUSXq7bmToq2ulpraiub8Q+0kzl3LFOudgVz7gpEaiqaWP9cIaeONTJhVjyL7s4mJEJbc/pyrKCaN/90gJRJ0VQeqmOplUc2EhhjOHW0hJKd2yjJ286p0hIAZtzwQa7/zAOeKlYDHKVGovZWB899awspk6JZ/rlpXi/fGMOTD9xHQkYWt3712wM61tnl5PCOk+xcfYy6Ey1EjQ0hd/k4MueOxWb3/CgWbc2dHNp+kgPvVlBT0YxfoJ2s3DHkXJ3MmHHuCwS8obfuuDHjwplydTITc8cMKHAbSP6Es8vJnrfK2P7aUfwCbVxzZxaZc8cOq5+dpzWfaedEyRmqrEf18Uaczvc/exMmRDJ+Rhzp0+KITgwZdj87R2cnZfvzKcnbRsnObTTV1iBiIzYllTOnTpCzaDGH3ntXW3AGSwMcNZpte/UIeatKufu784lJCvV6+W/96Q/sf+ctHnj6efwDAvvcv6vTycGtVexac4yG6jZik8PI/WA6E2bFY+vnwIXuTGI0xnCytIEDmyo5nHcSR0fvXTleTpzsV5mtjR0cfM/VWlN/soWAIDtZVkJ1fOrgut4Gkz9RW9XM+ucKOXm0gfTpcVz7sWxCI/t+L/T3OocL4zTUnmh+P6Aprqehug0Au5+NMenhhEUFcaygmgmzxlC88yQhkQE0nHbtExEXxPjp8aRPjyUxMwq7FwL9wWhpOMPR3XmU7NxG6d7ddLa14h8YRPqM2WTkzicgOJi1T/5Wc3DcQQMcNZq1NnXw3Le2MGFWPDd8aorXyy/du4uXf/xdbvv6/5AxZ/5F9+vs6OLAu5XsfvM4zfXtjBkXTu6N40mfFjvgb62eSmLsaHVwaMdJ9m+qcCXjBtiYmDuWKQuT2L9xG4Xv/B+3fOWb3WW++vOfMHnRf7D4vhsGXealrHt2LYXvPHNBmanT7yEwdDxH957G2WVImBDJlKvfvyXeOJ10tLXR0dZCR2srHa3Wc1srHS0truce2zut9fbWFjpbW2mur6Oh5jT+AYE4OjqIiI8nJCqagKBg/AMD8Q8Mcj2CrEdgEH4BgZw40sKRPfXY/QOYft14MmYnd78eEBSMf1Agdr8LbzH3clKq23R2dHGqtIGqkjOcKDnDiSNnaG9xABAc7k/ChEgSM6JInBhJfJprTKHecnCuuSuL9hYHR/dWU1FUR5fDSUCwH+OmxJA+PY60KbEEhfr21vzaygqr62kblUWFGOMkLDqGjNz5ZMyZT+qU6fgFuLoo9S4qN9IAR4127750mPz15XzsBwuIjA/2atldjk5+/5mPkbVgIUs//8ULXu9oc1DwTgV73jpOa2MnSZlR5C5PJ2Vy9KCa4ztaW2iqq+Xorh1sefF5kidPobywgCmLridqbALOri6cTifGejidXdaztd7VY/2cfV3LZ7e3NXdwprqZ5ro2jNOJ3V9wdDSDqSU0OprmujrEHkd8WjzB4YHYbDbEZsNmsyPdy7b3l+32c9dtNsRm737uub/N7lpvqG7jwKZCnJ0HSJg4mYqi/YhtPGILxmbrJDTKRlCowTg7XMGKFah0trX262cpNhsBwcEEBIcQEBT8/nJwMPVVVZw+fpTYlDSiEpLobG+js62VzvZ2a9l6dLTDAD5LbHb7+8FRd6AUiKPTQfWxI8Qkp1JXVUHONYtJyppEcEQEIeGRBEdEEhIRiX9Q0IDfM+5yqe6m6IQQEjMiSciIIjEjksgxwRe8v/tzF1VHm4PywjqO7qvm2L5qWhs7EZuQNDGS9OlxpE+PI2pMiMev1ensovLQQavraTt1leUAxKdPIGPOfCbmzmfM+IzLoUtNAxylRrLm+nae+84WJl2RyHUfm+TVsreveInSPTupqSjjc//7Z2w2O8cL8ik/eBD/4LnsXVdGe4uD1JwYcpePIynzwoRKYwwdra001dXQXFdHc10NTfXWc10dzXW1NNfX0lRbS2d724Dr2B08nBNkuJa7Aw1779sRob2li7YmBx3tTkxXI5gGkHACgqMQMdako06McYJxdq9jjGsb1jbjxOB67t5m7Qf9/P9Y7PgHBhMcHkJgcAj+VkDSW5ASEBRMQMjFt/v5B/T6AXW2BWXGkg+y981Vl2xJMcbg6Gh3BT5trXS2tdHR1kbRtjIObDqGiIOM2dHEpQS5AqOzjzZr//a27qDpzMkTtDY2ICIXncjVLyDQFfRERBESEUFwxPvBj2t7JMHhrvWQyEj8gy4MNAD+/fjTpE2dzJzlV3Vv2/nGZo4XFHL71z7j6m6qau5unakq6dHd5G9jzLhwV+tMRiQJEyI9Mvih02k4VdrA0fxqSvOrqa1sBlzB1NlgJ2FCZL+7dvvS0dbKsb27Kdm5jSO7dtDa2IDN7kfqlGmulprZ84iI73v8Iy/fDq8BjlIj3YbniyjcUsknfnglYdH9z38YqnXPrqVg3R9xdLRx1w9+SmtjKyt/9VP8Qj4IkkLalDAmzY8gMKSd5vo6mmprXM91te8HLnW1ONrbLzi3X2AgYdExhEbFEBodYy1HExYTS3N9Hdv+/U+mLFrMgY3rWfr5L5KSM6279cPWozXFXfa9vZW3nvoF4j8NZ0c+idl3EhyZwdnPTxHXPwKc/ce17eyq0OPJ9cFrveYKfAxIz6DHSVPtEcoKXsLml4OYg9z+jW97tNvGnd1FZ063sP65g1Qeric1J4brPj6J8JjeW2DOD6qW/udDxCan0tJwhtbGM67nhgbr2fVoaXh/u6PjwvcPgN3f3xUAhfcIgCIiqauq5+ieLUy57mamLprP4e2F7Fr1AumzPopf0AROlTbT0eqa2yw43J/EjCgSMiJJzHB1N9n9Bv6+GmrXTUN1a3ewU3moHqfTEBTqz7hpsaRPiyNtSswFCeV9ldlYW82RndspydvG8YK9dDkcBIWGMX72XDLmzCd9xmwCQwbWYuTl2+E1wFFqpGuobuWv393K9GtTWPhR783wXV5Ux8pfvUJzzcv4B0XS2dYEtmj8/Lswzma6OjsuOMY/MIiwmJ6BSzSh0bGERbmeQ6OjCYuOJSC492/fvsjZOJv/4hd6I7OWXMnuN7fgaH69Oz9mpJTp7vwJ4zQUbKxgy79LEODKD09kysIkpEergzt+n51tbd3BT0vj+8FQy5l6WhsaegRJZ2hpaOi7G09s+AcEERASQlDoha1k/mdbxXq2jgUF43/OtmACglzH2ux2t75v21sdHN9fQ2l+NccKamhvcWCzC8nZ0aRPiyN9eiwRscEX5HEdK9jLisd/REzKNHDWcPJIMQBRYxPJyJ1Hxpz5JE+ags1+6bGnjDE4Op20N3fS1uxwPbd00t7soK25k+qyRo7sqSYiLojWxg5P3g6vAY5So8G6Zw9QvPMUn/zxlW4dYba91UFjTSuNNW001LTRWNtGU4/ltqZO2s48B85qkCBiktIYk57oam2J7tH6Yj0HBA8th8AXd92sffovlOwRbvqvG7u/la78zetkzDTc8JlPjJgyPaWhupW3/3qQ8oN1JGdH8YFPTCYizpUv5snfZ3urg+qyRqrLmjhtPddVNdPV1QGmDUfbVrra9xESlUPO1VcSHCGYrvZz8pm6E7R7JGt3Ws/Orv7NYO/nH4B/cDA2u42WM2cIjYqm5Uw9MSmpBIdFuLpHRc7J0xIR69l2yddBaG1y0FjdRkNNh5XoLASHBxISEUBt5UlMVzFxKWmcLC2xWgqFxMxsMmbPI21qLsGRCXS0OlwBSktnd+DSc7m95f1gpr3FQZfDedHrtdkFm11wdDiZfl0KV9+ZNaTf4yVogKPUaLD5pcPseauMOcvGseC2DKDvvm9jDO3NDhpr22iwgphGK3BpsJY7Wh3nHOPnbyM8Nsj1iAnC0XGcgnVPg30aYgq4/eue7UbxBV8Msz/ShvY3xnDg3Uo2v1yMMXDFbRlMW5R8TmvOUM7dcqbDCmLeD2jO5s0ABEcEEJ8aRlxqOPGp4Zw4sp/t//o9KTnXUH5gI4s++dA5OTn9KbOrs/Pcu9J6BD+uba3dd7OdDZZOlBymrqqCiPgxRMSPsZLcjevZWInuxnQnypue6z1ex3nevuZsIr31cDqtfK/3P+vFFk3E2KvwD8nA0R5Ee0vnJXPE/QLtBIX4ERjqT1CoH4Eh/j3W/QkM8XM993w91J+TR8+w5un9TL0mmYKNFZ4crVkDHKVGg/KiOl77zR5sItz32FWcLmtizVMFXHtPNqHRgd2ByznPNW10tp/7LdQ/yE6EFbyExwZbz+8HNMHh/t1dR77oRlHDW2NtGxv+epDjB2pJyoziuk9MGtCdQcZpOHO69YJgprWxs3ufyPhg4noEM3GpYeeMzbPzjc2889wT3UHN+eueMpAEbndoa+pk5xub2fbv32Pzm4azM5+kyXcTnZRFUIg/gaFWgBJiBSih/u9vD/Ef1GjimoPjRhrgKPW+/Zsq2PC3IoLD/Wlrct1i6uw69289MMSvO1iJiA0+J3gJjw0iMMSv37d/jqRuFOU9xhgOvlfFuy8W42jvYvLCRK65K7v7jqCzLVUzPpBKbVWzK5g53kh1eRPV5U3dQbnNLsQkhRKX0iOYSQkjoI+5tvq6i8oTRkvu2Ii/i0pElgG/AuzA08aYR897PRB4DpgD1AB3GmNKrde+CXwa6AK+aIxZc6myNMBR6lwv/mQHp441Ep0QwrhpcVYg834Q09d//gMx0rpRlHc11bWz+sl9nDzaQHRiKFfensGx/TUUbq4kNCqQptr27rFm/APtrlaZFFeLTHxqODGJoW6fs8xTRkvumJd5N8ARETtwCLgBKAd2AHcbYw702OcBYLox5vMichdwuzHmThHJAf4OzAOSgLeALGPMRTO5NMBR6n1nm4O90PetlFsYY9i64gi7Vh/r3hYQ4kfC+IhzgpnI+GC35OuMJqPgC0ivbwhPTps7Dyg2xhwBEJEXgFuBAz32uRX4vrX8EvBbcbWJ3wq8YIxpB46KSLF1vvc8WF+lRoTz+7qTs6M92fetlFuICFfclkFXp5O968qYsTiFhR/x2F03o0pvQUxKdvSI///Ak216yUBZj/Vya1uv+xhjHMAZILafxyIinxWRPBHJO336tBurrtTwdaq04ZxgJiU7mqX3T+VUaYOPa6bUpZUX1VG07QS5H0ynaNtJyovqfF0lNYx5sgXH44wxTwJPgquLysfVUeqyMFq/ranhTVselbt5sgWnAkjtsZ5ibet1HxHxAyJxJRv351illFIjhLY8KnfzZICzA8gUkfEiEgDcBbx63j6vAvday3cA640r6/lV4C4RCRSR8UAmsN2DdVVKKeVDs5eOu6ClJiU7eqQkwSof8FgXlTHGISIPAmtw3Sb+jDFmv4g8AuQZY14F/gT8xUoirsUVBGHt909cCckO4AuXuoNKKaWUUqonHehPKaWUUsNZr7eJD4+RkZRSSimlBkADHKWUUkqNOBrgKKWUUmrEGTE5OCJyGjjW546DFwdUe/D8WqaWqWVqmVqmlqllDly1MWbZ+RtHTIDjaSKSZ4zJ1TK1TC1Ty9QytUwt8/IuE7SLSimllFIjkAY4SimllBpxNMDpvye1TC1Ty9QytUwtU8scFmVqDo5SSimlRh5twVFKKaXUiKMBjlJKKaVGHA1w+klEVotIvYis9FJ5M0XkPRHZLyL5InKnm88/TkR2icgeq4zPX2S/GBFZKyKHrefo3vZzc5kfsV53isiQbi0cQJmPi8hB62f9bxGJ8kKZP7TK2yMib4pI0mDL7KM+ESJSLiK/9cC5u6z67xGRVy+yT6CI/ENEikVkm4ike6HMa6zfgUNE7hhKeQMo88sicsD6na4TkSFPg93Pcj8vIvusfd4VkRxPl9lj3w+LiHHD32l/rvM+ETndY7/PeLpMa7+PWr/X/SLyvKfLFJFf9tjnkIjUe6HMNBF5W0R2W+/fD3qhzHHW30m+iGwQkZShlNkrY4w++vEAFgM3Ayu9VF4WkGktJwFVQJQbzx8ABFrLYUApkNTLfj8FHraWHwYe80KZk4FsYAOQ66XrXAL4WcuPeek6I3osfxH4Xw+9l34FPA/81gPnburHPg+cvTbgLuAfXigzHZgOPAfc4aXrvA4IsZb/c6jXOYBye76PbgFWe7pMa79wYCOw1Q1/p/25zvvc+R7uZ5mZwG4g2lof442fbY/9/wt4xgvX+STwn9ZyDlDqhTJfBO61lj8A/MVdv9uzDz/UOUTkEaDWGPOEtf4j4JQx5lcicq23ywQwxlSKyCkgHqh39/mBQC7emncrcK21/GdcQcc3PFmmMabQOqavYtxZ5ps9VrcC/frWP8QyG3qshgKDzvi/WD2Ad4GxwGpg0N+yL3H+/rgV+L61/BLwWxERY/3P5okyjTGl1jHOftbRHWW+3WN1K/BxL5U7qPfREH+nAD/E9WXga/09wA1lDtgQy7wf+J0xpg7AGNOv49x4nXcD3/NCmQaIsJYjgUovlJkDfNlafht4pZ/H9Z+7I6bh/sD1zW+XtWwDSoBYa/1aPNCCc6kyrW3zgELA5s7zA6lAPtACfKHH/k9jfSMD6ntsl57rniqzx7YN52/zdJnW9teAj3ujTOBHQBlQAMS7+z1k/QxTGOK330uc3wHk4fpAv63H/o8At1jLBUBKj9dKgDhPltlj27MMoAXHHWVa238LfMdb5QJfsI4pw2r59fDvdDbw8kD/TodY5n24WrLzcQXKqV4o8xVcrdibrf2Weet9BIyzrtfuhetMBPYB5UAdMMcLZT4P/Le1/CFcQVZsf8rt99+VO082Uh7AWmAWsAx4qcf2a/FQF9UlykwEioAFnji/9VoSsB0Y28tx9eet13m6zB77bGCATd9uKPPbwL+xhlDwRpnWft8EfuDO3zHwIPB167X7GGLzfm/XCSRbzxNwdcVl9HLcoAKcoZTZ4/hnGWAXlRvK/Diu/9gDvVmutd89wJ89WSauD7INQLq1PqC/0yG8j2J5v+v3c8B6L5S5Etf/B/7AeFwBZJSX3kffAH7jjfcQrpaUr1jLVwAH6OcX6iGUmQT8C1cX4K9wBVf9+tn296FdVL17GtcHQgLwjK/KFJEI4HXg28aYre4+/1nG1QVWAFyN64Oxp5MikmiMqRKRRAbWzDrYModi0GWKyH3ATcBiY/0FerrMHv4GrKKfzdH9rMfHgKtF5AFcuUABItJkjHnYTefHGFNhPR8RkQ24/qMrOe+4ClwtWuUi4oerCbzGw2UOxaDLFJHrcQXJi4wx7d4qt4cXgD94uMxwYCqwwepGTgBeFZFbjDF5HioTY0zNeef4ab+vcvA/23JgmzGmEzgqIodw5eXs8GCZZ92Fq2VuIAZb5qdxBSgYY94TkSBcE2T25//7wf4+K3G13CAiYcCHjTH1/b/UfnBntDRSHriSRIuAI/RoHsSzLTjnlGmtrwMe8tD5U4Bg67Vo4BAwrZfjHufcJOOferrMHsdvYOAtOIO9zmW4vrUMuJtoCGVm9lj+L85r/XHX+9Z67T6G3oJz/nVG8/436jjgMJDTy3Ff4Nwk4396uswexz/LwFtwBnudZ/8T71cXkRvL7fk+uhnI89bP19pvQH+nQ7jOxB7LtwNbvVDmMqwWMWu/MvrZjTKUny0wCVfLR79bkod4nW8A91nLk3Hl4PSr7CGUGYfVSoSrq/6RwfzdXOqhLTi9MMZ0iMjbuLpnugBEZBOuN12YiJQDnzbGrPFUmSJyN3ANEGu1LIDrDbjHTeefDPxcRAyu3JqfGWP2AYjI07g+kPKAR4F/isingWPARz1dpojcDvwGV1L16yKyxxiz1MPX+VtcCcFrrW+lW40xvd7e7cYyHxWRbMCJ62fbr/L6W4+hnKs/57eu849WIq8NeNQYcwC6kw/zjDGvAn8C/iIixUAtriDHo2WKyFxcXQvRwM0i8gNjzBQPX+fjuFrKXrTeQ8eNMbd4+lqBB62Wo05c+RP3eqHMQRtCmV8UkVtw5XfU4graPV3mGmCJiBwAuoCvmXNbkjxRJrj+Rl4w1qe/F67zK8BTIvIlXLkw9/W37CGUeS3wE+v/yY0MvLWqX5XTx4WRpQ3YwyC/iV2OZY7EaxrNZfqiHqPlZ+ur3+douVYtU8v01uNitwaPWuIaJKsYWGeMOTwSyhyJ1zSay/RFPUbLz9ZXv8/Rcq1appbpTTrZplJKKaVGHG3BUUoppdSIowGOUkoppUYcDXCUUkopNeJogKOUGjJxzSj91x7rfuKa+XnlAM9TKiJxQ92nn2XdJkOYeVtEoqxBFJVSlyENcJRS7tAMTBWRYGv9BlwjGF/ObsM14d9gReGaKV0pdRnSAEcp5S6rgBut5buBv599QURiROQVEckXka0iMt3aHisib4rIfmsQROlxzMdFZLuI7BGRP4qI/VKFi8jdIrJPRApE5LEe25t6LN8hIs+KyJXALcDj1vkzRGSDiPzKWi8QkXnWMd8Xka/2OEeBiKTjGgQzw9r/8UH/1JRSHqEBjlLKXV4A7hLXPDbTgW09XvsBsNsYMx34FvCctf17wLvGNcrwv4E0AGs01DuBq4wxM3GNIvuxixUsIknAY8AHgJnAXBG57WL7G2O2AK/iGpl2pjHm7Dw5IVZ5D9D3PHQPAyXW8V/rY1+llJfpVA1KKbcwxuRbLRt342rN6Wkh8GFrv/VWy00ErulIPmRtf11E6qz9FwNzgB3WtAfBXHriv7nABmPMaQAR+Zt17lcGeBl/t+qyUUQiRCRqgMcrpS4TGuAopdzpVeBnuOaZiR3CeQTXJIffdEOdeo5mGjSAfc+uOzi3tbuvcyilLgPaRaWUcqdngB8Ya3LRHjZhdTGJyLVAtTGmAdcke/dY25fjmhwTYB1wh4iMsV6LEZFxlyh3O7BIROKsXJ27gXes106KyGQRseGahfqsRiD8vPPcaZW3EDhjjDmDa1bn2db22cD4SxyvlLpMaICjlHIbY0y5MebXvbz0fWCOiOTjSs49O+P1D4BrRGQ/rq6q49Z5DgDfAd60jlkLJF6i3CpcOTFvA3uBncaYFdbLDwMrgS1AVY/DXgC+JiK7RSTD2tYmIruB/wU+bW17GYix6vggcMgqswbYbCUda5KxUpcZnYtKKaUAEdkAfNUYk+fruiilhk5bcJRSSik14mgLjlJKKaVGHG3BUUoppdSIowGOUkoppUYcDXCUUkopNeJogKOUUkqpEUcDHKWUUkqNOP8fZNtHSIDKUmIAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# plot weights\n", "\n", "fig, axes = plt.subplots(nrows=2, ncols=1, figsize=(8, 8))\n", "\n", "# scale weights\n", "\n", "scale_distance_ids = [\n", " distance_id\n", " for distance_id in distances.keys()\n", " if \"Ada.\" in distance_id and \"Stat\" not in distance_id\n", "]\n", "scale_log_files = []\n", "for i_dist, distance_id in enumerate(scale_distance_ids):\n", " scale_log_files.append(f\"{scale_log_file}_{distance_id}.json\")\n", "\n", "pyabc.visualization.plot_distance_weights(\n", " scale_log_files,\n", " labels=scale_distance_ids,\n", " colors=[colors[distance_id] for distance_id in scale_distance_ids],\n", " xlabel=\"Model output\",\n", " title=\"Scale weights\",\n", " ax=axes[0],\n", " keys=dict2arrlabels(data, keys=data.keys()),\n", ")\n", "\n", "# info weights\n", "\n", "info_distance_ids = [\n", " distance_id for distance_id in distances.keys() if \"Sensi\" in distance_id\n", "]\n", "info_log_files = []\n", "for i_dist, distance_id in enumerate(info_distance_ids):\n", " info_log_files.append(f\"{info_log_file}_{distance_id}.json\")\n", "\n", "pyabc.visualization.plot_distance_weights(\n", " info_log_files,\n", " labels=info_distance_ids,\n", " colors=[colors[distance_id] for distance_id in info_distance_ids],\n", " xlabel=\"Model output\",\n", " title=\"Sensitivity weights\",\n", " ax=axes[1],\n", " keys=dict2arrlabels(data, keys=data.keys()),\n", ")\n", "\n", "fig.tight_layout()" ] }, { "cell_type": "code", "execution_count": 14, "id": "b9baff36-7d84-4edd-acdc-a4e14324a7e8", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "ABC.Predictor INFO: Fitted in 0.02s\n", "ABC.Predictor INFO: Pearson correlations: 0.999 0.953 0.850 0.124 0.081 0.077 0.082 0.925 0.867 0.827 0.683 0.121 0.079 0.086 0.094 0.875\n", "ABC.Predictor DEBUG: Linear regression coefficients (n_target, n_feature):\n", "[[ 9.99467799e-01 -6.08456786e-05 -5.96816711e-05 -9.77668494e-05\n", " 2.39617680e-04 -8.92999377e-05 4.22410927e-05 1.69655282e-04\n", " -4.44860924e-05 1.86195873e-04 5.05596525e-04 3.79109863e-04\n", " 1.75463461e-04 -7.70261189e-05 4.95800243e-04 -1.72393054e-04\n", " -2.52460553e-04]\n", " [-3.94005909e-03 9.52625808e-01 -1.51758187e-03 -1.29099679e-03\n", " 2.78521627e-03 -7.00666584e-03 1.34386758e-04 -1.61199310e-03\n", " 2.52300175e-03 5.72280693e-03 -3.80291728e-03 6.88461560e-04\n", " -2.19637490e-03 -2.95666180e-05 3.04181510e-03 6.69539045e-03\n", " 3.15937444e-05]\n", " [ 1.50406124e-02 -1.19775493e-02 2.94759912e-01 2.89398576e-01\n", " 2.83188362e-01 2.84292226e-01 -1.79451966e-03 3.10644248e-03\n", " -7.93030482e-03 -5.34238685e-03 3.36709745e-03 -5.27885998e-04\n", " 1.33833095e-03 -4.90404382e-03 4.91586834e-03 2.48544435e-03\n", " 6.65773906e-03]\n", " [-4.29727247e-02 6.78809588e-02 -3.75164640e-02 -2.73419876e-02\n", " -2.94059185e-02 -2.33241195e-02 6.92171987e-03 5.98383634e-03\n", " -7.92166171e-03 -7.71487811e-03 -4.53864121e-03 -1.02870134e-02\n", " 2.72949986e-03 -1.61452844e-03 -1.35030681e-03 -5.27953011e-03\n", " 8.75565996e-03]\n", " [-5.46831600e-02 -3.89667658e-02 4.51058656e-03 1.49600678e-03\n", " 3.59513775e-02 4.19507023e-04 2.17130079e-02 7.94630106e-03\n", " -2.38982129e-03 6.63414175e-03 7.16806574e-03 -1.08874688e-02\n", " -4.08254398e-03 -5.91218983e-03 -9.18105497e-04 2.66562589e-03\n", " -1.11885793e-02]\n", " [-4.33170926e-02 -5.84786903e-02 1.48555950e-02 -6.83098761e-03\n", " -1.52933134e-02 1.51730784e-03 -3.75059409e-03 8.90618583e-05\n", " -1.00873073e-02 -4.43976636e-03 -6.69733662e-03 2.65948070e-03\n", " 3.08437689e-03 -9.78588767e-03 -5.56294130e-03 2.38408934e-03\n", " -1.15231963e-02]\n", " [-6.87404238e-02 2.61986061e-02 -1.28884618e-02 -4.03627600e-03\n", " -1.42847406e-02 1.63582062e-03 6.37321997e-03 4.91841683e-03\n", " 5.33362087e-03 -6.48723330e-03 5.54300308e-03 -3.21128457e-03\n", " 9.90302942e-03 2.87963380e-04 -1.66737282e-03 -1.72875830e-03\n", " -6.80467921e-03]\n", " [ 1.42623400e-03 -2.56332770e-03 3.46320867e-03 -6.06217730e-03\n", " -9.62905690e-04 2.54571955e-03 9.24946371e-01 -3.42009163e-03\n", " 3.31886338e-04 1.49397518e-03 2.69706465e-03 -2.81370032e-03\n", " -2.28303040e-03 -3.92370621e-03 4.12718816e-03 3.91637455e-03\n", " -6.37193916e-04]\n", " [ 8.67776728e-01 1.76252848e-02 -1.59609770e-02 -1.10021771e-03\n", " -7.97046781e-03 -2.19411708e-03 1.67970973e-02 8.36228086e-03\n", " -3.09691241e-04 -3.52425528e-03 -1.67665097e-03 5.33739631e-03\n", " -3.20494515e-03 2.49444727e-03 6.48756694e-03 9.21098220e-04\n", " 2.02104810e-03]\n", " [ 1.09887225e-02 8.26910701e-01 3.43621313e-03 -1.17949386e-03\n", " -1.13712786e-03 5.32917668e-04 1.57859662e-02 4.16087998e-04\n", " 3.24019382e-03 8.08376849e-03 -8.69719681e-04 -2.08583364e-03\n", " 2.57782439e-03 -5.88183165e-03 1.34058318e-03 9.40357644e-04\n", " 1.49951536e-03]\n", " [ 9.26484417e-03 -2.28874913e-02 2.31666085e-01 2.36306181e-01\n", " 2.31689570e-01 2.23534208e-01 -2.67149060e-02 4.46423506e-03\n", " -1.52495534e-03 -6.65712901e-03 7.22358909e-04 -1.07947284e-03\n", " 6.94144197e-04 -7.03428292e-03 -3.75406598e-03 -2.87239767e-03\n", " 3.08042348e-03]\n", " [-5.30008965e-02 6.90398917e-02 -3.46661020e-02 -1.86209478e-02\n", " -2.68786349e-02 -2.19446837e-02 3.65099894e-03 5.90193471e-03\n", " -5.48885782e-03 -3.09419571e-03 -3.62972114e-03 -7.84707926e-03\n", " 1.03394692e-03 -1.00174257e-03 -2.03988489e-03 -5.74044890e-04\n", " 1.06075451e-02]\n", " [-5.15345592e-02 -4.19702203e-02 1.21489375e-03 4.20093667e-03\n", " 3.64183975e-02 -2.70566105e-03 1.76865186e-02 -4.32720328e-04\n", " 1.83833456e-03 6.71729366e-03 3.78006425e-03 -1.29479534e-02\n", " -6.70705751e-03 -4.27785521e-03 -7.21097946e-03 4.21828780e-03\n", " -1.14203158e-02]\n", " [-4.48414873e-02 -6.87463587e-02 1.35411494e-02 -6.93410175e-03\n", " -1.49342063e-02 -1.33310349e-03 -5.32773253e-03 2.47821474e-03\n", " -9.93593523e-03 -2.46717612e-04 -9.68411133e-03 4.67410859e-03\n", " 2.55456077e-03 -9.86139778e-03 -4.56848597e-03 7.08141059e-03\n", " -1.07708475e-02]\n", " [-7.07037518e-02 4.26174467e-02 -1.38803772e-02 -2.92668410e-03\n", " -1.30301447e-02 -1.01603196e-02 9.75524943e-03 3.74548101e-03\n", " 3.88866090e-03 -9.72738112e-03 4.86491845e-03 -3.37795309e-03\n", " 1.56065048e-02 1.12536529e-04 1.58877810e-03 -2.32148916e-03\n", " -1.62344213e-03]\n", " [-7.99673387e-04 -6.88926811e-03 5.91311630e-03 -1.21272789e-02\n", " 2.71141710e-03 -1.96249299e-03 8.74733027e-01 -2.78978613e-03\n", " 3.25261770e-03 1.44845562e-03 2.53036895e-03 -5.09965067e-03\n", " -2.33374550e-03 -1.03569847e-03 6.06843672e-03 4.24396614e-03\n", " -2.57304341e-03]]\n", "ABC.Distance DEBUG: Optimal FD delta: [0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1]\n" ] }, { "data": { "image/svg+xml": [ "y1y2y3:0y3:1y3:2y3:3y4y5:0y5:1y5:2y5:3y5:4y5:5y5:6y5:7y5:8y5:9p1^1p2^1p3^1p4^1p1^2p2^2p3^2p4^2p1^3p2^3p3^3p4^3p1^4p2^4p3^4p4^4Data-parameter sensitivities" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# plot flow diagram\n", "\n", "fig = pyabc.visualization.plot_sensitivity_sankey(\n", " info_sample_log_file=f\"{info_sample_log_file}_L1+Ada.+MAD+SensiLR+P4\",\n", " t=f\"{info_log_file}_L1+Ada.+MAD+SensiLR+P4.json\",\n", " h=hs[-1],\n", " predictor=LinearPredictor(),\n", " par_trafo=ParTrafo(trafos=par_trafos, trafo_ids=trafo_ids),\n", " height=900,\n", ")\n", "\n", "# here just showing a non-interactive plot to reduce storage\n", "img_file = tempfile.mkstemp(suffix=(\".svg\"))[1]\n", "fig.write_image(img_file)\n", "display(SVG(img_file))" ] }, { "cell_type": "raw", "id": "13d023e4-9e48-432d-9616-78a3ebca0899", "metadata": { "raw_mimetype": "text/restructuredtext", "tags": [] }, "source": [ "This was a little introduction to approaches accounting for heterogeneous data scales by adaptive scale normalization, and data informativeness by using regression models to either construct low-dimensional summary statistics, or inform sensitivity weights.\n", "Beyond linear regression employed in this notebook, various other regression methods are possible, including e.g. Gaussian processes or neural networks to capture non-linear relationships better. These are also implemented in pyABC.\n", "\n", "It should be noted that the use of regression models may be sensitive to in particular training sample size, especially for more complex regression models, such that some care may need to be taken there. For example, also model selection with out-of-sample validation is provided via :class:`ModelSelectionPredictor `." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.9.7" } }, "nbformat": 4, "nbformat_minor": 5 }