SIT 112 | Data Science Concepts Lecturer: Dr Sergiy Shelyag | XXXXXXXXXX Data Science Project Due: Friday 5pm, 31st May 2019 Note: This project contributes 25% to your final SIT112 mark. It must be...

{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# SIT 112 - Data Science Concepts\n",
"# Data Science Project\n",
"\n",
"---\n",
"Lecturer: Sergiy Shelyag | [email protected]
\n",
"\n",
"School of Information Technology,
\n",
"Deakin University, VIC 3215, Australia.\n",
"\n",
"### Due: 5pm, 1st June 2018\n",
"---\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Instructions\n",
"\n",
"This notebook has been prepared for you to complete the Data Science Project. Some sections have been pre-filled to help you get started. **The total mark for this project is 100**.\n",
"\n",
"There are two parts in this notebook that require you to complete:\n",
"\n",
"* **Part 1**: *Linear Regression* (**50 marks**)\n",
"* **Part 2**: *Classification* (**50 marks**)\n",
"\n",
"Each part includes three main components:\n",
" * **A:** Load a dataset from sklearn and examine it.\n",
" * **B:** Build a training model and make predictions.\n",
" * **C:** Report the results and visualize the data.\n",
"\n",
"Before you start, read the entire notebook carefully to understand what you need to do. You should also refer to the main instructions in *Project_instructions.pdf* to know what else you need to complete for this project.\n",
"\n",
"For each cell marked with **# YOU ARE REQUIRED TO INSERT YOUR CODES IN THIS CELL**, there will be places where you **must** supply your own codes when instructed. \n",
"\n",
"In the end, you must execute the entire notebook and submit two files:\n",
"\n",
" 1. The source of your solution notebook: **[YourID]_project_solution.ipynb**\n",
" 2. And an exported version of your output: **[YourID]_project_output.html**\n",
" \n",
"As you go through this notebook:\n",
"\n",
"* markdown cells marked with **Note** mean description sections.\n",
"* markdown cells marked with **Instructions** mean the instructions given to you to complete the sections.\n",
"\n",
"Please proceed with the instructions for each part below to complete your programming tasks."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Note**: The following packages will be required for this assignment. If you need to import more packages, you might append them to the end of the following cell. "
]
},
{
"cell_type": "code",
"execution_count": 86,
"metadata": {},
"outputs": [],
"source": [
"'''\n",
"Import packages needed for processing\n",
"'''\n",
"import numpy as np\n",
"from sklearn import datasets\n",
"import sklearn.metrics as metrics\n",
"\n",
"from sklearn import linear_model\n",
"from sklearn import naive_bayes\n",
"from sklearn.manifold import TSNE\n",
"import matplotlib.pyplot as plt \n",
"\n",
"%matplotlib inline\n",
"\n",
"'''\n",
"If you need add any additional packages, then add them below this line\n",
"'''\n",
"import collections\n",
"import seaborn as sns\n",
"from sklearn.linear_model import LinearRegression\n",
"from sklearn.naive_bayes import MultinomialNB\n",
"from sklearn.metrics import precision_score, recall_score, f1_score"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Part 1: Linear Regression\n",
"\n",
"In this part, you will be required to work on Linear Regression for the **diabetes** dataset from sklearn. More about the dataset can be found [here](http://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_diabetes.html#sklearn.datasets.load_diabetes).\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Part 1A: Load and examine the diabetes dataset"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Instruction 1.1.** Write your code to load the **diabetes** dataset from sklearn and assign it to a variable called `diabetes`.\n",
"\n",
"[**Total mark: 3**]"
]
},
{
"cell_type": "code",
"execution_count": 87,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"dict_keys(['data', 'target', 'DESCR', 'feature_names', 'data_filename', 'target_filename'])\n"
]
}
],
"source": [
"# YOU ARE REQUIRED TO INSERT YOUR CODES IN THIS CELL\n",
"'''\n",
"1. Write your code to load the **diabetes** dataset from sklearn \n",
" and assign it to a variable called `diabetes`.\n",
"'''\n",
"diabetes = datasets.load_diabetes()\n",
"\n",
"print(diabetes.keys())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Note:** `diabetes` is a dictionary with two keys: *'data'* - a numpy 2D array containing the features and *'target'* containing the labels. The cell code below assigns the data to variable `X` and the labels to variable `Y`. Run the cell and use `X` and `Y` for later tasks."
]
},
{
"cell_type": "code",
"execution_count": 88,
"metadata": {},
"outputs": [],
"source": [
"X = diabetes['data']\n",
"Y = diabetes['target']"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Instruction 1.2.** Now you need to examine the size of data. Write your code to find and print out the number of **samples** and the number of **features** in the dataset.\n",
"\n",
"[**Total mark: 2**]"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The number of samples: 442\n",
"The number of features: 10\n"
]
}
],
"source": [
"# YOU ARE REQUIRED TO INSERT YOUR CODES IN THIS CELL\n",
"'''\n",
"2. Write your code to find and print out the number of **samples** \n",
" and the number of **features** in the dataset.\n",
" Using variable X.\n",
"'''\n",
"print('The number of samples:', X.shape[0])\n",
"\n",
"print('The number of features:',X.shape[1])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Instruction 1.3.** We also need to get a brief understanding about the task by doing some statistics on the labels.\n",
"\n",
"**Your tasks are:**\n",
"\n",
"1. Write your code to print the **min**, **max** and **median** of the labels. (3 marks)\n",
"2. Construct a **box-plot** for the labels. (2 marks)\n",
"\n",
"[**Total marks: 5**]"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"

"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"# YOU ARE REQUIRED TO INSERT YOUR CODES IN THIS CELL\n",
"'''\n",
"2. Construct a box-plot for the labels.\n",
"'''\n",
"# construct a box-plot for the labels\n",
"\n",
"color_vals = ['Red','Green','Grey','Darkorange','Olivedrab','Indigo','Cadetblue','Lightgreen','Gold','Salmon']\n",
"\n",
"fig = plt.figure(figsize=(16,8))\n",
"\n",
"fontsize = 15\n",
"for pos in range(X.shape[1]):\n",
" ax = plt.subplot(5,2,pos+1)\n",
" sns.boxplot(X[:,pos], color = color_vals[pos], ax = ax)\n",
" ax.set_title(diabetes['feature_names'][pos], fontsize = fontsize)\n",
" \n",
"plt.tight_layout()\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Feature\t\tMinimum Value\t\t\tMaximum Value\t\t\tMedian\n",
"age\t\t-0.107225631607358\t\t0.110726675453815\t\t0.00538306037424807\n",
"sex\t\t-0.044641636506989\t\t0.0506801187398187\t\t-0.044641636506989\n",
"bmi\t\t-0.0902752958985185\t\t0.17055522598066\t\t-0.00728376620968916\n",
"bp\t\t-0.112399602060758\t\t0.132044217194516\t\t-0.00567061055493425\n",
"s1\t\t-0.126780669916514\t\t0.153913713156516\t\t-0.00432086553661359\n",
"s2\t\t-0.115613065979398\t\t0.198787989657293\t\t-0.00381906512053488\n",
"s3\t\t-0.10230705051742\t\t0.181179060397284\t\t-0.00658446761115617\n",
"s4\t\t-0.076394503750001\t\t0.185234443260194\t\t-0.00259226199818282\n",
"s5\t\t-0.126097385560409\t\t0.133598980013008\t\t-0.00194763415685317\n",
"s6\t\t-0.137767225690012\t\t0.135611830689079\t\t-0.00107769750046639\n",
"Target Variable\n",
"Minimum Value: 25.0, Maximum Value: 346.0, Median: 140.5\n"
]
}
],
"source": [
"# YOU ARE REQUIRED TO INSERT YOUR CODES IN THIS CELL\n",
"'''\n",
"1. Write your code to print the min, max and median of the labels.\n",
" Using variable Y.\n",
"'''\n",
"print('Feature\\t\\tMinimum Value\\t\\t\\tMaximum Value\\t\\t\\tMedian')\n",
"for pos in range(X.shape[1]):\n",
" print('{}\\t\\t{}\\t\\t{}\\t\\t{}'.format(diabetes['feature_names'][pos], np.min(X[:,pos]), np.max(X[:,pos]), np.median(X[:,pos])))\n",
"\n",
"print('Target Variable')\n",
"print('Minimum Value: {}, Maximum Value: {}, Median: {}'.format(np.min(Y), np.max(Y), np.median(Y)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Part 1B. Linear Regression\n",
"\n",
"You are required to apply Linear Regression to train and make predictions on the **diabetes** dataset."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Note:** To perform a supervised learning task, we need to train the model on a training set of the input data and the correct labels, and predict the trained model on **unseen** data. Then, we use the correct labels of the **unseen** data to evaluate the performance of the model. The **unseen** dataset is called the **test set**."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Instruction 1.4.** First you need to split the **diabetes** dataset into a training set and a test set. We will use 70% samples for training and 30% for testing. Print the number of samples in each set.\n",
"\n",
"[**Total marks: 5**]"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The number of samples in the training set:\n",
"309\n",
"The number of samples in the test set:\n",
"133\n"
]
}
],
"source": [
"# YOU ARE REQUIRED TO INSERT YOUR CODES IN THIS CELL\n",
"\n",
"# first, compute the number of samples in the training set:\n",
"n_train = int(len(Y) * 0.7)\n",
"\n",
"# The training set is the first n_train samples in the dataset\n",
"X_train = X[:n_train]\n",
"Y_train = Y[:n_train]\n",
"\n",
"# The test set is the remaining samples in the dataset\n",
"X_test = X[n_train:]\n",
"Y_test = Y[n_train:]\n",
"\n",
"# Print the number of samples in the training set\n",
"print('The number of samples in the training set:')\n",
"print(len(X_train))\n",
"\n",
"# Print the number of samples in the test set\n",
"print('The number of samples in the test set:')\n",
"print(len(X_test))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Instruction 1.5.** Create a Linear Regression model called `lr`.\n",
"\n",
"[**Total marks: 5**]"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"lr = LinearRegression()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Instruction 1.6.** Fit the training data to the `lr` model.\n",
"\n",
"[**Total marks: 5**]"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None,\n",
" normalize=False)"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# YOU ARE REQUIRED TO INSERT YOUR CODES IN THIS CELL\n",
"lr.fit(X_train, Y_train)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Instruction 1.7** Predict the output of the test set.\n",
"\n",
"[**Total marks: 5**]"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[139.99381608 205.02640697 176.97778704 122.05974488 213.18077169\n",
" 174.98852064 112.65389212 202.82658131 172.35243033 164.47418705\n",
" 196.15962387 192.54406753 293.90068958 299.7465604 232.76334834\n",
" 213.53873831 228.48533512 157.1751098 226.27609511 194.21368886\n",
" 101.82219913 174.76393876 111.17348152 294.07940325 179.7869339\n",
" 76.42319163 85.90565583 259.9593708 168.07240778 119.57919313\n",
" 150.68038442 164.06743377 179.24446569 159.59344772 155.87358338\n",
" 143.36467882 123.92736711 176.618279 103.82379184 133.74527488\n",
" 90.94561588 253.81583777 84.12062018 61.3713544 177.97627662\n",
" 196.51767018 130.92146865 88.54111378 199.91912195 53.81979958\n",
" 173.22993854 198.32897556 121.58954455 233.94327416 161.48314734\n",
" 161.86371717 166.464451 261.38157828 260.15223634 204.29534606\n",
" 187.46774384 60.21859679 205.12037857 107.69117313 143.08887348\n",
" 127.96638789 174.54142953 213.69268751 162.95717781 160.21421003\n",
" 137.66760774 173.22737347 70.19308694 262.04969756 111.92846102\n",
" 106.78308221 135.27897046 111.39812286 96.75830871 156.2932552\n",
" 74.87226648 264.28605791 57.01316879 98.1732752 101.31653912\n",
" 276.71186426 170.88557856 62.93955692 186.13594953 171.95979912\n",
" 187.00830031 186.13852705 92.7534905 147.48019274 258.94145986\n",
" 198.28792015 280.72025011 49.41893384 178.41110056 202.3385569\n",
" 167.8026343 155.69294572 155.31812231 236.4358523 124.55734266\n",
" 164.29993856 174.51019295 225.77959304 155.78051853 100.5574813\n",
" 84.53953058 141.2656356 190.79685208 196.75932921 145.53709822\n",
" 171.10705054 113.76652532 160.56105266 130.19483903 262.70560773\n",
" 100.20764258 115.05499404 119.61524219 226.25793937 63.5114853\n",
" 133.50498439 119.54796909 54.62907085 189.07170565 101.65801976\n",
" 119.11267429 212.71676793 57.80383242]\n"
]
}
],
"source": [
"Y_pred = lr.predict(X_test)\n",
"print(Y_pred)"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": true
},
"source": [
"## Part 1C. Results and Visualization"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Note:** To evaluate the performance of a Linear Regression model, two commonly used measures are **mean absolute error** and **root mean squared error**.\n",
"\n",
"**mean absolute error** is defined by:\n",
"\n",
"$$mean\\_absolute\\_error(Y_{test}, Y_{pred}) = \\frac{1}{n_{samples}}\\sum_{i=1}^{n_{samples}}|y_{test}^i - y_{pred}^i|$$\n",
"\n",
"**root mean squared error** is defined by:\n",
"\n",
"$$root\\_mean\\_squared\\_error(Y_{test}, Y_{pred}) = \\sqrt{\\frac{1}{n_{samples}}\\sum_{i=1}^{n_{samples}}(y_{test}^i - y_{pred}^i)^2}$$\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Instruction 1.8.** Compute **mean absolute error** and **root mean squared error** between the correct labels and the predictions of the test set and print these two values.\n",
"\n",
"[**Total marks: 8**]\n",
"\n",
"**Hint:** You might need to use [Regression metrics](http://scikit-learn.org/stable/modules/model_evaluation.html#regression-metrics) from sklearn."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Mean Absolute Error: 40.871175845654435\n",
"Root Mean Squared Error: 52.174426892911136\n"
]
}
],
"source": [
"# YOU ARE REQUIRED TO INSERT YOUR CODES IN THIS CELL\n",
"\n",
"# Compute the mean absolute error between Y_test and Y_pred\n",
"# Then, print the value\n",
"\n",
"diff = abs(Y_test - Y_pred)\n",
"mean_absolute_error = np.sum(diff)/len(diff)\n",
"print('Mean Absolute Error:',mean_absolute_error)\n",
"\n",
"# Compute the root mean squared error between Y_test and Y_pred\n",
"# Then, print the value\n",
"\n",
"sqrd_diff = np.power((Y_test - Y_pred),2)\n",
"mean_squared_error = np.sum(sqrd_diff)/len(sqrd_diff)\n",
"root_mean_squared_error = np.sqrt(mean_squared_error)\n",
"print('Root Mean Squared Error:',root_mean_squared_error)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Note:** Visualisation is an important task. We want to see if two similar samples are predicted with two close labels. To evaluate how similar two samples are, we can compute their Euclidean distance and to evaluate how close the two labels are, we just need to compute their absolute difference.\n",
"\n",
"The function below returns a Euclidean distance matrix whose element (i, j) stores the Euclidean distance between X[i] and X[j]. **You will need this function for a subsequent task.**"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [],
"source": [
"def compute_euclidean_distance_matrix(X):\n",
" n_samples = X.shape[0]\n",
" \n",
" # initialise the distance matrix and set all value to 0\n",
" euclidean_distance_matrix = np.zeros([n_samples, n_samples], dtype=float)\n",
" \n",
" # compute the Euclidean distance matrix\n",
" for i in range(n_samples):\n",
" for j in range(n_samples):\n",
" euclidean_distance_matrix[i, j] = np.sqrt(np.sum((X[i] - X[j]) ** 2))\n",
" \n",
" return euclidean_distance_matrix"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Instruction 1.9**. The following code segment is designed to visualise the Euclidean distances of the samples and the absolute differences of their predicted labels.\n",
"\n",
"**Your tasks are:**\n",
"\n",
"1. Construct a function that returns a matrix of absolute differences of the prediction **Y_pred** whose element (i, j) stores the absolute difference between Y_pred[i] and Y_pred[j]. (4 marks)\n",
"\n",
"2. Compute the absolute difference matrix for **Y_pred** and visualise the matrix. (4 marks)\n",
"\n",
"3. Compute the Euclidean distance matrix for **X_test** using compute_euclidean_distance_matrix() and visualise the matrix. (4 marks)\n",
"\n",
"[**Total mark: 12**]"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
"# YOU ARE REQUIRED TO INSERT YOUR CODES IN THIS CELL\n",
"'''\n",
"1. Construct a function that returns a matrix of absolute difference of \n",
" the prediction **Y_pred** whose element (i, j) stores \n",
" the absolute difference between Y_pred[i] and Y_pred[j].\n",
"'''\n",
"def compute_abs_difference_matrix(Y):\n",
" # compute the absolute difference matrix\n",
" # and remember to return the matrix\n",
" \n",
" # initialise the absolute difference matrix and set all value to 0\n",
" absolute_diff_matrix = np.zeros([Y.shape[0], Y.shape[0]], dtype = float)\n",
" \n",
" # compute the absolute difference matrix\n",
" for i in range(Y.shape[0]):\n",
" for j in range(Y.shape[0]):\n",
" absolute_diff_matrix[i, j] = abs(Y[i] - Y[j])\n",
" \n",
" return absolute_diff_matrix"
]
},
{
"cell_type": "code",
"execution_count": 84,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[0. 0. 1. ... 1. 1. 0.]\n",
" [0. 0. 1. ... 1. 1. 0.]\n",
" [1. 1. 0. ... 0. 0. 1.]\n",
" ...\n",
" [1. 1. 0. ... 0. 0. 1.]\n",
" [1. 1. 0. ... 0. 0. 1.]\n",
" [0. 0. 1. ... 1. 1. 0.]]\n"
]
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAJCCAYAAADQsoPKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3WusZWl5H/j/M9XQpIgQN+M03a0BR11OsFVgVMEknkQOxMMlFu0PtgTxxK2EUWsyxONcDQzSeOaDJeeiOLEmIeoxBDyDwIQQ07KcVDCxgyIFcINxmYspasAD5cZujA2x0iNs8Dsfzm7N7lN7vWfttdbeZ3ed309qVZ113tvae1P7Ya31Pk+11gIAwGb/1WkvAADgkAmWAAA6BEsAAB2CJQCADsESAECHYAkAoEOwBADQsbNgqapeWlWfqqprVfW6Xc0DALBLtYuklFV1LsnVJN+V5HqSX0ryqtbaJxafDABgh27Z0bgvSHKttfaZJKmqdyS5O8nGYOnxdWt7Qp54w/ELFx8enODqlfMb260f7421bf+eoXVOWcsUc9c/NNa6oddrrLGvxbZz9trMWfPx9U75jG27linrXbLPmM/O2M/ukmsZc3zsuNu26em9XlPWvO08+/h3a+56p3wO1u3qHKeMt+TnbYk5h8Zd8vtgV6asccpnccj6nL+X3/3t1to3nNRnV1eWvjfJS1tr//3q57+c5Ntba399U/sn1VPbt9eLbzh++cGPDs7xkmc+b2O79eO9sbbt3zO0zilrmWLu+ofGWjf0eo019rXYds5emzlrPr7eKZ+xbdcyZb1L9hnz2Rn72V1yLWOOjx132zY9vddrypq3nWcf/27NXe+Uz8G6XZ3jlPGW/LwtMefQuEt+H+zKlDVO+SwOWZ/z59u7Ptxau3RSn11dWaoNxx4VlVXVvUnuTZIn5DCjXwCAXT3gfT3JnWs/35HkwfUGrbX7WmuXWmuXHpdbd7QMAIB5dhUs/VKSu6rq2VX1+CSvTHL/juYCANiZndyGa619rar+epLLSc4leXNr7eO7mAsAYJd28oD3ti499wntQ5fvvOH4kg9Qjn0Ibh8PL/fWMsXc9Q+NtW7fD8GPnbPXZs6apzwsvstzmTPu2D5zHybttZuzlikPpO/q9R7qf9y+N5Ac6oPjcx/e3ddD+EuONXfTw9g5h8Zd8vtgV5bcBDDF+pznbrs26gFvGbwBADoESwAAHYIlAIAOwRIAQIdgCQCgQ7AEANCxq3InW7l65fzGbYFqw20/v9pw2/UfM/fx/mrDbR6r127OWtSGO710HmrDbT+W2nAnO6TacMm1UX1cWQIA6BAsAQB0HMRtuAsXH87lyzdeYpPBe/v5ZfDerv+YuY/3l8F781i9dnPWIoP36d0al8F7+7Fk8D7ZYWXwHtfHlSUAgA7BEgBAx0HchrMbbt7lRbvhNrexG267PnbDbcduuM3shpt3a3rsnEPj2g13MrvhAAAWJlgCAOgQLAEAdAiWAAA6BEsAAB0HsRtOUsp5T/lLSrm5jaSU2/WRlHI7klJuJinlvB2iY+ccGldSypNJSgkAsDDBEgBAh2AJAKDjIJ5ZksF73r1YGbw3t5HBe7s+MnhvRwbvzWTwnvcc39g5h8aVwftkMngDACxMsAQA0HEQt+GkDph3eVHqgM1tpA7Yro/UAduROmAzqQPm3ZoeO+fQuFIHnEzqAACAhQmWAAA6DuI2nN1w8y4v2g23uY3dcNv1sRtuO3bDbWY33Lxb02PnHBrXbriT2Q0HALAwwRIAQIdgCQCgQ7AEANAhWAIA6BAsAQB0CJYAADoESwAAHYIlAIAOwRIAQIdgCQCgQ7AEANBxEIV0L1x8OJcv31gkb8lClWOLDe6jSGxvLVPMXf/QWOv2XWx47Jy9NnPWPKUo7y7PZc64Y/vMLdrZazdnLVMK/+7q9R7qf9y+C3UfaoHeuUVS91XseMmx5haXHjvn0LhLfh/sypLFlqdYn/PcbeP6uLIEANAhWAIA6BAsAQB0CJYAADoESwAAHQexG+7qlfMbn3RfcrfJ2B0D+9jp1VvLFHPXPzTWun3vGBw7Z6/NnDVP2Vm3y3OZM+7YPnN33vTazVnLlN17u3q9h/oft+/dtoe6y27uTqd97Vhccqy5O0THzjk07pLfB7uy5I7JKR4957VRfVxZAgDoECwBAHQIlgAAOgRLAAAdgiUAgI6D2A2nNty8p/zVhtvcRm247fqoDbcdteE2Uxtu3g7RsXMOjas23MnUhgMAWNjkYKmq7qyqX6iqT1bVx6vqh1bHn1pV762qT6/+fMpyywUA2K85V5a+luRvt9b+ZJIXJnlNVT0nyeuSvK+1dleS961+BgB4TJr8zFJr7QtJvrD6++9V1SeT3J7k7iTfuWr21iS/mOS1vbFk8J53L1YG781tZPDero8M3tuRwXszGbznPcc3ds6hcWXwPtmpZfCuqmcl+bYkH0zyjatA6pGA6hkDfe6tqgeq6oE/yFeXWAYAwOJmB0tV9UeT/Kskf6O19p/H9mut3ddau9Rau/S43Dp3GQAAOzErWKqqx+UoUHpba+3dq8O/VVW3rX5/W5KH5i0RAOD0zNkNV0nelOSTrbV/tPar+5Pcs/r7PUneM315AACna05Syu9I8peT/GpVPfLk1f+c5MeSvLOqXp3kc0m+b94SAQBOz5zdcP8xSQ38+sVTxwUAOCQyeAMAdAiWAAA6BEsAAB2CJQCADsESAECHYAkAoEOwBADQIVgCAOgQLAEAdMwpd7KYCxcfzuXLH73h+Eue+bzBPpcf/OjGduvHe2Nt279naJ1T1jLF3PUPjbVu6PUaa+xrse2cvTZz1nx8vVM+Y9uuZcp6l+wz5rMz9rO75FrGHB877rZtenqv15Q1bzvPPv7dmrveKZ+Ddbs6xynjLfl5W2LOoXGX/D7YlSlrnPJZHLI+57nbxvVxZQkAoEOwBADQcRC34a5eOb/xEtuSl7nHXqrcxy2m3lqmmLv+obHW7ftW5dg5e23mrHnKLb1dnsucccf2mXvJv9duzlqm3Dbc1es91P+4fd/mP9Tbe3NvsezrVumSY829NT12zqFxl/w+2JUlb9VO8eg5r43q48oSAECHYAkAoEOwBADQIVgCAOgQLAEAdAiWAAA6BEsAAB2CJQCADsESAECHYAkAoEOwBADQIVgCAOgQLAEAdAiWAAA6BEsAAB23nPYCkuTCxYdz+fJHbzj+kmc+b7DP5Qc/urHd+vHeWNv27xla55S1TDF3/UNjrRt6vcYa+1psO2evzZw1H1/vlM/YtmuZst4l+4z57Iz97C65ljHHx467bZue3us1Zc3bzrOPf7fmrnfK52Ddrs5xynhLft6WmHNo3CW/D3ZlyhqnfBaHrM957rZxfVxZAgDoECwBAHQIlgAAOgRLAAAdgiUAgI6D2A139cr5jU+6L7nbZOyOgX3s9OqtZYq56x8aa92+dwyOnbPXZs6ap+ys2+W5zBl3bJ+5O2967easZcruvV293kP9j9v3bttD3WU3d6fTvnYsLjnW3B2iY+ccGnfJ74NdWXLH5BSPnvPaqD6uLAEAdAiWAAA6DuI2nKSU8y4vSkq5uY2klNv1kZRyO5JSbiYp5bxb02PnHBpXUsqTSUoJALAwwRIAQIdgCQCgQ7AEANAhWAIA6BAsAQB0CJYAADoESwAAHYIlAIAOwRIAQIdgCQCgQ7AEANBxEIV0r145v7FI3pKFKscWG9xHkdjeWqaYu/6hsdbtu9jw2Dl7beaseUpR3l2ey5xxx/aZW7Sz127OWqYU/t3V6z3U/7h9F+o+1AK9c4uk7qvY8ZJjzS0uPXbOoXGX/D7YlSWLLU/x6DmvjerjyhIAQIdgCQCgQ7AEANAxO1iqqnNV9ctV9bOrn59dVR+sqk9X1U9X1ePnLxMA4HQscWXph5J8cu3nv5fkx1trdyX53SSvXmAOAIBTMWs3XFXdkeQvJvnRJH+rqirJi5L8pVWTtyb5X5O8sTfOhYsP5/LlG590X3K3ydgdA/vY6dVbyxRz1z801rp97xgcO2evzZw1T9lZt8tzmTPu2D5zd9702s1Zy5Tde7t6vYf6H7fv3baHustu7k6nfe1YXHKsuTtEx845NO6S3we7suSOySnW5zx327g+c68s/eMkP5zkD1c/Py3Jl1trX1v9fD3J7TPnAAA4NZODpar67iQPtdY+vH54Q9M20P/eqnqgqh744pe+PnUZAAA7Nec23HckeUVVvTzJE5I8KUdXmp5cVbesri7dkeTBTZ1ba/cluS9JLj33CRsDKgCA0zb5ylJr7fWttTtaa89K8sok/7619v1JfiHJ966a3ZPkPbNXCQBwSnaRZ+m1OXrY+1qOnmF60w7mAADYi0Vqw7XWfjHJL67+/pkkL1hiXACA06aQ7sj+PQrpnkwh3XnnMmfcsX0U0t2OQrqbKaQ7L53G2DmHxlVI92QK6QIALEywBADQcRC34WTwnnd5UQbvzW1k8N6ujwze25HBezMZvOfdmh4759C4Mnif7DQyeAMA3NQESwAAHYIlAIAOwRIAQIdgCQCg4yB2w0lKOe8pf0kpN7eRlHK7PpJSbkdSys0kpZy3Q3TsnEPjSkp5MkkpAQAWJlgCAOg4iNtwklLOu7woKeXmNpJSbtdHUsrtSEq5maSU825Nj51zaFxJKU8mKSUAwMIESwAAHYIlAICOg3hmSeqAefdipQ7Y3EbqgO36SB2wHakDNpM6YN5zfGPnHBpX6oCTSR0AALAwwRIAQMdB3IaTOmDe5UWpAza3kTpguz5SB2xH6oDNpA6Yd2t67JxD40odcDKpAwAAFiZYAgDoECwBAHQIlgAAOgRLAAAdgiUAgA7BEgBAh2AJAKBDsAQA0CFYAgDoECwBAHQcRG24q1fOb6z7smTtpbH1c/ZR96y3linmrn9orHX7rp83ds5emzlrnlJnbpfnMmfcsX3m1qHqtZuzlim17Hb1eg/1P27ftScPtebc3Lpf+6rft+RYc+sljp1zaNwlvw92Zcn6gVM8es5ro/q4sgQA0CFYAgDoECwBAHQcxDNLFy4+nMuXb7wfueQzAWPv6+7jeZzeWqaYu/6hsdbt+7musXP22sxZ85Tnn3Z5LnPGHdtn7vMRvXZz1jLlGatdvd5D/Y/b9zORh/os1NznUfb1XNmSY819jm/snEPjLvl9sCtLPtc2xfqc524b18eVJQCADsESAEDHQdyGkzpg3uVFqQM2t5E6YLs+UgdsR+qAzaQOmHdreuycQ+NKHXAyqQMAABYmWAIA6BAsAQB0CJYAADoESwAAHQexG05SynlP+UtKubmNpJTb9ZGUcjuSUm4mKeW8HaJj5xwaV1LKk0lKCQCwMMESAECHYAkAoEOwBADQIVgCAOgQLAEAdBxE6gCFdOdtiVRId3MbhXS366OQ7nYU0t1MId156TTGzjk0rkK6J1NIFwBgYYIlAICOg7gNJ4P3vMuLMnhvbiOD93Z9ZPDejgzem8ngPe/W9Ng5h8aVwftke8/gXVVPrqp3VdWvVdUnq+pPV9VTq+q9VfXp1Z9PmTMHAMBpmnsb7p8k+bettT+R5LlJPpnkdUne11q7K8n7Vj8DADwmTQ6WqupJSf5ckjclSWvt91trX05yd5K3rpq9Ncn3zF0kAMBpmXNl6ZuSfDHJv6iqX66qn6yqJyb5xtbaF5Jk9eczFlgnAMCpmBMs3ZLk+Une2Fr7tiT/JVvccquqe6vqgap64Itf+vqMZQAA7M6c3XDXk1xvrX1w9fO7chQs/VZV3dZa+0JV3ZbkoU2dW2v3JbkvSZ5UT22SUk4nKeXmNpJSbtdHUsrtSEq5maSU83aIjp1zaFxJKU+216SUrbXfTPL5qvrm1aEXJ/lEkvuT3LM6dk+S90ydAwDgtM3Ns/SDSd5WVY9P8pkkfyVHAdg7q+rVST6X5PtmzgEAcGqqtXbaa8il5z6hfejynTccl5Ry+/klpdyu/5i5j/eXlHLzWL12c9YiKeXp3RqXlHL7sSSlPNlhJaW89uHW2qWT+ih3AgDQIVgCAOgQLAEAdAiWAAA6BEsAAB2CJQCADsESAECHYAkAoEOwBADQMbfcySKuXjm/MTunQrrbz6+Q7nb9x8x9vL9CupvH6rWbsxaFdE8vq75CutuPpZDuyc5UIV0AgLNAsAQA0HEQt+EuXHw4ly/feIlNId3t51dId7v+Y+Y+3l8h3c1j9drNWYtCuqd3a1wh3e3HUkj3ZIdVSHdcH1eWAAA6BEsAAB2CJQCADsESAECHYAkAoEOwBADQIVgCAOgQLAEAdAiWAAA6DiKDt0K68zKTKqS7uY1Cutv1UUh3OwrpbqaQ7rys9mPnHBpXId2TKaQLALAwwRIAQMdB3IZTSHfe5UWFdDe3UUh3uz4K6W5HId3NFNKdd2t67JxD4yqkezKFdAEAFiZYAgDoOIjbcHbDzbu8aDfc5jZ2w23Xx2647dgNt5ndcPNuTY+dc2hcu+FOZjccAMDCBEsAAB2CJQCADsESAECHYAkAoEOwBADQIVgCAOgQLAEAdBxEUkq14eYl21IbbnMbteG266M23HbUhttMbbh5iVrHzjk0rtpwJ1MbDgBgYYIlAIAOwRIAQMdBPLOkkO68e7EK6W5uo5Dudn0U0t2OQrqbKaQ77zm+sXMOjauQ7skU0gUAWJhgCQCgQ7AEANAhWAIA6BAsAQB0HMRuOBm85z3lL4P35jYyeG/XRwbv7cjgvZkM3vN2iI6dc2hcGbxPJoM3AMDCBEsAAB2CJQCADsESAECHYAkAoEOwBADQIVgCAOiYFSxV1d+sqo9X1ceq6u1V9YSqenZVfbCqPl1VP11Vj19qsQAA+1attWkdq25P8h+TPKe19v9W1TuT/FySlyd5d2vtHVX1z5P8Smvtjb2xnlRPbd9eL77h+JJJ38Ym7tpHwsXeWqaYu/6hsdbtO3Hn2Dl7beaseUqCy12ey5xxx/aZmwCv127OWqYk0dzV6z3U/7h9J7091GSXcxMO7itx6JJjzU3UOnbOoXGX/D7YlSUTl06xPufPt3d9uLV26aQ+c2/D3ZLkj1TVLUnOJ/lCkhcledfq929N8j0z5wAAODWTg6XW2m8k+YdJPpejIOkrST6c5Mutta+tml1Pcvum/lV1b1U9UFUP/EG+OnUZAAA7NTlYqqqnJLk7ybOTPDPJE5O8bEPTjff5Wmv3tdYutdYuPS63Tl0GAMBOzSmk+xeSfLa19sUkqap3J/kzSZ5cVbesri7dkeTBkwZSSHfevViFdDe3UUh3uz4K6W5HId3NFNKd9xzf2DmHxlVI92T7LqT7uSQvrKrzVVVJXpzkE0l+Icn3rtrck+Q9M+YAADhVc55Z+mCOHuT+SJJfXY11X5LXJvlbVXUtydOSvGmBdQIAnIrJqQOWJHXAvMuLUgdsbiN1wHZ9pA7YjtQBm0kdMO/W9Ng5h8aVOuBkp5E6AADgpiZYAgDomLMbbjF2w827vGg33OY2dsNt18duuO3YDbeZ3XDzbk2PnXNoXLvhTrbv3XAAADc9wRIAQMdB3Ia7euX8xktsdsNtP7/dcNv1HzP38f52w20eq9duzlrshju9W+N2w20/lt1wJzuk3XDJtVF9XFkCAOgQLAEAdBzEbTi74eZdXrQbbnMbu+G262M33HbshtvMbrh5t6bHzjk0rt1wJ7MbDgBgYYIlAIAOwRIAQIdgCQCgQ7AEANAhWAIA6DiI1AEyeM/bEimD9+Y2Mnhv10cG7+3I4L2ZDN7z0mmMnXNoXBm8TyaDNwDAwgRLAAAdB3EbTgbveZcXZfDe3EYG7+36yOC9HRm8N5PBe96t6bFzDo0rg/fJZPAGAFiYYAkAoEOwBADQIVgCAOgQLAEAdBzEbjhJKec95S8p5eY2klJu10dSyu1ISrmZpJTzdoiOnXNoXEkpTyYpJQDAwgRLAAAdB3EbTlLKeZcXJaXc3EZSyu36SEq5HUkpN5OUct6t6bFzDo0rKeXJJKUEAFiYYAkAoEOwBADQIVgCAOgQLAEAdAiWAAA6BEsAAB2CJQCADsESAECHYAkAoEOwBADQIVgCAOg4iEK6V6+c31gkb8lClWOLDe6jSGxvLVPMXf/QWOv2XWx47Jy9NnPWPKUo7y7PZc64Y/vMLdrZazdnLVMK/+7q9R7qf9y+C3UfaoHeuUVS91XseMmx5haXHjvn0LhLfh/sypLFlqd49JzXRvVxZQkAoEOwBADQIVgCAOgQLAEAdAiWAAA6BEsAAB0HkTrgwsWHc/nyjdsCl9yaO3Z75T62xffWMsXc9Q+NtW7f6RXGztlrM2fNU9IQ7PJc5ow7ts/cbcq9dnPWMiXVwa5e76H+x+07NcmhpiSYuy18X+kdlhxrbjqNsXMOjbvk98GuLJleYor1Oc/dNq6PK0sAAB2CJQCAjoO4DSeD97zLizJ4b24jg/d2fWTw3o4M3pvJ4D3v1vTYOYfGlcH7ZDJ4AwAsTLAEANBxELfh7Iabd3nRbrjNbeyG266P3XDbsRtuM7vh5t2aHjvn0Lh2w51sJ7vhqurNVfVQVX1s7dhTq+q9VfXp1Z9PWR2vqvqJqrpWVVeq6vlbnwUAwAEZcxvuLUleeuzY65K8r7V2V5L3rX5OkpcluWv1371J3rjMMgEATseJwVJr7f1JfufY4buTvHX197cm+Z614z/VjnwgyZOrauRFLgCAwzP1Ae9vbK19IUlWfz5jdfz2JJ9fa3d9dQwA4DFp6d1wteFY29iw6t6qeqCqHvjil76+8DIAAJYxNVj6rUdur63+fGh1/HqSO9fa3ZHkwU0DtNbua61daq1d+oannZu4DACA3ZoaLN2f5J7V3+9J8p614z+w2hX3wiRfeeR2HQDAY9GJeZaq6u1JvjPJ06vqepIfSfJjSd5ZVa9O8rkk37dq/nNJXp6j/OEPJ/krO1gzAMDenBgstdZeNfCrF29o25K8Zu6iAAAOhXInAAAdgiUAgA7BEgBAx0EU0r165fzGInlLFqocW2xwH0Vie2uZYu76h8Zat+9iw2Pn7LWZs+YpRXl3eS5zxh3bZ27Rzl67OWuZUvh3V6/3UP/j9l2o+1AL9M4tkrqvYsdLjjW3uPTYOYfGXfL7YFeWLLY8xaPnvDaqjytLAAAdgiUAgA7BEgBAh2AJAKBDsAQA0HEQu+EuXHw4ly/f+KT7krtNxu4Y2MdOr95appi7/qGx1u17x+DYOXtt5qx5ys66XZ7LnHHH9pm786bXbs5apuze29XrPdT/uH3vtj3UXXZzdzrta8fikmPN3SE6ds6hcZf8PtiVJXdMTrE+57nbxvVxZQkAoEOwBADQcRC34SSlnHd5UVLKzW0kpdyuj6SU25GUcjNJKefdmh4759C4klKeTFJKAICFCZYAADoESwAAHYIlAIAOwRIAQIdgCQCgQ7AEANAhWAIA6BAsAQB0CJYAADoESwAAHYIlAICOgyike+Hiw7l8+cYieUsWqhxbbHAfRWJ7a5li7vqHxlq372LDY+fstZmz5ilFeXd5LnPGHdtnbtHOXrs5a5lS+HdXr/dQ/+P2Xaj7UAv0zi2Suq9ix0uONbe49Ng5h8Zd8vtgV5YstjzF+pznbhvXx5UlAIAOwRIAQIdgCQCgQ7AEANAhWAIA6DiI3XBXr5zf+KT7krtNxu4Y2MdOr95appi7/qGx1u17x+DYOXtt5qx5ys66XZ7LnHHH9pm786bXbs5apuze29XrPdT/uH3vtj3UXXZzdzrta8fikmPN3SE6ds6hcZf8PtiVJXdMTvHoOa+N6uPKEgBAh2AJAKDjIG7DSUo57/KipJSb20hKuV0fSSm3IynlZpJSzrs1PXbOoXElpTyZpJQAAAsTLAEAdAiWAAA6BEsAAB2CJQCADsESAECHYAkAoEOwBADQIVgCAOgQLAEAdAiWAAA6BEsAAB0HUUj36pXzG4vkLVmocmyxwX0Uie2tZYq56x8aa92+iw2PnbPXZs6apxTl3eW5zBl3bJ+5RTt77easZUrh31293kP9j9t3oe5DLdA7t0jqvoodLznW3OLSY+ccGnfJ74NdWbLY8hSPnvPaqD6uLAEAdAiWAAA6DuI23IWLD+fy5RsvsS15mXvspcp93GLqrWWKuesfGmvdvm9Vjp2z12bOmqfc0tvlucwZd2yfuZf8e+3mrGXKbcNdvd5D/Y/b923+Q729N/cWy75ulS451txb02PnHBp3ye+DXVnyVu0U63Oeu21cH1eWAAA6BEsAAB2CJQCADsESAEDHicFSVb25qh6qqo+tHfsHVfVrVXWlqv51VT157Xevr6prVfWpqnrJrhYOALAPY64svSXJS48de2+Sb22tXUxyNcnrk6SqnpPklUm+ZdXnn1XVucVWCwCwZycGS6219yf5nWPH/l1r7WurHz+Q5I7V3+9O8o7W2ldba5/NUWrMFyy4XgCAvVrimaW/muTfrP5+e5LPr/3u+urYDarq3qp6oKoe+OKXvr7AMgAAljcrWKqqNyT5WpK3PXJoQ7O2qW9r7b7W2qXW2qVveJo7dQDAYZqcwbuq7kny3Ule3Fp7JCC6nuTOtWZ3JHnwpLEU0p2XmVQh3c1tFNLdro9CuttRSHczhXTnZbUfO+fQuArpnmxvhXSr6qVJXpvkFa21h9d+dX+SV1bVrVX17CR3JfnQlDkAAA7BiVeWqurtSb4zydOr6nqSH8nR7rdbk7y3qpLkA621/6G19vGqemeST+To9txrWmseSAIAHrNODJZaa6/acPhNnfY/muRH5ywKAOBQyOANANAhWAIA6Ji8G25JFy4+nMuXb3zSfcndJmN3DOxjp1dvLVPMXf/QWOv2vWNw7Jy9NnPWPGVn3S7PZc64Y/vM3XnTazdnLVN27+3q9R7qf9y+d9se6i67uTud9rVjccmx5u4QHTvn0LhLfh/sypI7JqdYn/PcbeP6uLIEANAhWAIA6DiI23CSUs67vCgp5eY2klJu10dSyu1ISrmZpJTzbk2PnXNoXEkpT7a3pJQAAGeFYAkAoEOwBADQIVgCAOgQLAEAdAiWAAA6BEsAAB2CJQCADsESAECHYAkAoEOwBADQIVgCAOg4iELIbMD9AAAQFUlEQVS6Fy4+nMuXbyySt2ShyrHFBvdRJLa3linmrn9orHX7LjY8ds5emzlrnlKUd5fnMmfcsX3mFu3stZuzlimFf3f1eg/1P27fhboPtUDv3CKp+yp2vORYc4tLj51zaNwlvw92Zcliy1Osz3nutnF9XFkCAOgQLAEAdAiWAAA6BEsAAB2CJQCADsESAEDHQaQOuHrl/MZtgUtuzR27vXIf2+J7a5li7vqHxlq37/QKY+fstZmz5ilpCHZ5LnPGHdtn7jblXrs5a5mS6mBXr/dQ/+P2nZrkUFMSzN0Wvq/0DkuONTedxtg5h8Zd8vtgV5ZMLzHFo+e8NqqPK0sAAB2CJQCADsESAECHYAkAoEOwBADQIVgCAOgQLAEAdAiWAAA6BEsAAB2CJQCADsESAEDHQdSGu3Dx4Vy+fGPdlyVrL42tn7OPume9tUwxd/1DY63bd/28sXP22sxZ85Q6c7s8lznjju0ztw5Vr92ctUypZber13uo/3H7rj15qDXn5tb92lf9viXHmlsvceycQ+Mu+X2wK0vWD5xifc5zt43r48oSAECHYAkAoEOwBADQIVgCAOgQLAEAdAiWAAA6DiJ1wNUr5zduC1xya+7Y7ZX72BbfW8sUc9c/NNa6fadXGDtnr82cNU9JQ7DLc5kz7tg+c7cp99rNWcuUVAe7er2H+h+379Qkh5qSYO628H2ld1hyrLnpNMbOOTTukt8Hu7JkeokpHj3ntVF9XFkCAOgQLAEAdBzEbTgZvOddXpTBe3MbGby36yOD93Zk8N5MBu95t6bHzjk0rgzeJ5PBGwBgYYIlAIAOwRIAQIdgCQCgQ7AEANBxELvhJKWc95S/pJSb20hKuV0fSSm3IynlZpJSztshOnbOoXElpTzZTpJSVtWbq+qhqvrYht/9napqVfX01c9VVT9RVdeq6kpVPX/s4gEADtGY23BvSfLS4wer6s4k35Xkc2uHX5bkrtV/9yZ54/wlAgCcnhODpdba+5P8zoZf/XiSH07S1o7dneSn2pEPJHlyVY1M+QQAcHgmPeBdVa9I8huttV859qvbk3x+7efrq2MAAI9JWz/gXVXnk7whyX+76dcbjrUNx1JV9+boVl2ekPPbLgMAYC+mXFn640meneRXqurXk9yR5CNV9cdydCXpzrW2dyR5cNMgrbX7WmuXWmuXHpdbJywDAGD3tg6WWmu/2lp7RmvtWa21Z+UoQHp+a+03k9yf5AdWu+JemOQrrbUvLLtkAID9GZM64O1J/lOSb66q61X16k7zn0vymRwlLvg/kvyPi6wSAOCUnPjMUmvtVSf8/llrf29JXjN/WQAAh0G5EwCADsESAECHYAkAoOMgCuleuPhwLl++sUjekoUqxxYb3EeR2N5appi7/qGx1u272PDYOXtt5qx5SlHeXZ7LnHHH9plbtLPXbs5aphT+3dXrPdT/uH0X6j7UAr1zi6Tuq9jxkmPNLS49ds6hcZf8PtiVJYstT7E+57mRNUZcWQIA6BAsAQB0CJYAADoESwAAHYIlAIAOwRIAQIdgCQCgQ7AEANBxEEkpr145vzHh1JJJ38Ym7tpHwsXeWqaYu/6hsdbtO3Hn2Dl7beaseUqCy12ey5xxx/aZmwCv127OWqYk0dzV6z3U/7h9J7091GSXcxMO7itx6JJjzU3UOnbOoXGX/D7YlSUTl07x6DmvjerjyhIAQIdgCQCgQ7AEANBxEM8sKaQ7716sQrqb2yiku10fhXS3o5DuZgrpznuOb+ycQ+MqpHsyhXQBABYmWAIA6DiI23BSB8y7vCh1wOY2Ugds10fqgO1IHbCZ1AHzbk2PnXNoXKkDTiZ1AADAwgRLAAAdgiUAgA7BEgBAh2AJAKBDsAQA0CFYAgDoECwBAHQIlgAAOgRLAAAdgiUAgA7BEgBAh2AJAKBDsAQA0CFYAgDoECwBAHQIlgAAOgRLAAAdgiUAgA7BEgBAh2AJAKBDsAQA0CFYAgDoECwBAHQIlgAAOgRLAAAdgiUAgA7BEgBAh2AJAKBDsAQA0CFYAgDoECwBAHQIlgAAOgRLAAAdgiUAgI4Tg6WqenNVPVRVHzt2/Aer6lNV9fGq+vtrx19fVddWv3vJLhYNALAvt4xo85Yk/3uSn3rkQFX9+SR3J7nYWvtqVT1jdfw5SV6Z5FuSPDPJz1fVhdba15deOADAPpwYLLXW3l9Vzzp2+K8l+bHW2ldXbR5aHb87yTtWxz9bVdeSvCDJf+rNceHiw7l8+aM3HH/JM5832Ofygx/d2G79eG+sbfv3DK1zylqmmLv+obHWDb1eY419Lbads9dmzpqPr3fKZ2zbtUxZ75J9xnx2xn52l1zLmONjx922TU/v9Zqy5m3n2ce/W3PXO+VzsG5X5zhlvCU/b0vMOTTukt8HuzJljVM+i0PW5zx327g+U59ZupDkz1bVB6vqP1TVn1odvz3J59faXV8du0FV3VtVD1TVA1/8kgtPAMBhmhos3ZLkKUlemOTvJnlnVVWS2tC2bRqgtXZfa+1Sa+3SNzzt3MRlAADs1phnlja5nuTdrbWW5ENV9YdJnr46fudauzuSPHjSYFevnN94iW3Jy9xjL1Xu4xZTby1TzF3/0Fjr9n2rcuycvTZz1jzllt4uz2XOuGP7zL3k32s3Zy1Tbhvu6vUe6n/cvm/zH+rtvbm3WPZ1q3TJsebemh4759C4S34f7MqSt2qnePSc10b1mXpl6WeSvChJqupCkscn+e0k9yd5ZVXdWlXPTnJXkg9NnAMA4NSdeGWpqt6e5DuTPL2qrif5kSRvTvLmVTqB309yz+oq08er6p1JPpHka0leYyccAPBYNmY33KsGfvXfDbT/0SQ/OmdRAACHQgZvAIAOwRIAQIdgCQCgQ7AEANAhWAIA6BAsAQB0TM3gvSiFdOdlJlVId3MbhXS366OQ7nYU0t1MId15We3Hzjk0rkK6J9tnIV0AgDNBsAQA0CFYAgDoECwBAHQIlgAAOgRLAAAdgiUAgA7BEgBAh2AJAKBDsAQA0CFYAgDoECwBAHQIlgAAOgRLAAAdgiUAgA7BEgBAh2AJAKBDsAQA0HHLaS8gSa5eOZ+XPPN5Nxy//OBHB/ust19vt2mcTWNt279naJ1T1jLF3PUPjbVu6PUaa+xrse2cvTZz1nx8vVM+Y9uuZcp6l+wz5rMz9rO75FrGHB877rZtenqv15Q1bzvPPv7dmrveKZ+Ddbs6xynjLfl5W2LOoXGX/D7YlSlrnPJZHPLoOa+N6uPKEgBAh2AJAKCjWmunvYZU1ReT/D9Jnp7kt095OaflLJ974vzP8vmf5XNPzvb5n+VzT872+R/Kuf/XrbVvOKnRQQRLj6iqB1prl057HafhLJ974vzP8vmf5XNPzvb5n+VzT872+T/Wzt1tOACADsESAEDHoQVL9532Ak7RWT73xPmf5fM/y+eenO3zP8vnnpzt839MnftBPbMEAHBoDu3KEgDAQTmIYKmqXlpVn6qqa1X1utNez65V1Z1V9QtV9cmq+nhV/dDq+FOr6r1V9enVn0857bXuSlWdq6pfrqqfXf387Kr64Orcf7qqHn/aa9yVqnpyVb2rqn5t9Rn402flva+qv7n6zH+sqt5eVU+4md/7qnpzVT1UVR9bO7bxva4jP7H6d/BKVT3/9Fa+jIHz/werz/6VqvrXVfXktd+9fnX+n6qql5zOqpez6fzXfvd3qqpV1dNXP99U7//QuVfVD67e349X1d9fO37Q7/2pB0tVdS7JP03ysiTPSfKqqnrO6a5q576W5G+31v5kkhcmec3qnF+X5H2ttbuSvG/1883qh5J8cu3nv5fkx1fn/rtJXn0qq9qPf5Lk37bW/kSS5+bodbjp3/uquj3J/5TkUmvtW5OcS/LK3Nzv/VuSvPTYsaH3+mVJ7lr9d2+SN+5pjbv0ltx4/u9N8q2ttYtJriZ5fZKs/g18ZZJvWfX5Z6vvh8eyt+TG809V3Znku5J8bu3wzfb+vyXHzr2q/nySu5NcbK19S5J/uDp+8O/9qQdLSV6Q5Fpr7TOttd9P8o4cvZg3rdbaF1prH1n9/fdy9GV5e47O+62rZm9N8j2ns8Ldqqo7kvzFJD+5+rmSvCjJu1ZNbuZzf1KSP5fkTUnSWvv91tqXc0be+xzVo/wjVXVLkvNJvpCb+L1vrb0/ye8cOzz0Xt+d5KfakQ8keXJV3bafle7GpvNvrf271trXVj9+IMkdq7/fneQdrbWvttY+m6OiXS/Y22J3YOD9T5IfT/LDSdYfGr6p3v+Bc/9rSX6stfbVVZuHVscP/r0/hGDp9iSfX/v5+urYmVBVz0rybUk+mOQbW2tfSI4CqiTPOL2V7dQ/ztE/FH+4+vlpSb689g/ozfwZ+KYkX0zyL1a3IX+yqp6YM/Det9Z+I0f/T/JzOQqSvpLkwzk77/0jht7rs/hv4V9N8m9Wfz8T519Vr0jyG621Xzn2q7Nw/heS/NnVbff/UFV/anX84M/9EIKl2nDsTGzRq6o/muRfJfkbrbX/fNrr2Yeq+u4kD7XWPrx+eEPTm/UzcEuS5yd5Y2vt25L8l9yEt9w2WT2bc3eSZyd5ZpIn5ujWw3E363t/krP0v4NU1Rty9EjC2x45tKHZTXX+VXU+yRuS/C+bfr3h2E11/jn69+8pOXr85O8meefqzsLBn/shBEvXk9y59vMdSR48pbXsTVU9LkeB0ttaa+9eHf6tRy67rv58aKj/Y9h3JHlFVf16jm65vihHV5qevLo1k9zcn4HrSa631j64+vldOQqezsJ7/xeSfLa19sXW2h8keXeSP5Oz894/Yui9PjP/FlbVPUm+O8n3t/8/f81ZOP8/nqP/s/Arq38D70jykar6Yzkb5389ybtXtxo/lKO7C0/PY+DcDyFY+qUkd612xDw+Rw953X/Ka9qpVST9piSfbK39o7Vf3Z/kntXf70nynn2vbddaa69vrd3RWntWjt7rf99a+/4kv5Dke1fNbspzT5LW2m8m+XxVffPq0IuTfCJn4L3P0e23F1bV+dX/Bh459zPx3q8Zeq/vT/IDq11RL0zylUdu191MquqlSV6b5BWttYfXfnV/kldW1a1V9ewcPej8odNY46601n61tfaM1tqzVv8GXk/y/NW/C2fh/f+ZHP0f5FTVhSSPz1Ex3cN/71trp/5fkpfnaFfE/53kDae9nj2c73+To0uMV5J8dPXfy3P07M77knx69edTT3utO34dvjPJz67+/k05+h/HtST/Msmtp72+HZ7385I8sHr/fyZHl6XPxHuf5H9L8mtJPpbk/0xy68383id5e46ez/qDHH0xvnrovc7RrYh/uvp38FdztGvw1M9hB+d/LUfPpzzyb98/X2v/htX5fyrJy057/bs4/2O///UkT78Z3/+B9/7xSf6v1f/+P5LkRY+V914GbwCAjkO4DQcAcLAESwAAHYIlAIAOwRIAQIdgCQCgQ7AEANAhWAIA6BAsAQB0/H+nL7IJeGuinQAAAABJRU5ErkJggg==\n",
"text/plain": [
"

"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"# YOU ARE REQUIRED TO INSERT YOUR CODES IN THIS CELL\n",
"'''\n",
"2. Compute the absolute difference matrix for Y_pred and visualise the matrix\n",
"Hint: You might want to use imshow function.\n",
"'''\n",
"\n",
"# compute the absolute difference matrix\n",
"abs_difference_matrix = compute_abs_difference_matrix(Y_pred)\n",
"print(abs_difference_matrix)\n",
"\n",
"# visualise the matrix\n",
"fig = plt.figure(figsize=(10,10))\n",
"plt.imshow(abs_difference_matrix)\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 85,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[0. 3.74165739 9. ... 7.93725393 9.89949494 5.29150262]\n",
" [3.74165739 0. 7.54983444 ... 6.8556546 8.1240384 4.24264069]\n",
" [9. 7.54983444 0. ... 5.47722558 3.31662479 9.64365076]\n",
" ...\n",
" [7.93725393 6.8556546 5.47722558 ... 0. 5.56776436 7.81024968]\n",
" [9.89949494 8.1240384 3.31662479 ... 5.56776436 0. 9.38083152]\n",
" [5.29150262 4.24264069 9.64365076 ... 7.81024968 9.38083152 0. ]]\n"
]
},
{
"data": {
"image/png":...