diff --git a/cs2109s/labs/ps4/housing_data.csv b/cs2109s/labs/ps4/housing_data.csv new file mode 100644 index 0000000..bf37a4c --- /dev/null +++ b/cs2109s/labs/ps4/housing_data.csv @@ -0,0 +1,91 @@ +floor_area_sqm,bedrooms,schools,asking_price +60,2,3,480000.0 +63,2,4,450000.0 +65,2,1,480000.0 +65,2,4,360000.0 +66,2,5,350000.0 +67,2,0,400000.0 +67,2,1,430000.0 +67,2,2,450000.0 +67,2,3,410000.0 +67,2,4,390000.0 +67,2,5,390000.0 +67,2,6,390000.0 +68,2,1,460000.0 +68,2,2,400000.0 +68,2,3,370000.0 +68,2,4,360000.0 +68,2,6,370000.0 +68,2,7,400000.0 +68,2,8,370000.0 +69,2,3,420000.0 +70,2,3,510000.0 +70,2,8,370000.0 +73,2,5,370000.0 +73,2,7,380000.0 +83,2,1,590000.0 +83,3,1,650000.0 +83,3,2,550000.0 +83,3,3,550000.0 +83,3,4,580000.0 +84,3,3,560000.0 +86,3,2,560000.0 +88,3,3,510000.0 +89,3,1,610000.0 +90,3,3,500000.0 +90,3,4,520000.0 +90,3,5,490000.0 +91,3,0,550000.0 +91,3,3,620000.0 +92,3,1,490000.0 +92,3,2,590000.0 +92,3,3,490000.0 +92,3,4,510000.0 +92,3,5,490000.0 +92,3,6,490000.0 +92,3,7,510000.0 +93,3,0,490000.0 +93,3,1,660000.0 +93,3,2,540000.0 +93,3,3,550000.0 +93,3,4,490000.0 +93,3,5,510000.0 +93,3,6,490000.0 +93,3,7,490000.0 +94,3,2,590000.0 +94,3,3,550000.0 +94,3,4,490000.0 +94,3,5,540000.0 +95,3,1,700000.0 +95,3,2,620000.0 +95,3,3,530000.0 +95,3,4,540000.0 +96,3,2,600000.0 +96,3,7,480000.0 +97,3,1,660000.0 +97,3,2,600000.0 +97,3,4,440000.0 +98,3,5,450000.0 +104,3,1,720000.0 +105,3,0,630000.0 +105,3,1,670000.0 +105,3,2,670000.0 +105,4,1,610000.0 +108,3,1,780000.0 +109,3,2,700000.0 +110,3,3,670000.0 +110,3,4,660000.0 +111,3,3,640000.0 +112,3,1,700000.0 +112,3,2,660000.0 +112,3,3,670000.0 +112,3,4,650000.0 +113,3,1,640000.0 +113,3,2,590000.0 +113,3,3,600000.0 +113,3,4,590000.0 +113,3,5,590000.0 +115,3,1,720000.0 +115,3,2,700000.0 +119,4,3,690000.0 +124,3,1,770000.0 diff --git a/cs2109s/labs/ps4/imgs/add_bias.jpeg b/cs2109s/labs/ps4/imgs/add_bias.jpeg new file mode 100644 index 0000000..19b782f Binary files /dev/null and b/cs2109s/labs/ps4/imgs/add_bias.jpeg differ diff --git a/cs2109s/labs/ps4/imgs/bias_scatter.ipynb b/cs2109s/labs/ps4/imgs/bias_scatter.ipynb new file mode 100644 index 0000000..b6ce3ea --- /dev/null +++ b/cs2109s/labs/ps4/imgs/bias_scatter.ipynb @@ -0,0 +1,87 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "f64907f4", + "metadata": {}, + "outputs": [], + "source": [ + "# CODE TO GENERATE bias_scatter.png\n", + "import numpy as np\n", + "from sklearn.linear_model import LinearRegression" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf22eb4a", + "metadata": {}, + "outputs": [], + "source": [ + "X = np.array([1, 2, 3, 4, 5, 6]).reshape((-1, 1))\n", + "y = np.array([6, 7, 8, 8, 9, 11])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b185d8b9", + "metadata": {}, + "outputs": [], + "source": [ + "model_no_bias = LinearRegression(fit_intercept = False).fit(X, y)\n", + "model_with_bias = LinearRegression().fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f5076cdc", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "X_with_zero = np.vstack([0, X]) # Added to show the lines passing through Feature=0\n", + "plt.scatter(X, y)\n", + "plt.plot(X_with_zero, model_no_bias.predict(X_with_zero), color = 'b', label=\"Without bias\")\n", + "plt.plot(X_with_zero, model_with_bias.predict(X_with_zero), color = 'r', label=\"With bias\")\n", + "plt.ylim(ymin=0)\n", + "plt.xlim(xmin=0, xmax=8)\n", + "plt.xlabel(\"Feature\")\n", + "plt.ylabel(\"Target\")\n", + "plt.legend(loc=\"center right\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e68dd023", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/cs2109s/labs/ps4/imgs/bias_scatter.png b/cs2109s/labs/ps4/imgs/bias_scatter.png new file mode 100644 index 0000000..c7671a9 Binary files /dev/null and b/cs2109s/labs/ps4/imgs/bias_scatter.png differ diff --git a/cs2109s/labs/ps4/imgs/feature_scaling.png b/cs2109s/labs/ps4/imgs/feature_scaling.png new file mode 100644 index 0000000..2145dfc Binary files /dev/null and b/cs2109s/labs/ps4/imgs/feature_scaling.png differ diff --git a/cs2109s/labs/ps4/imgs/grad_desc_algorithm.png b/cs2109s/labs/ps4/imgs/grad_desc_algorithm.png new file mode 100644 index 0000000..11a9eb2 Binary files /dev/null and b/cs2109s/labs/ps4/imgs/grad_desc_algorithm.png differ diff --git a/cs2109s/labs/ps4/imgs/grad_desc_algorithm.tex b/cs2109s/labs/ps4/imgs/grad_desc_algorithm.tex new file mode 100644 index 0000000..7ab2deb --- /dev/null +++ b/cs2109s/labs/ps4/imgs/grad_desc_algorithm.tex @@ -0,0 +1,24 @@ +% CODE TO GENERATE grad_desc_algorithm.tex +\documentclass{article} +\usepackage{algorithm2e} +\usepackage{bm} +\begin{document} +\RestyleAlgo{ruled} +\DontPrintSemicolon +\begin{algorithm}[hbt!] + \caption{Gradient Descent for Linear Regression} + $w_0, w_1, \ldots, w_n \gets 0$\; + \For{$i\gets 1$ \KwTo $N$}{ + $w'_0 \gets w_0 - \alpha\frac{\partial J(\boldsymbol{w})}{\partial w_0}$\; + $w'_1 \gets w_1 - \alpha\frac{\partial J(\boldsymbol{w})}{\partial w_1}$\; + $\vdots$\; + $w'_n \gets w_n - \alpha\frac{\partial J(\boldsymbol{w})}{\partial w_n}$\; + $w_0 \gets w'_0$\; + $w_1 \gets w'_1$\; + $\vdots$\; + $w_n \gets w'_n$\; + $loss \gets J(\boldsymbol{w})$\; + } +\end{algorithm} + +\end{document} \ No newline at end of file diff --git a/cs2109s/labs/ps4/imgs/linear_reg.png b/cs2109s/labs/ps4/imgs/linear_reg.png new file mode 100644 index 0000000..c3e85cd Binary files /dev/null and b/cs2109s/labs/ps4/imgs/linear_reg.png differ diff --git a/cs2109s/labs/ps4/imgs/loss.png b/cs2109s/labs/ps4/imgs/loss.png new file mode 100644 index 0000000..564d877 Binary files /dev/null and b/cs2109s/labs/ps4/imgs/loss.png differ diff --git a/cs2109s/labs/ps4/imgs/mse_plot.png b/cs2109s/labs/ps4/imgs/mse_plot.png new file mode 100644 index 0000000..7abd43f Binary files /dev/null and b/cs2109s/labs/ps4/imgs/mse_plot.png differ diff --git a/cs2109s/labs/ps4/imgs/poly_matrix.png b/cs2109s/labs/ps4/imgs/poly_matrix.png new file mode 100644 index 0000000..144a799 Binary files /dev/null and b/cs2109s/labs/ps4/imgs/poly_matrix.png differ diff --git a/cs2109s/labs/ps4/imgs/poly_reg.png b/cs2109s/labs/ps4/imgs/poly_reg.png new file mode 100644 index 0000000..955f801 Binary files /dev/null and b/cs2109s/labs/ps4/imgs/poly_reg.png differ diff --git a/cs2109s/labs/ps4/imgs/school_price_rel.png b/cs2109s/labs/ps4/imgs/school_price_rel.png new file mode 100644 index 0000000..96c9504 Binary files /dev/null and b/cs2109s/labs/ps4/imgs/school_price_rel.png differ diff --git a/cs2109s/labs/ps4/imgs/school_price_rel_cubicfit.png b/cs2109s/labs/ps4/imgs/school_price_rel_cubicfit.png new file mode 100644 index 0000000..0a1ed44 Binary files /dev/null and b/cs2109s/labs/ps4/imgs/school_price_rel_cubicfit.png differ diff --git a/cs2109s/labs/ps4/imgs/school_price_rel_linearfit.png b/cs2109s/labs/ps4/imgs/school_price_rel_linearfit.png new file mode 100644 index 0000000..610a8e1 Binary files /dev/null and b/cs2109s/labs/ps4/imgs/school_price_rel_linearfit.png differ diff --git a/cs2109s/labs/ps4/ps4.ipynb b/cs2109s/labs/ps4/ps4.ipynb new file mode 100644 index 0000000..72f0fe4 --- /dev/null +++ b/cs2109s/labs/ps4/ps4.ipynb @@ -0,0 +1,1278 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problem Set 4: Predicting House Prices in Singapore\n", + "\n", + "**Release Date:** 13 February 2024\n", + "\n", + "**Due Date:** 23:59, 24 February 2024" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overview\n", + "\n", + "We have learned how to solve a regression problem using linear regression in class.\n", + "In this problem set, we will apply our knowledge to solve a real-world problem. More\n", + "specifically, we will develop linear regression and polynomial regression models to predict\n", + "house prices in Singapore.\n", + "\n", + "**Required Files**:\n", + "* ps4.ipynb\n", + "* housing_data.csv\n", + "\n", + "**Honour Code**: Note that plagiarism will not be condoned! You may discuss with your classmates and check the internet for references, but you MUST NOT submit code/report that is copied directly from other sources!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Orientation to files\n", + "\n", + "**ps4.ipynb**:\n", + "The template for all your tasks is provided in this file. Some test cases have\n", + "been provided for you to check the output of your algorithm against the expected result. The tests are **not** comprehensive, and you are\n", + "encouraged to write your own tests to check for correctness.\n", + "\n", + "**housing.csv**:\n", + "There are 90 housing data points. Each data point consists of 3 features:\n", + "* **floor_area_sqm** - size of the house in square meters\n", + "* **bedrooms** - number of bedrooms\n", + "* **schools** - number of primary schools within a 1km radius\n", + "\n", + "Our target value is the **asking_price**, which is the price of the housing unit." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### IMPORTANT\n", + "\n", + "Similar to PS0, your implementation in the following tasks **should not\n", + "involve any iteration, including `map` and `filter`, or recursion**. Instead, please work\n", + "with the operations available in NumPy†. Solutions that violate this will be penalised.\n", + "\n", + "There is, however, an exception for **Tasks 2.4, 2.5, and 3.4**. In the pseudo-code for the\n", + "algorithm required, there is an explicit while loop. Hence, **only for these tasks**, you\n", + "may use a **single for/while loop** to iterate for the number of epochs required.\n", + "\n", + "† You are allowed to use any mathematical functions, but this **does not mean that you are allowed to\n", + "use *any* NumPy function** (there are NumPy functions that aren’t mathematical functions). For example,\n", + "`np.vectorize` is not allowed since it is iterative. If you are in doubt about which functions are allowed, please\n", + "ask in the forum (:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Inital imports and setup\n", + "\n", + "import os\n", + "import numpy as np\n", + "\n", + "###################\n", + "# Helper function #\n", + "###################\n", + "def load_data(filepath):\n", + " \"\"\"\n", + " Load in the given csv filepath as a numpy array\n", + "\n", + " Parameters\n", + " ----------\n", + " filepath (string) : path to csv file\n", + "\n", + " Returns\n", + " -------\n", + " X, y (np.ndarray, np.ndarray) : (m, num_features), (m,) numpy matrices\n", + " \"\"\"\n", + " *X, y = np.genfromtxt(\n", + " filepath,\n", + " delimiter=',',\n", + " skip_header=True,\n", + " unpack=True,\n", + " ) # default dtype: float\n", + " X = np.array(X, dtype=float).T # cast features to int type\n", + " return X, y.reshape((-1, 1))\n", + "\n", + "data_filepath = 'housing_data.csv'\n", + "X, y = load_data(data_filepath)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Part 1: Defining cost functions\n", + "\n", + "We need to define cost functions before creating a linear regression model to calculate\n", + "the error between our prediction and the true values. We will define two cost functions:\n", + "Mean Squared Error (MSE) and Mean Absolute Error (MAE)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Task 1.1: Mean Squared Error (MSE)\n", + "\n", + "Write the function `mean_squared_error(y_true, y_pred)` that returns a number representing the mean squared error of the predictions.\n", + "\n", + "The formula for Mean Squared Error is as follows:\n", + "$$ MSE(\\boldsymbol{y}, \\boldsymbol{\\hat{y}}) = \\frac{1}{2m} \\sum_{i=1}^{m}(\\hat{y}_i - y_i)^2 $$\n", + "\n", + "where $\\boldsymbol{y}$ is the vector with actual values, $\\boldsymbol{\\hat{y}}$ is the prediction vector, and $m$ is the number of samples in the\n", + "training data.\n", + "\n", + "**Remark**: The formula here follows the lecture slides for consistency. In definitions and implementations elsewhere, the denominator is usually just $m$ instead of $2m$.\n", + "\n", + "**Hint**: Consider using `np.square` or `np.power`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def mean_squared_error(y_true, y_pred):\n", + " \"\"\"\n", + " Calculate mean squared error between y_pred and y_true.\n", + "\n", + " Parameters\n", + " ----------\n", + " y_true (np.ndarray) : (m, 1) numpy matrix consists of true values\n", + " y_pred (np.ndarray) : (m, 1) numpy matrix consists of predictions\n", + " \n", + " Returns\n", + " -------\n", + " The mean squared error value.\n", + " \"\"\"\n", + " return np.mean(np.square(y_true - y_pred))\n", + " \n", + " # TODO: add your solution here and remove `raise NotImplementedError`\n", + " raise NotImplementedError" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "y_true, y_pred = np.array([[3], [5]]), np.array([[12], [15]])\n", + "\n", + "assert mean_squared_error(y_true, y_pred) in [45.25, 90.5]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Task 1.2: Mean Absolute Error (MAE)\n", + "\n", + "Write the function `mean_absolute_error(y_true, y_pred)` that returns a number representing the mean absolute error of the predictions.\n", + "\n", + "The formula for Mean Absolute Error is as follows:\n", + "$$ MSE(\\boldsymbol{y}, \\boldsymbol{\\hat{y}}) = \\frac{1}{m} \\sum_{i=1}^{m}|\\hat{y}_i - y_i| $$\n", + "\n", + "where $\\boldsymbol{y}$ is the vector with actual values, $\\boldsymbol{\\hat{y}}$ is the prediction vector, and $m$ is the number of samples in the\n", + "training data.\n", + "\n", + "**Hint**: Consider using `np.abs`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def mean_absolute_error(y_true, y_pred):\n", + " \"\"\"\n", + " Calculate mean absolute error between y_pred and y_true.\n", + "\n", + " Parameters\n", + " ----------\n", + " y_true (np.ndarray) : (m, 1) numpy matrix consists of true values\n", + " y_pred (np.ndarray) : (m, 1) numpy matrix consists of predictions\n", + " \n", + " Returns\n", + " -------\n", + " The mean absolute error value.\n", + " \"\"\"\n", + " return np.mean(np.abs(y_true - y_pred))\n", + " \n", + " # TODO: add your solution here and remove `raise NotImplementedError`\n", + " raise NotImplementedError" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "y_true, y_pred = np.array([[3], [5]]), np.array([[12], [15]])\n", + "\n", + "assert mean_absolute_error(y_true, y_pred) == 9.5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Part 2: Linear Regression\n", + "\n", + "Now we’re ready to create our own linear regression model. We will try to approximate a linear function, which can be written as follows:\n", + "\n", + "$$ y = w_0 + w_1 x_1 + w_2 x_2 + \\dots + w_n x_n $$\n", + "\n", + "where $y$ is the target value, $x_1, x_2, \\dots, x_n$ are feature values, and $w_0, w_1, \\dots, w_n$ are parameters. $w_0$ is meant to represent the bias term, while $w_1, \\dots, w_n$ are the feature weights.\n", + "\n", + "**Bias term**\n", + "\n", + "The bias term ($w_0$) is useful in capturing an inherent offset of the target values from the origin, i.e. they have some non-zero value when all features are zero. The bias term accounts for this scenario in our model. Without a bias term (or bias = 0), our regression lines can only pass through the origin, which might not be appropriate for some data.\n", + "\n", + "Consider the scatter plot below. The blue line is the best fitting line without a bias term, while the red line includes a non-zero bias. Since the blue line starts at the origin, it is unable to capture the offset of the points. In contrast, the red line starts higher (at around 5), and hence is better able to approximate the data.\n", + "\n", + " \n", + "
\n", + "\"bias\n", + "
Figure 0: Example of models with bias vs without bias.
\n", + "
\n", + "\n", + "Usually, we have to explicitly add a bias term into our data when building our models. In the following tasks, you'll explore how to do so and how this choice can affect the accuracy of your models." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Task 2.1: Adding a bias column\n", + "\n", + "In the lecture, we learned that adding a bias column allows our linear model to be more\n", + "flexible. Write the function `add_bias_column(X)` that takes a NumPy matrix `X` and returns\n", + "a new matrix with an additional column. The additional column should have all of its\n", + "elements set to 1 and is located at the first column of the matrix.\n", + "\n", + "
\n", + "\"adding\n", + "
Figure 1: Example of a matrix before and after adding a bias column.
\n", + "
\n", + "\n", + "**Note**: Your function should work for all kinds of matrix shapes.\n", + "\n", + "**Hint**: Consider using `np.hstack` to add the bias column." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def add_bias_column(X):\n", + " \"\"\"\n", + " Create a bias column and combine it with X.\n", + "\n", + " Parameters\n", + " ----------\n", + " X : (m, n) numpy matrix representing a feature matrix\n", + " \n", + " Returns\n", + " -------\n", + " new_X (np.ndarray):\n", + " A (m, n + 1) numpy matrix with the first column consisting of all 1s\n", + " \"\"\"\n", + " return np.hstack((np.ones((X.shape[0], 1)), X))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "without_bias = np.array([[1, 2], [3, 4]])\n", + "expected = np.array([[1, 1, 2], [1, 3, 4]])\n", + "\n", + "assert np.array_equal(add_bias_column(without_bias), expected)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Task 2.2: Get best fitting bias and weights\n", + "\n", + "Write the function `get_bias_and_weight(X, y, include_bias)` that returns $w_0$ (bias) and\n", + "$w_1, w_2, \\dots, w_n$ (weights) that will lead to best fitting line.\n", + "\n", + "The `include_bias` argument is used to specify if the model includes a bias term, i.e. has a non-zero bias term. Hence, the function should return $w_0 = 0$ if it is set to `false`. The function should return $w_1, \\dots, w_n$ as a NumPy matrix with shape $(n, 1)$, where $n$ is the number of features (excluding the bias column).\n", + "\n", + "We can use the normal equation to get $w_0, w_1, \\dots, w_n$. The normal equation is as\n", + "follows:\n", + "\n", + "$$ \\begin{pmatrix} w_0 \\\\ w_1 \\\\ \\vdots \\\\ w_n \\end{pmatrix} = (X^TX)^{-1}X^T \\boldsymbol{y} $$\n", + "\n", + "where $X$ is the (augmented for bias) feature matrix and $\\boldsymbol{y}$ is the vector of target values.\n", + "\n", + "**Note**: You can use the `add_bias_column` function for this task. (You do not need to re-define the function in Coursemology. However, you are free to do so if you explicitly want to use your own implementation of the function for this task.)\n", + "\n", + "**Hint**: Consider using `numpy.linalg.inv` for the matrix inverse." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "def get_bias_and_weight(X, y, include_bias = True):\n", + " \"\"\"\n", + " Calculate bias and weights that give the best fitting line.\n", + "\n", + " Parameters\n", + " ----------\n", + " X (np.ndarray) : (m, n) numpy matrix representing feature matrix\n", + " y (np.ndarray) : (m, 1) numpy matrix representing target values\n", + " include_bias (boolean) : Specify whether the model should include a bias term\n", + " \n", + " Returns\n", + " -------\n", + " bias (float):\n", + " If include_bias = True, return the bias constant. Else,\n", + " return 0\n", + " weights (np.ndarray):\n", + " A (n, 1) numpy matrix representing the weight constant(s).\n", + " \"\"\"\n", + " if include_bias:\n", + " X = add_bias_column(X)\n", + " weights = np.linalg.inv(X.T @ X) @ X.T @ y\n", + " return (weights[0][0], weights[1:]) if include_bias else (0, weights)\n", + " \n", + " # TODO: add your solution here and remove `raise NotImplementedError`\n", + " raise NotImplementedError" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "public_X, public_y = np.array([[1, 3], [2, 3], [3, 4]]), np.arange(4, 7).reshape((-1, 1))\n", + "\n", + "test_1 = (round(get_bias_and_weight(public_X, public_y)[0], 5) == 3)\n", + "test_2 = np.array_equal(np.round(get_bias_and_weight(public_X, public_y)[1], 1), np.array([[1.0], [0.0]]))\n", + "test_3 = np.array_equal(np.round(get_bias_and_weight(public_X, public_y, False)[1], 2), np.round(np.array([[0.49], [1.20]]), 2))\n", + "\n", + "assert test_1 and test_2 and test_3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Task 2.3: Get the prediction line\n", + "\n", + "Write the function `get_prediction_linear_regression(X, y, include_bias)` that returns `y_pred`,\n", + "a vector of predicted values for the training data.\n", + "\n", + "**Note**: You can use the `get_bias_and_weight` function for this task. (You do not need to re-define the function in Coursemology. However, you are free to do so if you explicitly want to use your own implementation of the function for this task.)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "def get_prediction_linear_regression(X, y, include_bias = True):\n", + " \"\"\"\n", + " Calculate the best fitting line.\n", + "\n", + " Parameters\n", + " ----------\n", + " X (np.ndarray) : (m, n) numpy matrix representing feature matrix\n", + " y (np.ndarray) : (m, 1) numpy matrix representing target values\n", + " include_bias (boolean) : Specify whether the model should include a bias term\n", + "\n", + " Returns\n", + " -------\n", + " y_pred (np.ndarray):\n", + " A (m, 1) numpy matrix representing prediction values.\n", + " \"\"\"\n", + " bias, weights = get_bias_and_weight(X, y, include_bias)\n", + " return bias + X @ weights" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 3]\n", + " [2 3]\n", + " [3 4]] 2.9999999999999645 [[1.00000000e+00]\n", + " [1.77635684e-14]]\n", + "[[4.]\n", + " [5.]\n", + " [6.]]\n" + ] + } + ], + "source": [ + "test_X, test_y = np.array([[1, 3], [2, 3], [3, 4]]), np.arange(4, 7).reshape((-1, 1))\n", + "\n", + "assert round(mean_squared_error(test_y, get_prediction_linear_regression(test_X, test_y)), 5) == 0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To check your work, create a linear regression model with **floor_area_sqm** as the only\n", + "feature and **asking_price** as the target value. Plot your prediction line using the code\n", + "snippet below. It should look similar to Figure 2.\n", + "\n", + " \n", + "
\n", + "\"regression\n", + "
Figure 2: Example of linear regression using floor_area_sqm as feature.
\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "area = X[:, 0].reshape((-1, 1))\n", + "predicted = get_prediction_linear_regression(area, y)\n", + "plt.scatter(area, y)\n", + "plt.plot(area, predicted, color = 'r')\n", + "plt.xlabel(\"Size in square meter\")\n", + "plt.ylabel(\"Price in SGD\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gradient Descent\n", + "\n", + "We will now learn to use gradient descent to approximate $\\boldsymbol{w} = (w_0, w_1, \\dots, w_n)$.\n", + "\n", + "*Gradient descent*† is an algorithm that minimizes the cost function by iteratively trying to\n", + "find the best parameters. In linear regression, we will try to minimize the Mean Squared\n", + "Error. The outline of the algorithm is as follows:\n", + " \n", + "* Start with some $\\boldsymbol{w} = (w_0, \\dots, w_n)$\n", + "* Keep changing $w_0,\\dots, w_n$ to minimize $J(\\boldsymbol{w})$, where $J$ is our cost function\n", + "\n", + "In this problem set, we will initially set $w_0, w_1, \\dots, w_n$ to all be 0s. Then, we will set a\n", + "learning rate $\\alpha$ that will affect the rate of change of $w_0, \\dots, w_n$. Lastly, we will set\n", + "$N$ to specify the number of epochs of gradient descent we want to run.\n", + "\n", + "The pseudo-code of Gradient Descent for linear regression is defined in Algorithm 1.\n", + "\n", + "**Note**: In the following gradient descent-related tasks, calculate the value of the loss function *after* updating the bias and weights.\n", + "\n", + "† *The Gradient Descent algorithm is not limited to the linear regression model – it is a general optimisation technique and is also used in many other machine learning models such as Neural Networks.*\n", + "\n", + "
\n", + " \"gradient\n", + " \"gradient\n", + "
\n", + "
Figure 3: Gradient descent tries to find parameters that lead to the lowest MSE.
\n", + "\n", + "For MSE, The partial derivative $\\frac{\\partial J(\\boldsymbol w)}{\\partial w_i}$ with $m$ training samples can be derived as: \n", + "$$\n", + "\\frac{\\partial J(\\boldsymbol{w})}{\\partial w_i} = \\frac 1m\\sum^m_{j=1}(h_w(x^{(j)})-y^{(j)})\\cdot x_i^{(j)} \n", + "$$\n", + "where $h_w$ is our hypothesis." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Task 2.4: Gradient Descent on a single feature\n", + "\n", + "Write the function `gradient_descent_one_variable(x, y, lr, number_of_epochs)` that\n", + "returns:\n", + "\n", + "* $w_0$ - a number representing the bias constant\n", + "* $w_1$ - a number representing the weight constant\n", + "* $loss$ - a list that contains the MSE scores calculated during the gradient descent process.\n", + "\n", + "The default value is $10^{-5}$ for `lr` and $250$ for `number_of_epochs`.\n", + "\n", + "**Note**: You can use the `mean_squared_error` function for this task. (You do not need to re-define the function in Coursemology. However, you are free to do so if you explicitly want to use your own implementation of the function for this task.)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "def gradient_descent_one_variable(x, y, lr = 1e-5, number_of_epochs = 250):\n", + " \"\"\"\n", + " Approximate bias and weight that give the best fitting line.\n", + "\n", + " Parameters\n", + " ----------\n", + " x (np.ndarray) : (m, 1) numpy matrix representing a feature column\n", + " y (np.ndarray) : (m, 1) numpy matrix representing target values\n", + " lr (float) : Learning rate\n", + " number_of_epochs (int) : Number of gradient descent epochs\n", + " \n", + " Returns\n", + " -------\n", + " bias (float):\n", + " The bias constant\n", + " weight (float):\n", + " The weight constant\n", + " loss (list):\n", + " A list where the i-th element denotes the MSE score at i-th epoch.\n", + " \"\"\"\n", + " # Do not change\n", + " bias = 0\n", + " weight = 0\n", + " loss = []\n", + "\n", + " for _ in range(number_of_epochs):\n", + " predicted_y = bias + weight * x\n", + "\n", + " weight_gradient = np.mean((predicted_y - y)*x)\n", + " weight -= lr * weight_gradient\n", + "\n", + " bias_gradient = np.mean(predicted_y - y)\n", + " bias -= lr * bias_gradient\n", + "\n", + " loss.append(mean_squared_error(y, predicted_y))\n", + " return bias, weight, loss" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "area = X[:, 0].reshape((-1, 1))\n", + "\n", + "loss_initial = gradient_descent_one_variable(area, y, lr = 1e-5, number_of_epochs = 250)[2][0]\n", + "loss_final = gradient_descent_one_variable(area, y, lr = 1e-5, number_of_epochs = 250)[2][-1]\n", + "\n", + "assert loss_initial > loss_final" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To check your work, plot the `loss` against `number_of_epochs` using the code snippet\n", + "below. It should be similar to Figure 4.\n", + "\n", + " \n", + "
\n", + "\"gradient\n", + "
Figure 4: MSE values decrease as the epoch number increases.
\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHACAYAAABeV0mSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA00klEQVR4nO3deXxU9b3/8feZLJOFJKxJJrIkIosGjQguUUAUGwnVFtFbq7Zie28tingR+fVe1Fu33ota8Ue5KEgrIHXBWpTSQtVYCSjoT4GgiMiiQCIkjYBkg0yWOb8/wgyOCSGEOedMJq/n43EeZM4y+czX6SPvfs73nGOYpmkKAAAgQricLgAAACCUCDcAACCiEG4AAEBEIdwAAICIQrgBAAARhXADAAAiCuEGAABEFMINAACIKIQbAAAQUQg3AAAgonTqcLN27Vpde+21ysjIkGEYWr58+SkdX1tbq9tuu03nnnuuoqOjNX78+Gb7lJaW6uabb9agQYPkcrk0derUkNQOAABa1qnDTU1NjXJycjR37tx2Hd/Y2Kj4+Hjdfffduuqqq1rcx+v1qlevXrr//vuVk5NzOuUCAIA2iHa6ACfl5+crPz//hNvr6ur0wAMP6MUXX9Thw4c1ZMgQPf744xo9erQkKTExUfPmzZMkrVu3TocPH272HpmZmfrd734nSVq4cGHIPwMAAAjWqcPNyfzsZz/Tnj17tHTpUmVkZOj111/X2LFjtWXLFg0YMMDp8gAAQAs69Wmp1nzxxRd6+eWX9eqrr2rkyJHq37+/pk+frhEjRmjRokVOlwcAAE6Azs0JbNq0SaZpauDAgUHrvV6vevTo4VBVAADgZAg3J+Dz+RQVFaWNGzcqKioqaFuXLl0cqgoAAJwM4eYEhg4dqsbGRpWXl2vkyJFOlwMAANqoU4eb6upq7dq1K/B69+7d2rx5s7p3766BAwfqlltu0a233qpZs2Zp6NChOnDggN555x2de+65GjdunCTps88+U11dnQ4dOqSqqipt3rxZknT++ecH3te/rrq6Wl9//bU2b96s2NhYnXPOOXZ9VAAAOg3DNE3T6SKcUlhYqCuuuKLZ+okTJ2rx4sWqr6/Xb37zGy1ZskT79u1Tjx49lJubq4cffljnnnuupKZLvffu3dvsPb49rIZhNNver18/7dmzJ3QfBgAASOrk4QYAAEQeLgUHAAARhXADAAAiSqebUOzz+bR//34lJSW1OBcGAACEH9M0VVVVpYyMDLlcrfdmOl242b9/v/r06eN0GQAAoB1KSkrUu3fvVvfpdOEmKSlJUtPgJCcnO1wNAABoi8rKSvXp0yfwd7w1nS7c+E9FJScnE24AAOhg2jKlhAnFAAAgohBuAABARCHcAACAiEK4AQAAEYVwAwAAIgrhBgAARBTCDQAAiCiEGwAAEFEINwAAIKIQbgAAQEQh3AAAgIhCuAEAABGFcBMijT5TpRVHVXzwiNOlAADQqRFuQuSflbXKnfmOrnpqjdOlAADQqRFuQiQuJkqSVNfoU6PPdLgaAAA6L0fDzcyZM3XhhRcqKSlJqampGj9+vLZv397qMYWFhTIMo9ny+eef21R1y9zRx4fS29DoYCUAAHRujoabNWvWaPLkyfrggw9UUFCghoYG5eXlqaam5qTHbt++XaWlpYFlwIABNlR8Yv7OjSR5630OVgIAQOcW7eQvf+ONN4JeL1q0SKmpqdq4caNGjRrV6rGpqanq2rWrhdWdmiiXoZgoQ/WNpmrp3AAA4JiwmnNTUVEhSerevftJ9x06dKg8Ho/GjBmj1atXn3A/r9erysrKoMUq7uim7g2dGwAAnBM24cY0TU2bNk0jRozQkCFDTrifx+PRggULtGzZMr322msaNGiQxowZo7Vr17a4/8yZM5WSkhJY+vTpY9VHUFxM03DSuQEAwDmGaZphcWnP5MmTtXLlSr333nvq3bv3KR177bXXyjAMrVixotk2r9crr9cbeF1ZWak+ffqooqJCycnJp133t1322Dvad/io/jL5MuX06RrS9wYAoDOrrKxUSkpKm/5+h0XnZsqUKVqxYoVWr159ysFGki655BLt3LmzxW1ut1vJyclBi1Xc/s5NPZ0bAACc4uiEYtM0NWXKFL3++usqLCxUVlZWu96nqKhIHo8nxNWdOv+cm9oG5twAAOAUR8PN5MmT9dJLL+kvf/mLkpKSVFZWJklKSUlRfHy8JGnGjBnat2+flixZIkmaPXu2MjMzlZ2drbq6Or3wwgtatmyZli1b5tjn8PPPufHSuQEAwDGOhpt58+ZJkkaPHh20ftGiRbrtttskSaWlpSouLg5sq6ur0/Tp07Vv3z7Fx8crOztbK1eu1Lhx4+wq+4Ti6NwAAOA4x09LnczixYuDXv/qV7/Sr371K4sqOj1uOjcAADguLCYURwo6NwAAOI9wE0J0bgAAcB7hJoT8nRsvnRsAABxDuAmhOO5zAwCA4wg3IeSOoXMDAIDTCDchFBdN5wYAAKcRbkIo0LnhqeAAADiGcBNC7mieCg4AgNMINyHk79xwWgoAAOcQbkLIP+eGCcUAADiHcBNCcXRuAABwHOEmhNx0bgAAcBzhJoSOd24INwAAOIVwE0KBzg2npQAAcAzhJoTiuEMxAACOI9yEkJtnSwEA4DjCTQjxVHAAAJxHuAkhLgUHAMB5hJsQ8k8obvCZamikewMAgBMINyHk79xInJoCAMAphJsQ8nduJE5NAQDgFMJNCLlchmKjuEsxAABOItyEGJeDAwDgLMJNiLm5HBwAAEcRbkIsjs4NAACOItyEGE8GBwDAWYSbEONGfgAAOItwE2L+zk1tPZ0bAACcQLgJseNPBqdzAwCAEwg3IRYIN3RuAABwBOEmxI5PKKZzAwCAEwg3IXZ8QjGdGwAAnEC4CbHjE4rp3AAA4ATCTYgdn1BM5wYAACcQbkKMZ0sBAOAswk2I8WwpAACcRbgJMZ4tBQCAswg3IUbnBgAAZxFuQozODQAAziLchJi/c1NL5wYAAEcQbkLM37nx0rkBAMARhJsQi6NzAwCAowg3IXb8wZl0bgAAcALhJsTiY5uG9CjhBgAARxBuQiw+JlqSdLSOcAMAgBMINyEWH9t0WopwAwCAMwg3IRZ/bM4Np6UAAHAG4SbE/OGmwWeqvpErpgAAsBvhJsTiYo8PKd0bAADsR7gJsdgol6JchiTm3QAA4ATCTYgZhnF83g3hBgAA2xFuLBDHpGIAABxDuLEAN/IDAMA5hBsLJBy7kV8tp6UAALAd4cYCccdu5HeEcAMAgO0INxaIj+G0FAAATnE03MycOVMXXnihkpKSlJqaqvHjx2v79u0nPW7NmjUaNmyY4uLidOaZZ2r+/Pk2VNt23KUYAADnOBpu1qxZo8mTJ+uDDz5QQUGBGhoalJeXp5qamhMes3v3bo0bN04jR45UUVGR7rvvPt19991atmyZjZW3zv98qVrCDQAAtot28pe/8cYbQa8XLVqk1NRUbdy4UaNGjWrxmPnz56tv376aPXu2JOnss8/Whg0b9OSTT+r666+3uuQ24cngAAA4J6zm3FRUVEiSunfvfsJ93n//feXl5QWtu/rqq7VhwwbV19c329/r9aqysjJosZr/UnAmFAMAYL+wCTemaWratGkaMWKEhgwZcsL9ysrKlJaWFrQuLS1NDQ0NOnDgQLP9Z86cqZSUlMDSp0+fkNf+Xf45N5yWAgDAfmETbu666y598sknevnll0+6r2EYQa9N02xxvSTNmDFDFRUVgaWkpCQ0BbeCCcUAADjH0Tk3flOmTNGKFSu0du1a9e7du9V909PTVVZWFrSuvLxc0dHR6tGjR7P93W633G53SOs9mfhY5twAAOAURzs3pmnqrrvu0muvvaZ33nlHWVlZJz0mNzdXBQUFQeveeustDR8+XDExMVaVekq4zw0AAM5xNNxMnjxZL7zwgl566SUlJSWprKxMZWVlOnr0aGCfGTNm6NZbbw28njRpkvbu3atp06Zp27ZtWrhwoZ577jlNnz7diY/QIv+l4HRuAACwn6PhZt68eaqoqNDo0aPl8XgCyyuvvBLYp7S0VMXFxYHXWVlZWrVqlQoLC3X++efr0Ucf1Zw5c8LmMnCJp4IDAOAkR+fc+CcCt2bx4sXN1l1++eXatGmTBRWFBhOKAQBwTthcLRVJEphQDACAYwg3FvDfxI/73AAAYD/CjQX8c264QzEAAPYj3FiAOTcAADiHcGMB/5wbTksBAGA/wo0F/J2b+kZT9Y0+h6sBAKBzIdxYIC72+LDSvQEAwF6EGwvERrnkOvYMTy4HBwDAXoQbCxiGwaRiAAAcQrixSODJ4IQbAABsRbixiP9GfpyWAgDAXoQbi3BaCgAAZxBuLBIIN3RuAACwFeHGIvGxdG4AAHAC4cYidG4AAHAG4cYi/s4NN/EDAMBehBuLxDGhGAAARxBuLJJwrHNzhNNSAADYinBjES4FBwDAGYQbi/jDTS2dGwAAbEW4sUjcsdNSNYQbAABsRbixSBf3sWdLEW4AALAV4cYiCccenFlT1+BwJQAAdC6EG4sk+q+W8tK5AQDAToQbiyS46dwAAOAEwo1F/J2bGi/hBgAAOxFuLHJ8zg2npQAAsBPhxiKJbv+cGzo3AADYiXBjkcRjc26O1DfK5zMdrgYAgM6DcGORxGOnpUxTqm3g1BQAAHYh3FgkLsYlw2j6uZpTUwAA2IZwYxHDMALdG+51AwCAfQg3FkoIPF+Kzg0AAHYh3FgoMKmYy8EBALAN4cZC/svBuZEfAAD2IdxYKHAjP+bcAABgG8KNhRKZcwMAgO0INxbyPzyTuxQDAGAfwo2FjnduOC0FAIBdCDcW8s+5OcJpKQAAbEO4sVAXNxOKAQCwG+HGQglcCg4AgO0INxYKPH6BOTcAANiGcGMhHr8AAID9CDcWCjx+gTk3AADYhnBjITo3AADYj3BjocTA1VKEGwAA7EK4sZB/QjE38QMAwD6EGwv5nwrO4xcAALAP4cZCgTsU1zfK5zMdrgYAgM6BcGMhf+fGNKXaBk5NAQBgB8KNheKio2QYTT9Xc2oKAABbEG4s5HIZSojxz7uhcwMAgB0INxYLXA7OvW4AALAF4cZigbsUczk4AAC2INxYLHCXYubcAABgC0fDzdq1a3XttdcqIyNDhmFo+fLlre5fWFgowzCaLZ9//rk9BbdD4EZ+zLkBAMAW0U7+8pqaGuXk5OhnP/uZrr/++jYft337diUnJwde9+rVy4ryQiLBzfOlAACwk6PhJj8/X/n5+ad8XGpqqrp27Rr6gixwvHNDuAEAwA4dcs7N0KFD5fF4NGbMGK1evdrpclqVFNcUbqprCTcAANjB0c7NqfJ4PFqwYIGGDRsmr9erP/7xjxozZowKCws1atSoFo/xer3yer2B15WVlXaVK0nqcuxqKW7iBwCAPTpUuBk0aJAGDRoUeJ2bm6uSkhI9+eSTJww3M2fO1MMPP2xXic0kxcVIkirp3AAAYIsOeVrq2y655BLt3LnzhNtnzJihioqKwFJSUmJjdVKXODo3AADYqUN1blpSVFQkj8dzwu1ut1tut9vGioL559xU1dY7VgMAAJ2Jo+Gmurpau3btCrzevXu3Nm/erO7du6tv376aMWOG9u3bpyVLlkiSZs+erczMTGVnZ6uurk4vvPCCli1bpmXLljn1EU4qyc2EYgAA7ORouNmwYYOuuOKKwOtp06ZJkiZOnKjFixertLRUxcXFge11dXWaPn269u3bp/j4eGVnZ2vlypUaN26c7bW3lX/OTRXhBgAAWximaZpOF2GnyspKpaSkqKKiIuhGgFbZXHJY459epzO6xmvdf15p+e8DACASncrf7w4/oTjc+efcVDLnBgAAWxBuLJb0rfvcdLImGQAAjiDcWMw/58Y0pZo6Hp4JAIDVCDcWi4txKcplSOKKKQAA7EC4sZhhGNzrBgAAGxFubOB/vlQVdykGAMByhBsbcK8bAADsQ7ixgf+0FHNuAACwHuHGBv7LwZlzAwCA9Qg3NkjiyeAAANimXeGmpKREX331VeD1hx9+qKlTp2rBggUhKyySdAncpZhwAwCA1doVbm6++WatXr1aklRWVqbvfe97+vDDD3XffffpkUceCWmBkcA/oZg5NwAAWK9d4ebTTz/VRRddJEn605/+pCFDhmj9+vV66aWXtHjx4lDWFxG6MOcGAADbtCvc1NfXy+12S5Lefvtt/eAHP5AkDR48WKWlpaGrLkIkM+cGAADbtCvcZGdna/78+Xr33XdVUFCgsWPHSpL279+vHj16hLTASNAlcIdiwg0AAFZrV7h5/PHH9eyzz2r06NG66aablJOTI0lasWJF4HQVjktyH7uJH50bAAAsF92eg0aPHq0DBw6osrJS3bp1C6y//fbblZCQELLiIkUXni0FAIBt2tW5OXr0qLxebyDY7N27V7Nnz9b27duVmpoa0gIjAXcoBgDAPu0KNz/84Q+1ZMkSSdLhw4d18cUXa9asWRo/frzmzZsX0gIjQeC0FOEGAADLtSvcbNq0SSNHjpQk/fnPf1ZaWpr27t2rJUuWaM6cOSEtMBL4OzdH6xvV0OhzuBoAACJbu8LNkSNHlJSUJEl66623NGHCBLlcLl1yySXau3dvSAuMBP45NxKXgwMAYLV2hZuzzjpLy5cvV0lJid58803l5eVJksrLy5WcnBzSAiNBTJRLcTFNQ82pKQAArNWucPPrX/9a06dPV2Zmpi666CLl5uZKauriDB06NKQFRoouzLsBAMAW7boU/IYbbtCIESNUWloauMeNJI0ZM0bXXXddyIqLJMlx0TpQ7eVycAAALNaucCNJ6enpSk9P11dffSXDMHTGGWdwA79WJMc3dW4qjhJuAACwUrtOS/l8Pj3yyCNKSUlRv3791LdvX3Xt2lWPPvqofD6uBmpJ1wTCDQAAdmhX5+b+++/Xc889p8cee0yXXXaZTNPUunXr9NBDD6m2tlb//d//Heo6O7wUOjcAANiiXeHm+eef1x/+8IfA08AlKScnR2eccYbuvPNOwk0LCDcAANijXaelDh06pMGDBzdbP3jwYB06dOi0i4pEhBsAAOzRrnCTk5OjuXPnNls/d+5cnXfeeaddVCTyh5vDRwg3AABYqV2npZ544gl9//vf19tvv63c3FwZhqH169erpKREq1atCnWNEYHODQAA9mhX5+byyy/Xjh07dN111+nw4cM6dOiQJkyYoK1bt2rRokWhrjEiEG4AALBHu+9zk5GR0Wzi8Mcff6znn39eCxcuPO3CIk3XhFhJhBsAAKzWrs4NTh2dGwAA7EG4scm3w41pmg5XAwBA5CLc2MR/h+JGn6lqLw/PBADAKqc052bChAmtbj98+PDp1BLR4mKiFBvtUl2DTxVH65UUF+N0SQAARKRTCjcpKSkn3X7rrbeeVkGRLCU+Rl9XeVVxtF69uzldDQAAkemUwg2XeZ+eQLjhRn4AAFiGOTc26soVUwAAWI5wYyMuBwcAwHqEGxsFni9FuAEAwDKEGxulJNC5AQDAaoQbG3FaCgAA6xFubBQIN1wtBQCAZQg3NurKaSkAACxHuLERp6UAALAe4cZGx6+WqnO4EgAAIhfhxkbMuQEAwHqEGxulxMdKkqq8DfL5TIerAQAgMhFubOTv3Jgm824AALAK4cZGsdEuJbmbnlV66AjzbgAAsALhxmbduzSdmjpUQ7gBAMAKhBubdU8k3AAAYCXCjc26JxBuAACwEuHGZnRuAACwlqPhZu3atbr22muVkZEhwzC0fPnykx6zZs0aDRs2THFxcTrzzDM1f/586wsNIebcAABgLUfDTU1NjXJycjR37tw27b97926NGzdOI0eOVFFRke677z7dfffdWrZsmcWVhg6npQAAsFa0k788Pz9f+fn5bd5//vz56tu3r2bPni1JOvvss7VhwwY9+eSTuv766y2qMrQ4LQUAgLU61Jyb999/X3l5eUHrrr76am3YsEH19R3jpniEGwAArOVo5+ZUlZWVKS0tLWhdWlqaGhoadODAAXk8nmbHeL1eeb3ewOvKykrL62wN4QYAAGt1qM6NJBmGEfTaNM0W1/vNnDlTKSkpgaVPnz6W19iaHoluSYQbAACs0qHCTXp6usrKyoLWlZeXKzo6Wj169GjxmBkzZqiioiKwlJSU2FHqCXVLbHq+1NH6Rh2ta3S0FgAAIlGHOi2Vm5urv/71r0Hr3nrrLQ0fPlwxMTEtHuN2u+V2u+0or026uKMVG+VSXaNPh47U6YzYeKdLAgAgojjauamurtbmzZu1efNmSU2Xem/evFnFxcWSmrout956a2D/SZMmae/evZo2bZq2bdumhQsX6rnnntP06dOdKL9dDMM4Pu+mmlNTAACEmqPhZsOGDRo6dKiGDh0qSZo2bZqGDh2qX//615Kk0tLSQNCRpKysLK1atUqFhYU6//zz9eijj2rOnDkd5jJwv27Hws3BGu9J9gQAAKfK0dNSo0ePDkwIbsnixYubrbv88su1adMmC6uyXo9j4eabI3RuAAAItQ41oThSBDo3nJYCACDkCDcOoHMDAIB1CDcO4EZ+AABYh3DjAE5LAQBgHcKNAzgtBQCAdQg3DuiW4L8UnHADAECoEW4c0Cup6Y7JX1dxnxsAAEKNcOOA1OSmcFNV26Daep4vBQBAKBFuHJDkjpY7umno6d4AABBahBsHGIYR6N6UV9U6XA0AAJGFcOOQXl2YdwMAgBUINw5JTYqTJJUTbgAACCnCjUO4YgoAAGsQbhySeizclFcSbgAACCXCjUOYUAwAgDUINw4JnJaqpnMDAEAoEW4cEphQzGkpAABCinDjEH/n5mBNnRp9psPVAAAQOQg3DumRGCvDkBp9pg7xAE0AAEKGcOOQ6CiXeiQ2PR2cy8EBAAgdwo2DegVu5McVUwAAhArhxkHcyA8AgNAj3DgocCM/wg0AACFDuHFQKp0bAABCjnDjoF5J3KUYAIBQI9w4yJMSL0naf5hwAwBAqBBuHJTRtelqqdKKow5XAgBA5CDcOMjfuSmv8qq+0edwNQAARAbCjYN6JMYqNsol05TKKjg1BQBAKBBuHORyGfIETk0RbgAACAXCjcM8Kcy7AQAglAg3DsvgiikAAEKKcOOwjK7+cEPnBgCAUCDcOMzD5eAAAIQU4cZhnJYCACC0CDcO83du9tO5AQAgJAg3DvPPuTl8pF5H6xodrgYAgI6PcOOw5LgYdXFHS6J7AwBAKBBuwkDgXjfMuwEA4LQRbsKAh8vBAQAIGcJNGDjj2KTirwg3AACcNsJNGOjTPUGSVHLoiMOVAADQ8RFuwkC/7omSpL0HaxyuBACAjo9wEwb69Wjq3BTTuQEA4LQRbsJA32Ph5kB1naq9DQ5XAwBAx0a4CQPJcTHqlhAjSSo+SPcGAIDTQbgJE317NM27KT7EvBsAAE4H4SZM9Dt2xdReOjcAAJwWwk2Y6OsPN0wqBgDgtBBuwoR/UjFzbgAAOD2EmzAROC3FnBsAAE4L4SZM9Ds2oXj/4VrVN/ocrgYAgI6LcBMmUpPccke71OgzeYAmAACngXATJlwuIzCpeA/zbgAAaDfCTRg5s1fTqald5dUOVwIAQMdFuAkjA1KTJBFuAAA4HY6Hm2eeeUZZWVmKi4vTsGHD9O67755w38LCQhmG0Wz5/PPPbazYOgPSukiSdpVXOVwJAAAdl6Ph5pVXXtHUqVN1//33q6ioSCNHjlR+fr6Ki4tbPW779u0qLS0NLAMGDLCpYmv179UUbnaWV8s0TYerAQCgY3I03Dz11FP613/9V/3bv/2bzj77bM2ePVt9+vTRvHnzWj0uNTVV6enpgSUqKsqmiq3Vv1cXGYZ0+Ei9DtbUOV0OAAAdkmPhpq6uThs3blReXl7Q+ry8PK1fv77VY4cOHSqPx6MxY8Zo9erVVpZpq/jYKPXuFi+JeTcAALSXY+HmwIEDamxsVFpaWtD6tLQ0lZWVtXiMx+PRggULtGzZMr322msaNGiQxowZo7Vr157w93i9XlVWVgYt4cw/qXgn4QYAgHaJdroAwzCCXpum2Wyd36BBgzRo0KDA69zcXJWUlOjJJ5/UqFGjWjxm5syZevjhh0NXsMUGpHbRO5+Xa9c/mVQMAEB7ONa56dmzp6Kiopp1acrLy5t1c1pzySWXaOfOnSfcPmPGDFVUVASWkpKSdtdsh/6px66Y+prODQAA7eFYuImNjdWwYcNUUFAQtL6goECXXnppm9+nqKhIHo/nhNvdbreSk5ODlnA24Fi42flPwg0AAO3h6GmpadOm6ac//amGDx+u3NxcLViwQMXFxZo0aZKkpq7Lvn37tGTJEknS7NmzlZmZqezsbNXV1emFF17QsmXLtGzZMic/RkiddSzclFd5VXGkXikJMQ5XBABAx+JouLnxxht18OBBPfLIIyotLdWQIUO0atUq9evXT5JUWloadM+buro6TZ8+Xfv27VN8fLyys7O1cuVKjRs3zqmPEHJJcTE6o2u89h0+qs9KK5Xbv4fTJQEA0KEYZie7W1xlZaVSUlJUUVERtqeofvnHDXpz6z/1wPfP1r+NPNPpcgAAcNyp/P12/PELaC47I0WStHV/eF+2DgBAOCLchKEhZzQl0q37KxyuBACAjodwE4b8nZtd5dU6WtfocDUAAHQshJswlJrkVs8ubvlMaVsZp6YAADgVhJswZBiGsjP8p6YINwAAnArCTZgKzLvZx7wbAABOBeEmTA05Nu/mUyYVAwBwSgg3YWrIGU3hZntZlWrrmVQMAEBbEW7CVO9u8UpNcqu+0dTHJYedLgcAgA6DcBOmDMPQ8MxukqQNe79xuBoAADoOwk0YG9avuyRpI+EGAIA2I9yEseH9mjo3G/d+I5+vUz0CDACAdiPchLFzMpIVHxOliqP1+uLraqfLAQCgQyDchLGYKJdy+jRdNcW8GwAA2oZwE+YuzGyad/PRnkMOVwIAQMdAuAlzF2U1hZv1uw7KNJl3AwDAyRBuwtyFmd3ljnaprLJWu8qZdwMAwMkQbsJcXExUoHuzZsfXDlcDAED4I9x0AJcP7CVJenfnAYcrAQAg/BFuOoCRA5rCzf/bfZDnTAEAcBKEmw5gYFoXpSW7VVvv46opAABOgnDTARiGEejerP6ceTcAALSGcNNBfO+cNEnSm1vLuCQcAIBWEG46iMsH9lJCbJT2HT6qT76qcLocAADCFuGmg4iLidKVg1MlSas+LXW4GgAAwhfhpgMZd65HkvT3LZyaAgDgRAg3HcjoQb0UF+NS8aEj2rq/0ulyAAAIS4SbDiQhNlpjBjdNLP7zxq8crgYAgPBEuOlg/mV4b0nS60X7uKEfAAAtINx0MCMH9FJGSpwqjtbrza1lTpcDAEDYIdx0MFEuQ/8yvI8k6ZWPShyuBgCA8EO46YD+ZXhvGYa0/ouD+uLraqfLAQAgrBBuOqDe3RI05tg9b36/9kuHqwEAILwQbjqoSZf3lyS9tmmfyitrHa4GAIDwQbjpoIZndtfwft1U1+jTc+t2O10OAABhg3DTgfm7Ny+8v1dfV3kdrgYAgPBAuOnArhycqvN6p6imrlG/+8cOp8sBACAsEG46MJfL0H3jzpYkvfxhiXaVVzlcEQAAziPcdHCXnNlD3zsnTY0+U4/8bRsP1AQAdHqEmwgwI3+wYqNdWrvjay3btM/pcgAAcBThJgKc2auLpl41QJL0yF+36p9cGg4A6MQINxHi9pFn6rzeKaqsbdDUpZvV0OhzuiQAABxBuIkQ0VEuPfWjHCXERun9Lw/qt29ud7okAAAcQbiJIGelJunJf8mRJD279ku9uoEHawIAOh/CTYQZd65Hd45uurnffyz7RG98WupwRQAA2ItwE4H+z9WD9KPhveUzpSkvF+mvH+93uiQAAGxDuIlAhmFo5oTzdM15HtU3mprycpF+v/ZL7oEDAOgUCDcRKspl6Hc/HqqJuf0kSf+9apvufHGTKmvrHa4MAABrEW4iWJTL0EM/yNaD156jmChDf/+0TFf/37V6a2uZ06UBAGAZwk2EMwxDP7ssS69OulR9uyeotKJWt/9xo25d+KE+3VfhdHkAAIScYXayiRiVlZVKSUlRRUWFkpOTnS7HVkfrGjXnnZ36/dov1eBr+s8+amAv/fyyTI04q6eio8i6AIDwdCp/vwk3ndDegzX6vwU79JeP98v/X79nl1jlD/Ho2pwMDe/XTS6X4WyRAAB8C+GmFYSb44oPHtGi9bv1etE+HT5yfKJxSnyMLszspgszu+vCrO4anJ6khNhoBysFAHR2hJtWEG6aq2/0ad2uA/rbJ6V6c2uZqmobgrYbhtSnW4IGpnXRmb26yJMSJ09KnNJT4uVJiVPPLm5F0ekBAFiIcNMKwk3r6ht9+mx/pT7cfUgf7jmkouJvdKC6rtVjolyGkuOilRwfo5T4GCXHNf2b6I5SXMyxJdolt//nGJfc0VGKdhmK+tYS7TLkOvZvlHFsXZQhl2Eo2uWScSw/Bf6VEbTOkPGd7cd/1rf39a8xjG/93Px4AJGH/33bI8plyJMSH9L3JNy0gnBz6g5We7Xjn9Xa8c8qFR86orKKWpVWHFVZRa3+WeVVo69TfYUAACeRmuTWh/dfFdL3PJW/345PpHjmmWf029/+VqWlpcrOztbs2bM1cuTIE+6/Zs0aTZs2TVu3blVGRoZ+9atfadKkSTZW3Pn06OJWbhe3cvv3aLatodGngzV1qjhar8qj9ar41nKkrlG19f7F1/RvQ9O/3gaffD5Tjf7FNNXgM9Xo86nRJzX6fGrwmfL5/OtNmaZkqilINf2swM/61nr/K39uN7+9/lvrdIJ9v/0+iHym+I/dWfC/a/u4Y5y9+tbRcPPKK69o6tSpeuaZZ3TZZZfp2WefVX5+vj777DP17du32f67d+/WuHHj9Itf/EIvvPCC1q1bpzvvvFO9evXS9ddf78AnQHSUS2nJcUpLjnO6FAAAJDl8Wuriiy/WBRdcoHnz5gXWnX322Ro/frxmzpzZbP//+I//0IoVK7Rt27bAukmTJunjjz/W+++/36bfyWkpAAA6nlP5++1Y36iurk4bN25UXl5e0Pq8vDytX7++xWPef//9ZvtfffXV2rBhg+rreWYSAABw8LTUgQMH1NjYqLS0tKD1aWlpKitr+dlHZWVlLe7f0NCgAwcOyOPxNDvG6/XK6/UGXldWVoagegAAEK4cv9++8Z3r8kzTbLbuZPu3tN5v5syZSklJCSx9+vQ5zYoBAEA4cyzc9OzZU1FRUc26NOXl5c26M37p6ekt7h8dHa0ePZpfySNJM2bMUEVFRWApKSkJzQcAAABhybFwExsbq2HDhqmgoCBofUFBgS699NIWj8nNzW22/1tvvaXhw4crJiamxWPcbreSk5ODFgAAELkcPS01bdo0/eEPf9DChQu1bds23XPPPSouLg7ct2bGjBm69dZbA/tPmjRJe/fu1bRp07Rt2zYtXLhQzz33nKZPn+7URwAAAGHG0fvc3HjjjTp48KAeeeQRlZaWasiQIVq1apX69esnSSotLVVxcXFg/6ysLK1atUr33HOPnn76aWVkZGjOnDnc4wYAAATw+AUAABD2OsR9bgAAAKxAuAEAABGFcAMAACIK4QYAAEQUwg0AAIgojl4K7gT/xWE8YwoAgI7D/3e7LRd5d7pwU1VVJUk8YwoAgA6oqqpKKSkpre7T6e5z4/P5tH//fiUlJbX6gM72qKysVJ8+fVRSUsI9dCzEONuHsbYPY20Pxtk+oR5r0zRVVVWljIwMuVytz6rpdJ0bl8ul3r17W/o7eIaVPRhn+zDW9mGs7cE42yeUY32yjo0fE4oBAEBEIdwAAICIQrgJIbfbrQcffFBut9vpUiIa42wfxto+jLU9GGf7ODnWnW5CMQAAiGx0bgAAQEQh3AAAgIhCuAEAABGFcBMizzzzjLKyshQXF6dhw4bp3XffdbqkDu+hhx6SYRhBS3p6emC7aZp66KGHlJGRofj4eI0ePVpbt251sOKOYe3atbr22muVkZEhwzC0fPnyoO1tGVev16spU6aoZ8+eSkxM1A9+8AN99dVXNn6KjuFkY33bbbc1+45fcsklQfsw1ic3c+ZMXXjhhUpKSlJqaqrGjx+v7du3B+3D9/r0tWWcw+U7TbgJgVdeeUVTp07V/fffr6KiIo0cOVL5+fkqLi52urQOLzs7W6WlpYFly5YtgW1PPPGEnnrqKc2dO1cfffSR0tPT9b3vfS/wiA20rKamRjk5OZo7d26L29syrlOnTtXrr7+upUuX6r333lN1dbWuueYaNTY22vUxOoSTjbUkjR07Nug7vmrVqqDtjPXJrVmzRpMnT9YHH3yggoICNTQ0KC8vTzU1NYF9+F6fvraMsxQm32kTp+2iiy4yJ02aFLRu8ODB5n/+5386VFFkePDBB82cnJwWt/l8PjM9Pd187LHHAutqa2vNlJQUc/78+TZV2PFJMl9//fXA67aM6+HDh82YmBhz6dKlgX327dtnulwu84033rCt9o7mu2NtmqY5ceJE84c//OEJj2Gs26e8vNyUZK5Zs8Y0Tb7XVvnuOJtm+Hyn6dycprq6Om3cuFF5eXlB6/Py8rR+/XqHqoocO3fuVEZGhrKysvTjH/9YX375pSRp9+7dKisrCxp3t9utyy+/nHE/DW0Z140bN6q+vj5on4yMDA0ZMoSxb4fCwkKlpqZq4MCB+sUvfqHy8vLANsa6fSoqKiRJ3bt3l8T32irfHWe/cPhOE25O04EDB9TY2Ki0tLSg9WlpaSorK3Ooqshw8cUXa8mSJXrzzTf1+9//XmVlZbr00kt18ODBwNgy7qHVlnEtKytTbGysunXrdsJ90Db5+fl68cUX9c4772jWrFn66KOPdOWVV8rr9UpirNvDNE1NmzZNI0aM0JAhQyTxvbZCS+Mshc93utM9ONMq333CuGmaIX/qeGeTn58f+Pncc89Vbm6u+vfvr+effz4wQY1xt0Z7xpWxP3U33nhj4OchQ4Zo+PDh6tevn1auXKkJEyac8DjG+sTuuusuffLJJ3rvvfeabeN7HTonGudw+U7TuTlNPXv2VFRUVLPEWV5e3uz/JeD0JCYm6txzz9XOnTsDV00x7qHVlnFNT09XXV2dvvnmmxPug/bxeDzq16+fdu7cKYmxPlVTpkzRihUrtHr1avXu3Tuwnu91aJ1onFvi1HeacHOaYmNjNWzYMBUUFAStLygo0KWXXupQVZHJ6/Vq27Zt8ng8ysrKUnp6etC419XVac2aNYz7aWjLuA4bNkwxMTFB+5SWlurTTz9l7E/TwYMHVVJSIo/HI4mxbivTNHXXXXfptdde0zvvvKOsrKyg7XyvQ+Nk49wSx77TIZua3IktXbrUjImJMZ977jnzs88+M6dOnWomJiaae/bscbq0Du3ee+81CwsLzS+//NL84IMPzGuuucZMSkoKjOtjjz1mpqSkmK+99pq5ZcsW86abbjI9Ho9ZWVnpcOXhraqqyiwqKjKLiopMSeZTTz1lFhUVmXv37jVNs23jOmnSJLN3797m22+/bW7atMm88sorzZycHLOhocGpjxWWWhvrqqoq89577zXXr19v7t6921y9erWZm5trnnHGGYz1KbrjjjvMlJQUs7Cw0CwtLQ0sR44cCezD9/r0nWycw+k7TbgJkaefftrs16+fGRsba15wwQVBl8ahfW688UbT4/GYMTExZkZGhjlhwgRz69atge0+n8988MEHzfT0dNPtdpujRo0yt2zZ4mDFHcPq1atNSc2WiRMnmqbZtnE9evSoedddd5ndu3c34+PjzWuuucYsLi524NOEt9bG+siRI2ZeXp7Zq1cvMyYmxuzbt685ceLEZuPIWJ9cS2MsyVy0aFFgH77Xp+9k4xxO32meCg4AACIKc24AAEBEIdwAAICIQrgBAAARhXADAAAiCuEGAABEFMINAACIKIQbAAAQUQg3AAAgohBuAIQdwzC0fPlyp8tos8zMTM2ePdvpMgAcQ7gBEHDbbbfJMIxmy9ixY50uDQDaLNrpAgCEl7Fjx2rRokVB69xut0PVdF719fWKiYlxugygQ6JzAyCI2+1Wenp60NKtW7fAdsMwNG/ePOXn5ys+Pl5ZWVl69dVXg95jy5YtuvLKKxUfH68ePXro9ttvV3V1ddA+CxcuVHZ2ttxutzwej+66666g7QcOHNB1112nhIQEDRgwQCtWrGi17szMTP3P//yPfv7znyspKUl9+/bVggULAtsLCwtlGIYOHz4cWLd582YZhqE9e/ZIkhYvXqyuXbvqb3/7mwYNGqSEhATdcMMNqqmp0fPPP6/MzEx169ZNU6ZMUWNjY9Dvr6qq0s0336wuXbooIyND//u//xu0vaKiQrfffrtSU1OVnJysK6+8Uh9//HFg+0MPPaTzzz9fCxcu1Jlnnim32y0e/Qe0D+EGwCn7r//6L11//fX6+OOP9ZOf/EQ33XSTtm3bJkk6cuSIxo4dq27duumjjz7Sq6++qrfffjsovMybN0+TJ0/W7bffri1btmjFihU666yzgn7Hww8/rB/96Ef65JNPNG7cON1yyy06dOhQq3XNmjVLw4cPV1FRke68807dcccd+vzzz0/psx05ckRz5szR0qVL9cYbb6iwsFATJkzQqlWrtGrVKv3xj3/UggUL9Oc//znouN/+9rc677zztGnTJs2YMUP33HOPCgoKJEmmaer73/++ysrKtGrVKm3cuFEXXHCBxowZE/SZdu3apT/96U9atmyZNm/efEp1A/iWkD5jHECHNnHiRDMqKspMTEwMWh555JHAPpLMSZMmBR138cUXm3fccYdpmqa5YMECs1u3bmZ1dXVg+8qVK02Xy2WWlZWZpmmaGRkZ5v3333/COiSZDzzwQOB1dXW1aRiG+fe///2Ex/Tr18/8yU9+Enjt8/nM1NRUc968eaZpmubq1atNSeY333wT2KeoqMiUZO7evds0TdNctGiRKcnctWtXYJ9f/vKXZkJCgllVVRVYd/XVV5u//OUvg3732LFjg+q58cYbzfz8fNM0TfMf//iHmZycbNbW1gbt079/f/PZZ581TdM0H3zwQTMmJsYsLy8/4WcE0DbMuQEQ5IorrtC8efOC1nXv3j3odW5ubrPX/k7Dtm3blJOTo8TExMD2yy67TD6fT9u3b5dhGNq/f7/GjBnTah3nnXde4OfExEQlJSWpvLy8zccYhqH09PSTHvNdCQkJ6t+/f+B1WlqaMjMz1aVLl6B1333flsbEfwXVxo0bVV1drR49egTtc/ToUX3xxReB1/369VOvXr1OqV4AzRFuAARJTExsdoqoLQzDkNR0Csb/c0v7xMfHt+n9vjuZ1jAM+Xy+dh/jcrkC9fnV19e36T3aU4t/P0ny+XzyeDwqLCxstk/Xrl0DP387EAJoP+bcADhlH3zwQbPXgwcPliSdc8452rx5s2pqagLb161bJ5fLpYEDByopKUmZmZn6xz/+YWvN/o5IaWlpYF0o57W0NiYXXHCBysrKFB0drbPOOito6dmzZ8hqANCEcAMgiNfrVVlZWdBy4MCBoH1effVVLVy4UDt27NCDDz6oDz/8MDBh+JZbblFcXJwmTpyoTz/9VKtXr9aUKVP005/+VGlpaZKargyaNWuW5syZo507d2rTpk3Nri4KtbPOOkt9+vTRQw89pB07dmjlypWaNWtWyN5/3bp1euKJJ7Rjxw49/fTTevXVV/Xv//7vkqSrrrpKubm5Gj9+vN58803t2bNH69ev1wMPPKANGzaErAYATQg3AIK88cYb8ng8QcuIESOC9nn44Ye1dOlSnXfeeXr++ef14osv6pxzzpHUNGflzTff1KFDh3ThhRfqhhtu0JgxYzR37tzA8RMnTtTs2bP1zDPPKDs7W9dcc4127txp6eeKiYnRyy+/rM8//1w5OTl6/PHH9Zvf/CZk73/vvfdq48aNGjp0qB599FHNmjVLV199taSm01OrVq3SqFGj9POf/1wDBw7Uj3/8Y+3ZsycQ+ACEjmGa3EgBQNsZhqHXX39d48ePd7oUAGgRnRsAABBRCDcAACCicCk4gFPCmWwA4Y7ODQAAiCiEGwAAEFEINwAAIKIQbgAAQEQh3AAAgIhCuAEAABGFcAMAACIK4QYAAEQUwg0AAIgo/x8eXVXD09TXKQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "area = X[:, 0].reshape((-1, 1))\n", + "b, w, loss = gradient_descent_one_variable(area, y, 1e-5, 250)\n", + "plt.plot([i for i in range(len(loss))], loss)\n", + "plt.xlabel('Epoch number')\n", + "plt.ylabel('Loss')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Task 2.5: Gradient Descent on multiple features\n", + "\n", + "Now, extend the code in Task 2.4 so it is able to find $w_0, w_1, \\dots, w_n$ for multiple features. Write the function `gradient_descent_multi_variable(X, y, lr, number_of_epochs)` that returns:\n", + "\n", + "* $w_0$ - a number representing the bias constant\n", + "* $w_1, w_2, \\dots, w_n$ - $(n,1)$ NumPy matrix, where each element denotes the weight constant of a certain feature\n", + "* $loss$ - a list that contains the MSE scores calculated during the gradient descent process.\n", + "\n", + "**Note**: You can use the `mean_squared_error` function for this task. (You do not need to re-define the function in Coursemology. However, you are free to do so if you explicitly want to use your own implementation of the function for this task.)" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [], + "source": [ + "def gradient_descent_multi_variable(X, y, lr = 1e-5, number_of_epochs = 250):\n", + " '''\n", + " Approximate bias and weight that gave the best fitting line.\n", + "\n", + " Parameters\n", + " ----------\n", + " X (np.ndarray) : (m, n) numpy matrix representing feature matrix\n", + " y (np.ndarray) : (m, 1) numpy matrix representing target values\n", + " lr (float) : Learning rate\n", + " number_of_epochs (int) : Number of gradient descent epochs\n", + " \n", + " Returns\n", + " -------\n", + " bias (float):\n", + " The bias constant\n", + " weights (np.ndarray):\n", + " A (n, 1) numpy matrix that specifies the weight constants.\n", + " loss (list):\n", + " A list where the i-th element denotes the MSE score at i-th epoch.\n", + " '''\n", + " # Do not change\n", + " bias = 0\n", + " weights = np.full((X.shape[1], 1), 0).astype(float)\n", + " loss = []\n", + "\n", + " for _ in range(number_of_epochs):\n", + " predicted_y = bias + X @ weights\n", + "\n", + " weight_gradient = np.mean((predicted_y - y)*X, axis=0)\n", + " weight_gradient = weight_gradient.reshape((X.shape[1],1))\n", + " weights -= lr * weight_gradient\n", + "\n", + " bias_gradient = np.mean(predicted_y - y)\n", + " bias -= lr * bias_gradient\n", + "\n", + " loss.append(mean_squared_error(y, predicted_y))\n", + " \n", + " return bias, weights, loss" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [], + "source": [ + "_, _, loss = gradient_descent_multi_variable(X, y, lr = 1e-5, number_of_epochs = 250)\n", + "loss_initial = loss[0]\n", + "loss_final = loss[-1]\n", + "\n", + "assert loss_initial > loss_final" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Task 2.6: Which algorithm should we use for Linear Regression?\n", + "\n", + "Compare the pros and cons of using normal equation and gradient descent for linear regression. Specifically:\n", + "\n", + "- Compare the speed of the two algorithms on data with many features. \n", + "- Compare the quality of the solutions obtained by the two algorithms. (i.e. how close to the optimal solution are the solutions obtained by the algorithms)\n", + "- Compare whether feature scaling is necessary for each algorithm to perform well.\n", + "\n", + "Finally, select the algorithm you think is more suitable for this problemset and explain why you chose it." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Part 3: Polynomial Regression\n", + "\n", + "In real-world data, a straight line might not fit the data perfectly. Consider the relation between **schools** and **asking_price**.\n", + "\n", + " \n", + "
\n", + "\"school\n", + "
Figure 5: Schools - Price Relationship.
\n", + "
\n", + "\n", + "Houses with 0 schools nearby tend to be cheaper than houses with 1 school nearby. However, as the number of schools increases, the prices decrease. If we try a linear regression on the data, we obtain the following:\n", + "\n", + " \n", + "
\n", + "\"school\n", + "
Figure 5.1: Schools - Price Relationship With Linear Fit.
\n", + "
\n", + "\n", + "Notice how we lose the detail that houses with 0 schools are actually cheaper than houses with 1 school nearby. A polynomial function can better capture this relationship:\n", + "\n", + " \n", + "
\n", + "\"school\n", + "
Figure 5.2: Schools - Price Relationship With Cubic Fit.
\n", + "
\n", + "\n", + "A polynomial function is written as follows:\n", + "\n", + "$$ y = w_0 + w_1 x + w_2 x^2 + ... + w_n x^n $$\n", + "\n", + "where $y$ is the target value, $x$ is a (*single*) feature value, and $n$ is the degree of the polynomial. $w_0$ is the bias term and $w_1, \\dots, w_n$ are the feature weights. \n", + "\n", + "Notice how if we set $x_1 = x, x_2 = x^2, \\dots, x_n = x^n$. The polynomial function is simply linear regression with $n$ features:\n", + "\n", + "$$ y = w_0 + w_1 x_1 + w_2 x_2 + ... + w_n x_n $$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Task 3.1 : Create Polynomial Matrix\n", + "\n", + "Write the function `create_polynomial_matrix(X, power)` that takes a $(m, 1)$-matrix and an\n", + "integer, and returns a polynomial matrix with shape $(m, power)$.\n", + "\n", + "$$\n", + "\\left[\\begin{array}{cc} \n", + "1\\\\\n", + "2\\\\\n", + "3\n", + "\\end{array}\\right]\n", + "\\xrightarrow{\\text{create\\_polynomial\\_matrix(3)}}\n", + "\\left[\\begin{array}{cc} \n", + "1 & 1^2 & 1^3\\\\ \n", + "2 & 2^2 & 2^3\\\\\n", + "3 & 3^2 & 3^3\n", + "\\end{array}\\right]\n", + "\\rightarrow\n", + "\\left[\\begin{array}{cc} \n", + "1 & 1 & 1\\\\ \n", + "2 & 4 & 8\\\\\n", + "3 & 9 & 27\n", + "\\end{array}\\right]\n", + "t]\n", + "$$\n", + "**Hint**: Consider using `np.tile`/`np.repeat` together with `np.cumprod`/`np.power`." + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [], + "source": [ + "def create_polynomial_matrix(X, power = 2):\n", + " '''\n", + " Create a polynomial matrix.\n", + " \n", + " Parameters\n", + " ----------\n", + " X: (m, 1) numpy matrix\n", + "\n", + " Returns\n", + " -------\n", + " A (m, power) numpy matrix where the i-th column denotes\n", + " X raised to the power of i.\n", + " '''\n", + " result = np.repeat(X, power, axis=1)\n", + " result = np.power(result, np.arange(1, power+1))\n", + " return result" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [], + "source": [ + "vector = np.array([[1], [2], [3]])\n", + "poly_matrix = np.array([[1, 1, 1], [2, 4, 8], [3, 9, 27]])\n", + "\n", + "assert np.array_equal(create_polynomial_matrix(vector, 3), poly_matrix)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Task 3.2: Get the prediction line\n", + "\n", + "Write the function `get_prediction_poly_regression(X, y, power, include_bias)` that returns\n", + "`y_pred`, a vector of predicted values for the training data.\n", + "\n", + "**Note**: You can use the functions `create_polynomial_matrix` and `get_prediction_linear_regression` from before for this task. (You do not need to re-define the functions in Coursemology. However, you are free to do so if you explicitly want to use your own implementation of the functions for this task.)" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [], + "source": [ + "def get_prediction_poly_regression(X, y, power = 2, include_bias = True):\n", + " '''\n", + " Calculate the best polynomial line.\n", + "\n", + " Parameters\n", + " ----------\n", + " X (np.ndarray) : (m, 1) numpy matrix representing feature matrix\n", + " y (np.ndarray) : (m, 1) numpy matrix representing target values\n", + " power (int) : Specify the degree of the polynomial\n", + " include_bias (boolean) : Specify whether the model should include a bias term\n", + "\n", + " Returns\n", + " -------\n", + " A (m, 1) numpy matrix representing prediction values.\n", + " '''\n", + " return get_prediction_linear_regression(create_polynomial_matrix(X, power), y, include_bias)" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": {}, + "outputs": [], + "source": [ + "test_X, test_y = np.arange(3).reshape((-1, 1)), np.arange(4, 7).reshape((-1, 1))\n", + "pred_y = get_prediction_poly_regression(test_X, test_y, 2)\n", + "\n", + "assert round(mean_squared_error(test_y, pred_y), 5) == 0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To check your work, create a polynomial regression model, using `power = 3` and `include_bias = True`, with **schools** as the only feature and **asking_price** as the target value. Plot your prediction line using the code snippet below. It should look similar to Figure 6.\n", + "\n", + " \n", + "
\n", + "\"polynomial\n", + "
Figure 6: Example of polynomial regression using schools as feature.
\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "schools = X[:, 2].reshape((-1, 1))\n", + "predicted = get_prediction_poly_regression(schools, y, 3)\n", + "plt.scatter(schools, y)\n", + "plt.scatter(schools, predicted, color = 'r', s = 100)\n", + "plt.xlabel(\"Number of schools within 1km\")\n", + "plt.ylabel(\"Price in SGD\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Task 3.3: Feature Scaling\n", + "\n", + "As we create a higher degree polynomial matrix, each column will have a larger scale\n", + "than the previous one. This can lead to poor performance for gradient descent. Here\n", + "is where feature scaling plays an important role. Write the function `feature_scaling(X)`\n", + "that takes a NumPy matrix `X` and returns a mean-normalized matrix.\n", + "\n", + "**Note**: The normalization occurs on the column level (i-th column is normalized by the\n", + "mean and standard deviation of the i-th column). That is,\n", + "\n", + "$$\n", + "\\text{If} \\quad \\boldsymbol{v} = \\begin{pmatrix} v_1 \\\\ v_2 \\\\ \\vdots \\\\ v_k \\end{pmatrix} \\\\\n", + "\\boldsymbol{v}_{norm} = \\frac{\\boldsymbol{v} - \\boldsymbol{\\hat{v}}}{\\sigma_{v}}\n", + "$$\n", + "\n", + "where $\\boldsymbol{v}$ is a vector of $k$ elements, $\\boldsymbol{\\hat{v}}$ is its mean, and $\\sigma_{v}$ is its standard deviation.\n", + "\n", + "$$\n", + "\\left[\\begin{array}{cc} \n", + "1 & 133\\\\\n", + "4 & 700\\\\\n", + "5 & 133\\\\\n", + "8 & 700\n", + "\\end{array}\\right]\n", + "\\xrightarrow[]{\\text{feature\\_scaling}}\n", + "\\left[\\begin{array}{cc} \n", + "-1.4 & -1\\\\\n", + "-0.2 & 1\\\\\n", + "0.2 & -1\\\\\n", + "1.4 & 1\n", + "\\end{array}\\right]\n", + "$$ \n", + "\n", + "Focusing on the first feature:\n", + "\n", + "$$\n", + "\\boldsymbol{v} = \\left(\\begin{array}{cc}\n", + "1\\\\\n", + "4\\\\\n", + "5\\\\\n", + "8\n", + "\\end{array}\\right), \\boldsymbol{\\hat{v}} = 4.5, \\sigma_{v} = 2.5$$\n", + "\n", + "$$\\boldsymbol{v}_{norm} = \\frac{\\boldsymbol{v} - 4.5}{2.5} = \\left(\\begin{array}{cc}\n", + "-1.4\\\\\n", + "-0.2\\\\\n", + "0.2\\\\\n", + "1.4\n", + "\\end{array}\\right)\n", + "$$\n", + "\n", + "**Hint**: Consider using `np.mean()` and `np.std()`." + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [], + "source": [ + "def feature_scaling(X):\n", + " '''\n", + " Mean normalized each feature column.\n", + "\n", + " Parameters\n", + " ----------\n", + " X (np.ndarray) : (m, n) numpy matrix representing feature matrix\n", + "\n", + " Returns\n", + " -------\n", + " A (m, n) numpy matrix where each column has been mean-normalized.\n", + " '''\n", + " means = np.mean(X, axis=0)\n", + " stds = np.std(X, axis=0)\n", + " return (X - means) / stds" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [], + "source": [ + "public_X = np.array([[1, 133], [4, 700], [5, 133], [8, 700]])\n", + "expected = np.array([[-1.4, -1], [-0.2, 1], [0.2, -1], [1.4, 1]])\n", + "\n", + "assert np.array_equal(feature_scaling(public_X), expected)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Task 3.4: Find number of epochs to converge\n", + "\n", + "Fill in the function `find_number_of_epochs(X, y, lr, delta_loss)` that that returns:\n", + "\n", + "* $w_0$ - a number representing the bias constant\n", + "* $w_1, w_2, \\dots, w_n$ - $(n, 1)$ NumPy matrix, where each element denotes the weight constant of a certain feature\n", + "* $num\\_of\\_epochs$ - a number representing the number of epochs performed to reach convergence\n", + "\n", + "We define a single epoch as performing gradient descent *once* and calculating the loss. The loss calculation and gradient descent should be performed using MSE.\n", + "\n", + "The definition of convergence is as follows:\n", + "\n", + "$$ |J_{t-1} - J_{t}| < delta\\_loss $$\n", + "\n", + "where $J_{t-1}$ is loss at timestep $t-1$ (previous timestep), $J_{t}$ is loss at timestep $t$ (current timestep), and $delta\\_loss$ is the termination criterion. " + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "metadata": {}, + "outputs": [], + "source": [ + "def find_number_of_epochs(X, y, lr, delta_loss):\n", + " '''\n", + " Do gradient descent until convergence and return number of epochs\n", + " required.\n", + "\n", + " Parameters\n", + " ----------\n", + " X (np.ndarray) : (m, n) numpy matrix representing feature matrix\n", + " y (np.ndarray) : (m, 1) numpy matrix representing target values\n", + " lr (float) : Learning rate\n", + " delta_loss (float) : Termination criterion\n", + " \n", + " Returns\n", + " -------\n", + " bias (float):\n", + " The bias constant\n", + " weights (np.ndarray):\n", + " A (n, 1) numpy matrix that specifies the weight constants.\n", + " num_of_epochs (int):\n", + " Number of epochs to reach convergence.\n", + " current_loss (float):\n", + " The loss value obtained after convergence.\n", + " '''\n", + " # Do not change\n", + " bias = 0\n", + " weights = np.full((X.shape[1], 1), 0).astype(float)\n", + " num_of_epochs = 0\n", + " previous_loss = 1e14\n", + " current_loss = -1e14\n", + "\n", + " while abs(previous_loss - current_loss) >= delta_loss:\n", + " previous_loss = current_loss\n", + "\n", + " predicted_y = bias + X @ weights\n", + "\n", + " weight_gradient = np.mean((predicted_y - y)*X, axis=0).reshape((X.shape[1],1))\n", + " weights -= lr * weight_gradient\n", + "\n", + " bias_gradient = np.mean(predicted_y - y)\n", + " bias -= lr * bias_gradient\n", + " num_of_epochs += 1\n", + "\n", + " predicted_y = bias + X @ weights\n", + " current_loss = mean_squared_error(predicted_y, y)\n", + " \n", + " return bias, weights, num_of_epochs, current_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "metadata": {}, + "outputs": [], + "source": [ + "poly_X = create_polynomial_matrix(X[:, 2].reshape((-1, 1)), 3)\n", + "_, _, num_of_epochs, _ = find_number_of_epochs(poly_X, y, 1e-5, 1e7)\n", + "\n", + "assert num_of_epochs > 0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Task 3.5: Analyze the effects of feature scaling on Gradient Descent\n", + "\n", + "In this task, we will examine the influence of feature scaling on the efficiency of gradient descent algorithms. Specifically, we utilize a degree 3 polynomial feature matrix derived from a dataset of schools.\n", + "\n", + "Objective: \n", + "You will compare the convergence patterns of gradient descent with and without the application of feature scaling.\n", + "\n", + "Experiment Procedure: \n", + "Below is a pre-written code segment design for this analysis. You are not required to modify the code. Instead, use it to focus on two key aspects:\n", + "1. Convergence analysis\n", + " - Observe the number of epochs required to achieve convergence for both the non-normalized (original) and normalized feature matrices. \n", + " This comparison should be conducted across various learning rates.\n", + "2. Loss visualization\n", + " - Analyze and plot the loss values corresponding to both the non-normalized and normalized matrices as a function of epoch count, again considering different learning rates.\n", + "\n", + "##### Instructions:\n", + "Execute the provided code and **draw 2 observations or conclusions** from the experiment results. **Include a screenshot** of the results(image and tabulation) along with your submission. These insights should relate to the effects of feature scaling on the efficiency of gradient descent algorithms.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning Rate | Epochs to convergence (Not normalized) | Epochs to convergence (Normalized) \n", + "----------------------------------------------------------------------------------------------------\n", + "1.0e-05 | 517177 | 319333 \n", + "5.0e-05 | 161792 | 80692 \n", + "1.0e-04 | 134359 | 44246 \n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "poly_X = create_polynomial_matrix(X[:, 2].reshape((-1, 1)), 3)\n", + "_, _, num_of_epochs, _ = find_number_of_epochs(poly_X, y, 1e-5, 1e7)\n", + "\n", + "assert num_of_epochs > 0 \n", + "poly_X_normalized = feature_scaling(poly_X)\n", + "delta_loss = 1e4\n", + "lrs = [1e-5, 5e-5, 1e-4]\n", + "LIMIT = 50000\n", + "lr_epochs_original = {}\n", + "lr_epochs_normalized = {}\n", + "losses_original = {} # key: lr, value: array of losses\n", + "losses_normalized = {} # key: lr, value: array of losses\n", + "poly_epochs_original = []\n", + "poly_epochs_normalized = []\n", + "print(\"{:<15} | {:<40} | {:<40}\".format(\"Learning Rate\", \"Epochs to convergence (Not normalized)\",\n", + " \"Epochs to convergence (Normalized)\"))\n", + "print(\"-\" * 100)\n", + "for lr in lrs:\n", + " _, _, num_of_epochs, _ = find_number_of_epochs(poly_X, y, lr, delta_loss)\n", + " _, _, num_of_epochs_normalized, _ = find_number_of_epochs(poly_X_normalized, y, lr, delta_loss)\n", + "\n", + " poly_epochs_original.append(num_of_epochs)\n", + " poly_epochs_normalized.append(num_of_epochs_normalized)\n", + "\n", + " lr_epochs_original[lr] = min(num_of_epochs, LIMIT)\n", + " lr_epochs_normalized[lr] = min(num_of_epochs_normalized, LIMIT)\n", + " lr_formatted = \"{:.1e}\".format(lr)\n", + " print(\"{:<15} | {:<40} | {:<40}\".format(lr_formatted, num_of_epochs, num_of_epochs_normalized))\n", + " losses_original[lr] = gradient_descent_multi_variable(poly_X, y, lr, num_of_epochs)[2]\n", + " losses_normalized[lr] = gradient_descent_multi_variable(poly_X_normalized, y, lr, num_of_epochs_normalized)[2]\n", + "\n", + "# Find the global minimum and maximum loss values so that their scales are the same\n", + "all_losses = list(losses_original.values()) + list(losses_normalized.values())\n", + "global_min_loss = min([min(losses) for losses in all_losses])\n", + "global_max_loss = max([max(losses) for losses in all_losses])\n", + "\n", + "plt.figure(figsize=(12, 6))\n", + "\n", + "# Plot for Original Data\n", + "plt.subplot(1, 2, 1)\n", + "plt.title('Loss vs Epochs (Original Data)')\n", + "for lr in lrs:\n", + " epochs = lr_epochs_original[lr]\n", + " plt.plot(range(epochs), losses_original[lr][:epochs], label=f'LR = {lr}')\n", + "plt.xlabel('Epoch Number')\n", + "plt.ylabel('Loss')\n", + "plt.ylim([global_min_loss, global_max_loss]) # Set common y-axis limits\n", + "plt.legend()\n", + "\n", + "# Plot for Normalized Data\n", + "plt.subplot(1, 2, 2)\n", + "plt.title('Loss vs Epochs (Normalized Data)')\n", + "for lr in lrs:\n", + " epochs = lr_epochs_normalized[lr]\n", + " plt.plot(range(epochs), losses_normalized[lr][:epochs], label=f'LR = {lr}')\n", + "plt.xlabel('Epoch Number')\n", + "plt.ylabel('Loss')\n", + "plt.ylim([global_min_loss, global_max_loss]) # Set common y-axis limits\n", + "plt.legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Submission\n", + "\n", + "Once you are done, please submit your work to Coursemology, by copying the right\n", + "snippets of code into the corresponding box that says “Your answer,” and click “Save.”\n", + "After you save, you can still make changes to your submission.\n", + "\n", + "Once you are satisfied with what you have uploaded, click “Finalize submission.” Note\n", + "that once your submission is finalized, it is considered to be submitted for grading\n", + "and cannot be changed. If you need to undo this action, you will have to email your\n", + "assigned tutor for help. Please do not finalize your submission until you are sure that\n", + "you want to submit your solutions for grading." + ] + } + ], + "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.9.9" + }, + "vscode": { + "interpreter": { + "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}