stsievert · September 10, 2018 18:52
diff --git a/_Hyperband-example-test-patience.ipynb b/_Hyperband-example-test-patience.ipynb
 {
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prior work for default patience:\n",
    "\n",
    "* `torch.optim.ReduceLROnPlateau` default to `patience=10` epochs\n",
    "    * https://pytorch.org/docs/stable/optim.html#torch.optim.lr_scheduler.ReduceLROnPlateau\n",
    "* `keras.ReduceOnPlateau` defaults to `patience=10` epochs.\n",
    "    * https://github.com/tensorflow/tensorflow/blob/4dcfddc5d12018a5a0fdca652b9221ed95e9eb23/tensorflow/python/keras/callbacks.py#L891\n",
    "* MXNet defaults to `patience=10` epochs in their ReduceLROnPlateau\n",
    "    * https://github.com/awslabs/keras-apache-mxnet/blob/01d59d3f91ffb13d73cadc11db94a30e4b05c2f8/keras/callbacks.py#L991\n",
    "* \"Random Search for Hyper-Parameter Optimization\" says \"We permitted a minimum of 100 and a maximum of 1000 iterations over the training data, stopping if ever, at iteration $t$ , [if] the best validation performance was observed before iteration $t / 2$.\"\n",
    "    *  by Bengio et. al. http://www.jmlr.org/papers/volume13/bergstra12a/bergstra12a.pdf (mentioned in the sklearn docs at http://scikit-learn.org/stable/modules/grid_search.html#randomized-parameter-optimization)\n",
    "    \n",
    "An approach like the last seems ideal and similar to the doubling trick. But they have a minimum number of iterations; that's what we're trying to choose.\n",
    "\n",
    "I think a static patience parameter is best.\n",
    "\n",
    "I am inclined to have this in terms of epochs; I think there's some paper that says \"run for X epochs\" for convergence.\n",
    "\n",
    "It looks like we should default to 10; that's what everyone else is doing (including Facebook, Amazon and Google)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table style=\"border: 2px solid white;\">\n",
       "<tr>\n",
       "<td style=\"vertical-align: top; border: 0px solid white\">\n",
       "<h3>Client</h3>\n",
       "<ul>\n",
       "  <li><b>Scheduler: </b>tcp://dask-scheduler:8786\n",
       "  <li><b>Dashboard: </b><a href='http://dask-scheduler:8787/status' target='_blank'>http://dask-scheduler:8787/status</a>\n",
       "</ul>\n",
       "</td>\n",
       "<td style=\"vertical-align: top; border: 0px solid white\">\n",
       "<h3>Cluster</h3>\n",
       "<ul>\n",
       "  <li><b>Workers: </b>16</li>\n",
       "  <li><b>Cores: </b>32</li>\n",
       "  <li><b>Memory: </b>96.00 GB</li>\n",
       "</ul>\n",
       "</td>\n",
       "</tr>\n",
       "</table>"
      ],
      "text/plain": [
       "<Client: scheduler='tcp://10.52.111.5:8786' processes=16 cores=32>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import distributed\n",
    "from distributed import Client\n",
    "client = Client()\n",
    "client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'tcp://10.52.101.3:32807': 2,\n",
       " 'tcp://10.52.102.3:42949': 2,\n",
       " 'tcp://10.52.103.4:39683': 2,\n",
       " 'tcp://10.52.104.3:35883': 2,\n",
       " 'tcp://10.52.105.3:44301': 2,\n",
       " 'tcp://10.52.106.3:44269': 2,\n",
       " 'tcp://10.52.107.3:45867': 2,\n",
       " 'tcp://10.52.108.3:34393': 2,\n",
       " 'tcp://10.52.109.3:35189': 2,\n",
       " 'tcp://10.52.110.3:39023': 2,\n",
       " 'tcp://10.52.111.4:36131': 2,\n",
       " 'tcp://10.52.112.3:41667': 2,\n",
       " 'tcp://10.52.114.3:43839': 2,\n",
       " 'tcp://10.52.115.3:46805': 2,\n",
       " 'tcp://10.52.116.3:36847': 2,\n",
       " 'tcp://10.52.117.3:34885': 2}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.ncores()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import subprocess\n",
    "def debug_loop():\n",
    "    subprocess.call(\"pip install git+https://github.com/stsievert/dask-ml@hyperband-scale\".split(\" \"))\n",
    "    import dask_ml\n",
    "    return dask_ml.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 136 ms, sys: 21.6 ms, total: 157 ms\n",
      "Wall time: 3.26 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'0.4.2.dev395+g7b1cf92'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%time debug_loop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dask_ml.model_selection._successive_halving import _SHA\n",
    "#_SHA.fit??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 11.4 ms, sys: 2.42 ms, total: 13.9 ms\n",
      "Wall time: 3.67 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'tcp://10.52.101.3:32807': '0.4.2.dev395+g7b1cf92',\n",
       " 'tcp://10.52.102.3:42949': '0.4.2.dev395+g7b1cf92',\n",
       " 'tcp://10.52.103.4:39683': '0.4.2.dev395+g7b1cf92',\n",
       " 'tcp://10.52.104.3:35883': '0.4.2.dev395+g7b1cf92',\n",
       " 'tcp://10.52.105.3:44301': '0.4.2.dev395+g7b1cf92',\n",
       " 'tcp://10.52.106.3:44269': '0.4.2.dev395+g7b1cf92',\n",
       " 'tcp://10.52.107.3:45867': '0.4.2.dev395+g7b1cf92',\n",
       " 'tcp://10.52.108.3:34393': '0.4.2.dev395+g7b1cf92',\n",
       " 'tcp://10.52.109.3:35189': '0.4.2.dev395+g7b1cf92',\n",
       " 'tcp://10.52.110.3:39023': '0.4.2.dev395+g7b1cf92',\n",
       " 'tcp://10.52.111.4:36131': '0.4.2.dev395+g7b1cf92',\n",
       " 'tcp://10.52.112.3:41667': '0.4.2.dev395+g7b1cf92',\n",
       " 'tcp://10.52.114.3:43839': '0.4.2.dev395+g7b1cf92',\n",
       " 'tcp://10.52.115.3:46805': '0.4.2.dev395+g7b1cf92',\n",
       " 'tcp://10.52.116.3:36847': '0.4.2.dev395+g7b1cf92',\n",
       " 'tcp://10.52.117.3:34885': '0.4.2.dev395+g7b1cf92'}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%time client.run(debug_loop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3.5 ms, sys: 1.44 ms, total: 4.95 ms\n",
      "Wall time: 206 ms\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<table style=\"border: 2px solid white;\">\n",
       "<tr>\n",
       "<td style=\"vertical-align: top; border: 0px solid white\">\n",
       "<h3>Client</h3>\n",
       "<ul>\n",
       "  <li><b>Scheduler: </b>tcp://dask-scheduler:8786\n",
       "  <li><b>Dashboard: </b><a href='http://dask-scheduler:8787/status' target='_blank'>http://dask-scheduler:8787/status</a>\n",
       "</ul>\n",
       "</td>\n",
       "<td style=\"vertical-align: top; border: 0px solid white\">\n",
       "<h3>Cluster</h3>\n",
       "<ul>\n",
       "  <li><b>Workers: </b>16</li>\n",
       "  <li><b>Cores: </b>32</li>\n",
       "  <li><b>Memory: </b>96.00 GB</li>\n",
       "</ul>\n",
       "</td>\n",
       "</tr>\n",
       "</table>"
      ],
      "text/plain": [
       "<Client: scheduler='tcp://10.52.111.5:8786' processes=16 cores=32>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%time client.restart()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4.41 ms, sys: 3.43 ms, total: 7.85 ms\n",
      "Wall time: 985 ms\n"
     ]
    }
   ],
   "source": [
    "%time client.upload_file('autoencoder.py')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.4.2.dev395+g7b1cf92'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from dask_ml.model_selection._successive_halving import stop_on_plateau\n",
    "from dask_ml.model_selection import HyperbandCV\n",
    "import dask_ml\n",
    "dask_ml.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data\n",
    "See below for an image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import noisy_mnist\n",
    "_X, _y = noisy_mnist.dataset()#n=10 * 1024)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(dask.array<array, shape=(70000, 784), dtype=float32, chunksize=(35000, 784)>,\n",
       " dask.array<array, shape=(70000, 784), dtype=float32, chunksize=(35000, 784)>)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import dask.array as da\n",
    "n, d = _X.shape\n",
    "X = da.from_array(_X, chunks=(n // 2, d))\n",
    "y = da.from_array(_y, chunks=n // 2)\n",
    "X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x144 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "cols = 5\n",
    "w = 1.0\n",
    "fig, axs = plt.subplots(figsize=(cols*w, 2*w), ncols=cols, nrows=2)\n",
    "for col, (upper, lower) in enumerate(zip(axs[0], axs[1])):\n",
    "    if col == 0:\n",
    "        upper.text(-28, 14, 'ground\\ntruth')\n",
    "        lower.text(-28, 14, 'input')\n",
    "    i = np.random.choice(len(X))\n",
    "    noisy = X[i].reshape(28, 28)\n",
    "    clean = y[i].reshape(28, 28)\n",
    "    kwargs = {'cbar': False, 'xticklabels': False, 'yticklabels': False, 'cmap': 'gray'}\n",
    "    sns.heatmap(noisy, ax=lower, **kwargs)\n",
    "    sns.heatmap(clean, ax=upper, **kwargs)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I use a deep learning library (PyTorch) for this model, at least through the scikit-learn interface for PyTorch, [skorch].\n",
    "\n",
    "[skorch]:https://github.com/dnouri/skorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from autoencoder import Autoencoder, NegLossScore\n",
    "import torch\n",
    "\n",
    "model = NegLossScore(module=Autoencoder,\n",
    "                     criterion=torch.nn.BCELoss,\n",
    "                     warm_start=True,\n",
    "                     train_split=None,\n",
    "                     max_epochs=1,\n",
    "                     callbacks=[])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I don't show it here; I'd rather concentrate on tuning hyperparameters. But briefly, it's a simple fully connected 3 hidden layer autoencoder with a latent dimension of 49."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameters\n",
    "\n",
    "The parameters I am interested in tuning are\n",
    "\n",
    "* model\n",
    "    * initialization\n",
    "    * activation function\n",
    "    * weight decay (which is similar to $\\ell_2$ regularization)\n",
    "* optimizer\n",
    "    * which optimizer to use (e.g., Adam, SGD)\n",
    "    * batch size used to approximate gradient\n",
    "    * learning rate (but not for Adam)\n",
    "    * momentum for SGD\n",
    "    \n",
    "After looking at the results, I think I was too exploratory in my tuning of step size. I should have experimented with it more to determine a reasonable range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "params = {\n",
    "    'module__init': ['xavier_uniform_',\n",
    "                     'xavier_normal_',\n",
    "                     'kaiming_uniform_',\n",
    "                     'kaiming_normal_',\n",
    "                    ],\n",
    "    'module__activation': ['ReLU', 'LeakyReLU', 'ELU', 'PReLU'],\n",
    "    'optimizer': ['SGD'] * 5 + ['Adam'] * 2,\n",
    "    'batch_size': [32, 64, 128, 256, 512],\n",
    "    'optimizer__lr': np.logspace(1, -1.5, num=1000),\n",
    "    'optimizer__weight_decay': [0]*200 + np.logspace(-7, -3, num=1000).tolist(),\n",
    "    'optimizer__nesterov': [True],\n",
    "    'optimizer__momentum': np.linspace(0, 1, num=1000),\n",
    "    'train_split': [None],\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import ParameterSampler\n",
    "import torch\n",
    "\n",
    "def trim_params(**kwargs):\n",
    "    if kwargs['optimizer'] != 'Adam':\n",
    "        kwargs.pop('optimizer__amsgrad', None)\n",
    "    if kwargs['optimizer'] == 'Adam':\n",
    "        kwargs.pop('optimizer__lr', None)\n",
    "    if kwargs['optimizer'] != 'SGD':\n",
    "        kwargs.pop('optimizer__nesterov', None)\n",
    "        kwargs.pop('optimizer__momentum', None)\n",
    "    kwargs['optimizer'] = getattr(torch.optim, kwargs['optimizer'])\n",
    "    return kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # for debugging; ignore this cell\n",
    "# from sklearn.linear_model import SGDClassifier\n",
    "# from sklearn.datasets import make_classification\n",
    "# from sklearn.model_selection import ParameterSampler\n",
    "# import dask.array as da\n",
    "# import numpy as np\n",
    "# model = SGDClassifier()\n",
    "# params = {'alpha': np.logspace(-7, 0, num=int(1e6))}\n",
    "\n",
    "# n, d = int(10e3), 700\n",
    "# _X = np.random.rand(n, d)\n",
    "# _beta = np.random.rand(d)\n",
    "# _y = np.sign(_X @ _beta + d * 0.1 * np.random.randn(n))\n",
    "# X = da.from_array(_X, chunks=(n // 10, d))\n",
    "# y = da.from_array(_y, chunks=n // 10)\n",
    "# X, y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hyperparameter optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dask_ml.model_selection import train_test_split\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from dask_ml.model_selection import HyperbandCV\n",
    "\n",
    "def test_hyperband(model, params, X, y, max_iter=27, patience=np.inf, tol=1e-4):\n",
    "    fit_params = {}\n",
    "    if isinstance(model, SGDClassifier):\n",
    "        fit_params = {'classes': da.unique(y).compute()}\n",
    "        param_list = list(ParameterSampler(params, max_iter * 100))\n",
    "    else:\n",
    "        param_list = [trim_params(**param)\n",
    "                      for param in ParameterSampler(params, max_iter * 100)]\n",
    "        \n",
    "    search = HyperbandCV(model, param_list, max_iter, patience=patience)\n",
    "    search.fit(X, y, **fit_params)\n",
    "    \n",
    "    meta = {'max_iter': max_iter, 'patience': patience, 'tol': tol, \"alg\": \"hyperband\"}\n",
    "    [h.update(meta) for h in search.history_]\n",
    "    return search, search.history_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(X, y)\n",
    "max_iter = 243"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_history = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 0 -0.09480269998311996\n",
      "40 0 -0.09297627210617065\n",
      "243 0 -0.09296257048845291\n",
      "20 1 -0.09345395863056183\n",
      "40 1 -0.09191805869340897\n",
      "243 1 -0.09264714270830154\n"
     ]
    }
   ],
   "source": [
    "searches = []\n",
    "\n",
    "# [inf, 5, 10] epochs respectively\n",
    "# P = [max_iter, 20, 10]\n",
    "P = [20, 40, max_iter]\n",
    "# 10, 20, 40 and 121 epochs respectively\n",
    "for p in P:\n",
    "    all_history[f\"hyperband-p{p}\"] = []\n",
    "for _ in range(3):\n",
    "    for p in P:\n",
    "        search, hist = test_hyperband(model, params, X_train, y_train, max_iter=max_iter, patience=p)\n",
    "        if p == max_iter:\n",
    "            searches += [search]\n",
    "        all_history[f\"hyperband-p{p}\"] += [hist]\n",
    "        print(p, _, search.best_score_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualizing output of best estimator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "noisy_test = X_test.compute()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "search = searches[0]\n",
    "clean_hat = search.best_estimator_.predict(noisy_test)\n",
    "clean_hat.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "cols = 5\n",
    "w = 1.0\n",
    "fig, axs = plt.subplots(figsize=(cols*w, 3*w), ncols=cols, nrows=3)\n",
    "for col, (upper, middle, lower) in enumerate(zip(axs[0], axs[1], axs[2])):\n",
    "    if col == 0:\n",
    "        upper.text(-28, 14, 'ground\\ntruth')\n",
    "        middle.text(-28, 14, 'input')\n",
    "        lower.text(-28, 14, 'output')\n",
    "    i = np.random.choice(len(X_test))\n",
    "    noisy = X_test[i].reshape(28, 28)\n",
    "    clean = y_test[i].reshape(28, 28)\n",
    "    clean_hat_i = clean_hat[i].reshape(28, 28)\n",
    "    kwargs = {'cbar': False, 'xticklabels': False, 'yticklabels': False, 'cmap': 'gray'}\n",
    "    sns.heatmap(noisy, ax=middle, **kwargs)\n",
    "    sns.heatmap(clean, ax=upper, **kwargs)\n",
    "    sns.heatmap(clean_hat_i, ax=lower, **kwargs)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setting parameters for Hyperband\n",
    "Need to know two things:\n",
    "\n",
    "1. how many \"epochs\" or \"passes through data\" to train model\n",
    "2. how many configs to evaluate\n",
    "    * this is some measure of how complex the search space is\n",
    "    \n",
    "This determines\n",
    "\n",
    "* The `max_iter` argument for `HyperbandCV`\n",
    "* the chunks size for the array to pass in\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison with early stopping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dask_ml.model_selection._successive_halving import _HistoryRecorder, stop_on_plateau\n",
    "from dask_ml.model_selection._incremental import fit\n",
    "from dask_ml.model_selection import train_test_split\n",
    "from sklearn.model_selection import ParameterSampler\n",
    "import random\n",
    "\n",
    "def test_rand(model, params, X, y, max_iter, num_models, num_calls, patience=10, tol=1e-4):\n",
    "    rand_search = _HistoryRecorder(stop_on_plateau, patience=patience, tol=tol, max_iter=num_calls)\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.15)\n",
    "    \n",
    "    if isinstance(model, SGDClassifier):\n",
    "        rand_params = list(ParameterSampler(params, int(num_models)))\n",
    "        fit_params = {'classes': da.unique(y).compute()}\n",
    "    else:\n",
    "        rand_params = [trim_params(**param)\n",
    "                      for param in ParameterSampler(params, int(num_models))]\n",
    "        fit_params = {}\n",
    "\n",
    "    _ = fit(\n",
    "        model,\n",
    "        rand_params,\n",
    "        X_train,\n",
    "        y_train,\n",
    "        X_test,\n",
    "        y_test,\n",
    "        additional_partial_fit_calls=rand_search.fit,\n",
    "        fit_params=fit_params,\n",
    "        random_state=42\n",
    "    )\n",
    "    meta = {'max_iter': max_iter, 'patience': patience, 'tol': tol, \"alg\": \"stop_on_plateau\"}\n",
    "    [h.update(meta) for h in rand_search.history]\n",
    "    return rand_search.history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total_calls = search.metadata()['partial_fit_calls']\n",
    "num_calls = max_iter\n",
    "num_models = max(sum(client.ncores().values()), total_calls // num_calls)\n",
    "num_calls, num_models, search.metadata()['partial_fit_calls']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#P = [max_iter, 10, 20]\n",
    "P = [20, 40, 80, max_iter]\n",
    "P = [20, 40, 80, 120, max_iter]\n",
    "for p in P:\n",
    "    all_history[f\"random-p{p}\"] = []\n",
    "for p in P:\n",
    "    for _ in range(3):\n",
    "        all_history[f\"random-p{p}\"] += [test_rand(model, params, X, y, max_iter, num_models, num_calls, patience=p)]\n",
    "        print(p, _)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performance\n",
    "`HyperbandCV` will find close to the best possible parameters with the given computational budget.*\n",
    "\n",
    "<sup>* \"will\" := with high probability,\n",
    "\"close\" := within log factors,\n",
    "\"best possible\" in expected value.</sup>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hi'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'hi'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pprint import pprint\n",
    "import toolz\n",
    "\n",
    "def shape_history(hist, **kwargs):\n",
    "    history = sorted(hist, key=lambda item: item['wall_time'])\n",
    "    \n",
    "    out = []\n",
    "    scores = {}\n",
    "    calls = {}\n",
    "    train_time = {}\n",
    "    \n",
    "    start = min(h['wall_time'] for h in history)\n",
    "    for h in history:\n",
    "        scores[h['model_id']] = h['score']\n",
    "        calls[h['model_id']] = h['partial_fit_calls']\n",
    "        train_time[h['model_id']] = h['partial_fit_time'] + h['score_time']\n",
    "        p = h[\"patience\"]\n",
    "        out += [{'wall_time': h['wall_time'] - start,\n",
    "                 'best_score': max(scores.values()),\n",
    "                 'cumulative_partial_fit_calls': sum(calls.values()),\n",
    "                 'alg': h['alg'],\n",
    "                 'adaptive': not \"hyperband\" in h[\"alg\"],\n",
    "                 'train_time': sum(train_time.values()),\n",
    "                 'model_id': h[\"model_id\"],\n",
    "                 'patience': p if not np.isinf(p) else -1,\n",
    "                 'patience_': \"p=\" + str(p) if not np.isinf(p) else \"p=inf\",\n",
    "                 'tol': h[\"tol\"],\n",
    "                 'base_alg': \"hyperband\" if \"hyperband\" in h[\"alg\"] else \"stop_on_plateau\",\n",
    "                 **kwargs\n",
    "                }]\n",
    "    return out\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "shaped_history = [shape_history(h, repeat=repeat, alg=alg)\n",
    "                  for alg, hist in all_history.items()\n",
    "                  for repeat, h in enumerate(hist)]\n",
    "alg_shaped_histories = {alg: [shape_history(h, repeat=repeat, alg=alg)\n",
    "                              for repeat, h in enumerate(hist)]\n",
    "                        for alg, hist in all_history.items()}\n",
    "history = sum(shaped_history, [])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['hyperband-p20' 'hyperband-p40' 'hyperband-p243']\n",
      "[ 20  40 243]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>adaptive</th>\n",
       "      <th>alg</th>\n",
       "      <th>base_alg</th>\n",
       "      <th>best_score</th>\n",
       "      <th>cumulative_partial_fit_calls</th>\n",
       "      <th>model_id</th>\n",
       "      <th>patience</th>\n",
       "      <th>patience_</th>\n",
       "      <th>repeat</th>\n",
       "      <th>tol</th>\n",
       "      <th>train_time</th>\n",
       "      <th>wall_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>False</td>\n",
       "      <td>hyperband-p20</td>\n",
       "      <td>hyperband</td>\n",
       "      <td>-0.542950</td>\n",
       "      <td>1</td>\n",
       "      <td>bracket=2-0</td>\n",
       "      <td>20</td>\n",
       "      <td>p=20</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>8.795053</td>\n",
       "      <td>0.000000e+00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>False</td>\n",
       "      <td>hyperband-p20</td>\n",
       "      <td>hyperband</td>\n",
       "      <td>-0.542950</td>\n",
       "      <td>2</td>\n",
       "      <td>bracket=2-1</td>\n",
       "      <td>20</td>\n",
       "      <td>p=20</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>12.844531</td>\n",
       "      <td>9.536743e-07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>False</td>\n",
       "      <td>hyperband-p20</td>\n",
       "      <td>hyperband</td>\n",
       "      <td>-0.253263</td>\n",
       "      <td>3</td>\n",
       "      <td>bracket=2-2</td>\n",
       "      <td>20</td>\n",
       "      <td>p=20</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>17.382286</td>\n",
       "      <td>1.430511e-06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>False</td>\n",
       "      <td>hyperband-p20</td>\n",
       "      <td>hyperband</td>\n",
       "      <td>-0.211405</td>\n",
       "      <td>4</td>\n",
       "      <td>bracket=2-3</td>\n",
       "      <td>20</td>\n",
       "      <td>p=20</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>23.095830</td>\n",
       "      <td>1.907349e-06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>False</td>\n",
       "      <td>hyperband-p20</td>\n",
       "      <td>hyperband</td>\n",
       "      <td>-0.211405</td>\n",
       "      <td>5</td>\n",
       "      <td>bracket=2-4</td>\n",
       "      <td>20</td>\n",
       "      <td>p=20</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>28.456335</td>\n",
       "      <td>2.145767e-06</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   adaptive            alg   base_alg  best_score  \\\n",
       "0     False  hyperband-p20  hyperband   -0.542950   \n",
       "1     False  hyperband-p20  hyperband   -0.542950   \n",
       "2     False  hyperband-p20  hyperband   -0.253263   \n",
       "3     False  hyperband-p20  hyperband   -0.211405   \n",
       "4     False  hyperband-p20  hyperband   -0.211405   \n",
       "\n",
       "   cumulative_partial_fit_calls     model_id  patience patience_  repeat  tol  \\\n",
       "0                             1  bracket=2-0        20      p=20       0  0.0   \n",
       "1                             2  bracket=2-1        20      p=20       0  0.0   \n",
       "2                             3  bracket=2-2        20      p=20       0  0.0   \n",
       "3                             4  bracket=2-3        20      p=20       0  0.0   \n",
       "4                             5  bracket=2-4        20      p=20       0  0.0   \n",
       "\n",
       "   train_time     wall_time  \n",
       "0    8.795053  0.000000e+00  \n",
       "1   12.844531  9.536743e-07  \n",
       "2   17.382286  1.430511e-06  \n",
       "3   23.095830  1.907349e-06  \n",
       "4   28.456335  2.145767e-06  "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "df = pd.DataFrame(history)\n",
    "df.to_csv('2018-09-10-history.csv')\n",
    "print(df.alg.unique())\n",
    "print(df.patience.unique())\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWMAAAFCCAYAAAAkMrxyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsvXl4HNWVv//eXtVSS7IWW6sXecc2NgiBMBgDAQKEBEggJGQjkwAJZGAyGfINTGayzhAY8hsg2wQCmZBMYJhAQjAECBiEMRgT2djGNrYlLNuSbO27Wr3W/f1R1ZvUrW65JXcV1Ps8etRVdav6c7q6T58+995zhZQSExMTE5PsYsm2ABMTExMT0xmbmJiY6ALTGZuYmJjoANMZm5iYmOgA0xmbmJiY6ADTGZuYmJjogKw5YyFEsRDiRSFEk/a/KEm767Q2TUKI62L2f0oIsUsIsUcIcXfMfqcQ4nEhRLMQYqsQYsHMW2NiYmKSGdmMjG8HNkoplwAbte04hBDFwHeBeuAM4LtCiCIhRAlwD3CBlHIlUC6EuEA77ctAv5RyMXAvcPf465qYmJjojWw64yuAR7THjwBXJmhzMfCilLJPStkPvAhcAiwEmqSU3Vq7l4CrElz3CeACIYSYAf0mJiYm00Y2nXGZlPKY9rgDKEvQpgpojdlu0/Y1A8uEEAuEEDZURz53/DlSyiAwCJRMv3wTExOT6cM2kxcXQrwElCc49O3YDSmlFEKkPS9bStkvhLgJeBxQgDeARceh70bgRoDc3NzTqqurAXA6nVitVjweDwA2mw2Xy8Xw8HD4PNxuNyMjI4Snk+fl5REIBPD7/QDk5OQghGBsbAwAu92O0+lkZGQEAIvFQl5eHh6Ph1AolNE1RkdHURQFALfbjc/nIxAIAOByuZBS4vV6AXA4HNjtdkZHR5FSYrPZyM3NPe5rAFitVnJzc+Nej/z8fMbGxggGg2ivL6FQCJ/Pl9ZrnO41FEWJ6Ex2n6bjNZ6p++T3+xFCpP0a6/E+OZ1OQqHQcV8j2/dpeHgYIUTGn6dk9+nAgQM9UsrZpGBGnbGU8sJkx4QQnUKICinlMSFEBdCVoFk7cF7MdjXQoF17A7BBu9aNQCjmnLlAmxY1FwK9SfQ9CDwIUFdXJxsbG9O2DWBsbAyXyzWlc/SE0fWD8W0wun4wvg0zrV8IcTiddtlMUzwNhEdHXAf8OUGbF4APa512RcCHtX0IIeZo/4uAm4GHElz3auBlOUPVkNra2mbisicMo+sH49tgdP1gfBv0oj+bzvgu4CIhRBNwobaNEKJOCPEQgJSyD/gh8Dft7wfaPoD7hRB7gdeBu6SUB7T9DwMlQohm4BskGKUxXbS3t8/UpU8IRtcPxrfB6PrB+DboRf+MpikmQ0rZC1yQYH8jcH3M9q+BXydod22S63qBT06fUhMTE5OZx5yBlwHLli3LtoSMMLp+ML4NRtcPxrdBL/pNZ5wBVqs12xIywuj6wfg2GF0/GN8Gveg3nXEG7N27N9sSMsLo+sH4NhhdPxjfBr3oN52xiYmJiQ4wnXEGlJcnms9iHIyuH4xvg9H1g/Ft0It+0xlnQE1NTbYlZITR9YPxbTC6fjC+DXrRn7Whbe8HtmzZwnnnnZdtGceN0fWD8W0wun6YXhv+3PxnHtz1IJLoPK1zqs7hjvo7ALh/2/28cPiFuHOswsr3z/o+tWW1E67XOdrJTS/dhDfkTfh8NouNPF8eg/bBtPRdNP8i/vG0f0zXnClhRsYmJia6oGeshzu33okiFarcVVS5qxjxj7CpbRMAISXEY/sfI6gEI8er3FW0j7TzZNOTCa/5+P7HaRpooiKvIu6cKncVs12zaRlsYbd3N2PBsQnHx/+N+EfYeHjjjNlvRsYZYOT5+GB8/WB8G4yuH6bPhp+9/TP8ip9fXvRL5hfMB+CrL36VlsEWAN7pfofRwCj/fMY/c/niyyPnfebZz7Cza2fCa754+EWWzFrCwxc/POFY52gnFz6hls85p+ocfnD2DybV981Xv8nWY1uPy7Z0MCPjDKivr8+2hIwwun4wvg1G1w/TY8P+vv38qflPXLv82ogjBjUFoUi1+tlLR15CIFhfvT7u3LqyOo4MH2HQF59qaBls4dDQIS6puSThc8aWOZ/tSllUjRJXCUP+oYie6cZ0xhmwdevMfUueCIyuH4xvg9H1Q+Y2SCm5p/Ee8h35fGX1V+KOWYQFBdX5vXH0DWoKa5iVMyuuzVlVZyGR/K3jb3H7/9ys1h772MKPJXxeQdQZl+elHlFRklNCSIbo9/anNuo4MJ1xBoTrohoVo+sH49tgdP2QuQ2vtb/G1mNbuWnNTRQ6C+OOWYQFRSoMegdpHmjm7KqzJ5x/yuxTsAkbbxx9I25/OEVR4a5I+LyxkfGc3DkpdZa6SgE1tz0TmM7YxMQkawSUAPf87R4WFCzgmmXXTDgedsab2jchkZxfff6ENjm2HBbNWsS2zm2RfU19TRwZPsKlNZempaMsL9FCQ/HUldXxg7U/iEujTCdmB14GrF27NtsSMsLo+iFLNgTGYKQTihaAdxAsNug/BFKBwmpwFYFvGIRV3Y+E3BL1+Fj8T9yzFhVC5x5w5sOseek9fyigasgpSK+9bwSsdrA5k7fx9MGwtgpaQaVqQ5pkcg/+sP8PHBo6xE8/9FPsFvuE41ZhRUrJy0dexmVzcWrZqQmvU1dWx2P7H2PUP0qeI4+nDz4NwGULL0tLRzjqnYxZObNYOGshObactK45VUxnnAEtLS0sX7482zKOG6PrhyzZ8Og10LIJrt8ID02oAgvf6YdfXQA9+1NeyhG7cct2KElj9bBN98COR+EfdoIljSI3v/s4lC6FK3+evM0D62FQW25y9nL4Wvp54OO9B4O+Qf5r539RX1HPudXnJmwTjoy3dW5jzew12CyJXdYZFWfw+32/562Otzh/3vm8ePhFlhYtpdJdmfT5Y3PGRc7UXz5WYYUZXNrYTFNkQEdHR7YlZITR9UOWbGhRx73S9W50X/HC6OOhduhtUh8782F5TAfSGTfCR++Ha34L1/yW3Su/BZfcpR7r2JXe8490qY6z9a0023fCu0+rEXUi/KPq9VZ/GhaeNyF6T8Xx3oMHdz3IoG+Qb9Z9My5/G4tFWBj0D9Lv658wiiKWM8rPwCIsvHnsTfb27KV9pJ1LFiQeRREm9jmtaXypCSFUhzxDmM7YxGQqBGI6q4ZiVogonBt93L5NTUkAOAthScxSkKs/DXVfhBVXwIor6Jl9FtR+QT3W05yehvC19z+bXnslBL4hOPxG4uNDWnpi0YfUL5UZGroVy5GhIzy671E+seQTLCtOXk/YIqIuKln0DOB2uJlfMJ9tndt4+uDTCAQfqfnIpBrEFMNcu8We9EtjOjCdcQasWLEi2xIyQu/632h/g6+++FU+/uePc8Nfb4j8PXsw6oRWrFjBj7b+iPu23RfZ5wv5+N4b34sbd/rInkd4qvkpPAF1heKH3nmIN4+9GTm+o3MHv9jxi8j2a22v8fA7EycK0KOu7vVMXi7PdEU7jMiJGQVw+A0eKcjnbzlOQIKw8stZBbzjcIA7vtd+xYoV4MiDgupoNJ2KiDN+LuHhl4+8zAM7H4juUNRVmznwfGSXN+hlV/cuHt/3ON/f9mMaXC41VywskzrjkBLi/u33c2jwULwN4+gZ66GhtYGfvf0zvvfG92jqj7ftP7f9J3aLnb8/9e8nNTUcsVbkVTCvYPKceu2cWt4bfI+XDr/E0qKlVOVXTdp+qs7YZrGxsmTllM6Z0vVn7MofAMJLghuVjPTv+gP8UVsdq2Z99Kc7wNpbVKfVpNUQqDwVbmyATT+Gl3+o7suviOkwqoqPMgFO/QL3ju5gX2AAgE5PJyVS0BkcZbhnP+uq1uF842eMDHTy6NArANzcP4hjpIvnLF6e7H8L66E3+NeClQw687j/6NPkYWVxwSKWtW7n/t33A/BOyxEAPl+jftBveOoO7PVf5bFDf2SLy8ln9ryCq7gGhFAj18UXEALuLiki19PER8N6YzrTjrW+wY9Lirhg1MPpXUcZUHz8vGgWPy+Ci7b/f1QVzOWsyrOoK69j0DvIg1sepLS4GEvf23S/+e9YhIV8Rz41hTWRDqj/3v3fbDm6BQDn0F4uy8vlkt5m+tveQilZRCAU4N7t99Ix2sH2ru0AkdEF8/Mg5Cyir3UDoy900+PtpWWwhZCM3v/OAjdnu+dw3+gBrrJA4Vh0QfUjw0f41a5fEVSCeIIednbv5KF3HmJthdpx55Iurlh+Bc2Dzezp2cPu3t10edTF3i3CgtPq5Knmp7h2+bXcfMrN7Ovbx8YjG7nl1FtSdpyFI+Mzys+YtB3A6eWn82TTk3R6Orl66dUp289klHs8mM44A/bv309FReIxjCcCX8iHRftxc//2+7n+5OuZlTOLQd8gD+56kFtrb8VpdTLiH+H/bfp/VORV8C9n/kvkTZiR/j9eH30c64gBtvw0fvvo2+r/N2L2hx0xTHTEwP7dj7GvOqrt8yd9jpueuoM7ZpewLcfH4aHDrH71PwjY7aC163jzJ8wLBvHnu6G0mNH+ZjiwlRfy3QRKixkgyOaW5yl/4U6YX53QrA6blblbf8n+uZUEheCdQ3/ljH2+GN1H2el0MmC1MkCIDquV8lAIcqIdQM96DkPOLA447IBkvzc6LvXFVrW2wW/2/Iaff+jnPPjmg+wc26l2DNmB/f8bp+eyhZehSIWHdz9MSAkxK2cWA8owrUWzuGTUw8DOR2lfczV/6/gbf2n5CxV50dfsQP8BJJItuQ7AQXkwiH3wEPOKFnPBvAs4qeQkVhSv4J+e+QyKp5VXhpr47dghDhQ4uLZrJw6r2r34zMFneK39Narzo69ZSU4JrSOt+EN+ujxdvNzxMgALChZQV1bHqtJVrCpdxbKiZfhDfn7y9k/4/bu/57mW58ix5VCeV84XVnwh4T2IxWFRNZxTfU7KtvUV6kzAdFIUsVjRx0ofpjM2MIeHDlOcU0zHaAeP7H2Ek0pO4rKFl7H12FZ+u/e3nFt9LmdUnMEvdv6C19pfA+CaZddMmqObUdLp+dd4xp2HTUrWe8Z4OS8Xp1bEqyIY5Jgtj1H/CBI4bI++hY/YbcwLBunRltHxa186z7pzqfEHsEvJhtaXONsWPUcBAjEB0jGbjXxF0qW12Zbj5AxvjDM++jYbq2qAUOT4ZaMetaMOkMAGdx4ArXY7HiHY61G/eJ5p6+Cj1dGZXk8ffJqdYzuxWWwEw6mEcUgp6ff2M+gb5IaTb+DW2lv5ye8/zEPyKBvKF1PX9hZFZ97Aa+2vUZZbxvNXPc9VT19F80Az951/HwElwJde+BIA3+vp4+zlN8HZt8Y9hyUUIGR18FjTk1iAN512Th9o5qyqsxBCMOAboMhZxHOfSJwWuf+Z+1l18ipOrzidAsfE4Xa59ly+s/Y7XLXkKu7ceie7enZx9zl3pzVEbFbOLFw2F2srUw+fK3WVUlNQg8vmSpnSACIjM07POz1l2xOB6YwzoKpq8pzUTBJQAnR5uijOKWbYPwzAiH9E/R9Q/x8bVZ1AOE8KxM2rP+H6pUzdBtXNPevOZZ1njK/3D3DEbuPiOXUAzA2oTuuWV25lZcUctudEP9A7nE7WjXk5alOdcZfVSpvNyvacHG7tG8AhJT92HuUzVVGH+P3SYp7SnCeozjjsm21S8rfcPG4aGKLbasErBHODIRocFuq9Y+xx2GgMO2Ntyu4+h52DDjvnjPl4zeXkgMPOu2MdFIdCzHPET+N94dALrC9ej8/hY2tH4qFk/b5+Dg4cBKDKrd6v9dZZPOo/yj+7/AjpY37DbRwaaePLq76MRVioKayheaCZJUVLIu8JgMJZNWreeJwztoYCHHTY6Ops5Gb3Mp4c2MtPd/yUh3c/TKW7kk5PJ/Pykzu3i5dczLJ5y1L+7F9ZupLffeR3vHTkJT48/8OTtg3zqWWf4pTSUxI6+UT84OwfJByvnIg8ex4PXPgA+UP5abWfacwOvAyork78U/dEMOgdnOB8hwOqUw4757Az9gajtVxj68RmU/9kbHXl0G2zcfnIKDWBIH9q76BMqD9XLx71sMbrwxfysT0nh0tGRrmnq4el+QvYmKdWDzumRbVdNivPao72stFRTvb5JzzXH/Pd5CmSf+hTc9NHbVYtvQAXjnrY6bDjB24pm80XK8o4YLdzhAAf8oc41eujMfxloKiR8gYtor9lWI2mDzgcNHu7Wer3I/JKybNHHX99eT23nH4LNYXJi5sf2fUo77zzPwAs6j8K725gTfOrNLR3cdeK67lpYBB30E95bjlXLr4SgG/WfZO7191Nnj2P2bnRAjiFC86FI2+qEzxisAZ9dAmJw+Lg03k1/KZ7gE8t+5Sal7c6sQordWV1STXOnzc/7fyrRVg4ZfYpabUFdfxvsokeiTip5CSWFC1Ju/2aOWtYND+Nsd0nANMZZ0A2i7wcHT0aGfMYdspD/iF1W3POHaMdBJUgASU6vjTWGZ9Q/VIC6UXGT7vzyA8pnOuJDiOzetUvmFwp+cpAdJTE3/cPcsmoh7PnnEazw8ERmy0SGXdbrWxw53HamJfKYIjl/nhnvFjbrvd6uX5wiNJgiGM2GwccDopDIS4e9eAX8EhhAXucTrpsNr41pwSA8y2zqPN6OeSw02OxwLy1BCtW81xeHus9YywfG8GtSPY57Bz29bHUH4DcEtx2NwA3nHwD1624jmP7jk06vfbIpjvZcPh5lvr8rHnuX+DxzyGCXnKCPvLLT+FLwRwe8Lr47trvRuorOKwO5hWqkWzs0LCCpR8BGYLm+Jq81qD6OlxScwlFVhdVwSDnVJ/D3636O/517b9y1zl38bkVn0uqcarvo3TqQES0Wazk2nPTbu+0OiO57nTIs+fx1ltpjteeYcw0hQHxBr0M+gZx2dRIMOKENaccjoyPjhzFE/TEnRtIMvD/4MBBHtv3GEuKlrC2ci0/2vojvrTqS9SVqxHR8y3PM7z/WZ488gJ7nE5unlWAXUJjjpOzx7x8bmiY/81380qei9nBECWh+OFRB399Kr5CG3XOAtyKQofVxohFMGKxsDCgagohCAnYmOvi8pHRuNlp4i/fiDyuDAYnPP7E0CD/Dfy8qJAOmw2XojBmsXDYbufvBtTXJ3dcmmSWpnGp5pQrg0H+lK86y/oxL6dpueKfFM+iKBSiKKTQ7HBQk1dJxTWPU3toI7z1Pb5bfzXl3W/QNHcBPd0DfKx3FIFgSdkpbHQdwe/rV51xXimFzmE6PZ2U5pRSnV/NYQ4ndE6/PdrJdRVz+E3VYpr9/dw471Lkxz6LEBb45ToATp69msEFZ1Hy7nNYQ75IDrbQWRh1wkr0PuTPOxvyZsOB52D1J7U3hBdryA+4uHb5tbDjCZCS2a7Z9Hn7kFISCAWSznwzmT7MVzgD3G53Vp6339uPBUskyo2kKfwT0xTDvuG4WUOB0R4YGwDXLFX/0DHIKeCRPb/hj81/AtTxmtu7tvNa+2u8s+o2grNP4pubvqlewKnWN/hFUTT/+Xqui8pgkDtLiyP7nEq8M/ZZQmBz8WaKQuQ2KXEpkquHR+IPaON7AaqCIXIsDuZ6RwhnBxe89WtqK+bwFy0t8cmhER4rzCdHSi7yRL+Qrhsc4pHCAlZ7fZzi89HoyqHW64NZ81gR8hOeA3dayELR0o9Qmw/be3bxhcFh5lhdfNsB15z0WXDNYuWyy6ne+xBburZB1zaCSpA5zmLOGTsCFgcnz17D2907sSJY4/VBbinXLfsE337926yevZrK/Ep63b3MnR0zYUTjFJ+PZYqFff5+Zrtm86HV12EZN8a1KKcI5dTrsOx+ikV9bVjmqw7YZrFRFB7doQS5emiYJwrysVhtsORieHeDOhvPaoehdqqDQerd81lVugrEnxBSYUXJCgJKgGH/MD2eHnKsyTvbsvU5mC70ot90xhlQV5c8jzZTSClpH2kn15HLqH8UmBgRh7c7RjvoGeuJi2r8//dZ8IXgOz2q/ntXweprkN3Rn2pNAzED9Dfcym6nAyonr/fakBvvZBsPt8Vt31VcxDGblR939TBqsXBOzNCyZ1uPUh0Mpp0zy5GS1878EdbffzJu/0PHuhi2WLAiKVQkt/QPYL+9jZwfRTsqb+sb4DYtPyy/dZgvW224HeqH8Z+l5DbFj5QSp9UJQvAI4P3+LJxSIv5xC5e6y7Bb1a8Au8XOc1dFRxgElSDS049932LIm8Ntdbdx/cnX43jrV+S1/DsUVHL54sv52KKPRXKs4ffQri9Ep0KL5++Alv/i0XN+zPDcOtx2d9Kf3pb568BZwJwXvgOb7p3YQCp8Z6Cf7576dXV72SWw43/gJ6eqBY6CPr493I/yEe2Xh7Cok0TuPwU7UKz9xXHjK3GFhLLxOZhO9KLfdMYZsGXLlhNeNWwkMMJYcIxiVzGjqM54fEQcjpS9IS+tI61xPfV+IUDLIb/5+ibOHGyF4Q6U4Y5I1ZrwdcJsTmNZnafyJ48ubu+L1juYpSh8r7uXH5YWExKCklBoyp0XOYMTxybbgWJFgZLFUHUa+WUng9MNdpc6jblkMfS+B0hYfBHCNYtY1UII1QmPf65r/kd1UIXVTNZPb7PYwD0bPvxvsPRShBBqhHrm1yDghTNvjjxPmPB7KK4D7JTPQGEV9sUXUZyoY+y6DdFOOJsDLr0b3nslqS4x/2xYrk1PWXyRWh9jbCB63JmPde6Z6sbKK9U6FcokE4LGpSyy8TmYTvSi33TGGeDz+VI3mmbaR9onRElh5zvUtRv2Ps2wfxgL6mCr3+35XWQ2FIAv/OH+9aUoVdrEjR2/JzC7RJ2WOw4JvJ4b/YlaN+al0RXd/vWxTr5UEV8L9rs9vaTiqpFRLh8ZpdNmJS/VkDeLLTqlN0yfOtzr9bMe4ewPXzn5+d/OsJjQSR9N3SaWs26J33bkwQXfSdg04XuoYrX6l4yacQVzTvmM+pcO9hz4yD3Jj5ethI//Mr1raWTjczCd6EW/OZrCQHgCHro93ZHhUU39TTT1N0XTFEoA/vw1RgIjzPOr0e/evr1c6ormJBtznPzJncdvBt7hlaGX2eNw0OBy0WpL/L38aIGbPY6o8z/DG7/k+bzAxMkKZ4yl9+a2A9XB1FOyg/aJ40APNe1BWh2MWvJ5eHMLIUV16Ioi8QcVvIEQD712kKDWSff2kX42HegGoK3fwx+3R9MoPSM+fr/1cFqavYEQT25ri1wrGX955xjf37CH72/Yw78/u5f2AeOv6GEys5iRcQasW7fuhD5f52gnVosVIQT+kJ8Hdj3ASSUnRUZMjFgE2HMZ8Y9wut/PIYedKncVN9qqeG5MrVX7eEGMY/Ns4n9jJkCs9PnY44z/mX5XiZoxnIONLoIs8sePxshVJhaVKZzsJ+5xcHgsh0XjwgZPZzOj+WXsldXc98xe8hxWPn3GPIa8AQbHArzXPcK/PfsuJ1cVUr+whHtfaqK938PGfzqPzz20lUO9Hj5ycgU5dit/aGzj7uf3ccnKckrciQuw9474+J83j/C7Nw/RM+LnpIoC1i9NvojlnX95l84hLzk2K8O+ICVuJ189d+J41hP9HpoJjG6DXvSbkXEGHDhwIHWjaSIQCnB09Cj5DtWZNnY0MhocpWesJxIZ+ywWfI5chgPDzA0G+X53L9858zuUSht/O9TKK5c8yobWo/xD3wDzAwG+7FjOqV4v1w8MsqH1KL851sUjZ/6QZ1qP8rujHSwKhHjwpBvYeKSdu5QiyoMh1o55ucBZQUUwyBK/nzwp+f3RDi4fHuFszxivHW6jUElvPHG6DDExfTJPdDLqLKejS6370DEUjdjH/CGGvWrE3u9Rvzy6h310axMxurT/Iz61zeFeNfceTKC7uWuYO/64i7Puepl7XzrAyVWFrKoqIBCavMzkqC/Ip0+fx87vqjPNPP7EX1An8j00UxjdBr3oNyPjDOjq6pqWMpRSSn6x8xfs6dnD/IL5FDoLI2OIFakw5B/iikVXgIwO4n+5VS3M0jfWg9Vix4JAQdLtdBFUhnErkk+MjELVWdD4KEhJjiOf0mCQ6weHuH5wiPbKU/j6sa44LbUlKyEYZH4QnhoIQtFJEAoxxx/kxUEvCBv3lZ4N+/4zcs5qn5/VvvhZXdPJoJzojN3CS4+rHOnXfhV4o+kSf0iJONrBMXUMce+IjyFvEG8ghN1qAVSHXep2crhXvUbYGUspeb25l4c2H6RhfzdOm4VP1Fbz5XULWDwnn1sfe5t32uOXhR/PqD9ErsOKxSJw2iz4Aomd8XS9h7KJ0W3Qi37TGeuArR1b+eVOtdMkXNBnPBIZWemgc7ST3T27KVQUBgMjWIWVOc5ZdPj6OWZX+/vzY9MH4foE49IHrrFjTIqwqqUjAbxDakdUwAuhidOKM+VnwSv4e9ufEx4bTBAZA3hcFbi0YHY41hkHlYhzHvAEUBRJ76iquXvYpzljGPaqUfORPtUZj/lD/KGxlYc3t7CvY5hSt5N/umgpnz1zPsV50by5zSIiOepEBEMK/qBCrkP9eLkcVsaSOGMTkzCmM86AVatWTct1wjUkJsMb8EYmbzS0NmBB8NnBIX5RNIuQDFHpUJ3xUa1imTvWGfu0oWrjRiQUKgmi2VhHKyyqQwZ1pQh3uboAZ7Lle2aIIZl4Oqwvt4IFJdWw5yDDvqgmXzAaGQ+MBRgYC0ScZ9ewD4dV/YIZ8QbxBxWODqqdaxfft4mQIllens89V6/m8lMqcdomVpqzpnDGHs3x5jnVc112K2NJ0hTT9R7KJka3QS/6TWecAdM1JMafRqQZlEGswkpICdHQ2sBp7vms7OiMHK+057MdOGa1QGhcZOwLR8bxztgydDSBmJjp01JRHTKokXHJYrA6ZiQynoxkkfFYbjk+rUMxNjIOKZIhLeod8PjpHYnep+5hH3abatOQN0hbvydSTC6kSO64dDk3rl84aeEbq0UQTNBxGdGlOV6XQ3XGOXYr3mDi9noZVpUJRrdBL/qz1oEnhCgWQrwohGjS/idcnlUIcZ3WpkkIcV3M/k8JIXYJIfYIIe6O2f9FIUS3EGKH9nd9ousw0HYvAAAgAElEQVROB01NaS6TkwJfKPWbQUqJEIK3u96m39fPR63FzI5ZqaPCqlUss6ieJWGaIhA/LE3IBDV0Yyd8yFC0BrESUNMUVkdGkfFTobM4okwchSAnWQInUc4YwOuq4Jj2hTQU44wVRcalKbpjnfFIfJricF987Y4zF5akrECWKjIe1aLyPC1NkTNJZDxd76FsYnQb9KI/m6Mpbgc2SimXABu17TiEEMXAd4F64Azgu0KIIiFECXAPcIGUciVQLoSIXTP9cSnlKdrfQzNuSYYkK94Ti0QipWTDexsoySnh3JFhZseM0a0U6pCso5qDdYedhaJE0xTBNMa6alOs1XOD0cgYwOFW6xkox++MQ1i5yD/JpIMEJIuMfXmVhCI546imoCIjznnAE6B3JBrJdw95Y5xxkCO98c54QUni54rFZhEJR16ECY+cyHWE0xQWvGbO2CQF2XTGVwCPaI8fARJNo7oYeFFK2Sel7AdeBC4BFgJNUsrwyPuXgKtmWO8E5s6dWODlePAr6f3sb9v2K/b37+djiz5GXt9BihUlsmBMhfbomFSjwEhkHPQmjYwBdfXiWHwxBXqUUDRnDJozzjxNoSR42002GC5ZZKw4CsgvVAsWjYxLU4zG5Ix7tMjYYbNokbEa+Q57g5HOuzCFuakLk1stFkKhdJxxNDJO5oyn6z2UTYxug170Z9MZl0kpwz1XHUBZgjZVQGvMdpu2rxlYJoRYIISwoTry2Ff0Ki2F8YQQYsZe6bKyRJKnTrppij+2PEtJMMQFVetw9h/BAhQL1XnMVtSKZ+0h1blEOvACY1EHmygyLhpXSzdmZYi4nDGodR4s9ow78NIvCaSSaJwxgNUCuXlqdYlwzvg//3qA257YGe3A8/jpHfFjtQgWlubRNeQjqDnSEV8gMqxtKtisk0fGo371uXNjO/CSOOPpeg9lE6PboBf9M9qBJ4R4CUhU7uvbsRtSSimESHumgJSyXwhxE/A4agmGN4Dw9KYNwGNSSp8Q4iuoUfeHkui7EbgRoLKykoaGBgAWLlxIfn4+O3fuBKCkpISVK1eyaZO68KbNZmPdunVs2rSJ3Fy1p7+uro7Ozk5aW9XvjiVLluB0Otm9ezcAc+bMYenSpWzevBkAp9PJ2rVraWxspKstfqxvIg607meXy8U/9vUz+tbbCG1l31Jhp1sG8LS1UmoL0WETCESkdm/P0RZKNWe/d9d2xo+m7KeQ2GT9e/t2RV7IUMDHjrd3cJq2fbijj2KPF4t9IIl7TA+ZMDIWvK0s5lRL84RjyUZT9PT00HJILRg0Fgixa9cufvum+vofOKaOAx7wBNh3qB23HWxBDx2DMOxRX4/9La20emzk2i14AgolOYK9e/cmvU8jI+oXlQyVEgwpkffLsmXLsFqt7N27F4Bmr/oFsXfn2wwdtOAZDuAN2Nm6dStjY+oX4tq1a2lpaaG5uRm3282KFSsIhULs378fUJfEqq6ujhRud7vd1NXVsWXLlkiH07p16zhw4ABdXer7Z9WqVfh8vkgOdO7cuZSVldHY2AhAQUEBtbW1bN68maBWB3r9+vXs2bOH3l61nsiaNWsYHh7m4EG19seCBQsoLi5m+3Z1xemioiLWrFnDq6++GunHkFJSVFREf79aDKq2tpa+vj4OHToEpP952r59O0NDau3pTD5P4ftUX19PW1sb7e3tCe9TeXk5NTU1NDQ04Ha7cblc1NfXJ7xPHR1qfZPjuU/pMqPOWEp5YbJjQohOIUSFlPKYEKICSOSR2oHzYrargQbt2htQHW/YqYa0/bFVah4C/mMSfQ8CDwLU1dXJ8847L+54qu3c3Ny4fW63m0WLFk16zvjturo6ng8+D5PPIWCX9x3yQwqfGhqhr1RzCsJCmXDwLh4Wl8ziqrYRfl40Cxnj7kpzoh15K5bUwLvx1y1aeAp0RMc2L6ouA/VziFXAaXV1oH4Omb/4JDhwBBwndhDOCBOrxu1R5lNaOhv53jHCi4PWLD2J8A8prxaIjgVC+Gx5VBbbWV5ZwOvNPVi01Iu7qJRjnV3MK87lQOcIiyqKIoP/E92nMI0v7Cck5YQ2c+aoReK7G1uBTs49+0zmFueyoWsnRw72Ul9fH9d++fLldHR0xF1n/Grd459jfHWxFStWTJiwMH5tw/HXGD/99+STT47bLioqYt68+DXvxl/j3HPPjTxuaGhgzZo1cccLCgpYsGDBpNcYv11bWxu3fbyfp1iWLFnCkiXxyzCF71Ps88ReJ9F9Wr58edy+qd6ndMjm0LangeuAu7T/iUb8vwDcGTPS4sPAHQBCiDlSyi7t2M3ANdr+ipj0x+VMcD/TR0FBeoskpsIbSpDLTcCnhofJk5K+jj1Iqx2RX0mpsKuRsH+Ma4eG+XlR/KKXjMR8xwUSpClmjU9TxHTgTUhT5Gs548QrGWeGSJo3HpUu/jNwNVdZN/HL0MfwSTuNchmXHOnnj03RlMn4YjwOqwV/SOFg9ygLZ+cxO99J97CPApea2jnYPYo3oJBjV53z3KL0lvexWgSKhC/8OvFyPcc0HZEOPIeFrmFvwvZDQ0F+fTD5sj/zi3P54ZX6GAebjOn6HGQLvejPpjO+C/g/IcSXgcNEnWkd8FUp5fVSyj4hxA+Bv2nn/EBKGZ6pcL8QYk3M/vAE81uFEJcDQaAP+OJMGTD+m/x48QXT+zlzuteH1+Kibc9BcnMXkhPyc8pYLu/NvoR9777FCkXyBf8CmkpWAb8AoK39COEy7oc6e1gw7ppNgRJi44bO7p5I8l7KEK39XsIxUpfPRqG0IgLxSyIlIygt2MTkNRxisVoSDykbxclPQp9gQ9HnaemJflk8uOlgXLu7n9sXt726upDGw/20D4xxRk0xc/KdBBVJnzYbb3+nOsrkxvULeW53B7dfGh/9JGPdklI2N/cwNJY4d57ntHHZ6gqKctVX6YKTythzdChxe7sr6XUgmn/WM9P1OcgWetGfNWespRMuSLC/Ebg+ZvvXwK8TtLs2yXXvQIueZ5rNmzdPS8WndCPjpT4/R4IV1IjDNAyuZI04iHUgwKbmc/mG40WwwJzDTp54bwVoJYf/95Xt3KYNEHjqrWa+Pu6Of+WZXl6OKVT21oEjfEwbQCGkwvW/e5u/ase/+/xhPmkdpFQMsjqNPrggVmyk54xrip2sycuDBJMRvTj47ZfOYP3S2Tz02kH+7dnEP3Ze2d/NOUtKqSzM4fHGNj535nwaD6t5zLlFLuaXxEe+UoIATp1XxEdXV6alE+D0BcU8edNZabc/f9kczl+WeBHO6XoPZROj26AX/eYMvAwIBqcnavEG03PGpYpCDxbKRT/7lHmstrYgNGfnRr2GBYldRHvuS0U0GZ1DfATmkza6ZHxao1zET5GOXYNjlBwC2CggvREIQaxAeiMvPraiWP19lIAtd1xEeaH67fLFsxZw+ZpKJOC0WdjyxuucfuZZ9I36GfUFObmqEIsQ/MOFS6kozGF5RT5j/hArKgtwWC08c8s6AiGFhaVumrtHmJVrp2pW6pVMZorpeg9lE6PboBf9pjPWAek6Y4DlFrWDar+ciwROFi3cY/slBUJ1kAKJlagz/qLtr5HHxQzFXatNzmaU+IUmT7dEywm+oyxgVEaP98oChmQuC6ydpMNGpZYrrG/E7euWhQnbCmc+zFsLx3ZMOBZ2xAA2q4U5BdFtl01Q6nZSOq4OcaXmYJeXx+cDV1VFn/+0+QknfZqYZAXTGWfA+vXrUzeahGBIYVNTd1rO+Gsd8beqQxajYGGepZt5luiqExYkNhKPaT3f+jZj0sFl/jsZlTkIbdzFOt99BKWVWksTHpy0y9kUMMoRWUY3s7jS9wNsBNkjF/Dvwc/yrFKPgyAFwsNbynLsBLEgURCUiX6kNYejQTdHZSk/Dn4Sv7QjkNRYOtihaL3jt2yHfc9CWyOcfDUsvhBsTlh+mdpJaMuBvvegYk1CW8Jkeg+yjdH1g/Ft0It+0xlnwJ49eyYMC5oKP3ulmfteamLe6tGUba/wDBBbviGINcnoA4k9iTOeLYZ4MXQaB2V8frRNqvnMvyglCc/bIRdHHg+QT4NyalKd78kqinLs9AfU9ESrjA6o74i9fskiOPvWiReoOSf6uHJyRwyZ34NsY3T9YHwb9KLfXOkjA8ID5Y+X8OwvfxodeBXjcrlBrBSL4QntLEgck+Rp/6qclvRYmMtWV1CcO3G8xM8/k9wJxxIeKnYiyPQeZBuj6wfj26AX/aYzziJSmyUXlKmHtt0buIomJTqYPyQtlAl1ufXWmCpon7Y18LTzXxNeQ5GCV0LpOVRfgoVCXWlO9jiRztjE5P2C6YwzYPyso6kigbzFP8Inh1K2vT90FR0y2uEUiMkw/S6UdKJjHNvlEnpI3IE2Xlii+rv2JOOAx+NK4YyTjSc+HjK9B9nG6PrB+DboRb/pjDNgeHhimmAqKBIs9hTzoGPwaCMfQlIwRnT0wGYlPt/1P8EJw7cJSCvPhU5P63kkMmG93nDpyVSEi6onwzaNzjjTe5BtjK4fjG+DXvSbHXgZcPDgwQlz+KdCOE2RLt8OfJnHQufTLWcxTC6ne39BEAv9FHCR7z8Yw8GQzGOIXH4fupBhXASkeovdYowWWZHiGcK6Eu9PUXM9Qipna7NOnzPO9B5kG6PrB+PboBf9pjPOIum6Yk+rusBJD4VxIxm6iU7YaJLVcee8K+NrTnROze9nRKo0hN1i/iAzMRmP+anIgPFVqaZKupFxaOSkjJ5nqiSTla4/T+WMpzNnnOk9yDZG1w/Gt0Ev+k1nnAHFxcUZnT/FLIVhsKbIZ6Sbe06HTO9BtjG6fjC+DXrRbzrjDAgX3D5elBTeOOQtY7Tl7zN6juNBJomBU+kNkzJNMY0540zvQbYxun4wvg160W/mjLPISGAEJhl4IIMFKN7q5A1OANeePpdDvaOM+kLUzkuvlkNqZ2zGACYm4zGdcQYUFWVWaMYfGpvUGWPJbK254yU2AL54VTkleQ6CikxrMofNIk5oZJzpPcg2RtcPxrdBL/rNECUDMh0sHpSTr7IsxMw74+qiieUjY5MR6qoW6Se3nTZLSmdsm8bIWC8D9o8Xo+sH49ugF/2mM86AV199NaPzQymcMZYUx6eBq0+bPA0iiBZhTwen3ZpynPF0pikyvQfZxuj6wfg26EW/mabIgKlM2hj2BujXlvvJz7Hx/N6jvNPqw70k+TknIjK2JBj5EGtWODJO1C4RamQ8ubOdTmc81YkzesPo+sH4NuhFv+mMM0CkOyUN6B3xs/fYECHpZZZb4Y4n92F1d0x+UpZyxrGJCoE2ukKk50Bz0oiMHdOYM57KPdAjRtcPxrdBL/rNNEUGxC5XngohoCDHjmIZ4NBQEwC5cx+Z/JwT4IwTvQ1jAwWLRaCkv6YoTpsFW4p+Prtt+t52U7kHesTo+sH4NuhFv+mMM2Dnzp1TPkdBMuzvT6/xCUhTJPqBFrvPIsSUfsY5bRZsqdIU0zgd+njugZ4wun4wvg160W864wzo70/TqcYgZSjppIrxCDHzuaxUM5OtYoodeDZrwpxwnjMaLk9nZHw890BPGF0/GN8Gveg3nfEJJiS1ou2W1AXlTwSJhqHFRsIWiyXtmhQATrslYVW22ODaMY3O2MTk/YL5qciA2traKZ8Tkuqy4BZb+nWMZ5LURX3U/+n2cTht1pTO2DmNoymO5x7oCaPrB+PboBf95miKDOjr66OgoGDSNlJKVv929YT9eYtmStXUSDQMLT5nbEGmnaSAHLsFRwJnG5uacdimr/c6nXugZ4yuH4xvg170m5FxBhw6dChlm9DQ0UmPBwZOw9t5Gc7AxJlw/oG645WWNqmGoQmh5otFmg7ZabMkzBnHpymmb428dO6BnjG6fjC+DXrRb0bGM4z82elQXZL0uLfjSpB2zh8McY/9Qc723k87s5O2H4/NIggmWCIpXWbl2ifsm1+cS9WsHNoHvLjsVrz2iYuTJqOmNI/cBAuXlrqdtA+MATCveOIXj4nJBx3TGWfAwoULU7aRgVEguTNGqs6wAA8Aw0zuqD5XP4+GA918/sz5HBvwcsnJ5fgCIXa0DuDxh3hudwenLygi12HjstUVePxB3E4rv9/aykdOruC5d45R4LITDEnmu0NcuqqCshtzyLFbGfD4kRLOWlzCLR9azP7OEeaX5DKvODeSZHjpG+sZ8YXw+IKM+IOU5jkByVhAYXAswMUryxnzBwkpktXVhVgsgp5hH6sqC3lqRzv9Hj+fP3NB6hc3TdK5B3rG6PrB+DboRb/pjDMgPz8/ZRslzZ6vfKE64xFyJ2134Ull/NvHT56w/9xlcwC44yOJVwU5o6YUgItXlkf29ff347BZOHPhxC8LZ76V0nx1AdRYExbPSW2zO8fOl9bVTNh/8/mLU547VdK5B3rG6PrB+DboRb+ZM86AdAaLJ0sgWKXkifZjke18xhiROSgpbklpvnPS41NBL4PdM8HoNhhdPxjfBr3oNyPjGSaZM95xqDVuOx8PwymiYoA50+iMTUxM9IMZGWdASckkuWCNdMs65AsPwzKNjq1prGmSjn69Y3QbjK4fjG+DXvSbkXEGrFy5MmUbJYHztMaM81oujgBQJvrTioynk3T06x2j22B0/WB8G/Si34yMM2DTpk0p2ySaMFEYUwbteeftPO+8nVpLMz2ycFr1pSId/XrH6DYYXT8Y3wa96Dcj4xkmUZqiIBTd+xX/1yOPdyipRxtMZ8UzExMT/WA64wyw2VK/fImccX5MZPyCckbC83708ZPpGfUx4AlgtwqWlRcAkqI8x3GqnUg6+vWO0W0wun4wvg160a8PFQZl3bp1KdvIBDnjPJm6W6+swMm19fOOR1bapKNf7xjdBqPrB+PboBf9WfvNK4QoFkK8KIRo0v4nXC9bCPG8EGJACPHMuP01QoitQohmIcTjQgiHtt+pbTdrxxfMlA3bt29P2UZJkDPO06Yvvz1JWiJVNbXpIB39esfoNhhdPxjfBr3oz2YC8nZgo5RyCbBR207EPcDnE+y/G7hXSrkY6Ae+rO3/MtCv7b9XazcjDA0NpWyTKAaeG1DLaH7c/4Ok550IZ5yOfr1jdBuMrh+Mb4Ne9GfTGV8BhBeBewS4MlEjKeVGYDh2n1BXEPwQ8ESC82Ov+wRwgcjiioPjJ32c4vVxS/9AyvNOhDM2MTHRD9l0xmVSyvB84A6gbArnlgADUmqV2qENqNIeVwGtANrxQSat1HP81NWlLnEZO874FK+P3x3rJJ0uuBPhi9PRr3eMboPR9YPxbdCL/hntwBNCvASUJzj07dgNKaUUJ2LBt3EIIW4EbgSorKykoaEBUKs45efnR+asl5SUsHLlysh4RJvNxrp169i2bVtkiaK6ujo6OztpbVWnOS9ZsgSn05n2DLzxdDft4JhrJVarlb179wJQXl5OTU0NW7ZsAcDlclFfX8/WrVsZG1PLU65du5aWlhY6OjoAWLFiBaFQiP379wNQVVVFdXU1W7duxefzUVJSQl1dHVu2bMHnU5eCWrduHQcOHKCrqwuAVatW4fP5aGpSV7WeO3cuZWVlNDY2AlBQUEBtbS2bN28mGFS/H9evX8+ePXvo7e0FYM2aNQwPD3Pw4EEAFixYQHFxcSRfV1RUxJo1a3j11VeRUiKE4Nxzz2Xnzp2RNcpqa2vp6+uL1J9duHAhg4ODkedIdp+2b98e+Sma7D7t3r0bgDlz5rB06VI2b94MgNPpZO3atTQ2NjIyMgJAfX09bW1ttLe3A7Bs2bLjvk+HDx/G6XROep8A3G63bu9TdXU177333qT3KZ3PU7bu0+uvv47T6cz485TsPqWLmMrKv9OJEGI/cJ6U8pgQogJokFIuS9L2POA2KeVHtW0BdAPlUsqgEGIt8D0p5cVCiBe0x1uEEDbUqHu2TGFoXV2dDL9p06WhoYHzzjtv0jat/1bCR+ZWAlDr9fLIMfWDU+/9GZ0UJz3vTzefxanzEvZpThvp6Nc7RrfB6PrB+DbMtH4hxDYpZcrwO5tpiqeB67TH1wF/TvdEzbG+Alyd4PzY614NvJzKEc8kySLjyRwxgCV7aW4TE5MskE1nfBdwkRCiCbhQ20YIUSeEeCjcSAjxGvAH1I64NiHExdqhbwHfEEI0o+aEH9b2PwyUaPu/QfJRGhmzZMmSlG0S1abwSH1UXktHv94xug1G1w/Gt0Ev+rM26UNK2QtckGB/I3B9zPY5Sc4/CEyYvial9AKfnD6lyXE6UzvV2JA8nBUPpvEdeCIC43T06x2j22B0/WB8G/Si3yx0kAHhzoTJiJ30ISL70nDG01krMwnp6Nc7RrfB6PrB+DboRb/pjGeYRDnjRLPyxmOmjE1MPliYzjgD5syZk7JNbG2K8MNQipf99kuXs6pq5stppqNf7xjdBqPrB+PboBf9pjPOgKVLl6ZsExsZV2hjO1OlKXJsJ+a2pKNf7xjdBqPrB+PboBf9pjPOgPCA88mIdcb/3KsOik8VGZ8o0tGvd4xug9H1g/Ft0It+fXiF9ym9w964lT5c2nDndDrwTExMPliYXiEDUg2J6R8LxI0zjoymSFTkOAvoZUhPJhjdBqPrB+PboBf9pjPOgLVr1056XFESj6bQS5oilX4jYHQbjK4fjG+DXvTrwysYlFS1LBQp4yd9hPeneNlPVMXPqdbi0CNGt8Ho+sH4NuhFv+mMMyBcHSoZIUUmXB1aLznjVPqNgNFtMLp+ML4NetGvD6/wPkVRZMLaFHpJU5iYmOgH0ytkQH19/aTHg+PSFGH0Ehmn0m8EjG6D0fWD8W3Qi359eAWD0tbWNunxkCKPazr0iZoKnUq/ETC6DUbXD8a3QS/6TWecAeEVBJKhyMTOWC9pilT6jYDRbTC6fjC+DXrRrw+v8D5FUSQyQZibKk1RU5o3U5JMTEx0StbqGb8fWLYs4SpRERQJt8+euBZqCAuP3lDPWYtKCYYUgookpEhyHVa8AQWXwzpTkuNIpd8IGN0Go+sH49ugF/1pR8ZCiKVCiI1CiN3a9mohxL/MnDT9Y7VO7jS7vZ30J2gTm6awWS3k2K3kOW0IIU6YI4bU+o2A0W0wun4wvg160T+VNMWvgDuAAICUchfw6ZkQZRTCq8wmJWYoxf+1H4vZLXSxxl1K/QbA6DYYXT8Y3wa96J+KM86VUr41bl9wOsW83wjFOOOyYChmv+UErONhYmJiJKbijHuEEIvQ4j0hxNXAsclPeX9TXl6e9Nh7/e/RMtAc2S5SouMq9DKaYjL9RsHoNhhdPxjfBr3on0oH3teAB4HlQoh2oAX47IyoMgg1NTVJjw35h+j19gFgkfGToiXihNWfmIzJ9BsFo9tgdP1gfBv0oj+tEE0IYQHqpJQXArOB5VLKdVLKwzOqTuds2bIl6TEFhUBIjYb/vbt33LHsO2KYXL9RMLoNRtcPxrdBL/rTcsZSSgX4f9rjUSnl8Iyqep/gD6l54vE/P0JYsOjDH5uYmOiEqSQvXxJC3CaEmCuEKA7/zZgyA+ByuSY9Hgj4AbDK+AoVEosuVn9Opd8IGN0Go+sH49ugF/1TyRl/Svv/tZh9Elg4fXKMxWQFRhSpEPJ7gYnfeHpJU+ilQEomGN0Go+sH49ugF/1pR8ZSypoEfx9YRwywdevWpMckkqA2gsI2ITIWoAOHPJl+o2B0G4yuH4xvg170px0ZCyHswE3Aem1XA/CAlDIwA7oMwdjYWNJjUkoC2kDjRJGxHtIUk+k3Cka3wej6wfg26EX/VNIU/wXYgV9o25/X9l0/3aLeF0gIKKoztsoJh3QQF5uYmOiJqTjj06WUa2K2XxZC7JxuQUZisoUMJRKkGhNbmdiBpwf0shBjJhjdBqPrB+PboBf9U/EKIW0GHgBCiIVAaJL273taWlqSHrNZbBGnO74MieTELTo6GZPpNwpGt8Ho+sH4NuhF/1Sc8TeBV4QQDUKIV4GXgX+aGVnGoKOjY9LjQS1NMb4DT0EftSlS6TcCRrfB6PrB+DboRX/aaQop5UYhxBIgXPxzv5TSNzOy3h8EFQUsE7/x1Mg4G4pMTEz0ylTqGX8NcEkpd2nlM3OFEDfPnDT9s2LFikmPh4e2TZz0IRA6iI1T6TcCRrfB6PrB+DboRf9U0hQ3SCkHwhtSyn7ghumXZBxCoclT5oPqnI8JOWO9TPpIpd8IGN0Go+sH49ugF/1TccZWEdPrJISwAo7pl2Qc9u/fn/RY7KSP8UPb0Mk448n0GwWj22B0/WB8G/SifypD254HHhdCPKBtf0XbZ5IEIdRv3PFD2xSpA09sYmKiK6YSGX8LdQTFTdrfRrRKbseDVmjoRSFEk/a/KEm754UQA0KIZ8btrxFCbBVCNAshHhdCOLT9XxRCdAshdmh/MzYppaqqKukxGQoipboQyvjIuItZuoiMJ9NvFIxug9H1g/Ft0Iv+qdSmUKSUv5RSXg3cCGyRUmaSbLkd2CilXILq2G9P0u4e1Nl+47kbuFdKuRjoB74cc+xxKeUp2t9DGWiclOrq6kmPq5VHJ0bG9wWv1kUHXir9RsDoNhhdPxjfBr3on8poigYhRIFWNnMb8CshxL0ZPPcVwCPa40eAKxM1klJuBOLqJ2u56w8BT6Q6fyaZtMCIlEgS54wDU8oOzRx6KZCSCUa3wej6wfg26EX/VNIUhVLKIeATwG+llPXABRk8d5mUMryGXgdQNoVzS4ABGc4DQBsQ+1vjKiHELiHEE0KIuRlozIAYZxyz9zP8CDDHGZuYmMQzlRDNJoSoAK4Bvp3OCUKIl4BEq/3FnS+llEKICWMOjpMNwGNSSp8Q4iuoUfOHkui7ETXlQmVlJQ0NDQAsXLiQ/Px8du5US2+UlJSwcuVKNm3aBIDNZmPdunUEAoHIOXV1dXR2dtLa2qpeuyiElOFCQVHTDgn1J9GuXTs5qeIcGhsbGUfVIQcAACAASURBVBkZAdS6qm1tbbS3twOwbNkyrFZrZCnx8vJyampqIsvEuFwu6uvr2bp1a6Ty1Nq1a2lpaYnMKlqxYgWhUCjSY1xVVUV1dTVbt27F4/HQ2NhIXV0dW7ZswedT5/CsW7eOAwcO0NXVBcCqVavw+Xw0NTUBMHfuXMrKymhsbASgoKCA2tpaNm/eTDCofj+uX7+ePXv20NurLjm1Zs0ahoeHOXjwIAALFiyguLiY7du3A1BUVMSaNWt49dVXkVIihODcc89l586d9Pf3A1BbW0tfXx+HDh2K3CeHwxG5B8nu0/bt2xkaGkp4n5YsWYLT6WT37t0AzJkzh6VLl7J582YAnE4na9eunbH75PF4aGhomPQ+Abjdbt3eJ7fbnfI+pfN5ytZ9Ct+DTD9Pye5Tuggp0/OBQohPAv8KbJZS3qzVprhHSnnVlJ4xer39wHlSymOak2+QUi5L0vY84DYp5Ue1bQF0A+VSyqAQYi3wPSnlxePOswJ9UsrCVHrq6upk+E07HWxtfY2vPfk0vqLnee1wG7O0YW7ni4doGcvlha+vZ1l5/rQ9n4mJiT4RQmyTUtalajeVDrw/SClXSylv1rYPxjpiIcQdU9T4NHCd9vg64M9T0CKBV4Crx5+vOfYwlwPvTlFX2ky2kKH0j0Q78GK+8C4rU6OHOfnOmZKVNnpZiDETjG6D0fWD8W3Qi/7prOX4ySm2vwu4SAjRBFyobSOEqBNCREZACCFeA/4AXCCEaBNChKPfbwHfEEI0o+aQH9b23yqE2KOV97wV+OLxGpSKZD9DpJT84O378Be9CMTngv5paS/7/vUcivKyP19mqj+j9IjRbTC6fjC+DXrRP53d+lPqkpJS9pKgA1BK2UhMwXop5TlJzj8InJFg/x3AVKP0aSUog7SOHkX45vHZsQFcMZGxEJBjHz9B2sTE5IPOdEbG09UBZxjWrVuX+ID2SljGFrPOk3viBE2RpPoNhNFtMLp+ML4NetE/nc74AzdY68CBAwn3S80bS5nsRdHHS5VMv5Ewug1G1w/Gt0Ev+qcy6ePsFPv+MC2KDER4SNF4Is4YoRe/m5Bk+o2E0W0wun4wvg160T+VyPink+2TUt6ZuZz3B5HhglJg+eBlb0xMTI6DlB142hjes4DZQohvxBwqYGKp3g8Uq1atSrg/LjIej0A30++S6TcSRrfB6PrB+DboRX86oykcgFtrGztLYYjoON8PJJMNbVP/66NucTL0MqQnE4xug9H1g/Ft0Iv+lM5YSvkq8KoQ4jdSysMAQggL4NZqVXww8fTRtGcHVYHDgAL2PHV/YAxCHgDy8VDv/Vv2NKagqalJN+UDjxej22B0/WB8G/Sifyo54x9pVdvygN3AXiHEN2dIl/4ZPgZKEIaPwmAbBD3q33A7yqA6F76KniQn6zhcNjExyQpTccYrtEj4SuA5oIbEdYY/MMwtEIAEqwPsueof0ZzxtJU+miHmzs1SQbtpxOg2GF0/GN8GveifijO2CyHsqM74aSllgA/gRI9YypLM54gMpkizCFO2KCubStVSfWJ0G4yuH4xvg170T8UZPwAcAvKATUKI+aideB9YGjsSO9twZJz4xdVPimI6q9RlC6PbYHT9YHwb9KI/7doUUsqfAD+J2XVYCHH+9EsyODH+2aoVl5+AnodYmJiYZIWpzMArE0I8LIR4TtteQbQE5geSAgcJEzWTR8b6oaCgINsSMsboNhhdPxjfBr3on4q/+A3wAlCpbR8Avj7dgoxEbXnily/sn5NGxjqhtrY22xIyxug2GF0/GN8GveifijMulVL+H6geRlt/LpPVoQ3P5rbEzjYaGSfKKQv0kjcOL1ljZIxug9H1g/Ft0Iv+qTjjUSFECVrgJ4Q4ExicEVUGIZgk8FUUzRknG00h9JHACK+DZmSMboPR9YPxbdCL/qkUl/8G6lJJC4UQrwOz+YBPh06MRDpcQJLIePGFYJ3Omv4mJibvB6biFfYCfwI8wDDwFGre+APL+rkCQhMdrhRq/SSrSBA6V58207LSZv369dmWkDFGt8Ho+sH4NuhF/1R+L/8WWA7ciVo6cynwu5kQZRT29CROQyiT5oz1w549e7ItIWOMboPR9YPxbdCL/qlExquklCtitl8RQuydbkFGoncMKJq4P9KBNz5nvOLKmRc1BXp7e7MtIWOMboPR9YPxbdCL/qk44+1CiDOllG8CCCHqAX1MXdETMQ7YFhsZf/yBLIgxMTExCukUl38HdQTF/9/emcdXVZ17//tkThhCBmQKJSABJECQhOklQtoqFEWUar1aK9T7Wt56tRVbK7Zonep96cVrq8XWVq8Dt06vWseqFSio4SKIzCAQhigBGWRMQuaz3j/2PoeTcA4Zzkn2Wrq+n88he689nN9v78Nz1ll7rWfFA/8jIp+76/2Abe0rT29GdIdT9TUQ64MGNydqQy2Vbo+/vrHhsrbpQV5entcSIsZ0D6brB/M96KK/JTXjae2uwlAOV9dyoKGU2NgEwA3Glfs4pJxg7H+Qpyvl5eWkpYVoZzEI0z2Yrh/M96CL/mYf4CmlPjvbqyNE6krZyThiiSEtrhNpiV2cV1wKqXFO17Zk9Oi/GI7du3d7LSFiTPdgun4w34Mu+vUYffCVQgWajRNUrbdSLBaLMdhg3FaUoneXekJlCqpzR+Cdo/R4ShuO7OxsryVEjOkeTNcP5nvQRb8NxhHQNSn0eOj6BqdcjwwU4UlPT/daQsSY7sF0/WC+B13022DcVkTYdjjByTMRF3+6PLkbKsGZnFT3YLx27VqvJUSM6R5M1w/me9BFv02SEClde0FCUD7UpFRUTTUAovkIPIvFog+2ZhwBXRJ9Ts24ycwd/hBcS2LHi2oFOnTniRTTPZiuH8z3oIt+WzNuK0oxKLOOzWG2AVRJClz5O9i/rkOltRRdOrtHgukeTNcP5nvQRb+tGUfA2n0JIctV4G8MdOsLbhuybrz//vteS4gY0z2Yrh/M96CLfhuMIyB8i7By/9X78qpwye8NwnQPpusH8z3ool/vaKEzImF7S5yuGevdn0K+ArNUm+7BdP1gvgdd9Ntg3FaUYlTvGkKFZBUIx3pf3kmTJnktIWJM92C6fjDfgy769Y4WmrPjSHzIcp/7s0dpMtddODZs2OC1hIgx3YPp+sF8D7ro9yxaiEi6iCwWkRL3b8j+JSLyrogcF5G3mpTfLCI7RUSJSGZQuYjII+62jSLSbvNwl9eEu3xmtBkfO3bMawkRY7oH0/WD+R500e9ltLgDWKqUygGWuuuhWABcF6J8BXAh0DRz3FQgx33NBv4UFbWt4PTjAL2DscVi0Qcvo8VlwDPu8jNAyDmJlFJLcSZAbVq+TilVGua8i5TDR0A3EekVHcmNGZwZLiubv2asx4OBcIwa1W4/GjoM0z2Yrh/M96CLfi+DcQ+l1Bfu8gGgR5TO2wfYG7Re5pZFnZPhmika3DzGmrcZHz161GsJEWO6B9P1g/kedNHfriPwRGQJ0DPEpnnBK0opJSId3tlPRGbjNGXQu3dvli9fDsCAAQPo0qVLoGE/IyOD3NxcPvjgAwDi4uIoHNiNPcfiUeWxlEsMPXr7OFUplJ8QUvZ/ArFQQyLLPz0ENf04hzgGpdZT7L5HYmIi48ePZ82aNVRUVAAwduxYysrK2LdvHwCDBw8mNjaWrVudeV979uxJ//79WblyJQDJycmMHTuWVatWUVVVBcD48ePZs2cPBw4cAGDo0KE0NDSwfft2APr06UNWVharVq2ioqKCL7/8koKCAlauXElNjTNbSWFhITt27ODQoUMADBs2jJqaGkpKSgDo27cvPXr0YM0aZwrErl27MmrUKIqLi6mvd76IJk6cyJYtWwKTPebl5VFeXh5I5J2dnU16enogSUtaWhp5eXm8//77KKUQESZNmsSGDRsCbXqjRo3i6NGjlJaWBu7Tzp07A+sh71NhIWvXruXkyZMAFBQUcPDgQfbudb6vc3JySExMZPNmZyzlOeecw6BBgyguLu6Q++TXf7b7BNC5c2dt75NSihMnTpz1PjX7/8nD+7R582ZKS0sj/v8U7j61FPGqw7OIbAeKlFJfuM0Iy5VSg8PsWwTcppQ6YwooESkFCpRSX7rrf3bP9XzT9zmbnoKCAuX/0LaIA5tZum4Hib3LSUvs0mjTwU/+m1vqd5JXczV/vXgK7FwKaf2cjXlXt/w92pnly5dTVFTktYyIMN2D6frBfA/trV9EPlFKFTS3n5e/o98AZrnLs4DXo3jemW6vinHAieYCcVvp0zXMtEruF1x9TFJ7vG3UGDBggNcSIsZ0D6brB/M96KLfy2A8H7hIREpwekXMBxCRAhF5wr+TiHwIvAR8W0TKRGSKW/5TESkDsoCNQce8DewGdgKPA//WXgZS4kMnl/cP+gg/Rk8PunTp0vxOmmO6B9P1g/kedNHvWTBWSh1RSn1bKZWjlLpQKXXULV+jlLohaL8LlFLdlVLJSqkspdQ/3PJH3PU4pVRv/zFuL4qblFLnKqWGK6Va0fbQOkqOhE4UhCHBWJfO7pFgugfT9YP5HnTRr/fjfkPx14xjNBnzbrFY9McG4whIDTMHnv+ZqO6xOCMjw2sJEWO6B9P1g/kedNFvg3EEnJsWbtCHf0JSvaNxbm6u1xIixnQPpusH8z3oot8G4whY+8XZe0voHYoJ9PM0GdM9mK4fzPegi34bjNsBf9/tWN3bKSwWizbYYBwBsWFirf8BXkK4HTQhLs78KRBN92C6fjDfgy76bTCOgJG9qkNvcB/gxcfoHYwLCwu9lhAxpnswXT+Y70EX/TYYR8C2w6H7GfuTy+sejP35BkzGdA+m6wfzPeii3wbjCKisC335/G3GcZq3GfuTspiM6R5M1w/me9BFvw3G7YC/Zhyrec3YYrHogw3GEXBeZlXI8gb3b2zHZwVtFQUFzSaS0h7TPZiuH8z3oIt+G4wj4GhVmKew/maK+soOVNN6Dh486LWEiDHdg+n6wXwPuui3wTgCDlaefXZozXu2BRJ3m4zpHkzXD+Z70EW/DcbtgB30YbFYWosNxhGQ1TV0bgp/+qA4za9uTk6O1xIixnQPpusH8z3ool/zcKE3CbFhHtAZ0rUtMTHRawkRY7oH0/WD+R500W+DcQTsPhb6JprSZuyf3NFkTPdgun4w34Mu+m0wjpQQAdefm0L3mrHFYtEHPTJkGEpaUj2nQpT7k8vrPujjnHPO8VpCxJjooa6ujrKyMqqrq0lPT+fTTz/1WlJEmO4hWvqTkpLIysoiPj50L6vmsME4Ar6RWss2d9mnfByqOQ7AUXGGfejeTDFo0CCvJUSMiR7Kysro0qUL2dnZAIjhv6CUUkZ7iIZ+pRRHjhyhrKyM/v37t+kctpkiAjYcTAksL/rsXeZseJg5Gx7mT0lOUE6K0fu7rri42GsJEWOih+rqajIyMhARKioqvJYTMaZ7iIZ+ESEjI4Pq6jCZHFuA3tHCII7XVZAW34Vr+l5E7OaldDvxJd3PyfRalkVTTK5JWkIT6T21NeO2ktCJ+BiFP3mxT/noFJfMxO55TKpNoeCUOp1CMykVug9xXhqhS5eeSDDdg25BOTs7my+//LJVx+jmobXoot/WjNtKUirD+8aypd5Z9aGICdxUHwo5PegjuRv0HumFyrMyfvx4ryVEjOkeOnfu7LWEiDHdgy76bc04Aj794vSyT/mI8V9OhROM9fjCDcuaNWu8lhAxpnuorPQumdTll19Ofn4+ubm5/OUvfzlj+/3338/gwYMpLCzkmmuu4cEHHwx5Hi89RANd9NuacQRU1YH/R7JPna4ZK6VQiPZd20x/8ALme/D5fM3v1E48+eSTpKenU1VVxejRo7niiisC2z7++GNeeeUVNmzYQF1dHaNGjSI/Pz/kebz0EA100W+DcZTwEVwzdoZ9xGuez9jy9eaRRx7h1VdfBZzMZSUlJYFtK1as4LLLLiMpKYmkpCQuvfRSr2R+bbDBOAKG9oJd7nJwzRgUPmKI1bwRaOzYsV5LiBjTPXTq1MmT912+fDlLlixh5cqVpKSkUFRU1OZuWV55iBa66Nc8XOjN4fLTyz7lI0acy+nzOX0sEjUf9VFWVua1hIgx3UNtbejMf+3NiRMnSEtLIyUlhW3btvHRRx812j5hwgTefPNNqqurqaio4K233gp7Lq88RAtd9NtgHAGHg5orfShi3EQVtQ0KENIS9G6m2Ldvn9cSIsZ0D3V1dZ6873e+8x3q6+s577zzuOOOOxg3blyj7aNHj2b69OmMGDGCqVOnMnz4cFJTU0OeyysP0UIX/baZoo00KKit91FeUctJdYqa+gYSYuLZd7yK7g0N+CQG0fwBnuXrS2JiIu+8884Z5aWlpYHl2267jXvuuYdTp04xceLEsA/wLNHBBuM2UtfgIz6uij0nKqnxHaeirprUuDi+OFHNOb566on1WmKzDB482GsJEWO6B50HrcyePZutW7dSXV3NrFmzGDVqVMj9dPbQEnTRb4NxBAjw5ol3KKtxOhz3SEwHIJYGagy4tLGx+n9hNIfpHnQZ/RWK5557rkX76eyhJeii37YZR0BVXRJVDdX0iu/J9zKncVn3CwHI8B2jQfQPElu3bvVaQsSY7iGSxDK6YLoHXfTbYBwxiq6xXRjWaQjd4rsC0M13ki64o3qUHh3KLRaL3uj/W1pj4mPr3DRBjX/m1BPLbvrQM30gpGdDbIIH6pqnZ8+eXkuIGNM9xMWZ/1/QdA+66NdDhaEkxNXiDHxuHIzjaOCkdMZ3zlDolAydMjxSeHbamgRbJ0z3oMvDo0gw3YMu+j1rphCRdBFZLCIl7t+0MPu9KyLHReStJuU3i8hOEVEikhlUXiQiJ0Rkvfv6dXt5qKzp5AbjxsRTT50B33MrV670WkLEmO7BqyQ1paWlDBs2LCrnaomHp59+mptvvjkq79eU1mZdW7x4Mfn5+QwfPpz8/HzefvvtwLZPPvmE4cOHM3DgQH7605+iVMeNFfCyzfgOYKlSKgdY6q6HYgFwXYjyFcCFwGchtn2olBrpvu6LitqzEhSOlXKCscSfUWO2WL6O1NfXey2hEZmZmbz55pts2rSJZ555htmzZwe23XjjjTz++OOUlJRQUlLCu+++22G6vAzGlwHPuMvPAJeH2kkptRQoD1G+TilV2m7qWoCID6VoFHRjlDP/XT1xaNJjJizJycleS4gY0z142a2qoaGBH/3oR+Tm5jJ58mS2bNnSqC9xSUlJYD07O5vbb7+d4cOHM2bMGHbu3AnA4cOH+cEPfsDo0aMZPXo0K1asAOCee+7huuuuY8KECVx3nVOX2rt3L0VFReTk5HDvvfcG3idcKs/OnTszb9488vLyGDduHAcPHgRgz549jB8/nuHDh3PnnXeG9ffDH/6QH//4xxQUFDBo0KDAkO7zzz+f3r17A5Cbm0t1dTU1NTV88cUXnDx5knHjxiEizJw5k9deey3i69xSvPwt3UMp5c8IfADoEcVzjxeRDcB+4Dal1JYonjtAp8RTgI+U2hP0PryBxLgYUiqd+aLrRP9mCtOT7ID5Hv5z2Wds3X8yqucc2rsrd1+a2+x+JSUlPP/88zz++ONcddVVrFu3jtTUVNavX8/IkSN56qmnuP766wP7p6amsmnTJhYtWsScOXN46623uOWWW/jFL35BYWEhn3/+OVOmTAnMtLx161aKi4tJTk7m6aefZvXq1WzevJmUlBRGjx7NJZdcQkFBQchUnhkZGVRWVjJu3DgeeOABbr/9dh5//HHuvPNObrnlFm688UZmzpzJo48+elaPpaWlrF69ml27dvHNb36TnTt3kpSUFNj+yiuvMGrUKBITE9m3bx9ZWVmBbVlZWR063L5dI4aILAFCPe6eF7yilFIiUcs3uRbop5SqEJGLgdeAnDD6ZgOzAXr37s3y5csBGDBgAF26dGHDhg0AZGRkkJubywcffAA4T1/zhw/h5KmuxDY00Kd8B+N2NU60cpxUThw7xsaPtwPOlPKDBg0KTKCZmJjI+PHjWbNmTSAn79ixYykrKwt8AAYPHkxsbGygL23Pnj3p379/oJ00OTmZsWPHsmrVKqqqqgBn5os9e/Zw4MABAIYOHUpDQwPbtzs6+vTpQ1ZWFqtWraKyspIePXpQUFDAypUrqampAaCwsJAdO3Zw6NAhAIYNG0ZNTU0gxWLfvn3p0aNHILF7165dGTVqFMXFxYGfpBMnTmTLli0cOXIEgLy8PMrLy9m9ezfg1LTS09NZu3YtAGlpaeTl5fH+++8HZuudNGkSGzZs4NixYwCMGjWKo0ePBobsDhgwgM8++4yGhoaw96mwsJC1a9dy8qQT8AoKCjh48CB79+4FICcnh8TERDZv3txh9yk1NRWfz0dNTQ01NTU0NDQQE+NPMuXzfzaJiYkJeBOBmJjYwDo4A158Pl+gXdN/jrraOsrLy4mPjyc+Pp5Tp04Ftnfq1Iny8nIqKiro168feXl5nDp1imHDhrF9+3auv/56nnjiCX7zm9/w/PPPs2LFChoaGlBKcemll3Lq1CmuueYa5syZQ3l5OYsXLw5cO3ASEJ04cYL6+nqmTJlCfX19wGNRUREJCQkopZgxYwZLlixh8ODBLFiwgLfffhufz8fevXtZv359YN9JkyZRXl5OXl4eS5cupby8nOLiYv7617+ilOLyyy9n7ty5VFRU0LlzZyorKwPX0P8+lZWVgXuyadMmhgxxpj/bsWMHc+fO5eWXX6a8vDxwnSoqKlBKcerUKZRSVFVVBT7XSUlJKKUC/1fi4+NJSEgItJv7y4P/P7UYpZQnL2A70Mtd7gVsP8u+RcBbYbaVAplnOfas2/2v/Px81RpOHT2gVi26U016aoS68w/Zqvjl29WH785XH747X/3r/31EFf77y+pYZU2rztnRLFu2zGsJEWOih61btwaWT5486YmGPXv2qNzc3MD6ggUL1N13362qqqpUTk6Oeu2119T3vve9wPZ+/fqp3bt3K6WUqq2tVRkZGUoppTIyMtShQ4fOOP/dd9+tFixYEFh/6qmn1MyZMwPrd911l/r973+vli1bpiZMmKAqKyuVUkpNmjQpcE87deoU2P+ll15Ss2bNUkoplZ6erurq6pRSSp04cSKw369+9SuVl5en8vLylFJKzZo1Sz355JOBc1xwwQVq/fr1Siml9u7dq3JyclRxcXHgHuzfv18NHjw4sP9zzz2nZs+e3fzFDCL43voB1qgWxEQv24zfAGa5y7OA16NxUhHpKW5DnIiMwWkXPxKNcwfTsHclY3Y9QmxDLUpiOJjan8MpmRxOyWQn5xAbY8fTWMwjKSmJKVOmcOONNzZqogB48cUXA3/9cw9OnjyZP//5z4F91q9fH/bcixcv5ujRo1RVVfHaa68xYcKEZlN5hmLChAm88MILADz77LOB8gceeID169c30vDSSy/h8/nYtWsXu3fvZvDgwRw/fpxLLrmE+fPnM2HChMC+vXr1omvXrnz00UcopVi0aBGXXXZZs3qihZcRYz5wkYiU4PSKmA8gIgUi8oR/JxH5EHgJ+LaIlInIFLf8pyJSBmQBG4OOuRLY7LYZPwJc7X47RZWjFc5P1Nq4FD7LGEk5DcTFxNI1rjPxEm9EMDZ9Mk8w34Muic2Dufbaa4mJiWHy5MmNyo8dO8aIESN4+OGH+d3vfgc4s4Vs3LiRESNGMHToUB577LGw5x0zZgxXXHEFI0aM4IorrqCgoKDZVJ6hePjhh3n00UcZPnx4s2263/jGNxgzZgxTp07lscceIykpiYULF7Jz507uu+8+Ro4cyQUXXBBokvvjH//IDTfcwMCBAzn33HOZOnVqs3qihbRDnDKSgoIC1ZrJLT9bsZB+i+cxYcAgspMGMjm9kCGp3yAtLpUrXy0nu1sci378Tbql6Dn6DmDbtm2B9jNTMdHDp59+ynnnnQdAVVWVdj1CHnzwQU6cOMH9998fKMvOzmbNmjVkZmaesb+OHsDpTTFt2jSuvPLKs+4XTf3B99aPiHyilCpo7lj9H/lriwr8Kwj+r7R1Bxs4WQs+A77jDhw4YFwga4rpHnTrgztjxgx27drFP//5zxYfo5uH1qKLfhuMI0ThzH2X6E54V17rROHvDtavpmCxNId/gtKmBCedN4Wnn37aawmtQv+GTW05XfVNio8lxp3vzl/aLVn/Szt06FCvJUSM6R6C+7yaiukedNGvf8TQFH+v6KaJgvzNEybMuBTcZ9VUTPfwVXhmY7oHXfTbYNxmgtuM/Qj++2pALA4MBDEZ0z20emCAhpjuQRf9Nhi3FeUPxqpRfgGfCpXh2GKxWM6ODcYR0jT0+n/wmNBM0adPH68lRIzpHuLj4z1532im0GyJB51SaPr5/PPP6dy5MwsXLgyUvfvuuwwePJiBAwcyf/78aElsETYYR0zjfMb+NmPdM7YBjZKimIrpHhIS9O2H3lKa86BL17Gm/OxnP2Pq1KmBmT4aGhq46aabeOedd9i6dSvPP/98h86xaINxm2nczzhQalCb8apVq7yWEDGme/AquTxEL4XmjBkzjEqhCfDaa6/Rv39/cnNzqa2tBWD16tUMHDiQAQMGkJCQwNVXX83rr0clS0OLsP2M24q/zVg1foR3upnChHBs8ZrEZXfDkSg/hOw5HKY2/xM7Wik0b7rpJiZPnmxMCs36+np++9vfsnjxYh588MHAvvv27aNv376BdX92w47C1ozbiATXjOXMrm0C2s/00da2Np0w3YOXyeX79+/PyJEjAcjPz6e0tJQbbriBp556ioaGBl588UW+//3vB/a/5pprAn/96UGXLFnCbbfdxsiRI5k+fTonT54MpBqdPn16o2HGF110ERkZGSQnJ/Pd7343kKb0kUceCdR+9+7dG0jVmpCQwLRp0xrpA1ixYkVAi7/WHY6rBhqKSAAAEQRJREFUrrqKmJgYcnJyGDBgANu2beOee+7h1ltvDXx2vLwHwdiacYQ0nQNPGdRmXFDQ7HB57THdQ/yl/+nZewdPxBkbG0tVVRVXXHEF9957L9/61rfIz88nI+P0ZLrBQcu/7PP5WL16dciBE02TIDUNeiLC8uXLWbJkCStXriQlJYWioiKqq6sB58Gg/5jY2NhGbc+hAui8efP4+9//DpzOHhfqPVetWsXLL7/M7bffzvHjx4mJiaFr167k5+cH8lwDlJWVdegDYlszbitKsT0hnnp8jQd9uH9N6E1h+mSeYL4Hfy1SF9qSQjP4p74JKTQ//PBDSktLKS0tZc6cOfz85z/n5ptvZvTo0ZSUlLBnzx5qa2t54YUXmD59eguuWnSwwbjNKN5LSQGgf/LpJ/omPcDTpbN7JJjuQZfRX8G0NoXmunXrjEqhGY64uDgWLlzIlClTOO+887jqqqvIzW1++qpoYVNourQ2hebe9xfw6vo/8ES3bvxHzlxO1JeTnZzF8t1J/GldDU9O60b+qDGkpnjTj7QlLF++nKKiIq9lRISJHoLTLJaXl9OlSxePFTWmtSk0dfQALU+hGU39NoWmF4QZaef/aqvzoT2FhYVeS4gY0z3o9gCyLSk0dfPQWnTRb4NxBDT9TSFAvZu3pne3RBLj9W4F2rFjh/FZz0z3UF1drVVi9rak0NTNg5+WptDURb/e0UJjBHXGgA+fgp3HnGh8bmYXkuJjPVLXMvxTzZiM6R50HZ3WGkz3oIt+G4zbSoi29n/sguV764kVRVysCY/wLBaLLthg3GbUGc0U5c6oSv4wERIMCMbRShTjJaZ70CWxeSSY7kEX/TYYR4CTVr5xM4UAA7t5p6k1mN4tDMz38FXozWS6B13022DcVkL0J/YpMwZ7+PEPOzUZ0z149WUSzRSaLfGgUwrNxYsXk5+fz/Dhw8nPz+e99947Y5/p06c3uj533XUXI0aMYOTIkUyePJn9+/dHrLspNhi3GbeZwg2+4s7yYVIwtlg6Al0ekPnJzMzkzTffZNOmTTzzzDPMnj270fa//e1vZwT4X/ziF2zcuJH169czbdo07rvvvqjrssG4zfj7GTdupohxMgQZQXCGKlMx3YNXyeUheik0r7vuOqNSaJ5//vn07t0bgNzcXKqrqwO1+4qKCh566KEzztu1a9fAcmVlZbskF7L9jNuIKIVqcj8aN1PoH5F79OjhtYSIMd3D7zb8jh3HdkT1nEPShzB3zNxm94tWCs1bb72VSZMmGZNCM/iB3SuvvML5558fSJp011138fOf/5wUN9VBMPPmzWPRokWkpqaybNmyFt2L1mBrxhEQ3OyvlDKuzbg1w791xXQP9XXe/YSPVgrNn/zkJ0al0PSzZcsW5s6dy0MPPQQ4SY527drFjBkzQp7rgQceYO/evVx77bWNpmqKFrZm3GZCD/owKRhbvGdO3hzP8jpEK4Xm0qVL6d69+xnn1zWFJjjpMWfMmMGiRYsYMGAA4GQAXLNmDdnZ2dTX13Po0CGKiopYvnx5o3Nce+21XHzxxY2aWqKBrRlHQOM5PvzB2JxoHNwOZiqme4iJ0eu/YFtSaAa385qQQvP48eNccsklzJ8/nwkTJgTuwY033sj+/fspLS2luLiYQYMGBQJxcK+d119/nSFDhjSrs7Xo9UkwiRB9E31KjKoZBz+sMRXTPTStPepAa1Nobty40agUmgsXLmTnzp3cd999jBw5kgkTJjQ7rP6OO+5g2LBhjBgxgvfee4+HH364WZ2txabQdGltCs19S+7lr1uf5OVumdw14GZO1leydFt/Nh4Unp/iY9DAIZA5sB0VR05xcbHxWc9M9GBTaHYMNoXm1wRRuBMuKXwoqO/GslLI9D75U4vRrf9nW/gqeNCJtqTQtEQHG4zbjAr0NM5O7sPfSmOBGrJTYzg9+ZLFYhZtSaGpKy1NoakLts24zahGD/BqGhTxMXBvYXLI9mQdmThxotcSIsZ0D7okNo8E0z3oot8G4wgIHvRR7wPNc8mfwZYtW7yWEDGmevA/q6mqqvJYSeSY7iFa+iN9/mZY+NAIf6IgtytbnU8R53alMKVDxZEjR7yWEDEmekhKSuLIkSMopWhoaPBaTsSY7iEa+pVSHDlyJKJ0nLbNuM00zmfc4IM4+9VmaQFZWVmUlZVx+PBhqqurtcmn21ZM9xAt/UlJSWRlZTW/Yxg8C8Yikg68CGQDpcBVSqljIfZ7FxgHFCulpgWVPwsUAHXAauD/KKXqxKmqPgxcDJwCfqiUWht1A+5PEqXg8ClFea15zRR5eXleS4gYEz3Ex8fTv39/wOm7m5aW5rGiyDDdgy76vQwfdwBLlVI5wFJ3PRQLgFAD0J8FhgDDgWTgBrd8KpDjvmYDf4qi5gD+OfCq6mL50d8b+GBvPUlx0mgP3SkvL/daQsSY7sF0/WC+B130exmMLwOecZefAS4PtZNSailwxtVSSr2tXHBqxv7fB5cBi9xNHwHdRKRX1NVzOlHQv+bF8LPRScwdZ1AnY2D37t1eS4gY0z2Yrh/M96CLfi/bjHsopb5wlw8AbcqFKCLxODXnW9yiPsDeoF3K3LIvaBeESf2E3ikJANTW2z7GFoul9bRrMBaRJUDPEJvmBa8opZSItLVfyB+BD5RSH7ZB32ycpgyAChHZ3spTZMJnXxYxtbVvrQuZwJdei4gQ0z2Yrh/M99De+vu1ZKd2DcZKqQvDbRORgyLSSyn1hduMcPZMHaHPcTfQHfg/QcX7gODpH7LcslD6/gL8JdS2Fr7/mpaMOdcV0/WD+R5M1w/me9BFv5dtxm8As9zlWcDrrTlYRG4ApgDXKKWC2wbeAGaKwzjgRFBziMVisWiJl8F4PnCRiJQAF7rriEiBiDzh30lEPgReAr4tImUiMsXd9BhOO/NKEVkvIr92y98GdgM7gceBf+sQNxaLxRIBnj3AU0odAb4donwNp7upoZS6IMzxIbW7vStuipLM5mhzE4cmmK4fzPdgun4w34MW+m0+Y4vFYtEAw8aMWSwWy1cTG4zbgIh8R0S2i8hOEQk3ctATRORJETkkIpuDytJFZLGIlLh/09xyEZFHXB8bRWRU0DGz3P1LRGRWqPdqJ/19RWSZiGwVkS0icotJHkQkSURWi8gGV/+9bnl/EVnl6nxRRBLc8kR3fae7PTvoXL90y7cHPSvpMEQkVkTWichbpnkQkVIR2eQ+T1rjlun9GVJK2VcrXkAssAsYACQAG4ChXusK0jcRGAVsDir7D+AOd/kO4Lfu8sXAOzhjt8cBq9zydJyHoOlAmruc1kH6ewGj3OUuwA5gqCkeXB2d3eV4YJWr6/8BV7vljwE3usv/BjzmLl8NvOguD3U/W4lAf/czF9vBn6WfAc8Bb7nrxnjAyXeT2aRM689Qh93Yr8oLGA/8I2j9l8AvvdbVRGN2k2C8HejlLvcCtrvLf8bpGthoP+Aa4M9B5Y3262AvrwMXmegBSAHWAmNxBhXENf0MAf8AxrvLce5+0vRzFbxfB2nPwskZ8y3gLVeTMR7CBGOtP0O2maL1hBturTPhhp6H86KFR/fn7vk4tUtjPLg/79fjDGRajFMjPK6U8k/YF6wloNPdfgLIwPt78Hvgdk7PIZaBWR4U8J6IfCLOSFvQ/DNk8xl/zVAqoqHnHYaIdAZeAeYopU6KnM6Cp7sHpVQDMFJEugGv4mQXNAYRmQYcUkp9IiJFXutpI4VKqX0icg6wWES2BW/U8TNka8atp8XDrTXioLiZ66Tx0PNwXjz1KE7yp1eAZ5VSf3OLjfIAoJQ6DizD+UnfTUT8lZ9gLQGd7vZU4Aje6p8ATBeRUuAFnKaKhzHIg1Jqn/v3EM4X4hg0/wzZYNx6PgZy3CfLCTgPLN7wWFNzhBt6Hm7o+D+AySKS5j5xnuyWtTviVIH/C/hUKfWQaR5EpLtbI0ZEknHauz/FCcpXhtHv93Ul8E/lNFC+AVzt9lToj5Ofe3V76wdQSv1SKZWllMrG+Xz/Uyl1rSkeRKSTiHTxL+Pc+83o/hnqqAcCX6UXztPXHThtgfO81tNE2/M46ULrcNq4/jdO+91SoARYAqS7+wrwqOtjE1AQdJ5/xRlSvhO4vgP1F+K0920E1ruvi03xAIwA1rn6NwO/dssH4ASinTjD+xPd8iR3fae7fUDQuea5vrYDUz36PBVxujeFER5cnRvc1xb//1HdP0N2BJ7FYrFogG2msFgsFg2wwdhisVg0wAZji8Vi0QAbjC0Wi0UDbDC2WCwWDbDB2GKxWDTABmOLdohItgSlAD3LPt8PWi8QkUfaX13LEZFfNVn/nxYcU9HM9gXipOZcICI/FpGZbvkPRaR3ZIobvU/gHohIkT+NpqX9sLkpLKaSDXwfJ8Ujypmua42Xgvy4owgF+BXw7/5ypdT/isLpZ+MMVmhoUv5DnEEm+6PwHhYPsDVjS4sRkZlu8u0NIvLfIvK0iFwZtL3C/VskIu+LyOsisltE5ovIteIkXd8kIue6+4U8vsl7ZovIhyKy1n35A9p84AJxkoff6q+9iUiMOInFuwWdo0REerhDlV8RkY/d14SzeL3H9bjSPf5HbnlnEVnqatkkIpcF6dwuIotwguJ/AcmuvmebXJ+Q52jB9X8D6Ax8IiL/4mq8zb2GBcCz7vslhzl+tIj8j3v/VotIl7Nc33AaJrnvsV6cxPNdWqLd0gK8GGJpX+a9gFycIeCZ7no68DRwZdA+Fe7fIuA4Tk7YRJzkKve6224Bfu8uhzs+GzcfM05O4CR3OQdYE/QebwUdG1jHSWpzvbs8FljiLj+Hk80L4Bs4+S/C+b0HZzhtMpCJk0qxN86vya7uPpk4w2TF1ewDxjX1E8JfyHOEOiaEroomGm9zl5cTNIw3xHEJOMnRR7vrXV0d4a5v8D0IvrZvAhPc5c64+Y3tK/KXbaawtJRvAS8ppb4EUEodlaC0liH4WLm5Y0VkF/CeW74J+GYr3jceWCgiI4EGYFALjnkR+DXwFO7ME275hcDQIN1dRaSzUipcO+3rSqkqoEpEluFk/vo78O8iMhEn+PbhdF7cz5RSH7VAn4Q5x4EWHNtWBgNfKKU+BlBKnYRAIp3WXN8VwENubf9vSqmydtT8tcIGY0sk1OM2dYlIDE7ty09N0LIvaN3H6c/d2Y73cytwEMhz961uga6VwEAR6Q5cDvzGLY/Bqbm25BzgJCxqun4t0B3IV0rViZNmMsndXtnC857tHB1Nq66vUmq+iPwdJ3nTChGZopTadrZjLC3DthlbWso/ge+JSAY4kzviTG2T726fjlOLbQ0tOT4Vp0bnA67DmYMQoBxnjrwzUM5v6FeBh3CaIo64m94DfuLfz60Nno3LxJlgNAPnp/rHrp5DbhD9JtDvLMfXiZObOZSnlp6jpYS9Hi7bgV4iMhrAbS/25x4OdX1DIiLnKqU2KaV+i3M9jEqcrzM2GFtahFJqC/AA8L6IbMAJdI8Dk9z18bS8ZuinJcf/EZjl7jMkaJ+NQIP7MOrWEMe9CPyA000UAD8FCtyHkFuBHzejbyNODt+PgPuVUvuBZ91zbAJmAmerFf4F2Oh/gBdEa87RUp4GHgv3AE8pVQv8C/AH91ouxqmNh7u+4ZgjIptFZCNOmtZ3oqDdAjaFpsUSChG5B+dh2YNea7F8PbA1Y4vFYtEA+wDP8rVGRK7H6W4XzAql1E1e6AEQkeHAfzcprlFKjW3h8a8C/ZsUz1VKdcjUWZa2YZspLBaLRQNsM4XFYrFogA3GFovFogE2GFssFosG2GBssVgsGmCDscVisWjA/wdpByUg+k4wWAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "w = 5\n",
    "fig, ax = plt.subplots(figsize=(w, w))\n",
    "\n",
    "# adaptiveness = sorted([a for a in df.alg.unique() if a not in ['hyperband', 'stop_on_plateau']])\n",
    "# adaptiveness = ['stop_on_plateau', 'hyperband']\n",
    "\n",
    "x = \"cumulative_partial_fit_calls\"\n",
    "show = df.copy()\n",
    "\n",
    "sns.lineplot(\n",
    "    x=x,\n",
    "    y='best_score',\n",
    "    hue=\"alg\",\n",
    "    data=show,\n",
    "    ax=ax,\n",
    "    estimator='mean',\n",
    ")\n",
    "ax.grid(linestyle='--')\n",
    "# ax.set_ylim(-0.13, -0.09)\n",
    "# ax.set_ylim(0.85, 0.875)\n",
    "# plt.savefig('./successive-halving-comparison.png', dpi=300, bbox_inches='tight')\n",
    "ax.set_ylim(-0.12, -0.09)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shape_histories(histories, **kwargs):\n",
    "    histories = sum(histories, [])\n",
    "    _df = pd.DataFrame(histories)\n",
    "    _df = _df.sort_values(by=\"wall_time\")\n",
    "    \n",
    "    data = []\n",
    "    most_recent_scores = {}\n",
    "    most_recent_times = {}\n",
    "    for _, datum in _df.iterrows():\n",
    "        most_recent_scores[datum[\"repeat\"]] = datum[\"best_score\"]\n",
    "            \n",
    "        most_recent_times[datum[\"repeat\"]] = datum[\"wall_time\"]\n",
    "        scores = np.array(list(most_recent_scores.values()))\n",
    "        \n",
    "        data += [{\"best_score_mean\": scores.mean(),\n",
    "                  \"best_score_std\": np.std(scores),\n",
    "                  \"best_score_max\": scores.max(),\n",
    "                  \"best_score_median\": np.median(scores),\n",
    "                  \"best_score_min\": scores.min(),\n",
    "                  \"wall_time (s)\": datum[\"wall_time\"],\n",
    "                  \"wall_time (min)\": datum[\"wall_time\"] / 60,\n",
    "                  \"alg\": datum[\"alg\"],\n",
    "                  \"patience\": datum[\"patience\"],\n",
    "                  \"tol\": datum[\"tol\"],\n",
    "                  **kwargs}]\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>alg</th>\n",
       "      <th>best_score_max</th>\n",
       "      <th>best_score_mean</th>\n",
       "      <th>best_score_median</th>\n",
       "      <th>best_score_min</th>\n",
       "      <th>best_score_std</th>\n",
       "      <th>patience</th>\n",
       "      <th>tol</th>\n",
       "      <th>wall_time (min)</th>\n",
       "      <th>wall_time (s)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>hyperband-p20</td>\n",
       "      <td>-0.542950</td>\n",
       "      <td>-0.542950</td>\n",
       "      <td>-0.542950</td>\n",
       "      <td>-0.54295</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>20</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000e+00</td>\n",
       "      <td>0.000000e+00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>hyperband-p20</td>\n",
       "      <td>-0.130327</td>\n",
       "      <td>-0.336639</td>\n",
       "      <td>-0.336639</td>\n",
       "      <td>-0.54295</td>\n",
       "      <td>0.206311</td>\n",
       "      <td>20</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000e+00</td>\n",
       "      <td>0.000000e+00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>hyperband-p20</td>\n",
       "      <td>-0.130327</td>\n",
       "      <td>-0.433896</td>\n",
       "      <td>-0.542950</td>\n",
       "      <td>-0.62841</td>\n",
       "      <td>0.217472</td>\n",
       "      <td>20</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.000000e+00</td>\n",
       "      <td>0.000000e+00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>hyperband-p20</td>\n",
       "      <td>-0.130327</td>\n",
       "      <td>-0.359529</td>\n",
       "      <td>-0.405311</td>\n",
       "      <td>-0.54295</td>\n",
       "      <td>0.171535</td>\n",
       "      <td>20</td>\n",
       "      <td>0.0</td>\n",
       "      <td>7.947286e-09</td>\n",
       "      <td>4.768372e-07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>hyperband-p20</td>\n",
       "      <td>-0.130327</td>\n",
       "      <td>-0.359529</td>\n",
       "      <td>-0.405311</td>\n",
       "      <td>-0.54295</td>\n",
       "      <td>0.171535</td>\n",
       "      <td>20</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.192093e-08</td>\n",
       "      <td>7.152557e-07</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             alg  best_score_max  best_score_mean  best_score_median  \\\n",
       "0  hyperband-p20       -0.542950        -0.542950          -0.542950   \n",
       "1  hyperband-p20       -0.130327        -0.336639          -0.336639   \n",
       "2  hyperband-p20       -0.130327        -0.433896          -0.542950   \n",
       "3  hyperband-p20       -0.130327        -0.359529          -0.405311   \n",
       "4  hyperband-p20       -0.130327        -0.359529          -0.405311   \n",
       "\n",
       "   best_score_min  best_score_std  patience  tol  wall_time (min)  \\\n",
       "0        -0.54295        0.000000        20  0.0     0.000000e+00   \n",
       "1        -0.54295        0.206311        20  0.0     0.000000e+00   \n",
       "2        -0.62841        0.217472        20  0.0     0.000000e+00   \n",
       "3        -0.54295        0.171535        20  0.0     7.947286e-09   \n",
       "4        -0.54295        0.171535        20  0.0     1.192093e-08   \n",
       "\n",
       "   wall_time (s)  \n",
       "0   0.000000e+00  \n",
       "1   0.000000e+00  \n",
       "2   0.000000e+00  \n",
       "3   4.768372e-07  \n",
       "4   7.152557e-07  "
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "histories = [shape_histories(alg_hist, alg=alg) for alg, alg_hist in alg_shaped_histories.items()]\n",
    "time_df = pd.DataFrame(sum(histories, []))\n",
    "time_df.to_csv('2018-09-10-shaped-history-more-freq-score.csv')\n",
    "time_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'Best score')"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "key = \"wall_time (s)\"\n",
    "for alg in time_df.alg.unique():\n",
    "    s = time_df[time_df.alg == alg]\n",
    "    ax.plot(s[key].values, s[\"best_score_mean\"].values, label=alg)\n",
    "    ax.fill_between(\n",
    "        s[key],\n",
    "        s.best_score_mean - s.best_score_std,\n",
    "        s.best_score_mean + s.best_score_std,\n",
    "        alpha=0.2,\n",
    "    )\n",
    "ax.set_ylim(-0.12, -0.09)\n",
    "ax.legend(loc=\"lower right\", title=\"algorithm\")\n",
    "ax.set_xlabel(key)\n",
    "ax.grid(linestyle='--')\n",
    "ax.set_ylabel(\"Best score\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameter visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "hist = pd.DataFrame(search.cv_results_)\n",
    "hist['param_optimizer_'] = hist['param_optimizer'].apply(lambda opt: str(opt).replace('<class', '').strip('>'))\n",
    "hist['test_loss'] = -1 * hist['test_score']\n",
    "hist = hist.sort_values(by='test_loss')\n",
    "hist['rank'] = np.arange(len(hist)) + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "w = 5\n",
    "fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(2*w, 2*w))\n",
    "axs = axs.flat[:]\n",
    "hues = ['param_optimizer', 'param_module__init', 'param_module__activation', 'param_batch_size']\n",
    "for ax, hue in zip(axs, hues):\n",
    "    cmap = None\n",
    "    if 'batch_size' in hue:\n",
    "        cmap = 'viridis'\n",
    "    sns.barplot(\n",
    "        x='rank', \n",
    "        y='test_loss',\n",
    "        hue=hue,\n",
    "        data=hist,\n",
    "        ax=ax,\n",
    "        palette=cmap,\n",
    "        dodge=False,\n",
    "    )\n",
    "    ax.set_xlim(-1.5, 50)\n",
    "    ax.set_ylim(0, 0.14)\n",
    "    ax.grid(linestyle='--', which='y')\n",
    "    ax.legend(loc='lower right')\n",
    "    ax.set_title(hue.replace('param_', ''))\n",
    "    ax.tick_params(labelbottom=False)\n",
    "plt.savefig('2018-09-10-global-params.png', dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "sgd_alg = [a for a in hist.param_optimizer_.unique() if 'sgd' in a.lower()][0]\n",
    "sgd = hist[hist.param_optimizer_ == sgd_alg]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\" 'torch.optim.sgd.SGD'\"]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "w = 5\n",
    "fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(2*w, 2*w))\n",
    "axs = axs.flat[:]\n",
    "variables = ['param_optimizer__lr', 'param_optimizer__momentum', 'param_optimizer__weight_decay', 'param_batch_size']\n",
    "print(sgd.param_optimizer_.unique())\n",
    "for ax, var in zip(axs, variables):\n",
    "    show = sgd.copy()\n",
    "    show = show.sort_values(by=var)\n",
    "    if 'weight_decay' in var:\n",
    "        show[var] += 1e-8\n",
    "    show = show[show.test_loss < 0.16]\n",
    "    sns.scatterplot(\n",
    "        x=var,\n",
    "        y='test_loss',\n",
    "        data=show,\n",
    "        hue='test_loss',\n",
    "        palette='magma',\n",
    "        legend=False,\n",
    "        ax=ax,\n",
    "    )\n",
    "    if 'lr' in var:\n",
    "        ax.set_xscale('log', basex=10)\n",
    "    if 'batch_size' in var:\n",
    "        ax.set_xscale('log', basex=2)\n",
    "    if 'weight_decay' in var:\n",
    "        ax.set_xlim(5e-9, 1e-3)\n",
    "        ax.set_xscale('log', basex=10)\n",
    "    \n",
    "    ax.grid(linestyle='--')\n",
    "    ax.set_ylim(0.08, 0.16)\n",
    "plt.savefig('2018-09-10-sgd-params.png', dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
 }
diff --git a/autoencoder.py b/autoencoder.py
 import skorch.utils
 from skorch import NeuralNetRegressor
 import torch.nn as nn
 import torch
 import skorch


 def _initialize(method, layer, gain=1):
    weight = layer.weight.data
    # _before = weight.data.clone()
    kwargs = {'gain': gain} if 'xavier' in str(method) else {}
    method(weight.data, **kwargs)
    # assert torch.all(weight.data != _before)


 class Autoencoder(nn.Module):
    def __init__(self, activation='ReLU', init='xavier_uniform_',
                 **kwargs):
        super().__init__()

        self.activation = activation
        self.init = init
        self._iters = 0

        init_method = getattr(torch.nn.init, init)
        act_layer = getattr(nn, activation)
        act_kwargs = {'inplace': True} if self.activation != 'PReLU' else {}

        gain = 1
        if self.activation in ['LeakyReLU', 'ReLU']:
            name = 'leaky_relu' if self.activation == 'LeakyReLU' else 'relu'
            gain = torch.nn.init.calculate_gain(name)

        inter_dim = 28 * 28 // 4
        latent_dim = inter_dim // 4
        layers = [
            nn.Linear(28 * 28, inter_dim),
            act_layer(**act_kwargs),
            nn.Linear(inter_dim, latent_dim),
            act_layer(**act_kwargs)
        ]
        for layer in layers:
            if hasattr(layer, 'weight') and layer.weight.data.dim() > 1:
                _initialize(init_method, layer, gain=gain)
        self.encoder = nn.Sequential(*layers)
        layers = [
            nn.Linear(latent_dim, inter_dim),
            act_layer(**act_kwargs),
            nn.Linear(inter_dim, 28 * 28),
            nn.Sigmoid()
        ]
        layers = [
            nn.Linear(latent_dim, 28 * 28),
            nn.Sigmoid()
        ]
        for layer in layers:
            if hasattr(layer, 'weight') and layer.weight.data.dim() > 1:
                _initialize(init_method, layer, gain=gain)
        self.decoder = nn.Sequential(*layers)

    def forward(self, x):
        self._iters += 1
        shape = x.size()
        x = x.view(x.shape[0], -1)
        x = self.encoder(x)
        x = self.decoder(x)
        return x.view(shape)
    
 class NegLossScore(NeuralNetRegressor):
    steps = 0
    def partial_fit(self, *args, **kwargs):
        
        super().partial_fit(*args, **kwargs)
        self.steps += 1
        
    def score(self, X, y):
        X = skorch.utils.to_tensor(X, device=self.device)
        y = skorch.utils.to_tensor(y, device=self.device)
        
        self.initialize_criterion()
        y_hat = self.predict(X)
        y_hat = skorch.utils.to_tensor(y_hat, device=self.device)
        loss = super().get_loss(y_hat, y, X=X, training=False).item()
        print(f'steps = {self.steps}, loss = {loss}')
        return -1 * loss
    
    def initialize(self, *args, **kwargs):
        super().initialize(*args, **kwargs)
        self.callbacks_ = []
        
diff --git a/noisy_mnist.py b/noisy_mnist.py
 from keras.datasets import mnist
 import numpy as np
 import skimage.util
 import random

 import skimage.filters
 import skimage
 import scipy.signal


 def noise_img(x):
    noises = [
        {"mode": "s&p", "amount": np.random.uniform(0.1, 0.1)},
        {"mode": "gaussian", "var": np.random.uniform(0.10, 0.15)},
    ]
    # noise = random.choice(noises)
    noise = noises[1]
    return skimage.util.random_noise(x, **noise)


 def train_formatting(img):
    img = img.reshape(28, 28).astype("float32")
    return img.flat[:]


 def blur_img(img):
    assert img.ndim == 1
    n = int(np.sqrt(img.shape[0]))
    img = img.reshape(n, n)
    h = np.zeros((n, n))
    angle = np.random.uniform(-5, 5)
    w = random.choice(range(1, 3))
    h[n // 2, n // 2 - w : n // 2 + w] = 1
    h = skimage.transform.rotate(h, angle)
    h /= h.sum()
    y = scipy.signal.convolve(img, h, mode="same")
    return y.flat[:]


 def dataset(n=None):
    (x_train, _), (x_test, _) = mnist.load_data()
    x = np.concatenate((x_train, x_test))
    if n:
        x = x[:n]
    else:
        n = int(70e3)
    x = x.astype("float32") / 255.
    x = np.reshape(x, (len(x), 28 * 28))

    y = np.apply_along_axis(train_formatting, 1, x)

    clean = y.copy()

    noisy = y.copy()
    # order = [noise_img, blur_img]
    # order = [blur_img]
    order = [noise_img]

    random.shuffle(order)

    for fn in order:
        noisy = np.apply_along_axis(fn, 1, noisy)

    noisy = noisy.astype("float32")
    clean = clean.astype("float32")
 #     noisy = noisy.reshape(-1, 1, 28, 28).astype("float32")
 #     clean = clean.reshape(-1, 1, 28, 28).astype("float32")
    return noisy, clean
	import skorch.utils
	from skorch import NeuralNetRegressor
	import torch.nn as nn
	import torch
	import skorch


	def _initialize(method, layer, gain=1):
	weight = layer.weight.data
	# _before = weight.data.clone()
	kwargs = {'gain': gain} if 'xavier' in str(method) else {}
	method(weight.data, **kwargs)
	# assert torch.all(weight.data != _before)


	class Autoencoder(nn.Module):
	def __init__(self, activation='ReLU', init='xavier_uniform_',
	**kwargs):
	super().__init__()

	self.activation = activation
	self.init = init
	self._iters = 0

	init_method = getattr(torch.nn.init, init)
	act_layer = getattr(nn, activation)
	act_kwargs = {'inplace': True} if self.activation != 'PReLU' else {}

	gain = 1
	if self.activation in ['LeakyReLU', 'ReLU']:
	name = 'leaky_relu' if self.activation == 'LeakyReLU' else 'relu'
	gain = torch.nn.init.calculate_gain(name)

	inter_dim = 28 * 28 // 4
	latent_dim = inter_dim // 4
	layers = [
	nn.Linear(28 * 28, inter_dim),
	act_layer(**act_kwargs),
	nn.Linear(inter_dim, latent_dim),
	act_layer(**act_kwargs)
	]
	for layer in layers:
	if hasattr(layer, 'weight') and layer.weight.data.dim() > 1:
	_initialize(init_method, layer, gain=gain)
	self.encoder = nn.Sequential(*layers)
	layers = [
	nn.Linear(latent_dim, inter_dim),
	act_layer(**act_kwargs),
	nn.Linear(inter_dim, 28 * 28),
	nn.Sigmoid()
	]
	layers = [
	nn.Linear(latent_dim, 28 * 28),
	nn.Sigmoid()
	]
	for layer in layers:
	if hasattr(layer, 'weight') and layer.weight.data.dim() > 1:
	_initialize(init_method, layer, gain=gain)
	self.decoder = nn.Sequential(*layers)

	def forward(self, x):
	self._iters += 1
	shape = x.size()
	x = x.view(x.shape[0], -1)
	x = self.encoder(x)
	x = self.decoder(x)
	return x.view(shape)

	class NegLossScore(NeuralNetRegressor):
	steps = 0
	def partial_fit(self, args, *kwargs):

	super().partial_fit(args, *kwargs)
	self.steps += 1

	def score(self, X, y):
	X = skorch.utils.to_tensor(X, device=self.device)
	y = skorch.utils.to_tensor(y, device=self.device)

	self.initialize_criterion()
	y_hat = self.predict(X)
	y_hat = skorch.utils.to_tensor(y_hat, device=self.device)
	loss = super().get_loss(y_hat, y, X=X, training=False).item()
	print(f'steps = {self.steps}, loss = {loss}')
	return -1 * loss

	def initialize(self, args, *kwargs):
	super().initialize(args, *kwargs)
	self.callbacks_ = []
	from keras.datasets import mnist
	import numpy as np
	import skimage.util
	import random

	import skimage.filters
	import skimage
	import scipy.signal


	def noise_img(x):
	noises = [
	{"mode": "s&p", "amount": np.random.uniform(0.1, 0.1)},
	{"mode": "gaussian", "var": np.random.uniform(0.10, 0.15)},
	]
	# noise = random.choice(noises)
	noise = noises[1]
	return skimage.util.random_noise(x, **noise)


	def train_formatting(img):
	img = img.reshape(28, 28).astype("float32")
	return img.flat[:]


	def blur_img(img):
	assert img.ndim == 1
	n = int(np.sqrt(img.shape[0]))
	img = img.reshape(n, n)
	h = np.zeros((n, n))
	angle = np.random.uniform(-5, 5)
	w = random.choice(range(1, 3))
	h[n // 2, n // 2 - w : n // 2 + w] = 1
	h = skimage.transform.rotate(h, angle)
	h /= h.sum()
	y = scipy.signal.convolve(img, h, mode="same")
	return y.flat[:]


	def dataset(n=None):
	(x_train, _), (x_test, _) = mnist.load_data()
	x = np.concatenate((x_train, x_test))
	if n:
	x = x[:n]
	else:
	n = int(70e3)
	x = x.astype("float32") / 255.
	x = np.reshape(x, (len(x), 28 * 28))

	y = np.apply_along_axis(train_formatting, 1, x)

	clean = y.copy()

	noisy = y.copy()
	# order = [noise_img, blur_img]
	# order = [blur_img]
	order = [noise_img]

	random.shuffle(order)

	for fn in order:
	noisy = np.apply_along_axis(fn, 1, noisy)

	noisy = noisy.astype("float32")
	clean = clean.astype("float32")
	# noisy = noisy.reshape(-1, 1, 28, 28).astype("float32")
	# clean = clean.reshape(-1, 1, 28, 28).astype("float32")
	return noisy, clean