diff --git a/linear regression/1_cuda.py b/linear regression/1_cuda.py index 634e697..c9ccb3e 100644 --- a/linear regression/1_cuda.py +++ b/linear regression/1_cuda.py @@ -39,7 +39,7 @@ def gradient_descent_runner(points, starting_b, starting_w, learningRate, num_it def run(): points_np = np.genfromtxt("data1.csv", delimiter=',').astype(np.float32) - points = torch.tensor(points_np, device='cuda:5') + points = torch.tensor(points_np, device='cuda') learning_rate = 0.0001 initial_b = 0.0 initial_w = 0.0 diff --git a/linear regression/m1.pth b/linear regression/m1.pth new file mode 100644 index 0000000..1e389c5 Binary files /dev/null and b/linear regression/m1.pth differ diff --git a/linear regression/m1.py b/linear regression/m1.py new file mode 100644 index 0000000..9215f34 --- /dev/null +++ b/linear regression/m1.py @@ -0,0 +1,76 @@ +import torch +import torch.nn as nn +import torch.optim as optim +from torch.utils.data import DataLoader, TensorDataset +import matplotlib.pyplot as plt + + +# 检查是否支持MPS（Apple Metal Performance Shaders） +device = torch.device("mps" if torch.backends.mps.is_available() else "cpu") +print(f"使用设备: {device}") + +# 生成示例数据 +# y = 3x + 2 + 噪声 +torch.manual_seed(0) +X = torch.linspace(-10, 10, steps=100).reshape(-1, 1) +y = 3 * X + 2 + torch.randn(X.size()) * 2 + +# 创建数据集和数据加载器 +dataset = TensorDataset(X, y) +dataloader = DataLoader(dataset, batch_size=10, shuffle=True) + + +# 定义线性回归模型 +class LinearRegressionModel(nn.Module): + def __init__(self): + super(LinearRegressionModel, self).__init__() + self.linear = nn.Linear(1, 1) # 输入和输出都是1维 + + def forward(self, x): + return self.linear(x) + + +# 实例化模型并移动到设备 +model = LinearRegressionModel().to(device) + +# 定义损失函数和优化器 +criterion = nn.MSELoss() +optimizer = optim.SGD(model.parameters(), lr=0.01) + +# 训练模型 +num_epochs = 100 +for epoch in range(num_epochs): + for batch_X, batch_y in dataloader: + batch_X = batch_X.to(device) + batch_y = batch_y.to(device) + + # 前向传播 + outputs = model(batch_X) + loss = criterion(outputs, batch_y) + + # 反向传播和优化 + optimizer.zero_grad() + loss.backward() + optimizer.step() + + if (epoch + 1) % 10 == 0: + print(f"Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}") + +# 保存整个模型 +torch.save(model.state_dict(), 'm1.pth') +print("整个模型已保存为 m1.pth") + +# 评估模型 +model.eval() +with torch.no_grad(): + X_test = torch.linspace(-10, 10, steps=100).reshape(-1, 1).to(device) + y_pred = model(X_test).cpu() + + +plt.scatter(X.numpy(), y.numpy(), label='真实数据') +plt.plot(X_test.cpu().numpy(), y_pred.numpy(), color='red', label='预测线') +plt.legend() +plt.xlabel('X') +plt.ylabel('y') +plt.title('线性回归结果') +plt.show() diff --git a/linear regression/m1test.py b/linear regression/m1test.py new file mode 100644 index 0000000..d320812 --- /dev/null +++ b/linear regression/m1test.py @@ -0,0 +1,56 @@ +import torch +import torch.nn as nn +import matplotlib.pyplot as plt + + +# 定义线性回归模型结构 +class LinearRegressionModel(nn.Module): + def __init__(self): + super(LinearRegressionModel, self).__init__() + self.linear = nn.Linear(1, 1) # 输入和输出都是1维 + + def forward(self, x): + return self.linear(x) + + +def main(): + # 检查是否支持MPS（Apple Metal Performance Shaders） + device = torch.device("mps" if torch.backends.mps.is_available() else "cpu") + print(f"使用设备: {device}") + + # 实例化模型并加载保存的模型参数 + model = LinearRegressionModel().to(device) + model.load_state_dict(torch.load('m1.pth')) + with open('m1.pth', 'rb') as f: + f.seek(0, 2) + size = f.tell() + print(f"模型文件大小: {size} 字节") + model.eval() + # 输出模型大小 + model_size = sum(p.numel() for p in model.parameters()) + print(f"模型大小: {model_size} 个参数") + print("模型参数已加载") + + # 生成测试数据 + X_test = torch.linspace(-10, 10, steps=100).reshape(-1, 1).to(device) + + # 使用加载的模型进行预测 + with torch.no_grad(): + y_pred = model(X_test).cpu() + + # 将测试数据移至CPU并转换为NumPy数组 + X_test_numpy = X_test.cpu().numpy() + y_pred_numpy = y_pred.numpy() + + # 可视化预测结果 + plt.scatter(X_test_numpy, 3 * X_test_numpy + 2, label='真实线性关系', color='blue') + plt.plot(X_test_numpy, y_pred_numpy, color='red', label='模型预测线') + plt.legend() + plt.xlabel('X') + plt.ylabel('y') + plt.title('加载模型后的线性回归预测结果') + plt.show() + + +if __name__ == "__main__": + main() diff --git a/mlcode/22.py b/mlcode/22.py new file mode 100644 index 0000000..db7a52e --- /dev/null +++ b/mlcode/22.py @@ -0,0 +1,9 @@ +import numpy as np + +w = np.array([1, 2, 3]) +b = 4 +x = np.array([10, 20, 30]) + +f = np.dot(w, x) + b + +print(f) diff --git a/plt/style.mplstyle b/plt/style.mplstyle deleted file mode 100644 index e6d4222..0000000 --- a/plt/style.mplstyle +++ /dev/null @@ -1,52 +0,0 @@ -# Line properties -lines.linewidth: 4 -lines.solid_capstyle: butt - -# Legend properties -legend.fancybox: true - -# Color and cycle properties -axes.prop_cycle: cycler('color', ['#0096FF', '#FF9300', '#FF40FF', '#7030A0', '#C00000']) -axes.facecolor: '#ffffff' # white -axes.labelsize: large -axes.axisbelow: true -axes.grid: False -axes.edgecolor: '#f0f0f0' -axes.linewidth: 3.0 -axes.titlesize: x-large - -# Patch properties -patch.edgecolor: '#f0f0f0' -patch.linewidth: 0.5 - -# SVG properties -svg.fonttype: path - -# Grid properties -grid.linestyle: '-' -grid.linewidth: 1.0 -grid.color: '#cbcbcb' - -# Ticks properties -xtick.major.size: 0 -xtick.minor.size: 0 -ytick.major.size: 0 -ytick.minor.size: 0 - -# Savefig properties -savefig.edgecolor: '#f0f0f0' -savefig.facecolor: '#f0f0f0' - -# Figure properties -figure.facecolor: '#ffffff' # white - -# Font properties -font.family: sans-serif -font.style: normal -font.variant: normal -font.weight: normal -font.stretch: normal -font.size: 8.0 - -# Text properties -text.color: black diff --git a/week2/C1_W2_Lab01_Python_Numpy_Vectorization_Soln.ipynb b/week2/C1_W2_Lab01_Python_Numpy_Vectorization_Soln.ipynb new file mode 100644 index 0000000..24f4d9c --- /dev/null +++ b/week2/C1_W2_Lab01_Python_Numpy_Vectorization_Soln.ipynb @@ -0,0 +1,916 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Optional Lab: Python, NumPy and Vectorization\n", + "A brief introduction to some of the scientific computing used in this course. In particular the NumPy scientific computing package and its use with python.\n", + "\n", + "# Outline\n", + "- [  1.1 Goals](#toc_40015_1.1)\n", + "- [  1.2 Useful References](#toc_40015_1.2)\n", + "- [2 Python and NumPy ](#toc_40015_2)\n", + "- [3 Vectors](#toc_40015_3)\n", + "- [  3.1 Abstract](#toc_40015_3.1)\n", + "- [  3.2 NumPy Arrays](#toc_40015_3.2)\n", + "- [  3.3 Vector Creation](#toc_40015_3.3)\n", + "- [  3.4 Operations on Vectors](#toc_40015_3.4)\n", + "- [4 Matrices](#toc_40015_4)\n", + "- [  4.1 Abstract](#toc_40015_4.1)\n", + "- [  4.2 NumPy Arrays](#toc_40015_4.2)\n", + "- [  4.3 Matrix Creation](#toc_40015_4.3)\n", + "- [  4.4 Operations on Matrices](#toc_40015_4.4)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # it is an unofficial standard to use np for numpy\n", + "import time" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 1.1 Goals\n", + "In this lab, you will:\n", + "- Review the features of NumPy and Python that are used in Course 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 1.2 Useful References\n", + "- NumPy Documentation including a basic introduction: [NumPy.org](https://NumPy.org/doc/stable/)\n", + "- A challenging feature topic: [NumPy Broadcasting](https://NumPy.org/doc/stable/user/basics.broadcasting.html)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# 2 Python and NumPy \n", + "Python is the programming language we will be using in this course. It has a set of numeric data types and arithmetic operations. NumPy is a library that extends the base capabilities of python to add a richer data set including more numeric types, vectors, matrices, and many matrix functions. NumPy and python work together fairly seamlessly. Python arithmetic operators work on NumPy data types and many NumPy functions will accept python data types.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# 3 Vectors\n", + "\n", + "## 3.1 Abstract\n", + "Vectors, as you will use them in this course, are ordered arrays of numbers. In notation, vectors are denoted with lower case bold letters such as $\\mathbf{x}$. The elements of a vector are all the same type. A vector does not, for example, contain both characters and numbers. The number of elements in the array is often referred to as the *dimension* though mathematicians may prefer *rank*. The vector shown has a dimension of $n$. The elements of a vector can be referenced with an index. In math settings, indexes typically run from 1 to n. In computer science and these labs, indexing will typically run from 0 to n-1. In notation, elements of a vector, when referenced individually will indicate the index in a subscript, for example, the $0^{th}$ element, of the vector $\\mathbf{x}$ is $x_0$. Note, the x is not bold in this case. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 3.2 NumPy Arrays\n", + "\n", + "NumPy's basic data structure is an indexable, n-dimensional *array* containing elements of the same type (`dtype`). Right away, you may notice we have overloaded the term 'dimension'. Above, it was the number of elements in the vector, here, dimension refers to the number of indexes of an array. A one-dimensional or 1-D array has one index. In Course 1, we will represent vectors as NumPy 1-D arrays. \n", + "\n", + " - 1-D array, shape (n,): n elements indexed [0] through [n-1]\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 3.3 Vector Creation\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Data creation routines in NumPy will generally have a first parameter which is the shape of the object. This can either be a single value for a 1-D result or a tuple (n,m,...) specifying the shape of the result. Below are examples of creating vectors using these routines." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "np.zeros(4) : a = [0. 0. 0. 0.], a shape = (4,), a data type = float64\n", + "np.zeros(4,) : a = [0. 0. 0. 0.], a shape = (4,), a data type = float64\n", + "np.random.random_sample(4): a = [0.04076162 0.01386783 0.16757523 0.9833998 ], a shape = (4,), a data type = float64\n" + ] + } + ], + "source": [ + "# NumPy routines which allocate memory and fill arrays with value\n", + "a = np.zeros(4); print(f\"np.zeros(4) : a = {a}, a shape = {a.shape}, a data type = {a.dtype}\")\n", + "a = np.zeros((4,)); print(f\"np.zeros(4,) : a = {a}, a shape = {a.shape}, a data type = {a.dtype}\")\n", + "a = np.random.random_sample(4); print(f\"np.random.random_sample(4): a = {a}, a shape = {a.shape}, a data type = {a.dtype}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Some data creation routines do not take a shape tuple:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "np.arange(4.): a = [0. 1. 2. 3.], a shape = (4,), a data type = float64\n", + "np.random.rand(4): a = [0.37476357 0.06946621 0.79627083 0.96134986], a shape = (4,), a data type = float64\n" + ] + } + ], + "source": [ + "# NumPy routines which allocate memory and fill arrays with value but do not accept shape as input argument\n", + "a = np.arange(4.); print(f\"np.arange(4.): a = {a}, a shape = {a.shape}, a data type = {a.dtype}\")\n", + "a = np.random.rand(4); print(f\"np.random.rand(4): a = {a}, a shape = {a.shape}, a data type = {a.dtype}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "values can be specified manually as well. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "np.array([5,4,3,2]): a = [5 4 3 2], a shape = (4,), a data type = int64\n", + "np.array([5.,4,3,2]): a = [5. 4. 3. 2.], a shape = (4,), a data type = float64\n" + ] + } + ], + "source": [ + "# NumPy routines which allocate memory and fill with user specified values\n", + "a = np.array([5,4,3,2]); print(f\"np.array([5,4,3,2]): a = {a}, a shape = {a.shape}, a data type = {a.dtype}\")\n", + "a = np.array([5.,4,3,2]); print(f\"np.array([5.,4,3,2]): a = {a}, a shape = {a.shape}, a data type = {a.dtype}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These have all created a one-dimensional vector `a` with four elements. `a.shape` returns the dimensions. Here we see a.shape = `(4,)` indicating a 1-d array with 4 elements. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 3.4 Operations on Vectors\n", + "Let's explore some operations using vectors.\n", + "\n", + "### 3.4.1 Indexing\n", + "Elements of vectors can be accessed via indexing and slicing. NumPy provides a very complete set of indexing and slicing capabilities. We will explore only the basics needed for the course here. Reference [Slicing and Indexing](https://NumPy.org/doc/stable/reference/arrays.indexing.html) for more details. \n", + "**Indexing** means referring to *an element* of an array by its position within the array. \n", + "**Slicing** means getting a *subset* of elements from an array based on their indices. \n", + "NumPy starts indexing at zero so the 3rd element of an vector $\\mathbf{a}$ is `a[2]`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0 1 2 3 4 5 6 7 8 9]\n", + "a[2].shape: () a[2] = 2, Accessing an element returns a scalar\n", + "a[-1] = 9\n", + "The error message you'll see is:\n", + "index 10 is out of bounds for axis 0 with size 10\n" + ] + } + ], + "source": [ + "#vector indexing operations on 1-D vectors\n", + "a = np.arange(10)\n", + "print(a)\n", + "\n", + "#access an element\n", + "print(f\"a[2].shape: {a[2].shape} a[2] = {a[2]}, Accessing an element returns a scalar\")\n", + "\n", + "# access the last element, negative indexes count from the end\n", + "print(f\"a[-1] = {a[-1]}\")\n", + "\n", + "#indexs must be within the range of the vector or they will produce and error\n", + "try:\n", + " c = a[10]\n", + "except Exception as e:\n", + " print(\"The error message you'll see is:\")\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.4.2 Slicing\n", + "Slicing creates an array of indices using a set of three values (`start:stop:step`). A subset of values is also valid. Its use is best explained by example:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a = [0 1 2 3 4 5 6 7 8 9]\n", + "a[2:7:1] = [2 3 4 5 6]\n", + "a[2:7:2] = [2 4 6]\n", + "a[3:] = [3 4 5 6 7 8 9]\n", + "a[:3] = [0 1 2]\n", + "a[:] = [0 1 2 3 4 5 6 7 8 9]\n" + ] + } + ], + "source": [ + "#vector slicing operations\n", + "a = np.arange(10)\n", + "print(f\"a = {a}\")\n", + "\n", + "#access 5 consecutive elements (start:stop:step)\n", + "c = a[2:7:1]; print(\"a[2:7:1] = \", c)\n", + "\n", + "# access 3 elements separated by two \n", + "c = a[2:7:2]; print(\"a[2:7:2] = \", c)\n", + "\n", + "# access all elements index 3 and above\n", + "c = a[3:]; print(\"a[3:] = \", c)\n", + "\n", + "# access all elements below index 3\n", + "c = a[:3]; print(\"a[:3] = \", c)\n", + "\n", + "# access all elements\n", + "c = a[:]; print(\"a[:] = \", c)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.4.3 Single vector operations\n", + "There are a number of useful operations that involve operations on a single vector." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a : [1 2 3 4]\n", + "b = -a : [-1 -2 -3 -4]\n", + "b = np.sum(a) : 10\n", + "b = np.mean(a): 2.5\n", + "b = a**2 : [ 1 4 9 16]\n" + ] + } + ], + "source": [ + "a = np.array([1,2,3,4])\n", + "print(f\"a : {a}\")\n", + "# negate elements of a\n", + "b = -a \n", + "print(f\"b = -a : {b}\")\n", + "\n", + "# sum all elements of a, returns a scalar\n", + "b = np.sum(a) \n", + "print(f\"b = np.sum(a) : {b}\")\n", + "\n", + "b = np.mean(a)\n", + "print(f\"b = np.mean(a): {b}\")\n", + "\n", + "b = a**2\n", + "print(f\"b = a**2 : {b}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.4.4 Vector Vector element-wise operations\n", + "Most of the NumPy arithmetic, logical and comparison operations apply to vectors as well. These operators work on an element-by-element basis. For example \n", + "$$ c_i = a_i + b_i $$" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Binary operators work element wise: [0 0 6 8]\n" + ] + } + ], + "source": [ + "a = np.array([ 1, 2, 3, 4])\n", + "b = np.array([-1,-2, 3, 4])\n", + "print(f\"Binary operators work element wise: {a + b}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Of course, for this to work correctly, the vectors must be of the same size:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The error message you'll see is:\n", + "operands could not be broadcast together with shapes (4,) (2,) \n" + ] + } + ], + "source": [ + "#try a mismatched vector operation\n", + "c = np.array([1, 2])\n", + "try:\n", + " d = a + c\n", + "except Exception as e:\n", + " print(\"The error message you'll see is:\")\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.4.5 Scalar Vector operations\n", + "Vectors can be 'scaled' by scalar values. A scalar value is just a number. The scalar multiplies all the elements of the vector." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b = 5 * a : [ 5 10 15 20]\n" + ] + } + ], + "source": [ + "a = np.array([1, 2, 3, 4])\n", + "\n", + "# multiply a by a scalar\n", + "b = 5 * a \n", + "print(f\"b = 5 * a : {b}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.4.6 Vector Vector dot product\n", + "The dot product is a mainstay of Linear Algebra and NumPy. This is an operation used extensively in this course and should be well understood. The dot product is shown below." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The dot product multiplies the values in two vectors element-wise and then sums the result.\n", + "Vector dot product requires the dimensions of the two vectors to be the same. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's implement our own version of the dot product below:\n", + "\n", + "**Using a for loop**, implement a function which returns the dot product of two vectors. The function to return given inputs $a$ and $b$:\n", + "$$ x = \\sum_{i=0}^{n-1} a_i b_i $$\n", + "Assume both `a` and `b` are the same shape." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def my_dot(a, b): \n", + " \"\"\"\n", + " Compute the dot product of two vectors\n", + " \n", + " Args:\n", + " a (ndarray (n,)): input vector \n", + " b (ndarray (n,)): input vector with same dimension as a\n", + " \n", + " Returns:\n", + " x (scalar): \n", + " \"\"\"\n", + " x=0\n", + " for i in range(a.shape[0]):\n", + " x = x + a[i] * b[i]\n", + " return x" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "my_dot(a, b) = 24\n" + ] + } + ], + "source": [ + "# test 1-D\n", + "a = np.array([1, 2, 3, 4])\n", + "b = np.array([-1, 4, 3, 2])\n", + "print(f\"my_dot(a, b) = {my_dot(a, b)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note, the dot product is expected to return a scalar value. \n", + "\n", + "Let's try the same operations using `np.dot`. " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NumPy 1-D np.dot(a, b) = 24, np.dot(a, b).shape = () \n", + "NumPy 1-D np.dot(b, a) = 24, np.dot(a, b).shape = () \n" + ] + } + ], + "source": [ + "# test 1-D\n", + "a = np.array([1, 2, 3, 4])\n", + "b = np.array([-1, 4, 3, 2])\n", + "c = np.dot(a, b)\n", + "print(f\"NumPy 1-D np.dot(a, b) = {c}, np.dot(a, b).shape = {c.shape} \") \n", + "c = np.dot(b, a)\n", + "print(f\"NumPy 1-D np.dot(b, a) = {c}, np.dot(a, b).shape = {c.shape} \")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Above, you will note that the results for 1-D matched our implementation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.4.7 The Need for Speed: vector vs for loop\n", + "We utilized the NumPy library because it improves speed memory efficiency. Let's demonstrate:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "np.dot(a, b) = 2501072.5817\n", + "Vectorized version duration: 197.7768 ms \n", + "my_dot(a, b) = 2501072.5817\n", + "loop version duration: 8699.8875 ms \n" + ] + } + ], + "source": [ + "np.random.seed(1)\n", + "a = np.random.rand(10000000) # very large arrays\n", + "b = np.random.rand(10000000)\n", + "\n", + "tic = time.time() # capture start time\n", + "c = np.dot(a, b)\n", + "toc = time.time() # capture end time\n", + "\n", + "print(f\"np.dot(a, b) = {c:.4f}\")\n", + "print(f\"Vectorized version duration: {1000*(toc-tic):.4f} ms \")\n", + "\n", + "tic = time.time() # capture start time\n", + "c = my_dot(a,b)\n", + "toc = time.time() # capture end time\n", + "\n", + "print(f\"my_dot(a, b) = {c:.4f}\")\n", + "print(f\"loop version duration: {1000*(toc-tic):.4f} ms \")\n", + "\n", + "del(a);del(b) #remove these big arrays from memory" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So, vectorization provides a large speed up in this example. This is because NumPy makes better use of available data parallelism in the underlying hardware. GPU's and modern CPU's implement Single Instruction, Multiple Data (SIMD) pipelines allowing multiple operations to be issued in parallel. This is critical in Machine Learning where the data sets are often very large." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.4.8 Vector Vector operations in Course 1\n", + "Vector Vector operations will appear frequently in course 1. Here is why:\n", + "- Going forward, our examples will be stored in an array, `X_train` of dimension (m,n). This will be explained more in context, but here it is important to note it is a 2 Dimensional array or matrix (see next section on matrices).\n", + "- `w` will be a 1-dimensional vector of shape (n,).\n", + "- we will perform operations by looping through the examples, extracting each example to work on individually by indexing X. For example:`X[i]`\n", + "- `X[i]` returns a value of shape (n,), a 1-dimensional vector. Consequently, operations involving `X[i]` are often vector-vector. \n", + "\n", + "That is a somewhat lengthy explanation, but aligning and understanding the shapes of your operands is important when performing vector operations." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X[1] has shape (1,)\n", + "w has shape (1,)\n", + "c has shape ()\n" + ] + } + ], + "source": [ + "# show common Course 1 example\n", + "X = np.array([[1],[2],[3],[4]])\n", + "w = np.array([2])\n", + "c = np.dot(X[1], w)\n", + "\n", + "print(f\"X[1] has shape {X[1].shape}\")\n", + "print(f\"w has shape {w.shape}\")\n", + "print(f\"c has shape {c.shape}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# 4 Matrices\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 4.1 Abstract\n", + "Matrices, are two dimensional arrays. The elements of a matrix are all of the same type. In notation, matrices are denoted with capitol, bold letter such as $\\mathbf{X}$. In this and other labs, `m` is often the number of rows and `n` the number of columns. The elements of a matrix can be referenced with a two dimensional index. In math settings, numbers in the index typically run from 1 to n. In computer science and these labs, indexing will run from 0 to n-1. \n", + "
\n", + "
missing
\n", + "
Generic Matrix Notation, 1st index is row, 2nd is column
\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 4.2 NumPy Arrays\n", + "\n", + "NumPy's basic data structure is an indexable, n-dimensional *array* containing elements of the same type (`dtype`). These were described earlier. Matrices have a two-dimensional (2-D) index [m,n].\n", + "\n", + "In Course 1, 2-D matrices are used to hold training data. Training data is $m$ examples by $n$ features creating an (m,n) array. Course 1 does not do operations directly on matrices but typically extracts an example as a vector and operates on that. Below you will review: \n", + "- data creation\n", + "- slicing and indexing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 4.3 Matrix Creation\n", + "The same functions that created 1-D vectors will create 2-D or n-D arrays. Here are some examples\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below, the shape tuple is provided to achieve a 2-D result. Notice how NumPy uses brackets to denote each dimension. Notice further than NumPy, when printing, will print one row per line.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a shape = (1, 5), a = [[0. 0. 0. 0. 0.]]\n", + "a shape = (2, 1), a = [[0.]\n", + " [0.]]\n", + "a shape = (1, 1), a = [[0.44236513]]\n" + ] + } + ], + "source": [ + "a = np.zeros((1, 5)) \n", + "print(f\"a shape = {a.shape}, a = {a}\") \n", + "\n", + "a = np.zeros((2, 1)) \n", + "print(f\"a shape = {a.shape}, a = {a}\") \n", + "\n", + "a = np.random.random_sample((1, 1)) \n", + "print(f\"a shape = {a.shape}, a = {a}\") " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One can also manually specify data. Dimensions are specified with additional brackets matching the format in the printing above." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " a shape = (3, 1), np.array: a = [[5]\n", + " [4]\n", + " [3]]\n", + " a shape = (3, 1), np.array: a = [[5]\n", + " [4]\n", + " [3]]\n" + ] + } + ], + "source": [ + "# NumPy routines which allocate memory and fill with user specified values\n", + "a = np.array([[5], [4], [3]]); print(f\" a shape = {a.shape}, np.array: a = {a}\")\n", + "a = np.array([[5], # One can also\n", + " [4], # separate values\n", + " [3]]); #into separate rows\n", + "print(f\" a shape = {a.shape}, np.array: a = {a}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 4.4 Operations on Matrices\n", + "Let's explore some operations using matrices." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.4.1 Indexing\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Matrices include a second index. The two indexes describe [row, column]. Access can either return an element or a row/column. See below:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a.shape: (3, 2), \n", + "a= [[0 1]\n", + " [2 3]\n", + " [4 5]]\n", + "\n", + "a[2,0].shape: (), a[2,0] = 4, type(a[2,0]) = Accessing an element returns a scalar\n", + "\n", + "a[2].shape: (2,), a[2] = [4 5], type(a[2]) = \n" + ] + } + ], + "source": [ + "#vector indexing operations on matrices\n", + "a = np.arange(6).reshape(-1, 2) #reshape is a convenient way to create matrices\n", + "print(f\"a.shape: {a.shape}, \\na= {a}\")\n", + "\n", + "#access an element\n", + "print(f\"\\na[2,0].shape: {a[2, 0].shape}, a[2,0] = {a[2, 0]}, type(a[2,0]) = {type(a[2, 0])} Accessing an element returns a scalar\\n\")\n", + "\n", + "#access a row\n", + "print(f\"a[2].shape: {a[2].shape}, a[2] = {a[2]}, type(a[2]) = {type(a[2])}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is worth drawing attention to the last example. Accessing a matrix by just specifying the row will return a *1-D vector*." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Reshape** \n", + "The previous example used [reshape](https://numpy.org/doc/stable/reference/generated/numpy.reshape.html) to shape the array. \n", + "`a = np.arange(6).reshape(-1, 2) ` \n", + "This line of code first created a *1-D Vector* of six elements. It then reshaped that vector into a *2-D* array using the reshape command. This could have been written: \n", + "`a = np.arange(6).reshape(3, 2) ` \n", + "To arrive at the same 3 row, 2 column array.\n", + "The -1 argument tells the routine to compute the number of rows given the size of the array and the number of columns.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.4.2 Slicing\n", + "Slicing creates an array of indices using a set of three values (`start:stop:step`). A subset of values is also valid. Its use is best explained by example:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a = \n", + "[[ 0 1 2 3 4 5 6 7 8 9]\n", + " [10 11 12 13 14 15 16 17 18 19]]\n", + "a[0, 2:7:1] = [2 3 4 5 6] , a[0, 2:7:1].shape = (5,) a 1-D array\n", + "a[:, 2:7:1] = \n", + " [[ 2 3 4 5 6]\n", + " [12 13 14 15 16]] , a[:, 2:7:1].shape = (2, 5) a 2-D array\n", + "a[:,:] = \n", + " [[ 0 1 2 3 4 5 6 7 8 9]\n", + " [10 11 12 13 14 15 16 17 18 19]] , a[:,:].shape = (2, 10)\n", + "a[1,:] = [10 11 12 13 14 15 16 17 18 19] , a[1,:].shape = (10,) a 1-D array\n", + "a[1] = [10 11 12 13 14 15 16 17 18 19] , a[1].shape = (10,) a 1-D array\n" + ] + } + ], + "source": [ + "#vector 2-D slicing operations\n", + "a = np.arange(20).reshape(-1, 10)\n", + "print(f\"a = \\n{a}\")\n", + "\n", + "#access 5 consecutive elements (start:stop:step)\n", + "print(\"a[0, 2:7:1] = \", a[0, 2:7:1], \", a[0, 2:7:1].shape =\", a[0, 2:7:1].shape, \"a 1-D array\")\n", + "\n", + "#access 5 consecutive elements (start:stop:step) in two rows\n", + "print(\"a[:, 2:7:1] = \\n\", a[:, 2:7:1], \", a[:, 2:7:1].shape =\", a[:, 2:7:1].shape, \"a 2-D array\")\n", + "\n", + "# access all elements\n", + "print(\"a[:,:] = \\n\", a[:,:], \", a[:,:].shape =\", a[:,:].shape)\n", + "\n", + "# access all elements in one row (very common usage)\n", + "print(\"a[1,:] = \", a[1,:], \", a[1,:].shape =\", a[1,:].shape, \"a 1-D array\")\n", + "# same as\n", + "print(\"a[1] = \", a[1], \", a[1].shape =\", a[1].shape, \"a 1-D array\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Congratulations!\n", + "In this lab you mastered the features of Python and NumPy that are needed for Course 1." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "dl_toc_settings": { + "rndtag": "40015" + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + }, + "toc-autonumbering": false + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/week2/C1_W2_Lab02_Multiple_Variable_Soln.ipynb b/week2/C1_W2_Lab02_Multiple_Variable_Soln.ipynb new file mode 100644 index 0000000..ea16775 --- /dev/null +++ b/week2/C1_W2_Lab02_Multiple_Variable_Soln.ipynb @@ -0,0 +1,737 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Optional Lab: Multiple Variable Linear Regression\n", + "\n", + "In this lab, you will extend the data structures and previously developed routines to support multiple features. Several routines are updated making the lab appear lengthy, but it makes minor adjustments to previous routines making it quick to review.\n", + "# Outline\n", + "- [  1.1 Goals](#toc_15456_1.1)\n", + "- [  1.2 Tools](#toc_15456_1.2)\n", + "- [  1.3 Notation](#toc_15456_1.3)\n", + "- [2 Problem Statement](#toc_15456_2)\n", + "- [  2.1 Matrix X containing our examples](#toc_15456_2.1)\n", + "- [  2.2 Parameter vector w, b](#toc_15456_2.2)\n", + "- [3 Model Prediction With Multiple Variables](#toc_15456_3)\n", + "- [  3.1 Single Prediction element by element](#toc_15456_3.1)\n", + "- [  3.2 Single Prediction, vector](#toc_15456_3.2)\n", + "- [4 Compute Cost With Multiple Variables](#toc_15456_4)\n", + "- [5 Gradient Descent With Multiple Variables](#toc_15456_5)\n", + "- [  5.1 Compute Gradient with Multiple Variables](#toc_15456_5.1)\n", + "- [  5.2 Gradient Descent With Multiple Variables](#toc_15456_5.2)\n", + "- [6 Congratulations](#toc_15456_6)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 1.1 Goals\n", + "- Extend our regression model routines to support multiple features\n", + " - Extend data structures to support multiple features\n", + " - Rewrite prediction, cost and gradient routines to support multiple features\n", + " - Utilize NumPy `np.dot` to vectorize their implementations for speed and simplicity" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 1.2 Tools\n", + "In this lab, we will make use of: \n", + "- NumPy, a popular library for scientific computing\n", + "- Matplotlib, a popular library for plotting data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import copy, math\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "plt.style.use('./deeplearning.mplstyle')\n", + "np.set_printoptions(precision=2) # reduced display precision on numpy arrays" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 1.3 Notation\n", + "Here is a summary of some of the notation you will encounter, updated for multiple features. \n", + "\n", + "|General
Notation | Description| Python (if applicable) |\n", + "|: ------------|: ------------------------------------------------------------||\n", + "| $a$ | scalar, non bold ||\n", + "| $\\mathbf{a}$ | vector, bold ||\n", + "| $\\mathbf{A}$ | matrix, bold capital ||\n", + "| **Regression** | | | |\n", + "| $\\mathbf{X}$ | training example matrix | `X_train` | \n", + "| $\\mathbf{y}$ | training example targets | `y_train` \n", + "| $\\mathbf{x}^{(i)}$, $y^{(i)}$ | $i_{th}$Training Example | `X[i]`, `y[i]`|\n", + "| m | number of training examples | `m`|\n", + "| n | number of features in each example | `n`|\n", + "| $\\mathbf{w}$ | parameter: weight, | `w` |\n", + "| $b$ | parameter: bias | `b` | \n", + "| $f_{\\mathbf{w},b}(\\mathbf{x}^{(i)})$ | The result of the model evaluation at $\\mathbf{x^{(i)}}$ parameterized by $\\mathbf{w},b$: $f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) = \\mathbf{w} \\cdot \\mathbf{x}^{(i)}+b$ | `f_wb` | \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# 2 Problem Statement\n", + "\n", + "You will use the motivating example of housing price prediction. The training dataset contains three examples with four features (size, bedrooms, floors and, age) shown in the table below. Note that, unlike the earlier labs, size is in sqft rather than 1000 sqft. This causes an issue, which you will solve in the next lab!\n", + "\n", + "| Size (sqft) | Number of Bedrooms | Number of floors | Age of Home | Price (1000s dollars) | \n", + "| ----------------| ------------------- |----------------- |--------------|-------------- | \n", + "| 2104 | 5 | 1 | 45 | 460 | \n", + "| 1416 | 3 | 2 | 40 | 232 | \n", + "| 852 | 2 | 1 | 35 | 178 | \n", + "\n", + "You will build a linear regression model using these values so you can then predict the price for other houses. For example, a house with 1200 sqft, 3 bedrooms, 1 floor, 40 years old. \n", + "\n", + "Please run the following code cell to create your `X_train` and `y_train` variables." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "X_train = np.array([[2104, 5, 1, 45], [1416, 3, 2, 40], [852, 2, 1, 35]])\n", + "y_train = np.array([460, 232, 178])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 2.1 Matrix X containing our examples\n", + "Similar to the table above, examples are stored in a NumPy matrix `X_train`. Each row of the matrix represents one example. When you have $m$ training examples ( $m$ is three in our example), and there are $n$ features (four in our example), $\\mathbf{X}$ is a matrix with dimensions ($m$, $n$) (m rows, n columns).\n", + "\n", + "\n", + "$$\\mathbf{X} = \n", + "\\begin{pmatrix}\n", + " x^{(0)}_0 & x^{(0)}_1 & \\cdots & x^{(0)}_{n-1} \\\\ \n", + " x^{(1)}_0 & x^{(1)}_1 & \\cdots & x^{(1)}_{n-1} \\\\\n", + " \\cdots \\\\\n", + " x^{(m-1)}_0 & x^{(m-1)}_1 & \\cdots & x^{(m-1)}_{n-1} \n", + "\\end{pmatrix}\n", + "$$\n", + "notation:\n", + "- $\\mathbf{x}^{(i)}$ is vector containing example i. $\\mathbf{x}^{(i)}$ $ = (x^{(i)}_0, x^{(i)}_1, \\cdots,x^{(i)}_{n-1})$\n", + "- $x^{(i)}_j$ is element j in example i. The superscript in parenthesis indicates the example number while the subscript represents an element. \n", + "\n", + "Display the input data." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X Shape: (3, 4), X Type:)\n", + "[[2104 5 1 45]\n", + " [1416 3 2 40]\n", + " [ 852 2 1 35]]\n", + "y Shape: (3,), y Type:)\n", + "[460 232 178]\n" + ] + } + ], + "source": [ + "# data is stored in numpy array/matrix\n", + "print(f\"X Shape: {X_train.shape}, X Type:{type(X_train)})\")\n", + "print(X_train)\n", + "print(f\"y Shape: {y_train.shape}, y Type:{type(y_train)})\")\n", + "print(y_train)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 2.2 Parameter vector w, b\n", + "\n", + "* $\\mathbf{w}$ is a vector with $n$ elements.\n", + " - Each element contains the parameter associated with one feature.\n", + " - in our dataset, n is 4.\n", + " - notionally, we draw this as a column vector\n", + "\n", + "$$\\mathbf{w} = \\begin{pmatrix}\n", + "w_0 \\\\ \n", + "w_1 \\\\\n", + "\\cdots\\\\\n", + "w_{n-1}\n", + "\\end{pmatrix}\n", + "$$\n", + "* $b$ is a scalar parameter. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For demonstration, $\\mathbf{w}$ and $b$ will be loaded with some initial selected values that are near the optimal. $\\mathbf{w}$ is a 1-D NumPy vector." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "w_init shape: (4,), b_init type: \n" + ] + } + ], + "source": [ + "b_init = 785.1811367994083\n", + "w_init = np.array([ 0.39133535, 18.75376741, -53.36032453, -26.42131618])\n", + "print(f\"w_init shape: {w_init.shape}, b_init type: {type(b_init)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# 3 Model Prediction With Multiple Variables\n", + "The model's prediction with multiple variables is given by the linear model:\n", + "\n", + "$$ f_{\\mathbf{w},b}(\\mathbf{x}) = w_0x_0 + w_1x_1 +... + w_{n-1}x_{n-1} + b \\tag{1}$$\n", + "or in vector notation:\n", + "$$ f_{\\mathbf{w},b}(\\mathbf{x}) = \\mathbf{w} \\cdot \\mathbf{x} + b \\tag{2} $$ \n", + "where $\\cdot$ is a vector `dot product`\n", + "\n", + "To demonstrate the dot product, we will implement prediction using (1) and (2)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 3.1 Single Prediction element by element\n", + "Our previous prediction multiplied one feature value by one parameter and added a bias parameter. A direct extension of our previous implementation of prediction to multiple features would be to implement (1) above using loop over each element, performing the multiply with its parameter and then adding the bias parameter at the end.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def predict_single_loop(x, w, b): \n", + " \"\"\"\n", + " single predict using linear regression\n", + " \n", + " Args:\n", + " x (ndarray): Shape (n,) example with multiple features\n", + " w (ndarray): Shape (n,) model parameters \n", + " b (scalar): model parameter \n", + " \n", + " Returns:\n", + " p (scalar): prediction\n", + " \"\"\"\n", + " n = x.shape[0]\n", + " p = 0\n", + " for i in range(n):\n", + " p_i = x[i] * w[i] \n", + " p = p + p_i \n", + " p = p + b \n", + " return p" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x_vec shape (4,), x_vec value: [2104 5 1 45]\n", + "f_wb shape (), prediction: 459.9999976194083\n" + ] + } + ], + "source": [ + "# get a row from our training data\n", + "x_vec = X_train[0,:]\n", + "print(f\"x_vec shape {x_vec.shape}, x_vec value: {x_vec}\")\n", + "\n", + "# make a prediction\n", + "f_wb = predict_single_loop(x_vec, w_init, b_init)\n", + "print(f\"f_wb shape {f_wb.shape}, prediction: {f_wb}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note the shape of `x_vec`. It is a 1-D NumPy vector with 4 elements, (4,). The result, `f_wb` is a scalar." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 3.2 Single Prediction, vector\n", + "\n", + "Noting that equation (1) above can be implemented using the dot product as in (2) above. We can make use of vector operations to speed up predictions.\n", + "\n", + "Recall from the Python/Numpy lab that NumPy `np.dot()`[[link](https://numpy.org/doc/stable/reference/generated/numpy.dot.html)] can be used to perform a vector dot product. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def predict(x, w, b): \n", + " \"\"\"\n", + " single predict using linear regression\n", + " Args:\n", + " x (ndarray): Shape (n,) example with multiple features\n", + " w (ndarray): Shape (n,) model parameters \n", + " b (scalar): model parameter \n", + " \n", + " Returns:\n", + " p (scalar): prediction\n", + " \"\"\"\n", + " p = np.dot(x, w) + b \n", + " return p " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x_vec shape (4,), x_vec value: [2104 5 1 45]\n", + "f_wb shape (), prediction: 459.99999761940825\n" + ] + } + ], + "source": [ + "# get a row from our training data\n", + "x_vec = X_train[0,:]\n", + "print(f\"x_vec shape {x_vec.shape}, x_vec value: {x_vec}\")\n", + "\n", + "# make a prediction\n", + "f_wb = predict(x_vec,w_init, b_init)\n", + "print(f\"f_wb shape {f_wb.shape}, prediction: {f_wb}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The results and shapes are the same as the previous version which used looping. Going forward, `np.dot` will be used for these operations. The prediction is now a single statement. Most routines will implement it directly rather than calling a separate predict routine." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# 4 Compute Cost With Multiple Variables\n", + "The equation for the cost function with multiple variables $J(\\mathbf{w},b)$ is:\n", + "$$J(\\mathbf{w},b) = \\frac{1}{2m} \\sum\\limits_{i = 0}^{m-1} (f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) - y^{(i)})^2 \\tag{3}$$ \n", + "where:\n", + "$$ f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) = \\mathbf{w} \\cdot \\mathbf{x}^{(i)} + b \\tag{4} $$ \n", + "\n", + "\n", + "In contrast to previous labs, $\\mathbf{w}$ and $\\mathbf{x}^{(i)}$ are vectors rather than scalars supporting multiple features." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below is an implementation of equations (3) and (4). Note that this uses a *standard pattern for this course* where a for loop over all `m` examples is used." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_cost(X, y, w, b): \n", + " \"\"\"\n", + " compute cost\n", + " Args:\n", + " X (ndarray (m,n)): Data, m examples with n features\n", + " y (ndarray (m,)) : target values\n", + " w (ndarray (n,)) : model parameters \n", + " b (scalar) : model parameter\n", + " \n", + " Returns:\n", + " cost (scalar): cost\n", + " \"\"\"\n", + " m = X.shape[0]\n", + " cost = 0.0\n", + " for i in range(m): \n", + " f_wb_i = np.dot(X[i], w) + b #(n,)(n,) = scalar (see np.dot)\n", + " cost = cost + (f_wb_i - y[i])**2 #scalar\n", + " cost = cost / (2 * m) #scalar \n", + " return cost" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost at optimal w : 1.5578904880036537e-12\n" + ] + } + ], + "source": [ + "# Compute and display cost using our pre-chosen optimal parameters. \n", + "cost = compute_cost(X_train, y_train, w_init, b_init)\n", + "print(f'Cost at optimal w : {cost}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected Result**: Cost at optimal w : 1.5578904045996674e-12" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# 5 Gradient Descent With Multiple Variables\n", + "Gradient descent for multiple variables:\n", + "\n", + "$$\\begin{align*} \\text{repeat}&\\text{ until convergence:} \\; \\lbrace \\newline\\;\n", + "& w_j = w_j - \\alpha \\frac{\\partial J(\\mathbf{w},b)}{\\partial w_j} \\tag{5} \\; & \\text{for j = 0..n-1}\\newline\n", + "&b\\ \\ = b - \\alpha \\frac{\\partial J(\\mathbf{w},b)}{\\partial b} \\newline \\rbrace\n", + "\\end{align*}$$\n", + "\n", + "where, n is the number of features, parameters $w_j$, $b$, are updated simultaneously and where \n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\frac{\\partial J(\\mathbf{w},b)}{\\partial w_j} &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) - y^{(i)})x_{j}^{(i)} \\tag{6} \\\\\n", + "\\frac{\\partial J(\\mathbf{w},b)}{\\partial b} &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) - y^{(i)}) \\tag{7}\n", + "\\end{align}\n", + "$$\n", + "* m is the number of training examples in the data set\n", + "\n", + " \n", + "* $f_{\\mathbf{w},b}(\\mathbf{x}^{(i)})$ is the model's prediction, while $y^{(i)}$ is the target value\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 5.1 Compute Gradient with Multiple Variables\n", + "An implementation for calculating the equations (6) and (7) is below. There are many ways to implement this. In this version, there is an\n", + "- outer loop over all m examples. \n", + " - $\\frac{\\partial J(\\mathbf{w},b)}{\\partial b}$ for the example can be computed directly and accumulated\n", + " - in a second loop over all n features:\n", + " - $\\frac{\\partial J(\\mathbf{w},b)}{\\partial w_j}$ is computed for each $w_j$.\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def compute_gradient(X, y, w, b): \n", + " \"\"\"\n", + " Computes the gradient for linear regression \n", + " Args:\n", + " X (ndarray (m,n)): Data, m examples with n features\n", + " y (ndarray (m,)) : target values\n", + " w (ndarray (n,)) : model parameters \n", + " b (scalar) : model parameter\n", + " \n", + " Returns:\n", + " dj_dw (ndarray (n,)): The gradient of the cost w.r.t. the parameters w. \n", + " dj_db (scalar): The gradient of the cost w.r.t. the parameter b. \n", + " \"\"\"\n", + " m,n = X.shape #(number of examples, number of features)\n", + " dj_dw = np.zeros((n,))\n", + " dj_db = 0.\n", + "\n", + " for i in range(m): \n", + " err = (np.dot(X[i], w) + b) - y[i] \n", + " for j in range(n): \n", + " dj_dw[j] = dj_dw[j] + err * X[i, j] \n", + " dj_db = dj_db + err \n", + " dj_dw = dj_dw / m \n", + " dj_db = dj_db / m \n", + " \n", + " return dj_db, dj_dw" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dj_db at initial w,b: -1.673925169143331e-06\n", + "dj_dw at initial w,b: \n", + " [-2.73e-03 -6.27e-06 -2.22e-06 -6.92e-05]\n" + ] + } + ], + "source": [ + "#Compute and display gradient \n", + "tmp_dj_db, tmp_dj_dw = compute_gradient(X_train, y_train, w_init, b_init)\n", + "print(f'dj_db at initial w,b: {tmp_dj_db}')\n", + "print(f'dj_dw at initial w,b: \\n {tmp_dj_dw}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected Result**: \n", + "dj_db at initial w,b: -1.6739251122999121e-06 \n", + "dj_dw at initial w,b: \n", + " [-2.73e-03 -6.27e-06 -2.22e-06 -6.92e-05] " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 5.2 Gradient Descent With Multiple Variables\n", + "The routine below implements equation (5) above." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def gradient_descent(X, y, w_in, b_in, cost_function, gradient_function, alpha, num_iters): \n", + " \"\"\"\n", + " Performs batch gradient descent to learn w and b. Updates w and b by taking \n", + " num_iters gradient steps with learning rate alpha\n", + " \n", + " Args:\n", + " X (ndarray (m,n)) : Data, m examples with n features\n", + " y (ndarray (m,)) : target values\n", + " w_in (ndarray (n,)) : initial model parameters \n", + " b_in (scalar) : initial model parameter\n", + " cost_function : function to compute cost\n", + " gradient_function : function to compute the gradient\n", + " alpha (float) : Learning rate\n", + " num_iters (int) : number of iterations to run gradient descent\n", + " \n", + " Returns:\n", + " w (ndarray (n,)) : Updated values of parameters \n", + " b (scalar) : Updated value of parameter \n", + " \"\"\"\n", + " \n", + " # An array to store cost J and w's at each iteration primarily for graphing later\n", + " J_history = []\n", + " w = copy.deepcopy(w_in) #avoid modifying global w within function\n", + " b = b_in\n", + " \n", + " for i in range(num_iters):\n", + "\n", + " # Calculate the gradient and update the parameters\n", + " dj_db,dj_dw = gradient_function(X, y, w, b) ##None\n", + "\n", + " # Update Parameters using w, b, alpha and gradient\n", + " w = w - alpha * dj_dw ##None\n", + " b = b - alpha * dj_db ##None\n", + " \n", + " # Save cost J at each iteration\n", + " if i<100000: # prevent resource exhaustion \n", + " J_history.append( cost_function(X, y, w, b))\n", + "\n", + " # Print cost every at intervals 10 times or as many iterations if < 10\n", + " if i% math.ceil(num_iters / 10) == 0:\n", + " print(f\"Iteration {i:4d}: Cost {J_history[-1]:8.2f} \")\n", + " \n", + " return w, b, J_history #return final w,b and J history for graphing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the next cell you will test the implementation. " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 0: Cost 2529.46 \n", + "Iteration 100: Cost 695.99 \n", + "Iteration 200: Cost 694.92 \n", + "Iteration 300: Cost 693.86 \n", + "Iteration 400: Cost 692.81 \n", + "Iteration 500: Cost 691.77 \n", + "Iteration 600: Cost 690.73 \n", + "Iteration 700: Cost 689.71 \n", + "Iteration 800: Cost 688.70 \n", + "Iteration 900: Cost 687.69 \n", + "b,w found by gradient descent: -0.00,[ 0.2 0. -0.01 -0.07] \n", + "prediction: 426.19, target value: 460\n", + "prediction: 286.17, target value: 232\n", + "prediction: 171.47, target value: 178\n" + ] + } + ], + "source": [ + "# initialize parameters\n", + "initial_w = np.zeros_like(w_init)\n", + "initial_b = 0.\n", + "# some gradient descent settings\n", + "iterations = 1000\n", + "alpha = 5.0e-7\n", + "# run gradient descent \n", + "w_final, b_final, J_hist = gradient_descent(X_train, y_train, initial_w, initial_b,\n", + " compute_cost, compute_gradient, \n", + " alpha, iterations)\n", + "print(f\"b,w found by gradient descent: {b_final:0.2f},{w_final} \")\n", + "m,_ = X_train.shape\n", + "for i in range(m):\n", + " print(f\"prediction: {np.dot(X_train[i], w_final) + b_final:0.2f}, target value: {y_train[i]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Expected Result**: \n", + "b,w found by gradient descent: -0.00,[ 0.2 0. -0.01 -0.07] \n", + "prediction: 426.19, target value: 460 \n", + "prediction: 286.17, target value: 232 \n", + "prediction: 171.47, target value: 178 " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot cost versus iteration \n", + "fig, (ax1, ax2) = plt.subplots(1, 2, constrained_layout=True, figsize=(12, 4))\n", + "ax1.plot(J_hist)\n", + "ax2.plot(100 + np.arange(len(J_hist[100:])), J_hist[100:])\n", + "ax1.set_title(\"Cost vs. iteration\"); ax2.set_title(\"Cost vs. iteration (tail)\")\n", + "ax1.set_ylabel('Cost') ; ax2.set_ylabel('Cost') \n", + "ax1.set_xlabel('iteration step') ; ax2.set_xlabel('iteration step') \n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*These results are not inspiring*! Cost is still declining and our predictions are not very accurate. The next lab will explore how to improve on this." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "# 6 Congratulations!\n", + "In this lab you:\n", + "- Redeveloped the routines for linear regression, now with multiple variables.\n", + "- Utilized NumPy `np.dot` to vectorize the implementations" + ] + } + ], + "metadata": { + "dl_toc_settings": { + "rndtag": "15456" + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + }, + "toc-autonumbering": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/week2/C1_W2_Lab03_Feature_Scaling_and_Learning_Rate_Soln.ipynb b/week2/C1_W2_Lab03_Feature_Scaling_and_Learning_Rate_Soln.ipynb new file mode 100644 index 0000000..473c018 --- /dev/null +++ b/week2/C1_W2_Lab03_Feature_Scaling_and_Learning_Rate_Soln.ipynb @@ -0,0 +1,864 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Optional Lab: Feature scaling and Learning Rate (Multi-variable)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Goals\n", + "In this lab you will:\n", + "- Utilize the multiple variables routines developed in the previous lab\n", + "- run Gradient Descent on a data set with multiple features\n", + "- explore the impact of the *learning rate alpha* on gradient descent\n", + "- improve performance of gradient descent by *feature scaling* using z-score normalization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tools\n", + "You will utilize the functions developed in the last lab as well as matplotlib and NumPy. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from lab_utils_multi import load_house_data, run_gradient_descent \n", + "from lab_utils_multi import norm_plot, plt_equal_scale, plot_cost_i_w\n", + "from lab_utils_common import dlc\n", + "np.set_printoptions(precision=2)\n", + "plt.style.use('./deeplearning.mplstyle')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Notation\n", + "\n", + "|General
Notation | Description| Python (if applicable) |\n", + "|: ------------|: ------------------------------------------------------------||\n", + "| $a$ | scalar, non bold ||\n", + "| $\\mathbf{a}$ | vector, bold ||\n", + "| $\\mathbf{A}$ | matrix, bold capital ||\n", + "| **Regression** | | | |\n", + "| $\\mathbf{X}$ | training example maxtrix | `X_train` | \n", + "| $\\mathbf{y}$ | training example targets | `y_train` \n", + "| $\\mathbf{x}^{(i)}$, $y^{(i)}$ | $i_{th}$Training Example | `X[i]`, `y[i]`|\n", + "| m | number of training examples | `m`|\n", + "| n | number of features in each example | `n`|\n", + "| $\\mathbf{w}$ | parameter: weight, | `w` |\n", + "| $b$ | parameter: bias | `b` | \n", + "| $f_{\\mathbf{w},b}(\\mathbf{x}^{(i)})$ | The result of the model evaluation at $\\mathbf{x}^{(i)}$ parameterized by $\\mathbf{w},b$: $f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) = \\mathbf{w} \\cdot \\mathbf{x}^{(i)}+b$ | `f_wb` | \n", + "|$\\frac{\\partial J(\\mathbf{w},b)}{\\partial w_j}$| the gradient or partial derivative of cost with respect to a parameter $w_j$ |`dj_dw[j]`| \n", + "|$\\frac{\\partial J(\\mathbf{w},b)}{\\partial b}$| the gradient or partial derivative of cost with respect to a parameter $b$| `dj_db`|" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Problem Statement\n", + "\n", + "As in the previous labs, you will use the motivating example of housing price prediction. The training data set contains many examples with 4 features (size, bedrooms, floors and age) shown in the table below. Note, in this lab, the Size feature is in sqft while earlier labs utilized 1000 sqft. This data set is larger than the previous lab.\n", + "\n", + "We would like to build a linear regression model using these values so we can then predict the price for other houses - say, a house with 1200 sqft, 3 bedrooms, 1 floor, 40 years old. \n", + "\n", + "## Dataset: \n", + "| Size (sqft) | Number of Bedrooms | Number of floors | Age of Home | Price (1000s dollars) | \n", + "| ----------------| ------------------- |----------------- |--------------|----------------------- | \n", + "| 952 | 2 | 1 | 65 | 271.5 | \n", + "| 1244 | 3 | 2 | 64 | 232 | \n", + "| 1947 | 3 | 2 | 17 | 509.8 | \n", + "| ... | ... | ... | ... | ... |\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# load the dataset\n", + "X_train, y_train = load_house_data()\n", + "X_features = ['size(sqft)','bedrooms','floors','age']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's view the dataset and its features by plotting each feature versus price." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig,ax=plt.subplots(1, 4, figsize=(12, 3), sharey=True)\n", + "for i in range(len(ax)):\n", + " ax[i].scatter(X_train[:,i],y_train)\n", + " ax[i].set_xlabel(X_features[i])\n", + "ax[0].set_ylabel(\"Price (1000's)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plotting each feature vs. the target, price, provides some indication of which features have the strongest influence on price. Above, increasing size also increases price. Bedrooms and floors don't seem to have a strong impact on price. Newer houses have higher prices than older houses." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Gradient Descent With Multiple Variables\n", + "Here are the equations you developed in the last lab on gradient descent for multiple variables.:\n", + "\n", + "$$\\begin{align*} \\text{repeat}&\\text{ until convergence:} \\; \\lbrace \\newline\\;\n", + "& w_j := w_j - \\alpha \\frac{\\partial J(\\mathbf{w},b)}{\\partial w_j} \\tag{1} \\; & \\text{for j = 0..n-1}\\newline\n", + "&b\\ \\ := b - \\alpha \\frac{\\partial J(\\mathbf{w},b)}{\\partial b} \\newline \\rbrace\n", + "\\end{align*}$$\n", + "\n", + "where, n is the number of features, parameters $w_j$, $b$, are updated simultaneously and where \n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\frac{\\partial J(\\mathbf{w},b)}{\\partial w_j} &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) - y^{(i)})x_{j}^{(i)} \\tag{2} \\\\\n", + "\\frac{\\partial J(\\mathbf{w},b)}{\\partial b} &= \\frac{1}{m} \\sum\\limits_{i = 0}^{m-1} (f_{\\mathbf{w},b}(\\mathbf{x}^{(i)}) - y^{(i)}) \\tag{3}\n", + "\\end{align}\n", + "$$\n", + "* m is the number of training examples in the data set\n", + "\n", + " \n", + "* $f_{\\mathbf{w},b}(\\mathbf{x}^{(i)})$ is the model's prediction, while $y^{(i)}$ is the target value\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Learning Rate\n", + "
\n", + " \n", + "
\n", + "The lectures discussed some of the issues related to setting the learning rate $\\alpha$. The learning rate controls the size of the update to the parameters. See equation (1) above. It is shared by all the parameters. \n", + "\n", + "Let's run gradient descent and try a few settings of $\\alpha$ on our data set" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### $\\alpha$ = 9.9e-7" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration Cost w0 w1 w2 w3 b djdw0 djdw1 djdw2 djdw3 djdb \n", + "---------------------|--------|--------|--------|--------|--------|--------|--------|--------|--------|--------|\n", + " 0 9.55884e+04 5.5e-01 1.0e-03 5.1e-04 1.2e-02 3.6e-04 -5.5e+05 -1.0e+03 -5.2e+02 -1.2e+04 -3.6e+02\n", + " 1 1.28213e+05 -8.8e-02 -1.7e-04 -1.0e-04 -3.4e-03 -4.8e-05 6.4e+05 1.2e+03 6.2e+02 1.6e+04 4.1e+02\n", + " 2 1.72159e+05 6.5e-01 1.2e-03 5.9e-04 1.3e-02 4.3e-04 -7.4e+05 -1.4e+03 -7.0e+02 -1.7e+04 -4.9e+02\n", + " 3 2.31358e+05 -2.1e-01 -4.0e-04 -2.3e-04 -7.5e-03 -1.2e-04 8.6e+05 1.6e+03 8.3e+02 2.1e+04 5.6e+02\n", + " 4 3.11100e+05 7.9e-01 1.4e-03 7.1e-04 1.5e-02 5.3e-04 -1.0e+06 -1.8e+03 -9.5e+02 -2.3e+04 -6.6e+02\n", + " 5 4.18517e+05 -3.7e-01 -7.1e-04 -4.0e-04 -1.3e-02 -2.1e-04 1.2e+06 2.1e+03 1.1e+03 2.8e+04 7.5e+02\n", + " 6 5.63212e+05 9.7e-01 1.7e-03 8.7e-04 1.8e-02 6.6e-04 -1.3e+06 -2.5e+03 -1.3e+03 -3.1e+04 -8.8e+02\n", + " 7 7.58122e+05 -5.8e-01 -1.1e-03 -6.2e-04 -1.9e-02 -3.4e-04 1.6e+06 2.9e+03 1.5e+03 3.8e+04 1.0e+03\n", + " 8 1.02068e+06 1.2e+00 2.2e-03 1.1e-03 2.3e-02 8.3e-04 -1.8e+06 -3.3e+03 -1.7e+03 -4.2e+04 -1.2e+03\n", + " 9 1.37435e+06 -8.7e-01 -1.7e-03 -9.1e-04 -2.7e-02 -5.2e-04 2.1e+06 3.9e+03 2.0e+03 5.1e+04 1.4e+03\n", + "w,b found by gradient descent: w: [-0.87 -0. -0. -0.03], b: -0.00\n" + ] + } + ], + "source": [ + "#set alpha to 9.9e-7\n", + "_, _, hist = run_gradient_descent(X_train, y_train, 10, alpha = 9.9e-7)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It appears the learning rate is too high. The solution does not converge. Cost is *increasing* rather than decreasing. Let's plot the result:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_cost_i_w(X_train, y_train, hist)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The plot on the right shows the value of one of the parameters, $w_0$. At each iteration, it is overshooting the optimal value and as a result, cost ends up *increasing* rather than approaching the minimum. Note that this is not a completely accurate picture as there are 4 parameters being modified each pass rather than just one. This plot is only showing $w_0$ with the other parameters fixed at benign values. In this and later plots you may notice the blue and orange lines being slightly off." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### $\\alpha$ = 9e-7\n", + "Let's try a bit smaller value and see what happens." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration Cost w0 w1 w2 w3 b djdw0 djdw1 djdw2 djdw3 djdb \n", + "---------------------|--------|--------|--------|--------|--------|--------|--------|--------|--------|--------|\n", + " 0 6.64616e+04 5.0e-01 9.1e-04 4.7e-04 1.1e-02 3.3e-04 -5.5e+05 -1.0e+03 -5.2e+02 -1.2e+04 -3.6e+02\n", + " 1 6.18990e+04 1.8e-02 2.1e-05 2.0e-06 -7.9e-04 1.9e-05 5.3e+05 9.8e+02 5.2e+02 1.3e+04 3.4e+02\n", + " 2 5.76572e+04 4.8e-01 8.6e-04 4.4e-04 9.5e-03 3.2e-04 -5.1e+05 -9.3e+02 -4.8e+02 -1.1e+04 -3.4e+02\n", + " 3 5.37137e+04 3.4e-02 3.9e-05 2.8e-06 -1.6e-03 3.8e-05 4.9e+05 9.1e+02 4.8e+02 1.2e+04 3.2e+02\n", + " 4 5.00474e+04 4.6e-01 8.2e-04 4.1e-04 8.0e-03 3.2e-04 -4.8e+05 -8.7e+02 -4.5e+02 -1.1e+04 -3.1e+02\n", + " 5 4.66388e+04 5.0e-02 5.6e-05 2.5e-06 -2.4e-03 5.6e-05 4.6e+05 8.5e+02 4.5e+02 1.2e+04 2.9e+02\n", + " 6 4.34700e+04 4.5e-01 7.8e-04 3.8e-04 6.4e-03 3.2e-04 -4.4e+05 -8.1e+02 -4.2e+02 -9.8e+03 -2.9e+02\n", + " 7 4.05239e+04 6.4e-02 7.0e-05 1.2e-06 -3.3e-03 7.3e-05 4.3e+05 7.9e+02 4.2e+02 1.1e+04 2.7e+02\n", + " 8 3.77849e+04 4.4e-01 7.5e-04 3.5e-04 4.9e-03 3.2e-04 -4.1e+05 -7.5e+02 -3.9e+02 -9.1e+03 -2.7e+02\n", + " 9 3.52385e+04 7.7e-02 8.3e-05 -1.1e-06 -4.2e-03 8.9e-05 4.0e+05 7.4e+02 3.9e+02 1.0e+04 2.5e+02\n", + "w,b found by gradient descent: w: [ 7.74e-02 8.27e-05 -1.06e-06 -4.20e-03], b: 0.00\n" + ] + } + ], + "source": [ + "#set alpha to 9e-7\n", + "_,_,hist = run_gradient_descent(X_train, y_train, 10, alpha = 9e-7)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cost is decreasing throughout the run showing that alpha is not too large. " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAuwAAADnCAYAAABFeAMWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdeVxUVf/A8c+w74gs7mJiiiLigrsG9KhphrmlGaaUJWbb8/jkWu5LZWlZZm6l/UzE0jQ1tdRcMykXMHFDCcw1AZUlQZb7++M+jDPMoIjADPB9v16+cs659853JjlzOHPu96tRFEVBCCGEEEIIYZYsTB2AEEIIIYQQomgyYRdCCCGEEMKMyYRdCCGEEEIIMyYTdiGEEEIIIcyYTNiFEEIIIYQwYzJhF0IIIYQQwozJhF0IcU/h4eE0aNDA1GEIIUSVERwcjEajQaPR0KFDhxJfp0uXLtrr1K1btxQjFOVNJuyizNy8eZPp06fTqlUrXFxcsLOzo1GjRrz88sscO3aszJ73yy+/5OOPPy6z65dEeHg4Go2G3Nxcbdt3333HtGnTTBeUjqNHjzJt2jQSExNNHYoQooKTsb90+Pr6smrVKqZPn27QFxMTQ48ePXB2dqZatWr079+fhIQEg+OmTJnCqlWr8PX1LY+QRRnSSOEkURbi4uLo1asXV65c4ZlnnqFTp07Y2dkRHx/Pt99+S2JiIhcuXCiT3/i7dOnCxYsXzWryGR4ezldffUVOTg5WVlYADB06lNWrV2MOP4LLly/n5ZdfZvfu3QQHB+v15eTkkJ+fj62trWmCE0JUGDL2l46CcXjPnj0GfadPn6Zdu3Z4eXnxxhtvkJWVxUcffYRGo+HYsWPUqFHD6PXOnTvHxYsXyzhyUVasTB2AqHwyMjLo06cPmZmZREdH07p1a73+2bNn88EHH5jFRLUyysvLIy8vDxsbm1K5nrW1dalcRwhRucnYXz4mTpyIoijs3buXOnXqANCrVy9atmzJnDlzWLBggYkjFGVBtsSIUrd06VISEhL48MMPDQZsACsrKyZOnEi9evW0bZcuXSI8PJwaNWpga2tLs2bN+OijjwwG9piYGEJDQ6lRowZ2dnbUr1+fgQMHcuHCBQAaNGjAL7/8QlJSknbfnkajKTLWBQsWoNFoOHz4sEHfvn370Gg0LF26FFAnwu+++y6+vr44ODhQvXp12rRpw2efffbA71FwcDCrV68G0ItTd2Vo79699OjRA1dXV+zt7enQoQNbtmzRu86ePXvQaDQsW7aMDz/8EB8fH2xtbTl48CAA8+fPJygoCC8vL2xtbWnUqBFTp04lJydHe41p06bx8ssvAxASEqKNZeXKlUDRe9hXrVpF69atsbe3p3r16gwYMIDTp08bjW/58uUsXryYRo0aYWtrS8uWLdm9e/cDv29CCPMlY7++8ePHY21tTUZGhrbt66+/RqPR0KtXL71jn332Wb33pSgZGRls3bqVgQMHaifrAP7+/oSEhBAVFXXfa4iKSVbYRanbsGEDtra2PPfcc8U6PiUlhU6dOnH16lVeffVVGjZsyJYtWxgzZgznz59n4cKFAFy/fp1u3bpRrVo1xowZg4eHB5cvX+ann37i4sWL1K9fn48//pjx48eTmprKRx99dN/nfvbZZ/nvf//L6tWrCQwM1OuLjIzExsaGgQMHAjBjxgxmzJhBeHg4Y8aMISsri5MnT7J//35effXVB3qP3n77bXJycjh48CCrVq3Stnt6egKwfv16Bg8eTMeOHZk6dSpWVlasWbOGPn36sGbNGgYPHqx3vQULFpCbm8vIkSNxcHCgVq1aAHzwwQc88cQT9OnTBwcHBw4cOMCsWbO4cOECK1asAKB///5cvHiRL774gkmTJtG0aVMAOnXqVGT8H374IWPHjqVdu3a8++67pKam8umnn9KxY0d+//13GjVqpHf8kiVLSE9P5+WXX8ba2pqPP/6Yp59+mqSkJNzc3B7ovRNCmCcZ+/UFBwczd+5cfvnlF5544glAXYixsLDgwIED5ObmardI7tu3j8cff/y+cR8/fpw7d+7Qvn17g74OHTqwa9cuLl68KDeYVkaKEKWsevXqSosWLYp9/NixYxVAWbdunbYtPz9f6devnwIox48fVxRFUTZu3KgAym+//XbP63Xu3Fnx9vYu9vP36NFDqVWrlpKXl6dtu3PnjuLu7q48/fTT2raWLVsqTz75ZLGvq2v48OEKoOTk5GjbwsLCFGM/gpmZmYq7u7syYMAAvfbc3FwlMDBQqVevnpKfn68oiqLs3r1bARQvLy/l5s2bBtfKyMgwaJs2bZpiYWGhXLx4Udu2bNkyBVB2795tNHbd9zM5OVmxs7NT2rRpo2RlZWnbjxw5olhYWOjFXRBf3bp1lfT0dL1jAeWzzz4zeD4hRMUkY7++tLQ0xdLSUpk4caK27dFHH1WeffZZBVB+/fVXRVEU5cyZMwqgLF26VHtcUFCQEhQUZHDNb7/9VgGUTZs2GfR99tlnCqAcOnTIoC8oKEipU6fOA78GYT5kS4wodWlpabi4uBT7+E2bNtGoUSMGDBigbdNoNIwdOxaAzZs3A+Dq6qp9fOfOnVKLNywsjCtXruht0fjxxx9JSUkhLCxM2+bq6kpcXBynTp0qtec2ZufOnaSkpDB06FCSk5O1f27cuEGvXr3466+/OHv2rMFrKHh/dDk6OgLqV7o3b94kOTmZkJAQ8vPzOXr0aIni27FjB1lZWfz73//WuxG1devWdOvWja1bt+plwwF4/vnncXJy0jvWxcWF8+fPlygGIYT5kbFfn7OzM61bt9beOHrlyhXi4+N56aWXqFOnjrZ97969AAQFBd33mrdv3wYwmgTAzs5O7xhRuciEXZQ6FxcX0tLSin18YmKi0ZRTzZo1A+DPP/8E1MFs0KBBzJw5E3d3d5588kk++eQTkpOTHyrefv36YW9vT2RkpLYtMjISZ2dnnnrqKW3bzJkzSU9Pp1mzZjRr1ozXXnutTPZhF+wD79evH56ennp/Zs6cCcDff/+td84jjzxi9Frbt2+nU6dO2Nvb4+bmhqenp/ZD4caNGyWKr2CffcHWGV3NmjXj9u3bXLt2Ta/d29vb4Fg3NzdSU1NLFIMQwvzI2G8oODiYw4cPk5mZyd69e7G2tqZjx44EBQXpTdhr1apF48aN73s9e3t7ALKzsw36srKy9I4RlYtM2EWpa9asGWfOnNEOHsVxr5uDCvo0Gg1r167l8OHDjBs3jszMTMaMGYOvry8xMTEljtfZ2ZnQ0FC+++47srOzyczMZNOmTfTv319v4OvatSsJCQmsXr2aDh06sGHDBh5//HFGjBhR4uc2Jj8/H4DPP/+cHTt2GP3TvHlzvXOMDdCHDh2id+/eAHz66ads2bKFHTt2aG8mLXiekjL2/0z5341ihfssLS2NXkORbBFCVBoy9hsKCgrS3q+0d+9e2rVrh4ODA8HBwfzyyy/k5uayd+/eYq2uA9SuXRuAy5cvG/QVtBUcIyoXmbCLUte3b1+ys7P1Vi3upUGDBka/aixoK5yhpE2bNkyePJm9e/dy9OhRbt26xdy5c7X99/oAKEpYWBg3b95k69atfP/992RmZup9JVrA1dWV5557ji+//JKkpCTt3wtvUSmOouIsuGGzevXqdOvWzeif4tyouXbtWmxsbNi1axcRERH07t2bbt26UbNmzWLHYkzB/4+TJ08a9J0+fRp7e3u8vLyKfT0hROUgY7+hrl27YmlpyZ49e/Qm5kFBQWRkZPDNN99w8eLFYk/Y/f39sba2Jjo62qAvOjoaLy8vueG0kpIJuyh1I0eOpEGDBowdO9ZoVbvc3Fzef/99bQGH0NBQzp07x4YNG7THKIrChx9+qO0HdQtH4RXZpk2bYm9vr7e1wsnJiZs3bz5QzL169aJ69epERkYSGRlJzZo1De7YT0lJ0XtsZWWFv78/QIm2dhTs6S68NeWJJ57Azc2NOXPmGN2LWHg7TFEsLS3RaDTk5eVp2/Ly8vjggw+KHYsx3bt3x87Ojk8++URvP2lsbCw7duygV69e2swHQoiqQ8Z+Qy4uLrRq1Yr169dz6tQp7cS8cePG1KpVS7vNsbgTdmdnZ5588knWrVvHlStXtO0nTpxg9+7dDBo0qES/uAjzJ5+qotQ5OzuzadMmevXqRfv27fWq3Z07d45169aRkJDA0KFDAZgwYQLffPMNQ4YM0ab2+uGHH9i2bRuvvvqqdmD86quv+PTTT+nXrx+NGjUiNzeXqKgo0tPT9VZE2rZty/bt23nzzTdp3749FhYWPPvss/eM2drammeeeYavvvqKvLw8Xn31VYNtHE2bNqVLly60bduWGjVqcObMGRYuXEiTJk1o06bNA79Pbdu2ZfHixbz22mvaSW5oaCjOzs4sX76cwYMH4+fnx/PPP0+9evW4cuUKhw4d4vTp08W6WfPpp59m/vz5PP744wwfPpzbt2+zdu1ao1thAgMD0Wg0vPvuu9y8eRN7e3vat29vdG+8u7s7M2bMYNy4cTz22GMMGTJEm9bRxcWF995774HfCyFExSdjv3FBQUHMmzcPKysrOnfurNceFRWFl5eX0XuCijJnzhzat2/PY489xuuvv052djYfffQRnp6eTJo0qdjXERWMKVPUiMotNTVVmTJlihIQEKA4OjoqNjY2io+PjzJy5EglNjZW79iLFy8qw4YNUzw8PBQbGxvF19dXmTdvnjZ9oaIoytGjR5WwsDClQYMGip2dnVK9enWlS5cuynfffad3rVu3bilDhgxR3NzcFI1GYzR1ojH79u1TgCLTh82ZM0fp2LGj4u7urtja2ioNGzZUXn/9deXq1av3vbaxtI537txRRo8erXh5eWnj/PPPP7X90dHRSt++fRV3d3fFxsZGqVevnhIaGqqsWbNGe0xB2sRly5YZfd6oqCjF399fsbOzU2rXrq28+eabyokTJxRAWbFihd6xixYtUho2bKhYWlrq9RdO61jgq6++Ulq2bKnY2toq1apVU/r166ecOnVK75h7xeft7a0MHz783m+cEKLCkbFf3+bNmxVA6dChg177559/rgDKwIEDDc4pKq1jgSNHjijdunVTHB0dFRcXF6Vv375KfHx8kcdLWseKT6MocteXEEIIIYS5CA4OJicnh++//x5ra2ujaXuL49atW+Tk5GgL1RVsRxIVj+xhF0IIIYQwMwcPHsTT01NbJbUkevfujaenJwcPHizFyIQpyAq7EEIIIYQZOXLkiDYJgKurK23bti3RdQ4fPqy9EdfOzo4uXbqUWoyifMmEXQghhBBCCDMmWWL+59atW6YOQQghHlpJ97pWNDJmCyEqg+KO2bKHXQghhBBCCDMmE3YhhBBCCCHMmGyJMaKqfKUshKgcqvr2EBmzhRAVSUnGbFlhF0IIIYQQwozJhF0IIYQQQggzJhP2UiCJMYUQQgghRFmRCXspmBgNb0fDnTxTRyKEEEIIIcrarWzILsd5n0zYH9LPF2HuMZhzFDptgDM3TB2REEIIIYQoS2//Bo9GwqITkJVb9s8nE/aHcCMbhv0MBTtijlyHVutgcZxskxFCCCGEqIwuZcCyk/BXBry6HxpFwsnUsn1OmbA/hD/TIL/QxPx2LryyD/psg7//MU1cQgghhBCibLwfA3fy7z621ECjMs4uKxP2h9DaE/4YDP0fMezbkgT+38CWxHIPSwghxH38k2PqCIQQFdGVTFh6Ur9tUmuwsSzb55UJ+0Nyt4N1T8CXIeBkrd/3920I3Qaj98mHgxBCmIO/MtQxuf7XkHzb1NEIISqauTH6N5vWc4Jw37J/XpmwlwKNBl7whZhnoGMNw/7P46D1OnWPuxBCCNOY8hs0Wq2OySlZMD/W1BEJISqSq/+o9ynqmtAKbMt4dR1kwl6qfFxhX1+Y3lbdz6TrzE3o8B28exTy8o2fL4QQouy42ujvO/30hKyyCyGK78MYyNJZXa/jCCOals9zy4S9lFlZwJRAONAXfFz0+3LzYVI0hGyCxDTTxCeEEFXVKD/wsr/7OCMH5skquxCiGP7+BxaZaHUdZMJeZjrUhJhBMMLIvqb9VyDgW/j6rKR/FEKI8uJoDeNb6bd9+gdcl1V2IcR9zItVMwEWqOUAL5XT6jrIhL1MOVnD8hD47gn15lRdaXfg+V3w3E41n7sQQoiyN6oZ1NBZZc/MlVV2IcS9Jd+Gz07ot41vBXZW5ReDTNjLQb+G8McgeKKeYV/UOQj4BvZcKv+4hBBVW3Z2NiNGjMDb2xtnZ2datWrFtm3bAEhMTESj0eDk5KT9M3PmTO25iqIwfvx43N3dcXd3Z9y4cSg6XxkmJiYSEhKCg4MDvr6+7Ny5U++5IyMj8fb2xtHRkb59+5KaerfqSHZ2Ni+++CIuLi7UrFmT+fPnl9prdjCyyr5QVtmFEPcwL1b95b5ADXsY2ax8Y5AJezmp5Qhbe8MnXQz3O/2VAY9vgnG/6qcKEkKIspSbm0u9evXYu3cvt27dYubMmQwaNIjExETtMTdv3iQjI4OMjAwmT56sbV+6dCkbN24kNjaW48ePs2XLFpYsWaLtHzJkCK1atSIlJYXZs2czcOBArl9XU2XFxcURERHBqlWruHbtGg4ODowePVp77rRp04iPjycpKYndu3czd+5ctm/fXmqvO8LIKvuHMaV2eSFEJZKSBQsLra6PawX25bi6DqBRFNlFDXDr1i3t311dy7ZcVVwqhO2E2BTDvpYesPpf0Kx6mYYghKhESnP8atGiBVOnTqVNmzY88sgj5OTkYGVl+MnUqVMnwsPDGTlyJABffPEFy5Yt49ChQ5w9exZ/f3+Sk5NxdnYGoGvXroSFhTFq1CgmTZpEYmIikZGRAJw/f56mTZuSkpKCs7MzderUYcWKFfTo0QOAyZMnEx8fT1RUVKm95o9j4T8H7z52sII/w8DL4YEvJYSoxN6JhtlH7z72slfHCgfros+5n5KMX7LCbgJ+1SF6AIxtCYWyPxKTDG3WqTdCya9SQojydO3aNc6ePYufn5+2zdvbm7p16/LCCy+QnJysbY+LiyMgIED7OCAggLi4OG1fw4YNtZN1Y/265/r4+GBjY8PZs2e5ceMGly9fLvLapSXCD2rqTM7/yYUPZS+7EEJHahZ88od+29iWDzdZLymZsJuIrSXM7Qi7+kBdR/2+rDx44wA8+YNaAlcIIcpaTk4OYWFhDB8+HF9fXzw8PPj9999JSkriyJEjpKenExYWpj0+IyNDb2XI1dWVjIwMFEUx6CvoT09PN3qubn9GRob2sbFzS4u9lZqSTddnJ9TUbUIIAbDgOKTrVKr3sINX/Io+vizJhN3EQurA8cEwuJFh3/a/oMU3sPHP8o9LCFF15Ofn8/zzz2NjY8PChQsBcHJyIjAwECsrK2rUqMHChQv56aefSEtL0/YX/B0gLS0NJycn7Y2qun0F/QUr7vfqd3Jy0j42dm5pGtlMTc1W4J9c+ED2sgshgJvZsKDQ6vpbLdX0sKYgE3Yz4GYLa7rBqn+Bi41+X3IW9NsOL+9Ri3wIIURpUhSFESNGcO3aNdavX4+1tfFPI41Goz0ewM/Pj9jYu3tIYmNjtVtp/Pz8SEhI0FsVL9yve25CQgLZ2dk0btwYNzc3atWqVeS1S5PRVfY4uCar7EJUeQuOw607dx+728GrzU0Xj0zYzYRGA0MbQ+wz0LWWYf/yU9DqW4i+Vv6xCSEqr1deeYVTp06xefNm7O3vpk6Jjo7mzJkz5Ofnk5KSwhtvvEFwcLB2q8qwYcOYP38+ly5d4vLly8ybN4/w8HAAGjduTMuWLZk+fTpZWVls2LCB48ePM2DAAADCwsLYvHkz+/fvJzMzkylTptC/f3/tKvqwYcOYNWsWN27c4PTp0yxbtkx77dJWeJX9tqyyC1Hl3cqGj4/rt41podbXMRWZsJuZBi6wuw/MaQ9Whf7vnLsFnTfAjMOQm2+a+IQQlUdSUhJLliwhJiaGmjVravOtr169moSEBHr27ImzszPNmzfH1taWNWvWaM+NiIggNDQUf39/mjdvTu/evYmIiND2R0VFcfjwYdzc3JgwYQLr1q3D09MTUFfYFy9eTFhYGF5eXqSnp7No0SLtudOnT8fHxwdvb2+CgoIYO3YsPXv2LJP3wM4KJrbWb1sUB1dllV2IKuvTE3BTZ3XdzRZe8zddPCBpHbXKM61jcR3+W03/ePaWYV/HGvB1N2joUv5xCSHMizmOX2WtNF9zVi74RMJlnZv8xwTAvE4PdVkhRAWUfge8v9avQj+zHbzTpvSeQ9I6VjKBXnD0GeN3JP96Ta2Q+uUpSf8ohBAPw84KJhbay/65rLILUSUtPKE/Wa9mA6+bcO96AZmwmzlHa1j0GGzuBZ52+n0ZOTBiD/T6AS6UbsYzIYSoUl5qCnV0UuzezoW5x0wXjxCi/GXkwLxC9Rj+3QJcbU0Tjy6ZsFcQTzWAPwZDb2/Dvh//Ar+18PkJyJfVdiGEeGDG9rJ/Hie1MISoShadgJSsu49dbODNFqaLR5dM2CuQGg7qSvvnj6npyHRl5MDo/fD4JvXmVCGEEA+m8Cp7Vh7MlYwxQlQJmTnwYaGf9zf9oZoZrK6DTNgrHI0GRvnB8UEQVNuwf+9ltdjS/FjIk0wyQghRbLaWMKnQKvtiWWUXokr4PA6u66yuO1ur22HMhUzYK6hGrvBzH1jU1TAv6O1c+O9BNQXkyVTTxCeEEBXRiKZQt9Aq+/uyl12ISu2fHMP6C2/4Q3U748ebgkzYKzALDbzSHE4MhifqGfZH/60WW5pzBHLyyj8+IYSoaIyusp/UT/kohKhclpyEv2/ffexkDf8JMF08xsiEvRLwdoZtvWFFiJp+SNedfHj7N2j3HcQkmyY+IYSoSF5sCvWc7j7OzoP3ZJVdiErpdq7hvSqvNQd3M1pdBxNM2KOiomjatCmOjo74+Piwf/9+AHbt2oWvry8ODg6EhISQlJSkPUdRFMaPH4+7uzvu7u6MGzcO3XpPiYmJhISE4ODggK+vLzt37tR7zsjISLy9vXF0dKRv376kpla+fSIaDYT7wsln4ekGhv0xydB2PbwTrX74CCGEMM7YKvvSk3ApwzTxCCHKzrKT+jUXHK3gv2a2ug7lPGHfsWMH48ePZ8WKFaSnp7Nv3z4aNmxIcnIy/fv3Z+bMmaSmphIYGMjgwYO15y1dupSNGzcSGxvL8ePH2bJlC0uWLNH2DxkyhFatWpGSksLs2bMZOHAg169fByAuLo6IiAhWrVrFtWvXcHBwYPTo0eX5sstVLUfY0BOiuoNHod8Oc/Nh9lFo/S1EXzNNfEIIURG86Av1ZZVdiEotIwfeLfRzPbo5eNibJp570ShK+dXJ7NSpEyNGjGDEiBF67UuXLmXlypUcPHgQgMzMTDw8PDh27Bi+vr506tSJ8PBwRo4cCcAXX3zBsmXLOHToEGfPnsXf35/k5GScnZ0B6Nq1K2FhYYwaNYpJkyaRmJhIZGQkAOfPn6dp06akpKRoj4fKWdr7+m148wCsOWfYZ6FR736e2RYcrA37hRAVR2Ucv+6nPF7z0pMQsffuYxsLSAiDOk5FnyOEqDim/gYzjtx9bG8FiWHg5VC2z1uS8avcVtjz8vI4fPgw169fp1GjRtStW5fXXnuN27dvExcXR0DA3e8fCrbLxMXFARj0BwQE6PU1bNhQb/JduF/3XB8fH2xsbDh79myZvl5z4GkPkd1hY0+oVegfX76ipn5s8Y2aClIIIYS+8CbqPUIF7uQbrsYJISqmSxnwQaGqpv9pUfaT9ZIqtwn7tWvXyMnJYd26dezfv5+YmBiOHTvGrFmzyMjIMPgNw9XVlfT0dACDfldXVzIyMlAU5YHPLdxfFTz9CMQ9q37FW9j5NAj+Hl7dB+l3yj82IYQwVzaW8HahvezLTsJfspddiApvyu/qDacFvOxhQivTxXM/5TZht7dXNwS9/vrr1KpVCw8PD8aMGcPWrVtxcnIiLS1N7/i0tDTtqnnh/rS0NJycnNBoNA98buH+qsLNFr4IgR+f0t+XWWBRHDRfCz9eKP/YhBDCXA03sso++TfTxSOEeHixybDitH7b9LbgbGP8eHNQbhN2Nzc36tati0ajMejz8/MjNvbu9xKZmZmcP38ePz8/o/2xsbF6fQkJCXor5oX7dc9NSEggOzubxo0bl+4LrCB61FPztr/a3LDvQgb0/AFe3A03sss/NiGEMDc2ljC5jX7bV2fgyHXTxCOEeDiKAm/9Cro3cDZ1g5eamiykYinXLDEvvPACn376KX///Tc3btzg448/5qmnnqJfv36cOHGC9evXk5WVxYwZM2jRogW+vuoejmHDhjF//nwuXbrE5cuXmTdvHuHh4QA0btyYli1bMn36dLKystiwYQPHjx9nwIABAISFhbF582b2799PZmYmU6ZMoX///lVuhV2Xsw0s7Ap7n1Yrpha24jQ0i4Lv/yz/2IQQwtwMbwLNq+u3/ecX9YNfCFGx/PgX7Lyo3/ZBR7Ay88pE5Rre5MmTadu2LY0bN6Zp06a0atWKt99+G09PT9avX8/bb7+Nm5sb0dHRREVFac+LiIggNDQUf39/mjdvTu/evYmIiND2R0VFcfjwYdzc3JgwYQLr1q3D09MTUFfYFy9eTFhYGF5eXqSnp7No0aLyfNlm67HaEPsMvBWgZo3RdfUf6LsdhuxQs80IIURVZWUB8zrpt+2/At8lmCYeIUTJ5ObDWwf12x6vA0/WN008D6Jc0zqas6qYFk1X9DV1K8zJG4Z9HnbwaRcY3Egt0CSEMC8lHb+ys7MZPXo0O3fuJDU1lUaNGjFnzhx69eoFqAXtXn31VS5cuED79u1ZuXIl3t7egFrQbsKECSxfvhyAESNG8P7772u3PSYmJvLCCy8QHR1N/fr1WbhwId26ddM+d2RkJBMnTiQ5OZnu3bvz5ZdfUr16dW1cr7zyCuvWrcPBwYFx48YxZsyYUnnND6P3D7BV5z6fhi5qsTpby3J5eiHEQ1p2EkbqpGrVAEefgZYe5RuHWad1FOatfQ31H+07bQy/FkrOgiE7od92uJxpmviEEKUvN9ojIGsAACAASURBVDeXevXqsXfvXm7dusXMmTMZNGgQiYmJJi1oN23aNOLj40lKSmL37t3MnTuX7du3l98bU4QPO4GlzqJFQhp8+ofp4hFCFF/6HcMbxoc1Kf/JeknJCvv/VPUVdl0xyepq+7Fkwz5XG/ios5qfWFbbhTAPpTl+tWjRgqlTp5KSkmKygnZ16tRhxYoV9OjRA1C3U8bHx+ttlTTVmP3afvjsxN3HLjZw7jm17oUQwnxN+Q1mFiqSdHYI1DVBITRZYReloqUHRPeHOe3Vyn66bt1RJ/M9f4DENOPnCyEqpmvXrnH27Fn8/PxMVtDuxo0bXL58uchrm9q0QHXhokDaHZj6u+niEULc36UM+LBQkaT/Bphmsl5SMmEXRllbwsTWEDMIOtQw7P/pL2i2Ft49Cnfyyj8+IUTpysnJISwsjOHDh+Pr62uygnYZGRnax8bONTUPe5gSqN+25CTEpZomHiHE/b3zm2GRpHEtTRdPSciEXdxTUzc40Bfmd1K/PtJ1OxcmRUPAN/DzRePnCyHMX35+Ps8//zw2NjYsXLgQuH/RubIqaOfk5KR9bOxcc/Bac/2UuPmKYeYJIYR5iElWayfommHmRZKMkQm7uC9LC/hPABwfBMG1DftP34R/bYawnXBFbkoVokJRFIURI0Zw7do11q9fj7W1NWC6gnZubm7UqlWryGubAxtLmNtBv237X7BdKkULYVaU//0yrXuzZjM3GGHmRZKMkQm7KLZGrrCrDywPBnc7w/7IePCNUrMm5OaXe3hCiBJ45ZVXOHXqFJs3b8be/u6dk6YsaDds2DBmzZrFjRs3OH36NMuWLdNe21z0fQSCCi1g/PegjH1CmJNtF2DXJf22ilAkyZgKGLIwJQuN+pvpmSHwspHfUNPuwBsHoN16OHS1/OMTQhRfUlISS5YsISYmhpo1a+Lk5ISTkxOrV682aUG76dOn4+Pjg7e3N0FBQYwdO5aePXuW3xtTDBqNulVQN1nWyRtqnmchhOnl5sPYX/Xb/lUHelWAIknGSFrH/5G0jiXz61V4ZR/Ephjvf7kpvNvB+Iq8EKJ0VMXxy1xe8ws/w0qd/bEedhD/HFSzNVlIQghg6UmIMIMiScZIWkdR7jrWhMMDYUFncLY27F92CnzXwIrT6o1ZQghRmcxuD446N+QnZ8HsI0UfL4Qoe8aKJA2vQEWSjJEJu3hoVhbwRgt1m8yQRob9yVlq7vauG+F4ESvxQghREdV2hPGt9NsW/AHnbxk/XghR9ubGwN+37z62t4JZ7UwXT2mQCbsoNbUcIbI77AyFJtUM+w9ehdbfwphf1N9+hRCiMvhvANR1vPs4Jx/GHzJdPEJUZRczYF6hIklvBUCdClQkyRiZsItS96+6EDsIZrczzN2ep8BHx9VsMt+cU1MuCSFEReZgrd6ro2t9Auy7bJp4hKjKChdJqmEPYytYkSRjZMIuyoStJUxqAycHQ6i3Yf/lTBi8A57YAmdvln98QghRmp57FNp66beNOSj37ghRno5dh/8rXCSpXcUrkmSMTNhFmWrgApuehO97greRQoU7LoL/WphS6DdiIYSoSCw08FEn/bYj12HVGePHCyFKl6LAW7/qF0nyc4MXfU0WUqmSCbsoF30eUVfbJ7UG60L/6u7kw8wj4BcFW5NME58QQjyszrXgGR/9tkm/QWaOaeIRoirZegF+riRFkoypJC9DVAQO1moKtOOD4PE6hv1/pkPvrdB/O1xIN+wXQghz934HsNH5ZL2cCR/EmC4eIaoCY0WSutWFnhW0SJIxMmEX5c7XTc0kE9kNajoY9m/4E5pGwfvH4E5e+ccnhBAl9YgL/CdAv21ujJq5QghRNj6Pg1M37j7WAB92VCsSVxYyYRcmodHAkEfh9LPwhr+6/1PXP7kw4RC0/Bb2XDJ+DSGEMEeTWoOnTnXn27kwKdp08QhRmf2VYfjzFe4LARW4SJIxMmEXJuVqCwu6wOEB0N7LsP/UDQjZBM/vgmv/lH98QgjxoFxsYGahIi2rzsLhv00TjxCVlaLAq/sgQ+c+ERebil8kyRiZsAuz0MoTDvaHpUFQ3daw/+uz0GQNfHYC8vLLPz4hhHgQI5pC8+r6bW/+ImkehShN6xJgc6FkFe+1VysQVzYyYRdmw0IDLzeDM0NghJE0TLfuwGv7od16+OVK+ccnhBDFZWUB8wuleTx4FRbHmSYeISqbG9nw+n79tk41IcLPNPGUNZmwC7PjYQ/LQ+CXftDC3bD/aDJ02QiDf4LEtPKPTwghiqN7PcPCceMPSRYsIUrD+F/h2u27j60tYFmQ4T1xlYVM2IXZ6lQTjgxUi5E4WRv2f3MefKNg4iFIu1P+8QkhxP189pj++JWRA6/sU/feCiFKZt9lWHZKv21iK2hW3fjxlUGxJ+wvvvgi6emGywKZmZm8+OKLpRqUEAWsLODfAWo2mcGNDPuz8+C9Y/BoJCw7KfvbRdUi47L5q+ek5mbXtfUCrIk3TTxCVHRZuTByr35bk2owsbVp4ikvGkUp3u/5lpaWXLlyBS8v/VQeycnJ1KxZk9zcil1X/tatW9q/u7q6mjAScS/7LsN/flG3xRjTwl3dN/qvuuUblxCmUDAu29revVPb1dW10ozL91KRxux8BYI2woGrd9vc7eDUs+Bpb7q4hKiIpv4GM47ot+19Gh6rbZp4SqIk41exV9gVRUFTKAO9oigcOHAAT0/P4l5GiIfyWG34fSCsDDF+F/jxFOi2GfpshbM3yz8+IcqTjMsVg4UGlgeDreXdtpQsePOAyUISokKKS4V3j+m3vdy0Yk3WS+q+E3YLCwssLS3RaDTUrFkTS0tL7R8rKysGDBjAkCFDyiNWIQD1w2+4L5wdAlPagL2V4TGbk8BvLfz7AKRmlX+MQpSlwuNy9erVtX8eZFxeuHAhgYGB2NraEh4erm1PTExEo9Hg5OSk/TNz5kxtv6IojB8/Hnd3d9zd3Rk3bhy6X9YmJiYSEhKCg4MDvr6+7Ny5U+95IyMj8fb2xtHRkb59+5Kamqrty87O5sUXX8TFxYWaNWsyf/78h3inzEcTN5gaqN+25hxsSTRJOEJUOPmKuhUmR2fra00HmNvRdDGVJyNTHX2rVq1CURSGDRvGwoUL9ZbubWxseOSRRwgMDLzHFYQoG47WML0dvNRMrXL29Vn9/tx8WPAH/N9ZmBYIr/iBtaXxawlRkRQel62t797VWK1atWKPy7Vr1+add97hxx9/5Pbt2wb9N2/exMrK8GNi6dKlbNy4kdjYWDQaDd27d6dhw4aMGjUKgCFDhtCxY0e2bt3K1q1bGThwIPHx8Xh6ehIXF0dERAQ//PADrVu3ZuTIkYwePZqoqCgApk2bRnx8PElJSVy9epWQkBCaNWtGz549S/p2mY23AtSb5WN0tvS9sk9dHXSxMV1cQlQES+LU1Ki6PukC1YzUbqmMir2Hfe/evXTu3Nno4F0ZVKT9kMK4367Bfw4a/kAXaOwKH3aCp7xBU0nTPomqpWBczszM1LaVZPx65513uHjxIitXrgTUFfJHHnmEnJwco2N+p06dCA8PZ+TIkQB88cUXLFu2jEOHDnH27Fn8/f1JTk7G2dkZgK5duxIWFsaoUaOYNGkSiYmJREZGAnD+/HmaNm1KSkoKzs7O1KlThxUrVtCjRw8AJk+eTHx8vHZCX6CijtlHr6u1JPJ0Pnlf8YNFj5kuJiHM3aUMaLZWPyNcqDd836tifp6X6R72Rx99lL//vltX+dixY4wdO1Y7wAthau1qwIG+sLY7eDsb9p+9BX22QffN6l53ISq6wuNybGxsqY7L3t7e1K1blxdeeIHk5LvLwnFxcQQEBGgfBwQEEBcXp+1r2LChdrJurF/3XB8fH2xsbDh79iw3btzg8uXLRV67MmjtCW+11G/7PE69oV4IYdzrB/Qn607WasrUijhZL6liT9ife+45tm/fDkBKSgqPP/44P/zwA2+88QYffPBBmQUoxIPQaGBQIzUN5LvtwdlI/vZdl6DVtzByD1z7p7wjFKL06I7Lqamp9OnTp1TGZQ8PD37//XeSkpI4cuQI6enphIWFafszMjL0VoVcXV3JyMhAURSDvoL+gvST9+rPyMjQPjZ2bmUxNRAeLbSo9tIeuF15k/oIUWIbEmDDn/ptc9qrKVOrkmJP2E+cOEH79u0B+O6772jYsCEnT57kq6++Yvny5WUWoBAlYWcFE1pD/HPqHeSFK5/lK2rRhUcj4b2jal5XISoa3XF58+bNNGjQoFTGZScnJwIDA7GysqJGjRosXLiQn376ibS0NG1/wd8B0tLScHJy0t6oqttX0F+w4n6vficnJ+1jY+dWFvZWatYYXfG3YMZhk4QjhNm6lQ2vFcqm1N4LRvuZJh5TKvaEPTMzExcXFwB+/vlnQkNDAQgMDOSvv/4qm+iEeEg1HGBpMBx7Bv5Vx7A/PQcmRkPTKPjmnFQfFBWL7ri8b98+7Y2ZpT0uF6SOLLjlyc/Pj9jYWG1/bGwsfn5+2r6EhAS9VfHC/brnJiQkkJ2dTePGjXFzc6NWrVpFXrsyeaw2jGqm3/ZBjLrHXQihmhQNl+/eooOVhfqZblns2WvlUeyX/Mgjj7Bv3z4yMjLYsWMH3bp1A+D69euVbvVDVD4t3GFHKGzqpd58WlhiOgzeAV03wu9/G/YLYY50x+Xdu3cTHBwMFH9czs3NJSsri7y8PPLy8sjKyiI3N5fo6GjOnDlDfn4+KSkpvPHGGwQHB2u3qgwbNoz58+dz6dIlLl++zLx587RpIRs3bkzLli2ZPn06WVlZbNiwgePHjzNgwAAAwsLC2Lx5M/v37yczM5MpU6bQv39/bbzDhg1j1qxZ3Lhxg9OnT7Ns2TK9lJOVyfsdoY5OPYk8BUbsgZw8k4UkhNk4eFW9v0PX2AD187wqKvaEfcyYMYSHh1OvXj3q169P586dAXVVp3nz5mUWoBClRaOB0Abwx2D4uDO4GUkF9ctVNYPD87vgYka5hyjEAykYl/38/Khbty4dOnQAij8uz5o1C3t7e9577z2+/vpr7O3tmTVrFgkJCfTs2RNnZ2eaN2+Ora0ta9as0Z4XERFBaGgo/v7+NG/enN69exMREaHtj4qK4vDhw7i5uTFhwgTWrVunLeTk5+fH4sWLCQsLw8vLi/T0dBYtWqQ9d/r06fj4+ODt7U1QUBBjx46tFCkdjXGxgc8LZYeJSYZ5scaPF6KqyM6Dl/eA7pfejVxhchXOIl7stI4AR48e5cKFC3Tv3h1HR3VZYNOmTbi5udG1a9cyC7I8VNQUYaLkUrNg+mFYFKfmbC/M3kr9bX5cKzXnuxDm6OjRo5w6dYqQkBAcHR1xdXWtNOPyvVSmMfu5HWoRpQK2lhD7jFpsSYiqaOZhmPK7ftuuUHi8rmniKW0lGb8eaMJemVWmwV88mDM34K1fYUuS8f7ajjCnHTzfxPDmVSHMQVUcvyrTa75+W72PJkWnKnPXWrDnaRlzRNVz+gYEfAN3dBbSXvCFL0NMF1NpK9M87AC7d++mW7du1KpVi9q1a9O9e3f27NlT7PODg4Oxs7PTlrpu0qSJtm/Xrl34+vri4OBASEgISUl3Z09lWQZbiCZusPlJdY+7f3XD/suZEL5b3SojuZKFudm9ezdPP/00TZo0wdfX94HHZWF6nvawoLN+2/4ramVHIaqSfAVG7tWfrHvawQcdTReTuSj2hH3NmjV069YNFxcXJkyYwLhx43BycqJbt26sXbu22E+4cOFCMjIyyMjI4MyZMwAkJyfTv39/Zs6cSWpqKoGBgQwePFh7jm4Z7OPHj7NlyxaWLFmi7R8yZAitWrUiJSWF2bNnM3DgQK5fV2+1LyiDvWrVKq5du4aDgwOjR48udryi6uhWV80msyQIvOwN+49ch6Dv4ckf9EuLC2EqBeOys7Mz//73v3njjTdKNC4L03vuUehVX79t/CH4S+6lEVXIF6fUX1Z1LegC7namicecFHtLjJ+fH0OHDmXixIl67XPmzCEyMpITJ07c9xrBwcEMHTqUl156Sa996dKlrFy5koMHDwJqqjIPDw+OHTuGr69vmZbBLlCZvl4VDy/tDsw5Ch/F6v+mr2twI5jZFh6tVr6xCVGgYFzWXYRwdXV9oHG5oqqMY/aFdPBbCxk5d9t6e8PmClp+XYgHkZCmFjXUrWjaqz788GTl+/dfpltizp07xzPPPGPQPmjQIM6dO2fkDOMmTpyIh4cHnTt31n5tW7hUtaOjIz4+PkWWsi6tMthCFMXFBt7rAKeHwDM+xo9Ze07ddzpyj2SUEaZRWuOyMA/1neH9DvptPyTBmnjTxCNEebmTB4N/0p+sO1jBoq6Vb7JeUsWesHt6enL8+HGD9piYGG26rvt5//33SUhI4NKlS4wcOZLQ0FDOnz//wKWsS6sMthD384gLfNMDDvSFLjUN+/P+VzG1UST89yAk3y7/GEXVVRrjsjAvo/wMx5o3f1FvTBWispoYDYcLFQ17vwM0cDFNPOao2BP2oUOHEhERwZIlSzh58iSnTp1i8eLFvPLKKzz//PPFukb79u1xdnbG1taW4cOH07lzZ7Zu3frApaxLqwy2EMXVuRbs66t+NRdgpGhDdh7Mj4WGq2H675B+x/AYIUpbwbi8YsUKTp8+zZkzZx54XBbmxUIDy4PV1I4FkrNg+M/qDXlCVDZbEtXPT119H4FXpcSPHqviHjhr1izy8vJ48803ycnJQVEUbG1teeONN5gxY0aJnlyj0aAoCn5+fnz11Vfa9szMTM6fP29Qyrpdu3ZA0WWwCybhsbGxPPfcc3rnFtAtgy3Eg9Bo4Elv6Fkfvj0Pk3+D+Fv6x6TnwLTDsPAETGwNo/3Artg/ZUI8mIJxecKECaU2LgvTa+IGUwPVsuwFtl2AucdgQmvTxSVEabuYof4yqqu+E3wRLFthCrvvTaf5+fmcOHGCRx99FHt7e27fvq3dG+nj48O5c+do3rw5Fhb3Xqy/efMm0dHRBAUFYWVlxdq1axk5ciRHjx6levXqNGrUiC+//JLevXszdepU9u7dy6FDhwBYvHgxCxYsYOfOnWg0Grp3787rr7/OqFGjAOjQoQNdunRh1qxZbNu2jRdeeIH4+Hg8PT2Ji4ujY8eO/PDDD7Ru3ZqIiAhyc3OJiorSi68y3sAkylZOHqw8oxZfupRp/Ji6juoHb7gvWD1QElUhilZ4XL569SoJCQkAtGzZstjjckVW2cfsnDwI3qSWZy9goYHdfeCx2qaLS4jSkpsPj2/SzwpjqVG/ze5kZAtqZVImN52uXr2aYcOGYWNjA4C9vT3+/v74+/tjY2PDsGHDipU+LCcnh3feeQdPT088PDz49NNP2bhxI02aNMHT05P169fz9ttv4+bmRnR0tN6EuizLYAtRUtaW8HIziH8O5nUynnbqYia8vBeaRak3qcpX2qI0GBuX/fz88PPze6BxWZgva0uI6q4/ruQr8OwO+Psf08UlRGmZftgwheOsdpV/sl5S911hDw4OZsSIEUXuh/z666/54osv2L17d5kEWF4q+2qNKHtpd9R9ePNi9dOy6WrlAbPbqdtq5Os+UVKFx+XC41dlGZfvpaqM2duS4Mmt+m3d6sL23mBZeb9AEZXcrovQfTPoTkB71INtvatGdd8yWWE/ffo0nTp1KrK/Y8eOnDp1qlhPJkRl5mID09pCQhj8p4X+TWMFjiWrH76PbYQDVwz7hSgOGZerjl7eMLGVftvOizD7qGniEeJhXfsHhu7Sn6zXdID/e7xqTNZL6r4T9lu3bpGTU8RyIXDnzh2DLCxCVGWe9jC/s7pV5qWm6p68wg5cha4bobdUTRUlIONy1TKjHTxWS79t2u/qKqUQFUm+AsN+hqs627o0wNf/ghoOJgurQrjvhN3b25uYmJgi+2NiYqhfv36R/UJUVfWcYFkwnHxWrYpqzNYLamW3ITsg/ma5hicqMBmXqxYrC1jTHTx19rMrwHM74UoRN7wLYY7mHoOf/tJve7sN/KuuaeKpSO47Ye/Tpw+TJ08mI8OwlGNaWhpTp04lNDS0TIITojJoXE29eezoQLXMsjFRUjVVPAAZl6ue2o4Q2V1djSzw920YslPNtiGEuTt4Fd75Tb+tay01k5q4v/vedJqamkqrVq3Iycnh9ddfp2nTpmg0GuLi4li4cCHW1tYcPXoUd3cj1WQqkKpyA5Mwvf2X1apuv1w13m9rqRaMmNgKPOzLNzZRMRQel+vXr49Go+H06dMsX7680ozL91JVx+xpv6vZNXRNag2z25smHiGKIzVL/Tb5gs4ag7sdxDwDdZ1MF5eplGT8uu+EHeDSpUuMGjWKbdu2kZ+v/ipvYWFBr169WLRoEfXq1SthyOajqg7+wjQURS2EMikaYlOMH+NsDf8NgDEB4GxTvvEJ81cVxuV7qapjdl4+PLEFdl3Sb9/6pHqDqhDmRlGg/4+w8U/99s294KkGJgnJ5MokSwxAnTp12Lx5M9evXyc6OppDhw5x/fp1Nm/eXOk/FIQoCwVVU48+A2u6QSMjP68FVVMbroaPYiErt/zjFOZLd1zetWsXO3fu5Pz58w80Li9cuJDAwEBsbW0JDw/X69u1axe+vr44ODgQEhJCUlKStk9RFMaPH4+7uzvu7u6MGzcO3bWfxMREQkJCcHBwwNfXl507d+pdOzIyEm9vbxwdHenbty+pqanavuzsbF588UVcXFyoWbMm8+fPL8G7U3lZWsDqbmpWDV3P/wx/yXY6YYYWnjCcrP+nRdWdrJfUA2VxdXNzo23btrRr1w43N7eyikmIKsNCA88+CicHw9IgqONoeExyFow5CD6RsOA4/FN0chBRBbm5udG6dWvatGlDtWrVHujc2rVr88477/Diiy/qtScnJ9O/f39mzpxJamoqgYGBDB48WNu/dOlSNm7cSGxsLMePH2fLli0sWbJE2z9kyBBatWpFSkoKs2fPZuDAgVy/fh2AuLg4IiIiWLVqFdeuXcPBwYHRo0drz502bRrx8fEkJSWxe/du5s6dy/bt20vy1lRaNRzU+2J0U+ClZKlFlXLyTBeXEIUdvQ5vHdRvC/SE9zqYJp6KrFhbYqqCqvr1qjAvt3Nh0Ql495j6AWyMlz28FQCvNAcn6/KNT5inhx2/3nnnHS5evMjKlSsBdUK+cuVKDh5UP2kzMzPx8PDg2LFj+Pr60qlTJ8LDwxk5ciQAX3zxBcuWLePQoUOcPXsWf39/kpOTcXZ2BqBr166EhYUxatQoJk2aRGJiIpGRkQCcP3+epk2bkpKSgrOzM3Xq1GHFihX06NEDgMmTJxMfH69X/bo0XnNlMOcIvF3oJr63AuCDolP0C1Fu0u9A63Vw7u6PKi42agIGn6r5I6tVZltihBDlw94K/ttSLb40NdD4hPzv2zDuEDT4Wv3ATrtT/nGKyi0uLo6AgADtY0dHR3x8fIiLizPaHxAQoNfXsGFD7WTdWL/uuT4+PtjY2HD27Flu3LjB5cuXi7y20DehNfQstPvpw1jY9Kfx44UoL4oCo/bpT9YBlgXJZL2kZMIuhBnSrZo6JkCdyBeWkqWurnmvUjNH3Mgu/zhF5ZSRkWGw6uPq6kp6errRfldXVzIyMlAU5YHP1e0vSFNZ+NoF5wp9FhpY9S+oW2gr3fCfIVHqZgkTWnEaIuP120Y2g0FF1CQR9ycTdiHMmKc9zOsEiWEwvpXxFfebd9Q0b96r4O1oSL5d/nGKysXJycmgUmpaWpp21bxwf1paGk5OTmg0mgc+V7ffyclJ+9jYucKQhz2s7aEWVypw8w4M2gF3ZD+7MIETKfDaAf225tXh486miaeykAm7EBWAl4N6k07iUHinjboCX1h6Dsw5qm6VGXsQrv1jeIwQxeHn50dsbKz2cWZmJufPn8fPz89of2xsrF5fQkKC3qp44X7dcxMSEsjOzqZx48a4ublRq1atIq8tjOtUE94tlIf9979h7K+miUdUXZcy4Mmt6v1YBRysYG13498Ui+KTCbsQFYi7HcxsB0lDYUZbcLM1PCYzV93H2uBr+PcBdQAVwpjc3FyysrLIy8sjLy+PrKwscnNz6devHydOnGD9+vVkZWUxY8YMWrRoga+vLwDDhg1j/vz5XLp0icuXLzNv3jxtWsjGjRvTsmVLpk+fTlZWFhs2bOD48eMMGDAAgLCwMDZv3sz+/fvJzMxkypQp9O/fX7uKPmzYMGbNmsWNGzc4ffo0y5YtM0g5KQz9NwBCC+Vh/+QPWH/eNPGIqudWtjpZL5xedGFXaFbdNDFVJjJhF6ICqmYLkwPVFfd324OHneExWXmw4A81j/vofXBBtgGLQmbNmoW9vT3vvfceX3/9Nfb29syaNQtPT0/Wr1/P22+/jZubG9HR0XpZWiIiIggNDcXf35/mzZvTu3dvIiIitP1RUVEcPnwYNzc3JkyYwLp16/D09ATUFfbFixcTFhaGl5cX6enpLFq0SHvu9OnT8fHxwdvbm6CgIMaOHUvPnj3L702poDQa+Opf4F1o99Dwn9XVdiHK0p08GPAjHC9UCHBUMwhvYpqYKhtJ6/g/kiJMVGSZObDkJMw9BteK2MNubQHDm8DE1tDQpXzjE2WrKo5fVfE1F8dv16DLRsjJv9vmYQcH+kITKZ8iyoCiwPO7YHWhm0z7NIDvnlCLfQl9ktZRiCrK0VrNJvPnUPiki/ECTDn5sPwUNI6E8J/h7M3yj1MIUbba1YAFhW7uS86CJ36Ay5mmiUlUbpOiDSfr7b3UKt4yWS898lYKUYnYW8Hr/nA+DBY/Zvj1OECeAl+dgaZR8NwOiEs1PEYIUXG90hwmttJvS0qHnlvgpqR/FaVo0Ql475h+WyNX2PwkOEhhv1IlE3YhKiFbS4jwg/gh8EUw+BjZApOvwJpz4L8WnvkRYpPLPUwhRBmZ3R5G+Oq3v8JJoAAAIABJREFU/ZEKoYUyeAhRUhv/hNf267d52sH23mpKYlG6ZMIuRCVmbQkvNoXTQ9QCK02qGR6jAOsSoOW38PQ2OCw3qAlR4Wk0sDhI3Ues68BVeHYH5OYbPU2IYvn1KgzZoX5+FHCwgh96SyXTsiITdiGqACsLGNoY4gZDVHe1iIUxmxKh7Xp48gd1QBZCVFxWFurPe5ea+u2bEmHUXvVmQSEe1NmbELpNzURWwFID3/SAtl6mi6uykwm7EFWIpQUMbgSxg2D9E9DSw/hx2y5Apw3QbRPsvVy+MQohSo+9FWx60vCX9C9Owzu/mSYmUXFd+0e9FyIlS7/988egt7fxc0TpkAm7EFWQhQb6N4SjA2Fzr6JXRXZdguDvodN3sCEB8uRrdCEqHDdb+PEpw5vQ5xyFT46bJiZR8WTkQO+t8Gehmh6T28DLzUwTU1UiE3YhqjCNBp5qANH91RuFOtc0ftyv16D/j2pmmcVxctOaEBVNbUf46SnDImtv/gJr4o2fI0SB3HwY9BMcua7fHt4Eprc1TUxVjUzYhRBoNPBEfdjfF37uAyG1jR8Xfwte2Qf1V8H03+F6EUWahBDmp3E12NobHK3024f/DD/9ZZqYhPlTFPWeh20X9NufqAdLg9TPD1H2pNLp/0jVPCH0HbgCs4/A9nt8kNtZwgu+atGmRvJjYzJVcfyqiq+5tPz0Fzy1Vb8aqqMV7H5abhosNYoC+TmQn/u//+YU83E5nZOXA0pu0Y+7fgINnwZgxmGY+rv+y2vtAXueBmcbE7y3lUBJxi+ZsP+PDP5CGPdHCsyLhch4/Q94XRqg3yPwVkvoWMS2GlF2quL4VRVfc2laEw/P7dRv87CDA32hiVs5BqIooOQVb6KZ97//Fkwsi/u4oC2viOuWxcRZybv/azdn3VdBk6F8eQpG7NHvauAMv/aHmg4miaxSkAn7Q5DBX4h7u5QBn/wBi09C2p2ij+tcU52492mg3twqyl5VHL+q4msubZ/E5rHxl700U05iRS7W5OBpm8Mo3xxcrMpiQlvENYT5efxLtju9wFNb1erYBarbwi/9wLc8f6mrhGTC/hBk8BeieNLuwPJT8PFx+Cuj6OMau6pbZYY1UVPLibJTFcevqviaS93e1+GPhaaOQpihGP8ldDwzUi/Xup0l7AyFzrVMF1dlIRP2hyCDvxAPJicPvjkPH8ZCTHLRx3nawWv+MNoPPKRcdZn4//buPC6qen3g+GfYVxEBwUAlUcTQkHJNSkC9VmaaZbhxMzdyq3vTq2W5UFZer9Y1vWQ3K80w+imWdc0yMXBJTU1QcUMJcyUFjU328/vj5CQ4IMMyMzDP+/U6L5izzDyPR77zzHe+53vMsf0yx5zr3SoPKKzmj1eYMA1Y2f+xOFT6qWOdpT1Y3/L7zW3WDmDdDBy9wMIaLKyJO2PNpJ/cycXp1ldjw0B1OmBRd1Kw14E0/kLUjqKo87UvSYbvqrlA1d4KxgXA3++VW1fXN3Nsv8wx53r3v8ch42tjRyFMgWdPlMHf8mZqc5031Foeona8iPohBXsdSOMvRN0dzoKlybDutDpvry4a1F6af3SFnp4GDa/JMsf2yxxzrneF1+DEasg+TmlZCQm/lnKtsARrpUQ7pt3FqoT7WhRir9yAshtQWmkpr+aCFtGofO21kMevvFJhnYUG3n8IJsiNkeqVFOx1II2/EPXn/B8XqL5/hwtUH2wFM4PUmzfJBaq1Z47tlznm3NCuFcHnsQsYXPABLcj+o2iXi0LNxXTNu6ywmK59bGcJnw+Ax+82YlBNVG3aL7lxkhCi3vk4weLe8OsYWNIbfBx177fzEgz5Fu6Jgw+OQaHUBiYlNDQUOzs7nJyccHJyomPHjtptCQkJBAQE4ODgQFhYGGfPntVuUxSF2bNn4+bmhpubG7NmzeLWvqGMjAzCwsJwcHAgICCAbdsqzi+4bt062rZti6OjI0OHDiU7O7vhkxW4Zu3kuYJovLmIPYVSrDdVFtbq+HWbZpTbtuA3Sx/e0zzHSs1z2l2a26h3xpVi3XRIwS6EaDAutjCjK6SPhrX9IMhN934nr8OkJGj7KSw8CFmFho1TVG3FihXk5eWRl5fHyZMnAbh69SrDhg3j9ddfJzs7m27duhEREaE95r///S9ffvklKSkpHD58mP/973+8//772u0jR44kODiYrKws3njjDZ566imuXFHveZ6amkpUVBRr164lMzMTBwcHpkyZYtikzVVZkbEjEIbS7yMyx/xOt+ZZeHKOKRbvUaqxBuAuR/Wu1w9WccdrYRxSsAshGpy1JYzxh0PD1V6bAT669/vtBsz9Cdqshek7IT3HsHGKmtm4cSOBgYEMHz4cOzs7FixYQEpKCidOnABgzZo1zJgxAx8fH7y9vZkxYwarV68G4NSpU/z8889ER0djb2/Pk08+SZcuXYiPjwcgNjaWwYMH89BDD+Hk5MTrr7/Oxo0byc3NNVa65sOnH9wzQe2BFU1XeQnl257lLxtzOVRpkqCOzeHHJ6BzFZ0rwnikYBdCGIxGAwNaw9bBkDwcIv3BSkcrVFAKK45C+1gYsgW2nVdnoxGG9/LLL+Pu7k6fPn1ITEwE1F7woKAg7T6Ojo74+fmRmpqqc3tQUFCFbe3atcPZ2bnK7bce6+fnh42NDadOnWqwHMUfNBoI/wAm5cCELBiXyc++c40dlWgA5WXFZORUnBmgZ0v1Trdtnas4SBiVUQr2tLQ07OzsGDNmjHadjIcUwrwEucMn/dThMjOCwFlHp54CfJUBA75Wx7mvOFL9Rayifv3zn/8kPT2dCxcuMGnSJAYPHsyZM2fIy8u77UIpFxcXbS945e0uLi7k5eWhKIrex1beLgzAyg7sWoBdC+77dZGxoxEN4AXNMnI0f/6dPdIGEh6Xe2WYMqMU7FOnTqV79+7axzIeUgjz1doJljwA5yJhcS/wruIC1RPXYfou8P5EHS5z4pph4zRHPXv2xNnZGVtbW5555hn69OnDN998g5OTEzk5Fccr5eTkaHvNK2/PycnByckJjUaj97GVtwtD0oC10513E6av3VC+DrtIW6uL2FgUEWMxVbsp0h82PQyOMhLKpBm8YI+Li6N58+b069dPu07GQwohXGzhH8Fqj/sn4dDVXfd+eSXqcJlOcWrP+6ZfoKyKOd9F/dJoNCiKQmBgICkpKdr1+fn5nDlzhsDAQIDbtqekpFTYlp6eXqENrrz91mPT09MpKirC39+/QXMTOlhYwsDPwcXP2JGIOirJ2MqQHa34VWlFicZGu35mEKwOV68zEqbNoAV7Tk4O8+bNY+nSpRXWy3hIIcRNNpYQ2RF+fgp2PwEj2use5w7q2Pah34LfOlh8SGaXqU/Xr1/nu+++o7CwkNLSUmJjY9mxYwcDBw7kiSee4OjRo8THx1NYWMhrr73GvffeS0BAAAB//etfefvtt7lw4QIXL15k6dKljB07FgB/f3+6du1KdHQ0hYWFfPHFFxw+fJgnn3wSgNGjR/P111+zc+dO8vPzmTdvHsOGDZMedmNpMwAiT8M0BaaUUO7Y2tgRiVr4sbwblS8D+ldv+NcDcg+MxsKgBfvcuXMZP348rVtX/IOX8ZBCiMo0GnjACz4boM7nvqAbeDno3vdsLszeCz6fwPgf4NAVw8baFJWUlPDqq6/i4eGBu7s7y5cv58svv6Rjx454eHgQHx/PK6+8gqurK/v27SMuLk57bFRUFIMHD6ZLly507tyZQYMGERUVpd0eFxfHgQMHcHV15aWXXmLDhg14eHgAag/7ypUrGT16NC1btiQ3N5eYmBiD5y90UMqwyD9n7CiEnl7TzOVpi//TPrayUL/FnNnViEEJvVkZ6oWSk5PZtm0bhw4dum2bjIcUQlSnlSPM7w4v3wcb09UhMbsv375fYRl8dEJdHvCC6Z1hWDu1117ox8PDg/3791e5vX///tphi5VpNBoWL17M4sWLdW739fXVzjijy6hRoxg1apRe8QoDsLSFrjMgeemd9xVGF2T3C4dLfCusc7CCDX+BR9oaJyZRewYr2BMTE8nIyKBNmzaA2vNdVlbGsWPHeO6551izZo1236rGQ/bo0QOoejzkzSI8JSVF29jLeEghmg4bSxjRQV1+vgL/OQrr0tRCvbIfL6uLlwNE3QOT7lFvCCKEqIOQJRA4Cc6o14nt+w3apL9LK3R8ghZGcwV3Mopd4ZbhLm52sPlR6OlpvLhE7WkUxTCzGxcUFFTo6V6yZAkZGRm89957ALRv356PPvqIQYMGMX/+fJKSkti7dy8AK1euZNmyZWzbtg2NRsOAAQOYPn06zz2n3ka3V69ehISEsHDhQrZs2cKzzz5LWloaHh4epKam0rt3bzZv3sx9991HVFQUpaWlFb6+Bfj999+1v1ceQiOEMF1ZhfDhcYhJVYfGVMXKAp5qB9M6q73vmiY0btMc2y9zzNlUHUmMocvRqXfeURjEXnryvMW77Nf00K7r46VOo9uumREDE1q1ab8M1sPu4OCAg8OfA1CdnJyws7PTjluMj49n2rRpjBkzhp49e942HjI9PZ0uXboAMGHChNvGQ44dOxZXV1fatGlT5XjIrKws+vfvz8cff2yIlIUQBuBmB7OC1bncN5+F5UfVi1ErKy2HuNPq0tVdHS4zsgPYG6wVFKJp6uJewzFnFtagsQQLq2p+Wqmz0+j8Wd1x9XT8zd/renzln9Uebwma2l9SmFMML+6GD3WMULOxgIU94MUgsJRbZTZqButhN3XSWyNE03H8GsQchdUn1Wkgq9LCFsZ3gimB4NuIe57Msf0yx5xNVnEeFP9ObqkV0QetWHXSklKsKOPPn4rGgnEBsPQBaG5r7ICbjsQLMPYH3d8uBrurF5d2djN8XKJ6tWm/pGD/gzT+QjQ9OcXwyUn1ItWT16veTwMM9lWHy/T3aXzDZcyx/TLHnBuLxAswPhHSc27fdpcjvPcgPH63wcNqUm6Uwpx98O/Dt2+z1MCc++DV++WCe1MlBXsdSOMvRNOlKJBwAZYfga8zuG0+4lt1bK4W7n/tCM1sqtnRhJhj+2WOOTcm+SUw9ye1oNT19zayPSwLAQ97g4fW6O3/Df6aoN79ubKA5rAmHHrIhaUmTQr2OpDGXwjzkJED76XCquOQXVT1fo5WENEeJnZSZ1Uw5V53c2y/zDHnxmjvZRiXqA5Tq8zdDlY8CE/7mfbfl6koLoOFB+HNn6FMR+X2t3vhzZ5yXU5jIAV7HUjjL4R5uVEKn6WpF6kmX61+384tYEIniPSHFnaGiU8f5th+mWPOjVVRGbx+ABYd0l1oDvGFmIdk2tXqHLqiDjM6pKOtausMq8Mg1NvgYYlakoK9DqTxF8I8KQrsyVSHy2xIV2eTqYqtJTzZTi3eQ+8ynV5Bc2y/zDHnxu7QFbW3XdcHZBcb9YLUsR1lNpObFAUSL8LiQ/BtFTeYHR8Ab/dpPMP3hEoK9jqQxl8IcSkf3j+mDpe5kF/9vu1d1ML9mY7qzZmMyRzbL3PMuSkoKYN/JUP0ASjW8eG4rbN6Dcn4TuBqprPJlJXDxl/UQv3AFd37eDnAqlAYJHcsbZSkYK8DafyFEDeVlsO3v6qF+//O6v4a/yYrCxjcVh3r/pfWxukdNMf2yxxzbkqOX4NxP8DeTN3bHazUIWjPd4F7Whg2NmO5UQqrT8DSFDijY4admyLaw38eVO9BIRonKdjrQBp/IYQuF/PVN9FVx+GXau6kCtDaCcYFqEsbZ8PEB+bZfpljzk1NWbk6FG3OT2qxWpX+PmrhPqgtWJjIMLT6lFWo3jdi+RG4Ulj1fr091ekaH/M1WGiigUjBXgfS+AshqlOuwA8X4IPj8EW67q/zb9IAD7dRe90fawvWDTwXsjm2X+aYc1OVngNvHITYNPUC1ar4NVOHyzwbAC5NYLhMRg68c1jtDCio5gPL474wqyv0aWWw0EQDk4K9DqTxF0LU1NUbsPaUWrzrmq7uVp72MDZAHe/evoGaFnNsv8wx56bu6g31b+o/R6u/hsTJWr04dVpn6OhquPjqS/JVdRz/56erHm5nbaEOCZrZFTo1whxF9aRgrwNp/IUQ+lIU+PGy2kP2+Znqv9YHdWaZiZ1gWDuwq8e5ks2x/TLHnM1FSRl88Qu8ewR2X65+34dbwwv3wgAf051dpqhMvdnRrkuw9Rz8cLHqfZvZwHP3qDnJNJdNlxTsdSCNvxCiLn4vgnVpag+hrrmSb+Vqq/aeTewEnd3q4bXNsP0yx5zN0cEr8O5hiDtd/TA0Ryu43wO6t4QeLdWfvs7GmXo1p1j9IL/zkrr89Fv1Q31ALc7/1gUm3dM0hvuI6knBXgfS+Ash6svPV+CDY+qY3NyS6vft5akOl4lor37VXxvm2H6ZY87mLLNAnXL1vVS4XFCzY9ztoJvHnwV895bg2QBTsF4u+LM433kJDmep17zURCdX+EdXGNVBvc+DMA9SsNeBNP5CiPqWXwLrz6i97j/e4at9J2v1TXtCJ7XI0KdnsCm2X9nZ2YwfP56tW7fi7u7OW2+9xahRo7Tbm2LO4s6Ky2DDGVh2RO251lcbpz+L9+4ecHczdRx5WTmUKuqUrqWVH5er+5Tesi6rEH7MVAv007/f+XUrC/GCWcFNd+YbUT0p2OtAGn8hRENKzYYPj8Mnp9Q3+6p4O8LZMfqNx22K7dfIkSMpLy/nww8/JDk5mUGDBvHjjz8SGBgINM2chX72ZcKKo+o9E65W8zdlClo7wYOt1KXvXXIhqbmTgr0OpPEXQhhCUZk6LeSq45Bw4fbtc++H13ro95xNrf3Kz8/H1dWVo0eP4u/vD0BkZCTe3t4sWrQIaHo5i9pTFDibq/a47/8N9l9Rx77n3WE4WkO6x/XPAv3BVoa9L4MwfbVpv+pxngIhhBB3YmsJIzqoy5nf1V73j0+q42A1qLdkN3enTp3C0tJSW6wDBAUFkZSUZMSohKnSaMC3mbo83V5dV1YOJ67/UcD/phbzKVlQUs2Fq7VlZQH3u/9ZnPdpJXchFfVPCnYhhDASPxd4sxdEd4dvflVnl2krPXHk5eXd1uvk4uJCbu4dbjUrxB8sLSCwhbqMDVDXFZWpF4TeLOAPXlFndLGyACuN+tPyj586193y2MYSAv/oRe/pCY61vGBciJqSgl0IIYzM2hKG3K0uApycnMjJyamwLicnB2dn+TQjas/W8s8LTqcYOxgh9GSitxkQQghhrvz9/SktLSUtLU27LiUlRXvBqRBCmBsp2IUQQpgUR0dHhg0bxrx588jPz2f37t1s2rSJyMhIY4cmhBBGIQW7EEIIkxMTE8ONGzdo2bIlI0eO5L333pMediGE2ZJpHf9w6xQ7QgjRWJnLFIfSZgshmoKattnSwy6EEEIIIYQJk4JdCCGEEEIIEyZDYoQQQgghhDBh0sMuhBBCCCGECZOCXQghhBBCCBMmBbsQQgghhBAmTAr2OsjOzuaJJ57A0dGRtm3bsm7dOmOH1KCKiooYP348bdu2xdnZmeDgYLZs2WLssAwmLS0NOzs7xowZY+xQDCYuLo5OnTrh6OiIn58fO3fuNHZIDS4jI4NHH30UV1dXvLy8mDZtGqWlpcYOSzQQfdrxNWvWcP/999OsWTN8fHyYNWuWyf3f0Cefd955By8vL1xcXBg3bhxFRUUGjLR2appfYzhXutSmrggPD0ej0Zh8fvrklp6ezmOPPYazszPu7u7MmjXLgJHWTk3zUxSFV199FW9vb1xcXAgNDSU1NfWOzy8Fex1MnToVGxsbMjMziY2NZfLkyTX6R2+sSktLad26NUlJSfz++++8/vrrPP3002RkZBg7NIOYOnUq3bt3N3YYBvP9998ze/ZsPv74Y3Jzc9mxYwft2rUzdlgNbsqUKbRs2ZJLly6RnJxMUlISMTExxg5LNBB92vGCggL+/e9/c/XqVfbt20dCQgJLliwxcMTVq2k+3333HYsWLSIhIYGMjAzS09OZP3++ESLWT03zawznShd964rY2FiTL9RvqmluxcXFDBgwgPDwcC5fvsz58+cbRUdZTfNbv349H330ETt37iQ7O5vevXvX7C7OiqiVvLw8xdraWjl58qR23ZgxY5TZs2cbMSrD69Kli7JhwwZjh9HgPvvsM2X48OHK/PnzldGjRxs7HIPo3bu3smrVKmOHYXABAQHK5s2btY9nzpypTJo0yYgRiYZS13Z86dKlymOPPdZQ4elNn3xGjhypvPzyy9rH27ZtUzw9PQ0SZ23V5XyZ2rnSRd/8rl+/rnTo0EHZs2ePAiglJSWGClVv+uT2/vvvKyEhIYYMr870yW/RokXK8OHDtY+PHj2q2Nra3vE1pIe9lk6dOoWlpSX+/v7adUFBQU26h72yzMxMTp061eRvF56Tk8O8efNYunSpsUMxmLKyMg4cOMCVK1do3749Pj4+TJs2jRs3bhg7tAb3wgsvEBcXR0FBARcuXGDLli08/PDDxg5LNIC6tuM7duwwqfZPn3xSU1MJCgqqsF9mZiZZWVkGibU26nK+TO1c6aJvfnPmzGHy5Ml4eXkZKsRa0ye3vXv34uvryyOPPIK7uzuhoaEcOXLEkOHqTZ/8RowYwenTpzl16hQlJSWsWbOmRu8xUrDXUl5e3m23k3VxcSE3N9dIERlWSUkJo0eP5plnniEgIMDY4TSouXPnMn78eFq3bm3sUAwmMzOTkpISNmzYwM6dO0lOTubQoUMsXLjQ2KE1uL59+5Kamqod+9qtWzeGDh1q7LBEA6hLO/7xxx9z4MABZs6c2VDh6U2ffCrve/N3U34Pq+35MsVzpYs++R04cIDdu3czffp0Q4VXJ/rkdv78eeLi4nj++ee5ePEigwYNYsiQIRQXFxsqXL3pk1+rVq148MEH6dixI/b29qxfv5533nnnjq8hBXstOTk5kZOTU2FdTk4Ozs7ORorIcMrLy4mMjMTGxoYVK1YYO5wGlZyczLZt2/j73/9u7FAMyt7eHoDp06fTqlUr3N3defHFF/nmm2+MHFnDKi8vZ+DAgQwbNoz8/HyuXr3KtWvXmD17trFDE7UQGhqKRqPRuYSEhNS6Hf/yyy956aWX2LJlC+7u7g2Zgl70yafyvjd/N+X3sNqcL1M9V7rUNL/y8nKmTJnCsmXLsLKyMmSItabPubO3tyckJIRHHnkEGxsbZs6cSVZWFsePHzdUuHrTJ7/o6Gj279/PuXPnKCwsZP78+YSHh1NQUFDta0jBXkv+/v6UlpaSlpamXZeSkmLyX7nVlaIojB8/nszMTOLj47G2tjZ2SA0qMTGRjIwM2rRpg5eXF0uWLCE+Pp777rvP2KE1KFdXV3x8fNBoNMYOxaCys7M5d+4c06ZNw9bWFjc3N5599tkm/0GlqUpMTERRFJ3Lrl27atWOf/vtt0ycOJGvv/6aLl26GCKNGtMnn8DAQFJSUirs5+npiZubm0FirQ19z5cpnytdappfTk4OBw4cICIiAi8vL+1kCD4+PiY7k5c+5+7ee+9tdO89+uSXkpJCREQEPj4+WFlZMXbsWK5du8axY8eqf5E6jrM3axEREcqIESOUvLw8ZdeuXUqzZs2Uo0ePGjusBhUVFaX07NlTyc3NNXYoBpGfn69cunRJu8yYMUN58sknld9++83YoTW4uXPnKt26dVMyMzOV7OxsJSQkRHn11VeNHVaDu/vuu5W33npLKSkpUa5du6YMHTpUGTVqlLHDEg1En3Y8ISFBadGihZKUlGTgKGuupvls2bJF8fT0VFJTU5Xs7GwlLCysUUyaUNP8GsO50qUm+ZWXl1d4X/rpp58UQDl//rxSVFRkpMjvrKbn7sSJE4q9vb3y/fffK6Wlpcrbb7+ttGvXzqRzU5Sa57dgwQKlT58+yuXLl5WysjLlk08+URwcHJRr165V+/xSsNdBVlaWMmTIEMXBwUFp3bq1Ehsba+yQGlRGRoYCKLa2toqjo6N2+fTTT40dmsGY0ywxxcXFyuTJkxUXFxfF09NTmT59unLjxg1jh9XgDh06pPTt21dp3ry54ubmpjz11FNKZmamscMSDaS6dvzs2bOKo6OjcvbsWUVRFCU0NFSxtLSs0P49/PDDxgpdp6ryqZyLoqgzp7Rs2VJxdnZWxo4dqxQWFhor7BqraX6N4Vzpos/5u+mXX34x+VliFEW/3OLj4xU/Pz/F2dlZ6du3b6PoDK1pfjdu3FCmTJmieHl5Kc7OzkpwcLCyZcuWOz6/RlEUpV6/FxBCCCGEEELUGxnDLoQQQgghhAmTgl0IIYQQQggTJgW7EEIIIYQQJkwKdiGEEEIIIUyYFOxCCCGEEEKYMCnYhRBCCCGEMGFSsAuzNHbsWPr372/sMG4TGhrKhAkTjB2GEEKYJY1Go13y8vL0Otbd3V177Pnz5xsoQmGupGAXZmnZsmWsX78egAkTJhAaGmrQ11+4cCG+vr63rd+4cSNvv/22QWMRQgjxpxUrVnDp0iUcHR2163Jzc5k4cSJubm44OjryyCOPcObMmQrHHTt2jPj4eEOHK8yEFOzCLLm4uODq6lrvz1tcXFyn41u0aEGzZs3qKRohhBD6cnFxwcvLC41Go10XGRlJQkICGzZsYNeuXSiKwoABA7hx44Z2n5YtW9KiRQtjhCzMgBTswizdHBKzYMECPvzwQ5KSkrRfZa5evRqAvLw8XnjhBby9vXFwcCA4OJiNGzdqnyMjIwONRkNsbCyPPvoojo6OzJkzB0VRmDhxIn5+ftjb29OuXTvmzJlDUVERAKtXr2bu3LmcPXtW+5oLFiwAbh8SU1JSwksvvYS3tzc2Njbcc889rFu3rkIuGo2GmJgYIiMjcXZ2pnXr1ixevLhh/wGFEKIR2LZtG7a2thQUFABQWFiInZ0dISEh2n1++OEHrKysyMnJ0fkcp06dYtOmTaxcuZKwsDCCg4P57LPepxxUAAAFg0lEQVTPuHDhAp9//rlB8hDCytgBCGFMM2fOJC0tjV9++UVbjLu4uKAoCoMHD0ZRFD7//HPuuusutm3bxogRI9iyZQv9+vXTPsfs2bNZtGgRK1asQKPRoCgKnp6erFu3Dk9PTw4fPkxUVBTW1tZER0cTERHBiRMniI2NZf/+/QA4OTnpjG/OnDl89NFHrFy5kqCgIDZs2MCYMWPw9PSsEEN0dDQLFy5kwYIFbN68mRdeeIHu3bsTFhbWgP96Qghh2vr06YNGo2Hnzp0MHDiQ3bt34+zszE8//UReXh5OTk5s376dbt26Vfnt5u7du7G2tq7Q5rq6utKjRw927drF2LFjDZSNMGdSsAuz5uTkhL29PTY2Nnh5eWnXJyYmsmfPHjIzM3FxcQFg0qRJ7N27l+XLl1douKOiohgzZkyF5124cKH2d19fX86cOUNMTAzR0dHY29vj5OSEpaVlhdesrKCggHfffZd33nmH4cOHA2oBv3//ft54440KMURERDBx4kQAnn/+eWJiYti6dasU7EIIs2Zvb0+vXr1ISEhg4MCBbN++nccff5w9e/awY8cOHn30UbZv3054eHiVz3Hp0iXc3d2xtLSssN7Ly4tLly41dApCAFKwC6HT/v37KS4uxtvbu8L64uJiOnToUGFdjx49bjv+gw8+YNWqVWRkZJCfn09paSnl5eV6xXD69GmKi4t56KGHKqzv27cvb731VoV1Xbt2rfDY29ubzMxMvV5PCCGaovDwcL766isAtm/fzvTp07Gzs2P79u089NBD7N+/n+jo6Fo9963j3IVoSFKwC6FDeXk5Li4u2iErt7Kxsanw+NaZBADWr1/P1KlTWbRoEX379qVZs2asX7+eV155pVaxVH5DUBTltnWVY9JoNHp/QBBCiKYoPDyc6Ohofv31Vw4ePEh4eDi2trYsXLiQfv36YWFhQZ8+fao8vlWrVly9epWysrIKveyZmZn4+/sbIgUhpGAXwsbGhrKysgrrunXrxvXr1yksLKRz5856Pd+OHTsIDg7mxRdf1K7LyMi442tW1r59e2xtbUlKSiIwMLDC89/6WAghRNV69uyJvb09r732Gh06dMDLy4uwsDAiIiJYv349vXr1wt7evsrj+/TpQ0lJCdu3b2fAgAEAXL9+nX379jFu3DhDpSHMnMwSI8ze3XffzYkTJ0hNTeXq1asUFRURHh5O//79GTZsGF988QXp6ekcPHiQ5cuX88EHH1T7fB07duTIkSNs2rSJM2fOsGzZsgqzy9x8zcuXL7Nnzx6uXr2qncHgVg4ODjz//PPMnTuX9evXk5aWxptvvsmmTZuYM2dOvf4bCCFEU2VtbU1ISAhr1qzRjlVv0aIFXbp0Ye3atdWOXwfw9/dnyJAhTJ48maSkJJKTkxk1ahTe3t5EREQYIgUhpGAXYvz48XTv3p0HHngADw8PPvvsMzQaDV999RXDhg3jxRdfJCAggEGDBrF582b8/Pyqfb6oqCgiIyN59tlnCQ4OZt++fdppG28aOnQow4cPZ9CgQXh4eFQ5DeMbb7zBxIkT+dvf/kZgYCCffvopn376aYULToUQQlSvX79+lJaWVijOw8PDb1tXlbVr1xIaGsoTTzzBAw88QHl5OVu3bq22Z16I+qRRFEUxdhBCCCGEEMam0WhYu3btbTN/1VRiYiJhYWGcO3cOHx+feo5OmDMp2IUQQgghUAt2W1tbrKysyMzMvG1Sger4+vqSmZlJYWGhFOyi3slFp0IIIYQQQFpamvZ3BwcHvY794YcftJMJtGrVql7jEkJ62IUQQgghhDBhctGpEEIIIYQQJkwKdiGEEEIIIUyYFOxCCCGEEEKYMCnYhRBCCCGEMGFSsAshhBBCCGHC/h/4cmXS/9a/8wAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_cost_i_w(X_train, y_train, hist)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "On the left, you see that cost is decreasing as it should. On the right, you can see that $w_0$ is still oscillating around the minimum, but it is decreasing each iteration rather than increasing. Note above that `dj_dw[0]` changes sign with each iteration as `w[0]` jumps over the optimal value.\n", + "This alpha value will converge. You can vary the number of iterations to see how it behaves." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### $\\alpha$ = 1e-7\n", + "Let's try a bit smaller value for $\\alpha$ and see what happens." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration Cost w0 w1 w2 w3 b djdw0 djdw1 djdw2 djdw3 djdb \n", + "---------------------|--------|--------|--------|--------|--------|--------|--------|--------|--------|--------|\n", + " 0 4.42313e+04 5.5e-02 1.0e-04 5.2e-05 1.2e-03 3.6e-05 -5.5e+05 -1.0e+03 -5.2e+02 -1.2e+04 -3.6e+02\n", + " 1 2.76461e+04 9.8e-02 1.8e-04 9.2e-05 2.2e-03 6.5e-05 -4.3e+05 -7.9e+02 -4.0e+02 -9.5e+03 -2.8e+02\n", + " 2 1.75102e+04 1.3e-01 2.4e-04 1.2e-04 2.9e-03 8.7e-05 -3.4e+05 -6.1e+02 -3.1e+02 -7.3e+03 -2.2e+02\n", + " 3 1.13157e+04 1.6e-01 2.9e-04 1.5e-04 3.5e-03 1.0e-04 -2.6e+05 -4.8e+02 -2.4e+02 -5.6e+03 -1.8e+02\n", + " 4 7.53002e+03 1.8e-01 3.3e-04 1.7e-04 3.9e-03 1.2e-04 -2.1e+05 -3.7e+02 -1.9e+02 -4.2e+03 -1.4e+02\n", + " 5 5.21639e+03 2.0e-01 3.5e-04 1.8e-04 4.2e-03 1.3e-04 -1.6e+05 -2.9e+02 -1.5e+02 -3.1e+03 -1.1e+02\n", + " 6 3.80242e+03 2.1e-01 3.8e-04 1.9e-04 4.5e-03 1.4e-04 -1.3e+05 -2.2e+02 -1.1e+02 -2.3e+03 -8.6e+01\n", + " 7 2.93826e+03 2.2e-01 3.9e-04 2.0e-04 4.6e-03 1.4e-04 -9.8e+04 -1.7e+02 -8.6e+01 -1.7e+03 -6.8e+01\n", + " 8 2.41013e+03 2.3e-01 4.1e-04 2.1e-04 4.7e-03 1.5e-04 -7.7e+04 -1.3e+02 -6.5e+01 -1.2e+03 -5.4e+01\n", + " 9 2.08734e+03 2.3e-01 4.2e-04 2.1e-04 4.8e-03 1.5e-04 -6.0e+04 -1.0e+02 -4.9e+01 -7.5e+02 -4.3e+01\n", + "w,b found by gradient descent: w: [2.31e-01 4.18e-04 2.12e-04 4.81e-03], b: 0.00\n" + ] + } + ], + "source": [ + "#set alpha to 1e-7\n", + "_,_,hist = run_gradient_descent(X_train, y_train, 10, alpha = 1e-7)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Cost is decreasing throughout the run showing that $\\alpha$ is not too large. " + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_cost_i_w(X_train,y_train,hist)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "On the left, you see that cost is decreasing as it should. On the right you can see that $w_0$ is decreasing without crossing the minimum. Note above that `dj_w0` is negative throughout the run. This solution will also converge, though not quite as quickly as the previous example." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## Feature Scaling \n", + "
\n", + " \n", + "
\n", + "The lectures described the importance of rescaling the dataset so the features have a similar range.\n", + "If you are interested in the details of why this is the case, click on the 'details' header below. If not, the section below will walk through an implementation of how to do feature scaling." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + "\n", + " Details\n", + "\n", + "\n", + "Let's look again at the situation with $\\alpha$ = 9e-7. This is pretty close to the maximum value we can set $\\alpha$ to without diverging. This is a short run showing the first few iterations:\n", + "\n", + "
\n", + " \n", + "
\n", + "\n", + "Above, while cost is being decreased, its clear that $w_0$ is making more rapid progress than the other parameters due to its much larger gradient.\n", + "\n", + "The graphic below shows the result of a very long run with $\\alpha$ = 9e-7. This takes several hours.\n", + "\n", + "
\n", + " \n", + "
\n", + " \n", + "Above, you can see cost decreased slowly after its initial reduction. Notice the difference between `w0` and `w1`,`w2`,`w3` as well as `dj_dw0` and `dj_dw1-3`. `w0` reaches its near final value very quickly and `dj_dw0` has quickly decreased to a small value showing that `w0` is near the final value. The other parameters were reduced much more slowly.\n", + "\n", + "Why is this? Is there something we can improve? See below:\n", + "
\n", + "
\n", + "
\n", + "\n", + "The figure above shows why $w$'s are updated unevenly. \n", + "- $\\alpha$ is shared by all parameter updates ($w$'s and $b$).\n", + "- the common error term is multiplied by the features for the $w$'s. (not $b$).\n", + "- the features vary significantly in magnitude making some features update much faster than others. In this case, $w_0$ is multiplied by 'size(sqft)', which is generally > 1000, while $w_1$ is multiplied by 'number of bedrooms', which is generally 2-4. \n", + " \n", + "The solution is Feature Scaling." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The lectures discussed three different techniques: \n", + "- Feature scaling, essentially dividing each positive feature by its maximum value, or more generally, rescale each feature by both its minimum and maximum values using (x-min)/(max-min). Both ways normalizes features to the range of -1 and 1, where the former method works for positive features which is simple and serves well for the lecture's example, and the latter method works for any features.\n", + "- Mean normalization: $x_i := \\dfrac{x_i - \\mu_i}{max - min} $ \n", + "- Z-score normalization which we will explore below. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### z-score normalization \n", + "After z-score normalization, all features will have a mean of 0 and a standard deviation of 1.\n", + "\n", + "To implement z-score normalization, adjust your input values as shown in this formula:\n", + "$$x^{(i)}_j = \\dfrac{x^{(i)}_j - \\mu_j}{\\sigma_j} \\tag{4}$$ \n", + "where $j$ selects a feature or a column in the $\\mathbf{X}$ matrix. $µ_j$ is the mean of all the values for feature (j) and $\\sigma_j$ is the standard deviation of feature (j).\n", + "$$\n", + "\\begin{align}\n", + "\\mu_j &= \\frac{1}{m} \\sum_{i=0}^{m-1} x^{(i)}_j \\tag{5}\\\\\n", + "\\sigma^2_j &= \\frac{1}{m} \\sum_{i=0}^{m-1} (x^{(i)}_j - \\mu_j)^2 \\tag{6}\n", + "\\end{align}\n", + "$$\n", + "\n", + ">**Implementation Note:** When normalizing the features, it is important\n", + "to store the values used for normalization - the mean value and the standard deviation used for the computations. After learning the parameters\n", + "from the model, we often want to predict the prices of houses we have not\n", + "seen before. Given a new x value (living room area and number of bed-\n", + "rooms), we must first normalize x using the mean and standard deviation\n", + "that we had previously computed from the training set.\n", + "\n", + "**Implementation**" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def zscore_normalize_features(X):\n", + " \"\"\"\n", + " computes X, zcore normalized by column\n", + " \n", + " Args:\n", + " X (ndarray (m,n)) : input data, m examples, n features\n", + " \n", + " Returns:\n", + " X_norm (ndarray (m,n)): input normalized by column\n", + " mu (ndarray (n,)) : mean of each feature\n", + " sigma (ndarray (n,)) : standard deviation of each feature\n", + " \"\"\"\n", + " # find the mean of each column/feature\n", + " mu = np.mean(X, axis=0) # mu will have shape (n,)\n", + " # find the standard deviation of each column/feature\n", + " sigma = np.std(X, axis=0) # sigma will have shape (n,)\n", + " # element-wise, subtract mu for that column from each example, divide by std for that column\n", + " X_norm = (X - mu) / sigma \n", + "\n", + " return (X_norm, mu, sigma)\n", + " \n", + "#check our work\n", + "#from sklearn.preprocessing import scale\n", + "#scale(X_orig, axis=0, with_mean=True, with_std=True, copy=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's look at the steps involved in Z-score normalization. The plot below shows the transformation step by step." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0wAAADOCAYAAAANDYL5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdeVxU1f8/8NcIsg6gAqIiAqKCohJlLoEKipmSG2WaoqCYe2mZmaXpJ63UtOUnn1y/ZtmifcRdKvc1TTPBBARkyxUlF0ABEc7vj2lGZpgZBhhmBng9Hw8eMOfeuffcy73n3vc9y5UIIQSIiIiIiIionAbGzgAREREREZGpYsBERERERESkAQMmIiIiIiIiDRgwERERERERacCAiYiIiIiISAMGTERERERERBowYCKqQQsXLkSbNm00ftanI0eOQCKR4OrVq2o/69vGjRthbm5eI8uuiitXrqBv376wtbWFRCLRON+RI0fQsWNHNGzYEEFBQYbLoAnQ5zFRW/ZjUFAQJkyYYHLLqikrV65Ey5Yt0aBBAyxcuNDY2TFpquWxoco0Uys7iahiDJiIDOjtt9/G6dOndZ6/TZs2Ot/0PPfcc7hx4wZatGhRxdypd/XqVUgkEhw5ckQpfcSIEbh27Zpe11UdH3/8MW7duoW4uDjcuHFD43xTpkzB008/jfT0dGzbtk1v658wYYJJBw76VlP70ZRt27YNn332mbGzodH169cxc+ZMzJ07F9euXcPbb7+NkJAQREZGGjtrtYK+y7TaUnYSUcX4iIPIgKRSKaRSqd6X++jRI1hYWKBZs2Z6X7Ym1tbWsLa2Ntj6KpKamoquXbuibdu2Fc733nvvwc3NzUA5qzz5/9OU6WM/lpaWQggBMzMzPeZM/+T/jyZNmhg7K1qlp6ejtLQUgwcPRvPmzfW+fEMfl4Zen6HKNFMrO4moYqxhItKToqIiTJkyBQ4ODmjcuDGmTJmCoqIipXlUm4BcvXoVL730EpycnGBtbY3WrVvj008/BSBr/pOWlob//Oc/kEgkkEgkyMzMVDSr2rt3LwIDA2FlZYW1a9dqbG51/vx5dO3aFVZWVvD19cX+/fsV0zR9x9zcHBs3bgQAxQ1xcHAwJBIJPDw8AKhvVhIbG4tnnnkGlpaWaNq0KaZOnYoHDx4opkdGRiIkJARr166Fu7s77O3tMWTIENy+fVvrvs3Ly8OkSZPg7OwMKysrdOnSBfv27VNMl0gkOHjwIDZs2ACJRKL2ibp8W0tKSjB27FhIJBLFNl6+fBkvvfQSGjVqhMaNG+P555/HX3/9pfju3bt3ER4ejlatWsHa2hre3t5YsWIFhBAAZP/X//u//8PRo0cV/yv5siUSCb777julvKg+9ffw8MC8efMwdepUODo6IiAgAABw7tw5PP/885BKpXB2dkZYWBiysrIU39N2/Gij7ZioaH9o24+nT59Gr169YG1tjcaNG2PUqFG4deuWYrny43/Lli3w8fGBhYUFkpKSkJ+fjxkzZsDV1RU2Njbw9/evUq1VVlYWXnjhBVhbW6NVq1ZYuXJluXk8PDywePFipTTV2sGgoCBERUVh/vz5aN68OVxdXRXpZZvkyT8vWrQIzZo1Q5MmTRAZGal0zJeWluK9996Ds7MzpFIpRo4ciS+++KLSTbJ0OQZ79uwJAGjVqpXiPDh48CC++eYbxXEpr+3Izs5GZGQknJ2dYWdnh4CAABw7dkyxPk3ljDq67AchBJYvX47WrVvDwsICXl5e+OKLL5SWo+48kOcjNjYWPXr0gLW1NZ555hkkJCQgISEBgYGBsLGxQdeuXZGYmKjz/lJHtUzz8PBQ7LeyP/J9+MMPP6Bbt25wcHCAk5MTQkNDkZKSovi+KZSdRKQngoj0YubMmcLZ2Vns2LFDJCUliVmzZgk7Ozvh5eWlmGfBggVKnwcNGiT69u0rzp8/LzIyMsShQ4fEDz/8IIQQ4p9//hEeHh5i1qxZ4saNG+LGjRvi8ePH4vDhwwKA8Pb2Fjt37hTp6eniypUrivQrV64IIYTic5s2bcTu3btFYmKiGD9+vLCyshJXr15Vmkf+HTkzMzPx9ddfCyGE+PPPPwUAERMTI27cuCFu3bolhBDi66+/FmZmZorvxMfHCzMzMzFz5kyRmJgoYmNjhZubmwgPD1fMExERIezt7cXIkSPFX3/9JU6ePClatWolxo4dq3Xfvvzyy8Ld3V388ssvIjExUbzxxhuiYcOGIikpSQghxI0bN0SPHj3EqFGjxI0bN8S9e/fKLaOoqEjcuHFDABDR0dHixo0b4uHDh+LmzZvCxcVFTJ48WVy4cEFcunRJTJ8+XTRp0kSxrTdu3BBLliwR586dE+np6WLTpk3C1tZWbNiwQQghRF5enhg1apTo0aOH4n/18OFDIYQQAMSmTZuU8tK3b18RERGh+Ozu7i7s7OzEggULRHJyskhISBAJCQnC1tZWfPDBByIpKUlcuHBBvPzyy6Jt27aioKCgwuNHHV2OiYr2h6b9eOPGDWFnZydeffVVceHCBXH8+HHRqVMnERgYqFj/ggULhLW1tejVq5c4deqUSE5OFrm5uSIoKEj07t1bHD9+XKSlpYk1a9aIhg0bigMHDmg9LsoqLS0V/v7+okuXLuL06dPi/PnzIiQkRNjZ2YmoqCilfb1o0SKl70ZFRYnevXsrPvfu3VtIpVIxadIkkZCQIC5cuKBIL7us3r17CwcHBzFz5kyRlJQkfv75Z+Hg4CA++OADxTwrVqwQtra24ttvvxUpKSlixYoVonHjxkrnji50OQZjYmIEAPHnn38qzoOePXuKV155RXFcFhUViYcPH4r27duLsLAwcfbsWZGamioWL14sLCwsRGJiohBCaCxn1NFlP0RHRwsrKyuxZs0akZKSIlatWiUsLS3F+vXrlf43queBPB9PPfWUOHjwoEhISBDdu3cXnTp1Ej179hQHDhwQiYmJIiAgQHTt2lXn/SVE+fJYtUy7deuWYr/duHFDREREiGbNmokbN24IIYTYsGGD2L17t7h8+bL4888/xaBBg0SbNm1EUVGREMI0yk4i0g8GTER6kJ+fLywtLcXatWuV0p955hmtAVPnzp3FggULNC7Xy8ur3HT5DcS3336rNl01YCp7Q1JcXCxatWol3n//fbXfkSsbMF25ckUAEIcPH1aaR/WiHx4eLp599lmleXbs2CEkEonIzMwUQsgu+k5OTqKwsFAxzyeffCKaNWumcR+kpqYKAGLv3r1K6f7+/mLcuHGKz6o3s5qoBjALFiwQ3bp1U5qntLRUtG7dWnz++ecal/PGG2+IkJAQxWfVm25N6xNCfcDUp08fpXkiIiLEiBEjlNIKCwuFtbW12L59uxCi4uNHlS7HhK77Q3W75s2bJ1xdXRU3i0IIERcXJwCIo0ePKpYtkUhEVlaWUp4sLS3LBbnjxo0TQ4YM0Xnb9u/fLwCI5ORkRdqtW7eElZVVlQKmtm3bipKSEqX51AVMnTp1Uppn0qRJonv37orPLVq0EPPmzVOaZ8SIEZUOmNRRPQbVnc+qx5oQsnPX1dVVFBcXK6UHBweLGTNmKC1LtZxRR5f90LJlSzF79myleWbOnCk8PT0Vn9WdB/J8yI95IYT46aefBACxdetWRdq2bdsEAJGXl6cxn6r7q6KAqax169YJGxsbcebMGY3L/+effwQAceLECSGE8ctOItIfNskj0oO0tDQUFRXhueeeU0oPDAzU+r2ZM2fi448/Rrdu3TBnzhylJjEV6dq1q07z9ejRQ/G3ubl5uaYr+pKQkIBevXoppfXu3RtCCKX1tW/fHpaWlorPrq6uyM7O1rhc+XdVl92rVy8kJCRUO99nz57FuXPnFP3LpFIp7OzskJmZidTUVACyZlVLlizBU089BScnJ0ilUqxevVqpeVx1qf4/z549i+3btyvly9HREYWFhYp8VfX40XZM6LI/1ElISED37t2V+pz4+fnBwcFB6f/k4uKCVq1aKW3no0eP4OrqqrTO7777Tuv6VCUmJsLJyQnt2rVTpDk7O8Pb21vnZZT1zDPPoEGDii+RTz31lNLnssdzbm4url+/ju7duyvNU3b/60qfx+DZs2dx8+ZNNGrUSGmfHz9+vNw+17WcqWg/XL16VW35kJmZiYcPH1a4Pj8/P8Xf8r6anTt3LpcmbwKqz/116NAhTJ8+HZs2bcKzzz6rSI+Li8OwYcPg6ekJOzs7xXFd2XXUVNlJRPrDQR+I9ED82y5e23DW6owbNw4vvPACfvnlFxw+fBgDBgzAsGHDyvV5UcfW1rZaeQWguCEsm1ZSUoLS0tIqLVvT9pdNV+3ELZFItPYr0EQIUen9rU5paSn69u2L6OjoctMcHBwAACtWrMAnn3yCzz77DE8//TTs7Ozw+eefY+/evRUuX932FRcXl5tP9f9ZWlqKMWPG4N133y03r6OjI4DqHT9llc2fLvtDE13+/+q208HBAWfPni33vcp0+Nf1eGjQoEGV/h+aqDue5edPVcsFdapzDKoqLS1F+/btsX379nLTbGxslD7rYz+UTStL3XmvaX0NGzYstxx1afJ16mt/paSk4OWXX8aiRYsQFhamSH/48CGef/55BAYGYsOGDYqAzdfXF48eParUOsrmX1u6vspOIqo8BkxEetCmTRtYWFjg5MmT6NChgyL9t99+q/C7zZs3x7hx4zBu3DgMHDgQr776Kr766ivY29vDwsICJSUl1crb6dOnFXl6/Pgxzp49i/DwcABA06ZNAciGI5Z3UI6Li1O6CMsv0hXlw9fXF0ePHlVKkw+CUHafVJavry8A4NixYxg4cKAi/fjx4/D396/ycuW6dOmCjRs3wtXVVePIVceOHcMLL7yAqKgoRZrqk3hN/6umTZvi+vXris9FRUVITEyEp6dnhfm6cOECvLy8tN5wazt+NNF2TOiyP9Tx9fXF119/rTSyWXx8PO7fv6/4H2raznv37qGwsBAdO3bUeX3q1n/79m2kpqYqRkrMyclBSkoKunTpophP9f8ByAbBqIkR8BwcHNCiRQucOnVK6ditzKsF5HQ5BtVRd1x26dIF3377Lezt7RVlQE2yt7dHy5YtcfToUYSGhirSjx07Bk9Pz3JBmj5UdX+VdefOHYSGhuKll17C7NmzlaYlJSXh9u3b+Oijj9C+fXsAsvLelMpOItIfNskj0gNbW1tMnjwZ8+bNw65du5CcnIx33nkHly5d0vq96dOnIzY2FmlpaUhISMC2bdvg5uYGOzs7AICnpydOnjyJv//+Gzk5OVWq+VmyZAliY2ORlJSEKVOmIDs7G1OmTAEgC/Tc3d2xcOFCXLp0CSdOnMCbb76pdIMub86yb98+3Lx5E3fv3lW7ntmzZ+PPP//EW2+9hUuXLuGXX37B66+/jtGjRys1waosLy8vDB8+HFOnTsWvv/6KS5cuYcaMGbh48WK5m5iqmD59OkpKSjB06FAcP34cmZmZOHHiBN5//31FwOvt7Y0jR47g8OHDSElJwbx58/D7778rLcfT0xOXLl1CQkICcnJyFCMkhoSEYPXq1Th16hQuXryIyMhInZ5Av/fee0hKSkJ4eDjOnDmDjIwMHD58GDNmzEB6eroi79qOH020HRO67A9N+zE3NxeRkZG4ePEiTpw4gTFjxiAwMFAxeps6ffr0QUhICMLCwrB9+3akp6fj3LlzWLlyJdatW1fhfpLr27cv/Pz8FPsrLi4Oo0ePLjcaWUhICLZs2YJ9+/YhOTkZb775pl6bVqqaNWsWvvjiC3z//fdITU3FF198gX379lW61kmXY1AdT09PnDt3DmlpacjJyUFxcTFGjx4NT09PhIaGYt++fcjMzMTvv/+OTz75BDt27Kjqpmo1d+5cxf80NTUVa9aswapVq/Dee+/VyPqqur/KCgsLQ6NGjbBgwQLcvHlT8fPo0SO4u7vD0tISK1euRFpaGg4ePIgZM2aYVNlJRPrDgIlIT5YsWYKhQ4dizJgx6Nq1K+7du4dp06Zp/Y4QAjNnzkTHjh3Rq1cvPHjwAD///LPiovuf//wH9+/fh7e3N5ydnfH3339XOl/Lly/H/Pnz8dRTT+HkyZPYuXMnWrZsCUDWf2XLli24desW/P39MW3aNHz00UdKfTcaNGiA//73v/jpp5/g5uamsVanc+fO2LVrF44ePQo/Pz+MGTMGoaGhWL16daXzrGr9+vXo378/wsPD4efnh5MnT2LPnj3w8fGp9rJdXFxw6tQpODk5ISwsDN7e3hg9ejSysrIU77KZP38+evfujSFDhqBHjx64e/cu3njjDaXlREVF4dlnn8Vzzz0HZ2dn/PjjjwBk+79jx47o378/BgwYgF69ein1g9Ckffv2+O2335Cfn4/+/fujQ4cOeO2111BQUIBGjRoBqPj40UTbMaHL/tC0H/ft24erV6/i2WefxYsvvoiOHTsiJiZGa14kEgl27dqFsLAwvPXWW/Dx8UFoaCj27t0LLy8vxXxBQUFaXwwskUiwY8cOODg4oFevXnjxxRcxcOBAPP3000rzzZkzB6GhoRgxYgR69uwJBwcHDB8+XGseq2PmzJmYPn06ZsyYAX9/f5w+fRqzZs2ClZWVYp7MzEyl4dnV0eUYVGfWrFlwcnKCn58fnJ2dcfLkSVhZWeHo0aPo0qULxo0bh3bt2iEsLAxnzpyBu7u7Pja7nClTpuDDDz/Exx9/jA4dOmDp0qVYsmSJUg2QPlV1f5V19OhR/PHHH3Bzc0Pz5s0VP7/99hucnJzw3XffYf/+/fD19cXbb7+N5cuXm1zZSUT6IRFsAEtERCbO3d0dkydPxty5c42dlWobP3484uPjce7cOQCyQQVCQ0ORkJCA1q1bGzl3RESkin2YiIjIpF24cAGWlpaYNWuWsbNSadevX8f27dsRHBwMMzMz7N69G99++63SoBp79uzBnDlzGCwREZko1jARERHVkOzsbIwYMQIXLlxAYWEh2rRpg9dffx2vvfaasbNGREQ6YsBERERERESkAQd9ICIiIiIi0oABExERERERkQYMmIiIiIiIiDRgwERERERERKQBAyYiIiIiIiINGDARERERERFpwICJ6q3MzExIJBJs3LhRkbZx40ZIJBJkZmYaPD+RkZHw8PAw+HqJiIio/uL9UMUYMBERUa0zdepUNGjQAEePHi03LTExEZaWlhgyZIgRckZUe0kkkgp/TO1GlsgQzI2dASJTMmbMGIwcORKWlpbGzgoRabF06VLs2bMHr732GuLj42FtbQ0AKC0tRVRUFKytrbFq1Soj55Kodtm0aZPGadu3b8e2bdvw3HPPGTBHZCy8H1LGgIlMwsOHD2FjY2PsbMDMzAxmZmbGzgYRVcDOzg6rV69GaGgoFixYgGXLlgEAvvzyS5w+fRpr165FixYtjJxLotolPDxcbXpCQgImTZqEtm3bYvXq1QbOVdU9evSo1l3XeT9kmtgkr45YuHAhJBJJuXTVdqnyNqm//vorFi9eDDc3N1hZWSEgIADx8fFK363MvABw7do1REZGwsXFBZaWlujQoQM+//xzCCGU5gsKCkLLli2RnJyMgQMHwt7eHgMHDlSalpGRgRdffBF2dnZwcXHB/PnzIYTAP//8gzFjxqBJkyawt7dHVFQUCgsLlZa/a9cuDB06FG5ubrC0tESzZs0QGRmJmzdvVrgfVdvsHjlyRGvThLJte2/fvo1p06bBzc0NFhYW8PDwwNy5c1FUVFRuPZ9//jlat24NKysr+Pv7Y8+ePRXmjYiUDRw4EKNGjcJnn32Gc+fOIT09HfPmzUNwcDAmTJhQI+vs3r07evToUS595cqVkEgkyMrKqpH1EhlLXl4eXnrpJQghsHXrVtjb21f4nfT0dIwaNQqurq6wtLREixYtEBoaWu7eISsrC+PHj1fM5+bmhtGjR+PatWuKeYQQ+Pzzz9GhQwdYWlrCxcUFkZGRuH79utKy5Nfv2NhYzJ07Fy1btoSVlRWuXLkCoHLXaFW8H+L9EGuY6ql58+ZBIpHgrbfeQkFBAZYvX46hQ4ciNTUV5ubmlZ73n3/+wXPPPYebN29i2rRpaN26Nfbs2YO33noLaWlpiI6OVlrmw4cPERISgv79+2P58uVKTzEKCgoQEhKC559/HsuWLcP27duxePFiSKVSbNmyBe3bt8dHH32Eo0ePYsOGDXBxccHHH3+s+P6GDRvw+PFjTJ48GU2bNsWlS5ewbt06/P7774iLi6tU9XL79u3LNVEoKSnB7NmzkZ+fDzs7O8X2d+/eHXl5eZg4cSJatWqFc+fO4dNPP8Vff/2lVAB89NFHmDdvHnr27ImZM2fi2rVrGDVqFNzd3XXOFxHJfPnll9i/fz+ioqLg6OgIIQTWrVun9gFSdQkhcPHiRYwdO7bctLi4ODRq1IjnMdU5EyZMQHJyMjZs2IDOnTtXOH9xcTGef/555OfnY8qUKXBzc0N2djaOHTuGpKQk+Pn5AQCSk5MREBCAhw8f4rXXXkOHDh1w69Yt7N27F5cvX4arqysA4PXXX8d///tf9OvXD1OnTkVmZiaio6Nx+PBh/Pnnn3B0dFRa/zvvvAMbGxu8/fbbKC4uhlQqrdQ1WhveD9Xj+yFBdcKCBQuEun9nRkaGACC+/vprIYQQX3/9tQAgunTpIoqLixXzxcTECABi7969irTKzDt79mwBQGzdulWRVlpaKoYNGyYAiAsXLijSe/fuLQCITz75pFx+5dO++OILRdqjR49E8+bNhUQiEW+99ZbS/F26dBFNmjRRSsvPzy+33CNHjggA4scff9S4b8puc0ZGRrllyL3++usCgNi8ebMibcqUKaJx48bi77//Vpr3yy+/FADE/v37hRBC5OTkCEtLS/Hcc88p7dPY2FgBQLi7u2tcLxGp98MPPwgAAoD49NNPa2w9KSkpAoBYu3ZtuWn+/v6id+/eNbZuImP44osvBAAxfvx4nb8TFxcnAIiffvpJ63x9+/YVDRs2FOfPny83rbS0VAghxMWLFwUAMXjwYEWaEELs2LFDABCzZs1SpMmv3507dxZFRUVKy9P1Gq0J74fUq0/3Q2ySV0+99tprSjVJwcHBAIC0tLQqzbtr1y60adMGL730kiJNIpFg9uzZAIDdu3eXW+6UKVPU5q1BgwaYNGmS4nPDhg3RtWtXCCEwefJkpXkDAgJw584d3L17V5Fma2sLQPY0ODc3Fzk5OfD19UWjRo1w9uxZtevU1bp167By5UrMmzcPI0aMUKxny5YteP7552FtbY2cnBzFT79+/QAABw8eBADs378fRUVFmD59utI+HTBgANq3b1+tvBHVV05OToq/BwwYUGPruXDhAgDA399fKb24uBgJCQmKJ+dEdcGpU6cwe/Zs+Pn54b///a/O33NwcAAA/PLLL8jPz1c7T05ODg4dOoQRI0bgqaeeKjddXkMsv3eYPXu2Uq3xkCFD4O3tjV27dpX7blRUFCwsLBSfK3ONrgjvh56ob/dDDJjqKdXqzsaNGwMA7ty5U6V5MzMz4ePjU+67HTp0AABkZGQopTdp0kRRqKpq2rQprKyslNIaNWoEAGjVqpXa9LJ5SUlJQVhYGOzt7eHg4ABnZ2c4Ozvj3r17SgVJZR09ehTTpk3D0KFD8eGHHyrSb9++jTt37mDLli2Kdcl/5Nt/69YtAFC08fX29i63fHVpRKTdgwcPMHHiRHh4eMDOzg6TJ08u109AnZKSEty8eVPpp6CgQOt34uPjYW5ujo4dOyqlJyYm4tGjR2pv/Ihqo5ycHLzyyiuwtrbG1q1by12TAeD+/ftK58/t27cBAB4eHpg1axY2bNgAJycn9OnTB0uWLFH0JQJkAYYQosImfvJrprob6Pbt26t9R5Cnp6fS58pcoyvC+yGZ+ng/xD5MdYSm9volJSVq0zWNfKLuRkPXebX1GVCdJh8CuDJ50yUveXl56N27Nxo2bIgFCxagbdu2sLGxgUQiwciRI1FaWqpx2dpkZGTg5Zdfho+PDzZt2qS0PfJlDhs2DFOnTlX7ffloXfJ81kT/CqL66L333kNmZiYOHjyIxMREvP7661i9erXGJ7ZyV65cKXdj9fXXXyMyMlLjdy5cuAAfH59yNzB//vknALCGieqE0tJSjBo1ClevXkVMTAzatGmjdr4ZM2bgm2++UXx2d3dX3AQvX74cEyZMwO7du3HgwAEsXLgQixYtwrZt29C/f3/Fd3S9FqqbT9ODEdX7i8pcoyvC+6H6ez/EgKmOkD/luHv3ruJvQDZSjSF4eHggKSmpXLo8zVAvujt06BBu3ryJw4cPIygoSJFeUFBQ5acpeXl5GDRoECQSCXbt2gWpVKo03dnZGfb29igsLERISIjWZclv0C5dulSuWU9ycnKV8kdUX506dQrR0dGIiopCnz59EBQUhB9++AHvvvsuBg8erOg0rk6zZs2wf/9+pTRfX1+t64uPj0eXLl3Kpf/6668wNzev8PtEtcHChQuxf/9+vPnmmwgLC9M43zvvvKM0DLnqjb+Pjw98fHwwe/ZsXLlyBf7+/vjPf/6D/v37o02bNpBIJIpmrprI7x0SExMRGBioNO3SpUs63VtU5hqtD7wfqpv3Q2ySV0e0bdsWgOwEkRNC4MsvvzTI+gcNGoTLly9j+/btSutfvny5YrohyJ+4qD45WbZsWZWepsiftKWkpCAmJkZtQWdmZoZXXnkFv/76K06cOFFuemFhIfLy8gAA/fr1g6WlJaKjo/H48WPFPD///LPaApaI1Hv06BEmTJiApk2bKsqZBg0aYN26dSgsLNT4dFPOysoKISEhSj/NmzfXOH9ubi4yMzPLDWX8xx9/YNu2bfD29uYLHqnW+/nnn7F48WI899xzWLp0qdZ5O3TooHT+BAQEAJCdK2WvbwDg5uYGZ2dnRXMxR0dH9OnTB5s3b1YbNMlrH+T3DitWrFCqxdm9ezeSk5N1ureozDVaH3g/VDfvh1jDVEf069cPXl5emDBhApKSkuDg4ICYmBg8fPjQIOt/99138dNPP+HVV19VDKO5d+9e/Pzzz5g2bRo6depkkHwEBATA2dkZY8aMweuvvw57e3scOnQIZ0mmTpkAACAASURBVM+eLTf0qC5Wr16NPXv2YODAgcjKyir3jpVhw4bB1tYWS5YswbFjx9CnTx9ERkbC398fhYWFSE5Oxv/+9z/ExMQgKCgIjo6OeO+997BgwQL06dMHw4cPx7Vr1/DVV1+hY8eOei20ieqyRYsWITExETExMYq2+4Cslujdd9/Fhx9+iP/9738YPny4XtYnv6mLi4vD6NGj0b17d1y+fBk//vgjJBIJ7t69i2+++QYRERF6WR+Rod24cUNRYzRo0CBs2bJF47yaXnALyB7cTpkyBS+//DK8vb1hbm6OPXv24NKlS0r9XVauXImAgAD06NFDMax4Tk4OYmNj8dFHH6F3797w9fXF1KlT8dVXX+GFF17AoEGDkJWVhejoaLRq1QrvvfeeTtum6zVaH3g/VEfvhww5JB/VrL/++kv07t1bWFpaCmdnZ/HGG2+IhIQEtcOKqxtCE4BYsGCB4nNl5hVCiKtXr4qxY8cKJycnYWFhIXx8fMSKFSuUhgIVQjZUpqurq9pt0DQtIiJCAFAaelKIJ8Opp6amKtLOnTsngoODhZ2dnWjUqJEYNmyYSE9PF+7u7iIiIkIxny7DaMqXr+mn7HCbd+/eFbNnzxZt2rQRFhYWwtHRUTz77LNi4cKF4p9//lHK9/Lly4W7u7uwtLQUfn5+Yvfu3SIiIsLkhtEkMkXx8fGiYcOGYtiwYWqnFxYWivbt2wsXFxdx584dvawzOjpaABA7d+4UnTp1EhYWFuKpp54Shw8fFuHh4UIqlYrFixfrZV1ExnD48GGt17uyP9qkp6eLCRMmiLZt2wobGxthb28vunTpItavX1/ufuDy5csiPDxcNG3aVFhYWAg3NzcRHh4url27ppinpKRErFixQvj4+AgLCwvh7Owsxo4dK65evaq0LG33LEJU7hqtivdDvB+SCKHDcEJERET12KRJk7B161b8888/xs4KEREZGPswERERVSA+Pp6DOhAR1VMMmIiIiLQQQuDixYvl3r9ERET1AwMmIiIiLS5fvowHDx4wYCIiqqfqZR+m+/fvGzsLRPWSpreZ13YsU4iMh+UKEembarnCGiYiIiIiIiINGDARERERERFpUO9fXFtXq/KJTEV9a1bCMoWo5rFcISJ901ausIaJiIiIiIhIAwZMREREREREGjBgIiIiIiIi0oABExERERERkQYMmIiIiIiIiDRgwERERERERKQBAyYiIiIiIiINGDARERERERFpwICJiIiIiIhIAwZMREREREREGjBgIiIiIiIi0oABExERERERkQYMmIioXggKCoKVlRWkUimkUim8vb0V0w4ePAgfHx/Y2NggODgYWVlZimlCCMyZMweOjo5wdHTEO++8AyGEMTaBiIgMLCMXCD8ABO+U/c7INXaOyBgYMBFRvREdHY38/Hzk5+cjOTkZAJCTk4OwsDAsWrQId+7cQZcuXTBixAjFd9auXYsdO3YgPj4eFy5cwJ49e7BmzRpjbQIRERlIRi7QbzfwfSpw5Lrsd7/dDJrqIwZMRFSvbdu2Db6+vhg+fDisrKywcOFCxMfH49KlSwCAb775BrNmzULLli3h6uqKWbNmYePGjcbNNBER1bj5Z4A0leAoLVeWTvULAyYiqjfmzp0LJycnBAQE4MiRIwCAhIQE+Pn5KeaxtbWFl5cXEhIS1E738/NTTCMiorrr2gP16dc1pFPdZZIBE/saEJG+LV26FOnp6bh27RomTpyIQYMGIS0tDfn5+XBwcFCa18HBAXl5eQBQbrqDgwPy8/NZthAR1XGuturTW2hIp7rLJAMmgH0NiEi/unXrBjs7O1haWiIiIgIBAQGIjY2FVCpFbq5ym4vc3FzY2dkBQLnpubm5kEqlkEgkBs0/EREZ1qKugJe9cpqXvSyd6heTDZjUYV8DItIXiUQCIQR8fX0RHx+vSH/w4AHS0tLg6+sLAOWmx8fHK6YREZF+bE4FpOsA89Wy35tTjZ0jwNMe2D8IGN0WCG4h+71/kCyd6heTDZjY14CI9OXevXv49ddfUVhYiMePH+P777/HsWPH0L9/fwwbNgwXL15ETEwMCgsL8eGHH6Jz587w8fEBAIwdOxafffYZrl27huvXr2PFihWIjIw07gYREdUhm1OBVw8ADx4DJUL2+9UDsnRjD+vtaQ98FwIcGiL7zWCpfjI3dgbUWbp0KTp06AALCwts3rwZgwYNQlxcHPLz8+Hs7Kw0r659Ddh8hqj+Ki4uxrx583Dp0iWYmZnBx8cHO3bsUPSPjImJwfTp0xEeHo5u3bph8+bNiu9OmjQJ6enp6NSpEwBgwoQJmDRpklG2g4ioLppwRH36uEOAq1R5pLrT2azlIcMzyYCpW7duir8jIiLw448/sq8BEVWZs7Mzzp49q3F6SEiIommvKolEgmXLlmHZsmU1lT0ionqtsER9elGp5mG9vwup+XwRyZlsk7yy2NeAiIiIqG6yMlOfrmksUg7rTYZmcgET+xoQERER1R/rgyo3P4f1JkMzuSZ57GtAREREVH+MbAt8eAZIUjOgg7UZUFCmyR6H9SZjkIh6+PbF+/fvK/5WfWElEelXfTjf6sM2EpmS+nDO1YdtLCv8APC9mqHEh7gDUgtZM7wWtrJgiQM+UE3Qds6ZXJM8IiIiorqsqKgIUVFRcHd3h52dHfz9/fHzzz8bO1tGpeklsZ8HclhvMj6Ta5JHREREVJc9fvwYbm5uOHr0KFq1aoXY2Fi88sor+Ouvv+Dh4WHs7BmF/CWx88+wNolMDwMmIiIiIgOytbXFwoULFZ9ffPFFeHp64ty5c/U2YAKevCSWyNQwYCIiIiIyouzsbKSkpPBVKFTrZfz7nqxrDwDXOlRLyICJiIiIyEiKi4sxevRoREREKF6TQlQbZeQC/XYrv2z4dLasqWVtD5o46AMRERGREZSWlmLMmDGwsLBAdHS0sbNDVC3zzygHS4Ds8/wzxsmPPrGGiYiIiMjAhBCIiopCdnY2YmNj0bBhQ2NniVTU1eZlNeXaA/Xp1zWk1yYMmIiIiIgMbMqUKUhKSsKBAwdgbW1t7OyQirrcvKymuNqqT2+hIb02YZM8IiIiIgPKysrCmjVrEBcXh2bNmkEqlUIqleL77783dtboX3W5eVlN0fQurUVdjZMffWINExEREZEBubu7Qwhh7GzoXUYu8OYJ4NQt2efuLsAXAbWzRqYuNy+rKXX5XVoMmIiIiIioWjJygd47gCtlAopdmUBcDnBkSO27aa7LzctqUl19lxab5BERERFRtcw/oxwsyf2dXzubsdXl5mVUeaxhIiIiIqJq0dSEDaidzdjqcvMyqjwGTERERERULZqasAG1txlbXW1eRpXHJnlEREREVC2LugJuagKjVlL9NGPLyAXCDwDBO2W/M3Ir/g6RvrCGiYiIiIiqxdMeODpUNkre6X9HyeumYZS8yr4Qlu9EImNjwERERERE1eZpD+wYqH2eqgQ/2t6JxCZzZAhskkdEREREBlGVF8LynUhkbAyYiIiIiMggqhL88J1IZGwMmIiIiIjIIKoS/PCdSGRslQqYvv76a/j7+8Pe3h4ZGRkAgE8//RQxMTE1kjkiIiIiqjuqEvzI34k0ui0Q3EL2mwM+kCHpHDCtXbsWs2bNQlhYGIqLiyGEAAA4OTkhOjq6xjJIRERERLWPuqHAqxr8yN+JdGiI7DeDJTIknUfJW7lyJdasWYPhw4dj2bJlivRnnnkGc+bMqZHMEREREVHtU9FoeGVHt5MHVroOM05kaDoHTJcvX0bXruXrS21tbZGby7eHVcbmVGDCEaCwBLAyA9YHASPbKs9T2XcUmLK6tC1Epqo+lSt1ZTuI6jJdhwJXF1jFpAP9WwKfByqf2xWd+ywbqKboHDA1b94cly9fhru7u1L6qVOn0Lp1a71nrK7anAq8euDJ5wePZZ//3wXg+36yE7suvaCtLm0LPcGLkmmpT+VKXdkOKo/lSt2i62h46gKrwhJgZxZw8e6Tc/vYdSB0L5D/+Ml8Zc99lg1Uk3TuwzR27FjMmjULKSkpkEgkKCgoQGxsLObMmYPx48fXZB6NIiMXGBoLuGyU/Qz5WZZWXROOqE8/dUt2ossvGOqeynTf9qQNcG2QkQv02VX59y2QaZNflL5PBY5cl/2WH7ukmbzJSfetgOd3QI8Y/Z3P9alcefMEy5S6iOVK3aPraHhp9zUvQ15GDY0FBqgES/Lp8nO/Ku93klPX14qoLJ1rmObPn4/MzEy0b98eQgh07twZADBu3DjMmjWrxjJoDBm5QO8dwJUyT0F2ZQJxOcCmvsDaRO1PwDQ9JTt2XfbkV5O0XNnNwKlb6qffKpBdRLalAZ0dgTaNKn4CZ6wndvKLX2ae+ul82VztxTeuV566J5+ZecDpW7InoBuCq1auALIyo6Jypc8u4G6R+unycuV/l4EBrco3gdG0PcYqV369qn4ay5TajeVK3bOoq6x8K/t/VR0NLyMXuHBH+3JuFchqmzSRn/tVfbkta6ZIFzoHTGZmZti4cSMWLFiAc+fOobS0FM888wy8vLxqMn9GMf+McrAk93c+MGAP8LDkSdrODKBjE8DLAZjYAVh0Djh0FSiF8jwulkCaDhf0X64CRSXa5ykoBX6/LfvRdlKrKwTK5ldeaFXlxqeiGyZ1F7+y7CzYwbO24hvXK0/b+ZCWW7VyZUsqUAJA6LB+TQ8uynokyjeBUaeicmVih4qDP010KVcKNZSPLWzZpKs2Y7lS98hHw5t/RvZ/bKHmnJx5Enio5YGPLuQ1VppqtDLynozOpw6DddKFzgGTnKenJzw9PWsiLyZDU8ENKN/UALLq4dO3ZD+bLwMlau5e8h+Xr0bWpKJgSZW2k1pdIVA2v4euAuYNlINDXZ6qaHsaI1/vHi1Pg5pbA+dvV369cseuAxGHZE/MG1sC3/QBerWo+HukH/Xxjet37txBVFQU9u3bBycnJ3zyyScYNWqUzt/XVqYAVStXqnmPoVFFNwoVlSs/pioHdrqe25rKlbK1b4l31X+3gQR40b16T4lZrhhXfSxX6qrKPLg4nV29dUnNnzz8VVejBcgeGPXbrbksYLBOutA5YJo4caLadIlEAisrK7Rr1w6vvPIKnJ2d9ZY5Y9FUcFdE3U2NIWg6qSu6SbtRUD5N081S2QIwM6/8E+u0XNmTooQ72muWAOB+cfknSro+zTl2Hei7C3j8776+/0j2eVNfWZDGJ8s1T5dmFnXNtGnTYGFhgezsbMTFxSE0NBR+fn7w9fXV6ftVLVMA45Qr2m4UKipXSlU+61KmuNoCecXqn/KqdvJWu04BvHZEc/8Gliumrz6WK3WRvpq3SVBx7bnUHNgb+mS58hqtPrvU36N03wb0a1n+PK5ssM6a7PpJIuRvoK1AcHAwzp8/j+LiYnh7ewMAUlJS0LBhQ7Rr1w7Jyclo0KABTpw4gQ4dOtRopqvr/v0nPQwdHBzKTVfXh8mUDfl34MJTt4DHpYC5RHaTlV8MFKnevejAvqGs2UtxqazAsmkAFImKb9wsG1RtfXLBLWQvpANk/4OJh4Hj2cDjEsDCDPBpBKTcV99fw1zy5GYHkF1oDd3+WNdCtC4UtvJt0NTMoqyKzjdT9+DBAzRu3BgXL15Eu3btAABjxoyBq6srlixZAkC3MkX1JsKUjW4ra1onr3GRmgPudsDlXOB+UeXPc0dLwMMOOJ9TPqCqaWXLlWPXgdEHgOyHss9NrABPO+CvO7W7XKkLZQpQv8oVXdTGbQw/IOsTqWqwB2DXsPwxOjRWff+kkBZARr5ymelmC/g7A3mPtB8fwTtlA4doonoeqyufNZ3rlZmXah9t55zONUzDhw+HjY0NvvvuOzRu3BgAcPfuXYwdOxYDBw7EmDFj8Morr+Dtt99GbGysnrJeedVtOgPIDvqjQwHv74HiGsqnvrjZAmduqa8tqqpclY1+qOMdTnWCJeDJ05xj14Hnd8mCNLmCEuD8P5q/+1glmDN0+2Ndn6rVlc6lqi8drMtSUlJgZmamCJYAwM/PD0ePHtV5GWXb8m/+t++RqfKylzVvU61xufaw6sv8p0j2YwzycmVzKjDqgPJT6+wC2Y8mtaFcqStlClC/ypW6SlMN9L4ryv0P5cfo54HAnznKD6jdbIG1wbK/dQ2gy6qoRl/1PNalr5Uc+zvVXzoPK75s2TJ88sknimAJABo3bozFixdjyZIlkEqligEhjKls05nvv/8eU6ZMQUJCQqWX42kPDPCo3HfMJJVeTbU0tZQ9bdFnsGQs5hJZAZXxbxOcIj00QzJk+2NdhzOtzrCnZBz5+fnlnjQ5ODggL0+HkRTKkN8MhnpUbv2GLlcWdwXm/l4+WKiNypYrYw7qNkBGRUytXGGZQqZEU7CiOliLfPROQPaAeog74GINNLWW3dcAsjJzUVdZAHPtgeyY1mW470VdZQ9+tFE9j+Xl86Ehst+aAjP2d6q/dA6YsrOzUVxcvr6luLgYt2/fBgC4uLjgwQPjHTUPHjxATEwMFi1aBKlUisDAQAwePBibNm2q0vK+CABaSSuez9pMdrIfGiyrdnaxlv0McQd+DJE1Z6ksK7OK58l9DOQ+qvyyTZG1mayAmn9G9wEy5DTdTxqys7CuhSgL29pHKpUiN1f5Kp2bmws7O7sqLa+65UpfV9lPVTTUIfia+7vmIchrm7LlSmUDwNpSrrBMIVOiLljRdD8jH4zhSr5sdM7sAtkQ4rsyZenHrgNBO5XfzRW0s+KgSV5jNLqtrMxUp6rnMQcnqb90Dph69uyJ6dOnIyMjQ5GWnp6OGTNmoGfPngCApKQkuLu76z+XOtLUdKYqNUyA7KQ7MkT7SedhBySMBHYMlI2otHMAcDNS9rNjIDCyLXBhBGBbyaDppdayZWtTUlq9zuQ1qbIPxR3/3b8VdSiXszUHGlnI9tEPIeULaEN3Fta1EGVhW/u0a9cOjx8/Rmrqk4b58fHxOg/4oEpermg6v12sZWWOpnLlwGDZT1XO/VfaVFxjde/fUeJMkc4XrH/Vh3KFZQqZkrLBSnAL2e/+LTXPn6ahf2darqwJ7d/5yul/58sGmNIlH9+FAKfC9HseqwsIOThJ/aDz9Wft2rUoKChAmzZt4OLigmbNmqFt27Z4+PAh1q5dCwB4/PgxPvjggxrLbEX01XSmrIpOukODK25T62kPxIbKmoeUZQb1ncjkJ983fbQvt6mNbD63Ci6MLWyAxg21z6NvfVzLb68EwLyny6ebS55sqy43gV72wF8jgLtRQEa4LChVLaAN3X5f10KUhW3tY2tri7CwMHzwwQd48OABTp48iZ07d2LMmDFVXqbnv2WHumPhVJj2JiFyP4SoP5eebgxYqAmK5MfZih7al9vo3yG1VZetyhjlSjDLlXLlBcsUMjWqzds+D9TeRO6Rhv7PtzT0m/y9EkORqwvgqnMe63t5VHvoPEqe3IEDB5CYmAgA6NChA0JCTKeX2/nz5xEQEICHD5+cZStWrMCRI0ewe/duRVpVR56pzAg+6sjf83Gv6MlNSa8W2pd77DowcBfwQOW/ZC4BDg5+8v03T8jegfK4VPYEueTfebq5yJoAAcDo/cDvt56MUmUGQNoQsDSTjYBn3gDwkgLn/ik/gENTK8DRAvj7oWz5DSSy5oDqyjn5iDFX8tVvr6b9IN/H6p42WZkB7RsBHZqY7ghQuh4f1T2OapvaONKTqjt37mD8+PHYv38/HB0dsWTJEqXBZEytTKlo2V/GAzN/K7+8suVK2WXb/jtKnvy81FauNPh3OdbmshdUt7SRlTPHbpa/MZKaycqqhg1k8zYyA5LyZMOEq6qJcsXJEmjT6EmAYYrnoS7HSH0rU4C6Ua5UpK5sY8a/rx359Url3jVpaaZ+fhdrWW27IdWVkShJO23nXKUCprt37+KXX35BVlYWHj1S7jxjzJolOfnwvwkJCWjbti0AYOzYsWjRooVi+F+gdhZC2m4G9K2yF199X6zr48W/LquN51tl1dZtZLlS9eWRcdXWc64y6sI2VvWVCl72gKcUOKBmePAh7rLmyobCocTrD70ETGfPnsULL7wAIQRyc3Ph7OyMW7duwcbGBs2bN0dKSop+c11FI0eOhEQiwfr16xEXF4eBAwfit99+U+pvUBcKIaLaoj6cb/VhG4lMSX045+rCNmp6L5MmLtZASMsnTUpV34npZisbVc+QgYqmbRjdlkOJ1zXazjmd+zDNnj0bL730EnJycmBtbY2TJ08iKysL/v7+WLp0qf5yW01fffUVCgoK0LRpU7z66qtYtWpVlTtnExEREVHV6DrgClC+D6f8nZhl+wsZOlgCqjYS5bHrgOd3QKP/k/0+puVFulQ76Dx2W1xcHFatWoUGDRqgQYMGePToEVq3bo2lS5di/PjxGDZsWE3mU2dNmjTBjh07jJ0NIiIionpN04ArHnZAMxvg5kPZyJT3Hsn6FM4/o9xc1hReZlzZkSiPXS//4u++u570D6XaSecaJjMzM1hYWAAAmjZtiitXrgAAnJyckJWVVTO5IyIiIqJaSdMojocGy2qTDg0G7hTJ3sn0+23d37VUkYxcWVO64J2y39VZXmVHoow4VP69b4+FLJ1qL51rmDp37oy4uDh4eXmhe/fu+Pjjj1FaWop169bB29u7JvNIRERERLWMfBhuTQOuzDyp+V1LOwdUbZ3qBmk4nV25QRpUR8XbEAysTdRt0BhNL/6+V0deCF5f6Rwwvf/++8jPlx3VixYtQmhoKAYMGABnZ2ds3bq1xjJIRERERLWTtmZ1pzW8U6ky71pSNf+M+hfhzj+jW/O+6gZcjS1lzfBUNTLRF4KTbnRukhcSEoKhQ4cCADw8PJCQkICcnBzcvHkTPXv2rLEMEhEREdU1d+7cwbBhw2Brawt3d3f88MMPxs6SXuizOVxVVGWQhrK0BVy6UPfi77Iv0qbaSecaJnWaNGmir3wQERER1RvTpk2DhYUFsrOzERcXh9DQUPj5+dXqkX0rWzvToymwU003+O5Nq56Hyg7SoKq6AVevFrIBHgz1jjsyDJ1rmIiIiIio+h48eICYmBgsWrQIUqkUgYGBGDx4MDZt2mTsrFVLZWtnPg+UvVupLBszILug6rVTlR2kQVV1Ay5AFhxlhAN3o2S/GSzVfgyYiIiIiAwoJSUFZmZmaNeunSLNz88PCQkJRsxV9VW2dqbsu5a6OwNSc+BhCXD6lmzEvH67Kx80yQeaKPv+psoM+FDdgIvqpmo1ySMiIiKiysnPz4eDg4NSmoODA/Ly8oyUI/2oSu2MfFCI8APA6dvK0yozWIO6ZVZFRSP7Uf3EgImIiIjIgKRSKXJzlatOcnNzYWdnZ6Qc6ceirrI+S2Wb5elaO5N2X0O6gQeNAEzjhblkWtgkj4iIiMiA2rVrh8ePHyM1NVWRFh8fX6sHfACq1xzuZoGG9If6zSNRVbCGiYiIiMiAbG1tERYWhg8++ADr169HXFwcdu7cid9++83YWau2qtbOuFgBmWpaJDazqn6eiKqLNUxEREREBvbVV1+hoKAATZs2xauvvopVq1bV+hqm6mjTSH26l4Z0IkNiDRMRERGRgTVp0gQ7duwwdjZMRnX6P1VVxr+DSlx7IBuwgoM7kCYMmIiIiIjIqDztgQ3Byi983RBccwGMri/ZZVBFAJvkEREREZGRZeQC4w/L+jHdeyT7Pf5w1V5eqwtdXrIrD6q+TwWOXK/6u6EycmXDpgfvrPoLecm4WMNEREREREZx7LqsVulaPlAslKdV9T1MQMU1Q7q8ZFdbUKVrnnStySLTxoCJiIiIiAzu2HWg7y7gsdA8z3UNgY026oKUnRnA3lCgVwvZZ11esnv5XvXzpI+gi4yPTfKIiIiIyOAiDmkPlgDlAEZX6oKU/MdA6N4nzeEWdZUNKlFWKymQ/0jWdG5oLPDX3ernSZeaLDJ9rGEiIiIiIoO7W6R9elVHyUu7rz49//GTmh35S3bnn5EFL3YWwPnbwM4s7cuWmmvOk7pmgLrUZOkTB6moGQyYiIiIiMjgGlsC9x+VT7cyA15qrXyzry0QKDvNoaEs8NFEXrNT9jv2FsC5W8C1hxXn2dJMNhiFujyo66u0Idhww6Wzv1TNYcBERERERAb3TZ/yfZjMJcCvLz7pawRoDwSA8tO0aWGrfnm6+qdINmJe2Tx42mvuq7Q2Ubkmq0UN1vqwv1TNYcBERERERAbXqwVwcLDyu5e+6aMcLAHAzJPahwDXNfDxsgcmdgD67JINW15dZYMRbX2VPO0NE7Cwv1TNYcBERERERHqla1+aXi2AjHDty/n1b/XTrj8AKhgzQsmG4CfvetKX6w9kedS0zJrqq6SOoftL1ScMmIiIiIhIb6rbl6ZssJV6HygqVT9fC1vZqHa66rMTKNF9dp2YNQB67wCuqKnFqam+SoD6gHRRV8P1l6pvGDARERERkd5Upy+Nrv2LGkAWCMw8qXu+9B0sAcCF28AtNaP9NbOuucEWtAWkhuovVd8wYCIiIiIivalOXxp1wZY6pQB+z9bcXM9Q7harT79dWHPrrCgg5QAP+scX1xIRERGR3lSnL42mYEudUQc0N9ez1MMdrrmk4nk0zVIingxKoW8c3MHwGDARERERkd4s6irrO1OWrn1pNAVb6mga8MHLHujfSvflaPJYAB52QHALYLAH4KaSNzdbwExLUFVTAQwHdzA8NskjIiIiIr3xtK96Xxp1AxdURsMGT97PFJcD/J1fteXIedoBh4bI/pYPtCDfprxiYFem5u/WVADDwR0MjzVMRFSnBQUFwcrKClKpFFKpFN7e3krTDx48CB8fH9jY2CA4OBhZWVmKaUIIzJkzB46OjnB0dMQ777wDISoziC0RUf0kf/fQoSGy37oOPCAPtka3ldXsuNpUbr2utrJleNoDR4bIaoYcLQErM83N5wDNNUVltFHHTgAAE3VJREFUgx7VbcrVMkJfTQYwqvtodNuaG2CCZBgwEVGdFx0djfz8fOTn5yM5OVmRnpOTg7CwMCxatAh37txBly5dMGLECMX0tWvXYseOHYiPj8eFCxewZ88erFmzxhibQERUb5QNTI4PA8x0/J65RPbi27LL2TkAyBkPFEwERrVV/z2pOXBocOWbEWpqGudhV/MBTFUDUqoaBkxEVG9t27YNvr6+GD58OKysrLBw4ULEx8fj0qVLAIBvvvkGs2bNQsuWLeHq6opZs2Zh48aNxs00EVE9Ig8MVCuAzCXAF8/JgpNGFrLfBwfLXoSribq+VVJzYG+o7HuVrbXR1Ffr0GAGMHWNSQVMbDpDRDVh7ty5cHJyQkBAAI4cOaJIT0hIgJ+fn+Kzra0tvLy8kJCQoHa6n5+fYhoRERnGyLay5nWqwdEMPyAjHLgbJfutLVgC1DdluzDiyfcqW2vDpnH1h8kN+hAdHY0JEyaUS5c3nVm/fj0GDRqE+fPnY8SIETh9+jQA5aYzEokE/fr1Q+vWrTF58mRDbwIRmZClS5eiQ4cOsLCwwObNmzFo0CDExcXBy8sL+fn5cHZ2VprfwcEBeXl5AID8/Hw4ODgoTcvPz4cQAhKJDuPNEhGRXvRqIQuKqkseFOmLvpdHpsmkapi0YdMZIlIVFBQEiUSi9icwMBAA0K1bN9jZ2cHS0hIREREICAhAbGwsAEAqlSI3V3koptzcXNjZ2amdnpubC6lUymCJiIioHjG5gIlNZ4hIV0eOHIEQQu3PiRMn1H5HIpEomuv6+voiPj5eMe3BgwdIS0uDr6+v2unx8fGKaURERFQ/mFTAtHTpUqSnp+PatWuYOHEiBg0ahLS0NADlm8YAujedIaL66d69e/j1119RWFiIx48f4/vvv8exY8fQv39/AMCwYcNw8eJFxMTEoLCwEB9++CE6d+4MHx8fAMDYsWPx2Wef4dq1a7h+/TpWrFiByMhII24RERERGZrBAiY2nSEiQysuLsa8efPg7OwMJycnrFy5Ejt27FAMKOPs7IyYmBi8//77aNy4MX7//Xds3rxZ8f1JkyZh0KBB6NSpEzp27IjQ0FBMmjTJWJtDRERERmCwQR/KNq/TlWrTmW+++UYxTVPTma5dZQPms+kMETk7O+Ps2bNa5wkJCVH0hVQlkUiwbNkyLFu2rCayR0RERLWAyTTJY9MZIiIiIiIyNSYzrLi86cylS5dgZmYGHx8ftU1npk+fjvDwcHTr1q1c05n09HR06tQJADBhwgQ2nSEiIiIiomqRiHo4KsL9+/cVf6sOJEFE+lUfzrf6sI1EpqQ+nHP1YRuJTIm2c85kmuQRERERERGZGgZMREREREREGjBgIiIiIiIi0oABExERERERkQYmM0qesZTt4EVEVF0sU4hI31iuEBkXa5iIiIiIiIg0YMBERERERESkQb18DxMREREREZEuWMNERERERESkAQMmIiIiIiIiDRgwVUJ0dDS6dOkCS0tLREZGKk07ePAgfHx8YGNjg+DgYGRlZSmmCSEwZ84cODo6wtHREe+88w7KtoTMzMxEcHAwbGxs4OPjgwMHDtRIPjMzMyGRSCCVShU/ixYtMko+i4qKEBUVBXd3d9jZ2cHf3x8///yzYrqp7E9t+TSl/QkA4eHhaN68Oezt7dGuXTusX79eMc1U9iepFxQUBCsrK8Vx5O3trTS9Ov+/mnTnzh0MGzYMtra2cHd3xw8//GCQ9arStv+Mte94vWC5URdVdO02FaZSNumituxTdVJTU2FlZYXw8HBjZ6VCmzdvRvv27WFrawsvLy8cP368cgsQpLOYmBixfft2MXnyZBEREaFIv337trC3txc//fSTKCgoEG+//bbo1q2bYvrq1atFu3btxJUrV8TVq1dF+/btxapVqxTTu3fvLt58803x8OFDsXXrVuHg4CBu3bql93xmZGQIAKK4uFjt9wyZz/z8fLFgwQKRkZEhSkpKxO7du4VUKhUZGRkmtT+15dOU9qcQQly8eFEUFhYKIYRISkoSLi4u4o8//jCp/Unq9e7dW6xbt07ttOr+/2rSyJEjxSuvvCLy8vLE8ePHhb29vbh48aJB1l2Wpv1nzH3H6wXLjbpI2zXRlJhK2aSL2rJP1enXr58IDAwUo0ePNnZWtNq3b59o1aqVOHXqlCgpKRFXr14VV69erdQyGDBVwfvvv690YVmzZo3o0aOH4nN+fr6wsrISSUlJQgghevToIdasWaOYvn79esUFMjk5WVhYWIjc3FzF9MDAQL1ctFXzWdEF0Fj5lOvUqZPYunWrye5P1Xya8v68dOmSaNasmdiyZYvJ70/SHjBV5/9Xk/Lz80XDhg1FcnKyIi08PFzMmTOnxtetStP+M4V9x+uFfvNJpkd+TTQVplQ2VZWp7VN1fvzxRzF8+HCxYMECkw+YevToIdavX1+tZbBJnh4kJCTAz89P8Vle3ZeQkKB2up+fn9K01q1bw87OTu30muDu7o6WLVti3LhxyMnJ0bgdhsxndnY2UlJS4Ovra9L7s2w+5Uxpf06dOlXRBKZ58+YYOHCgSe9PemLu3LlwcnJCQEAAjhw5okivzv+vJqWkpMDMzAzt2rUz+LrVUbf/THHf1bbz0ZTKNzI96q6JxmZqZVNlmeI+VZWbm4sPPvgAK1asMHZWKlRSUoI//vgDt2/fRps2bdCyZUtMnz4dBQUFlVoOAyY9yM/Ph4ODg1Kag4MD8vLy1E53cHBAfn4+hBAVflefnJyccPbsWWRlZeHcuXPIy8vD6NGjNW6HofJZXFyM0aNHIyIiAj4+Pia7P1XzaYr786uvvkJeXh6OHz+OsLAwWFpamuz+pCeWLl2K9PR0XLt2DRMnTsSgQYOQlpYGoHrlS00ypWND0/4zxX1XW85HUyzfyLSoXhNNRW0+/kx1n6qaP38+oqKi4ObmZuysVCg7OxvFxcXYunUrjh8/jri4OJw/fx6LFy+u1HIYMOmBVCpFbm6uUlpubq7i6Zrq9NzcXEilUkWHWm3f1Xc+u3TpAnNzc7i4uCA6Ohr79u1TrN8Y+SwtLcWYMWNgYWGB6OhotflQXZcp5dPU9icAmJmZITAwEFevXsWqVatMcn/WJ0FBQZBIJGp/AgMDAQDdunWDnZ0dLC0tERERgf/f3v3HRF3/cQB/Xiic5wVd0wSxOpARU9amYzAUPZ1zjT9ac23mKqYblusP51AJt2ps+kf+UdNlswTNmoSrCYK1Iq2FQrMfEmdMRxCBGp0QUQzcLTnv+f3D8flywskhH7xDn4/t88fd+3Ofz5sXfJ4f3ve59+eWLl2KL774AsDEjofJFEl/G8HqF4m1myrHY6Tmm0yuUPIKGP2cGCmm6t9fJNd0OLfbja+//hoFBQXh7kpIZsyYAQDYvHkzEhISMGvWLGzdutU4x4ZKAyYTLFy4EOfPnzceX7t2DW1tbcbl1Fvbz58/H9D2+++/B7zzMbx9Mg39UzD0burd7idJ5Ofno6urCxUVFZg+ffqo/Qh3PYP181bhruetfD6fUbdIquf9pra2Frw5X3TEUl9fP+prLBZL0L+j8fz+JlNqaip8Ph9aW1vv+r7HMlS/SKzdVD0eIy3fZHKEklehnhPDJZKzKZhIr+lwtbW16OjowGOPPYb4+Hi89dZbqKiowOLFi8PdtVE5HA7Mmzdv4m+ETWgG1H1mcHCQXq+XO3bs4Isvvkiv18vBwUF2d3czNjaWx44do9fr5auvvhowcfi9995jWloa//jjD3Z2dnLBggUBk1+zsrK4bds2er1eVlZWTvhuQsH6+f3337O5uZk3btxgT08P165dyxUrVoStn5s2bWJWVhb7+/sDno+0egbrZyTVs6uri0ePHmV/fz99Ph9rampos9lYVVUVcfWUQP/88w9ramqM47SsrIw2m43Nzc0kJ348TKbnnnuO69at48DAAOvr68NyJ6rb1S+ctdP5Qrlxrwp2TowkkZBN4zEVajrk2rVr9Hg8xrJt2zY+++yzEX18v/HGG8zIyGBXVxd7e3uZk5PD119/fVzb0IBpHIqLiwkgYCkuLiZJnjp1ik888QStVitdLlfA7SD9fj8LCwvpcDjocDhYWFhIv99vtLe3t9PlctFqtTI1NZWnTp2alH6Wl5fT6XTSZrMxPj6eeXl59Hg8YelnR0cHATAmJoYzZ840lrKyMpKRU8/b9TOS6tnd3c3ly5czLi6ODz74INPT01lSUmK0R0o9ZaTu7m5mZGTQbrczLi6OWVlZPHnyZMA6E/n9Taa///6bzzzzDG02Gx999FF+/PHHd2W/w41Vv3DVTucL5ca9aKxzd6SIhGwK1VSpaTBT4S55169f5yuvvMK4uDjOmTOHmzdvptfrHdc2LORd+oZDERERERGRKUZzmERERERERILQgElERERERCQIDZhERERERESC0IBJREREREQkCA2YREREREREgtCASUREREREJAgNmMQ0FosFZWVlpm7T7/dj0aJFOHbsmKnbbWpqQmZmJqxWK5xOZ9D1Nm3ahO3bt5u6bxEJnXJFRMymXJHx0vcwiWmuXr2Khx56CFar1bRtHjp0CPv27UNjYyMsFotp283NzcXg4CAOHjyImTNn4quvvkJeXh5uPRw6OzuRmpqKpqYmJCcnm7Z/EQmNckVEzKZckfHSFSYxTXx8vKnhAwB79uzByy+/bGr4AEBraytcLhecTidmz54ddL3ExESsWrUK+/fvN3X/IhIa5YqImE25IuNGkXGoq6vjkiVLaLfbabfb+eSTT7KmpoYkCYBHjhwhSRYXFxPAiGX9+vXGtk6ePMklS5bQarVy7ty53LBhA3t6eoz2xsZGAmBnZ2dAH0pLS5mWlsaYmBg+/PDDXLZsGa9cuWK0f/LJJ5w/fz5jYmKYnZ3N6upqAmBdXR3b29tH9Mnlct22nx988AHnzJkzCdUUEVK5IiLmU66ImTRgkpD5fD46HA4WFBSwpaWFLS0trKys5JkzZ0gGBlB/fz89Ho+xnDhxgtOmTePhw4dJkt988w1nzJjBd955hy0tLfzxxx+5YsUKLlu2jH6/nyS5d+9eJiYmBvTh3LlzjIqK4kcffcSOjg7+8ssvLC0tNQLo559/psVi4Y4dO9jc3MyKigo6nU4jgHw+Hz0eD+fNm8eioiJ6PB729fXx3XffJQCjv//++6+xzwsXLhAAL168ONklFrnvKFeUKyJmU64oV8ymAZOErLe3lwD47bffjto+PICGu3z5MuPj41lYWGg853K5WFRUFLDepUuXCICNjY0kyS1btjAzMzNgncrKSsbGxrKvr2/UPrzwwgvMzs4OeG7fvn1GAA15/PHHuWvXLuPxkSNHGOyCa19fHwHw888/H7VdRO6cckW5ImI25YpyxWyawyQhczgc2LhxI5566ink5uZi9+7d+PXXX2/7moGBATz99NPIzs7G7t27jed/+ukn7N27F3a73VgWLFgA4ObndQHA6/WO+Izx6tWrkZycjKSkJKxbtw4lJSXo6ekx2i9evIilS5cGvCYnJ2dCP/dQH7xe74S2IyIjKVeUKyJmU64oV8ymAZOMS2lpKRoaGrB69WqcPn0a6enpOHDgwKjr+v1+PP/885g+fTrKysrwwAMPBLQVFRXB7XYHLK2trcjNzQUAzJ49G729vQHbtNvtOHfuHI4fP47U1FS8//77SElJQUNDAwCApOkTLof6cLvJliJy55QrImI25YqYSQMmGbf09HRs3boVX375JfLz81FSUjLqetu3b4fb7cZnn30Gm80W0JaRkYELFy4gJSVlxGK32wEAixcvRmtrK65fvx7w2qioKCxfvhw7d+5EQ0MDEhISUF5eDgBYuHAhvvvuu4D1b308mujoaADAjRs3RrQ1NTUhKioKixYtGnM7InJnlCsiYjbliphFAyYJ2W+//YaioiLU19fj0qVLOHv2LOrq6oxL08N9+OGH2L9/Pw4ePAjg5nceXL16FX19fQCAnTt3orq6GgUFBXC73Whra0NNTQ3y8/ONS8krV66ExWLBDz/8YGy3uroae/bsQUNDAy5fvoyqqipcuXLF6ENBQQHOnj2L1157DS0tLTh+/DjefvvtMX+2pKQkAMCJEyfw119/YWBgwGirra1FTk4OYmNj77ByIhKMckW5ImI25YpyxXRhnkMlU8iff/7JNWvWMDExkdHR0UxISODGjRuNO7Rg2CTK9evXj3mbzjNnznDVqlW02+202WxMS0vjli1bODg4aKyzYcMGvvTSS8bj06dPc+XKlZw1axZjYmKYkpLCN99807hTDUkePXqUycnJjI6OZmZmJquqqsacREnenLT5yCOP0GKxGP30+/10Op0sLy83rY4i8n/KFRExm3JFzGYhb/mqYJEI0tbWZlwOnzt37h1to6OjA0lJSairqxv3hMpPP/0Uu3btgtvtRlRU1B3tX0Qii3JFRMymXLm36SN5EtHmz5+PAwcOoL29PSz7/++//3D48GGFj8g9RLkiImZTrtzbpoW7AyJjWbt2bdj2nZeXF7Z9i8jkUa6IiNmUK/cufSRPREREREQkCH0kT0REREREJAgNmERERERERILQgElERERERCQIDZhERERERESC0IBJREREREQkCA2YREREREREgvgfeaaZlHTxgTgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mu = np.mean(X_train,axis=0) \n", + "sigma = np.std(X_train,axis=0) \n", + "X_mean = (X_train - mu)\n", + "X_norm = (X_train - mu)/sigma \n", + "\n", + "fig,ax=plt.subplots(1, 3, figsize=(12, 3))\n", + "ax[0].scatter(X_train[:,0], X_train[:,3])\n", + "ax[0].set_xlabel(X_features[0]); ax[0].set_ylabel(X_features[3]);\n", + "ax[0].set_title(\"unnormalized\")\n", + "ax[0].axis('equal')\n", + "\n", + "ax[1].scatter(X_mean[:,0], X_mean[:,3])\n", + "ax[1].set_xlabel(X_features[0]); ax[0].set_ylabel(X_features[3]);\n", + "ax[1].set_title(r\"X - $\\mu$\")\n", + "ax[1].axis('equal')\n", + "\n", + "ax[2].scatter(X_norm[:,0], X_norm[:,3])\n", + "ax[2].set_xlabel(X_features[0]); ax[0].set_ylabel(X_features[3]);\n", + "ax[2].set_title(r\"Z-score normalized\")\n", + "ax[2].axis('equal')\n", + "plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n", + "fig.suptitle(\"distribution of features before, during, after normalization\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The plot above shows the relationship between two of the training set parameters, \"age\" and \"size(sqft)\". *These are plotted with equal scale*. \n", + "- Left: Unnormalized: The range of values or the variance of the 'size(sqft)' feature is much larger than that of age\n", + "- Middle: The first step removes the mean or average value from each feature. This leaves features that are centered around zero. It's difficult to see the difference for the 'age' feature, but 'size(sqft)' is clearly around zero.\n", + "- Right: The second step divides by the standard deviation. This leaves both features centered at zero with a similar scale." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's normalize the data and compare it to the original data." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X_mu = [1.42e+03 2.72e+00 1.38e+00 3.84e+01], \n", + "X_sigma = [411.62 0.65 0.49 25.78]\n", + "Peak to Peak range by column in Raw X:[2.41e+03 4.00e+00 1.00e+00 9.50e+01]\n", + "Peak to Peak range by column in Normalized X:[5.85 6.14 2.06 3.69]\n" + ] + } + ], + "source": [ + "# normalize the original features\n", + "X_norm, X_mu, X_sigma = zscore_normalize_features(X_train)\n", + "print(f\"X_mu = {X_mu}, \\nX_sigma = {X_sigma}\")\n", + "print(f\"Peak to Peak range by column in Raw X:{np.ptp(X_train,axis=0)}\") \n", + "print(f\"Peak to Peak range by column in Normalized X:{np.ptp(X_norm,axis=0)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The peak to peak range of each column is reduced from a factor of thousands to a factor of 2-3 by normalization." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAskAAADpCAYAAADWBqryAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdeXhMZ/sH8O8ksu8khIhIgiRCIiR2Yq21LWlRRW2tvVq6aMWS4m21pSjV9uXXDW8pSVXtqkLshCAhEVmsISKy75Pn98czZ7LLJJmZM8v9uS7XOZnMnHMnZjL3POd+7kfCGGMghBBCCCGEyBmIHQAhhBBCCCGahpJkQgghhBBCKqEkmRBCCCGEkEooSSaEEEIIIaQSSpIJIYQQQgiphJJkQgghhBBCKqEkmRAlCwkJQZs2bWr8WpnCw8MhkUjw4MGDar9Wtl9++QWNGjVSybHr4/79+xg4cCAsLCwgkUhqvF94eDg6dOgAIyMj9OvXT30BapHdu3fD3d0dhoaGmDJlitjhaLTKrwNVv+7UfR5CCEdJMiEq9uGHH+L8+fMK379NmzYICQlR6L49e/ZESkoKWrRoUc/oqvfgwQNIJBKEh4dXuH3cuHF4+PChUs/VEJ9//jlSU1MRFRWFlJSUGu83e/ZsdO7cGYmJiQgLC1Pa+d9++22dSLqlUimmTZuGsWPH4t69e9iwYYPO/GzqoIrXYaNGjfDLL7+o/DyEkJppzpAQITrK0tISlpaWSj9uUVERjI2N4ejoqPRj18TMzAxmZmZqO19t4uPj0bVrV7Rt27bW+y1evBjOzs5qiqzuhP9PMaSkpCAnJwfDhw+Hk5OT0o+v7p9N3edT1+tQ3a93QvQeI4TUW0FBAZs1axaztrZmtra2bNasWeyTTz5h7u7u8vssX768wtf3799nQUFBrEmTJszU1JS5urqyr776ijHGWGBgIANQ4V9SUhI7ceIEA8D279/PevXqxUxMTNjGjRvlt9+/f58xxuRf79u3jwUEBDATExPWvn17dvToUfn5Kz9GYGhoyH7++WfGGKsSg4uLC2OMsZ9//pkZGhpWeNyBAwdY586dmbGxMXNwcGCzZ89mOTk58u9PnjyZDRw4kP3444+sVatWzMrKir3yyissNTX1hb/brKwsNmPGDGZvb89MTExYly5d2JEjR+Tfrxzj5MmTqxxD+FnL/xN+xvj4eBYUFMRsbGyYra0tGzx4MLt+/br8senp6WzChAnM2dmZmZqasnbt2rE1a9aw0tJS+f9rTccGwLZt21YhloEDB1aI0cXFhQUHB7PZs2ezxo0bM39/f8YYY5cvX2aDBw9mFhYWzN7eno0ePZolJyfLH/ei5091SktL2dtvv83c3Nzk9//0009ZQUEBY4z/n1b+Oap7Hgo/W3Z2Nps/fz5r0aIFMzMzY506dWKhoaHy8yUlJTEAbPv27WzYsGHM3NycffDBB9XGpuhz45dffmFeXl7M2NiYOTk5seDgYFZcXCz/fmBgIJs2bRpbsmQJc3R0ZPb29vI4duzYwV566SVmZmbGPDw8WHh4OHvw4IE8Ni8vL3bq1CmFf1/C76z866Dya6q631/53+HRo0dZYGAgs7OzY9bW1qxv377swoULFZ4blR9b3XkYY+zcuXOsT58+zNTUlNna2rLx48ezJ0+eyL8v/P3Zu3cv8/DwYObm5qxfv37szp07NT5nCCEcJcmENMD777/PHBwc2N69e9mtW7fYBx98wKysrF6YJL/88sts4MCB7OrVqywpKYn9+++/7H//+x9jjLFnz56x1q1bsw8++IClpKSwlJQUVlJSIn9z9PDwYH/99RdLTExk9+/frzFJbtOmDfv777/ZzZs32bRp05ipqSl78OBBhfu8KEm+cuUKA8BCQ0NZSkqKPGmpnBxcu3aNGRoasvfff5/dvHmTHTx4kDk7O7OJEyfK7zN58mRmbW3N3njjDXbjxg125swZ1qpVK/bWW2+98Hf7+uuvMxcXF3b48GF28+ZNNn/+fGZkZMRu3brFGGMsJSWF9ejRg7355pssJSWFZWRkVDlGYWEhS0lJYQDYpk2bWEpKCsvLy2OPHz9mzZo1Y7NmzWLXr19nsbGxbN68eaxx48bynzUlJYWtXr2aRUZGssTERLZt2zZmYWHBfvrpJ8YYTxbffPNN1qNHD/n/VV5eHmNM8STZysqKLV++nMXFxbGYmBgWExPDLCws2LJly9itW7fY9evX2euvv87atm3L8vPza33+VEcqlbLg4GB2/vx5lpSUxP766y/m6OjIli1bxhhjLC8vj128eJEBYH/99RdLSUlhmZmZ1f5spaWlrF+/fiwwMJBFRESwhIQE9uOPPzIjIyP2zz//MMbKkmQnJye2bds2lpCQwBITE6uNTZHnxv79+5mBgQH7/PPPWVxcHNu5cyeztbVlS5Yskd8nMDCQWVpaspkzZ7KYmBh2/fp1eRxubm7szz//ZHFxcWzUqFGsefPmbODAgSwsLIzFxcWxoKAg1rJlS1ZUVKTQ74ux2pPkZ8+eyX9vKSkpbMmSJczCwoJFR0czxhgLCwtjf/zxB4uLi2PR0dFs+vTpzM7OjqWlpTHGGEtNTWWGhoZs/fr18mNUd56UlBRmZWXFxo8fz65fv84iIiJYx44dWe/eveWxLV++nJmbm7MhQ4awy5cvs6ioKNapUyfWt2/fGp8zhBCOkmRC6iknJ4eZmJiw//73vxVu79KlywuTZB8fH7Z8+fIaj+vu7l7l+8Kb42+//Vbt7ZWT5K1bt8rvU1xczFq1asWCg4OrfYygfJJ8//59BoCdOHGiwn0qJwcTJ05kAQEBFe6zd+9eJpFI5KOfkydPZvb29hVG4r744gvm6OhY4+8gPj6eAWAHDhyocLufnx+bOnWq/OvAwEA2ffr0Go8jqJy0Ll++nHXr1q3CfUpLS5mbmxtbt25djceZP38+GzRokPzr6dOns8DAwFrPx1j1SfKAAQMq3Gfy5Mls3LhxFW4rKChgZmZm7M8//2SM1f78UcQ333zD2rRpI/9aSCgjIiLkt1X3s504cYKZmJhU+UAydepU9uqrr1Y41ooVK2qNQ5HnRu/evdmYMWMqPG79+vXM1NSUFRYWMsb486Bt27ZMKpVW+ZnK/38KHwbWrFkjv034QHjjxo0a46z8+6otSS7v8OHDzNjYmO3bt6/G40ulUmZra8u2b98uv63867Gm8yxZsoQ5OTnJfw+MMRYVFcUAsJMnTzLG+HPd0NCwwuj877//ziQSifyDFyGkelSTTEg9JSQkoLCwED179qxwe+/evbF///4aH/f+++9j5syZOHToEPr164cRI0agb9++Cp2za9euCt2vR48e8v1GjRqha9euuHnzpkKPrYuYmBgMGDCgwm2BgYFgjOHmzZtwcXEBAHh5ecHExER+HycnJzx58qTG4wqxVv699O3bF+fOnWtw3JcuXUJkZGSVWvH8/HzEx8cDAEpLS/HVV19h586dePDgAQoKClBcXCz/mZSh8v/npUuXcOfOnSpxFRQUyOOqz/Nny5Yt2Lp1K5KTk5Gbm4uSkhKUlpbWOd5Lly6hqKioSt1yUVFRlbpwRZ+rtT03YmJiMG7cuAqPCQwMREFBARISEuDl5QUA6NKlCwwMqs5F9/X1le8L9bw+Pj5VbktNTZXfpqzfV0xMDMaOHYsvv/wSL7/8svz2pKQkLFu2DOfOnUNqaipKS0uRl5eHu3fv1vn43bt3r1B/7evrCxsbG8TExMifFy1atICDg4P8Pk5OTmCMITU1Fa1atarzz0WIvqAkmZB6YowBwAtbj1Vn6tSpGDp0KA4fPowTJ05g2LBhGD16NLZv317rYy0sLBoUKwB5IlH+NqlUWq8kAKj55y9/e+VJVBKJpML5FcUYq/PvuzqlpaUYOHAgNm3aVOV7NjY2AIC1a9fiiy++wDfffIPOnTvDysoK69atw4EDB2o9fnU/X3FxcZX7Vf7/LC0txaRJk/DJJ59UuW+TJk0A1P35s3v3bsydOxerV69GYGAgrK2tsXv3bgQHB9f6c1RWWloKGxsbXLp0qcr3Kv8fK/pcVeS5Ufn/vLrXXk3nMzIyqnKc6m4Tnv/K+n2lpqZi5MiRmDhxIt5///0K3xs5ciTs7e3x3XffwdnZGcbGxujduzeKiorqdI7y8b/o9up+xwDq/ZonRF9QkkxIPbVp0wbGxsY4c+YM2rdvL7/97NmztT62efPmmDp1KqZOnYrhw4dj/Pjx2Lx5M6ytrWFsbAypVNqg2M6fPy+PqaSkBJcuXcLEiRMBAE2bNgUAPHr0SN7tISoqqkJiIryp1haHt7c3Tp48WeG2kydPQiKRVPid1JW3tzcA4NSpUxg+fLj89oiICPj5+dX7uAJ/f3/88ssvcHJyqrFbx6lTpzB06FBMnz5dfpswmiuo6f+qadOmePTokfzrwsJC3Lx5E66urrXGdf36dbi7u7/ww8CLnj/V/Rx+fn5YuHCh/Lbk5OQXxlHTz+bv74+MjAwUFBSgQ4cOtR5DGYTn2Ny5c+W3nTp1CmZmZnBzc1P6+er7+yqvsLAQo0ePhqenJ7799tsK33v27Blu3ryJgwcPYsiQIQB4y8XyI9lAzc+t8ry9vfHzzz9X6OZx7do1ZGZmyl9DhJD6oz7JhNSThYUFZs2ahSVLlmDfvn2Ii4vDxx9/jNjY2Bc+bt68eTh48CASEhIQExODsLAwODs7w8rKCgDg6uqKM2fO4N69e0hLS6vXaM/q1atx8OBB3Lp1C7Nnz8aTJ08we/ZsADy5d3FxQUhICGJjY3H69GksWLCgQlJmb28PS0tLHD16FI8fP8bz58+rPc9HH32EK1euYOHChYiNjcXhw4fx7rvvYsKECQ26jOvu7o4xY8Zgzpw5OHLkCGJjY/Hee+8hOjoaH330Ub2PK5g3bx6kUilGjRqFiIgIJCcn4/Tp0wgODpZ/yPHw8EB4eDhOnDiB27dvY8mSJbhw4UKF47i6uiI2NhYxMTFIS0tDYWEhAGDQoEH44YcfcO7cOURHR2PKlCkKjRIuXrwYt27dwsSJE3Hx4kUkJSXhxIkTeO+995CYmCiP/UXPn8o8PDxw48YN/PXXX0hISMCGDRsU6hVd3c82YMAADBo0CEFBQfjzzz+RmJiIyMhIbNy4EVu2bKn1mPXx6aefIjQ0FKtXr8bt27fxxx9/ICQkBB988IFK2rzV9/dV3syZM/Ho0SNs2LABT58+xePHj/H48WPk5+fDzs4ODg4O2LJlC27fvo1z585h/PjxVT6subq64sSJE3j06BHS0tKqPc+8efOQlZWFKVOmIDo6GqdPn8akSZPQu3dv9OnTp96/A0IIR0kyIQ2wevVqjBo1CpMmTULXrl2RkZFRYcSrOowxvP/+++jQoQP69u2L3NxcHDp0SJ6kfvbZZ8jMzISHhwccHBxw7969Ose1Zs0aLF26FJ06dcKZM2fw119/oWXLlgB4jfKuXbuQmpoKPz8/zJ07F//5z38q1HMaGBjgu+++wx9//AFnZ+caR299fHywb98+nDx5Er6+vpg0aRJGjBiBH374oc4xV7Z161YMGTIEEydOhK+vL86cOYP9+/fD09Ozwcdu1qwZzp07B3t7ewQFBcHDwwMTJkzA3bt30bx5cwDA0qVLERgYiFdffRU9evTA8+fPMX/+/ArHmT59OgICAtCzZ084ODjg999/B8B//x06dMCQIUMwbNgw9O3bFwEBAbXG5eXlhbNnzyInJwdDhgxB+/bt8c477yA/Px+2trYAan/+VDZz5kxMmjQJU6dOhZ+fHy5cuKDQYjXV/WwSiQT79u1DUFAQFi5cCE9PT4wYMQIHDhyAu7t7rcesj+HDh+Onn37Cr7/+ig4dOmDBggWYM2cOli9frpLz1ff3VV54eDiSk5Ph4eGB5s2by//t2rULBgYG2L17NxISEuDj44MpU6bg/ffflz/vBGvXrkVkZCRcXV0r1BOX16xZMxw9ehQPHjxAQEAARo4ciQ4dOiA0NLS+Pz4hpBwJq09hICGEEEIIITqMRpIJIYQQQgiphJJkQgghhBBCKqEkmRBCCCGEkEooSSaEEEIIIaQSSpIJIYQQQgiphJJkQgghhBBCKqEkmRBCCCGEkEooSSaEEEIIIaSSRmIHUF5mZqbYIRAdY2Njo5bz0HOXKBs9d4k2ouct0VbVPXdpJJkQQgghhJBKKEkmhBBCCCGkEo0qtyhPXZdsiO4R+zIcPXdJfdFzl2gjet4SbVXbc5dGkgkhhBBCCKmEkmRCCCGEEEIqoSSZEJmdO3fCy8sLFhYWcHd3R0REBADg+PHj8PT0hLm5Ofr374+7d++KHCkhpE7yc4GIUOCnxUDwcGC6F/CONzDTB1g0GPg5GDi3D8jPETtSQogG0diaZELU6dixY1i0aBF27dqFrl27IiUlBQCQlpaGoKAgbN26FS+//DKWLl2KcePG4fz58yJHTAipVfwVYP8PwMmdQF52DXe6AVz9h++aWwEDJwEjZwOuHdQWJiEAgNJSwIDGLjUJ/W8oW1EBsOwVYLwTELaef0003vLly7Fs2TJ0794dBgYGcHJygpOTE8LCwuDt7Y0xY8bA1NQUISEhuHbtGmJjY8UOWf/ciAA+HQKMaQpcPyV2NBqFroJUkvYQ+HISMLcLcGgLT5C9ugMTlgJL9wA/Xgf+Gw18HwUsCwPGLQI8u/H7/b0ZmNkR+Oot4PkTsX8SossYA/7ZBiweBkxpC4wwAd5uD/yzHZCWiB0dASBhjDGxgxCUn2Uo9mxVky1VL7sVvmNZ7fflt5cUAytf55ftZO6ZtUSrxT8A3UaoLlhSQV2fR1KpFGZmZlixYgW2bt2KgoICjBo1Cl9//TU++eQTFBUV4fvvv5ffv0OHDvjss8/w2muv1fucpA6yngErxwDXTpTdZtsU+C4ScGgpv0l4TZZ/nWqb+jyPjh07hrfffrvKVRATExO4u7tXuAoSERFR5SqIup671f7NVDbGgD83AL8sAQpyASMTPio8/B3ApX3tj0+6Afz9PXDkJ6C4ELCwAaZ+Drw8G5BIVBOzDhDj759Yf3OV9nemIA/YOAc49mv133dqC3z4C+Dds2HnIS9U2/OIRpKVpbQUWDOVJ8hWdpjbeQNu2HijVf4D4IvxQPZzsSMkNXjy5AmKi4uxZ88eREREICoqClevXsWqVauQk5NT5YVjY2OD7OyaLt0SpduxiifIlrbAxOWA3yAgIxVY8RpQVCh2dKKjqyAyuZn8OfHDAp4g934N2HoLmL1OsQQZAFw7AvM3A1tigK7D+TE3zQU+f4PqlYnypN4D3u/BE2QTM2DuRn5lY28WsPD/gOZuwMN4YMlw/sGNiIaSZGUJWwf8uwMwtQBWHcJW92noOvgMTjj05Zfw/tokdoSkBmZmZgCAd999F82bN4e9vT0WLlyIgwcPwtLSEllZWRXun5WVBSsrKzFC1T/Zz/nlcgD46l/grRBg8e9AMxcg7iLw/Xuihic2qVSKy5cv4+nTp2jTpg1atmyJefPmIT8/HzExMfD19ZXfVyjFiImJETFiFbkXC8z1B878yUd/l/8JLNsDNHet3/FauAMr9wPBu3id8sk/gPd6AA/vKDduon+Ki/gV58TrfLT42wvAq/OA1t78uTZ0GvBTHNDndf4hbfFQnlQTUVCSrAylpcC+7/j+x78BXt34zRJDfNF+Eb/9z/U0EqGh7Ozs0LJlS0iquZzq7e2Na9euyb/Ozc1FQkICvL291Rmi/jrwIx8V9BsEtPHjt9nY8zpSIxP+/ZREcWMUEV0FAXDnKvBBH+DRHcDNl5fh9BrV8ONKJEDgWODbi0BLDyA5Gni/J43skYb5dSkQdwlo2grYcJ5fvajMsBGwaBvQsS/w7BFPlHPFXbBFX1GSrAzXTgCPk/iTvmfFP84nHfoA7XsC2el8ljXRSFOnTsXGjRuRmpqK58+fY/369Rg5ciRGjx6N6OhohIaGoqCgACtWrICPjw88PT3FDln3FRUCezfw/TEfVfxe2858pAUAwnepNy4NovdXQW6eAz7qD2SmAQHDgPVn+SiwMrXyBDZeBLq8BGQ+5ee7c1W55yD6IfIY8MdXvIPFp/8DrBvXfF9jU+Czv4DWHYB7t4DflqsvTiJHSbIyHNrKt0OmVW3fIpEAbwbz/dC11O1CQy1duhQBAQFo164dvLy84Ofnh+DgYDg4OCA0NBTBwcGws7PDhQsXsHPnTrHD1Q//7gDSHwNuPkCXwVW/3+8Nvj2pv/8fen0VJPYi8MlgPsLW+zUgZC9gaq6ac1lY84Sl2wg+kfTjAcDtSNWci+imrHTg67f4/sQQwLtX7Y+xtOUjygYGvGQzKVqlIZKqKEluoMaFz4AzYTwZHjK1+jsFDOOXitMfA0d/UWt8RDFGRkbYvHkzMjIy8PjxY3z77bcwNTUFAAwaNAixsbHIz89HeHg4WrduLW6w+oAxYM8avv/6h9V3FujyEn8TSbwO3L2p3vg0iF5eBXl4B1g6gpfiDJgABO8EjIxVe05jU17m02s0kJPBz/84WbXnJLpj99c8B/DuBYxfrPjj3DsBw2cCpVJg83z+t5GoDSXJDTT+3h+8EL/LEF5uUR2JBAhawPcj9qgvOEK0VdINfonRrlnZiHFlRsZ8BBEAwvV3NFnvroI8fwIsHsJLLPyHAh/+zGs41cHIGFi8E/AbyOMIHkadi0jtnj8B9n7L92d+Axga1u3xU1YCVo15aSflEGpFSXJDMIapSbIeh0Onv/i+XYfzSyY3Tr1g5SdCCADgyjG+9R8KNDKq+X5CAh2+U29HWPTqKoiwWFNKItC2C7B094ufH6pgZAwsC+W1ovdjgZBRfKCEkJrsXA0U5gE9XgE8u9b98dZNgKn/4fv//ZCeb2pESXID+GZcR8fMGD7bvscrL76zdRPAsztfcOTqcfUESIi2EpLkztXUIpfn248vLPIwHp0yrr34vkT7bX6Pt/5r5gKsOgCYibRwjIUNsOog0KQFH/j47wfixEE039MHwH7ZYlRvraj/cYbJFsRJvcdbEhK1oCS5AQY/+Yfv9BytWD1c1+F8e/Gg6oIiRNsVFfDEAwA6D3rxfQ0bAX3HAADG3dut4sCIqA7/BBz8L2/9tyyMl+KIqakz78fcyIhPqjqhA6UsRPn+t4qv3hg4FnD3rf3+NTE0BIIW8v3QtXp75UzdKElugP6psjdyv4GKPUBIki8dpCc4ITWJOQsU5vOuFookQrIkecjjYyoOjIgm/gpfwhcA5n/PWwBqAs+uwKz1fH/d27yOnhBBxlPg6M98XtKkzxp+vIET+JWzhCgg6kTDj0dqRUlyPRlLC9Ez7Rz/wrefYg9y7wQ0bg6kPaSG9ITURNFSC4Fnd8DIBN5Zt2BbRJOodE5+LvDFeD4aN+ydmrsIieXl2UD/8bzTxsrX+Qc8QgCeIBcX8QGyVkroKmNsCrwyj+8L3X+ISlGSXE9d0y/BXJqPaOv2il/2k0io5IKQ2siT5JcUu7+xCeARAADo8eyCioIiotnyEfDgNuDiDczZIHY0VUkkwPv/5avy3b0J/BwsdkREE5SWli0gNnK28o778mzAxAy4dEivW1+qi1qT5OTkZAwfPhx2dnZwdHTEvHnzUFJSos4QlKafrNQivGlg3R5ISTIhNctMA+5c4XWnHfso/jhZY3751R2iGy4e5JOeGhkBn+zgyYEmMrOULfpgCISto0vhBLh8hK/E28yFd+lRFht7YPBkvh+2XnnHJdVSa5I8Z84cNG3aFCkpKYiKisLJkyexefNmdYagNP1TwwEA4U371u2BfoP4ZKObZ6m/JiGVXT3O6/U79K5bQuTdGwAlyTolMw1YO43vT1nVsElP6uARALy5hO9/PZmvBEj0l9DRYvjMuvdFrs2o+Xx7cidQkKfcY5MK1JokJyUlYezYsTA1NYWjoyOGDh2KmJgYdYagHPm56PbsEqQwwCmH3nV7rIU1H/UqlQLXT6omPkK0VV3rkQXtewIA/NOvAEWFSg6KiOKHBXwRho59gde0pMXam8FAO3/g6X3gh4ViR0PEknoPuHiAXwGpbQ2F+mjlBXh05WsunPlT+ccncmpNkt977z3s3LkTeXl5ePjwIQ4dOoShQ5V4GUJdYk7DiJXgip0fMo1t6/54Yc32WKqfJKSC6NN822lA3R5n3Rgx1l4wLS0E4iOVHxdRr8tHgOPb+USlhf+n/JE4VWlkBHz8G28JeuQn4Fq42BERMRzaymuSe78G2DVVzTlemsK3x35VzfEJADUnyYGBgYiJiYG1tTVatmwJf39/jBo1Sp0hKEfUvwDqUWoh8OrBt7HnlRQQITogNwt4EMcTDLe6X1o/ay97XcWcVnJgRK3yc4ANM/n+W58BTm3EjaeuWnkB42WT9zbM5H2/if5gjH/AA3g3FlUJHMf/Vl79hy9YQlRCbUlyaWkphgwZgqCgIOTm5iItLQ3Pnz/HokWL1BWC8siT5DpO2hN4duPbuEuAVDsnLhKidHeu8K2br2KL81RyRkiSoylJ1mq/LgOe3AXa+AGvaWnJwthFPFl+cBv4/XOxoyHqFHuBT9hr0gLwqWeOoAjrxkD3V3hS/s821Z1Hz6ktSU5PT8f9+/cxb948mJiYoEmTJpg6dSoOHtSyLg/5ucCdKyiRGOKsfff6HcPWAWjhzvtqJkcrNz5CtFXcJb5t61+vh58TXo83z/JLnUT7JEQBezfwLhELtvJJztrI2IS3hQOAXaupVZc++fd/fBs4TvVlQuVLLmiBMpVQW5Jsb28PV1dXfP/99ygpKUFGRgZ+/fVX+Ppq+IzlyhKuAqWliLFuj7xGFvU/jqfsDf0WlVwQAgCIv8y3sp7HdZVs7oKHps2BrGe8bINoF8aATfP4B5xX5mrOqnr11aE3MHwGUFIMbJ5PSYw+kJYAp/7g+wPeVP35/IfwdRoexNEcJxVRa01yWFgYDh8+DAcHB7Rp0waNGjXCunXr1BlCw93mb+SXGzfwD7gXJcmEVCB7baFd/UaSIZGU1SVTyYX2Ob4DiDnDl919SwlL+GqCaZ8DVo15a8PTYWJHQ1TtWjjvyOLUFmjbRfXnM2wE9Jcl4zHJEYwAACAASURBVOG7VH8+PaTWJLlTp04IDw/H8+fPkZaWht27d6NpUxXN/FQV2SXhSEqSCVGerGdASiLvjdzKq96HudxY9sYk1DcT7ZCbBWz9iO+//SVgWY+uQZrIugnv8QwAPy6knra67oSs1KL/eL4Sozr0HcO3p0PpaoUK0LLUdXVbliTbNTBJdvXh7Y0exAFZ6UoIjBAtdlvWts3dr0F1qFF2svKthCglBEXUZsdKIP0xHzwY9JbY0SjX8Bl8MmrqPeCPL8WOhqhKUUHZ1YJ+49V3Xs9ugL0T780tzOsgSkNJcl3kZAAP4wEjE8TYtG/YsYyMyy7HxF1seGyEaLMG1iMLrtt04DuJ1wGptIFBEbV4lMAn60kkwNyNgIGOvS0ZGvKfCwD++Iony0T3XD7CV1ls4we08lTfeQ0MgF5BfD9ij/rOqyd07K+RigmLFLj5otig7i2qqqCSC0K4Bna2EKSbNAEcnIHCPODRHSUERlTu/z7hk9sGTqp/Pbqm69iHdzsoKgB+WSJ2NEQVzu7l2z5j1H/uPq/zLZVcKB0lyXVxWzmjXXJChwtaVITou4ZO2ivPvRPf3rna8GMR1Yo5w0e/TMyAqf8ROxrVmvYFv4L4z7ay8iKiG6QlwPm/+X4vERZI8+7Fu1ykJFKpmZJRklwXwmhXOyUlycJIcuwF+vRH9Ff6YyDtAWBuBbRs1/DjtfHj20R6s9BopaXAD7LFQl7/EHBoKW48qtbcFXh1Pt/f8iH9zdclMWf45OOW7QBnNZZaCAwNqeRCRShJrovbQpKspEuC9k683VFOBl9hihB9JIwit+2inHpUN9lIMo2oaLZTu/l8jMaOwNiPxY5GPcYv5i3hroUD5/eLHY2oNm3aBH9/f5iYmGDKlCny25OTkyGRSGBpaSn/t3LlSvECVcQZWalFz1Hq62pRWZ/X+DZiD30AUyJKkhXkUPCUT7gwtVDeJ0WJpOzSML2hE30ltGtTVl9Rek1pvuIi4Jdgvv/WCsDMUtx41MXKDpi4jO//3yK9nlzaokULLFmyBNOmTav2+xkZGcjJyUFOTg6WLl2q5ujqgLGyeuSeIpRaCHwCecvBB7eBe7fEi0PHUJKsoC7PZW/kbTord6lJekMn+i7pBt+6KWn1TcfWgIUNb+r/LEU5xyTKdfj/eFeLlh7AkKliR6NeI2cDjq48kTm+TexoRBMUFIRRo0ahSZMmYofSMInXgSfJvCbYs5t4cRg2ArqO4PsX9PsqhTJRkqygzs9lk4CUNWlPQEky0XdCkty6g3KOR1doNJp5SS6wYwX/Yup/GtQXWysZGfPRcwD4bTlQVChuPBrKxcUFLVu2xNSpU5GWliZ2ODUTRpF7vCp++8LuI/lWz0t5lImSZAXJk2RltygS3sxpkhHRR4X5wKN4wMCwQSvtVUFJssZ6N34zn6zpEQD0DhI7HHH0Hw+4duQlfAd+EDsajWJvb49Lly7h7t27iIyMRHZ2NiZMmCB2WDXThFILQZch/EPnTdlEQtJglCQrqGNGDN9R1iVhgVM73v7oyV0g+7lyj02Iprt3i3c5cGrLV6BUFvrwqZHsitLxQex6/sW01eJNchKboSEwRdby7n+rgLxscePRIJaWlvD390ejRo3QrFkzbNq0CUePHkVWVpbYoVWVeo9/EDezBDoNEDsawMKa1yaXlgKXDosdjU6gJFkB1sWZaJ13FzAyaXCLKpMtORX//ZQPtO7Iv5l4TQnREqJFhFIL147KPa67rA0c9UrWKAvivoVNSRbgNwjw04CkQkzdRwLtewKZaUDYOrGj0VgS2QcppokdGy4e4tvOgwFjE3FjEXR/mW+Fvs2kQShJVkCHTNkosou3aurn6NIw0VfJQj2ykpPkVl5AIyO+jDyN0mkEh4KnmBf/Pf9iyipxg9EEEknZAiqh3+jdlcSSkhIUFBRAKpVCKpWioKAAJSUluHDhAuLi4lBaWopnz55h/vz56NevH2xsbMQOuaqLB/i263Bx4yivm6wu+fJhvpIlaRBKkhXgkxHNd9yVXGohoCSZ6CtVjSQbGQOt2vP9uzHKPTaplw/jvoGFNA8Hmg8FvETsAqBJfPvxy/S5mcCetWJHo1arVq2CmZkZVq9eje3bt8PMzAyrVq1CYmIihg4dCisrK3To0AEmJib4/fffxQ63qqIC4Opxvq9JSXILd96mNjcTiD4tdjRaj5JkBXTMlCXJrj6qOQElyURfqSpJBviVHwBIpiRZdM8eYeadrQCAz7yXiByMhpksWyhj7wZeeqEnQkJCwBir8C8kJATjx49HUlIScnNzkZKSgt9++w2Ojo5ih1vV9VNAYR5//27SQuxoKhJKLqgVXINRkqyAjhlK7uNamWtHfunt3k3eZJ8QfZD1DEhP4Qv0OLoq//itZUkyjSSL7/fPYVZagDCnV3HNTkV/R7WVd0/AfyiQnwP88ZXY0RBFaWKphUAouaAkucEoSa6FhJWiQ+ZN/oWbikaSzSz57P6SYp4oE6IPhFFkF2/V9BcV+i4nRyv/2ERxTx8Ah7agFBKs8A4WOxrNNEU2mrxvE18Eh2i+iwf5VhOTZO+efEGlB7eBlCSxo9FqlCTXwi03CRbSPDwwa8GXfFQVoeSCZuMTfaHKUgugrNyCRpLFtWs1UFyEPc5BuGWjxF7YuqSdP9DjFd43fPfXYkdDatEm+w7w6A5g1Rjw7C52OFUZNuIdZAAg8oi4sWg5SpJr0VE2aS/aRkmrgdXEjeqSiZ5RdZLs6Mp7kD97BORkqOYc5MVko8iQSPC51yKxo9FsE5fz7d+bgeep4sZCXmhYiizx9B/Ce15rooChfHvpkLhxaDlKkmshTNq7bqviJFnonJF0XbXnIURTqKr9m8DAAHCWjVzSaLI4ZKPI6DuWRpFr07YzjSZriSGPj/GdgGHiBvIiXYbw7dXjNNepAShJroWPbNLeDVWPJAuJQtINQBObphOiTKWlZbXCqhpJBsrqkpOoLlntyo0iY8JSsaPRDhOW8e3f39FosoYyK8lDn6ey1mpCIqqJmjrzkrOCXCDmjNjRaC1KkmvRUbaQiMqTZIeWvNA+6xlN3CC6L/Uen81v1wywdVDdeajDhXj++FI+iiz/fyAv1q4Lb99Fo8kaq0/aGZiWFgJtOgN2TcUO58WEkovLtER1fVGS/AJWxVlwzU1GoYExblu1Ve3JJBKajU/0h5C0tlbxh0+avCeOZynAwS18/03qi1wn5WuTM56KGwupYvBj2QIi/ho8iiwQykGoLrneKEl+AWE56pvWXpAaqGA56spcy5VcEKLL7spaHQqr4qkKJcni2P01UFwI9A4CXFX8QUjXtOvC24oV5gFh68SOhlQy+PE/fEcbkmTv3oCJOc8p0h6KHY1WUnuSvHPnTnh5ecHCwgLu7u6IiIhQdwgKE/oj37BR06VCGkkWXXx8PExNTTFx4kT5bcePH4enpyfMzc3Rv39/3L17V8QIdYTQD9xFxUly01a8D/nzJ3q1mpmonqcCB37g+1SLXD/C723fJiArXdxYSJnU+/DKjkN2I0vAq4fY0dTO2IQvew4Al6jkoj7UmiQfO3YMixYtws8//4zs7GycOnUKbm5u6gyhToSR5Bi1JcmykeRkGkkWy9y5cxEQECD/Oi0tDUFBQVi5ciXS09Ph7++PcePGiRihjhBGdlU9kmxgUHYOGk1Wj9C1vKa2+8tl/d9J3Xh1531u87KBvd+KHQ0RyHoOhzftCxgZixyMgoQR7ytHxY1DS6k1SV6+fDmWLVuG7t27w8DAAE5OTnByclJnCHXSXjaSHGOj4jdygXwkOYbP/idqtXPnTtja2mLgwIHy28LCwuDt7Y0xY8bA1NQUISEhuHbtGmJjY0WMVMsxVlZuoY4JXcI5knU3SdaYKyBZz4B93/F9GkVuGOH3t3cDkJslbiyEu8yT5GPNBokcSB3Ik+R/AKlU3Fi0kNqSZKlUisuXL+Pp06do06YNWrZsiXnz5iE/P19dIdQNY/DOUnOSbN0YaNKC16I9pqUk1SkrKwvLli3D2rVrK9weExMDX19f+ddCmVBMjO4mXCr39D5vS2TbVLWrWAr0oC5ZY66A/LmB/9/6DwU8Amq/P6mZT1+gY1++EM6+TWJHQ6QlwFVej3zUUYuS5BZtgGatgex04M4VsaPROmpLkp88eYLi4mLs2bMHERERiIqKwtWrV7Fq1Sp1hVAnjgVP0KToOZ4b2eKRaXMAgMmWHPk/VTnaSJaQ0+Q9tVq6dCmmT58OZ2fnCrfn5OTAxsamwm02NjbIzs5WZ3i65a6a6pEFOl7rrzFXQHIzy0oDaBRZOYTfY9g6ID9X3Fj0XdwlICcDdyzdkWTpKnY0ipNIgC4v8f1IKrmoK7UlyWZmZgCAd999F82bN4e9vT0WLlyIgwcPqiuEOhFGkaNt2vMnmZrECKtS6egbuiaKiorCP//8gwULFlT5nqWlJbKyKl7qzMrKgpWVlbrC0z3qqkcWCCPJwmRBHaJRV0D2fccTZd/+gHdP1Z1Hn/gNBDy78UmnB/8rdjT6TZZg/tNsgMiB1INQckFJcp2pLUm2s7NDy5YtIVFjwtkQ8vZv6iq1kIkWJgnS5D21CQ8PR3JyMlq1agVHR0esWbMGoaGh6Ny5M7y9vXHt2jX5fXNzc5GQkABvb1ocod7kI8lq+h3aOwHmVjzR0LG+sxpzBSQ/Fwj9hu+/Gayac+gjiaSsz/Tur4GiAnHj0WeyBPOY48Ba7qiBOg3gk5hvnuWTQYnC1Dpxb+rUqdi4cSNSU1Px/PlzrF+/HiNHjlRnCAqTT9qzVm+SLK9/ppFktZkxYwYSEhIQFRWFqKgozJo1CyNGjMCRI0cwevRoREdHIzQ0FAUFBVixYgV8fHzg6ekpdtjaS13t3wQSSdmotQ6NJmvUFZADP/JJe17dy1pOEeXoNgJw8wXSU4AjP4sdjX7KyQBiLwCGjXDSoY/Y0dSdpS2/IiEtAa6Fix2NVlE4Sb537x4YY1VuZ4zh3r17Ch1j6dKlCAgIQLt27eDl5QU/Pz8EB2vmqIN35i0A5cof1OSWtSekMADuxwFFhWo9t74yNzeHo6Oj/J+lpSVMTU3h4OAABwcHhIaGIjg4GHZ2drhw4QJ27twpdsjaq3xnC3WVWwBlCfld3UmSNeYKSFEBsEe2hPKbS9RanqYXJJKy0fldq4GSYnHj0UdRJ4BSKeDVA9lG1mJHUz+dZXXJ1AquThReRs7V1RUpKSlo2rTiWuXp6elwdXWFVIHWIkZGRti8eTM2b95c90jVqbQU7bN4knzTWr1JcoGhGRIs3dAu5w7wIA5w81Hr+QkQEhJS4etBgwZRyzdlefYIyMviXS1sHdR3Xh0cSZ4xYwbeeOMN+ddr1qxBcnIyvv/+ewDARx99hNDQUIwYMUK1V0AO/wSkP+Y9kbsOV/7xCdArCHD2BO7HAv/uAF6aInZE+kVILLu8BOSJG0q9+Q8Btn9Gdcl1pPBIcnWjyACQl5cHExMTpQWkEZ4kw0Kah0emjkg3UUOLqkrkJRfU4YLoGqFXsYu3ekccdXAkWSOugJQUA398yffHB9MosqoYGgLjF/P93z+nfrfqduUY3wpdIrSRRwBgYQM8uA08ThY7Gq1R60jyihUrAAASiQRr1qyBpaWl/HtSqRRnzpzRvUlMsnpgdU/aE0TbeGP0w31Ul0x0j7rrkQU6OJJcmShXQI5vB1LvAa28gN5Bqj2Xvus/HvhtOfAwHojYA/RTvO+10La08B3LWu5JqniUwP9Z2QFtuwARGrq2Q20MG/FuKafDeNI//B2xI9IKtSbJ27ZtA8BHkvfs2QNDQ0P594yNjeHq6oovv/xSdRGKQTaCGy1SkkyT94jOEqMeGQCatgJMzHlZQFY6X7iHNIxUCuz8gu+/8SmfPU9Ux7ARMO4TYMNM4H+rgL5j6HeuDsIocqeBfERfm3V+iSfJkUcpSVZQrUlyfHw8AKB///4ICwuDnZ2dyoMSnSw5VXdnC4G8DpqSZKJrxBpJNjDgo53xkcD9W4B3L/WeXxdF7OGjmo6ufJSTqN7gycCOFfy94fzfQM9XxY5I90WWq0fWdl0G8+1V2RLV2p70q4HCH0NPnDihHwkyUJYkizSSfMfSHTAyBp4kU09DojsYU/9CIuXpYF2yaEpL+WgmwEc3DRWeA04awtgEGPMR3//9P/w1RVRHWgJE/cv3Ow8WNxZlaO4GtHDnLe1uXxY7Gq1Qp79sJ0+exNGjR/HkyROUlpZW+N5PP/2k1MBEU1LMu0qAt2MTg9SgEeDsBSRe40mFV3dR4iBEqdIf8z/OVnZAY0f1n78VJclKc/5vPphg78RHN4n6DHsH+N9/+DLJkccAfx0Y4dRUcZf4KpJObQHH1mJHoxydXwIefc/LSLy6iR2NxlN4JPnrr7+Wl1wkJyfj/v37Ff7pjPtxQEkxEi1ckdfIQrw4WnfgWyq5ILriXrl6ZDG6ILjo/uQ9tWCMj2ICwJiP+egmUR9Tc+D1D/i+MJpPVEMotRCWddYFQtkItYJTiMIjyRs3bsSGDRvw7rvvqjIe8cmSUrEm7cm5duRbSpKJrijf/k0MNJKsHJHH+AibbVNg2NtiR6OfRs7mC4tERwDXTwE+fcWOSDdFHuHbzlVH64WOIYCWdQ3p1B8wMARunQNyswALLV0cRU0UHknOyMjQ2CWklSqZd7YQqx5ZjkaSia4Ra9KewNEVMDIB0h7wNwdSP8Lo5esf8FFNon4W1sCo9/g+jSarRrmlqOHbT+xolMfCpmyJ6uvhYkej8RROkkeNGoV///1XlbFoBnn7N5F7PwtJMi0oQnSFWO3fBIaGfNUyALh3S5wYtN31U3z00sqOj2YS8YyaD5hZ8trSWxfEjkb3RP3LJ6i27wmYW4kdjXJRyYXCFC636NGjB5YsWYLo6Gj4+vrC2Ni4wvfffPNNpQcnCnm5hchJctNW/A9gRirwPBWwa1r7YwjRVOU7W4g1kiycO/EabwNHk1bqbsdKvh31nu4lDtrGujHwylxg15d8NHnl32JHpFt0qfVbZZ0HA9tCgMtHxI5E4ymcJM+dOxcAsGHDhirfk0gkupEk52UDj5OARka8DZuYJBI+mnzrPE8uKEkm2iwjFchO55f6mrQQLw5hFFuojyaKu3We91c1t+KjmER8QQuBvd8CF/YDd64CbfzEjkg3MFaWQOpikuzZlf8tfnQHSEkCmruKHZHGUrjcorS0tMZ/Ul1ZR15+OdgLJQZG4sYCUF0y0R13y9Uji9HZQiDvlUxJcp0Jo8ivvsvLLYj47JoCw2fyfS2rTd60aRP8/f1hYmKCKVOmVPje8ePH4enpCXNzc/Tv3x93795Vb3CP7vB1CqwaA206q/fc6iAsUQ2UTU4k1aI1LcuTTdqDSwdx4xBQkkx0hZiLiJQndNagJLlubkcCFw8CphZA0AKxoyHljf2IT0g9HQYkac97RYsWLbBkyRJMmzatwu1paWkICgrCypUrkZ6eDn9/f4wbN069wQmlFp0H6e6qdF1kbe2o5OKFFC63WLFixQu/v2zZsgYHIzohGXXtCGjCQnfyJJkm7xEtJx9JFrnWv4U7TyhS71H7o7oQRilHzgZs7MWNhVTUpAUwdDrw92bev3rx72JHpJCgoCAAwOXLl/HgwQP57WFhYfD29saYMWMAACEhIbC3t0dsbCw8PdW0wJc8SdbBUguB0Ps56jhfRK2RBlw910AKJ8nbtm2r8HVxcTEePnwIU1NTNG/eXDeSZKGThGtH4Lq4oQAAWpfrlcyYuJepCWkIsdu/CQwb8Q4Xidd4TLSaZe0SrwNn9wLGpmWLWBDNMm4RcGgLcHIXMHE50Eqc1WKVISYmBr6+vvKvLSws4O7ujpiYGPUkycVFZUtR62I9sqCZC9DSg68wfOs80LGP2BFpJIXLLeLj4yv8S05OxsOHD9G7d2989dVXqoxRfYQkubWGlFvYNQVsHPiEwidqrskiRJk0pdwCKBvNpsl7itkuu4o4YqY4y4mT2jVtBQyeUnE1RC2Vk5MDGxubCrfZ2NggO1tNl3dvngXyc/jfiabO6jmnWPyp5KI2DapJbtq0KVatWoVFixYpKx7xPE8FMp/ymdtNW4kdTRk3H76lfslEW2U8BTLT+GvLoaXY0QCtqS5ZYUk3gNOhvERl7MdiR0NeZPxifqXkxP+AB7fFjqbeLC0tkZVVcbGfrKwsWFmpqeXg5cN8q0tLUddE+Blp8l6NGjxxz8jICI8ePVJGLOJKLjeKrEllDa5CkqwJ9R+E1MO9couIaMJriybvKU7oaDF8hrit+0jtHFsDL03hC2BoWaeL8ry9vXHt2jX517m5uUhISIC3t5rmM1wSkuSh6jmfmDoGAkbGQHwkH8ggVSicJJ89e7bCvzNnzmD37t2YPn06/P39VRmjegiT9oQ6YE3hRkky0XLJGrCISHnUNUYxyTFAxB7+JjpOB64W6oM3ZKPJ/+4AHsaLHc0LlZSUoKCgAFKpFFKpFAUFBSgpKcHo0aMRHR2N0NBQFBQUYMWKFfDx8VFPPfKzFD5fwcRMP2p0zSyADn14mc6VY2JHo5EUTpJ79+6NPn36oHfv3vL9cePGwdTUFFu2bFFljOpRftKeJhFGkhMpSSZaSjZi+0mKO0y25IgcDABHV/4m+OwRkJMhdjSaK/UeYNcMGPYOYO8kdjREEc1dgcGTZaPJml2bvGrVKpiZmWH16tXYvn07zMzMsGrVKjg4OCA0NBTBwcGws7PDhQsXsHPnTvUEJXS18O3PJ6rqA2oF90IKd7dISkqq8LWBgQEcHBxgaqojTyRNm7QncGkPGBgCD28Dhfn8zZ0QbSJ7bYm+1LvAwABw9gLuXOEJvHcvsSPSTF2HAb8mAkUFYkdC6mL8YuDoL8Dx7cCbwYBTW7EjqlZISAhCQkKq/d6gQYMQGxur3oCAcvXIelBqIQgYBmz9mP/spaX87yORU/i34eLiUuGfs7Oz7iTIUmlZTbKb74vvq27GpoCzB3/yCr1mCdEWjMlfWzE2GlJuAZRN3qMOFy9mYkar62mb5m6y2mRpWU05qZ1UWjaSHKBHSXJrb8DBGXj+hC9tTiqo00eG27dv4+2330aPHj3Qs2dPvPPOO7h9W3tn0co9jOejtA7OmvmGQJP3iLZKewjkZCDdyA6PTJuLHU0Z4YoRTd4juujNJWW1yfdEGJHVRrcvA9np/ENGizZiR6M+EgkfTQaAS4fEjUUDKZwkHzt2DB07dsTVq1fRvXt3dO3aFVeuXIGPjw+OHz+uyhhVL1E2k9a9k7hx1ITqkom2kpdaaEhnC4G8VzJN3iM6yLE1X4WvtBTY8eLVcolM+VKLSn+rTLbkyP/ppK7D+fbSQXHj0EAKJ8mLFy/G7NmzERkZiXXr1mH9+vWIjIzEzJkz8emnn9bppPHx8TA1NcXEiRPrHLBKCEmyppVaCIQOF4nXXnw/QjSNLAmN0ZR6ZAG1gSO6bvxi3pkkfCe8Mm+JHY3mu3iAb4VRVX3SaQBflvrWeSDrmdjRaBSFk+To6GjMnj27yu1z5szBjRt1W+hi7ty5CAgIqNNjVCohim81NUkuX27BmLixEFIXyRo2aU/QtBVgasHr8OhNgeiipq14ZxLGsCxGsztdiC79MRB3ic8B6jRA7GjUz9wK6NiX5xdCXTYBUIck2crKCvfv369y+927d2Ftba3wCXfu3AlbW1sMHDhQ4ceonKaXWzi0BCxt+Zt5eorY0RCiuPLlFprEwIBKLojue+NTwNgUQQ//QqfnUWJHo7mEWtxOAwBTc3FjEYswgn6RSi7KUzhJHj16NGbMmIEjR44gLy8PeXl5OHz4MGbNmoWgoCCFjpGVlYVly5Zh7dq19Q5YWYT6ohabknm/VDNLXrCvwnPVu55JIqG6ZKJ9pCXAPX6ZV6M6WwiEnugJVMZEdJS9E/DKXADAZ9HU6aJGF2SlFl1HiBuHmIS6ZKEVHAFQhyR57dq16NKlC4YNGwYrKytYWVlhxIgRCAgIwFdffaXQMZYuXYrp06fD2dm53gErm0+GbBTJtaNm9wcUSkGowwXRFg/jgeJCoJkLso0Uv9qkNvSaIvpg3CfIbmSJoY+PAjcixI5G8xQXAVdkJQbd9DhJdvYEmrnw5anjLokdjcZQOCu0tLTE7t27ER8fj71792Lv3r2Ij4/Hrl27YGVlVevjo6Ki8M8//2DBggUNCljZfDNkb5BuGlpqIXCjkWSiZeQL9GjYKpYCIUmmCbFEl9nYY327d/n+z4tpXktl0RFAXjZvC9nMRexoxCORlI2kX9gvbiwaROEV98aOHYtOnTph8eLFcHd3l9++evVqXL16Fbt27Xrh48PDw5GcnIxWrVoBAHJyciCVSnHz5k1cuXKlnuE3XMdM2Uiypk7aEwjlFgnU7JtoifJLvUvFDaVawgfP5GheGmKo8J9DQrTKhnbzMOfOD2gSfRq4dJivpkg4odRCn0eRBT1eAf7eDJz/G5hC5TlAHUaST548ieHDh1e5fdiwYTh16lStj58xYwYSEhIQFRWFqKgozJo1CyNGjMCRI+KuF+6TIXsjd9f0JLkjX576fiyQnyt2NITUrnySrIksbfnIUVEBLw0hREdlG1nja88P+Bc/fUI1p+VdpHpkOZ9+fH5W4jXgyV2xo9EICifJmZmZsLS0rHK7ubk5nj9/Xuvjzc3N4ejoKP9naWkJU1NTODg41C1iJTIqLYJnVhy/zKCpl4QFJmZ8+cjSUqqhJNohWcPLLYCyK0g0eY/ouM1tZvJVZROv85X4CP9w/OA2X2m3fQ+xoxGfsQnQZQjfP/+3uLFoCIWTZHd3dxw7dqzK7ceOHYOrq2udTxwSEoLt27fX+XHK5JUVC2NWDDi1BcwsRI1FIW278G18pLhxEFKb/BwgJZE3qHf2EDuamlFdMtEThYamwGTZJfRflvArKPruz9lnnwAAIABJREFU7F986z+Myq0EPV7hW0qSAdQhSZ4zZw4WLVqEdevWITo6GjExMfjmm2/wySefYM6cOaqMUWXkpRaaXo8saNOZb++IV8NNiEKSZSvZOXvyRFlTUZJM9MnAiXyCWuo9YN9msaMR3zlZktxrlLhxaJKuw3mnr2sngNwssaMRncJJ8ty5c7FgwQIEBwfD19cXPj4+WLJkCd577z28++67qoxRZToLzdU1dRGRymgkmWgLYYKppn8ApSSZ6BNDQ2D6ar7/+3+A7NpLJXXW81Qg5gxfutt/qNjRaA4be6B9L6CkGIgUd86YJqhTY+DPPvsMaWlpOH/+PM6fP4+nT59i5UrtnQHZ+blsRLadBi2R/SJuvvwTXnIMXSojmi1e9toSPthpquZufKLKs0e8Pyghuq7rcMC3H5CdzhNlfXX+b94Oz28QX5aZlOn+Mt9SyUXdkmSAT8ALCAhAQEAALCy0oI63Bo1Ki9HpuWwCXDt/cYNRlKk54OwFlEqpXzLRbEJJkFAipKkMDMq6b9BoMtEHEgkwYy3f7v0WeJQgdkTiOLuXb3tSqUUVQl3yhQO8PaYe0+Al5lTLKysWZqUFSLBw4zNbtUVbqksmGq64qKyzhTaUMslLLuiDJ9ETbTsDg97il9S3LhI7GvXLzwGuHOMfFIRRU1LG2YPPJ8lOB66fFDsaUeltkuyfzut6LzfW8JGuyqgumWi6ezd5ouzUFrDQwOWoKxMW6qGRZKJPpv6HtxY9Hap/y1VfPgIUFwJePYDGjmJHo5l6v8a3EXvEjUNkepskd3nOJxZdsfMTOZI6Ei5fx9NIMtFQ8VpSaiGgyXtEH9k7AWM+5vs/LNCvBUao1KJ2fV/n2zN/AlJNXDJVPfQ3SU7nb+RaN5Ls3olfIkq+ARQVih2NTigsLMT06dPh4uICKysr+Pn54dChQ/LvHz9+HJ6enjA3N0f//v1x9y6tRPRCwlWOtlry2nLz4a+puzH0miL6ZcxHPFmOjwSO/Cx2NOpRXARc2M/3e74qbiyazM2XT2x+/oR3AdFT+pkkFxWgQ2YMSiFBlK2Gt6iqzNwKcGrHa8nuxogdjU4oKSmBs7MzTp48iczMTKxcuRJjx45FcnIy0tLSEBQUhJUrVyI9PR3+/v4YN26c2CFrtjta0tlCYGYJtPLiryktG02mD3ikQcwsgHe+5vs/fQrkZIgbjzpEHuU/p2tHoGU7saPRXBJJWcnF6VBxYxGRfibJiddhzIoRa+2BHCMtbP0iJB+3L4sbh46wsLBASEgIWrduDQMDA4wcORKurq6IjIxEWFgYvL29MWbMGJiamiIkJATXrl1DbGys2GFrJmlJWaLprkWlTEIbyNuXxI2jjugDHmmwfm8AHfoAmU+BbSFiR6N6p/7g20B6LdSqj6zk4nSofpXjlKOfSbIsuYzUtnpkgYfsDT32grhx6KgnT57g9u3b8Pb2RkxMDHx9y642WFhYwN3dHTExNIpfrftxQGE+0Kw1YN1Y7GgU59GVb2MvihtHHdEHPNJgEgkw91veDvGvTUBStNgRqU5RQVk9cuBYcWPRBh4BgIMzkPYQiNOuv43Kop+LlctGiyIb8xFZky05SjlsfY9T3eNqOlbhO5Z8Ri6AW2fPoJN1Dr+NKEVxcTEmTJiAyZMnw9PTEzk5OXBwcKhwHxsbG2RnZ4sUoYaTl1poST2ywEM7R5IrK/8B7/vvv6/xA56np6eIURKN494JGD4T2P89sGkusCacJ8+65tJhIC8baOPHu++QFxNKLv5cD5zaDXh1FzsitdPPkeQ4WZKsrSPJbfxQYGACr+w42BWlix2NzigtLcWkSZNgbGyMTZs2AQAsLS2RlVVx/fqsrCxYWWlhmY46aFtnC4GrD1+e9n4skJtV+/01UHUf8GxsbCrchz7gkRpNWQXYOAA3TgHHfhM7GtWgUou6E7pcnPxDL0su9C9Jzs8F7t9CsaQRrtt2FDua+jEylnfl6PZMu0e+NAVjDNOnT8eTJ08QGhoKIyMjAIC3tzeuXSubzJWbm4uEhAR4e3uLFapm05aV9iozNuGzuRnTyh7k9AGPNJh1Y2DmWr6/5UMg65m48ShbQR5wbh/f7ztGqYc22ZJT5Z/O8OrBy+fSHvAPUHpG/5LkuItAaSmibbxRYGgmdjT1dqEJr6Hs9kw/64SUbfbs2bh16xb+/vtvmJmVPS9Gjx6N6OhohIaGoqCgACtWrICPjw9drq6OVAok8P7jWlduAZTVJWtZ7R19wCNKM3Ai4NsPyEwD/u9TsaNRrosHgYJcXlrV3E3saLSHgQEw4E2+/+8OcWMRgf4lydF8ZaEz9j1FDqRhzjfpBgDo8Ywm7zXU3bt38eOPPyIqKgqOjo6wtLSEpaUlduzYAQcHB4SGhiI4OBh2dna4cOECdu7cKXbImuluDK/3a9YasGsmdjR1J3S4iNOuqzP0AY8ojUQCvLsZaGQEHNqiWyvxhf/Ot31pwl6dDZjAtxF79K6XvP4lybIX/WkH3UiS/dMjedstUm8uLi5gjKGgoAA5OTnyfxMm8D8MgwYNQmxsLPLz8xEeHo7WrVuLG7CmEhrOt9fS15an9o0k0wc8onStvIBxn/D9b6bzbjXaLusZcP5vPiraf7zY0Wgfl/Z8cmdOBh+R1yP61d1CWgLcOgcAOGvfQ+RgGibVtCkSLVzhlpsEJEfzJzAhYhKSZO9e4sZRXy09+GI9T+8D6Y+Bxo5iR1Qr4QNeTYQPeITUyfhg3hv37k1g+2fA9NViR9Qw4Tv5YkH+Q/gKg6TuBkwAEqJ4yUXv0WJHozb6NZKcEMVrklq0wRNTLbwcXMk52Wgybp4TNxBCAODmWb711tKRZAMDoK0/39eykgtClMrYBFj4f7z8Yvca4Lb6J7P269cPpqam8qsjHh4e9T/Y0V/4dvBkpcSml/qP58+HC/uB3Eyxo1Eb/UqShfqqjn3EjUNJhMl78uSEELE8SwEeJ/ElnltradcYoKxfshaVXBCiEl7dgVHvAaVSYO1UUWpRN23aJC9/i4uLq99B7t7kC4iZWwM9Ryk3QH1i7wT49geKC3k7OD2hX0mybNIeOuhGknzOXhhJpiSZiEx4Dnp2BwwNxY2lITzpNUWI3JRVQAt3IOkGsG252NHUz7Ff+TZwLGCivR2tNIIwEn9oq7hxqJH+JMmMAdGn+b6OJMkx1u2RY2gBpCTyGkpCxKLt9cgC4W/DrXN6N4ubkCrMLICPfuOlSH98VfYeqiaffvop7O3t0atXL4SHh9f9AFIpcHw7339pijJD01oN6uXc53XAwoZfaUu8rvzgNJD+JMkPbgOZT/lknBbuYkejFFKDRjhnL1sm8toJcYMh+k0YedXWzhYCWwfAxZvP6NfyJaoJUQrvnsDYRXyg6evJvM2jGnz55ZdITEzEw4cPMWPGDLz88stISEio20EijwLPHgEt2mj/3yZNYGrOe2kDvEWgHtCfJFkotfDurVNr0v/brB/fufKPqHEQPVaYz1fak0h4HaO28+3Ht9fCxYyCEM0xKYR3UCouAp7cVcspu3XrBisrK5iYmGDy5Mno1asXDh6sY/ux/d/z7ZCpOvW+L6ph7/DtP9v4KoY6Tm1JcmFhIaZPnw4XFxdYWVnBz88Phw4dUtfpyybt6UipheB40/5858ox/kmfEHW7fZm3V3LtCFhYix1Nw/kE8u31k+LGQYimMDIGloUC/70BuHYQJQSJRPLCdodVPE7mnRiMjIGhb6ssLr3j7stXJ83N5IuL6Di1JcklJSVwdnbGyZMnkZmZiZUrV2Ls2LFITk5W/ckZA27I3vB0pLOF4LptR8DGnvd2fRgvdjhEH8kXEdHyemRBR1mSfPMMHzkjhPClnC1t1XKqjIwMHDlyBAUFBSgpKcGOHTtw6tQpDBkyRPGDHPiRv/f3GQPYNVVdsPpouGw0WQ9KLtSWJFtYWCAkJAStW7eGgYEBRo4cCVdXV0RGqqH/4v1YfonIxgFw81X9+dSISQyATgP5F1RyQcRw4xTf6krNn11TvsJUYT4fJSeEqFVxcTGWLFkCBwcH2NvbY+PGjdi7d6/ivZKLCoHDsg4ML89RXaD6qt8bvN1n9Gmdn8AnWk3ykydPcPv2bXh7e6v+ZBdlZR3+Q/gsXV3TeTDfXjkmbhxE/xQVANfD+b7fQFFDUSphNFn42QghauPg4IBLly4hOzsbGRkZOH/+/9u787ioyrYP4L9hYIZ9UQEVFRVEBZXcMAUBc8uK1MoVCRTNp7TH1zRxDZc0tafcUHPpQV/RelXU0NwtFdPcAhVQQMGlJBdMAkW2ud4/jkwOm6Azc84M1/fzmc+cmbnnnOvc3Odwzzn38it69+5d/RXEbwdy7gvtqD0Ne3ZdSbKwBvqMFJZ3LhU3Fh0TpcZYVFSE4OBghIaGolWrVrrf4Nmnjf0799PJ6l94OBVtbatDL+H5ws/C1NuM6UvSCeGKa3NvoG4DsaPRHu68x5jh+vEb4TnoI+6wpysDJwh5+9Nmox6CVu+VZJVKhZCQECgUCkRFRel+g/l5wsgWMplwJdkYObsCLi2EhvQiTB/KarFz+4VnYzu2SjvvJf8idEpkjBmOKZuA4TOBHsPFjsR4NXQTZjAsKgR2rxI7Gp3RayWZiBAeHo47d+4gNjYWZmZmut9o4k/CH7FVF8C2ru63J5b2T68mc5MLpk/nDgjPnV4XNw5tc3AGGrcCCh4DqTxeMmMGpX5TIGyeMBmKAavuXernTRDyUhOIVOWdicLz7lXCHcUa0llcWqTXSvKHH36Iy5cvY/fu3bCw0NP0kGeftkfWUVMLyejAlWSmZ/f/AK4nAeZWhj/TXkVK21if1eNQlYwxZija+AEenYC/s4Vxk42Q3irJN27cwJo1a5CYmIj69evD2toa1tbW2Lx5s+42SlR7KsmvvAaYmgHJJ4CH98SOhtUG5w8Kz949hLFIjc2rQcLzqR/EjYMxxqRIJgPe/URY3valUfaJ0lsl2dXVFUSEJ0+eIC8vT/0IDg7W3UafHfqtRUfdbUcKrO2FJhcqFXByl9jRsNqgtD1yZyNralGqXSBgaQNkXgKyMsWOhjHGpMd/kNA++fZV4IgOL3qKxAjHQ3vGmaejWhjr0G9ldX9PeK4Fs+AwkZWU/NO0p6ORddorpVD+cweKryYzxlh5clNgRKSwvHmu0XV0Nu6a47H/E55Lb5sau279ARM5kHBEaCPEmK6knQNy/xKuILi4ix2N7nTtLzxzJZkxxirWYxjQqCWQlQEc+l+xo9Eq460k/5Eu9Eq3tAG6vCV2NPphW1fobKQqAU7yP3WmQydihWdjb+vv84ZwpeRSPPD3A7GjYYwx6ZGbAiFPryZvmSeMKGYkjLeSXNo2xvcdwNxS3Fj0iZtcMF1TqYCfvxOWA4eJG4uuWdsLYyarSoAzP4odDWOMSZP/YMDVU+gHtm+d2NFojXFWkomAn2KE5dd02DFQiroNENpfJxwWboczpm1J8cD93wHnprVjytfSJhd8d4YxVk36GAO4ovWLNvawXA6Efi4sb/zMaJp8Gmcl+coZ4PY1oE59YWi02sTeUeiVX1wEnIoTOxpmjErv0vQYVjumfO36tvB8bj+Q/0jcWBhjTKp8BwhNPnMfABtmih2NVhhnJfmnp//EA4YKv25qG//BwvP+b8WNgxmfwgLgxNOmPLXlLo2zqzBj55NHQPw2saNhjDFpksmAD5cJAwj8uAa4miB2RC/N+CrJxUXA0e+F5Z4jxI1FLK8NFzosJsUDGRfFjoYZk3P7hWY8zdsBTb3EjkZ/3vhAeN67Vtw4GGNMypp6Af0/Fpq9rnz6bMCMr5L86x4g554wHEmLDmJHIw5LG6B3qLAct1LcWJhx+XmL8FxbriKXChgiHFcpp4DMJLGjYYwx6Xp/NmDvBCT/AuxeLXY0L8W4KslEwLbFwnLQh7WjvWRlgsYJz0digLyH4sbCjMPfD/5p5x44VNxY9M3CCnjt6Z0pI+q5zRhjWmdlB4yPEpbXTQZ+TxM3npdgXJXk5F+Ay78CNg7A6+FiRyOuJq2EaaoLHgMHN4gdDTMGu1cBhU+ADr0BpyZiR6MXGj3F33za5OLw/wIF+eIGxhhjUuY/SLjjWJAPLAoBSorFjuiFGFcleduXwnPQOMDCutzHog2NIpb+44XnuJXC2LZl6HP4mFqV78aoIB/YtVxYHhIhbixicXsFaNlZuDPD45AzxljVxkcB9RoBqWeALfPFjuaFmIodgNbcvCzcCjZTCo3GmTDToFMT4PZV4OQuwO8dsSNihupAtNDW36NT7RtW8VlvfCDM5LljqdAxuDY36WKMacWzF5AKxlR8ge9l16uLWCr6XIO1PfDpBiCiFxAzR7jI4PNGjWMSk/FcSd72H+G570jAwUncWKRCLgcGP73qtz7CqKaKZHpUUvzPXZrBEbW7YthjOFCnAXD1N76azBhjz9O+JxAyW+gztmAocCNF7IhqxDgqyZmXhHaCMhnw7iSxo5GWN8YII33cvgrs+UbsaJghOr4NuHMdcGkB+A4UOxpxmVsCIyKF5egZwpCTjDHGKhc8S2ij/DgXiHzboGbjM/xKskoFLP9QuNr11oeAi7vYEUmLqRkw5umIHzFzeKQLVjOFT4BNc4TlQZ/Wzsl5ynp9lPCD4Y90oRkKY4yxypmYAJM3AO7thdmQZ7wBPMoRO6pqMfxK8oFoYVQLB2dgpGE2DNe5V4OAdgHCVJEG2nieieS7BcDvqUDjVkCv98WORhpMzYCwz4XlmDnAk8fixsMYY1JnbgnMiQOcmwod+ab1hW2R9CvKhl1JzrkPrJ8iLI/9WmgkzsqTyYAPvhKWdy4Fkk+KGw8zDNeTgf9bKCxPXAcolOLGIyXd3wPcOwDZt4WKMmOMsao5NgL+c1SoKF85jd3HB8Kh8IHYUVXJcCvJKhWwbKxwdbR9T6DHMLEjkjaPjsB7k4RmKfMHAw/viR0RkzKVClg6Rmhz++ZYoI2f2BFJi4kJMG4FYCIHti4Gzu4XOyLGGJM+Z1fgy58BZ1e8+uAsfjncA61zLosdVaUMt5K8YSZwYgdgaQv8e3Xt7nFfXaO+ADy7Aff/ABaHQEblx05mDIDQzCLllDCSw+hFYkcjTV7dgNC5wvLi94WryowxxqpWvynwVTx+s38Fbo8yEP/Ta8DJH8SOqkKGWUk+EA18/4VwFWfWdqETDXs+UzNgxv8BdvWAcwew4OIsYVgWxp6171tg4yzhh+f/rBWmGGUVGzJVmIEw5x7wxXCgsEDsiBhjElPRJF3GMLnZs/tQk31RrsuD8gcHvNbjALY1egc2xXnA7AHAV6OAvIeSyhfDqyQf2wosfTo97MergI69xY3H0Dg2AiI2AyZyfJK2HMsTPqlwNj5WS53aDSx7enyNiwJefUvceKTOxASI2ATUqQ9cPCYMb5T/SOyoGGNM8vJNLTHi1Q2Y2u5zYSK4A9HAGC+8e2uHZO50G04lWaUCNswC5g8R2tUO+hR48wOxozJMnfoAkTvxxESJsdfWA4tGCEN9sdqLCNj/X6G9ukoFDJ8JvP2R2FEZBgdnYP4+wM4ROH8QmNaHh1pkjLHqkMmwpOUEYHUi0PpVIPs2tvwaipOHA4BzB0S/2204leQdS4EtnwtXbj5cyu0kX1bXIAR134m/TW2An78D/uUtXAljtU9+HvBlKPB1uPBjqf/4f9rasupxewVYcgJwbAyknATGdwJ+Oyx2VIwxZhiatAK+PgH8+xv8Yd4AHR4mAtNfB8a2A+JWAY/+FiUsw6kkvzkW8A4EPt8HDJzAHfW04LhTd/QK3Ac0aQ38ngZMDsS6M2PhmWNY00ayF1RYAOxeDYz2BA5vApQWwoDv41bw8fUiGnkAS34BmrUVBsyf2htYFAJkZYodGWOMSZ9cDrw1Fl79EjGt3TzhLt31JCBqHDDEGZg9EDgcIwz/qyd6rSQ/ePAAAwcOhJWVFVxdXbFly5bqf9nCClj8k9BUgGnNBQdvYFWCMLe6qRnev7EFCQe74MDRN4Tb73dviR2iJLxU2ZUSIiD1rDClcpgbsOIj4N4toHk7YMVZoE+o2BEaNqfGQNQ5YOQCQGEOHIkR8nl6PyA+Vu+zTBlNuWW1Dpfd2ivf1BJft/wfIOamMNhAuwDhLufJXcDiEGCQIzCmDbBinNCO+WqCzjpNm+pkrZUYN24cFAoF7ty5g8TERLz55pvw9vaGl5dX9VbAV7d0Q6EEQiKBHsPwzfz/YMT1LQi8Fw98HS983qgl0KID0LSNMPNaXRegbkPA3lGoCNQCL112tai012/BGOvKExU+EcbCvndLeNxMEU4kaWeBB3/+k65ZWyD4M5hf6QM6ZAIgr+r1suczUwDDpgEBg4FNs4Hj24Bz+4WHiYkwCcnne4XjR8ekVG4ZqwkuuwxmCuE8GjBYGLr25C7gl53CLMs3koVHKRMTwLEJ0NBdGIu5bkPhYecI2NYV/tfZ1q1xCDIi/bSKfvToERwcHJCUlAQPDw8AQEhICFxcXLBwoTCrV06O9KcorBUe5UDxSyxMEw7BNCkesieVD8VCpgqQpS2gtAApLAAzJUhuJgw3ZyIXCq6JHASZsAyZ8GNH/YPn6XNlP4Cq+F30ZMh0qJp5V7krdnYvP3zZy5Zd+cWjUO5dXfkGnj0CNQ5H+uc9IuG1SiX0+lWVCB3sSoogKy4CigshK3gMFORD9jgHsqLKf1Wr6jREUec3UeTzJkra+D/9uzBdkeU+gNnRLTA7vQfyq+dAVvbIXZ/+3B/9L1t2q1NuAT7vMu2SwjmXGbmiAsivnofpldMwuX4J8uuXYJJ1rcoRMR59sgHFXQdUudqKyq7eriSnpaVBLperCzwAeHt749gx7iwmOVZ2KOwzCoV9RokdiSS8bNktaReIx+0CdRQdkzqyqYPCoPEoDBqv1+3yOZcZKi67rEpmSpS07oaS1t10vim9XULKy8srV0u3s7NDbm6uvkJg7IVw2WWGiMstM1RcdplU6O1KsrW1Nf7+W3MIj7///hs2Njbq19q4TcOYtnHZZYaoOuUW4LLLpIfPuUwq9HYl2cPDA8XFxUhPT1e/d+HCBW6EzySPyy4zRFxumaHissukQm8d9wBg6NChkMlkWL9+PRITE/HGG2/g5MmTXPCZ5HHZZYaIyy0zVFx2mRTotVv7qlWrkJ+fDycnJwwbNgyrV6+uVoEvKChAeHg4XF1dYWNjg/bt22Pfvn2Vpt+wYQPkcjmsra3Vj6NHj2pxTwQ1GcdxyZIlqF+/Puzs7DBq1CgUFOhmTL9SNckzfeVXRQIDA2Fubq7ebsuWLStNq+88fNaLlt1n1WRfAf3tr9SOL6keV4ZyTD1LG+W2uqKiotCpUycolUqEhYXpZBvaYKjj7xpK/mpLdctuTc9fUmSoZbIsY/hblEMGIC8vjyIjIykzM5NKSkpo9+7dZG1tTZmZmRWmj46OJl9fX53HNXToUBo8eDDl5uZSfHw82draUlJSUrl0+/fvJycnJ0pKSqIHDx5QQEAARURE6DS2muSZvvKrIgEBAbRu3brnphMjD7WtuvtKpN/9ldrxJdXjylCOKbHExsbSzp076V//+heFhoaKHU6lqlu+pMZQ8lffanr+kiJDLZNlGcPfoiyDqCRXpG3btrR9+/YKP9PHP6i8vDwyMzOj1NRU9XsjRoyo8J/0sGHDaNq0aerXhw8fJmdnZ53GV5HK8swQKslSycOXUZNKstj7K9bxZWjHlRSPKbHNmDFDspW4mpQvqZJy/kpFVecvqTGGMlkVQ/pbVMQgZxG4c+cO0tLSqrxtmJCQgHr16sHDwwPz5s1DcXGxVmOobBzH5OTkcmmTk5Ph7e2tke7OnTvIzs7WakxVeV6e6Tq/qjJt2jTUq1cPvr6+ld6SlkIeakN19hUQd3/FPL4M6biS8jHFKlaT8sUMU3XOX1JizGXS0P4WFTG4SnJRURGCg4MRGhqKVq1aVZjG398fSUlJuHv3LmJjY/Hdd9/hyy+/1GocNRnHsWza0mV9jfn4vDzTR35VZtGiRcjIyMAff/yBDz74AEFBQbh27Vq5dGLnoTZUd18B8fZX7OPLUI4rKR9TrHI8/q5xq875S2qMtUwa4t+iIpKoJAcGBkImk1X48PPzU6dTqVQICQmBQqFAVFRUpetr3rw5mjVrBhMTE7Rt2xafffYZtm/frtWYqzsGaUVpS5crSqtt1ckzfeRXZbp06QIbGxsolUqEhobC19cXe/fuLZdOzDysjuqU4eruK6Dd/TWk48sQjiupH1O6UN0yJHU1KV9MGrR9/pIaYyyThvq3qIgkKslHjx4FCe2jyz1OnDgBACAihIeH486dO4iNjYWZmVm11y+TyUBaHumuJuM4enl54cKFCxrpnJ2dUbduXa3GVNaL5pku8qu6Ktu2WHlYXdUpw2VVlc/a3F9DOr6kflwZ4jGlDS9SvqWIx981PLo+f4nN2MqkIf8tKqSrxs7aNnbsWOrSpQvl5uY+N+3evXvpzz//JCKiy5cvk5eXF82ePVvrMQ0ZMoSGDh1KeXl5dOLEiUp7pO7bt4+cnZ0pOTmZHjx4QD169NBLo/zq5pm+8qusv/76i/bv30/5+flUVFREMTExZGlpSVeuXCmXVqw81Jaa7CuR/vdXSseXlI8rqR9TYioqKqL8/HyaOnUqjRgxQl3Wpaa65UtqDCV/xVCT85cUGWqZrIih/y3KMohK8vXr1wkAKZVKsrKyUj9iYmKIiOjGjRtkZWVFN27cICKiSZMmkZOTE1laWlKzZs1o1qxZVFhYqPW4srOzqX///mRpaUmNGzemzZs3VxgPEdFXX31FTk5OZGNjQ2FhYfTkyROtx/OsqvJMrPwq6+7du9SpUyeytrYmOzs76tKlCx08eJCIpJGH2lTVvhKJu79SO76kelwZwjElpsjISAKg8YiMjBQ7rHIqK186TJXCAAAP+ElEQVRSZyj5q2/PO38ZAkMtk2UZw9+iLL3OuMcYY4wxxpghkESbZMYYY4wxxqSEK8mMMcYYY4yVwZVkxhhjjDHGyuBKMmOMMcYYY2VwJZkxxhhjjLEyuJLMGGOMMcZYGVxJ1gGZTIaYmBitrlOlUqF9+/Zan9r20qVL8PHxgbm5OZo2bVppurFjx2Ly5Mla3TbTj8DAQIwePVrr6w0LC0OvXr20vl7GtGn69OlwdnaGTCZD06ZN4e7uLnZIjDEDwZVkHcjKysJ7772n1XVGR0eDiPDuu+9qdb1TpkyBra0trly5grNnzyImJgYymaxcus8++wyrV69GRkaGVrfPGGO6cvr0aXzxxRdYu3YtsrKyMGTIELFDYowZEK4k60D9+vVhbm6u1XUuWbIEH3zwQYUV2JeRnp6OgIAANG3aFI6OjpWmc3FxQc+ePbFq1Sqtbp8Zr8LCQrFDYLVceno6TExM0L9/f9SvXx8WFhZ62S6XfcaMA1eSX9CJEyfg6+sLGxsb2NjYwNvbGwcOHACg2dxi9uzZkMlk5R5hYWHqdR06dAi+vr6wsLCAi4sLRo4ciezsbPXniYmJSE5OxoABAzRiWL9+PVq3bg1zc3PUrVsX/v7++P3339Wfb926Fe7u7jA3N0e3bt0QFxcHmUyGEydO4Pr165DJZLh27Ro+++wzyGQyBAYGIiQkRL0PZeMcOHCg1puRMP1QqVSYOnUq6tWrB1tbW4wePRr5+fnqz1esWIFWrVrB3NwcLVq0wPz581FcXKz+/K+//sKQIUNgZWUFZ2dnzJw5E2Un6wwMDER4eDhmzZqFBg0awMXFBQDw66+/wt/fHxYWFnBwcMDw4cNx9+5dje9u3LgRnp6eUCqVaNSoEWbOnKmx/dJ1z5w5E05OTrC3t8eMGTOgUqkwd+5cODs7w9HRETNmzNBY7w8//ID27dvD0tIS9vb28PHxQUJCgtbylUlXWFgYQkJCoFKp1Oezijyv7BUVFWHq1KlwcXGBQqGAp6cntmzZorEOmUyG5cuXY/jw4bCzs0NwcDAAYMGCBWjevDmUSiUcHR3Rt29fjeOOsRdx6NAhBAYGok6dOrCzs0NAQADOnDmj/jwzMxN9+vSBubk5mjRpgpUrV5ZrdldcXIzZs2ejWbNmMDc3h5eXF9asWSPG7kibuLNiG6bi4mJycHCgiRMnUlpaGqWlpdGOHTvo+PHjREQEgDZt2kRERLm5uZSVlaV+xMXFkampKUVHRxMR0ZEjR8jCwoKWL19OaWlpdObMGQoMDKTu3buTSqUiIqKlS5eSi4uLRgznzp0juVxOGzdupOvXr9PFixdp3bp1dOvWLSIi+u2330gmk9HUqVPpypUrFBsbS02bNiUAFB8fT8XFxZSVlUWNGjWiiIgIysrKopycHIqKiiIA6ngfPnyo3mZycjIBoJSUFF1nMdOigIAAsrGxodGjR1NKSgrFxcWRo6Mjffzxx0REFBkZSU2aNKEdO3ZQRkYG/fjjj9S4cWOaOXOmeh0DBgwgNzc3OnLkCCUlJVFwcDDZ2NhQz549NbZjbW1NY8eOpeTkZLp48SJlZWWRjY0NDRs2jC5evEjx8fHUtm1b8vPzU39vz549ZGJiQgsWLKDU1FT6/vvvyd7eXmP7AQEBZGtrS1OmTKHU1FT69ttvCQD169ePPv30U0pNTaUNGzYQANq7dy8REWVlZZGZmRktWrSIMjIyKCUlhTZv3kwXL17UdZYzCXj48CEtXbqU5HK5+nwWGRlJbm5u6jTVKXuTJ0+mOnXq0NatWyk1NZXmz59PMpmMDh8+rE4DgOrUqUPLly+nq1evUmpqKsXGxpKNjQ3FxcXRjRs3KCEhgZYsWUKPHz/Waz4w47Njxw51eUxKSqLw8HBycHCg+/fvk0qlIm9vb/Lx8aHTp09TQkIC9evXj2xtbSk8PFy9jtDQUGrbti0dOHCAMjIy6Pvvvyc7Oztav369iHsmPVxJfgEPHjwgAPTzzz9X+PmzleRn3bx5k+rXr0+ffvqp+r2AgACKiIjQSHfjxg0CQAkJCURENGHCBPLx8dFIs2PHDrK1taWcnJwKYwgODqauXbtqvLdixQp1JbmUq6srzZs3T/1606ZNVNlvp5ycHAJAe/bsqfBzJk0BAQHk6upKxcXF6vfWrFlDCoWC8vLyyMLCgvbt26fxnY0bN5KdnR0REaWnpxMAOnjwoPrzgoICatiwYblKcosWLaikpET93syZM8nFxYUKCgrU7yUmJhIAOnbsGBER+fn50aBBgzS2v3TpUjI3N1d/LyAggLy9vTXSeHp6Ups2bTTea9euHU2aNImIhB+KACgzM7N6GcWMTnR0NMnlcvXrspXk55W9R48ekUKhoJUrV2qkGTBgAPXo0UP9GgCNGjVKI83XX39NLVq0oMLCQm3uEmPllJSUkL29PcXExNDBgwcJAKWnp6s/z87OJgsLC3UlOSMjg2QyGV2+fFljPXPmzCl3nq3tuLnFC3BwcMDo0aPRt29f9OvXDwsXLkRqamqV38nLy0NQUBC6du2KhQsXqt8/e/Ysli5dCmtra/XD09MTgNCeDgDy8/PLtXHu3bs3mjdvjmbNmmHo0KFYu3Yt7t+/r/48JSUFvr6+Gt/x8/N7qf0ujYFvFxoeHx8fyOVy9WtfX18UFhbi3LlzyM/Px7vvvqtRBseOHYucnBzcu3cPKSkpAIBu3bqpv69QKNC5c+dy2+nYsSNMTP45rSQnJ+PVV1+FQqFQv+ft7Q07OzskJyer0/j7+2usJyAgAE+ePMG1a9c0vves+vXro127duXeK23K0a5dO/Tt2xdt2rTBwIEDsWzZMty6dat6GcZqheeVvatXr6KwsLDCNKXlt5SPj4/G68GDB6OoqAiurq4ICwvDpk2bkJubq5sdYbVKZmYmQkJC4O7uDltbW9ja2iInJwc3btxASkoK6tWrpzGKS506ddCyZUv163PnzoGI0KlTJ43z/oIFC9T1DibgSvILWrduHc6fP4/evXvj2LFjaNOmTaXteVQqFYYPHw4zMzPExMRoVCJUKhUiIiKQmJio8UhPT0e/fv0AAI6Ojnjw4IHGOq2trXHu3Dns3LkTHh4e+Oabb+Du7o7z588DAIhI6538SmOoqoMfMwxUpj3xtm3bNMrfpUuXkJ6ejjp16pRLWxUrK6ty71VWDp99v2ya0m0++76ZmVm571f0nkqlAgDI5XLs27cPP/30Ezp37ozY2Fh4eHhgz5491d4fZvyqU/YqSlP2vbJl38XFBVeuXMF///tfODk5Yd68eWjZsiX/UGMv7a233sLNmzexcuVK/Prrr0hMTISTk5O6w+jz/veXniNPnjypcd5PSkrCxYsXdR6/IeFK8kto06YNPvnkE+zbtw/h4eFYu3ZthekmT56MxMRE7N69G5aWlhqfderUCcnJyXB3dy/3sLa2BgB06NAB6enp5XpMy+Vy+Pv7Y+7cuTh//jwaNGig7lDi5eWFX375RSN92dcVKb3iV1JSUu6zS5cuQS6Xo3379s9dD5OWs2fPavxNT506BYVCgVdeeQXm5ubIyMiosAzK5XJ4eXkBEE6opQoLC3H27NnnbtfLywunTp3SKLsXLlxATk6Oer1eXl44duyYxveOHz8OCwsLNG/e/KX2WyaTwcfHB9OnT8fx48cREBCA6Ojol1onMx7PK3vu7u5QKpUVpiktv1VRKpV4/fXXsXjxYly6dAmPHz/Grl27tLoPrHbJzs5GSkoKpk6dir59+8LT0xPm5ubqO2ienp64d+8erl69qv7OX3/9hbS0NPXrjh07AgBu3rxZ7pzv5uam3x2SOFOxAzBEV69exbp16xAUFITGjRvj9u3biI+PR4cOHcql3bBhA1atWoW4uDgAwJ9//gkAsLCwgJ2dHebOnYs+ffpg4sSJCA0NhY2NDdLT07Ft2zZERUXBwsICPXr0gEwmw+nTp9G9e3cAQq/9jIwM+Pv7w9HREefPn8etW7fUTTUmTpyIzp07Y8aMGQgNDUVycjK++uqr5+5bs2bNAABxcXHw8/ODhYWFurJ+9OhR+Pn5wdbW9uUzkelVdnY2xo0bhwkTJiAjIwOzZs3CmDFjYGdnh+nTp2P69OkAhGY8xcXFuHTpEhISErBo0SK4u7vj7bffxrhx47BmzRo4Oztj4cKF1bp1PH78eCxbtgxhYWGYPn06Hj58iI8++gh+fn7qsjxt2jQEBQVh4cKFeOedd5CYmIjZs2dj0qRJGs00aurkyZM4cuQI+vTpgwYNGiA9PR0XL15EeHj4C6+TGZfnlT2FQoF///vfmDVrFhwdHfHKK69g27Zt+OGHH3Do0KEq1/3tt99CpVLBx8cH9vb2OHLkCHJzc9XnaMZehIODAxwdHbFu3Tq4ubkhOzsbU6ZMUQ9v2KtXL3h7e+P999/HsmXLoFAoMGPGDJiamqqvMLu7u2PUqFEYM2YMFi9ejK5du+LRo0c4f/487t27h4iICDF3UVpEbA9tsG7fvk0DBw4kFxcXUigU1KBBAxo9erR6JAg803EvNDSUAJR7hIaGqtd3/Phx6tmzJ1lbW5OlpSW1atWKJkyYQEVFReo0YWFhNGbMGPXrY8eOUY8ePahevXqkVCrJ3d2dvvjiC/WIGERE3333HTVv3pwUCgX5+PjQrl27nttxj0joKOjk5EQymUwdp0qloqZNm9KWLVu0lo9MPwICAmjkyJHqXvrW1tY0cuRIevTokTrN+vXrydvbm5RKJdnb25OPjw+tWrVK/fn9+/dp0KBBZGlpSfXq1aOpU6fS+++/X67j3rO9p0udOnWKunfvTubm5mRnZ0fDhg2jO3fuaKTZsGEDtWrViszMzKhhw4Y0ffp0jfJf0bp79uypcRwREfXt25eCg4OJiCgpKYn69etHzs7OpFAoqEmTJjR58mSNToTMuD2v4x7R88teYWEhRUREUMOGDcnMzIxat25Nmzdv1lgHKuisHRsbS127diV7e3uysLAgLy8vHjmAacXRo0epXbt2pFQqycPDg7Zv305ubm4UGRlJRELHvF69epFSqaRGjRpRVFQUde7cmcaPH69eR3FxMS1atIhatmxJZmZmVLduXfL396etW7eKtFfSJCOqQYNDJppr166pm2Y0bNjwhdZx/fp1NGvWDPHx8TXuxLd161bMmzcPiYmJGh3AGGOMMSZdubm5aNSoET7//HN8/PHHYodjULi5hYFwc3PDmjVrkJmZ+cKV5JdRUFCA6OhoriAzxhhjEhYXFwdTU1O0bt0ad+/exZw5cyCTyTB48GCxQzM4XEk2IGIW8NKZ+BhjjDEmXY8fP8bcuXNx/fp1WFlZoWPHjjhx4gScnZ3FDs3gcHMLxhhjjDHGyuAh4BhjjDHGGCuDK8mMMcYYY4yVwZVkxhhjjDHGyuBKMmOMMcYYY2VwJZkxxhhjjLEyuJLMGGOMMcZYGf8PGdVnHwP07qUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig,ax=plt.subplots(1, 4, figsize=(12, 3))\n", + "for i in range(len(ax)):\n", + " norm_plot(ax[i],X_train[:,i],)\n", + " ax[i].set_xlabel(X_features[i])\n", + "ax[0].set_ylabel(\"count\");\n", + "fig.suptitle(\"distribution of features before normalization\")\n", + "plt.show()\n", + "fig,ax=plt.subplots(1,4,figsize=(12,3))\n", + "for i in range(len(ax)):\n", + " norm_plot(ax[i],X_norm[:,i],)\n", + " ax[i].set_xlabel(X_features[i])\n", + "ax[0].set_ylabel(\"count\"); \n", + "fig.suptitle(\"distribution of features after normalization\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Notice, above, the range of the normalized data (x-axis) is centered around zero and roughly +/- 2. Most importantly, the range is similar for each feature." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's re-run our gradient descent algorithm with normalized data.\n", + "Note the **vastly larger value of alpha**. This will speed up gradient descent." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration Cost w0 w1 w2 w3 b djdw0 djdw1 djdw2 djdw3 djdb \n", + "---------------------|--------|--------|--------|--------|--------|--------|--------|--------|--------|--------|\n", + " 0 5.76170e+04 8.9e+00 3.0e+00 3.3e+00 -6.0e+00 3.6e+01 -8.9e+01 -3.0e+01 -3.3e+01 6.0e+01 -3.6e+02\n", + " 100 2.21086e+02 1.1e+02 -2.0e+01 -3.1e+01 -3.8e+01 3.6e+02 -9.2e-01 4.5e-01 5.3e-01 -1.7e-01 -9.6e-03\n", + " 200 2.19209e+02 1.1e+02 -2.1e+01 -3.3e+01 -3.8e+01 3.6e+02 -3.0e-02 1.5e-02 1.7e-02 -6.0e-03 -2.6e-07\n", + " 300 2.19207e+02 1.1e+02 -2.1e+01 -3.3e+01 -3.8e+01 3.6e+02 -1.0e-03 5.1e-04 5.7e-04 -2.0e-04 -6.9e-12\n", + " 400 2.19207e+02 1.1e+02 -2.1e+01 -3.3e+01 -3.8e+01 3.6e+02 -3.4e-05 1.7e-05 1.9e-05 -6.6e-06 -2.7e-13\n", + " 500 2.19207e+02 1.1e+02 -2.1e+01 -3.3e+01 -3.8e+01 3.6e+02 -1.1e-06 5.6e-07 6.2e-07 -2.2e-07 -2.6e-13\n", + " 600 2.19207e+02 1.1e+02 -2.1e+01 -3.3e+01 -3.8e+01 3.6e+02 -3.7e-08 1.9e-08 2.1e-08 -7.3e-09 -2.6e-13\n", + " 700 2.19207e+02 1.1e+02 -2.1e+01 -3.3e+01 -3.8e+01 3.6e+02 -1.2e-09 6.2e-10 6.9e-10 -2.4e-10 -2.6e-13\n", + " 800 2.19207e+02 1.1e+02 -2.1e+01 -3.3e+01 -3.8e+01 3.6e+02 -4.1e-11 2.1e-11 2.3e-11 -8.1e-12 -2.7e-13\n", + " 900 2.19207e+02 1.1e+02 -2.1e+01 -3.3e+01 -3.8e+01 3.6e+02 -1.4e-12 7.0e-13 7.6e-13 -2.7e-13 -2.6e-13\n", + "w,b found by gradient descent: w: [110.56 -21.27 -32.71 -37.97], b: 363.16\n" + ] + } + ], + "source": [ + "w_norm, b_norm, hist = run_gradient_descent(X_norm, y_train, 1000, 1.0e-1, )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The scaled features get very accurate results **much, much faster!**. Notice the gradient of each parameter is tiny by the end of this fairly short run. A learning rate of 0.1 is a good start for regression with normalized features.\n", + "Let's plot our predictions versus the target values. Note, the prediction is made using the normalized feature while the plot is shown using the original feature values." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#predict target using normalized features\n", + "m = X_norm.shape[0]\n", + "yp = np.zeros(m)\n", + "for i in range(m):\n", + " yp[i] = np.dot(X_norm[i], w_norm) + b_norm\n", + "\n", + " # plot predictions and targets versus original features \n", + "fig,ax=plt.subplots(1,4,figsize=(12, 3),sharey=True)\n", + "for i in range(len(ax)):\n", + " ax[i].scatter(X_train[:,i],y_train, label = 'target')\n", + " ax[i].set_xlabel(X_features[i])\n", + " ax[i].scatter(X_train[:,i],yp,color=dlc[\"dlorange\"], label = 'predict')\n", + "ax[0].set_ylabel(\"Price\"); ax[0].legend();\n", + "fig.suptitle(\"target versus prediction using z-score normalized model\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The results look good. A few points to note:\n", + "- with multiple features, we can no longer have a single plot showing results versus features.\n", + "- when generating the plot, the normalized features were used. Any predictions using the parameters learned from a normalized training set must also be normalized." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Prediction**\n", + "The point of generating our model is to use it to predict housing prices that are not in the data set. Let's predict the price of a house with 1200 sqft, 3 bedrooms, 1 floor, 40 years old. Recall, that you must normalize the data with the mean and standard deviation derived when the training data was normalized. " + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.53 0.43 -0.79 0.06]\n", + " predicted price of a house with 1200 sqft, 3 bedrooms, 1 floor, 40 years old = $318709\n" + ] + } + ], + "source": [ + "# First, normalize out example.\n", + "x_house = np.array([1200, 3, 1, 40])\n", + "x_house_norm = (x_house - X_mu) / X_sigma\n", + "print(x_house_norm)\n", + "x_house_predict = np.dot(x_house_norm, w_norm) + b_norm\n", + "print(f\" predicted price of a house with 1200 sqft, 3 bedrooms, 1 floor, 40 years old = ${x_house_predict*1000:0.0f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Cost Contours** \n", + "Another way to view feature scaling is in terms of the cost contours. When feature scales do not match, the plot of cost versus parameters in a contour plot is asymmetric. \n", + "\n", + "In the plot below, the scale of the parameters is matched. The left plot is the cost contour plot of w[0], the square feet versus w[1], the number of bedrooms before normalizing the features. The plot is so asymmetric, the curves completing the contours are not visible. In contrast, when the features are normalized, the cost contour is much more symmetric. The result is that updates to parameters during gradient descent can make equal progress for each parameter. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt_equal_scale(X_train, X_norm, y_train)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Congratulations!\n", + "In this lab you:\n", + "- utilized the routines for linear regression with multiple features you developed in previous labs\n", + "- explored the impact of the learning rate $\\alpha$ on convergence \n", + "- discovered the value of feature scaling using z-score normalization in speeding convergence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Acknowledgments\n", + "The housing data was derived from the [Ames Housing dataset](http://jse.amstat.org/v19n3/decock.pdf) compiled by Dean De Cock for use in data science education." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + }, + "toc-autonumbering": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/week2/C1_W2_Lab04_FeatEng_PolyReg_Soln.ipynb b/week2/C1_W2_Lab04_FeatEng_PolyReg_Soln.ipynb new file mode 100644 index 0000000..c5cd8b0 --- /dev/null +++ b/week2/C1_W2_Lab04_FeatEng_PolyReg_Soln.ipynb @@ -0,0 +1,505 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Optional Lab: Feature Engineering and Polynomial Regression\n", + "\n", + "![](./images/C1_W2_Lab07_FeatureEngLecture.PNG)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Goals\n", + "In this lab you will:\n", + "- explore feature engineering and polynomial regression which allows you to use the machinery of linear regression to fit very complicated, even very non-linear functions.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tools\n", + "You will utilize the function developed in previous labs as well as matplotlib and NumPy. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from lab_utils_multi import zscore_normalize_features, run_gradient_descent_feng\n", + "np.set_printoptions(precision=2) # reduced display precision on numpy arrays" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Feature Engineering and Polynomial Regression Overview\n", + "\n", + "Out of the box, linear regression provides a means of building models of the form:\n", + "$$f_{\\mathbf{w},b} = w_0x_0 + w_1x_1+ ... + w_{n-1}x_{n-1} + b \\tag{1}$$ \n", + "What if your features/data are non-linear or are combinations of features? For example, Housing prices do not tend to be linear with living area but penalize very small or very large houses resulting in the curves shown in the graphic above. How can we use the machinery of linear regression to fit this curve? Recall, the 'machinery' we have is the ability to modify the parameters $\\mathbf{w}$, $\\mathbf{b}$ in (1) to 'fit' the equation to the training data. However, no amount of adjusting of $\\mathbf{w}$,$\\mathbf{b}$ in (1) will achieve a fit to a non-linear curve.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Polynomial Features\n", + "\n", + "Above we were considering a scenario where the data was non-linear. Let's try using what we know so far to fit a non-linear curve. We'll start with a simple quadratic: $y = 1+x^2$\n", + "\n", + "You're familiar with all the routines we're using. They are available in the lab_utils.py file for review. We'll use [`np.c_[..]`](https://numpy.org/doc/stable/reference/generated/numpy.c_.html) which is a NumPy routine to concatenate along the column boundary." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 0, Cost: 1.65756e+03\n", + "Iteration 100, Cost: 6.94549e+02\n", + "Iteration 200, Cost: 5.88475e+02\n", + "Iteration 300, Cost: 5.26414e+02\n", + "Iteration 400, Cost: 4.90103e+02\n", + "Iteration 500, Cost: 4.68858e+02\n", + "Iteration 600, Cost: 4.56428e+02\n", + "Iteration 700, Cost: 4.49155e+02\n", + "Iteration 800, Cost: 4.44900e+02\n", + "Iteration 900, Cost: 4.42411e+02\n", + "w,b found by gradient descent: w: [18.7], b: -52.0834\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# create target data\n", + "x = np.arange(0, 20, 1)\n", + "y = 1 + x**2\n", + "X = x.reshape(-1, 1)\n", + "\n", + "model_w,model_b = run_gradient_descent_feng(X,y,iterations=1000, alpha = 1e-2)\n", + "\n", + "plt.scatter(x, y, marker='x', c='r', label=\"Actual Value\"); plt.title(\"no feature engineering\")\n", + "plt.plot(x,X@model_w + model_b, label=\"Predicted Value\"); plt.xlabel(\"X\"); plt.ylabel(\"y\"); plt.legend(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Well, as expected, not a great fit. What is needed is something like $y= w_0x_0^2 + b$, or a **polynomial feature**.\n", + "To accomplish this, you can modify the *input data* to *engineer* the needed features. If you swap the original data with a version that squares the $x$ value, then you can achieve $y= w_0x_0^2 + b$. Let's try it. Swap `X` for `X**2` below:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# create target data\n", + "x = np.arange(0, 20, 1)\n", + "y = 1 + x**2\n", + "\n", + "# Engineer features \n", + "X = x**2 #<-- added engineered feature" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 0, Cost: 7.32922e+03\n", + "Iteration 1000, Cost: 2.24844e-01\n", + "Iteration 2000, Cost: 2.22795e-01\n", + "Iteration 3000, Cost: 2.20764e-01\n", + "Iteration 4000, Cost: 2.18752e-01\n", + "Iteration 5000, Cost: 2.16758e-01\n", + "Iteration 6000, Cost: 2.14782e-01\n", + "Iteration 7000, Cost: 2.12824e-01\n", + "Iteration 8000, Cost: 2.10884e-01\n", + "Iteration 9000, Cost: 2.08962e-01\n", + "w,b found by gradient descent: w: [1.], b: 0.0490\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "X = X.reshape(-1, 1) #X should be a 2-D Matrix\n", + "model_w,model_b = run_gradient_descent_feng(X, y, iterations=10000, alpha = 1e-5)\n", + "\n", + "plt.scatter(x, y, marker='x', c='r', label=\"Actual Value\"); plt.title(\"Added x**2 feature\")\n", + "plt.plot(x, np.dot(X,model_w) + model_b, label=\"Predicted Value\"); plt.xlabel(\"x\"); plt.ylabel(\"y\"); plt.legend(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Great! near perfect fit. Notice the values of $\\mathbf{w}$ and b printed right above the graph: `w,b found by gradient descent: w: [1.], b: 0.0490`. Gradient descent modified our initial values of $\\mathbf{w},b $ to be (1.0,0.049) or a model of $y=1*x_0^2+0.049$, very close to our target of $y=1*x_0^2+1$. If you ran it longer, it could be a better match. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Selecting Features\n", + "\n", + "Above, we knew that an $x^2$ term was required. It may not always be obvious which features are required. One could add a variety of potential features to try and find the most useful. For example, what if we had instead tried : $y=w_0x_0 + w_1x_1^2 + w_2x_2^3+b$ ? \n", + "\n", + "Run the next cells. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# create target data\n", + "x = np.arange(0, 20, 1)\n", + "y = x**2\n", + "\n", + "# engineer features .\n", + "X = np.c_[x, x**2, x**3] #<-- added engineered feature" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 0, Cost: 1.14029e+03\n", + "Iteration 1000, Cost: 3.28539e+02\n", + "Iteration 2000, Cost: 2.80443e+02\n", + "Iteration 3000, Cost: 2.39389e+02\n", + "Iteration 4000, Cost: 2.04344e+02\n", + "Iteration 5000, Cost: 1.74430e+02\n", + "Iteration 6000, Cost: 1.48896e+02\n", + "Iteration 7000, Cost: 1.27100e+02\n", + "Iteration 8000, Cost: 1.08495e+02\n", + "Iteration 9000, Cost: 9.26132e+01\n", + "w,b found by gradient descent: w: [0.08 0.54 0.03], b: 0.0106\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model_w,model_b = run_gradient_descent_feng(X, y, iterations=10000, alpha=1e-7)\n", + "\n", + "plt.scatter(x, y, marker='x', c='r', label=\"Actual Value\"); plt.title(\"x, x**2, x**3 features\")\n", + "plt.plot(x, X@model_w + model_b, label=\"Predicted Value\"); plt.xlabel(\"x\"); plt.ylabel(\"y\"); plt.legend(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note the value of $\\mathbf{w}$, `[0.08 0.54 0.03]` and b is `0.0106`.This implies the model after fitting/training is:\n", + "$$ 0.08x + 0.54x^2 + 0.03x^3 + 0.0106 $$\n", + "Gradient descent has emphasized the data that is the best fit to the $x^2$ data by increasing the $w_1$ term relative to the others. If you were to run for a very long time, it would continue to reduce the impact of the other terms. \n", + ">Gradient descent is picking the 'correct' features for us by emphasizing its associated parameter\n", + "\n", + "Let's review this idea:\n", + "- Intially, the features were re-scaled so they are comparable to each other\n", + "- less weight value implies less important/correct feature, and in extreme, when the weight becomes zero or very close to zero, the associated feature is not useful in fitting the model to the data.\n", + "- above, after fitting, the weight associated with the $x^2$ feature is much larger than the weights for $x$ or $x^3$ as it is the most useful in fitting the data. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### An Alternate View\n", + "Above, polynomial features were chosen based on how well they matched the target data. Another way to think about this is to note that we are still using linear regression once we have created new features. Given that, the best features will be linear relative to the target. This is best understood with an example. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# create target data\n", + "x = np.arange(0, 20, 1)\n", + "y = x**2\n", + "\n", + "# engineer features .\n", + "X = np.c_[x, x**2, x**3] #<-- added engineered feature\n", + "X_features = ['x','x^2','x^3']" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig,ax=plt.subplots(1, 3, figsize=(12, 3), sharey=True)\n", + "for i in range(len(ax)):\n", + " ax[i].scatter(X[:,i],y)\n", + " ax[i].set_xlabel(X_features[i])\n", + "ax[0].set_ylabel(\"y\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Above, it is clear that the $x^2$ feature mapped against the target value $y$ is linear. Linear regression can then easily generate a model using that feature." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Scaling features\n", + "As described in the last lab, if the data set has features with significantly different scales, one should apply feature scaling to speed gradient descent. In the example above, there is $x$, $x^2$ and $x^3$ which will naturally have very different scales. Let's apply Z-score normalization to our example." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Peak to Peak range by column in Raw X:[ 19 361 6859]\n", + "Peak to Peak range by column in Normalized X:[3.3 3.18 3.28]\n" + ] + } + ], + "source": [ + "# create target data\n", + "x = np.arange(0,20,1)\n", + "X = np.c_[x, x**2, x**3]\n", + "print(f\"Peak to Peak range by column in Raw X:{np.ptp(X,axis=0)}\")\n", + "\n", + "# add mean_normalization \n", + "X = zscore_normalize_features(X) \n", + "print(f\"Peak to Peak range by column in Normalized X:{np.ptp(X,axis=0)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can try again with a more aggressive value of alpha:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 0, Cost: 9.42147e+03\n", + "Iteration 10000, Cost: 3.90938e-01\n", + "Iteration 20000, Cost: 2.78389e-02\n", + "Iteration 30000, Cost: 1.98242e-03\n", + "Iteration 40000, Cost: 1.41169e-04\n", + "Iteration 50000, Cost: 1.00527e-05\n", + "Iteration 60000, Cost: 7.15855e-07\n", + "Iteration 70000, Cost: 5.09763e-08\n", + "Iteration 80000, Cost: 3.63004e-09\n", + "Iteration 90000, Cost: 2.58497e-10\n", + "w,b found by gradient descent: w: [5.27e-05 1.13e+02 8.43e-05], b: 123.5000\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = np.arange(0,20,1)\n", + "y = x**2\n", + "\n", + "X = np.c_[x, x**2, x**3]\n", + "X = zscore_normalize_features(X) \n", + "\n", + "model_w, model_b = run_gradient_descent_feng(X, y, iterations=100000, alpha=1e-1)\n", + "\n", + "plt.scatter(x, y, marker='x', c='r', label=\"Actual Value\"); plt.title(\"Normalized x x**2, x**3 feature\")\n", + "plt.plot(x,X@model_w + model_b, label=\"Predicted Value\"); plt.xlabel(\"x\"); plt.ylabel(\"y\"); plt.legend(); plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Feature scaling allows this to converge much faster. \n", + "Note again the values of $\\mathbf{w}$. The $w_1$ term, which is the $x^2$ term is the most emphasized. Gradient descent has all but eliminated the $x^3$ term." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Complex Functions\n", + "With feature engineering, even quite complex functions can be modeled:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Iteration 0, Cost: 2.20188e-01\n", + "Iteration 100000, Cost: 1.70074e-02\n", + "Iteration 200000, Cost: 1.27603e-02\n", + "Iteration 300000, Cost: 9.73032e-03\n", + "Iteration 400000, Cost: 7.56440e-03\n", + "Iteration 500000, Cost: 6.01412e-03\n", + "Iteration 600000, Cost: 4.90251e-03\n", + "Iteration 700000, Cost: 4.10351e-03\n", + "Iteration 800000, Cost: 3.52730e-03\n", + "Iteration 900000, Cost: 3.10989e-03\n", + "w,b found by gradient descent: w: [ -1.34 -10. 24.78 5.96 -12.49 -16.26 -9.51 0.59 8.7 11.94\n", + " 9.27 0.79 -12.82], b: -0.0073\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = np.arange(0,20,1)\n", + "y = np.cos(x/2)\n", + "\n", + "X = np.c_[x, x**2, x**3,x**4, x**5, x**6, x**7, x**8, x**9, x**10, x**11, x**12, x**13]\n", + "X = zscore_normalize_features(X) \n", + "\n", + "model_w,model_b = run_gradient_descent_feng(X, y, iterations=1000000, alpha = 1e-1)\n", + "\n", + "plt.scatter(x, y, marker='x', c='r', label=\"Actual Value\"); plt.title(\"Normalized x x**2, x**3 feature\")\n", + "plt.plot(x,X@model_w + model_b, label=\"Predicted Value\"); plt.xlabel(\"x\"); plt.ylabel(\"y\"); plt.legend(); plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Congratulations!\n", + "In this lab you:\n", + "- learned how linear regression can model complex, even highly non-linear functions using feature engineering\n", + "- recognized that it is important to apply feature scaling when doing feature engineering" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + }, + "toc-autonumbering": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/week2/C1_W2_Lab05_Sklearn_GD_Soln.ipynb b/week2/C1_W2_Lab05_Sklearn_GD_Soln.ipynb new file mode 100644 index 0000000..ce0dfc0 --- /dev/null +++ b/week2/C1_W2_Lab05_Sklearn_GD_Soln.ipynb @@ -0,0 +1,277 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Optional Lab: Linear Regression using Scikit-Learn" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There is an open-source, commercially usable machine learning toolkit called [scikit-learn](https://scikit-learn.org/stable/index.html). This toolkit contains implementations of many of the algorithms that you will work with in this course.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Goals\n", + "In this lab you will:\n", + "- Utilize scikit-learn to implement linear regression using Gradient Descent" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tools\n", + "You will utilize functions from scikit-learn as well as matplotlib and NumPy. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.linear_model import SGDRegressor\n", + "from sklearn.preprocessing import StandardScaler\n", + "from lab_utils_multi import load_house_data\n", + "from lab_utils_common import dlc\n", + "np.set_printoptions(precision=2)\n", + "plt.style.use('./deeplearning.mplstyle')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Gradient Descent\n", + "Scikit-learn has a gradient descent regression model [sklearn.linear_model.SGDRegressor](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.SGDRegressor.html#examples-using-sklearn-linear-model-sgdregressor). Like your previous implementation of gradient descent, this model performs best with normalized inputs. [sklearn.preprocessing.StandardScaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html#sklearn.preprocessing.StandardScaler) will perform z-score normalization as in a previous lab. Here it is referred to as 'standard score'." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the data set" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "X_train, y_train = load_house_data()\n", + "X_features = ['size(sqft)','bedrooms','floors','age']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Scale/normalize the training data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Peak to Peak range by column in Raw X:[2.41e+03 4.00e+00 1.00e+00 9.50e+01]\n", + "Peak to Peak range by column in Normalized X:[5.85 6.14 2.06 3.69]\n" + ] + } + ], + "source": [ + "scaler = StandardScaler()\n", + "X_norm = scaler.fit_transform(X_train)\n", + "print(f\"Peak to Peak range by column in Raw X:{np.ptp(X_train,axis=0)}\") \n", + "print(f\"Peak to Peak range by column in Normalized X:{np.ptp(X_norm,axis=0)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create and fit the regression model" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "SGDRegressor(alpha=0.0001, average=False, early_stopping=False, epsilon=0.1,\n", + " eta0=0.01, fit_intercept=True, l1_ratio=0.15,\n", + " learning_rate='invscaling', loss='squared_loss', max_iter=1000,\n", + " n_iter_no_change=5, penalty='l2', power_t=0.25, random_state=None,\n", + " shuffle=True, tol=0.001, validation_fraction=0.1, verbose=0,\n", + " warm_start=False)\n", + "number of iterations completed: 135, number of weight updates: 13366.0\n" + ] + } + ], + "source": [ + "sgdr = SGDRegressor(max_iter=1000)\n", + "sgdr.fit(X_norm, y_train)\n", + "print(sgdr)\n", + "print(f\"number of iterations completed: {sgdr.n_iter_}, number of weight updates: {sgdr.t_}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### View parameters\n", + "Note, the parameters are associated with the *normalized* input data. The fit parameters are very close to those found in the previous lab with this data." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model parameters: w: [110.29 -21.12 -32.54 -38.03], b:[363.17]\n", + "model parameters from previous lab: w: [110.56 -21.27 -32.71 -37.97], b: 363.16\n" + ] + } + ], + "source": [ + "b_norm = sgdr.intercept_\n", + "w_norm = sgdr.coef_\n", + "print(f\"model parameters: w: {w_norm}, b:{b_norm}\")\n", + "print( \"model parameters from previous lab: w: [110.56 -21.27 -32.71 -37.97], b: 363.16\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Make predictions\n", + "Predict the targets of the training data. Use both the `predict` routine and compute using $w$ and $b$." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "prediction using np.dot() and sgdr.predict match: True\n", + "Prediction on training set:\n", + "[295.18 485.97 389.61 492.14]\n", + "Target values \n", + "[300. 509.8 394. 540. ]\n" + ] + } + ], + "source": [ + "# make a prediction using sgdr.predict()\n", + "y_pred_sgd = sgdr.predict(X_norm)\n", + "# make a prediction using w,b. \n", + "y_pred = np.dot(X_norm, w_norm) + b_norm \n", + "print(f\"prediction using np.dot() and sgdr.predict match: {(y_pred == y_pred_sgd).all()}\")\n", + "\n", + "print(f\"Prediction on training set:\\n{y_pred[:4]}\" )\n", + "print(f\"Target values \\n{y_train[:4]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot Results\n", + "Let's plot the predictions versus the target values." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot predictions and targets vs original features \n", + "fig,ax=plt.subplots(1,4,figsize=(12,3),sharey=True)\n", + "for i in range(len(ax)):\n", + " ax[i].scatter(X_train[:,i],y_train, label = 'target')\n", + " ax[i].set_xlabel(X_features[i])\n", + " ax[i].scatter(X_train[:,i],y_pred,color=dlc[\"dlorange\"], label = 'predict')\n", + "ax[0].set_ylabel(\"Price\"); ax[0].legend();\n", + "fig.suptitle(\"target versus prediction using z-score normalized model\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Congratulations!\n", + "In this lab you:\n", + "- utilized an open-source machine learning toolkit, scikit-learn\n", + "- implemented linear regression using gradient descent and feature normalization from that toolkit" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/week2/C1_W2_Lab06_Sklearn_Normal_Soln.ipynb b/week2/C1_W2_Lab06_Sklearn_Normal_Soln.ipynb new file mode 100644 index 0000000..7820d64 --- /dev/null +++ b/week2/C1_W2_Lab06_Sklearn_Normal_Soln.ipynb @@ -0,0 +1,241 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Optional Lab: Linear Regression using Scikit-Learn" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There is an open-source, commercially usable machine learning toolkit called [scikit-learn](https://scikit-learn.org/stable/index.html). This toolkit contains implementations of many of the algorithms that you will work with in this course.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Goals\n", + "In this lab you will:\n", + "- Utilize scikit-learn to implement linear regression using a close form solution based on the normal equation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tools\n", + "You will utilize functions from scikit-learn as well as matplotlib and NumPy. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.linear_model import LinearRegression\n", + "from lab_utils_multi import load_house_data\n", + "plt.style.use('./deeplearning.mplstyle')\n", + "np.set_printoptions(precision=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Linear Regression, closed-form solution\n", + "Scikit-learn has the [linear regression model](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html#sklearn.linear_model.LinearRegression) which implements a closed-form linear regression.\n", + "\n", + "Let's use the data from the early labs - a house with 1000 square feet sold for \\\\$300,000 and a house with 2000 square feet sold for \\\\$500,000.\n", + "\n", + "| Size (1000 sqft) | Price (1000s of dollars) |\n", + "| ----------------| ------------------------ |\n", + "| 1 | 300 |\n", + "| 2 | 500 |\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the data set" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "X_train = np.array([1.0, 2.0]) #features\n", + "y_train = np.array([300, 500]) #target value" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create and fit the model\n", + "The code below performs regression using scikit-learn. \n", + "The first step creates a regression object. \n", + "The second step utilizes one of the methods associated with the object, `fit`. This performs regression, fitting the parameters to the input data. The toolkit expects a two-dimensional X matrix." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "linear_model = LinearRegression()\n", + "#X must be a 2-D Matrix\n", + "linear_model.fit(X_train.reshape(-1, 1), y_train) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### View Parameters \n", + "The $\\mathbf{w}$ and $\\mathbf{b}$ parameters are referred to as 'coefficients' and 'intercept' in scikit-learn." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "b = linear_model.intercept_\n", + "w = linear_model.coef_\n", + "print(f\"w = {w:}, b = {b:0.2f}\")\n", + "print(f\"'manual' prediction: f_wb = wx+b : {1200*w + b}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Make Predictions\n", + "\n", + "Calling the `predict` function generates predictions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "y_pred = linear_model.predict(X_train.reshape(-1, 1))\n", + "\n", + "print(\"Prediction on training set:\", y_pred)\n", + "\n", + "X_test = np.array([[1200]])\n", + "print(f\"Prediction for 1200 sqft house: ${linear_model.predict(X_test)[0]:0.2f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Second Example\n", + "The second example is from an earlier lab with multiple features. The final parameter values and predictions are very close to the results from the un-normalized 'long-run' from that lab. That un-normalized run took hours to produce results, while this is nearly instantaneous. The closed-form solution work well on smaller data sets such as these but can be computationally demanding on larger data sets. \n", + ">The closed-form solution does not require normalization." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# load the dataset\n", + "X_train, y_train = load_house_data()\n", + "X_features = ['size(sqft)','bedrooms','floors','age']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "linear_model = LinearRegression()\n", + "linear_model.fit(X_train, y_train) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "b = linear_model.intercept_\n", + "w = linear_model.coef_\n", + "print(f\"w = {w:}, b = {b:0.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(f\"Prediction on training set:\\n {linear_model.predict(X_train)[:4]}\" )\n", + "print(f\"prediction using w,b:\\n {(X_train @ w + b)[:4]}\")\n", + "print(f\"Target values \\n {y_train[:4]}\")\n", + "\n", + "x_house = np.array([1200, 3,1, 40]).reshape(-1,4)\n", + "x_house_predict = linear_model.predict(x_house)[0]\n", + "print(f\" predicted price of a house with 1200 sqft, 3 bedrooms, 1 floor, 40 years old = ${x_house_predict*1000:0.2f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Congratulations!\n", + "In this lab you:\n", + "- utilized an open-source machine learning toolkit, scikit-learn\n", + "- implemented linear regression using a close-form solution from that toolkit" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/week2/archive/C1_W2_Lab01_Python_Numpy_Vectorization_Soln-Copy1.ipynb b/week2/archive/C1_W2_Lab01_Python_Numpy_Vectorization_Soln-Copy1.ipynb new file mode 100644 index 0000000..8e137d2 --- /dev/null +++ b/week2/archive/C1_W2_Lab01_Python_Numpy_Vectorization_Soln-Copy1.ipynb @@ -0,0 +1,730 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Optional Lab: Python, NumPy and Vectorization\n", + "A brief introduction to some of the scientific computing used in this course. In particular the NumPy scientific computing package and its use with python.\n", + "\n", + "# Outline\n", + "- [  1.1 Goals](#toc_40015_1.1)\n", + "- [  1.2 Useful References](#toc_40015_1.2)\n", + "- [2 Python and NumPy ](#toc_40015_2)\n", + "- [3 Vectors](#toc_40015_3)\n", + "- [  3.1 Abstract](#toc_40015_3.1)\n", + "- [  3.2 NumPy Arrays](#toc_40015_3.2)\n", + "- [  3.3 Vector Creation](#toc_40015_3.3)\n", + "- [  3.4 Operations on Vectors](#toc_40015_3.4)\n", + "- [4 Matrices](#toc_40015_4)\n", + "- [  4.1 Abstract](#toc_40015_4.1)\n", + "- [  4.2 NumPy Arrays](#toc_40015_4.2)\n", + "- [  4.3 Matrix Creation](#toc_40015_4.3)\n", + "- [  4.4 Operations on Matrices](#toc_40015_4.4)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np # it is an unofficial standard to use np for numpy\n", + "import time" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 1.1 Goals\n", + "In this lab, you will:\n", + "- Review the features of NumPy and Python that are used in Course 1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 1.2 Useful References\n", + "- NumPy Documentation including a basic introduction: [NumPy.org](https://NumPy.org/doc/stable/)\n", + "- A challenging feature topic: [NumPy Broadcasting](https://NumPy.org/doc/stable/user/basics.broadcasting.html)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# 2 Python and NumPy \n", + "Python is the programming language we will be using in this course. It has a set of numeric data types and arithmetic operations. NumPy is a library that extends the base capabilities of python to add a richer data set including more numeric types, vectors, matrices, and many matrix functions. NumPy and python work together fairly seamlessly. Python arithmetic operators work on NumPy data types and many NumPy functions will accept python data types.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# 3 Vectors\n", + "\n", + "## 3.1 Abstract\n", + "Vectors, as you will use them in this course, are ordered arrays of numbers. In notation, vectors are denoted with lower case bold letters such as $\\mathbf{x}$. The elements of a vector are all the same type. A vector does not, for example, contain both characters and numbers. The number of elements in the array is often referred to as the *dimension* though mathematicians may prefer *rank*. The vector shown has a dimension of $n$. The elements of a vector can be referenced with an index. In math settings, indexes typically run from 1 to n. In computer science and these labs, indexing will typically run from 0 to n-1. In notation, elements of a vector, when referenced individually will indicate the index in a subscript, for example, the $0^{th}$ element, of the vector $\\mathbf{x}$ is $x_0$. Note, the x is not bold in this case. \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 3.2 NumPy Arrays\n", + "\n", + "NumPy's basic data structure is an indexable, n-dimensional *array* containing elements of the same type (`dtype`). Right away, you may notice we have overloaded the term 'dimension'. Above, it was the number of elements in the vector, here, dimension refers to the number of indexes of an array. A one-dimensional or 1-D array has one index. In Course 1, we will represent vectors as NumPy 1-D arrays. \n", + "\n", + " - 1-D array, shape (n,): n elements indexed [0] through [n-1]\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 3.3 Vector Creation\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Data creation routines in NumPy will generally have a first parameter which is the shape of the object. This can either be a single value for a 1-D result or a tuple (n,m,...) specifying the shape of the result. Below are examples of creating vectors using these routines." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# NumPy routines which allocate memory and fill arrays with value\n", + "a = np.zeros(4); print(f\"np.zeros(4) : a = {a}, a shape = {a.shape}, a data type = {a.dtype}\")\n", + "a = np.zeros((4,)); print(f\"np.zeros(4,) : a = {a}, a shape = {a.shape}, a data type = {a.dtype}\")\n", + "a = np.random.random_sample(4); print(f\"np.random.random_sample(4): a = {a}, a shape = {a.shape}, a data type = {a.dtype}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Some data creation routines do not take a shape tuple:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# NumPy routines which allocate memory and fill arrays with value but do not accept shape as input argument\n", + "a = np.arange(4.); print(f\"np.arange(4.): a = {a}, a shape = {a.shape}, a data type = {a.dtype}\")\n", + "a = np.random.rand(4); print(f\"np.random.rand(4): a = {a}, a shape = {a.shape}, a data type = {a.dtype}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "values can be specified manually as well. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# NumPy routines which allocate memory and fill with user specified values\n", + "a = np.array([5,4,3,2]); print(f\"np.array([5,4,3,2]): a = {a}, a shape = {a.shape}, a data type = {a.dtype}\")\n", + "a = np.array([5.,4,3,2]); print(f\"np.array([5.,4,3,2]): a = {a}, a shape = {a.shape}, a data type = {a.dtype}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These have all created a one-dimensional vector `a` with four elements. `a.shape` returns the dimensions. Here we see a.shape = `(4,)` indicating a 1-d array with 4 elements. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 3.4 Operations on Vectors\n", + "Let's explore some operations using vectors.\n", + "\n", + "### 3.4.1 Indexing\n", + "Elements of vectors can be accessed via indexing and slicing. NumPy provides a very complete set of indexing and slicing capabilities. We will explore only the basics needed for the course here. Reference [Slicing and Indexing](https://NumPy.org/doc/stable/reference/arrays.indexing.html) for more details. \n", + "**Indexing** means referring to *an element* of an array by its position within the array. \n", + "**Slicing** means getting a *subset* of elements from an array based on their indices. \n", + "NumPy starts indexing at zero so the 3rd element of an vector $\\mathbf{a}$ is `a[2]`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#vector indexing operations on 1-D vectors\n", + "a = np.arange(10)\n", + "print(a)\n", + "\n", + "#access an element\n", + "print(f\"a[2].shape: {a[2].shape} a[2] = {a[2]}, Accessing an element returns a scalar\")\n", + "\n", + "# access the last element, negative indexes count from the end\n", + "print(f\"a[-1] = {a[-1]}\")\n", + "\n", + "#indexs must be within the range of the vector or they will produce and error\n", + "try:\n", + " c = a[10]\n", + "except Exception as e:\n", + " print(\"The error message you'll see is:\")\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.4.2 Slicing\n", + "Slicing creates an array of indices using a set of three values (`start:stop:step`). A subset of values is also valid. Its use is best explained by example:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#vector slicing operations\n", + "a = np.arange(10)\n", + "print(f\"a = {a}\")\n", + "\n", + "#access 5 consecutive elements (start:stop:step)\n", + "c = a[2:7:1]; print(\"a[2:7:1] = \", c)\n", + "\n", + "# access 3 elements separated by two \n", + "c = a[2:7:2]; print(\"a[2:7:2] = \", c)\n", + "\n", + "# access all elements index 3 and above\n", + "c = a[3:]; print(\"a[3:] = \", c)\n", + "\n", + "# access all elements below index 3\n", + "c = a[:3]; print(\"a[:3] = \", c)\n", + "\n", + "# access all elements\n", + "c = a[:]; print(\"a[:] = \", c)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.4.3 Single vector operations\n", + "There are a number of useful operations that involve operations on a single vector." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = np.array([1,2,3,4])\n", + "print(f\"a : {a}\")\n", + "# negate elements of a\n", + "b = -a \n", + "print(f\"b = -a : {b}\")\n", + "\n", + "# sum all elements of a, returns a scalar\n", + "b = np.sum(a) \n", + "print(f\"b = np.sum(a) : {b}\")\n", + "\n", + "b = np.mean(a)\n", + "print(f\"b = np.mean(a): {b}\")\n", + "\n", + "b = a**2\n", + "print(f\"b = a**2 : {b}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.4.4 Vector Vector element-wise operations\n", + "Most of the NumPy arithmetic, logical and comparison operations apply to vectors as well. These operators work on an element-by-element basis. For example \n", + "$$ \\mathbf{a} + \\mathbf{b} = \\sum_{i=0}^{n-1} a_i + b_i $$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = np.array([ 1, 2, 3, 4])\n", + "b = np.array([-1,-2, 3, 4])\n", + "print(f\"Binary operators work element wise: {a + b}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Of course, for this to work correctly, the vectors must be of the same size:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#try a mismatched vector operation\n", + "c = np.array([1, 2])\n", + "try:\n", + " d = a + c\n", + "except Exception as e:\n", + " print(\"The error message you'll see is:\")\n", + " print(e)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.4.5 Scalar Vector operations\n", + "Vectors can be 'scaled' by scalar values. A scalar value is just a number. The scalar multiplies all the elements of the vector." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = np.array([1, 2, 3, 4])\n", + "\n", + "# multiply a by a scalar\n", + "b = 5 * a \n", + "print(f\"b = 5 * a : {b}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.4.6 Vector Vector dot product\n", + "The dot product is a mainstay of Linear Algebra and NumPy. This is an operation used extensively in this course and should be well understood. The dot product is shown below." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The dot product multiplies the values in two vectors element-wise and then sums the result.\n", + "Vector dot product requires the dimensions of the two vectors to be the same. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's implement our own version of the dot product below:\n", + "\n", + "**Using a for loop**, implement a function which returns the dot product of two vectors. The function to return given inputs $a$ and $b$:\n", + "$$ x = \\sum_{i=0}^{n-1} a_i b_i $$\n", + "Assume both `a` and `b` are the same shape." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def my_dot(a, b): \n", + " \"\"\"\n", + " Compute the dot product of two vectors\n", + " \n", + " Args:\n", + " a (ndarray (n,)): input vector \n", + " b (ndarray (n,)): input vector with same dimension as a\n", + " \n", + " Returns:\n", + " x (scalar): \n", + " \"\"\"\n", + " x=0\n", + " for i in range(a.shape[0]):\n", + " x = x + a[i] * b[i]\n", + " return x" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# test 1-D\n", + "a = np.array([1, 2, 3, 4])\n", + "b = np.array([-1, 4, 3, 2])\n", + "print(f\"my_dot(a, b) = {my_dot(a, b)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note, the dot product is expected to return a scalar value. \n", + "\n", + "Let's try the same operations using `np.dot`. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# test 1-D\n", + "a = np.array([1, 2, 3, 4])\n", + "b = np.array([-1, 4, 3, 2])\n", + "c = np.dot(a, b)\n", + "print(f\"NumPy 1-D np.dot(a, b) = {c}, np.dot(a, b).shape = {c.shape} \") \n", + "c = np.dot(b, a)\n", + "print(f\"NumPy 1-D np.dot(b, a) = {c}, np.dot(a, b).shape = {c.shape} \")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Above, you will note that the results for 1-D matched our implementation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.4.7 The Need for Speed: vector vs for loop\n", + "We utilized the NumPy library because it improves speed memory efficiency. Let's demonstrate:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(1)\n", + "a = np.random.rand(10000000) # very large arrays\n", + "b = np.random.rand(10000000)\n", + "\n", + "tic = time.time() # capture start time\n", + "c = np.dot(a, b)\n", + "toc = time.time() # capture end time\n", + "\n", + "print(f\"np.dot(a, b) = {c:.4f}\")\n", + "print(f\"Vectorized version duration: {1000*(toc-tic):.4f} ms \")\n", + "\n", + "tic = time.time() # capture start time\n", + "c = my_dot(a,b)\n", + "toc = time.time() # capture end time\n", + "\n", + "print(f\"my_dot(a, b) = {c:.4f}\")\n", + "print(f\"loop version duration: {1000*(toc-tic):.4f} ms \")\n", + "\n", + "del(a);del(b) #remove these big arrays from memory" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So, vectorization provides a large speed up in this example. This is because NumPy makes better use of available data parallelism in the underlying hardware. GPU's and modern CPU's implement Single Instruction, Multiple Data (SIMD) pipelines allowing multiple operations to be issued in parallel. This is critical in Machine Learning where the data sets are often very large." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 3.4.8 Vector Vector operations in Course 1\n", + "Vector Vector operations will appear frequently in course 1. Here is why:\n", + "- Going forward, our examples will be stored in an array, `X_train` of dimension (m,n). This will be explained more in context, but here it is important to note it is a 2 Dimensional array or matrix (see next section on matrices).\n", + "- `w` will be a 1-dimensional vector of shape (n,).\n", + "- we will perform operations by looping through the examples, extracting each example to work on individually by indexing X. For example:`X[i]`\n", + "- `X[i]` returns a value of shape (n,), a 1-dimensional vector. Consequently, operations involving `X[i]` are often vector-vector. \n", + "\n", + "That is a somewhat lengthy explanation, but aligning and understanding the shapes of your operands is important when performing vector operations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# show common Course 1 example\n", + "X = np.array([[1],[2],[3],[4]])\n", + "w = np.array([2])\n", + "c = np.dot(X[1], w)\n", + "\n", + "print(f\"X[1] has shape {X[1].shape}\")\n", + "print(f\"w has shape {w.shape}\")\n", + "print(f\"c has shape {c.shape}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# 4 Matrices\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 4.1 Abstract\n", + "Matrices, are two dimensional arrays. The elements of a matrix are all of the same type. In notation, matrices are denoted with capitol, bold letter such as $\\mathbf{X}$. In this and other labs, `m` is often the number of rows and `n` the number of columns. The elements of a matrix can be referenced with a two dimensional index. In math settings, numbers in the index typically run from 1 to n. In computer science and these labs, indexing will run from 0 to n-1. \n", + "
\n", + "
missing
\n", + "
Generic Matrix Notation, 1st index is row, 2nd is column
\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 4.2 NumPy Arrays\n", + "\n", + "NumPy's basic data structure is an indexable, n-dimensional *array* containing elements of the same type (`dtype`). These were described earlier. Matrices have a two-dimensional (2-D) index [m,n].\n", + "\n", + "In Course 1, 2-D matrices are used to hold training data. Training data is $m$ examples by $n$ features creating an (m,n) array. Course 1 does not do operations directly on matrices but typically extracts an example as a vector and operates on that. Below you will review: \n", + "- data creation\n", + "- slicing and indexing" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 4.3 Matrix Creation\n", + "The same functions that created 1-D vectors will create 2-D or n-D arrays. Here are some examples\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below, the shape tuple is provided to achieve a 2-D result. Notice how NumPy uses brackets to denote each dimension. Notice further than NumPy, when printing, will print one row per line.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "a = np.zeros((1, 5)) \n", + "print(f\"a shape = {a.shape}, a = {a}\") \n", + "\n", + "a = np.zeros((2, 1)) \n", + "print(f\"a shape = {a.shape}, a = {a}\") \n", + "\n", + "a = np.random.random_sample((1, 1)) \n", + "print(f\"a shape = {a.shape}, a = {a}\") " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One can also manually specify data. Dimensions are specified with additional brackets matching the format in the printing above." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# NumPy routines which allocate memory and fill with user specified values\n", + "a = np.array([[5], [4], [3]]); print(f\" a shape = {a.shape}, np.array: a = {a}\")\n", + "a = np.array([[5], # One can also\n", + " [4], # separate values\n", + " [3]]); #into separate rows\n", + "print(f\" a shape = {a.shape}, np.array: a = {a}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## 4.4 Operations on Matrices\n", + "Let's explore some operations using matrices." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.4.1 Indexing\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Matrices include a second index. The two indexes describe [row, column]. Access can either return an element or a row/column. See below:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#vector indexing operations on matrices\n", + "a = np.arange(6).reshape(-1, 2) #reshape is a convenient way to create matrices\n", + "print(f\"a.shape: {a.shape}, \\na= {a}\")\n", + "\n", + "#access an element\n", + "print(f\"\\na[2,0].shape: {a[2, 0].shape}, a[2,0] = {a[2, 0]}, type(a[2,0]) = {type(a[2, 0])} Accessing an element returns a scalar\\n\")\n", + "\n", + "#access a row\n", + "print(f\"a[2].shape: {a[2].shape}, a[2] = {a[2]}, type(a[2]) = {type(a[2])}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is worth drawing attention to the last example. Accessing a matrix by just specifying the row will return a *1-D vector*." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Reshape** \n", + "The previous example used [reshape](https://numpy.org/doc/stable/reference/generated/numpy.reshape.html) to shape the array. \n", + "`a = np.arange(6).reshape(-1, 2) ` \n", + "This line of code first created a *1-D Vector* of six elements. It then reshaped that vector into a *2-D* array using the reshape command. This could have been written: \n", + "`a = np.arange(6).reshape(3, 2) ` \n", + "To arrive at the same 3 row, 2 column array.\n", + "The -1 argument tells the routine to compute the number of rows given the size of the array and the number of columns.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "### 4.4.2 Slicing\n", + "Slicing creates an array of indices using a set of three values (`start:stop:step`). A subset of values is also valid. Its use is best explained by example:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#vector 2-D slicing operations\n", + "a = np.arange(20).reshape(-1, 10)\n", + "print(f\"a = \\n{a}\")\n", + "\n", + "#access 5 consecutive elements (start:stop:step)\n", + "print(\"a[0, 2:7:1] = \", a[0, 2:7:1], \", a[0, 2:7:1].shape =\", a[0, 2:7:1].shape, \"a 1-D array\")\n", + "\n", + "#access 5 consecutive elements (start:stop:step) in two rows\n", + "print(\"a[:, 2:7:1] = \\n\", a[:, 2:7:1], \", a[:, 2:7:1].shape =\", a[:, 2:7:1].shape, \"a 2-D array\")\n", + "\n", + "# access all elements\n", + "print(\"a[:,:] = \\n\", a[:,:], \", a[:,:].shape =\", a[:,:].shape)\n", + "\n", + "# access all elements in one row (very common usage)\n", + "print(\"a[1,:] = \", a[1,:], \", a[1,:].shape =\", a[1,:].shape, \"a 1-D array\")\n", + "# same as\n", + "print(\"a[1] = \", a[1], \", a[1].shape =\", a[1].shape, \"a 1-D array\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Congratulations!\n", + "In this lab you mastered the features of Python and NumPy that are needed for Course 1." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "dl_toc_settings": { + "rndtag": "40015" + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.10" + }, + "toc-autonumbering": false + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/week2/data/houses.txt b/week2/data/houses.txt new file mode 100644 index 0000000..a9f6f69 --- /dev/null +++ b/week2/data/houses.txt @@ -0,0 +1,100 @@ +9.520000000000000000e+02,2.000000000000000000e+00,1.000000000000000000e+00,6.500000000000000000e+01,2.715000000000000000e+02 +1.244000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,6.400000000000000000e+01,3.000000000000000000e+02 +1.947000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,1.700000000000000000e+01,5.098000000000000114e+02 +1.725000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,4.200000000000000000e+01,3.940000000000000000e+02 +1.959000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,1.500000000000000000e+01,5.400000000000000000e+02 +1.314000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,1.400000000000000000e+01,4.150000000000000000e+02 +8.640000000000000000e+02,2.000000000000000000e+00,1.000000000000000000e+00,6.600000000000000000e+01,2.300000000000000000e+02 +1.836000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,1.700000000000000000e+01,5.600000000000000000e+02 +1.026000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,4.300000000000000000e+01,2.940000000000000000e+02 +3.194000000000000000e+03,4.000000000000000000e+00,2.000000000000000000e+00,8.700000000000000000e+01,7.182000000000000455e+02 +7.880000000000000000e+02,2.000000000000000000e+00,1.000000000000000000e+00,8.000000000000000000e+01,2.000000000000000000e+02 +1.200000000000000000e+03,2.000000000000000000e+00,2.000000000000000000e+00,1.700000000000000000e+01,3.020000000000000000e+02 +1.557000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,1.800000000000000000e+01,4.680000000000000000e+02 +1.430000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,2.000000000000000000e+01,3.741999999999999886e+02 +1.220000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,1.500000000000000000e+01,3.880000000000000000e+02 +1.092000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,6.400000000000000000e+01,2.820000000000000000e+02 +8.480000000000000000e+02,1.000000000000000000e+00,1.000000000000000000e+00,1.700000000000000000e+01,3.118000000000000114e+02 +1.682000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,2.300000000000000000e+01,4.010000000000000000e+02 +1.768000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,1.800000000000000000e+01,4.498000000000000114e+02 +1.040000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,4.400000000000000000e+01,3.010000000000000000e+02 +1.652000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,2.100000000000000000e+01,5.020000000000000000e+02 +1.088000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,3.500000000000000000e+01,3.400000000000000000e+02 +1.316000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,1.400000000000000000e+01,4.002819999999999823e+02 +1.593000000000000000e+03,0.000000000000000000e+00,1.000000000000000000e+00,2.000000000000000000e+01,5.720000000000000000e+02 +9.720000000000000000e+02,2.000000000000000000e+00,1.000000000000000000e+00,7.300000000000000000e+01,2.640000000000000000e+02 +1.097000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,3.700000000000000000e+01,3.040000000000000000e+02 +1.004000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,5.100000000000000000e+01,2.980000000000000000e+02 +9.040000000000000000e+02,3.000000000000000000e+00,1.000000000000000000e+00,5.500000000000000000e+01,2.198000000000000114e+02 +1.694000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,1.300000000000000000e+01,4.906999999999999886e+02 +1.073000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,1.000000000000000000e+02,2.169600000000000080e+02 +1.419000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,1.900000000000000000e+01,3.681999999999999886e+02 +1.164000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,5.200000000000000000e+01,2.800000000000000000e+02 +1.935000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,1.200000000000000000e+01,5.268700000000000045e+02 +1.216000000000000000e+03,2.000000000000000000e+00,2.000000000000000000e+00,7.400000000000000000e+01,2.370000000000000000e+02 +2.482000000000000000e+03,4.000000000000000000e+00,2.000000000000000000e+00,1.600000000000000000e+01,5.624260000000000446e+02 +1.200000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,1.800000000000000000e+01,3.698000000000000114e+02 +1.840000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,2.000000000000000000e+01,4.600000000000000000e+02 +1.851000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,5.700000000000000000e+01,3.740000000000000000e+02 +1.660000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,1.900000000000000000e+01,3.900000000000000000e+02 +1.096000000000000000e+03,2.000000000000000000e+00,2.000000000000000000e+00,9.700000000000000000e+01,1.580000000000000000e+02 +1.775000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,2.800000000000000000e+01,4.260000000000000000e+02 +2.030000000000000000e+03,4.000000000000000000e+00,2.000000000000000000e+00,4.500000000000000000e+01,3.900000000000000000e+02 +1.784000000000000000e+03,4.000000000000000000e+00,2.000000000000000000e+00,1.070000000000000000e+02,2.777740000000000009e+02 +1.073000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,1.000000000000000000e+02,2.169600000000000080e+02 +1.552000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,1.600000000000000000e+01,4.258000000000000114e+02 +1.953000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,1.600000000000000000e+01,5.040000000000000000e+02 +1.224000000000000000e+03,2.000000000000000000e+00,2.000000000000000000e+00,1.200000000000000000e+01,3.290000000000000000e+02 +1.616000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,1.600000000000000000e+01,4.640000000000000000e+02 +8.160000000000000000e+02,2.000000000000000000e+00,1.000000000000000000e+00,5.800000000000000000e+01,2.200000000000000000e+02 +1.349000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,2.100000000000000000e+01,3.580000000000000000e+02 +1.571000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,1.400000000000000000e+01,4.780000000000000000e+02 +1.486000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,5.700000000000000000e+01,3.340000000000000000e+02 +1.506000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,1.600000000000000000e+01,4.269800000000000182e+02 +1.097000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,2.700000000000000000e+01,2.900000000000000000e+02 +1.764000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,2.400000000000000000e+01,4.630000000000000000e+02 +1.208000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,1.400000000000000000e+01,3.908000000000000114e+02 +1.470000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,2.400000000000000000e+01,3.540000000000000000e+02 +1.768000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,8.400000000000000000e+01,3.500000000000000000e+02 +1.654000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,1.900000000000000000e+01,4.600000000000000000e+02 +1.029000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,6.000000000000000000e+01,2.370000000000000000e+02 +1.120000000000000000e+03,2.000000000000000000e+00,2.000000000000000000e+00,1.600000000000000000e+01,2.883039999999999736e+02 +1.150000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,6.200000000000000000e+01,2.820000000000000000e+02 +8.160000000000000000e+02,2.000000000000000000e+00,1.000000000000000000e+00,3.900000000000000000e+01,2.490000000000000000e+02 +1.040000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,2.500000000000000000e+01,3.040000000000000000e+02 +1.392000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,6.400000000000000000e+01,3.320000000000000000e+02 +1.603000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,2.900000000000000000e+01,3.518000000000000114e+02 +1.215000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,6.300000000000000000e+01,3.100000000000000000e+02 +1.073000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,1.000000000000000000e+02,2.169600000000000080e+02 +2.599000000000000000e+03,4.000000000000000000e+00,2.000000000000000000e+00,2.200000000000000000e+01,6.663360000000000127e+02 +1.431000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,5.900000000000000000e+01,3.300000000000000000e+02 +2.090000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,2.600000000000000000e+01,4.800000000000000000e+02 +1.790000000000000000e+03,4.000000000000000000e+00,2.000000000000000000e+00,4.900000000000000000e+01,3.303000000000000114e+02 +1.484000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,1.600000000000000000e+01,3.480000000000000000e+02 +1.040000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,2.500000000000000000e+01,3.040000000000000000e+02 +1.431000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,2.200000000000000000e+01,3.840000000000000000e+02 +1.159000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,5.300000000000000000e+01,3.160000000000000000e+02 +1.547000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,1.200000000000000000e+01,4.303999999999999773e+02 +1.983000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,2.200000000000000000e+01,4.500000000000000000e+02 +1.056000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,5.300000000000000000e+01,2.840000000000000000e+02 +1.180000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,9.900000000000000000e+01,2.750000000000000000e+02 +1.358000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,1.700000000000000000e+01,4.140000000000000000e+02 +9.600000000000000000e+02,3.000000000000000000e+00,1.000000000000000000e+00,5.100000000000000000e+01,2.580000000000000000e+02 +1.456000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,1.600000000000000000e+01,3.780000000000000000e+02 +1.446000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,2.500000000000000000e+01,3.500000000000000000e+02 +1.208000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,1.500000000000000000e+01,4.120000000000000000e+02 +1.553000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,1.600000000000000000e+01,3.730000000000000000e+02 +8.820000000000000000e+02,3.000000000000000000e+00,1.000000000000000000e+00,4.900000000000000000e+01,2.250000000000000000e+02 +2.030000000000000000e+03,4.000000000000000000e+00,2.000000000000000000e+00,4.500000000000000000e+01,3.900000000000000000e+02 +1.040000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,6.200000000000000000e+01,2.673999999999999773e+02 +1.616000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,1.600000000000000000e+01,4.640000000000000000e+02 +8.030000000000000000e+02,2.000000000000000000e+00,1.000000000000000000e+00,8.000000000000000000e+01,1.740000000000000000e+02 +1.430000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,2.100000000000000000e+01,3.400000000000000000e+02 +1.656000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,6.100000000000000000e+01,4.300000000000000000e+02 +1.541000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,1.600000000000000000e+01,4.400000000000000000e+02 +9.480000000000000000e+02,3.000000000000000000e+00,1.000000000000000000e+00,5.300000000000000000e+01,2.160000000000000000e+02 +1.224000000000000000e+03,2.000000000000000000e+00,2.000000000000000000e+00,1.200000000000000000e+01,3.290000000000000000e+02 +1.432000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,4.300000000000000000e+01,3.880000000000000000e+02 +1.660000000000000000e+03,3.000000000000000000e+00,2.000000000000000000e+00,1.900000000000000000e+01,3.900000000000000000e+02 +1.212000000000000000e+03,3.000000000000000000e+00,1.000000000000000000e+00,2.000000000000000000e+01,3.560000000000000000e+02 +1.050000000000000000e+03,2.000000000000000000e+00,1.000000000000000000e+00,6.500000000000000000e+01,2.578000000000000114e+02 diff --git a/week2/deeplearning.mplstyle b/week2/deeplearning.mplstyle new file mode 100644 index 0000000..a77929b --- /dev/null +++ b/week2/deeplearning.mplstyle @@ -0,0 +1,124 @@ +# see https://matplotlib.org/stable/tutorials/introductory/customizing.html +lines.linewidth: 4 +lines.solid_capstyle: butt + +legend.fancybox: true + +# Verdana" for non-math text, +# Cambria Math + +#Blue (Crayon-Aqua) 0096FF +#Dark Red C00000 +#Orange (Apple Orange) FF9300 +#Black 000000 +#Magenta FF40FF +#Purple 7030A0 + +axes.prop_cycle: cycler('color', ['0096FF', 'FF9300', 'FF40FF', '7030A0', 'C00000']) +#axes.facecolor: f0f0f0 # grey +axes.facecolor: ffffff # white +axes.labelsize: large +axes.axisbelow: true +axes.grid: False +axes.edgecolor: f0f0f0 +axes.linewidth: 3.0 +axes.titlesize: x-large + +patch.edgecolor: f0f0f0 +patch.linewidth: 0.5 + +svg.fonttype: path + +grid.linestyle: - +grid.linewidth: 1.0 +grid.color: cbcbcb + +xtick.major.size: 0 +xtick.minor.size: 0 +ytick.major.size: 0 +ytick.minor.size: 0 + +savefig.edgecolor: f0f0f0 +savefig.facecolor: f0f0f0 + +#figure.subplot.left: 0.08 +#figure.subplot.right: 0.95 +#figure.subplot.bottom: 0.07 + +#figure.facecolor: f0f0f0 # grey +figure.facecolor: ffffff # white + +## *************************************************************************** +## * FONT * +## *************************************************************************** +## The font properties used by `text.Text`. +## See https://matplotlib.org/api/font_manager_api.html for more information +## on font properties. The 6 font properties used for font matching are +## given below with their default values. +## +## The font.family property can take either a concrete font name (not supported +## when rendering text with usetex), or one of the following five generic +## values: +## - 'serif' (e.g., Times), +## - 'sans-serif' (e.g., Helvetica), +## - 'cursive' (e.g., Zapf-Chancery), +## - 'fantasy' (e.g., Western), and +## - 'monospace' (e.g., Courier). +## Each of these values has a corresponding default list of font names +## (font.serif, etc.); the first available font in the list is used. Note that +## for font.serif, font.sans-serif, and font.monospace, the first element of +## the list (a DejaVu font) will always be used because DejaVu is shipped with +## Matplotlib and is thus guaranteed to be available; the other entries are +## left as examples of other possible values. +## +## The font.style property has three values: normal (or roman), italic +## or oblique. The oblique style will be used for italic, if it is not +## present. +## +## The font.variant property has two values: normal or small-caps. For +## TrueType fonts, which are scalable fonts, small-caps is equivalent +## to using a font size of 'smaller', or about 83%% of the current font +## size. +## +## The font.weight property has effectively 13 values: normal, bold, +## bolder, lighter, 100, 200, 300, ..., 900. Normal is the same as +## 400, and bold is 700. bolder and lighter are relative values with +## respect to the current weight. +## +## The font.stretch property has 11 values: ultra-condensed, +## extra-condensed, condensed, semi-condensed, normal, semi-expanded, +## expanded, extra-expanded, ultra-expanded, wider, and narrower. This +## property is not currently implemented. +## +## The font.size property is the default font size for text, given in points. +## 10 pt is the standard value. +## +## Note that font.size controls default text sizes. To configure +## special text sizes tick labels, axes, labels, title, etc., see the rc +## settings for axes and ticks. Special text sizes can be defined +## relative to font.size, using the following values: xx-small, x-small, +## small, medium, large, x-large, xx-large, larger, or smaller + + +font.family: sans-serif +font.style: normal +font.variant: normal +font.weight: normal +font.stretch: normal +font.size: 12.0 + +font.serif: DejaVu Serif, Bitstream Vera Serif, Computer Modern Roman, New Century Schoolbook, Century Schoolbook L, Utopia, ITC Bookman, Bookman, Nimbus Roman No9 L, Times New Roman, Times, Palatino, Charter, serif +font.sans-serif: Verdana, DejaVu Sans, Bitstream Vera Sans, Computer Modern Sans Serif, Lucida Grande, Geneva, Lucid, Arial, Helvetica, Avant Garde, sans-serif +font.cursive: Apple Chancery, Textile, Zapf Chancery, Sand, Script MT, Felipa, Comic Neue, Comic Sans MS, cursive +font.fantasy: Chicago, Charcoal, Impact, Western, Humor Sans, xkcd, fantasy +font.monospace: DejaVu Sans Mono, Bitstream Vera Sans Mono, Computer Modern Typewriter, Andale Mono, Nimbus Mono L, Courier New, Courier, Fixed, Terminal, monospace + + +## *************************************************************************** +## * TEXT * +## *************************************************************************** +## The text properties used by `text.Text`. +## See https://matplotlib.org/api/artist_api.html#module-matplotlib.text +## for more information on text properties +#text.color: black + diff --git a/week2/images/C1_W2_L1_S1_Lecture_b.png b/week2/images/C1_W2_L1_S1_Lecture_b.png new file mode 100644 index 0000000..6b6120e Binary files /dev/null and b/week2/images/C1_W2_L1_S1_Lecture_b.png differ diff --git a/week2/images/C1_W2_L1_S1_model.png b/week2/images/C1_W2_L1_S1_model.png new file mode 100644 index 0000000..c7e1076 Binary files /dev/null and b/week2/images/C1_W2_L1_S1_model.png differ diff --git a/week2/images/C1_W2_L1_S1_trainingdata.png b/week2/images/C1_W2_L1_S1_trainingdata.png new file mode 100644 index 0000000..19aeea9 Binary files /dev/null and b/week2/images/C1_W2_L1_S1_trainingdata.png differ diff --git a/week2/images/C1_W2_L1_S2_Lectureb.png b/week2/images/C1_W2_L1_S2_Lectureb.png new file mode 100644 index 0000000..737a39a Binary files /dev/null and b/week2/images/C1_W2_L1_S2_Lectureb.png differ diff --git a/week2/images/C1_W2_L2_S1_Lecture_GD.png b/week2/images/C1_W2_L2_S1_Lecture_GD.png new file mode 100644 index 0000000..c21a949 Binary files /dev/null and b/week2/images/C1_W2_L2_S1_Lecture_GD.png differ diff --git a/week2/images/C1_W2_Lab02_GoalOfRegression.PNG b/week2/images/C1_W2_Lab02_GoalOfRegression.PNG new file mode 100644 index 0000000..fddc8da Binary files /dev/null and b/week2/images/C1_W2_Lab02_GoalOfRegression.PNG differ diff --git a/week2/images/C1_W2_Lab03_alpha_to_big.PNG b/week2/images/C1_W2_Lab03_alpha_to_big.PNG new file mode 100644 index 0000000..540b33d Binary files /dev/null and b/week2/images/C1_W2_Lab03_alpha_to_big.PNG differ diff --git a/week2/images/C1_W2_Lab03_lecture_learningrate.PNG b/week2/images/C1_W2_Lab03_lecture_learningrate.PNG new file mode 100644 index 0000000..f81e034 Binary files /dev/null and b/week2/images/C1_W2_Lab03_lecture_learningrate.PNG differ diff --git a/week2/images/C1_W2_Lab03_lecture_slopes.PNG b/week2/images/C1_W2_Lab03_lecture_slopes.PNG new file mode 100644 index 0000000..f77d3d9 Binary files /dev/null and b/week2/images/C1_W2_Lab03_lecture_slopes.PNG differ diff --git a/week2/images/C1_W2_Lab04_Figures And animations.pptx b/week2/images/C1_W2_Lab04_Figures And animations.pptx new file mode 100644 index 0000000..874900d Binary files /dev/null and b/week2/images/C1_W2_Lab04_Figures And animations.pptx differ diff --git a/week2/images/C1_W2_Lab04_Matrices.PNG b/week2/images/C1_W2_Lab04_Matrices.PNG new file mode 100644 index 0000000..3f70f51 Binary files /dev/null and b/week2/images/C1_W2_Lab04_Matrices.PNG differ diff --git a/week2/images/C1_W2_Lab04_Vectors.PNG b/week2/images/C1_W2_Lab04_Vectors.PNG new file mode 100644 index 0000000..c2a35e3 Binary files /dev/null and b/week2/images/C1_W2_Lab04_Vectors.PNG differ diff --git a/week2/images/C1_W2_Lab04_dot_notrans.gif b/week2/images/C1_W2_Lab04_dot_notrans.gif new file mode 100644 index 0000000..39d972a Binary files /dev/null and b/week2/images/C1_W2_Lab04_dot_notrans.gif differ diff --git a/week2/images/C1_W2_Lab06_LongRun.PNG b/week2/images/C1_W2_Lab06_LongRun.PNG new file mode 100644 index 0000000..0f8965a Binary files /dev/null and b/week2/images/C1_W2_Lab06_LongRun.PNG differ diff --git a/week2/images/C1_W2_Lab06_ShortRun.PNG b/week2/images/C1_W2_Lab06_ShortRun.PNG new file mode 100644 index 0000000..0b4b0eb Binary files /dev/null and b/week2/images/C1_W2_Lab06_ShortRun.PNG differ diff --git a/week2/images/C1_W2_Lab06_contours.PNG b/week2/images/C1_W2_Lab06_contours.PNG new file mode 100644 index 0000000..bc31d2d Binary files /dev/null and b/week2/images/C1_W2_Lab06_contours.PNG differ diff --git a/week2/images/C1_W2_Lab06_featurescalingheader.PNG b/week2/images/C1_W2_Lab06_featurescalingheader.PNG new file mode 100644 index 0000000..dc37d27 Binary files /dev/null and b/week2/images/C1_W2_Lab06_featurescalingheader.PNG differ diff --git a/week2/images/C1_W2_Lab06_learningrate.PNG b/week2/images/C1_W2_Lab06_learningrate.PNG new file mode 100644 index 0000000..e673ba0 Binary files /dev/null and b/week2/images/C1_W2_Lab06_learningrate.PNG differ diff --git a/week2/images/C1_W2_Lab06_scale.PNG b/week2/images/C1_W2_Lab06_scale.PNG new file mode 100644 index 0000000..60144ed Binary files /dev/null and b/week2/images/C1_W2_Lab06_scale.PNG differ diff --git a/week2/images/C1_W2_Lab07_FeatureEngLecture.PNG b/week2/images/C1_W2_Lab07_FeatureEngLecture.PNG new file mode 100644 index 0000000..e4fd46e Binary files /dev/null and b/week2/images/C1_W2_Lab07_FeatureEngLecture.PNG differ diff --git a/week2/lab_utils_common.py b/week2/lab_utils_common.py new file mode 100644 index 0000000..fbef0da --- /dev/null +++ b/week2/lab_utils_common.py @@ -0,0 +1,112 @@ +""" +lab_utils_common.py + functions common to all optional labs, Course 1, Week 2 +""" + +import numpy as np +import matplotlib.pyplot as plt + +plt.style.use('./deeplearning.mplstyle') +dlblue = '#0096ff'; dlorange = '#FF9300'; dldarkred='#C00000'; dlmagenta='#FF40FF'; dlpurple='#7030A0'; +dlcolors = [dlblue, dlorange, dldarkred, dlmagenta, dlpurple] +dlc = dict(dlblue = '#0096ff', dlorange = '#FF9300', dldarkred='#C00000', dlmagenta='#FF40FF', dlpurple='#7030A0') + + +########################################################## +# Regression Routines +########################################################## + +#Function to calculate the cost +def compute_cost_matrix(X, y, w, b, verbose=False): + """ + Computes the gradient for linear regression + Args: + X (ndarray (m,n)): Data, m examples with n features + y (ndarray (m,)) : target values + w (ndarray (n,)) : model parameters + b (scalar) : model parameter + verbose : (Boolean) If true, print out intermediate value f_wb + Returns + cost: (scalar) + """ + m = X.shape[0] + + # calculate f_wb for all examples. + f_wb = X @ w + b + # calculate cost + total_cost = (1/(2*m)) * np.sum((f_wb-y)**2) + + if verbose: print("f_wb:") + if verbose: print(f_wb) + + return total_cost + +def compute_gradient_matrix(X, y, w, b): + """ + Computes the gradient for linear regression + + Args: + X (ndarray (m,n)): Data, m examples with n features + y (ndarray (m,)) : target values + w (ndarray (n,)) : model parameters + b (scalar) : model parameter + Returns + dj_dw (ndarray (n,1)): The gradient of the cost w.r.t. the parameters w. + dj_db (scalar): The gradient of the cost w.r.t. the parameter b. + + """ + m,n = X.shape + f_wb = X @ w + b + e = f_wb - y + dj_dw = (1/m) * (X.T @ e) + dj_db = (1/m) * np.sum(e) + + return dj_db,dj_dw + + +# Loop version of multi-variable compute_cost +def compute_cost(X, y, w, b): + """ + compute cost + Args: + X (ndarray (m,n)): Data, m examples with n features + y (ndarray (m,)) : target values + w (ndarray (n,)) : model parameters + b (scalar) : model parameter + Returns + cost (scalar) : cost + """ + m = X.shape[0] + cost = 0.0 + for i in range(m): + f_wb_i = np.dot(X[i],w) + b #(n,)(n,)=scalar + cost = cost + (f_wb_i - y[i])**2 + cost = cost/(2*m) + return cost + +def compute_gradient(X, y, w, b): + """ + Computes the gradient for linear regression + Args: + X (ndarray (m,n)): Data, m examples with n features + y (ndarray (m,)) : target values + w (ndarray (n,)) : model parameters + b (scalar) : model parameter + Returns + dj_dw (ndarray Shape (n,)): The gradient of the cost w.r.t. the parameters w. + dj_db (scalar): The gradient of the cost w.r.t. the parameter b. + """ + m,n = X.shape #(number of examples, number of features) + dj_dw = np.zeros((n,)) + dj_db = 0. + + for i in range(m): + err = (np.dot(X[i], w) + b) - y[i] + for j in range(n): + dj_dw[j] = dj_dw[j] + err * X[i,j] + dj_db = dj_db + err + dj_dw = dj_dw/m + dj_db = dj_db/m + + return dj_db,dj_dw + diff --git a/week2/lab_utils_multi.py b/week2/lab_utils_multi.py new file mode 100644 index 0000000..ad31e3b --- /dev/null +++ b/week2/lab_utils_multi.py @@ -0,0 +1,569 @@ +import numpy as np +import copy +import math +from scipy.stats import norm +import matplotlib.pyplot as plt +from mpl_toolkits.mplot3d import axes3d +from matplotlib.ticker import MaxNLocator +dlblue = '#0096ff'; dlorange = '#FF9300'; dldarkred='#C00000'; dlmagenta='#FF40FF'; dlpurple='#7030A0'; +plt.style.use('./deeplearning.mplstyle') + +def load_data_multi(): + data = np.loadtxt("data/ex1data2.txt", delimiter=',') + X = data[:,:2] + y = data[:,2] + return X, y + +########################################################## +# Plotting Routines +########################################################## + +def plt_house_x(X, y,f_wb=None, ax=None): + ''' plot house with aXis ''' + if not ax: + fig, ax = plt.subplots(1,1) + ax.scatter(X, y, marker='x', c='r', label="Actual Value") + + ax.set_title("Housing Prices") + ax.set_ylabel('Price (in 1000s of dollars)') + ax.set_xlabel(f'Size (1000 sqft)') + if f_wb is not None: + ax.plot(X, f_wb, c=dlblue, label="Our Prediction") + ax.legend() + + +def mk_cost_lines(x,y,w,b, ax): + ''' makes vertical cost lines''' + cstr = "cost = (1/2m)*1000*(" + ctot = 0 + label = 'cost for point' + for p in zip(x,y): + f_wb_p = w*p[0]+b + c_p = ((f_wb_p - p[1])**2)/2 + c_p_txt = c_p/1000 + ax.vlines(p[0], p[1],f_wb_p, lw=3, color=dlpurple, ls='dotted', label=label) + label='' #just one + cxy = [p[0], p[1] + (f_wb_p-p[1])/2] + ax.annotate(f'{c_p_txt:0.0f}', xy=cxy, xycoords='data',color=dlpurple, + xytext=(5, 0), textcoords='offset points') + cstr += f"{c_p_txt:0.0f} +" + ctot += c_p + ctot = ctot/(len(x)) + cstr = cstr[:-1] + f") = {ctot:0.0f}" + ax.text(0.15,0.02,cstr, transform=ax.transAxes, color=dlpurple) + + +def inbounds(a,b,xlim,ylim): + xlow,xhigh = xlim + ylow,yhigh = ylim + ax, ay = a + bx, by = b + if (ax > xlow and ax < xhigh) and (bx > xlow and bx < xhigh) \ + and (ay > ylow and ay < yhigh) and (by > ylow and by < yhigh): + return(True) + else: + return(False) + +from mpl_toolkits.mplot3d import axes3d +def plt_contour_wgrad(x, y, hist, ax, w_range=[-100, 500, 5], b_range=[-500, 500, 5], + contours = [0.1,50,1000,5000,10000,25000,50000], + resolution=5, w_final=200, b_final=100,step=10 ): + b0,w0 = np.meshgrid(np.arange(*b_range),np.arange(*w_range)) + z=np.zeros_like(b0) + n,_ = w0.shape + for i in range(w0.shape[0]): + for j in range(w0.shape[1]): + z[i][j] = compute_cost(x, y, w0[i][j], b0[i][j] ) + + CS = ax.contour(w0, b0, z, contours, linewidths=2, + colors=[dlblue, dlorange, dldarkred, dlmagenta, dlpurple]) + ax.clabel(CS, inline=1, fmt='%1.0f', fontsize=10) + ax.set_xlabel("w"); ax.set_ylabel("b") + ax.set_title('Contour plot of cost J(w,b), vs b,w with path of gradient descent') + w = w_final; b=b_final + ax.hlines(b, ax.get_xlim()[0],w, lw=2, color=dlpurple, ls='dotted') + ax.vlines(w, ax.get_ylim()[0],b, lw=2, color=dlpurple, ls='dotted') + + base = hist[0] + for point in hist[0::step]: + edist = np.sqrt((base[0] - point[0])**2 + (base[1] - point[1])**2) + if(edist > resolution or point==hist[-1]): + if inbounds(point,base, ax.get_xlim(),ax.get_ylim()): + plt.annotate('', xy=point, xytext=base,xycoords='data', + arrowprops={'arrowstyle': '->', 'color': 'r', 'lw': 3}, + va='center', ha='center') + base=point + return + + +# plots p1 vs p2. Prange is an array of entries [min, max, steps]. In feature scaling lab. +def plt_contour_multi(x, y, w, b, ax, prange, p1, p2, title="", xlabel="", ylabel=""): + contours = [1e2, 2e2,3e2,4e2, 5e2, 6e2, 7e2,8e2,1e3, 1.25e3,1.5e3, 1e4, 1e5, 1e6, 1e7] + px,py = np.meshgrid(np.linspace(*(prange[p1])),np.linspace(*(prange[p2]))) + z=np.zeros_like(px) + n,_ = px.shape + for i in range(px.shape[0]): + for j in range(px.shape[1]): + w_ij = w + b_ij = b + if p1 <= 3: w_ij[p1] = px[i,j] + if p1 == 4: b_ij = px[i,j] + if p2 <= 3: w_ij[p2] = py[i,j] + if p2 == 4: b_ij = py[i,j] + + z[i][j] = compute_cost(x, y, w_ij, b_ij ) + CS = ax.contour(px, py, z, contours, linewidths=2, + colors=[dlblue, dlorange, dldarkred, dlmagenta, dlpurple]) + ax.clabel(CS, inline=1, fmt='%1.2e', fontsize=10) + ax.set_xlabel(xlabel); ax.set_ylabel(ylabel) + ax.set_title(title, fontsize=14) + + +def plt_equal_scale(X_train, X_norm, y_train): + fig,ax = plt.subplots(1,2,figsize=(12,5)) + prange = [ + [ 0.238-0.045, 0.238+0.045, 50], + [-25.77326319-0.045, -25.77326319+0.045, 50], + [-50000, 0, 50], + [-1500, 0, 50], + [0, 200000, 50]] + w_best = np.array([0.23844318, -25.77326319, -58.11084634, -1.57727192]) + b_best = 235 + plt_contour_multi(X_train, y_train, w_best, b_best, ax[0], prange, 0, 1, + title='Unnormalized, J(w,b), vs w[0],w[1]', + xlabel= "w[0] (size(sqft))", ylabel="w[1] (# bedrooms)") + # + w_best = np.array([111.1972, -16.75480051, -28.51530411, -37.17305735]) + b_best = 376.949151515151 + prange = [[ 111-50, 111+50, 75], + [-16.75-50,-16.75+50, 75], + [-28.5-8, -28.5+8, 50], + [-37.1-16,-37.1+16, 50], + [376-150, 376+150, 50]] + plt_contour_multi(X_norm, y_train, w_best, b_best, ax[1], prange, 0, 1, + title='Normalized, J(w,b), vs w[0],w[1]', + xlabel= "w[0] (normalized size(sqft))", ylabel="w[1] (normalized # bedrooms)") + fig.suptitle("Cost contour with equal scale", fontsize=18) + #plt.tight_layout(rect=(0,0,1.05,1.05)) + fig.tight_layout(rect=(0,0,1,0.95)) + plt.show() + +def plt_divergence(p_hist, J_hist, x_train,y_train): + + x=np.zeros(len(p_hist)) + y=np.zeros(len(p_hist)) + v=np.zeros(len(p_hist)) + for i in range(len(p_hist)): + x[i] = p_hist[i][0] + y[i] = p_hist[i][1] + v[i] = J_hist[i] + + fig = plt.figure(figsize=(12,5)) + plt.subplots_adjust( wspace=0 ) + gs = fig.add_gridspec(1, 5) + fig.suptitle(f"Cost escalates when learning rate is too large") + #=============== + # First subplot + #=============== + ax = fig.add_subplot(gs[:2], ) + + # Print w vs cost to see minimum + fix_b = 100 + w_array = np.arange(-70000, 70000, 1000) + cost = np.zeros_like(w_array) + + for i in range(len(w_array)): + tmp_w = w_array[i] + cost[i] = compute_cost(x_train, y_train, tmp_w, fix_b) + + ax.plot(w_array, cost) + ax.plot(x,v, c=dlmagenta) + ax.set_title("Cost vs w, b set to 100") + ax.set_ylabel('Cost') + ax.set_xlabel('w') + ax.xaxis.set_major_locator(MaxNLocator(2)) + + #=============== + # Second Subplot + #=============== + + tmp_b,tmp_w = np.meshgrid(np.arange(-35000, 35000, 500),np.arange(-70000, 70000, 500)) + z=np.zeros_like(tmp_b) + for i in range(tmp_w.shape[0]): + for j in range(tmp_w.shape[1]): + z[i][j] = compute_cost(x_train, y_train, tmp_w[i][j], tmp_b[i][j] ) + + ax = fig.add_subplot(gs[2:], projection='3d') + ax.plot_surface(tmp_w, tmp_b, z, alpha=0.3, color=dlblue) + ax.xaxis.set_major_locator(MaxNLocator(2)) + ax.yaxis.set_major_locator(MaxNLocator(2)) + + ax.set_xlabel('w', fontsize=16) + ax.set_ylabel('b', fontsize=16) + ax.set_zlabel('\ncost', fontsize=16) + plt.title('Cost vs (b, w)') + # Customize the view angle + ax.view_init(elev=20., azim=-65) + ax.plot(x, y, v,c=dlmagenta) + + return + +# draw derivative line +# y = m*(x - x1) + y1 +def add_line(dj_dx, x1, y1, d, ax): + x = np.linspace(x1-d, x1+d,50) + y = dj_dx*(x - x1) + y1 + ax.scatter(x1, y1, color=dlblue, s=50) + ax.plot(x, y, '--', c=dldarkred,zorder=10, linewidth = 1) + xoff = 30 if x1 == 200 else 10 + ax.annotate(r"$\frac{\partial J}{\partial w}$ =%d" % dj_dx, fontsize=14, + xy=(x1, y1), xycoords='data', + xytext=(xoff, 10), textcoords='offset points', + arrowprops=dict(arrowstyle="->"), + horizontalalignment='left', verticalalignment='top') + +def plt_gradients(x_train,y_train, f_compute_cost, f_compute_gradient): + #=============== + # First subplot + #=============== + fig,ax = plt.subplots(1,2,figsize=(12,4)) + + # Print w vs cost to see minimum + fix_b = 100 + w_array = np.linspace(-100, 500, 50) + w_array = np.linspace(0, 400, 50) + cost = np.zeros_like(w_array) + + for i in range(len(w_array)): + tmp_w = w_array[i] + cost[i] = f_compute_cost(x_train, y_train, tmp_w, fix_b) + ax[0].plot(w_array, cost,linewidth=1) + ax[0].set_title("Cost vs w, with gradient; b set to 100") + ax[0].set_ylabel('Cost') + ax[0].set_xlabel('w') + + # plot lines for fixed b=100 + for tmp_w in [100,200,300]: + fix_b = 100 + dj_dw,dj_db = f_compute_gradient(x_train, y_train, tmp_w, fix_b ) + j = f_compute_cost(x_train, y_train, tmp_w, fix_b) + add_line(dj_dw, tmp_w, j, 30, ax[0]) + + #=============== + # Second Subplot + #=============== + + tmp_b,tmp_w = np.meshgrid(np.linspace(-200, 200, 10), np.linspace(-100, 600, 10)) + U = np.zeros_like(tmp_w) + V = np.zeros_like(tmp_b) + for i in range(tmp_w.shape[0]): + for j in range(tmp_w.shape[1]): + U[i][j], V[i][j] = f_compute_gradient(x_train, y_train, tmp_w[i][j], tmp_b[i][j] ) + X = tmp_w + Y = tmp_b + n=-2 + color_array = np.sqrt(((V-n)/2)**2 + ((U-n)/2)**2) + + ax[1].set_title('Gradient shown in quiver plot') + Q = ax[1].quiver(X, Y, U, V, color_array, units='width', ) + qk = ax[1].quiverkey(Q, 0.9, 0.9, 2, r'$2 \frac{m}{s}$', labelpos='E',coordinates='figure') + ax[1].set_xlabel("w"); ax[1].set_ylabel("b") + +def norm_plot(ax, data): + scale = (np.max(data) - np.min(data))*0.2 + x = np.linspace(np.min(data)-scale,np.max(data)+scale,50) + _,bins, _ = ax.hist(data, x, color="xkcd:azure") + #ax.set_ylabel("Count") + + mu = np.mean(data); + std = np.std(data); + dist = norm.pdf(bins, loc=mu, scale = std) + + axr = ax.twinx() + axr.plot(bins,dist, color = "orangered", lw=2) + axr.set_ylim(bottom=0) + axr.axis('off') + +def plot_cost_i_w(X,y,hist): + ws = np.array([ p[0] for p in hist["params"]]) + rng = max(abs(ws[:,0].min()),abs(ws[:,0].max())) + wr = np.linspace(-rng+0.27,rng+0.27,20) + cst = [compute_cost(X,y,np.array([wr[i],-32, -67, -1.46]), 221) for i in range(len(wr))] + + fig,ax = plt.subplots(1,2,figsize=(12,3)) + ax[0].plot(hist["iter"], (hist["cost"])); ax[0].set_title("Cost vs Iteration") + ax[0].set_xlabel("iteration"); ax[0].set_ylabel("Cost") + ax[1].plot(wr, cst); ax[1].set_title("Cost vs w[0]") + ax[1].set_xlabel("w[0]"); ax[1].set_ylabel("Cost") + ax[1].plot(ws[:,0],hist["cost"]) + plt.show() + + +########################################################## +# Regression Routines +########################################################## + +def compute_gradient_matrix(X, y, w, b): + """ + Computes the gradient for linear regression + + Args: + X : (array_like Shape (m,n)) variable such as house size + y : (array_like Shape (m,1)) actual value + w : (array_like Shape (n,1)) Values of parameters of the model + b : (scalar ) Values of parameter of the model + Returns + dj_dw: (array_like Shape (n,1)) The gradient of the cost w.r.t. the parameters w. + dj_db: (scalar) The gradient of the cost w.r.t. the parameter b. + + """ + m,n = X.shape + f_wb = X @ w + b + e = f_wb - y + dj_dw = (1/m) * (X.T @ e) + dj_db = (1/m) * np.sum(e) + + return dj_db,dj_dw + +#Function to calculate the cost +def compute_cost_matrix(X, y, w, b, verbose=False): + """ + Computes the gradient for linear regression + Args: + X : (array_like Shape (m,n)) variable such as house size + y : (array_like Shape (m,)) actual value + w : (array_like Shape (n,)) parameters of the model + b : (scalar ) parameter of the model + verbose : (Boolean) If true, print out intermediate value f_wb + Returns + cost: (scalar) + """ + m,n = X.shape + + # calculate f_wb for all examples. + f_wb = X @ w + b + # calculate cost + total_cost = (1/(2*m)) * np.sum((f_wb-y)**2) + + if verbose: print("f_wb:") + if verbose: print(f_wb) + + return total_cost + +# Loop version of multi-variable compute_cost +def compute_cost(X, y, w, b): + """ + compute cost + Args: + X : (ndarray): Shape (m,n) matrix of examples with multiple features + w : (ndarray): Shape (n) parameters for prediction + b : (scalar): parameter for prediction + Returns + cost: (scalar) cost + """ + m = X.shape[0] + cost = 0.0 + for i in range(m): + f_wb_i = np.dot(X[i],w) + b + cost = cost + (f_wb_i - y[i])**2 + cost = cost/(2*m) + return(np.squeeze(cost)) + +def compute_gradient(X, y, w, b): + """ + Computes the gradient for linear regression + Args: + X : (ndarray Shape (m,n)) matrix of examples + y : (ndarray Shape (m,)) target value of each example + w : (ndarray Shape (n,)) parameters of the model + b : (scalar) parameter of the model + Returns + dj_dw : (ndarray Shape (n,)) The gradient of the cost w.r.t. the parameters w. + dj_db : (scalar) The gradient of the cost w.r.t. the parameter b. + """ + m,n = X.shape #(number of examples, number of features) + dj_dw = np.zeros((n,)) + dj_db = 0. + + for i in range(m): + err = (np.dot(X[i], w) + b) - y[i] + for j in range(n): + dj_dw[j] = dj_dw[j] + err * X[i,j] + dj_db = dj_db + err + dj_dw = dj_dw/m + dj_db = dj_db/m + + return dj_db,dj_dw + +#This version saves more values and is more verbose than the assigment versons +def gradient_descent_houses(X, y, w_in, b_in, cost_function, gradient_function, alpha, num_iters): + """ + Performs batch gradient descent to learn theta. Updates theta by taking + num_iters gradient steps with learning rate alpha + + Args: + X : (array_like Shape (m,n) matrix of examples + y : (array_like Shape (m,)) target value of each example + w_in : (array_like Shape (n,)) Initial values of parameters of the model + b_in : (scalar) Initial value of parameter of the model + cost_function: function to compute cost + gradient_function: function to compute the gradient + alpha : (float) Learning rate + num_iters : (int) number of iterations to run gradient descent + Returns + w : (array_like Shape (n,)) Updated values of parameters of the model after + running gradient descent + b : (scalar) Updated value of parameter of the model after + running gradient descent + """ + + # number of training examples + m = len(X) + + # An array to store values at each iteration primarily for graphing later + hist={} + hist["cost"] = []; hist["params"] = []; hist["grads"]=[]; hist["iter"]=[]; + + w = copy.deepcopy(w_in) #avoid modifying global w within function + b = b_in + save_interval = np.ceil(num_iters/10000) # prevent resource exhaustion for long runs + + print(f"Iteration Cost w0 w1 w2 w3 b djdw0 djdw1 djdw2 djdw3 djdb ") + print(f"---------------------|--------|--------|--------|--------|--------|--------|--------|--------|--------|--------|") + + for i in range(num_iters): + + # Calculate the gradient and update the parameters + dj_db,dj_dw = gradient_function(X, y, w, b) + + # Update Parameters using w, b, alpha and gradient + w = w - alpha * dj_dw + b = b - alpha * dj_db + + # Save cost J,w,b at each save interval for graphing + if i == 0 or i % save_interval == 0: + hist["cost"].append(cost_function(X, y, w, b)) + hist["params"].append([w,b]) + hist["grads"].append([dj_dw,dj_db]) + hist["iter"].append(i) + + # Print cost every at intervals 10 times or as many iterations if < 10 + if i% math.ceil(num_iters/10) == 0: + #print(f"Iteration {i:4d}: Cost {cost_function(X, y, w, b):8.2f} ") + cst = cost_function(X, y, w, b) + print(f"{i:9d} {cst:0.5e} {w[0]: 0.1e} {w[1]: 0.1e} {w[2]: 0.1e} {w[3]: 0.1e} {b: 0.1e} {dj_dw[0]: 0.1e} {dj_dw[1]: 0.1e} {dj_dw[2]: 0.1e} {dj_dw[3]: 0.1e} {dj_db: 0.1e}") + + return w, b, hist #return w,b and history for graphing + +def run_gradient_descent(X,y,iterations=1000, alpha = 1e-6): + + m,n = X.shape + # initialize parameters + initial_w = np.zeros(n) + initial_b = 0 + # run gradient descent + w_out, b_out, hist_out = gradient_descent_houses(X ,y, initial_w, initial_b, + compute_cost, compute_gradient_matrix, alpha, iterations) + print(f"w,b found by gradient descent: w: {w_out}, b: {b_out:0.2f}") + + return(w_out, b_out, hist_out) + +# compact extaction of hist data +#x = hist["iter"] +#J = np.array([ p for p in hist["cost"]]) +#ws = np.array([ p[0] for p in hist["params"]]) +#dj_ws = np.array([ p[0] for p in hist["grads"]]) + +#bs = np.array([ p[1] for p in hist["params"]]) + +def run_gradient_descent_feng(X,y,iterations=1000, alpha = 1e-6): + m,n = X.shape + # initialize parameters + initial_w = np.zeros(n) + initial_b = 0 + # run gradient descent + w_out, b_out, hist_out = gradient_descent(X ,y, initial_w, initial_b, + compute_cost, compute_gradient_matrix, alpha, iterations) + print(f"w,b found by gradient descent: w: {w_out}, b: {b_out:0.4f}") + + return(w_out, b_out) + +def gradient_descent(X, y, w_in, b_in, cost_function, gradient_function, alpha, num_iters): + """ + Performs batch gradient descent to learn theta. Updates theta by taking + num_iters gradient steps with learning rate alpha + + Args: + X : (array_like Shape (m,n) matrix of examples + y : (array_like Shape (m,)) target value of each example + w_in : (array_like Shape (n,)) Initial values of parameters of the model + b_in : (scalar) Initial value of parameter of the model + cost_function: function to compute cost + gradient_function: function to compute the gradient + alpha : (float) Learning rate + num_iters : (int) number of iterations to run gradient descent + Returns + w : (array_like Shape (n,)) Updated values of parameters of the model after + running gradient descent + b : (scalar) Updated value of parameter of the model after + running gradient descent + """ + + # number of training examples + m = len(X) + + # An array to store values at each iteration primarily for graphing later + hist={} + hist["cost"] = []; hist["params"] = []; hist["grads"]=[]; hist["iter"]=[]; + + w = copy.deepcopy(w_in) #avoid modifying global w within function + b = b_in + save_interval = np.ceil(num_iters/10000) # prevent resource exhaustion for long runs + + for i in range(num_iters): + + # Calculate the gradient and update the parameters + dj_db,dj_dw = gradient_function(X, y, w, b) + + # Update Parameters using w, b, alpha and gradient + w = w - alpha * dj_dw + b = b - alpha * dj_db + + # Save cost J,w,b at each save interval for graphing + if i == 0 or i % save_interval == 0: + hist["cost"].append(cost_function(X, y, w, b)) + hist["params"].append([w,b]) + hist["grads"].append([dj_dw,dj_db]) + hist["iter"].append(i) + + # Print cost every at intervals 10 times or as many iterations if < 10 + if i% math.ceil(num_iters/10) == 0: + #print(f"Iteration {i:4d}: Cost {cost_function(X, y, w, b):8.2f} ") + cst = cost_function(X, y, w, b) + print(f"Iteration {i:9d}, Cost: {cst:0.5e}") + return w, b, hist #return w,b and history for graphing + +def load_house_data(): + data = np.loadtxt("./data/houses.txt", delimiter=',', skiprows=1) + X = data[:,:4] + y = data[:,4] + return X, y + +def zscore_normalize_features(X,rtn_ms=False): + """ + returns z-score normalized X by column + Args: + X : (numpy array (m,n)) + Returns + X_norm: (numpy array (m,n)) input normalized by column + """ + mu = np.mean(X,axis=0) + sigma = np.std(X,axis=0) + X_norm = (X - mu)/sigma + + if rtn_ms: + return(X_norm, mu, sigma) + else: + return(X_norm) + +