From 832b1809c7707586cb7332b0fa6891a1afcae6ac Mon Sep 17 00:00:00 2001 From: wassname Date: Mon, 12 Oct 2020 14:32:34 +0800 Subject: [PATCH] fix applications --- notebooks/c09_Autoencoders/Autoencoders.ipynb | 1764 +++++++++++------ notebooks/c09_Autoencoders/Autoencoders.py | 610 ++++-- 2 files changed, 1590 insertions(+), 784 deletions(-) diff --git a/notebooks/c09_Autoencoders/Autoencoders.ipynb b/notebooks/c09_Autoencoders/Autoencoders.ipynb index 8f55533..32abd73 100644 --- a/notebooks/c09_Autoencoders/Autoencoders.ipynb +++ b/notebooks/c09_Autoencoders/Autoencoders.ipynb @@ -33,6 +33,23 @@ "We pass the input through the model and it will compress and decompress the input and returns a result. Then we compare the output of the model with the original input. To check how close the output is to the original input we use a loss function." ] }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-10-12T02:04:25.772894Z", + "start_time": "2020-10-12T02:04:25.763235Z" + } + }, + "source": [ + "## Applications\n", + "\n", + "Autoencoders are not only useful for dimensionality reduction. They are often used for other purposes as well, including:\n", + "1. __Denoising:__ We could add noise to the input and then feed it to the model and then compare the output with the original image (without noise). This approach will create a model which is capable of removing noise from the input.\n", + "2. __Anomaly Detection:__ When we train a model on specific set of data, the model learns how to recreate the dataset. As a result when there are uncommon instances in the data the model will not be able to recrate them very well. This behaviour is sometimes used as a technique to find anomalous data points. \n", + "3. __Unsupervised Clustering:__ Like clustering algorithms but more flexible, able to fit complex relationships" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -45,8 +62,8 @@ "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:15:36.008512Z", - "start_time": "2020-10-12T01:15:34.531339Z" + "end_time": "2020-10-12T06:14:18.130055Z", + "start_time": "2020-10-12T06:14:16.633076Z" } }, "outputs": [], @@ -83,6 +100,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "## Dataset and dataloader\n", + "\n", "First we need to create a `Dataset` class. The `Dataset` class reads the data from file and returns data points when we need them. The advantage of using a `Dataset` is that we can adjust it based on what we need for each problem. If we are not dealing with large amount of data we can decide to keep everything in RAM so it is ready use. But if we are dealing with a few gigabytes of data we might need to open the file only when we need them.
\n", "The MNIST data set is not large so we can easily fit it into memory. In the `Dataset` class we define a few methods:\n", "- `__init__`: What information is required to create the object and how this information is saved.\n", @@ -99,8 +118,8 @@ "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:15:36.020439Z", - "start_time": "2020-10-12T01:15:36.010583Z" + "end_time": "2020-10-12T06:14:18.143318Z", + "start_time": "2020-10-12T06:14:18.132535Z" } }, "outputs": [], @@ -133,7 +152,7 @@ " return output\n", "\n", " def show(self, idx):\n", - " plt.figure(figsize=(2, 2))\n", + "# plt.figure(figsize=(2, 2))\n", " plt.imshow(self.x[idx].reshape((28, 28)), \"gray\")\n", "\n", " def sample(self, n):\n", @@ -165,14 +184,86 @@ "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:15:41.430923Z", - "start_time": "2020-10-12T01:15:36.022753Z" + "end_time": "2020-10-12T06:14:23.557119Z", + "start_time": "2020-10-12T06:14:18.146646Z" } }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "<__main__.DigitsDataset at 0x7fb3b04ffb90>" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "ds_train = DigitsDataset(path / \"train.csv\", transform=ToTensor())\n", - "ds_test = DigitsDataset(path / \"test.csv\", transform=ToTensor())" + "ds_test = DigitsDataset(path / \"test.csv\", transform=ToTensor())\n", + "ds_train" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2020-10-12T06:14:24.382184Z", + "start_time": "2020-10-12T06:14:23.559114Z" + }, + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for i in range(4):\n", + " for j in range(4):\n", + " plt.subplot(4, 4, 1+i*4+j)\n", + " ds_train.show(i*4+j)\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + "plt.show()\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2020-10-12T06:14:24.391977Z", + "start_time": "2020-10-12T06:14:24.384715Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([784])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Both of these are the same\n", + "ds_train.__getitem__(1).shape\n", + "ds_train[1].shape" ] }, { @@ -184,20 +275,32 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:15:41.437078Z", - "start_time": "2020-10-12T01:15:41.433048Z" + "end_time": "2020-10-12T06:14:24.402204Z", + "start_time": "2020-10-12T06:14:24.394809Z" } }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "batch_size = 64\n", "train_loader = torch.utils.data.DataLoader(\n", " ds_train, batch_size=batch_size, shuffle=True\n", ")\n", - "test_loader = torch.utils.data.DataLoader(ds_test, batch_size=batch_size, shuffle=False)" + "test_loader = torch.utils.data.DataLoader(ds_test, batch_size=batch_size, shuffle=False)\n", + "test_loader" ] }, { @@ -211,16 +314,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "## Model definition\n", + "\n", "Now we need to create the model. The architecture we are going to use here is made of two linear layers for the encoder and two linear layers for the decoder." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:15:41.448238Z", - "start_time": "2020-10-12T01:15:41.438998Z" + "end_time": "2020-10-12T06:14:24.411658Z", + "start_time": "2020-10-12T06:14:24.404590Z" } }, "outputs": [], @@ -228,19 +333,23 @@ "class AE(nn.Module):\n", " def __init__(self):\n", " super(AE, self).__init__()\n", - "\n", - " self.fc1 = nn.Linear(784, 400)\n", - " self.fc2 = nn.Linear(400, 2)\n", - " self.fc3 = nn.Linear(2, 400)\n", - " self.fc4 = nn.Linear(400, 784)\n", - "\n", + " \n", + " self.encoder = nn.Sequential(\n", + " nn.Linear(784, 400),\n", + " nn.ReLU(inplace=True),\n", + " nn.Linear(400, 2)\n", + " )\n", + " self.decoder = nn.Sequential(\n", + " nn.Linear(2, 400),\n", + " nn.ReLU(inplace=True),\n", + " nn.Linear(400, 784),\n", + " nn.Sigmoid()\n", + " )\n", " def encode(self, x):\n", - " h1 = F.relu(self.fc1(x))\n", - " return self.fc2(h1)\n", + " return self.encoder(x)\n", "\n", " def decode(self, z):\n", - " h3 = F.relu(self.fc3(z))\n", - " return torch.sigmoid(self.fc4(h3))\n", + " return self.decoder(z)\n", "\n", " def forward(self, x):\n", " z = self.encode(x.view(-1, 784))\n", @@ -256,11 +365,11 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:15:41.492791Z", - "start_time": "2020-10-12T01:15:41.450422Z" + "end_time": "2020-10-12T06:14:24.432906Z", + "start_time": "2020-10-12T06:14:24.415038Z" } }, "outputs": [ @@ -270,7 +379,7 @@ "device(type='cuda')" ] }, - "execution_count": 6, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -289,11 +398,11 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:15:44.679707Z", - "start_time": "2020-10-12T01:15:41.494712Z" + "end_time": "2020-10-12T06:14:27.392719Z", + "start_time": "2020-10-12T06:14:24.436598Z" } }, "outputs": [ @@ -301,14 +410,21 @@ "data": { "text/plain": [ "AE(\n", - " (fc1): Linear(in_features=784, out_features=400, bias=True)\n", - " (fc2): Linear(in_features=400, out_features=2, bias=True)\n", - " (fc3): Linear(in_features=2, out_features=400, bias=True)\n", - " (fc4): Linear(in_features=400, out_features=784, bias=True)\n", + " (encoder): Sequential(\n", + " (0): Linear(in_features=784, out_features=400, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=400, out_features=2, bias=True)\n", + " )\n", + " (decoder): Sequential(\n", + " (0): Linear(in_features=2, out_features=400, bias=True)\n", + " (1): ReLU(inplace=True)\n", + " (2): Linear(in_features=400, out_features=784, bias=True)\n", + " (3): Sigmoid()\n", + " )\n", ")" ] }, - "execution_count": 7, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -318,6 +434,57 @@ "model" ] }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2020-10-12T06:14:27.745762Z", + "start_time": "2020-10-12T06:14:27.395847Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==================================================================\n", + " Kernel Shape Output Shape Params Mult-Adds\n", + "Layer \n", + "0_encoder.Linear_0 [784, 400] [2, 400] 314.0k 313.6k\n", + "1_encoder.ReLU_1 - [2, 400] - -\n", + "2_encoder.Linear_2 [400, 2] [2, 2] 802.0 800.0\n", + "3_decoder.Linear_0 [2, 400] [2, 400] 1.2k 800.0\n", + "4_decoder.ReLU_1 - [2, 400] - -\n", + "5_decoder.Linear_2 [400, 784] [2, 784] 314.384k 313.6k\n", + "6_decoder.Sigmoid_3 - [2, 784] - -\n", + "------------------------------------------------------------------\n", + " Totals\n", + "Total params 630.386k\n", + "Trainable params 630.386k\n", + "Non-trainable params 0.0\n", + "Mult-Adds 628.8k\n", + "==================================================================\n" + ] + }, + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Let use torchsummary X to see the size of the model\n", + "x=torch.rand((1, 784)).to(device)\n", + "summary(model, torch.rand((2, 784)).to(device))\n", + "1" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -327,11 +494,11 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:15:44.685711Z", - "start_time": "2020-10-12T01:15:44.682951Z" + "end_time": "2020-10-12T06:14:27.751046Z", + "start_time": "2020-10-12T06:14:27.747807Z" } }, "outputs": [], @@ -343,16 +510,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "And the final component is the loss function. Here we are going to use Binary Cross Entropy function." + "And the final component is the loss function. Here we are going to use Binary Cross Entropy function because each pixel can go from zero to one." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:15:44.695219Z", - "start_time": "2020-10-12T01:15:44.687826Z" + "end_time": "2020-10-12T06:14:27.759330Z", + "start_time": "2020-10-12T06:14:27.753048Z" } }, "outputs": [], @@ -367,22 +534,16 @@ "metadata": {}, "source": [ "Let's define two functions one for executing a single epoch of training and one for evaluating the mdel using test data.
\n", - "Notice the following steps in the training loop:\n", - "1. We make sure the data is in the right device (cpu or gpu)\n", - "2. We make sure that any saved gradient (derivative) is zeroed.\n", - "3. We pass a mini-batch of data into the model and grab the predictions.\n", - "4. We use the loss function to find out how close the model's output is to the actual image.\n", - "5. We use `loss.backward()` to claculate the derivative of loss with respect to model parameters.\n", - "6. We ask the optimiser to update model's parameters." + "Notice the following comments in the training loop" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 13, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:15:44.706897Z", - "start_time": "2020-10-12T01:15:44.696972Z" + "end_time": "2020-10-12T06:14:27.780026Z", + "start_time": "2020-10-12T06:14:27.761860Z" } }, "outputs": [], @@ -391,12 +552,22 @@ " model.train()\n", " train_loss = 0\n", " for batch_idx, data in enumerate(tqdm(train_loader, leave=False, desc='train')):\n", + " # We make sure the data is in the right device (cpu or gpu)\n", " data = data.to(device)\n", " \n", + " # We make sure that any saved gradient (derivative) is zeroed.\n", " optimizer.zero_grad()\n", + " \n", + " # We pass a mini-batch of data into the model and grab the predictions.\n", " recon_batch = model(data)\n", + " \n", + " # We use the loss function to find out how close the model's output is to the actual image.\n", " loss = loss_function(recon_batch, data)\n", + " \n", + " # We use loss.backward() to calculate the derivative of loss with respect to model parameters.\n", " loss.backward()\n", + " \n", + " # We ask the optimiser to update model's parameters.\n", " optimizer.step()\n", " \n", " train_loss += loss.item()\n", @@ -424,6 +595,55 @@ " print('#{} Test loss: {:.4f}'.format(epoch, test_loss))" ] }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2020-10-12T06:14:28.098171Z", + "start_time": "2020-10-12T06:14:27.782941Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def cvt2image(tensor):\n", + " return tensor.detach().cpu().numpy().reshape(28, 28)\n", + "\n", + "def show_prediction(idx, title='', ds=ds_train):\n", + " \"\"\"Show a predict vs actual\"\"\"\n", + " model.eval()\n", + " original = ds[[idx]]\n", + " result = model(original.to(device))\n", + " img = cvt2image(result[0])\n", + " \n", + " plt.figure(figsize=(4, 2))\n", + " plt.subplot(1, 2, 1)\n", + " plt.imshow(img, \"gray\")\n", + " plt.title(\"Predicted\")\n", + "\n", + " plt.subplot(1, 2, 2)\n", + " ds.show(idx)\n", + " plt.title(\"Actual\")\n", + " \n", + " plt.suptitle(title)\n", + " plt.show()\n", + " \n", + "show_prediction(10, '0')" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -433,18 +653,18 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 15, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:17:19.337492Z", - "start_time": "2020-10-12T01:15:44.708599Z" + "end_time": "2020-10-12T06:15:54.627586Z", + "start_time": "2020-10-12T06:14:28.100002Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6d2c6b25ae764a6ea94b15a92bcceed3", + "model_id": "5df94d5b7be24e22aaadb44100175689", "version_major": 2, "version_minor": 0 }, @@ -455,6 +675,18 @@ "metadata": {}, "output_type": "display_data" }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -473,7 +705,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "#1 Train loss: 178.6538\tBatch Loss: 174.185730 \n" + "#1 Train loss: 179.6139\tBatch Loss: 165.800812 \n" ] }, { @@ -494,9 +726,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "#1 Test loss: 163.7434\n" + "#1 Test loss: 164.3627\n" ] }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -515,7 +759,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "#2 Train loss: 160.4988\tBatch Loss: 157.540527 \n" + "#2 Train loss: 160.5507\tBatch Loss: 167.639282 \n" ] }, { @@ -536,9 +780,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "#2 Test loss: 157.2849\n" + "#2 Test loss: 157.6894\n" ] }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -557,7 +813,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "#3 Train loss: 156.0557\tBatch Loss: 148.907104 \n" + "#3 Train loss: 156.3866\tBatch Loss: 158.919724 \n" ] }, { @@ -578,9 +834,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "#3 Test loss: 154.4691\n" + "#3 Test loss: 155.2302\n" ] }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -599,7 +867,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "#4 Train loss: 153.5898\tBatch Loss: 158.858505 \n" + "#4 Train loss: 154.0644\tBatch Loss: 148.728592 \n" ] }, { @@ -620,9 +888,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "#4 Test loss: 152.8978\n" + "#4 Test loss: 153.1066\n" ] }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -641,7 +921,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "#5 Train loss: 151.9238\tBatch Loss: 150.934601 \n" + "#5 Train loss: 152.2685\tBatch Loss: 140.175247 \n" ] }, { @@ -662,9 +942,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "#5 Test loss: 151.3499\n" + "#5 Test loss: 151.5302\n" ] }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -683,7 +975,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "#6 Train loss: 150.4838\tBatch Loss: 150.495544 \n" + "#6 Train loss: 150.8636\tBatch Loss: 135.777985 \n" ] }, { @@ -704,9 +996,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "#6 Test loss: 150.4536\n" + "#6 Test loss: 150.5745\n" ] }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAACWCAYAAADe+D2yAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAVbUlEQVR4nO2de5CU1ZXAfwcEEd+osCOCoGAK3CgmaqKR8hVK1DVaWmYlUbFW1vXBrqaIQuImoSzddWsTNT4TNCiuqNHEUtcqTRCTVTfRFfCJowLyloeoPHwLnv3ju9Pce5ju6Znp6e7p7/yqvpp7vvt937099+vT95xzH6KqOI6TX3rUugKO49QWVwKOk3NcCThOznEl4Dg5x5WA4+QcVwKOk3NcCThtIiJDRERFZLta18WpPK4EnKohIr8SkQ+j4zMR2VTreuUdVwJlICJ3icjVIT1aRN6sUrkqIsOqUVY1UNULVXWnlgO4D3iw1vXqKkRkqojcU+t6tEVDKQERWSIin4RfmTUicqeI7FTJMlT1GVX9Shl1OU9Enq1k2eb5e4vI70XkXRFZLCL/Es5PFZHfichvRWSTiMwTkYOj+0aIyJ9FZL2IzBeR70R5O4jIL0RkqYhsEJFnRWSHqNjvi8gyEVknIld2sv47AmcAMzrznDLK+bOIfCAi25dxbZe2Wb3SUEogcEr4lfkacBjwr3FmI9i1ItID+G/gZWAgcDxwmYicEC45lewXth9wL/CwiPQSkV7hvj8C/YF/BmaKSItS+znwdeDIcO8VwJdR0UcBXwnl/VRERoT6fC8olWLH4FY+xhnAu8DTlfiftIaIDAFGAwp8p/TVOUZVG+YAlgDfjuT/BB4jewkuARYAi0Pe3wEvAeuBvwAHRfcdAswDNgG/Be4Hrg55xwAromsHAQ+RvdDvATcDI4BPgS3Ah8D6cO32ZF+0ZcAa4FfADtGzLgdWAe8A/xDqPayVz/kNYJk59yPgTmAq8Fx0vkd45uhwrAZ6RPn3hXt6AJ8AB7dS3pBQl32ic/8HnNWJtpoNTO3i9+GnwP8C1wGPdbDN/gxMiO49D3g2kn8JLAc2AnOB0VHeVOCeWn8v2joasScAgIgMAk4CXgynTiP78owUka8B04F/AvYAfg08KiLbi0hv4GHgv8h+DR8k+9VqrYyeZEpmKdkXZSBwv6o2AxcCf9XM/t0t3PIfwAHAKGBYuP6n4VljgR8CY4DhwLdLfLx9gb3jX1vgx8CAkL+85UJV/RJYAewdjuXhXAtLQz32BPoAi0qUuzpKfwx0yNQKbXM0cHdH7m8H5wIzw3GCiAzoQJu1xQtk7dnS63pQRPpU8kN0NY2oBB4OX4pngf8B/i2c/3dVfV9VPwH+Efi1qj6vqltUdQbwGfDNcPQCblDVL1T1d2QN3RqHk32xLlfVj1T1U1Vt1aYUEQnl/iDUY1Oo21nhku8Cd6rqa6r6EdmvSDGWk/VodouOnVX1pJA/KCq3B7APWe/iHWBQONfCYGAlsI7sl3D/EuW2ioh833j97WHNgXOBv6jq2+0tqx11OopMWT6gqnPJlNv3aEeblYOq3qOq76nqZlX9BVlvr02fUT3RiErgtPCl2FdVLw5feoh+Hclejknml3QQW38tV2rozwWWFilrELBUVTeXUa+9gL7A3KjMJ8J5QrlxHYuVCVlXfKOITA7OvJ4i8rcicljI/7qInB78H5eRKbjngOeBj4Argo/gGOAUsl/CL8l6R9cFp2NPETmiHIeaqs7UyOvfyrHM3HIucFdbz+0k44E/quq6IN8bzrWnzdpERCaJSHNwpK4HdiXrVXUbGlEJFCP+Ui8HrjG/pH1V9T4y+3lg+OVuoTXHVstzBhdxNtqFGtaR2dwHRmXuqpkTk1DuoOj6YmWiqlvIvryjgMXh2XeQvYAAjwB/D3wAnAOcHno1n5M5yE4M99wKnKuqb4T7fgi8StbzeZ/MfKnoOyIiR5D1TLosNBgiGt8FjhaR1SKyGvgBcDCZL6bcNoNMafaN5L+JyhkNTA5l7R5MiA1A/O7UP7V2SlTywDgGo/OJgw04lOwL/A2yBtsROBnYGehN5ri7FNgOOB34glYcg0BPMg/9z8Mz+gDfCnljQ316R+X+EngA6B/kgcAJIX0imc09kuylu8fWu8z/wVS6gTOqi9+DcWRKbDDZl7bleBq4vp1tdg2Zc7AvmR9nAcExSOZzeic8uzeZf2dLyzvYXdoiTz2BAqo6h8w+v5ns13IhmdcXzX4tTw/yB2S/qA8VeU7LL/IwMsWxIlwP8BQwH1gtIi1d0smhrOdEZCPwJMF+VNXHgRvCfQvDX6djjCfzryxT1dUtB1l7j6N9bXY98DlZD2IGmZOxhT8AjwNvkZlvn5KadN0CCRrLaRBEZCpZ7+HsWtfF6R64EnCcnJNLc8BxnK24EnCcnNMpJSAiY0XkTRFZKCJTKlUpp77wdm5wOhGG6Uk2Cms/svDIy8DINu5RP+rv8HbOx9EVIcLDgYWq+nYIq91PNnvNaSy8nRucziiBgaQx0RXhXIKIXCAic0RkTifKcmqHt3OD05m59a0NjdRtTqhOA6ZBtlJOJ8pzaoO3c4PTmZ7ACtKx7i0z1ZzGwtu5wemMEngBGC4iQ8Mc/LOARytTLaeO8HZucDpsDqjqZhGZSDZ+uicwXVXnV6xmTl3g7dz4VHXYsNuK9YmqVnTqq7dzfVKsnX3EoOPkHFcCjpNzXAk4Ts7p9mvwV4t0tbH2XWvlnj17Fs378ssvW023RuzPsb4dnyLulIv3BBwn57gScJyc40rAcXJOrn0C1h7v0SPVib169SqkYzu+Lbl3794lr928eeuS99Z2L+UHsHlffPFFIf3pp58meVu2bElk9xE4xfCegOPkHFcCjpNzGt4cKBWu22679OPvsMMOibzXXnsV0gMGDEjydtop3Ytzzz237jxlu+2xWWGx3fhYts/5/PPPE3nt2rWF9OrVq5O8DRs2FH2umwZOjPcEHCfnuBJwnJzjSsBxck7D+QTaE/bbfffdk7z9998/kb/61a8W0iNHjkzyhgwZksi77LJLIW3Dc5988kkib9y4sZC2PoE4fGjve//99xP57bffLqR33XXXJG/p0nRn85UrVxbScWjRge2337r7un0nLCeeeGIhfccdd3S4zPi9fOyxx5K8n/zkJ4n80ksvdbicsurSpU93HKfucSXgODmnW5oDpcJ+Ns+O3uvXr18hHXf3AY444ohEPvzwwwvpoUOHJnk2ZPjhhx8W0h999FGSZ7vxffv2LaStuRKbEtasWLVqVSLH99qw35o1axI5HrWYd3Ng8ODBiRx364877riS98bvV2dCrXH4NzYxAEaNGpXIRx55ZCG9fHnldz73noDj5BxXAo6Tc1wJOE7O6ZY+gVLYocB2eO+gQVv30bC210EHHZTIse3Yv3//JM/a6x988EEh/dlnnyV577yT7tURh6Ri/wDAzjvvXPQ59rPF9qm91vpC8jxU+IADDkjkyy+/PJHb8gN0lNiHM3HixCTv+uuvL6Stj6KpqSmRJ0yYUEj/7Gc/q2QVAe8JOE7ucSXgODnHlYDj5JyG8AmUmh5sh9PG8f7YPwDQp0+fRI5t902bNiV5duruiy++WEjb4b4ff/xxIsfTjvfYY48kL66/HW/w7rvvJnI8FNiOC1i/fn0i580ncOaZZxbSN998c5Jn/+ddRewTePLJJ5O8+fO37uRmfQIW+/5UGu8JOE7OaVMJiMh0EVkrIq9F5/qJyCwRWRD+lp514dQ93s75pRxz4C7gZuDu6NwUYLaqXisiU4I8ufLVK494+KwNjcWz+yA1D0oNKYa0a25n5c2dOzeRX3ut8N3ZZmFRGwaMVzCKTQ5IZxEuWrQoyVu4cGEiL168uJBesmRJkmeHKtuQZivcRZ23cykOPPDARL799tsL6TjsCtUzjUaMGFFIT5o0KcmzIedS7LvvvhWrU2u02RNQ1aeB983pU4EZIT0DOK2y1XKqjbdzfumoY3CAqq4CUNVVIlJUrYnIBcAFHSzHqS3ezjmgy6MDqjoNmAa+b30j4+3cfemoElgjIk3h16EJWNvmHVWirRWE4/Dc3nvvneTFqwtD6muwITjrI4inEls/hJXjkKadHhxP821ubk7yFixYkMjxvTYkaFcm7qAdXLftbH0p999/fyLHfgA7XbutjV5jbFg2DtuecsopSd7rr7+eyBdeeGEhfcsttyR5cZ1sfexKQl0xVDipSwfvexQYH9LjgUcqUx2nzvB2zgHlhAjvA/4KfEVEVojI+cC1wBgRWQCMCbLTjfF2zi9tmgOqOq5I1vEVrotTQ7yd80u3HDZs7dtYtvaftcd32223QtrGanfcccdEju1qa7dZX0O83Jgdjmyf+9577xXS1paP4/2vvvpqkmft03g4qV0yrNT/qBGwYzrslPH489q2K/W/eOuttxL5qKOOSmQ7/iJmv/32S+RLL720aJlxnZYtW5bkXXLJJYls273S+LBhx8k5rgQcJ+d0S3PAEne14mG3sO3mHvEMPxtOtGGnOJRnw4m2exdfa00QG9qLV4y1eW+88UYhHa9WBNt2+csYCtyw2NDq1Vdfncg33XRTIW3btRSTJ6ejom33P37W0UcfneRdc801iTx8+PCi5Tz88MOFtF11yH62rsZ7Ao6Tc1wJOE7OcSXgODlHqhk66qox5XFY0E4bjadzQhryOf74NAR+2GGHJXJs/9nVfEsNy7W7xMyePTuRH3/88UL6lVdeSfLisF9boa1KtZ2qSttXlU89zB2IN5C1odZS/zcbsr3yyisTOd6l6uyzzy5Zh3jD2BtvvDHJs6sdVYNi7ew9AcfJOa4EHCfnuBJwnJzTEOME4hi9jZ3bOG8cl7fLNtmhp/HYgHgKMpResdbG/jdu3JjIa9dunZFrfQ2lYv+NNvS3K4mn9d56661J3kUXXVT0vnhYOWw7BTh+1+J2BLjqqqsSeebMmYW0fQfqCe8JOE7OcSXgODmnW5oDdqZgHMqzs/vi7hukw4ZtKM/eGw/btTMO4xAUbDtcuVj9IF192K5MHOPd/8pgh/NefPHFHX5W/O498cQTSd706dMT2Zp69Yr3BBwn57gScJyc40rAcXJOt/EJxLa9td3jqbs2dGfleEUaO/TXrigcr+iyYsWKJM/uXhTvbGTDTE1NTYkchyLtdOb4c7pPoOPEOxKdfPLJSZ79v8YrRVsfjX3X4qHcY8eOTfLsilJ2x6h6xXsCjpNzXAk4Ts5xJeA4Oafb+ARiW83u8jtw4MBCesiQIUmenVoc+wSsPW6HdsY+AzsOIN6JBtLdi2yZdjhyjNv9HcP6em644YZEPuOMMwppO07jqaeeSuR4SbFDDjkkyYuXKbPPsjtWDR06NJHdJ+A4TrfAlYDj5Jy6NQfscN+4GxaH4yANwdmVhGy3MV6x14YI7aoysQnQp0+fJM8OXY679TbMZDePiJ9rn+OUx+jRoxN5zJgxiRyHcOfNm5fk2Q0+43x77bBhwxL5iiuuKFqnQw89NJFnzZpV9Np6wt9Ax8k5rgQcJ+eUsyvxIBH5k4g0i8h8Ebk0nO8nIrNEZEH4u3vXV9fpKryd80s5PoHNwCRVnSciOwNzRWQWcB4wW1WvFZEpwBRgconntItSU2ztBp+x3b/PPvskeXZFoHh657p165I8u1tRPPzXPqdXr16JHPsX7GpGGzZsSOTYD2BXFK4hNWnn9hAPBb733nuTPDuMe86cOYW0XVXahndLEW8e2xZxmd2JNnsCqrpKVeeF9CagGRgInArMCJfNAE7rojo6VcDbOb+0KzogIkOAQ4DngQGqugqyF0hE+he55wLggk7W06ki3s75omwlICI7Ab8HLlPVjTaEVwxVnQZMC88oe3icHUkXL8BpV2yJ62JDebbbHo/es2aFne0Xj/yzm4za2WVxeHHx4sVJnt1gstSik7UeQVjtdm4P8cg+OwrwmWeeSeR45mB7uv8Wu+lonZpynaKs6ICI9CJ7MWaq6kPh9BoRaQr5TcDaYvc73QNv53xSTnRAgN8Azap6XZT1KDA+pMcDj1S+ek618HbOL+WYA98CzgFeFZGXwrkfA9cCD4jI+cAy4MwuqaFTLbydc0qbSkBVnwWKGYbHFznfaay9FfsErE0dh/qWLVuW5NnQUTxzcPDgwUlePMMQUrsz3igUtg0DxnJzc3OSZ1c13rRpUyFdarORalKrdi6F9efEIVvrO4k3eYXUD2CfY1eKjjnnnHMS+Zhjjknk+L2stf+mUviIQcfJOa4EHCfnuBJwnJxTt1OJLbH9ZeO+sc1tY//WfxAPK25rt6J46LKdDrxo0aKidXj55ZeTPDtuIPYJlNq5KO/YadZ2DEjMxIkTE/nYY48tpO2YAjsNuaPEqxRD+4YY1xPeE3CcnONKwHFyTt2aAzb8Est22PDKlSsLaRvKW7JkSSLHG0TYcKI1D+LNS+2qQ6tXry5aB7tvvTVf4udac6BU2MmaK40SoiqGXQj29ddfL6TtClJ2yHcsV/L/NmHChELaDlXuLguLWrwn4Dg5x5WA4+QcVwKOk3OkmnZlZ6aYxvahrXMcSrJhJWtXxmG/UpuBQjpE1NruVo5XMbZDnkv5N+oBVS1vvnCZdNVU4phRo0Yl8rhx4xL5oosuKqRt2Nj6bO6+++6i5dx2222JbH1M3Yli7ew9AcfJOa4EHCfnuBJwnJzTbXwCTtfRHX0CTvtxn4DjOK3iSsBxco4rAcfJOa4EHCfnuBJwnJzjSsBxck61pxKvA5YCe4Z0vZDn+uzbBc/0di6Pumjnqo4TKBQqMkdVD616wUXw+nQN9fY5vD6t4+aA4+QcVwKOk3NqpQSm1ajcYnh9uoZ6+xxen1aoiU/AcZz6wc0Bx8k5rgQcJ+dUVQmIyFgReVNEForIlGqWHdVhuoisFZHXonP9RGSWiCwIf3evYn0GicifRKRZROaLyKW1rlNnqXU7exu3j6opARHpCdwCnAiMBMaJSPE9oruOu4Cx5twUYLaqDgdmB7labAYmqeoI4JvAJeH/Uss6dZg6aee78DYuH1WtygEcAfwhkn8E/Kha5Zu6DAFei+Q3gaaQbgLerEW9QvmPAGPqqU7dsZ29jcs/qmkODASWR/KKcK4eGKCqqwDC3/61qISIDAEOAZ6vlzp1gHpt57r4f9ZjG1dTCbS2tJHHJwMishPwe+AyVd3Y1vV1jLdzEeq1jaupBFYAgyJ5H+CdKpZfijUi0gQQ/q5t4/qKIiK9yF6Omar6UD3UqRPUazt7GxehmkrgBWC4iAwVkd7AWcCjVSy/FI8C40N6PJnNVhUk2/HkN0Czql5XD3XqJPXazt7GxaiyQ+Qk4C1gEXBljZwy9wGrgC/IfrXOB/Yg884uCH/7VbE+R5F1l18BXgrHSbWsU3dvZ2/j9h0+bNhxco6PGHScnONKwHFyjisBx8k5rgQcJ+e4EnCcnONKwHFyjisBx8k5/w+tdtRU5ZU9WQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -725,7 +1029,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "#7 Train loss: 149.3414\tBatch Loss: 136.385132 \n" + "#7 Train loss: 149.6275\tBatch Loss: 147.464142 \n" ] }, { @@ -746,9 +1050,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "#7 Test loss: 149.2784\n" + "#7 Test loss: 149.9035\n" ] }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -767,7 +1083,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "#8 Train loss: 148.2855\tBatch Loss: 141.117233 \n" + "#8 Train loss: 148.5860\tBatch Loss: 160.936905 \n" ] }, { @@ -788,9 +1104,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "#8 Test loss: 148.5178\n" + "#8 Test loss: 148.7231\n" ] }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -809,7 +1137,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "#9 Train loss: 147.4358\tBatch Loss: 137.274933 \n" + "#9 Train loss: 147.6321\tBatch Loss: 147.757065 \n" ] }, { @@ -830,28 +1158,40 @@ "name": "stdout", "output_type": "stream", "text": [ - "#9 Test loss: 147.8183\n" + "#9 Test loss: 148.3126\n" ] }, { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, + "image/png": "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\n", "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, description='train', max=657.0, style=ProgressStyle(description_width=…" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, description='train', max=657.0, style=ProgressStyle(description_width=…" + ] + }, + "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ - "#10 Train loss: 146.6685\tBatch Loss: 156.462265 \n" + "#10 Train loss: 146.8001\tBatch Loss: 150.039413 \n" ] }, { @@ -872,16 +1212,30 @@ "name": "stdout", "output_type": "stream", "text": [ - "#10 Test loss: 147.6682\n", + "#10 Test loss: 147.6022\n", "\n" ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ "epochs = 10\n", "for epoch in tqdm(range(1, epochs + 1)):\n", + " show_prediction(10, title=f\"epoch={epoch}\")\n", " train(epoch, loss_bce)\n", - " test(epoch, loss_bce)" + " test(epoch, loss_bce)\n", + "show_prediction(10, title=f\"epoch={epoch}\")" ] }, { @@ -894,56 +1248,19 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-12T01:17:19.342318Z", - "start_time": "2020-10-12T01:17:19.339147Z" - } - }, - "outputs": [], - "source": [ - "def cvt2image(tensor):\n", - " return tensor.detach().cpu().numpy().reshape(28, 28)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, + "execution_count": 16, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:17:19.735702Z", - "start_time": "2020-10-12T01:17:19.344057Z" + "end_time": "2020-10-12T06:15:54.865942Z", + "start_time": "2020-10-12T06:15:54.629327Z" } }, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "Text(0.5, 1.0, 'Actual')" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -953,17 +1270,10 @@ } ], "source": [ + "# Generate a random integer\n", "idx = np.random.randint(0, len(ds_test))\n", - "\n", - "model.eval()\n", - "original = ds_train[[idx]]\n", - "result = model(original.to(device))\n", - "img = cvt2image(result[0])\n", - "plt.figure(figsize=(2, 2))\n", - "plt.imshow(img, \"gray\")\n", - "plt.title(\"Predicted\")\n", - "ds_train.show(idx)\n", - "plt.title(\"Actual\")" + "# show this row of the data\n", + "show_prediction(idx)" ] }, { @@ -977,7 +1287,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "There are certainly some similarities but the predicted (reconstructed) images are not always very clear. We will shortly discuss how we can improve the model. But before that, let's have look at the latent space. The model is converting every image which has 784 values (28x28 pixels) to only 2 values. We can plot these two values for a few numbers." + "## Latent space" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are certainly some similarities but the predicted (reconstructed) images are not always very clear. We will shortly discuss how we can improve the model. But before that, let's have look at the latent space. The model is converting every image which has 784 values (28x28 pixels) to only 2 values. \n", + "\n", + "Those 2 values are the latent space. We can plot them for a few numbers (see below).\n", + "\n", + "We can also traverse the latent space and see how the reconstructed image changes in meaningfull ways. This is a usefull property and means the model has learnt how to vary images." ] }, { @@ -985,8 +1306,8 @@ "execution_count": 17, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:18:26.374503Z", - "start_time": "2020-10-12T01:18:26.359664Z" + "end_time": "2020-10-12T06:15:54.893417Z", + "start_time": "2020-10-12T06:15:54.867697Z" } }, "outputs": [ @@ -1001,62 +1322,97 @@ "output_type": "execute_result" } ], - "source": [ - "res = model.encode(ds_train[:1000].to(device))\n", - "res = res.detach().cpu().numpy()\n", - "res.shape" - ] + "source": [] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:18:04.642511Z", - "start_time": "2020-10-12T01:18:04.580273Z" + "end_time": "2020-10-12T06:24:47.556163Z", + "start_time": "2020-10-12T06:24:47.536837Z" } }, "outputs": [], - "source": [] + "source": [ + "# Scatter plot\n", + "\n", + "def traverse(ds=ds_train, model=model, y=3, xmin=-5, xmax=5):\n", + " res = model.encode(ds_train[:1000].to(device))\n", + " if isinstance(res, Normal):\n", + " res = res.loc\n", + " res = res.detach().cpu().numpy()\n", + " res.shape\n", + "\n", + " for i in range(10):\n", + " idx = ds.y[:1000] == i\n", + " plt.scatter(res[idx, 0], res[idx, 1], label=i)\n", + " plt.title('the latent space')\n", + " plt.xlabel('latent variable 1')\n", + " plt.ylabel('latent variable 2')\n", + "\n", + " # change these numbers, to change where we travel\n", + " y=3\n", + " xmin=-5\n", + " xmax=5\n", + "\n", + " plt.hlines(y, xmin, xmax, color='r', lw=2, label='traversal')\n", + " plt.legend()\n", + " plt.show()\n", + "\n", + " # Do out traversal\n", + " plt.figure(figsize=(12, 12))\n", + " n_steps = 10\n", + " xs = np.linspace(xmin, xmax, n_steps)\n", + " for xi, x in enumerate(xs):\n", + " # Decode image at x,y\n", + " z = torch.tensor([x, y])[None :].float().to(device)\n", + " img = model.decode(z).cpu().detach().numpy()\n", + " img = (img.reshape((28, 28)) * 255).astype(np.uint8)\n", + " \n", + " # plot an image at x, y\n", + " plt.subplot(1, n_steps, xi+1)\n", + " plt.imshow(img, cmap='gray')\n", + " plt.title(f'{x:2.1f}, {y:2.1f}')\n", + " plt.xticks([])\n", + " plt.yticks([])" + ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:18:28.017161Z", - "start_time": "2020-10-12T01:18:27.442945Z" + "end_time": "2020-10-12T06:15:56.109203Z", + "start_time": "2020-10-12T06:15:54.907676Z" } }, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "for i in range(10):\n", - " idx = ds_train.y[:1000] == i\n", - " plt.scatter(res[idx, 0], res[idx, 1], label=i)\n", - "plt.legend()" + "traverse(model=model, y=3, xmin=-5, xmax=5)" ] }, { @@ -1095,6 +1451,13 @@ "In a VAE, the encoder generates two values for each parameter in latent space. One represent the mean and one represents the standard deviation of the parameter. Then sampling layer uses these two numbers and generates random values from the same distribution. These values then are fed to decoder which will create an output similar to the input." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model definition: VAE" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1104,54 +1467,52 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 20, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:21:37.472603Z", - "start_time": "2020-10-12T01:21:37.463642Z" + "end_time": "2020-10-12T06:15:56.122234Z", + "start_time": "2020-10-12T06:15:56.111309Z" } }, "outputs": [], "source": [ + " \n", "class VAE(nn.Module):\n", " \"\"\"Variational Autoencoder\"\"\"\n", " def __init__(self):\n", " super(VAE, self).__init__()\n", - "\n", - " # Typically we would use convolutions here, but to keep it simple we use linear layers\n", - " self.fc1 = nn.Linear(784, 400)\n", - " self.fc21 = nn.Linear(400, 2)\n", - " self.fc22 = nn.Linear(400, 2)\n", - " self.fc3 = nn.Linear(2, 400)\n", - " self.fc4 = nn.Linear(400, 784)\n", + " \n", + " self.encoder = nn.Sequential(\n", + " nn.Linear(784, 400),\n", + " nn.ReLU(),\n", + " nn.Linear(400, 4) # 2 for mean, 2 for std\n", + " )\n", + " self.decoder = nn.Sequential(\n", + " nn.Linear(2, 400),\n", + " nn.ReLU(),\n", + " nn.Linear(400, 784),\n", + " nn.Sigmoid()\n", + " )\n", "\n", " def encode(self, x):\n", " \"\"\"Takes in image, output distribution\"\"\"\n", - " h1 = F.relu(self.fc1(x))\n", - " loc, log_scale = self.fc21(h1), self.fc22(h1)\n", - " return Normal(loc, torch.exp(log_scale))\n", - "\n", - "# def reparameterize(self, mu, logvar):\n", - "# \"\"\"\n", - "# The reparameterization trick.\n", - " \n", - "# Commonly used way to sample from a normal distribution to allow differentiaton with less noise.\n", - " \n", - "# See https://stats.stackexchange.com/a/205336\n", - "# \"\"\"\n", - "# std = torch.exp(0.5 * logvar)\n", - "# eps = torch.randn_like(std)\n", - "# return mu + eps * std\n", + " h = self.encoder(x)\n", + " # first few features are mean\n", + " mean = h[:, :2]\n", + " # second two are the log std\n", + " log_std = h[:, 2:]\n", + " std = torch.exp(log_std)\n", + " # return a normal distribution with 2 parameters\n", + " return Normal(mean, std)\n", "\n", " def decode(self, z):\n", " \"\"\"Takes in latent vector and produces image.\"\"\"\n", - " h3 = F.relu(self.fc3(z))\n", - " return torch.sigmoid(self.fc4(h3))\n", + " return self.decoder(z)\n", "\n", " def forward(self, x):\n", " \"\"\"Combine the above methods\"\"\"\n", " dist = self.encode(x.view(-1, 784))\n", - " z = dist.rsample()\n", + " z = dist.rsample() # sample, with gradient\n", " return self.decode(z), dist" ] }, @@ -1169,11 +1530,11 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 21, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:21:37.511518Z", - "start_time": "2020-10-12T01:21:37.474671Z" + "end_time": "2020-10-12T06:15:56.140214Z", + "start_time": "2020-10-12T06:15:56.123786Z" } }, "outputs": [], @@ -1184,11 +1545,11 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 22, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:21:37.541769Z", - "start_time": "2020-10-12T01:21:37.513882Z" + "end_time": "2020-10-12T06:15:56.187835Z", + "start_time": "2020-10-12T06:15:56.142720Z" } }, "outputs": [ @@ -1196,21 +1557,23 @@ "name": "stdout", "output_type": "stream", "text": [ - "===================================================\n", - " Kernel Shape Output Shape Params Mult-Adds\n", - "Layer \n", - "0_fc1 [784, 400] [1, 400] 314000 313600\n", - "1_fc21 [400, 2] [1, 2] 802 800\n", - "2_fc22 [400, 2] [1, 2] 802 800\n", - "3_fc3 [2, 400] [1, 400] 1200 800\n", - "4_fc4 [400, 784] [1, 784] 314384 313600\n", - "---------------------------------------------------\n", - " Totals\n", - "Total params 631188\n", - "Trainable params 631188\n", - "Non-trainable params 0\n", - "Mult-Adds 629600\n", - "===================================================\n" + "==================================================================\n", + " Kernel Shape Output Shape Params Mult-Adds\n", + "Layer \n", + "0_encoder.Linear_0 [784, 400] [1, 400] 314.0k 313.6k\n", + "1_encoder.ReLU_1 - [1, 400] - -\n", + "2_encoder.Linear_2 [400, 4] [1, 4] 1.604k 1.6k\n", + "3_decoder.Linear_0 [2, 400] [1, 400] 1.2k 800.0\n", + "4_decoder.ReLU_1 - [1, 400] - -\n", + "5_decoder.Linear_2 [400, 784] [1, 784] 314.384k 313.6k\n", + "6_decoder.Sigmoid_3 - [1, 784] - -\n", + "------------------------------------------------------------------\n", + " Totals\n", + "Total params 631.188k\n", + "Trainable params 631.188k\n", + "Non-trainable params 0.0\n", + "Mult-Adds 629.6k\n", + "==================================================================\n" ] }, { @@ -1219,14 +1582,15 @@ "1" ] }, - "execution_count": 40, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# We can view the shape of our model and number of params\n", - "summary(model, torch.rand((1, 784)).to(device))\n", + "x = torch.rand((1, 784)).to(device)\n", + "summary(model, x)\n", "1" ] }, @@ -1250,37 +1614,18 @@ "\n", "\n", "\n", + "However we are using the KLD_loss, which is always positive\n", + "\n", "Image source: wikipedia" ] }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 23, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:21:37.548138Z", - "start_time": "2020-10-12T01:21:37.544006Z" - } - }, - "outputs": [], - "source": [ - "def loss_bce_kld(recon_x, x, mu, logvar):\n", - " BCE = F.binary_cross_entropy(recon_x, x.view(-1, 784), reduction=\"sum\")\n", - " \n", - " # KL-divergence between a diagonal multivariate normal,\n", - " # and a standard normal distribution (with zero mean and unit variance)\n", - " # In other words, we are punishing it if it's distribution moves away from a standard normal dist\n", - " KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\n", - " return BCE + KLD" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-12T01:21:37.554254Z", - "start_time": "2020-10-12T01:21:37.549968Z" + "end_time": "2020-10-12T06:15:56.200381Z", + "start_time": "2020-10-12T06:15:56.194842Z" } }, "outputs": [], @@ -1292,41 +1637,16 @@ " # and a standard normal distribution (with zero mean and unit variance)\n", " # In other words, we are punishing it if it's distribution moves away from a standard normal dist\n", " KLD = -0.5 * torch.sum(1 + p.scale.log() - p.loc.pow(2) - p.scale)\n", - " \n", - "# KLD = torch.distributions.kl.kl_divergence(dist, q = Normal(0, 1))\n", " return BCE + KLD" ] }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 24, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:21:37.561913Z", - "start_time": "2020-10-12T01:21:37.556017Z" - } - }, - "outputs": [], - "source": [ - "# # You can try the KLD here with differen't distribution\n", - "# p = Normal(-1, 2.5)\n", - "# q = Normal(0, 1)\n", - "\n", - "# KLD = -0.5 * torch.sum(1 + p.scale.log() - p.loc.pow(2) - p.scale)\n", - "# print(KLD)\n", - "# kld = torch.distributions.kl.kl_divergence(p, q)\n", - "# print(kld)\n", - "# kld = torch.distributions.kl.kl_divergence(q, p).log()\n", - "# print(kld)" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-12T01:21:37.967407Z", - "start_time": "2020-10-12T01:21:37.564904Z" + "end_time": "2020-10-12T06:15:56.623690Z", + "start_time": "2020-10-12T06:15:56.203354Z" } }, "outputs": [ @@ -1340,7 +1660,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1353,15 +1673,16 @@ ], "source": [ "# You can try the KLD here with differen't distribution\n", - "p = Normal(1, 2)\n", - "q = Normal(-1, 3)\n", + "p = Normal(loc=1, scale=2)\n", + "q = Normal(loc=0, scale=1)\n", "kld = torch.distributions.kl.kl_divergence(p, q)\n", "\n", + "# plot the distributions\n", "ps=p.sample_n(10000).numpy()\n", "qs=q.sample_n(10000).numpy()\n", "\n", - "sns.kdeplot(x=ps, label='p')\n", - "sns.kdeplot(x=qs, label='q')\n", + "sns.kdeplot(ps, label='p')\n", + "sns.kdeplot(qs, label='q')\n", "plt.title(f\"KLD(p|q) = {kld:2.2f}\\nKLD({p}|{q})\")\n", "plt.legend()\n", "plt.show()" @@ -1378,12 +1699,25 @@ "source": [ "## Exercise 1: KLD\n", "\n", - "Run the above cell with while changing Q. Test if:\n", + "Run the above cell with while changing Q.\n", + "\n", + "- Use the code above and test if the KLD is higher for distributions that overlap more\n", + "\n", + "- (advanced) Write new code that plots a line of kld vs q.loc, using the function below\n", "\n", - "- KLD is higher for distributions that overlap more\n", + "```python\n", + "def kld_vs_qloc(loc):\n", + " kld = torch.distributions.kl.kl_divergence(p, Normal(loc=loc, scale=1))\n", + " return kld\n", + " \n", + "klds = []\n", + "locs = range(-10, 10)\n", + "for loc in locs:\n", + " # YOUR CODE HERE: run kld_vs_qloc, for a loc\n", + " klds.append(kld)\n", "\n", - "Now\n", - "- plot the KLD as you vary the mean of q" + "# YOUR code here, plot locs vs klds\n", + "```" ] }, { @@ -1402,11 +1736,11 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 25, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:21:37.979617Z", - "start_time": "2020-10-12T01:21:37.969778Z" + "end_time": "2020-10-12T06:15:56.748503Z", + "start_time": "2020-10-12T06:15:56.625610Z" } }, "outputs": [], @@ -1448,11 +1782,11 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 26, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:21:38.015971Z", - "start_time": "2020-10-12T01:21:37.981323Z" + "end_time": "2020-10-12T06:15:56.783878Z", + "start_time": "2020-10-12T06:15:56.750677Z" } }, "outputs": [ @@ -1460,21 +1794,23 @@ "name": "stdout", "output_type": "stream", "text": [ - "===================================================\n", - " Kernel Shape Output Shape Params Mult-Adds\n", - "Layer \n", - "0_fc1 [784, 400] [1, 400] 314000 313600\n", - "1_fc21 [400, 2] [1, 2] 802 800\n", - "2_fc22 [400, 2] [1, 2] 802 800\n", - "3_fc3 [2, 400] [1, 400] 1200 800\n", - "4_fc4 [400, 784] [1, 784] 314384 313600\n", - "---------------------------------------------------\n", - " Totals\n", - "Total params 631188\n", - "Trainable params 631188\n", - "Non-trainable params 0\n", - "Mult-Adds 629600\n", - "===================================================\n" + "==================================================================\n", + " Kernel Shape Output Shape Params Mult-Adds\n", + "Layer \n", + "0_encoder.Linear_0 [784, 400] [1, 400] 314.0k 313.6k\n", + "1_encoder.ReLU_1 - [1, 400] - -\n", + "2_encoder.Linear_2 [400, 4] [1, 4] 1.604k 1.6k\n", + "3_decoder.Linear_0 [2, 400] [1, 400] 1.2k 800.0\n", + "4_decoder.ReLU_1 - [1, 400] - -\n", + "5_decoder.Linear_2 [400, 784] [1, 784] 314.384k 313.6k\n", + "6_decoder.Sigmoid_3 - [1, 784] - -\n", + "------------------------------------------------------------------\n", + " Totals\n", + "Total params 631.188k\n", + "Trainable params 631.188k\n", + "Non-trainable params 0.0\n", + "Mult-Adds 629.6k\n", + "==================================================================\n" ] }, { @@ -1483,7 +1819,7 @@ "1" ] }, - "execution_count": 46, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -1496,18 +1832,30 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 27, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:23:24.435691Z", - "start_time": "2020-10-12T01:21:38.017843Z" + "end_time": "2020-10-12T06:17:32.117561Z", + "start_time": "2020-10-12T06:15:56.786486Z" } }, "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6339896038c340e3817d97f14a18ef56", + "model_id": "d3b8ac8005dd4200b8f62b425b1a9b57", "version_major": 2, "version_minor": 0 }, @@ -1536,10 +1884,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "#1 Train loss: 180.7413Loss: 154.715042 \n", - "#1 Test loss: 163.7449\n" + "#1 Train loss: 182.8299Loss: 162.364532 \n", + "#1 Test loss: 167.1158\n" ] }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -1558,10 +1918,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "#2 Train loss: 161.2095Loss: 150.815536 \n", - "#2 Test loss: 159.4665\n" + "#2 Train loss: 163.0715Loss: 142.663788 \n", + "#2 Test loss: 159.4571\n" ] }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -1580,10 +1952,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "#3 Train loss: 157.7323Loss: 163.109680 \n", - "#3 Test loss: 156.5088\n" + "#3 Train loss: 157.4994Loss: 152.167542 \n", + "#3 Test loss: 155.9764\n" ] }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -1602,10 +1986,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "#4 Train loss: 155.5982Loss: 168.470352 \n", - "#4 Test loss: 154.7300\n" + "#4 Train loss: 154.5008Loss: 146.090439 \n", + "#4 Test loss: 153.5092\n" ] }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -1624,10 +2020,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "#5 Train loss: 153.8618Loss: 155.316452 \n", - "#5 Test loss: 153.2298\n" + "#5 Train loss: 152.4510Loss: 157.357117 \n", + "#5 Test loss: 152.0208\n" ] }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -1646,10 +2054,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "#6 Train loss: 152.3849Loss: 139.790909 \n", - "#6 Test loss: 151.9220\n" + "#6 Train loss: 150.9579Loss: 151.812119 \n", + "#6 Test loss: 150.5554\n" ] }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -1668,10 +2088,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "#7 Train loss: 151.1941Loss: 150.445114 \n", - "#7 Test loss: 151.7725\n" + "#7 Train loss: 149.6140Loss: 141.610352 \n", + "#7 Test loss: 150.0307\n" ] }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQEAAACWCAYAAADe+D2yAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAVmklEQVR4nO2dabBV1ZWAvwWCE0ZFAZ/4EBU0YFeLiRkciBpDidpGS8u0JCpWh7Yd6NYUUUjsJFRKu+3qRE3UNkFFsUXNZKltlSaoidGO0gJqA9IIDgzK4ITgLLj6x9nvsvfi3eG9d9+dzvqqTr29zr7n7H3fPnedvdbag6gqjuPklz71roDjOPXFlYDj5BxXAo6Tc1wJOE7OcSXgODnHlYDj5BxXAk5ZRGS4iKiIbFfvujjVx5WAUzNE5Bci8m50fCQim+pdr7zjSqACROQ2EbkipMeKyNIalasiMqIWZdUCVT1fVQd0HMBdwG/qXa/eQkSmi8gd9a5HOVpKCYjIKyLyQXjLrBORW0VkQDXLUNXHVfWgCupyrog8Uc2yzf33FpHficjrIvKyiPxTOD9dRH4rIr8SkU0iskBEDomuGyUifxKRDSKyWES+HuXtKCI/FZEVIvKOiDwhIjtGxX5LRFaKyBsicnkP678zcDowqyf3qaCcP4nI2yKyfQWf7dU2a1RaSgkETg5vmc8BXwD+Oc5sBbtWRPoA/wU8BwwFjgMuEZHjw0dOIXvDDgTuBO4VkX4i0i9c9wdgMPCPwGwR6VBqPwE+DxwRrr0M+DQq+ijgoFDeD0VkVKjPN4NSKXYM6+RrnA68Dvy5Gv+TzhCR4cBYQIGvl/50jlHVljmAV4CvRfK/Aw+QPQQXAcuAl0Pe3wDPAhuAvwB/HV13KLAA2AT8CrgbuCLkHQOsjj7bDtxD9kC/CVwPjAI+BLYA7wIbwme3J/uhrQTWAb8AdozudSmwBngN+LtQ7xGdfM8vASvNue8BtwLTgaei833CPceGYy3QJ8q/K1zTB/gAOKST8oaHuuwTnfsf4MwetNUjwPRefh5+CPw3cDXwQDfb7E/ApOjac4EnIvlnwCpgIzAfGBvlTQfuqPfvotzRij0BAESkHTgReCacOpXsxzNaRD4HzAT+AdgD+CVwv4hsLyL9gXuB/yR7G/6G7K3VWRl9yZTMCrIfylDgblVdApwPPKmZ/btbuOTfgAOBMcCI8PkfhnuNB74LjANGAl8r8fX2BfaO37bA94EhIX9VxwdV9VNgNbB3OFaFcx2sCPXYE9gBeLFEuWuj9PtAt0yt0DZHA7d35/oucA4wOxzHi8iQbrRZOZ4ma8+OXtdvRGSHan6J3qYVlcC94UfxBPAY8C/h/L+q6luq+gHw98AvVXWuqm5R1VnAR8CXw9EPuFZVP1HV35I1dGd8keyHdamqvqeqH6pqpzaliEgo9zuhHptC3c4MH/kGcKuqLlLV98jeIsVYRdaj2S06dlHVE0N+e1RuH2Afst7Fa0B7ONfBMOBV4A2yN+EBJcrtFBH5lvH628OaA+cAf1HVl7paVhfqdBSZsvy1qs4nU27fpAttVgmqeoeqvqmqm1X1p2S9vbI+o0aiFZXAqeFHsa+qXhh+9BC9HckejinmTdrO1rflqxr6c4EVRcpqB1ao6uYK6jUI2AmYH5X5UDhPKDeuY7EyIeuKbxSRqcGZ11dE/kpEvhDyPy8ipwX/xyVkCu4pYC7wHnBZ8BEcA5xM9ib8lKx3dHVwOvYVkcMrcaip6myNvP6dHCvNJecAt5W7bw+ZCPxBVd8I8p3hXFfarCwiMkVElgRH6gZgV7JeVdPQikqgGPGPehVwpXmT7qSqd5HZz0PDm7uDzhxbHfcZVsTZaBdqeIPM5j44KnNXzZyYhHLbo88XKxNV3UL24x0DvBzufTPZAwhwH/C3wNvA2cBpoVfzMZmD7IRwzX8A56jq/4XrvgssJOv5vEVmvlT1GRGRw8l6Jr0WGgwRjW8AR4vIWhFZC3wHOITMF1Npm0GmNHeK5L2icsYCU0NZuwcT4h0gfnYan3o7Jap5YByD0fnEwQYcRvYD/hJZg+0MnATsAvQnc9xdDGwHnAZ8QieOQaAvmYf+J+EeOwBHhrzxoT79o3J/BvwaGBzkocDxIX0Cmc09muyhu8PWu8L/wXSawBnVy8/BBDIlNozsR9tx/Bm4pottdiWZc3AnMj/OMoJjkMzn9Fq4d38y/86WjmewWdoiTz2BAqo6j8w+v57sbbmczOuLZm/L04L8Ntkb9Z4i9+l4I48gUxyrw+cBHgUWA2tFpKNLOjWU9ZSIbAQeJtiPqvogcG24bnn463SPiWT+lZWqurbjIGvvCXStza4BPibrQcwiczJ28HvgQeAFMvPtQ1KTrimQoLGcFkFEppP1Hs6qd12c5sCVgOPknFyaA47jbMWVgOPknB4pAREZLyJLRWS5iEyrVqWcxsLbucXpQRimL9korP3JwiPPAaPLXKN+NN7h7ZyPozdChF8ElqvqSyGsdjfZ7DWntfB2bnF6ogSGksZEV4dzCSJynojME5F5PSjLqR/ezi1OT+bWdzY0Urc5oToDmAHZSjk9KM+pD97OLU5PegKrSce6d8xUc1oLb+cWpydK4GlgpIjsF+bgnwncX51qOQ2Et3OL021zQFU3i8hksvHTfYGZqrq4ajVzGgJv59anpsOG3VZsTFS1qlNfvZ0bk2Lt7CMGHSfnuBJwnJzjSsBxck7Tr8HfaqSrmqX4tG+nN/CegOPkHFcCjpNzXAk4Ts5xn0Av0Ldv30S2dn4s27w+fYrrZesT+PTTTztNA2zZsqWyyjq5x3sCjpNzXAk4Ts5xcyCiVLfddtN33HHHRN5pp62b1HzyySdJnu2qx/Tr1y+R+/fvX0jvsEO6r+WAAen+n3GX/4MPPkjy1q9fn8jvvfdeRfVx8of3BBwn57gScJyc40rAcXJOy/sESoXgrD2+/fbpLty77LJLIb3XXnsleYMGDUrkOHxnbXdbTmzrx74ESMOL9jrra3jtta0L/Hz00UdJ3nbbpU27cuXW3cGt/yDvxO2+++67l/zsCSecUEjffPPN3S4zfg4feOCBJO8HP/hBIj/77LPdLqeiuvTq3R3HaXhcCThOzmmJlYW6MgIv7vp95jOfSfL222+/RD7ooIMK6dGjRyd5ttsYh+BsaO/jjz9O5Di8aM2KgQMHFtLWrFi9enUiL1mypJBesGBBkvfCCy8k8uLFW1cEs6ZD3lYWGjZsWCLH3fqvfvWrJa+Nn6+e/HZK3WfNmjWJfMQRRxTSq1Z1f+dzX1nIcZxOcSXgODnHlYDj5JyWCBHG9pWdwWfDbLvttlshbe38o446KpGPPvroQnqfffZJ8t56661EjsN11g9RKgxohx8PHjy4kLZhyT333DOR33333UL6ueeeK1m/OGRofQKtzoEHHpjIl156aSKX8wN0l9i2nzx5cpJ3zTXXFNLWR9HW1pbIkyZNKqR/9KMfVbOKgPcEHCf3uBJwnJzjSsBxck5T+gTsWIDYxrb29x577JHIBx98cCF97LHHJnlHHnlkIu+///6F9Pvvv5/kvf3224m8du3aQtoO77XjBnbdddei9Vu3bl0hbf0ZpXwN9n9ih0DH04erFetuZM4444xC+vrrr0/y7P+8t4h9Ag8//HCSF4/bsD4Bi332qo33BBwn55RVAiIyU0TWi8ii6NxAEZkjIsvC39KzLpyGx9s5v1RiDtwGXA/cHp2bBjyiqleJyLQgT61+9bZSKgwYr8YTd7Vh2/BQ3OU//vjjkzwbMnzzzTcL6XgWHsDcuXOLftZ2222dYnPBrvIThzBtXhwSBHj++ecL6dgcAdi4cWMib968mTLcRgO0c3eJzTyAm266qZCOZ4NC7UygUaNGFdJTpkxJ8uJQcDn23XffqtWpM8r2BFT1z8Bb5vQpwKyQngWcWt1qObXG2zm/dNcxOERV1wCo6hoRKarWROQ84LxuluPUF2/nHNDr0QFVnQHMgMafXeZ0H2/n5qW7SmCdiLSFt0MbsL7sFVWk1Mq/dqjtmDFjEnncuHGFtPUBbNq0KZGffvrpQvqxxx5L8uww3bhOsY+iszrtvPPOhbQNA8a+BTuk+NVXX03k+fPnF9IvvfRSkme/S+xf6IJNXNd2LoUNgd59992JHPsB7PPSldWWX3/99USOp4yffPLJSV7sowE4//zzC+kbbrghyYvrZOtjVxLqjaHCSV26ed39wMSQngjcV53qOA2Gt3MOqCREeBfwJHCQiKwWkW8DVwHjRGQZMC7IThPj7ZxfypoDqjqhSNZxVa6LU0e8nfNLUw4btuME4im2BxxwQJL3la98JZHjfBs7t3Z+PNRz2bJlSd6HH36YyPHQYGvn25V/Y5vcLhkW59lY/4oVKxJ50aLCuB7eeeedJK/VVxSOl2GDbZdii/+P1uYu5ROxy7LZ6eV2inZMPMwc4OKLLy5aZlwnOwbloosuSmTrl6g2PmzYcXKOKwHHyTlNYw7Ew4bjEBuk5sBnP/vZJG/48OGJHJsSL7/8cpK3dOnSRI5nb9mVia1JEndH7ZBQO7MxNiVsNz42JeLVigBefPHFRI7DiXHoCrrWBW5G7Iq8V1xxRSJfd911hbQNJ5Zi6tR0VLTt/sf3ileeArjyyisTeeTIkUXLuffeewtpu+qQ/W69jfcEHCfnuBJwnJzjSsBxck7T+ARi7Kq78c5BdtpubDdD6luw4bktW7Ykcrziiw0nWhs7Ltd+1oYT49WD7PDeeDipDQ3ZkGE8JdnWvdV8AOW45ZZbEvnJJ58spBcuXFjxfW699dZEvvzyyxP58MMPL6TPOuuskveKh3L//Oc/T/Lsakf1xHsCjpNzXAk4Ts5xJeA4OadpdiWOp+faVYIPOeSQQnrvvfdO8uzuwfHyXTZGb5fvin0P8XWwbVw+rp8db2B9AuvXb52Ra30CGzZsKKTtUGU7lTiug935uCvTZVt9V+J4zADABRdc0O17xT6luB0BfvzjHyfy7NmzC2nrz6kHviux4zid4krAcXJO04QI41ljdlhuPIPPdtPtsM94yLGd3WdX8olluzqN3aA07tZbE+SVV15J5HjoqTVJ4vraDU7szMAKVhB22HY474UXXtjte8XPwUMPPZTkzZw5M5GbZeNX7wk4Ts5xJeA4OceVgOPknIb1CdgNNmO734bVYj+AHWprw36xTVdu89I4fNrW1pbkWbs/ttdtuM7KcX3tdOE4DGjDSqXCgHkbJlyOeEeik046Kcmz/6v4GbFTxK2fKP6fjx8/Pslrb29P5OXLl3ehxvXDewKOk3NcCThOznEl4Dg5p2F9ApZ4qS9r98dLcllbPb4OStvRVo53sbFTdW18P863/gwb34+XNbNDgeOhqNafYeuQZ6z/5tprr03k008/vZC2y4s9+uijiRwvKXbooYcmeXbIcXyvQYMGJXnxlHZwn4DjOE2CKwHHyTkNaw7YrnncpbarBcXmgF0V2M7+i7vUNhwUd/8hnUVo8+wMsrgOthtvw4CrVq0qpO3qRnH407v/xRk7dmwixxvNQjqrc8GCBUme3eAzzrefHTFiRCJfdtllRet02GGHJfKcOXOKfraR8J6A4+QcVwKOk3Mq2ZW4XUT+KCJLRGSxiFwczg8UkTkisiz83b3cvZzGxds5v1TiE9gMTFHVBSKyCzBfROYA5wKPqOpVIjINmAZMLXGfHhGH+qw9Hk8PjlfghW1t+Th8Z6cS252NYrvShiXjFYAgHdZcbuegeANKOzS4KysCVZmGaOdSxEOB77zzziQvbiuAefPmFdLHHZdurGynm5fC+p9KEZfZTJTtCajqGlVdENKbgCXAUOAUYFb42Czg1F6qo1MDvJ3zS5eiAyIyHDgUmAsMUdU1kD1AIjK4yDXnAef1sJ5ODfF2zhcVKwERGQD8DrhEVTfaUXHFUNUZwIxwj25PdYu7yXY2XRxWs6Pzhg4dmshDhgwppOOwHmy7elBsLthuuw1hxl3+RYsWJXk2DBiHEOvY/e+UerdzKeKRfXYU4OOPP57I8czBrnT/LXbT0fgZabS26y4VRQdEpB/ZgzFbVe8Jp9eJSFvIbwPWF7veaQ68nfNJJdEBAW4Blqjq1VHW/cDEkJ4I3Ff96jm1wts5v1RiDhwJnA0sFJFnw7nvA1cBvxaRbwMrgTN6pYZOrfB2zilllYCqPgEUMwyPK3K+psThIbvCq92gdPjw4YW0XVnIhgxj2z0O68G2s/9WrFhRSMcbUcK24cRGXCW4EdvZ+mziIeDWJ/Pggw8mcuwHsPcZPXp00TLPPvvsRD7mmGMSuRVXc/IRg46Tc1wJOE7OcSXgODmnYacSW+J4tZ1iG48bsMOE7WqxcXw5nircGfFQYbuL0MKFCxM5Hsps/QV2XINTGXbcRjw02zJ58uREjjettWMK7DTk7mKnjHdliHEj4T0Bx8k5rgQcJ+c0pTlQavMIO0TXrh4UD/8dMGBAkmc3NVm6dGkh/cwzzyR5dlZhfK3t/rdKKKnW2JDt888/X0iPGjUqybObw8SyHfrck/aYNGlSIW2HKjfLwqIW7wk4Ts5xJeA4OceVgOPkHKmlvdqTKaZxuMja+fGwYWvnWzkOC9rvbjcqie1+u9mIHZ7czHa/qlY2X7hCemsqccyYMWMSecKECYl8wQUXFNJ2xSi7MtXtt99etJwbb7wxkW2ouJko1s7eE3CcnONKwHFyjisBx8k5TeMTiLHDSU0ZFd+n3PJQzWznd4Vm9Ak4Xcd9Ao7jdIorAcfJOU0zbDjGduNjE6BVVoB1nFrhPQHHyTmuBBwn57gScJycU2ufwBvACmDPkK4KVQjlVbU+VaCW9dm3F+7ZK+1cBfJcn6LtXNNxAoVCReap6mE1L7gIXp/eodG+h9enc9wccJyc40rAcXJOvZTAjDqVWwyvT+/QaN/D69MJdfEJOI7TOLg54Dg5x5WA4+ScmioBERkvIktFZLmITKtl2VEdZorIehFZFJ0bKCJzRGRZ+Lt7DevTLiJ/FJElIrJYRC6ud516Sr3b2du4a9RMCYhIX+AG4ARgNDBBRIrvEd173AaMN+emAY+o6kjgkSDXis3AFFUdBXwZuCj8X+pZp27TIO18G97GlaOqNTmAw4HfR/L3gO/VqnxTl+HAokheCrSFdBuwtB71CuXfB4xrpDo1Yzt7G1d+1NIcGAqsiuTV4VwjMERV1wCEv4PrUQkRGQ4cCsxtlDp1g0Zt54b4fzZiG9dSCXS2tJHHJwMiMgD4HXCJqm4s9/kGxtu5CI3axrVUAquB9kjeB3ithuWXYp2ItAGEv+vLfL6qiEg/sodjtqre0wh16gGN2s7exkWopRJ4GhgpIvuJSH/gTOD+GpZfivuBiSE9kcxmqwmSLYt0C7BEVa9uhDr1kEZtZ2/jYtTYIXIi8ALwInB5nZwydwFrgE/I3lrfBvYg884uC38H1rA+R5F1l/8XeDYcJ9azTs3ezt7GXTt82LDj5BwfMeg4OceVgOPkHFcCjpNzXAk4Ts5xJeA4OceVgOPkHFcCjpNz/h8raPXNKQtIegAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -1690,10 +2122,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "#8 Train loss: 150.1893Loss: 160.404709 \n", - "#8 Test loss: 150.5877\n" + "#8 Train loss: 148.5601Loss: 148.968811 \n", + "#8 Test loss: 148.9268\n" ] }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -1712,10 +2156,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "#9 Train loss: 149.2637Loss: 136.567825 \n", - "#9 Test loss: 149.5045\n" + "#9 Train loss: 147.5803Loss: 144.431747 \n", + "#9 Test loss: 148.1566\n" ] }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "application/vnd.jupyter.widget-view+json": { @@ -1734,17 +2190,37 @@ "name": "stdout", "output_type": "stream", "text": [ - "#10 Train loss: 148.4125Loss: 142.673355 \n", - "#10 Test loss: 148.7284\n", + "#10 Train loss: 146.6695Loss: 154.406540 \n", + "#10 Test loss: 147.9801\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "\n" ] } ], "source": [ "epochs = 10\n", + "show_prediction(10, title=f\"epoch={0}\")\n", "for epoch in tqdm(range(1, epochs + 1)):\n", " train(epoch, loss_bce_kld)\n", - " test(epoch, loss_bce_kld)" + " test(epoch, loss_bce_kld)\n", + " show_prediction(10, title=f\"epoch={epoch}\")" ] }, { @@ -1756,11 +2232,11 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 28, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:23:24.440221Z", - "start_time": "2020-10-12T01:23:24.437499Z" + "end_time": "2020-10-12T06:17:32.126372Z", + "start_time": "2020-10-12T06:17:32.122654Z" } }, "outputs": [], @@ -1770,11 +2246,11 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 29, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:23:24.455798Z", - "start_time": "2020-10-12T01:23:24.441794Z" + "end_time": "2020-10-12T06:17:32.143908Z", + "start_time": "2020-10-12T06:17:32.128508Z" } }, "outputs": [], @@ -1785,11 +2261,11 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 30, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:23:24.461889Z", - "start_time": "2020-10-12T01:23:24.457766Z" + "end_time": "2020-10-12T06:17:32.151973Z", + "start_time": "2020-10-12T06:17:32.146373Z" } }, "outputs": [ @@ -1797,15 +2273,21 @@ "data": { "text/plain": [ "" ] }, - "execution_count": 50, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -1816,16 +2298,16 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 31, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:23:24.484481Z", - "start_time": "2020-10-12T01:23:24.464513Z" + "end_time": "2020-10-12T06:17:32.179199Z", + "start_time": "2020-10-12T06:17:32.154256Z" } }, "outputs": [], "source": [ - "model = VAE()\n", + "model = VAE().to(device)\n", "with open(\"VAE.pk\", \"rb\") as fp:\n", " model.load_state_dict(pickle.load(fp))" ] @@ -1839,56 +2321,19 @@ }, { "cell_type": "code", - "execution_count": 52, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-12T01:23:24.494166Z", - "start_time": "2020-10-12T01:23:24.486643Z" - } - }, - "outputs": [], - "source": [ - "def cvt2image(tensor):\n", - " return tensor.detach().numpy().reshape(28, 28)" - ] - }, - { - "cell_type": "code", - "execution_count": 53, + "execution_count": 32, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:23:24.790959Z", - "start_time": "2020-10-12T01:23:24.498695Z" + "end_time": "2020-10-12T06:17:32.552070Z", + "start_time": "2020-10-12T06:17:32.181903Z" } }, "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "Text(0.5, 1.0, 'Actual')" - ] - }, - "execution_count": 53, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -1899,48 +2344,56 @@ ], "source": [ "idx = np.random.randint(0, len(ds_test))\n", - "\n", - "model.eval()\n", - "original = ds_train[[idx]]\n", - "result = model(original)\n", - "img = cvt2image(result[0])\n", - "plt.figure(figsize=(2, 2))\n", - "plt.imshow(img, \"gray\")\n", - "plt.title(\"Predicted\")\n", - "ds_train.show(idx)\n", - "plt.title(\"Actual\")" + "show_prediction(idx)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Now let's plot the predicted mean of both parameters." + "One property of a latent space is that you can travese it, and get meaningful varations of outputs." ] }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 33, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:24:12.120423Z", - "start_time": "2020-10-12T01:24:11.407928Z" + "end_time": "2020-10-12T06:17:32.580050Z", + "start_time": "2020-10-12T06:17:32.554008Z" } }, "outputs": [ { "data": { "text/plain": [ - "" + "(1000, 2)" ] }, - "execution_count": 60, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" - }, + } + ], + "source": [ + "dist = model.encode(ds_train[:1000].to(device))\n", + "res = dist.loc.cpu().detach().numpy()\n", + "res.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "ExecuteTime": { + "end_time": "2020-10-12T06:17:33.780249Z", + "start_time": "2020-10-12T06:17:32.581817Z" + } + }, + "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1949,41 +2402,51 @@ "needs_background": "light" }, "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "dist = model.encode(ds_train[:1000])\n", - "mu = dist.loc.detach().numpy()\n", + "# Scatter plot\n", "for i in range(10):\n", " idx = ds_train.y[:1000] == i\n", - " plt.scatter(mu[idx, 0], mu[idx, 1], label=i)\n", - "plt.legend()" + " plt.scatter(res[idx, 0], res[idx, 1], label=i)\n", + "plt.title('the latent space')\n", + "plt.xlabel('latent variable 1')\n", + "plt.ylabel('latent variable 2')\n", + "\n", + "# change these numbers, to change where we travel\n", + "y=1\n", + "xmin=-5\n", + "xmax=5\n", + "plt.hlines(y, xmin, xmax, color='r', lw=2, label='traversal')\n", + "plt.legend()\n", + "plt.show()\n", + "\n", + "# Do out traversal\n", + "plt.figure(figsize=(12, 12))\n", + "model.to(device)\n", + "n_ims = 10\n", + "xs = np.linspace(xmin, xmax, 10)\n", + "for xi, x in enumerate(xs):\n", + " plt.subplot(1, 10, xi+1)\n", + " z = torch.tensor([x, y])[None :].float().to(device)\n", + " img = model.decode(z).cpu().detach().numpy()\n", + " img = (img.reshape((28, 28)) * 255).astype(np.uint8)\n", + " plt.imshow(img, cmap='gray')\n", + " plt.title(f'{x:2.1f}, {y:2.1f}')\n", + " plt.xticks([])\n", + " plt.yticks([])" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-12T01:23:24.816197Z", - "start_time": "2020-10-12T01:23:24.813584Z" - } - }, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-12T01:23:25.530446Z", - "start_time": "2020-10-12T01:23:24.820189Z" - } - }, - "outputs": [], - "source": [] - }, { "cell_type": "markdown", "metadata": {}, @@ -1997,51 +2460,71 @@ "source": [ "## Exercise 2: Deeper\n", "Create a new VAE but this time use a deeper network. Note, everything else (loss function, dataloaders, training loops, etc.) will stay the same only the model will change. The example above was using these sizes: 784 --> 400 --> 2 --> 400 --> 784\n", - "
Try a new model which uses these size: 784 --> 400 --> 80 --> 2 --> 80 --> 400 --> 784 " + "\n", + "Try a new model which uses these size: 784 --> 400 --> 80 --> 2 --> 80 --> 400 --> 784 " ] }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 64, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:23:25.535007Z", - "start_time": "2020-10-12T01:23:25.532437Z" + "end_time": "2020-10-12T06:32:14.644894Z", + "start_time": "2020-10-12T06:32:14.641397Z" } }, "outputs": [], "source": [ - "# Create the model definition" + "# Create the model definition\n", + "# YOUR CODE HERE" ] }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 62, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:23:25.542721Z", - "start_time": "2020-10-12T01:23:25.536817Z" + "end_time": "2020-10-12T06:32:03.333511Z", + "start_time": "2020-10-12T06:32:03.329554Z" } }, "outputs": [], "source": [ - "# Insert Training loop here" + "# # Training logic\n", + "# epochs = 10\n", + "# show_prediction(10, title=f\"epoch={0}\")\n", + "# for epoch in tqdm(range(1, epochs + 1)):\n", + "# train(epoch, loss_bce_kld)\n", + "# test(epoch, loss_bce_kld)\n", + "# show_prediction(10, title=f\"epoch={epoch}\")" ] }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 63, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:23:25.548390Z", - "start_time": "2020-10-12T01:23:25.544633Z" + "end_time": "2020-10-12T06:32:06.281159Z", + "start_time": "2020-10-12T06:32:06.277347Z" } }, "outputs": [], "source": [ - "# Visualise the results" + "# # Visualise the results\n", + "# idx = np.random.randint(0, len(ds_test))\n", + "# show_prediction(idx)\n", + "# plt.show()\n", + "\n", + "# traverse(model=model, y=3, xmin=-5, xmax=5)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": { @@ -2055,78 +2538,210 @@ "Create a new VAE but this time use a more than two parameters for the latent space. This will reduce the loss" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-10-12T06:27:38.602002Z", + "start_time": "2020-10-12T06:26:51.173089Z" + } + }, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2020-10-12T03:27:58.177087Z", + "start_time": "2020-10-12T03:24:47.111Z" + } + }, "source": [ - "# Traversing the latent space\n", + "# Application: Anomaly Detection\n", "\n", - "One property of a latent space is that you can travese it, and get meaningful varations of outputs./" + "The model will reconstruct normal data well, and fail to reconstruct anomolies. This means we can use it for anomoly detection" ] }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 60, "metadata": { "ExecuteTime": { - "end_time": "2020-10-12T01:31:37.771335Z", - "start_time": "2020-10-12T01:31:37.765082Z" + "end_time": "2020-10-12T06:31:18.572098Z", + "start_time": "2020-10-12T06:31:17.943901Z" } }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "img_loss=85.39, random_loss=1953.95\n", + "anomoly detected=True\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD1CAYAAABJE67gAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAZbUlEQVR4nO3de7BV5Znn8e9PBBRBQVEkeIXYRrTLS9AkyiRO1G6QdiDJJBMs07Q6kkqNE6lyMjI6bbRLU3ZVvHRmTE9rtMDESwyCl9iZaBKNrUkUwUtQxPsFQRAvAVSQyzN/rHWmdljv5uxzzt7nnHfz+1TtOns/+11rvevs9zz7Petda72KCMzMLD879XUFzMyse5zAzcwy5QRuZpYpJ3Azs0w5gZuZZcoJ3MwsU07g1mWSTpS0fDvvr5c0tjfr1FWSLpH0k76uh1lPOIFb00XE0Ih4ua/rkQNJX5S0WNJaSS9Lmlnz3t9J2lJ+IXY8TqyznpGSHpH0jqT3Jf1e0gk17w+WdLWkFZLek/RDSQNbv4fWSk7gOyBJO/d1HQzKBLoA+BdgD+A/AVdJOrKm2O/LL8SOx4N1VrceOAvYGxgB/CNwT81nPRuYABwB/AVwDPA/m7xL1sucwHcQkl6VdIGkp4EPJO0s6bOSflf22J6q7d1JOlPSUknryp7hN7uwrZD0yfL5nLK394uyB/mIpH0lXVP2BJ+TdHTNsrMlvVRu91lJX6p5b4CkKyWtkfSKpHPLbe1cvr+HpBskrZT0pqTLJA1osM7/QdIz5e/iQUmH1bx3Qbm+dZKWSTqpjB8n6fGy97xK0lWN/o5KewK7Az+OwkJgKTC+i+shIjZExLKI2AoI2EKRyPcsi5wG/CAi3o2It4EfUCR8y5gT+I5lOjAFGA6MAu4FLqP4I/9vwB2S9i7Lrgb+hiLBnAlcLemYbm73axS9vZHARuD3wOLy9TygNvG9BPw7ih7ppcBPJI0u3zsHmAwcRdGDnLbNduYCm4FPAkcDfwX8584qJ+kvgFuBWRQ92H+l6L0OknQocC5wbEQMA/4aeLVc9J+Af4qI3YFxwO0163x/O4/ZABGxqtzumeWX0+eAA4GHa6p3dPmF9bykv+/sv6fyC3oDcDfwo4hY3fFW+aDm9X6S9ujs92P9WET4sQM8KJLOWTWvL6Do+dWW+SUwo87ydwLnlc9PBJZvZ1sBfLJ8Pge4vua9/wosrXn9l8D721nXk8DU8vlvgG/WvHdyua2dKb6QNgK71rw/HXigznovAX5SPv974Paa93YC3iz385MUX2YnAwO3WcdDFF8yI3vwuZwGrKL44tkMnFPz3ljg4LI+fwk8C/yPBta5S7nvM2pilwGPUHxB7Qs8Wv7uRvd12/Sj+w/3wHcsb9Q8PxD4am3PEJgIjAaQNFnSHyS9W753KkWPuTtW1Tz/KPF6aMcLSX8r6cmaOh1Rs91PbLMP2+7PQGBlzbL/AuzTQP0+AbzW8SKKwxBvAGMi4kWKnvklwGpJt0n6RFn0bIrjyc9JWijpbxrY1v8n6VPAT4G/BQYBhwP/XdKUsh4vR8QrEbE1Iv4I/APwHztbbxSHU24FZtccT78ceILiC/F3FF/Imyi+nCxTTuA7ltpbT75B0QMfXvPYLSKukDQYuAP4PjAqIoZTHFZQdZXNI+lA4HqKQxZ7ldtdUrPdlcB+NYvsv83+bKToDXfsz+4RcXgDm15B8QXQUQ+V634TICJuiYiJZZmgGCAkIl6IiOkUXxL/CMyTtFu5jvXbeVxYbuoIYFlE/LJM0ssoDmtNrlPPoGufwUCKXjwR8VFEnBsRYyJiLPAOsCgitnRhfdbPOIHvuH4CnCbpr8vjr7uoOL97P4re4GDgbWCzpMkUx5NbbTeKJPU2FAOpFEmuw+3AeZLGSBpOcRgIgIhYCdwHXClpd0k7SRon6QsNbPd2YIqkk1ScGXI+xZfB7yQdquJUv8EUx5Y/ohggRNIZkvYue+zvl+vaUtZn6HYe3yvLPgEcUq5fksZRjDs8Va5/sqRR5fNPURzquSu1AyoGpCeWx+13lXQBxWGlR8v3x0j6RLmdz5br+m4Dvxvrx5zAd1AR8QYwFbiQImG+AXwH2Cki1gHfpkhs7wGnUwyKtbpOzwJXUgxyrqI47vtITZHrKZL00xTJ718pjht39CI7DkU8W9Z7HuUhoU62uww4A/hfwBqK49KnRcTHFF9kV5Txtyh62x096EnAM5LWUwxofj0iNnRhf1+iOBPkB8Ba4LcU//ncUBY5CXha0gflvs4HOpI/Ks7s6ajLYOBaip71mxSHvKZExIry/XEUh04+oBjsnR0R9zVaV+ufFOEJHSxP5X8G/yciDuy0sFkbcg/cslEeGjhVxTnsYygOASzo63qZ9RX3wC0bkoZQHGb4FMWx6HspTm1c26cVM+sjTuBmZpnyIRQzs0w5gZuZZcoJ3MwsU07gZmaZcgI3M8uUE7iZWaacwM3MMuUEbmaWKSdwM7NMOYGbmWXKCdzMLFNO4GZmmXICNzPLlBO4mVmmnMDNzDLlBG5mlikncDOzTDmBm5llygnczCxTTuBmZplyAjczy5QTuJlZppzAzcwy5QRuZpYpJ3Azs0w5gZuZZcoJ3MwsU07gZmaZcgI3M8uUE7iZWaacwM3MMuUEbmaWKSdwM7NMOYGbmWXKCdzMLFNO4GZmmXICNzPLlBO4mVmmnMDNzDLlBG5mlikncDOzTDmBm5llygnczCxTTuBmZplyAjczy5QTuJlZpnqUwCVNkrRM0ouSZjerUmZ9zW3bcqCI6N6C0gDgeeAUYDmwEJgeEc82r3pmvc9t23Kxcw+WPQ54MSJeBpB0GzAVqNvIJXXv28KsQRGhJqzGbdv6nVTb7skhlDHAGzWvl5cxs9y5bVsWetIDT/V0Kr0QSTOBmT3Yjllvc9u2LPQkgS8H9q95vR+wYttCEXEdcB3430zLhtu2ZaEnh1AWAodIOljSIODrwN3NqZZZn3Lbtix0uwceEZslnQv8EhgA3BgRzzStZmZ9xG3bctHt0wi7tTH/m2kt1qSzULrMbdtardlnoZiZWR9yAjczy5QTuJlZppzAzcwy5QRuZpYpJ3Azs0w5gZuZZcoJ3MwsU07gZmaZcgI3M8uUE7iZWaacwM3MMuUEbmaWKSdwM7NMOYGbmWXKCdzMLFNO4GZmmXICNzPLlBO4mVmmuj2pMYCkV4F1wBZgc0RMaEalzPqa23aepPSUqAMHDmx4Hal5grds2ZIsu3Xr1obX2wo9SuClfx8Ra5qwHrP+xm3b+jUfQjEzy1RPE3gA90laJGlmMypk1k+4bVu/19NDKCdExApJ+wD3S3ouIh6qLVA2fv8BWG7ctq3fU+qAfbdWJF0CrI+I72+nTHM2ZlZHRKRHsXrAbTsf7TyImWrb3e6BS9oN2Cki1pXP/wr4hx7Uz7axxx57JOMHH3xwJTZjxoxk2cMPP7wS+9znPpcs+6Mf/agSu+aaa5JlX3vttWS8Hbht/7lUUtxpp/TR1912260SGzp0aCU2bNiwhpcfOXJksuyBBx7YcNlUAl+4cGGy7LJlyyqxFStWJMtu3LixEmtWp7gRPTmEMgpYUH64OwO3RMT/bUqtzPqW27ZlodsJPCJeBo5sYl3M+gW3bcuFTyM0M8uUE7iZWaaadhZKQxvzSH1dX/nKVyqxiy++OFn2iCOOqMRa9Tk+/PDDyfjUqVMrsT/96U8tqUNXtOIslEa0Q9uudwbHoEGDKrHhw4cny44fP74SO/bYYyuxcePGJZffc889K7FNmzYly+6///4N1yul3iDmE088UYnNnz8/WXblypWVWKvOTEm1bffAzcwy5QRuZpYpJ3Azs0w5gZuZZcoJ3MwsU824H7jVUe/+C3Pnzq3EpkyZUomlLivuqtTo+YYNG5JlTz/99Eps4sSJybJnnXVWJXb11Vd3sXbWn9S7PH7EiBGVWL128e1vf7sSO+SQQyqxDz74ILn8qlWrKrHXX389Wfa9996rxFKX10P6thRr1qRv9b5+/fqGlgd46623kvHe4h64mVmmnMDNzDLlBG5mlikncDOzTHkQs4vqDUx+5jOfqcTqXX6bulw45aOPPkrGv/e971Vi99xzT7Lss88+W4nttddeybKpy/kHDx6cLLvLLrsk45aH1IBlvXY5adKkSuyCCy5Ilk0NIq5evboSe+yxx5LLP/TQQ5VYvVs0pO5rf+SR6ZtIbt68uRJLDc5CepA/NbDZH7gHbmaWKSdwM7NMOYGbmWXKCdzMLFOdJnBJN0paLWlJTWxPSfdLeqH8mR4NMOvH3LYtd42chTIH+N/ATTWx2cCvI+IKSbPL1+lh6TaTuuQdYN68eQ2vI3V2yZ133lmJ1bs0ffHixQ1vK+X9999PxmfNmlWJrVu3Llk2Vd8MzaHN23a9SRpSt2mod3n8OeecU4mNGjUqWTZ1afmCBQsqsZ///OfJ5d9+++1KbMyYMcmyqYkT6u3vli1bKrF6tw546aWXKrEPP/wwWbY3J8RJ6bQHHhEPAe9uE54KdNzQYy4wrbnVMms9t23LXXePgY+KiJUA5c99mlclsz7ltm3ZaPmFPJJmAjNbvR2z3ua2bX2tuz3wVZJGA5Q/q5dalSLiuoiYEBETurkts97ktm3Z6G4P/G5gBnBF+fOuptWoH/nWt75ViV166aUNL5+6jB3Sl8LfdtttjVesCyZPnlyJ1Zvt/rDDDqvETjjhhGTZevcUbwNt1bZ33jn9Jz527NhKbOrUqcmyqUHEep9/6l73N998cyW2du3a5PKpgcVjjjkmWTZ1Kf2QIUOSZVODjc8//3yy7COPPFKJ1bucv1Uz0DeqkdMIbwV+Dxwqabmksyka9ymSXgBOKV+bZcVt23LXaQ88IqbXeeukJtfFrFe5bVvufCWmmVmmnMDNzDLlBG5mlilP6LAd06ZNq8Tq3fQ+dcbJSSelD6WmLhdOnS1Qb9KE/fbbrxJ74IEHkmVT9R0wYECybMrQoUMbLmv9T73LxVNncBx33HHJsqkJQF599dVk2eeee64SS52psfvuuyeXT50JdfrppyfLHnrooZVYvf1dtGhRJXbttdcmy77yyiuVWGpCiP7APXAzs0w5gZuZZcoJ3MwsU07gZmaZ8iDmdqQGeupJDThefvnlDS9/wAEHVGInn3xysmzqnsdduS9xvQGZBx98sBJLDehY/gYNGlSJpe4RDun716cGKyF9if6nP/3pSqzeIOZRRx1ViY0fPz5ZduDAgZXYsmXLkmVvuummSmzhwoXJsqn97ev7ftfjHriZWaacwM3MMuUEbmaWKSdwM7NMeRBzO1IDeIcffniybGrwJhXrD+oN3kyaNKmXa2KtVm+S39TE2EuWLEmW3Wef6qxy9e4z/oUvfKES27RpUyVWb1Lk1N9XarAS0vckv+eee5Jlf/GLX1RiqcFK6Pt7fHeFe+BmZplyAjczy5QTuJlZppzAzcwy1cicmDdKWi1pSU3sEklvSnqyfJza2mqaNZ/btuVOnV0iKunzwHrgpog4ooxdAqyPiO93aWNS/7wetY4RI0ZUYql7EAN87Wtfq8SeeuqpZNkjjzyyEps/f34ltvfeeyeXnzdvXiVW73N85plnKrF69ylfs2ZNMp6TiEifdpGwI7Ttevd+T93ju94ZVscff3wlNnjw4GTZYcOGVWKptjl58uTk8uPGjavE6p1Jk7oH/5lnnpksm/pb3LJlS7Jsf5Vq2532wCPiIeDdltTIrA+5bVvuenIM/FxJT5f/hla7qmb5ctu2LHQ3gf8zMA44ClgJXFmvoKSZkh6X9Hg3t2XWm9y2LRvdSuARsSoitkTEVuB6ID2ZXlH2uoiYEBETultJs97itm056dal9JJGR8TK8uWXgPQ1uJl77733KrE//OEPybL14o1K3Yv5lltuSZZNTdy6cuXKRMn0PcnbYbCyVdqtbdcbqHvnnXcqscceeyxZ9qWXXqrEhg8fniybGnj//Oc/3/DyqUv0U3UFuOyyyyqxJ598Mlk2p8vju6LTBC7pVuBEYKSk5cB3gRMlHQUE8CrwzdZV0aw13LYtd50m8IiYngjf0IK6mPUqt23Lna/ENDPLlBO4mVmmnMDNzDLlCR36wNChQyuxWbNmVWJTpkxJLv/hhx9WYl/+8peTZXt6doy1p9TZKfUmOEid4ZQ6QwtgyJAhldi0adMqsZEjRyaX//jjjyux66+/Plk2NXlDu55tUo974GZmmXICNzPLlBO4mVmmnMDNzDLlQcw+cNFFF1Vi3/nOdxpePnXPYw9WWk/VGwBM3c978+bNybKnnHJKJZa6h37qdhAAS5ZU71xw4403Jstu3LgxGd+RuAduZpYpJ3Azs0w5gZuZZcoJ3MwsU07gZmaZ6nRW+qZurJ/O3N0qU6dOTcZ/+tOfVmJduZH9qFGjelaxNtaVWembqZ3bduqMkYkTJybL3nnnnZXYiBHVaUXXrVuXXP6MM86oxO69995k2dxmle+pbs1Kb2Zm/ZMTuJlZppzAzcwy1WkCl7S/pAckLZX0jKTzyvieku6X9EL5s3qgy6wfc9u23HU6iClpNDA6IhZLGgYsAqYBfwe8GxFXSJoNjIiICzpZV9sO9KTUmyk+NXP34sWLK7EvfvGLyeXXr1/fs4q1sa4MYrptNyZ17+4FCxYky55wwgkNrfNnP/tZMv6Nb3yjEkvdI3xH1K1BzIhYGRGLy+frgKXAGGAqMLcsNpei4Ztlw23bctelY+CSDgKOBh4FRkXESij+EIB9ml47s17itm05avhuhJKGAncAsyJirdTYf6qSZgIzu1c9s9Zz27ZcNdQDlzSQooHfHBHzy/Cq8hhix7HE1allI+K6iJgQEROaUWGzZnLbtpw1chaKgBuApRFxVc1bdwMzyuczgLuaXz2z1nHbttw1cgjlBOAbwB8lPVnGLgSuAG6XdDbwOvDVltSwn6k3m3Zq5uzUJcT1/OY3v6nEfLZJy+2wbTt1mGjXXXdNlj3//PMrsQkT0v90pNabOhvrvPPOSy7vM066ptMEHhEPA/UOCp7U3OqY9R63bcudr8Q0M8uUE7iZWaacwM3MMuVZ6bto+vTpyfhpp53W8Dp+/OMfV2IXX3xxt+tk1lWp+8+nZpQHOOussyqxXXbZJVl2w4YNldiVV15Zia1ataqzKloD3AM3M8uUE7iZWaacwM3MMuUEbmaWKSdwM7NMeVb67TjooIMqsfvuuy9ZduzYsQ2v9+GHH67EFi1aVIldeumlyeXXrl3b8LZ2NJ6V/s+lZpQHOOCAAyqxOXPmJMsef/zxldiAAQOSZZ966qlK7NRTT63E3nrrreTyVp9npTczayNO4GZmmXICNzPLlBO4mVmmfCn9dpx99tmVWFcGK+sZNmxYJfarX/2qEvNgpfXUoEGDkvFx48ZVYkOGDEmW3bp1ayW2Zs2aZNnUZfPvvPPO9qpoPeAeuJlZppzAzcwy5QRuZpapRiY13l/SA5KWSnpG0nll/BJJb0p6snxUz9Y368fcti13jQxibgbOj4jFkoYBiyTdX753dUR8v3XVM2spt23LWiOTGq8EVpbP10laCoxpdcXawQ9/+MNk/KKLLqrE1q1b1+rq2DbarW2nZoTfd999k2WPPfbYSiw1yQOkL3u/6667kmV/+9vfVmKbNm1KlrWe69IxcEkHAUcDj5ahcyU9LelGSSOaXTmz3uK2bTlqOIFLGgrcAcyKiLXAPwPjgKMoejHVE0CL5WZKelzS4z2vrlnzuW1brhpK4JIGUjTwmyNiPkBErIqILRGxFbgeOC61bERcFxETImJCsypt1ixu25azRs5CEXADsDQirqqJj64p9iVgSfOrZ9Y6btuWu07vBy5pIvBvwB+BjmtqLwSmU/yLGcCrwDfLQaHtratf3jPZ2kdX7ge+I7Ttevft3muvvRoum8oR7777brLsxx9/3IXaWVek2rYndLC24gkd/pwTePvwhA5mZm3ECdzMLFNO4GZmmXICNzPLlAcxra14ENPalQcxzczaiBO4mVmmnMDNzDLlBG5mlqnenpV+DfBa+Xxk+brdeL/6zoF9uO2Otp3D76m72nXfctivZNvu1bNQ/mzD0uPteBc379eOrZ1/T+26bznvlw+hmJllygnczCxTfZnAr+vDbbeS92vH1s6/p3bdt2z3q8+OgZuZWc/4EIqZWaZ6PYFLmiRpmaQXJc3u7e03Uzlj+WpJS2pie0q6X9IL5c/sZjSXtL+kByQtlfSMpPPKePb71krt0rbdrvPZt15N4JIGANcCk4HxwHRJ43uzDk02B5i0TWw28OuIOAT4dfk6N5uB8yPiMOCzwH8pP6d22LeWaLO2PQe36yz0dg/8OODFiHg5Ij4GbgOm9nIdmiYiHgK2nVtqKjC3fD4XmNabdWqGiFgZEYvL5+uApcAY2mDfWqht2rbbdT771tsJfAzwRs3r5WWsnYzqmAC3/LlPH9enRyQdBBwNPEqb7VuTtXvbbqvPvl3adW8n8NS9mn0aTD8laShwBzArItb2dX36ObftTLRTu+7tBL4c2L/m9X7Ail6uQ6utkjQaoPy5uo/r0y2SBlI08psjYn4Zbot9a5F2b9tt8dm3W7vu7QS+EDhE0sGSBgFfB+7u5Tq02t3AjPL5DOCuPqxLt0gScAOwNCKuqnkr+31roXZv29l/9u3Yrnv9Qh5JpwLXAAOAGyPi8l6tQBNJuhU4keJuZquA7wJ3ArcDBwCvA1+NiG0HhPo1SROBfwP+CGwtwxdSHC/Met9aqV3attt1PvvmKzHNzDLlKzHNzDLlBG5mlikncDOzTDmBm5llygnczCxTTuBmZplyAjczy5QTuJlZpv4fU5mEMKdA5HQAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, { "data": { "text/plain": [ - "(4, 5)" + "" ] }, - "execution_count": 92, + "execution_count": 60, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "xi, yi" + "img = ds_train[11].to(device)\n", + "\n", + "# First try to reconstruct a real image\n", + "img_recon, _ = model(img)\n", + "loss_img = loss_bce(img_recon , img)\n", + "\n", + "# then a fake image, a vector of random noise\n", + "rand = torch.rand((28, 28)).to(device)\n", + "rand[:, 15] = 1\n", + "rand[15, :] = 1\n", + "rand = rand.reshape((-1, ))\n", + "rand_recon, _ = model(rand)\n", + "loss_rand = loss_bce(rand_recon , rand)\n", + "\n", + "print(f'img_loss={loss_img:2.2f}, random_loss={loss_rand:2.2f}\\nanomoly detected={loss_img" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" }, { - "ename": "ValueError", - "evalue": "num must be 1 <= num <= 25, not 26", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mxi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0myi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxi\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0myi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mxi\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m5.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0myi\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m5.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda/envs/deep_ml_curriculum/lib/python3.7/site-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36msubplot\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 1124\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1125\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgcf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1126\u001b[0;31m \u001b[0max\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_subplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1127\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1128\u001b[0m \u001b[0maxes_to_delete\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda/envs/deep_ml_curriculum/lib/python3.7/site-packages/matplotlib/figure.py\u001b[0m in \u001b[0;36madd_subplot\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1400\u001b[0m \u001b[0;31m# more similar to add_axes.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1401\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_axstack\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1402\u001b[0;31m \u001b[0max\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msubplot_class_factory\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprojection_class\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1403\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1404\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_add_axes_internal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda/envs/deep_ml_curriculum/lib/python3.7/site-packages/matplotlib/axes/_subplots.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, fig, *args, **kwargs)\u001b[0m\n\u001b[1;32m 37\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 38\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 39\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_subplotspec\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mSubplotSpec\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_from_subplot_args\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 40\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate_params\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[0;31m# _axes_class is set in the subplot_class_factory\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda/envs/deep_ml_curriculum/lib/python3.7/site-packages/matplotlib/gridspec.py\u001b[0m in \u001b[0;36m_from_subplot_args\u001b[0;34m(figure, args)\u001b[0m\n\u001b[1;32m 688\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnum\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mnum\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0mrows\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mcols\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 689\u001b[0m raise ValueError(\n\u001b[0;32m--> 690\u001b[0;31m f\"num must be 1 <= num <= {rows*cols}, not {num}\")\n\u001b[0m\u001b[1;32m 691\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mgs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnum\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# -1 due to MATLAB indexing.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 692\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mValueError\u001b[0m: num must be 1 <= num <= 25, not 26" - ] + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -2136,31 +2751,20 @@ } ], "source": [ - "# TODO\n", - "plt.figure(figsize=(12, 12))\n", - "for xi in range(10):\n", - " for yi in range(10):\n", - " plt.subplot(5, 5, xi*5+yi+1)\n", - " x = (xi-5)/5.\n", - " y = (yi-5)/5.\n", - " z = torch.tensor([x, y])[None :].float()\n", - " img = model.decode(z).detach().numpy()\n", - " img = (img.reshape((28, 28)) * 255).astype(np.uint8)\n", - " plt.imshow(img, cmap='gray')\n", - " plt.title(f'{z.numpy()}')\n", - "# plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Applications\n", "\n", - "Autoencoders are not only useful for dimensionality reduction. They are often used for other purposes as well, including:\n", - "1. __Denoising:__ We could add noise to the input and then feed it to the model and then compare the output with the original image (without noise). This approach will create a model which is capable of removing noise from the input.\n", - "2. __Anomaly Detection:__ When we train a model on specific set of data, the model learns how to recreate the dataset. As a result when there are uncommon instances in the data the model will not be able to recrate them very well. This behaviour is sometimes used as a technique to find anomalous data points. \n", - "3. __Unsupervised Clustering:__ Like clustering algorithms but more flexible, able to fit complex relationships" + "plt.subplot(1, 2, 1)\n", + "plt.suptitle(f'real image loss={loss_img:2.2f}')\n", + "plt.imshow(cvt2image(img), cmap=\"gray\")\n", + "plt.subplot(1, 2, 2)\n", + "plt.imshow(cvt2image(img_recon), cmap=\"gray\")\n", + "plt.show()\n", + "\n", + "plt.subplot(1, 2, 1)\n", + "plt.suptitle(f'noisy image loss={loss_rand:2.2f}')\n", + "plt.imshow(cvt2image(rand), cmap=\"gray\")\n", + "plt.subplot(1, 2, 2)\n", + "plt.imshow(cvt2image(rand_recon), cmap=\"gray\")\n", + "# You can see it's removed the noise that we added, but retained the digit" ] }, { @@ -2183,13 +2787,15 @@ "
Solution\n", "\n", "```Python\n", + " \n", + "# Part 1\n", "p = Normal(0, 1)\n", "kld_close = torch.distributions.kl.kl_divergence(p, Normal(0, 1))\n", "kld_far = torch.distributions.kl.kl_divergence(p, Normal(10, 1))\n", "print(kld_close, kld_far)\n", "print('close is lower?', kld_close" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "ExecuteTime": { - "end_time": "2020-10-12T00:34:13.760634Z", - "start_time": "2020-10-12T00:34:13.521849Z" - } - }, - "outputs": [], - "source": [] - }, { "cell_type": "markdown", "metadata": {}, @@ -2227,42 +2821,54 @@ "## Exercise 2\n", "
Solution\n", "\n", - "```Python\n", - "class VAE2(nn.Module):\n", + "```Python \n", + " \n", + "class DeeperVAE(nn.Module):\n", + " \"\"\"Deeper Variational Autoencoder\"\"\"\n", " def __init__(self):\n", - " super(VAE2, self).__init__()\n", - "\n", - " self.fc1 = nn.Linear(784, 400)\n", - " self.fc2 = nn.Linear(400, 80)\n", - " self.fc31 = nn.Linear(80, 2)\n", - " self.fc32 = nn.Linear(80, 2)\n", - " self.fc4 = nn.Linear(2, 80)\n", - " self.fc5 = nn.Linear(80, 400)\n", - " self.fc6 = nn.Linear(400, 784)\n", + " super(DeeperVAE, self).__init__()\n", + " \n", + " self.encoder = nn.Sequential(\n", + " nn.Linear(784, 400),\n", + " nn.ReLU(),\n", + " nn.Linear(400, 80),\n", + " nn.ReLU(),\n", + " nn.Linear(80, 4)\n", + " )\n", + " self.decoder = nn.Sequential(\n", + " nn.Linear(2, 80),\n", + " nn.ReLU(),\n", + " nn.Linear(80, 400),\n", + " nn.ReLU(),\n", + " nn.Linear(400, 784),\n", + " nn.Sigmoid()\n", + " )\n", "\n", " def encode(self, x):\n", - " h1 = F.relu(self.fc1(x))\n", - " h2 = F.relu(self.fc2(h1))\n", - " return self.fc31(h2), self.fc32(h2)\n", - "\n", - " def reparameterize(self, mu, logvar):\n", - " std = torch.exp(0.5*logvar)\n", - " eps = torch.randn_like(std)\n", - " return mu + eps*std\n", + " \"\"\"Takes in image, output distribution\"\"\"\n", + " h = self.encoder(x)\n", + " # first few features are mean\n", + " mean = h[:, :2]\n", + " # second two are the log std\n", + " log_std = h[:, 2:]\n", + " std = torch.exp(log_std)\n", + " # return a normal distribution with 2 parameters\n", + " return Normal(mean, std)\n", "\n", " def decode(self, z):\n", - " h3 = F.relu(self.fc4(z))\n", - " h4 = F.relu(self.fc5(h3))\n", - " return torch.sigmoid(self.fc6(h4))\n", + " \"\"\"Takes in latent vector and produces image.\"\"\"\n", + " return self.decoder(z)\n", "\n", " def forward(self, x):\n", - " mu, logvar = self.encode(x.view(-1, 784))\n", - " z = self.reparameterize(mu, logvar)\n", - " return self.decode(z), mu, logvar\n", - "\n", - "\n", - "model = VAE2().to(device)\n", + " \"\"\"Combine the above methods\"\"\"\n", + " dist = self.encode(x.view(-1, 784))\n", + " z = dist.rsample() # sample, with gradient\n", + " return self.decode(z), dist\n", + " \n", + "model = DeeperVAE().to(device)\n", "optimizer = optim.Adam(model.parameters(), lr=1e-3)\n", + " \n", + "# training loop\n", "epochs = 10\n", "for epoch in tqdm(range(1, epochs + 1)):\n", " train(epoch,loss_bce_kld)\n", @@ -2296,45 +2902,55 @@ "
Solution\n", "\n", "```Python\n", - "class VAE2(nn.Module):\n", + " \n", + "class WiderVAE(nn.Module):\n", + " \"\"\"Wider Variational Autoencoder\"\"\"\n", " def __init__(self):\n", - " super(VAE2, self).__init__()\n", - "\n", - " self.fc1 = nn.Linear(784, 400)\n", - " self.fc2 = nn.Linear(400, 80)\n", - " self.fc31 = nn.Linear(80, 4) # We changed 2->4\n", - " self.fc32 = nn.Linear(80, 4) # We changed 2->4\n", - " self.fc4 = nn.Linear(4, 80) # We changed 2->4\n", - " self.fc5 = nn.Linear(80, 400)\n", - " self.fc6 = nn.Linear(400, 784)\n", + " super(WiderVAE, self).__init__()\n", + " \n", + " self.encoder = nn.Sequential(\n", + " nn.Linear(784, 400),\n", + " nn.ReLU(),\n", + " nn.Linear(400, 8)\n", + " )\n", + " self.decoder = nn.Sequential(\n", + " nn.Linear(4, 400),\n", + " nn.ReLU(),\n", + " nn.Linear(400, 784),\n", + " nn.Sigmoid()\n", + " )\n", "\n", " def encode(self, x):\n", - " h1 = F.relu(self.fc1(x))\n", - " h2 = F.relu(self.fc2(h1))\n", - " return self.fc31(h2), self.fc32(h2)\n", - "\n", - " def reparameterize(self, mu, logvar):\n", - " std = torch.exp(0.5*logvar)\n", - " eps = torch.randn_like(std)\n", - " return mu + eps*std\n", + " \"\"\"Takes in image, output distribution\"\"\"\n", + " h = self.encoder(x)\n", + " # first few features are mean\n", + " mean = h[:, :4]\n", + " # second two are the log std\n", + " log_std = h[:, 4:]\n", + " std = torch.exp(log_std)\n", + " # return a normal distribution with 2 parameters\n", + " return Normal(mean, std)\n", "\n", " def decode(self, z):\n", - " h3 = F.relu(self.fc4(z))\n", - " h4 = F.relu(self.fc5(h3))\n", - " return torch.sigmoid(self.fc6(h4))\n", + " \"\"\"Takes in latent vector and produces image.\"\"\"\n", + " return self.decoder(z)\n", "\n", " def forward(self, x):\n", - " mu, logvar = self.encode(x.view(-1, 784))\n", - " z = self.reparameterize(mu, logvar)\n", - " return self.decode(z), mu, logvar\n", - "\n", - "\n", - "model = VAE2().to(device)\n", + " \"\"\"Combine the above methods\"\"\"\n", + " dist = self.encode(x.view(-1, 784))\n", + " z = dist.rsample() # sample, with gradient\n", + " return self.decode(z), dist\n", + " \n", + "model = WiderVAE().to(device)\n", "optimizer = optim.Adam(model.parameters(), lr=1e-3)\n", "epochs = 10\n", + "show_prediction(10, title=f\"epoch={0}\")\n", "for epoch in tqdm(range(1, epochs + 1)):\n", - " train(epoch,loss_bce_kld)\n", - " test(epoch,loss_bce_kld)\n", + " train(epoch, loss_bce_kld)\n", + " test(epoch, loss_bce_kld)\n", + " show_prediction(10, title=f\"epoch={epoch}\")\n", + "\n", + "traverse(model=model, y=3, xmin=-5, xmax=5)\n", "\n", "```\n", "\n", diff --git a/notebooks/c09_Autoencoders/Autoencoders.py b/notebooks/c09_Autoencoders/Autoencoders.py index b8564cc..1dd8959 100644 --- a/notebooks/c09_Autoencoders/Autoencoders.py +++ b/notebooks/c09_Autoencoders/Autoencoders.py @@ -42,6 +42,13 @@ # # We pass the input through the model and it will compress and decompress the input and returns a result. Then we compare the output of the model with the original input. To check how close the output is to the original input we use a loss function. +# ## Applications +# +# Autoencoders are not only useful for dimensionality reduction. They are often used for other purposes as well, including: +# 1. __Denoising:__ We could add noise to the input and then feed it to the model and then compare the output with the original image (without noise). This approach will create a model which is capable of removing noise from the input. +# 2. __Anomaly Detection:__ When we train a model on specific set of data, the model learns how to recreate the dataset. As a result when there are uncommon instances in the data the model will not be able to recrate them very well. This behaviour is sometimes used as a technique to find anomalous data points. +# 3. __Unsupervised Clustering:__ Like clustering algorithms but more flexible, able to fit complex relationships + # Let's start by importing the required libraries. # + @@ -68,6 +75,8 @@ # ## Problem Description # We are going to start with a simple problem. We will use MNIST dataset which is a collection of hand-written digits as 28x28 pixel images. We are going to use autoencoder to compress each image into only two values and then reconstruct the image. When the model is trained we will have a look at the reconstructed images as well as latent space values. +# ## Dataset and dataloader +# # First we need to create a `Dataset` class. The `Dataset` class reads the data from file and returns data points when we need them. The advantage of using a `Dataset` is that we can adjust it based on what we need for each problem. If we are not dealing with large amount of data we can decide to keep everything in RAM so it is ready use. But if we are dealing with a few gigabytes of data we might need to open the file only when we need them.
# The MNIST data set is not large so we can easily fit it into memory. In the `Dataset` class we define a few methods: # - `__init__`: What information is required to create the object and how this information is saved. @@ -107,7 +116,7 @@ def __getitem__(self, idx): return output def show(self, idx): - plt.figure(figsize=(2, 2)) +# plt.figure(figsize=(2, 2)) plt.imshow(self.x[idx].reshape((28, 28)), "gray") def sample(self, n): @@ -128,6 +137,20 @@ def __call__(self, data): ds_train = DigitsDataset(path / "train.csv", transform=ToTensor()) ds_test = DigitsDataset(path / "test.csv", transform=ToTensor()) +ds_train + +for i in range(4): + for j in range(4): + plt.subplot(4, 4, 1+i*4+j) + ds_train.show(i*4+j) + plt.xticks([]) + plt.yticks([]) +plt.show() + + +# Both of these are the same +ds_train.__getitem__(1).shape +ds_train[1].shape # Next step is to create a data loaders. The training process takes place at multiple steps. At each step, we choose a few images and feed them to the model. Then we calculate the loss value based on the output. Using the loss value we update the values in the model. We do this over and over until when we think the model is trained. Each of these steps are called a mini-batch and the number of images passed in at each mini-batch is called batch size. Dataloader's job is to go to the dataset and grab a mini-batch of images for training. To create a Dataloader we use a pytorch dataloder object. @@ -136,28 +159,35 @@ def __call__(self, data): ds_train, batch_size=batch_size, shuffle=True ) test_loader = torch.utils.data.DataLoader(ds_test, batch_size=batch_size, shuffle=False) +test_loader # __Note:__ Shuffle tells the data loader whether the data needs to be shuffled at the end of each epoch. We do it for training to keep the input random. But we don't need to do it for testing since we only use the test dataset for evaluation. +# ## Model definition +# # Now we need to create the model. The architecture we are going to use here is made of two linear layers for the encoder and two linear layers for the decoder. class AE(nn.Module): def __init__(self): super(AE, self).__init__() - - self.fc1 = nn.Linear(784, 400) - self.fc2 = nn.Linear(400, 2) - self.fc3 = nn.Linear(2, 400) - self.fc4 = nn.Linear(400, 784) - + + self.encoder = nn.Sequential( + nn.Linear(784, 400), + nn.ReLU(inplace=True), + nn.Linear(400, 2) + ) + self.decoder = nn.Sequential( + nn.Linear(2, 400), + nn.ReLU(inplace=True), + nn.Linear(400, 784), + nn.Sigmoid() + ) def encode(self, x): - h1 = F.relu(self.fc1(x)) - return self.fc2(h1) + return self.encoder(x) def decode(self, z): - h3 = F.relu(self.fc3(z)) - return torch.sigmoid(self.fc4(h3)) + return self.decoder(z) def forward(self, x): z = self.encode(x.view(-1, 784)) @@ -174,12 +204,17 @@ def forward(self, x): model = AE().to(device) model +# Let use torchsummary X to see the size of the model +x=torch.rand((1, 784)).to(device) +summary(model, torch.rand((2, 784)).to(device)) +1 + # We also need to choose an optimiser. The optimiser use the loss value and it's gradients with respect to model parameters and tells us how much each value must be adjusted to have a better model. optimizer = optim.Adam(model.parameters(), lr=1e-3) -# And the final component is the loss function. Here we are going to use Binary Cross Entropy function. +# And the final component is the loss function. Here we are going to use Binary Cross Entropy function because each pixel can go from zero to one. def loss_bce(recon_x, x): BCE = F.binary_cross_entropy(recon_x, x.view(-1, 784), reduction="sum") @@ -187,25 +222,29 @@ def loss_bce(recon_x, x): # Let's define two functions one for executing a single epoch of training and one for evaluating the mdel using test data.
-# Notice the following steps in the training loop: -# 1. We make sure the data is in the right device (cpu or gpu) -# 2. We make sure that any saved gradient (derivative) is zeroed. -# 3. We pass a mini-batch of data into the model and grab the predictions. -# 4. We use the loss function to find out how close the model's output is to the actual image. -# 5. We use `loss.backward()` to claculate the derivative of loss with respect to model parameters. -# 6. We ask the optimiser to update model's parameters. +# Notice the following comments in the training loop # + def train(epoch, loss_function, log_interval=50): model.train() train_loss = 0 for batch_idx, data in enumerate(tqdm(train_loader, leave=False, desc='train')): + # We make sure the data is in the right device (cpu or gpu) data = data.to(device) + # We make sure that any saved gradient (derivative) is zeroed. optimizer.zero_grad() + + # We pass a mini-batch of data into the model and grab the predictions. recon_batch = model(data) + + # We use the loss function to find out how close the model's output is to the actual image. loss = loss_function(recon_batch, data) + + # We use loss.backward() to calculate the derivative of loss with respect to model parameters. loss.backward() + + # We ask the optimiser to update model's parameters. optimizer.step() train_loss += loss.item() @@ -233,51 +272,108 @@ def test(epoch, loss_function, log_interval=50): print('#{} Test loss: {:.4f}'.format(epoch, test_loss)) +# + +def cvt2image(tensor): + return tensor.detach().cpu().numpy().reshape(28, 28) + +def show_prediction(idx, title='', ds=ds_train): + """Show a predict vs actual""" + model.eval() + original = ds[[idx]] + result = model(original.to(device)) + img = cvt2image(result[0]) + + plt.figure(figsize=(4, 2)) + plt.subplot(1, 2, 1) + plt.imshow(img, "gray") + plt.title("Predicted") + + plt.subplot(1, 2, 2) + ds.show(idx) + plt.title("Actual") + + plt.suptitle(title) + plt.show() + +show_prediction(10, '0') # - # Now that all the components are ready, let's train the model for $10$ epochs. epochs = 10 for epoch in tqdm(range(1, epochs + 1)): + show_prediction(10, title=f"epoch={epoch}") train(epoch, loss_bce) test(epoch, loss_bce) - +show_prediction(10, title=f"epoch={epoch}") # ## Results # Now let's check out the model. -def cvt2image(tensor): - return tensor.detach().cpu().numpy().reshape(28, 28) +# Generate a random integer +idx = np.random.randint(0, len(ds_test)) +# show this row of the data +show_prediction(idx) +# Run the cell above a few times and compare the predicted and actual images. -# + -idx = np.random.randint(0, len(ds_test)) +# ## Latent space -model.eval() -original = ds_train[[idx]] -result = model(original.to(device)) -img = cvt2image(result[0]) -plt.figure(figsize=(2, 2)) -plt.imshow(img, "gray") -plt.title("Predicted") -ds_train.show(idx) -plt.title("Actual") -# - +# There are certainly some similarities but the predicted (reconstructed) images are not always very clear. We will shortly discuss how we can improve the model. But before that, let's have look at the latent space. The model is converting every image which has 784 values (28x28 pixels) to only 2 values. +# +# Those 2 values are the latent space. We can plot them for a few numbers (see below). +# +# We can also traverse the latent space and see how the reconstructed image changes in meaningfull ways. This is a usefull property and means the model has learnt how to vary images. -# Run the cell above a few times and compare the predicted and actual images. -# There are certainly some similarities but the predicted (reconstructed) images are not always very clear. We will shortly discuss how we can improve the model. But before that, let's have look at the latent space. The model is converting every image which has 784 values (28x28 pixels) to only 2 values. We can plot these two values for a few numbers. -res = model.encode(ds_train[:1000].to(device)) -res = res.detach().cpu().numpy() -res.shape +# + +# Scatter plot + +def traverse(ds=ds_train, model=model, y=3, xmin=-5, xmax=5): + res = model.encode(ds_train[:1000].to(device)) + if isinstance(res, Normal): + res = res.loc + res = res.detach().cpu().numpy() + res.shape + + for i in range(10): + idx = ds.y[:1000] == i + plt.scatter(res[idx, 0], res[idx, 1], label=i) + plt.title('the latent space') + plt.xlabel('latent variable 1') + plt.ylabel('latent variable 2') + + # change these numbers, to change where we travel + y=3 + xmin=-5 + xmax=5 + + plt.hlines(y, xmin, xmax, color='r', lw=2, label='traversal') + plt.legend() + plt.show() + + # Do out traversal + plt.figure(figsize=(12, 12)) + n_steps = 10 + xs = np.linspace(xmin, xmax, n_steps) + for xi, x in enumerate(xs): + # Decode image at x,y + z = torch.tensor([x, y])[None :].float().to(device) + img = model.decode(z).cpu().detach().numpy() + img = (img.reshape((28, 28)) * 255).astype(np.uint8) + + # plot an image at x, y + plt.subplot(1, n_steps, xi+1) + plt.imshow(img, cmap='gray') + plt.title(f'{x:2.1f}, {y:2.1f}') + plt.xticks([]) + plt.yticks([]) +# - -for i in range(10): - idx = ds_train.y[:1000] == i - plt.scatter(res[idx, 0], res[idx, 1], label=i) -plt.legend() +traverse(model=model, y=3, xmin=-5, xmax=5) # Each color represents a number. Despite most numbers overlapping, we can still see some distictions, for instance between $1$ and other numbers. @@ -296,48 +392,48 @@ def cvt2image(tensor): # Since VAE is a variation of autoencoder, it has a similar architecture. The main difference between the two is an additional layer between encoder and decoder which samples from latent space distribution. # In a VAE, the encoder generates two values for each parameter in latent space. One represent the mean and one represents the standard deviation of the parameter. Then sampling layer uses these two numbers and generates random values from the same distribution. These values then are fed to decoder which will create an output similar to the input. +# ## Model definition: VAE + # Let's create a VAE model. We will use layers with the same size as the previous model. Notice for the second layer we have two linear layers, one to generate the mean and one to generate the log of variance which will be converted into standard deviation. # + + class VAE(nn.Module): """Variational Autoencoder""" def __init__(self): super(VAE, self).__init__() - - # Typically we would use convolutions here, but to keep it simple we use linear layers - self.fc1 = nn.Linear(784, 400) - self.fc21 = nn.Linear(400, 2) - self.fc22 = nn.Linear(400, 2) - self.fc3 = nn.Linear(2, 400) - self.fc4 = nn.Linear(400, 784) + + self.encoder = nn.Sequential( + nn.Linear(784, 400), + nn.ReLU(), + nn.Linear(400, 4) # 2 for mean, 2 for std + ) + self.decoder = nn.Sequential( + nn.Linear(2, 400), + nn.ReLU(), + nn.Linear(400, 784), + nn.Sigmoid() + ) def encode(self, x): """Takes in image, output distribution""" - h1 = F.relu(self.fc1(x)) - loc, log_scale = self.fc21(h1), self.fc22(h1) - return Normal(loc, torch.exp(log_scale)) - -# def reparameterize(self, mu, logvar): -# """ -# The reparameterization trick. - -# Commonly used way to sample from a normal distribution to allow differentiaton with less noise. - -# See https://stats.stackexchange.com/a/205336 -# """ -# std = torch.exp(0.5 * logvar) -# eps = torch.randn_like(std) -# return mu + eps * std + h = self.encoder(x) + # first few features are mean + mean = h[:, :2] + # second two are the log std + log_std = h[:, 2:] + std = torch.exp(log_std) + # return a normal distribution with 2 parameters + return Normal(mean, std) def decode(self, z): """Takes in latent vector and produces image.""" - h3 = F.relu(self.fc3(z)) - return torch.sigmoid(self.fc4(h3)) + return self.decoder(z) def forward(self, x): """Combine the above methods""" dist = self.encode(x.view(-1, 784)) - z = dist.rsample() + z = dist.rsample() # sample, with gradient return self.decode(z), dist # - @@ -347,7 +443,8 @@ def forward(self, x): optimizer = optim.Adam(model.parameters(), lr=1e-3) # We can view the shape of our model and number of params -summary(model, torch.rand((1, 784)).to(device)) +x = torch.rand((1, 784)).to(device) +summary(model, x) 1 @@ -357,19 +454,10 @@ def forward(self, x): # # # +# However we are using the KLD_loss, which is always positive +# # Image source: wikipedia -def loss_bce_kld(recon_x, x, mu, logvar): - BCE = F.binary_cross_entropy(recon_x, x.view(-1, 784), reduction="sum") - - # KL-divergence between a diagonal multivariate normal, - # and a standard normal distribution (with zero mean and unit variance) - # In other words, we are punishing it if it's distribution moves away from a standard normal dist - KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp()) - return BCE + KLD - - -# + def loss_bce_kld(recon_x, x, dist): BCE = F.binary_cross_entropy(recon_x, x.view(-1, 784), reduction="sum") @@ -377,34 +465,21 @@ def loss_bce_kld(recon_x, x, dist): # and a standard normal distribution (with zero mean and unit variance) # In other words, we are punishing it if it's distribution moves away from a standard normal dist KLD = -0.5 * torch.sum(1 + p.scale.log() - p.loc.pow(2) - p.scale) - -# KLD = torch.distributions.kl.kl_divergence(dist, q = Normal(0, 1)) return BCE + KLD -# + -# # You can try the KLD here with differen't distribution -# p = Normal(-1, 2.5) -# q = Normal(0, 1) - -# KLD = -0.5 * torch.sum(1 + p.scale.log() - p.loc.pow(2) - p.scale) -# print(KLD) -# kld = torch.distributions.kl.kl_divergence(p, q) -# print(kld) -# kld = torch.distributions.kl.kl_divergence(q, p).log() -# print(kld) - # + # You can try the KLD here with differen't distribution -p = Normal(1, 2) -q = Normal(-1, 3) +p = Normal(loc=1, scale=2) +q = Normal(loc=0, scale=1) kld = torch.distributions.kl.kl_divergence(p, q) +# plot the distributions ps=p.sample_n(10000).numpy() qs=q.sample_n(10000).numpy() -sns.kdeplot(x=ps, label='p') -sns.kdeplot(x=qs, label='q') +sns.kdeplot(ps, label='p') +sns.kdeplot(qs, label='q') plt.title(f"KLD(p|q) = {kld:2.2f}\nKLD({p}|{q})") plt.legend() plt.show() @@ -414,12 +489,25 @@ def loss_bce_kld(recon_x, x, dist): # ## Exercise 1: KLD # -# Run the above cell with while changing Q. Test if: +# Run the above cell with while changing Q. +# +# - Use the code above and test if the KLD is higher for distributions that overlap more # -# - KLD is higher for distributions that overlap more +# - (advanced) Write new code that plots a line of kld vs q.loc, using the function below # -# Now -# - plot the KLD as you vary the mean of q +# ```python +# def kld_vs_qloc(loc): +# kld = torch.distributions.kl.kl_divergence(p, Normal(loc=loc, scale=1)) +# return kld +# +# klds = [] +# locs = range(-10, 10) +# for loc in locs: +# # YOUR CODE HERE: run kld_vs_qloc, for a loc +# klds.append(kld) +# +# # YOUR code here, plot locs vs klds +# ``` # ## Train @@ -468,9 +556,11 @@ def test(epoch, loss_function, log_interval=50): 1 epochs = 10 +show_prediction(10, title=f"epoch={0}") for epoch in tqdm(range(1, epochs + 1)): train(epoch, loss_bce_kld) test(epoch, loss_bce_kld) + show_prediction(10, title=f"epoch={epoch}") # ## Saving and Loading Model @@ -481,89 +571,167 @@ def test(epoch, loss_function, log_interval=50): model.load_state_dict -model = VAE() +model = VAE().to(device) with open("VAE.pk", "rb") as fp: model.load_state_dict(pickle.load(fp)) - # ## Results -def cvt2image(tensor): - return tensor.detach().numpy().reshape(28, 28) - - -# + idx = np.random.randint(0, len(ds_test)) +show_prediction(idx) -model.eval() -original = ds_train[[idx]] -result = model(original) -img = cvt2image(result[0]) -plt.figure(figsize=(2, 2)) -plt.imshow(img, "gray") -plt.title("Predicted") -ds_train.show(idx) -plt.title("Actual") -# - +# One property of a latent space is that you can travese it, and get meaningful varations of outputs. -# Now let's plot the predicted mean of both parameters. +dist = model.encode(ds_train[:1000].to(device)) +res = dist.loc.cpu().detach().numpy() +res.shape -dist = model.encode(ds_train[:1000]) -mu = dist.loc.detach().numpy() +# + +# Scatter plot for i in range(10): idx = ds_train.y[:1000] == i - plt.scatter(mu[idx, 0], mu[idx, 1], label=i) + plt.scatter(res[idx, 0], res[idx, 1], label=i) +plt.title('the latent space') +plt.xlabel('latent variable 1') +plt.ylabel('latent variable 2') + +# change these numbers, to change where we travel +y=1 +xmin=-5 +xmax=5 +plt.hlines(y, xmin, xmax, color='r', lw=2, label='traversal') plt.legend() +plt.show() - - - +# Do out traversal +plt.figure(figsize=(12, 12)) +model.to(device) +n_ims = 10 +xs = np.linspace(xmin, xmax, 10) +for xi, x in enumerate(xs): + plt.subplot(1, 10, xi+1) + z = torch.tensor([x, y])[None :].float().to(device) + img = model.decode(z).cpu().detach().numpy() + img = (img.reshape((28, 28)) * 255).astype(np.uint8) + plt.imshow(img, cmap='gray') + plt.title(f'{x:2.1f}, {y:2.1f}') + plt.xticks([]) + plt.yticks([]) +# - # If we compare this plot with the similar plot for normal autoencoder, we can see that VAE did a better job at creating clusters. The points for each digits are closer together compared to previous model. However, there is still room for improvement. # ## Exercise 2: Deeper # Create a new VAE but this time use a deeper network. Note, everything else (loss function, dataloaders, training loops, etc.) will stay the same only the model will change. The example above was using these sizes: 784 --> 400 --> 2 --> 400 --> 784 -#
Try a new model which uses these size: 784 --> 400 --> 80 --> 2 --> 80 --> 400 --> 784 +# +# Try a new model which uses these size: 784 --> 400 --> 80 --> 2 --> 80 --> 400 --> 784 # + # Create the model definition +# YOUR CODE HERE # + -# Insert Training loop here +# # Training logic +# epochs = 10 +# show_prediction(10, title=f"epoch={0}") +# for epoch in tqdm(range(1, epochs + 1)): +# train(epoch, loss_bce_kld) +# test(epoch, loss_bce_kld) +# show_prediction(10, title=f"epoch={epoch}") # + -# Visualise the results +# # Visualise the results +# idx = np.random.randint(0, len(ds_test)) +# show_prediction(idx) +# plt.show() + +# traverse(model=model, y=3, xmin=-5, xmax=5) # - + + # ## Exercise 3: Wider # Create a new VAE but this time use a more than two parameters for the latent space. This will reduce the loss -# # Traversing the latent space + + +# # Application: Anomaly Detection # -# One property of a latent space is that you can travese it, and get meaningful varations of outputs./ +# The model will reconstruct normal data well, and fail to reconstruct anomolies. This means we can use it for anomoly detection -xi, yi +# + +img = ds_train[11].to(device) + +# First try to reconstruct a real image +img_recon, _ = model(img) +loss_img = loss_bce(img_recon , img) + +# then a fake image, a vector of random noise +rand = torch.rand((28, 28)).to(device) +rand[:, 15] = 1 +rand[15, :] = 1 +rand = rand.reshape((-1, )) +rand_recon, _ = model(rand) +loss_rand = loss_bce(rand_recon , rand) + +print(f'img_loss={loss_img:2.2f}, random_loss={loss_rand:2.2f}\nanomoly detected={loss_imgSolution # # ```Python +# +# # Part 1 # p = Normal(0, 1) # kld_close = torch.distributions.kl.kl_divergence(p, Normal(0, 1)) # kld_far = torch.distributions.kl.kl_divergence(p, Normal(10, 1)) # print(kld_close, kld_far) # print('close is lower?', kld_close - - # ## Exercise 2 #
Solution # -# ```Python -# class VAE2(nn.Module): +# ```Python +# +# class DeeperVAE(nn.Module): +# """Deeper Variational Autoencoder""" # def __init__(self): -# super(VAE2, self).__init__() -# -# self.fc1 = nn.Linear(784, 400) -# self.fc2 = nn.Linear(400, 80) -# self.fc31 = nn.Linear(80, 2) -# self.fc32 = nn.Linear(80, 2) -# self.fc4 = nn.Linear(2, 80) -# self.fc5 = nn.Linear(80, 400) -# self.fc6 = nn.Linear(400, 784) +# super(DeeperVAE, self).__init__() +# +# self.encoder = nn.Sequential( +# nn.Linear(784, 400), +# nn.ReLU(), +# nn.Linear(400, 80), +# nn.ReLU(), +# nn.Linear(80, 4) +# ) +# self.decoder = nn.Sequential( +# nn.Linear(2, 80), +# nn.ReLU(), +# nn.Linear(80, 400), +# nn.ReLU(), +# nn.Linear(400, 784), +# nn.Sigmoid() +# ) # # def encode(self, x): -# h1 = F.relu(self.fc1(x)) -# h2 = F.relu(self.fc2(h1)) -# return self.fc31(h2), self.fc32(h2) -# -# def reparameterize(self, mu, logvar): -# std = torch.exp(0.5*logvar) -# eps = torch.randn_like(std) -# return mu + eps*std +# """Takes in image, output distribution""" +# h = self.encoder(x) +# # first few features are mean +# mean = h[:, :2] +# # second two are the log std +# log_std = h[:, 2:] +# std = torch.exp(log_std) +# # return a normal distribution with 2 parameters +# return Normal(mean, std) # # def decode(self, z): -# h3 = F.relu(self.fc4(z)) -# h4 = F.relu(self.fc5(h3)) -# return torch.sigmoid(self.fc6(h4)) +# """Takes in latent vector and produces image.""" +# return self.decoder(z) # # def forward(self, x): -# mu, logvar = self.encode(x.view(-1, 784)) -# z = self.reparameterize(mu, logvar) -# return self.decode(z), mu, logvar -# -# -# model = VAE2().to(device) +# """Combine the above methods""" +# dist = self.encode(x.view(-1, 784)) +# z = dist.rsample() # sample, with gradient +# return self.decode(z), dist +# +# model = DeeperVAE().to(device) # optimizer = optim.Adam(model.parameters(), lr=1e-3) +# +# # training loop # epochs = 10 # for epoch in tqdm(range(1, epochs + 1)): # train(epoch,loss_bce_kld) @@ -659,45 +839,55 @@ def cvt2image(tensor): #
Solution # # ```Python -# class VAE2(nn.Module): +# +# class WiderVAE(nn.Module): +# """Wider Variational Autoencoder""" # def __init__(self): -# super(VAE2, self).__init__() -# -# self.fc1 = nn.Linear(784, 400) -# self.fc2 = nn.Linear(400, 80) -# self.fc31 = nn.Linear(80, 4) # We changed 2->4 -# self.fc32 = nn.Linear(80, 4) # We changed 2->4 -# self.fc4 = nn.Linear(4, 80) # We changed 2->4 -# self.fc5 = nn.Linear(80, 400) -# self.fc6 = nn.Linear(400, 784) +# super(WiderVAE, self).__init__() +# +# self.encoder = nn.Sequential( +# nn.Linear(784, 400), +# nn.ReLU(), +# nn.Linear(400, 8) +# ) +# self.decoder = nn.Sequential( +# nn.Linear(4, 400), +# nn.ReLU(), +# nn.Linear(400, 784), +# nn.Sigmoid() +# ) # # def encode(self, x): -# h1 = F.relu(self.fc1(x)) -# h2 = F.relu(self.fc2(h1)) -# return self.fc31(h2), self.fc32(h2) -# -# def reparameterize(self, mu, logvar): -# std = torch.exp(0.5*logvar) -# eps = torch.randn_like(std) -# return mu + eps*std +# """Takes in image, output distribution""" +# h = self.encoder(x) +# # first few features are mean +# mean = h[:, :4] +# # second two are the log std +# log_std = h[:, 4:] +# std = torch.exp(log_std) +# # return a normal distribution with 2 parameters +# return Normal(mean, std) # # def decode(self, z): -# h3 = F.relu(self.fc4(z)) -# h4 = F.relu(self.fc5(h3)) -# return torch.sigmoid(self.fc6(h4)) +# """Takes in latent vector and produces image.""" +# return self.decoder(z) # # def forward(self, x): -# mu, logvar = self.encode(x.view(-1, 784)) -# z = self.reparameterize(mu, logvar) -# return self.decode(z), mu, logvar -# -# -# model = VAE2().to(device) +# """Combine the above methods""" +# dist = self.encode(x.view(-1, 784)) +# z = dist.rsample() # sample, with gradient +# return self.decode(z), dist +# +# model = WiderVAE().to(device) # optimizer = optim.Adam(model.parameters(), lr=1e-3) # epochs = 10 +# show_prediction(10, title=f"epoch={0}") # for epoch in tqdm(range(1, epochs + 1)): -# train(epoch,loss_bce_kld) -# test(epoch,loss_bce_kld) +# train(epoch, loss_bce_kld) +# test(epoch, loss_bce_kld) +# show_prediction(10, title=f"epoch={epoch}") +# +# traverse(model=model, y=3, xmin=-5, xmax=5) # # ``` #