82_performance.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Computational Performance](https://scikit-learn.org/stable/computing/computational_performance.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Latency - Bulk vs Atomic Mode\n",
    "\n",
    "- In general doing predictions in bulk (many instances at the same time) is more efficient for a number of reasons (branching predictability, CPU cache, linear algebra optimizations, etc.). \n",
    "\n",
    "### Latency vs Validation Overhead\n",
    "\n",
    "- Scikit-learn's data validations increase the overhead per call to `predict` and similar functions. \n",
    "\n",
    "- In particular: checking for finite (not NaN or Infinite) features  involves a full pass over the data. If you know your data is acceptable, *you can suppress finiteness checking* by setting the environment variable `SKLEARN_ASSUME_FINITE` to a non-empty string before importing scikit-learn -  or configure it in Python with `set_config`. \n",
    "\n",
    "- For fine-tuned control of this feature:\n",
    "\n",
    "`with sklearn.config_context(assume_finite=True):\n",
    "    pass <learning/prediction method here, with reduced validation>`\n",
    "\n",
    "### Latency vs Number of Features\n",
    "\n",
    "- A matrix of $M$ samples with $N$ features has a memory footprint of $O(NM)$. This means the number of basic math operations increases too. (See the prediction time vs #features graph, below.) \n",
    "\n",
    "### Latency vs Input Datatypes\n",
    "\n",
    "- [SciPy provides sparse matrix structures](https://docs.scipy.org/doc/scipy/reference/sparse.html), which are much more memory efficient. A non-zero value in a **CSR** or **CSC** sparse matrix will consume, on average:\n",
    "    - a position (integer, 32b)\n",
    "    - a value (floating point, 64)\n",
    "    - row or column ID (integer, 32b)\n",
    "    \n",
    "- Math operations on dense data structures can leverage vector operations and multithreading in **BLAS**, and usually results in fewer CPU cache misses.\n",
    "\n",
    "- As a general rule: if the data sparsity ratio is >90%, consider using a sparse format. \n",
    "\n",
    "### Latency vs Feature Extraction\n",
    "\n",
    "- Most scikit-learn use compiled Cython extensions or optimized computing libraries. However, the feature extraction process (i.e. turning raw data like database rows or network packets into numpy arrays) governs the overall prediction time in most real-world applications. \n",
    "\n",
    "- Example: the data prep for the Reuters text classification task (reading and parsing SGML files, tokenizing the text and hashing it into a common vector space) takes **100-500X** more time than the prediction code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Example: Model Complexity](https://scikit-learn.org/stable/auto_examples/applications/plot_model_complexity_influence.html)\n",
    "\n",
    "- Compare SGD Classifier (stochastic gradient descent) vs NuSVR (Nu support vector regression) vs Gradient Boosting Regressor (additive model, iterative)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn import datasets\n",
    "from sklearn.utils import shuffle\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.svm import NuSVR\n",
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.metrics import hamming_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- regressions: use diabetes toy dataset.\n",
    "- classifications: use 20newsgroups text dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_data(case):\n",
    "    if case == 'regression':\n",
    "        X, y = datasets.load_diabetes(return_X_y=True)\n",
    "    elif case == 'classification':\n",
    "        X, y = datasets.fetch_20newsgroups_vectorized(subset='all',\n",
    "                                                      return_X_y=True)\n",
    "    X, y             = shuffle(X, y)\n",
    "    offset           = int(X.shape[0] * 0.8)\n",
    "    X_train, y_train = X[:offset], y[:offset]\n",
    "    X_test, y_test   = X[offset:], y[offset:]\n",
    "\n",
    "    data = {'X_train': X_train, \n",
    "            'X_test': X_test, \n",
    "            'y_train': y_train,\n",
    "            'y_test': y_test}\n",
    "    return data\n",
    "\n",
    "regression_data = generate_data('regression')\n",
    "classification_data = generate_data('classification')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Benchmark influence: find param influence on each estimator. Collect prediction time, performance & complexities.\n",
    "- Complexity calculated with `complexity_computer`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def benchmark_influence(conf):\n",
    "    prediction_times = []\n",
    "    prediction_powers = []\n",
    "    complexities = []\n",
    "\n",
    "    for param_value in conf['changing_param_values']:\n",
    "        conf['tuned_params'][conf['changing_param']] = param_value\n",
    "        estimator = conf['estimator'](**conf['tuned_params'])\n",
    "\n",
    "        print(\"Benchmarking %s\" % estimator)\n",
    "        estimator.fit(conf['data']['X_train'], \n",
    "                      conf['data']['y_train'])\n",
    "        conf['postfit_hook'](estimator)\n",
    "        complexity = conf['complexity_computer'](estimator)\n",
    "        complexities.append(complexity)\n",
    "\n",
    "        start_time = time.time()\n",
    "        for _ in range(conf['n_samples']):\n",
    "            y_pred = estimator.predict(conf['data']['X_test'])\n",
    "        elapsed_time = (time.time() - start_time) / float(conf['n_samples'])\n",
    "        prediction_times.append(elapsed_time)\n",
    "        pred_score = conf['prediction_performance_computer'](\n",
    "            conf['data']['y_test'], y_pred)\n",
    "        prediction_powers.append(pred_score)\n",
    "        print(\"Complexity: %d | %s: %.4f | Pred. Time: %fs\\n\" % (\n",
    "            complexity, conf['prediction_performance_label'], pred_score,\n",
    "            elapsed_time))\n",
    "    return prediction_powers, prediction_times, complexities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _count_nonzero_coefficients(estimator):\n",
    "    a = estimator.coef_.toarray()\n",
    "    return np.count_nonzero(a)\n",
    "\n",
    "configurations = [\n",
    "    {'estimator': SGDClassifier,\n",
    "     'tuned_params': {'penalty': 'elasticnet', \n",
    "                      'alpha': 0.001, \n",
    "                      'loss': 'modified_huber', \n",
    "                      'fit_intercept': True, \n",
    "                      'tol': 1e-3},\n",
    "     \n",
    "     'changing_param': 'l1_ratio',\n",
    "     'changing_param_values': [0.25, 0.5, 0.75, 0.9],\n",
    "     'complexity_label': 'non_zero coefficients',\n",
    "     'complexity_computer': _count_nonzero_coefficients,\n",
    "     'prediction_performance_computer': hamming_loss,\n",
    "     'prediction_performance_label': 'Hamming Loss (Misclassification Ratio)',\n",
    "     'postfit_hook': lambda x: x.sparsify(),\n",
    "     'data': classification_data,\n",
    "     'n_samples': 30},\n",
    "\n",
    "    {'estimator': NuSVR,\n",
    "     'tuned_params': {'C': 1e3, 'gamma': 2 ** -15},\n",
    "     'changing_param': 'nu',\n",
    "     'changing_param_values': [0.1, 0.25, 0.5, 0.75, 0.9],\n",
    "     'complexity_label': 'n_support_vectors',\n",
    "     'complexity_computer': lambda x: len(x.support_vectors_),\n",
    "     'data': regression_data,\n",
    "     'postfit_hook': lambda x: x,\n",
    "     'prediction_performance_computer': mean_squared_error,\n",
    "     'prediction_performance_label': 'MSE',\n",
    "     'n_samples': 30},\n",
    "    \n",
    "    {'estimator': GradientBoostingRegressor,\n",
    "     'tuned_params': {'loss': 'ls'},\n",
    "     'changing_param': 'n_estimators',\n",
    "     'changing_param_values': [10, 50, 100, 200, 500],\n",
    "     'complexity_label': 'n_trees',\n",
    "     'complexity_computer': lambda x: x.n_estimators,\n",
    "     'data': regression_data,\n",
    "     'postfit_hook': lambda x: x,\n",
    "     'prediction_performance_computer': mean_squared_error,\n",
    "     'prediction_performance_label': 'MSE',\n",
    "     'n_samples': 30},\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_influence(conf, mse_values, prediction_times, complexities):\n",
    "\n",
    "    fig = plt.figure()\n",
    "    fig.subplots_adjust(right=0.75)\n",
    "\n",
    "    # first axes (prediction error)\n",
    "    ax1 = fig.add_subplot(111)\n",
    "    line1 = ax1.plot(complexities, mse_values, c='tab:blue', ls='-')[0]\n",
    "    ax1.set_xlabel('Model Complexity (%s)' % conf['complexity_label'])\n",
    "    y1_label = conf['prediction_performance_label']\n",
    "    ax1.set_ylabel(y1_label)\n",
    "\n",
    "    ax1.spines['left'].set_color(line1.get_color())\n",
    "    ax1.yaxis.label.set_color(line1.get_color())\n",
    "    ax1.tick_params(axis='y', colors=line1.get_color())\n",
    "\n",
    "    # second axes (latency)\n",
    "    ax2 = fig.add_subplot(111, sharex=ax1, frameon=False)\n",
    "    line2 = ax2.plot(complexities, prediction_times, c='tab:orange', ls='-')[0]\n",
    "    ax2.yaxis.tick_right()\n",
    "    ax2.yaxis.set_label_position(\"right\")\n",
    "    y2_label = \"Time (s)\"\n",
    "    ax2.set_ylabel(y2_label)\n",
    "    ax1.spines['right'].set_color(line2.get_color())\n",
    "    ax2.yaxis.label.set_color(line2.get_color())\n",
    "    ax2.tick_params(axis='y', colors=line2.get_color())\n",
    "\n",
    "    plt.legend((line1, line2), (\"prediction error\", \"latency\"),\n",
    "               loc='upper right')\n",
    "\n",
    "    plt.title(\"Influence of varying '%s' on %s\" % (conf['changing_param'],\n",
    "                                                   conf['estimator'].__name__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `SGD classifier`: Relaxing the L1 penalty reduces the prediction error but leads to an increase in the training time. \n",
    "\n",
    "- `NuSVR`: Training time increases with the #support vectors; and there is an optimal number of support vectors which reduces the prediction error. Too few support vectors lead to an underfitted model while too many support vectors lead to an overfitted model. \n",
    "\n",
    "- `Gradient boosting`: Same conclusions.\n",
    "- `Nu-SVR`: too many trees in the ensemble is not as detrimental."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Benchmarking SGDClassifier(alpha=0.001, l1_ratio=0.25, loss='modified_huber',\n",
      "              penalty='elasticnet')\n",
      "Complexity: 4507 | Hamming Loss (Misclassification Ratio): 0.2576 | Pred. Time: 0.016135s\n",
      "\n",
      "Benchmarking SGDClassifier(alpha=0.001, l1_ratio=0.5, loss='modified_huber',\n",
      "              penalty='elasticnet')\n",
      "Complexity: 1629 | Hamming Loss (Misclassification Ratio): 0.2952 | Pred. Time: 0.011621s\n",
      "\n",
      "Benchmarking SGDClassifier(alpha=0.001, l1_ratio=0.75, loss='modified_huber',\n",
      "              penalty='elasticnet')\n",
      "Complexity: 869 | Hamming Loss (Misclassification Ratio): 0.3218 | Pred. Time: 0.009315s\n",
      "\n",
      "Benchmarking SGDClassifier(alpha=0.001, l1_ratio=0.9, loss='modified_huber',\n",
      "              penalty='elasticnet')\n",
      "Complexity: 655 | Hamming Loss (Misclassification Ratio): 0.3310 | Pred. Time: 0.008578s\n",
      "\n",
      "Benchmarking NuSVR(C=1000.0, gamma=3.0517578125e-05, nu=0.1)\n",
      "Complexity: 36 | MSE: 5238.2682 | Pred. Time: 0.000153s\n",
      "\n",
      "Benchmarking NuSVR(C=1000.0, gamma=3.0517578125e-05, nu=0.25)\n",
      "Complexity: 90 | MSE: 4964.6865 | Pred. Time: 0.000313s\n",
      "\n",
      "Benchmarking NuSVR(C=1000.0, gamma=3.0517578125e-05)\n",
      "Complexity: 178 | MSE: 4730.7114 | Pred. Time: 0.000564s\n",
      "\n",
      "Benchmarking NuSVR(C=1000.0, gamma=3.0517578125e-05, nu=0.75)\n",
      "Complexity: 266 | MSE: 4714.1041 | Pred. Time: 0.000814s\n",
      "\n",
      "Benchmarking NuSVR(C=1000.0, gamma=3.0517578125e-05, nu=0.9)\n",
      "Complexity: 318 | MSE: 4740.0085 | Pred. Time: 0.000956s\n",
      "\n",
      "Benchmarking GradientBoostingRegressor(n_estimators=10)\n",
      "Complexity: 10 | MSE: 3396.6536 | Pred. Time: 0.000093s\n",
      "\n",
      "Benchmarking GradientBoostingRegressor(n_estimators=50)\n",
      "Complexity: 50 | MSE: 3295.5133 | Pred. Time: 0.000147s\n",
      "\n",
      "Benchmarking GradientBoostingRegressor()\n",
      "Complexity: 100 | MSE: 3339.2239 | Pred. Time: 0.000222s\n",
      "\n",
      "Benchmarking GradientBoostingRegressor(n_estimators=200)\n",
      "Complexity: 200 | MSE: 3703.0803 | Pred. Time: 0.000302s\n",
      "\n",
      "Benchmarking GradientBoostingRegressor(n_estimators=500)\n",
      "Complexity: 500 | MSE: 4153.1172 | Pred. Time: 0.000608s\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZoAAAEXCAYAAACUKIJlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAABVnUlEQVR4nO3dd3wURf/A8c+kUw8IvR699yKICoooelIsNEEBsbfHbuxrfc7y2CuKYqPbgCggij8ERZp0BAIcEHo9CKRnfn/MBo+QCrm7lO/79corW2ZnZ8vtd8vsjtJaI4QQQvhLSLALIIQQomSTQCOEEMKvJNAIIYTwKwk0Qggh/EoCjRBCCL+SQCOEEMKvCjXQKKVqKKUWKKWOK6X+p5SylFJfFeY8gkUZnymljiillgS5LB8qpZ4KZhkCQSn1k1JqVLDLUdoppTxKqUvt7seVUp8Eu0z+VBqWMdDyDDS+O1k+3AocBCpqrR88p5IVPRcAfYG6WutuwSyI1vp2rfXzhZ2vUsqplPIUdr75nPcZJyVa6yu01p/7YV5OpZRWSoUVdt52/r8ppXr7I+9s5jVMKfWXUuqEUmq/3X2nUkr5Y35a65e01jefaz7ZbQOl1GilVLpSKsH+26qUuuNc55VHOXorpeJ9hxXWMtr5e5RSifby7FVKTVBKlS+MvIuTwr511gBYr0vmW6ANAI/W+oQ/Z2JfOcktzSLMXwGqoJRSDwJvAa8CNYEawO1ATyAih2lCA1bAs/On1rq81ro8cC3wilKqY7ALdY7628vTAegIPFbYMwj2Ppnn/LXWuf4BHuBSu3s0sBB4DTgCbAOusMdNAFKBFCABuBSwgK/s8b2B+FzyDgFigC3AIWAqUMUe5wQ0MArYgblqesInn1DgcXva48ByoJ49rgXwM3AY2AgMyWVZawMz7LRxwC328LFAEpBuL9uzWaaLBI4CbXyGVQMSgepAZWAWcMBeb7MwV0aZaX8DXgQW2dM8DCzPMo8HgB981vULvusVeBDYD+wBxvhMFw3MBI4BS4EXgIU5LL8TE0x9t89DwGrAC0wBovKxz1wFrLTXyR9AO59xjwK77O20EegD9LP3m1R7/a7yWS83++x7i4A37Hy3Aufbw3fayz7KZz4u4G97uXcCls+4HZj9KcH+64HZ/54Ettt5fQE4sux/Y+1pFwBRwFeYffWovW5r+JS7dw7rxmHnfcCe15NASF6/rxzyOQFcm8e2mAB8APxop780t3VjT3ODXbZDwBOc/ju1sH/Tdn93exsfBVb5Lre9Hp63t9txYC5QNZdtMJos+yawBLjep38AsM6e329AS59xLe1hR+00A3zGXQmst8uxC7Nfl8P83jJ8ylGb049bmds+p2NPGeBze3ttAB7B5zjnu+7s/leA2Hyuv4aYfe04MA94L5tyndon7eE32eU4AswBGtjDFea3s9/e7muwj1fZrRufMtyCORYexhwba/uM08BdwGZgW677YT4OGqdWlL0jpNozDwXuAHYDKusBMOtOSd6B5j/AYqAu5sD9ETApy0r92N6w7YFk7J0Mc2BeAzS3V2h7zAG2HOaHNAYIw5xNHARa5bCsC4D3MQeRDpiDwSW+B4Fc1tOnwIs+/XcBs30O9tcCZYEKwDTg+yw/yB1Aa7uckfaG9f0R/Y19UOHMQJMGPAeE2zvNSaCyPX6y/VcWaGWvjxyXI5vtswTz46uC2YFvz2Oajpid+Tx7Hxll5xNpb5+d2DurvV0bZ3cA81kvvoEmzd6WoZiAuQPz44sELsP8UMr7rJe2mADSDtgHDMqyP4X5zOsmzA+qEVAe+Bb4Mkv6LzD7VBngNkwAL2uXpzPmlnFe6/QL4Ad7P3ACm4Cx+fl9Zcmnn70+wvKY3wTMSUJPe11E5bFuWmEOuBfZ6/V1ez5nBBqgDiYYXWnn1dfur+az/bYAzex19hvgzmUbjMZn3wS6Yg7Azez+Zphg2Rezrz9ib7MIuz8Oc8IZAVxi7w/N7Wn3ABfa3ZWBTrkcl3yXMbOcOR173MD/2XnWxZyUZRto7PFrgLfyuf7+xJx0RGBu3R/Lply+++RAex20xBxHngT+sNNfjjkBr4Q5RrYEauWxbi7BHC87YfaFd7ADmk+g+RlzbChT2IEmzmdcWXtmNQsh0GwA+viMq4X50YX5rFTfq4AlwDC7eyMwMJuyDwV+zzLsI+CZbNLWw1yxVPAZ9l9gQnY/gmymvxTY4tO/CLgxh7QdgCNZDqjPZUnzAXbgwgSgI0Bk1vVsr9dETv/B7secKYXa67C5z7gcr2hy2PYjffpfAT7MY5oPgOezDNsI9AKa2GW7FAjP6cedZb34BprNPuPa2vtEDZ9hh4AOOZTrTeCNLD9S33X2C3CnT3/zbPa/Rj7jbyLL1Vo+1mco5sqtlc+w24Df8vP7ypLXSGBvlmGZZ8aJwEU++8oXeZTLd908DUz2GVfOLnN2geZR7GDsk34O9pWlvf2e9Bl3J/+efGW3DUZjgtpRTJDQmINb5onsU8BUn/QhmDPw3sCFwF7sq0N7/CTsqzXMScltZDkZIP+BJqdjz1bgcp9xN3NmoEnwWZ5fgEp5rT+gvr0uyvqM+yqbcvnukz9hn7T4rJ+TmNv+l2BOarr7rqM81s144BWf/vKY34TT7tfYJ+J5/Z3Ns4C9mR1a65N2Z2E83GoAfKeUOqqUOooJPOmY+85nzBuzAjPnWw9z5pRdnudl5mnnOwJzPzur2sBhrfVxn2HbMWcd+TEfKKuUOk8p5cQEk+8AlFJllVIfKaW2K6WOYa6cKmW5X74zS36fA9fbD3VvwPzAknOY9yGtdZpPf+a6qYY5UPrmnXU+eclpneekAfBglnVeD3MVEwfch/kh71dKTVZK1S5AWfb5dCcCaK2zDisPYG+H+UqpA0opL+bZRdVc8q6N2d6ZtmPWne/+57vuvsQcFCYrpXYrpV5RSoXnUf6qmDPvrPPx3cfy+/s6BFT1vTeutT5fa13JHuf72z5tm+exbmr7ptfmmeShHJanATA4y7a+AHOSeMbykL/9Z7HWupLWugLmd9oaeMmnbKfWndY6wy5rncxy28My+a7bazFXDtuVUv+nlOqRRzmyymk5TltfZP/7GmQvT2/MrfzMdZ3b+ss8Hp30ySe7vH2HNQDe8snrMObqpY7W+lfgXcwdgP1KqXFKqYr2dDmtm6zrOwGzL/jur/k6ngTyofMJzBkacOqhZDWf8Tsx96Mr+fxFaa135SPvnUDjHIb/X5Y8y2uts6vJshuoopSq4DOsPuaMKU9a63TMc6Xh9t8sn6D1IOYM+TytdUXMbQkwO8GpLLLktxhzJnkhcD3mwFZQBzBnRXV9htU7i3wKYifmSsx3nZfVWk8C0FpP1FpfgPlRaOBlezqdQ35nayLmnnI9rbUD+JB/13d289ptlylT5hmlbyA7NZ3WOlVr/azWuhXmWdFVwI15lOkg5oww63zytY9l8SfmFs7AfKTNury5rZs9+OwjSqmymFu/2dmJOSP33dbltNbusyjTmQnMScQ3QH970GnbyD4Jq4dZf7uBelkq0pxat1rrpVrrgZhnpt9jfqv5Kkce9pDP35fW+v8wV5iv2YNyW397MMejsj5ZZJe3b/l3Ardlya+M1voPe/5va607Y26PNsM8csht3WRd3+Uw+4Lv/pqv9RfIQLMJiFJKuewzvycx9/0yfQi8qJRqAKCUqqaUys+PCOAT4HmlVFO71lY7pVQ05qF7M6XUDUqpcPuvq1KqZdYMtNY7Mbce/quUilJKtcM8aCvIe0ATMbfrRtjdmSpgzraPKqWqAM/kM78vMGchqVrrhQUoB3Aq+H0LWPZVVQvyPhieq4+B2+2zZqWUKmdv8wpKqeZKqUuUUpGYyhWZD2LBHNCdhVjjrgLmjDBJKdUNE6wzHbDn28hn2CTgfqVUQ7v66UvAlCxXiqcopS5WSrW1T5iOYQJIRnZpM/mcjLxor48GmEoeBX7XTGt9FHgWeF8pdZ2dX4hSqgPmdlducls304GrlFIXKKUiMM/+ctomXwH9lVKXK6VC7d9Nb6VU3RzS+8puG5zG/g1fjXmwD2bduZRSfexjyIOYYPsH8BfmSuMR+3feGxOgJiulIpRSI5RSDq11KmZ7+e530UopRz7KnJ2pwGNKqcpKqTrA3XmkfxPoq5RqTy7rT2u9HViG+e1G2FcZ/XPJF8wx9DGlVGsApZRDKTXY7u5q/ybDMSf9SUBGHutmEjBGKdXB/s2+BPyltfYUZAVBAAON1tqLuUf7CSYinsDUlsr0FuYsa65S6jimYsB5+cz+dcwGn4tZUeMxD6eOYx4SD8NE572YM+jIHPIZjrn3uRtz2+sZrfW8fJYBrfVf9nLVxtwvzfQm5mHdQcxyzc5nll8CbTiLA5GPuzE1lPba+U3C/Dj9Qmu9DPMw+13Mc6U4zL13MOvdjVkPezFnUJlVPafZ/w8ppVYUQlHuBJ6z96Wn+fcsLfOW1IvAIvs2Q3dMZY4vMbc1t2F+iPfkkn9NzEH5GOY27/+Rv6vOezD7yFZMDbOJ9rwLTGv9CiZQPYI5YO7DPIN8FHPwzUlu62YdpiLLRMxZ9RFO/536zn8n5orqcUzg2Ik5S87zuJLDNgDooez3aDDr9QD2dtBab8Q8m3oHsw/1x1QdTtFap9j9V9jj3sc8I/3HzvcGwKPMrevbMSeD2OMnAVvtchTkVi6YQByP2WfmYfaJHH9fWusDmBPIp/Ox/kZgauMdwjxbnZJH3t9hjm+T7eVci1kfABUxJ4FH+LdG4av2uJzWzTzMc7FvMPtCY8yxtMAyH7KJIkgpVQbz8LyT1npzIeX5Mubh8qjCyE8I8S9lXjAdprXu5Ye8pwD/aK3ze0ekyJAXA4u2O4Cl5xJklFIt7FuJyr5NMha7koIQ4twopWoppXraty2bY27nFcrvy77d1djOux/m6uf7wsg70IrEG87iTMp8CkYBg84xqwqYWwO1MbdW/od5j+NcyvY45nI/q9+11ldkM1yIkioCc7uyIaZa9mTMbbvCUBPzjDUac3vuDq3134WUd0DJrTMhhBB+JbfOhBBC+JXcOstBnbY9dK3I1GAXQwhRjITtXXlwcXxatbxTli4SaHLQ6dZXmXnPBcEuhhCiOLEc2/NOVPrIrTMhhBB+JYFGCCGEX0mgEUII4VfyjEaIIEhNTSU+Pp6kpKRgF0WchaioKOrWrUt4eF4f7BYggUaIoIiPj6dChQo4nU6UUnlPIIoMrTWHDh0iPj6ehg0bBrs4xYLcOhMiCJKSkoiOjpYgUwwppYiOjpar0QKQQCNEkEiQKb5k2xWMBBohhMjGCe9Bkk4ezzuhyJM8oxFCnLPffvuN1157jVmzZjFjxgzWr19PTExMtmmPHj3KxIkTufPOOwHYvXs39957L9OnTw9kkXOUlp7OyYM7qZh+hBMhFaBshbwnKgjL0Q/T/lYo8AmW151lfCSmzZrOmHZjhmJ5Pfa4xzBfYE8H7sXyzsk1T8uhMG3ZDLan+QDL+3bhLlDe5IpGCJGj9PT0Ak8zYMCAHIMMmEDz/vv/fuC4du3aAQ0yaWlpOfafOJlIyr5NVEw/wsnwypSp/m8DoGezLs5gOUKB9zANkrUChmM5WmVJNRY4guVtArxBZnPnJt0woDXQD3gfyxGaR56jMU1At8DytsR8XTrgJNAIUQp5PB5atGjBiBEjaNmyJddddx0nT54EwOl08uijj9KpUyemTZvG3Llz6dGjB506dWLw4MEkJCQAMHv2bFq0aEGnTp349ttvT+U9YcIE7r7btGi8b98+rr76atq3b0/79u35448/iImJYcuWLXTo0IGHH34Yj8dDmzZtAFNJYsyYMbRt25aOHTsyf/78U3lec8019OvXj6ZNm/LII49ku1zLly+nV69edO7cmcsvv5w9e/YA0Lt3b+677z66dOnCW2+9dUb/zz/Po227dpzXqR13PfAYxyKqU7aak0aNGp22LgpBNyAOy7sVy5uCOfBnbbJ+IPC53T0d6GNfmQwEJmN5k7G82zCt13bLI887gOewvKZ5Zsu7vzAWoqDk1pkQQfbszHWs332sUPNsVbsiz/RvnWuajRs3Mn78eHr27MlNN93E+++/z0MPPQRAdHQ0K1as4ODBg1xzzTXMmzePcuXK8fLLL/P666/zyCOPcMstt/Drr7/SpEkThg4dmu087r33Xnr16sV3331Heno6CQkJuN1u1q5dy8qVKwET9DK99957KKVYs2YN//zzD5dddhmbNm0CYOXKlfz9999ERkbSvHlz7rnnHurVq3dq2tTUVO655x5++OEHqlWrxpQpU3jiiSf49FPTUnZKSgrLli0DYObMmaf6D3sTaNuyGb9MeZ8mTZow5uGX+PSradx3332nrYt8qorlWObTPw7LO86nvw6myeZM8ZzZZP2/aSxvGpbDi2mTpg6mKXjfaevY3Tnl2RgYiuW4GtNc9L1Y3kJprbcg5IpGiFKqXr169OzZE4CRI0eycOHCU+MyA8fixYtZv349PXv2pEOHDnz++eds376df/75h4YNG9K0aVOUUowcOTLbefz666/ccccdAISGhuJwOHIt08KFC0/l1aJFCxo0aHAq0PTp0weHw0FUVBStWrVi+/bTv1+5ceNG1q5dS9++fenQoQMvvPAC8fHxZyxTpsFDhrDfe5J1S36lcf2aNGnRhrAaLRg9ZiwLFizIcbo8HMTydvH5G5f3JH4VCSRhebsAHwOfBqMQckUjRJDldeXhL1mr6Pr2lytXDjAvJ/bt25dJkyadljbzaiSQIiMjT3WHhoae8axFa03r1q35888/s50+c5kAMrQmITmdCgnbqEAihEYQVrUxZFNt2Xe6QrAL88wkU117WHZp4rEcYYADUykgt2lzGh6PaaUTTBPTn51j+c+KXNEIUUrt2LHj1EF54sSJXHDBmc1idO/enUWLFhEXFwfAiRMn2LRpEy1atMDj8bBlyxaAMwJRpj59+vDBBx8A5mG61+ulQoUKHD+efbXhCy+8kK+//hqATZs2sWPHDpo3b56v5WnevDkHDhw4tUypqamsW7futDRaaw4mJJOSkkr1jH1EhqTTouvFeHbuJs5eli+//JJevXrla55nYSnQFMvREMsRgXm4PyNLmhnAKLv7OuBXLK+2hw/DckRiORoCTYEleeT5PXCx3d0L2OSfxcqdBBohSqnmzZvz3nvv0bJlS44cOXLqFpevatWqMWHCBIYPH067du3o0aMH//zzD1FRUYwbNw6Xy0WnTp2oXr16tvN46623mD9/Pm3btqVz586sX7+e6OhoevbsSZs2bXj44YdPS3/nnXeSkZFB27ZtGTp0KBMmTDjtSiY3ERERTJ8+nUcffZT27dvToUMH/vjjj1PjU9My8Bw8QYZ3F1EqBRUaQUi1FkRVqs5nn33G4MGDadu2LSEhIdx+++0FWJMFYHnTgLuBOcAGYCqWdx2W4zksxwA71XggGssRBzwAxNjTrgOmAuuB2cBdWN70HPM03MC1WI41wH+Bm/2zYLlTWutgzLfI6//OQi0Nnwl/2bBhAy1btgza/D0eD1dddRVr164NWhkCRWvN0cRU9h1NoK7eT3mViC4bjapYF0LO/lw7221oOZbbz0OED3lGI4QosdLSM9h1NJHUxAQah+wnTKVDpfqostHBLlqpIoFGiFLI6XSW+KuZY0mpxB9OxKG91A85BKHhqMqNIaJssItW6kigEUKUKOkZmj3eRI6eSKZe6CEcHIfIClDJCaFyyAsGWetCiBLjRHIaO4+chLQUmoftJywjGcrXhAo1s626LAJDAo0QotjL0Jr9x5I4cDyZSqFJ1A3dj9JAlUYQlftLosL/JNAIIYq1pNR0dhw+SXJqOg0ijlEx7RCElYEqDSEsf1WjhX/JezRClFLly5fPdXzWrywXNVprDhxPYvP+BHR6Gi0iDpggU6YKVG0mQaYIkUAjhMhWUQ40KWnpbD14gj3eJKIj0mgWspvwtBPgqAeV6p/T+zGi8MnWEKKUS0hIoE+fPnTq1Im2bdvyww8/AJzxOX+AV199la5du9KuXTueeeYZwLz82bJlS2655RZat27NZZddRmJiIgBxcXFceumltG/fnk6dOrFlyxZuvPFGvv/++1PzHzFixKl55kVrzeETKWzal0BSSjqNyyVTK3UnCg1Vm0K5qvLQvwiSZzRCBNtPMbB3TeHmWbMtXOHOOx0QFRXFd999R8WKFTl48CDdu3dnwIABZ3zOf+7cuWzevJklS5agtWbAgAEsWLCA+vXrs3nzZiZNmsTHH3/MkCFD+Oabbxg5ciQjRowgJiaGq6++mqSkJDIyMhg7dixvvPEGgwYNwuv18scff/D555/nXkggNT2DXUcSOZaUSvnIUBqEHiY08TBEVIDKDSA0/FzWmPAjCTRClHJaax5//HEWLFhASEgIu3btYt++fWekmzt3LnPnzqVjx46AuRLavHkz9evXp2HDhnTo0AGAzp074/F4OH78OLt27eLqq68GTEAD6NWrF3feeScHDhzgm2++4dprryUsLPdDkTcxlV1HEknXmroVQqmcsguVlAjla0CFWnIVU8RJoBEi2PJ55eEvX3/9NQcOHGD58uWEh4fjdDpJSko6I53Wmscee4zbbrvttOEej+eMT/hn3jrLyY033shXX33F5MmT+eyznL9cn56Rwe6jSRw5mUKZ8FCalM8g4tg2M7JyQyhTKf8LKoJGntEIUcp5vV6qV69OeHg48+fPP9WgWNbP+V9++eV8+umnp5py3rVrF/v359wycIUKFahbt+6p5zHJycmnmosePXo0b775JgCtWrXKdvqEpDQ270vg6MkUqleIpEnZE0R4t5lbZNWaSZApRuSKRohSbsSIEfTv35+2bdvSpUsXWrRoAXDa5/yvuOIKXn31VTZs2ECPHj0AUz36q6++IjQ0NMe8v/zyS2677TaefvppwsPDmTZtGo0aNaJGjRq0bNmSQYMGnTFNRoZm77EkDiYkExkWQuOqZSh7Ih6Sj0GZyqZmWUjO8xRFjzQTkANpJkD4U7CbCQi2kydP0rZtW1asWHFa886JKWnsPJxIUlo60eUiqFUOQo5sg/RUqFinSNUqk2YC8k9unQkhAmrevHm0bNmSe+6551SQ0fYnZOL2nyBdaxpWLUedyCRCDm4GrSG6CZSvVmSCjCgYuXUmhAioSy+99NRzIIDk1HR2HknkZEoajjLh1KkURdjx3XDyIESUh8pOqbpczEmgESJItNaoUnyGnvny5R5vEkpB/SplqRQBHI6D1JNQrjpUrF0kr2LkkUPBSKARIgiioqI4dOgQ0dHRpTLYpKZnEH8kkeNJqZSPDKNe5bKEp5+Agx7QGeYqpkzlYBczW1prDh06dOq9IJE3CTRCBEHdunWJj4/nwIEDwS5KwCWmpHP0ZAoaqFgmnPCIUOJ2HYdEr2mYrGxVOLoX2BvsouYoKiqKunXrBrsYxYYEGiGCIDw8nIYNGwa7GAHlPZnKUz+sZcaq3bSvV4k3hrSnUYUM+OFO2DATWg2Ege+Z1jBFiSKBRgjhd79vPsDD01ZzMCGZB/o2487ejQk7tAk+HgmHt8JlL0KPu4rk8xhx7iTQCCH8JjElnf/+tIEv/txO42rl+PjGnrSt64C138IPd0NEWRg1A5zyzlpJViwCjTMmNhRYBuzyuF1XOWNiGwKTgWhgOXCDx+1KccbERgJfAJ2BQ8BQj9vlsfN4DBgLpAP3etyuOYFfEiFKj793HOHBqavYevAEN/VsyCP9mhMVkgGzH4fF70G982DwBFOzTJRoxeWFzf8AG3z6Xwbe8LhdTYAjmACC/f+IPfwNOx3OmNhWwDCgNdAPeN8OXkKIQpaansHrczdy3Yd/kpSazsSbz+Pp/q2ISjoInw8wQabbbTBqlgSZUqLIBxpnTGxdwAV8Yvcr4BJgup3kc2CQ3T3Q7sce38dOPxCY7HG7kj1u1zYgDugWkAUQohSJ23+ca97/g7d/jWNgh9r8dN9FnN+kKmz/Ez66CPashGs+gStfgbCIYBdXBEiRDzTAm8AjQIbdHw0c9bhdaXZ/PFDH7q4D7ASwx3vt9KeGZzONEOIcZWRoPl24DdfbC4k/cpIPRnTi9SEdcESFweIP4POrzPOYm+dBu8HBLq4IsCL9jMYZE3sVsN/jdi13xsT2DsD8bgVuBahTqYy/ZydEibDraCIPT1vFH1sO0adFdf57bVuqV4iC5ASYeS+s/Qaau+DqDyDKkXeGosQp0oEG6AkMcMbEXglEARWBt4BKzpjYMPuqpS6wy06/C6gHxDtjYsMAB6ZSQObwTL7TnOJxu8YB48B8vdkvSyRECaG15ru/d/HMD+vI0Br3NW0Z2rWe+dLBwTiYMhIOboQ+T0PP+yGkONxAEf5QpLe8x+16zON21fW4XU7Mw/xfPW7XCGA+cJ2dbBTwg909w+7HHv+rx+3S9vBhzpjYSLvGWlNgSYAWQ4gS5/CJFO74agUPTF1F85oV+Ok/FzGsW30TZDbMhHG94cR+GPktXPigBJlSrqhf0eTkUWCyMyb2BeBvYLw9fDzwpTMmNg44jAlOeNyudc6Y2KnAeiANuMvjdqUHvthCFH+/bNjHo9+swZuYwqP9WnDrRY0IDVGQnga/Pg+L3oTanWDIF1CpXp75lTqWox/mzkwo8AmW151l/BmvaWB5Pfa4017TwPLOyTVPyzEB6IV5Xg0wGsu70k9LliNp+CwH0vCZEKdLSE7jhVnrmbx0Jy1qVuCNoR1oWauiPfIATB8Dnt+h8xi44mUIiwxugYMhr4bPLEcosAnoi6mUtBQYjuVd75PmTqAdlvd2LMcw4Gos71AsRytgEqbGbG1gHtDMnir7PE2gmYXlnU4QFdcrGiFEAC31HOaBqSuJP5LI7b0ac3/fpkSG2a+i7VwKU2+ExMMw8H3oOCK4hS3augFxWN6tAFiOyZjXL9b7pBkIWHb3dOBdLMep1zSwvMnANiyH72saeeUZVBJohBA5Sk5L542fN/PRgi3UrVyGqbf1oKuzihmpNSwbDz/FmBcvx86FWu2DW+Dgq4rlWObTPw7LO86nP7tXLc7Lkse/aSxvGpbD9zWNxVmmzXxNI7c8X8RyPA38AsTYgSqgJNAIIbK1Yc8x7p+ykn/2Hmd4t3o84WpF+Uj7kJFyEmIfgFWToOllcPVHULZKcAtcNBzM9dZZ4D2GaW8hAlOj9lHguUAXQgKNEOI06Rmaj3/fyutzN1GxTDjjR3WhT8sa/yY4vBWm3AD71kHvx+Gih6VWWf7l51WLU69pYDny+5pG9sMt7x57WDKW4zPgoXNfhIKTQCOEOGXHoZM8OG0lSz1H6Ne6Ji9e3Ybo8j4P9TfOhm9vNZ/zHzENmvYNXmGLp6VAUyxHQ0wwGAZcnyVN5msaf2K/poHl1ViOGcBELMfrmMoAma9pqBzztBy1sLx77Gc8g4C1/l287EmgEUKgtWbK0p08P2s9IUrxv8HtuaZTnX+bmc5Ih9/csOAVqNkOhn5pmlsWBWOeudwNzMFURf4Uy7sOy/EcsAzLOwP7NQ37Yf+p1zTsdKe9poHlNa9pZJen8TWWoxomGK0Ebg/IcmYh1ZtzINWbRWmx/3gSj32zhl/+2U+PRtG8NqT96Z9gOnkYvrkZtvwCHUaC6zUIl080ZSuv6s2llFzRCFGKzV67h8e+XcOJlHSeuqoVY853EhLi08rl7r9hyo2QsBf6vwWdRkkrmKLAJNAIUQodS0rFmrGOb1fsom0dB68PaU/TGhVOT7TiC4h9CMpVg5tmQ53OwSmsKPYk0AhRyvwRd5CHpq1i3/Fk7r2kCff0aUp4qE+tsdQk+OlhE2gaXQzXjody0cErsCj2JNAIUUokpabzyuyNfLpoG42qlmP67T3oWL/y6YmO7jBVl/eshAsfgosfhxBpjFacGwk0QpQCa+K93D91JXH7E7ixRwMeu6IlZSKyBJC4eeahf0Y6DJsELa4MTmFFiSOBRogSLC09g/d/28Lbv2wmunwEX9zUjYuaVTs9UUYG/P4/mP8iVG9lqi5HNw5OgUWJJIFGiBJq64EE7p+6ilU7jzKgfW2eH9gGR9nw0xMlHoXvboNNs6HtEOj/JkSUC0ZxRQkmgUaIEkZrzZeLt/PSjxuIDAvlneEd6d++9pkJ964xz2O8O+HK16DrzVJ1WfiFBBohSpC93iQenr6K3zcf5KJm1Xj1unbUqBh1ZsJVk2HmfVCmEoz+Eepn/YCwEIVHAo0QJcQPK3fx1PdrSU3XPD+oDSPPq//vJ2QypaXAnMdg6SfQ4AIY/BmUrx6cAotSQwKNEMXc0ZMpPPn9Wmat3kPH+pV4fUgHGlbN5jmLdxdMGwXxS+H8e6CPBaFyCBD+J3uZEMXYbxv388j01Rw+kcJDlzXj9l6NCQvN5pP92xbAtDGQlgSDP4fWgwJeVlF6SaARohg6mZLGSz9u4KvFO2havTyfju5KmzqOMxNqDYvegl+eheimMPQrqNbszHRC+JEEGiGKmRU7jvDAlJVsP3ySmy9oyEOXNycqPJu395OOwQ93woaZ0GoQDHwXIiucmU4IP5NAI0QxkZKWwdu/bOb93+Ko5SjDxJu706NxDt8g278BpoyEw9vgshehx11SdVkEjQQaIYqBTfuOc/+UlazbfYzrOtfl6f6tqBgVnn3itd/AD/eYFy9HzQRnz8AWVogsJNAIUYRlZGg+XbSNV+ZspHxkGB+O7Ey/NjWzT5yeCj8/DYvfh3rnmYf+FWsFtsBCZEMCjRBFVPyRkzw4dRV/bTvMpS2r899r2lGtQmT2iY/vhWmjYcefcN7t0Pd5CIsIaHmFyIkEGiGKGK0105fH8+zM9WiteeXadgzuUvfMly8zbf/DBJnk46btmLbXBbS8QuRFAo0QRcihhGQe/24Nc9bto5uzCv8b0p56Vcpmn1hrWPwBzH0SKjvhhu+hRqtAFleIfJFAI0QR8fP6fTz27WqOJabx+JUtGHtBI0JDcriKSU6AGffAum+hxVUw6H2IyuY9GiGKAAk0QgTZ8aRUnp+1nqnL4mlZqyJf3dyeFjUr5jzBwc2m6vLBTXCpBT3vk6rLokiTQCNEEP219RAPTlvF7qOJ3Nm7Mf+5tCmRYbk0nbx+Bnx/p3nQf8N30Kh3wMoqxNmSQCNEECSlpvP6z5v4+Pet1Ktclqm39aCLs0rOE6Snwa/Pmc/J1OkMQ74AR93AFViIcyCBRogAW7fbywNTVrFx33GuP68+T1zZknKRufwUEw7A9DHg+R26jIV+/4WwHKo5C1EESaARIkDSMzQf/t8W3py3iUplI/hsdFcubpFHWzA7l8LUGyHxMAz6ADpcH5jCClGIJNAIEQDbD53ggamrWL79CFe2rckLg9pSpVwuL1RqbRonm/0YVKwNY3+GWu0CV2AhCpEEGiH8SGvNpCU7eSF2PaEhijeGtmdQhzo5v3wJkHISZt0PqydD08vhmo+gTOXAFVqIQiaBRgg/2X8siUe/Wc38jQfo2SSaV69rT+1KZXKf6PBWmHID7FsHFz8BFz4EIdk0ZCZEMSKBRgg/+HHNHp74bg0nU9J5pn8rRvVwEpLTy5eZNv4E395m3okZMR2aXhqYworAshz9gLeAUOATLK87y/hI4AugM3AIGIrl9djjHgPGAunAvVjeOfnM823gJixveT8tVa6KdKBxxsRGAQuASExZp3vcrmecMbF9gFeBECABGO1xu+KcMbFnbCCP2+Wx8zptA3ncrjmBXh5R8nkTU3nmh7V8v3I37eo6eH1IB5pUz+O3nZEOv/0XFrwKtdqbqsuVnQEprwgwyxEKvAf0BeKBpViOGVje9T6pxgJHsLxNsBzDgJeBoViOVsAwoDVQG5iH5chsLjXnPC1HFyCo916L+jV5MnCJx+1qD3QA+jljYrsDHwAjPG5XB2Ai8KSdfixwxON2NQHewGwgnDGxvhuoH/C+MyY2l7fihCi4hZsP0u/NBcxcvYf7Lm3KN3ecn3eQOXkYvr7OBJmOI+GmuRJkSrZuQByWdyuWNwWYDAzMkmYg8LndPR3og+VQ9vDJWN5kLO82IM7OL+c8TWB7FXjEv4uVuyJ9ReNxuzTmigUg3P7T9l/mNzocwG67eyBg2d3TgXedMbGnNpDH7UoGtjljYjM30J/+XgZR8iWmpPPy7H+Y8IeHRtXK8e0d59O+XqW8J9y1AqaOgoS90P9t6DzK72UVflcVy7HMp38clnecT38dYKdPfzxwXpY8/k1jedOwHF4g2h6+OMu0dezunPK8G5iB5d2DFbxv4RXpQANgX3ksB5oA73ncrr+cMbE3Az86Y2ITgWNAdzv5qQ3kcbvSnDGx+dlAQpy1VTuPcv/UlWw9cILR5zt5tF8LykTk42J5+efw40NQvgbcNNu87S9KgoNY3i7BLgQAlqM2MBjonY+0UcBVwIWY23KJwFogFsu77lyLUuQDjcftSgc6OGNiKwHfOWNi2wD3A1faQedh4HXg5nOdlzMm9lbgVoA6edUOEqVaanoG7/4ax7vz46hWPpIvx3bjwqbV8jFhkgkwf38JjS427ceUi/Z/gUVRsQuo59Nf1x6WXZp4LEcY5q7NoTymzW54R8wJepx9NVMWyxGH5W1y2twsx7OYIPMb8BewH4gCmgFuOwg9iOVdXfDFNYp8oMnkcbuOOmNi5wNXAO09btdf9qgpwGy7+9QGcsbE5ncD+c5jHDAOoP87C7U/lkMUf3H7E3hw6kpWxXsZ1KE2zw5og6NseN4THtlu3vLfs9JUW774cQiRR4WlzFKgKZajIeYYNAzI+rmHGcAozK3964BfsbwayzEDmIjleB1z1dEUWAKobPM0VyL/tvttORLOCDLGEizvMzmU93UsR3Wg/lktra1IVwZwxsRWs69kcMbElsHUqtgAOJwxsZm1LTKHwb8bCOwNZD/nmQEMc8bERjpjYhvy7wYSIt8yMjQTFm3D9fbvbD98kveu78SbwzrmL8jEzYNxveDwNhg+Gfo8JUGmNLK8aZjnJnMwx62pWN51WI7nsBwD7FTjgWgsRxzwABBjT7sOmAqsx5xc34XlTc8xz/yXKfbMYY4QLEdFe/x+LO+yM9IUgNK66J64O2Ni22FqX4RiguJUj9v1nDMm9mrgOSADOALc5HG7ttrVob/EXDIeBoZ53K6tdl5PADcBacB9Hrfrp9zm3f+dhXrmPRf4aclEcbP7aCKPTF/NwriD9G5ejVeubUf1ilF5T5iRAb+/BvNfguqtYOiXEN3Y/wUWwWE5lheZZzQFZTkmArdjXgFZiqlw9RaW99VzzbpIB5pgkkAjwHxC5oeVu3nqh7WkpWuevKol13ern/snZDIlHjEvYG6eA+2GwlVvQkQOzTKLkqF4B5qVWN4OWI4RQCfMldRyLO85f2Sv2DyjESLQjpxI4Ynv1/Djmr10blCZ/w1uj7NqufxNvHeNaQXTuwuufA263iytYIqiLhzLEQ4MAt7F8qZiOQrlSkQCjRDZmP/Pfh75ZjVHT6bw8OXNub1XY0Lz+oRMppWTYNZ95kOYY36Eet38WlYhCslHgAdYBSzAcjTAvD5yziTQCOHjRHIaL8RuYNKSHTSrUZ4JY7rSunY+X3RLSzaf9V82HpwXwnWfQvk82psRoqiwvG8Db//b79gBXFwYWUugEcK2fPthHpi6ih2HT3LrRY14oG8zosLzWTPMu8tUXd61DM6/F/o8A6Hy8xLFgOUYCUzE8macPtyrgTQsR2OgFpZ34dnOwu+/BGdM7EiP2/WV3d3T43Yt8hl3t8ftetffZRAiNylpGbw5bxMf/t8WajnKMOmW7nRvVICXKLf+H0y/yVzRDPkCWmX9dJUQRVo08DeWYznmKywHMC9sNgF6AQfJrGJ9lgJxyvUA8JXd/Q6mNkOmmwAJNCJoNu49zn1TVrJhzzGGdKnLU1e1okJUPt6LAdMK5qI34ZfnoGozGPoVVG3q1/IKUegs71tYjneBS4CeQDvMJ2g2ADdgeXec6ywCEWhUDt3Z9QsREOkZmvELt/LanE1UiApj3A2duax1zbwnzJTkhe/vhH9mQetrYMA7EBmUpj6EOHeWNx342f4rdIEINDqH7uz6hfC7nYdP8uC0VSzZdpjLWtXgpWvaUrV8ZP4z2LfeVF0+4oHL/wvd75Cqy0LkIhCBpoUzJnY15uqlsd2N3d8oAPMXAjAvX05bFs+zM9ehlOLV69pxXee6+Xv5MtOa6TDjHoisAKNnQYPz/VdgIUqIQASalgGYhxC5OnA8mce+XcO8Dfs4r2EVXhvcnnpVCvCWfnoqzH0K/voA6veAwROgQgFutQlRivk90Hjcru2+/c6Y2GjgImCHx+1a7u/5CzFn3V4e/3YNx5PTeNLVkpt6NiQkvy9fAhzfaxoo27kYut8JfZ+D0HxWGBCiuLAcNYCXgNpY3ivspqN7YHnHn2vWfv96szMmdpbdhgzOmNhamMZ0bgK+dMbE3ufv+YvS63hSKg9NW8VtXy6nRsUoZt59ATdf2KhgQcazCD68EPauNm3H9PuvBBlRUk3AfAG6tt2/CbivMDIORDMBDT1u11q7ewzws8ft6o9pavSmAMxflEJ/bjlEvzd/59sV8dx9cRO+v6snzWtWyH8GWsOf78Hn/SGqItzyK7S9zn8FFiL4qmJ5p2K+ip/ZpEF6YWQciECT6tPdB/gRwON2HSdzgYQoJEmp6bwwaz3Xf7KY8FDFtNvP56HLmxMRVoBdPTkBpo+BOY9D8yvglvlQXR41ihLvBJYjmszawJajO+AtjIwDURlgpzMm9h4gHvOy5mw41ZCZ3IMQhWbtLi/3T1nJ5v0JjOxen8evbEnZiALu4gc2marLhzbDpc9Cz/9I1WVRWjyAaSSyMZZjEVAN04DkOQtEoBmLaaTsUmCox+06ag/vDnwWgPmLEi4tPYMP/28Lb87bTJVyEUwY05Xezc/iY5brfzAvYYZFwQ3fQ6NehV5WIYosy7sCy9ELaI55/WQjljc1j6nyRRo+y4E0fFY8JCSnMerTJSzffgRXu1q8MLANlctFFCyT9DT45Vn4422o0wWGfA6Ouv4psCjZinfDZ6GAC3DiexFieV8/16wD8VHNGbmN97hdA3IbL0Ru3vx5Eyt2HOH1Ie25umOdgr18CZCw33wQ0/O7aZzs8pcgrABfCRCi5JgJJAFrKOTn54G4ddYD2AlMAv5Cvm8mCsmmfcf57A8PQ7vU45pOZ3EFsnOJeT8m8TAM+hA6DC/8QgpRfNQtjGabsxOIQFMT6AsMB64HYoFJHrdrXQDmLUoorTVP/7CW8pFhPNKvRUEnhqWfmEbKHHVg7M9Qyy+/LyGKk5+wHJdheecWdsaB+DJAOqam2WxnTGwkJuD85oyJfVbaohFna9bqPSzeepjnB7amSkGeyaScNM0sr54CTS+Haz4yTS4LIRYD32E5QjCvpShAY3krnmvGAWkC0A4wLkyQcWKaC/0uEPMWJc+J5DRejN1A69oVuf68Bvmf8NAW0wrmvnVw8ZNw4YMQEohXyYQoFl7HPOpYY7euWWgCURngC6AN5kXNZ32+EiDEWXn7183sPZbEeyM6EZrfz8ls/Am+vc0ElpHTocml/i2kEMXPTmBtYQcZCMwVzUjgBPAf4F5nTGzmcAVoj9t1zpdlovSI25/A+N+3cV3nunRukI9bXhnpMP8l+P01qNUehnwJlQtwFSRE6bEV+A3L8ROQfGpocaje7HG75N6EKBRaa6wZ6ygTEUrMFfmoAHDiEHwzFrbOh443wJWvQXiU/wsqRPG0zf6LsP8KTUCe0QhRGH5au5eFcQex+rfKu0XMXSvM85iE/dD/beg8KjCFFKK4srzP+itrCTSiWDiZksYLs9bTomYFRnbP49bX8s/hx4egfA24aTbU6RSYQgpRHFmOd7G8d2M5ZpL5Qc3TxnvP+aV6CTSiWHj31zh2e5N4a3hHwkJzuBubmmgCzN9fQeNL4JpPoFx0YAsqRPFzI3A38Jq/ZiCBRhR5Ww8k8PHvW7mmYx26Oqtkn+jIdph6A+xZBRc9DL0fg5DQwBZUiPywHP2At4BQ4BMsrzvL+EjgC6AzcAgYiuX12OMew3yoOB24F8s7J9c8Lcd4oAum8tUmYDSWNyFLibaYtN7/K8zF9CWBRhRpWmusmeuJCgsl5socKgBsngff3gwZGTB8CjTvF9hCCpFf5sOV72G+lhIPLMVyzMDyrvdJNRY4guVtguUYBrwMDLWbVh4GtMa0gjkPy9HMnianPO/H8h6z5/065srl9MAG1bAcD+Rc5mJQ60yIczFn3T4WbDrAU1e1onqFLDXGTh6GeRas+BxqtIWhX0CVRkEppxD51A2Iw/JuBcByTAYGAr6BZiBg2d3TgXexHMoePhnLmwxsw3LE2fmRY57/BhkFlCG7ZzDmKqg8fvwOpQQaUWQlpqTz/Kz1NK9RgVE9fCoAaA2rJsHcJyHxKPS4Gy5+AiLKBq2sQuRTHcyLkZniMc3aZ5/G8qZhObxAtD18cZZp69jdOedpOT4DrsQEswezKdMeLO9zBVyOApFAI4qsD36LY9fRRCbf2v3fCgD7/4HYB2D7IqjbDa56A2q2CW5BhfhXVSzHMp/+cVjecUErDYDlHWPfsnsHGMqZDU76/Yv6EmhEkbT90Ak+XLCVAe1r071RtPkY5oJX4I93IKK8eTem4w3yrTJR1BzMo+GzXUA9n/669rDs0sRjOcIAB6ZSQG7T5p6n5U23b6k9wpmBpk8u5S0UEmhEkfTszPWEhyiecLWEjbPhx4fBuwM6jIC+z0G5qsEuohBnYynQFMvREBMMhmGaT/E1AxgF/AlcB/yK5dVYjhnARPuhfm2gKbAEc0VyZp7muUxjLG+c3T0A+OeMElnew4W/mKeT00FR5Mxbv49f/9nP4xeUp8aPY2HSUPP8ZfSPMOh9CTKi+LK8aZiaX3OADcBULO86LMdzWI7MFyPHA9H2w/4HgBh72nXAVMyzltnAXeZKJYc8TQD6HMuxBtNqZi3Ar89icqK0LvQPdZYI/d9ZqGfec0Gwi1HqJKWm0+/1Xxie8SO3ZkxBaQ29H4Xud0FYoX5+SYjCZzmW53HrrFSSW2eiSPlh5rd8eOJZWoTshOZXwhUvQ6X6wS6WEOIcFOlA44yJjQIWAJGYsk73uF3POGNiFfACMBjzhuwHHrfrbXv4W5iqfCeB0R63a4Wd1yjgSTvrFzxu1+eBXRqRqxOHSIh9gqHrJ3E4ojpcNxFauIJdKiFEISjqz2iSgUs8bld7oAPQzxkT2x0Yjall0cLjdrUEJtvpr8A8IGsK3Ap8AOCMia0CPIOpW94NeMYZEyvt9xYFGRmw4kt4twtR66fyiR5Ayu1/SpARogQp0lc0HrdLA5nf5Qm3/zRwB3C9x+3KsNPtt9MMBL6wp1vsjImt5IyJrQX0Bn72uF2HAZwxsT8D/YBJgVoWkY1962DWA7BzMUerdmHI0cFcfXlfalaVh/1ClCRFOtAAOGNiQ4HlQBPgPY/b9ZczJrYxMNQZE3s1cAC41+N2bSb7t27r5DI867xuxVwJUadSGT8sjQAg5QT85obF70NkRVJdbzNofl1CqoYy9oKGwS6dEKKQFfVbZ3jcrnSP29UB8xJSN2dMbBvMM5skj9vVBfgY+LSQ5jXO43Z18bhdXaqUkxpOfvFPLLzbDf54G9oPh3uW89Hx8/EcTsLq35qIsCK/SwohCqjY/Ko9btdRYD7mllc88K096jugnd2d05uz+XkbV/jT0R0wcRhMvh6iKsJNc2Dgu8QnR/Hu/Dj6ta7JRc2qBbuUQgg/KNK3zpwxsdWAVI/bddQZE1sG8xnsl4HvgYsx7Vv3wrSzAOaN2rudMbGTMQ/+vR63a48zJnYO8JJPBYDLgMcCtySlWFoKLH4PfnsZlIK+z0P3OyA0HIAXZm0A4Kn+rYJZSiGEHxX1K5pawHxnTOxqzKcbfva4XbMw7Slc64yJXQP8F7jZTv8jsBWIw9xSuxPArgTwvJ3HUuC5zIoBwo88i+CjC82n/Jv0gbuWQM97TwWZBZsOMHvdXu6+uIk8ExOiBJMvA+RAvgxwDk4chJ+fhpVfg6M+XPkKNL/itCTJaelc8ebvZGjNnPsvIjJMWsMUJYB8GSBbRfrWmShmMjLg7y/g52cgJQEuuN80qxxR7oyk4xduY+vBE3w2pqsEGSFKOAk0onDsXQuz7of4JdCgJ7heh+rZN728+2gi7/wSR99WNbi4efUAF1QIEWgSaMS5ST5uvxPzAZSpBIM+MNWWVc5tKb0Yu4EMrXn6KqkAIERpIIFGnB2tYcNMmB0Dx3ZB59HQ5xkoWyXXyRZuPkjsmj3cf2kz6lWRppeFKA0k0IiCO+IxDZFtngs12sDgCVCvW56TpaRl8MyMtdSvUpbbejXyezGFEEWDBBqRf2kp5o3+Ba9CSBhc/hJ0uw1C87cbTfhjG1sOnGD8qC5EhUsFACFKCwk0In+2/Q6xD8DBTdByAPRzg+OMz8XlaN+xJN6at5k+LarTp2UNPxZUCFHUSKARuUs4AHOfhNWToVIDuH4aNLuswNm8GLuB1AzN0/IFACFKHQk0InsZGbBignmrP+UkXPgQXPggRBT8Af6fWw4xY9Vu7r2kCQ2iz3ynRghRskmgEWfas8q0E7NrGTgvBNf/oFrzs8oqNd1UAKhTqQx39G5SyAUVQhQHEmjEv5KPw/yX4K8PoUwVuHoctBuS6zsxefn8Dw+b9iXw0Q2dKRMhFQCEKI0k0AjzTsz672H2Y3B8L3QZA32ehjLn1tr1/mNJvDlvM72aVeOyVlIBQIjSSgJNaXd4q3knJm4e1GwHQ7+CuoXzTcD//vQPKWkZWANao87hqkgIUbxJoCmt0tNg4Rvw+2sQEm6qK3e9Jd/vxORlybbDfPf3Lu66uDENq0oFACFKMwk0pZHW8NPDsOxTaDUI+v0XKtYutOzT0jN4+oe11HZEcdfFUgFAiNJOAk1p9MfbJsj0vA/6Plvo2X+1eDv/7D3OByM6UTZCdjEhSrui3sKmKGxrvzWNkrW+xnwEs5AdOJ7M/37exIVNq9KvTc1Cz18IUfxIoClNdiyG726H+j3M5/xDCn/zvzz7H5JS06UCgBDiFAk0pcWhLTBpOFSqB8MmQnhUoc9i+fYjTF8ez9gLGtG4WvlCz18IUTxJoCkNThyEr641L16OmJZnmzFnIz1D8/QPa6lZMYp7LpEKAEKIf8mT2pIuNdFcyRzfA6NmQRX/tAMz8a/trNt9jHeGd6RcpOxWQuTIcvQD3gJCgU+wvO4s4yOBL4DOwCFgKJbXY497DBgLpAP3Ynnn5Jqn5fga6AKkAkuA27C8qf5cvOzIFU1JlpEB394K8Uvhmo+hXle/zOZQQjKvztnI+Y2juapdLb/MQ4gSwXKEAu8BVwCtgOFYjqyfNB8LHMHyNgHeAF62p20FDANaA/2A97EcoXnk+TXQAmgLlAFu9t/C5UxOPUuyn5+CDTNMA2WtBvhtNq/M3sjJlHSelQoAQuSlGxCH5d0KgOWYDAwE1vukGQhYdvd04F0sh7KHT8byJgPbsBxxdn7kmKfl/fFUrpZjCVDXL0uVBwk0JdWSj+HPd6HbrdD9Tr/N5u8dR5iybCe3XNiQpjUq+G0+QhQTVbEcy3z6x2F5x/n01wF2+vTHA+dlyePfNJY3DcvhBaLt4YuzTJvZ+mDueVqOcOAG4D8FWJZCI4GmJNr4E/z0CDS/0nxaxk9XGaYCwDqqV4jkP5c288s8hChmDmJ5C+djgYXrfWABlvf3YMxcAk1Js2sFTL8JarWHaz+BEP99mn/K0p2s2eXlrWEdKC8VAITIj11APZ/+uvaw7NLEYznCAAemUkBu0+acp+V4BqgG3HbuxT87cnQoSY7ugIlDoWxVGD4FIvz3McsjJ1J4Zc4/nNewCgPaF9530oQo4ZYCTbEcDTHBYBhwfZY0M4BRwJ/AdcCvWF6N5ZgBTMRyvA7UBppiapKpHPO0HDcDlwN9sLwZfl62HEmts5Ii8Sh8PRjSk2HkdKjg3/ZfXp27keNJaTw3sI1UABAivyxvGnA3MAfYAEzF8q7DcjyH5cissTMeiLYf9j8AxNjTrgOmYioOzAbuwvKm55in8SFQA/gTy7ESy/F0IBYzK6W1DsZ8i7z+7yzUM++5INjFyJ+0FPjqGvOJmRu+g4YX+nV2q+OPMvC9RYw5vyFP989aM1OIUsxyLC+iz2iCSm6dFXdaw4x7wPO7aXrZz0Emw64AEF0ukvv6NvXrvIQQJYPcOivufvsvrJ4MFz8J7Yf6fXbTlu9k5c6jPH5lCypGhft9fkKI4k8CTXH291fwfy9Dx5Fw0UN+n93Rkym8PHsjXRpU5uqOdfKeQAghkEBTfG2ZDzP/A40uhqve9Nu7Mr7+N3cTR0+mSAUAIUSBSKApjvatg6k3QtXmMOQLCPX/Lay1u7x8/dd2bujegFa1K/p9fkKIkkMCTXFzbA98PcS8IzNiKkT5/6CfYTcBULlsBA9c1tzv8xNClCwSaIqT5OMwcTAkHYXrp4IjMN/H+/bvXazYcZRHr2iBo4xUABBCFIxUby4u0tPMp2X2rTdBpla7gMzWm5iK+6cNdKxfies6BeXDr0KIYq5IBxpnTGwUsACIxJR1usftesZn/NvATR63q7zdf0aDQR63y2OPO63BII/bNSeAi3JutIYfH4LNc6H/W9D00oDN+o2fN3HoRAoTxnQjJEQqAAghCq6o3zpLBi7xuF3tgQ5AP2dMbHcAZ0xsF6BylvRjgSMet+u0BoOcMbFnNBjkjIn139cmC9uit2D5Z3DBA9B5dMBmu2HPMb7408OI8+rTpo4jYPMVQpQsRTrQeNwu7XG7EuzecPtP20HiVeCRLJMMBD63u6cDfZwxsacaDPK4Xcket2sb4NtgUKHYcehkYWb3r7XfwLxnoM21cMlT/plHNrQ2FQAcZcJ5SCoACCHOQZEONADOmNhQZ0zsSmA/8LPH7foL8wG5GR63a0+W5KcaDPK4XWmAb4NBWRsGOuONQ2dM7K3OmNhlzpjYZYdPpOS7jNOXx9Pn9d/4Y8vB/C9Yfmz/E767HeqfD4M+gJDAba7vV+5iqecIj/ZrQaWyEQGbrxCi5CnygcbjdqV73K4OmDYWujljYi8CBgPv+GFe4zxuVxeP29WlSrn8H1z7tqqBM7oct3+5nLj9CXlPkB8HN8Pk4VCpAQz7GsIiCyfffDielMpLP/5D+3qVGNKlXt4TCCFELop8oMnkcbuOAvOBi4EmQJwzJtYDlHXGxMbZyU41DOSMic1vg0HnzFEmnE9HdyUiLIQxE5ZwKCH53DJMOABfXwcqFEZMg7JVCqeg+fTmvM0cTEjmuQGtpQKAEOKcFelA44yJreaMia1kd5cB+gLLPW5XTY/b5fS4XU7gpP3wH/5tMAjsBoM8bpe2hw9zxsRGOmNiG/Jvg0GFpl6Vsnwyqiv7jyVzyxfLSEpNP7uMTh6GLwbC8X1w/RSo0rAwi5mnjXuPM+EPD8O61qN9vUoBnbcQomQq0oEGqAXMd8bErsa0TPezx+2alUv68UC0fYVzqsEgj9t1RoNBHrfrLCNBzjrUq8SbQzvw986jPDhtFRkZBWzrJ8lr2pU5FAfDJ0HdwDZrkVkBoEJUGA9f3iKg8xZClFzS8FkOzqXhs3ELtvDSj/9wZ+/GPNIvnwfs5AQTZHatMM9kml1+VvM+FzNW7ebeSX/zwqA2jOzeIODzF6LYk4bPslWkX9gsrm65sBGeQyd5/7ctNIguy9Cu9XOfIDURJg2D+GUw+LOgBJmE5DRejF1PmzoVGd4tj/IKIUQBSKDxA6UUzw1oTfyRRJ74bi11KpXlgqZVs0+clgxTRoJnIVwzDloNDGxhbe/8spl9x5L5YGRnQqUCgBCiEBX1ZzTFVlhoCO9d35Em1ctzx1fL2bTv+JmJ0lPN98vi5sGAt6HdkMAXFIjbf5zxC7cxpEtdOtXP+rEFIYQ4NxJo/KhCVDjjR3clKiKUMZ8t5cBxn2rPGenw3W3wzyy44lXodGNQyqi15pkZ6ygbEcqj+X2eJIQQBSCBxs/qVCrDp6O6cvhECjd/sYzElHTIyIAZ95jPy/R9Ds67NWjl+3HNXhbFHeKhy5sTXT5wL4UKIUoPCTQB0Laug7eGdWB1/FHun/w3+seHYOXX0Ptx6PmfoJXrRHIaL8Sup1Wtiow4T2qZCSH8QyoDBMhlrWvy5JUt0XMeR4X9BD3vg15ZvwkaWO/Oj2OPN4l3r+8oFQCEEH4jgSaAbkr5GhX2E5+lXU5EhTGMUME5uO8/lsTUZTv55PetXNupLp0bBPYTN0KI0kUCTaAseA31+2tkdBzFgkMjWDBjPXWrlKNXs2oBmX1GhmZh3EEm/rWDeRv2kZahuaBJVR6/UioACCH8SwJNIPz5Hvz6PLQbRkj/N3knNYPBH/7JXV+vYPodPWhRs6LfZn3geDLTlu9k8pKd7Dh8ksplwxnT08nwbvVpVK283+YrhBCZJND429LxMOdxaDUIBr4HISGUjwzh09FdGPTeIm76bCnf39WT6hWjCm2WGRmaP7ceYuJfO5i7fi+p6ZpuDavw4GXNuLx1TaLCi0/jokKI4k8CjT+tnAixD0CzK+CajyH039Vdy1GG8aO6MuSjPxn7+TKm3NadshHntjkOJSQzfXk8k5bswHPoJI4y4dzQ3cn159WjSfUK57o0QghxViTQ+Mvab+CHu6DRxTB4AoSd2ZBamzoO3hnekVu+WMZ/Jq/kw7P4/IvWmsVbDzNxyQ7mrN1LSnoGXRpU5t4+TbmybS25ehGiqLEc/YC3gFDgEyyvO8v4SOALoDOmPa2hWF6PPe4xYCyQDtyL5Z2Ta56W427gPqAxUA3LW8jNAOePBBp/2DALvrkF6veAYRMhPOfbYn1a1uCZ/q15ZsY6XvpxA09d1SpfszhyIoVvVsQzcckOth44QcWoMK4/rz7Xn1efZjXk6kWIIslyhALvYdrWigeWYjlmYHnX+6QaCxzB8jbBcgwDXgaGYjlaAcOA1kBtYB6Wo5k9TU55LgJmAb/5f+FyJoGmsG2eB9PHQO2OpuGyiLJ5TjLqfCeeQycYv3AbDaLLcmMPZ7bptNYs9Rxh4l/b+XHtXlLSMuhUvxKvDW6Pq20tykTI1YsQRVw3IA7LuxUAyzEZGIhpKyvTQMCyu6cD72I5lD18MpY3GdiG5Yiz8yPHPC3v3/Yw/y1RPkigKUzbFsCUEVCtBYz8BiLzf2XxpKsVOw+fxJqxjrqVy3BJixqnxnlPpp66eonbn0CFyDCGda3H8G71aVnLfzXWhBAFVhXLscynfxyWd5xPfx1gp09/PHBeljz+TWN507AcXiDaHr44y7R17O688gwqCTSFZcdfMHEYVG4IN3wPZSoVaPLQEMVbwzoydNyf3D3xb6be1oPktHS+/msHsav3kJyWQft6lXjl2nZc1b7WOVccEEL4xUFp+OxMcrQqDLtWwNfXQcVacOMPUC76rLIpFxnG+FFdGfTeIga9t4i0DE25iFCu61yX68+rT+vawb38FUKcs11APZ/+uvaw7NLEYznCAAemUkBu0+aVZ1BJoCkMGWlQuQEMnwIVauSdPhc1Kkbx2Ziu/G/uJi5pUZ0B7WtTLlI2kxAlxFKgKZajISYYDAOuz5JmBjAK+BO4DvgVy6uxHDOAiViO1zGVAZoCSwCVjzyDSr7eXBjqdYNbF4CjTt5p86FFzYp8fGMXhnerL0FGiJLE8qYBdwNzgA3AVCzvOizHc1iOAXaq8UC0/bD/ASDGnnYdMBVTcWA2cBeWNz3HPAEsx71YjnjMVc5qLMcngVnQ0ymtdTDmW+T1f2ehnnnPBcEuhhCiOLEcy+UZzZnkikYIIYRfSaARQgjhVxJohBBC+JUEGiGEEH4lgUYIIYRfSaARQgjhVxJohBBC+JW8R5ODyDotDqTs3rg9h9FOwBO40viNk5KxHFBylsWJLEdR4qQAy3FendAGi+PTqvmtNMWUBJqzoJQ6obUuF+xynKuSshxQcpZFlqNoKSnLEWxy60wIIYRfSaARQgjhVxJozs63wS5AISkpywElZ1lkOYqWkrIcQSXPaIQQQviVXNEIIYTwKwk0Qggh/EoCTQEppZ5QSqXYfz8Fuzy5UUptUkplKKWSfIY1Ukodsst/SCnltIcrpdRKe3iiUqrItNCnlOqmlDqilEpWSiUppb6xhxerZVFKOZRSCXaZkpRSv9nDL7SHpyildiilytnDK9j9Kfb4ItVAklIqXCl1Uim1z+4vdsuhlEqzt0WiUuqEPaxY7VfFgQSaAlBKhQMW0BeoDPRWSvUPaqFy9zYwMsuwScASrXUEphnYyfbwp4A6QCSmtb5xgSpkPiQDd2mtI4GGQH97vRe3ZTkGNNZal8HsP12UUmOBicB4ezmOAx/b6T8GjtvDx9vpipLpwH6f/uK6HO201mV83pcpbvtV0ae1lr98/gG3AAd9+mcDs4NdrjzKfAGQ5NOfArS3u9sDKXb3euCd7NIVtT9gD/BocV4WIBo4CdwEZACRWfcx4CBwi90daadTwS67XZ4uwGFMU8P7MO3WF8flSAOaZRlWbPerovonVzQF0xzzo8nkAWoHpyhnLVxrvcruXg2E293RmB9SpgSgXSALlh/2bZdqwFcUw2WxbzclYvaj1cBCIE1rnWwnWQWUt7vLA38D2OPTgaaBLXGOvgfuwQQNMOUqjsuhgZVKqRNKqS/tYcVuvyrqJNCUYtqclhWb+u1KqRrAHOB/WutdvuOKy7JorVO1uXXmxJy49AluiQpOKfUscFRr/XWwy1IIumutywJdgeuUUnf7jiwu+1VRJ4GmYDYCVX36ncDu4BTlrKUqpdoD2P/T7OGHgFY+6cpjzuaKBKVUGWAdME9r/ag9uFguC4DWejuwAnABYUqpSHtUe8yZMvb/jgD2+FBgc4CLmp2+QAulVBrwP6A65gSguC0HWuvl9v/1wF/A5RTj/aqokkBTMF8ADrt2TTmgF/B+kMtUUCsBt93txr6lAUwFhtk1a8Zi7kuvymb6gFNKKWAtsFNrPdBn1EqK0bIopVoopRrY3ZUxzzmWA7uAV+xk9wHz7O5f7H7s8bvsM+yg0lqfr7UO01qHAQ8C+7XWDSlmy6GUqqaUqpXZDXQCFlPM9qtiIdgPiYrbH/A05iFgKjA32OXJo6zbMffDNeas7DOgCeYhbgrmDK2RnVYBa+zlSgJuCHb5fZbjDnsZEn3+ni5uywJci6kAkGiX6xd7eC/MWX8KsBOoYA932P0p9vhewV6GbJbpPmBfcVwOu7yZ+1NS5u+5uO1XxeFPPkEjhBDCr+TWmRBCCL+SQCOEEMKvJNAIIYTwKwk0Qggh/EoCjRBCCL+SQCOEEMKvJNCIfFFKaaXUVz79YUqpA0qpWQXMx6OUqno2aZRS5ZVSHymltiilliulflNKnVeQ+RewrE6l1NqznHaAUirG7h6klGqV1zTZ5PGmUuqis5iut1Lq/IJOV8B5VFNKzfbnPETJIYFG5NcJoI39KRgwnyHZlUt6f/gE8yJdU611Z2AMp38SqMjQWs/QWme+XT6I0z9dkielVDTmO1wLzmL2vYFsA41SKuws8juD1voAsEcp1bMw8hMlmwQaURA/Yr7NBTAc024HAEqpKkqp75VSq5VSi5VS7ezh0UqpuUqpdUqpTzBvV2dOM1IptcRuTOojpVRoTjNWSjUGzgOe1FpnAGitt2mtY+3xDyil1tp/99nDnEqpf5RSE5RpBO5rpdSlSqlFSqnNSqludjpLKfWlUupPe/gt2cw/VCn1qlJqqb2Mt9nD71dKfWp3t7XnX1YpNVop9a59ZTEAeNVezsZKqRU++Tb17fdxLaYZisx0HqXUs0qpFUqpNUqpFjmsJydwO3C/Pb8L7eX/UCn1F/CKXYbZ9lXh75l52Vcp39jLuDQziCiletl5rVRK/a2UqmDP7ntgRE7bTIhTgv1pAvkrHn/8+0n06UAU5ntQvYFZ9vh3gGfs7kuAlXb328DTdrcL8ymZqkBLYCbmk+xgvhl3o93tAapmmf8A4LscytYZ82mQcpgPHa7DfMTRifn0TlvMSdVy4FNMsBsIfG9Pb2E+a1/GLttOTPMPTmCtneZWTJAD06bKMkwjbCHAAuBqe1hPO81o4F27ewJwnU955wMd7O6XgHuyWabPgf4+/Z7MdMCdwCe5bCsLeMinfwIwCwi1+3/BXBWCCd6/2t0TgQvs7vrABrt7ps9ylQfC7O46wJpg75vyV/T/CuUyWpQOWuvV9hnzcMzVja8LMGfhaK1/ta9kKgIXAdfYw2OVUkfs9H0wAWKpUgrMQX4/Z+cCTBDKbIr3W+BCYAawTWu9xh6+DvN9Ma2UWoMJJJl+0FonAolKqflAN0wwzXQZ0E4pdZ3d78AcrLcppUZjvuL7kdZ6UT7K+wkwRin1ADDUnldWtYADWYZ9a/9fjr1OC2Ca1jpdKVUec1ttmr3ewQROgEuBVj7DK9rpFwGvK6W+Br7VWsfb4/dT/NpjEkEggUYU1AzgNczVTPQ55KOAz7XWj+Uz/TqgvVIqVGudXoD5JPt0Z/j0Z3D6/p/1o39Z+xXmimJONvNoirniy+9B9xvgGeBXYLnW+lA2aRIxV46+MsueTsF/uyfs/yGYtmQ6ZJMmBPNcKCnLcLdSKha4EliklLpca/2PXb7EApZDlELyjEYU1KfAs5lXCT5+x75fr5TqjWnG9xjmttL19vArgMp2+l8wDU1Vt8dVUfYn9LOjtd6CuTX1rLJPue1nMC573oPsZyPlMLexfi/gcg1USkXZD+F7A0uzjJ8D3KGUCrfn3UwpVU4p5cDcHrwIiPa54vF1HMh8roF9IJ8DfID5onZ2NmC+Inw2TpufL3ubbFNKDbaXQym77RVgLqbVTOxxHez/jbXWa7TWL2PWS+bzoWaY5huEyJUEGlEgWut4rfXb2YyygM5KqdWYNjxG2cOfBS6yb1tdA+yw81kPPAnMtaf5GXO7KDc3AzWAOGWqHU/AtIWywu5egmm86hOt9d85ZZKD1ZhnJ4uB57XWWRu0+wTTjO8Ke94fYa4q3gDe01pvAsZizv6rZ5l2MvCw/SC9sT3sa8xV1dwcyhOLCXhnYyZwdWZlgGzGjwDGKqVWYa4UM9v4uRfoYld2WI+pVABwn13JYTXmE/k/2cMvtsspRK6kmQBR6imlLCBBa/1aAOf5EODQWj+VS5qFwFVa66OBKldBKKUWAAO11kfyTCxKNXlGI0SAKaW+Axpjaufl5kFM7a+j/i5TQSnTIuXrEmREfsgVjRDFlFJqDPCfLIMXaa3vCkZ5hMiJBBohhBB+JZUBhBBC+JUEGiGEEH4lgUYIIYRfSaARQgjhV/8Pg7Q4HiQwOb0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for conf in configurations:\n",
    "    prediction_performances, prediction_times, complexities = \\\n",
    "        benchmark_influence(conf)\n",
    "    plot_influence(conf, prediction_performances, prediction_times,\n",
    "                   complexities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tips - Linear Algebra\n",
    "\n",
    "- Make sure your version of NumPy is built using an optimized version of [BLAS](https://en.wikipedia.org/wiki/Basic_Linear_Algebra_Subprograms) / [LAPACK](https://en.wikipedia.org/wiki/LAPACK).\n",
    "\n",
    "- Not all models benefit from BLAS & LAPACK, for example randomized decision trees or SVMs. However, a linear model built with a `BLAS DGEMM` call (via `numpy.dot`) is a huge improvement.\n",
    "\n",
    "- Optimized BLAS/LAPACK implementations:\n",
    "    - ATLAS (requires hardware-specific tuning)\n",
    "    - OpenBLAS\n",
    "    - MKL\n",
    "    - Apple Accelerate & vecLib (MacOS)\n",
    "\n",
    "\n",
    "- [libblas & liblapack installation notes](https://danielnouri.org/notes/2012/12/19/libblas-and-liblapack-issues-and-speed,-with-scipy-and-ubuntu/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/bjpcjp/.local/lib/python3.8/site-packages/numpy/distutils/system_info.py:1914: UserWarning: \n",
      "    Optimized (vendor) Blas libraries are not found.\n",
      "    Falls back to netlib Blas library which has worse performance.\n",
      "    A better performance should be easily gained by switching\n",
      "    Blas library.\n",
      "  if self._calc_info(blas):\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BLAS:\t {'define_macros': [('NO_ATLAS_INFO', 1), ('HAVE_CBLAS', None)], 'libraries': ['blas', 'blas'], 'library_dirs': ['/home/bjpcjp/anaconda3/envs/working/lib'], 'include_dirs': ['/usr/local/include', '/usr/include', '/home/bjpcjp/anaconda3/envs/working/include'], 'language': 'c'}\n",
      "LAPACK:\t {'libraries': ['lapack', 'lapack', 'blas', 'blas'], 'library_dirs': ['/home/bjpcjp/anaconda3/envs/working/lib'], 'language': 'c', 'define_macros': [('NO_ATLAS_INFO', 1), ('HAVE_CBLAS', None)], 'include_dirs': ['/usr/local/include', '/usr/include', '/home/bjpcjp/anaconda3/envs/working/include']}\n"
     ]
    }
   ],
   "source": [
    "from numpy.distutils.system_info import get_info\n",
    "print(\"BLAS:\\t\",get_info('blas_opt'))\n",
    "print(\"LAPACK:\\t\",get_info('lapack_opt'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tips - Working Memory Limits\n",
    "\n",
    "- Some vectorized NumPy ops consume large amounts of temporary memory Consider limiting computation to fixed-size chunks where possible. \n",
    "\n",
    "- Working memory size can be accessed via `set_config` or `config_context`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`with sklearn.config_context(working_memory=1024):\n",
    "    pass <code goes here>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tips - Model Compression\n",
    "\n",
    "- Only applies to linear models, for now, in Scikit-learn.\n",
    "- Whenever possible - combine model sparsity with sparse input data formats, eg `clf.fit(X_train,y_train).sparsify()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tips - Model Reshaping\n",
    "\n",
    "- Model reshaping implies selecting a portion of the available features to fit a model. If a model discards features during the learning phase we can strip them from the input. \n",
    "\n",
    "- It reduces memory (and therefore time) overhead of the model itself. It also allows us to discard explicit feature selection components in a pipeline once we know which features to keep from a previous run. Finally, it can reduce processing time and I/O usage upstream in the data access and feature extraction layers by not collecting features that are discarded by the model. \n",
    "\n",
    "- If raw data comes from a database, write simpler and queries or reduce I/O usage by making the queries return lighter records. \n",
    "\n",
    "- Currently scikit-learn reshaping is manual. In the case of sparse input (particularly in CSR format), it is generally sufficient to not generate the relevant features, leaving their columns empty."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Example: measure prediction latency, various estimators, bulk vs atomic mode](https://scikit-learn.org/stable/auto_examples/applications/plot_prediction_latency.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "import time\n",
    "import gc\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.datasets import make_regression\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.linear_model import Ridge\n",
    "from sklearn.linear_model import SGDRegressor\n",
    "from sklearn.svm import SVR\n",
    "from sklearn.utils import shuffle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _not_in_sphinx():\n",
    "    # Hack to detect whether we are running by the sphinx builder\n",
    "    return '__file__' in globals()\n",
    "\n",
    "\n",
    "def atomic_benchmark_estimator(estimator, X_test, verbose=False):\n",
    "    \"\"\"Measure runtime prediction of each instance.\"\"\"\n",
    "    n_instances = X_test.shape[0]\n",
    "    runtimes = np.zeros(n_instances, dtype=float)\n",
    "    for i in range(n_instances):\n",
    "        instance = X_test[[i], :]\n",
    "        start = time.time()\n",
    "        estimator.predict(instance)\n",
    "        runtimes[i] = time.time() - start\n",
    "    if verbose:\n",
    "        print(\"atomic_benchmark runtimes:\", min(runtimes), np.percentile(\n",
    "            runtimes, 50), max(runtimes))\n",
    "    return runtimes\n",
    "\n",
    "\n",
    "def bulk_benchmark_estimator(estimator, X_test, n_bulk_repeats, verbose):\n",
    "    \"\"\"Measure runtime prediction of the whole input.\"\"\"\n",
    "    n_instances = X_test.shape[0]\n",
    "    runtimes = np.zeros(n_bulk_repeats, dtype=float)\n",
    "    for i in range(n_bulk_repeats):\n",
    "        start = time.time()\n",
    "        estimator.predict(X_test)\n",
    "        runtimes[i] = time.time() - start\n",
    "    runtimes = np.array(list(map(lambda x: x / float(n_instances), runtimes)))\n",
    "    if verbose:\n",
    "        print(\"bulk_benchmark runtimes:\", min(runtimes), np.percentile(\n",
    "            runtimes, 50), max(runtimes))\n",
    "    return runtimes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Benchmarking SGDRegressor(alpha=0.01, l1_ratio=0.25, penalty='elasticnet', tol=0.0001)\n",
      "Benchmarking RandomForestRegressor()\n",
      "Benchmarking SVR()\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "benchmarking with 100 features\n",
      "benchmarking with 250 features\n",
      "benchmarking with 500 features\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAo0AAAGBCAYAAAADh4urAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAA1gklEQVR4nO3dd7gkVZn48e/LECXjjCySBhVRUBhhRPyJipiQVTGHVQFFEV1XMS3oqgTzqqsigqKygAEwIKAiMJKVOEMOIrMEAYecEQnD+/vjnJ6pae+91TNz+96eud/P8/Rzq05VV71d91TX2xXOicxEkiRJGsky4x2AJEmSBp9JoyRJklqZNEqSJKmVSaMkSZJamTRKkiSplUmjJEmSWpk0aqkREYdFxBfq8Asj4upFXM73IuKzoxtd6zqnRkRGxLJjud5hYtkuIm4ax/WvHRFnRsT9EfGNPix/gW0dEb+PiF0a078QEXdExC11/PURcWNEPBARzxnteAbFeNT7fomI90fEt8ZhvStFxG8i4t6I+MVYr3+0RMQ3IuID4x2HBo9Jo8ZURFwfEQ/VA/CtNdFbZbTXk5lnZeYmPcSza0T8seu9e2Tm50cznnpAfqC+HomIRxvjvx/NdQ2yobb3EHYH7gBWy8yP9zumzHxVZh5e49sA+DiwaWb+S53l68CHMnOVzLyo3/E0RcTpEfHePix3TOp9Y30ZEU/rx7KHWNfywGeArzXKDomIqyPi8YjYdYj3fDQibomI+yLi0IhYoTFtakScFhF/j4g/R8TLRlj9m4C1gSdm5psX83PsGxE/WZxlLIavA5+u21Kax6RR4+E1mbkKsCUwnfIFv4BBOOM2muoBeZX6ub8EHN0Zz8xXLezylrbt02VD4MpchJ4HRmG7bADcmZm3dcVzxaIsbCn/P42JRdiGOwF/zsybG2WXAB8ELhxi+a8E9gZeSvlfPwXYrzHLkcBFwBOB/wJ+GRFThln3hsBfMvOxhYx51C1O3cvMOcCfgdeOXkRaKmSmL19j9gKuB17WGP8a8Ns6nMC/A9cA19WyVwMXA/cAZwObN977HMpB4H7gaOAo4At12nbATY151weOAW4H7gQOBJ4J/AOYCzwA3FPnPayznDr+PmA2cBdwPPDkxrQE9qgx3wN8F4iWbbAv8JOusql1WbsAf6Wcafuvrvf8EvgJcB/wXuDJNZ67anzva8zf/Rm6t8eWlAPh/cAv6vZbYNtRzrjdBswB3t217O8BM+r7zwA27PocyzbmP73GO+T27toOhwGPAo/UeV4GrAB8C/hbfX0LWKEr1r2AW4AfD7HMSZQzJ3cA11Lq2LwYG/G9DHgIeLyu+8j6N4EHgf+r8z8Z+BWlLl0HfLjl/7Q68KO6HW8GvgBMqvPvCvyxxnd3Xd6r6rQv1m31jxrHgcPUp20o+8Y9lORou8a0Xetnvr8u+x3D/R9o1JnGdv1P5teB1wE7An+h1LlPN9azNXBOjWEOZf9avk47s7ENHwDe2uN+Ne+7AAjgmzWW+4DLgGcNsz0OBT4zzLQ/Art2lf0M+FJj/KXALXX46cDDwKqN6WcBewyx7P0o9fbR+jl3q+XvAa6q/9+TqPtKnfZt4Mb6mWYBL6zlO3Qt65Jhvj/3pX6XMH/f243yHXLmSOtv26aUBPl/+3Ec8LXkvsY9AF8T69X80qMkclcAn6/jSUlE1gJWoiSFtwHPoxz4d6nvXwFYHrgB+CiwHOWy0KMMkTTW915SvyBXBlYEtq3TdgX+2BXjYY3lbE9JNras6/1O58u4EfNvgTUoZ6luB3Zo2QbzvugbZZ0v/B/Uz74F5WD1zMZ7HqUcuJep85wJHFQ/z7S67u27P8MQ26Oz7T5St90bKAeo5rZ7DNi/Tt8R+DuwZmPZ9wMvqtvk251tyAhJ43Dbe4jt0x37/sC5wJOAKZQE6fNdsX61xrLSEMvbg3LWZH1K3TqNIZLG7u3U9T9+Wh1ehnJw/1zdjk+hJGWvHOH/9Gvg+5S69yTgfOD9je3xKCWBmgR8gJIYR3dsw2yrdSk/gnas63t5HZ9S13cfsEmddx1gsx7rfWe7fq7WgfdR6tfPgFWBzSgJ9kZ1/q0oyeuytQ5cBew51DZciP2q+V3wyrrd16AkO88E1hlmm1wAvHmYaUMljZdQE9k6Prmu/4nA64GruuY/EPhOL/s25azn7BrvspSrKmc3pr+zrmdZyo+0W4AVR/ieuJ72pPGI+r9faaT1t21TyvfChaPxve9r6Xl5eVrj4diIuIfyBX4G5XJtx5cz867MfIhyb9v3M/O8zJyb5b6zhykHp20oB7NvZeajmflLysFiKFtTzg59MjMfzMx/ZGbbfXUd7wAOzcwLM/Nh4FPA8yNiamOer2TmPZn5V0pCMq3HZQ9lv8x8KDMvoRzMtmhMOyczj83MxykHthcAe9XPczHwQ2DnHtbRObgfULfdMZREpulRYP86/QTK2Y7mPaK/y8wz6zb5L8o2WX/hP25P3lFjuS0zb6ec0XlXY/rjwD6Z+XCtN93eQqknN2bmXcCXFyOW5wJTMnP/zHwkM6+lJPpva8zT/D+tRkno9qx17zbKj5fm/Ddk5g8ycy5wOCW5W7vHeN4JnJCZJ2Tm45k5A5hZ1wll2zwrIlbKzDmZuTCX2R8FvpiZj1LO4k8Gvp2Z99flXEmtn5k5KzPPzczHMvN6SpL84hGW3ct+1fwueJSSrD6DklBfleUS6lDWoPyo6dUqwL2N8c7wqkNM60xftcdl70H5HFdluWT9JWBaRGwIkJk/ycw763b7BiWBbr0Xu8W+ta491LL+tm16P2VbSvOYNGo8vC4z18jMDTPzg10H+hsbwxsCH4+IezovytmiJ9fXzZmZjflvGGZ961MOzItyn9GTm8vNzAcoZ3LWbcxzS2P475QDzaIaaVnNbfNk4K7MbB4cb+iKazhDbbsbu+a5s2t7DRtL3SZ31eX2wwL/gzrcXNftmfmPlvc3P99w9aQXGwJP7qqTn2bBJK+7Di8HzGnM/33KGceOef/zzPx7Hey1Dm0IvLkrnm0pZ4weBN5KSRzmRMTvIuIZPS4XSh2YW4c7++itjekPdeKMiKdHxG87D5NQkpPJIyy7l/2qWcdOpZzh+y5wW32wZbVhln03vSd1UH4QNZfVGb5/iGmd6b0mpRsC3278b+6inNVbFyAiPhERV9Wnre+h3Mow0nbrRXf9G3L9PWzTVSm3G0jzmDRq0HQnMl+sCWbn9YTMPJJy39S6ERGN+TcYZpk3AhsMc2N4DlHW9DfKFy8AEbEy5XLSzcO+o3+asf4NWCsimgfHDZgf14PAExrT/qUxPNS2W9izhPPmr0+/r1VjerAWD7futu09lAX+B5TP+beFWOYcFvx8w9WTXtxIud+2WSdXzcwdG/N01+GHgcmN+VfLzM16XF/bZ7uRch9nM56VM/MrAJl5Uma+nHL28s+Us6K9LHdhHVyXv3FmrkZJpGOE+XvZrxaIMTMPyMytgE0p9xp+cphlX1qn9+oKFjyjvwVwa2beWac9pWs/24LeH4y6kXIrQvP/s1Jmnh0RL6TcM/oWyq0fa1DOYna221D/o5H2647u+jfk+qF1mz6TcrVDmsekUYPsB8AeEfG8KFaOiH+tX+DnUO65+nBELBcRb6Bchh7K+ZTE4St1GStGxAvqtFuB9UZoWuJI4N0RMa02w/El4Lx6CW7cZOaNlHv7vlw/z+aUG+A7TXRcDOwYEWtFxL8Aezbefg7lIYgPRcSyEbETw2+74ewYEdvW7fZ54Nx6+fd2yoH/nRExKSLeAzy18b627T2UI4HPRMSUiJhMuc9uYZoi+TmlnqwXEWtSnpRdVOcD90fEXlHa5JsUEc+KiOcONXO93Hcy8I2IWC0ilomIp0bESJdum26l3Dc5nJ8Ar4mIV9ZYVozSzuZ6Udq73KkmZA9Tzpo93ljuwv4fRrIq5f7JB+rZzO42/ro/x0LtVxHx3Po9sBwlcfpH47N0O4GuS+MRsXxErEhJyJar26lz/DsC2C0iNo2INSj3/R0GkJl/oexL+9T3vB7YnPIgVC++B3wqIjarcaweEZ2meFalfIfdDiwbEZ9jwbOatwJTG3FSY3lb/c6bTrmXe5HW38M2fTEwYZoDU29MGjWwMnMm5Qb8AymXnGZTbuAnMx+h3Ki9K+WSy1spT0cPtZy5wGuAp1GeKrypzg9wKuWswS0RcccQ7/0D8FnKQWIOJQF6W/d84+TtlJvf/0Z52GKfGi/AjylnCa6nJC1Hd97U2Ha7US4/vZPyMM/DC7HunwH7ULb9VnUZHe+jnLG4k/LAxNmNaSNu72F8gXKf3qWUJzwvrGW9+gHlqdFL6nuHrCe9qHXp1ZT7Vq+jPMzxQ8plxeHsTHlo5kpKPf4l5cxfL74NvCki7o6IA4aI50bKww6fpiQfN1K2/TL19TFK/biLkgR0krlF+T+M5BPAv1Eu2/6ARn2r9gUOr5dJ37II+9Vqdbl3Uy5r30mjHcYuvwGeERHNWxhOplxO/3/AIXX4RQCZeSLw35T7kf9al79P471vozQNdjfwFeBN9cdRq8z8NeUhraPqZfvLgU4TWycBJ1KeRr+BkrQ1Ly13Gge/MyI6TQV9lrKt7qbc2/uzxVj/sNs0ItahnH08tpfPqYmj84SepAksIs4DvpeZ/9vDvIdRnjD+p/Y1pUEQEbtTGmjfc7xjWRJF6Ynp/zLzoPGORYPFhmelCaheHr2acqbsHZRLbieOa1DSKMnMQ8Y7hiVZjkFPTFoymTRKE9MmlHv9Vqa0M/imEZowkSTJy9OSJElq54MwkiRJamXSKEmSpFYT7p7GyZMn59SpU8c7DEmSpFazZs26IzOnjHccMAGTxqlTpzJz5szxDkOSJKlVRCxO16ejysvTkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWy453AEuliPGOQEPJHO8IJElaYnmmUZIkSa1MGiVJktTKpFGSJEmtTBolSZLUqm9JY0SsHxGnRcSVEXFFRHyklq8VETMi4pr6d81aHhFxQETMjohLI2LLxrJ2qfNfExG7NMq3iojL6nsOiPAJFEmSpH7o55nGx4CPZ+amwDbAv0fEpsDewCmZuTFwSh0HeBWwcX3tDhwMJckE9gGeB2wN7NNJNOs872u8b4c+fh5JkqQJq29JY2bOycwL6/D9wFXAusBOwOF1tsOB19XhnYAjsjgXWCMi1gFeCczIzLsy825gBrBDnbZaZp6bmQkc0ViWJEmSRtGY3NMYEVOB5wDnAWtn5pw66RZg7Tq8LnBj42031bKRym8aolySJEmjrO9JY0SsAvwK2DMz72tOq2cI+97ickTsHhEzI2Lm7bff3u/VSZIkLXX6mjRGxHKUhPGnmXlMLb61Xlqm/r2tlt8MrN94+3q1bKTy9YYo/yeZeUhmTs/M6VOmTFm8DyVJkjQB9fPp6QB+BFyVmf/TmHQ80HkCehfguEb5zvUp6m2Ae+tl7JOAV0TEmvUBmFcAJ9Vp90XENnVdOzeWJUmSpFHUz76nXwC8C7gsIi6uZZ8GvgL8PCJ2A24A3lKnnQDsCMwG/g68GyAz74qIzwMX1Pn2z8y76vAHgcOAlYDf15ckSZJGWZTbCieO6dOn58yZM/u7EpuLHEwTrK5LkpZ8ETErM6ePdxxgjzCSJEnqgUmjJEmSWpk0SpIkqZVJoyRJklqZNEqSJKmVSaMkSZJamTRKkiSplUmjJEmSWpk0SpIkqZVJoyRJklqZNEqSJKmVSaMkSZJamTRKkiSplUmjJEmSWpk0SpIkqZVJoyRJklqZNEqSJKmVSaMkSZJamTRKkiSplUmjJEmSWpk0SpIkqZVJoyRJklqZNEqSJKmVSaMkSZJaLds2Q0RMB14IPBl4CLgcmJGZd/c5NkmSJA2IYc80RsS7I+JC4FPASsDVwG3AtsAfIuLwiNhgbMKUJEnSeBrpTOMTgBdk5kNDTYyIacDGwF/7EJckSZIGyLBJY2Z+d6Q3ZubFox6NJEmSBlLrgzD1MvQajfE1I+LQvkYlSZKkgdLL09ObZ+Y9nZH6AMxz+haRJEmSBk4vSeMyEbFmZyQi1qKHp64lSZK09Ogl+fsGcE5E/KKOvxn4Yv9CkiRJ0qBpTRoz84iImAlsX4vekJlX9jcsSZIkDZJee4RZC3gwMw8Ebo+IjfoYkyRJkgZML09P7wPsRWnkG2A54Cf9DEqSJEmDpZczja8HXgs8CJCZfwNW7WdQkiRJGiy9JI2PZGYCCRARK/c3JEmSJA2aXpLGn0fE94E1IuJ9wB+AH/Q3LEmSJA2SXp6e/npEvBy4D9gE+Fxmzuh7ZJIkSRoYrUljvRx9ambOiIhNgE0iYrnMfLT/4UmSJGkQ9HJ5+kxghYhYFzgReBdwWD+DkiRJ0mDpJWmMzPw78Abg4Mx8M7BZf8OSJEnSIOkpaYyI5wPvAH5Xyyb1LyRJkiQNml6Sxj0pDXv/OjOviIinAKf1NSpJkiQNlGEfhImITwEnZuYZwBmd8sy8FvjwGMQmSZKkATHS09PXAh+JiC2AS4DfAydn5t1jEpkkSZIGxrBJY2YeDRwNEBHPAXYAjomISZQGvk/MzPPHJEpJkiSNq9Z2GgEy8yLgIuDLEbEa8HLgvYBJoyRJ0gTQ+iBMRLw5Ilatw5+htNF4XWbu3ufYJEmSNCB6eXr6s5l5f0RsC7wM+BFwcH/DkiRJ0iDpJWmcW//+K3BIZv4OWL5/IUmSJGnQ9JI03hwR3wfeCpwQESv0+D5JkiQtJXpJ/t4CnAS8MjPvAdYCPtnPoCRJkjRYWpPG2u/0ccCDEbEBsBzw534HJkmSpMHR2uRORPwHsA9wK/B4LU5g8z7GJUmSpAHSSzuNHwE2ycw7+x2MJEmSBlMv9zTeCNzb70AkSZI0uHpJGq8FTo+IT0XExzqvtjdFxKERcVtEXN4o2zcibo6Ii+trx8a0T0XE7Ii4OiJe2SjfoZbNjoi9G+UbRcR5tfzoiLAZIEmSpD7pJWn8KzCD0jbjqo1Xm8Mo/VV3+2ZmTquvEwAiYlPgbcBm9T0HRcSk2s/1d4FXAZsCb6/zAny1LutpwN3Abj3EJEmSpEXQek9jZu4HEBGr1PEHellwZp4ZEVN7jGMn4KjMfBi4LiJmA1vXabMz89oaw1HAThFxFbA98G91nsOBfbGnGkmSpL7ope/pZ0XERcAVwBURMSsiNluMdX4oIi6tl6/XrGXrUu6d7Liplg1X/kTgnsx8rKtckiRJfdDL5elDgI9l5oaZuSHwceAHi7i+g4GnAtOAOcA3FnE5CyUido+ImREx8/bbbx+LVUqSJC1VekkaV87M0zojmXk6sPKirCwzb83MuZn5OCXx7FyCvhlYvzHrerVsuPI7gTUiYtmu8uHWe0hmTs/M6VOmTFmU0CVJkia0np6ejojPRsTU+voM5YnqhRYR6zRGXw90nqw+HnhbRKwQERsBGwPnAxcAG9cnpZenPCxzfGYmcBrwpvr+XSi91kiSJKkPemnc+z3AfsAxdfysWjaiiDgS2A6YHBE3UXqV2S4iplF6lLkeeD9AZl4RET8HrgQeA/49M+fW5XyI0vf1JODQzLyirmIv4KiI+AJwEfCjHj6LJEmSFkGUk3YTx/Tp03PmzJn9XUlEf5evRTPB6rokackXEbMyc/p4xwEjnGmMiG9l5p4R8RvKmcEFZOZr+xqZJEmSBsZIl6d/XP9+fSwCkSRJ0uAaNmnMzFl1cFpmfrs5LSI+ApzRz8AkSZI0OHp5enqXIcp2HeU4JEmSNMBGuqfx7ZRu+jaKiOMbk1YF7up3YJIkSRocI93TeDal15bJLNhzy/3Apf0MSpIkSYNlpHsabwBuiIh3AH/LzH8ARMRKlB5Yrh+TCCVJkjTuermn8efA443xucAv+hOOJEmSBlEvSeOymflIZ6QOL9+/kCRJkjRoekkab4+IeQ15R8ROwB39C0mSJEmDppe+p/cAfhoRBwIB3Ajs3NeoJEmSNFBak8bM/D9gm4hYpY4/0PeoJEmSNFBGaqfxnZn5k4j4WFc5AJn5P32OTZIkSQNipDONK9e/q45FIJIkSRpcI7XT+P36d7+xC0eSJEmDaKTL0weM9MbM/PDohyNJkqRBNFKTO7Pqa0VgS+Ca+pqG7TRKkiRNKCNdnj4cICI+AGybmY/V8e8BZ41NeJIkSRoEvTTuvSawWmN8lVomSZKkCaKXxr2/AlwUEadRGvd+EbBvP4OSJEnSYOmlce//jYjfA8+rRXtl5i39DUuSJEmDpPXydJTWvF8GbJGZxwHLR8TWfY9MkiRJA6OXexoPAp4PvL2O3w98t28RSZIkaeD0ck/j8zJzy4i4CCAz744Im9yRJEmaQHo50/hoREwCEiAipgCP9zUqSZIkDZReksYDgF8DT4qILwJ/BL7U16gkSZI0UEa8PB0RywDXAf8JvJTS5M7rMvOqMYhNkiRJA2LEpDEzH4+I72bmc4A/j1FMkiRJGjC9XJ4+JSLeWJvekSRJ0gTUS9L4fuAXwCMRcX993dfnuCRJkjRAeukRZtWxCESSJEmDq5d2GomINwDbUprdOSszj+1nUJIkSRosvXQjeBCwB3AZcDmwR0TYI4wkSdIE0suZxu2BZ2Zmp3Hvw4Er+hqVJEmSBkovD8LMBjZojK9fyyRJkjRB9HKmcVXgqog4n3JP49bAzIg4HiAzX9vH+CRJkjQAekkaP9f3KCRJkjTQhk0aIyKyOGOkefoTliRJkgbJSPc0nhYR/xERzfsZiYjlI2L7+kDMLv0NT5IkSYNgpMvTOwDvAY6MiI2Ae4CVKInmycC3MvOivkcoSZKkcTds0piZ/wAOAg6KiOWAycBDmXnPGMUmSZKkAdFTjzCZ+Sgwp8+xSJIkaUD10k6jJEmSJjiTRkmSJLXqpe/pr/ZSJkmSpKVXL2caXz5E2atGOxBJkiQNrpEa9/4A8EHgKRFxaWPSqsCf+h2YJEmSBsdIT0//DPg98GVg70b5/Zl5V1+jkiRJ0kAZqZ3Ge4F7I2KvrkmrRMQqmfnX/oYmSZKkQdFLO42/AxIIYEVgI+BqYLM+xiVJkqQB0po0Zuazm+MRsSXlXkdJkiRNEAvdTmNmXgg8rw+xSJIkaUC1nmmMiI81RpcBtgT+1reIJEmSNHB6uadx1cbwY5R7HH/Vn3AkSZI0iHq5p3E/gIhYrYzm/X2PSpIkSQOll24Ep0fEZcClwGURcUlETO9/aJIkSRoUvVyePhT4YGaeBRAR29ayzfsZmCRJkgZHL09Pz+0kjACZ+UfKvY0jiohDI+K2iLi8UbZWRMyIiGvq3zVreUTEARExOyIurc36dN6zS53/mojYpVG+VURcVt9zQERErx9akiRJC6eXpPGMiPh+RGwXES+OiIOA0yNiy2ZyN4TDgB26yvYGTsnMjYFTmN894auAjetrd+BgKEkmsA+liZ+tgX06iWad532N93WvS5IkSaOkl8vTW9S/+3SVP4fSU8z2Q70pM8+MiKldxTsB29Xhw4HTgb1q+RGZmcC5EbFGRKxT553R6es6ImYAO0TE6cBqmXluLT8CeB2lr2xJkiSNsl6enn7JKK5v7cycU4dvAdauw+sCNzbmu6mWjVR+0xDlQ4qI3SlnMNlggw0WI3xJkqSJqZfGvVcA3ghMbc6fmfsvzoozMyMiF2cZC7GuQ4BDAKZPnz4m65QkSVqa9HJP43GUy8ePAQ82Xovi1nrZmfr3tlp+M7B+Y771atlI5esNUS5JkqQ+6OWexvUyc7QeMjke2AX4Sv17XKP8QxFxFOWhl3szc05EnAR8qfHwyyuAT2XmXRFxX0RsA5wH7Ax8Z5RilCRJUpdeksazI+LZmXnZwiw4Io6kPMgyOSJuojxI8xXg5xGxG3AD8JY6+wnAjsBs4O/AuwFqcvh54II63/6dh2KAD1Ke0F6J8gCMD8FIkiT1SZQHloeYUHqBSUpiuTFwLfAwEJRbEpfIxr2nT5+eM2fO7O9KbDJyMA1T1yVJGlQRMSszB6InvpHONL56zKKQJEnD8lzE4JmI5yGGTRoz8waY18B2t/v7FpEkSZIGTi9PT18I3A78BbimDl8fERdGxFb9DE6SJEmDoZekcQawY2ZOzswnUrr8+y3lQZSD+hmcJEmSBkMvSeM2mXlSZyQzTwaeX7vwW6FvkUmSJGlg9NLkzpyI2As4qo6/ldJI9yTg8b5FJkmSpIHRy5nGf6P0uHJsfW1QyyYxv51FSZIkLcVazzRm5h3AfwwzefbohiNJkqRB1Jo0RsRplEa+F5CZ2/clIkmSJA2cXu5p/ERjeEXgjcBj/QlHkiRJg6iXy9Ozuor+FBHn9ykeSZIkDaBeLk83e4RZBtgKWL1vEUmSJGng9HJ5ehblnsagXJa+Dtitn0FJkiRpsPRyeXqjsQhEkiRJg6uXy9PLAR8AXlSLTge+n5mP9jEuSZIkDZBeLk8fDCzH/H6m31XL3tuvoCRJkjRYekkan5uZWzTGT42IS/oVkCRJkgZPL90Izo2Ip3ZGIuIpwNz+hSRJkqRB02vj3qdFxLWUJ6g3BN7d16gkSZI0UEZMGiNiErAFsDGwSS2+OjMf7ndgkiRJGhwjXp7OzLnA2zPz4cy8tL5MGCVJkiaYXi5P/ykiDgSOBh7sFGbmhX2LSpIkSQOll6RxWv27f6Msge1HPRpJkiQNpF56hHnJWAQiSZKkwdVLjzArAG8Epjbnz8z9h3uPJEmSli69XJ4+DrgXmAX4EIwkSdIE1EvSuF5m7tD3SCRJkjSweukR5uyIeHbfI5EkSdLAGvZMY0RcDjxe53l37RHmYUqvMJmZm49NiJIkSRpvI12eXpf5ze1IkiRpAhspabwuM28Ys0gkSZI0sEZKGp8UER8bbmJm/k8f4pEkSdIAGilpnASsQrmHUZIkSRPYSEnjHBvwliRJEozc5I5nGCVJkgSMnDS+dMyikCRJ0kAbNmnMzLvGMhBJkiQNrl56hJEkSdIEZ9IoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqNS5JY0RcHxGXRcTFETGzlq0VETMi4pr6d81aHhFxQETMjohLI2LLxnJ2qfNfExG7jMdnkSRJmgjG80zjSzJzWmZOr+N7A6dk5sbAKXUc4FXAxvW1O3AwlCQT2Ad4HrA1sE8n0ZQkSdLoGqTL0zsBh9fhw4HXNcqPyOJcYI2IWAd4JTAjM+/KzLuBGcAOYxyzJEnShDBeSWMCJ0fErIjYvZatnZlz6vAtwNp1eF3gxsZ7b6plw5VLkiRplC07TuvdNjNvjognATMi4s/NiZmZEZGjtbKamO4OsMEGG4zWYiVJkiaMcTnTmJk317+3Ab+m3JN4a73sTP17W539ZmD9xtvXq2XDlQ+1vkMyc3pmTp8yZcpofhRJkqQJYcyTxohYOSJW7QwDrwAuB44HOk9A7wIcV4ePB3auT1FvA9xbL2OfBLwiItasD8C8opZJkiRplI3H5em1gV9HRGf9P8vMEyPiAuDnEbEbcAPwljr/CcCOwGzg78C7ATLzroj4PHBBnW//zLxr7D6GJEnSxBGZo3br4BJh+vTpOXPmzP6upCTEGjQTrK5LWnp4WBk8Y3VIiYhZjeYJx9UgNbkjSZKkAWXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWpl0ihJkqRWJo2SJElqZdIoSZKkViaNkiRJamXSKEmSpFYmjZIkSWq1xCeNEbFDRFwdEbMjYu/xjkeSJGlptEQnjRExCfgu8CpgU+DtEbHp+EYlSZK09Fl2vANYTFsDszPzWoCIOArYCbhyXKOS1JPYL8Y7BHXJfXK8Q5A0oJboM43AusCNjfGbapkkSZJG0ZJ+prEnEbE7sHsdfSAirh7PeDROIiYDd4x3GNIgi33dT6ReRDBW+8qGY7COnizpSePNwPqN8fVq2QIy8xDgkLEKSoMpImZm5vTxjkMaZO4nUm8m4r6ypF+evgDYOCI2iojlgbcBx49zTJIkSUudJfpMY2Y+FhEfAk4CJgGHZuYV4xyWJEnSUmeJThoBMvME4ITxjkNLBG9RkNq5n0i9mXD7SmTavIIkSZJGtqTf0yhJkqQxYNKoMRMRDwxRtkdE7DzGcZweEX+NiGiUHTtUfC3LOSwi3rS480gAETE3Ii6OiMsj4jcRscYoLXfXiDhwlJZ1fURcVuO8OCL+32gsd4j1TIuIHfuxbKlXEfFfEXFFRFxa6/s+EfHlrnmmRcRVdbizf1waEWdExMA0lTNaTBo1rjLze5l5RL+WH8VQ9fwe4AV1njWAdfoVg9SjhzJzWmY+C7gL+PfxDmgYL6lxTsvMs3t5Q0Qs7P3z0wCTRo2biHg+8Gpgy8zcHHgZcBrw1q5Z3wYc2Rh/SZ3/dOAzYxDqmDJp1LiKiH0j4hN1+PSI+GpEnB8Rf4mIF9bySRHxtYi4oP6Ce38tXyUiTomIC+uvu51q+dSIuDoijgAuZ8G2PDuOouzsAG8AjmnEFHV9l9flvrVRfmBd9h+AJzXes1X9ZTkrIk6KCJNQLY5zqL1bRcTWEXFORFwUEWdHxCa1fNeIOCYiToyIayLivztvjoh3133ofOqPo1o+NSJOrfvRKRGxQS0/LCIOjohzI+LaiNguIg6NiKsi4rCRAm1Z5vci4jzgvyPiqTXWWRFxVkQ8o8735rqvXRIRZ0ZpPm1/4K317E73QVoaC+sAd2TmwwCZeUdmngncHRHPa8z3FhZMGjvm7cNLlcz05WtMXsADQ5TtC3yiDp8OfKMO7wj8oQ7vDnymDq8AzAQ2ojz9v1otnwzMBgKYCjwObDNMHKcDzwMupTTVdHJ9zwN1+huBGXXa2sBfKV8gb2iUP5lytvJNwHLA2cCU+v63Upp/AjgMeNN4b3tfg/9q1L9JwC+AHer4asCydfhlwK/q8K7AtcDqwIrADZQfSOvUOjsFWB74E3Bgfc9vgF3q8HuAY+vwYZQfUgHsBNwHPJtyYmEWMK3Odz1wGXAxcF4Py/wtMKmOnwJsXIefB5xahy8D1q3DazQ+24Hj/T/xNXFfwCq1nv8FOAh4cS3/BPDNOrwNMLPxnuuByXX4W8Du4/05Rvu1xDe5o6VO54zfLEoiB/AKYPPGvYGrAxtT+hr/UkS8iJIkrktJ8gBuyMxzR1jPXOCPlLONK2Xm9TH/FsdtgSMzcy5wa0ScATwXeFGj/G8RcWqdfxPgWcCMuoxJwJxF+Oya2FaKiIsp9fgqyg8UKPX98IjYGEjKj5SOUzLzXoCIuJLS3dhk4PTMvL2WHw08vc7/fMqPH4AfA//dWNZvMjMj4jLg1sy8rL7/Csq+eHGd7yWZ2ew6baRl/iIz50bEKsD/A37R2M9WqH//BBwWET+nccZfGk+Z+UBEbAW8EHgJcHRE7A0cDZwdER/nny9NA5wWEWsBDwCfHcuYx4JJowbNw/XvXObXzwD+IzNPas4YEbtSzqZslZmPRsT1lDMuAA/2sK6jgF9TznYujgCuyMznL+ZyNLE9lJnTIuIJlA4L/h04APg8cFpmvj4iplLOlHc83Bhu7jOLorOsx7uW+/hiLLezHy4D3JOZ07pnyMw96uW+fwVm1QO1NO7qCYLTgdPrj6ldMvOwiLgOeDHlqlT39/5LKFehfgrsB3xszAIeA97TqCXBScAHImI5gIh4ekSsTDkDc1tNGF/CwnfqfhbwZf75l+JZlPupJkXEFMoZxvOBMxvl61C+HACuBqbUG6eJiOUiYrOF/5gSZObfgQ8DH4/yAMnqwM118q49LOI84MUR8cS6z7y5Me1s5t/L+w5KXV9crcvMzPuA6yLizTDv/uAt6vBTM/O8zPwccDvlEvv9wKqjEJu0SCJik3p2v2Ma5RYQKMeMbwLXZuZN3e/NzMeAPYGd61nHpYZJo8bSEyLipsar119gPwSuBC6MiMuB71POfPwUmF5/Ae4M/Hlhgsni612X2qCcfbwUuAQ4FfjPzLylll9TYzmCcqMzmfkI5d7Gr0bEJZTLeH1pikQTQ2ZeRKmDb6dc7v1yRFxED2f8MnMO5ez5OZRLv1c1Jv8H8O6IuBR4F/CRUQi312W+A9it7iNXUO6dBPhalAfOLqckoJdQnlLd1AdhNI5WodwWcmWt25sy/6rUL4DNGPoBGGDefngkg9sKwiKxRxhJkiS18kyjJEmSWpk0SpIkqZVJoyRJklqZNE4wEbFS7blkUh0/MSLuiYjfds23UUScFxGzI+Lo2kuDukTpOeaK+ndK3WYXRcQLI+KEGKH/4FiMfrdrLxz/1jLP8rWHDZvWGiCLuw9GxAp1fHadPnUUYtqzNvXTGR+x7i7EcketD2nr85JtiHq/QUScHKXXoSs79bg+Wf/FKD0aXRURH26UH1Dr/aURseU4fpxW3ftUH5Y/LvuWSePE8x7gmNr+FMDXKE88dvsqpdX7pwF3A7uNUXyLpfOFNIZ2BzbPzE8CLwUuy8znZOZZmbljZt4z3Btz8frdngqMmDTWp7pP4Z/7StX4Wtx9cDfg7lr+zTrf4toTmHeAa6u7C2EaC9mH9HAHLuvzEq+73h8BfC0znwlsDdxWy3elNLv0jDrtqFr+KkqnDhtTvncPHqO4F1o9Du1JY5/qg2mMx7413l3S+BrbF6VJi6ldZdsBv22MB3AH87suez5w0hDL2hc4lNL46bXAhxvTPkbp9/lyYM9aNpXS/McPKE1unEzpjaV7uXtQmq25GLiO0rAxlJ5hzgEupDR5sEotv55y4LyQ0l7c2yldk10OfHWY7fBc5jfvcT6lTbgVgf+t772I0vMFlB5evgZcQGkG5f21/HhKg8oXA3tRum67vY6vxIJdSu3M/GZ8ftzYfp0uFJ8KnEjpCecsyhcmlK7YDqixXkvtkhA4F7i3ruujlOYfzq/jlzK/u7YtgBPGu975Gr19kNJu6fPr8LJ1vhhiPZ9s1Nn9atnKwO9qPbyccpD4MPBIrfedfe16Ss8yUylNWR1G6U7tp5SuDP9EaX5q6zr/1pR986L6+TahdGHY3CfeCqwFHFtjOpfyg6uzL/y4LvdI6/PS92rWe0rzNX8cZr7zgacNUf594O2N8auBdbrm+af63azPdXg6pcekZr07p9bn99Xy7Sjt8v6urud7wDJ12pDHF0oPMN+o6/5c9z7VmG8HSk9J/7TvM/wxrvt4tfp47VvjXpF8jd2L8iV+yxDl8yptHZ8MzG6Mrw9cPsT79q0VeYX6njspXZxtVXeWlSltXV0BPIdyAHqM+f3Y/hx45wjxLkdJoF5Tl38msHKdthfwuTp8PaUtRSh9Qnf63V2W0s7i64bYDtcCz63jq9V5P878PqOfUZezIsP0fV3HH2gsd1ca/eUy/8C7GeWA2/nSWqux/TpJ43D98h5G+fJYhvJFO3uY/9l3gHc0Pt9KdXgScPt41z1fo7cPUg5W6zWm/V+nbjXKXgEcQkk+l6H0Af0iSg8WP2jMt3qzrg5Rd6dS9tlmP9SHMr+P6mPr/CP1j93cJ74D7FOHtwcursP71mWv1JjP+ryUvLrrPfC6WiePofzQ+Brz+yi/E/gvyvfs7xvfi78Ftm0s4xRgetd6Wus3/5w0XkL5kT8ZuJFyDNkO+AfwlFrnZlDa4h32+ELp4vMtjXUvsE81ypety+gcyw4G3skwxziGP16Ny77l5emJZTKle6PR9LvMfDhLA9m3Ufp+3hb4dWY+mJkPUL4YXljnvy4zL67Dzf6lh/JtSvL0G0rH8JsCf4rSP+8uLNgDzNH173Op/e5maZX/p5SDZdMmwJzMvABKbxV13m2Bn9SyP1Na/3865QC8c13vecATKZdIerU95ZflHXXZdzUnxoL98l5M+UW9TmOWYzPz8cy8kvl9a3c7B/h0ROwFbJiZD9V1zQUeiQh71xgM/dgHh/KK+rqIctbiGZQ6exnw8oj4akS8MGu/1S2uy8zLMvNxyg/AU7IcZS5j/v67OqX+Xk65ZD5cj0jbUs56kJmnAk+MiNXqtOM79Rbr89Kmu94vSzkmfILynf0U5vd2tALwj8ycTrkqdehCrGdR6vdxmflQ/X4+jXLWHOD8zLy21rkjKXV3pOPLXOBXbSur7zsReE29XPyvwHEMf4wb7njVbUz2LZPGieUh5vfNPJI7gTUa9z+sx/xuzLotbN+3/zR/RKxfe364OCL2gHn9Sm9I6bsTypmNGZk5rb42zczmfZa99DW9qDp9X3fWvVFmnjyKy5/XL2/j9czG9OY2i6EWkJk/A15L+R+fEBHbNyavQPnVrPE3GvvgzZQzj517lFav8zcF8OVGfXpaZv4oM/8CbEk5uH4hIj7XQyzd/VA3+6juxNfpH/tZlCsDvXzGbvP2YevzUqe73t9EORN2bU2AjqXUy860Y+rwr4HN6/C8el/903FphPr9GPPzne66mcOMD1c+nH/k/Ps12xwFvIVyQmFmZt5P+zFucYzavmXSOIFk5t3ApIgY8Qu9nkU4jXI6HsovnuMWYlVnAa+LiCdE6SP69YzQx21m3tjYUb4XEVtRfoG+s57dgHKPxgsi4mkAEbFyRDx9iMWdT+l3d3K9GfntwBld81wNrBMRz63LWrUefM+idHVGXfYGdd7h+r7u1anAmyPiifX9C/RFmiP0yzuCBfrmjYinUPpBPYDyv9q8lj8RuCMzH12IeNUno7QPHl/HqdNPrfM3nQS8p57FJiLWjYgnRcSTgb9n5k8olwQ7B+rF7et5dYbuH7t7uc19bDtK3byve2HW56XLEPX+AsqPoil1fHtK96xQEsiX1OEXU27tgVLvd67fj9sA92bpqm+eEer39ZTbpqBcwm7aKSJWrHVruxobwNZRWjBYhnLP4B/p7fjSMdI+dUaN7X3Mf9BnuGPccMercdm3TBonnpMpp7EBiIizKPfMvTRKf9CvrJP2Aj4WEbMpl2N/1OsKMvNCyr1451Mu5/4wS1+6vfoQ5abe0+rZxx9m5u2Ug9GRUfoBPYdyya173XOAvSkH3EuAWZl5XNc8j1C+BL4TpR/cGZRfnwcBy0Tpy/poYNfMfJjh+77uSWZeAXwROKOu73+GmG24fnmHcykwNyIuiYiPUn61Xl4vazyL8mQilC/f3/Uaq8bE4u6DP6JceppNeeBs7+4V1DPhPwPOqfX5l5QDzLOB82s92Qf4Qn3LIcCJEXHaIn6m4frHPo0F+5DeF9iq7sNfYX7y2836vPSZV+/rGblPAKfU+hmUS9FQ6sUba/mXgffW8hMo9/bNrvN+cIh1DFe/9wO+HREzKVe4mi6l1NNzgc9n5t9q+QXAgZSHN6+j3HLVenxpGHafqp//t5Qnwn9by4Y8xo1wvBqXfcu+pyeYKG1bfTQzh2riQ0uZiDgG2LtettEAcB9cdNbnJdcg1vuI2JfyMOPXu8q3ozyk+OpxCGtc9LpveaZxgqlnAU+LsW/PUGMsSmPQx3qAHSzug4vG+rxks94ProXZtzzTKEmSpFaeaZQkSVIrk0ZJkiS1MmmUJElSK5NGSZIktTJplCRJUiuTRkmSJLX6/9Cac3l+unEvAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example run in 8.42s\n"
     ]
    }
   ],
   "source": [
    "def benchmark_estimator(estimator, X_test, n_bulk_repeats=30, verbose=False):\n",
    "    \"\"\"\n",
    "    Measure runtimes of prediction in both atomic and bulk mode.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    estimator : already trained estimator supporting `predict()`\n",
    "    X_test : test input\n",
    "    n_bulk_repeats : how many times to repeat when evaluating bulk mode\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    atomic_runtimes, bulk_runtimes : a pair of `np.array` which contain the\n",
    "    runtimes in seconds.\n",
    "\n",
    "    \"\"\"\n",
    "    atomic_runtimes = atomic_benchmark_estimator(estimator, X_test, verbose)\n",
    "    bulk_runtimes = bulk_benchmark_estimator(estimator, X_test, n_bulk_repeats,\n",
    "                                             verbose)\n",
    "    return atomic_runtimes, bulk_runtimes\n",
    "\n",
    "\n",
    "def generate_dataset(n_train, n_test, n_features, noise=0.1, verbose=False):\n",
    "    \"\"\"Generate a regression dataset with the given parameters.\"\"\"\n",
    "    if verbose:\n",
    "        print(\"generating dataset...\")\n",
    "\n",
    "    X, y, coef = make_regression(n_samples=n_train + n_test,\n",
    "                                 n_features=n_features, noise=noise, coef=True)\n",
    "\n",
    "    random_seed = 13\n",
    "    X_train, X_test, y_train, y_test = train_test_split(\n",
    "        X, y, train_size=n_train, test_size=n_test, random_state=random_seed)\n",
    "    X_train, y_train = shuffle(X_train, y_train, random_state=random_seed)\n",
    "\n",
    "    X_scaler = StandardScaler()\n",
    "    X_train = X_scaler.fit_transform(X_train)\n",
    "    X_test = X_scaler.transform(X_test)\n",
    "\n",
    "    y_scaler = StandardScaler()\n",
    "    y_train = y_scaler.fit_transform(y_train[:, None])[:, 0]\n",
    "    y_test = y_scaler.transform(y_test[:, None])[:, 0]\n",
    "\n",
    "    gc.collect()\n",
    "    if verbose:\n",
    "        print(\"ok\")\n",
    "    return X_train, y_train, X_test, y_test\n",
    "\n",
    "\n",
    "def boxplot_runtimes(runtimes, pred_type, configuration):\n",
    "    \"\"\"\n",
    "    Plot a new `Figure` with boxplots of prediction runtimes.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    runtimes : list of `np.array` of latencies in micro-seconds\n",
    "    cls_names : list of estimator class names that generated the runtimes\n",
    "    pred_type : 'bulk' or 'atomic'\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    fig, ax1 = plt.subplots(figsize=(10, 6))\n",
    "    bp = plt.boxplot(runtimes, )\n",
    "\n",
    "    cls_infos = ['%s\\n(%d %s)' % (estimator_conf['name'],\n",
    "                                  estimator_conf['complexity_computer'](\n",
    "                                      estimator_conf['instance']),\n",
    "                                  estimator_conf['complexity_label']) for\n",
    "                 estimator_conf in configuration['estimators']]\n",
    "    plt.setp(ax1, xticklabels=cls_infos)\n",
    "    plt.setp(bp['boxes'], color='black')\n",
    "    plt.setp(bp['whiskers'], color='black')\n",
    "    plt.setp(bp['fliers'], color='red', marker='+')\n",
    "\n",
    "    ax1.yaxis.grid(True, linestyle='-', which='major', color='lightgrey',\n",
    "                   alpha=0.5)\n",
    "\n",
    "    ax1.set_axisbelow(True)\n",
    "    ax1.set_title('Prediction Time per Instance - %s, %d feats.' % (\n",
    "        pred_type.capitalize(),\n",
    "        configuration['n_features']))\n",
    "    ax1.set_ylabel('Prediction Time (us)')\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def benchmark(configuration):\n",
    "    \"\"\"Run the whole benchmark.\"\"\"\n",
    "    X_train, y_train, X_test, y_test = generate_dataset(\n",
    "        configuration['n_train'], configuration['n_test'],\n",
    "        configuration['n_features'])\n",
    "\n",
    "    stats = {}\n",
    "    for estimator_conf in configuration['estimators']:\n",
    "        print(\"Benchmarking\", estimator_conf['instance'])\n",
    "        estimator_conf['instance'].fit(X_train, y_train)\n",
    "        gc.collect()\n",
    "        a, b = benchmark_estimator(estimator_conf['instance'], X_test)\n",
    "        stats[estimator_conf['name']] = {'atomic': a, 'bulk': b}\n",
    "\n",
    "    cls_names = [estimator_conf['name'] for estimator_conf in configuration[\n",
    "        'estimators']]\n",
    "    runtimes = [1e6 * stats[clf_name]['atomic'] for clf_name in cls_names]\n",
    "    boxplot_runtimes(runtimes, 'atomic', configuration)\n",
    "    runtimes = [1e6 * stats[clf_name]['bulk'] for clf_name in cls_names]\n",
    "    boxplot_runtimes(runtimes, 'bulk (%d)' % configuration['n_test'],\n",
    "                     configuration)\n",
    "\n",
    "\n",
    "def n_feature_influence(estimators, n_train, n_test, n_features, percentile):\n",
    "    \"\"\"\n",
    "    Estimate influence of the number of features on prediction time.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "\n",
    "    estimators : dict of (name (str), estimator) to benchmark\n",
    "    n_train : nber of training instances (int)\n",
    "    n_test : nber of testing instances (int)\n",
    "    n_features : list of feature-space dimensionality to test (int)\n",
    "    percentile : percentile at which to measure the speed (int [0-100])\n",
    "\n",
    "    Returns:\n",
    "    --------\n",
    "\n",
    "    percentiles : dict(estimator_name,\n",
    "                       dict(n_features, percentile_perf_in_us))\n",
    "\n",
    "    \"\"\"\n",
    "    percentiles = defaultdict(defaultdict)\n",
    "    for n in n_features:\n",
    "        print(\"benchmarking with %d features\" % n)\n",
    "        X_train, y_train, X_test, y_test = generate_dataset(n_train, n_test, n)\n",
    "        for cls_name, estimator in estimators.items():\n",
    "            estimator.fit(X_train, y_train)\n",
    "            gc.collect()\n",
    "            runtimes = bulk_benchmark_estimator(estimator, X_test, 30, False)\n",
    "            percentiles[cls_name][n] = 1e6 * np.percentile(runtimes,\n",
    "                                                           percentile)\n",
    "    return percentiles\n",
    "\n",
    "\n",
    "def plot_n_features_influence(percentiles, percentile):\n",
    "    fig, ax1 = plt.subplots(figsize=(10, 6))\n",
    "    colors = ['r', 'g', 'b']\n",
    "    for i, cls_name in enumerate(percentiles.keys()):\n",
    "        x = np.array(sorted([n for n in percentiles[cls_name].keys()]))\n",
    "        y = np.array([percentiles[cls_name][n] for n in x])\n",
    "        plt.plot(x, y, color=colors[i], )\n",
    "    ax1.yaxis.grid(True, linestyle='-', which='major', color='lightgrey',\n",
    "                   alpha=0.5)\n",
    "    ax1.set_axisbelow(True)\n",
    "    ax1.set_title('Evolution of Prediction Time with #Features')\n",
    "    ax1.set_xlabel('#Features')\n",
    "    ax1.set_ylabel('Prediction Time at %d%%-ile (us)' % percentile)\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def benchmark_throughputs(configuration, duration_secs=0.1):\n",
    "    \"\"\"benchmark throughput for different estimators.\"\"\"\n",
    "    X_train, y_train, X_test, y_test = generate_dataset(\n",
    "        configuration['n_train'], configuration['n_test'],\n",
    "        configuration['n_features'])\n",
    "    throughputs = dict()\n",
    "    for estimator_config in configuration['estimators']:\n",
    "        estimator_config['instance'].fit(X_train, y_train)\n",
    "        start_time = time.time()\n",
    "        n_predictions = 0\n",
    "        while (time.time() - start_time) < duration_secs:\n",
    "            estimator_config['instance'].predict(X_test[[0]])\n",
    "            n_predictions += 1\n",
    "        throughputs[estimator_config['name']] = n_predictions / duration_secs\n",
    "    return throughputs\n",
    "\n",
    "\n",
    "def plot_benchmark_throughput(throughputs, configuration):\n",
    "    fig, ax = plt.subplots(figsize=(10, 6))\n",
    "    colors = ['r', 'g', 'b']\n",
    "    cls_infos = ['%s\\n(%d %s)' % (estimator_conf['name'],\n",
    "                                  estimator_conf['complexity_computer'](\n",
    "                                      estimator_conf['instance']),\n",
    "                                  estimator_conf['complexity_label']) for\n",
    "                 estimator_conf in configuration['estimators']]\n",
    "    cls_values = [throughputs[estimator_conf['name']] for estimator_conf in\n",
    "                  configuration['estimators']]\n",
    "    plt.bar(range(len(throughputs)), cls_values, width=0.5, color=colors)\n",
    "    ax.set_xticks(np.linspace(0.25, len(throughputs) - 0.75, len(throughputs)))\n",
    "    ax.set_xticklabels(cls_infos, fontsize=10)\n",
    "    ymax = max(cls_values) * 1.2\n",
    "    ax.set_ylim((0, ymax))\n",
    "    ax.set_ylabel('Throughput (predictions/sec)')\n",
    "    ax.set_title('Prediction Throughput for different estimators (%d '\n",
    "                 'features)' % configuration['n_features'])\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "# #############################################################################\n",
    "# Main code\n",
    "\n",
    "start_time = time.time()\n",
    "\n",
    "# #############################################################################\n",
    "# Benchmark bulk/atomic prediction speed for various regressors\n",
    "configuration = {\n",
    "    'n_train': int(1e3),\n",
    "    'n_test': int(1e2),\n",
    "    'n_features': int(1e2),\n",
    "    'estimators': [\n",
    "        {'name': 'Linear Model',\n",
    "         'instance': SGDRegressor(penalty='elasticnet', alpha=0.01,\n",
    "                                  l1_ratio=0.25, tol=1e-4),\n",
    "         'complexity_label': 'non-zero coefficients',\n",
    "         'complexity_computer': lambda clf: np.count_nonzero(clf.coef_)},\n",
    "        {'name': 'RandomForest',\n",
    "         'instance': RandomForestRegressor(),\n",
    "         'complexity_label': 'estimators',\n",
    "         'complexity_computer': lambda clf: clf.n_estimators},\n",
    "        {'name': 'SVR',\n",
    "         'instance': SVR(kernel='rbf'),\n",
    "         'complexity_label': 'support vectors',\n",
    "         'complexity_computer': lambda clf: len(clf.support_vectors_)},\n",
    "    ]\n",
    "}\n",
    "benchmark(configuration)\n",
    "\n",
    "# benchmark n_features influence on prediction speed\n",
    "percentile = 90\n",
    "percentiles = n_feature_influence({'ridge': Ridge()},\n",
    "                                  configuration['n_train'],\n",
    "                                  configuration['n_test'],\n",
    "                                  [100, 250, 500], percentile)\n",
    "plot_n_features_influence(percentiles, percentile)\n",
    "\n",
    "# benchmark throughput\n",
    "throughputs = benchmark_throughputs(configuration)\n",
    "plot_benchmark_throughput(throughputs, configuration)\n",
    "\n",
    "stop_time = time.time()\n",
    "print(\"example run in %.2fs\" % (stop_time - start_time))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:working] *",
   "language": "python",
   "name": "conda-env-working-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}