{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# EXERCISE 2 - ML - Grundlagen und Algorithmen\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.) Multiclass Classification\n", "\n", "The Iris Dataset is a very classical machine learning and statistics benchmark for classification, developed in the 1930's. The goal is to classify 3 types of flowers (more specifically, 3 types of flowers form the Iris species) based on 4 features: petal length, petal width, sepal length and sepal width.\n", "\n", "As we have $K=3$ different types of flowers we are dealing with a multi-class classification problem and need to extend our sigmoid-based classifier from the previous exercise / recap session. \n", "\n", "We will reuse our \"minimize\" and \"affine feature\" functions. Those are exactly as before. The affine features are sufficient here." ] }, { "cell_type": "code", "execution_count": 292, "metadata": {}, "outputs": [], "source": [ "from typing import Callable, Tuple\n", "from sklearn.ensemble import RandomForestRegressor\n", "import warnings\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "%matplotlib inline\n", "\n", "\n", "warnings.filterwarnings('ignore')\n", "\n", "\n", "def minimize(f: Callable, df: Callable, x0: np.ndarray, lr: float, num_iters: int) -> \\\n", " Tuple[np.ndarray, float, np.ndarray, np.ndarray]:\n", " \"\"\"\n", " :param f: objective function\n", " :param df: gradient of objective function\n", " :param x0: start point, shape [dimension]\n", " :param lr: learning rate\n", " :param num_iters: maximum number of iterations\n", " :return argmin, min, values of x for all interations, value of f(x) for all iterations\n", " \"\"\"\n", " # initialize\n", " x = np.zeros([num_iters + 1] + list(x0.shape))\n", " f_x = np.zeros(num_iters + 1)\n", " x[0] = x0\n", " f_x[0] = f(x0)\n", " for i in range(num_iters):\n", " # update using gradient descent rule\n", " grad = df(x[i])\n", " x[i + 1] = x[i] - lr * grad\n", " f_x[i + 1] = f(x[i + 1])\n", " # logging info for visualization\n", " return x[i+1], f_x[i+1], x[:i+1], f_x[:i+1]\n", "\n", "\n", "def affine_features(x: np.ndarray) -> np.ndarray:\n", " \"\"\"\n", " implements affine feature function\n", " :param x: inputs\n", " :return inputs with additional bias dimension\n", " \"\"\"\n", " return np.concatenate([x, np.ones((x.shape[0], 1))], axis=-1)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Load and Prepare Data\n", "In the original dataset the different types of flowers are labeled with $0, 1$ and $2$. The output of our classifier will be a vector with $K=3$ entries, $\\begin{pmatrix}p(c=0 | \\boldsymbol x) & p(c=1 | \\boldsymbol x) & p(c=2 | \\boldsymbol x) \\end{pmatrix}$, i.e. the probability for each class that a given sample is an instance of that class, given a datapoint $\\boldsymbol x$. As presented in the lecture, working with categorical (=multinomial) distributions is easiest when we represent the labels in a different form, a so called one-hot encoding. This is a vector of the length of number of classes, in this case 3, with zeros everywhere except for the entry corresponding to the class number, which is one. For the train and test data we know to which class it belongs, so the probability for that class is one and the probability for all other classes zero." ] }, { "cell_type": "code", "execution_count": 293, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "data = np.load(\"./iris_data.npz\")\n", "train_samples = data[\"train_features\"]\n", "train_labels = data[\"train_labels\"]\n", "test_samples = data[\"test_features\"]\n", "test_labels = data[\"test_labels\"]\n", "\n", "train_features = affine_features(train_samples)\n", "test_features = affine_features(test_samples)\n", "\n", "\n", "def generate_one_hot_encoding(y: np.ndarray, num_classes: int) -> np.ndarray:\n", " \"\"\"\n", " :param y: vector containing classes as numbers, shape: [N]\n", " :param num_classes: number of classes\n", " :return a matrix containing the labels in an one-hot encoding, shape: [N x K]\n", " \"\"\"\n", " y_oh = np.zeros([y.shape[0], num_classes])\n", "\n", " # can be done more efficiently using numpy with\n", " # y_oh[np.arange(y.size), y] = 1.0\n", " # we use the for loop for clarity\n", "\n", " for i in range(y.shape[0]):\n", " y_oh[i, y[i]] = 1.0\n", "\n", " return y_oh\n", "\n", "\n", "oh_train_labels = generate_one_hot_encoding(train_labels, 3)\n", "oh_test_labels = generate_one_hot_encoding(test_labels, 3)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Optimization using Gradient Descent\n", "\n", "The multi-class generalization of the sigmoid is the softmax function. It takes an vector of length $K$ and outputs another vector of length $K$ where the $k$-th entry is given by\n", "$$ \\textrm{softmax}(\\boldsymbol{x})_k = \\dfrac{\\exp(x_k)}{\\sum_{j=1}^K \\exp(x_j)}.$$\n", "This vector contains positive elements which sum to $1$ and thus can be interpreted as parameters of a categorical distribution." ] }, { "cell_type": "code", "execution_count": 294, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "def softmax(x: np.ndarray) -> np.ndarray:\n", " \"\"\"softmax function\n", " :param x: inputs, shape: [N x K]\n", " :return softmax(x), shape [N x K]\n", " \"\"\"\n", " a = np.max(x, axis=-1, keepdims=True)\n", " log_normalizer = a + np.log(np.sum(np.exp(x - a), axis=-1, keepdims=True))\n", " return np.exp(x - log_normalizer)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Practical Aspect:** In the above implementation of the softmax we stayed in the log-domain until the very last command.\n", "We also used the log-sum-exp-trick (https://en.wikipedia.org/wiki/LogSumExp#log-sum-exp_trick_for_log-domain_calculations).\n", "Staying in the log domain and applying the log-sum-exp-trick whenever possible is a simple way to make the implementation\n", "numerically more robust. It does not change anything with regards to the underlying theory.\n", "\n", "We also need to extend our loss function. Instead of the log-likelihood of a Bernoulli distribution, we now maximize the log-likelihood of a categorical distribution which, for a single sample $\\boldsymbol{x}_i$, is given by\n", "$$\\log p(c_i | \\boldsymbol x_i) = \\sum_{k=1}^K h_{i, k} \\log(p_{i,k})$$\n", "where $\\boldsymbol h_i$ denotes the one-hot encoded true label and $p_{i,k} \\equiv p(c_i = k | \\boldsymbol x_i)$ the class probabilities predicted by the classifier. In multiclass classification, we learn one weight vector $\\boldsymbol w_k$ per class s.t. those probabilities are given by $p(c_i = k | \\boldsymbol x_i) = \\mathrm{softmax}(\\boldsymbol w_k^T \\boldsymbol \\phi (\\boldsymbol x_i)) $.\n", "We can now implement the (negative) log-likelihood of a categorical distribution (we use the negative log-likelihood as we will minimize the loss later on)." ] }, { "cell_type": "code", "execution_count": 295, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "def categorical_nll(predictions: np.ndarray, labels: np.ndarray, epsilon: float = 1e-12) -> np.ndarray:\n", " \"\"\"\n", " cross entropy loss function\n", " :param predictions: class labels predicted by the classifier, shape: [N x K]\n", " :param labels: true class labels, shape: [N x K]\n", " :param epsilon: small offset to avoid numerical instabilities (i.e log(0))\n", " :return negative log-likelihood of the labels given the predictions, shape: [N]\n", " \"\"\"\n", "\n", " return - np.sum(labels * np.log(predictions + epsilon), -1)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This gives us the loss for a single sample. To get the loss for all samples we will need to sum over loss for a single sample\n", "\n", "\\begin{align} \n", "\\mathcal L_{\\mathrm{cat-NLL}} \n", "=& - \\sum_{i=1}^N \\log p(c_i | \\boldsymbol x_i) \\\\\n", "=& - \\sum_{i=1}^N \\sum_{k=1}^K h_{i, k} \\log(p_{i,k}) \\\\\n", "=& - \\sum_{i=1}^N \\sum_{k=1}^K h_{i, k} \\log(\\textrm{softmax}(\\boldsymbol{w}_k^T \\boldsymbol \\phi(\\boldsymbol{x}_i))_k)\\\\\n", "=& - \\sum_{i=1}^N \\left(\\sum_{k=1}^K h_{i,k}\\boldsymbol{w}^T_k \\boldsymbol \\phi(\\boldsymbol{x}_i) - \\log \\sum_{j=1}^K \\exp(\\boldsymbol{w}_j^T \\boldsymbol \\phi(\\boldsymbol{x}_i))\\right).\n", "\\end{align}\n", "\n", "In order to use gradient based optimization for this, we of course also need to derive the gradient.\n", "This gives us the loss for a single sample. To get the loss for all samples we will need to sum over loss for a single sample\n", "\n", "\n", "\n", "### 1.1) Derivation (4 Points)\n", "Derive the gradient $\\dfrac{\\partial \\mathcal L_{\\mathrm{cat-NLL}}}{\\partial \\boldsymbol{w}}$ of the loss function w.r.t. the full weight vector $\\boldsymbol w \\equiv \\begin{pmatrix} \\boldsymbol w_1^T & \\dots & \\boldsymbol w_K^T \\end{pmatrix}^T$, which is obtained by stacking the class-specific weight vectors $\\boldsymbol w_k$.\n", "\n", "**Hint 1:** Follow the steps in the derivation of the gradient of the loss for the binary classification in the lecture.\n", "\n", "**Hint 2:** Derive the gradient not for the whole vector $\\boldsymbol w$ but only for $\\boldsymbol w_k$ i.e., $\\dfrac{\\partial \\mathcal L_{\\mathrm{cat-NLL}}}{\\partial \\boldsymbol{w}_k}$. The gradients for the individual\n", "$\\boldsymbol w_k$ can then be stacked to obtain the full gradient." ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "\\begin{align}\n", "\\mathcal L_{\\mathrm{cat-NLL}}\n", "=& - \\sum_{i=1}^N \\left(\\sum_{k=1}^K h_{i,k}\\boldsymbol{w}^T_k \\boldsymbol \\phi(\\boldsymbol{x}_i) - \\log \\sum_{j=1}^K \\exp(\\boldsymbol{w}_j^T \\boldsymbol \\phi(\\boldsymbol{x}_i))\\right) \\\\\n", "=& - \\sum_{i=1}^N \\left(\\sum_{k=1}^K h_{i,k}\\boldsymbol{w}^T_k \\boldsymbol \\phi(\\boldsymbol{x}_i) \\right) + \\sum_{i=1}^N \\log \\left(\\sum_{j=1}^K h_{i,k} \\exp(\\boldsymbol{w}_j^T \\boldsymbol \\phi(\\boldsymbol{x}_i)\\right) \\\\\n", "\\end{align}\n" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "Take $\\nabla_{w_j}\\mathcal L_{\\mathrm{cat-NLL}}$ with respect to a particular weight vector $\\boldsymbol{w}_j$, which leads to the fact that the sum $\\sum_{k=1}^K$ is no longer necessary and $\\sum_{i=1}^N\\log \\left(\\sum_{j=1}^K h_{i,k} \\exp(\\boldsymbol{w}_j^T \\boldsymbol \\phi(\\boldsymbol{x}_i)\\right) = \\sum_{i=1}^N \\log \\left( \\sum_{j=1}^K \\exp(\\boldsymbol{w}_j^T \\boldsymbol \\phi(\\boldsymbol{x}_i)\\right)$, since $\\sum_{k=1}^K h_{i,k} = 1$\n" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "\\begin{align}\n", "\\dfrac{\\partial \\mathcal L_{\\mathrm{cat-NLL}}}{\\partial \\boldsymbol{w}_k}\n", "=& \\dfrac{\\partial}{\\partial \\boldsymbol{w}_k} \\left(- \\sum_{i=1}^N \\left( h_{i,k}\\boldsymbol{w}^T_k \\boldsymbol \\phi(\\boldsymbol{x}_i) \\right) + \\sum_{i=1}^N \\log \\left(\\sum_{j=1}^K \\exp(\\boldsymbol{w}_j^T \\boldsymbol \\phi(\\boldsymbol{x}_i)\\right)\\right) \\\\\n", "=& - \\sum_{i=1}^N \\left( h_{i,k}\\boldsymbol \\phi(\\boldsymbol{x}_i) \\right) + \\sum_{i=1}^N \\left( \\frac{1}{\\sum_{j=1}^K \\exp(\\boldsymbol{w}_j^T \\boldsymbol \\phi(\\boldsymbol{x}_i))} \\right) \\exp(\\boldsymbol{w}_j^T \\boldsymbol \\phi(\\boldsymbol{x}_i)) * \\phi(\\boldsymbol{x}_i)\\\\\n", "=& \\sum_{i=1}^N \\left[ \\left( \\frac{\\exp(\\boldsymbol{w}_j^T \\boldsymbol \\phi(\\boldsymbol{x}_i))}{\\sum_{j=1}^K \\exp(\\boldsymbol{w}_j^T \\boldsymbol \\phi(\\boldsymbol{x}_i))} - h_{i,k} \\right ) \\right] \\phi(\\boldsymbol{x}_i))\n", "\\end{align}" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "This is the derivation for one specific weight vector/class. This has to be done for all weight vectors\n" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } }, "source": [ "$$\n", "\\dfrac{\\partial \\mathcal L_{\\mathrm{cat-NLL}}}{\\partial \\boldsymbol{w}}\n", "= \\begin{pmatrix}\n", "\\sum_{i=1}^N \\left[ \\left( \\frac{\\exp(\\boldsymbol{w}_j^T \\boldsymbol \\phi(\\boldsymbol{x}_i))}{\\sum_{j=1}^K \\exp(\\boldsymbol{w}_j^T \\boldsymbol \\phi(\\boldsymbol{x}_i))} - h_{i,1} \\right ) \\right] \\phi(\\boldsymbol{x}_i)) \\\\\n", "\\vdots \\\\\n", "\\sum_{i=1}^N \\left[ \\left( \\frac{\\exp(\\boldsymbol{w}_j^T \\boldsymbol \\phi(\\boldsymbol{x}_i))}{\\sum_{j=1}^K \\exp(\\boldsymbol{w}_j^T \\boldsymbol \\phi(\\boldsymbol{x}_i))} - h_{i,K} \\right ) \\right] \\phi(\\boldsymbol{x}_i))\n", "\\end{pmatrix}\n", "$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 1.2) Implementation (3 Points)\n", "Now that we have the formulas for the loss and its gradient, we can implement them. Fill in the function skeletons below so that they implement the loss and its gradient. Again, in praxis, it is advisable to work with the mean nll instead of the sum, as this simplifies setting the learning rate.\n", "\n", "Hint: The optimizer works with vectors only. So the function get the weights as vectors in the flat_weights parameter. Make sure you use efficient vectorized computations (no for-loops!). Thus, we reshape the weights appropriately before using them for the computations. For the gradients make sure to return again a vector by flattening the result." ] }, { "cell_type": "code", "execution_count": 397, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "# objective\n", "def objective_cat(flat_weights: np.ndarray, features: np.ndarray, labels: np.ndarray) -> float:\n", " \"\"\"\n", " :param flat_weights: weights of the classifier (as flattened vector), shape: [feature_dim * K]\n", " :param features: samples to evaluate objective on, shape: [N x feature_dim]\n", " :param labels: labels corresponding to samples, shape: [N x K]\n", " :return cross entropy loss of the classifier given the samples \n", " \"\"\"\n", "\n", " #flat weights (15,) --> weights (5,3) initialized with zeros\n", " #features (120,5)\n", " #labels (120,3)\n", "\n", " num_features = features.shape[-1]\n", " num_classes = labels.shape[-1]\n", " weights = np.reshape(flat_weights, [num_features, num_classes])\n", "\n", " prediction = softmax(features @ weights)\n", "\n", "\n", " #print('weights', weights)\n", "\n", " #N = features.shape[0] #120\n", " #K = weights.shape[-1] #3\n", "\n", " #loss = 0\n", "\n", " #for i in range(0, N):\n", " #sample = features[i,:].reshape(1, num_features) #shape (1,5)\n", "\n", " #for k in range(0,K):\n", " #class_label = [0] * K\n", " #class_label[k] = 1\n", " #label_is_class = (labels[i, :] == class_label).all()\n", " #zero_or_one = 1 if label_is_class else 0\n", " #if zero_or_one == 0:\n", " #loss += 0\n", " #else:\n", " #softmax_value = softmax(np.matmul(sample, weights))\n", " #loss += categorical_nll(softmax_value , labels[i, :])\n", "\n", " #print('loss', loss)\n", " return np.mean(categorical_nll(prediction, labels))\n", "\n", "\n", "def d_objective_cat(flat_weights: np.ndarray, features: np.ndarray, labels: np.ndarray) -> np.ndarray:\n", " \"\"\"\n", " :param flat_weights: weights of the classifier (as flattened vector), shape: [feature_dim * K]\n", " :param features: samples to evaluate objective on, shape: [N x feature_dim]\n", " :param labels: labels corresponding to samples, shape: [N x K]\n", " :return gradient of cross entropy loss of the classifier given the samples, shape: [feature_dim * K]\n", " \"\"\"\n", " feature_dim = features.shape[-1] #(5)\n", " num_classes = labels.shape[-1] #(3)\n", " weights = np.reshape(flat_weights, [feature_dim, num_classes])\n", "\n", " #flat weights (15,) --> weights (5,3) initialized with zeros\n", " #features (120,5)\n", " #labels (120,3)\n", "\n", " diff = softmax(features @ weights) - labels\n", " grad = features.T @ diff / diff.shape[0]\n", "\n", "\n", " #N = features.shape[0] #120\n", " #K = weights.shape[-1] #3\n", "\n", " #weight_list = []\n", "\n", " #for k in range(0,K):\n", "\n", " #class_label = [0] * K\n", " #class_label[k] = 1\n", "\n", " #weight_class = weights[:, k]\n", "\n", " #sum_loss = np.array([0.0] * len(weights))\n", "\n", " #for i in range(0,N):\n", "\n", " #sample = features[i,:].reshape(1, feature_dim) #sample shape(1,5)\n", " #softmax_value = softmax(np.matmul(sample, weights[:, k])) #(1,5) * (5,1) --> (1)\n", " #label = labels[i, :] #(1,3)\n", " #label_is_class = (label == class_label).all()\n", " #zero_or_one = 1 if label_is_class else 0\n", " #prod = sample.transpose().dot(zero_or_one - softmax_value) #(1 - (1))\n", " #sum_loss += prod\n", " #print(sum_loss)\n", "\n", " #new_weights = np.sum([sum_loss, weight_class], axis= 0)\n", " #weight_list.append(new_weights)\n", " #print('new_weights', new_weights)\n", "\n", "\n", " #for i in range(0, N):\n", " #sample = features[i,:].reshape(1, feature_dim) #sample shape(1,5)\n", " #softmax_value = softmax(np.matmul(sample, weights))\n", "\n", " #label = labels[i, :]\n", "\n", " #diff = label - softmax_value\n", " #grad = (sample.transpose().dot(diff))\n", " #sum_grad += grad\n", "\n", "\n", " #label_is_class = (labels[i, :] == class_label).all()\n", " #zero_or_one = 1 if label_is_class else 0\n", "\n", "\n", "\n", " #for k in range(0, K):\n", "\n", " #class_label = [0] * K\n", " #class_label[k] = 1\n", " #label_is_class = (labels[i, :] == class_label).all()\n", " #zero_or_one = 1 if label_is_class else 0\n", "\n", " #diff = zero_or_one - softmax(np.matmul(sample, weights))\n", " #print('diff', diff)\n", " #print('softmax', softmax(np.matmul(sample, weights)))\n", " #print('label', labels[i, :])\n", "\n", " #grad = (sample.transpose().dot(diff))\n", " #sum_grad += grad\n", " #weight_list = np.reshape(weight_list, (5,3))\n", " return grad.flatten() #grad shape (15,)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally, we can tie everything together again. Both train and test accuracy should be at least 0.9:" ] }, { "cell_type": "code", "execution_count": 398, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Final Loss: 0.359969971552708\n", "Train Accuracy: 0.9583333333333334 Test Accuracy: 1.0\n" ] }, { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# optimization\n", "\n", "w0_flat = np.zeros(5 * 3) # 4 features + bias, 3 classes\n", "w_opt_flat, loss_opt, x_history, f_x_history = \\\n", " minimize(lambda w: objective_cat(w, train_features, oh_train_labels),\n", " lambda w: d_objective_cat(w, train_features, oh_train_labels),\n", " w0_flat, 1e-2, 1000)\n", "\n", "w_opt = np.reshape(w_opt_flat, [5, 3])\n", "\n", "# plotting and evaluation\n", "print(\"Final Loss:\", loss_opt)\n", "plt.figure()\n", "plt.plot(f_x_history)\n", "plt.xlabel(\"iteration\")\n", "plt.ylabel(\"negative categorical log-likelihood\")\n", "\n", "train_pred = softmax(train_features @ w_opt)\n", "train_acc = np.count_nonzero(\n", " np.argmax(train_pred, axis=-1) == np.argmax(oh_train_labels, axis=-1))\n", "train_acc /= train_labels.shape[0]\n", "test_pred = softmax(test_features @ w_opt)\n", "test_acc = np.count_nonzero(\n", " np.argmax(test_pred, axis=-1) == np.argmax(oh_test_labels, axis=-1))\n", "test_acc /= test_labels.shape[0]\n", "print(\"Train Accuracy:\", train_acc, \"Test Accuracy:\", test_acc)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2.) k-NN (3 Points)\n", "Here we implement a simple k-NN approach. As we want to use it for classification now and later for regression, we choose a modular approach. Firstly we implement a function that returns the $k$ nearest neighbour points' x-values and (target) y-values, given a querry point. Then we implement a function to do a majority vote for classification, given the (target) y-values of the k nearest points. Note that we use the \"real\" labels, not the one-hot encoding for the k-NN classifier.\n", "\n", "Work flow and hints (get_k_nearest):\n", "- Compute the distance (e.g. Euclidean) between the query point to all data points.\n", "- Sort the data points according to their distance to the query point. Sort indices can be more efficient.\n", "- Get the K nearest points, return their x and y values." ] }, { "cell_type": "code", "execution_count": 298, "metadata": {}, "outputs": [], "source": [ "def get_k_nearest(k: int, query_point: np.ndarray, x_data: np.ndarray, y_data: np.ndarray) \\\n", " -> Tuple[np.ndarray, np.ndarray]:\n", " \"\"\"\n", " :param k: number of nearest neigbours to return \n", " :param query_point: point to evaluate, shape [dimension]\n", " :param x_data: x values of the data [N x input_dimension]\n", " :param y_data: y values of the data [N x target_dimension]\n", " :return k-nearest x values [k x input_dimension], k-nearest y values [k x target_dimension]\n", " \"\"\"\n", "\n", " distance = []\n", " for i in range(x_data.shape[0]):\n", " point = np.array([x_data[i], y_data[i]])\n", " dist = 0\n", " for j in range(len(point[0])):\n", " dist_1d = (query_point[j] - point[0][j])**2\n", " dist += dist_1d\n", " final_dist = np.sqrt(dist)\n", " distance.append(final_dist)\n", "\n", " #idx = np.argpartition(distance, k)\n", " #idx = idx[:k]\n", "\n", " idx = sorted(range(len(distance)), key=lambda i: distance[i])[:k]\n", "\n", " nearest_x = []\n", " nearest_y = []\n", " for j in range(len(idx)):\n", " nearest_x.append(x_data[idx[j]])\n", " nearest_y.append(y_data[idx[j]])\n", "\n", " return nearest_x, nearest_y\n", "\n", "\n", "\n", "def majority_vote(y: np.ndarray) -> int:\n", " \"\"\"\n", " :param y: k nearest targets [K]\n", " :return the number x which occours most often in y. \n", " \"\"\"\n", " return np.bincount(y).argmax()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We run the classifier and measure the accuracy. For $k=5$ it should be $1.0$." ] }, { "cell_type": "code", "execution_count": 299, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy: 1.0\n" ] } ], "source": [ "k = 5\n", "predictions = np.zeros(test_features.shape[0])\n", "for i in range(test_features.shape[0]):\n", " _, nearest_y = get_k_nearest(\n", " k, test_features[i], train_features, train_labels)\n", " predictions[i] = majority_vote(nearest_y)\n", "\n", "print(\"Accuracy: \", np.count_nonzero(\n", " predictions == test_labels) / test_labels.shape[0])\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.) Hold-out and Cross Validation\n", "In this part of the exercise we will have a closer look on the hold-out and cross validation methods for model selection. We will apply these methods to do model selection for different regression algorithms below.\n", "\n", "Let's first have a look at the data. Note that the data is given as a tensor of shape [20 x 50 x 1], corresponding to 20 different data sets (drawn from the same ground truth function) with 50 data points each. The data is 1-dimensional. \n", "\n", "**Note:** \n", "In practice we typically have only one dataset available. We evaluate hold-out and cross validation for 20 different datasets here only to get a feeling for the robustness of these methods." ] }, { "cell_type": "code", "execution_count": 300, "metadata": {}, "outputs": [ { "data": { "text/plain": "" }, "execution_count": 300, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "%matplotlib inline\n", "\n", "\n", "np.random.seed(33)\n", "\n", "# Load 20 training sets with 50 samples in each set\n", "x_samples = np.load('x_samples.npy') # shape: [20, 50, 1]\n", "y_samples = np.load('y_samples.npy') # shape: [20, 50, 1]\n", "\n", "# Load the ground truth data\n", "x_plt = np.load('x_plt.npy')\n", "y_plt = np.load('y_plt.npy')\n", "\n", "# Plot the data (for the training data we just use the first training set)\n", "plt.plot(x_plt, y_plt, c=\"blue\", label=\"Ground truth polynomial\")\n", "plt.scatter(x_samples[0, :, :], y_samples[0, :, :],\n", " c=\"orange\", label=\"Samples of first training set\")\n", "plt.legend()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Utility Functions for Plotting\n", "Before we start, we define some helper functions which we will make use of later on. You do not need to implement anything yourself here." ] }, { "cell_type": "code", "execution_count": 301, "metadata": {}, "outputs": [], "source": [ "def plot(mse_val: np.ndarray, mse_train: np.ndarray, x_axis, m_star_idx: int, x_plt: np.ndarray, y_plt: np.ndarray,\n", " x_samples: np.ndarray, y_samples: np.ndarray, model_best, model_predict_func: callable):\n", " plt.figure(figsize=(20, 5))\n", " plt.subplot(121)\n", " plot_error_curves(mse_val, mse_train, x_axis, m_star_idx)\n", " plt.subplot(122)\n", " plot_best_model(x_plt, y_plt, x_samples, y_samples,\n", " model_best, model_predict_func)\n" ] }, { "cell_type": "code", "execution_count": 302, "metadata": {}, "outputs": [], "source": [ "def plot_error_curves(MSE_val: np.ndarray, MSE_train: np.ndarray, x_axis, m_star_idx: int):\n", " plt.yscale('log')\n", " plt.plot(x_axis, np.mean(MSE_val, axis=0), color='blue',\n", " alpha=1, label=\"mean MSE validation\")\n", " plt.plot(x_axis, np.mean(MSE_train, axis=0),\n", " color='orange', alpha=1, label=\"mean MSE train\")\n", " plt.plot(x_axis[m_star_idx], np.min(\n", " np.mean(MSE_val, axis=0)), \"x\", label='best model')\n", " plt.xticks(x_axis)\n", " plt.xlabel(\"Model complexity\")\n", " plt.ylabel(\"MSE\")\n", " plt.legend()\n", "\n", "\n", "def plot_best_model(x_plt: np.ndarray, y_plt: np.ndarray, x_samples: np.ndarray, y_samples: np.ndarray,\n", " model_best, model_predict_func: callable):\n", " plt.plot(x_plt, y_plt, color='g', label=\"Ground truth\")\n", " plt.scatter(x_samples, y_samples, label=\"Noisy data\", color=\"orange\")\n", " f_hat = model_predict_func(model_best, x_plt)\n", " plt.plot(x_plt, f_hat, label=\"Best model\")\n", " plt.xlabel('x')\n", " plt.ylabel('y')\n", " plt.legend()\n", "\n", "\n", "def plot_bars(M, std_mse_val_ho, std_mse_val_cv):\n", " models = np.arange(1, M+1)\n", " fig = plt.figure()\n", " ax1 = fig.add_subplot(111)\n", " ax1.bar(models, std_mse_val_ho, yerr=np.zeros(std_mse_val_ho.shape), align='center', alpha=0.5, ecolor='black',\n", " color='red', capsize=None)\n", " ax1.bar(models, std_mse_val_cv, yerr=np.zeros(std_mse_val_cv.shape), align='center', alpha=0.5, ecolor='black',\n", " color='blue', capsize=None)\n", " ax1.set_xticks(models)\n", " ax1.set_xlabel('Model complexity')\n", " ax1.set_ylabel('Standard deviation')\n", " ax1.set_yscale('log')\n", " ax1.set_xticklabels(models)\n", " ax1.set_title('Standard Deviations of MSEs')\n", " ax1.yaxis.grid(True)\n", " plt.legend(['HO', 'CV'])\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.1) Hold-Out Method (4 Points)\n", "We will implement the hold-out method for model selection in this section. First, we require a function to split a dataset into a training set and a validation set. Please fill in the missing code snippets. Make sure that you follow the instructions written in the comments." ] }, { "cell_type": "code", "execution_count": 303, "metadata": {}, "outputs": [], "source": [ "def split_data(data_in: np.ndarray, data_out: np.ndarray, split_coeff: float) -> Tuple[dict, dict]:\n", " \"\"\"\n", " Splits the data into a training data set and a validation data set. \n", " :param data_in: The input data which we want to split, shape: [n_data x indim_data] \n", " :param data_out: The output data which we want to split, shape: [n_data x outdim_data]\n", " Note: each pair of data points with index i in data_in and data_out is considered as a \n", " training/validation sample: (x_i, y_i)\n", " :param split_coeff: A value between [0, 1], which determines the index to split data into test and validation set\n", " according to: split_idx = int(n_data*split_coeff)\n", " :return: A tuple of 2 dictionaries: the first element in the tuple is the training data set dictionary\n", " containing the input data marked with key 'x' and the output data marked with key 'y'.\n", " The second element in the tuple is the validation data set dictionary containing the input data \n", " marked with key 'x' and the output data marked with key 'y'.\n", " \"\"\"\n", " n_data = data_in.shape[0]\n", " # We use a dictionary to store the training and validation data.\n", " # Please use 'x' as a key for the input data and 'y' as a key for the output data in the dictionaries\n", " # for the training data and validation data.\n", "\n", " split_idx = int(n_data*split_coeff)\n", "\n", " train_data = {}\n", " val_data = {}\n", "\n", " train_split_x = data_in[0: split_idx, :]\n", " train_split_y = data_out[0: split_idx, :]\n", "\n", " test_split_x = data_in[split_idx : , :]\n", " test_split_y = data_in[split_idx: , :]\n", "\n", " train_data['x'] = train_split_x\n", " train_data['y'] = train_split_y\n", "\n", " val_data['x'] = test_split_x\n", " val_data['y'] = test_split_y\n", "\n", " return train_data, val_data\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This function implements the hold-out method. We split the dataset into a training and a validation data set (using the split_data function you have implemented above). Then, we train a model for a range of complexity values on the training set and choose the model complexity with the best MSE on the validation set. \n", "\n", "The function expects a callable `fit_func` and a callable `predict_func`. We will pass different functions to this argument depending on the regression algorithm we consider. The `fit_func` function returns model parameters obtained by training a given model with a given complexity on a given training data set. The `predict_func` function computes predictions using a given model with a given complexity. For more information, have a look at the comments.\n", "\n", "As noted above, we do hold-out for 20 different datasets to get a feeling for the robustness of this method. To this end, we compute the standard deviation of the resulting MSEs over the 20 datasets.\n", "\n", "You do not need to implement anything here." ] }, { "cell_type": "code", "execution_count": 304, "metadata": {}, "outputs": [], "source": [ "def eval_hold_out(M: int, split_coeff: float, fit_func: callable, predict_func: callable) -> float:\n", " \"\"\"\n", " :param M: Determines the range of model complexity parameters. \n", " We perform the hold_out method for model complexities (1, ..., M).\n", " :param split_coeff: A value between [0, 1] determines the index to split data (cf. split_data function).\n", " :param fit_func: Callable which fits the model: \n", " (x_train: np.ndarray, y_train: np.ndarray, complexity_parameter: int) -> model_parameters: np.ndarray\n", " :param predict_func: Callable which computes predictions with the model: \n", " (model_parameters: np.ndarray, x_val: np.ndarray) -> y_pred_val: np.ndarray\n", " \"\"\"\n", " n_datasets = 20\n", " mse_train_ho = np.zeros((n_datasets, M))\n", " mse_val_ho = np.zeros((n_datasets, M))\n", "\n", " for d in range(n_datasets):\n", " # Extract current data set and split it into train and validation data\n", " c_x_samples = x_samples[d, :, :]\n", " c_y_samples = y_samples[d, :, :]\n", " train_data, val_data = split_data(\n", " c_x_samples, c_y_samples, split_coeff)\n", "\n", " for m in range(M):\n", " # Train model with complexity m on training set\n", " p = fit_func(train_data['x'], train_data['y'], m + 1)\n", "\n", " # Compute MSE on validation set\n", " y_pred_val = predict_func(p, val_data['x'])\n", " mse_val_ho[d, m] = np.mean((y_pred_val - val_data['y'])**2)\n", "\n", " # For comparison, compute the MSE of the trained model on current training set\n", " y_pred_train = predict_func(p, train_data['x'])\n", " mse_train_ho[d, m] = np.mean((y_pred_train - train_data['y'])**2)\n", "\n", " # Compute mean and std-deviation of MSE over all datasets\n", " mean_mse_train_ho = np.mean(mse_train_ho, axis=0)\n", " mean_mse_val_ho = np.mean(mse_val_ho, axis=0)\n", " std_mse_train_ho = np.std(mse_train_ho, axis=0)\n", " std_mse_val_ho = np.std(mse_val_ho, axis=0)\n", "\n", " # Pick model with best mean validation loss\n", " m_star_ho = np.argmin(mean_mse_val_ho)\n", " print(\"Best model complexity determined with hold-out method: {}\".format(m_star_ho + 1))\n", "\n", " # Plot predictions with best model (use only the first data set for better readability)\n", " train_data, val_data = split_data(\n", " x_samples[0, :, :], y_samples[0, :, :], split_coeff)\n", " p_best_ho = fit_func(train_data['x'], train_data['y'], m_star_ho + 1)\n", " plot(mse_val_ho, mse_train_ho, np.arange(1, M+1), m_star_ho, x_plt, y_plt,\n", " x_samples[0, :, :], y_samples[0, :, :], p_best_ho, predict_func)\n", "\n", " return std_mse_val_ho\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.2) k-Fold-Cross Validation Method (4 Points)\n", "We will now implement the $k$-fold cross validation method for model selection in this section. In contrast to the hold-out method, we do not use a single split of a given dataset into a training and validation sets, but rather $k$ different splits. Refer to the lecture slide 21 for our convention on how to define the $i$-th split.\n", "\n", "Please fill in the missing code snippets. Make sure that you follow the instructions written in the comments. You can refer to the `eval_hold_out`-function above for inspiration (note that for clarity we split the logic into two separate functions `k_fold_cross_validation` and `eval_k_fold_cross_validation` here)." ] }, { "cell_type": "code", "execution_count": 305, "metadata": {}, "outputs": [], "source": [ "def k_fold_cross_validation(data_in: np.ndarray, data_out: np.ndarray, m: int, k: int, fit_func: callable,\n", " predict_func: callable) -> Tuple[np.ndarray, np.ndarray]:\n", " \"\"\"\n", " Perform k-fold cross validation for a model with complexity m on data (data_in, data_out). \n", " Return the mean squared error incurred on the training and the validation data sets.\n", " :param data_in: The input data, shape: [N x indim_data] \n", " :param data_out: The output data, shape: [N x outdim_data]\n", " :param m: Model complexity parameter. \n", " :param k: Number of partitions of the data set (not to be confused with k in kNN).\n", " :param fit_func: Callable which fits the model: \n", " (x_train: np.ndarray, y_train: np.ndarray, complexity_parameter: int) -> model_parameters: np.ndarray\n", " :param predict_func: Callable which computes predictions with the model: \n", " (model_parameters: np.ndarray, x_val: np.ndarray) -> y_pred_val: np.ndarray\n", " :return mse_train: np.ndarray containg the mean squarred errors incurred on the training set for each split k, shape: [k]\n", " :return mse_val: np.ndarray containing the mean squarred errors incurred on the validation set for each split, shape: [k]\n", " \"\"\"\n", "\n", " # Check consistency of inputs and prepare some constants\n", " n_data = data_in.shape[0] # total number of datapoints\n", " assert k <= n_data # number of partitions has to be smaller than number of data points\n", " # we assume that we can split the data into k equally sized partitions here\n", " assert n_data % k == 0\n", " n_val_data = n_data // k # number of datapoints in each validation set\n", "\n", " # Prepare return values\n", " mse_train = np.zeros(k)\n", " mse_val = np.zeros(k)\n", "\n", " for i in range(k):\n", " # 1: Prepare i-th partition into training and validation data sets (cf. lecture slide 21)\n", " i_training_split = data_in[i * n_val_data: (i+1)*n_val_data, :]\n", " i_validation_split = data_out[i * n_val_data: (i+1)*n_val_data, :]\n", "\n", " # 2: Fit model on training set\n", "\n", " p = fit_func(i_training_split, i_validation_split, m)\n", "\n", "\n", " # 3: Compute predictions on training set and validation set\n", "\n", " y_pred_train = predict_func(p, i_training_split)\n", " y_pred_val = predict_func(p, i_validation_split)\n", "\n", " # 4: Compute the mean squarred error for the training and validation sets\n", " # TODO\n", "\n", " mse_val[i] = np.mean((y_pred_val - data_out[i * n_val_data: (i+1)*n_val_data, :])**2)\n", " mse_train[i] = np.mean((y_pred_train - data_in[i * n_val_data: (i+1)*n_val_data, :])**2)\n", "\n", " return mse_train, mse_val\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This function will uses the functions you have implemented to evaluate the robustness of the k-fold cross validation method. Similar to the `eval_held_out` function above, it will perform cross validation on the 20 different data sets we have loaded at the beginning and return the standard deviation of the mean squarred errors over the 20 data sets of each different model it is tested on." ] }, { "cell_type": "code", "execution_count": 306, "metadata": {}, "outputs": [], "source": [ "def eval_k_fold_cross_validation(M: int, k: int, fit_func: callable, predict_func: callable) -> float:\n", " \"\"\"\n", " :param M: Determines the range of model complexity parameters. \n", " We perform the cross-validation method for model complexities (1, ..., M).\n", " :param k: Number of partitions of the data set (not to be confused with k in kNN).\n", " :param fit_func: Callable which fits the model: \n", " (x_train: np.ndarray, y_train: np.ndarray, complexity_parameter: int) -> model_parameters: np.ndarray\n", " :param predict_func: Callable which computes predictions with the model: \n", " (model_parameters: np.ndarray, x_val: np.ndarray) -> y_pred_val: np.ndarray \n", " \"\"\"\n", " n_datasets = 20\n", " mse_train_cv = np.zeros((n_datasets, M))\n", " mse_val_cv = np.zeros((n_datasets, M))\n", "\n", " for d in range(n_datasets):\n", " # Extract current data set and split it into train and validation data\n", " c_x_samples = x_samples[d, :, :]\n", " c_y_samples = y_samples[d, :, :]\n", "\n", " for m in range(M):\n", " mse_train_k_cv, mse_val_k_cv = k_fold_cross_validation(\n", " c_x_samples, c_y_samples, m + 1, k, fit_func, predict_func)\n", " # Average MSEs over splits\n", " mse_train_cv[d, m] = np.mean(mse_train_k_cv)\n", " mse_val_cv[d, m] = np.mean(mse_val_k_cv)\n", "\n", " # Compute mean and std-deviation of MSE over all datasets\n", " mean_mse_train_cv = np.mean(mse_train_cv, axis=0)\n", " mean_mse_val_cv = np.mean(mse_val_cv, axis=0)\n", " std_mse_train_cv = np.std(mse_train_cv, axis=0)\n", " std_mse_val_cv = np.std(mse_val_cv, axis=0)\n", "\n", " # Pick model with best mean validation loss\n", " m_star_cv = np.argmin(mean_mse_val_cv)\n", " print(\"Best model complexity determined with cross-validation method: {}\".format(m_star_cv + 1))\n", "\n", " # Plot predictions with best model (use only the first data set for better readability)\n", " train_data, val_data = split_data(\n", " x_samples[0, :, :], y_samples[0, :, :], split_coeff)\n", " p_best_cv = fit_func(train_data['x'], train_data['y'], m_star_cv + 1)\n", " plot(mse_val_cv, mse_train_cv, np.arange(1, M+1), m_star_cv, x_plt, y_plt,\n", " x_samples[0, :, :], y_samples[0, :, :], p_best_cv, predict_func)\n", "\n", " return std_mse_val_cv\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.3) kNN Regression\n", "We will now apply hold-out and k-fold cross validation on the regression problem using kNN Regression. In the following we provide a fit and an evaluate function for kNN, which we will use as the callables `fit_func` and `eval_func` for hold-out and cross validation." ] }, { "cell_type": "code", "execution_count": 307, "metadata": {}, "outputs": [], "source": [ "def fit_knn_regressor(train_in: np.ndarray, train_out: np.ndarray, k: int) -> dict:\n", " \"\"\"\n", " Fit a k-nearest neighbors model to the data. This function just returns a compact representation of the input data\n", " data provided, i.e. it stores the training in- and output data together with the number of k neighbors in a dictionary.\n", " :param train_in: The training input data, shape: [N x input dim]\n", " :param train_out: The training output data, shape: [N x output dim]\n", " :param k: The parameter determining how many nearest neighbors to consider\n", " :return: A dictionary containing the training data and the parameter k for k-nearest-neighbors.\n", " Key 'x': the training input data, shape: [N x input dim]\n", " Key 'y': the training output data, shape: [N x output dimension]\n", " Key 'k': the parameter determining how many nearest neighbors to consider\n", " \"\"\"\n", "\n", " model = {'x': train_in, 'y': train_out, 'k': k}\n", " return model\n" ] }, { "cell_type": "code", "execution_count": 308, "metadata": {}, "outputs": [], "source": [ "def predict_knn_regressor(model, data_in: np.ndarray) -> np.ndarray:\n", " \"\"\"\n", " This function will perform predictions using a k-nearest-neighbor regression model given the input data. \n", " Note that knn is a lazy model and requires to store all the training data (see dictionary 'model').\n", " :param model: A dictionary containing the training data and the parameter k for k-nearest-neighbors.\n", " Key 'x': the training input data, shape: [N x input dim]\n", " Key 'y': the training output data, shape: [N x output dimension]\n", " Key 'k': the parameter determining how many nearest neighbors to consider\n", " :param data_in: The data we want to perform predictions on, shape: [N x input dimension]\n", " :return prediction based on k nearest neighbors (mean of the k - neares neighbors) (shape[N x output dimension])\n", " \"\"\"\n", " # Prepare data\n", " if len(data_in.shape) == 1:\n", " data_in = np.reshape(data_in, (-1, 1))\n", " train_data_in = model['x']\n", " train_data_out = model['y']\n", " k = model['k']\n", " if len(train_data_in.shape) == 1:\n", " train_data_in = np.reshape(train_data_in, (-1, 1))\n", "\n", " # Perform predictions\n", " predictions = np.zeros((data_in.shape[0], train_data_out.shape[1]))\n", " for i in range(data_in.shape[0]):\n", " _, nearest_y = get_k_nearest(\n", " k, data_in[i, :], train_data_in, train_data_out)\n", " # we take the mean of the nearest samples to perform predictions\n", " predictions[i, :] = np.mean(nearest_y, axis=0)\n", "\n", " return predictions\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.3.1) Apply Hold-Out and Cross-Validation to kNN Regression " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We now apply $k$-nearest neighbor regression on our data set and use the hold-out and cross-validation methods to determine the complexity parameter of this model, i.e., the number $k$ of nearest neighbors to consider.\n", "As described above, we furthermore plot and compare the standard deviations of the mean squared errors for each model based on the 20 data sets to get a feeling of the robustness of hold-out and cross validation." ] }, { "cell_type": "code", "execution_count": 309, "metadata": {}, "outputs": [], "source": [ "M_knn = 20 # Maximum number k of nearest neighbors\n", "split_coeff = 0.8 # Split coefficient for the hold-out method\n", "k = 10 # Number of splits for the cross validation method\n" ] }, { "cell_type": "code", "execution_count": 310, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Best model complexity determined with hold-out method: 20\n", "Best model complexity determined with cross-validation method: 2\n" ] }, { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": "
", "image/png": "iVBORw0KGgoAAAANSUhEUgAABKMAAAE9CAYAAADXrqGFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAACLG0lEQVR4nOzdeVhV1f7H8fdiBkUccMIR5xFQcdacp4bbnCWmZmVWZt26dSvzZt2fZXOZqWlZVmrdUnMoS03NWXM2c1ZUnEdEAZnW74+D5AA4AZvh83oensPZe+29PweJDl/W+m5jrUVERERERERERCQnuDkdQERERERERERECg4Vo0REREREREREJMeoGCUiIiIiIiIiIjlGxSgREREREREREckxKkaJiIiIiIiIiEiOUTFKRERERERERERyjIfTAZwWGBhoK1eu7HQMERERySarV68+Zq0t6XSO/MAYMw64FThira2Xum0I8ChwNHXYy9ban690Lr0HExERyd8yew9W4ItRlStXZtWqVU7HEBERkWxijNnjdIZ85EtgBPDVJds/sNa+ey0n0nswERGR/C2z92BapiciIiIiV8VauxA44XQOERERydtUjBIRERGRGzXAGLPBGDPOGFPM6TAiIiKSu6kYJSIiIiI3YhRQFQgDDgLvZTTQGNPPGLPKGLPq6NGjGQ0TERGRfK7A94wSERERketnrT18/nNjzFhgZiZjxwBjAMLDw+2l+xMTE4mKiiI+Pj47oso18PHxoXz58nh6ejodRURE8iEVo0RERETkuhljylprD6Y+vRP483rPFRUVhb+/P5UrV8YYkzUB5ZpZazl+/DhRUVEEBwc7HUdERPIhFaNERERE5KoYYyYBbYFAY0wU8CrQ1hgTBlggEnjses8fHx+vQlQuYIyhRIkSaCmliIhkFxWjREREROSqWGsfSGfz51l5DRWicgf9O4iISHZSA3MRERERkVSHDx+mR48eVKlShUaNGtG8eXOmTp2aoxkiIyOpV69eutsnTpx4Xef88MMPiY2NTXteuHDh684nIiJyo1SMEhERERHB1Svpjjvu4KabbmLXrl2sXr2ab7/9lqioqMvGJiUl5Xi+zIpRV8pzaTFKRETESVqmJ/nWoUMwcybYy+7VIyIiudFDD4GH3pmIg+bNm4eXlxf9+/dP21apUiWeeuopAL788kumTJnCmTNnSE5OZurUqfTt25ddu3bh5+fHmDFjCAkJYciQIRQuXJh//etfANSrV4+ZM103GezWrRutWrVi6dKllCtXjmnTpuHr68vq1avp27cvAJ07d04334svvsjmzZsJCwujd+/eFCtW7KI8r732Gu+++27atQYMGEB4eDinT5/mwIEDtGvXjsDAQObPnw/AoEGDmDlzJr6+vkybNo3SpUtnzxdWRERypZnbZuLn6Uf74PY5fm295ZN8a+BA+P57p1OIiMjVevBBFaPEWZs2baJhw4aZjlmzZg0bNmygePHiPPXUUzRo0IAff/yRefPm0atXL9atW5fp8du3b2fSpEmMHTuW++67j8mTJ9OzZ08eeughRowYwU033cTzzz+f7rHDhg27qNj05ZdfXpRnwYIF6R43cOBA3n//febPn09gYCAAZ8+epVmzZgwdOpQXXniBsWPH8sorr2T+BRIRkXwjxabwzC/PEOQfpGKUSFY5cACmToUBA+DFF51OIyIiV8Pb2+kEkps888szrDu0LkvPGVYmjA+7fnjV45988kkWL16Ml5cXf/zxBwCdOnWiePHiACxevJjJkycD0L59e44fP87p06czPWdwcDBhYWEANGrUiMjISE6dOsWpU6e46aabAHjwwQeZNWvWVWW8MM+18PLy4tZbb03LMWfOnGs+h4iI5F2zd85m58md/F/7/3Pk+vmyGGWMqQIMAgKstfc4nUdy3tixkJQEzzwD5co5nUZERETygrp166YVlwA++eQTjh07Rnh4eNq2QoUKXfE8Hh4epKSkpD2Pj49P+9z7gqqru7s7cXFxN5T5wjyZXfdSnp6eaXfMc3d3d6QHloiIOGfkHyMpXag0d9W+y5HrZ1sxyhhTAfgKKA1YYIy19qPrPNc44FbgiLW23iX7ugIfAe7AZ9baYdbaXcDDxpgfbuQ1SN6UmAhjxkDXrlC1qtNpRERE5HpcywymrNK+fXtefvllRo0axeOPPw6QadPv1q1bM2HCBAYPHsyCBQsIDAykSJEiVK5cOW0p3Zo1a9i9e3em1y1atChFixZl8eLFtGrVigkTJqQ7zt/fn5iYmAzPU6lSJf766y/OnTtHXFwcv/32G61atbro2PPL9EREpOCKPBXJzG0zGdR6EF7uXo5kyM676SUBz1lr6wDNgCeNMXUuHGCMKWWM8b9kW7V0zvUl0PXSjcYYd+AToBtQB3jg0mtIwTNtmmuZ3pNPOp1ERERE8hJjDD/++CO///47wcHBNGnShN69e/PWW2+lO37IkCGsXr2akJAQXnzxRcaPHw/A3XffzYkTJ6hbty4jRoygRo0aV7z2F198wZNPPklYWBg2g7uvhISE4O7uTmhoKB988MFl+ytUqMB9991HvXr1uO+++2jQoEHavn79+tG1a1fatWt3NV8KERHJxz5d9SnGGPo16udYBpPR/+yy/ELGTANGWGvnXLDtXqA/cLO19pwx5lHgLmttt3SOrwzMvHBmlDGmOTDEWtsl9flLANbaN1Of/3ClZXrh4eF21apVN/z6JPdo3x527YKdO8Hd3ek0IiLiNGPMamtt+JVHSk5K7z3Y5s2bqV27tkOJ5FL69xARyX/OJZ2j/AflaVWxFVO7T83Wa2X2Hiw7Z0ZdGKAy0ABYceF2a+33wK/Ad8aYCKAvcO81nLocsO+C51FAOWNMCWPMaKDB+QJVOpluM8aMiY6OvobLSW73118wfz70769ClIiIiIiIiMiFvv/re47FHuOJ8CcczZHtxShjTGFgMvCMtfay24tYa98G4oFRwD+stWdu9JrW2uPW2v7W2qrnZ0mlM2aGtbZfQEDAjV5OcpFRo8DLCx5+2OkkIiIiIiIiIrnLyD9GUqNEDTpU6eBojmwtRhljPHEVoiZYa6dkMKY1UA+YCrx6jZfYD1S44Hn51G1SAJ05A+PHw333QcmSTqcRERERERERyT3WHlzLsqhlPB7+OG4mRxbKZSjbrm5c94r9HNhsrX0/gzENgDHA7cBDQAljzP9dw2X+AKobY4KNMV7A/cD0G0suedU330BMjBqXi4iIiIiIiFxq5B8j8fXwpXdob6ejZOvMqJbAg0B7Y8y61I+bLxnjB9xnrd1prU0BegF7Lj2RMWYSsAyoaYyJMsY8DGCtTQIG4Oo7tRn4n7V2U/a9JMmtrIWRI6FBA2ja1Ok0IiIiIiIiIg7aPQF+rAwT3eDHypzaOoYJGycQUT+CYr7FnE6HR3ad2Fq7GDBXGLPkkueJwNh0xj2QyTl+Bn6+zpiSTyxeDBs3wmefgcn0u05EREREREQkH9s9AVb2g+RY1/PYPYybN4C4pEQeb/y4s9lSObtIMD878AtsHeF0igJj5EgoWhQeyLBsKSIiInJl7u7uhIWFERoaSsOGDVm6dOl1nefDDz8kNjY2i9Ndrk+fPvzwww83PEZERPKR9YP+LkQByRY+PpFIq0LeNCzb0MFgf1MxKrtE/QjrX4aURKeT5HuHDsHkyfDQQ+Dn53QaERERyct8fX1Zt24d69ev58033+Sll166rvPkVDFKRETkMrF7L3o6/SxEJsEz/uccCnQ5FaOyS5lOkBQDx1c6nSTf++wzSEyE/v2dTiIiIiL5yenTpylW7O++Gu+88w6NGzcmJCSEV1913QT67Nmz3HLLLYSGhlKvXj2+++47hg8fzoEDB2jXrh3t2rW77LyVK1fmpZdeIiwsjPDwcNasWUOXLl2oWrUqo0ePBsBay/PPP0+9evWoX78+3333Xdr2AQMGULNmTTp27MiRI0fSzrt69WratGlDo0aN6NKlCwcPHszOL4+IiORWfhUvevrRKajoAbeXqpj+eAdkW8+oAq9MezBucHAOlGzpdJp8KykJPv0UOnWCGjWcTiMiIiJ5XVxcHGFhYcTHx3Pw4EHmzZsHwOzZs9m+fTsrV67EWss//vEPFi5cyNGjRwkKCuKnn34CIDo6moCAAN5//33mz59PYGBgutepWLEi69at45///Cd9+vRhyZIlxMfHU69ePfr378+UKVPSZmgdO3aMxo0bc9NNN7Fs2TK2bt3KX3/9xeHDh6lTpw59+/YlMTGRp556imnTplGyZEm+++47Bg0axLhx43LsayciIrlE6NC0nlFr4+H3OHinpCceYW84nSyNilHZxasYFG8Mh2ZDyBCn0+RbM2ZAVBSMUHsuERGRfOW1GZv468DpLD1nnaAivHpb3UzHnF+mB7Bs2TJ69erFn3/+yezZs5k9ezYNGjQA4MyZM2zfvp3WrVvz3HPP8e9//5tbb72V1q1bX1WWf/zjHwDUr1+fM2fO4O/vj7+/P97e3pw6dYrFixfzwAMP4O7uTunSpWnTpg1//PEHCxcuTNseFBRE+/btAdi6dSt//vknnTp1AiA5OZmyZctez5dJRETyuuAI1+P6QXx0aA9+boaH24/4e3suoGJUdirTCf56ExKiwSvA6TT50iefQIUKcMstTicRERGR/KZ58+YcO3aMo0ePYq3lpZde4rHHHrts3Jo1a/j555955ZVX6NChA//5z3+ueG5vb28A3Nzc0j4//zwpKemas1prqVu3LsuWLbvmY0VEJB8KjuBwyY5M+rAijzR8hGK1+jmd6CIqRmWnsp1g0//B4flQ4Q6n0+Q7W7bAb7/B0KHgoe9kERGRfOVKM5hywpYtW0hOTqZEiRJ06dKFwYMHExERQeHChdm/fz+enp4kJSVRvHhxevbsSdGiRfnss88A8Pf3JyYmJsNlelfSunVrPv30U3r37s2JEydYuHAh77zzDklJSWnbjxw5wvz58+nRowc1a9bk6NGjLFu2jObNm5OYmMi2bduoW9f5r6OIiDhj9KrRJCQnMLDpQKejXEa/wmenEs3AoxAcmqNiVDYYPRo8PeHhh51OIiIiIvnF+Z5R4JptNH78eNzd3encuTObN2+mefPmABQuXJhvvvmGHTt28Pzzz+Pm5oanpyejRo0CoF+/fnTt2pWgoCDmz59/zTnuvPNOli1bRmhoKMYY3n77bcqUKcOdd97JvHnzqFOnDhUrVkzL4+XlxQ8//MDAgQOJjo4mKSmJZ555RsUoEZEC6lzSOUatGkW3at2oGVjT6TiXMdZapzM4Kjw83K5atSr7LrDgVojZBrdty75rFEBnz0K5cq7leRMmOJ1GRERyM2PMamttuNM55GLpvQfbvHkztWvXdiiRXEr/HiIieddX67+i94+9+bXnr3Su2tmRDJm9B3PL6TAFTplOELMdzu5xOkm+MnEiREfDE084nUREREREREQk97DW8tGKj6gdWJtOVTo5HSddWqaX3cqmViAPzoFqjzibJZ+w1tW4PDQUWrRwOo2IiIiIiIhI7jE/cj5/RUHPOoMYvzQy07Gli/jQrX7O331VxajsVqQW+JaDQ7NVjMoiy5bB+vXw6adgjNNpRERERERERHKPYYs+olTCf5izzoM56/7KdGyTysVVjMqXjHHdVS9qOqQkg5u704nyvE8+gSJFoEcPp5OIiIiIiIiI5B4bD29k8Y4jlMKDcX3CaVChWKbj3d2dmeGhYlROKNMJdn0JJ9dCCfVPvRFHjsD338Pjj0Phwk6nEREREREREck93l32Lv62Mb6ebrSqVhIvj9zZKjx3pspvynR0PR6a42yOfOCzzyAx0VWMEhERERERERGXfdH7mLhxIoEerWheNTDXFqJAxaic4VMKioaqGHWDkpNh9Gjo0AFq1XI6jYiIiORHxhiee+65tOfvvvsuQ4YMyfSY0aNH89VXX2VpjsqVK3Ps2LFMx7zxxhtZek0REcnbPlrxEW7JgZyNK0SraoFOx8mUilE5pWwnOLoEks46nSTP+ukn2LcPnnjC6SQiIiKSX3l7ezNlypQrFoIu1L9/f3r16pWNqdKnYpSIiJwXHR/NmNVjaFXGdeO01tVVjBKAMp0hJQGOLHQ6SZ71ySdQrhz84x9OJxEREZFcYfcE+LEyTHRzPe6ecMOn9PDwoF+/fnzwwQeX7YuMjKR9+/aEhITQoUMH9u7dC8CQIUN49913ARg+fDh16tQhJCSE+++/n5SUFKpXr87Ro0cBSElJoVq1amnPzzt+/DidO3embt26PPLII1hr0/bdcccdNGrUiLp16zJmzBgAXnzxReLi4ggLCyMiIiLDcSIiUjB8uvpTYhJiKO3ZltJFvKlWKnc3WVYxKqeUbAVu3nBQS/Wux/btMHs2PPYYeKjtvoiIiCOMMeOMMUeMMX9esK24MWaOMWZ76mPmt+3JKrsnwMp+ELsHsK7Hlf2ypCD15JNPMmHCBKKjoy/a/tRTT9G7d282bNhAREQEAwcOvOzYYcOGsXbtWjZs2MDo0aNxc3OjZ8+eTJjgyjV37lxCQ0MpWbLkRce99tprtGrVik2bNnHnnXemFboAxo0bx+rVq1m1ahXDhw/n+PHjDBs2DF9fX9atW5d27vTGiYhI/ncu6RwfLv+QDsGd+Gt/Mq2rl8QYZ+6Sd7VUjMopHr5QqrX6Rl2nUaNcRahHHnE6iYiISIH2JdD1km0vAr9Za6sDv6U+z37rB0Fy7MXbkmNd229QkSJF6NWrF8OHD79o+7Jly+jRowcADz74IIsXL77s2JCQECIiIvjmm2/wSP0LWt++fdN6So0bN46HHnrosuMWLlxIz549AbjlllsoVuzvmt7w4cMJDQ2lWbNm7Nu3j+3bt6eb+2rHiYhIPrJ7AhO/KsfBMwe5Lz6aU7GJuX6JHqgYlbPKdILoPyHuoNNJ8pTYWPjiC7j7bihb1uk0IiIiBZe1diFw4pLNtwPjUz8fD9yRI2Fi917b9mv0zDPP8Pnnn3P27LX1+/zpp5948sknWbNmDY0bNyYpKYkKFSpQunRp5s2bx8qVK+nWrdtVn2/BggXMnTuXZcuWsX79eho0aEB8fPx1jxMRkXxk9wSSVzzKsEPHCfOGxLOVAGjp9bvDwa5MxaicVKaT6/HQXGdz5DGTJsGpU2pcLiIikkuVttae/0vbIaB0RgONMf2MMauMMasu7Zl0zfwqXtv2a1S8eHHuu+8+Pv/887RtLVq04NtvvwVgwoQJtG7d+qJjUlJS2LdvH+3ateOtt94iOjqaM2fOAPDII4/Qs2dP7r33Xtzd3S+73k033cTEiRMBmDVrFidPngQgOjqaYsWK4efnx5YtW1i+fHnaMZ6eniQmJl5xnIiI5FPrBzE5Oo5tiTCoGCw+E0Ztn10EbnvZ6WRXpGJUTioWCt4l1TfqGljralxerx5c8n5PREREchnr6rptM9k/xlobbq0Nv7Rn0jULHQrufhdvc/dzbc8izz333EV31fv444/54osvCAkJ4euvv+ajjz66aHxycjI9e/akfv36NGjQgIEDB1K0aFEA/vGPf3DmzJl0l+gBvPrqqyxcuJC6desyZcoUKlZ0FdW6du1KUlIStWvX5sUXX6RZs2Zpx/Tr1y9tWWBm40REJH+yZ/cw9ATU8oSuft6siq1D68Jrs2yWcHZSK+icZNygTAdX3yhrIZc3FMsNVqyAtWth5Eh9uURERHKpw8aYstbag8aYssCRHLlqsOsOcqwf5HrT7VfRVYg6v/06nZ/JBFC6dGliY//uS1WpUiXmzZt32TFDhgxJ+zy9PlIA69evJzQ0lFq1aqW7v0SJEsyePTvdfbNmzUp3+1tvvcVbb711xXEiIpI/zUwqyYaEo3xVGv44W49E60kr/3VZNks4O2lmVE4r0xniD7l6R8kVjRwJ/v6Q2s9TREREcp/pQO/Uz3sD03LsysERcEck9EhxPd5gISq7DBs2jLvvvps333zT6SgiIpJPWGsZeqYIwZ6GB/xh8ZkGeJkEmhTZlaWzhLOLilE5rWxq3ygt1buiY8fgu++gVy9XQUpEREScZYyZBCwDahpjoowxDwPDgE7GmO1Ax9TncoEXX3yRPXv20KpVK6ejiIhIPvHb7t9YcWwn/27UB49ClVh8JowmRXbi0+yTXPvHmQtpmV5O8ysPRWq5lurVftbpNLna559DQoIal4uIiOQW1toHMtjVIUeDiIiIFHBDFw0lyD+IPh1GcSTWsnX5b9zZrhYEV3U62lXRzCgnlOkER36H5HNOJ8m1kpNh9Gho2xbq1HE6jYiIiOQUVw90cZr+HUREcq8le5ewIHIBz7d4Hm8PbxbvcN1so1W1QIeTXT0Vo5xQphMkx8GxpU4nybVmzYLISM2KEhERKUh8fHw4fvy4CiEOs9Zy/PhxfHx8nI4iIiLpGLpoKCX9SvJow0c5eTaBEfN2UKaID3XKFnE62lXTMr1sYi0cPQqlSqWzs3RbMB6uvlGl2+V0tDxh5EgoWxbuuMPpJCIiIpJTypcvT1RUFEePHnU6SoHn4+ND+fLlnY4hIiKXWHVgFbN2zOKN9m/gbnx45KsVRJ2KY8IjTXFzyzu3oFcxKps89BCsWgVr14Kn5yU7Pf0hsBkcmg284US8XG3nTvjlF/jPf9L52omIiEi+5enpSXBwsNMxREREcpfdE2D9IIjdy6uHfCjuVZjHw5/g2f+tY83ek4x4oCGNKxd3OuU10TK9bHLHHbBpE4walcGAMp3hxBo4dzwnY+UJo0eDmxv06+d0EhEREREREREH7Z4AK/tB7B6Wx1l+jonj+YBzjJg6l583HmLQzbW5JaSs0ymvmYpR2eT226FzZ9fsnnRnmpftBFg49FtOR8vV4uJg3Di4804ICnI6jYiIiIiIiIiDVj+NTYol0boz+LgPgW7++CfcwmcbfOhTZgEP760GP1Z2Fa3yEC3TyybGwIcfQkgIvPwyjB17yYDi4eAZAIfmQKX7nIiYK333HZw4AU8+6XQSERERERERkawxcsEOPpiz7doOsinYlM9Jxg2bOpeoEPDOWehcZBmDS76PMRZi97hmTwEER2Rt8GyiYlQ2ql0bBg6EDz6Axx6D8PALdrp5QOn2rmKUta7qlfDJJ1CnDrRp43QSERERERERkayxdu8pAny9uC/8Gm4OsW0kJEbjYZL5JiaJw8mJ/KdEIoEeZ7klYDHuJuXvscmxrr5SKkYJuJbpffONqyi1eLGrF1Kasp0gairE7IAi1R3LmFv88Yer6fuIEarNiYiIiIiISP4RHZtI1ZKFeKFrras/6MQIwLIgFp6LgQ9Kw2PFMhkfu/dGY+YY9YzKZgEBMGwYLFsGEy5dwlmmk+vx0Owcz5UbjRwJhQrBgw86nUREREREREQk65yKS6Co3zXeLt6vItbCf45DkDs8FnB+RwazN/wq3kjEHKViVA7o3RsaN4YXXoCYmAt2FK4KhSq7luoVcMePw7ffugpRRYo4nUZEREREREQk60THJVLU1+vaDgodym/nvFkUDy8XB183wN0PqvV3PV7I3Q9Ch2ZZ3uymYlQOcHODjz+GQ4fg//7vgh3GQNnOcHg+pCQ5li83+OILiI+HJ55wOomIiIiIiIhI1joVm0jANc6MspV7MDiuAuU93XmkCOBXCZqMgSYjXY9+lQDz9/Y80i8K1DMqxzRtCg895Gpm3rcv1KyZuqNMJ9gxBo6vhJItHM3olJQUGDUKWreG+vWdTiMiIiIiIiKSdeITkzmXlEKA77UVo6ZtncbyYzsYc+sYvBs9evHO4Ig8VXy6lGZG5aA33wRfX3jmGdcN9ADXHfUwBXqp3q+/wq5d8OSTTicRERERERERyVrRcYkA11SMSkpJ4qXfXqJWYC0eavBQdkVzjIpROah0aXj1VfjlF/jpp9SN3sWheHiBLkZ98onra3PnnU4nEREREREREcla54tR19LAfPy68Ww5toWh7Yfi4Zb/FrWpGJXDBgyAWrVcs6POnUvdWLYTHFsOiaedjOaI3bvh55+hXz/wusZebiIiIiIiIiK53anYa5sZFZcYx6sLXqVpuabcWSt/ztpQMSqHeXnBRx/Bzp2u/lGAq2+UTXY1Mi9gRo92NXjv18/pJCIiIiIiIiJZL21m1FXeTe/jlR+zP2Y/b3V8C2NMdkZzjIpRDujcGW6/3XVnvf37gcDm4FEIDhaspXrx8fD5566vRfnyTqcRERERERERyXqnYhOAq5sZdTLuJG8ufpObq99Mm8ptsjuaY1SMcsj770NSEvz734C7N5RqU+D6Rn3/PRw/Dk884XQSERERERERkeyR1sD8KnpGDVs8jOj4aN7s8GZ2x3KUilEOqVIFnn8eJkyAxYtxLdWL2QZn9zodLUds2uRq5l6zJrRv73QaERERERERkewRHZeIMeDvnXkj8v2n9zN85XAiQiIIKR2SQ+mcoWKUg1580bU87amnILlUJ9fGAjA76uuvoUkTiI11LdPLp0tgRURERERERDgVm0iArydubpn/8jto3iBSbAqvt309h5I5R8UoBxUqBO++C+vWwWff1wHfoHzdNyo+3tWovFcvCA+HtWuhZUunU4mIiIiIiIhkn+i4RIpeoV/U6gOrGb9+PM80fYbgYsE5lMw5KkY57L774KabYNAgw7liHeHwXLApTsfKcjt2QPPmMHYsvPQS/PYblC3rdCoRERERERGR7HUqLjHT5uXWWv756z8p6VeSQTcNysFkzlExymHGwPDhcPIkfPt7Jzh3HE6udTpWlpoyBRo1gj17YOZMeOMN8Mh8qayIiIiIiIhIvhAdl0iAn1eG+6dsnsKivYv4b7v/UsS7SA4mc46KUblAaCg8/ji89FFH14Z8slQvIQH++U+4+26oVcu1LO+WW5xOJSIiIiIiIpJzomMTMpwZFZ8Uz/Nznqd+qfo83PDhHE7mHBWjconXX4dzpgw7jodg80ET8337oE0b+PBDV4P2RYugUiWnU4mIiIiIiIjkrMx6Rg1fMZzdp3bzfpf38XArOEuIVIzKJYoXh6FD4cflnUg5vBiSYp2OdN1mzYIGDWDTJvjf/1zLEL0ynpEoIiIiIiIiki+lpFjXMr10ilFHzh7h/xb+H7fWuJWOVTo6kM45KkblIo8+CjvPdsKdBOL3LXI6zjVLToZXXoGbb4Zy5WDVKrj3XqdTiYiIiIiIiDjjTEISKRaK+l1ejPrP/P8QlxTHu53edSCZs1SMykXc3aHnP1tzLtGL1TPz1lK9Q4egUyfX7K6+fWH5cqhRw+lUIiIiIiIiIs6Jjk0EoMglM6PWHlzL2DVjebLxk9QMrOlENEepGJXLtGzjx/boVhSJnc3u3U6nuTq//+5alrd8OXzxBXz+Ofj6Op1KRERERERExFmnUotRF/aMSrEpPPnzk5TwLcGQtkMcSuYsFaNyoQqNO1G/wkb++/Ihp6NkKiUF3nwT2reHIkVgxQro08fpVCIiIiIiIiK5Q3RcajHK7+9GyuPXjWdZ1DLe6fQORX2KOpTMWSpG5UIBNTsDkLBvLnNy6Wq948fhH/+Al1929YVatQrq13c6lYiIiIiIiEjucSouASCtgfnJuJO8MPcFWlZoyYOhDzoZzVEqRuVGxcKwXoHc1XwOAwdCYqLTgS62ciU0bAizZ8OIETBpEvj7O51KREREnGSMiTTGbDTGrDPGrHI6j4iISG7w98woVzFq0LxBnIw7ychbRuJmCm5JpuC+8tzMuGHKdODmhnPYssUyYoTTgVyshY8/hlatwBhYsgSefNL1uYiIiAjQzlobZq0NdzqIiIhIbnC+Z1SAryerD6xm9KrRDGgygJDSIQ4nc5aKUblV2U742IP06/4XQ4bA4cPOxjl9Grp3h4EDoUsXWLMGGjd2NpOIiIiIiIhIbnY6LhFvDze8PAxP/PwEpQqV4rW2rzkdy3EqRuVWZToB8N8nZhMX5+rN5JT16yE8HKZMgbfegmnToHhx5/KIiIhIrmSB2caY1caYfukNMMb0M8asMsasOnr0aA7HExERyXmnYhMJ8PXk8zWfs3L/St7t/C4BPgFOx3KcilG5VaGK4F+DUslzeOYZGDfO1aspp40bB82awZkzMG8evPACuOm7RkRERC7XylrbEOgGPGmMuenSAdbaMdbacGtteMmSJXM+oYiISA6LjkuksI/hhbkvcFOlm4ioH+F0pFxBZYXcrEwnOPI7r7x0jjJlXEvkUlKy/7IJCTB/PkREwMMPQ4sWsHYt3HTZW0oRERERF2vt/tTHI8BUoImziURERJx3Ki6Bo3F7iE2MZcytYzBqugyoGJW7le0MybEUSVjGW2/BihXw1VfZc6moKBg7Fu66CwIDoX17+P57GDzYdde80qWz57oiIiKS9xljChlj/M9/DnQG/nQ2lYiIiPP2njzO4djdDL5pMDUDazodJ9fwcDqAZKJ0WzDucGgOPXu2ZdQoePFFuPNOCLjBJaYJCa674c2a5fr4M/XtYoUK8MADcPPNroKUv/8NvwoRERHJ/0oDU1P/2usBTLTW/uJsJBEREWedPnea/dEnKeLrwQstX3A6Tq6iYlRu5lkEApvBwTm4hQ5l+HBo2hT++194991rP11U1N/Fp7lzISYGPD2hdWt45x3o1g3q1AHNGhQREZFrYa3dBYQ6nUNERCQ3efm3l7EpbelSrRVe7l5Ox8lVVIzK7cp0go2vwbnjNG5cgr594aOP4JFHoFatzA9NTPx79tPPP18++6lbN+jQQbOfRERERERERLLS0n1LGblyDBXpRq1SFZ2Ok+uoZ1RuV6YTYOHwPABq3bmTgOrHePppsNY1ZOnOY4z+fSdwce+nEiWgXTv44AMoVco1++nPP2HPHvj0U7jjDhWiRERERERERLLSuaRzPDrjUcoXrg5AgJ+nw4lyH82Myu1KNHEt1zs4ByreS4taAZS8Yy2/T2jAjBmBFKt5jCe+WUujhAaMfAo2bnQdptlPIiIiIiIiIjnv9d9f56+jf/FZt5n8dwoE+KoYdSkVo3I7Nw8o3Q4OzQFraVE1kDG9G/Bg3Foe+7ginnX2cuTHBmw9GEirVur9JCIiIiIiIuKUFVErGLZkGA+FPURY6ebAMhWj0qFiVF5QpjNETYMzO8G/Gq1rBnJHvYr86L2DKnHVGP5RoGY/iYiIiIiIiDgoNjGWXj/2opx/OT7o8gGrI+MBKOqn5uWXUs+ovKBMJ9fjoTmAq0fUwgN7Gdi+GqcC91Kq/jEVokREREREREQcNOi3QWw7vo0vbv+CAJ8ATsUmAlqmlx4Vo/IC/2pQqBIcnMPSnccYMHEtI3o04NnONRnRowEDJq5l6c5jTqcUERERERERKZAWRC7gwxUfMqDxADpU6QBAdJyrGFVUxajLqBiVFxjjmh11+Dc27DvJiB4NaFE1EIAWVQMZ0aMBG6KiHQ4pIiIiIiIiUvDEnIvhoWkPUa14NYZ1HJa2/fzMqCIqRl1GPaPyijKdYOdn9K97DEpWv2hXi6qBacUpEREREREREck5z81+jr3Re1n00CIKeRVK2x4dl4i/jwfubrq72KU0MyqvKNMBMGl9o0RERERE8qXdE+DHyjDRzfW4e4LTia5NXs8vItdkyuYpjF0zludbPE+LCi0u2hcdl0hRP82KSo+KUXmFdwko3kjFKBERERHJv3ZPgJX9IHYPYF2PK/vlnYJOXs8vItdkb/ReHp7+MI2DGvN6u9cv238qNkHNyzOgYlReUqYTHFsOiTFOJxERERERyXrrB0Fy7MXbkmNd23OjS2dBrXo6b+UXkeuWlJJEzyk9SU5JZtLdk/By97psTHRcIkV9L98uKkblLWU7gU2CwwucTiIiIiIikvVi917bdielNwsq8Xj6Y3NjfhG5IUMXDmXR3kWMumUUVYtXTXfMqbhEzYzKgIpReUlgC3D3g0OznU4iIiIiIpL1/Cpe23YnpTeLKyO5Mb+IXLdFexbx+sLX6RXai4iQiAzHnY5LJEA9o9KlYlRe4u4NpW5S3ygRERERyZ9Ch7r++Hohdz/X9tzmamc75db8InJdTsadJGJKBFWKVWFEtxEZjrPWcipWM6My4uF0ALlGZTrB2ufg7D4oVMHpNCIiIiIi1+ytX7Ywf8uRdPZUgIRJEH8QUhLxcHencEBZ/BeVx3/lOgr7eODhdvHf04sX8uThVlXw9XK/9iC7J7hmOMXudc1eCh0KwRnPcriIX8XUJXqX8CqBdS988Tkr9wBrLxtqjG73LpKXpNgUev/Ym4NnDrLs4WX4e/tnODY2IZmkFEtRFaPSpWJUXlO2E6zFNTuqal+n04iIiIiIXJOVu08wasFOGlYsSmBh73RG+AFBACQmp3D2XDL7TsRy5lwSZ84lkZx8cVEn5lwSczYf4bNe4ZT0T+98GTjf8+n8Urvzd76DqytIhQ69+HjgDMV59fRYpmz3+rv2tALg58sOD/D1ZFyfxjSqVOzqM4uIo4YtHsaMbTMY3nU44UHhmY49FZcIoJlRGVAxKq8JqAc+ZVSMEhEREZE8x1rLsFmbKV3EmwmPNEt/NtOFs5WKXDBbKYNZTL9uOsTT367ljk+W8OVDjaleOoOZCrsnkLLuZWLO7CXauxxnE8+QnBBLMpBsIRnwNLH4rHgB32Kt8PHwwc/Tj8JehdOfwXS+YJWaaX1KKwbu/Rf7YtyJaFoxg0Lb375fFcXz36/n56db4+N5HbO6RCRHzd01l8HzB/NAvQcY0GTAFcefik0AoKh6RqVLxai8xhjXUr2Ds8CmgFHbLxERERHJG+b8dZg1e0/x5l31My5EpTdb6egS2D0+3VlMXepG8L/HmvPwl39wx8hF9LwpHg+fneyP2c/+mP1EnY7iwMntnIo7TkwKuCYs7c8k5QHYWjntmaebJ8V9i1PCrwQlfEtQunBpKhSp4PoIqEC5Rt+yfGshPpm3j1L+3nz3WAMa21lXXP7XuHJxIj5bwXuztzLoljrX+yUVkRywL3ofD0x+gNqBtRl729irWmIbnTYzyiu74+VJKkblRWU7QeTXcHI9FG/gdBoRERERkStKTrG88+tWqpQsxL2Nyqc/KL071CXHws4xYJPTNh1Jgj/OxrLy1ydZE/Atm49uZm/SGQIT/sPoOeU4674fD3co5FmDQl4NKJ8QRWe/KQR5HaaIGwS4QSE31y9D7gbccX0kAvGegcSFvUV8UjxnE85yIu4Ex+OOczz2BJEHg1i9tzSLEmNJtoeAQ3ik7MXb1iTJ8w9SSixk5OIkap1eTohnImHeUObsHkw6y/9aVgskomlFPlu8m671ytCoUvErfxFvpMeViFyXc0nnuOf7eziXdI4p3adQyKvQVR0XHatleplRMSovKtPR9XhotopRIiIiIpInTF4TxfYjZxgV0RAP9wxm92dwh7rIhGTmxsJvsbA8HiKTXNvdiKZ2ym4aBTUion4tggOK88vqwmw9dDNupM5cSICjsbVZFd+KTyu/QZNCmzIO6e4HTT68rMCTlJzCq9M3sfrQXsoV9cWnsBvJNoWk5ERSSKRWxUN4FDrI9pOW2XuW8mXS34Wzku4Q5h1LoxNP0KxdYZqWb0qZwmUAeOnm2izYepTnv99w5eV66c0aW9EXVj0NiSdUnBLJJv/89Z+s3L+SyfdNpkaJGld93PmZUVqmlz4Vo/Ii37Ku3lEH50CdfzudRkREREQkU/GJyXw4ZxuhFYrStV6ZjAem3qEuPgVmx8LPZ2FuHOx0/U5HkDu08oUBPtDEBxoWrUChu/+86BR9Gl5+2t2TGvPw5keI2PV/vFFuBPcW/821w7MEeBbOdKbR6fhEnpywhkXbj9G/TVVe6FITN7f0lug87HqY6MbJZNhwDtYnwLpzro93j5wm6bs7AKgUUIlm5ZtxU6WbeLJjU17+4dCVl+ulN2ssJQFSjrs+v9YG7CJyRWNWj2HUqlE83+J57qp91zUdqwbmmVMxKq8q0wm2j4SkWPDwczqNiIiIiEiGvl62hwPR8bx7X2j6vVZ2T+DMmpeYdWwfk8/AT2fhjAV/N2jr587T1ZrTMX4VtdzjSTvc3Q8avnlV1w9u9gxTU/7Jk7sH8nzUP9lxrgIvlPse9/CPMi3cRJ2Mpe+Xf7Dr6FmG3VWf+5tUvPLF/CpSLHYPbfygzQVv0+N8KrAmfBIr9q9gedRyFu9dzHebvgMgyPtZxi5qR7Rdzn1hLQguGuw6aO9k2PQGxEXh6nZVhNgUX3bEV2DHuQpsT32MSb7gQlvi8Cy6iHsaladH04pqji5ynebvns+TPz9Jt2rdeKPDG9d8fHRcIp7uBr/0+uOJilF5VtnOsPUDOLIQgro6nUZEREREJF2n4xP5ZMEObqpRkhZVAy/al2JT+H35YMYtf4vJMcnEWdeytgf84e7C0K5ERbwavJHp3fSuSnAEAcAXvoN5bWc3Pj16D4vtHZSILQvzV2Z42Kb90SQkpzC+bxNaVgvMcNxFQodevJwOwN0P3wZv0rJiS1pWbAm47iy4+9RuFkQuYO7OxSxZc4L/LS7N/xbvBHamHhgAvJXhpQI9TlLVO4rqPvsu2n7Qszavz/yLsYt2MbBDde5pVB7PjJZGishldpzYwT3f30P14tWZdPckPNyuvXRyKjaRAF/Pq2p2XhCpGJVXlWoD7j5wYJaKUSIiIiKSaw2fu51TsYm80KVm2rao01F8ue5Lvlj3BbtO7iLADXoXgfsLu5bhuRvArxLcEfn3iYIjbmz5WXAEnsER/Ndaaq3Yy+Q1UZxOXUaTkbrlAhh8S22ql/a/pusAVyycGWOoUqwKVYpVoW+Dvuxrf5bvVv/F5mN/sfnYFrYd3cg56/qFrboX1E/9KOORSFWfKKp576OYR8zl1/erBHe8yZIdx3jn1628NGUjo3/fyUvdame8RFKN0UXSnIo/xW2TbsNgmPHADAJ8Aq7rPKfjErVELxMqRuVVHr5Qqh0cnAV85HQaEREREZHLbIyKZtyS3UQ0rUi9cgGsPrCa95e/z/82/Y+klCTaB7fnda9d3FUYfC+duJNBM/MbZYyhZ7NK9GxW6doPvtqizXUUzioUL8S/OjUGGgOQMMGwNA5mnoUZZ2FcPBAPIV5wF3C3bwBF8cCQ9PdJ3P1cmXDdra9F1RLM23KEd37dyhMTVvO/x5oTXvmSu/al1xhdvaekgEpKSeL+H+5nx4kdzH1wLlWLV73uc52KS1AxKhOaq5mXBXWDmO0Qs/PKY0VEREREstruCfBjZZjo5nrcPSFtV1JyCi9O2UBgYW/qV91N2y/bEj42nBlbZzCwyUB2DtzJb71+I6JMpcsLUeAq9uQm54s2sXsA+3fR5oLXnJW8ClWirR+8WxK2VoYtleCdQCji6c1rJwz1d0ZT63AgL0cXYW08WN+K0GTMRQUkYwwdapfm+/7NqVDcj6e/XZd2u/k06TVGT451bRcpQKy1PPPLM/y681dG3zKaNpXbZPoz7kpOxSZS1M8r2/LmdSpG5WVB3VyPB2Y5m0NERERECp4rFGfGLdnNpgOnifH+nAem3s7uU7t5r/N77PvnPt7r8h5VilVxnSd0qGtGz4UumOGTa9xI0eZ6fqG95OtS0wv+FejHors/Z/+z+xl580gqlKjL20fP0nAf1N7vy5A929lybMtlp/L38WT4/Q04fDqeF6dswFr7986MZqBl08w0kdzqrSVv8ckfn/Cv5v/i4YYP33ABOjoukaKaGZUhFaPyMv9qULha6lI9EREREZEclEFxxq57mS9Xz+SNWRuIdVtOsvcavrnzG3YO3MmzzZ+9vP9KcIRrRo9fJcC4Hi+Z4ZMrXG/R5np/oc3k61LWvyyPN36cub3mcuhfhxhz6xiC/IN4/ffXqf1JbcJGh/HOknc4EHMg7XShFYryfJeazPrzEJNWXtDwPKMZaLltZppINvpy3Ze89NtL9Kjfg7c6pd404AZnDUbHJlJExagMqWdUXhfUDXZ+BsnxrobmIiIiIiI5IZ0izPI4eGbvXnb/sRpf6vHKLTV4ovmmK9+J6kabk+cEv4qpBaV0tmcms19or/Sar+LrEugXyKONHuXRRo9yMOYg3//1PRM3TuSFuS/w77n/pkOVDjwY8iB31b6LR1tXYfGOY7w2YxPhlYtRo7R/hnf/y3Uz00Syyazts3hk+iN0rNKRL27/AjeTOmfnBmYNJiWnEHMuiaJ+KkZlRDOj8rqgbpAcB4d/dzqJiIiIiBQkFxRh9ifBg4egeRRExbfDNyWcwbeEMbDlg9d1S/Rc6XqXE+bgMriy/mUZ2HQgyx9ZztYBW3nlplfYeWInvX/sTZl3y/DwjL7c2yKOwj4eDJy0lgOn4jhS4m6O1B3LEY/6HEks7nqsO9a1/XQ8SckpV3fxG+itI+KUlftXcs/39xBaJpQp903By/2CHk83MGvwdLzrxgJqYJ6xfPJ/hgKsVFvXjKiDsyCoi9NpRERERCQ/ueDucZttMx7e/RLnbOps/OSPsUkxxKZYYlPAAjXcIJkA6lYoSp8WVRyNnuXOz1C6mrvpXeh6Z1TdoBolavB6u9d5re1rLNm3hPHrxvPtpm/5ct2XBPvewvFDj9Ni2LzU0QHAm38fvAbgNwDKF/Plv3fUo13NUhlfTHfkkzxo67Gt3DLxFkoXKs1PPX7C39v/4gE3MGswOs51owDNjMqYilF5nYevqyB1YBY0+tDpNCIiIlJAGWO6Ah8B7sBn1tphDkeSG3VJgeHjvW2IiY3n9lqJUKQ6B04fYMHuNUQnxBLsAy0KF6JIqeZ4Fgumb8tg3N2Mwy8gG1zPckKHl8EZY2hVsRWtKrbiw64fMnnzZMatHcfyMy/hZctTr1Q9WlVsRf1S9XFzu3jhTFKy5atlkTz0xR/cGlKW/9xWh1LHJl9ekLuRpYgi2eGCQnp6heMdJ3bQ/qv2uBk3fu35K2UKlyE+MZlRC3ayas+J1FFVIW6C6+71KfHg5gP+VeG3MsDyTC9/5lwyoJlRmVExKj8I6garn4Yzu6BwPvsLlIiIiOR6xhh34BOgExAF/GGMmW6t/cvZZHJDLigw7DoXxKzoFjxR6nv6FVrAvz1u5ovdn1KlWBW+vWU0nap2cjhsLna9M6qyQSGvQvQK7UWv0F7sPLGTcWvH8cW6L1i27h3K+hblIf8UHvU7TeWASmkZ729SgU9/38WIeTv4fcsBXiz9P3oU3YMx/D0D6tJC1Hm6I5844Qoz9fac2kOHrzpwLukcC/osoHqJ6qyKPMELkzew6+hZQsoH4OWeWpj1KAXFLpkVmHjlpaueboabapQkpHzRrHtd+YyKUflB2W7A067ZUTWedDqNiIiIFDxNgB3W2l0AxphvgdsBFaNyqyvMGgAuKiSMOXo3XiaR8r4zqLvlFAeTx/Jss2d5vd3rFPIqlMPh86Bc2KC9avGqDO0wlNfavcZPi17gsz8+YtiRFN4Euvrtof+xvtzcLhnvqr0Y2KE6t4aUZdDYMQza1w9SEogo8YvrRMmxYNzBJl9+Ed2RT5yQyUy9qBJtaDe+HafPnWZer3kEB9RiyPRNjF8WSVChFL6q9Qk3ec12tGhcUOSrBubGmCrGmM+NMT84nSVHFakOhau6ilEiIiIiOa8ccMG94olK3Sa50flZA7F7APv3rIFLG06nFhIOJxZn8sn2lPSZS48jpyjq4cnSvkt5r8t7KkTlAx5uHtx+cgozglKIrAyDi8P6c3D7/gSCv+vL67+/zsGYg1QpWZiJlf5FI7+/+OTIfZxLuWBeg02+vubuItkhnRl5idadF7Z1pvV733PuyGO0LPQd78w8R4f3fmf8skh61z3H7Cq9ucnrVzL9uShZJtNilDGm5wWft7xk34DsCnXJdcYZY44YY/68ZHtXY8xWY8wOY8yLANbaXdbah3MiV64T1A0Oz4PkeKeTiIiIiKTLGNPPGLPKGLPq6NGjTscpuDLr73Oh1LvHvXnodhKtGytSpvBicQ/W3D2WpuWb5lxeyX6pv7xX8ITXSsCeYJhaFup4JvPqglep+GFF7vv+Pn63pXiq1LccSCzFDyc7/n28XyVoMsb1iPn7uWaViBMumZGXYg1P7X2a/524nYQkqFcqFF+PwiQmp1CzjD/fP9acIYWfpRAnLz5Pej8XJctcaZnes8A3qZ9/DDS8YF9fYER2hLrEl6nX+er8BvUlSEfZbrBtBBxZCGU7O51GRERECpb9QIULnpdP3XYRa+0YYAxAeHi4zZlocpmM+vhcsj2l8gO8uX4OU052A49FzK4O7Vp+qQJDfnTJHf88DNxRGO4oVYkdN81l9KrRjFs7ju/jT1LL8whlvbYw4sh93FtsLl6eXn8vZ9L3huQGF9w0wFp4Yf/D/BLdnlivSXzf91HaVG5z+TFLr+7nomSdKy3TMxl8nt7zbGGtXQicuGRzWl8Ca20CcL4vQcFVui24eWupnoiIiDjhD6C6MSbYGOMF3A9MdziTZCSjPj4XbD8ee5xbJt7C26ticcOPb/s+Rbueh1RsyK9SZ8FdJHWZXbXi1Xi387vsf3Y/X9z+BYWLVGYdkziYWIp79t/MlppD9H0huUtwRNpMvdcO3ssPJ+7gnNdPTH90QPqFKLiqn4uSta5UjLIZfJ7e85yUbl8CY0wJY8xooIEx5qWMDs6XU8Q9/FwFqYMqRomIiEjOstYmAQOAX4HNwP+stZucTSUZyqTwALDu0DrCx4Yzb9diyrn3pE2NkrSool/I8rULfnnPaJmdr6cvfcL68MeAXSzo9wn+hY6z5tTt1P7xJTp93YlpW6aRnJJOE3MRJwRH8JbfBL481psk76XMeuIxmlVolvH4K/xclKx3pWV6tYwxG3DNgqqa+jmpz6tka7LrYK09DvS/inH5c4p42W6w5hk4sxsKBzudRkRERAoQa+3PwM9O55CrcL7AkM7d9CZsmMCjMx6luG9xXgmfwee/n+XxtlWdzSs54xqW2TUt35SP7q1M3y9X8WD1j5l/5A3u+O4OKhetzBPhT/Bww4cp7ls8mwNLXjdvy2G+WBKJzYbfyE/GneLP/QngtYlfn3iQuqVrZX5AJj8XJXtcqRhVO0dSXLur6ktQ4ASlFqMOzIIaTzidRkRERERyq0sKD4nJifxr1jOMWv4jdYo8Tq3Cd/DNkjM0qFiUpsEqKsjl2tUsRf1yAUTur8X2f+5k5vbpfLzyY16Y+wKvLniVniE9earJU9QvXd/pqJJLfTR3O3tOxFK1ZOEsPe/x2ONsO74Nb7/TzHq8N7VKXuU8GvU9y1GZFqOstXsufG6MKQHcBOy11q7OzmBXkNaXAFcR6n6gh4N5cgf/6lC4iopRIiIiBZwx5ingG2vtySsOlgJn++EYhszYxMmziQAk22QiT+0mNj6cIDpx6igcJZkHmlSkb8tgjMmRVrGSxxhjGNihOo9+tYqZG45wT6N7uKfOPaw/tJ4RK0fwzYZvGLtmLG0rt2Vgk4HcVvM2PNyuNBdCCoq9x2NZHxXNyzfXot9NWTP70lrLB8s/4F+z/0Wzqs2Ydv80ShYqmSXnlqyX6U8DY8xM4EVr7Z/GmLLAGmAVriV7Y6y1H2Z3QGPMJKAtEGiMiQJetdZ+bow535fAHRinvgSAMa6leru+gOR4cPdxOpGIiIg4ozSuuw2vAcYBv1qbHQshJK/5eeNB/vX9evy83AmrUIz4pDiWR/1BTGIMTSuF0LNxCK2qBRJU1NfpqJIHdKxdirpBRRg0dSPv/Lrlgj3dqcu9xNpYdm09y1ObY3jG/Uv6tD/N0y36aAmfMHPjAQBurl82S86XnJLMM788w4g/RnB37bv5+s6v8fXUz7HczGT2vsQYs8laWzf185eBWtbaXsYYf2CJtTYkh3Jmm/DwcLtq1SqnY2Sd/T/B77dCu9lQtpPTaURERBxnjFltrQ13OkdOM67pLJ2Bh4Bw4H/A59banY4GS5Xv3oPlcskplndnb2XUgp00qFiUURGNOBS3hVsm3kLMuRgm3zeZTlX13lGu3YaoU0xauTfDvj8pNoU9p/ayYoc7pzy+IcF3GhH1I3iq6VOElM7zv07Kdbr5o0V4e7ox9YmW137w7gkX9XaKqfMKPdfMYPrW6TzX/Dne7vQ2buZK92qTnJDZe7ArzZNMvODzDsBYAGttjDEmJYvySVYq3Q7cvF1L9VSMEhERKbCstdYYcwg4BCQBxYAfjDFzrLUvOJtOssrp+ESOn0nIdExicgr/nfkXi7Yfo0fTirx6Wx3mR87h3u/vpahPUZb0XaK+PnLdQsoXJaR80SuMCqPnZyvYerg3YfX9+Wbj13y29jPaVGrDU02e4vZat2sJXwGy6+gZ/jp4msG31rn2g3dPgJX9IDkWgG2n9nDn5H5sSYSPu33MgCYDsjitZJcr/Re/L7XnQBTQEPgFwBjjC3hmcza5Hh5+UKoNHJwFvO90GhEREXGAMeZpoBdwDPgMeN5am2iMcQO2AypG5QPWWjq/v5BDp+OvONbL3Y1hd9Xn/iYVmbhxIr2m9qJ+0fL8VDaJoN9CdecoyXb3N6nAgInHiKj5fwzr+Cafr/2cT/74hHu+v4cKRSrwROMneKThIwT6BTodVbLZzA0HMQZuuZ4leusHpRWiZpyBnofBy1jmBJeivQpRecqVilEPA68DHYHu1tpTqdubAV9kYy65EUHdYM0/4UwkFK7sdBoRERHJecWBuy69GY21NsUYc6tDmSSLHY05x6HT8dwXXp4WVTP/Bb5uUBGql/ZnzOox9J/ZnzalazG9SCT+iXGuAbF7XLMNQAUpyRad6pSmeCEvvl25j7Y1G/FCyxd4rvlzzNg2g49XfsxLv73EkAVDeKD+AwxoPIBGQY2cjizZZOaGAzSuVJwyAdfR4zh2LykWXj8Br52ARt4wuSxUcj+a9UElW13pbnpHgP7pbJ8PzM+uUHKDzhejDs6C6o87nUZERERymLX21Uz2bc7JLJJ9dhw9A8A/QsvRqvqVZ5O8t/Q9/jXnX9xc/WZ+8NmIb3zcxQOSY12zDlSMkmzg7eHO3Q3L8cWSSI7GnKOkvzfubu7cUesO7qh1B5uObGLEyhF8veFrvlz3Jc3KN2NA4wHcU+cevD28r3yBS/oIaaZf7rTtcAzbDp/htX/Uva7jj3iWo09kFLNiobc/jCoFvm64/s0lT8m0q5cxZnpmHzkVUq6Rfw0oFOzqGyUiIiIi+dKuo2cBqFqqUKbjrLW8tuA1/jXnX9xb516mdp+Kb3xU+oNj92Z1TJE03RtXJCnF8sPqy7//6paqy6hbR7H/2f181PUjTsSdoOfUnlT8sCKDfhvE3uhMvjfP9xGK3QPYv2f67Z6QfS9GrsvMDQdxM9CtfplrPvbXHb8SsiuGeXHwSUn4onRqIcrdz1V8lDzlSi3mmwPlgUXAu8B7l3xIbmSMa3bU4XmQfM7pNCIiIiKSDXYePYOflztlimS81MVay4tzX2TI70PoE9aHiXdPxMvdK+NZBJpdINmoWqnCNKlcnO/+2EtGd3UP8AlgYNOBbH5yM7/2/JXm5ZszbMkwgj8K5vZvb+fXHb+SYi+5l9YFfYTSnJ/pJ7mGtZaZGw7QNLgEpfyvfoneuaRzPPfrc3Sd0JVA//L8ceubPBFUCWMM+FWCJmM0Cy4PulIxqgzwMlAP+AjoBByz1v5urf09u8PJDQjqBkln4egip5OIiIiISDbYefQsVUoWcv1CloHB8wfz9tK3eTz8cT7/x+d/37EsdKhrNsGFNLtAcsD9TSoQeTyWZbuOZzrOzbjRuWpnfrz/R3Y/vZuXWr3E8qjldJ3QlRof1+DtJW9z9Gxqn6CMZvRppt+12T0BfqwME91cj1k8s2zzwRh2HT3LraFX37h805FNNP+8Oe8vf58nGz/JH4/+Qf2GL8IdkdAjxfWoQlSelGkxylqbbK39xVrbG1fT8h3AAmOM2tTndqXbgZuXluqJiIiI5FM7j5yhasnCGe7/v4X/x9BFQ3m04aOMuHkEbuaCt/7BEa7ZBH6VAM0ukGyQQWHj5vplKeLjwbcr913xFInJKWw7HENcXDEerPNv5j7wF++3/5aS3qG8Mnskld9twe1f92dCbAO2xFVia/zfH2eSfTXT71rkwFLHmRsO4O5m6Fr3ykv0EpITeG3BazT4tAH7Tu9j2v3TGHHzCHw9fbMsjzjrSnfTwxjjDdwCPABUBoYDU7M3ltwwj0JQqo2rGNVQKypFRERE8pO4hGT2n4qje8kKl+/cPYF35gxg8MFT9C5WiNF1W19ciDovOELFJ8ke5wsb55fOXXC3Rp/gCO5sUI5JK/dx8mwCxQp5XXb40U0TmTR/IRMOteBwUolL9hYG+hJEXwDWb4L13HbZOUp7nmB6d3dKZ+Xrys8yW+qYBT8nXEv0DtKiaglKFM68If3K/St5ePrD/HnkT3rU78GHXT6kZKGSN5xBcpdMi1HGmK9wLdH7GXjNWvtnjqSSrBHUDdY8C2f3QKFKTqcRERERkSyy+1hq8/JLZ0btnsDwXx7ihSOJ3F8YPi9xFrc/+oNxU+FJcs4VChvdG1dk/LI9fLZ4F10umCVzJj6JH35fxMwdfiTY27ip8GpeKDYeX3cL1ftDqdaXXepc0jmWRS1j7tYpbD19EDegkW8RDp7pT//fi/NtrWS8Pdyz+QXnA9m81HHh9mPsPRHLk+2qZjjm9LnTDFkwhI9WfETZwmWZ8cAMbq1xa5ZcX3KfK82M6gmcBZ4GBl6wHt0A1lpbJBuzyY0q2w141jU7qnp/p9OIiIiISBbZefQMcPmd9MbNe5qnjyRyVyH4qgy4G7J0doPIVblCYaNOUBHCKhTlk/k7+WT+zouGFHJL4YHic+hVYiZVffb/vSNmF3SITPe0dzaoDLc9wF9H/+LzNZ8zfv14Yt1PcW7fIG4eOZ5RPVpRI7BGFrywfMyvYuoSvXS236DYhCQGTd1IlcBC3B5W7rL9KTaFL9Z+wcvzXubI2SP0a9iPtzu9TYBPwA1fW3KvTItR1torNTjPs4wxtwG3VatWzeko2adITShUWcUoERERkXxm59EzGAOVS/xdjJq5bSb9oo7T2Q8mlQXPC/uaq5Gz5KSrKGyMebARG/dHX7Tbzc0QvjIYf/fYS4+8qu/hOiXr8F6X93ijwxvM2DaDYb+sYueBcBp99AxhVWLoHdqbe+vcqyJHekKHXry0ErLspgbvz95G1Mk4vuvXDB/Pi2epLdm7hKd/eZrVB1fTvHxzZj4wk8blGt/wNSX3y7fFpiux1s6w1vYLCMjHP4iMcS3VO/wbJJ9zOo2IiIiIZJGdR89Svphv2i92y6OWc9/399HA14vJZcHr0hvsqZGz5KSruFtjqSI+dKhd+qKPdjVL4e+fQW+ga/ge9vbw5p4697Dymf/QsloRSiY9waEThXh0xqOUea8M3X/ozsxtM0lMTryeV5c/ZdNNDdbvO8W4JbuJaFqRplX+7v+16cgm7vnfPbT6ohWHzhxiwl0TWNJ3iQpRBUiBLUYVGGW7QdJZOLrY6SQiIiIikkUuvJPelmNbuGXiLQT5B/HTrR9Q2DPzIoBItruRwsZVFLKulpubYVTPZlQOLEyRuOcY3Gg+7Uv+l4V/edDj67FUGHYzj898gkV7FpFiU675/Hlaenc7DI6AOyKhR4rr8QYLUQlJKfx78gZK+nvz7261ANh2fBs9Jveg/qj6zN45m1fbvMrWAVvpUb8HF7QFkgLginfTkzyuTHtw83It1SvTwek0IiIiInKDUlIsu46doXnVEhyIOUDXb7ri4ebBrz1/pVTxquAb4OoRFbvXNZskdKj6RUnOu967NZ4/Jou+h4v4eDLmwXC6f7qMrxafBWrjTW28ARJh0uqhjF49inL+5ehetzv31b2PJuWa5O/CSHp3O1z2IBxdAk1GZtllxizcyZZDMYztFU5UzHbe/uVtvt7wNT4ePrzQ8gWeb/E8JfwuvVuiFBTGWut0BkeFh4fbVatWOR0je83rBHEH4JZNTicRERHJccaY1dbacKdzyMUKxHuwbLL/VBwth83jP7dVZ/jG+9hxYge/9/mdRkGNnI4mkmslJKUQl5ic9jw5xXLXyCW4uUHfjof4fvO3zNo+i8SURMoXKc9dte7i7jp307JCS9zd8tnd+H6snH5PLww0/zpLitc71kzi5u99CSm0jFi/4cyKicfHw4fHwx/n3y3/TenCpW/4GpL7ZfYeTDOjCoKy3WDtc3B2LxRSvwARERGRvGznEded9CZsfo+NRzbyU4+fVIgSuQIvDze8PC7uUvNit9r0/2Y1xLVg2v0PcDLuJDO2zWDy5sl8uvpThq8cTqlCpbi1+q3cVvM2OlXpRCGvQhlcIXf7bNEuPpizjaQUC8nvZzxwowH3WTd2MZtMQnIhMLFMTRpDydh4/hvoSf/2HxBYWzfWEhcVowqCoNRi1IFZUP0xp9OIiIiIyA3YedRVjFoQ9T8+7PYhXat1dTiRSN7UpW5pmgQX54M527g9LIhivsXoFdqLXqG9iDkXw8/bf2bKlin8sPkHxq0bh7e7N+2D23NrjVvpUrULVYtXdfolXJUZ6w/wfz9tplW1QOqWKwLbRkPS6YwPqPPCtV/EwoGY/Ww4vIHNRzeSaKCs91I+CzzFA/7g45YIW4eBilGSSsWogqBILShUCQ6qGCUiIiKS1/28eTXJJPNoo/sZ0GSAa+PuCeoTJXKNjDG8cktt/jFiCSMX7OTfXWul7fP39qd7ve50r9edhOQEFu1ZxIxtM5ixbQazfnbNHKparCqdq3amS9UutKnchqI+RR16JRlbvecEz32/nsaVi/F5n3C8PdyhVhNXjyjSadnjVwm6fXFV57bWsunoJib/NZlvN33LlmNbKORZiO7Fz/JwEWju47rBe5rYvVnymiR/UDGqIDDGtVQv8htITgB3L6cTiYiIiMh1WLJ3CYt376CIbwk+vnm4q8lyes2IV/Zzfa6ClEimQsoX5a4G5fh88W4imlakfDG/y8Z4uXvRoUoHOlTpwAddPmD7ie38uuNXZu+azVfrv2LUqlG4AWHe0Mbfn7b1H6F148EU8y2W8y/oAnuPx/LoV6sJCvDh0wdTC1Hg+rlwdAnsGM1FBamruGthckoyaw6uYeqWqUzePJltx7dhMLSq2IoX/vEC99a9l8I/10u/J5WfWsbI39TAvKA0z4yaDgtvh/a/ue6wJyIiUkCogXnuVGDeg2WhyFORNBnbBL+TH3JbSDU+vr+Ja0dGzYj9Krluzy4imTpwKo527y6gS90yDH+ggWvjVc42PLfjS5Yt7M+Cs+dYEAfL4+Fc6q/YtQJr0ax8M5qVa0az8s2oW6ouHm45Mx8kOjaRO0ct4cTZBKY83oIqJQtfPugqX+Ouk7uYs3MOc3fPZd7ueZyIO4G7caddcDvurn03d9S6gzKFy1x83gsL5OAqdDUZowJ5AaMG5gKl24Obl2upnopRIiIiInlKXGIcd313FwlJ7vilBFCnzAW3Q89o6YuWxIhclaCivjzaugoj5u+gS90yVIj/HTYNg2RPoCrEAguGwVF3CLqkR9vycRRPqcBdvnCXr6sQtSkB/rLubC5ejZnbZvLlui8B8PHwoV6peoSWDiWsTBihpUOpXbI2JXxLuGY5XoXth2OYuHIvCUkpmY5bH3WKfSdi+ebhplQ5Mw2WpFN0Ov9xgej4aFYdWMXK/Sv548AfrNy/kv0x+wEoX6Q8t9e8nQ7BHeharSsl/Eqkd+m/z6mlw5IJFaMKCs/CULK1q4l5g3ecTiMiIiIi12DAzwNYe2gtIzrO4J0ZULXkBXf08quoJTEiN6h/26p8t2ofT05cA/gDwy4ftBVgySUb/53hOTsULsWinjXx8jnGsn3LWHNwDesPr2fa1ml8vvbztHHFfIpRM7AmNUrUoFqxalQIqECFIhWoGFCR8kXK4+vpS3xiMiPm7eDThTtxMwZ/n8x/lfd0d+O9+8Joan65aJaSPbuH08seJepUFPuLNGDHiR1sObaFzcc2s+XYFqJOR6Wdo3rx6rSt3Jbm5ZvTqWonqhevftVFs/QKXSIXUjGqIAnqBmv/BWf3QaEKTqcRERERkavw2ZrPGLduHINaD6Ksbxiw/uIlN6FD018Sc4XeLyLyt8LeHvz0VCs27o+G3/9Bus29MdBm+sWblj8M545cNnJLchijI++m2/BF3N2wPP/sdBcRIa7ijLWWAzEH2HB4A1uPb2Xrsa1sO7GN33b9xlcxX112rmKmBUXOPQrJJSlSdDM1Kv9JgK87Ph4++Hj44Ovpi7txJ9kmk5ySnPY4c+93TNg5gdOJsUSnwPFk2J8EZ20cbH8x7fz+Xv7UCqxFu8rtqBVYi/CgcMKDwinuW/xGvqQimVIxqiA5X4w6OAuq9XM6jYiIiIhcweoDqxnw8wA6VenEa21f4/052/FwM1QqcUGTZS2JEckSpYr40KGID2w9nHEfttqlL97m80C6xeAOTZ4monQ7Ri7YyZdLI5m+/gBNg4vj7nbhzKISQAugBRWACsUgpWgK8UnxxCXGEZ8Uz+n4BA6fLIyP92lKVZxKvNsG1h89mbY/PimeuKQ4UmwKbsYNd+OOu5s77sadwl6FCUiIJcANAtygvDfcXAjKeUB5DyjXdSFVilUhyD/o6mc8iWQRFaMKkiK1XW9ODqgYJSIiIpLbnYg7wd3/u5tShUox8e6JuLu5s/PIWSqW8MPT3e3iwVoSI5J1rmW2YSbF4KLAyzfXplfzSnz82w62HDp9lQE8cMMfP3d//AobHmhUkv5tquLj+cAFTccPpF7rIwiOwFqbfkEpsxscVGp9lXlEsp6KUQWJMa7ZUZETIDkB3L2cTiQiIiIi6UixKfSc0pODZw6y6KFFBPoFArDr2BmqpndXLBHJOtc62/AKxeDyxfx4656QG8916V3qYve4ngMmo+trGa/kUm5XHiL5SlA3SDoDxy5tvCciIiIiucU7S95h1o5ZfNT1I5qUawJAUnIKkcdiVYwSyQnBEXBHJPRIcT3mhpmH6wddXFQC1/P1gzI+JjgCmoxxzYTCuB6bjMkdr0cKNM2MKmhKtwc3T9dSvdLtnE4jIiIieZwxZgjwKHA0ddPL1tqfnUuU962IWsEr81/hvrr38Vijx9K2R52MIyE5hSoX3klPRAqO2L3Xtv08LeOVXEgzowoaT38o2dpVjBIRERHJGh9Ya8NSP1SIugHR8dE8MPkByvmX49NbP72oB8zOo2cANDNKpKDyq3ht20VysQJbjDLG3GaMGRMdHe10lJwX1A2i/4Sz+5xOIiIiIiKprLU8/tPj7I3ey8S7J1LUp+hF+/8uRmlmlEiBFDrU1e/pQur/JHlUgS1GWWtnWGv7BQQEOB0l55Xt5no8+IuzOURERCS/GGCM2WCMGWeMKeZ0mLzqq/VfMenPSQxpO4QWFVpctv/P/acpXcSbon66CY1IgaT+T5KPqGdUQRRQB/wquJbqVXvU6TQiIiKSyxlj5gJl0tk1CBgF/BewqY/vAX0zOE8/oB9AxYpaVnKhbce38eTPT9KmUhteavXSZfuttSzfdZxmVUo4kE5Ecg31f5J8QsWogsgY11K9yEmQnADu+uuaiIiIZMxa2/FqxhljxgIzMznPGGAMQHh4uM2adHlfYnIiEVMi8Pbw5pu7vsHdzf2yMbuOneVIzDmaV1UxSkRE8r4Cu0yvwCvbDZJi4NhSp5OIiIhIHmaMKXvB0zuBP53Kkle9ufhNVh1Yxae3fkr5IuXTHbN813EAzYwSEZF8QTOjCqoyHcDN07VUr3Rbp9OIiIhI3vW2MSYM1zK9SOAxR9PkMWsOruG/C/9Lj/o9uKfOPRmOW77rBKWLeFO5hF+GY0RERPIKFaMKKk9/KNkKDs6CBm85nUZERETyKGvtg05nyKvOJZ2j19RelCpUihHdRmQ4zlrLsp3HaVWtBMaYHEwoIiKSPbRMryAr2w1ObYTYKKeTiIiIiBQ4/5n/HzYd3cRnt31GMd+Mb0K48+hZjp05pyV6IiKSb6gYVZAFdXM9HvjF2RwiIiIiBczSfUt5Z+k7PNrwUbpV75bp2GWp/aLUvFxERPILFaMKsoC64FfetVRPRERERHLE2YSz9P6xN5WKVuK9zu9dcfzyXccpG+BDxeLqFyUiIvmDekYVZMa4lurt/Q5SEl0NzUVEREQkW70y7xV2nNjBvF7z8Pf2z3SstZYVu47TunpJ9YsSEZF8QzOjCrqgbpB4Go4udTqJiIiISL63cv9Khq8cTv9G/WkX3O6K43ccOcOxMwk0V78oERHJR1SMKujKdADjoaV6IiIiItksMTmRR6Y/QpnCZRjWcdhVHbM8tV+UmpeLiEh+omJUQedZBEq2ggMqRomIiIhkp3eXvsvGIxsZefNIAnwCruqYZbuOU66oLxWK+2ZzOhERkZyjYpS4luqd2gCx+51OIiIiIpIvbTu+jdd+f4176tzD7bVuv6pjrLUs33WCplWKq1+UiIjkKypGiasYBXDwF2dziIiIiOQ3uyeQMrUS/T6viY9NYHidNld96LbDZzhxNkFL9EREJN9RMUogoB74ltNSPREREZGstHsCrOzHuEN7+T0O3g20lP3z367tV+F8vyg1LxcRkfxGxSgBY1yzow7NgZREp9OIiIiI5A/rB3HkXCzPH4O2vvBwESA5FtYPuqrDl+083y/KL3tzioiI5DAPpwNILhHUDXZ+BseWQambnE4jIiIikvfF7uXfx+BsCowq5fr7H0D8mYPsORRDirUZHmotrNh9nA61S+dQWBERkZyjYpS4lOkIxsO1VE/FKBEREZHrkpJiOXb2HAB/xJXnq9MxDAhwZ398FX48XodVZ+uwIa4GCX8uvKrztaymJXoiIpL/qBglLp5FoGRLVzEq7E2n04iIiIjkSa/P/Isvl0amPhtFBWBaPEwDPE0i9X138FCp2dRt/wpe7pnfIc/bw53W1QOzObGIiEjOUzFK/hbUDda9CLEHwC/I6TQiIiIieUpScgrT1u2nSXBx/N1n8789K3gsABp4W6p6RxHmtw0ftwTAQOhIp+OKiIg4psAWo4wxtwG3VatWzekouUfZrq5i1MFfoGpfp9OIiIiI5Ckrd5/gZGwidzYqSv9Zr9GyiOWdsn/3ikrjV9GRfCIiIrlFgb2bnrV2hrW2X0BAgNNRco+iIeAb5FqqJyIiIiLX5Oc/D+Lr6c7MyLeJt5aPS6ZTiAIIHZrj2URERHKTAluMknQY45oddWgOpCQ5nUZEREQkz0hOsfy66TD1KhgmbvqS50sWobpXOgO9SkBwRI7nExERyU1UjJKLBXWDxGg4tszpJCIiIiJ5xuo9Jzkac45Np7+hYkBFXu74Abj7XTzI3Q8afeRMQBERkVxExSi5WJmOYNy1VE9ERETkGsz68yDubpYtZybzdse38aveF5qMAb9KgHE9NhmjWVEiIiIU4AbmkgGvohDYAg7OgrA3nE4jIiIikuulpFh+3niABI91NK/YgPvq3ufaERyh4pOIiEg6NDNKLhfUDU6ug7iDTicRERERyfXWR53i8OkETtr5fNDlA0y6XctFRETkPBWj5HJB3VyPB35xNoeIiIhIHvDd6q1YErk1pBJNyjVxOo6IiEiup2KUXK5oKPiWdS3VExEREZEMWWuZujaSBPc/ebfL607HERERyRNUjJLLGQNlu8LBOZCS5HQaERERkVxr4pqFnEvwp12tAMoXKe90HBERkTxBxShJX1A3SDwFx5Y7nUREREQkV0qxKQydMwtLMm/f2tPpOCIiInmGilGSvjKdwM0b9kxyOomIiIhIrvTtxu+Ijg6mSukUyhcr5nQcERGRPMPD6QCSS3kVhYr3we6vIewt8CzsdCIRERERRz397VrmbT4CgAXOJHjhacvzULM6zgYTERHJYzQzSjJW/XFIioHICU4nEREREXFUUnIKv/x5iKqlCnNveAVqVjjOabdf6BIKdzWs4HQ8ERGRPEXFKMlYYDPXnfW2jwJrnU4jIiIi4pjI47GcS0rhwWaV+GfnCiw6+QyhNXYw+v6bKeytxQYiIiLXQsUoyZgxrtlRp9arkbmIiIgUaFsOnQagVll/3l/2PkdjjzKswzCMMQ4nExERyXtUjJLMVY4AD3/X7CgRERGRAmrLwRjc3QwBheJ4d9m73F37bpqWb+p0LBERkTxJxSjJnGdhCH4Q9v4Pzh13Oo2IiIg4xBhzrzFmkzEmxRgTfsm+l4wxO4wxW40xXZzKmJ22HDpNlcBCvL30DeIS4xjafqjTkURERPIsFaPkyqr3h5RzsOsLp5OIiIiIc/4E7gIWXrjRGFMHuB+oC3QFRhpj3HM+XvbafDCG8iXcGL1qNA83eJiagTWdjiQiIpJnqRglV1a0PpRsCdtHg01xOo2IiIg4wFq72Vq7NZ1dtwPfWmvPWWt3AzuAJjmbLnudjk9k/6k4dsUswsPNg1fbvup0JBERkTxNxSi5OtUehzM74dBcp5OIiIhI7lIO2HfB86jUbfnGtkMxAPxx5EcGNh1IkH+Qw4lERETytnxZjDLGFDLGjDfGjDXGRDidJ1+oeA94B6qRuYiISD5mjJlrjPkznY/bs+j8/Ywxq4wxq44ePZoVp8wRm1OLUZ7eR3i+xfOwewL8WBkmurked09wNJ+IiEhek63FKGNMUWPMD8aYLcaYzcaY5td5nnHGmCPGmD/T2dc1tVnmDmPMi6mb7wJ+sNY+CvzjBl6CnOfuDVX6wv7pEBvldBoRERHJBtbajtbaeul8TMvksP1AhQuel0/dlt75x1hrw6214SVLlszK6Nlqya7dJHOGp5o9SInDv8DKfhC7B7Cux5X9VJASERG5Bh7ZfP6PgF+stfcYY7wAvwt3GmNKAXHW2pgLtlWz1u645DxfAiOAry453h34BOiEa0r4H8aY6bjeBG1MHZacdS+ngKv+GGx+B3aMhZDXnE5zZfFH4MAswDqdRERErkblB8Et3/W9LgimAxONMe8DQUB1YKWzkbLWop27SHE/wXMtnoVfG0By7MUDkmNh/SAI1oR8ERGRq5FtxShjTABwE9AHwFqbACRcMqwN0N8Yc7O19pwx5lFcs5q6XTjIWrvQGFM5ncs0AXZYa3elXvNbXE00o3AVpNaRT5ciOqJwFSjbBXaOhXqvgJun04kyt/whOPCz0ylERORqVbofUDEqtzLG3Al8DJQEfjLGrLPWdrHWbjLG/A/4C0gCnrTW5ps/Bq46sJqYs/6EVIRivsUgdm/6AzPaLiIiIpfJzplRwcBR4AtjTCiwGnjaWnv2/ABr7ffGmGDgO2PM90BfXLOcrlZ6DTObAsOBEcaYW4AZ6R1ojLkNuK1atWrXcDmh+uOw8HaImg4V73Y6TcaOLHYVour9B6o85HQaERG5Gm7eTieQTFhrpwJTM9g3FBias4lyxiuz38eNHtwbGuLa4FcxdYneJfwq5mwwERGRPCw7i1EeQEPgKWvtCmPMR8CLwOALB1lr306d0TQKqGqtPXOjF04teGVagbDWzgBmhIeHP3qj1ytQgm4BvwquRua5tRhlLax/CXzKQJ1/g4fflY8RERERucTK/StZuGsnpYAGFUq5NoYOdfWIunCpnrufa7uIiIhclexcwhYFRFlrV6Q+/wFXceoixpjWQD1cf2l79RqvcdUNMyWLuLlDtX5w+Dc4vc3pNOk7+AscXQz1BqsQJSIiItft1QWvEuBeB2OgRml/18bgCGgyBvwqAcb12GSM+kWJiIhcg2wrRllrDwH7jDE1Uzd1wNVLII0xpgEwBlefp4eAEsaY/7uGy/wBVDfGBKc2SL8fVxNNyU5VHwHjAdtHO53kcjYF1r8MhYJdOUVERESuw9J9S/llxy/UKdqRSsX9KOR9wYKC4Ai4IxJ6pLgeVYgSERG5Jtnd3PspYIIxZgMQBrxxyX4/4D5r7U5rbQrQC7hsEb4xZhKwDKhpjIkyxjwMYK1NAgYAvwKbgf9Zazdl14uRVL5loMKdsPtLSIpzOs3F9n4PJ9dByOvg7uV0GhEREcmj/rvwvwT6BZKSWIZaZYo4HUdERCRfyc6eUVhr1wHhmexfcsnzRGBsOuMeyOQcPwO6ZVpOq/64q/Cz939QpbfTaVxSEmHDYAioB5Uy/JYRkTwkMTGRqKgo4uPjnY4ieYCPjw/ly5fH0zOX3+1Vcr3VB1bzy45feK3Nm3z5axy3h5V3OpKIiEi+kq3FKMnHSrWFIrVcjcxzSzFq15cQsx1umubqbSUieV5UVBT+/v5UrlwZY4zTcSQXs9Zy/PhxoqKiCA4OdjqO5HFvLH6DAO8AOlboyTi7nlpl/J2OJCIikq9k9zI9ya+MgWr94fgKOLHW6TSu5YIbX4PA5lDuNqfTiEgWiY+Pp0SJEipEyRUZYyhRooRm0ckN23RkE1M2T+GpJk8RdcICaJmeiIhIFlMxSq5fld7g7uuaHeW07SMhbj+EvuEqlIlIvqFClFwtfa9IVnhz8ZsU8izE082eZvOh0/h6ulOxuO7OKyIikpVUjJLr51XU1ZspcgIkRDuXI/E0/PUmlOkMpds6l0NEJIv16dMHPz8/YmJi0rY988wzGGM4duwYAEOHDqVu3bqEhIQQFhbGihUrAGjbti01a9YkLCyMsLAw7rnnnhvO8+WXXzJgwAAARo8ezVdffXXZmMjISOrVq5fpeSIjI5k4cWLa81WrVjFw4MAbzidyo3ac2MGkPyfRP7w/gX6BbDkYQ80y/ri5qdApIiKSldQzSm5M9cdh1zjY/TXUHOBMhs3vw7njEDrUmeuLiGSjatWqMW3aNHr27ElKSgrz5s2jXLlyACxbtoyZM2eyZs0avL29OXbsGAkJCWnHTpgwgfDwDO8jckP69+9/3ceeL0b16NEDgPDw8GzLKXIt3lr8Fp5unjzX/DmstWw5dJqu9co4HUtERCTf0cwouTElwqF4OOwYBdbm/PXjj8KW96DC3a4sIiJZKDIyklq1atGnTx9q1KhBREQEc+fOpWXLllSvXp2VK1cCcPbsWfr27UuTJk1o0KAB06ZNSzu+devWNGzYkIYNG7J06VIAFixYQNu2bbnnnnuoVasWERER2Ax+ht5///189913ace1bNkSDw/X35IOHjxIYGAg3t7eAAQGBhIUFHRVry0lJYXKlStz6tSptG3Vq1fn8OHDzJgxg6ZNm9KgQQM6duzI4cOHLzt+yJAhvPvuuwCsXr2a0NBQQkND+eSTTy76+qX3+l988UUWLVpEWFgYH3zwAQsWLODWW28F4MSJE9xxxx2EhITQrFkzNmzYkHa9vn370rZtW6pUqcLw4cOv6nWKXK190fsYv348Dzd4mLL+ZTkSc46TsYnqFyUiIpINNDNKblz1x2HFw3B0EZS6KWevvelNSI6FkP/m7HVFJMc98wysW5e15wwLgw8/zHzMjh07+P777xk3bhyNGzdm4sSJLF68mOnTp/PGG2/w448/MnToUNq3b8+4ceM4deoUTZo0oWPHjpQqVYo5c+bg4+PD9u3beeCBB1i1ahUAa9euZdOmTQQFBdGyZUuWLFlCq1atLrt+jRo1mD59OidPnmTSpEn07NmTWbNmAdC5c2def/11atSoQceOHenevTtt2rRJOzYiIgJfX18AOnXqxDvvvJO2z83Njdtvv52pU6fy0EMPsWLFCipVqkTp0qVp1aoVy5cvxxjDZ599xttvv817772X4dfooYceYsSIEdx00008//zzadszev3Dhg3j3XffZebMmYCryHbeq6++SoMGDfjxxx+ZN28evXr1Yl3qP/yWLVuYP38+MTEx1KxZk8cffxxPT8/M/wGlwNkYFU1iSso1H/f+sjF4JFfnlsoDWLP3JBujXC0IdCc9ERGRrKdilNy4SvfDmudcjcxzshh1dp+rcXlwbwionXPXFZECJTg4mPr16wNQt25dOnTogDGG+vXrExkZCcDs2bOZPn162kyh+Ph49u7dS1BQEAMGDGDdunW4u7uzbdu2tPM2adKE8uXLAxAWFkZkZGS6xSiAu+66i2+//ZYVK1bw6aefpm0vXLgwq1evZtGiRcyfP5/u3bszbNgw+vTpA1x5mV737t15/fXXeeihh/j222/p3r07AFFRUXTv3p2DBw+SkJBAcHBwhuc4deoUp06d4qabXD//H3zwwbRiWWJiYoavPyOLFy9m8uTJALRv357jx49z+vRpAG655Ra8vb3x9vamVKlSHD58OO1rKHLew+P/4EjMues4shmlaMYTX+8CdgHg4WY0M0pERCQbqBglN87Dz3Vnve0jIe4w+JbOmev++Rpgof6QnLmeiDjqSjOYssv5JXDgmk10/rmbmxtJSUkAWGuZPHkyNWvWvOjYIUOGULp0adavX09KSgo+Pj7pntfd3T3tXOnp3r07jRo1onfv3ri5XbzC3t3dnbZt29K2bVvq16/P+PHj04pRV9K8eXN27NjB0aNH+fHHH3nllVcAeOqpp3j22Wf5xz/+wYIFCxgyZMhVne9SH3zwQYav/3pcy9dMCq4P7w8jIekaZkYdms/Xf7zHxNPJjC0F5T0BN2+o8TSlqncjwE+z70RERLKailGSNar1h60fuZqZ130p+693eivs+gJqPAWFKmb/9UREMtGlSxc+/vhjPv74Y4wxrF27lgYNGhAdHU358uVxc3Nj/PjxJCcnX9f5K1WqxNChQ+nYseNF27du3YqbmxvVq1cHYN26dVSqVOmqz2uM4c477+TZZ5+ldu3alChRAoDo6Oi0Junjx4/P9BxFixalaNGiLF68mFatWjFhwoS0fRm9fn9//4vuEHih1q1bM2HCBAYPHsyCBQsIDAykSBHNTJGr16Jq4DWNP/vn89wdt48uRaBn8Qt2nDwAQd2zNpyIiIgAamAuWSWgFpRuBzs+hZTr+2XrmmwYDO6+UPfl7L+WiMgVDB48mMTEREJCQqhbty6DBw8G4IknnmD8+PGEhoayZcsWChUqdN3XeOyxx6hatepF286cOUPv3r2pU6cOISEh/PXXXxfNYoqIiCAsLIywsLDLClnnde/enW+++SZtiR64ZnTde++9NGrUiMDAK/9i/8UXX/Dkk08SFhZ2USP2jF5/SEgI7u7uhIaG8sEHH1x0riFDhrB69WpCQkJ48cUXr1gME7lRXxzex4kUeL7YJTti9zqSR0REpCAwGd29p6AIDw+355vJyg3a+z0svg/azIRyt2TfdU6sgV8aQb3BEPJ69l1HRBy3efNmatdWTzi5eul9zxhjVltrdcvVXCY3vAdLSkmi+ls+lHVLZmmFS3b6VYI7Ip2IJSIiki9k9h5MM6Mk65S/A3zKuBqZZ6f1g8CrONR6LnuvIyIiIvna5L8mE5mQzAslvC7e4e4HoUOdCSUiIlIAqBglWcfNE6o+Agd+hjOR2XONIwvh4C9Q50XwCsiea4iIiEi+Z63lnaXvUKNEDf7R/jPXTCiM67HJGAiOcDqiiIhIvqVilGStav3AGNgxJuvPbS2sewl8g6DGgKw/v4iIiBQY8yPns/rgap5r/hxuVR50LcnrkeJ6VCFKREQkW6kYJVmrUAUIuhV2fQ7JCVl77gM/wbGlUO8/4OGbtecWERGRAuWdpe9QqlApeoX2cjqKiIhIgaNilGS96o9D/BHYNyXrzmlTXL2iCleDqn2z7rwiIiJS4Gw8vJFfdvzCwCYD8fHwcTqOiIhIgaNilGS9sp2hcBXYkYWNzPd8C6c2uO6e5+aZdecVERGRAue9Ze9RyLMQjzd+3OkoIiIiBZKKUZL1jBtUe8zVbPzUphs/X0oibPgPFA2FSt1v/HwiInlEnz598PPzIyYmJm3bM888gzGGY8eOATB06FDq1q1LSEgIYWFhrFixAoC2bdtSs2ZNwsLCCAsL45577rns/AsWLGDp0qXXnGvVqlUMHDjwOl+ViLMOnTnExI0T6RPWh+K+xZ2OIyIiUiB5OB1A8qkqD8GGwbDjUwgffmPn2jkOzuyENjNdhS4RkQKkWrVqTJs2jZ49e5KSksK8efMoV64cAMuWLWPmzJmsWbMGb29vjh07RkLC3/36JkyYQHh4eIbnXrBgAYULF6ZFixaX7UtKSsLDI/23CeHh4ZmeVyQ3Gz3nCRJTEnn6yCfw40wIHaqG5SIiIjlMv9lL9vApCRXugd3jIens9Z8nKQ7+fB0CW0DQzVmXT0TkKkRGRlKrVi369OlDjRo1iIiIYO7cubRs2ZLq1auzcuVKAM6ePUvfvn1p0qQJDRo0YNq0aWnHt27dmoYNG9KwYcO0WUgLFiygbdu23HPPPdSqVYuIiAistelmuP/++/nuu+/SjmvZsmVakejgwYMEBgbi7e0NQGBgIEFBQVf92kaPHs0HH3xAWFgYixYtok+fPvTv35+mTZvywgsvsHLlSpo3b06DBg1o0aIFW7duTctx6623AjBkyBD69u1L27ZtqVKlCsOH3+AfIESyUfyOLxi1aSq3+EF1LyB2D6zsB7snOB1NRESkQNHMKMk+1R+HPRMhchJUe+T6zrFtBMQdgJaTwJiszSciecvqZ+Dkuqw9Z7EwaPRhpkN27NjB999/z7hx42jcuDETJ05k8eLFTJ8+nTfeeIMff/yRoUOH0r59e8aNG8epU6do0qQJHTt2pFSpUsyZMwcfHx+2b9/OAw88wKpVqwBYu3YtmzZtIigoiJYtW7JkyRJatWp12fVr1KjB9OnTOXnyJJMmTaJnz57MmjULgM6dO/P6669To0YNOnbsSPfu3WnTpk3asREREfj6uu4+2qlTJ9555520fZUrV6Z///4ULlyYf/3rXwB8/vnnREVFsXTpUtzd3Tl9+jSLFi3Cw8ODuXPn8vLLLzN58uTLMm7ZsoX58+cTExNDzZo1efzxx/H0VH8/yX2+Xfg8R5LhmWIXbEyOdd0kRbOjREREcoyKUZJ9SraEgHqwfRRUffjai0kJ0fDXMCjbFUrdlD0ZRUSuIDg4mPr16wNQt25dOnTogDGG+vXrExkZCcDs2bOZPn067777LgDx8fHs3buXoKAgBgwYwLp163B3d2fbtm1p523SpAnly5cHICwsjMjIyHSLUQB33XUX3377LStWrODTTz9N2164cGFWr17NokWLmD9/Pt27d2fYsGH06dMHuPIyvfTce++9uLu7AxAdHU3v3r3Zvn07xhgSExPTPeaWW27B29sbb29vSpUqxeHDh9Nem0huYa3loyPHqesFHXwv2Rm715FMIiIiBZWKUZJ9jHHNjlr1JBz/AwKbXNvxm9+FhBMQ+kb25BORvOUKM5iyy/klcABubm5pz93c3EhKSgJcv+ROnjyZmjVrXnTskCFDKF26NOvXryclJQUfH590z+vu7p52rvR0796dRo0a0bt3b9zcLl5h7+7uTtu2bWnbti3169dn/PjxacWo61GoUKG0zwcPHky7du2YOnUqkZGRtG3bNt1jruW1iDhl4Z6FrDsHY0ul8/cxv4qOZBIRESmoCmzPKGPMbcaYMdHR0U5Hyd+Ce4JHIdgx6tqOizsMWz+AivdB8QbZk01EJIt06dKFjz/+OK3v09q1awHXzKKyZcvi5ubG119/TXJy8nWdv1KlSgwdOpQnnnjiou1bt25l+/btac/XrVtHpUqVrvq8/v7+F92p71LR0dFpzdK//PLLawstkst8tOIjSngXJqLoJdOi3P1cTcxFREQkxxTYYpS1doa1tl9AQIDTUfI3zyJQuSfs+RbOnbj64za9AcnxEPLf7MsmIpJFBg8eTGJiIiEhIdStW5fBgwcD8MQTTzB+/HhCQ0PZsmXLRbOOrtVjjz1G1apVL9p25swZevfuTZ06dQgJCeGvv/5iyJAhafsjIiIICwsjLCyMjh07XnbO2267jalTp6Y1ML/UCy+8wEsvvUSDBg0020nytF0nd/Hjlh95rPFAfJuNBb9KgHE9NhmjflEiIiI5zGR0956CIjw83J5vJivZ5OR6mBUGDd+HWv+88vize2BGDQjuBU3HZns8Ecm9Nm/eTO3atZ2OIXlIet8zxpjV1tpra54l2S4n34M9++uzfLzyYyKfjqRckXI5ck0REZGCLrP3YAV2ZpTkoGKhENgcto+Gqyl+bnwNMFDvP9keTURERK6OMeZeY8wmY0yKMSb8gu2VjTFxxph1qR+jncx5qZhzMXy+9nPurXOvClEiIiK5hIpRkjOqPw4x2+DwvMzHRW+G3eOh+hNQqELOZBMREZGr8SdwF7AwnX07rbVhqR/9czhXpr7e8DWnz53m6aZPOx1FREREUqkYJTmj4r3gXQK2X6GR+YbBrkaidV/KmVwiIiJyVay1m621W53OcS2stXzyxyeEB4XTtHxTp+OIiIhIKhWjJGe4+0CVhyDqR4g9kP6Y46tg32So9Rz4lMzReCIiInJDgo0xa40xvxtjWjsd5ryFexby19G/eCL8iSsPFhERkRyjYpTknGqPgU2GnZ+lv3/9y67ZU7WfzdlcIiIiAoAxZq4x5s90Pm7P5LCDQEVrbQPgWWCiMaZIBufvZ4xZZYxZdfTo0ex4CRcZuWokxXyKcX+9+7P9WiIiInL1VIySnONfDcp0hh1jIOWSW4Qfng+H5kCdl8Ez3fevIiIiks2stR2ttfXS+ZiWyTHnrLXHUz9fDewEamQwdoy1NtxaG16yZPbOgj4Yc5Apm6fQt0FffD19s/VaIiIicm1UjJKcVf1xiNsP+2f+vc1aWPcS+JWHGppGLyK5R2RkJPXq1bvh8yxYsIClS5dmQaIrX+fWW2+94TEi18IYU9IY4576eRWgOrDL2VQwds1YklKS6B+eq/qpi4iICCpGSU4rd6ur6HRhI/P90+H4Cqj3qqu3lIjIdRj9+06W7jx20balO48x+vedDiX6W04Vo0SykzHmTmNMFNAc+MkY82vqrpuADcaYdcAPQH9r7QmHYgKQmJzIp6s/pWu1rlQrXs3JKCIiIpIOFaMkZ7l5QNVH4dBsiNkBKcmw/hXwrw5V+jidTkTysJDyAQyYuDatILV05zEGTFxLSPmAGzpvUlISERER1K5dm3vuuYfY2FgAVq9eTZs2bWjUqBFdunTh4MGDAAwfPpw6deoQEhLC/fffT2RkJKNHj+aDDz4gLCyMRYsWXXT+IUOG0Lt3b1q3bk2lSpWYMmUKL7zwAvXr16dr164kJiYC8Ntvv9GgQQPq169P3759OXfuHAC//PILtWrVomHDhkyZMiXtvGfPnqVv3740adKEBg0aMG1ahqusRK6KtXaqtba8tdbbWlvaWtsldftka21da22YtbahtXaG01mnb53OgZgDalwuIiKSS6kYJTmv6iNg3GHHp7BnEkT/CSH/dRWqRESuU4uqgYzo0YABE9fy/uytDJi4lhE9GtCiauANnXfr1q088cQTbN68mSJFijBy5EgSExN56qmn+OGHH1i9ejV9+/Zl0KBBAAwbNoy1a9eyYcMGRo8eTeXKlenfvz///Oc/WbduHa1bX36jsZ07dzJv3jymT59Oz549adeuHRs3bsTX15effvqJ+Ph4+vTpw3fffcfGjRtJSkpi1KhRxMfH8+ijjzJjxgxWr17NoUOH0s45dOhQ2rdvz8qVK5k/fz7PP/88Z8+evaGvhUheMXLVSCoGVOTm6jc7HUVERETSoWKU5Dy/ICh/B+z6Ajb8B4qFQcV7nU4lIvlAi6qB9GxakeHzdtCzacUbLkQBVKhQgZYtWwLQs2dPFi9ezNatW/nzzz/p1KkTYWFh/N///R9RUVEAhISEEBERwTfffIOHx9UV2bt164anpyf169cnOTmZrl27AlC/fn0iIyPZunUrwcHB1Kjh6gndu3dvFi5cyJYtWwgODqZ69eoYY+jZs2faOWfPns2wYcMICwujbdu2xMfHs3fv3hv+eojkdpuPbmbe7nn0b9Qfdzd3p+OIiIhIOjQVRZxR/XHYNxnOHYfGP4NRXVREbtzSncf4ZsVeBravxjcr9tKsaokbLkgZYy57bq2lbt26LFu27LLxP/30EwsXLmTGjBkMHTqUjRs3XvEa3t7eALi5ueHp6Zl2TTc3N5KSkjI7NEPWWiZPnkzNmjUv2n748OHrOp9IXjFq1Si83L14uOHDTkcRERGRDKgCIM4o3R4C6kKptlC2q9NpRCQfON8jakSPBjzbuWbakr1Lm5pfq71796YVnSZOnEirVq2oWbMmR48eTduemJjIpk2bSElJYd++fbRr14633nqL6Ohozpw5g7+/PzExMdedoWbNmkRGRrJjxw4Avv76a9q0aUOtWrWIjIxk505Xk/ZJkyalHdOlSxc+/vhjrLUArF279rqvL5JXJCQn8M2Gb7i3zr2UKlTK6TgiIiKSARWjxBnGQKfF0Ham63MRkRu0ISr6oh5R53tIbYiKvqHz1qxZk08++YTatWtz8uRJHn/8cby8vPjhhx/497//TWhoKGFhYSxdupTk5GR69uxJ/fr1adCgAQMHDqRo0aLcdtttTJ06Nd0G5lfDx8eHL774gnvvvZf6/9/e/UfJVdZ3HH9/8gOXHyKEEIosmhwEhfwkBA6KUiDQhh8HKpQCjRVrq2IBgaP2ABIhtrQItEilpUaI0BJCFYmliDEpULFHEwIhEEKgUAmQFEkIRVpREsi3f9xnzZju7DI7z72zs/N5nbNn59d+vs88O3fuvc88987EiQwbNoyzzjqLrq4u5syZw/HHH8/UqVMZM2brzvesWbPYvHkzkyZNYvz48cyaNaupfjBrB9sN347ln1rO7CNmt7opZmZm1gf1fGLaqaZNmxYPPvhgq5thZma9WL16Nfvvv3+rm2FtpLfXjKSHImJai5pkdXgbzMzMbGjraxvMM6PMzMzMzMzMzKwyHowyMzMzMzMzM7PKeDDKzMzMzMzMzMwq48EoMzMb1Dr93Ib21vm1YmZmZtYePBhlZmaDVldXFxs3bvQgg/UrIti4cSNdXV2tboqZmZmZ9WNEqxtgZmZWT3d3N2vXrmXDhg2tboq1ga6uLrq7u1vdDDMzMzPrhwejzMxs0Bo5ciTjxo1rdTPMzMzMzCwjH6ZnZmZmZmZmZmaV8WCUmZmZmZmZmZlVxoNRZmZmZmZmZmZWGXX6NxRJ2gA8W1L8aOClkrKryK+ihvNbX6Pd86uo4fzW13B+62u0c/67I2L3krJtgNp8G2wocp81zn3WGPdX49xnjXOfNa4l22AdPxhVJkkPRsS0ds2voobzW1+j3fOrqOH81tdwfutrtHu+dRa/nhrnPmuc+6wx7q/Guc8a5z5rXKv6zIfpmZmZmZmZmZlZZTwYZWZmZmZmZmZmlfFgVLnmtHl+FTWc3/oa7Z5fRQ3nt76G81tfo93zrbP49dQ491nj3GeNcX81zn3WOPdZ41rSZz5nlJmZmZmZmZmZVcYzo8zMzMzMzMzMrDIejCqBpLmS1kt6rKT8vSXdJ+lxSasknZc5v0vSA5IeSfmzc+bX1Bku6WFJd5WUv0bSSkkrJD1YQv4ukm6X9ISk1ZLenzH7vandPT+vSjo/V35NnQvS//gxSfMldWXOPy9lr8rR/t6WLUmjJC2W9FT6vWsJNU5Nz2GLpKa+aaJO/lXpdfSopAWSdsmc/2cpe4WkRZLemTO/5r7PSgpJoweaX6+GpMskratZJo7LmZ9uPzf9H1ZJujJz+/+ppu1rJK0YaH4fNaZIWtLznifpkMz5kyX9OL2v/ouknZvI73U9lnt5NoN8702dIOf6ohPkXH93ipzbVEOdpBmSnpT0tKQLW92ewa6vbVTrXb3tsap4MKocNwEzSsx/A/hsRBwAHAqcLemAjPmvA0dFxGRgCjBD0qEZ83ucB6wuIbfWkRExpaSvqrwWWBgR7wMmk/G5RMSTqd1TgIOA14AFufIBJO0FfAaYFhETgOHA6RnzJwCfAA6h6J8TJL2nydib+P/L1oXAPRGxL3BPup67xmPAycD9TWbXy18MTIiIScB/ABdlzr8qIial19NdwBcz5yNpb+C3gOeayO6zBnBNz3IREXfnzJd0JHASMDkixgNX58yPiNNqlulvA3c0kd9rDeBKYHaq8cV0PWf+DcCFETGR4v3o803k11uP5V6ercNlfm/qBDnXF50g5/q7U+TcphqyJA0H/hY4FjgAOCPz/t5QdBPl7oMPRWWPK/TJg1EliIj7gZdLzH8hIpany/9DMQiyV8b8iIj/TVdHpp+sJxeT1A0cT7Fz03YkvQM4HLgRICI2RcQrJZWbDvxnRDxbQvYIYHtJI4AdgP/KmL0/sDQiXouIN4AfUGx8DFidZesk4OZ0+Wbgd3LXiIjVEfFkM7n95C9KfQSwBOjOnP9qzdUdaWJ57uP97RrgT5vJfgs1sqiT/2ngioh4PT1mfeZ8ACQJ+D1g/kDz+6gRQM9spXfQxPJcJ38/tu48LAZOaSK/3nos6/JsRsb3pk6Qc33RCXKuvztFzm2qIe4Q4OmI+ElEbAJuo1hHWh1lbz8ORWWPK/THg1FtTtJY4EBgaebc4ekwkvXA4ojImg98hWLjcEvm3FoBLJL0kKRPZs4eB2wAvqHiUMMbJO2YuUaP02lyx7U3EbGOYvbHc8ALwM8iYlHGEo8BH5K0m6QdgOOAvTPm99gjIl5Il38K7FFCjSp9HPhe7lBJl0t6HphJ5k+6JZ0ErIuIR3Lm9uKcdCjE3BIO39qP4vW6VNIPJB2cOb/Hh4AXI+KpErLPB65K/+eryf8J/Sq2bgifSqbleZv12FBbnq2FKnxvGlLKXF8McaWsv61j7QU8X3N9LRUOEljnKWtcoS8ejGpjknaiONzj/G0+yWpaRLyZpmh3A4ekQ66ykHQCsD4iHsqVWccHI2IqxfTWsyUdnjF7BDAVuD4iDgR+TgmHk0jaDjgR+FYJ2btS7FiOA94J7CjpI7nyI2I18GVgEbAQWAG8mSu/Ts2gjT/FlfQFiumy83JnR8QXImLvlH1Ortw00Hgx5e+wXA/sQ3Ho8AvAX2XOHwGMopii/Hngm2kWU25nUMLgcvJp4IL0f76ANHMzo48DfyLpIeDtwKZmA/taj7X78mzVkPSvKs5NuO3PSVTz3tR2+umz0tYX7aq//kqPKW393Y7eSp+Z2eBR5rhCX0ZUVcjykjSS4gUzLyKaPfdIXRHxiqT7KI6/zXUyuMOAE1WcgLgL2FnSLRGRbSAEfjXzh4hYL2kBxXTXXMenrwXW1swYu51yzm1yLLA8Il4sIfto4JmI2AAg6Q7gA8AtuQpExI2kHWJJf0HRb7m9KGnPiHhB0p4Us/najqSPAScA09NOeFnmAXcDl2bK24diQPORNHbTDSyXdEhE/DRTDWqXAUlfpziXSU5rgTtS3z8gaQswmmIGZBbpcNiTKc4DV4YzKc7FB8UAdtbDoCPiCYpz7yBpP4pDrQesznpsSCzPVp2IOLq32yVNpIL3pnZUr896kXt90Zb6668K199to4HXmNW3jl+fgdydbjPLqqpxhd54ZlQbSp/W3wisjoi/LiF/d6VvA5G0PXAM8ESu/Ii4KCK6I2IsxSFo9+YeiJK0o6S391ym2IHK9s0KaUP2eUnvTTdNBx7PlV+jzFkUzwGHStohvaamk/mE8pLGpN/votgJvzVnfnInxU446fc/l1CjVJJmUBy2emJEvFZC/r41V08i7/K8MiLGRMTYtEyvBabm3tlLAxM9PkzG5Tn5DnBkqrUfsB3wUuYaRwNPREQZg7JQnCPqN9Plo4CshwLWLM/DgEuAv28iq956rO2XZxscqnpvGmrKXF8MRWWvv62jLQP2lTQuHSlxOsU60iybsscV+uOZUSWQNB84AhgtaS1waZohksthwB8AK7X168Evjua+XarWnsDNKr7FYRjwzYjIPQuhbHsAC9KnoSOAWyNiYeYa5wLz0griJ8Af5gxPg2jHAJ/KmdsjIpZKuh1YTjG1/GFgTuYy35a0G7AZOLvZk7z3tmwBV1AcUvVHwLMUJ4fOXeNl4KvA7sB3Ja2IiN/OmH8R8DZgcXrNLomIszLmH5cGTrdQ9NGAsuvlZ35/q/ccjpA0heKwrTU0sVzUyZ8LzFXxdcCbgDMH+gl3H32U7fxvdZ7DJ4Br0wysXwIDPldenfydJJ2dHnIH8I0BP4E66zEyL89m1rArcq0vOsR1ZFp/dwpJHybTNtVQFhFvSDoH+D7FN17PjYhVLW7WoFbFNuoQVPa4Qp/k2aRmZmZmZmZmZlYVH6ZnZmZmZmZmZmaV8WCUmZmZmZmZmZlVxoNRZmZmZmZmZmZWGQ9GmZmZmZmZmZlZZTwYZWZmZmZmZmZmlfFglJllISkk3VJzfYSkDZLuajBnjaTRzT6mbJIuk/S5Af7tDZIOSJcvztsyMzMzMzOzwc2DUWaWy8+BCZK2T9ePAda1sD2DVkT8cUQ8nq56MMrMzMzMzDqKB6PMLKe7gePT5TOA+T13SBol6TuSHpW0RNKkdPtukhZJWiXpBkA1f/MRSQ9IWiHpa5KG91Vc0gxJyyU9IumefupeJulmST+U9KykkyVdKWmlpIWSRqbHram5/QFJ7+ml7j7pbx5Kee9LM8OWSToiPeYvJV2eLv+bpGmSrgC2T89vnqQvSTq/JvdySec1+k8wMzMzGywkHZy2w7ok7Zi2+Sa0ul1m1loejDKznG4DTpfUBUwCltbcNxt4OCImUcwG+od0+6XAv0fEeGAB8C4ASfsDpwGHRcQU4E1gZr3CknYHvg6cEhGTgVP7qQuwD3AUcCJwC3BfREwEfsHWQTWAn6XbrwO+0kv5OcC5EXEQ8Dng7yLiDeBjwPWSjgZmpLb8SkRcCPwiIqZExExgLvDR9HyGAaendpmZmZm1pYhYBtwJ/DlwJXBLRDzW2laZWauNaHUDzGzoiIhHJY2lmBV19zZ3fxA4JT3u3jQjamfgcODkdPt3Jf13evx04CBgmSSA7YH1fZQ/FLg/Ip5JWS/3UxfgexGxWdJKYDiwMN2+Ehhbkz2/5vc1tUUl7QR8APhWaifA21K9VZL+EbgLeH9EbOqj/UTEGkkbJR0I7EExiLaxr78xMzMzawNfApYBvwQ+0+K2mNkg4MEoM8vtTuBq4AhgtyZyBNwcERflaFQdrwNExBZJmyMi0u1b+PX3x6hzGYoZpq+k2Vu9mQi8Aox5i226gWJG1W9QzJQyMzMza3e7ATsBI4EuinONmlkH82F6ZpbbXGB2RKzc5vYfkg6zS+dReikiXgXuB34/3X4ssGt6/D3A70oak+4bJendfdRdAhwuaVzP4/up24jTan7/uPaOlPWMpFNTDUmanC6fDIyimP31VUm79JK9uef8VMkCikP6Dga+32A7zczMzAajrwGzgHnAl1vcFjMbBDwzysyyioi1wN/0ctdlwFxJjwKvAWem22cD8yWtAn4EPJdyHpd0CbAonT9pM3A28GyduhskfRK4Iz1+PcU3+tWr24hd09+/TnEI4rZmUpwb6hKKT/xuk7QOuAKYHhHPS7oOuLaX+nOARyUtj4iZEbFJ0n0Us63eHEBbzczMzAYNSR8FNkfErenLaH4k6aiIuLfVbTOz1tHWo1LMzGxbktYA0yLipYrqDQOWA6dGxFNV1DQzMzMzM6uSD9MzMxskJB0APA3c44EoMzMzMzMbqjwzyszMzMzMzMzMKuOZUWZmZmZmZmZmVhkPRpmZmZmZmZmZWWU8GGVmZmZmZmZmZpXxYJSZmZmZmZmZmVXGg1FmZmZmZmZmZlYZD0aZmZmZmZmZmVll/g+qfw2fwy0LhgAAAABJRU5ErkJggg==\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Evaluate hold-out method\n", "std_mse_val_ho_knn = eval_hold_out(M=M_knn, split_coeff=split_coeff, fit_func=fit_knn_regressor,\n", " predict_func=predict_knn_regressor)\n", "\n", "# Evaluate cross validation method\n", "std_mse_val_cv_knn = eval_k_fold_cross_validation(M=M_knn, k=k, fit_func=fit_knn_regressor,\n", " predict_func=predict_knn_regressor)\n", "\n", "\n", "# Plot the standard deviations\n", "plot_bars(M_knn, std_mse_val_ho_knn, std_mse_val_cv_knn)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The first two rows in the cell above show the errorplots and the best model's prediction for hold out (first row) and cross validation (second row), respectively. The last row shows the standard deviation of the mean squarred error over the 20 different data sets incurred by each model." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.4) Forests\n", "We will now apply hold-out and $k$-fold-cross validation on regression with forests. As for k-nearest neighbor regression above, we provide a fit and an evaluate function for forests. Note that we have two different functions for fitting a forest model. In `fit_forest_fixed_n_trees` we investigate the behavior of the algorithm when fixing the number of trees to $1$ and varying the number of samples per leaf. In `fit_forest_fixed_n_samples_leaf` we fix the number of samples per leaf to $1$ and investigate the behavior of the algorithm when varying the number of trees. The evaluation function can be used for both models." ] }, { "cell_type": "code", "execution_count": 311, "metadata": {}, "outputs": [], "source": [ "def fit_forest_fixed_n_trees(train_in: np.ndarray, train_out: np.ndarray, min_samples_leaf: int):\n", " \"\"\"\n", " This function will fit a forest model based on a fixed number of trees (can not be change when using this \n", " function, is set globally)\n", " :param train_in: the training input data, shape [N x input dim]\n", " :param train_out: the training output data, shape [N x output dim]\n", " :param min_samples_leaf: the number of samples per leaf to be used \n", " \"\"\"\n", " model = RandomForestRegressor(\n", " n_estimators=1, min_samples_leaf=min_samples_leaf)\n", " model.fit(train_in, train_out)\n", " return model\n" ] }, { "cell_type": "code", "execution_count": 312, "metadata": {}, "outputs": [], "source": [ "def fit_forest_fixed_n_samples_leaf(train_in: np.ndarray, train_out: np.ndarray, n_trees: int):\n", " \"\"\"\n", " This function will fit a forest model based on a fixed number of sample per leaf (can not be change when \n", " using this function, is set globally)\n", " :param train_in: the training input data, shape [N x input dim]\n", " :param train_out: the training output data, shape [N x output dim]\n", " :param n_trees: the number of trees in the forest \n", " \"\"\"\n", " model = RandomForestRegressor(n_estimators=n_trees, min_samples_leaf=1)\n", " model.fit(train_in, train_out)\n", " return model\n" ] }, { "cell_type": "code", "execution_count": 313, "metadata": {}, "outputs": [], "source": [ "def predict_forest(model, data_in: np.ndarray) -> np.ndarray:\n", " \"\"\"\n", " This function will perform predictions using a forest regression model on the input data. \n", " :param model: the forest model from scikit learn (fitted before)\n", " :param data_in: :param data_in: the data we want to perform predictions (shape [N x input dimension])\n", " :return prediction based on chosen minimum samples per leaf (shape[N x output dimension]\n", " \"\"\"\n", " y = model.predict(data_in)\n", " if len(y.shape) == 1:\n", " y = y.reshape((-1, 1))\n", " return y\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.4.1) Apply Hold-out and Cross-validation to Forests (Fixed Number of Trees)\n", "\n", "We apply forest regression with a fixed number of trees of $1$ and use hold-out and cross-validation to determine the complexity parameter of this model, i.e., the number of samples per leaf. As described above, we furthermore plot and compare the standard deviations of the mean squared errors for each model based on the 20 data sets to get a feeling of the robustness of hold-out and cross validation." ] }, { "cell_type": "code", "execution_count": 314, "metadata": {}, "outputs": [], "source": [ "M_n_samples_leaf = 10 # Maximum number of samples per leaf\n", "split_coeff = 0.8 # Split coefficient for the hold-out method\n", "k = 10 # Number of splits for the cross validation method\n" ] }, { "cell_type": "code", "execution_count": 315, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Best model complexity determined with hold-out method: 9\n", "Best model complexity determined with cross-validation method: 1\n" ] }, { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Hold-out method\n", "std_mse_val_ho_forest_fixed_n_trees = eval_hold_out(M=M_n_samples_leaf, split_coeff=split_coeff,\n", " fit_func=fit_forest_fixed_n_trees,\n", " predict_func=predict_forest)\n", "# Cross validation method\n", "std_mse_val_cv_forest_fixed_n_trees = eval_k_fold_cross_validation(M=M_n_samples_leaf, k=k, fit_func=fit_forest_fixed_n_trees,\n", " predict_func=predict_forest)\n", "\n", "# Plot the standard deviations\n", "plot_bars(M_n_samples_leaf, std_mse_val_ho_forest_fixed_n_trees,\n", " std_mse_val_cv_forest_fixed_n_trees)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The first two rows in the cell above show the errorplots and the best model's prediction for hold out (first row) and cross validation (second row), respectively. The last row shows the standard deviation of the mean squarred error over the 20 different data sets incurred by each model." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.4.2) Apply Hold-out and Cross-validation to Forests (Fixed Number of Samples per Leaf) \n", "We apply forest regression with a fixed number of samples per leaf of $1$ and use hold-out and cross-validation to determine the complexity parameter of this model, i.e., the number of trees. As described above, we furthermore plot and compare the standard deviations of the mean squared errors for each model based on the 20 data sets to get a feeling of the robustness of hold-out and cross validation." ] }, { "cell_type": "code", "execution_count": 316, "metadata": {}, "outputs": [], "source": [ "M_n_trees = 20 # Maximum number of trees\n", "split_coeff = 0.8 # Split coefficient for the hold-out method\n", "k = 10 # Number of splits for the cross validation method\n" ] }, { "cell_type": "code", "execution_count": 317, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Best model complexity determined with hold-out method: 15\n", "Best model complexity determined with cross-validation method: 18\n" ] }, { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Hold-out method\n", "std_mse_val_ho_forest_fixed_n_samples = eval_hold_out(M=M_n_trees, split_coeff=split_coeff,\n", " fit_func=fit_forest_fixed_n_samples_leaf,\n", " predict_func=predict_forest)\n", "# Cross-validation method\n", "std_mse_val_cv_forest_fixed_n_samples = eval_k_fold_cross_validation(M=M_n_trees, k=k,\n", " fit_func=fit_forest_fixed_n_samples_leaf,\n", " predict_func=predict_forest)\n", "\n", "\n", "# Plot the standard deviations\n", "plot_bars(M_n_trees, std_mse_val_ho_forest_fixed_n_samples,\n", " std_mse_val_cv_forest_fixed_n_samples)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The first two rows in the cell above show the errorplots and the best model's prediction for hold out (first row) and cross validation (second row), respectively. The last row shows the standard deviation of the mean squarred error over the 20 different data sets incurred by each model." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.5) Comparisons\n", "\n", "#### 3.5.1) (1 Point)\n", "Comparing the error plots from section 3.4.2) to the error plots from 3.3.1) and 3.4.1) we observe that the validation error does not increase with the number of trees. Give an intution for this observation." ] }, { "cell_type": "markdown", "source": [ "Mean MSE plots of the two forests plot with fixed number of samples per leave (hold-out and cross-validation) show that an increasing model complexity leads to a decreasing MSE evaluation. In the fixed number of treas, we see that the model performance does not increase with an increasing model complexity. In the kNN case, we see that the model performance is highly dependet on the evaluation method (hold-out or cross-validation) with the best performance using cross-validation.\n", "\n", "The number of trees increases the model complexity and ensures that it is possible to better approximate non-linear functions. Therefore, a higher number of trees is more powerful in approximating the function and ensures a better generalization." ], "metadata": { "collapsed": false } }, { "cell_type": "markdown", "source": [ "#### 3.5.2) (1 Point)\n", "Compare the standard deviation plots from the last three sections. What is the main difference between the hold-out and cross validation methods? Explain the reason for the observed behavior." ], "metadata": { "collapsed": false } }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "With increasing model complexity, the standard deviation of the cross-validation method decreases. Same behavior partially observable with the hold-out method but with less magnitude. The reason for this behavior is that with the cross-validation our model is trained on multiple train-test splits, which geaves us a better indication how well the model performs. With increasing model-complexity, the model can better approximate the underlying function. Therefore, the standard-deviation in the cross-validation setting decreases since our model performs on k-folds and gives a good overview over the performance. With the hold-out method, the standard deviation is highly dependent on the random split between training and test split. With the cross-validation, we take out the randomness of the hold-out method (high randomness --> high standard deviation)." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.5" } }, "nbformat": 4, "nbformat_minor": 1 }