diff --git a/lab1/PT_Part1_Intro.ipynb b/lab1/PT_Part1_Intro.ipynb index db97d067..d1457baa 100644 --- a/lab1/PT_Part1_Intro.ipynb +++ b/lab1/PT_Part1_Intro.ipynb @@ -1,5 +1,15 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, { "cell_type": "markdown", "metadata": { @@ -60,11 +70,56 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "LkaimNJfYZ2w" - }, - "outputs": [], + "execution_count": 3, + "metadata": { + "id": "LkaimNJfYZ2w", + "outputId": "4e635cf3-7bd4-4897-ee34-f131e78a833f", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/2.8 MB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[91m╸\u001b[0m \u001b[32m2.8/2.8 MB\u001b[0m \u001b[31m87.1 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.8/2.8 MB\u001b[0m \u001b[31m53.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m152.3/152.3 kB\u001b[0m \u001b[31m13.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m9.7/9.7 MB\u001b[0m \u001b[31m93.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m666.7/666.7 kB\u001b[0m \u001b[31m36.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m69.7/69.7 kB\u001b[0m \u001b[31m5.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m45.2/45.2 kB\u001b[0m \u001b[31m3.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m82.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m4.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m67.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m36.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m42.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m2.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m5.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m21.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m7.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m6.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m188.7/188.7 MB\u001b[0m \u001b[31m5.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m88.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m66.1/66.1 kB\u001b[0m \u001b[31m5.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h Building wheel for mitdeeplearning (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Building wheel for litellm (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Gym has been unmaintained since 2022 and does not support NumPy 2.0 amongst other critical functionality.\n", + "Please upgrade to Gymnasium, the maintained drop-in replacement of Gym, or contact the authors of your software and request that they upgrade.\n", + "See the migration guide at https://gymnasium.farama.org/introduction/migration_guide/ for additional information.\n" + ] + } + ], "source": [ "import torch\n", "import torch.nn as nn\n", @@ -94,11 +149,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "tFxztZQInlAB" - }, - "outputs": [], + "execution_count": 2, + "metadata": { + "id": "tFxztZQInlAB", + "outputId": "ae5abcef-1b6a-40b0-da68-74803f50520e", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "`integer` is a 0-d Tensor: 1234\n", + "`decimal` is a 0-d Tensor: 3.1415927410125732\n" + ] + } + ], "source": [ "integer = torch.tensor(1234)\n", "decimal = torch.tensor(3.14159265359)\n", @@ -118,11 +186,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "oaHXABe8oPcO" - }, - "outputs": [], + "execution_count": 3, + "metadata": { + "id": "oaHXABe8oPcO", + "outputId": "606661e9-8736-4edd-8b3b-ab8c24816542", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "`fibonacci` is a 1-d Tensor with shape: torch.Size([6])\n", + "`count_to_100` is a 1-d Tensor with shape: torch.Size([100])\n" + ] + } + ], "source": [ "fibonacci = torch.tensor([1, 1, 2, 3, 5, 8])\n", "count_to_100 = torch.tensor(range(100))\n", @@ -142,16 +223,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "tFeBBe1IouS3" - }, - "outputs": [], + "execution_count": 12, + "metadata": { + "id": "tFeBBe1IouS3", + "outputId": "98cd1fd1-e7ad-4300-c0c0-bf9b7144b096", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "images is a 4-d Tensor with shape: torch.Size([10, 3, 256, 256])\n" + ] + } + ], "source": [ "### Defining higher-order Tensors ###\n", "\n", "'''TODO: Define a 2-d Tensor'''\n", - "matrix = # TODO\n", + "matrix = torch.tensor([[1,2] , [3,4]])\n", "\n", "assert isinstance(matrix, torch.Tensor), \"matrix must be a torch Tensor object\"\n", "assert matrix.ndim == 2\n", @@ -159,7 +252,7 @@ "'''TODO: Define a 4-d Tensor.'''\n", "# Use torch.zeros to initialize a 4-d Tensor of zeros with size 10 x 3 x 256 x 256.\n", "# You can think of this as 10 images where each image is RGB 256 x 256.\n", - "images = # TODO\n", + "images = torch.zeros(10,3, 256,256)\n", "\n", "assert isinstance(images, torch.Tensor), \"images must be a torch Tensor object\"\n", "assert images.ndim == 4, \"images must have 4 dimensions\"\n", @@ -178,11 +271,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "FhaufyObuLEG" - }, - "outputs": [], + "execution_count": 13, + "metadata": { + "id": "FhaufyObuLEG", + "outputId": "f56db1ca-4f7a-4999-85a1-e199851a81f3", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "`row_vector`: tensor([3, 4])\n", + "`column_vector`: tensor([2, 4])\n", + "`scalar`: 2\n" + ] + } + ], "source": [ "row_vector = matrix[1]\n", "column_vector = matrix[:, 1]\n", @@ -208,11 +315,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "X_YJrZsxYZ2z" - }, - "outputs": [], + "execution_count": 14, + "metadata": { + "id": "X_YJrZsxYZ2z", + "outputId": "6009e86e-8c26-4470-d1c6-49c949b564ea", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "c1: 76\n", + "c2: 76\n" + ] + } + ], "source": [ "# Create the nodes in the graph and initialize values\n", "a = torch.tensor(15)\n", @@ -244,7 +364,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": { "id": "PJnfzpWyYZ23", "scrolled": true @@ -256,9 +376,9 @@ "# Construct a simple computation function\n", "def func(a, b):\n", " '''TODO: Define the operation for c, d, e.'''\n", - " c = # TODO\n", - " d = # TODO\n", - " e = # TODO\n", + " c = a +b\n", + " d = b-1\n", + " e = c * d\n", " return e\n" ] }, @@ -273,11 +393,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "pnwsf8w2uF7p" - }, - "outputs": [], + "execution_count": 16, + "metadata": { + "id": "pnwsf8w2uF7p", + "outputId": "cb0771e4-e5e2-47c1-d4c8-ca58aa4229e7", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "e_out: 6.0\n" + ] + } + ], "source": [ "# Consider example values for a,b\n", "a, b = 1.5, 2.5\n", @@ -315,7 +447,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": { "id": "HutbJk-1kHPh" }, @@ -337,10 +469,10 @@ "\n", " def forward(self, x):\n", " '''TODO: define the operation for z (hint: use torch.matmul).'''\n", - " z = # TODO\n", + " z = torch.matmul(x, self.W) + self.bias\n", "\n", " '''TODO: define the operation for out (hint: use torch.sigmoid).'''\n", - " y = # TODO\n", + " y = torch.sigmoid(z)\n", " return y\n" ] }, @@ -355,11 +487,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "2yxjCPa69hV_" - }, - "outputs": [], + "execution_count": 20, + "metadata": { + "id": "2yxjCPa69hV_", + "outputId": "ac5b934e-30e3-46fd-a68c-6b04a39a3fcd", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "input shape: torch.Size([1, 2])\n", + "output shape: torch.Size([1, 3])\n", + "output result: tensor([[0.2512, 0.9572, 0.4520]], grad_fn=)\n" + ] + } + ], "source": [ "# Define a layer and test the output!\n", "num_inputs = 2\n", @@ -386,7 +532,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": { "id": "7WXTpmoL6TDz" }, @@ -401,7 +547,10 @@ "# Define the model\n", "'''TODO: Use the Sequential API to define a neural network with a\n", " single linear (dense!) layer, followed by non-linearity to compute z'''\n", - "model = nn.Sequential( ''' TODO ''' )\n" + "model = nn.Sequential(\n", + " nn.Linear(n_input_nodes, n_output_nodes),\n", + " nn.Sigmoid()\n", + ")\n" ] }, { @@ -415,11 +564,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "zKhp6XqCFFa0" - }, - "outputs": [], + "execution_count": 22, + "metadata": { + "id": "zKhp6XqCFFa0", + "outputId": "4d99eb74-45f4-411c-aced-c285828533c5", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "input shape: torch.Size([1, 2])\n", + "output shape: torch.Size([1, 3])\n", + "output result: tensor([[0.2512, 0.9572, 0.4520]], grad_fn=)\n" + ] + } + ], "source": [ "# Test the model with example input\n", "x_input = torch.tensor([[1, 2.]])\n", @@ -442,20 +605,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": { "id": "K4aCflPVyViD" }, "outputs": [], "source": [ + "\n", "### Defining a model using subclassing ###\n", "\n", "class LinearWithSigmoidActivation(nn.Module):\n", " def __init__(self, num_inputs, num_outputs):\n", " super(LinearWithSigmoidActivation, self).__init__()\n", " '''TODO: define a model with a single Linear layer and sigmoid activation.'''\n", - " self.linear = '''TODO: linear layer'''\n", - " self.activation = '''TODO: sigmoid activation'''\n", + " self.linear = nn.Linear(num_inputs,num_outputs)\n", + " self.activation = nn.Sigmoid()\n", "\n", " def forward(self, inputs):\n", " linear_output = self.linear(inputs)\n", @@ -474,11 +638,25 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "V-eNhSyRG6hl" - }, - "outputs": [], + "execution_count": 26, + "metadata": { + "id": "V-eNhSyRG6hl", + "outputId": "24733da0-2bd7-41ae-fdf6-1d3efab30ae3", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "input shape: torch.Size([1, 2])\n", + "output shape: torch.Size([1, 3])\n", + "output result: tensor([[0.6735, 0.4807, 0.6996]], grad_fn=)\n" + ] + } + ], "source": [ "n_input_nodes = 2\n", "n_output_nodes = 3\n", @@ -501,7 +679,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": { "id": "P7jzGX5D1xT5" }, @@ -517,7 +695,11 @@ " '''TODO: Implement the behavior where the network outputs the input, unchanged,\n", " under control of the isidentity argument.'''\n", " def forward(self, inputs, isidentity=False):\n", - " ''' TODO '''\n" + " if isidentity:\n", + " return inputs\n", + " else:\n", + " return self.linear(inputs)\n", + "\n" ] }, { @@ -531,20 +713,33 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "NzC0mgbk5dp2" - }, - "outputs": [], + "execution_count": 31, + "metadata": { + "id": "NzC0mgbk5dp2", + "outputId": "3d1544fd-94a4-4628-92f9-cc603eed714c", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "input: tensor([[1., 2.]])\n", + "Network linear output: tensor([[-0.0834, 2.0875, 1.2564]], grad_fn=); network identity output: tensor([[1., 2.]])\n" + ] + } + ], "source": [ "# Test the IdentityModel\n", "model = LinearButSometimesIdentity(num_inputs=2, num_outputs=3)\n", "x_input = torch.tensor([[1, 2.]])\n", "\n", "'''TODO: pass the input into the model and call with and without the input identity option.'''\n", - "out_with_linear = # TODO\n", + "out_with_linear = model(x_input)\n", "\n", - "out_with_identity = # TODO\n", + "out_with_identity = model(x_input, isidentity = True)\n", "\n", "print(f\"input: {x_input}\")\n", "print(\"Network linear output: {}; network identity output: {}\".format(out_with_linear, out_with_identity))" @@ -576,11 +771,23 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "tdkqk8pw5yJM" - }, - "outputs": [], + "execution_count": 27, + "metadata": { + "id": "tdkqk8pw5yJM", + "outputId": "2b9d67f0-c8ce-4313-b853-fa2db81390e4", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "dy_dx of y=x^2 at x=3.0 is: tensor(6.)\n" + ] + } + ], "source": [ "### Gradient computation ###\n", "\n", @@ -606,7 +813,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": { "attributes": { "classes": [ @@ -614,9 +821,32 @@ ], "id": "" }, - "id": "7g1yWiSXqEf-" - }, - "outputs": [], + "id": "7g1yWiSXqEf-", + "outputId": "e1e08891-9b5b-4fb2-d6b7-eed3eed76c2b", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 466 + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Initializing x=-1.1003597974777222\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], "source": [ "### Function minimization with autograd and gradient descent ###\n", "\n", @@ -635,7 +865,7 @@ " x = torch.tensor([x], requires_grad=True)\n", "\n", " # TODO: Compute the loss as the square of the difference between x and x_f\n", - " loss = # TODO\n", + " loss = (x - x_f) **2\n", "\n", " # Backpropagate through the loss to compute gradients\n", " loss.backward()\n", @@ -665,17 +895,16 @@ } ], "metadata": { - "accelerator": "GPU", "colab": { "collapsed_sections": [ "WBk0ZDWY-ff8" ], "name": "PT_Part1_Intro.ipynb", - "provenance": [] + "provenance": [], + "include_colab_link": true }, "kernelspec": { "display_name": "Python 3", - "language": "python", "name": "python3" }, "language_info": { @@ -698,4 +927,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} +} \ No newline at end of file diff --git a/lab1/PT_Part2_Music_Generation.ipynb b/lab1/PT_Part2_Music_Generation.ipynb index a99bca7d..3c6ad794 100644 --- a/lab1/PT_Part2_Music_Generation.ipynb +++ b/lab1/PT_Part2_Music_Generation.ipynb @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "id": "bUik05YqMyCH" }, @@ -66,16 +66,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { - "id": "riVZCVK65QTH" + "id": "riVZCVK65QTH", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "2c5e607f-71a0-4ee1-f81a-ddb0c8365a7c" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Gym has been unmaintained since 2022 and does not support NumPy 2.0 amongst other critical functionality.\n", + "Please upgrade to Gymnasium, the maintained drop-in replacement of Gym, or contact the authors of your software and request that they upgrade.\n", + "See the migration guide at https://gymnasium.farama.org/introduction/migration_guide/ for additional information.\n" + ] + } + ], "source": [ "!pip install comet_ml > /dev/null 2>&1\n", "import comet_ml\n", "# TODO: ENTER YOUR API KEY HERE!! instructions above\n", - "COMET_API_KEY = \"\"\n", + "COMET_API_KEY = \"wtmmeE3OhvyqV1Pbo1G6eVW4I\"\n", "\n", "# Import PyTorch and other relevant libraries\n", "import torch\n", @@ -119,11 +133,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { - "id": "P7dFnP5q3Jve" + "id": "P7dFnP5q3Jve", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "38b560d2-9230-4014-fc05-922fb2d90cee" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Found 817 songs in text\n", + "\n", + "Example song: \n", + "X:1\n", + "T:Alexander's\n", + "Z: id:dc-hornpipe-1\n", + "M:C|\n", + "L:1/8\n", + "K:D Major\n", + "(3ABc|dAFA DFAd|fdcd FAdf|gfge fefd|(3efe (3dcB A2 (3ABc|!\n", + "dAFA DFAd|fdcd FAdf|gfge fefd|(3efe dc d2:|!\n", + "AG|FAdA FAdA|GBdB GBdB|Acec Acec|dfaf gecA|!\n", + "FAdA FAdA|GBdB GBdB|Aceg fefd|(3efe dc d2:|!\n" + ] + } + ], "source": [ "# Download the dataset\n", "songs = mdl.lab1.load_training_data()\n", @@ -145,11 +183,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { - "id": "11toYzhEEKDz" + "id": "11toYzhEEKDz", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 75 + }, + "outputId": "52836051-ca12-4443-a499-4d091f08a356" }, - "outputs": [], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + " \n", + " " + ] + }, + "metadata": {}, + "execution_count": 6 + } + ], "source": [ "# Convert the ABC notation to audio file and listen to it\n", "mdl.lab1.play_song(example_song)" @@ -166,11 +228,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": { - "id": "IlCgQBRVymwR" + "id": "IlCgQBRVymwR", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "26a7f640-848b-4ab1-b2ff-90f72a53185f" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "There are 83 unique characters in the dataset\n" + ] + } + ], "source": [ "# Join our list of song strings into a single string containing all songs\n", "songs_joined = \"\\n\\n\".join(songs)\n", @@ -180,6 +254,114 @@ "print(\"There are\", len(vocab), \"unique characters in the dataset\")" ] }, + { + "cell_type": "code", + "source": [ + "vocab" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VUUGc4esAew3", + "outputId": "54f69f3b-306e-421c-8a13-ac291b672621" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['\\n',\n", + " ' ',\n", + " '!',\n", + " '\"',\n", + " '#',\n", + " \"'\",\n", + " '(',\n", + " ')',\n", + " ',',\n", + " '-',\n", + " '.',\n", + " '/',\n", + " '0',\n", + " '1',\n", + " '2',\n", + " '3',\n", + " '4',\n", + " '5',\n", + " '6',\n", + " '7',\n", + " '8',\n", + " '9',\n", + " ':',\n", + " '<',\n", + " '=',\n", + " '>',\n", + " 'A',\n", + " 'B',\n", + " 'C',\n", + " 'D',\n", + " 'E',\n", + " 'F',\n", + " 'G',\n", + " 'H',\n", + " 'I',\n", + " 'J',\n", + " 'K',\n", + " 'L',\n", + " 'M',\n", + " 'N',\n", + " 'O',\n", + " 'P',\n", + " 'Q',\n", + " 'R',\n", + " 'S',\n", + " 'T',\n", + " 'U',\n", + " 'V',\n", + " 'W',\n", + " 'X',\n", + " 'Y',\n", + " 'Z',\n", + " '[',\n", + " ']',\n", + " '^',\n", + " '_',\n", + " 'a',\n", + " 'b',\n", + " 'c',\n", + " 'd',\n", + " 'e',\n", + " 'f',\n", + " 'g',\n", + " 'h',\n", + " 'i',\n", + " 'j',\n", + " 'k',\n", + " 'l',\n", + " 'm',\n", + " 'n',\n", + " 'o',\n", + " 'p',\n", + " 'q',\n", + " 'r',\n", + " 's',\n", + " 't',\n", + " 'u',\n", + " 'v',\n", + " 'w',\n", + " 'x',\n", + " 'y',\n", + " 'z',\n", + " '|']" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ] + }, { "cell_type": "markdown", "metadata": { @@ -208,7 +390,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "id": "IalZLbvOzf-F" }, @@ -227,6 +409,114 @@ "idx2char = np.array(vocab)" ] }, + { + "cell_type": "code", + "source": [ + "char2idx" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sBYopHxUBPE8", + "outputId": "be76d616-5f93-4525-e528-b846ec1649d3" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'\\n': 0,\n", + " ' ': 1,\n", + " '!': 2,\n", + " '\"': 3,\n", + " '#': 4,\n", + " \"'\": 5,\n", + " '(': 6,\n", + " ')': 7,\n", + " ',': 8,\n", + " '-': 9,\n", + " '.': 10,\n", + " '/': 11,\n", + " '0': 12,\n", + " '1': 13,\n", + " '2': 14,\n", + " '3': 15,\n", + " '4': 16,\n", + " '5': 17,\n", + " '6': 18,\n", + " '7': 19,\n", + " '8': 20,\n", + " '9': 21,\n", + " ':': 22,\n", + " '<': 23,\n", + " '=': 24,\n", + " '>': 25,\n", + " 'A': 26,\n", + " 'B': 27,\n", + " 'C': 28,\n", + " 'D': 29,\n", + " 'E': 30,\n", + " 'F': 31,\n", + " 'G': 32,\n", + " 'H': 33,\n", + " 'I': 34,\n", + " 'J': 35,\n", + " 'K': 36,\n", + " 'L': 37,\n", + " 'M': 38,\n", + " 'N': 39,\n", + " 'O': 40,\n", + " 'P': 41,\n", + " 'Q': 42,\n", + " 'R': 43,\n", + " 'S': 44,\n", + " 'T': 45,\n", + " 'U': 46,\n", + " 'V': 47,\n", + " 'W': 48,\n", + " 'X': 49,\n", + " 'Y': 50,\n", + " 'Z': 51,\n", + " '[': 52,\n", + " ']': 53,\n", + " '^': 54,\n", + " '_': 55,\n", + " 'a': 56,\n", + " 'b': 57,\n", + " 'c': 58,\n", + " 'd': 59,\n", + " 'e': 60,\n", + " 'f': 61,\n", + " 'g': 62,\n", + " 'h': 63,\n", + " 'i': 64,\n", + " 'j': 65,\n", + " 'k': 66,\n", + " 'l': 67,\n", + " 'm': 68,\n", + " 'n': 69,\n", + " 'o': 70,\n", + " 'p': 71,\n", + " 'q': 72,\n", + " 'r': 73,\n", + " 's': 74,\n", + " 't': 75,\n", + " 'u': 76,\n", + " 'v': 77,\n", + " 'w': 78,\n", + " 'x': 79,\n", + " 'y': 80,\n", + " 'z': 81,\n", + " '|': 82}" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ] + }, { "cell_type": "markdown", "metadata": { @@ -238,11 +528,45 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": { - "id": "FYyNlCNXymwY" + "id": "FYyNlCNXymwY", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "56370919-a9f0-4b88-c252-3a4f088167c4" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{\n", + " '\\n': 0,\n", + " ' ' : 1,\n", + " '!' : 2,\n", + " '\"' : 3,\n", + " '#' : 4,\n", + " \"'\" : 5,\n", + " '(' : 6,\n", + " ')' : 7,\n", + " ',' : 8,\n", + " '-' : 9,\n", + " '.' : 10,\n", + " '/' : 11,\n", + " '0' : 12,\n", + " '1' : 13,\n", + " '2' : 14,\n", + " '3' : 15,\n", + " '4' : 16,\n", + " '5' : 17,\n", + " '6' : 18,\n", + " '7' : 19,\n", + " ...\n", + "}\n" + ] + } + ], "source": [ "print('{')\n", "for char, _ in zip(char2idx, range(20)):\n", @@ -252,11 +576,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { - "id": "g-LnKyu4dczc" + "id": "g-LnKyu4dczc", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "4904d0aa-71ae-44d6-e5ba-b7136300611c" }, - "outputs": [], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([49, 22, 13, ..., 22, 82, 2])" + ] + }, + "metadata": {}, + "execution_count": 12 + } + ], "source": [ "### Vectorize the songs string ###\n", "\n", @@ -270,8 +609,10 @@ "'''\n", "def vectorize_string(string):\n", " '''TODO'''\n", - "\n", - "vectorized_songs = vectorize_string(songs_joined)" + " output = np.array([char2idx[char] for char in string])\n", + " return output\n", + "vectorized_songs = vectorize_string(songs_joined)\n", + "vectorized_songs" ] }, { @@ -285,11 +626,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": { - "id": "l1VKcQHcymwb" + "id": "l1VKcQHcymwb", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "947c216c-6683-4dab-c518-1d07894845ec" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "'X:1\\nT:Alex' ---- characters mapped to int ----> [49 22 13 0 45 22 26 67 60 79]\n" + ] + } + ], "source": [ "print ('{} ---- characters mapped to int ----> {}'.format(repr(songs_joined[:10]), vectorized_songs[:10]))\n", "# check that vectorized_songs is a numpy array\n", @@ -313,11 +666,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": { - "id": "LF-N8F7BoDRi" + "id": "LF-N8F7BoDRi", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "9ccd59b8-5dcd-421c-f736-2017610ccc6a" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Batch function works correctly!\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/tmp/ipython-input-1551998044.py:16: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at /pytorch/torch/csrc/utils/tensor_new.cpp:254.)\n", + " x_batch = torch.tensor(input_batch, dtype=torch.long)\n" + ] + } + ], "source": [ "### Batch definition to create training examples ###\n", "\n", @@ -328,10 +701,10 @@ " idx = np.random.choice(n - seq_length, batch_size)\n", "\n", " '''TODO: construct a list of input sequences for the training batch'''\n", - " input_batch = # TODO\n", + " input_batch = [vectorized_songs[i:i + seq_length] for i in idx]\n", "\n", " '''TODO: construct a list of output sequences for the training batch'''\n", - " output_batch = # TODO\n", + " output_batch = [vectorized_songs[i+1:i+seq_length+1] for i in idx]\n", "\n", " # Convert the input and output batches to tensors\n", " x_batch = torch.tensor(input_batch, dtype=torch.long)\n", @@ -360,11 +733,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": { - "id": "0eBu9WZG84i0" + "id": "0eBu9WZG84i0", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "7cb8fc76-bd89-455f-f303-77fa87da8ce9" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Step 0\n", + " input: 1 (np.str_(' '))\n", + " expected output: 57 (np.str_('b'))\n", + "Step 1\n", + " input: 57 (np.str_('b'))\n", + " expected output: 56 (np.str_('a'))\n", + "Step 2\n", + " input: 56 (np.str_('a'))\n", + " expected output: 1 (np.str_(' '))\n", + "Step 3\n", + " input: 1 (np.str_(' '))\n", + " expected output: 61 (np.str_('f'))\n", + "Step 4\n", + " input: 61 (np.str_('f'))\n", + " expected output: 59 (np.str_('d'))\n" + ] + } + ], "source": [ "x_batch, y_batch = get_batch(vectorized_songs, seq_length=5, batch_size=1)\n", "\n", @@ -431,7 +830,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": { "id": "8DsWzojvkbc7" }, @@ -452,11 +851,11 @@ "\n", " '''TODO: Layer 2: LSTM with hidden_size `hidden_size`. note: number of layers defaults to 1.\n", " Use the nn.LSTM() module from pytorch.'''\n", - " self.lstm = nn.LSTM('''TODO''') # TODO\n", + " self.lstm = nn.LSTM(embedding_dim, self.hidden_size, batch_first = True) # TODO\n", "\n", " '''TODO: Layer 3: Linear (fully-connected) layer that transforms the LSTM output\n", " # into the vocabulary size.'''\n", - " self.fc = nn.Linear('''TODO''') # TODO\n", + " self.fc = nn.Linear(hidden_size, vocab_size) # TODO\n", "\n", " def init_hidden(self, batch_size, device):\n", " # Initialize hidden state and cell state with zeros\n", @@ -486,11 +885,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": { - "id": "MtCrdfzEI2N0" + "id": "MtCrdfzEI2N0", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "a4b04153-6f98-4f6d-8d17-b753b5b8e896" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "LSTMModel(\n", + " (embedding): Embedding(83, 256)\n", + " (lstm): LSTM(256, 1024, batch_first=True)\n", + " (fc): Linear(in_features=1024, out_features=83, bias=True)\n", + ")\n" + ] + } + ], "source": [ "# Instantiate the model! Build a simple model with default hyperparameters. You\n", "# will get the chance to change these later.\n", @@ -522,11 +937,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": { - "id": "C-_70kKAPrPU" + "id": "C-_70kKAPrPU", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "68dd504f-c969-4080-d322-13edfc497caa" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Input shape: torch.Size([32, 100]) # (batch_size, sequence_length)\n", + "Prediction shape: torch.Size([32, 100, 83]) # (batch_size, sequence_length, vocab_size)\n" + ] + } + ], "source": [ "# Test the model with some sample data\n", "x, y = get_batch(vectorized_songs, seq_length=100, batch_size=32)\n", @@ -557,11 +985,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": { - "id": "4V4MfFg0RQJg" + "id": "4V4MfFg0RQJg", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "9fda9286-45f7-4885-9ce2-8794951bf446" }, - "outputs": [], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([35, 53, 23, 56, 34, 8, 67, 73, 12, 5, 40, 15, 23, 70, 81, 63, 25,\n", + " 56, 26, 45, 62, 13, 56, 8, 27, 65, 17, 55, 54, 46, 56, 71, 12, 6,\n", + " 8, 80, 17, 2, 70, 57, 66, 23, 10, 47, 12, 82, 29, 38, 53, 14, 51,\n", + " 4, 46, 76, 39, 1, 68, 5, 43, 50, 37, 78, 11, 50, 47, 77, 4, 30,\n", + " 42, 7, 64, 15, 68, 58, 17, 51, 4, 21, 62, 74, 9, 59, 68, 0, 3,\n", + " 51, 60, 17, 22, 45, 10, 79, 22, 17, 60, 27, 15, 16, 31, 9])" + ] + }, + "metadata": {}, + "execution_count": 19 + } + ], "source": [ "sampled_indices = torch.multinomial(torch.softmax(pred[0], dim=-1), num_samples=1)\n", "sampled_indices = sampled_indices.squeeze(-1).cpu().numpy()\n", @@ -579,11 +1027,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": { - "id": "xWcFwPwLSo05" + "id": "xWcFwPwLSo05", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "81672c05-f338-43b6-8ce0-9d10ab30657a" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Input: \n", + " '|!\\nB2Bd BAFB|ABde fded|BEE2 BAFA|BFAF E2:|!\\nFA|Bdef gfge|dBB2 dBA2|Bdef gfge|dBAF E2ef|!\\ng2ga gfed|f'\n", + "\n", + "Next Char Predictions: \n", + " 'J]aATg1a,Bj5_^Uap0(,y5!obk<.V0|DM]2Z#UuN m\\'RYLw/YVv#EQ)i3mc5Z#9gs-dm\\n\"Ze5:T.x:5eB34F-'\n" + ] + } + ], "source": [ "print(\"Input: \\n\", repr(\"\".join(idx2char[x[0].cpu()])))\n", "print()\n", @@ -618,7 +1082,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": { "id": "4HrXTACTdzY-" }, @@ -638,15 +1102,15 @@ " Output:\n", " loss: scalar cross entropy loss over the batch and sequence length\n", " \"\"\"\n", - "\n", + " B, L, V = logits.shape\n", " # Batch the labels so that the shape of the labels should be (B * L,)\n", - " batched_labels = labels.view(-1)\n", + " batched_labels = labels.view(-1).long()\n", "\n", " ''' TODO: Batch the logits so that the shape of the logits should be (B * L, V) '''\n", - " batched_logits = \"\"\" TODO \"\"\" # TODO\n", + " batched_logits = logits.view(B*L, V).float()# TODO\n", "\n", " '''TODO: Compute the cross-entropy loss using the batched next characters and predictions'''\n", - " loss = \"\"\" TODO \"\"\" # TODO\n", + " loss = cross_entropy(batched_logits,batched_labels) # TODO\n", " return loss" ] }, @@ -659,16 +1123,29 @@ "\n", "'''TODO: compute the loss using the true next characters from the example batch\n", " and the predictions from the untrained model several cells above'''\n", - "example_batch_loss = compute_loss('''TODO''', '''TODO''') # TODO\n", + "example_batch_loss = compute_loss(y, pred) # TODO\n", "\n", "print(f\"Prediction shape: {pred.shape} # (batch_size, sequence_length, vocab_size)\")\n", "print(f\"scalar_loss: {example_batch_loss.mean().item()}\")" ], "metadata": { - "id": "GuGUJB0ZT_Uo" + "id": "GuGUJB0ZT_Uo", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "97cccc13-e80e-4712-9808-6aa4884141c7" }, - "execution_count": null, - "outputs": [] + "execution_count": 22, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Prediction shape: torch.Size([32, 100, 83]) # (batch_size, sequence_length, vocab_size)\n", + "scalar_loss: 4.42173957824707\n" + ] + } + ] }, { "cell_type": "markdown", @@ -681,7 +1158,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": { "id": "JQWUUhKotkAY" }, @@ -719,7 +1196,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": { "id": "MBsN1vvxInmN" }, @@ -759,17 +1236,61 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "metadata": { - "id": "F31vzJ_u66cb" + "id": "F31vzJ_u66cb", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 933 + }, + "outputId": "83410c39-2f6c-4dcb-fc65-342b0bc1e4b3" }, - "outputs": [], + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi8AAAGwCAYAAABhDIVPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAUPhJREFUeJzt3XdYk1f/BvA7YW9QtqKoKDgAt1IXbm1rHR1qfa2167XV/vRtta0dVruw861Va+1S69tWW+toraMuXHWiqDhwCyoORKYyc35/QEJCniwI5Em9P9fFdZEnT5KTRzA353zPOQohhAARERGRnVDaugFERERElmB4ISIiIrvC8EJERER2heGFiIiI7ArDCxEREdkVhhciIiKyKwwvREREZFccbd2AmlCpVLh69Sq8vLygUChs3RwiIiIygxACeXl5CA0NhVJpeT+KXYeXq1evIiwszNbNICIiompIT09Hw4YNLX6cXYcXLy8vAOVv3tvb28atISIiInPk5uYiLCxM8zluKbsOL+qhIm9vb4YXIiIiO1Pdkg8W7BIREZFdYXghIiIiu8LwQkRERHaF4YWIiIjsCsMLERER2RWGFyIiIrIrNg0vM2fOhEKh0PmKioqyZZOIiIhI5my+zkvr1q2xefNmzW1HR5s3iYiIiGTM5knB0dERwcHBZp1bVFSEoqIize3c3NzaahYRERHJlM1rXs6cOYPQ0FA0bdoUY8aMQVpamsFzExIS4OPjo/nivkZERET3HoUQQtjqxdevX4/8/HxERkYiIyMDs2bNwpUrV5CSkiK534FUz0tYWBhycnK4PQAREZGdyM3NhY+PT7U/v20aXqrKzs5G48aN8dlnn+Hpp582eX5N3zwRERHVvZp+ftt82Eibr68vWrRogbNnz9q6KSgpU6GkTGXrZhAREVEVsgov+fn5OHfuHEJCQmzaDpVK4L7ZWxGXsAVlKtl0TBERERFsHF6mTp2K7du34+LFi/j7778xfPhwODg4YPTo0bZsFnLuluBmXhEy84uRVVBs07YQERGRLptOlb58+TJGjx6NW7duISAgAN27d8fevXsREBBgy2YRERGRjNk0vCxbtsyWL09ERER2SFY1L0RERESmMLyYIMCCXSIiIjlheCEiIiK7wvBCREREdoXhhYiIiOwKwwsRERHZFYYXIiIisisML0RERGRXGF6IiIjIrjC8EBERkV1heCEiIiK7wvAiQaGwdQuIiIjIEIYXCYI7AhAREckWwwsRERHZFYYXU9gLQ0REJCsML0RERGRXGF4k6BTssniXiIhIVhheiIiIyK4wvBAREZFdYXiRoDNVmgW7REREssLwQkRERHaF4YWIiIjsCsOLBI4UERERyRfDCxEREdkVhhcJgpsbERERyRbDCxEREdkVhhciIiKyKwwvEjhoREREJF8MLyYwyBAREckLw4sE1usSERHJF8OLCQwyRERE8sLwQkRERHaF4UWCYKULERGRbDG8mMAgQ0REJC8ML1KYV4iIiGSL4UXCjbwizfcs2CUiIpIXhhcJe8/fsnUTiIiIyACGFxPY8UJERCQvDC9ERERkVxheTBAseiEiIpIVhhciIiKyKwwvREREZFcYXkzgqBEREZG8MLwQERGRXWF4ISIiIrvC8EJERER2heFFgkKh0HzPmhciIiJ5YXghIiIiu8LwYoLgBgFERESywvAiQWH6FCIiIrIRhhciIiKyKwwvJrBgl4iISF4YXiQoOG5EREQkWwwvJrDjhYiISF4YXoiIiMiuMLxI0B41Eix6ISIikhWGFyIiIrIrDC8msN+FiIhIXhheiIiIyK4wvBAREZFdYXiRwF2liYiI5IvhhYiIiOwKw4tJ7HohIiKSE4YXIiIisisMLxK09zZizQsREZG8MLwQERGRXZFNeJk9ezYUCgWmTJli66boYMcLERGRvMgivBw4cAALFy5ETEyMrZtCREREMmfz8JKfn48xY8bgm2++gZ+fn9Fzi4qKkJubq/NFRERE9xabh5eJEyfigQceQL9+/Uyem5CQAB8fH81XWFhYrbRJd1fpWnkJIiIiqiabhpdly5bh0KFDSEhIMOv86dOnIycnR/OVnp5eyy0kIiIiuXG01Qunp6dj8uTJ2LRpE1xdXc16jIuLC1xcXGq5ZboES3aJiIhkxWbhJSkpCTdu3ED79u01x8rKyrBjxw7MmzcPRUVFcHBwsFXziIiISKZsFl769u2LY8eO6RwbP348oqKi8Oqrr8omuLDmhYiISF5sFl68vLzQpk0bnWMeHh6oX7++3vE6p73ELhEREcmKzWcbyR17XoiIiOTFZj0vUhITE23dBCIiIpI59rxI4KARERGRfDG8mMCp0kRERPLC8EJERER2heFFgvZkIxbsEhERyQvDCxEREdkVhhciIiKyKwwvREREZFcYXiQotCZLs+aFiIhIXhheiIiIyK4wvBAREZFdYXgxQcVxIyIiIllheDGhjOGFiIhIVhheJGgvUlemYnghIiKSE4YXExheiIiI5IXhxQQVwwsREZGsMLyYwJoXIiIieWF4MaGUPS9ERESywvAiQatel8NGREREMsPwYgILdomIiOSF4cUELlJHREQkLwwvEpRaC72w5oWIiEheGF4kPBgbovmew0ZERETywvAiwd3ZEd0j/AFw2IiIiEhuGF4MUCrLh47KVDZuCBEREelgeDHAURNemF6IiIjkhOHFAHXRLnteiIiI5IXhxQCHiivD7QGIiIjkheHFAIeKYSOusEtERCQvDC8GOCjLLw3XeSEiIpIXhhcDHCrWqWPPCxERkbwwvBigmSrNmhciIiJZYXgxwEEz24jhhYiISE4YXgxwdGDBLhERkRwxvBigXueFBbtERETywvBigGaqNGteiIiIZIXhxQAla16IiIhkieHFAEfONiIiIpIlhhcD1MNGZWUML0RERHLC8GIA13khIiKSJ4YXA9TrvHCqNBERkbwwvBjgwJ4XIiIiWWJ4MUATXtjzQkREJCsMLwYwvBAREckTw4sBleu82LghREREpIPhxQBHrrBLREQkSwwvBqinSnNvIyIiInlheDGgYlNpTpUmIiKSGYYXA7gxIxERkTwxvBigUDC8EBERyRHDiwFKTXixcUOIiIhIB8OLARWjRhDseSEiIpIVhhcD2PNCREQkTwwvBijUs43Y80JERCQrDC8GsOeFiIhInhheDFBWXBnWvBAREckLw4sBSk6VJiIikiWGFwM067xwY0YiIiJZYXgxwIE9L0RERLLE8GKAkrONiIiIZInhxQAFZxsRERHJEsOLAex5ISIikieGFwO4zgsREZE8MbwYwHVeiIiI5InhxQAFZxsRERHJEsOLAUqu80JERCRLDC8GsGCXiIhInmwaXhYsWICYmBh4e3vD29sbcXFxWL9+vS2bpKFepI7ZhYiISF5sGl4aNmyI2bNnIykpCQcPHkSfPn0wdOhQHD9+3JbNAsCaFyIiIrlytOWLDxkyROf2+++/jwULFmDv3r1o3bq1jVpVjsNGRERE8mTT8KKtrKwMv/76KwoKChAXFyd5TlFREYqKijS3c3Nza609SiWHjYiIiOTI5gW7x44dg6enJ1xcXDBhwgSsWrUKrVq1kjw3ISEBPj4+mq+wsLBaa5e656WM6YWIiEhWbB5eIiMjkZycjH379uH555/HuHHjcOLECclzp0+fjpycHM1Xenp6rbWLNS9ERETyZPNhI2dnZ0RERAAAOnTogAMHDmDOnDlYuHCh3rkuLi5wcXGpk3ZxnRciIiJ5snnPS1UqlUqnrsVW1MNG3B6AiIhIXmza8zJ9+nQMHjwYjRo1Ql5eHn766SckJiZi48aNtmwWAG7MSEREJFc2DS83btzAE088gYyMDPj4+CAmJgYbN25E//79bdksANrhhemFiIhITmwaXr777jtbvrxR6l2l2fNCREQkL9WqeUlPT8fly5c1t/fv348pU6bg66+/tlrDbE2p2R6A6YWIiEhOqhVeHn/8cWzbtg0AcO3aNfTv3x/79+/HG2+8gXfeeceqDbQVrrBLREQkT9UKLykpKejcuTMA4JdffkGbNm3w999/48cff8TixYut2T6bUbBgl4iISJaqFV5KSko0661s3rwZDz30EAAgKioKGRkZ1mudDbFgl4iISJ6qFV5at26Nr776Cjt37sSmTZswaNAgAMDVq1dRv359qzbQVirXebFtO4iIiEhXtcLLhx9+iIULFyI+Ph6jR49GbGwsAOD333/XDCfZO/a8EBERyVO1pkrHx8cjMzMTubm58PPz0xx/7rnn4O7ubrXG2ZJCvTEji16IiIhkpVo9L3fv3kVRUZEmuFy6dAmff/45UlNTERgYaNUG2oqDUj1V2sYNISIiIh3VCi9Dhw7FDz/8AADIzs5Gly5d8Omnn2LYsGFYsGCBVRtoK+phozKmFyIiIlmpVng5dOgQevToAQBYsWIFgoKCcOnSJfzwww/44osvrNpAW2HNCxERkTxVK7zcuXMHXl5eAIC//voLI0aMgFKpRNeuXXHp0iWrNtBWtGcbcZVdIiIi+ahWeImIiMDq1auRnp6OjRs3YsCAAQDKN1r09va2agNtRV3zArBol4iISE6qFV5mzJiBqVOnIjw8HJ07d0ZcXByA8l6Ydu3aWbWBtqJeYRfgKrtERERyUq2p0o888gi6d++OjIwMzRovANC3b18MHz7cao2zJe2eF9a9EBERyUe1wgsABAcHIzg4WLO7dMOGDf8xC9QBlTUvAIeNiIiI5KRaw0YqlQrvvPMOfHx80LhxYzRu3Bi+vr549913oVKprN1Gm1Aq2PNCREQkR9XqeXnjjTfw3XffYfbs2ejWrRsAYNeuXZg5cyYKCwvx/vvvW7WRtqATXv4ZeYyIiOgfoVrhZcmSJfj22281u0kDQExMDBo0aIAXXnjhHxFeWPNCREQkT9UaNsrKykJUVJTe8aioKGRlZdW4UXKgU/PC8EJERCQb1QovsbGxmDdvnt7xefPmISYmpsaNkgOFQqHZnFHFgl0iIiLZqNaw0UcffYQHHngAmzdv1qzxsmfPHqSnp2PdunVWbaAtOSgUKBWC67wQERHJSLV6Xnr16oXTp09j+PDhyM7ORnZ2NkaMGIHjx49j6dKl1m6jzXBzRiIiIvmp9jovoaGheoW5R44cwXfffYevv/66xg2TAwelAigDysoYXoiIiOSiWj0v9wpnx/LLU1xWZuOWEBERkRrDixHq8FJUyoVeiIiI5ILhxQhnh4qeF4YXIiIi2bCo5mXEiBFG78/Ozq5JW2THxZHhhYiISG4sCi8+Pj4m73/iiSdq1CA5qax5YXghIiKSC4vCy6JFi2qrHbLkzJ4XIiIi2WHNixGseSEiIpIfhhcjOGxEREQkPwwvRnCqNBERkfwwvBjBYSMiIiL5YXgxwsXJAQDDCxERkZwwvBihXuelsJTbAxAREckFw4sRrk4VNS8l7HkhIiKSC4YXI1wdy4eN2PNCREQkHwwvRriw54WIiEh2GF6M0PS8lLDnhYiISC4YXoxwrZhtxHVeiIiI5IPhxQh1wS57XoiIiOSD4cUIFw4bERERyQ7DixEump4XDhsRERHJBcOLEZU1L+x5ISIikguGFyM0K+yy54WIiEg2GF6MUPe8cJE6IiIi+WB4MUIzbMSeFyIiItlgeDHCUakAAJSUMbwQERHJBcOLEUpFeXgRNm4HERERVWJ4MUJZcXWEYHwhIiKSC4YXI9Q9LypmFyIiItlgeDGiouQFKva8EBERyQbDixGKip6X7DslmLvljI1bQ0RERADDi1HqYSMA+HTTaZy4mmvD1hARERHA8GKUUqF7O/tusW0aQkRERBoML0Zo97wQERGRPDC8GKGXXVi3S0REZHMML0ZU7XnhlGkiIiLbY3gxomp4Eex6ISIisjmGFyOqFuxyuRciIiLbY3gxQqHX80JERES2xvBihH7PC+MLERGRrTG8GKFf80JERES2xvBiBKdKExERyQ/DixH6NS9ML0RERLbG8GIEZxsRERHJj03DS0JCAjp16gQvLy8EBgZi2LBhSE1NtWWTdFSteSkpU9moJURERKRm0/Cyfft2TJw4EXv37sWmTZtQUlKCAQMGoKCgwJbN0nB00A0vE/53CDl3SmzUGiIiIgIAR1u++IYNG3RuL168GIGBgUhKSkLPnj1t1KpKLo4OqOfhjKyCyt2k16VkYHTnRjZsFRER0b1NVjUvOTk5AIB69epJ3l9UVITc3Fydr9r2SIeGtf4aREREZD7ZhBeVSoUpU6agW7duaNOmjeQ5CQkJ8PHx0XyFhYXVeruqzpYmIiIi25JNeJk4cSJSUlKwbNkyg+dMnz4dOTk5mq/09PRab1fV6dIMM0RERLZl05oXtUmTJmHt2rXYsWMHGjY0PEzj4uICFxeXOmyZ/nRpIiIisi2bhhchBF588UWsWrUKiYmJaNKkiS2bI0lvlV0iIiKyKZuGl4kTJ+Knn37CmjVr4OXlhWvXrgEAfHx84ObmZsumaVRd64WIiIhsy6Y1LwsWLEBOTg7i4+MREhKi+Vq+fLktm6Wjas0LERER2ZbNh43kjtGFiIhIXmQz20iuqg4b/bQ/DRcy5bECMBER0b2I4cUEN2fdS3T0cg56f5Jom8YQERERw4spbk4Otm4CERERaWF4McGV4YWIiEhWGF5McHbkJSIiIpITfjKb4OTAS0RERCQn/GQ2wZH7AxAREckKw4sJjg4ML0RERHLC8GKCo5KXiIiISE74yWwCa16IiIjkhZ/MJjT0k8cGkURERFSO4cWEsHruksdf/uWI5vs/j2ZgwH+348z1vLpqFhER0T2L4cUMS5/urHfst0OXNRtLTvzpEE5fz8f/LUuu45YRERHde2y6q7S9aOgn3ftyt6QMJzMqe1ty75bUVZOIiIjuWex5MYODQnq6dF5hKTakZGhuqyp6YoiIiKj2MLyYwUB2QVGJCtp5pVTF8EJERFTbGF7MoDSwyu6G4xlISrutua1ieCEiIqp1rHkxg6EdAj5Yd0rnNnteiIiIah97XsxgqOalqjKGFyIiolrH8GIGRzNX2WV4ISIiqn0ML2ao5+Fs1nkML0RERLWP4cWKyjhVmoiIqNYxvFgRe16IiIhqH8OLlQkhNNsGEBERkfUxvFjZI1/twSNf7YEQAoUlZdiQkoG8Qm4bQEREZC0ML1aWdOk2ki7dRlZBMWasScGE/x3Ciz8ftnWzNMpUAt/sOI+jl7Nt3RQiIqJqYXgx06LxneDn7mT2+UqFAr8cvAwASEy9iRNXc2uraRZZfiAd7687iYfm7bZ1U4iIiKqF4cVMvSMD8fmodmafn3j6hs7t+7/Yae0mVUvqNXmEKCIioupieLFAmUpl9rlvrzleiy0hIiK6dzG8WKC0zPxZREWl5geduqQwc6sDIiIiuWJ4sYDKginQcg0vRERE9o7hxQLcNZqIiMj2GF4sYK0VdFUqgVPXcmW/Im9hSRkX3CMiItlheLGAJTUvxszZcgaDPt+JGWtSrPJ8teH8zXxEvbUB/1mebOumEBER6XC0dQPsSU17Sjq+twlZBcVQP82P+9IQ3cAHEYGe6BhezwotNM3cet1Fuy8CAFYnX7VoijgREVFtY8+LBe6PCUGojys6hftV6/GZ+ZXBRe21lcfwyFd7NLc3n7iOuVvOcLiGiIjIAPa8WMDTxRG7Xu2D63mFiEvYWiuv8cwPBwEAsWG+6NkiwOLHCyFwI68IQd6uNWqHAMMTERHJE3teLKRUKqCsg7VSrucWYvfZTHy88RRKy8yfdv3xxlR0+WALlu65KHm/AlznhYiI7BvDSzXUxce/QqHAmG/3Yf62c5o9kopKy7At9QbuFpfpnX8hswDv/3kCXyaeAwC8/bvpFX63pd4weQ4REZHcMLxURy2kl+JSFS5mFki+xIXMfADAzN9PYPyiA5IzgEZ9vQff7LyguW1ObfH4RQfMbl9Gzl1MXnYYh9Num/2YuiSEwNXsu7ZuBhER1QGGl2qojaGXMd/uRfwniZrbn206rfm+pEzgVn4Rft6fBgDYcPya3uOv5xZZvU3aXlp+BGuSr2L4l3/X6utU16w/TuC+2Vvx475Ltm4KERHVMoaXatAuefl6bAcorZBlDlzU7dG4otWLUKYSeHrJwZq/CMyfKl11stMFrV4hOVr890UAwIfrT9m2IUREVOsYXqrBz90Z7s4OcHNyQN+WQTif8ECtvl5WQTGS07P1jpsznbq4VIWkS7drvEYN93MkIiK54FTpanBQKnDorf6a72vbn8cy9I6VlKkw/MvdaOrviS9GG15E7rWVR7Hy0BVM6h2BqQMjq90GZhciIpIL9rxUk6uTA1ydHDS3fdyc6vT1Z68/hZQrufj9yFX8ciBd8pwylcDKQ1cAAPO2nZU8x9xp2Ao76Xqxl3YSEVH1MbxYyaaXetbp6323q3Jm0Su/HZU85921J/SOVf1oLyyVDi/5RaVmteNWfhHeW3sCZ67nmXW+IZtPXEefTxJx9HK20fPO3cxHetadGr0WERHZN4YXKwn0csXL/VsAAIbEhtq4NeXURazaqnZMGOqnWJN81eDzPvDFTrxWEZheWXEU3+66gAfn7qpmK8s988NBnM8swDNGCpPzCkvQ99Pt6PHRNqhkviM3ERHVHoYXK3qxb3OcfGcQelVjWX9bKTNzDyWl1k/K8au5WFYxVLX/QhYAoMhAD445tHt5pBbgU7uRVzkdXMW9n4iI7lkML1bm5uwg2w/WNclX9I5tPnEdE5YmYeup60Yfa2htm8JSw2HDXI9/s9fixxi6wix5ISL652N4qQVy3RF68rJkvYLWl345gg3Hr+GpxcbXkUkzUGdSUlbz93r0co5Z52m33JKAKITAley7sv13ISIiyzC81IJAr8odnX9+tqvm+wdiQmzRnBr791LpYGPLMGDJS8/behbdZm/FF1ukZ1wREZF94TovtSA+MgAv9olA61AfdAz30xwf2TEMRSUqbD5pfIimNh2RWOzOlI3Hpds7bYX0LCdjVCqBvMJS+LhLTy3PMzLLSbvXyFDPi9So0acVWy38d/NpRIV4YWDrYPMbXGH76Ztwd3ZAp/B6Fj+WiIisiz0vtUChUODlAZEY1CYYSq0PXAelAt+O62jDlgH7Kgpsjcm5W2LWc61Iumz0/p/3p2H76Zs6x15fdQyx7/wluWKw2mebTuPtNSlGn7u6Kwb/e2kSAOBiZoHOFgzGZOYXYdz3+/HoV3tkO/RUYuZ6PURE/wQML7VMewFee6kl/WRjarUel3Klsnbl2OUcTF95DOO+369zjnqWknrjyQKJnpYvtpzBkj2XcO5mvs5x3ZqXajURAJBbWIL4TxLRbfZWCCFMLtR3K79Y870cs0vSpdto8eZ6fJnIYTEiujcwvNQy7aEOua/+ere4DKVlKpzPzDd9soQH5+7CLwfTMXTeLgyZZ3zdl7zCElzLKUTrtzcaPKewRHcmk/aHc016QK7cruxx+WDdScTM+gvHLudg7pYzJhfAq82ZZFkFxaZPkvDGqmMQAvhoQ/VCJxGRvWF4qUOG9kFaOLZDHbdEWssZG9D5gy04fb164QUoX7TuSJXZQ1JBQwHpqdvatNd1EULgl4OVw1QqASzdewnbUm9I7nh9p7gUr/12FNtSb+jdpx1Avtl5AXeKyzBk3i58uuk0Riz422ibzFkXpzrB6peD6Wj/7qZq93oREd1LGF7qULB3+SykDx+O1jk+sHUwfns+Di1DvG3RLB1ZBcW4qRUarMFQfUqpibGf8YsOaFbSrXrqkcvZeGt1CsYvOoDenyTqPfabHRew7EA6xi86oHffhpRrBl9T6r1rd5hN/PGw0TavOnwZnd7fjENpt42eV9Vbq8trfAztQUVERJUYXurAT890wbzH26FRfXcAwMhOjfTO6dC4HtZP7lHXTasTY7/bj082puJGXqHmmADMWuK/uKIepWpB6rWcQqnTNUNzV40U487dajwgVB2+0e4vMzVT7D/LjyAzvxjP/y/J6HlV1WREUY51OEREtYlTpevAfRH+tm6CTe05fwt7zt/CjjOVM48Op2UjKth0T1NhSRmUCoVmLyU1qUJfbcoaxPIf9lzEw+0boqRMhWd/OIj+rSyfWl1qhcX7iIhIGnteqM5kVhmS+Xl/msnHtH1nE1q8uR6rq2wU+d6fJyXPzyooRmFJGW7kVn/o6/PNZ9Djo214c3UKzt0swFfbz1n8HNrRJedOCXp9vA2z158y67FlKoFdZzLNnrJuSzfzijD6670m65fkKL+oFH8dv6ZXGG7vVh2+jH99uw/Zd6pXAE5kDxheqM54utZNR1/UWxuw5ZR+oa6lCgxsEnn2Rp7Jx2YVFGumYC/ZcxGXbt0xGIK2nLyOwpLKYbHfDl3Gv77bhycX7Zc8v6i0DBN/OqQJf0Jip6e8whJM/fWI3jo7N3ILkXPHeqHoww2nsOf8LUxelmy156wrz/8vCc8tTcI7a0/YuilW9Z/lR7DrbCY+33zG1k0hqjUMLzbSNMADANCj+b0zpFSTWUw2YaCYpN9nO/D32UwA5UHik42pSLqkX6A7eVky8otKddaRWX5Av7fp6SW62y+sOlTei3E4LVvy9ben3sSfRzMwfeUxvftUKoENKRl4cO4urEi6rLPOTs7dEnT+YAti3/lL73FlKoHCkjJ8veNcxdRr84a9si0MQmdv5OHJRfuNLlJYV3aeKf83XGZGD6A9soeeO6LqYs2Ljfz4TBesPHQFozvrF++qLR7fCe+uPYFzN8unAjs7KtHU3wPuzg44ZOCDjayn6pRvbbP+OIHX7o/CnM1nkJyejXnbzuLi7Ad0zvnzWAbulpShdWhlbc+rvx1DfGQg/Nydcfp6ns59apezja81c0erR6jqTK7Jy5Pxx5GrVR+C/KJS/PD3RYPPOfDzHbiYWaCZAfZoxzC0DfM12o7qGPf9AVzJvovE1Jt618tWzIlpJzNycexKDh7t0FD26zUR3QsYXmwkxMcNE3tHGD0nPjIQ8ZGBCH/tTwBAk/oe2DClJwBgzuYz+O/m03qP2TGtN3p+vM36DSYdqdfz9KZhS80w2nrqBlqGeOkce/Gnw/D3csa6Y9cwuW9zvcekZ1XOlMoqKMbOMzcxsHUwXJ0cAOjOTCouVel0EEkFlwfn7sSV23dx20gvydkbur1idw0MmVlC3Xuj/WFv7pYMdcmcTqbBc3YCALxdHTGoTe1vsPrV9nO4XVCM6fe3rPXXIrJHHDaSmc0v9USrEG/87+kuevdpL642uV9zvSGnIG8XhNVzk3zeRzs0tG5DSc96A+vHVC0e3n8xC+uOlZ87Z4vxuoTRX+/F5GXJiHprA3ILS5B9p1hnv6x+n23X6YmRknIlVy+4VHeF4k82pmL8ov24U1yKo5ezkVUgXRgthMAjX+3BiAV/y3Y/KG35JmavqR27Yrg3zppmrz+FhTvO4/xNOxtqJaoj7HmRmYhAL6yrst7La4Oj8OGGU0gYobu4nfZftKffGwxnR8NZ9K0hrdCpST28Uo2doAHAUakwuagcSVsj0RtirtTrlcXBMTPLa1VGtG+gOVbdngyVABwqfnwkV0CuuO9OcSncnBygUCjwn+XJWHW4vB6n1QzD2zrkFZbggS92Ia1iq4XBc3bi/eFt0KGx7o7cQgiUqQT+PJaBC5kFeCg2FI3qucPRwfTfVLmFJTh06Ta6R/ibdb4pbd7eiN8ndUNMQ98aP1dNaf97aBdyE1Elm/a87NixA0OGDEFoaCgUCgVWr15ty+bI1oRezXD6vcHoGK77n/+MB1vC29UR0wZGGg0uAODt6oTHOoahnodztdpgaGsDqnsrD9V8WvKKpHTN94YyaXrWHbSasRH/XpqEwpIyTXAx5ftdFzXBBQBOXcvDwwv26J236vAVTPrpMCYvS8bnm8+gz6fbMerrvUhYdxKHTaxQfP+cnXhy0QEs3HHerDap3S0uw0WJ7SQAYL4ZqxvXVieSdu2SqdcoKCrFttQbKC6tvWBjD71l/xRCCKRcycGdYvN6/6yhqLQMBy9mmdyUVs5sGl4KCgoQGxuL+fPn27IZdsFJ4q/LiEAvJM8YoFc7s+vV3ljyVGfJ57F2BhnYOgjRDXys+6T/MLX5IVNdr/52DCczcgEApSr99p3KyNXUefx14jraGNlAs6q7Zq6b8seRq9hwXHeo7eCl21i44zyGf2l4j6m5W87gcsXmmisPXTZ4XlVCCLScsQHxnyTimEQxthDlU8k/2ZhqsEerNj7SP9mYipiZGzV7dJna/PP5Hw9h/KID+GiDeesGqRnapqOqycsOo++n26u1/k1WQTFu5Eqvfl3bVCqBolL7W7NnQ8o1PDh3F4bPN76vmjVN+/UoHvlqDz7+y373UrNpeBk8eDDee+89DB8+3JbNsGtKiTTS0M8dvVoEoGNjPwCV07IB3aGmna/0xh+Tuks+b5C3i1mvr4ACayZ2wy//jrOk2SQDg+fsxID/bkfuXf2/+Gb+cUKnDsScIcM1yVdwp7gUG1IyzHp9S0chi0tVKC5V4dNNlYXqljzFu2srFzbceFy/PunI5Wx0/mAL5m07i7Hf7bOscTUwb9tZFBSX4dOKDxLt9yQ1sWlHxdo9P+4zf4r38as5iJm5EQuNrDWUsO4kylQCa5Kv4nxmAdYezbCoN0ClEmj/7iZ0/mBLnfYiqD381d/o8O5mm7y2Jf48moH/LE/WhMPfKnpStYeIa9vvFUPZC7db1nMpJ3ZVsFtUVITc3FydLzLsy3+1x4t9IrBUq/jXWasHJ6yeO6IbVvaarHrhPjzdvQkA4IenuuD/+lT26BiaHapQlAeozk3qSZ9Asnb6ej72X8iyynNNXpaMB+fuwsVbxqd6q5nqYdBWphKIS9iCFm+u1zl+/qb+ENDFzAK8vSYFCetP6syi+n73Bc33Uj2Q17UKq8/fLEB61h08vfgA9p6/pTluyWhKYUmZzvDLvvO3cCX7LgqKSrHk74s4eyNPZw8u9Znau6mfuJqLD9adRG5hecG19p5e5uxwrvb6qhQUFJchwcAqz08vOYiFO85j9Nd7Ncem/noErWZsNLiPWFXFWkMQN3KLzO7pqY6DF7Pw97lMqFQCX20/hwMXs3A4LRv5RaVW+3muLRN/OoRVh69g0e6LevcJIcy+3vc6uyrYTUhIwKxZs2zdDLsR6OWKlwdE6hz7ckx7PL3kIKYPjtIcmzOqLbLvlKBdIz+0a+SHaQMj4erkgMjgSHxRsYlhZLA3jkgsLMYlL+xf1U0va0IqTKhVHYYw9brTfj2C4e0aILqhD/aez8KtAunl7rMKiuHr5oRZfxyHp6sj5m+r7F1YuP08tk+LR+P6HjqPmWtGfcvLvxzB/otZOqs1S61mLCUzvwid3t+MXi0CsHh8ZxxKu42RFcFgZMcwLD+YrvcYddDR7vV5+dcjmvf4xv0t0TVhi+Y+S4YjiySGgApLyvD+nycxoHWQ5tj+i/of/N0+3IpzH9xv8jW0/z1zC0vQ+f3N6B0ViEc6NET7Rn4m6/LMVVqmwiNflddQvTesjdnbbshNZr7+TL1P/zqNedvO4q0HW2n+kCRpdhVepk+fjpdeeklzOzc3F2FhYTZskf2JDfPFgTf66gwfDW3bQOcc9Xoi2oK9XfDxf3oir7AUDy+oHJtVaO25vPu1Pjh/Mx9jv5Ne1t6QBr5uOjUGUcFeOHWt7rpQ73VTlifXyev8VGWYY+95438h/5p0Gb8mma5puXz7Dvadv4sley5J3v/wgj04+GY/nWPmdFpI1b0s3H4e7Rv5oVeLAJ3fk4KiUmw+eR2dm9TDtzsvIDO/CEIAiak38faaFDho7RQqFVzUbXp37QnJAJicno1pEjMFP/0rFZP6RMDFsbwtUoGwsKRM8vfpmx3nsXTvJSzdK33d1MztQSnR2ox0+YF03Cooxoqky1iRdBmjOoVh9sMxmveSciUHw9s1gIdL+UfQ7YJiJKdno2eLAJOTA7SHMA2tQl0XhBBWWrCw8v3MqwjV7649UaPwkp51B3vP38Kwdg0k6yXV7PmPT7sKLy4uLnBxMa8Wgwyrzi+cAgq0CPKSukOjga8bGvjqrjPTr2UQNp+8bvS5/TycdD4oWgR5IT3rjsG9hQDA1UmJ75/shMe/qbvaBKqZb3bWzvh6qUrgnJH1UKT+wq2Jfy9NQrtGvvjo4Rg8teQAYhr64vzNAk0BdFWGQlVVN/OKDK4VdPZGvt5CggAwd+tZzN16Fj2a+2PJ+M6I/zhR534hBEZpDQVp054RZkrCupMmF8zTDk7KKv/HLDuQDn9PF0wdGIlh83cDAN5cnaJZZXn0N3tx6lqexT0O1uo1vJJ9F3vO3cLQtqFGP+zVgaVMJTBiwd9o4OuKL8d0MPn8QpQvCdAqpHJF7e92XcBbD7aySvur6vFR+UKluYWl/9geHLuqeSHb0f6/6Mn7wjXfh/q4Gn3cN0+Y/sWuatZDrU3+9aVUKHBfs3tnX6h/goxaGsv/eEMqPvlLf7VpbaeuWbc+7nBaNvr/dwfSs+7iz6MZBoOLJQ5K7I9lrp1nMrH99E2dPwJ+P3IVrWZsNLiPlCUVKVJT0nedycTP+9OgUgm8suKIzsajUvVM84wM1al7ht5dewInM3Lx8/40PLLgb2Tk6Pd+aT/37wbWUJq/7Sw++ysVKpXA1zvOIemS8V6+Pp8kYuqvR/DdrgsGz0m7dQed3t+C+dvO4tiVHBxJz9YsNql2t7gMW09d1xsi3XTiOib9dBh9Pt1utB2WMjUjbJ9WvdY/jU17XvLz83H2bOUP9IULF5CcnIx69eqhUSPDe/5Q3dMOLzMfao0ezf3x+5Gr+D+J5e11H6fA+sk98MeRq/gyUXqmAwA09ffA+Yqpon4ezpKzqLQ52HN/J1nVHjP+gx70+c46aIlt3cjTDYdlKoG7KsMfbjVdyuVfFbU5OXdL8MtB3eE9c5/6YmYB/jymOztNPUUfAGasOY5vnuiIP45cxfe7L2D+4+3h7eZk9DmLSlX4eGP5zC1vNyd8sK68JsbYXlpFFfVDu89mYkKvZprj3+48j5Iygefjm+HDDaeQmV+Ejzem4r5m9Svfq9bw0cu/JmPdsWs6w2TFpSqDAfLSrQLJ2X4AcCGzAO7ODgjylv4Dcf62s/h4YyqWP9cVXZrWlzynag+YOYQQWLjjPFqFeKNniwCLH19XbBpeDh48iN69e2tuq+tZxo0bh8WLF9uoVSTFx013cbu+LYPQt2WQgbN1tQzxRssQb3Rv7o9Xfzuqs3cPUD4kVVSl+NDQr9zL/Vvg002n8fGjMTrHPZwdjA4zEVlKPcPHXrz6m/4u41IKikqhVCjMLj5WW5N8BVHB3gj1dYW7c+VHh9RwlrniP0k0ev+mE9ex6cR1vPjzYQDAzN+P471hbYw+RnuGV022c7hTXIr3/iyfXv9Yx4YGr1eZSsCxYrlqdU/MsgPpmP1wDA5ezMKjC/UXaFTrVWWYT1vvimvzzRMdsfXUDcx8qJWmtgmAJqCN/Hovjs8aCA8XR2Tf0S1qV0qMrZiaSr7jTKamCFoum6dKsemwUXx8PIQQel8MLvLx35GxiGtaH9MGRpo+ucKwtqEAgPujg3WO39fMHztf6SP5mMb13U0+79Pdm+DFvs1xfNZAvc3xfn+xu8kZEd0jdIeZ1OvgqG2fFq+3X5RaswAPyeMLx0oPi71+f5TkcbIfeYXyXi+kulq/vREtZ2xAmplT2tUmL0vGwM93IHrmX2j2+jrNcUeJXlJrLtD77A8HNd//deI6On+wxcjZuusHVd2o9NzNfLy64igu3TI8K06tpLTyiUrKdItztb9/+/fjBp/jzdUpEKJm1+PZHw7i5/1pWGqkdur1VcdQXKpC23c2oe07myTbqbYm2fh2JdckhurkiDUvZNTwdg3x83NdLdpWIGFEDBaO7YCPH4k1+zGfPBqLoW1DsXpiNwDSv3Tq4jb1DAWgfCPLn57tgmYBnpJ1MoY2pGzg66bzd9Sht/qjcX0P/CCxMvGQ2FCdtXK0uTgqcXH2A5gzqq3O8QAvFpaTvNWkxkbbsgP6s6d+3i+9gN6qw+aviFxd17VW+K06UWrkwj1YfjAdvT5OxJurj0EIgf+r6NUByv/fmb7yKD7bdBq7zmZqjisVhnuDf9yXpjdkB5T3ALlYaXo4AFzNLsTxqzmY+ftxHL+q26O0Jvkqcu7q9xTmShzT3hJAiPKeI+3aGWtNaa9tdjXbiOyDm7MDBrYONn1iBYUCCPV1w5xR7TTH+kQFYoXWNNnRnaVroCICvRARKDELqkLrUG/8mlT+vfYy+O0a+eosEKYOZ1VD0/zH2+OBmPJenl/+HYfHqnQBq/+ieig2FJOXJWuOtwoxvmXCiglxuJlXhOd/PGT0PHM8EB2iVzdAJEf/WX6k1l9j1h8nJI+nZ91BZn7lsMr/9qahb8sgnaJf9erFAODkUPl/wfqUa1h7tPJ3rGqQKS3T71rZcvKGVYPA97svaBZaXPz3Rb37pcLLzjOZSFh/EqE+bhhXMdGi6npJ6l603a/1gberIzaf1FrXyGrTwa2P4YVsrn0jP71jMx9qjdiGPhjQOhjFpSq9KdiGfPxIDGb9cQIv9W8BlRD4V9fGmFnxn1mZSqC+hzNuFRRjcJsQfLvL9NRddXABILmKsHocvOoveGSwFzqH15Nc9AuAZpPNf/dqity7pZjYuxn6f7bD7H2BACC8vjvGxoWjQ2M/hhciE9TTh7UVGdm1W3vdmqpDQ1Wn/QvoT9t+Rmu4qy4sMDAhQr0FQKCXCwZHh+DzzWckz/tkY6re5qt3S8p06pvkxD76h+gfZe2L3fHB8GhsfqkXpg2MlKyn8XRxxNi4cAR5uyKsnrvJ2Udqj3YMw5G3B+Cp7k3wTI+mcNRas6F5kBc2/qcn/vd0F9wfHYxQH+lANC6uMQDdKeGGRAZXrtvwztDWCPZ2xeaXegEAumvVz2x9uZemd6dTeGVYmz64JRJGRKOhnzue7dnUrPeotmFKTzzdvYlOzUG/lkF4rKP0UBkR6apup4J2LwwAfLj+VLU2srSm30xsUvr8j4eQZGSoUGrX+FYzNmLtUeM1MrYiz0hF/2htGvigTcVO1BGBESbOtlzV2pc/JnXH6uQr+L++zeHj5oTuzcvrUd5+qBWKy1QY27WxzvlvPdgKD3doiNah+kM/h97qj7zCErg4OiD7brFOj9ATceF4Ii5csk1NAzyxYXIP/Jp0GY91lF4VelSnMHyxRfqvIinq0KJdDPj12A5QKhV6U1cBYOnTnTH11yM6e/hY4v3hbfDHkasmV8YlshfmFO6a4/cjV3H7jvT2FXIitcWLKZN+OowHY0Kt35gaYs8L/eNFN/TBWw+2gk+V9SECvVzxzRMd9dYycHRQIqahr2QBcD0PZzSu74FgH1dEafW6mCPQ2xUTe0cYLOYN9XXDsZkDJO/zctH/O0PdPu1Fu6R6qJoFeGD3a33Qo3mA3h4/lhAC+G5cp2o/nkhu1GvAWMPOM5mmT7IxS4al5Y7hhUhGvFydsGJCHH5+tqvO8b+n98EL8c10jqnrbNTbNlQNZwDwRFxjbHk5XtNDJDWt1RIeEiHKmlyd+F8SUW3Z+w9acZf/UxDVEs9qftB3DK+HuGa6K2Z6uTrhlUFReH+4/gJdbs4OSJk1EPvf6Kt3X8sQ3d6h6qy4WdUTcY1Nn1RN1W3fiHYNTJ9EdI+zh94hczG8ENWSx7s0Qq8WAXhnaGurPaehQOTp4qiz+uYfk7rjzQdaGqyvAYBXBlUWSjeu744Db/QzeC5QueS7NQKQIVI7mpujdQPjU9OlVB2+WzyeQ2JEUu7KcPVyhheiWuLq5IAlT3U2WMRryoIx7eHh7IDvxnW0+LHRDX3wTI+menU72rdHdWqkWcuibZgvArxcMLRtZWHeyhfuw4oJcZrb6hWJq2YXNycHzBnVVrIux5Dw+u7439NdMHd0O50lyKWGvqRUXT9jVCfDIc0Q7WXkB7cJRnxkoEUrSRPdK/6317yd0esSwwuRTA2ODsHRmQPN3kPKHNpbJNTzcMaGKT0xqXcEZj1U3jukPXOpfSM/dAyvh32v98Waid00Q1BVN8VMmTUQQ9s2wDEDQ1fq19L2wfBodG/ujyGx5WGpdWj5cw9tG6o31KXNw9kBiVPjcfKdQTo9Jx4ujuglsYlc1enuHs6VPTuTekfgX10boXdkAOY/3l7v/tog1UZtW1/uZfI5ukXUR/NAT2s1icik99edtHUT9DC8EMmY1IynmniyWzjeHdZGsxZNswBPTB0YCV/38nChktiEJcjbFbFhvprbVXtetNvo7arfc/LF6HY4+EY/dNDaS+q+KvtM/fRMV3zzREdM7B2BJU/pD9881a0JmgV4YNXEbgj394CDUqEXomIa6g8dvfVgKzzdvYnm9rZp8ZrvR3VuhPeGRWPR+M6aWVq1vZpomdZ69WO66K8a3TTAdCj58ZmuWPnCfVZtl7YFY9pb9fnkvDMx2S+GFyI7UtMN75wclBjbtTEiDPzlbs7Tq4OOFFcnB/z2fOVQU1N/DzwUGwqlUoHPR7ZF9wh/yf2jfNyd0L9VEJwclAj0csXht/rrfIg+0qEhtrwcr5lZBegHuxKJJdodlAp0Cq9cGTnQyxWLx3fC0qc7S9bXDG5j/rYWQPm+V5P7Njf7/Kjgyva/O7Q8RFZnHywviZBoyAMxIfjokRjTJ1bo38p6PX2Pd2mEJeM7Yd7j7UyfTGQBhhciO9Khyk7YVmdGehnfLVzzvXaPjFqHxpVhQfvpwuq543/PdDHrL3E/D2cMjg7B6/dH4cn7wtEyRH//qkBv3Q/9MpX0Uu9Vp1/HRwaiR3PpNgR6uyJl1kCDu4tXNXd0O/ynfwu941LXBQCm9G+B5+ObYe2L3aFUKhAR6ImBrcvDQhN/02vwGAqdxsx/vL3Rwu2qtFeltlRTrd3XB7cJxgfDo6FQKGS5yJmt1bdgs1vSx/BCZEfC6rlj29R4JM/oXyvPLzVsVJW7syMuzn4Am1/qieXPdTV6bpB3zXbXfq5nM8x8qLXkcM7nI9uia9N6mllCg6ND9M4BgPYVgS/Ux9Ws1/R0cUSImedKWfnCfQbX0/F0ccSrg6I0K0wDwOv3t8TsEdFY/m/da9m+ka/e49dU7LquzdwiZ23/Z6K3SHsmmpTPR7aVPL5kfGWvmqE9cbxdHdHQz7y9ysyVMCLaqs9XF9zMqK96dVAU7o+2rDfQkOou3SBXDC9EdqaJv4fRoZua0B6WMSUi0Mvg1OYfn+mCXi0C8PEjsdZqmp7G9T2w7Lk4xEcGAigvMN76ci+ceGcgljzVGXunlxcPe7s64djMATr1Lqa8OigKYfWkP2CXP9cVbk4OOlPg1Vll2XNd0b6Rn054+faJ8tli/+4lvXeVu7MjRnVuhEAv3cD0RFy4Ti8XALhozbJSP99bD7Yy701peUmit0jbqE6N4O1a/mH3fJXFEaf0a45hBtbVCavnbvK1FQoFdr3aB32jAs1srXH+ni4Y3bmRyWJobasndsO+16WLy+vSsue6oq2BXroDb/TD8/HNMP/x9vjqXzWvQ6rOjDy1flacNGAt/6woRkQ18nx8M5SpRI3rHrpF+KNbhHlDL9akLnit+kFmSY0IANT3dMGOab3x4YZUNKrnjq2nruN8ZgH+mNQdHi6OODZzgM7wyt7X++Ji5h3NzuPTBkbika/24Im4xujXKgjJM/pb3EMS7OOKYe1aY9Hui5pj2mvsvDYoCs90b4oALxc8FBuK1YevoFtzf+w+k4nT1/Pw7a4LmNRbf+8wL1fT/+3X83DG4RkDNHVF207dwKlreQCAKf2MBx81U7XPk/pEYMupG2Y9lzm2n74pefybJzriv5tO40RGruaYt6sjgrzN7117pENDrEgyvvGhIa5OSozp0hjf7bqgd1/XpvWxemI3hL/2p9596loohUKBQAvaakjV5QVMaRnijZMV18zK8wasgj0vRKTh6uSAqQMjDdZs3EsUCgVeGxyFx7s0wrfjOmHLS7002yNUrQsJ9HLVBBegfJXklFkDNVPQfd2dzZ7J9NW/OmDawEh0qXg+9XRyQHfvKoVCofmAc3ZU4rFOYWjg64bHOoXhzQdbIfW9QZhq5ro1VTcnBXQLoqXaXt2ZcOqnatfID0lvSi+M+P2THXH6vcF4uaKHqJ3EEJqaqSGo/q2CsG5yD51jpuqLXr8/SvO9v6cLgmsQHo68PUCyp8uSiW0qlfHh3C5aP3uGPKU16w4wHUhmaPXo1fIkvGpheCEiMoOl06g9XRyrNfV6UJtgTOwdoXnsw+2rt/WB9orL2lpWbCi67v8qP9Af6dAQ/VoGGlwNWuqDTvvxALBwbAed2+a88/qe0jVRfaKC4OyoxIT4Zlj+XFcsfy5O8jygvGga0F8x2ZBRncI019bfwOu7aQ2HKhSAMGsenjQXR4dqrxytFuJrPKB5ujjiyNsDDNZ1je3aWO+9nn5vMB7t0NDgc1raU1PX5N06IiKyivWTe2B05zB8UfFhH6k1bdvVyQHfjutkcDVoqS0hIoO9dFYkHtjavMJSS7aXcHJQokvT+nB2VGLti93RMsQbi8d30tT7rHrhPk2djblT1rUD5fJ/d8WoTmH45d9xmNJP+vEKAA5Kyz8qR7RroLnWpno5Ph/ZFh0a+xnsRWrg64alT+svMaA2pmsj+Lg54cGKXroQH1e8+UBLzf1SsxQdHZTwMzLjqalW75TCrChat1jzQkQkYzVc2kejZYg3EkZUrveiVAA9mvvj9p1ik1OwlQY+faWGU+IjA5CYetNgEKrux2CbBj5YXzH8Ex8ZiP/0a6HTo+GsNZT3xv0t8f66k+gWUV/vebRH/JoFeGL2w+XXpHOTevh88xkAutdcqVDgqW7hWJN8BZdu3QFQPox1OC3bYFv/OzIWw9tV9mqY6oEb1q4BhrVrgIuZBXjpl2Q8H69fq2Roev+nj8aiT1R5jdpL/VsgIsAT8ZEBCPR2RV5hKfZfyML9BmbilRkYjvrf013g5+GMfi2DsPnkdb3CcTlgeCEikjNrpZcqFAqFZsFAUx+uz3Rvghd/PozekbofoMPaNcDxq7no0rSy5uL7cZ2Qc7fE6F/1Uup7OFfM8jI9YwnQ38RT+y0806MJ4prV1wll/VsFYdOJ6xjbNdyidikU5TVL26f1Ruysv5BztwRDYkJx/EouisvK1xY68/5grEi6jOkrjwGATnAx+LwSMS7c3wMrX9CfDm9Mo/qV18vVyQGPac0qklqDSNszPZpg2f40jGjfEC/1b4F2724CADQLLO91+XpsB9wqKK7WQoq1jeGFiOgeZW5NzpDYULQO9dYLFg5KBWYM0Z2qrVQqjAYXFwO1FJ6ujjofvJbSHo5SKBQ6a+kA5R/EeUWlkltYGKN9hf76T08cvHgbA1sHIWF95X4/Tg5KswuYh8SGYv2xDHzyaO0tI2CuEB83HHm7fObc7YJizXHHimEypVIhy+ACsOaFiEjWalIsak1NAzzhVIPVd+eObocQH1d8+S/dwt6vx3ZAiyBPLBjTwcAjzWOqLEWhUFgUXF6oWN9mxpDKIuYgb1c8EBMCRwel3lYdD0SHoIGvG4YbWANnct/mGN6uAb4Y1Ran3h2kMzvNUto5yZIFFQ+/1R9N/D3wqVZwUs+c086xci/WBdjzQkQka90i/NHU38Pobtv2YEhsqM60b7UBrYMxwMxiX2NqEqzUFIry/cO6Nq2PFkFe+HevZgbX5/lsZFv838+HNdOqPVwcsfOV3gbrg7SHcBwdqlf589W/2uP1VSmYN7odPF0dcftOCRr6mTfMBpRvu7Ftarzkfb7uzpjYuxkcFIpqrdpc1xRC1HSrN9vJzc2Fj48PcnJy4O1t37/YRESGqFTC4IcilSsqLcNjX+1Bu0Z+mPmQ9JRvU24XFONGXpHOTCxjCopKNWv/1BUhRK3vfl4Xavr5zfBCREREdaqmn9/yH9giIiIi0sLwQkRERHaF4YWIiIjsCsMLERER2RWGFyIiIrIrDC9ERERkVxheiIiIyK4wvBAREZFdYXghIiIiu8LwQkRERHaF4YWIiIjsCsMLERER2RWGFyIiIrIrDC9ERERkVxxt3YCaEEIAKN9am4iIiOyD+nNb/TluKbsOL3l5eQCAsLAwG7eEiIiILJWXlwcfHx+LH6cQ1Y09MqBSqXD16lV4eXlBoVBY9blzc3MRFhaG9PR0eHt7W/W5/6l4zSzD62U5XjPL8ZpZjtfMcpZeMyEE8vLyEBoaCqXS8goWu+55USqVaNiwYa2+hre3N394LcRrZhleL8vxmlmO18xyvGaWs+SaVafHRY0Fu0RERGRXGF6IiIjIrjC8GODi4oK3334bLi4utm6K3eA1swyvl+V4zSzHa2Y5XjPL1fU1s+uCXSIiIrr3sOeFiIiI7ArDCxEREdkVhhciIiKyKwwvREREZFcYXiTMnz8f4eHhcHV1RZcuXbB//35bN8lmZs6cCYVCofMVFRWlub+wsBATJ05E/fr14enpiYcffhjXr1/XeY60tDQ88MADcHd3R2BgIKZNm4bS0tK6fiu1YseOHRgyZAhCQ0OhUCiwevVqnfuFEJgxYwZCQkLg5uaGfv364cyZMzrnZGVlYcyYMfD29oavry+efvpp5Ofn65xz9OhR9OjRA66urggLC8NHH31U22+t1pi6Zk8++aTez9ygQYN0zrnXrllCQgI6deoELy8vBAYGYtiwYUhNTdU5x1q/i4mJiWjfvj1cXFwQERGBxYsX1/bbqxXmXLP4+Hi9n7UJEybonHMvXbMFCxYgJiZGs9BcXFwc1q9fr7lfVj9jgnQsW7ZMODs7i++//14cP35cPPvss8LX11dcv37d1k2zibffflu0bt1aZGRkaL5u3rypuX/ChAkiLCxMbNmyRRw8eFB07dpV3HfffZr7S0tLRZs2bUS/fv3E4cOHxbp164S/v7+YPn26Ld6O1a1bt0688cYbYuXKlQKAWLVqlc79s2fPFj4+PmL16tXiyJEj4qGHHhJNmjQRd+/e1ZwzaNAgERsbK/bu3St27twpIiIixOjRozX35+TkiKCgIDFmzBiRkpIifv75Z+Hm5iYWLlxYV2/Tqkxds3HjxolBgwbp/MxlZWXpnHOvXbOBAweKRYsWiZSUFJGcnCzuv/9+0ahRI5Gfn685xxq/i+fPnxfu7u7ipZdeEidOnBBz584VDg4OYsOGDXX6fq3BnGvWq1cv8eyzz+r8rOXk5Gjuv9eu2e+//y7+/PNPcfr0aZGamipef/114eTkJFJSUoQQ8voZY3iponPnzmLixIma22VlZSI0NFQkJCTYsFW28/bbb4vY2FjJ+7Kzs4WTk5P49ddfNcdOnjwpAIg9e/YIIco/qJRKpbh27ZrmnAULFghvb29RVFRUq22va1U/iFUqlQgODhYff/yx5lh2drZwcXERP//8sxBCiBMnTggA4sCBA5pz1q9fLxQKhbhy5YoQQogvv/xS+Pn56VyvV199VURGRtbyO6p9hsLL0KFDDT7mXr9mQghx48YNAUBs375dCGG938VXXnlFtG7dWue1Ro4cKQYOHFjbb6nWVb1mQpSHl8mTJxt8zL1+zYQQws/PT3z77bey+xnjsJGW4uJiJCUloV+/fppjSqUS/fr1w549e2zYMts6c+YMQkND0bRpU4wZMwZpaWkAgKSkJJSUlOhcr6ioKDRq1Ehzvfbs2YPo6GgEBQVpzhk4cCByc3Nx/Pjxun0jdezChQu4du2azvXx8fFBly5ddK6Pr68vOnbsqDmnX79+UCqV2Ldvn+acnj17wtnZWXPOwIEDkZqaitu3b9fRu6lbiYmJCAwMRGRkJJ5//nncunVLcx+vGZCTkwMAqFevHgDr/S7u2bNH5znU5/wT/v+res3UfvzxR/j7+6NNmzaYPn067ty5o7nvXr5mZWVlWLZsGQoKChAXFye7nzG73pjR2jIzM1FWVqZz4QEgKCgIp06dslGrbKtLly5YvHgxIiMjkZGRgVmzZqFHjx5ISUnBtWvX4OzsDF9fX53HBAUF4dq1awCAa9euSV5P9X3/ZOr3J/X+ta9PYGCgzv2Ojo6oV6+ezjlNmjTRew71fX5+frXSflsZNGgQRowYgSZNmuDcuXN4/fXXMXjwYOzZswcODg73/DVTqVSYMmUKunXrhjZt2gCA1X4XDZ2Tm5uLu3fvws3NrTbeUq2TumYA8Pjjj6Nx48YIDQ3F0aNH8eqrryI1NRUrV64EcG9es2PHjiEuLg6FhYXw9PTEqlWr0KpVKyQnJ8vqZ4zhhYwaPHiw5vuYmBh06dIFjRs3xi+//GJ3v5RkH0aNGqX5Pjo6GjExMWjWrBkSExPRt29fG7ZMHiZOnIiUlBTs2rXL1k2xG4au2XPPPaf5Pjo6GiEhIejbty/OnTuHZs2a1XUzZSEyMhLJycnIycnBihUrMG7cOGzfvt3WzdLDYSMt/v7+cHBw0Kuevn79OoKDg23UKnnx9fVFixYtcPbsWQQHB6O4uBjZ2dk652hfr+DgYMnrqb7vn0z9/oz9PAUHB+PGjRs695eWliIrK4vXsELTpk3h7++Ps2fPAri3r9mkSZOwdu1abNu2DQ0bNtQct9bvoqFzvL297faPFUPXTEqXLl0AQOdn7V67Zs7OzoiIiECHDh2QkJCA2NhYzJkzR3Y/YwwvWpydndGhQwds2bJFc0ylUmHLli2Ii4uzYcvkIz8/H+fOnUNISAg6dOgAJycnneuVmpqKtLQ0zfWKi4vDsWPHdD5sNm3aBG9vb7Rq1arO21+XmjRpguDgYJ3rk5ubi3379ulcn+zsbCQlJWnO2bp1K1QqleY/0ri4OOzYsQMlJSWaczZt2oTIyEi7Hv4w1+XLl3Hr1i2EhIQAuDevmRACkyZNwqpVq7B161a9ITFr/S7GxcXpPIf6HHv8/8/UNZOSnJwMADo/a/fSNZOiUqlQVFQkv5+x6tUf/3MtW7ZMuLi4iMWLF4sTJ06I5557Tvj6+upUT99LXn75ZZGYmCguXLggdu/eLfr16yf8/f3FjRs3hBDlU+caNWoktm7dKg4ePCji4uJEXFyc5vHqqXMDBgwQycnJYsOGDSIgIOAfM1U6Ly9PHD58WBw+fFgAEJ999pk4fPiwuHTpkhCifKq0r6+vWLNmjTh69KgYOnSo5FTpdu3aiX379oldu3aJ5s2b60z7zc7OFkFBQWLs2LEiJSVFLFu2TLi7u9vttF9j1ywvL09MnTpV7NmzR1y4cEFs3rxZtG/fXjRv3lwUFhZqnuNeu2bPP/+88PHxEYmJiTrTeu/cuaM5xxq/i+pprNOmTRMnT54U8+fPt9tpv6au2dmzZ8U777wjDh48KC5cuCDWrFkjmjZtKnr27Kl5jnvtmr322mti+/bt4sKFC+Lo0aPitddeEwqFQvz1119CCHn9jDG8SJg7d65o1KiRcHZ2Fp07dxZ79+61dZNsZuTIkSIkJEQ4OzuLBg0aiJEjR4qzZ89q7r9796544YUXhJ+fn3B3dxfDhw8XGRkZOs9x8eJFMXjwYOHm5ib8/f3Fyy+/LEpKSur6rdSKbdu2CQB6X+PGjRNClE+Xfuutt0RQUJBwcXERffv2FampqTrPcevWLTF69Gjh6ekpvL29xfjx40VeXp7OOUeOHBHdu3cXLi4uokGDBmL27Nl19Ratztg1u3PnjhgwYIAICAgQTk5OonHjxuLZZ5/V++PhXrtmUtcLgFi0aJHmHGv9Lm7btk20bdtWODs7i6ZNm+q8hj0xdc3S0tJEz549Rb169YSLi4uIiIgQ06ZN01nnRYh765o99dRTonHjxsLZ2VkEBASIvn37aoKLEPL6GVMIIYRlfTVEREREtsOaFyIiIrIrDC9ERERkVxheiIiIyK4wvBAREZFdYXghIiIiu8LwQkRERHaF4YWIiIjsCsMLERER2RWGFyKyK+Hh4fj8889t3QwisiGGFyIy6Mknn8SwYcMAAPHx8ZgyZUqdvfbixYvh6+urd/zAgQN47rnn6qwdRCQ/jrZuABHdW4qLi+Hs7FztxwcEBFixNURkj9jzQkQmPfnkk9i+fTvmzJkDhUIBhUKBixcvAgBSUlIwePBgeHp6IigoCGPHjkVmZqbmsfHx8Zg0aRKmTJkCf39/DBw4EADw2WefITo6Gh4eHggLC8MLL7yA/Px8AEBiYiLGjx+PnJwczevNnDkTgP6wUVpaGoYOHQpPT094e3vjsccew/Xr1zX3z5w5E23btsXSpUsRHh4OHx8fjBo1Cnl5eZpzVqxYgejoaLi5uaF+/fro168fCgoKaulqElFNMbwQkUlz5sxBXFwcnn32WWRkZCAjIwNhYWHIzs5Gnz590K5dOxw8eBAbNmzA9evX8dhjj+k8fsmSJXB2dsbu3bvx1VdfAQCUSiW++OILHD9+HEuWLMHWrVvxyiuvAADuu+8+fP755/D29ta83tSpU/XapVKpMHToUGRlZWH79u3YtGkTzp8/j5EjR+qcd+7cOaxevRpr167F2rVrsX37dsyePRsAkJGRgdGjR+Opp57CyZMnkZiYiBEjRoB71hLJF4eNiMgkHx8fODs7w93dHcHBwZrj8+bNQ7t27fDBBx9ojn3//fcICwvD6dOn0aJFCwBA8+bN8dFHH+k8p3b9THh4ON577z1MmDABX375JZydneHj4wOFQqHzelVt2bIFx44dw4ULFxAWFgYA+OGHH9C6dWscOHAAnTp1AlAechYvXgwvLy8AwNixY7Flyxa8//77yMjIQGlpKUaMGIHGjRsDAKKjo2twtYiotrHnhYiq7ciRI9i2bRs8PT01X1FRUQDKezvUOnTooPfYzZs3o2/fvmjQoAG8vLwwduxY3Lp1C3fu3DH79U+ePImwsDBNcAGAVq1awdfXFydPntQcCw8P1wQXAAgJCcGNGzcAALGxsejbty+io6Px6KOP4ptvvsHt27fNvwhEVOcYXoio2vLz8zFkyBAkJyfrfJ05cwY9e/bUnOfh4aHzuIsXL+LBBx9ETEwMfvvtNyQlJWH+/PkAygt6rc3JyUnntkKhgEqlAgA4ODhg06ZNWL9+PVq1aoW5c+ciMjISFy5csHo7iMg6GF6IyCzOzs4oKyvTOda+fXscP34c4eHhiIiI0PmqGli0JSUlQaVS4dNPP0XXrl3RokULXL161eTrVdWyZUukp6cjPT1dc+zEiRPIzs5Gq1atzH5vCoUC3bp1w6xZs3D48GE4Oztj1apVZj+eiOoWwwsRmSU8PBz79u3DxYsXkZmZCZVKhYkTJyIrKwujR4/GgQMHcO7cOWzcuBHjx483GjwiIiJQUlKCuXPn4vz581i6dKmmkFf79fLz87FlyxZkZmZKDif169cP0dHRGDNmDA4dOoT9+/fjiSeeQK9evdCxY0ez3te+ffvwwQcf4ODBg0hLS8PKlStx8+ZNtGzZ0rILRER1huGFiMwydepUODg4oFWrVggICEBaWhpCQ0Oxe/dulJWVYcCAAYiOjsaUKVPg6+sLpdLwfy+xsbH47LPP8OGHH6JNmzb48ccfkZCQoHPOfffdhwkTJmDkyJEICAjQK/gFyntM1qxZAz8/P/Ts2RP9+vVD06ZNsXz5crPfl7e3N3bs2IH7778fLVq0wJtvvolPP/0UgwcPNv/iEFGdUgjOByQiIiI7wp4XIiIisisML0RERGRXGF6IiIjIrjC8EBERkV1heCEiIiK7wvBCREREdoXhhYiIiOwKwwsRERHZFYYXIiIisisML0RERGRXGF6IiIjIrvw/dHqjkXpnDi4AAAAASUVORK5CYII=\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 3000/3000 [01:27<00:00, 34.25it/s]\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m Uploading 487 metrics, params and output messages\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "True" + ] + }, + "metadata": {}, + "execution_count": 25 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], "source": [ "### Define optimizer and training operation ###\n", "\n", "'''TODO: instantiate a new LSTMModel model for training using the hyperparameters\n", " created above.'''\n", - "model = LSTMModel('''TODO: arguments''')\n", + "model = LSTMModel(vocab_size, params['embedding_dim'], params[\"hidden_size\"])\n", "\n", "# Move the model to the GPU\n", "model.to(device)\n", @@ -778,7 +1299,7 @@ " Checkout the PyTorch website for a list of supported optimizers.\n", " https://pytorch.org/docs/stable/optim.html\n", " Try using the Adam optimizer to start.'''\n", - "optimizer = # TODO\n", + "optimizer = optim.Adam(model.parameters(), lr=params[\"learning_rate\"])\n", "\n", "def train_step(x, y):\n", " # Set the model's mode to train\n", @@ -789,11 +1310,11 @@ "\n", " # Forward pass\n", " '''TODO: feed the current input into the model and generate predictions'''\n", - " y_hat = model('''TODO''')\n", + " y_hat = model(x)\n", "\n", " # Compute the loss\n", " '''TODO: compute the loss!'''\n", - " loss = compute_loss('''TODO''', '''TODO''')\n", + " loss = compute_loss(y, y_hat)\n", "\n", " # Backward pass\n", " '''TODO: complete the gradient computation and update step.\n", @@ -801,7 +1322,8 @@ " 1. Backpropagate the loss\n", " 2. Update the model parameters using the optimizer\n", " '''\n", - " '''TODO'''\n", + " loss.backward()\n", + " optimizer.step()\n", "\n", " return loss\n", "\n", @@ -882,7 +1404,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": { "id": "WvuwZBX5Ogfd" }, @@ -894,7 +1416,7 @@ " # Evaluation step (generating ABC text using the learned RNN model)\n", "\n", " '''TODO: convert the start string to numbers (vectorize)'''\n", - " input_idx = ['''TODO'''] # TODO\n", + " input_idx = [char2idx[char] for char in start_string] # TODO\n", " input_idx = torch.tensor([input_idx], dtype=torch.long).to(device)\n", "\n", " # Initialize the hidden state\n", @@ -906,32 +1428,44 @@ "\n", " for i in tqdm(range(generation_length)):\n", " '''TODO: evaluate the inputs and generate the next character predictions'''\n", - " predictions, hidden_state = model('''TODO''', '''TODO''', return_state=True) # TODO\n", + " predictions, hidden_state = model(input_idx, state, return_state=True) # TODO\n", "\n", " # Remove the batch dimension\n", " predictions = predictions.squeeze(0)\n", "\n", " '''TODO: use a multinomial distribution to sample over the probabilities'''\n", - " input_idx = torch.multinomial('''TODO''', dim=-1), num_samples=1) # TODO\n", + " input_idx = torch.multinomial(torch.softmax(predictions, dim=-1), num_samples=1) # TODO\n", "\n", " '''TODO: add the predicted character to the generated text!'''\n", " # Hint: consider what format the prediction is in vs. the output\n", - " text_generated.append('''TODO''') # TODO\n", + " text_generated.append(idx2char[input_idx].item()) # TODO\n", "\n", " return (start_string + ''.join(text_generated))" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "metadata": { - "id": "ktovv0RFhrkn" + "id": "ktovv0RFhrkn", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "6b52d259-e45f-4dfe-f16a-d1f2f411baa2" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 1000/1000 [00:00<00:00, 1674.18it/s]\n" + ] + } + ], "source": [ "'''TODO: Use the model and the function defined above to generate ABC format text of length 1000!\n", " As you may notice, ABC files start with \"X\" - this may be a good start string.'''\n", - "generated_text = generate_text('''TODO''', '''TODO''', '''TODO''') # TODO" + "generated_text = generate_text(model, start_string='X') # TODO" ] }, { @@ -949,11 +1483,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": { - "id": "LrOtG64bfLto" + "id": "LrOtG64bfLto", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "a1ec553e-7699-4a73-becd-5223a26c75e7" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Found 3 songs in text\n" + ] + } + ], "source": [ "### Play back generated songs ###\n", "\n", @@ -1049,4 +1595,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} +} \ No newline at end of file diff --git a/lab2/PT_Part1_MNIST.ipynb b/lab2/PT_Part1_MNIST.ipynb index bcfae490..fc226c5e 100644 --- a/lab2/PT_Part1_MNIST.ipynb +++ b/lab2/PT_Part1_MNIST.ipynb @@ -1,5 +1,15 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, { "cell_type": "markdown", "metadata": { @@ -55,11 +65,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { - "id": "RsGqx_ai_N8F" + "id": "RsGqx_ai_N8F", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "abf73a04-89eb-4f58-d7d8-a8694c258fcc" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Gym has been unmaintained since 2022 and does not support NumPy 2.0 amongst other critical functionality.\n", + "Please upgrade to Gymnasium, the maintained drop-in replacement of Gym, or contact the authors of your software and request that they upgrade.\n", + "See the migration guide at https://gymnasium.farama.org/introduction/migration_guide/ for additional information.\n" + ] + } + ], "source": [ "# Import PyTorch and other relevant libraries\n", "import torch\n", @@ -93,7 +117,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "id": "GSR_PAqjbzyZ" }, @@ -102,7 +126,7 @@ "!pip install comet_ml > /dev/null 2>&1\n", "import comet_ml\n", "# TODO: ENTER YOUR API KEY HERE!!\n", - "COMET_API_KEY = \"\"\n", + "COMET_API_KEY = \"wtmmeE3OhvyqV1Pbo1G6eVW4I\"\n", "\n", "# Check that we are using a GPU, if not switch runtimes\n", "# using Runtime > Change Runtime Type > GPU\n", @@ -115,11 +139,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { - "id": "wGPDtVxvTtPk" + "id": "wGPDtVxvTtPk", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "b82ed785-e83b-4bdf-9647-66750d429667" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\u001b[1;38;5;214mCOMET WARNING:\u001b[0m comet_ml.init() is deprecated and will be removed soon. Please use comet_ml.login()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Please paste your Comet API key from https://www.comet.com/api/my/settings/\n", + "(api key may not show as you type)\n", + "Comet API key: ··········\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m Valid Comet API Key saved in /root/.comet.config (set COMET_CONFIG to change where it is saved).\n", + "\u001b[1;38;5;214mCOMET WARNING:\u001b[0m To get all data logged automatically, import comet_ml before the following modules: tensorflow, keras, torch, sklearn.\n", + "\u001b[1;38;5;214mCOMET WARNING:\u001b[0m As you are running in a Jupyter environment, you will need to call `experiment.end()` when finished to ensure all metrics and code are logged before exiting.\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m Experiment is live on comet.com https://www.comet.com/benniedtg/6s191-lab2-part1-nn/939ee2f7494b432d932241cea5ecc594\n", + "\n" + ] + } + ], "source": [ "# start a first comet experiment for the first part of the lab\n", "comet_ml.init(project_name=\"6S191_lab2_part1_NN\")\n", @@ -139,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "id": "G1Bryi5ssUNX" }, @@ -167,11 +223,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { - "id": "LpxeLuaysUNX" + "id": "LpxeLuaysUNX", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "e8eaf4e9-adc8-4a0c-9c8a-372b5fd41672" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "torch.Size([1, 28, 28])\n", + "5\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.11/dist-packages/torchvision/datasets/mnist.py:143: DeprecationWarning: 'mode' parameter is deprecated and will be removed in Pillow 13 (2026-10-15)\n", + " img = Image.fromarray(img.numpy(), mode=\"L\")\n" + ] + } + ], "source": [ "image, label = train_dataset[0]\n", "print(image.size()) # For a tensor: torch.Size([1, 28, 28])\n", @@ -191,12 +268,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "id": "bDBsR2lP_N8O", - "scrolled": true + "scrolled": true, + "colab": { + "base_uri": "https://localhost:8080/", + "height": 896 + }, + "outputId": "debfaf3a-524a-4710-ea18-49bafbc9260d" }, - "outputs": [], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'web': 'https://www.comet.com/api/image/download?imageId=ce161706d79340a0ae9f0cfa665d31bf&experimentKey=939ee2f7494b432d932241cea5ecc594',\n", + " 'api': 'https://www.comet.com/api/rest/v1/image/get-image?imageId=ce161706d79340a0ae9f0cfa665d31bf&experimentKey=939ee2f7494b432d932241cea5ecc594',\n", + " 'imageId': 'ce161706d79340a0ae9f0cfa665d31bf'}" + ] + }, + "metadata": {}, + "execution_count": 6 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], "source": [ "plt.figure(figsize=(10,10))\n", "random_inds = np.random.choice(60000,36)\n", @@ -253,8 +358,10 @@ " # '''TODO: Define the activation function for the first fully connected (Dense/Linear) layer.'''\n", " nn.Linear(28 * 28, 128),\n", " '''TODO'''\n", + " nn.ReLU(),\n", "\n", " '''TODO: Define the second Linear layer to output the classification probabilities'''\n", + " nn.Linear(128, 10)\n", " )\n", " return fc_model\n", "\n", @@ -303,7 +410,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "id": "7JhFJXjYsUNX" }, @@ -317,10 +424,10 @@ " self.fc1 = nn.Linear(28 * 28, 128)\n", "\n", " # '''TODO: Define the activation function for the first fully connected layer'''\n", - " self.relu = # TODO\n", + " self.relu = nn.ReLU()\n", "\n", " # '''TODO: Define the second Linear layer to output the classification probabilities'''\n", - " self.fc2 = # TODO\n", + " self.fc2 = nn.Linear(128, 10)\n", "\n", " def forward(self, x):\n", " x = self.flatten(x)\n", @@ -328,6 +435,9 @@ "\n", " # '''TODO: Implement the rest of forward pass of the model using the layers you have defined above'''\n", " '''TODO'''\n", + " x=self.relu(x)\n", + " x=self.fc2(x)\n", + "\n", "\n", " return x\n", "\n", @@ -355,7 +465,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": { "id": "Lhan11blCaW7" }, @@ -366,7 +476,7 @@ " the best performance?'''\n", "# Define loss function and optimizer\n", "loss_function = nn.CrossEntropyLoss()\n", - "optimizer = optim.SGD(fc_model.parameters(), lr=0.1)" + "optimizer = optim.Adam(fc_model.parameters(), lr=0.005)" ] }, { @@ -386,7 +496,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": { "id": "EFMbIqIvQ2X0" }, @@ -400,7 +510,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": { "id": "dfnnoDwEsUNY" }, @@ -444,15 +554,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": { - "id": "kIpdv-H0sUNY" + "id": "kIpdv-H0sUNY", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "fa360e97-cb8a-4ae8-b702-04d2ae029af0" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1, Loss: 0.022011892289981672, Accuracy: 0.9935\n", + "Epoch 2, Loss: 0.019915462886447008, Accuracy: 0.9936\n", + "Epoch 3, Loss: 0.019627617113658926, Accuracy: 0.9939\n", + "Epoch 4, Loss: 0.016722993622219715, Accuracy: 0.9948\n", + "Epoch 5, Loss: 0.01760050603864268, Accuracy: 0.9950\n" + ] + } + ], "source": [ "# TODO: Train the model by calling the function appropriately\n", "EPOCHS = 5\n", - "train('''TODO''') # TODO\n", + "train(fc_model, trainset_loader, loss_function, optimizer, EPOCHS) # TODO\n", "\n", "comet_model_1.end()" ] @@ -463,7 +589,7 @@ "id": "W3ZVOhugCaXA" }, "source": [ - "As the model trains, the loss and accuracy metrics are displayed. With five epochs and a learning rate of 0.01, this fully connected model should achieve an accuracy of approximatley 0.97 (or 97%) on the training data." + "As the model trains, the loss and accuracy metrics are displayed. With ten epochs and a learning rate of 0.01, this fully connected model should achieve an accuracy of approximatley 0.98 (or 98%) on the training data." ] }, { @@ -481,11 +607,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": { - "id": "VflXLEeECaXC" + "id": "VflXLEeECaXC", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "e513cfa7-aa5b-4343-869b-86ece5fe93ff" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Test accuracy: 0.0943\n" + ] + } + ], "source": [ "'''TODO: Use the model we have defined in its eval state to complete\n", "and call the evaluate function, and calculate the accuracy of the model'''\n", @@ -500,25 +638,25 @@ " with torch.no_grad():\n", " for images, labels in testset_loader:\n", " # TODO: ensure evalaution happens on the GPU\n", - " images, labels = # TODO\n", + " images, labels = images.to(device), labels.to(device)\n", "\n", " # TODO: feed the images into the model and obtain the predictions (forward pass)\n", - " outputs = # TODO\n", + " outputs = fc_model(images)\n", "\n", " loss = loss_function(outputs, labels)\n", "\n", " # TODO: Calculate test loss\n", - " test_loss += # TODO\n", + " test_loss += loss.item() * images.size(0)\n", "\n", - " '''TODO: make a prediction and determine whether it is correct!'''\n", + " '''TODO: make a prediction and determine whether it is correct!'''\n", " # TODO: identify the digit with the highest probability prediction for the images in the test dataset.\n", - " predicted = # torch.argmax('''TODO''')\n", + " predicted = torch.argmax(outputs, dim = 1)# torch.argmax('''TODO''')\n", "\n", " # TODO: tally the number of correct predictions\n", - " correct_pred += TODO\n", + " correct_pred += (predicted == labels).sum().item()\n", "\n", " # TODO: tally the total number of predictions\n", - " total_pred += TODO\n", + " total_pred += labels.size(0)\n", "\n", " # Compute average loss and accuracy\n", " test_loss /= total_pred\n", @@ -526,7 +664,7 @@ " return test_loss, test_acc\n", "\n", "# TODO: call the evaluate function to evaluate the trained model!!\n", - "test_loss, test_acc = # TODO\n", + "test_loss, test_acc = evaluate(fc_model, testset_loader, loss_function)\n", "\n", "print('Test accuracy:', test_acc)" ] @@ -577,11 +715,32 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": { - "id": "vec9qcJs-9W5" + "id": "vec9qcJs-9W5", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "1a2636ac-9d92-4c08-e2f9-6579083fe561" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "CNN(\n", + " (conv1): Conv2d(1, 24, kernel_size=(3, 3), stride=(1, 1))\n", + " (pool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (conv2): Conv2d(24, 36, kernel_size=(3, 3), stride=(1, 1))\n", + " (pool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (flatten): Flatten(start_dim=1, end_dim=-1)\n", + " (fc1): Linear(in_features=900, out_features=128, bias=True)\n", + " (relu): ReLU()\n", + " (fc2): Linear(in_features=128, out_features=10, bias=True)\n", + ")\n" + ] + } + ], "source": [ "### Basic CNN in PyTorch ###\n", "\n", @@ -589,16 +748,16 @@ " def __init__(self):\n", " super(CNN, self).__init__()\n", " # TODO: Define the first convolutional layer\n", - " self.conv1 = # TODO\n", + " self.conv1 = nn.Conv2d(1, 24, kernel_size =3 )\n", "\n", " # TODO: Define the first max pooling layer\n", - " self.pool1 = # TODO\n", + " self.pool1 = nn.MaxPool2d(kernel_size = 2) # TODO\n", "\n", " # TODO: Define the second convolutional layer\n", - " self.conv2 = # TODO\n", + " self.conv2 = nn.Conv2d(24, 36, kernel_size=3) # TODO\n", "\n", " # TODO: Define the second max pooling layer\n", - " self.pool2 = # TODO\n", + " self.pool2 = nn.MaxPool2d(kernel_size = 2) # TODO\n", "\n", " self.flatten = nn.Flatten()\n", " self.fc1 = nn.Linear(36 * 5 * 5, 128)\n", @@ -606,7 +765,7 @@ "\n", " # TODO: Define the Linear layer that outputs the classification\n", " # logits over class labels. Remember that CrossEntropyLoss operates over logits.\n", - " self.fc2 = # TODO\n", + " self.fc2 = nn.Linear(128, 10)\n", "\n", "\n", " def forward(self, x):\n", @@ -617,7 +776,12 @@ "\n", " # '''TODO: Implement the rest of forward pass of the model using the layers you have defined above'''\n", " # '''hint: this will involve another set of convolutional/pooling layers and then the linear layers'''\n", - " '''TODO'''\n", + " x = self.conv2(x)\n", + " x = self.pool2(x)\n", + " x = self.flatten(x)\n", + " x = self.fc1(x)\n", + " x = self.relu(x)\n", + " x = self.fc2(x)\n", "\n", " return x\n", "\n", @@ -648,7 +812,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": { "id": "vheyanDkCg6a" }, @@ -663,7 +827,7 @@ "optimizer = optim.SGD(cnn_model.parameters(), lr=1e-2)\n", "\n", "# TODO: instantiate the cross entropy loss function\n", - "loss_function = # TODO\n", + "loss_function = nn.CrossEntropyLoss()\n", "\n", "# Redefine trainloader with new batch size parameter (tweak as see fit if optimizing)\n", "trainset_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n", @@ -672,11 +836,63 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": { - "id": "bzgOEAXVsUNZ" + "id": "bzgOEAXVsUNZ", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "fffc02a3-21eb-480f-a236-29305d39cbcd" }, - "outputs": [], + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 938/938 [00:10<00:00, 91.08it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 7, Loss: 0.0, Accuracy: 0.9733\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'web': 'https://www.comet.com/api/image/download?imageId=3d2496852f274a9aa8faab8f01039b7b&experimentKey=f6d2d4c7695b493ba5e575cfb44ef596',\n", + " 'api': 'https://www.comet.com/api/rest/v1/image/get-image?imageId=3d2496852f274a9aa8faab8f01039b7b&experimentKey=f6d2d4c7695b493ba5e575cfb44ef596',\n", + " 'imageId': '3d2496852f274a9aa8faab8f01039b7b'}" + ] + }, + "metadata": {}, + "execution_count": 24 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], "source": [ "loss_history = mdl.util.LossHistory(smoothing_factor=0.95) # to record the evolution of the loss\n", "plotter = mdl.util.PeriodicPlotter(sec=2, xlabel='Iterations', ylabel='Loss', scale='semilogy')\n", @@ -701,10 +917,10 @@ "\n", " # Forward pass\n", " # TODO: feed the images into the model and obtain the predictions\n", - " logits = # TODO\n", + " logits = cnn_model(images)\n", "\n", " # TODO: compute the categorical cross entropy loss using the predicted logits\n", - " loss = # TODO\n", + " loss = loss_function(logits, labels)\n", "\n", " # Get the loss and log it to comet and the loss_history record\n", " loss_value = loss.item()\n", @@ -716,8 +932,11 @@ " '''TODO: Compute gradients for all model parameters and propagate backwads\n", " to update model parameters. remember to reset your optimizer!'''\n", " # TODO: reset optimizer\n", + " optimizer.zero_grad()\n", " # TODO: compute gradients\n", + " loss.backward()\n", " # TODO: update model parameters\n", + " optimizer.step()\n", "\n", " # Get the prediction and tally metrics\n", " predicted = torch.argmax(logits, dim=1)\n", @@ -745,14 +964,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": { - "id": "JDm4znZcDtNl" + "id": "JDm4znZcDtNl", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "190b919d-c0a3-4f39-b121-6148712c3a89" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Test accuracy: 0.0943\n" + ] + } + ], "source": [ "'''TODO: Evaluate the CNN model!'''\n", - "test_loss, test_acc = evaluate('''TODO''')\n", + "test_loss, test_acc = evaluate(cnn_model, trainset_loader, loss_function)\n", "\n", "print('Test accuracy:', test_acc)" ] @@ -781,7 +1012,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": { "id": "Gl91RPhdCaXI" }, @@ -806,11 +1037,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": { - "id": "3DmJEUinCaXK" + "id": "3DmJEUinCaXK", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "4327b4dc-f14e-4e25-ee3a-97329f771a65" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "tensor([[ -1.7591, -3.4096, 6.7780, 4.6343, -5.0400, -1.3880, -13.2704,\n", + " 14.0184, -0.8899, 3.2088]], device='cuda:0',\n", + " grad_fn=)\n" + ] + } + ], "source": [ "print(predictions_test_image)" ] @@ -828,16 +1073,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": { - "id": "qsqenuPnCaXO" + "id": "qsqenuPnCaXO", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "ab6d7108-ffba-44c7-8f01-0837f0ab7d4e" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "7\n" + ] + } + ], "source": [ "'''TODO: identify the digit with the highest likelihood prediction for the first\n", " image in the test dataset. '''\n", "predictions_value = predictions_test_image.cpu().detach().numpy() #.cpu() to copy tensor to memory first\n", - "prediction = # TODO\n", + "prediction = np.argmax(predictions_value)\n", "print(prediction)" ] }, @@ -852,11 +1109,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": { - "id": "Sd7Pgsu6CaXP" + "id": "Sd7Pgsu6CaXP", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 537 + }, + "outputId": "6f864b1e-ece2-44e1-cf18-67a9d3e57f2b" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Label of this digit is: 7\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'web': 'https://www.comet.com/api/image/download?imageId=5f104981456046ac9cd7796554b0040b&experimentKey=f6d2d4c7695b493ba5e575cfb44ef596',\n", + " 'api': 'https://www.comet.com/api/rest/v1/image/get-image?imageId=5f104981456046ac9cd7796554b0040b&experimentKey=f6d2d4c7695b493ba5e575cfb44ef596',\n", + " 'imageId': '5f104981456046ac9cd7796554b0040b'}" + ] + }, + "metadata": {}, + "execution_count": 35 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], "source": [ "print(\"Label of this digit is:\", test_label)\n", "plt.imshow(test_image[0,0,:,:].cpu(), cmap=plt.cm.binary)\n", @@ -876,20 +1168,42 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "metadata": { - "id": "v6OqZSiAsUNf" + "id": "v6OqZSiAsUNf", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "f14f690b-301a-4eed-c7da-dfc64d6d16a1" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.11/dist-packages/torchvision/datasets/mnist.py:143: DeprecationWarning: 'mode' parameter is deprecated and will be removed in Pillow 13 (2026-10-15)\n", + " img = Image.fromarray(img.numpy(), mode=\"L\")\n" + ] + } + ], "source": [ "# Initialize variables to store all data\n", "all_predictions = []\n", "all_labels = []\n", "all_images = []\n", "\n", + "# Create DataLoaders for batch processing\n", + "BATCH_SIZE = 64\n", + "# Ensure the test dataset is on the correct device\n", + "test_dataset_on_device = datasets.MNIST(root='./data', train=False, download=True, transform=transform)\n", + "testset_loader = DataLoader(test_dataset_on_device, batch_size=BATCH_SIZE, shuffle=False)\n", + "\n", + "\n", "# Process test set in batches\n", "with torch.no_grad():\n", " for images, labels in testset_loader:\n", + " # Move images and labels to the same device as the model\n", + " images, labels = images.to(device), labels.to(device)\n", " outputs = cnn_model(images)\n", "\n", " # Apply softmax to get probabilities from the predicted logits\n", @@ -914,15 +1228,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "metadata": { - "id": "HV5jw-5HwSmO" + "id": "HV5jw-5HwSmO", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 495 + }, + "outputId": "cdae02e1-14bb-428d-fa20-6b003b6e50ca" }, - "outputs": [], + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'web': 'https://www.comet.com/api/image/download?imageId=1eae91e802ad4984addfa1e93ef03be6&experimentKey=f6d2d4c7695b493ba5e575cfb44ef596',\n", + " 'api': 'https://www.comet.com/api/rest/v1/image/get-image?imageId=1eae91e802ad4984addfa1e93ef03be6&experimentKey=f6d2d4c7695b493ba5e575cfb44ef596',\n", + " 'imageId': '1eae91e802ad4984addfa1e93ef03be6'}" + ] + }, + "metadata": {}, + "execution_count": 43 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAADz9JREFUeJzt3F2MXGUZwPFntqW26O42WtM67mCMLTF+gWiDHxfEaNMgEfDCJjUhiCSYokBvjMaIhAgkSvRCMH4leGU1EJGEYNKIqWDTxtQiVmok1KDddgVl1e4W6Ifs68XJsizdPd3udHZ29/n9kiad8855523Saf/7npnTKKWUAADS6un2AgCA7hIDAJCcGACA5MQAACQnBgAgOTEAAMmJAQBIbmm3FwAsXmNjYzE0NBS9vb3RaDS6vRxIp5QSo6Oj0Ww2o6dn+p//xQDQMUNDQ9Fqtbq9DEhvcHAwBgYGph0XA0DH9Pb2RkT1D1FfX9+cv/7gYMTw8OzPf8MbIrQMC9nIyEi0Wq2X34vTEQNAx4xfGujr65vzGDh4MOL97484dmz2cyxfHvHkkxHnnXf21gXdcLrLdD5ACCxKzz3XXghEVOc/99zZWQ/MZ2IAAJITAwCQnBgAgOTEAAAkJwYAIDkxAADJiQEASE4MAEByYgAAkhMDAJCcGACA5MQAACQnBgAgOTEAAMmJAQBITgwAQHJiAACSEwMAkJwYAIDkxAAAJCcGACA5MQAAyYkBAEhODABAcmIAAJITAwCQnBgAgOTEAAAkJwYAIDkxAADJiQEASE4MAEByYgAAkhMDAJCcGACA5MQAACQnBgAgOTEAAMmJAQBITgwAQHJiAACSEwMAkJwYAIDkxAAAJCcGACA5MQAAyYkBAEhODABAcmIAAJITAwCQnBgAgOTEAAAkJwYAIDkxAADJiQEASE4MAEByYgAAkhMDAJCcGACA5MQAACQnBgAgOTEAAMmJAQBITgwAQHJiAACSEwMAkJwYAIDkls7kSWNjYzE0NBS9vb3RaDQ6vSbgVUopMTo6Gs1mM3p6NDxwds0oBoaGhqLVanV6LcBpDA4OxsDAQLeXASwyM4qB3t7eiKj+Ierr6+vogoBTjYyMRKvVevm9CHA2zSgGxi8N9PX1iQHoIpfpgE5w8REAkhMDAJCcGACA5MQAACQnBgAgOTEAAMmJAQBITgwAQHJiAACSEwMAkJwYAIDkxAAAJCcGACA5MQAAyYkBAEhODABAcmIAAJITAwCQnBgAgOTEAAAkJwYAIDkxAADJiQEASE4MAEByYgAAkhMDAJCcGACA5MQAACQnBgAgOTEAAMmJAQBITgwAQHJiAACSEwMAkJwYAIDkxAAAJCcGACC5pd1eAAvHgw8+WDt++eWX147fddddteNbtmypHV+yZEntOACzY2cAAJITAwCQnBgAgOTEAAAkJwYAIDkxAADJiQEASM59BnjZ8PBw7fjp7gNwOjfccEPt+LXXXls7vmLFirZeH4Cp2RkAgOTEAAAkJwYAIDkxAADJiQEASE4MAEByYgAAknOfAV726KOP1o4fPny4rfk3b95cO758+fK25gdgduwMAEByYgAAkhMDAJCcGACA5MQAACQnBgAgOTEAAMmJAQBIzk2HEjl+/Hjt+G233dbR17/qqqtqxxuNRkdfH4Cp2RkAgOTEAAAkJwYAIDkxAADJiQEASE4MAEByYgAAknOfgUT27dtXO/7YY4+1Nf/SpfV/nS699NK25gegM+wMAEByYgAAkhMDAJCcGACA5MQAACQnBgAgOTEAAMm5z0Ai999/f0fn37BhQ0fnB6Az7AwAQHJiAACSEwMAkJwYAIDkxAAAJCcGACA5MQAAybnPQCKPPPJIW+cvW7asdvyOO+5oa34AusPOAAAkJwYAIDkxAADJiQEASE4MAEByYgAAkhMDAJCc+wwsIrt27aod3717d1vzn3vuubXjF154YVvzA9AddgYAIDkxAADJiQEASE4MAEByYgAAkhMDAJCcGACA5NxnYBHZs2dPR+ffsmVLR+cHoDvsDABAcmIAAJITAwCQnBgAgOTEAAAkJwYAIDkxAADJuc/AItLufQZWrlxZO3799de3NT8A85OdAQBITgwAQHJiAACSEwMAkJwYAIDkxAAAJCcGACA59xlYQHbu3Fk7vm3btrbm7+/vrx0fGBhoa34A5ic7AwCQnBgAgOTEAAAkJwYAIDkxAADJiQEASE4MAEBy7jOwgAwPD9eOl1Lamn/Dhg1tnQ/AwmRnAACSEwMAkJwYAIDkxAAAJCcGACA5MQAAyYkBAEjOfQYWkPvuu6+t81euXFk7ft1117U1PwALk50BAEhODABAcmIAAJITAwCQnBgAgOTEAAAkJwYAIDn3GZhHDh06VDu+bdu2tuYfGBioHV+/fn1b8wOwMNkZAIDkxAAAJCcGACA5MQAAyYkBAEhODABAcmIAAJJzn4F5ZNeuXbXjpZS25r/iiivaOh+AxcnOAAAkJwYAIDkxAADJiQEASE4MAEByYgAAkhMDAJCc+wzMI8PDw22dv2rVqtrxrVu3tjU/AIuTnQEASE4MAEByYgAAkhMDAJCcGACA5MQAACQnBgAgOfcZmEe2b9/e1vmtVqt2vL+/v635AVic7AwAQHJiAACSEwMAkJwYAIDkxAAAJCcGACA5MQAAyYkBAEjOTYfm0MmTJ2vHDxw40Nb8y5cvrx0/55xz2pofgMXJzgAAJCcGACA5MQAAyYkBAEhODABAcmIAAJITAwCQnPsMzKGenvr2Wr9+fe34/v37a8fXrVt3xmsCADsDAJCcGACA5MQAACQnBgAgOTEAAMmJAQBITgwAQHLuMzCHlixZUjt+++231443Go3a8YsuuuiM1wQAdgYAIDkxAADJiQEASE4MAEByYgAAkhMDAJCcGACA5NxnYB5pNpu14/fcc88crQSATOwMAEByYgAAkhMDAJCcGACA5MQAACQnBgAgOTEAAMmJAQBITgwAQHJiAACSEwMAkJwYAIDkxAAAJCcGACA5MQAAyYkBAEhODABAcmIAAJITAwCQnBgAgOTEAAAkJwYAILmlM3lSKSUiIkZGRjq6GGBq4++98fciwNk0oxgYHR2NiIhWq9XRxQD1RkdHo7+/v9vLABaZGcVAs9mMwcHB6O3tjUaj0ek1Aa9SSonR0dFoNpvdXgqwCM0oBnp6emJgYKDTawFq2BEAOsUHCAEgOTEAAMmJAQBITgwAQHJigFk7cSJi7dqIXbtmfs6f/xwxMBDx/POdWxcAZ0YMdMCjj0Z84hMRzWZEoxHxwAOnP+cf/4j49Kcjzj8/oqcnYuvWqZ93330Rb397xPLlEe9+d8Qvfzl5vJSIr30t4k1vilixIuJjH4t46qmJ8ePHI666KqKvr3qthx+efP6dd0bccMPM/pzf/37EW98a8aEPTRy7/fbq8bnnRqxceeo573hHxAc+EPHtb8/sNQDoPDHQAc8/H3HBBRHf/e7Mzzl+POKNb4z46lerc6eya1fE5s0R114b8Yc/RFx5ZfXriScmnvPNb0Z85zvVf9S/+13Ea18bsXFjxLFj1fgPfxixd2/E7t0R111XBcj4Te2efjriRz+q/kM/nVIi7r67WssrnTgR8alPRWzZMv2511wT8b3vRfzvf6d/HQDmQKGjIkr5xS/O7JxLLinlpptOPb5pUymXXTb52MUXl/K5z1W/HxsrZc2aUu68c2L8v/8t5TWvKeWnP60eb9lSype+VP3+hReq9f3zn9XjjRtLuf/+ma1xz55SenpKGRmZevzHPy6lv3/qsePHqzU9/PDMXouF68iRIyUiypEjR+b8tffurf5+t/tr7945XzqcNTN9D9oZWEB27662/V9p48bqeET1k/0zz0x+Tn9/xMUXTzznggsidu6MePHFiO3bq8sJq1ZF/OQn1aWHT35yZmv57W+rywy9vWf+51i2LOLCC6s5AOi+Gd2BkPnhmWciVq+efGz16ur4+Pj4seme89nPRuzbV127X7Uq4t57I/7zn+pzBr/5TXWZ4mc/i3jb2yLuuSfizW+eei1//3v1mYjZajarOQDoPjGQzDnnnPpZhmuuibjxxupzCA88EPHHP1afPbjxxoif/3zqeV58sdpJmK0VKyJeeGH25wNw9rhMsICsWRPx7LOTjz37bHV8fHz82HTPebUdOyL274/4wheqnYGPf7z60OGmTdXj6axaVe0ozNa//119YBKA7hMDC8gHPxjx619PPvarX1XHI6qv+a1ZM/k5IyPVtwrGn/NKx45FfP7zET/4QcSSJREvvRRx8mQ1dvJk9Xg6731vxF/+MvFNhDP1xBPVHAB0n8sEHXD0aMSBAxOPn3464vHHI17/+ojzzpv+vMcfnzj/X/+qHi9bVl3fj4i46aaISy6J+Na3Ii67rLq2//vfV18XjKjuabB1a8Rtt0WsW1fFwc03V9fnr7zy1Nf7+ternYDx/5Q//OGIL36xumxw993V4+l85CPVOvfvj3jXuyaOHzxY/dR/8GAVE+N/prVrI173uur3f/tbxOHDp34YEoAumaNvN6SyY8fUX1G6+ur686Y65y1vmfyce+8t5fzzS1m2rJR3vrOUhx6aPD42VsrNN5eyenX19b2PfrSUJ5889bX+9KdS1q4t5ejRiWMvvVR99bCvr5T160t56qn69W7aVMqXvzz52NVXT/3n2LFj4jl33FF9jZHFz1cLobtm+h5slDLbjV6y27cvYsOGiL/+deKn/tM5caLatdi2rX7ngcVhZGQk+vv748iRI9HX1zenr/3YYxHve1/78+zdG3HRRe3PA90w0/egzwwwa+95T8Q3vlFdBpmpgwcjvvIVIQAwn/jMAG35zGfO7Plr11a/AJg/7AwAQHJiAACSEwMAkJwYAIDkxAAAJCcGACA5MQAAyYkBAEhODABAcmIAAJITAwCQnBgAgOTEAAAkJwYAIDkxAADJiQEASE4MAEByYgAAkhMDAJCcGACA5MQAACQnBgAgOTEAAMmJAQBITgwAQHJiAACSEwMAkJwYAIDkxAAAJCcGACA5MQAAyYkBAEhODABAcmIAAJITAwCQnBgAgOTEAAAkJwYAIDkxAADJiQEASE4MAEByYgAAkhMDAJCcGACA5MQAACQnBgAgOTEAAMmJAQBITgwAQHJiAACSW9rtBQCLVyklIiJGRkbm/LWPHj1783Rh+czSLbfc0vYct95661lYyfww/t4bfy9Op1FO9wyAWTp06FC0Wq1uLwPSGxwcjIGBgWnHxQDQMWNjYzE0NBS9vb3RaDS6vRxIp5QSo6Oj0Ww2o6dn+k8GiAEASM4HCAEgOTEAAMmJAQBITgwAQHJiAACSEwMAkJwYAIDk/g/fQ2hSfXH9FwAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + } + ], "source": [ "#@title Change the slider to look at the model's predictions! { run: \"auto\" }\n", "\n", - "image_index = 79 #@param {type:\"slider\", min:0, max:100, step:1}\n", + "image_index = 5 #@param {type:\"slider\", min:0, max:100, step:1}\n", "plt.subplot(1,2,1)\n", "mdl.lab2.plot_image_prediction(image_index, predictions, test_labels, test_images)\n", "plt.subplot(1,2,2)\n", @@ -941,11 +1283,54 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "metadata": { - "id": "hQlnbqaw2Qu_" + "id": "hQlnbqaw2Qu_", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 910 + }, + "outputId": "fe28922e-c2e9-406b-83be-3dc378406a07" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m ---------------------------------------------------------------------------------------\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m Comet.ml Experiment Summary\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m ---------------------------------------------------------------------------------------\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m Data:\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m display_summary_level : 1\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m name : nursing_muffin_5714\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m url : https://www.comet.com/benniedtg/6-s191lab2-part1-cnn/f6d2d4c7695b493ba5e575cfb44ef596\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m Metrics [count] (min, max):\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m loss [6566] : (0.005107005126774311, 2.3100481033325195)\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m Others:\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m notebook_url : https://colab.research.google.com/notebook#fileId=https%3A%2F%2Fgithub.com%2FMITDeepLearning%2Fintrotodeeplearning%2Fblob%2Fmaster%2Flab2%2FPT_Part1_MNIST.ipynb\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m Uploads:\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m environment details : 1\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m figures : 8\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m filename : 1\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m installed packages : 1\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m notebook : 2\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m os packages : 1\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m source_code : 1\n", + "\u001b[1;38;5;39mCOMET INFO:\u001b[0m \n", + "\u001b[1;38;5;214mCOMET WARNING:\u001b[0m To get all data logged automatically, import comet_ml before the following modules: torch, tensorflow, keras, sklearn.\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], "source": [ "# Plots the first X test images, their predicted label, and the true label\n", "# Color correct predictions in blue, incorrect predictions in red\n", @@ -980,7 +1365,8 @@ "Xmf_JRJa_N8C" ], "name": "PT_Part1_MNIST.ipynb", - "provenance": [] + "provenance": [], + "include_colab_link": true }, "kernelspec": { "display_name": "Python 3", @@ -1001,4 +1387,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} +} \ No newline at end of file