{ "cells": [ { "cell_type": "markdown", "metadata": { "deletable": false, "editable": false, "nbgrader": { "cell_type": "markdown", "checksum": "3f243a3f6fc6544fc5a1bbe88071d398", "grade": false, "grade_id": "cell-902dd5d5b571df86", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "# Exercise 03\n", "**Kernel Methods in Machine Learning (CS-E4830)**\n", "\n", "
\n", " Tasks:\n", "\n", "1. [Support Vector Machines (SVM)](#csvm)\n", " 1. [Dual optimization using quadratic programming (QP)](#task_1) (**2 Points**)\n", " 2. [Comparison to LibSVM](#task_2) (**2 Points**)\n", " 3. [Visualize Support Vectors](#visual_sv)\n", "2. [Non-linear Kernels](#non_linear_kernels)\n", " 1. [Tanimoto kernel for binary data](#tanimoto_kernel) (**2 Points**)\n", " 2. [MinMax kernel for non-negative data](#minmax_kernel) (**2 Points**)\n", "
\n", "\n", "
\n", " Bonus Task:\n", " \n", "3. [Toxicity Prediction using Non-Linear SVM](#toxicity_prediction) (**1 Bonus-point**)\n", "\n", "
\n", "\n", "**Version**: 1.0\n", "\n", "**Version history**:\n", "\n", "- 1.0: Initial version" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " Please add you student number and email address to the notebook into the corresponding cell.\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "EMAIL: firstname.lastname@aalto.fi" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "STUDENT_NUMBER: 000000" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "998bbd359c6f1afea3f65c6b9cf376df", "grade": false, "grade_id": "cell-3d7c3a3baf2e8a84", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "import time\n", "\n", "import numpy as np\n", "import scipy.optimize as spopt\n", "import matplotlib.pyplot as plt\n", "\n", "from sklearn.base import BaseEstimator, ClassifierMixin\n", "from sklearn.model_selection import train_test_split, GridSearchCV, KFold\n", "from sklearn.svm import SVC as SVM_sk\n", "from sklearn.datasets import make_blobs, make_moons\n", "from sklearn.metrics.pairwise import rbf_kernel as rbf_kernel_sk\n", "from sklearn.metrics.pairwise import linear_kernel as linear_kernel_sk" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def gaussian_kernel_wrapper(X, Y=None, sigma=None):\n", " \"\"\"\n", " Wrapper around the sklearn rbf-kernel function. It converts between the\n", " gamma parametrization (sklearn) and the sigma parametrization (lecture).\n", " \"\"\"\n", " if sigma is None:\n", " sigma = np.sqrt(X.shape[1] / 2.)\n", "\n", " return rbf_kernel_sk(X, Y, gamma=(1. / (2. * (sigma**2))))" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def plot_svm_model(X, y, svm, ax=None, show_origin=False, verbose=True):\n", " \"\"\"\n", " Helper function to plot svm models for simple 2D-data.\n", " \"\"\"\n", " # Fit model\n", " svm.fit(X, y)\n", " \n", " if verbose:\n", " if isinstance(svm, SVM_sk):\n", " print(\"Number of support vectors:\", svm.n_support_)\n", " print(\"Bias:\", np.round(svm.intercept_, 4))\n", " else:\n", " print(\"Number of support vectors:\", svm.n_sv)\n", " print(\"Bias:\", np.round(svm._bias, 4))\n", " print(\"Dual variables:\\n\", np.round(svm._alpha[svm._alpha > 0], 4))\n", "\n", " if ax is None:\n", " fig = plt.figure()\n", " ax = fig.add_subplot(111)\n", " \n", " _ = ax.scatter(X[y == 1, 0], X[y == 1, 1], c=\"blue\", s=50, label=\"positive class\")\n", " _ = ax.scatter(X[y == -1, 0], X[y == -1, 1], c=\"red\", s=50, label=\"negative class\")\n", "\n", " # plot the decision function\n", " xlim = ax.get_xlim()\n", " ylim = ax.get_ylim()\n", " \n", " if show_origin:\n", " xlim = (np.minimum(-0.5, xlim[0]), np.maximum(0.5, xlim[1]))\n", " ylim = (np.minimum(-0.5, ylim[0]), np.maximum(0.5, ylim[1]))\n", " \n", " ax.plot(0, 0, 's', c=\"k\", label=\"Origin\")\n", "\n", " # create grid to evaluate model\n", " xx = np.linspace(xlim[0], xlim[1], 30)\n", " yy = np.linspace(ylim[0], ylim[1], 30)\n", " YY, XX = np.meshgrid(yy, xx)\n", " xy = np.vstack([XX.ravel(), YY.ravel()]).T\n", " Z = svm.decision_function(xy).reshape(XX.shape)\n", "\n", " # plot decision boundary and margins\n", " _ = ax.contour(XX, YY, Z, colors='k', levels=[-1, 0, 1], alpha=0.5, \n", " linestyles=['--', '-', '--'])\n", " # plot support vectors\n", " _ = ax.scatter(svm.support_vectors_[:, 0], svm.support_vectors_[:, 1], s=200,\n", " linewidth=1.5, facecolors='none', edgecolors='k', label=\"Support vectors\")\n", " _ = ax.legend()\n", " \n", " _ = ax.grid()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1. C - Support Vector Machine (C-SVM) \n", "\n", "In this task you are going to implement a soft-margin C-SVM. You will use the dual formulation (derived in the Pen & Paper exercise) to find the optimal model using quadratic programming (QP).\n", "\n", "#### SciPy Optimization Toolbox\n", "\n", "A convenient interface to a QP-solver is provided by the [scipy.optimization](https://docs.scipy.org/doc/scipy-1.1.0/reference/optimize.html) package (JupyterHub uses version 1.1.0). As optimization algorithm we will use [Sequential Least SQuares Programming (SLSQP)](https://neos-guide.org/content/sequential-quadratic-programming) (```scipy.optimize.minimize(..., method=\"SLSQP\")```). Another popular framework for optimization in Python is, e.g., [cvxpy](https://www.cvxpy.org/) (not available on JupyterHub).\n", "\n", "#### SVM Primal formulation\n", "\n", "For a given training set $\\{(\\mathbf{x}_i,y_i)\\}_{i=1}^{n_{train}}$, the C-SVM formulation is given as:\n", "\n", "\\begin{align}\n", "\\underset{\\mathbf{w},\\boldsymbol{\\xi},b}{\\min}&\\,\\frac{1}{2}\\|\\mathbf{w}\\|^2 + C \\sum_{i=1}^{n_{train}}\\xi_i \\\\\n", "\\text{s.t.}&\\,y_i(\\mathbf{w}^T\\phi(\\mathbf{x}_i))+b)\\geq 1-\\xi_i\\\\\n", "&\\,\\xi_i\\geq 0,\\quad i=1,\\ldots,n_{train},\n", "\\end{align}\n", "\n", "where $\\mathbf{w}\\in\\mathbb{R}^d$ are the model parameters, and $b\\in\\mathbb{R}$ is the bias, and $\\boldsymbol{\\xi}\\in\\mathbb{R}_{\\geq0}^{n_{train}}$ is the vector of slack-variables, and $C>0\\in\\mathbb{R}$ is the regularization parameter. \n", "\n", "The primal C-SVM **decision function** is given as:\n", "\n", "$$\n", "f(\\mathbf{x})=\\mathbf{w}^T\\phi(\\mathbf{x})+b\\in\\mathbb{R}\n", "$$\n", "\n", "and the corresponding **prediction function** as: \n", "\n", "$$\n", "g(\\mathbf{x})=sign(f(\\mathbf{x}))\\in\\{-1,1\\}.\n", "$$\n", "\n", "#### SVM Dual formulation \n", "\n", "In the Pen & Paper exercise you showed, that the dual C-SVM can be written as:\n", "\n", "\\begin{align}\n", "\\underset{\\boldsymbol{\\alpha}}{\\max}&\\,\\mathcal{L}(\\boldsymbol{\\alpha})=\\underbrace{\\sum_{i=1}^{n_{train}}\\alpha_i - \\frac{1}{2}\\sum_{i=1}^{n_{train}}\\sum_{j=1}^{n_{train}}\\alpha_i\\alpha_j y_i y_j \\kappa(\\mathbf{x}_i,\\mathbf{x}_j)}_{\\text{Loss function}}\\\\\n", "\\text{s.t.}&\\,0\\leq\\alpha_i\\leq C,\\quad i=1,\\ldots,n_{train} \\\\\n", "&\\,\\underbrace{\\sum_{i=1}^{n_{train}}\\alpha_i y_i=0}_{\\text{Bias constraint}},\n", "\\end{align}\n", "\n", "or, equivalent in matrix notation, as:\n", "\n", "\\begin{align}\n", "\\underset{\\boldsymbol{\\alpha}}{\\max}&\\,\\mathbf{1}^T\\boldsymbol{\\alpha} - \\frac{1}{2}\\boldsymbol{\\alpha}^T\\left(\\mathbf{y}\\mathbf{y}^T\\circ\\mathbf{K}\\right)\\boldsymbol{\\alpha}\\\\\n", "\\text{s.t.}&\\,0\\leq\\alpha_i\\leq C,\\quad i=1,\\ldots,n_{train} \\\\\n", "&\\,\\boldsymbol{\\alpha}^T\\mathbf{y}=0,\n", "\\end{align}\n", "\n", "where $\\boldsymbol{\\alpha}\\in\\mathbb{R}^{n_{train}}$ are the dual variables, and $\\mathbf{K}\\in\\mathbb{R}^{n_{train}\\times n_{train}}$ is the training kernel matrix (with $[\\mathbf{K}]_{ij}=\\kappa(\\mathbf{x}_i,\\mathbf{x}_j)=\\phi(\\mathbf{x}_i)^T\\phi(\\mathbf{x}_j)$), and $\\mathbf{y}\\in\\{-1,1\\}^{n_{train}}$ training labels, and $C>0\\in\\mathbb{R}$ being the regularisation parameter. Let us furthermore define the shorthand: $\\mathbf{G}=\\mathbf{y}\\mathbf{y}^T\\circ\\mathbf{K}$.\n", "\n", "##### Support Vector (SV) \n", "\n", "The training examples $\\mathbf{x}_i$ (respectively their feature vectors $\\phi(\\mathbf{x}_i)$) for which $\\alpha_i>0$ are called **support vectors (SV)**. The examples $\\mathbf{x}_i$ for which *additionally* holds $\\alpha_i\n", "\n", "For the SVs on the margin we know that $\\xi_i=0$ and therefore that $y_i f(\\mathbf{x}_i)=1$. We can therefore calculate $b$ for a given $\\boldsymbol{\\alpha}$ using:\n", "\n", "$$\n", " b = \\frac{1}{|\\mathcal{I}_M|}\\sum_{i\\in\\mathcal{I}_M}\\left(y_i - \\sum_{j\\in\\mathcal{I}_s} y_j\\alpha_j\\kappa(\\mathbf{x}_i, \\mathbf{x}_j)\\right)\n", "$$\n", "\n", "or, equivalent in matrix notation:\n", "\n", "$$\n", " b = \\frac{1}{|\\mathcal{I}_M|}\\mathbf{1}^T\\left(\\mathbf{y}[\\mathcal{I}_M]-\\mathbf{K}[\\mathcal{I}_M][:, \\mathcal{I}_S]\\left(\\mathbf{y}[\\mathcal{I}_S]\\circ\\boldsymbol{\\alpha}[\\mathcal{I}_S]\\right)\\right).\n", "$$\n", "\n", "For further details, check out [\"Pattern Recognition and Machine Learning\" book by C. Bishop](https://www.microsoft.com/en-us/research/people/cmbishop/#!prml-book) (p. 333-334).\n", "\n", "### A. Dual optimization using quadratic programming (QP) (**2 Points**) \n", "
\n", " Task:\n", " Implement missing code parts of the SVM class. You have to modify the following member-functions:\n", " \n", "- ```_loss_and_grad```: This function should return the loss function value $\\mathcal{L}(\\boldsymbol{\\alpha})$ for a given $\\boldsymbol{\\alpha}$ vector and the gradient $\\nabla_{\\boldsymbol{\\alpha}}\\mathcal{L}$ of the loss function.\n", "- ```_calculate_bias```: This function should return the bias calculated as [presented](#bias). Keep the [support vector definitions](#SV) in mind.\n", "- ```fit```: In this function you need to define the $\\mathbf{G}$ matrix, the box and linear constraints (*s.t.*) and run the optimizer.\n", "- ```decision_function``` and ```predict```: This functions should implement the functions $f(\\mathbf{x})$ and $g(\\mathbf{x})$.\n", "
\n", "\n", "
\n", " Hints / Notes: \n", " \n", "- There are online tools existing to check your derived gradients, e.g. [matrixcalculus.org](http://www.matrixcalculus.org/).\n", "- Make your self familiar with the [```scipy.optimize.minimize```](https://docs.scipy.org/doc/scipy-1.1.0/reference/generated/scipy.optimize.minimize.html) function.\n", "- Read how to define [box- (bounds)](https://docs.scipy.org/doc/scipy-1.1.0/reference/generated/scipy.optimize.Bounds.html#scipy.optimize.Bounds) and linear-constraints?\n", "- The dual loss function $\\mathcal{L}$ can be maximized by minimizing $-\\mathcal{L}$. Scipy only implements a minimize function.\n", "- [Visualizinf your model](#visualize_svm_model) might help you debugging it.\n", "- Instead of the index sets $\\mathcal{I}_M$ and $\\mathcal{I}_S$, the implementation works with indicator vectors, e.g. ```_is_sv```$ =\\{True,False\\}^{n_{train}}$ with ```_is_sv[i]``` = $\\alpha_i>0$.\n", "
" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "c9248c34aa40419816a80e3b2cb83ae0", "grade": false, "grade_id": "svm", "locked": false, "schema_version": 3, "solution": true, "task": false } }, "outputs": [], "source": [ "class SVM(BaseEstimator, ClassifierMixin):\n", " def __init__(self, C=1., alpha_threshold=1e-6, sigma=None, kernel=\"gaussian\", verbose=True):\n", " \"\"\"\n", " C - Support Vector Machine (SVM)\n", " \n", " :param C: scalar, regularization parameter C (default = 1)\n", " :param alpha_threshold: scalar, threshold to set the dual variables to zero if very\n", " small (e.g. due to numerical optimization) (default = 1e-6)\n", " :param sigma: scalar, sigma parameter used for the gaussian kernel (default = None)\n", " :param kernel: {string, calaable}, name of the kernel to use or function to\n", " calculate the kernel matrices (defualt = \"gaussian\")\n", " :param verbose: boolean, indicating whether some performance / debugging information\n", " should be plotted\n", " \"\"\"\n", " # Optimization parameters\n", " self.C = C \n", " self._alpha_threshold = alpha_threshold\n", " self._verbose = verbose\n", " \n", " # Model parameters\n", " self._alpha = None # dual variables alpha_i\n", " self._bias = None # bias term\n", " self._X_train = None # training feature vectors needed for prediction\n", " self._y_train = None # training labels\n", " \n", " # Support vector information\n", " self._is_sv = None # indicator vector, which example is support vector\n", " self.n_sv = None # number of support vectors per class\n", " self.support_vectors_ = None # Support vector input feature vectors \n", " \n", " # Kernel parameters\n", " self.kernel = kernel\n", " self.sigma = sigma\n", " \n", " def _loss_and_grad(self, alpha, G, sign=-1):\n", " \"\"\"\n", " Calculate the SVM dual loss function and its corresponding gradient.\n", " \n", " :param alpha: array-like, shape=(n_train, ), current dual variable vector\n", " :param G: array-like, shape=(n_train, n_train), G_train matrix \n", " :param sign: scalar, sign of the loss and gradient, should be 1 for minimization and \n", " -1 for maximization (default = -1)\n", " \n", " :return tuple=(loss function value, gradient vector [shape=(n_train,)])\n", " \"\"\"\n", " ### BEGIN SOLUTION\n", " loss_value = np.sum(alpha) - 0.5 * alpha.T @ G @ alpha\n", " gradient_vector = 1. - G @ alpha #1. - alpha.T @ G\n", " ### END SOLUTION\n", "\n", " return sign * loss_value, sign * gradient_vector\n", " \n", " def _calculate_bias(self, K_train, y_train, alpha, is_sv):\n", " \"\"\"\n", " Function to determine the bias term after the dual variables have been optimized.\n", " \n", " :param K_train: array-like, shape=(n_train, n_train), training kernel matrix\n", " :param y_train: array-like, shape=(n_train, 1), training labels\n", " :param alpha: array-like, shape=(n_train,), dual variables\n", " :param is_sv: array-like, shape=(n_train,), boolean vector indicating whether a \n", " training example is a support vector or not, i.e. is_cv[i] == True => alpha[i] > 0 \n", " \n", " :return: scalar, bias\n", " \"\"\"\n", " # Get indicator vector of the support vectors on the margin, \n", " # i.e. for which slack_i = 0.\n", " is_sv_mrg = np.bitwise_and(is_sv, (alpha < self.C).flatten())\n", " \n", " # Calculate the bias according to the formula. \n", " ### BEGIN SOLUTION\n", " bias = np.mean(y_train[is_sv_mrg] - \n", " (K_train[is_sv_mrg][:, is_sv] @ (y_train[is_sv] * alpha[is_sv])))\n", " ### END SOLUTION\n", " \n", " return bias\n", " \n", " def fit(self, X_train, y_train):\n", " \"\"\"\n", " Fit the SVM model parameters\n", " \n", " :param X_train: array-like, shape=(n_train, n_features), training feature matrix\n", " :param y_train: array-like, shape=(ntrain, ) or (n_train, 1), training labels, {-1, 1}\n", " \n", " :return: reference to it self\n", " \"\"\"\n", " self._X_train = X_train\n", " K_train = self._get_kernel(self._X_train)\n", " n_train = K_train.shape[0] # number of training examples\n", " \n", " # Make training labels beeing a column-vector\n", " self._y_train = y_train\n", " if len(self._y_train.shape) == 1:\n", " self._y_train = self._y_train[:, np.newaxis]\n", " \n", " # Calculate the matrix: G_train = yy' .* K_train\n", " ### BEGIN SOLUTION\n", " G_train = np.outer(self._y_train, self._y_train) * K_train\n", " ### END SOLUTION\n", " \n", " # Set up the equality contraint introduced by the bias-term: bias_const\n", " ### BEGIN SOLUTION\n", " bias_const = {\"type\": \"eq\", \"fun\": lambda alpha: self._y_train.T @ alpha}\n", " ### END SOLUTION\n", " \n", " assert (isinstance(bias_const, dict) and \\\n", " \"type\" in bias_const and \\\n", " \"fun\" in bias_const), \\\n", " \"bias_const must be specified as dictionary. See hints.\"\n", " assert (callable(bias_const[\"fun\"])), \"Provide a function to evalute the constraint.\"\n", " \n", " # Define the bounds (0 <= alpha_i <= C) for the dual varaibles: bound_const\n", " ### BEGIN SOLUTION\n", " bounds_const = spopt.Bounds(0, self.C)\n", " ### END SOLUTION\n", " \n", " assert (isinstance(bounds_const, spopt.Bounds))\n", " \n", " # Define a feasiable initial value for the dual variables: \n", " # 0 <= alpha0_i <= C, y^T alpha0_i = 0\n", " ### BEGIN SOLUTION\n", " alpha0 = np.zeros((n_train, ))\n", " ### END SOLUTION\n", " \n", " assert (alpha0.shape == (n_train, )), \"alpha0 must have shape=(n_train,).\"\n", " assert (all(alpha0 >= 0) and all(alpha0 <= self.C) and (self._y_train.T @ alpha0 == 0)), \\\n", " \"alpha0 must be feasible.\"\n", " \n", " if self._verbose:\n", " start = time.time()\n", " \n", " # Run the optimizer\n", " res = spopt.minimize(self._loss_and_grad, x0=alpha0, jac=True, args=(G_train, ),\n", " method=\"SLSQP\", constraints=bias_const, bounds=bounds_const)\n", " \n", " if self._verbose:\n", " print(\"Optimizing time: %.3fs\" % (time.time() - start))\n", " \n", " # Extract the optimal dual varaibles (solution) from the optimizer\n", " self._alpha = res[\"x\"][:, np.newaxis]\n", " \n", " # Threshold alpha values to zero if very small\n", " self._alpha[self._alpha < self._alpha_threshold] = 0\n", " self._alpha[np.abs(self._alpha - self.C) < self._alpha_threshold] = self.C\n", " \n", " # Find support vectors (alpha_i > 0)\n", " ### BEGIN SOLUTION\n", " self._is_sv = (self._alpha > 0).flatten()\n", " ### END SOLUTION\n", " \n", " assert (self._is_sv.shape == (n_train, )), \\\n", " \"_is_sv must be an indicator vector with shape=(n_train, ).\"\n", " \n", " self.support_vectors_ = X_train[self._is_sv]\n", " \n", " # Get number of support vectors per class\n", " self.n_sv = np.array([np.sum(self._is_sv[y_train.flatten() == -1]),\n", " np.sum(self._is_sv[y_train.flatten() == 1])])\n", " \n", " # Calcualte the bias\n", " self._bias = self._calculate_bias(K_train, self._y_train, self._alpha, self._is_sv)\n", " \n", " return self\n", " \n", " def decision_function(self, X):\n", " \"\"\"\n", " Calculate decision function:\n", " f(x) = sum_i y_i alpha_i k(x_i, x) + bias\n", "\n", " :param X: array-like, shape=(n_test, n_features), \n", " :return: array-like, shape=(n_test, ), decision function value f(x) for all test \n", " samples\n", " \"\"\"\n", " # Calculate the test-training kernel shape=(n_test, n_train)\n", " K_test_train = self._get_kernel(X, self._X_train)\n", " \n", " # Calculate the decision function values (only using SV)\n", " ### BEGIN SOLUTION\n", " g_X = K_test_train[:, self._is_sv] @ (\n", " self._alpha[self._is_sv] * self._y_train[self._is_sv]) + self._bias\n", " ### END SOLUTION\n", " \n", " # reduce to 1d vector\n", " g_X = g_X.flatten()\n", " \n", " # check output dimension\n", " assert (g_X.shape == (X.shape[0], )), \\\n", " \"Output of the decision function must have shape: (n_test, )\"\n", " \n", " return g_X\n", " \n", " def predict(self, X):\n", " \"\"\"\n", " Predict labels using C-SVM:\n", " g(x) = sign(f(x)), with f(x) being the decision function\n", "\n", " :param X: array-like, shape=(n_test, n_features), test feature matrix\n", " :return: array-like, shape=(n_test,), predicted labels {-1, 1} for all test samples\n", " \"\"\"\n", " ### BEGIN SOLUTION\n", " y_X = np.sign(self.decision_function(X))\n", " ### END SOLUTION\n", " \n", " assert ((np.in1d(y_X, [-1, 0, 1]).all())), \\\n", " \"Output of the prediction function must be {-1, 0, 1}\"\n", " \n", " return y_X\n", " \n", " def _get_kernel(self, X, Y=None):\n", " \"\"\"\n", " Caculate kernel matrix using specified kernel-function and parameters.\n", "\n", " :param X: array-like, shape=(n_samples_A, n_features), feature-matrix of set A\n", " :param Y: array-like, shape=(n_samples_B, n_features), feature-matrix of set B\n", " or None, than Y = X\n", " :return: array-like, shape=(n_samples_A, n_samples_B), kernel matrix\n", " \"\"\"\n", " if self.kernel == \"gaussian\":\n", " return gaussian_kernel_wrapper(X, Y, self.sigma)\n", " elif self.kernel == \"linear\":\n", " return linear_kernel_sk(X, Y)\n", " elif callable(self.kernel):\n", " return self.kernel(X, Y)\n", " else:\n", " raise ValueError(\"Invalid kernel chosen.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Tests for the ```_loss_and_grad``` Function" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "231f2c44f098faa685701915e3637f9e", "grade": true, "grade_id": "svm_loss_test", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "# Tests for the loss & gradient function \n", "\n", "# Very simple data\n", "# __X = np.array([[0, 1], [-1, 0], [0, -1], [1, 0]]) \n", "# __y = np.array([1, 1, -1, -1])\n", "\n", "# Linear kernel\n", "__G = np.array([[1, 0, 1, 0], [0, 1, 0, 1], [1, 0, 1, 0], [0, 1, 0, 1]]) # assume linear K\n", "__alpha = np.full((4, ), 0.5)\n", "__loss_val, __grad_vec = SVM(C=1.)._loss_and_grad(__alpha, __G)\n", "\n", "assert (np.isscalar(__loss_val)), \"Loss value must be a scalar.\"\n", "assert (__grad_vec.shape == __alpha.shape), \"Gradient vector must have same length as alpha.\"\n", "\n", "np.testing.assert_allclose(__loss_val, - (2. - 0.5 * 2.),\n", " err_msg=\"Loss value is wrong.\") # remember the negative sign of loss\n", "np.testing.assert_allclose(__grad_vec, np.zeros((4, )), \n", " err_msg=\"Gradient vector is wrong.\")\n", "\n", "# Gaussian kernel\n", "__G = np.array([[ 1. , 0.368, 0.135, 0.368],\n", " [ 0.368, 1. , 0.368, 0.135],\n", " [ 0.135, 0.368, 1. , 0.368],\n", " [ 0.368, 0.135, 0.368, 1. ]]) # assume gaussian K\n", "__alpha = np.ones((4, ))\n", "__loss_val, __grad_vec = SVM(C=1., kernel=\"gaussian\")._loss_and_grad(__alpha, __G)\n", "\n", "np.testing.assert_allclose(__loss_val, - (4. - 0.5 * 7.484),\n", " err_msg=\"Loss value is wrong.\") # remember the negative sign of loss\n", "np.testing.assert_allclose(__grad_vec, np.full((4, ), 0.871),\n", " err_msg=\"Gradient vector is wrong.\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "##### Tests for the ```_calculate_bias``` Function" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "d6f672dd7b31905c297cc0e61aa99842", "grade": true, "grade_id": "svm_bias_test", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "# Test for the bias calculation\n", "\n", "# Simple data (linear separable)\n", "__X = np.array([[-1, 0], [0, 1], [-.75, .75], [0, -1], [1, 0]])\n", "__y = np.array([1, 1, 1, -1, -1])\n", "__C = 10.\n", "\n", "# Get dual variable vector using the sklearn SVM\n", "__svm_sk = SVM_sk(C=__C, kernel=\"linear\").fit(__X, __y)\n", "__alpha = np.zeros((__X.shape[0], ))\n", "# Note: Sklearn stores only dual_coef_i = alpha_i * y_i\n", "__alpha[__svm_sk.support_] = __svm_sk.dual_coef_ * __y[__svm_sk.support_] \n", "\n", "# Determine support vectors\n", "__is_sv = (__alpha > 0)\n", "\n", "# Calculate the bias\n", "__bias = SVM(C=__C, kernel=\"linear\")._calculate_bias(linear_kernel_sk(__X), __y, \n", " __alpha, __is_sv)\n", "np.testing.assert_array_equal(__bias, __svm_sk.intercept_, err_msg=\"Bias term is not correct.\")\n", "\n", "# Simple data (linear separable): shifted data\n", "# Get dual variable vector using the sklearn SVM\n", "__X += np.array([-1., 1.])\n", "__svm_sk = SVM_sk(C=__C, kernel=\"linear\").fit(__X, __y)\n", "__alpha = np.zeros((__X.shape[0], ))\n", "__alpha[__svm_sk.support_] = __svm_sk.dual_coef_ * __y[__svm_sk.support_]\n", "\n", "# Determine support vectors\n", "__is_sv = (__alpha > 0)\n", "\n", "# Calculate the bias\n", "__bias = SVM(C=__C, kernel=\"linear\")._calculate_bias(linear_kernel_sk(__X), \n", " __y, __alpha, __is_sv)\n", "np.testing.assert_array_equal(__bias, __svm_sk.intercept_, err_msg=\"Bias term is not correct.\")\n", "\n", "# Simple data (not separable)\n", "__X = np.array([[-1, 0], [0, 1], [.75, -.75], [0, -1], [1, 0]]) + np.array([-1., 1.])\n", "__y = np.array([1, 1, 1, -1, -1])\n", "__C = 10.\n", "\n", "# Get dual variable vector using the sklearn SVM\n", "__svm_sk = SVM_sk(C=__C, kernel=\"linear\").fit(__X, __y)\n", "__alpha = np.zeros((__X.shape[0], ))\n", "__alpha[__svm_sk.support_] = __svm_sk.dual_coef_ * __y[__svm_sk.support_]\n", "\n", "# Determine support vectors\n", "__is_sv = (__alpha > 0)\n", "\n", "# Calculate the bias\n", "__bias = SVM(C=__C, kernel=\"linear\")._calculate_bias(linear_kernel_sk(__X), __y,\n", " __alpha, __is_sv)\n", "np.testing.assert_allclose(__bias, __svm_sk.intercept_, \n", " err_msg=\"Bias term is not correct.\", atol=1e-6)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Visual Inspection of your C-SVM Implementation \n", "\n", "Here we run a small classification problem, that is linearly seperable. The example is taken from the sklearn-package [Maximum margin separating hyperplane example](https://scikit-learn.org/stable/auto_examples/svm/plot_separating_hyperplane.html). Your model should have *three* support vectors (one red -, two blue +). Your estimated bias should $b=-3.2145$ and your dual variables (of the support vectors, i.e. $\\alpha_i > 0$) $\\boldsymbol{\\alpha}=[0.3834, 0.2537, 0.1297]^T$. \n", "\n", "
\n", " Note: Here for first time we actually run to optimizer. So if anything goes wrong, check that, e.g., your constraints are set up correctly and your prediction functions are outputting the right format.\n", "
" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number of support vectors: [1 2]\n", "Bias: -3.2145\n", "Dual variables:\n", " [0.3834 0.2537 0.1297]\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Create some very simple test data\n", "X, y = make_blobs(n_samples=40, centers=2, random_state=6)\n", "y[y==0] = -1\n", "plot_svm_model(X, y, SVM(C=1, kernel=\"linear\", verbose=False))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### B. Comparison to Sklearn SVM (libSVM) (2 Points) \n", "\n", "In this task your SVM implementation will be applied on two artificial datasets (see also exericse 1) and compared with the performance of the [sklearn SVC](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC) implementation. Sklearn uses [libSVM](https://www.csie.ntu.edu.tw/~cjlin/libsvm/) as solver in the background. If you are interested in SVM solver implementation details, you can read the [libSVM manual](https://www.csie.ntu.edu.tw/~cjlin/papers/libsvm.pdf). \n", "\n", "
\n", " Task: Your SVM implentation is applied here, i.e. do not need to write additional code. Simply run tests in the next cell. It will test all the functionality of your SVM class. Revise your implementation in case some tests fail.\n", "
" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "d75b53653c1bd695903536109c7f34e2", "grade": true, "grade_id": "svm_vs_sklearn_test", "locked": true, "points": 2, "schema_version": 3, "solution": false, "task": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Blobs:\n", "\tOptimizing time: 2.445s\n", "\tTest score (sklearn, scipy): 0.966 0.966\n", "\tN_sv (sklearn, scipy): [14 23] [14 23]\n", "\tBias (sklearn, scipy): [0.624] 0.624\n", "Moons:\n", "\tOptimizing time: 2.563s\n", "\tTest score (sklearn, scipy): 0.932 0.932\n", "\tN_sv (sklearn, scipy): [41 40] [41 40]\n", "\tBias (sklearn, scipy): [0.081] 0.082\n" ] } ], "source": [ "# Test implementation agains sklearn\n", "__X_blobs, __y_blobs = make_blobs(n_samples=350, centers=[[1, 1], [3, 3]],\n", " cluster_std=[0.5, 1.15], random_state=202)\n", "__X_moons, __y_moons = make_moons(n_samples=350, noise=0.25, random_state=212)\n", "\n", "# Make labels being {-1, 1}\n", "__y_blobs[__y_blobs==0] = -1\n", "__y_moons[__y_moons==0] = -1\n", "\n", "# Split data\n", "__X_blobs_train, __X_blobs_test, __y_blobs_train, __y_blobs_test = train_test_split(\n", " __X_blobs, __y_blobs, random_state=191)\n", "__X_moons_train, __X_moons_test, __y_moons_train, __y_moons_test = train_test_split(\n", " __X_moons, __y_moons, random_state=881)\n", "\n", "# Blobs\n", "print(\"Blobs:\", end=\"\\n\\t\")\n", "__svm_sk = SVM_sk(C=2., kernel=\"rbf\", gamma=\"auto\").fit(__X_blobs_train, __y_blobs_train)\n", "__svm = SVM(C=2., kernel=\"gaussian\").fit(__X_blobs_train, __y_blobs_train)\n", "\n", "print(\"\\tTest score (sklearn, scipy):\", \n", " np.round(__svm_sk.score(__X_blobs_test, __y_blobs_test), 3), \n", " np.round(__svm.score(__X_blobs_test, __y_blobs_test), 3))\n", "print(\"\\tN_sv (sklearn, scipy):\", __svm_sk.n_support_, __svm.n_sv)\n", "print(\"\\tBias (sklearn, scipy):\", np.round(__svm_sk.intercept_, 3), np.round(__svm._bias, 3))\n", "\n", "np.testing.assert_allclose(__svm.score(__X_blobs_test, __y_blobs_test), \n", " __svm_sk.score(__X_blobs_test, __y_blobs_test), \n", " err_msg=\"Blobs: Test set accuracies differ too much.\")\n", "np.testing.assert_equal(__svm.n_sv, __svm_sk.n_support_,\n", " err_msg=\"Moons: Number of support vectors does not match.\")\n", "np.testing.assert_allclose(__svm._bias, __svm_sk.intercept_, atol=1e-2, \n", " err_msg=\"Blobs: Bias values differ too much.\")\n", "\n", "# Moons\n", "print(\"Moons:\", end=\"\\n\\t\")\n", "__svm_sk = SVM_sk(C=2., kernel=\"rbf\", gamma=\"auto\").fit(__X_moons_train, __y_moons_train)\n", "__svm = SVM(C=2., kernel=\"gaussian\").fit(__X_moons_train, __y_moons_train)\n", "\n", "print(\"\\tTest score (sklearn, scipy):\", \n", " np.round(__svm_sk.score(__X_moons_test, __y_moons_test), 3), \n", " np.round(__svm.score(__X_moons_test, __y_moons_test), 3))\n", "print(\"\\tN_sv (sklearn, scipy):\", __svm_sk.n_support_, __svm.n_sv)\n", "print(\"\\tBias (sklearn, scipy):\", np.round(__svm_sk.intercept_, 3), np.round(__svm._bias, 3))\n", "\n", "np.testing.assert_allclose(__svm.score(__X_moons_test, __y_moons_test), \n", " __svm_sk.score(__X_moons_test, __y_moons_test), \n", " err_msg=\"Moons: Test set accuracies differ too much.\")\n", "np.testing.assert_equal(__svm.n_sv, __svm_sk.n_support_, \n", " err_msg=\"Moons: Number of support vectors does not match.\")\n", "np.testing.assert_allclose(__svm._bias, __svm_sk.intercept_, atol=1e-2, \n", " err_msg=\"Moons: Bias values differ too much.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### C. Visualization of the Model and Support Vectors " ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# Create synthetic data (Please do not change the random_state!)\n", "X_blobs, y_blobs = make_blobs(n_samples=250, centers=[[1, 1], [3, 3]], cluster_std=[0.5, 1.15], random_state=202)\n", "X_moons, y_moons = make_moons(n_samples=250, noise=0.25, random_state=211)\n", "# Make labels being {-1, 1}\n", "y_blobs[y_blobs==0] = -1\n", "y_moons[y_moons==0] = -1\n", "\n", "# Split data\n", "X_blobs_train, X_blobs_test, y_blobs_train, y_blobs_test = train_test_split(X_blobs, y_blobs, random_state=191)\n", "X_moons_train, X_moons_test, y_moons_train, y_moons_test = train_test_split(X_moons, y_moons, random_state=881)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABHcAAAGvCAYAAADR+jn+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAC5wElEQVR4nOzdeXwURfo/8E8lJBwJ4QwQDoWAXCqXWQGjgKtiwGPV6Kocgq5x8daf5+IFK954rLfEAzn0u7sGj3UlHiyihDNoAAFRCCBowAAaSDgCpH5/VDrTM5mZ9Mx0T3fPfN6vV16TmXRmaq7uqqefekpIKUFERERERERERO6UYHcDiIiIiIiIiIgofAzuEBERERERERG5GIM7REREREREREQuxuAOEREREREREZGLMbhDRERERERERORiDO4QEREREREREbkYgztEcUYIsVUIMdPudvgSQkghxByD24b9HIQQU2ofq0c4/09EREREROQ0DO4QmUwIMaI2eKD91AghfhNCfC6EOMfu9hERERGRtXz6g3cH2OYO3TYjottCIoo1DO4QWecNAOMBXA3gHwBOAlAohDjb1lYRERERUbQcguoP+nNV7d+JiCLG4A6RdZZJKedIKd+WUk4BcDbUd+52e5tFRERERFHyHwAnCSEG6G8UQpwMoB+Aj+xoFBHFHgZ3iKJESrkOwG4AXrVehBAXCiE+EEJsF0IcFkLsFELMFEJ08Nmua23a7jQhRK4QYq0Q4pAQ4gchxJ99H08IkSqEeFkIUS6EqBRCfCaE6OWvbUKIxkKIh4UQm2vbsF0I8bwQooXPdlq9mn5CiBeFEL8KIfYJIf4lhGglhEgUQjxU+/+HhBALhBDdQnmdhBDnCSG+FUIcFEKUCiFuNfh/hp6DTnMhxAwhxG4hRJUQ4mMhRKbPfaYIIZ6ovc9Dta/lEn+vNxEREZEfCwCUoX72zgQAv9T+3YsQorcQokAIsbe2P/SNEMJv9o8QYnzt3w/Wbl8ghOjts402RexaIcQkIcSm2r5SiRDiTJ9tE4UQfxNCfC+EOFB7n6uEEDdG9CoQkeUa2d0AonghhGgJoBWAH33+dA3Ud/FVAL8C6A0gD8BgIcQAKeVhn+1zoKZ6vQrgdwDXAXhXCFEipfxBt908AOcAmANgKYChAL4A0MRP894DcD6AfwN4GkB/ADcByBZCnOanDW8B2AVgKtR0s0kAGgPYDmAggKcAdARwB4C5AE4L/Mp4GQDggtrn9haAywA8J4RoIqV8ooH/Dec57APwdwCdANwM4CshRD8p5d7abV4GcCWAVwCsBZBWe79DAfzL4HMiIiKi+HUMwDsAxgoh7pZSHhNCJAIYA9VHqtFvXLvgw1IAAsCLAMoBXAFglhCivZRyum7bO6H6XCsA/A1Aa6j+zFIhxB+klJt82vJXAM0B5AM4AuA2AB8KIY6XUv5Wu82DtT8zATwD1W/sC+AMAC9F/GoQkWUY3CGyTqoQoi1Uhlw3AA8DSATwfz7bjZVSVulvEEJ8BOBLABf72b43gN5Syh21274HYCuAawHcXXvbeVCBnSellPfU/t/LQogntG10jzUaKijyopTyZt3t6wE8BxVoetGnDduklJfotm0L4FIAywFkSymP1d6eCOBOIcTJUsq1fl8lbycCGC2lnF/7/68A+BrAQ0KIfF3QxUuYz6EKwB+llEdrt10MlRp9T+0PAFwIIF9KaSh7iIiIiMiPWVAnvM4BUAg1VT8DwGwAp/ps+yiAFgBOlVIWA179oYeFEDOllLuFEG2g+parAAzTTmIJIT4AsBLA41B9M70OAPpIKStrt/2y9v+vhDqhBai+zydSyqtNeeZEFDWclkVknWehzrbsArAMwOlQZ0Je0G+kBXaEklYbKFkHlZXzBz/3+5EW2Kn9/zIA3wPortvmgtrL53z+92k/93dh7aVvZsyrUJktF6K+V32uF9VevqEFdnxuN7rs+EYtsAMAUsojAJ4H0BSqIxRIOM/hRS2wU/tY/4HKqrpAt00FVAZVF4PtJyIiIvIipVwDYA08U7OuArC69vY6tSfFRgP4nxbYqf3/aqg+XRMAI2tvPqf2+nP67GQp5TdQmdqjhRC+J/Jna4Ed3bb74N2HrABwohCiT3jPlojswuAOkXWegTrwXgAVVGkMIFVKKfUbCSF6CiHmQR1cK6ACQuUAWkJN4/K1zc9tv0Gl4mq6AthfG/ipI6X8FSpoBJ9tK/UBo9ptDwMohco6aqgN2n3+FOD21jDmBz+3bay9DFa7pytCfw4bA9ym3/YuqFTkbbXz2Z8SQmQFaQcRERGRP7MBXCSEyABwUe11X+kAUgBs8PO39bWXWj+la+1loG2bAmjvc7uRPuQDUFO31gsh1tfWWDzTz/8RkcMwuENknQ1Syi+klB9LKe8EMAXA3UKIuswQIURzAIsAZEHVr7kI6ozMOQD2wP939Jif2wA1N1v/uwywnT+Btg10P4HaYKRt4bQjkv8N9BwafCwp5b+hOk95UIGfawCsEEI8GGYbiYiIKD7NhTrRN6f28p0g2/rro4gAfwtl2wb7aVLKrwFkAhgLlXl+MYD/CSHeCNJeInIABneIoucpAD8DeFIIoX33/gg1//kqKeV0KeWHUsrPoaYz+cvaMWoLgLTas0N1hBDtoDKC9LZCrRzV2WfbZKizQ1sjaEeo/K3mpd22Jcj/bUXoz6G3n9t6+T6OlPJXKeUbUsorAXQB8BWAB4UQTYO0h4iIiKhObTb1Aqi+3xe+2dW1yqFqAvb18zet37LV5zLQtgehFuoIp60VUsp3pJTXADgeKhB1jRCiZzj3R0TRweAOUZRIKQ9BTdXqDU+BO+0Miu938W4/t4Xi49rL23xuv8PPtv+pvbzL5/a/Qq0O9R9ETy8hxCjtihAiCcAtAA5BzR8PJJzncJN+LnptRtUJqH3tapcC9VpGXUp5AKq+USJUsUMiIiIio6ZAZWpP9ffH2rqF8wH8UQgxSLu9tj90K4DDAD6rvflzqP7RLbUns7Rt+0NlgM/X1xY0qrZQs75NR6FWDAWMT7MnIhtwtSyi6HoNwH0A7hNC/BsqQ6ccwGwhxAtQdXf+CFVIeU8Ej/NfqLNDd9dm7ywDMKT2vnf7bPtJ7fa3CCHaQ2WmnAy1xPo3AGZE0I5QrQfwf7WrQvwM4M8ABgO4L9BKWbXCeQ4pUGnG/4ZaCv0WAGUAnqz9e3MAPwsh3gewGsBeqGXer4UqdLgzkidKRERE8UVKuRRqmfNgJkMtIrFACKFfCn0IgLuklLtr72tP7TTxJwF8JYR4F56l0PcBuDfMZm6oXUF0JdSiIL0A3AQ1PX1VmPdJRFHAzB2iKKpdGesFAP0AXCCl/A1ADtQBczKAR6C+lyMAVAa4GyOPI6HmSL8G4DyoKWEdAJwFle7ru20ugGlQgZTnoFaXehnAWfoVGKLgWwBjAJwL1ebOAO6QUj4a7J/CfA5XQ73uU6A6Ql9CLSWqBb8OQC2f3gfqvXkB6kzYY1C1kYiIiIhMJaX8EcBpABZCBVWehCqOPEFKOd1n26cATICq4fME1ImqLwEMrb2fcDwL1We8A6ofdSmANwAMr13FlIgcSvgs3ENERERERERERC7CzB0iIiIiIiIiIhdjcIeIiIiIiIiIyMUY3CEiIiIiIiIicjEGd4iIiIiIiIiIXMySpdDbtm0ru3btasVdExERkQOsWrVqt5Qy3e52kAf7X0RERLEvUB/MkuBO165dUVxcbMVdExERkQMIIbbZ3Qbyxv4XERFR7AvUB+O0LCIiIiIiIiIiF2Nwh4iIiIiIiIjIxRjcISIiIiIiIiJyMQZ3iIiIiIiIiIhcjMEdIiIiIiIiIiIXs2S1rIZ89tlneOmll1BWVoaamho7mkBxLiEhARkZGbjxxhsxcuRIu5tDREREREQ24fiU7GbG+DTqwZ3PPvsMTz/9NJ566in06dMHSUlJ0W4CEY4cOYINGzbgrrvuAgAGeIiIiIiI4hDHp+QEZoxPoz4t66WXXsJTTz2Ffv368YtDtklKSkK/fv3w1FNP4aWXXrK7OUREREREZAOOT8kJzBifRj24U1ZWhj59+kT7YYn86tOnD8rKyuxuBhERERER2YDjU3KSSManUQ/u1NTUMCJKjpGUlMR5tUREREREcYrjU3KSSManXC2LiIiIiIiIiMjFGNwhIiIiIiIiInIxBndMlJiYiAEDBuDEE09E//798cwzzzSYUrV161a88847lrft2muvxfr164Nu88EHHzS4DRERERERETkfx6fxhcEdEzVt2hQlJSVYt24dPv/8c3zyySeYOnVq0P+J1pfn9ddfR9++fYNuwy8PkX9FRcDEicCwYeqyqMjuFhEREZGrsDNBNuD4NL4wuGORdu3aYcaMGXjxxRchpcTWrVtxxhlnYNCgQRg0aBCWLFkCALj33nvx9ddfY8CAAXj22WcDbqe3detW9O7dGxMmTEC/fv1w6aWX4sCBAwCABQsWYODAgTj55JNxzTXX4PDhwwCAESNGoLi4GACQmpqK++67D/3798eQIUOwa9cuLFmyBB999BHuuusuDBgwAJs3b8bzzz+Pvn37ol+/frjiiiui9MoROUtREXDvvUB5OdCxo7q89172yYgofEKIN4UQvwohvgvw9xFCiAohREntz4PRbiMZxAF7bLHq/WRnghyA49PYx+COhTIzM1FTU4Nff/0V7dq1w+eff45vvvkG//znP3HLLbcAAB5//HGcccYZKCkpwe233x5wO18bN27EddddhzVr1iAtLQ0vv/wyDh06hIkTJ+Kf//wn1q5di6NHj+KVV16p979VVVUYMmQIVq9ejWHDhiE/Px+nnXYaLrzwQjz11FMoKSlB9+7d8fjjj+Pbb7/FmjVr8Oqrr1r6WhE5VX4+kJYGtGgBJCSoy7Q0dTsRUZhmAshpYJuvpZQDan/+HoU2Uag4YI8tVr6f7EyQQ3B8GtsY3LGYlBIAcOTIEeTl5eHkk0/GZZddFjC9zOh2Xbp0QXZ2NgBg3LhxWLx4MTZu3Ihu3bqhZ8+eAIAJEybgq6++qve/ycnJOP/88wEAp5xyCrZu3er3Mfr164exY8dizpw5aNSoUUjPmyhWlJYCzZt739a8ObBliz3tISL3k1J+BWCv3e2gCHHAHlusfD/ZmSAH4fg0djG4Y6HS0lIkJiaiXbt2ePbZZ9G+fXusXr0axcXFqK6u9vs/RrcTQtS7rn1RG5KUlFT3/4mJiTh69Kjf7f773//ixhtvxKpVq3DKKacE3I4olmVmAvv3e9+2fz/QrZs97SGiuDFUCLFaCDFfCHFioI2EENcJIYqFEMXl5eXRbB9xwB5brHw/2Zkgh+D4NLYxuGOR8vJyTJo0CTfddBOEEKioqEBGRgYSEhIwe/ZsHDt2DADQvHlz7Nft7ANt5+unn37C0qVLAQDvvvsuTj/9dPTu3Rtbt27Fpk2bAACzZ8/G8OHDDbdZ35aamhps374dZ555Jp588kn8/vvvqKysDOu1IHKzvDxg3z6gogKoqVGX+/ap24mILPINgOOllP0BvADgg0AbSilnSCmzpJRZ6enp0WofARywxxor3092JsgBOD6NfQzumOjgwYN1S82dffbZGDlyJB566CEAwA033IC3334bQ4YMwQ8//ICUlBQAKrWsUaNG6N+/P5599tmA2/nq06cP3n77bfTr1w979+7F9ddfjyZNmuCtt97CZZddhpNPPhkJCQmYNGmS4fZfccUVeOqppzBw4ED8+OOPGDduHE4++WQMHDgQt99+O1q2bBnxa0TkNtnZwOOPA+npQFmZunz8cXU7EZEVpJT7pJSVtb9/AiBJCNHW5maRLw7YY4uV7yc7E2QTjk/jizCaKhWKrKwsqVW+9vM3BPobGbN161acf/75+O47v4tsUIj4mSQiCp0QYpWUMsvudriVEKIrgI+llCf5+VsHALuklFIIcSqA96AyeYJ22oL1v8giRUWqJsuWLSrDIy8vdgfs2nMtLVVZLrH4XOPp/aQ6HAtEjuNTczX0mQzUB2MVIiIiIqIoEkK8C2AEgLZCiB0AHgKQBABSylcBXArgeiHEUQAHAVzRUGCHbJKdHR+Df20lqbQ075WkYi37JF7eTyKKSQzuuFDXrl0ZFSUiInIpKeWVDfz9RQAvRqk5RA3TryQFeC7z8xkMISKOTx2CNXeIiIiIiCgwrgxGROR4DO4QEREREVFgXBmMiMjxGNwhIiIiIqLAuDIYEZHjMbhDRERERESBcSnv2OBbl5112oliCgsqExERERFRcFxJyt0KCoCqKmD8eEAIFdiZPRtISQFyc+1uHRGZgJk7REREREREsUpKFdgpLFQBHS2wU1iobmcGD1FMYHDHZl9++SWEENixY4cp93fBBRdg+vTpptxXtJj9GmjOPfdcvPgiV5IlIiIiojgmhMrYyclRAZ2xY9VlTo4nk4eoFsen7h2fuju4U1UFHDwYlYcSQgT96dq1a1j3e9ppp6GsrAwdO3aMuI0LFizAypUrcdNNN0V8X1Zp1KgRZs6c6XWbma+B3sMPP4yHHnoI+/btM/V+iYiIiIhcRQvw6DGwY77Dh9VKclHIhuL41ByxND51Z3Bn+3bg9tuB0aOBUaOABx8E9u619CHLysrqfj788EMAwIoVK+puW7lypdf21dXVhu43OTkZHTp0QEJC5G/FM888g6uuugpNmjSJ+L6iyczXQO/UU09Fp06dMGvWLFPvl4iIiIjIVbSpWHraFC2K3IEDwPTpanx6/vlqJbkNGyx9SI5PrePW8amzgjuVlWonc/XVwE03AQsW1N/hVFUBt9wCrFkDZGQA7dsDX30F3HkncOxY/fuUEvj5Z/UTwc6rQ4cOdT+tW7cGAKSnp9fd1q5dOzz//PMYM2YMWrRogbFjxwIA7rvvPvTp0wfNmjVDly5dMGnSJFRUVNTdr2/Kl3b9888/x7Bhw9CsWTP07dsXn376adD27dmzB4WFhbjooou8bu/atSsefPBB3HrrrWjdujXat2+PO++8E8d8XqsXXngBvXv3RpMmTXDCCSfgkUcewdGjR73u/7LLLkNKSgrat2+PBx54ABMmTMDZZ59dt83nn3+OESNGoHXr1mjRogWGDx+OFStWeLXl2LFjuPrqq+siyr6vQU1NDY477jg8+uijXu07fPgwWrVqhVdffdVwmwHg4osvxpw5c4K+dkREREREMUtfYycnB5g71zNFiwGe4GpqgM8/B264AbjmGuCdd1Qgx9fDDwMffgi0aQN07KiSEW67Ddi50//97t0LbN0KHDkSdtM4PuX41JdzgjuHDqmgzYwZwO7dwObNwEMPAa+84r3d11+rL0P79kBCApCYqL5ApaUq4KO3ZQvwl7+oeaVjxwITJ6r7tcjUqVMxdOhQfPPNN3jkkUcAAE2bNsWMGTOwfv16zJw5E19++SVuueWWBu/rzjvvxOTJk7F69WpkZWXh8ssvx++//x5w+8WLF0MIgUGDBtX72wsvvICMjAwsX74czz//PJ577jmvaOGUKVMwffp0PPbYY9iwYQP+8Y9/4LXXXsPUqVPrtrn66quxevVqfPzxx/jf//6HHTt24IMPPvB6nMrKStx4441YtmwZlixZghNOOAE5OTnYs2cPAGDlypVITEzEc889VxdR9pWQkICxY8fWi2b+5z//wcGDB3H55ZcbbjMADB48GMXFxdi/f3/A146IiIiIKGYJoVbF0tfY0WrwpKRwalYwzz8PTJ2qxpXl5cDLL6sZJPosmJ9/BpYuBTp1Aho1Uq9nmzZqfPvf/3rfX2Ul8MADwCWXqISGiy8GvvjCsuZzfBpn41MpZYM/AFoCeA/A9wA2ABgabPtTTjlFBhLwb59+KuUZZ0h55ZWenz//Wcrhw6Xctcuz3ZtvSjlsmPd2V16ptvv0U892Bw9KedFFUp59tpRXXKF+Ro6U8oILpKyqCtg+I77++msJQG7ZsqXuNgDymmuuafB/582bJ5OTk+WxY8eklFIuXLhQApDbt2/3ul5QUFD3P2VlZRKALCwsDHi/zz77rGzXrl29248//nh5wQUXeN127rnnyiuuuEJKKWVVVZVs2rSpnD9/vtc2b7/9tmzRooWUUsoffvhBApBffPFF3d+rq6tl586d5VlnnRWwTceOHZMtW7aUc+bMqbstMTFRvvXWW17b+b4GGzZskADksmXL6ra54IIL5KWXXmq4zZrVq1dLAPK7774L2M5gn9dYVFMT/DoRkREAiqWBPgR/ovcTb8czIgoRO4F+Bdx37tihxp1//rNnzHnFFWrMunChZ7tvvpHyj3+sPz495xwpH3zQ+z7vv1/9/+WXq23+9Cc1jg0yVjGC49P4Gp8G6oM1MhgD+geAQinlpUKIZADNIg0q1VNSAiQne9+WmKiyczZvBtq1U7f17KkupfREmWtq1HV90agVK4DfflNZPZo2bVRkdckSQJeuZZZTTz213m3z5s3Dc889h02bNmHfvn2oqalBdXU1du7cGbRA04ABA+p+79ChAxITE7Fr166A2x88eDDgXEb9fQFAp06dsGXLFgDAunXrcPDgQeTm5taloQHAsWPHcOjQIZSXl2P9+vUAgCFDhtT9PSkpCVlZWV4Rxy1btuDBBx/E0qVL8euvv6KmpgYHDhzAtm3bArbbn969e+MPf/gDZs2ahcGDB2P37t0oLCzEvHnzDLc5PT0dAOpek4NRKrztdAUFamajdtJG1mbppqQAubl2t46IiIiILOObocOMneBKSz0zRTRCqOtr1gAjRqjbjj9ejUePHlWZO5rDh4GTTvJc371bzULp2FHdLwA0awbs2we8/z5w4ommPwWOT+NrfNpgcEcIkQZgGICJACClrAZgrBpTKDp2rD/nUEpVR6dNG89tp54K9OqlClS1aaO+SHv3AmeeCZxwgme7339Xf/N17Bigm1NoppSUFK/ry5cvx2WXXYa//e1veOqpp9CqVSssW7YMEyZMaLCgVbJvoAtAjb/nUys9PR17AxSV9r0vIUTdfWmX//73v9FTC5zpaPM3tf8L5vzzz0fbtm3x0ksvoUuXLkhOTsbpp59uuHiX3oQJE/DQQw/h2WefxbvvvotWrVohJycn5DZrr4n2ZYpnUqrATmGhuj5+vPf0a328lIiIiIgorrVqpTrIvp3kmhqgQwfP9datgT//WdUyatkSSErylBE591zPdhUVKqjjW6S3adPAtXkixPFpfI1PjWTuZAIoB/CWEKI/gFUAbpVSVuk3EkJcB+A6ADjuuONCb8k556iR5m+/qS+FlOpD3revd9AmKQl45hngX/9So9KkJFVP5+KLvb90vXqp6zU1ni9QTY2KtPbqFXr7wrB48WK0bdsW06ZNq7vtvffes+SxBg0ahMrKSvz0008hvf4nnngimjRpgtLSUowePdrvNn379gUALF26FGeddRYA4OjRo1i1alXdh3fPnj1Yv349PvnkE5xbuxPbsWMHfv31V6/7Sk5Orlcsy58rr7wS/+///T/897//xezZszFmzBg0qo2EG2mzZu3atUhPTw/vMxlj9CtgFhZ6gjz66ddERERERAQ1Du3eXWXwtG+vOsu//aaybWrHRHX++leVwfPvf6ul0HNzgTFjgLQ0zzadOwONGwMHD6qAjmb/fkCXgWIljk9je3xqJLjTCMAgADdLKZcLIf4B4F4AD+g3klLOADADALKyskIvud6+vQraPP64qi4OAKedBtx1V/1RZ2qqqlZ+zTWB769nTxUwKixU2wuhvjh//KMlKW/+9OrVC+Xl5XjjjTdw5plnYvHixXj55ZcteawBAwYgIyMDixYtwnhtBG9AamoqJk+ejMmTJwMAzjnnHBw9ehRr167Ft99+iyeeeAInnHACLrjgAtx444147bXXkJ6ejqeffhr79u2ri5a2atUK6enpyM/PR/fu3bFnzx7cfffdaKrfcQHo1q0bFi5ciFGjRiE5ORlt27b1267WrVvjvPPOw9///neUlJTgtddeC6nNmi+//BKjR49uMKobL7QAjxbYARjYISIiIiKqJyEBePJJ9bN8ubqta1fg3nu9Z5Zo244erX4CadxYLSD02GOqHEmTJmpKVqdOwAUXWPY09Dg+je3xqZHgzg4AO6SUtZ9ovAcV3DHfiScCs2apSuTJySqDJ1xCAH/7GzB4MPDJJyoTaNQoFWWN0kj2/PPPx3333YfJkyejsrISw4cPx1NPPYUxY8aY/lgJCQn461//itmzZ4f05QGABx54AB07dsQLL7yAO++8E02bNkXPnj0xceLEum3eeust/PWvf8WoUaOQmpqKSZMm4ZxzzsGhQ4fqHv/f//43brnlFvTr1w/HH388Hn30Udxzzz1ej/X000/j9ttvR7du3VBdXa0V7PZrwoQJuOiii3DSSSdh4MCBIbe5srISH374IT7//POQXo9YptXY0Zs9mwEeIiIiIqJ62rQBnnhClfyorgbS0yPrNI8apcqRzJsH/PorMHQocOGFQIsWpjU5GI5PY3t8KoI1vm4jIb4GcK2UcqMQYgqAFCnlXYG2z8rKksXFxYH+hkB/o8j8/vvv6NmzJwoLC/0uOWemY8eOoXfv3rjwwgvx9NNPW/pY4XryySexcOFCzJ8/P+h28fKZ1AI7Wo0d35o7DPAQUSiEEKuklFl2t4M8gvW/iGJOURGQn6+mzGRmAnl5QHZ25NtS3ImXsYAdOD71Ztb4NFAfzOhqWTcDmFu7UlYpgKsN/h9FUcuWLTFnzhyUlZWZft9fffUVfv31VwwcOBD79+/Hs88+i61bt3pFIp2madOmeOGFF+xuhmMIoVbF0gdytCB6SgoDO0REROQSRUVqakxamsqCKC9X1x9/vH7QJpRtichUHJ96s3p8aii4I6UsAcCzcy4wcuRIS+732LFjmDZtGjZt2oSkpCScdNJJWLhwIU4++WRLHs8MN998s91NcJzcXO+C/1qAh4EdIiIico38fBWs0aayaJf5+fUDNqFsS0Sm4/jUw+rxqdHMHYpzZ555JkpKSuxuBpnAN5DDwA4REZGLcIqReu4dO3rf1rw5sGVLZNsSkWtwfFpfgt0NICIiIiIiA7QpRuXl3lOMiorsbll0ZWaqVXD19u8HunWLbFtNUREwcSIwbJi6DPX1jfT/iYjCwOAOEREREZEb6KcYJSSoy7Q0dXs8yctTS0hXVAA1Nepy3z51eyTbApEH0BiAIyKbMLhDREREROQGpaVqSpFePE4xys5WBZHT04GyMnUZqEByKNsCkQfQGIAjIpuw5g4RERERkRtkZqpMEK0oMNDwFKNYlZ1tvNZQKNtGWqOHNX6IyCbM3CEiIiIicoNQpxjZwe31ZsKp0WPm/xMRhYnBHSIiIiIiNwh1ilG0xUK9mUgDaG4IwBFRTOK0LCIiIiIitwhlilG06evNAJ7L/HznttmXFkDLz1dTqbp1AyZPDm0KWCT/T0QUJmbuuFBNTQ0GDhyI9957z+6mhGTmzJlo1MjceOKxY8fQt29ffPzxx6beLxERERGFKFYKPmdnAzNnAosWqctQAzOR/j+Ry3B86mHn+NR9wZ29e4Fnn/Wey7prF/Dcc8CBA5Y9rBAi6E/Xrl0juv8ePXpgypQphrZ96623IKVEbm5uRI9plR07dkAIgS+//NLr9ssvvxw///yzqY+VmJiIKVOm4I477kBNTY2p901EREREAfirrcN6MxSPjh4FXnkF2LTJc9vhw8ALLwA//WTZw3J8aly8jE+dE9w5fBj44gtASs9tBw4A//uf93a7dgElJcC0aepgsWsX8PDDwIYNwG+/eW+rv69gtxlQVlZW9/Phhx8CAFasWFF328qVK8O633A8++yzuO666yCEiNpjmqFp06Zo37696fd78cUXY8+ePfjkk09Mv28iIiIi8hGots7gwaw3Q7FDSmDBAuDQIe/bPvsMqK723FZZCfzwA/DYYyrAc/gw8PTTwLJlwPbt9e/T3+OEgePTyMXa+NQ5wZ2vvgLefBOYM0d9wA8cUF+Qt95SBeM0ffoAd90F7NwJ3HILcPfdwJEjwH33AZ06ebYrLwcefND7C/XLL+q2XbtCbl6HDh3qflq3bg0ASE9Pr7vtp59+wsiRI5Gamor09HRccskl2LZtW93/79ixA7m5uWjbti2aNm2KzMxMPPXUUwCAESNGYPPmzZg6dWpdpHXr1q1+21FSUoJ169bhoosu8rpdCIGXX34Z48ePR/PmzdGlSxc8+eSTXtscPXoUU6ZMQbdu3dCkSROceOKJeO2117y22bJlC0aOHIkmTZrguOOOw0svvYQRI0bg2muvrdvmnXfeweDBg9GiRQu0bdsW5513Hn744Ye6v3fp0gUAcOaZZ3pFjfVpb/v27UOzZs3wzjvveD1+WVkZEhMTUVhYaLjNSUlJOO+88zBnzhy/rxkRERERmUhfWychQV2mpQHLlzu74DNRKHbsUGPRxx9XAR4p1fWZM4ElSzzbtWwJPPCA+g5MnQpcfz2wbh0waZL3Z//IERX0WbzYc9vhw2rMu2pVyM3j+JTjU1/OCe6cfTaQkwPMnw+89pr6kG/dCtx2G5CR4b3tSScBEyaoL8ORIyrIc9xx3tscO6amcE2bpgI8v/yift+9W6XOmWj9+vUYPnw4hg4diuLiYvzvf/9DYmIizjnnHByqjfTecMMNqKiowBdffIENGzbgjTfeQOfOnQEA8+bNQ9euXXHHHXfURVq1D6CvRYsWoVOnTujYsWO9v02dOhXDhg1DSUkJ7rrrLtxzzz1YuHBh3d+vvfZazJs3D6+99ho2bNiABx98EPfccw/eeOMNAICUEhdffDEqKirw1Vdf4aOPPsJ///tffPvtt16Pc/jwYTzwwAP45ptv8PnnnyMxMRHnnXceqmsj2N988w0AoKCgIGDUOC0tDX/605/w9ttve90+d+5ctG/fHuecc46hNmsGDx7s9VyJiIiIyCLBauuw3gzFii5d1Dhz0yY1Nn31VTXT5IILgOHDvbdt3Rq45x41Bj10SI1tzzjDe5uaGjV+feUVFeA5fBh44gkVCNJnApmA49M4HZ9KKU3/OeWUU2Qgwf4ma2qkfOUVKa+8Uv0UF/vfbudOKW+80bPd3XdLuW9f/e3KyqS84QbPdpMmSbljR+DHN+jrr7+WAOSWLVuklFJOmDBBXn755V7bHDp0SDZt2lS+//77Ukop+/XrJx966KGA99m9e/egf9fceuut8tRTT613OwB58803e93Wq1cvee+990oppSwtLZVCCLlhwwavbaZOnSr79+8vpZTys88+kwDkjz/+WPf3PXv2yKZNm8q//OUvAdu0Z88eCUAuXrxYSinl9u3bJQC5cOFCr+3eeustmZiYWHd9/vz5MjExUf788891t/Xr10/eeeedhtus+fDDDyUAWVlZGbCdgQT9TBIRkV8AiqUFfQj+WNP/IjLVhAlSjh7t6WNfeaW6PmGC3S0jClmD+85lyzyf8zfeUGNWX4cOSfnII57trrlGSt2YSsrafzt0SMpp06S88kpZc+WVUo4ZI+WSJRE/B45PvcX6+DRQH8w5mTsAcPCgSn/TrF9ffw6iVmPnyBGVIjd5spqipdXg0evQAfjLXzzXJ0zwnrplkpUrV+L9999Hampq3U+bNm1w6NAh/PjjjwCA2267DY8++igGDx6Me+65B1999VVYj3Xw4EE0adLE798GDBjgdb1Tp07YVTsFrbi4GFJKZGVlebXz0UcfrWvj+vXr0bZtW/To0aPuPlq3bo1evXp53W9JSQkuvvhidOvWDc2bN8dxtVlT+jQ/I8455xy0a9cOc+fOBQCsXr0aa9aswVVXXWW4zRrtNTl48GBIbSAiIiKiEOXlsbYOxQcpVWaN5qefVMaNnlZjZ906NSXrxRfVFC2tBg9Uadg9ewCZ3Bi4+WbI2n870HMAMHSo6c3m+DQ+x6fmrvsVCa3GzrZtwB13qC/H/Pnqb+PGAVpxpv37gUaNVK0dbSrWXXcBb7yh7kOfIvrLL8Drr3uuv/WWCu4ESCkLV01NDcaPH49777233t/atGkDALj66quRk5ODwsJCLFy4EKNGjcLFF18c8jy89PR0LNHP8dRJTk72ui6EqKvQrV0uWbIEzZo1q7edv9/9OXDgAEaOHInTTz8db775Jjp06AAAOPHEE+vS3oxKTEzE2LFjMWvWLNx1112YNWsWBg4ciJNPPjmkNgPA3r17kZiYWDfflIiIiIgskp2tTrLm56upWN26qROunIJFsUTW1tjRpmJlZqoVsB5/XBUQ1wIa1dUquDlpkmcq1gMPqLHt779DSjVba98+AIcPo83rz+HwYeDoEaDR2hLIrxdDnHG6qU3n+DQ+x6fOCe4sW+apsXPKKcCgQer2BQvUnEWt7k6PHioympjo+d+TTgKmT/e+raxMZfNICTz1lPrbww+r2+6/39QAT1ZWFtasWYPu3bsH/fBlZGTg6quvxtVXX43Ro0fjyiuvxMsvv4y0tDQkJyfj2LFjDT7WoEGDMH36dFRXV9f7sgRzyimnAAB++uknnH/++X636du3L8rLy7Fp06a66Ohvv/2GH374oe7/N2zYgPLycjzyyCPo06cPAPXhlroMK61dRp7PhAkTMH36dBQXF+Pdd9/FPffcE1KbNWvXrsXAgQORkOCsZDQiIiKimJSdbX8wR0rPCWB/14ki8fPPqnbUBRcAV1yhPltCAM8/D6xc6QnkNG8OPPKI91i0dWsVBEpMhADQpg2Aw4eRMP0JVJZuxL7xN6Px0EFo89Z0iFdfARKEqd8njk/jc3zqnJHwmWeqglK1LxiEAMaPVxFP34LK+i9OoNuSkoB27VQgp1MnNUXrgQfUfQVIGwvX5MmTsWHDBowbNw4rVqzAli1bsHDhQtx6660oLS0FANx000345JNPsHnzZqxbtw7z5s1Dly5d0Lw206hbt24oKirCTz/9hN27d9dFBX1pFb6XL18eUht79OiBa665Bnl5eZg9ezY2bdqE1atX480338QTTzwBADj77LPRv39/XHXVVVi5ciVWr16N8ePHo1GjRnU7heOPPx6NGzfGCy+8gM2bN2PBggW49dZbvXYabdu2RWpqKj777DPs3LkTv/kuUa9z0kknYeDAgcjLy0N5eTmuvPLKkNqs+fLLL3HeeeeF9JoQEREROVZRETBxIjBsmLosKrK7Rc5SUADMnu0p4SClul5QYG+7KHZ07qwCNFpgBwBOPVUlDvgWS25gfCoE0KZdImRKc+wbfxMODxqKNh0bQ9x1J9C/P+CTBRIpjk/jc3zqnOCOEIBvhW0h6gd2jGrbFnjoIe8aOx06qNvS08Nvpx99+vTBkiVLUFlZiXPPPRd9+/ZFXl4eDh48iJYtWwJQhatvu+02nHTSSRg2bBiqqqowf/78ug/d1KlTUVFRgV69eiE9PR0//fST38dq1aoVrrjiCsyePTvkds6YMQO33347HnnkEfTt2xdnnXUW3n77bWRmZgJQqWTvv/8+UlJScMYZZ+D888/HqFGj0KtXr7o5g23btsWcOXPw+eef48QTT8Sdd96J6dOne0UkExIS8NJLL+Ff//oXunTpgoEDBwZt14QJE1BSUoKcnBy0a9cupDYDQGlpKVasWIG/6OsrEREREblVUZGa9lFervrH5eXquj7AE63gjxODTFICVVVAYaEnwDN7trpeVVW/ZidRuDIy6meDhTE+lRLYU9EIFVffhsODVI2duho8d90FNDBeChXHp/E5PhXSgp1fVlaWLC4uDvQ3BPobGbN582ZkZWVh3bp1fpecM9P+/fvRuXNnTJs2DTfffLOljxWuG264AVJKvPLKK2H9Pz+TREShE0KsklJm2d0O8gjW/yKXmThRBXRatPDcVlGhTlDOnOkJ/qSlqSkh+/ergh6PP25sakdRkaqXU1qq6ojk5fn/v0gfx0r6gI4mJ0dl/nNqFoXA6rGAlCqQs2+f+iq1aVP/uts/shyferN6fBqoD+aczB0yrHv37njttdewZcsW0+/7o48+wieffIItW7Zg+fLluPzyyyGEwJ///GfTH8sMNTU16Ny5Mx5++GG7m0JERERkjtJS70VCAHVd6/vl56tRYYsWQEKCukxLU7c3xEhWkCaSx7GaVsJBj4EdciAh1AwtfSCnTRt1PTExNj6yHJ962Dk+dU5BZQqJVR/mAwcO4O9//zu2bt2KlJQUnHLKKVi8eDHat29vyeNFKiEhAZMnT7a7GURERETmycysn7mzf79alQpQwR/fs+P64E8w+oAN4LnMz6+fjRPJ41hNy9zRmz2bAR5ypFatvOt9awGeWPqocnyq2Dk+ZXCHvFxxxRW44oor7G4GERERUfzKy1PZNID3dChtwNBQ8CeYUAI2kTyOlfRTsrSpWPopWgzwkAP5fiT5ETWG41PjOC2LiIiIiMhJsrNVXZv0dKCsTF3q69zk5algT0UFUFOjLvftU7c3JDNTBWj0AgVsInkcKwkBpKR419gZP15dT0nhqJmI4hIzd4iIiIiInCY7O3DRYi34k5+vMm66dVNZPUaKHDeUFWTW41gtN7f+PBdm7BBRHGNwh4iI4o5+PODvOhGR4wUL/jT0f6EEbEJ8HKMLcZmC81yIiOowuENERHGloACoqvKc4NVKN6SkqBPBREQxL9zAkJ6fKE4RsutWTtcvxOWEldOJiGIda+4QEVHckFIFdgoLVUBHX5OzqkpdJyKiBgRYTj3/kV2OXTmdiCjWMXOHiIjihlaSAVABHW1hFX1NTiIiQvD5VQGWUy8t/g0dz/RentgpK6cTEcU6Zu7Y7Msvv4QQAjt27DDl/i644AJMnz7dlPuK1IgRI3Dttdeaep9Lly7FcccdhwMHDph6v0QUP/QBHg0DO0REOgEyc1BUpP5eWqqiNnrNmyMTWwwvxEVEzsTxaWicND51ZXDn2DF1bHn4YeCJJ4Bvv7U+lV4IEfSna9euYd3vaaedhrKyMnTs2DHiNi5YsAArV67ETTfdFPF9hWLatGl+n/+8efPwzDPPmPpYQ4cOxUknnWT6/RJR/NCmYulpU7SIiAjemTn+5lcFWE49b9AqR66cXsd3R88dP5lo40bgueeAhx4CPv8cqK629vE4Pg0sXsenjgvu7Nqlvgxffw34C35JCTz2mDp5sGgR8OmnwK23Am+9ZW27ysrK6n4+/PBDAMCKFSvqblu5cqXX9tUGv83Jycno0KEDEhIifyueeeYZXHXVVWjSpEnE92WG1q1bIy0tzfT7vfbaa/HSSy/hyJEjpt83EcU2fY2dnBxg7lx1qa/BQ0TkV1ERMHEiMGyYutSyWGJRgMycuvlVeXnwF8XJvv9MPP44kJ4OlJWpS8cUUy4o8N7RaweEggLj9xFPnwGqc+AA8NVXwBdfqCQ2f+bPB667DvjwQ2DpUuDvfwfuusvaAA/Hp6GL9fGpo4I7774LXH458MgjwAMPAJdeCnz3nfc2a9eq4E+nTkC7dkCHDurn7bfVQUTv6FH1Rbv5ZuDGG4GPPwbCfb07dOhQ99O6dWsAQHp6et1t7dq1w/PPP48xY8agRYsWGDt2LADgvvvuQ58+fdCsWTN06dIFkyZNQkVFRd39+qa9adc///xzDBs2DM2aNUPfvn3x6aefBm3fnj17UFhYiIsuusjr9q5du+K+++7Dtddei7S0NLRt2xb33HMPampq6rbZv38//vrXvyI9PR1NmjRBVlYWPvvsM6/7efTRR5GZmYnGjRsjPT0d5557Lg4ePIiZM2figQcewLZt2+qixFOmTAHgnfaWn5+PFi1a4ODBg173+8QTT6BTp0517dm0aRNyc3PRsmVLtGrVCiNHjsTatWu9/mf06NHYu3cvFixYEPQ1ISLyJYRaFUtfY2f8eHU9JYVTs4gogIamKcWaAJk5dfOrtOXU/URxsrOBmTPVSdiZMx0S2DGjmr6bPwMMSoWtpEStpPngg2rWyGWXAe+9573NgQPAs88CbdoAGRlA27ZA587AN9+ooJCvb74BJk9WMdI33wR++y28tnF8yvGpL8cEdzZsAF59VR0bOnZUP0KoD74+yKhNwdIHEhs1UtvqA0FSqiDRI48AmzapEw2PPw5MnWrdmdmpU6di6NCh+Oabb/DII48AAJo2bYoZM2Zg/fr1mDlzJr788kvccsstDd7XnXfeicmTJ2P16tXIysrC5Zdfjt9//z3g9osXL4YQAoMGDar3txdeeAEdO3bEypUr8eyzz+LFF1/Ec889V/f3a665Bp9++inmzJmDb7/9FtnZ2Tj//PPx/fffA1Dpa48//jj+8Y9/4Mcff8Tnn3+OUaNGAQAuv/xy3HPPPejcuXNdlPjOO++s14Y///nPqK6uxgcffOB1++zZszFu3DgkJCRg165dOP3009GuXTt8/fXXWLZsGXr16oURI0agXBcmb9KkCfr374+FCxc2+DoSEfnKzfWusaMFeLgMOhEF1NA0pVgTIDPHa36VI6M4Aegj+YWFwNixnhROo0XX3PoZcHNQymaHDgH33afGmh07quSCtm2BF15Q40vNDz+opAJ9cooQ6vrixd73+fHHwG23AStXAjt3qq/OpElAkGFeRDg+ja/xqWOCOwsXqi9BUpLnthYt1EmCdes8t/lmiOqlpHh+37gR+N//VNS0VSugZUv1+9df188GMstFF12Em2++Gd27d0fPnj0BAPfffz/OOOMMdO3aFWeddRYee+wx/N///Z9XZNKfhx56CDk5OTjhhBPw5JNPoqKiAsuXLw+4/ZYtW9CmTRu/KW/9+/fH3//+d/Tq1Qvjx4/HrbfeWjcncNOmTXjvvffw8ssv49xzz0WfPn3wj3/8AyeddBKefPJJAMC2bdvQoUMH5OTk4LjjjsOAAQNw2223oWnTpmjatClSU1ORmJhYFyVOTU2t14YWLVrgT3/6E2bNmlV32zfffIN169bhqquuAgC88sor6Nq1K1555RWcfPLJ6NWrF55//nm0bNkSc+fO9bq/zp07o7S0NOhrSEQUiG8/nhk7RBRUQ9OUYk2QzBzXirSavls/A24NSjnA6tUqK0f/ticnq8tFizy3paaqGKhvAsGRI2oMqjl8GHjpJRUgSk9X99u5s/qKffSRNc+B49P4Gp86JrhTXR1433r0qOf3YcOAxo29M0X37lX7qVNO8dz2ww/1M3wSElQx5h9+MLftmlNPPbXebfPmzcOwYcPQsWNHpKamYuzYsaiursbOnTuD3teAAQPqfu/QoQMSExOxa9eugNsfPHgw4FzGoUOHel3Pzs7Gzz//jH379mH9+vUAgGHDhnltM2zYMKyrjar9+c9/xpEjR3D88cdj4sSJmD17Nvb7puoacNVVV+Hzzz+ve+6zZ8/GKaecghNPPBEAsHLlSqxatQqpqal1P82bN8fWrVvx448/et1XkyZN6qXQEREREVmioWlKZnFSwV83ZeYYEWk1/Wh9Bszm1qCUAxw75v92IbzHp927q4/Hr796Pk7aMGX0aM92O3aoAI/vkK15c2DFCvParcfxaXCxNj51THBn+HD1BdJ/iQ4cUIGck07y3Na2LfDoo+r3sjL1k5YGTJ+uttW0bOkd2NEkJqpMHiuk6FOHACxfvhyXXXYZhg0bhvfffx/ffPMNXn31VQANF7RK1sLCOsGiqenp6di7d6+hdkoDBzEpJURttK1Tp074/vvv8eabb6Jdu3Z4+OGH0atXL2zfvt3Q42nOPfdcpKenY+7cuTh69CjefffduqgooJ7fWWedhZKSEq+fjRs31s2T1Ozduxfp6ekhPT4RERFRWIxMU4pUKAV/nRQEcgMzqulH4zNgBbcGpRygXz81JUs/Xj92TL39+linEGp8evzxamy6c6cq5fS3vwG1yTIAVDJCTY360Tt0SNXqsQLHp8HF2vjUMcGdAQOAiy9WX4gdO9TPvn3A/fcDTZt6b/uHPwDz5qn5jq+8ogoxn3CC9zanngq0bq2mlUqpfnbvVkGfIUOi85wWL16Mtm3bYtq0aRg8eDB69uxZV5jKbIMGDUJlZSV++umnen9btmyZ1/WlS5eiY8eOSEtLq4tKfuVT7evrr7+u+xsANG7cGDk5OXjyySexdu1aHDhwoG5+YnJyMo4FCm3rJCYmYsyYMZg1axY+++wz7N27F1deeWXd37OysrBu3Tp06tQJPXr08Prx/aKsXbsWWVlZDT4mERERUcSsnqYUSsFfM1Z9ijdmVNN361Q1twalHCA1VdV/rajwjE937lQLAOmGSQDUAj9vvAG8/rpaDv3DD4Fzz/Xepm1bYMQI4JdfPAkNVVXq90suicYz4vjUV6yNTxvZ+ug6QqjiUjk5QHEx0KwZcPrpQPv2/rdPSvLO6PHVpImqWj5tmpqGJYRKmbv/fnXf0dCrVy+Ul5fjjTfewJlnnonFixfj5ZdftuSxBgwYgIyMDCxatAjjfeYTl5SUYMqUKRgzZgyKi4vxj3/8oy7S2L17d1x22WW44YYb8Nprr+H444/HK6+8gu+++w7vvPMOAOCNN95ATU0NTj31VLRs2RILFizA/v370bdvXwBAt27dsHPnTixduhQnnHACmjVrhmYBXuQJEybgmWeewX333YdRo0Z5fSluuukmvPHGG7joootw//33o0uXLtixYwfmz5+P8847D6eddhoA4Mcff0RZWVld0SwiIiIiy2VnWzeQ19eDKSxUP0D9gr/6IBCg/qbPSJHSuiJiRUWqTktpqcoGyctzfmBDLzfX+/XRXvNQXi8rPwNW0YJS+flqKla3bipi4bbnYZMzzwT69FGFkQ8eVAkEPXv6/9gIAfToEfz+7rpLzS7R6u6mpQFTpqjHiAaOT+uLpfGpY4I7gPpC9Olj3of7+OOBGTM88x/bt49u0czzzz8f9913HyZPnozKykoMHz4cTz31FMaMGWP6YyUkJOCvf/0rZs+eXe/Lc/PNN2Pbtm3IyspCo0aNcP311+P222+v+/vrr7+Ou+66C+PGjcO+fftw8skn4+OPP0bv3r0BAK1atcL06dNx99134/Dhw8jMzMSMGTNw1llnAVCFui677DKcd955+O233/DQQw/VS1PT9OvXDwMGDEBJSQnuv/9+r7+1b98eS5cuxeTJk3HJJZdg37596NChA8444wxk6HIV58yZg3POOQeZmZlmvHREANzfZyUiIpfTgg1a4AaoH3wwGgQym7biUlqa94pLbshc0YvXavpuDEo5SIcOwKWXmnNfKSlqWfVbblGz4zIy1NSvaOH4tL5YGp8KI/PbQpWVlSWLi4sD/Q2B/kaR+f3339GzZ08UFhbWLTnXtWtXXHvttfU+qG5VWVmJHj164IMPPsAQk+bX8TNJ+j5r8+bqYLtvn/v6rETRJIRYJaXk/FgHCdb/IhfQT8XSBAraSKmW89bMnWttoGLiRBXQadHCc1tFhZqaNHOmdY9LFAUcC1iH49PwNPSZDNQHc0zNHYpcy5YtMWfOHJSVldndFMts2bIF06ZNM+2LQwRwlVAiIrJZKAV/I131KRxOXnGpqEgFn4YNU5dFRXa3iIhqcXwaXY6alkWRGzlypN1NsNTJJ5+Mk08+2e5mUIwpLVVZ5npO6bMSEVEcCFTwF/Au+OsbBNLX3AGsm5qVmVk/c8cJKy7FynQxohjG8Wn0MLgT47Zu3Wp3E4gcz6l9ViIisoFdRdiMFPw1GgQyW16eCpoA3vOXJ0+25vGM0qfeAp7L/HwGd4gciuNT63BaFhHFPa4SSkREADyZIOXl3pkg0ZrqY6Tgb26ud9BHC/Dk5lrXLqcuA+7k6WJERFFmKHNHCLEVwH4AxwAcZQFFIoolXCWUiIgAuCcTxI5Vn5y44hJTb4mI6oQyLetMKeVuy1pCRGQjJ/ZZiYgoyliEzV2cOl2MiMgGnJZFRGQD30VNrFzkhIicRQjxphDiVyHEdwH+LoQQzwshNgkh1gghBkW7jXErM1MFCPSYCeJcTp0uRkRkA6OZOxLAZ0IICeA1KeUM3w2EENcBuA4AjjvuOPNaSEQUYwoKgKoqT8kEbfGTlBRrSyYQkWPMBPAigFkB/j4KwAm1P4MBvFJ7SVZjJoj7MPWWiAiA8cydbCnlIKjOxo1CiGG+G0gpZ0gps6SUWenp6aY2kogoVkipAjuFhSqgo1/VtqqKGTxOV1QETJwIDBumLqNVY5Vii5TyKwB7g2zyJwCzpLIMQEshREZ0WudSZn05mQlCREQuZSi4I6X8pfbyVwDvAzjVykZRcDU1NRg4cCDee+89u5sCAOjatSumTZtm6n2+++67+MMf/gDJkS7FGG1Rk5wcFdAZO1Zd6le1Jf/snspm9yI6FFc6Adiuu76j9rZ6hBDXCSGKhRDF5eXlUWmc45j95czOBmbOBBYtUpcM7BARBcXxqTM0GNwRQqQIIZprvwMYCcDvHPFokBJYvbr+bWvWWPu4QoigP127do3o/nv06IEpU6YY2vatt96ClBK5UZ6/ce2112LEiBH1bl+5ciVuv/12Ux/riiuuwIEDBzB37lxT75ecwe5But20AI+eGYEdp2WVmNmeggJPphPgyXgqKDCjpcboF9FJSFCXaWnqdiKT+dsb+N1TMnMa/HISke3Wrweqq71v++474Ngx6x6T41OOT30ZydxpD2CxEGI1gBUA/iulLLSiMZWVDd+2dCnwxBOeDr2UwIwZKmN20yYrWqWUlZXV/Xz44YcAgBUrVtTdtnLlSuse3Mezzz6L6667DsIhp/jT09ORkpJi6n0KIfCXv/wFzz33nKn3S/ZzwiDdbtpz1tO/JuFwWlaJme1xylS20lJVgkOPi+iQRXYA6KK73hnALza1xfn45SQiixgZn+7Zo8aiTz/tCfAsWgQ89hjw8cfWtY3j08DidXzaYHBHSlkqpexf+3OilPIRKxpSVATcdpt3gOa//wXuuAPYtctz29ChwPDhaiD473+rwM6iRaoIaY8e+nYDCxd6R0uPHVO3hTMQ6NChQ91P69atAagPjXbbTz/9hJEjRyI1NRXp6em45JJLsG3btrr/37FjB3Jzc9G2bVs0bdoUmZmZeOqppwAAI0aMwObNmzF16tS6SOvWrVv9tqOkpATr1q3DRRdd5HW7EAL/+Mc/kJubi5SUFHTs2BHPPPOM1zZlZWW44oor0LJlSzRt2hQjRoxAcXFx3d+PHDmC//f//h86d+6Mxo0bIyMjA1dccQUAYMqUKXjjjTewaNGiujbOnDkTgHfa23333YdevXrVa/f111+PIUOG1F1ftWpV0NcLAC6++GKsWrUK33//faC3hVzGKYN0O+mfc04OMHeuZ4pWJAEep524NrM9TpnKxkV0KIo+AnBV7apZQwBUSCnL7G6UY/HLGXviPcWXHKGsDLj9duCzzzy3bdwI3HorsGKF57Y2bYC//EVl6jz9NPDFF2qMetJJwKhR3vdZXAz89pv3bcuW+Q8iNYTjU45PfTlmKfQ+fdRJlsceUwGe//5XDXr69gXatvVsJwRw3XUqzf/99z2BHd8MsHXr1CDihRdUUOfYMeDVV9VtJSXmtn39+vUYPnw4hg4diuLiYvzvf/9DYmIizjnnHBw6dAgAcMMNN6CiogJffPEFNmzYgDfeeAOdO3cGAMybNw9du3bFHXfcURdp7dKli9/HWrRoETp16oSOHTvW+9vUqVMxYsQIfPvtt7jnnntw9913Y968eQAAKSUuuugifP/99/j444+xYsUKtG/fHueccw52794NAHjhhRfwr3/9C3PmzMGPP/6Ijz76qO4Df+edd2LMmDEYOnRoXRsvv/zyem2YMGECfvjhByxdurTuturqavzrX//ChAkTDL9eANCtWze0a9cOCxcuDPk9IWdyyiDdTkKoVbH0z1l7TVJSwn8NnHbi2uz2WDWVLRR5eWrRnIoKoKZGXe7bp24nCoUQ4l0ASwH0EkLsEEL8RQgxSQgxqXaTTwCUAtgEIB/ADTY11R345QzOaXN2G8IUX3KI9HQ1Rp05UwV4Nm5UGTqtWgE9e3pvO3y4GqOuXQu8+SbQq5dKUkhO9mxTVaXGo9OmeQI8CxYAzz8PfPCBuW3n+NQjnsanRpdCt1zr1sADDwAPPww8+KC6bfBg4KabgMTE0O/vpJOAceOAOXOAf/xD3cfy5cDllwMDB5rb9ieffBLnn38+pk6dWnfbnDlz0KpVKxQWFuKiiy7Ctm3bcPHFF2PAgAEA4DUHsnXr1khMTERqaio6dOgQ9LG2bNmCTp381lTEeeedh5tvvhkA0LNnTyxfvhzPPPMMLrnkEvzvf//DihUrsG7dOvTt2xcAMGvWLHTt2hUvv/wyHnzwQWzbtg09e/bE8OHDIYTAcccdhz/84Q8AgNTUVDRt2hTJyclB29izZ08MHjwYs2bNwtChQwEAH3/8MSorK+u+bEZeL02nTp1QWloa9DUhd9EG6YW6yZ3xEtjR5Oaqvqr2nLXXJJLXIDNTTX1q0cJzm50nrs1uT6CpbNH87GiL6OTnqyBVt25qdWTWWqVQSSmvbODvEsCNUWqO+wX7chYVqdtLS9WOKS/PmV9a/UHB3/VwaXNk09K858g6dQUwfYovoHby+nRXs14XIgMaNQJuuUUFX2oTQtCxI3D//UDLlqHfX0oKcPfd6us3bRpw2mkqZjlwoBqjmonjU494Gp86JnMHUAGeQYM813Ny6gd2tBo7X30FXHyxZ4qWv2D+6NHAmDEq/W35cuCyy4A//cn8dq9cuRLvv/8+UlNT637atGmDQ4cO4ccffwQA3HbbbXj00UcxePBg3HPPPfjqq6/CeqyDBw+iSZMmfv+mfVg12dnZWL9+PQBg3bp1aNOmTd0XBwAaN26MwYMHY926dQCAq6++GmvXrkWPHj0wadIkFBQUoNq3MpgBV111Ff75z3/W/e/s2bNxwQUX1KULGnm9NE2aNMHBgwdDbgM5lxX1ZtzIt28aaV/VaSeuzWyPVVPZwsFFdIgcyt+X02nFyAKxMlPFaXN2G8IUX3KYRo2Ac8/1XD/1VP+BnUWL1Bj15JOBa65RWT76Gjyanj3VbqisTH3Fu3VTpUmSksxtN8en3uJlfOqo4M5//wvMn68+9G3bAk8+Wb9I8tKlnqlYl12m0t+0AI/vtseOAfppctu2WVOxvKamBuPHj0dJSYnXzw8//IBrr70WgPpgbtu2DZMmTUJZWRlGjRqFcePGhfxY6enp2Lt3r6FtfZdp81fgSkpZd/uAAQOwZcsWTJ8+HcnJybj11lsxYMAA7Nu3L6Q2XnHFFaiqqsJ//vMf7N27F5988gmuuuqqur8beb00e/fuRdyu/hGDnDRIjzXaiev0dNVhSE+398Ssme2xaiobEcU4NwQ2rC5G57Q5u0Y4YR4uUa2NG4Hp04F27VR91w8+8K7BA6iCym+8oWaO3HEHcPbZaoz63XdqbOtr+3bP7/v3h1dvpyEcn3qLl/GpY6ZlffWVGuhpU7EqKtQUrcceAx55BNAyrYYOVZ35/v3Vda0Gz9Ch3gWVtRo7RUUqzS0pSU3ReuEF4Oabw5vqFUhWVhbWrFmD7t27B60QnpGRgauvvhpXX301Ro8ejSuvvBIvv/wy0tLSkJycjGMGIk+DBg3C9OnTUV1djWT9JE4Ay5Ytww03eKblL126FH369AEAnHjiidi9ezfWr19fFx09fPgwVqxY4fU/qampuPjii3HxxRdj8uTJyMjIwKJFi3DBBRcYbmPr1q1x/vnnY9asWdi1axdatGiBUbpqYkZfr4MHD2Lz5s3Iyspq8DHJHQIN0gEO0s2Qne2sTBIz22PFVDYiinGlpSpjR89pgQ39gbCw0DMdyaxMFafN2TXCCfNwiQD8/LM6MdWmjZqKlZrqmaKVmqqmVQHq7/feq8ai2vBs+HB1e+1QrM6CBSoQNHCgmmXy9NNqitb996taPmbh+NRbvIxPHZO5M2AAcOGFnho7Wg2enBygfXvPdkJ4Ajv62/r1875t40ZgyRIV2PnTn9SXZ9w4Vdl87Vpz2z558mRs2LAB48aNw4oVK7BlyxYsXLgQt956a918vJtuugmffPIJNm/ejHXr1mHevHno0qULmteeTenWrRuKiorw008/Yffu3aipqfH7WGeeeSaEEFi+fHm9v3388cd48cUX8eOPP+KFF17AP//5T9x+++0AgD/+8Y849dRTMWbMGBQVFeG7777DVVddhUOHDuH6668HADz11FOYO3cu1q1bhy1btuDNN99EYmIietZWDOvWrRu+//57rFu3Drt378bhw4cDviYTJkzA/Pnz8fLLL+PKK69Eki7X0MjrBQCLFy9G48aNMXz48FDeDnK43Fzv/pnWr/Utik7ky+ypbEQU49yyipaVmSpOm7PbkEhTfLnKlvs5qAB4Rob6+Gk1drQaPBdcUH/s2bevd/FkQGXy6BMKqqqAf/5TBXZuuw048UQVFPrtN+9alGbg+LS+uBifSilN/znllFNkIMH+ZrZt24zdFqqvv/5aApBbtmypu23NmjXywgsvlC1btpRNmjSR3bt3l3l5eXLPnj1SSilvuOEGecIJJ8gmTZrI1q1by9GjR8vvvvuu7v9XrlwpBw0aJJs0aVLvvn1NnDhR5uXled0GQD777LPyT3/6k2zatKns0KGDfPLJJ722+eWXX+Tll18uW7RoIZs0aSKHDRsmV65cWff3V199VQ4aNEg2b95cpqSkyKysLPnBBx/U/X3Pnj1y1KhRMi0tTQKQb731lpRSyuOPP14+/PDDXo9VXV0t09PTJQBZXFxc7zk09HpJKeVVV10lr7vuuoCvg1mi+Zm0Sk1N8OtERGYDUCwt6EPwx5r+V1xavFjK00+XcvRoKS+/XF2efrq63UlqaqR8+20pr7zS8/P22+YdzBcvlnLCBCmHDVOXTnv+vt57z/v5a6/Pe+9Z83/kHDZ9Z6O57/zlFymrq71v27FDyqNHI7tfjk/ja3waqA8m1N/MlZWVJfXr0/v8DYH+RsZoqWDr1q2rW3JOCIHZs2eHNU/SibZv345+/frh22+/9arcbgW3fyYLCtSZAO0kn6w96ZWSwmwYIrKOEGKVlNKZeclxKlj/K25pq2Vpq2g5bbUs6ZOp4rs6VLxORZIhrh7G1zE2TJxYfxphRYUq3KctV2UBt48FnIDjU3M19JkM1AdzTM0dMq579+547bXXsGXLlrovT6zZunUr8vPzLf/iuJ3kiqFERESBOa0YmS8zi9G5Zdl3I0Kdh2t17SKKDjfUySK/OD51BgZ3XOrPf/6z3U2w1BlnnGF3E1yBfRmyQqgnTImIKAJmVIzXln1PS/Ne9t3OZROjTXvd9MVL2BlyFzcWAKc6HJ/azzEFlSkyUsqYSXmj0HDFUDJTQYF3zUot072gwN52ERHFtEgrxrth2XeraQcsPSNFmMk53FYAnILi+DT6GNwhcjn2ZczloEUaok4/zU/7DGnT/Kqq+JkiInKs0lI1fUUvnqaz+NbcMbLKVjwf8AFnPv/sbJVtlp4OlJWpy3jKPiOKUNSnZSUkJODIkSNeS48R2eXIkSNISHBvjDNY/UCAGTyhivesdk7zIyJyqXifzhJq7SInHPDtrJHkhOcfiA11sjg+JSeJZHwa9VFtRkYGNmzYEO2HJfJrw4YNyMjIsLsZYQvUl8nJCb0OIzGrHeA0PyIiR/HNOAmUQsnpLKp2kf6ApR3Q/C0davcBXwuulJd7B1eilT1j9/N3GI5PyUkiGZ9GPbhz44034q677sKaNWtw5MiRaD88EQAVEV2zZg3uuusu3HjjjXY3JyKh9GUouHjPagc4zY+IyDFCKYLG6SyK0dpFdh/w7Q6u2P38HYbjU3ICM8anUZ+WNXLkSADAAw88gLKyMtTU1ES7CURISEhARkYG7rjjjrrPpJtFWoeRlHjPauc0PyIih9AXQQO8d8g5Of6XMXT6su9OYvcB3+4lv/XPv7wc2LwZ+P13oHVrlT0UZ58jjk/JCcwYn9qyFPrIkSNjYkBNRLElL09lRQOqj7V/v8pqnzzZ3nZFS6glC4iIyCJCqAH49u3AnXcCU6YA3burnTIj7ZGz+4Bvd3BJe/579wKbNqnbEhNVxpdTau9EGcenFAvcW0mWiMhkzGrnND8iIkcoKgL+9jcVeGjaFDh0CFi9WgUFGNiJnN0HfLtrJGnPv7wcOHZMfc4GDFDBpTiuvRMpJy5ARvFFSAsKKWRlZcni4mLT75eI7F1cgQLj+0LxRgixSkqZZXc7yIP9rxgycSLw66/Ab7+p4AMAVFer7J2vvmKAJxZoHYctW1RQxY6Ow7BhanqYfmWemhr1mVu0KLptcTn9AmT6ZLB4O0lI0RGoD8bMHSIXsXtxBfKP7wsREZlCO+m6eTOwZw/wyy9ARgYwdCjQpQuwcaP9Ve6NruBlF6e2zzetAwBmzlRBlJkzzY8AGEkjycxUUQi9eCo2aCK7a2QTAQzuELkKDxz1OaEPx/fFGKYrE1FMsGpnpl8dq3t34MgRIClJ1UIRAmjTBujVy94iaKGs4GUHp7Yv2meBjD6e3dPDYggXICMnYHDHYhzMkJl44PDmlD4c35eGMbuJiGKCVTsz/epYs2cD114LVFaq244cUSsZ7d8PPPaYfUXQfNuoX2Kxqsr+DBknty/aZ4GMPp7dtYdiCJOgyAlsWS0rXujnXuqP/9xnUrjsXlzBScJZJdYqfF8apu9nAp7L/HzuD4nIRazamemXJ9QObMcfrwopCwG0awfcd5+9O0zfNmrt1C+xaCcnty/aS5+H8njZ2TwQm8DuBdiIAGbuWIpTNchszJ710PpwOTmq/zZ2rCewE+0+HN+XhjG7iYhigpU7M31wAlBZFF99pX6sqMkSDt82AvYHTvSc2r5op3UwjSTqmARFTsDgjoU4mCGz8cDhzSl9OL4vDWM/k4higpU7M20akZ7dxZN9Ob2NTm1ftM8C6R/v2DHvx7P7tXCJcEprZGdbWyObqCEM7liIgxmyAg8cHk7qw/F9CY7ZTUQUE6zamenrw+TkAHPnelJTnRCccEMbndy+aJ8F0h7vwAFg9WqgbVt1/bTTnFFg2uFYJ5DcisEdC3EwQ2QdJ/fhqD5mNxGRLcxeUtGqnZkQahUs/dxibe6xnatjuamNTm9ftM8CnXYacPXVwKBBwFlneQI7Tigw7XAsrUFuJaQFX+ysrCxZXFxs+v26UVGR2hFs2aIydvLyOJghMktBgeqfaH04LeCTkmLfYiJE8UIIsUpKmWV3O8iD/S8fbjxI+K4GEM3VAYxyehud3r5o0p8J0zihwLTDDRumMnYSdGkQNTUqnrtokX3tsoM2li0tVbNSOJZ1hkB9MK6WZTEWoCeyTm6ud59NO0nH/goRUZyze0nFcEdEvm1y4gHN6W10evuiSesY6YM77Cg1iKugKlz52X04LYuIXI19ODIqnOKIRORSdi6pyIId5BROKk7oIiytoXB6mvswuENRxcEVEdmBYy2iOGTXkoqBRkSPPMJOEJnDSIfazOKEUno/5oQJMf35ZZ1AhSs/uw+DOxQ1HFwRkV149okoDtmVteBvRHT4sOrwsBNEkTLaoTarwHRBAfDAA8A996jHysgASkqAa6+N6c8vV0Hlys9uxOAORQ0HV0T1mb2QC/nHs09EcULLLjjjDJVhMHt29JdU9Dci+v57tdOJw04Qs7ZNFkqHOjfXO1tNC/AYLSiu1a565x31mU5LA376Sc1TSk4GZsww73mR43B6mvswuENRw8EVkbeCAu8xhnaSuaDA3nbFIp59IooD+oyGTp3UoHTbNrUDiOay2P5GRPv3A716eW8XB50gZm1bINQOdSTFCbXvTVIS8PvvwNKlap5SRgbQuzewdWsoLSeX4fQ092Fwh6KGgytyKjvOKuoXctECPNrU+Koq52bwuDXTiGefiOKAb0ZD795Ajx7A66+rv4eatRAufyOi004DmjTx3i4OOkHM2rZAtDvUQgBDhgBHjnhu69oVqKyM+c8vcXqa2zC4Q1HDwRU5kV1nFe1cyCVcbs404tknojjgL6MhLc07oyFaO1ffEdH998dlJ4hZ2xaIdodaSqBLF+DoUaC6Wl1fv149box/fonchsEdihoOrsgsZmaP2HlW0a6FXMLh1kwjPZ59IgpDpKmN0UyNdHKKcJx2gpz8lrhWND9L2sG+tBS47jrgnHOApk3VmzhihMpIIyLHENKCHnlWVpYsLi42/X6JiAoKVDBBC4Jo/Y6UlPAy7YcNUxk7CbpQd02N6i8tWmReu/3RB0g0Ts7ccVt7yVpCiFVSyiy720Eepve/tNTGtDSVbrF/v8oQMDqQjPT/o91eJykqUmcZSktVhCQvz33PAbH1ljiW1Z8VszteRBSxQH0wZu4QkWtYkT1i11lFfdujvZBLuNyUaUREJog0tTHaqZGxkh0TQ1WIXfOWGM0wc1rhuWh8ViJdcYuIoqaR3Q0gIjJKH1woLPRkkBjNHvF3cisvT/WDAO+zipMnW/c8ANXWlBTvtmvPzeqFXMKlBaT0Zs9mgIcoZpWWqgGjXigFUyL9/3BkZzswchAifVAM8Fzm57vyuTn+LdGnF+kDJPoolJTAvHmeDBaN3Rks0fqsRLLiFhFFDYM7ROQqWhBEPzXIaGAnUN/t8cdVP2jLFpWxM3lydDqiubmqv+h7MsyJfSbfTKPx472naDm13U6if6/9XSdynMxMtbPUBoxAaKmNkf5/tDhtCpQdQbF41lCApKBArQwFAJ9+6snWKS4G9uxRB0Wzduihfhb5WSEiHU7LIiJXCZQ90lBmdLDZAXYW2nXLybBAmUY5Oc7NNHISN680RnEs0lV53LBMplnTWswsHM0qxNEVbEkvbT74p5+q2889F3j1VeChh1Rw59xzzTu7Ec5nkZ8VItJhcIeIXCOSOjVcjjVynHYfnlhYaYziVKQFU9xQcMWMukBm1z1xQ1AslgQLkOjPZHz6qdpxl5UBGRnq71ddZd7ZjXA+i/ysEJEOp2URkWtEUqfGLbMDnM6MTCOnzYCwWqS1oohsFWnBFKcXXDFjWovZdU+0oJgd84VjjZEDTkPF97Sd+Pz5wNat6jat82Bm4blwPov8rBCRjuHgjhAiEUAxgJ+llOdb1yRyG9aRcIdYeZ/CrVNjV+Fk8makbmUsCrdWFBFZzIzIvxV1T5weFHMDowechgIkUgKzZqnAjpa1c+656m/BCs+FeiYj3M8iPytEVCuUaVm3AthgVUPInVhHwh1i7X0KJ3vEDbMDosXM0hChivbKyE4Rbq0oIrKYGdNaol33xM6duJuEcsAJVHxP23l/+imQlQVMnQpMmuRdg8df6nA4U/U4xYqIImQouCOE6AzgPACvW9scchPWkXAHvk8edhZOdgqzS0OEKh5rH0VSK4qILGZG5D+ag3K7d+JuYsYBRz8f/PnnVY2dq65S11NT1e/+Cs+FcyaDZ6GIKEJGp2U9B+BuAM0DbSCEuA7AdQBw3HHHRdwwcj7WkXAHvk+kZ3ZpiFDFY+2jSGpFEVEUmFFXKFp1T+zeibuJWQcc3/ngQMMdqHCn6nGKFRFFoMHMHSHE+QB+lVKuCradlHKGlDJLSpmVnp5uWgPJ2fSDFA0DBs7D98l57MqqtztzJl6zzrnSGFGMMys1tKGDg907cTcx84AT6nxwty5R7ptKytRSIlcxMi0rG8CFQoitAP4PwB+FEHMsbRW5ButIuAPfJ2exM6ve7v5mPGedm7HSGBE5kFnReiMHB7t34m5y2mneB5y2baN3wHHjmYxYK9BIFIcaDO5IKf8mpewspewK4AoA/5NSjrO8ZeR4rCPhDnyfnMfOosJO6G+y9hERxYxIo/X6wNCECcDRo8EPDk7YibuBFqg47TR1oPnyS+Css4CdO6Pz+G47k8ECjUQxwfBS6ES+WEfCHfg+OY8Vq+YaFc3SEEREMS+SGji+S3V/950K1qSmqmAAUP/gwJ14w/SBCkB1evRnuXzr51gl2vVzQl16XY8FGoligpAWRGKzsrJkcXGx6fdLzuR7jIzWMZNCw/fJOSZOrF/jsaJC9eVnzrSrVUShEUKsklJm2d0O8mD/ywbDhqnATIIuGb6mRmVrLFoU/H99DwbLlqkpVs2bA0OGqNt4cAiPPvNE01CgIpLgiN30gcLmzdXnaN++0LOFpATGjvVcnzuXnUUiBwrUBzO0FDpRMKwj4Q58n5yDWfVERDEikho4vsWRu3dXl7//zoNDpEJdScLpS8w3VNfJjPneLNBI5HoM7hARRZnbpuITEcWVUFYMiiRa7xsYSk8HevQAWrfmwSFSoQYq7CyG1xAjgadIV1FjgUaimMCaO0RENoj2VHwiIjKgoEDVa9GyPLRBb0oKkJtbf/tIauDk5alBOuCZStOoEfD22zxARMI3UKGvuQP4z+CxsxheQ4zUdcrMrD/fO5RV1NxSoNHNU+eIooDBHaIYwGMdERFRhMItxBtutJ7Fka0RTqAi0uCIlYwEnvwFCvftU58no3JzvT/j2uvmpMCOvgC5lsHE7DaiOiyoTORyZtXQIyIKBQsqOw/7X36EuppAOIV4yZlCee+LiiDvuReihaczJSv2QTzhgM6U0VUYtDN9WqAw1s70cTUKojosqEwUo5w8TZyIAmuoPiYRRaigwLteiBa4KSgI/D+hFuIl5wphJYmCndmYPeINyLaqGJ5sm47ZI95AwU4HBEeM1nXKzlZBjkWL1GUsBXaAyOsKEcUBBneIXI7HOiL3cfrCLESup59ipQV4tIycqqrABWK5YpAxMRSdrvuolPbE7LNmQn65CLPPmonC0p5BPypRw1UYlEhWpiOKE6y5Q+RyTp4mblSoWfPkDqwFFZiR+phEFAF9Bk5hoWeaVbApVuEU4o1HMVb7JJyPiuX8HUDjfeqRGXWFiGIcM3eIXC6SVVidIJyseXI+ZqYEx4w7oigIdYpVoEK8OTnOWjHIbjE4H9xRs/F4APWPGUxEDWJwh8jl3HysCzdrnpwvBvv+pmJ2OVEUhDPFKjfXe1Svjfr9LYMer2IwOu2o2Xg8gAYW63WFiCLEaVlEMSDcVVjt5shUaDKFkZVb4xmzy4ksFskUqxAK8calWJgPruO42Xg8gBJRmJi5Q0S21kV0VCo0mYaZKcG5OeOOyBU4xco6bp8P7sNxHxUeQIkoTEJakG+YlZUli4uLTb9fIjKfvi6iPoMgWgNN/RkzDTN33M/uzxVZTwixSkqZZXc7yIP9Lz9Ysd8aWsHfLVtU0CEGKuY75qPCAygRNSBQH4yZO0Rxzs6p3b6p0HPnqkt9DR4yR7Szs5iZQkSOwClW1ojB2ieO+ajwAEpEYWLNHaI4Z+fU7kCp0ACz5s1k16q1bq0FRUREsc0xWTqBROMA6m+5dR60iVyNmTtEcc7uqd1cmMR6XHijvnAzmeysT0VEFuCXOu4UFHhnB2tZxAUF9rYrqrjcOlFMYnCHKM45oS5ioFRo32lZnKYVnhhctTYi4fRpi4qAUaOA0aOBL74AkpPZF6bICCFyhBAbhRCbhBD3+vn7CCFEhRCipPbnQTvaGdM4wI07UgJVVd7Tv7Xp4VVVcdTP4FkfopjE4A7ZjifN7OXUqd08s2Yeu7OznCbUPq02/lu7Vk0XrKkB1qwBqqvZF6bwCCESAbwEYBSAvgCuFEL09bPp11LKAbU/f49qI+MBB7hxR78SVmEhMHas9xLoVk3Nclxfl2d9iGISgztkK540c4aG6iKa2Skxcl88s2YuJ2RnOUmofVpt/FddDSQlqaydRo2AzZvZF6awnQpgk5SyVEpZDeD/APzJ5jbFHw5w45K+vp/G6sCO4/q6POtDFJMY3CFThRoEiMeTZo47e9MAMzslRu/LrjNrscqp2Vl2CbVPq43/UlOBI0fUbUlJQGUl+8IUtk4Atuuu76i9zddQIcRqIcR8IcSJ/u5ICHGdEKJYCFFcXl5uRVtjFwe4cUk7YaRn5Qqdjuzr8qwPUUxicIdME04QIN5Omjny7E0DzOyUhHJf0T6zFuticNXasIXap9XGf927q+BOdbX6SU5mX5jC5m9P5ju0/AbA8VLK/gBeAPCBvzuSUs6QUmZJKbPS09PNbaUTWHlGhAPcuKPPBM7JAebO9ZxIsirA48i+Ls/6EMUkBnfINOEEAeLtpJkjz940wMxOSSj3Fe0zaxQ/Qu3TauO/5GSgXz/13T1wQP3OvjCFaQeALrrrnQH8ot9ASrlPSllZ+/snAJKEEG2j10QHsPqMCAe4cUcIVTtNnwmsZQqnpFhzAsmxfV2e9SGKOY3sbgDFjtJS1ffSaygIkJen+mnatvv3q0HU5MnWtdNO4bxGdsvMVP3pFi08t4XbKTF6X75n1saP91wHmMFDkcvONt6P1cZ/+fnqu3r22WrfxX4wRWAlgBOEEN0A/AzgCgBj9BsIIToA2CWllEKIU6FOyO2JekvtpD8jAngu8/PN+wKGsjOgmJCbq/oZWj9CC/BY1a+It74uEdmHwR1qUFGR6keVlqrBeaBBTThBAN9BU7du6mAXq/0sMwMl0WJmpyQvD7jhBmD1auDwYaBxY6BNm/r3FejMGmDdmTWiYDj+IzNJKY8KIW4C8CmARABvSinXCSEm1f79VQCXArheCHEUwEEAV0gZZ7mLbjwjQq7g24+wsl8Rb31dIrIPgzsUlJYRnZbmnRHtL2s53CBAPA2a3Hj2xuxOie/QJNBQJdpn1oiIoql2qtUnPre9qvv9RQAvRrtdjuLGMyIuZfREHoUnnvq6REZwn2MNYcVJoKysLFlcXGz6/VL0TZxYv19VUaGmpc+cWX977YuqBQH4Ra0vnl+jUD9PRORcQohVUsosu9tBHjHX/9KfYdKfEXF6XRyXjVrc+jITkTtxnxO5QH0wBncoqGHDVMZOgq70dk2Nqju4aJF97SJ34ueJKHYwuOM8Mdn/ctsZEReOWnjihYiiifucyAXqg3FaFgXFjGhncdnJwHr4eSIiopC4bT5LNIpAmyxmSxvp53b7u07R4/YOLJkqZvc5DsCl0CkobQngigqVYVFRoa7n5dndsvhj9Yqw0cDPExERxbTSUjVK0XP4qMWqpbqN1tizREGBWmZTe1BtGc6Cgig2ggDERgeWTGXVPocY3KEGaMV009PV1Jn0dEdnFsc0/cnAhAR1mZambo+2oiKVUjlsmLo0enx26+cp3OdLREQxxMjBwIWjFitOvNgaW5ESqKoCCgs9jZg9W12vqopylAk2R7kcwEkdWAuwjxg6nuy1DmvuELmEU+rVuLCcQETi7fkSGcWaO87D/peFjB4MXHrQMLO0kT6WkpOjVrr0vW757Ch9IzRRe3CdggIVUNIeV2tXSopaFjQeOKUDawGXft0dwW3l1JyGNXeIXM4p9WpcWE4gIvH2fImIyA+jBwMtRVU/apk82fEHDDNLGwmhYhmAiq1o8ZWoxla0RuiDO9EO7OgziLTH10e54qUGkFM6sBZgHzF8biun5haclkXkEk5JYXRhOYGIxNvzJSIiP0I5GGRnqyVfFi1Sl/5GMDE+l0Mf4NFENbaiZcjo6eeJRYP2IuTkqIDO2LFRTl9yCKd0YC3APiI5DYM7RC7hlHo1LiwnEJF4e75EROSHmQeDOCgwa2tsxXde2Ny5ngCLXQEevXgK7ADO6cBagH1EchoGd4hcxMjJQKvF8AkYv+Lt+RIRkR9mHgxivMCs7bEVIVRNG32GjJZBk5IS/alZdmcQOYETOrAWYB+RnIbBHSIKSQyfgPEr3p4vEPOzBYiIQmfmwSDG53I4IraSm+udIaM1IppFjG2PcpHV4rGPSM7G1bKIiKJEWxmgtFSl8jpxZQCu/EBGcbUs52H/yyUmTqxfYLaiQo0MZ860q1Wm860X7Nb6wREdu7laFhFZIFAfjJk7RERR4JYSCzE+W4CIyH5xMpfDN5Dj1sBORMduJ2QQEVHcYHCHiCgK3BI0ifHZAkRE9uNcDtcw5dgdC1Euinucsu8OjexuABFRPCgtVWf99JwYNMnMrD9bgCs/EBGZLDubwRwXcMuxm8hK+in7+gw2xqSdh5k7REQRMnI2wy3LZcbJbAEiIqIGueXYTWQlt2SfE4M7RBSheE/TNDof3y1BE84WICIiUqJx7PZd24aLaJHTcMq+ezC4Q0ReQgnWuKVIsJWMns1wU9AkO1st2LJokbp0YhuJiIisZvWxu6DAe1V0bTGtggJz7p/IDMxgcw/W3CGiOqHOqdUHNgDPZX5+/AQEQpmPzxILRERE7mLVsVtKtUp6YaG6Pn68CuwUFgI5Oe5dOp5iT16eGg8Aqo+7f7/KYJs82d52UX3M3CGiOqHOqWWaJs9mEBERUei0VdFzclRAZ+xYT2BHv3o6+WFTTYCIH9altQzclH0e7xoM7gghmgghVgghVgsh1gkhpkajYUQUfaEGaxjYcE8tHSIiInIWLcCjx8BOA2yqCeD1sMnlKP+iBPeOXo2iUdOMPbbLaxlwyr47GMncOQzgj1LK/gAGAMgRQgyxtFXkeC4NPJsu1l6HUIM1DGzwbAYREVGsiVaRY63Gjp6+Bg/5YdPSTXUPW12OhDUlaFHzO9JSjiF/7RBjQRouOUVR0GBwRyqVtVeTan/iepcTawP6ULk88GyaWHwdQg3WMLCh8GwGEZFDcOmh2GdxRzxaRY61+9WmYs2d65mixQBPEDbVBKh72M2bgEZJQHISmicdxJbqTsaCNKxlQFFgqOaOECJRCFEC4FcAn0spl/vZ5johRLEQori8vNzkZjpHLA7oQ8XAsxKLr0M4wRoGNoiIyBG49FDss7gjri9yrH2UtABMVZW5ARchgJQU7xo7Wg2elBROzQrIppoAdQ9bWQkkJamHPdIU3VJ/NRakYS0DigJDwR0p5TEp5QAAnQGcKoQ4yc82M6SUWVLKrPT0dJOb6RyxOKAPFQPPSqy+Dk4N1mgn6gYMAHr0APr3j8/MOSIi8iOao3Kyj8Ud8WgXOc7N9b5f7fFzc819HEcwK+PKppoAdQ+bnI6a6iOoqG6KfUeaIa/7/4wFaVjLgKIgpNWypJS/A/gSQI4VjXGDWB3Qh4KBZ4WvQ/RoJ+o2bgR+/lkdD3/5RV2Pt8w5ip54n4JL5Fj+vpxceig+RKEjbnmRY5/Pr1jifXCJyY+qmRlXNtUEqHvYfhkoO9AS6Ql78Xi/d5CdXGwsSMNaBhQFRlbLShdCtKz9vSmAswF8b3G7HIsDegaeNXwdokc7Ubdrl8qETUlRl7t22Z85F+0AgNmPxwCGf5yCS+RQwb6cXHoo9kWhI25pkeN4PbiYnXFlU5p5djYw85P2WPRJFWaePQfZRxeFFqRxano8xQwjmTsZABYKIdYAWAlVc+dja5vlXBzQM/Cs4esQPdqJOt00ZyQlqet2Zs5Fu49m9uPFax/TCE7BJXKoYF9Of6PyBx4AJkxwRwSbxaAbZnFH3PIix/F6cIm1qQ8M0pBDGVkta42UcqCUsp+U8iQp5d+j0TCn4oBeiZd9WkP9rHh5HeymnahLTQWOHFG3HTmirmsn7MLJQIm0Hx3tPprZj2dV+2MhGyjW+qFEMSPQl7O0tP6oPDMTmDEDKCkBMjKcHcG2uBh0LOyXAVjeEbe8yLHTDi7R+mBw6gNRVIRUc4cUDujjAxfdcA7tRF379iqoU1WlLtu3V7cPHhx6BooZ72+0+2hmP54V7Y+VbCD2Q4kcKtCXMzOz/qh8+3YV1ElLAxITnZslYXEx6FjZL9exuCNuaZFjJx1crP5g6ANHu3YBO3bE99QHoihgcIfIDycvuhGLWdtGMqQefxzo1Qvo1En1zzt1UtcffxxYvjy0DBSz3t9o99HMfjwr2m9FNpAdn3lOwSVyqGBfTt9R+ZYtQO/eQJcunv8PN4Ltb0dkVtaDxcWg43UmUCR8X3LTyjY56eBi5QdDvxLG9u2qo/bTT8CePfE99YHIYgzuEPnh1EU3YjGbyOhz0k7UlZQAmzapS+2EnZaBou97a1n6/ixZAixYAKxaBUyZAowcGd77G+0+mtmPZ0X7zc4Gsuszzym4RA7V0JdTvwPPzFTF2fTCiWD72xE98ABw7bXmZT1YWAzaaTOB4pqTDi5WfjDy84GjR4HNm4HDh9X9Nmqk7vvRRzn1gcgiDO4QBeC0RTecnE0ULjMzaH74Adi61fM/+/ap332DANrJpN27gQEDgEOHgNWrVb881Pc32n00sx/PivabmQ1k92eeU3CJHMrol9OMCHagHdE77wDJySrTwYysBwuXaHLSTCCCcw4uVn4wSkuBnTtVQCc5WXWumjVTc+qZMkZkmUZ2N4DIqQL1s+wK8OiDTYWF6gcwP5uoqEgdd0tL1XE/L8+6fodZz+naa4FrrlH9iJoaoE0bld1z/PGeIIB2X1oWclqaCgYlJ6vbN28O7/3Nzo5uv8zsxzP7/vLyVPAMUCfq9u9XY6nJk0O/r2h95okoRmkRbP1BbfJkdbv+wBBMoB1RUpKa8qW/j0imfOmLQY8f77kORLzDM3O/HEui2d9xJCs+GNr3KjMT+O47tfKF5sgRFQQ18h2J+zeHKDzM3CHyw/KlMMNkdTaRHUUXzXhOp58OvPkm0L276jN8/70K7IwfX/++SktVX2PrVpWtkpEBnHGGCvLY/f7GArOzgZyWQUdELpOdDVxwgToL8NZbnsBOKPM7/e2IhgwxZ8qXdv8WLtHkpJlAThFzRabDYfYHQz99MS9PZe389ps6y1ZdrYI7HTo0/B3hm0MUNmbuEPkRqJ8FmLQUZpiszibS19YDPJf5+dZ1AsN5Tr4nXKVUAZ6vvlL1kTT+7iMzU/UTGjVSgZ2uXT0rbp11lr3vb6wwMxvIaRl0ROQy+mlVgHdWTE6OsQwefzuiLl1UyidgTtZDbq53W7SOh0k7umhnmTpdKP0dJyeRRNw2sz4Y/r5no0YB//ynSqlOT1dn3Ro1anhapO+bU12tztxdcom6Tye9AUQOw+AOUQAW97NCZnHWNgDVOejY0fs2K4suhvOcCgpU/0H7m3YfzZoBBw54b+svCKBlIaelqQyeffs8/fHTTmPAwEmi8ZknIhP5i7zb/SWNdH5nsB3RiBFqJaCtW1U2gjbly6iGRuZ2v3YOYNVHymh/R0siSUvzTiJxQuaTo9oW6Ht2553e3xEjgRn9m1NerlbQSEpSQSInvQFEDsTgDlEQli2FGYZoZBNpWS3ayRLA2qKLoT6nQCdg589XnbLKyoaDAPoSDFu2hNcfp+hwagYdEfkRKPKekqLOlthJ23loBwXAeHS4oR3RtGnhtclRI3NnsvIjZbS/45tEkpbmuT2U0k0hM5CSY0e2dVD+vmcPP9zwC+T7XFNS1JvRooXKjktKUts1b+6AJ0nkbAzuELmI1dlEdhRdDOU5BToxNGqUJ3PHSBCA6enmiEaqutMy6IjIDzOmPlndvkjmd1qxI3LcyNxZrP5IGe3v6JNItm9Xq3sfd5w6OWRZ/NJg4M9I9lFUk+nC+Z75e66//OIpfrh/v5rKdeyYKqwIWJtSTnHNyVMwjWJBZSKXsTKbyK6ii6E8p0AFdi+91Lv/oG1n9wnjWBXNeodOyqAjIj/0BYALC1XxM/00JicEdiJdIcHsHVFpqRqk6nHQWsfqj5TR/o62WriUKrBTVqYWbeja1fOx0lblNI0+8JeQoC7T0uotId7QSub6+sZA6HXEQxLu98zfc+3cWf2kp6ugzr59qhjz5s2qs2FlSjnFrVip483gDsUk32MIVz8yLjsbmDkTWLRIXTotYh3oxJC/s1EMAljHYN+TiOKFU5e2s3glqrA1NDInyz9SRvo7eXme2nzHHaeOdWVlKrnEsvilwcCf1raKClWOpqJCXc/L88580vpIs2cDhbPLUfXcDMgzhgETJ5o3cg33exbouVZVqSfSuTPQuDHQtClw8CCwahWwY0fDRZmJQhQr/VoGdyjmRPVMBUWVU5eoj0c86UxEXoJF3u2Wm+u81M5gI3MC4IyPlD7DZ+dOYMAAoH9/dR2wKH5pMPAXLPvIb+bT7HLkbHsN45t/CNHJgtSEcL5nwZ5rfr5ale6UU4AmTVQWT7NmKq3CaWceyfVipV/L4A7FlIBnKqxIm3WgWM9YcuoJ2HgU6UnnoiJ10nCYyScPicgGboi8Oy2106550C5hx0cq0HFJy/D58kvgrLM8gR3AoraEEPgLln1UL/Np8yaM77EUoqWFqQmhfs+CPVdttJ2eDgwZApx9NnD66fWXRiUyQawkUzK4QzHFydP+rRYvGUtOPAEbKTcG5SI56Rwr85qJqBYj7+Fx+jxoG0X7I9XQcSmqwSaTAn/1Mp8qKzF7z2jvttqdmhDsucbKaJtcIVaSKYW0YBSRlZUli4uLTb9fIqOkVIEdzdy5sd239O10+K4qEeuBLTdz8urBDdFWFdCWlDe6qsDEifWXoK2oUH26mTOtai2ZTQixSkqZZXc7yMP2/ldUl+aheBCtj5SR45Kbjtd++4XDZqBwc0/kHL8B47t+rV5HJx989Stp6Zc0Y4YbWSTcfq0dAvXBuBQ6xZxIVzx1o0BLhDOw42xOXz24IeEuKW9k+VYiciGnTX0i14vWR8rIcSk31/u4rPW9nPgx95v59NiJwDULkXJYQMgaYF+A9d+dQsvq0Y+2J0927mibXC/cfq2TMLhDMSVYBgvg3IOwGbROhvZcAfc+33g5+RuvQbnMzPpnSJlpTUREZgqlL2H0uOSm+GW9YNTp2Rj/JiBezwe2lLkjWBILo23yomXHlJaq752Ts2PciDV3KKY4Ydp/KIVizSwq64RVJcwQL7WDNE5dPdhKsTKvmYiInClYX8JfnTtXHZdC6DzWC0adzjpPZB/WXLQegzsUc+wsuBvKTsvMHZwbFioxIh5XO4uVoFwouEgMERFZJVhf4ssvgVmz6gd9du50yXGJo2Nysfx8VUKphYULtsU7TsuimGRX2qx+pwV4LvPz63cQQtm2IYEylgDnLFRiJA0z3qYpxfM0QmZaE1HM4/wDWwTqS5x7rrr89FPPNvpj8GmnueDtMbPzSBRlrLloPQZ3iEwUyk7L7B2ckwv96Rc80J9o8ndWLJZqBzXEDUE5IiIKQygHPjKdv77EVVd5/ubaE0gcHZOLhVpzkfHx0HFaFpGJMjPVTkov0E4rlG0B/3PEfTm10F8oaZjxNk1Jm0a4ZImaOj98OLBgAdChg90tIyKisHH+ga0C9SUAl9e5C7XzSOQgodS24gzE8DC4Q2SiUHZaoWzr9iLDpaXqxJKevxNN2vOaP9+7dtD8+bEd4FmyxPsAtns3D2BERK5m9MBHpgtWh3DWLPWj56r+hasqP9vEzNVKyFSh1FxkfDw8DO4QmSiUnZbRbWOhyLDRE01CAGvXqv7vuHHq+rhx6vratS46sxYiHsCIiGIMMyxsE2jK87nnAsXFquaOaxef4IoEwTHdw/GyDS7Yxvh4eFhzh8hkoRSKNbJtLBQZzstTx1ZA7Zj371cnmiZP9t5OSuDkk9VznDNHPb85c4DKSuD0071rCsWSUKbQc/4xEZEL+B74tm1TO+6MDJVNwJ23pfzVIezeXQ0mf/kFSEpS111Z544rEgTGgtMxI9T6PKQwc4fIBfQBHo1bAjuA8RNN2vPUzqSNHeu9kpRbnm+ojJ7g5QkpIiKX0B/4vv/eE5Hv3Zs77yjR9xmKioC//Q1o1gwYMMAz/XnJEtW/yM2NTps4Y8hi4aR78E1xJM5ADA+DO0QuEAtFho2mYbo9kBUOowcwTt8iInIR7cA3YACQlaUi9tx520J//ExM9H4LotW/4AmaKAh1OiTfFMfiDMTwMLhD5HDBCgO6LcBjRCwEskJl9ADG+cdERC7EnbftnPAW8ARNFBg9W6Zl61xyifoQVFfzTXEgoyeGyYM1d4gcLlBhQMBlc8QN8A1kjR/vuQ7EdgaPkSn0nH9MRORC3HnbzglvQSj19ShM2tmy/Hz1wnbrpgo86jtYWrZOWpoKANXUACUlKsMuPT2iN4V1EcluzNyJAZwqGvtyc70DG1qAJ1pzxKMlUCArJyf2Alnh4PxjIiIX4s7bdk54C7iAWpQ0lO6hT6HS0rmSkoDNm9XvYb4pnOFFTsDgjstxRxI/fAMbVgU67A4WxksgKxycf0xE5ELcedvOCW+BEwJMBO85et27A0ePqtTx/fsjelM47Y6cQEgLCllkZWXJ4uJi0++X6ps4sX6aaUWFOmjNnGlXq8it9Jmq+iXL3dAHZSosUXQJIVZJKbPsbgd5sP9F5GxaX0WbMcS+ig18B0/l5cCGDcCRI8CoUWG/KcOGqRPtCbrUiZoaFUxctMicpodCSu8Twb7Xyd0C9cGYueNyTigQR7HDrWcdmMFGTmB31hsREdnHyDGABWIdwDeFKjlZRdrmzYvoTXHStLuCAu/FSLSalgUF0W8LRReDOy7npB0JuZ9bg4VuDUpR7GCAkYgofvEY4CIWzdFzyrQ7KYGqKu9VdbXFSaqqYnv1WeJqWa6Xl6cOHoD3NJrJk+1tF7mTE1aTCAdXoCC76QOMgOcyP59nZomIYh2PAS5jZInSMDRvDmgzYwcNsqesgX5V3cJCz4qz+sVKKHYxc8flnFAgjmKHU846hIoZbGQ3t2a9ERFR5HgMiG9a5pYQwJlnAllZQGWlfe3RB3g0DOzEBwZ3YgDn77qcb36kjfmSbg0WujUoRbGDAUYiovgVyjGA9dlij9PKA2hTsfT0NXgodjG4Q2QnB1Y8c2Ow0K1BKYodDDBSqIQQOUKIjUKITUKIe/38XQghnq/9+xohxCA72klEDTN6DGBtHpM4LELmpMwtfY2dnBxg7lx1qa/BQ9ay8+PJ4A6RXVjxzFRuDEqFymF9GdJhgJFCIYRIBPASgFEA+gK4UgjR12ezUQBOqP25DsArUW0kERlm9BjgtAwPV3JghMxJ2btCACkpqk0LFgDDh6vLzEx1O6dmWcvuj6e7CipL6f2J9L1O5CaseOYqRUWq81Vaqg6QeXnmDNyN3q92sEhL8z5YMIDgHBbVZ6TYdCqATVLKUgAQQvwfgD8BWK/b5k8AZkkpJYBlQoiWQogMKWVZ9JtLRA0xcgzgAhAmcGD1aqctcNOhA/Dll+ql6dgR2L0b2LwZGDXKnvbEE7s/nu7J3HHg9BWiiLHimStYFYUP5X55to8opnQCsF13fUftbaFuQ0Qu4qQMD9dy0hyoWk7L3s3PV/1EfZ+xRYvo9BnjPcvc7o+nO4I7nL4SkFu+QG5pZ9Sx4pkrWBVYMXq/RUXA/PnAihXAsmUqCATY3pchovD5i+D77viNbAMhxHVCiGIhRHG5tnMgIkdifTYTODRCFqw8QLTHQXYFGOyekuQEdn883RHc0bIbtGpQY8d6qkTFcZaDW75AbmmnP5bujE2seOagBbdiklUHSSP3q31/kpLUz6FDwOrV6nvkgL4MEYVnB4AuuuudAfwSxjaQUs6QUmZJKbPS09NNbygRmcdpGR6u5LIImR3jILsCDMwyt//j2WBwRwjRRQixUAixQQixTghxazQa5qchnL7iwy1fILe005flO2Ot4pk+SKkFMUOoeMYZi9az6iBp5H6170+fPsCRI+q2xERgwwZH92WIKLiVAE4QQnQTQiQDuALARz7bfATgqtpVs4YAqGC9HSL3i4cFICzlsgiZ7zioulqdxLvkEuuyeOwKMNg9JckJ7P54GsncOQrgDillHwBDANzoZ0UH63H6Sj1u+QK5pZ2+ohKUys31DlJqAZ7cXEP/zhmL0RHqQdJoxpeR+9W+P+npwIABQJMmwNGjKtDj4L4MEQUhpTwK4CYAnwLYAOBfUsp1QohJQohJtZt9AqAUwCYA+QBusKWxFD7OSSeyhosiZPpxUHk5UFKi+nw1NdZl8dgVYLB7SpJT2PnxbHC1rNqzRGW1v+8XQmyAKui3Pug/msl3+sr48Z7rQNxm8GRmqp2CVoUbcOYXyC3t9BW1FQ18P7shfJa54FZ0aAfJ/Hz1/nfrplZACHVVK6D+ylgN3a/++5Oern4qKtSlg/syRNQAKeUnUAEc/W2v6n6XAG6MdrvIJFzikIjg3Y/bvFlNsQfUmMLKlZROO837PqNxwtdpq4bFo5Bq7gghugIYCGC5n79ZV9DPpOkrscbuOX1GuaWdvtwSfeaMxegwGoUPlPE1bZr/aX5A8Pt16/eHiCiuuXVOOhGZSt+P279fBVmOHgW6d1d/t+LEsV0lG+yekkQhBHeEEKkACgDcJqXc5/t3ywv6RTh9JRa55Qvklnb6csugmjMWnSXQNMRvvgmvn+/W7w8RUVxz65x0IjKVvh+XkKDqJvbvr64D4Z04Djbj0+6SDS6aMReTGpyWBQBCiCSowM5cKeU8a5sUtCHBr8eh7Gx3fGnc0k69UKbi2IUzFp0n0DREIPx+vhu/P0REcc2tc9IpaqT07qP5XqfYofXjtNmaycnqxHE405YCzfgcMwZYvlzFlbt1U7sglmyIP0ZWyxIA3gCwQUr5jPVNInIOp0efOWPReQJlfJ1yijum+RERkQnckv5LtuBKp/HJjGxsfzM+jx4FpkzxTP3fvRv48kt1XcPATnwwkrmTDWA8gLVCiJLa2ybXFgIkIpvl5nqf7dECPNyB2yNQxhfAInNERHHDDem/ZAv9tBnAO+s6J4cZPLEu0mxsfwu+7NypVlHVEgXT0oAdO4BffvFM/5o9O/zxAbPM3MPIalmLAfDtI3Iwzlh0lkAHbvbziYjiCOfUhqSoqP6KkrH48nGlU4qEvxmfFRWe61ICW7cCv/8ONG0KzJ0bWcmGggIVjNT+T8syS0mJ69K3jhXSallERFRfsMJ2ek6f5kdERGQHrY6I74qSgY6nbufUlU6N9mfIPr4zPrdsAQ4cAPbsAZYtU1OyGjUCWrYEBg+OrGSD3cWZKXQM7hARRSDeOqRu49vxYEeEiMh54m3l+GiudGo0YMP+jDvo6/Z8/73KdOvRA2jcWE35LylRNXiaNweuu079T7iLTOsDQ4WFwNix3ou42B2MpPoY3CEiikC8dUjdhAUriYjcIZ5Wjvdd6XTuXM/g2cwAT1ERMHq0+vniCyApKXjAhv0Z99AywQcMALKygH791O/NmwPHjqn3+YknvDPEww3EODXLjPxjcIeswbxOihNO65AyU0VhKjERkXtkZsbPipLRWOlUy8JZswZo1kxN31mzBqiuDhywcVp/hhqmf8/S04EhQ4CRI4FOncyb+h/NLDOKHIM78cyqUSDzOimONNQhjWack5kqHkwlJiJyj3hbOT431/tYFO60mUC0LJzqaiA5Wf0kJQGbNwcO2MRTgM1pwu0rWv2eRSvLjMzD4E68snIUyLxOCoNbM06CdUijGedkpkp9TCUmInIHfR2RsjJ1+fjjkWcfODmR3MqVTrWMjtRUtUQ2oII7lZWBB//xFmBzikj6ila/Z9HIMiNzMbgTj8waBQY6YjKvk0Lk5oyTYB3SaMY5malSH1OJiWKEk0foZBqzV5SM50RyLaOje3dVXLe6WgV5kpMDD/6tCrBRcJH0FaPxnlmdZUbmamR3A8gG+tPZhYXqBwhtFKgdMdPSvI+Yjz+ujijl5WrvpGFeJwWgjzUC6iOoTwGV0vmBiexs/wfS0lL19dCzMs6pfbW11xJgYEcf4NKuA/H7uhC5TrD+BkedFIR+0Ax4LvPzY/+jk5fn+dr066dWVdq/HzjtNOD++wM//0D9GQpPUZH6vJWWquFRXl7919doXzHQfUXjPbMyy4zMxcydeBXpfIVgYWbmdVIIoplxEu2Tv9Gev85MFQ+mEhPFCE71pjDFcyK5PqPjyBHg7LOBTz4B5s9n8CYUkfQbjWaOGekrxnMWGoWGwZ1YEkrRkkhHgcGOmIFyBAGmVZNf0aiNYseBMZpxTha9q4+pxEQxIJ5H6BSReC8QbPY0t3gTab/RaFzaSF+RMW4yisGdWBFK0RIzRoENHTF9jygAQ84UUDQyTuw4MEZz/jozVfxjKjGRy8X7CJ3CxkRyikSk/UajcWkjfUWrYtxuXcyEAmPNnVigFS2ZPdt7j9OkiRrd+RYtCTQKBIyPArXJvIDau+zfr46Ykyf7nxQazxOfKaho1UaJdv0bTTTnr+fmen/dta82AxpE5FrB+htEQWiD5vx8dazv1k19bNjtDI2RujGxKNJ+YyglSBvqK1pRzrSgQA0ftX6i1h9PSWGGs5sxcycWCKG+9du2AZs3Az/9pC63bVO3+xvZGZmvEGyiabCpV/4ydL791nFp1Vx8wxmilXESLyd/malCRDGFS/hQBDg1KTLxWOtFGx9s3AgsXqyesyaUfqOZmWNmZ6GZtXAyOY+QFrx7WVlZsri42PT7pSAmTgR+/RVYv95zW9++QLt2nmlRodCvTqE/U9ZQh2rixPqh5YoKtYfs1av+7enp4bUvQuE+PbKOb4KZ2atk8T0nMpcQYpWUMsvudpAH+19EZKZA3Xqbuu+W0/cVDx1S56YBYNAgoHHj0PuNWtaTljkWSdaTmfcFeAd0NFYsZkLWCNQH47SsWLF5M1Bd7X3bnj1AZWV49xfuNKpAOYypqWqPqF23Oa2as8Scx+qME6Znx5Z4TRMnIiKKFrumtNtFPz5o0QI45RRgwwbgu+9U4CPUfqOZU/PNnuavZcrrgzsNBXbY93I+TsuKBVr21fbtQEYGMHSouty+Xf3NNzvLwHykom+bYeL6uzDsiwcwcdlfUVR+grG9eaC5LwMGBE+rjsYcKd1jlM7/Hs0Pl3v9OZYPVqQwPTs2xGOaOBER2Sdep/LHy5R2jW/h4vR04PTT1eSDWOs3hrqYCfte7sDgTiwQQoWTU1OBVq3Ut7JVK3U9J8c7BBvom/nKK3VHraJR03Dv9htQ/lsSOlb9iPIdh3Hv1+ehaG1aw3vzYJNCA42so7G38HmMzKQd2P/Nj14TaWP5YEUUS7gkKBERRUs8D2rjbcWxeAlmhbNwMvte7sDgTqy47z7gzTdVjZ2yMnX55pvqdj3tm5mW5vlmHj0KPPRQ3VErf+0QpB36FS0qf0bCsSNokXQAaTW/I/+H4cCpp3rfn++3P5zCh9HYW/g8Rl6fr7EPaajY8HNcHKwodsXjMpZWLQlKRETkK1g3NdaPwfFWz9xfMGv7dlXWNJaytsJZzIR9L3dgzZ1Ycvrp6ieY0lLg2DFg716ga1f17S0rU6XR9+0DWrRAaXUndJQbgUaJQKMk4OgRNE86hC01JwDv3gFcf33wNfNCnRQajQm9Po+Rnf4jHh/4L+R/NxRbygaw/gq5UrwuY2nFkqBERET+BOqmrlgBzJoFXHWV5xg8a5ZKnHfqMTicmilm13pxMt/6jM2aqfdWCO+srVgIcOXmei9eogV4AtXcYd/LHdyTuROvk13N1q2bKrJcVgZs3aq+1eXl6pt89CggJTJTf8X+Y83U9m3bAB06YH+LzuiW8qta9SrcNfMCvYfRyIH08xjZTVZh5qh/sv4KuVI8L2MZb2niRERkH3/d1H371HH21VdVQEcL7Lz6KvDll848Bsfz9LJQ6KtItG8PdO4c/alI0coIC2UxEzP7XhzWW8cdwR3ujcxz3XXqdEOLFsAvv6g917FjQIcOdZk8ed3/h32iBSrQEjUSqKhuin1HmiGvx0JVUaywEBg71jNR08iaecHew2iM1DgapBijT6EN5yvpZvGWJk5ERPYJ1IW85BL191dfVcfgV19V17PqLU7sDKyZEjo7piIVFHjXvdFO3hUUWPeYRpjV9+Kw3lruCO5wb2Se7GzgiSfU6lUHDwJNmgAnn6yCO/v2ATU1yE4uxuOdX0R6s0qU7U9DeuN9eLzH68hOWgE89pj6Fi5bBnzxBbBgAbBkScOPG+w9jMZIjaNBcrhwzmJoAR69WA/saLjyGRERRYO/LuQTTwDTpgGTJqnblixRl5MmeaZpOY0dgQq31ySKdoFlp2dlm9H34rDeWu6ouWNmTZZwJpuGK5LH8ve/gPH7C/bYp50GbN4MHDni2T4zU1UM27oV6NYN2ZPzkA0A+U+r17lbN+Dax9TeZfVqoFEjoGlToKQEuOcedZQL9twaeg+jMaE32GPoJ536u05kIe0sRlpaaHO6Ay1jGS8BHiIiomjw14W0e6AdqmjXTImFuoB5eao/Bqhhy/796lz45Mmh3Y/RIaH+pF1hofoBYisrOxqlVuOZOzJ3zAqbRjMPLJLH8ve/118P3HCDsfsLttz5hAlA797AlCnqddXWvistBc46S00U1kKx+vDsW2+pbd55B8jIAIYPV/ddUaHeixkz6rdBn4aQkuLctQWdmv9IcSOcsxjhLGNJREREkdPX2MnIAIYOVZf6GjxOE80KBU7PQDHKjMT/UIeEsZ6VHS/LzdvFHcEds/ZG0cwDi+Sx/P3v3r3Anj3G7s/f/x89qgI6u3cDbduqEOmXX6o80obWvgM8a+YlJangkBCqRk9GhloWYOtWz7b+9mK//KIygwK9h/q9vJT1r1sllKMPq3+RRcJJlQ5nGUsiIiK3cWr3q7hYXU6apM59TprkfbvTRLNCQSzVBQw2FcnIZzPUIWGgrGy3BMQawjKo1hLSgk9KVlaWLDZ7z6bls2lThMKZTjVsmAo2JOhiWjU1ag+3aJG57Y3ksfz97+efq8tzzmn4/vz9/9Kl6tuTk6OuS6m+Senpak9ldBrShAkqQKTldPreD6D2br55nxUVatt27eq/h/q8zXnz1GpegAoaXXKJ/xxOM6fX6QM6Gt+jj37ejD4vk3V7yASBvjL6r1UgnFFIdhFCrJJSOrR0aHyypP9FZCMnd78KClSX1U1LoUeblCqwo5k7N3b6KEY/m6EMCX2zssePr389Fl4/M4b18S5QH8wdNXcAc2qyRHOyaSSP5e9/Gzeuv512f76BjtRU9TffkaL+uhDeqQFG9xTXXdfw5NNAkynLyuqPVPWZM1qgUVtuYNIkdZT89FO1R9NGreEWKAlEO72gD+747j31YXfAc6kVhCaKQCRzukNZxpKIiMhNnNz9ys31PqEihD3FlKNZTjQUsV4X0OhnM5QhYaCsbCD0rGynfi6A6JRajVfumJZllmjmgUXyWP7+t3VroE2b+vc3eHD9KVA7dqgf/bZJSWpFLL1wAltGcjpDmUypz9v89FPvAMunn3oCO/ojgdnT64zkP9qxxADFDS7mRkREVJ8Z3S8rp3XZfYLFqctKx0NdQKOfzVCHhLm53sMebagUSjaYUz8XZL34Cu5EcwQVyWP5+99XXgFefrn+/S1fXj/Q0aWL+ibrt50yRa1wZUZgq6F18ELdiy1ZopZU/+IL9XxSUrwDQb4hfjMDLUaPPqz+ZTunzrk3i91Le7vl9XX7sqpERGRcpN2vWB/kOnVZabfWBfTXxygqAkaPBtq3Vz+jRqnbjH42wxkSRho0dOrngqznnpo7RliZf+bU3LZQJnJGc4Kj0ccqKlJLqe/fD/z+O1BdraZpHXcc0K+f2sY3cyeSAiX+GFmr0cmTvuMAX35rueX1jYVlVWMJa+44D2vuUKyJ9PhkdpfRaaJZTjQcbqoL6K+P8cADwJw56jPXuLG6/dAhoHNntZDxO+84s+/k9M8FRS5QHyx2MnesDM07OewfyimNaKYGGH2sGTNUeysq1Mpbxx8PJCYCu3YB556rfnyzaMyeXmck/5HzZmzFMxDWcsPrGyvLqhIRkXGhdL/8ZV3E+qx6JyWW+3v97Z62ZlSgPsY773gCO40bA8nJQJMmahHj5cudOzRw0ueCoss9BZUbYmXFNSdXc4ukEqtVgoXpfTOgSkpUAehmzdTS6jt2AD17qiwebbUsLbdTuw/tSK/PDJo8ObL3wsjRh9W/bBOoRnesdM7s5obXV19UsLDQU54rllaPICKi+ox0vwJldiYm1l9jJNRBrlOT9wHnDAPcnlkbqI+RlKROeiUne7ZNSgIOHFB9JKcODYJ9LtyUTUWhi53MHStD806u5ua0jJL33vPOsqmpUdcLCvxnQO3cqbbp2lXtWbp0UYWjhwxRR4NAVcTsLlBCUcUzENZyy+ur73xpGNghIopvwTI7s7NVgne4yd7RSt4Pd5jghGFArGTW+utjDBmiMnWOHPHcduSIyuJxWh9JL9DnYudO72Ga9l4VFNjbXjJP7GTuWLnMeaT3bfbS3b6MhI2jcdrhvfeAzz7zjBLHjVPLmW/YoB5vxoz6GVCZmapNrVt7Qsv79wP33ee5X47c4p5Tzkw5VaRfb7e8vrG+rCoRUawxq/sZLNugoczOJUvCT/aORvJ+pMMEu7NHYiWz1l8fo0sXNUTZscPzmdNq7lix2LKZfD8X+qAboN4b/ZoyzOCJDbGTuWPlMueR3rfdBS30px2SktSqVKNHqx+zTj1IqXIUKyvV6HD+fLVH+ewzoE8fFejZsqV+BtTxx6taO07JPCJHcsKZKacy46yiG17feFhWlYgolpiV9VJQ0HC2QbDMzkiSvaNRsyeUYYJTV7YUQnX19caNc0+wIFAfo7QUuPBCYPBgtc2xY+r3V15xVh/JCP2KZYWFwNixnufrpiAcBRc7mTtW1GEx677tLmihHTWqq4E1a1SAp1kz9bu/UwPhnGbxDdsvXap+z8gAXn1VHa0CZUANGBAbSxaQpew+M+VUZp1VdPrrG2hZVcDZy6oSEcUrM45P+ik/QOBsA6syO62cGKAxOkyweiJAJFlWWvK+/v2YNAkYORK49NLI22a1hvoY06bZ2z6zaM9L+z4BDOzEmtjJ3AGsrcMSyX3bXdBCO+2webMK7CQnq5/qanW7/tTA4sXhn2bRwvb6o1HXrmoNQSmtza4iilOxvhKInpGF7YiIyBnMOD4ZyTawMrMzGl1Xo8MEKycCRJJlVVOjAjuffabe3zlz1KV2W01N5O2LhnjoYwQKgjL7OXbEVnDHqewOamhHjcpKFdwBVDUwIYA9e9TRF1Df7L/9TZ0iCefIUVOjwvRlZSpj57TT1N591iyVP3rvvep6TY1z534QuYzdseNoc8uyqkRE8c6s41NDxfQDZV3k5ESe2RnOtOVQp04ZHSZYeTInksBRQoLK0Bk5Ug01xo1Tl9ptCS4abcZyH4PT2+ODi75uDvbKK0CPHmpP2KOHuq5n9Mhg1URa7aiRnKyCOtXV6rJtW2D7dvVt1r7xGzeqAJD+G27kyCGlCtVv2KD25EVFao+xZQvw3XdqL9+pk9pLVlYCjz5qbnaV7x6JeyiKE3bHjomIiPwx6/hkJNvAyqyLUJL3w8mAMTpMsPJkTqSBo0svVVUY9F591R1TsuKFlUFQcg4hLRgEZ2VlyeLiYtPv15FeeQW45x61Jl7TpsDBg8Dhw8ATTwDXX2/8fvQTafXL1Zg5kXbaNLVkQPPmQO/eKtizaZMqapyerrbbvl39vWVLz/9u2eI5SgWbhFtQoLJ+xo1TYXopVaCqqko9nqaiQj2eWXV2tMf1zc9NSYmtXEqiALR58lpJMCsWwyPyJYRYJaXMsrsd5BFX/S9yhUiPT77ZBr41d5xWL2TixPo1eszq9lo5VIi03b4rMQHOfH8o+Mpz5B6B+mDM3AEiy5h5+mkV2ElJUQGNlBR1/emnQ2tDOPmQobQ7O1utYPXJJ8DZZ6vMnXbtgDff9AR2AOCxx9TRQjvNsmULsG6d2qahUxDaaRMt/1LbU/Ts6b2dmQVB9JX2tNM42tGlqooZPBQXrCw3RkREFK5Ij09uyzawcuqUlStbRpJlxek+7hLLU8+ImTuRh8FbtPAEZDTaXrGiIvj/6kOlw4apOjWJid73U1amjohmt1t7fH9h9sxM4PXX1ZHo55/V0UOf8xlKKN/KUxgNPQ+eLiAisgwzd5zHVf0vohC4JdsgGt1eq0SSZcUkeqLoYuZOIJGWnk9PV1Ox9A4e9M6G8aegwDuc3a0b8P33alqUJthE2kjbHSzMXloKvPWWCip17KimbekdPqy2M5IxFI2CIA1V2iMiIiIi13JLtoGb6+BFkmUVaytNWVUGlchqDO5Emj95xx0q2FFVpfbiVVXq+h13BP4ff1OJunRRWTr79gHHjjV8NIi03UbzXH2rt5WXA998AzRqZKxSnJU5pBqu60dERERENou02+vmoIJbAnANiWRZeCK7NWpoAyHEmwDOB/CrlPIk65sUZZmZ9fMnQyk9rxVNfvppdT/p6SqwE6yYsj7TpLDQM53ouutU5s7WrerxJ08OfDSItN2ACqfr81q1dun3xnl5ao8GqODRhg3q9z59PBlDgMoYCtTW7GzrioAEq7QHMIOHiIiIiKIm3G6vvuKCPqhg9jlRCk4/OQIwNtQhcgojmTszAeRY3A77mJE/ef31atWpigp1aWSVLH9TiR5+GHj7bWP5kGblfTYUZvc9BXHkCDBwoPe0MzMLJIdKCBUQ275d7XWvvloFvpxaac8fLuNOREREFNcirbhglnjvllpZFJvIag0Gd6SUXwHYG4W22CMa04b8iXQqkdZuKYEvvwSKi4HUVNObWfdY2iTcQYOAjRuBL74Ali1TpxVCzRgyU1GRytJp3hzo1Em1529/UwEeN0z09a29pH0uCgrsbRcRERERRY0TggrsltavSAHYO9QhCoVpNXeEENcJIYqFEMXl5eVm3W10RHsdYTPXDNy/HzjlFODMM1WY3+ik0HDC8kVFwC+/AAcOqFW9Dh0CVq1SWTN2VYrTTnO0bOl9muP11+1pTyi4jDsRERERwf6ggt3dUqfUG3JzUWyiBmvuGCWlnAFgBqCW4jTrfmNSoGLGgGcqkbYeYWmp2tv7W48w3Emh4a5XmJ8PdO4MtGsHbN4MVFYCzZqp2+yahPrtt2qPW1WlMpe6dwfatHFH7mSg2ktcxp2IiIjI8cxcot23zOX+/aqLO3ly5O00ws5uqZPqDWmTI/TLwgcrg0rkJKYFdyhEwYoZB9rDjRkDLF/uCfiUlAC9e3vfb0P5m/qwPOBdgDgnJ/BRqagImD9fhbCbN1dBlPR0db2szJSXJGRFRcDOnaoNzZqp0PrXXwPJySoAVVTk/D2x9r5r7wfAwA4RERGRw4V7rjQQJwQV7OqWOq2IsZVrwRBZicEdOwUqZuxvD7d3LzBlCpCV5Qn4lJUBR4+qaVKVlSpzpX17oFev4I9pJCyvzxxKSVHTsZKS1DLthw6pwNKAASqQ4i9f1EjmUaTy89V9a1lElZXqyHr4sAo8RTvkH85zDlR7iQEeIiIioohY1R0N91xpQ+wOKtjVLS0tVcMbPacUMY7GkIbILA3W3BFCvAtgKYBeQogdQoi/WN+sKDFadybaZeP9VVTbuVOtVKUvod+2LfDDDypvs0kTdbluHTB4cPD797dSl29g5957VQCpY0dg7VpVVycjQwV3ABXo2bDB/yRU3//XMo8imTzrbyJuaSlw/PFA//4qoCOlCjY1a6YCTvolBqyeyBvOczaz9hIRERER1bGiO6rRutJat23sWE93zq3n5+zsltpdbygQKz9DRFYwslrWlVLKDCllkpSys5TyjWg0zHJGy8HbUTbe3x6uosKTyaM5cABo3FgFgg4dUpcnnqimbgXT0EpdvmsxVlerx/n5Z6BRI5VFtHevenx/mTH+1nJs3tx7LcdQjhCB9qypqep1Sk9XAZ2MDPW4rVqp/9NC/tHYM4ezfmWg2ktuWsbdH6dUxCMiIqK4ZfXS4g2dK3UbO7ulTi1i7JTl6YmMMm21LFcxWg7errLx/vZwSUlAhw7e21VUqOydIUOAs89Wl8cf33DNnYbC8r6ZQ6mpKmtIWwWtfXv196Qk/4/h+//btwN79qjb9W0wGiALtGeV0vM6paSoYNPRo6oeEOAJ+Udjzxzu+pW5ud49Ae1I6oZl3P3hKQ4iIiJyAKuXFm/oXKkb2dUt1eoNpaerqhPp6dZXVjByLtIJy9MThSI+gztGcyntyrn0t4ebMkVlzTQU8AmWw1hUBFx9tbrv7dtVhpC/sLxv5lD37up6YqJ6zCNH1O2Zmf4DJPr/l1IFXLZvV7/7BsgWLw5/z6plDqWnewI32mpZ+pB/NPbMkeSTBqq95EYOP8UR7RmWREREZA8rp/rE8sx6u7ql2dnAzJnAokWq+56fb381BadOFyMKxP3BnXCngBjNpTQr5zLUdur3cDNnAtdfbyzgEyiHUb8X69dPBTf+9jd1u29Y3jdzKDlZPU6rVsDBg6q+z4ABgbOE9P8vpfq/1FT1f/oAWWamaoO2Z924EbjkEnXf+tco2J5Ve51KSoB581Qxad+QfzT2zE7NJ402B5/isGOGJREREdnDyq5ZrM6sdwInVVNg957cxt3BnUi+/UZzKc3IuTRrL2Uk4BMoh9F3L9aypfdeTH8U8pc5NGwYMGiQZ/pXenrgAInv/7drB7z5prquGT8eeP11T5v27AE2bfLsOfWvkdE9q+/ro70OkeyZjQbl7MgndSKHnuKwa4YlERER2cPqrpmbZtZr3dn+/YEePeqfR3USJ1VTYPee3EZIC0Y1WVlZsri42PT7rWfiRBUE0BcarqhQ37yZMwP/n28upe/6hdqe2uh2VrXTTMOGqcBSgi6eV1Oj9lSLFjX8/1qAKi1N7f3271cBEiN7OCmBBx4A3nnHs2T7mDHqcTt1Um1atkwVhU5KUtlBZ5/t/Rpp6xBu2aICBaGuQxjO/0fynOOVg18z/ddZ4+ZVLYjsJoRYJaXMsrsd5BG1/hcRuYbWNTt6VJ1H1fTooRLzHdBF8xLpkMUIJwzNiCIRqA/WyI7GmKa0VH379YxMAQmUSwl451Ia3c6qdoZKC2CUlqoMCn0AIzOz/l6soYwK3/sbM0atxKUFSCZPNh7YmTFDrWb1hz8A33+vrnfooF6Hli1V0KdpU1XPJzVV/a/+NcrOjuzIE87/608dAJ7L/HxnHQWdRDvFoQ+kGfmcRIH29dUHdxjYISIiolimdWc3bFDnUJOT1UK4u3YBffo4r1sbzpAlVHl5KuAFeJ+LnDzZvMcgsoO7gzuRfPtzc1XgwTeX0nekZ3S7QIqKgF9+Ab77TgUxuncPPqUpXPqMCf3ULy0cH+pezN/9vfNO6OF9IdR9ZWQAffuq6337qr8lJqp2aEG0ykr1u+9qV5HSv3/+rgfy7bfqNaqqUgEnrVizA+rHOFqkgTiLBJphyQAPERERxSrtHLN2HhVQQZ7KSseURfQSjcCLv3ORf/ubd/fV6HCByEncXXMn0ipXRsvBh1s2XguQpKd7AhklJWovYnY1roYmqIY6adTMCa/HjgG9e3sHyHr3VntsI6tdRSLcKrpFRcDOnZ4j4aFD6r3bts32+jEUulhe1YKIiIg8uDKmN60cYmqqZ8FbLVHeAWUR64lWnRt9qc4LLlBBMC66QW7n7sydcKaABJu6ZDZ9gCQ1Fdi8Gfj9d5UF8/bb5j6u79QvKb3D8VKGllFh5lQyfxlWlZWe1a60NvnWxYl0Oo++ii5Qv2ZSsJB8fr5q9+bN6gioLQFfWgpMnx5+m8gWZs2wJCIiIucqKFBdP9/ymSkpzix0HA1aJkz79qrmjhbgOf54505FimYSeCTDBSKncXdwBwjt29/Q1CWz6QMk6enqR6sIZubj+U79Sk1VR7FWrVSQJJwjW6QTXvVBtJQU1T4geH6lkfcylOCcfgRfWOjZaxupoltaqo56WlBOKwTdooUjpxxRwyKdYWmmaMaYichZhBCtAfwTQFcAWwH8WUr5m5/ttgLYD+AYgKMsXk0UHAfp/unPhR886OnS9urF/gcQ2XCByGncPS0rVNFYW08vGstC+0792rdPZb78+KMKz197bXhrPke6fLh+6feEBPW4UkaWXxnOkvL6PbbGyJ5ae+/S09XS72efrWoFDRgQWpvJUcKdYWmmcD7GRBRT7gWwQEp5AoAFtdcDOVNKOYCBHaKGaV0+bdr12LGhL3Abq7QpSCUlanhQUqKux3tgRxPucMFq2hL2w4Y1vHQ9pyMSEG/BndJSlTmiF2klsUDfuqIi4NdfgcWLga++UiXpzaojo6cFrLp1U4GHtDS1rmFioso8efnl8I5skUx49RdE69IFaNdOTWwN92gSTnAuUBXdhvZ4kdZzIgog2jFmik+hdAgp6v4E4O3a398GcJF9TSGKLU4dpJOzhTtcsFIoJwPDLTFKsSe+gjtmZ9IE+ta98oq6FEIt/Q0AxcUqSGD2FDB9wErLMjn3XKBnT3VdM25c6Ec2faWxUAIyVgTRwrnfSKroRquaG8Udq74eRBpmhzleeyllGQDUXrYLsJ0E8JkQYpUQ4rpAdyaEuE4IUSyEKC4vL7eguUTu4cRBejxx44kFpy66YfRkoH46otbecCZtUGxwf82dUJi9tp7+Wwd4Lp9+WgVXtOvt2qlCyu3amR8c8Fcb54cf1ITazp091eQmTQJGjgQuvdTcxzfaJjOmo4V6v75VdJcsARYsAFatUgGb7t2Dvx8OXdKb3M2qrweRJtChKT+fu7RoEUJ8AaCDnz/dF8LdZEspfxFCtAPwuRDieynlV74bSSlnAJgBAFlZWezGU9zyHaTra+4A5mTwsGZeYNEubWoWpy66UVoKJCcDy5Z56iRlZtY/GciaQaQXX5k7ZmdjBDoF/8svwJ493rlxe/YAK1aE3/ZAoXDf6UO//aYef98+1ZY5c9TlZ5+pn5oaY/cbCaumNIVzv7m5nsDOvfcCu3er6WvNmvFUNtmCM/7IaswOs5+U8mwp5Ul+fj4EsEsIkQEAtZe/BriPX2ovfwXwPoBTo9V+IjcKNEjPyTFnkM6syODcPO1cGy74Lrphxgpr4dbCSU0FvvkGOHQIaNpUXX7zjfos++J0RNLEV3AHCH+qkT/+pnlpQZXt24GtW9U3eOtWdb1Nm/By44IdTXwDVu3bAzfdBFx4oQrzjhunLkeOVD8JCcbuNxJWTWkK936F8D7iJCa664hDMYUz/shq0ajlTxH5CMCE2t8nAPjQdwMhRIoQorn2O4CRAL6LWguJXMrKQbqbgxfR4PYTC1YsuhFJLZxAQ0Z/t3M6Imnia1pWqBrKvfQ3zWv/fuChh4DnngO2bVNZNEeOqPDrY4+Ft6doKMdea5PWVgD4y19U7R/Nq696B3aM3G8krJrSFO796pel17jpiEMxhTP+yEpmz0Am0z0O4F9CiL8A+AnAZQAghOgI4HUp5WgA7QG8L1SfoRGAd6SUhTa1l8hVrFoZk13J4Djt3Ju+Fg7gPU0wJ0f9Pdhns6oKGDhQfb60aVl9+gAHDtR/HKunI5J7xF/mjlFGsloCnYK/4QbgzTeBJk2AgwfV5ZtvAqefHl5bGgqFa2399VfV1l9/VcEdfWHFOXPqh29DDbHbVSXNjMflqWwi07ixYGI8YXaYs0kp90gpz5JSnlB7ubf29l9qAzuQUpZKKfvX/pwopXzE3lYTEbuSwXHauTf9tMDCQmDs2NAWMM7MVEPIIUOAs89Wl02a1P+8WT0dkdyFwZ1AAuVeTpvmPaoB6k/zklIFTvTfxtLS8HPjGjqa5Oer8O5vv6nrv/2mQrzbtgGXXBK45HsoRym7Jhqb9bj+jjg7dqgl6jlCJTKMNQfcwcwZyERExOBFQ3hiob5IauGE8nmzcjoiuQuDO4H4y2o5dEgV5g02qrFiPb2Gvt2bNwNJSWpPum2bqinTtKkK8hw4oOru+AvfhrLXsGuisVmP63vEkVL9JCRwhOpSzB6xB2sOEBFRPGLwomE8seAtklo4oX7erJqOSO7CmjuB+Js4unGjCvgEq1FjdD0934mWwSZeat/u/Hw1ZapbN1U8QXvM7t3VVKyEBPXtB4DDh4Hevb3b4Hv/Dd2vnl0Tjc18XH2hk4kT1ethx1rBXEczYm5dbjMWsOYAERHFK9bMM1csd4nNqIXDzxuFisGdQAIVS/7DH7y38zeqyc31Dtb4BlcKCtQ0Ku027dufkuLJn/O3t5s5M3hbW7XyFHA+dsy7gHOwwJGRvYZdVdKsely7RqiMSpjCylrgFBwLJhIREVGkYr1LbPR8P5GZOC0rEH+5cNnZQOPG3tsFGtUEyo3Tl07X8vK0MG5Vlbqu7e02blRLqH/0kaqdo1/9yretjz2m2qIVcO7fP7I6P77smmhs1ePaVRWPc1pM4fblNt2MNQeIiIhin+8QwuxlteOhS8xaOBRtDO4E4ztx9L77Ih/VGCmdnp8PHD2qaukcPqxGrTU1wJQp/guLaAWcu3QBpk9X/zd+fHh1fgLtyRua+GlVARSTJzjXNbPkH5hY/P/bu/sYuarzjuO/B3sRpMurcGzjF7ATFEqJ6jYbcGXJoVXUGlqVkjQSidpC1dhqlUipVKmBrdKq/St/VX1R2opNApTajZDctFbqNoG0hGYRbmwwDcRBtdbQWBCvAeFlxZvAT/84c7Wz63m5M3PvPffc+X4ka3fG65nn3DO+e89zz3nOZzR74spqR6hkJQrBjhXxUHMAAIBm279/+RAiuxe9f39x7zEul8TUwkGVWJY1iEFq1PSSJXiyRZfS8rTu3Jz04x9Lq1dL558fnnvPe8LotdO6k6Lm/fVbLtZtCVfZ8yo7ve8Qi3SXhXntJTp94XbdNfc+ffGNv9SObRcM15eDYk1LITqtmlxYCF2I8rEGHACQoibXeClK+yIDaXmtmF27epcJHUSMS2L6H01nXvQcO0lTU1N++PDhwl+3MdqXYmWyxMxjj0l33CE991xYXjU5Gb6+/XZYErZ5c5hJ1O118xZp7hXTyqpf7UmjTu6889yz85kz4ZZ+tzpBo2jP0rSP7Pskk6oOs6MhY8e5sl/QWZ6VX9BAtczsiLtPxY4DS7j+ArrjEiy/XkOVYRM7KxMrN94o7dtXXX+U3f8kjlClbtdgJHeq1iuJsnWr9MgjoRjyk0+G5UJm4QxkJr3//dIHPlBeJmLYM/nOnWHGznltq/zOng1rNrolokYxZJamlDCHSaiRlQDQACR36ofrL6C7WtzkS4h7qB6R2bt3tMROp8TKpz4lHTqU/5J4lARKmf1P4hBV63YNxrKsqvVaQnXvveGMc8klYcerp58OiZ4335Q++MEwR3J+PmQpykgJZ7E88ECo27O4KE1MhK3We73PMPMqRzk7D7nTVeHTP/PsetYJa1oAAAAqFWuj1NiGueTOLmnbPfDA8DN3uu1yeuhQ/sTKqFUgyux/dnFFXVBQOYZupdNfeUX6wQ+khx8O319/vbRxo7RqlXTppeHnzJaf0YoqXCyFM/kXviA99VRIKF14oXT0qPT5z/d+n0G3z8nOzqdPD9eWyUnpu98Nx+nxx8O/z5GlKXSXnzy7ngEAAKAWxnEzhmEuuVcuMti7d2kfmEH3ackUUTx51N21yuz/cSkOjfojuRPLyrT3Y4+FIsqLiyGp8uab0vPPS+vWSbfdJq1dGxI9Ze0XmJ3J9+2T1q+XPvKR8FvgzJlw5rvnnu7/dtDtc0Y5O8/OSidPSq+/HgpOv/GGdORIeK5PlqbQXX7y7HoGAACAWij0Jl8ihrnk7rbIYNeuwfZpaVdEYmXUBEqZ/T+OiUPUE8mdupiZCWcGs7Aka2IiPD83F846ZaeEszP5xIR07bXh8dVXh0TP5GQo8NzLym3je2VMRmnLzEzY8v1DHwqFpt99N+wkduWVubI0g4TZV/uSugyJHQAAgNop9CZfIoa95O62yKBX1YFeikisjJpAKbP/s/a9+ury9n3606O/NjAIau5I9ShvPjcXkiurV4clWZJ02WVhxs6OHdXsF/jxj0sHDkgvvRTeJ0vwLCyEM2BRRmlLtmD2vPOWYsqqIlet6AXJAAAAKM24lT0c5ZJ75aXsKJe2WWKlfT+R6enB+mL37rCkTFpetHh6erA4yuj/HTuWJvMvLobjfvfdYdhy6tTwSTFgUMzcGbX+S1EmJ6Unngjfr10rXX659NZbS5W/qppLumfP8vdZWCj+fUZpS13mPZaxIBkAAADRzM6GXZV27gxfqx4OFK39kvvUKenRR0PZyvn56ts26uz5Os+8cg8LCzZtCrN17r03JHYoxYmqkdwZtTpXUbr9r8+er+qMVsX7jPIedVkwXcaCZAAAAERRl/u9Rcouuc+elQ4fDs99+MPhMjXFthVaXqFAlOJEXZiXkEqcmpryw9kZpO527lxa5pPJlvl85zvVxjExEeYqLi6GmTxbtkgvvyxt2xZ3yVjdZMvosnmdMY+J+/Iz9srHANBQZnbE3adix4ElSV1/ATVz553nLmE6cybcg8y7XXddNbltdeIeEjuZvXsZFqAc3a7BqLlTRS2bQeLYvn3puRMnQpJpw4bltxDqMgcxljotmC5yQTIAAACiyMo6tmvKdtZFtK0OJUrrjFKcqAOWZdVlmU+nOLKzZ+wlYwAAAECD1aWsYxlGbVsTl6wViVKcqAuSO3WpztUpjnXrpKuuWv5zF10kHT3arGpvAAAAQER1ud9bhlHbVpcSpXVFKU7UBTV36qzTAtkTJ8KMnqmp5fsAjvtSLQBApai5Uz9cfwGjqVNZx6KN0ra6lCitO0pxoirU3EnR7t1hzqO0lMhpX6olLX2dmWnObx8AAACgYnUq61i0UdpWlxKldUcpTsTGsqw667RUa/36zku1mlDtDQAAAECtNHnJGtAkzNypu5Vp9k5LtUidAwAAAChBdr+5fVnX9HRzZzmNO3ZGSxfJndR0Wqq1sBDOsAAAAABQsCYvWcOSbGe0iy9evjMa5V3TwLKs1NRldy8AAAAAQGOwM1ramLmTIlLnAAAAAIACzc2FGTvtKO+ajlwzd8xsl5k9a2bHzeyusoMCAAAAAADV2bo1VP1oR3nXdPRN7pjZKklfknSzpOskfdLMris7MPQwOxsKK+/cGb7OzsaOCAAAAACSw9BqCTujpS3PzJ0bJB139zl3f1vS1yTdWm5Y6CqrcnX69PIqV+N8FgIAAABQO3VPnDC0Wo7yrmnLU3Nng6QftT0+KenGlT9kZnsk7ZGkzZs3FxIcOmivciUtfZ2Z4X8dAAAAgFpIYeclhlbnorxruvLM3LEOz/k5T7jf4+5T7j61Zs2a0SNDZ3NzoapVO6pc1V7d71oAAAAARUph5yWGVuVg7BNHnuTOSUmb2h5vlPRCOeGgL6pcJYfpngAAABg3KSROGFoVj7FPPHmSO9+TdI2ZbTGz8yXdLulAuWGhK6pcJSeFuxYAAABAkVJInDC0Kh5jn3j6Jnfc/R1Jn5X0TUnHJD3o7s+UHRi6oMpVclK4awEAAAAUKYXECUOr4jH2iSdPQWW5+0FJB0uOBXlR5SopW7eG6YhZgTapfnctAAAAgCJliZOZmTCw37JFmp6u3zCGoVWxGPvEkyu5A2B4u3eHdaZSyFq/9lq4azE9HTcuAAAAoEwkTsYPY5948tTcATACpnsCAAAAGAeMfeJh5g5QAe5aAAAAABgHjH3iYOYOAAAAAABAwkjuAAAAAAAAJIzkDgAAAAAAQMJI7gAAAAAAACSM5A4AAAAAAEDCSO4AAAAAAAAkjOQOAAAAAABAwkjuAAAAAAAAJIzkDgAAAAAAQMJI7gAAAAAAACSM5A4AAAAAAEDCSO4AAAAAAAAkzNy9+Bc1Oy3p+cJfeHhXSHopdhANwHEcHcewGBzHYnAcizGux/Eqd18TOwgsGeL6q+mf3aa3T6KNTdH0Nja9fRJtbIpU2tjxGqyU5E7dmNlhd5+KHUfqOI6j4xgWg+NYDI5jMTiOSFXTP7tNb59EG5ui6W1sevsk2tgUqbeRZVkAAAAAAAAJI7kDAAAAAACQsHFJ7twTO4CG4DiOjmNYDI5jMTiOxeA4IlVN/+w2vX0SbWyKprex6e2TaGNTJN3Gsai5AwAAAAAA0FTjMnMHAAAAAACgkUjuAAAAAAAAJKzRyR0z22Vmz5rZcTO7K3Y8KTKzr5rZvJk9HTuWlJnZJjP7TzM7ZmbPmNnnYseUIjO7wMz+28yeah3HP40dU8rMbJWZPWlm34gdS6rM7Dkz+76ZHTWzw7HjAXoxs0+0zp1nzazrVq+pfq4HaF+y14dmdrmZPWRm/9v6elmXn0uuD/v1iwV/1fr7/zGzn40R57BytO8mMzvT6rOjZvbHMeIcRb9xQwP6sF/7mtCHfccsKfdjzvYl24+NTe6Y2SpJX5J0s6TrJH3SzK6LG1WS7pO0K3YQDfCOpD9w95+UtF3SZ/g8DuUtSb/g7j8taZukXWa2PW5ISfucpGOxg2iAn3f3be7edTAJ1MTTkj4m6dEcP5vi57pv+xpwfXiXpG+7+zWSvt163E0yfZizX26WdE3rzx5Jf1tpkCMY4HP3X60+2+buf1ZpkMW4T73HDcn2Yct96j8uSr0P84xZUu7HvGOyJPuxsckdSTdIOu7uc+7+tqSvSbo1ckzJcfdHJb0SO47UufuL7v5E6/vXFAbUG+JGlR4PFlsPJ1p/qAo/BDPbKOmXJX05diwAquHux9z92dhxlCVn+1K/PrxV0v2t7++X9GvxQilUnn65VdLft64FHpd0qZmtrzrQIaX+ucslx7gh5T4ci3FRzjFLsv3Y9DFZk5M7GyT9qO3xSTWo45AuM7ta0s9IOhQ5lCS1lhIdlTQv6SF35zgO5y8k/aGks5HjSJ1L+paZHTGzPbGDAQrS5M916teHa939RSkMUiS9t8vPpdaHefol5b7LG/vPtZae/5uZ/VQ1oVUq5T7MqzF92GPM0oh+7DMmS7IfV8cOoETW4Tnu8CMqM5uUtF/S77v7Qux4UuTu70raZmaXSvq6mV3v7tSEGoCZ/YqkeXc/YmY3RQ4ndTvc/QUze6+kh8zsh607e0AUZvawpHUd/uqP3P1fcr5MbT/XBbSv9teHvdo4wMvUtg+7yNMvte+7HvLE/oSkq9x90cxukfTPCstemiTlPsyjMX3YZ8ySfD/2aV+y/djk5M5JSZvaHm+U9EKkWACZ2YTCSWSvu/9T7HhS5+6vmtkjCmufSe4MZoekX239wrpA0sVm9g/u/huR40qOu7/Q+jpvZl9XmHpf5wEUGs7dP1rAa9T2c11A+2p/fdirjWZ2yszWu/uLrWUQ811eo7Z92EWefql93/XQN/b2Aaa7HzSzvzGzK9z9pYpirELKfdhXU/owx5gl6X7s176U+7HJy7K+J+kaM9tiZudLul3SgcgxYUyZmUn6iqRj7v7nseNJlZmtac3YkZldKOmjkn4YNagEufvd7r7R3a9WODf+B4mdwZnZT5jZRdn3kn5RJBqRuDH4XKd+fXhA0h2t7++QdM5spUT7ME+/HJD0W62derZLOpMtUUtA3/aZ2brW9aLM7AaFcdrLlUdarpT7sK8m9GHOMUuy/ZinfSn3Y2Nn7rj7O2b2WUnflLRK0lfd/ZnIYSXHzP5R0k2SrjCzk5L+xN2/EjeqJO2Q9JuSvt+qFyNJ0+5+MF5ISVov6X4Lu06cJ+lBd2cbb8SyVmFpoBR+n+5z93+PGxLQnZndJumvJa2R9K9mdtTdf8nMrpT0ZXe/RQl/rvO0rwHXh1+U9KCZ/Y6k/5P0CUlKvQ+79YuZ/W7r7/9O0kFJt0g6Lul1Sb8dK95B5Wzfr0v6PTN7R9Ibkm5399SWupwzblDY/CL5PpRytS/5PlSXMYukzVIj+jFP+5LtR0skTgAAAAAAAHTQ5GVZAAAAAAAAjUdyBwAAAAAAIGEkdwAAAAAAABJGcgcAAAAAACBhJHcAAAAAAAASRnIHAAAAAAAgYSR3AAAAAAAAEvb/Gprywa77anMAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Plot datasets\n", "fig, axrr = plt.subplots(1, 2, figsize=(20, 7))\n", "\n", "# Blobs\n", "for l_str, l_num, col in [(\"negative\", -1, \"red\"), (\"postive\", 1, \"blue\")]: \n", " axrr[0].scatter(\n", " X_blobs_train[y_blobs_train==l_num, 0], X_blobs_train[y_blobs_train==l_num, 1],\n", " c=col, alpha=0.65, label=\"Train (%s)\" % l_str)\n", " \n", " axrr[0].scatter(\n", " X_blobs_test[y_blobs_test==l_num, 0], X_blobs_test[y_blobs_test==l_num, 1],\n", " c=col, alpha=0.65, label=\"Test (%s)\" % l_str, marker=\"x\")\n", " \n", "# Blobs\n", "for l_str, l_num, col in [(\"negative\", -1, \"red\"), (\"postive\", 1, \"blue\")]: \n", " axrr[1].scatter(\n", " X_moons_train[y_moons_train==l_num, 0], X_moons_train[y_moons_train==l_num, 1],\n", " c=col, alpha=0.65, label=\"Train (%s)\" % l_str)\n", " \n", " axrr[1].scatter(\n", " X_moons_test[y_moons_test==l_num, 0], X_moons_test[y_moons_test==l_num, 1],\n", " c=col, alpha=0.65, label=\"Test (%s)\" % l_str, marker=\"x\")\n", "\n", "\n", "axrr[0].set_title(\"Random blobs\", fontsize=\"xx-large\")\n", "axrr[0].legend(title=\"Data points\", fontsize=\"x-large\", scatterpoints=3, edgecolor=\"k\")\n", "\n", "axrr[1].set_title(\"Moons\", fontsize=\"xx-large\")\n", "axrr[1].legend(title=\"Data points\", fontsize=\"x-large\", scatterpoints=3, edgecolor=\"k\")\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Optimizing time: 0.511s\n", "Optimizing time: 0.756s\n", "Optimizing time: 0.839s\n", "Optimizing time: 1.009s\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "fig, axrr = plt.subplots(2, 2, figsize=(20, 20))\n", "plot_svm_model(X_blobs_train, y_blobs_train, SVM(C=10., kernel=\"linear\"), \n", " ax=axrr[0, 0], verbose=False)\n", "axrr[0, 0].set_title(\"Blobs (linear)\")\n", "plot_svm_model(X_blobs_train, y_blobs_train, SVM(C=10., kernel=\"gaussian\", sigma=1.5),\n", " ax=axrr[0, 1], verbose=False)\n", "axrr[0, 1].set_title(\"Blobs (gaussian)\")\n", "plot_svm_model(X_moons_train, y_moons_train, SVM(C=10., kernel=\"linear\"), \n", " ax=axrr[1, 0], verbose=False)\n", "axrr[1, 0].set_title(\"Moons (linear)\")\n", "plot_svm_model(X_moons_train, y_moons_train, SVM(C=10., kernel=\"gaussian\", sigma=1.5),\n", " ax=axrr[1, 1], verbose=False)\n", "_ = axrr[1, 1].set_title(\"Moons (gaussian)\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Non-linear Kernels \n", "\n", "In this task you are going to implement two non-linear hyper-parameter free kernels for binary and non-negative feature vectors. Assume, we are given two sets of feature vectors $\\mathbf{X}_A\\in\\mathbb{R}^{n_A\\times d}, \\mathbf{X}_B\\in\\mathbb{R}^{n_B\\times d}$, where $d$ is the dimension of the feature vectors, and $n_a$ and $n_B$ are the number of examples in set $A$ respectively $B$.\n", "\n", "### A. Tanimoto-Kernel for Binary Data (2 Points) \n", "\n", "The tanimoto kernel is used to calculate the similarities for binary input data. It calculates the normalized intersection between two sets and is also known as [Jaccard Index](https://en.wikipedia.org/wiki/Jaccard_index). \n", "\n", "\n", "
\n", " Task:\n", " Implement missing code parts of the function calculation the Tanimoto kernel matrix given two feature vector matrices $\\mathbf{X}_A$ and $\\mathbf{X}_B$. The resulting kernel matrix $\\mathbf{K}_{tan}$ must have dimension $n_A\\times n_B$. For a single entry in the kernel matrix it must hold:\n", " \n", "$$\n", "[\\mathbf{K}_{tan}]_{ij}=\\kappa_{tan}(\\mathbf{x}_i,\\mathbf{x}_j) = \\frac{\\mathbf{x}_i^T\\mathbf{x}_j}{\\mathbf{x}_i^T\\mathbf{x}_i + \\mathbf{x}_j^T\\mathbf{x}_j - \\mathbf{x}_i^T\\mathbf{x}_j},\n", "$$\n", "\n", "where $\\mathbf{x}_i, \\mathbf{x}_j \\in \\{0,1\\}^d$ are two binary vectors from set $A$ respectively $B$.\n", "
\n", "\n", "Note that, the kernel values are normalized, i.e. $\\kappa_{tan}(\\mathbf{x}_i,\\mathbf{x}_j)\\in[0, 1]$." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "dad34a2ccd499dc6757be50c477bc6fc", "grade": false, "grade_id": "tanimoto_kernel", "locked": false, "schema_version": 3, "solution": true, "task": false } }, "outputs": [], "source": [ "def tanimoto_kernel(X, Y=None):\n", " \"\"\"\n", " Tanimoto kernel function\n", " \n", " :param X: array-like, shape=(n_samples_A, n_features), feature matrix of set A\n", " :param Y: array-like, shape=(n_samples_B, n_features), feature matrix of set B \n", " or None, than Y = X\n", " \n", " :return array-like, shape=(n_samples_A, n_samples_B), tanimoto kernel matrix\n", " \"\"\"\n", " if Y is None:\n", " Y = X\n", " \n", " ### BEGIN SOLUTION\n", " XY = X @ Y.T\n", " XX = np.sum(X * X, axis=1)[:, np.newaxis]\n", " YY = np.sum(Y * Y, axis=1)[:, np.newaxis]\n", " K = XY / (XX + YY.T - XY)\n", " ### END SOLUTION\n", "\n", " return K" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "7eed17a655ed48722091782fbb2f70ca", "grade": true, "grade_id": "tanimoto_kernel_test", "locked": true, "points": 2, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "__X_A = np.array([[1, 1, 0], [0, 1, 1], [1, 0, 0]])\n", "__X_B = np.array([[1, 0, 1], [1, 1, 1], [0, 0, 0], [1, 1, 0]])\n", "\n", "# symmetric kernel\n", "__K = tanimoto_kernel(__X_A)\n", "np.testing.assert_equal(__K.shape, (3, 3))\n", "np.testing.assert_equal(np.diag(__K), np.ones((3, )))\n", "np.testing.assert_equal(__K[0, 1], 1. / 3.)\n", "np.testing.assert_equal(__K[1, 0], 1. / 3.)\n", "np.testing.assert_equal(__K[0, 2], 1. / 2.)\n", "np.testing.assert_equal(__K[2, 0], 1. / 2.)\n", "assert(np.max(__K) <= 1.), \"Kernel values must be <= 1\"\n", "assert(np.min(__K) >= 0.), \"Kernel values must be >= 0\"\n", "\n", "# non-symmetric kernel\n", "__K = tanimoto_kernel(__X_A, __X_B)\n", "np.testing.assert_equal(__K.shape, (3, 4))\n", "np.testing.assert_equal(__K[0, 1], 2. / 3.)\n", "np.testing.assert_equal(__K[1, 0], 1. / 3.)\n", "np.testing.assert_equal(__K[0, 2], 0.)\n", "np.testing.assert_equal(__K[2, 0], 1. / 2.)\n", "assert(np.max(__K) <= 1.), \"Kernel values must be <= 1\"\n", "assert(np.min(__K) >= 0.), \"Kernel values must be >= 0\"\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### B. MinMax-Kernel for Non-negative Data (2 Points) \n", "\n", "The MinMax-Kernel is a normalized formulation of the intersection kernel for non-negative data, e.g. popular in image-processing and for counting data.\n", "\n", "
\n", " Task:\n", "Implement missing code parts of the function calculation the MinMax kernel matrix given two feature vector matrices $\\mathbf{X}_A$ and $\\mathbf{X}_B$. The resulting kernel matrix $\\mathbf{K}_{minmax}$ must have dimension $n_A\\times n_B$. For a single entry in the kernel matrix it must hold:\n", "\n", "$$\n", " [\\mathbf{K}_{minmax}]_{ij}=\\kappa_{minmax}(\\mathbf{x}_i, \\mathbf{x}_j) = \\frac{\\sum_{s=1}^d\\min(\\mathbf{x}_i^{(s)}, \\mathbf{x}_j^{(s)})}{\\sum_{s=1}^d\\max(\\mathbf{x}_i^{(s)}, \\mathbf{x}_j^{(s)})},\n", "$$\n", "\n", "where $\\mathbf{x}_i, \\mathbf{x}_j \\in \\mathbb{N}_0^d$ are two non-negative feature vectors.\n", "
\n", "\n", "Note, the kernel values are normalized, i.e. $\\kappa_{minmax}(\\mathbf{x}_i,\\mathbf{x}_j)\\in[0, 1]$." ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "904a5f340db2eaffdd691502adc173d7", "grade": false, "grade_id": "minmax_kernel", "locked": false, "schema_version": 3, "solution": true, "task": false } }, "outputs": [], "source": [ "def minmax_kernel(X, Y=None):\n", " \"\"\"\n", " Min-Max kernel function\n", " \n", " :param X: array-like, shape=(n_samples_A, n_features), feature matrix of set A\n", " :param Y: array-like, shape=(n_samples_B, n_features), feature matrix of set B \n", " or None, than Y = X\n", " \n", " :return array-like, shape=(n_samples_A, n_samples_B), minmax kernel matrix\n", " \"\"\"\n", " if Y is None:\n", " Y = X\n", " \n", " n_A, n_B = X.shape[0], Y.shape[0]\n", " \n", " ### BEGIN SOLUTION\n", " min_K = np.zeros((n_A, n_B))\n", " max_K = np.zeros((n_A, n_B))\n", " \n", " for s in range(X.shape[1]):\n", " c_s_A = X[:, s][:, np.newaxis]\n", " c_s_B = Y[:, s][:, np.newaxis]\n", " \n", " min_K += np.minimum(c_s_A, c_s_B.T)\n", " max_K += np.maximum(c_s_A, c_s_B.T)\n", " \n", " K = min_K / max_K\n", " ### END SOLUTION\n", " \n", " return K" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "db1d595dd6bb8285a252b3f8161e664f", "grade": true, "grade_id": "minmax_kernel_test", "locked": true, "points": 2, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "# Test on some small data\n", "__X_A = np.array([[0, 1, 2], [1, 0, 0], [3, 4, 0]])\n", "__X_B = np.array([[0, 0, 1], [3, 1, 0]])\n", "\n", "__K = minmax_kernel(__X_A)\n", "np.testing.assert_array_equal(np.diag(__K), np.ones((3,)))\n", "np.testing.assert_equal(__K.shape, (3, 3))\n", "assert(np.max(__K) <= 1.), \"Kernel values must be <= 1\"\n", "assert(np.min(__K) >= 0.), \"Kernel values must be >= 0\"\n", "np.testing.assert_equal(__K[0, 1], 0.)\n", "np.testing.assert_equal(__K[1, 0], 0.)\n", "np.testing.assert_equal(__K[0, 2], 1. / 9.)\n", "np.testing.assert_equal(__K[2, 0], 1. / 9.)\n", "np.testing.assert_equal(__K[1, 2], 1. / 7.)\n", "np.testing.assert_equal(__K[2, 1], 1. / 7.)\n", "\n", "__K = minmax_kernel(__X_A, __X_B)\n", "np.testing.assert_equal(__K.shape, (3, 2))\n", "assert(np.max(__K) <= 1.), \"Kernel values must be <= 1\"\n", "assert(np.min(__K) >= 0.), \"Kernel values must be >= 0\"\n", "np.testing.assert_equal(__K[0, 1], 1. / 6.)\n", "np.testing.assert_equal(__K[1, 0], 0.)\n", "np.testing.assert_equal(__K[1, 1], 1. / 4.)\n", "np.testing.assert_equal(__K[2, 1], 4. / 7.)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Toxicity Prediction using Non-Linear SVMs (1 Bonus Point) \n", "\n", "In this task you will predict whether a molecule can bind to a given receptor in the human body or not. Such prediction tasks do have relevance for drug design or environmental polution research. You are given a dataset with 600 molecular structures represented as molecular counting fingerprints (compare exercise 2), i.e. a non-negative vector where each entry counts the occurance of a predefined substructure in a molecule: \n", "\n", "\n", "![title](count_fingerprint_example.png \"Fingerprint example\")\n", "\n", "Let in the following $c(m_i)\\in\\mathbb{N}_{0}^d$ be the count vector representation of the molecule $m_i$. Furthermore, let $b(m_i)\\in\\{0,1\\}^d$ its binary representation, i.e. $b(m_i)_s = \\begin{cases} 1\\quad\\text{if }c(m_i)_s > 0 \\\\ 0\\quad\\text{else}\\end{cases}$. Depending on the kernel function we use, we define $\\mathbf{x}_i=c(m_i)$ respectively $\\mathbf{x}_i=b(m_i)$\n", "\n", "For each molecule you have the label $y_i\\in\\{-1,1\\}$ whether or whether not the molecules binds with the [aryl hydrocarbon receptor](https://en.wikipedia.org/wiki/Aryl_hydrocarbon_receptor). " ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "def read_tox_data(idir=\"/coursedata/exercise03/\", balance_classes=True,\n", " random_state=211, n_samples=600):\n", " \"\"\"\n", " Read in toxicity dataset.\n", " \"\"\" \n", " smi_X = np.genfromtxt(idir + \"maccs_count_nrahr.csv\", delimiter=\",\", comments=None, usecols=(0,), dtype=\"str\")\n", " smi_y = np.genfromtxt(idir + \"tox_nrahr.csv\", delimiter=\",\", comments=None, usecols=(0,), dtype=\"str\")\n", "\n", " X = np.genfromtxt(idir + \"maccs_count_nrahr.csv\", delimiter=\",\", comments=None)[:, 1:]\n", " y = np.genfromtxt(idir + \"tox_nrahr.csv\", delimiter=\",\", usecols=(1,), comments=None, dtype=\"int\")\n", " y[y == 0] = -1\n", "\n", " assert(np.all(smi_X == smi_y))\n", " assert(len(np.unique(smi_X)) == len(smi_X))\n", " \n", " if balance_classes:\n", " n_neg, n_pos = np.sum(y == -1), np.sum(y == 1)\n", " idc_neg = np.random.RandomState(random_state).choice(n_neg, n_pos, replace=False)\n", " \n", " X_pos = X[y == 1]\n", " X_neg = X[y == -1][idc_neg]\n", " \n", " y_pos = y[y == 1]\n", " y_neg = y[y == -1][idc_neg]\n", " \n", " X, y = np.concatenate((X_pos, X_neg)), np.concatenate((y_pos, y_neg))\n", " \n", " # Get a random set of samples\n", " rng = np.random.RandomState(random_state)\n", " rnd_idx = rng.choice(X.shape[0], n_samples, replace=False)\n", " \n", " return X[rnd_idx], y[rnd_idx]" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "# Read in data\n", "X, y = read_tox_data()\n", "\n", "# Split into train and test\n", "X_train_c, X_test_c, y_train, y_test = train_test_split(X, y, random_state=3211)\n", "\n", "# Create binary version of count vector\n", "X_train_b, X_test_b = (X_train_c > 0).astype(\"float\"), (X_test_c > 0).astype(\"float\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " Tasks:\n", "\n", "- Compare the performance of the Gaussian (rbf)-, MinMax- and Tanimoto Kernel (previous task) using on a test set.\n", "- Optimize the SVM hyper-parameters (and Gaussian-kernel parameters) using grid-search and 3-fold cross-validation.\n", "- Make use of the [sklearn C-SVM](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC) (imported as ```SVM_sk```) implementation (due to faster optimization).\n", "
\n", "\n", "
\n", " Hints / Notes: \n", " \n", "- In this application the MinMax-kernel (for counting data) performs the best.\n", "- In the sklearn package, the gaussian kernel is called [RBF-kernel](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise.rbf_kernel.html#sklearn.metrics.pairwise.rbf_kernel) and its parameter is $\\gamma.$\n", "
" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "deletable": false, "nbgrader": { "cell_type": "code", "checksum": "83a382b85aa32cc5892de645abc449e3", "grade": false, "grade_id": "toxicity_prediction", "locked": false, "schema_version": 3, "solution": true, "task": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(RBF-kernel) score: 0.78 best params: {'C': 2.0, 'gamma': 0.01}\n", "(MinMax-kernel) score: 0.83 best params: {'C': 2.0}\n", "(Tanimoto-kernel) score: 0.77 best_params: {'C': 4.0}\n" ] } ], "source": [ "# Define the range of the hyper-parameters for the grid-search\n", "C_range = 2.**np.arange(-2, 5)\n", "gamma_range = np.array([0.001, 0.01, 0.1, 1.])\n", "\n", "# Define the random states for the cross-validation\n", "random_state_cv = 10909 # do not change!\n", "\n", "# Define a 3-fold cross-validation using the sklearn\n", "cv = None\n", "### BEGIN SOLUTION\n", "cv = KFold(n_splits=3, shuffle=True, random_state=random_state_cv)\n", "### END SOLUTION\n", "assert(cv.random_state == random_state_cv), \"Set the KFold random state.\"\n", "\n", "# Define 3 SVMs: using rbf-kernel, minmax-kernel and tanimoto kernel\n", "svm_gaus, svm_mm, svm_tan = None, None, None\n", "### BEGIN SOLUTION\n", "svm_gaus = SVM_sk(kernel=\"rbf\")\n", "svm_mm = SVM_sk(kernel=minmax_kernel)\n", "svm_tan = SVM_sk(kernel=tanimoto_kernel)\n", "### END SOLUTION\n", "\n", "# Define 3 GridSearchCV objects using the different SVMs\n", "est_gaus, est_mm, est_tan = None, None, None\n", "### BEGIN SOLUTION\n", "est_gaus = GridSearchCV(SVM_sk(kernel=\"rbf\"),\n", " param_grid={\"C\": C_range, \"gamma\": gamma_range}, cv=cv)\n", "est_mm = GridSearchCV(SVM_sk(kernel=minmax_kernel),\n", " param_grid={\"C\": C_range}, cv=cv)\n", "est_tan = GridSearchCV(SVM_sk(kernel=tanimoto_kernel), \n", " param_grid={\"C\": C_range}, cv=cv)\n", "### END SOLUTION\n", "\n", "# Fit the grid-search objects with the training data\n", "### BEGIN SOLUTION\n", "_ = est_gaus.fit(X_train_c, y_train)\n", "_ = est_mm.fit(X_train_c, y_train)\n", "_ = est_tan.fit(X_train_b, y_train)\n", "### END SOLUTION\n", "\n", "print(\"(RBF-kernel) score:\", np.round(est_gaus.score(X_test_c, y_test), 2), \n", " \"best params:\", est_gaus.best_params_)\n", "print(\"(MinMax-kernel) score:\", np.round(est_mm.score(X_test_c, y_test), 2), \n", " \"best params:\", est_mm.best_params_)\n", "print(\"(Tanimoto-kernel) score:\", np.round(est_tan.score(X_test_b, y_test), 2), \n", " \"best_params:\", est_tan.best_params_)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "deletable": false, "editable": false, "nbgrader": { "cell_type": "code", "checksum": "a1e0ffaf942f1757c999deb49e5f7287", "grade": true, "grade_id": "toxicity_prediction_test", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false } }, "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.9.5" } }, "nbformat": 4, "nbformat_minor": 2 }