conditional_pixelcnn.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "conditional_pixelcnn.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "W6zEY3RBXuMN",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e1f01ee3-a7e1-4559-bf0e-b56f6338648f"
      },
      "source": [
        "import torch\n",
        "import torch.optim as optim\n",
        "import torch.utils.data as data\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import numpy as np\n",
        "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "print(DEVICE)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "cuda\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T2r_QdymHVt7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 411
        },
        "outputId": "829fc7b7-420a-4440-f4c7-26058cbac0be"
      },
      "source": [
        "!if [ -d deepul ]; then rm -Rf deepul; fi\n",
        "!git clone https://github.com/rll/deepul.git \n",
        "!unzip -qq deepul/homeworks/hw1/data/hw1_data.zip -d deepul/homeworks/hw1/data/\n",
        "!pip install ./deepul"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Cloning into 'deepul'...\n",
            "remote: Enumerating objects: 749, done.\u001b[K\n",
            "remote: Total 749 (delta 0), reused 0 (delta 0), pack-reused 749\u001b[K\n",
            "Receiving objects: 100% (749/749), 114.90 MiB | 33.34 MiB/s, done.\n",
            "Resolving deltas: 100% (344/344), done.\n",
            "Checking out files: 100% (129/129), done.\n",
            "Processing ./deepul\n",
            "Building wheels for collected packages: deepul\n",
            "  Building wheel for deepul (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for deepul: filename=deepul-0.1.0-cp36-none-any.whl size=16679 sha256=b7eb114ce5d563fb972abc756272f5da301f0ea02656941803bf60a329dcd06f\n",
            "  Stored in directory: /tmp/pip-ephem-wheel-cache-3uw_07_r/wheels/39/1a/4b/a6f51db275abb2e5dae32540e06ed5011e792f162467bd3aa8\n",
            "Successfully built deepul\n",
            "Installing collected packages: deepul\n",
            "  Found existing installation: deepul 0.1.0\n",
            "    Uninstalling deepul-0.1.0:\n",
            "      Successfully uninstalled deepul-0.1.0\n",
            "Successfully installed deepul-0.1.0\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.colab-display-data+json": {
              "pip_warning": {
                "packages": [
                  "deepul"
                ]
              }
            }
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2COYUqTpHWub"
      },
      "source": [
        "from deepul.hw1_helper import *"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gJo-wSdtX8cU"
      },
      "source": [
        "class MaskedCon2d(nn.Conv2d):\n",
        "  def __init__(self, color_conditioning, mask_type, conditional_size, **kwargs):\n",
        "    super().__init__(**kwargs)\n",
        "    self.color_conditioning = color_conditioning\n",
        "    self.register_buffer('mask', torch.zeros_like(self.weight))\n",
        "    self.create_mask(mask_type)\n",
        "\n",
        "    self.conditional_size = conditional_size\n",
        "    self.condition_transformation = nn.Linear(conditional_size[0], self.out_channels)\n",
        "  \n",
        "  def forward(self, x, condition):\n",
        "    batch_size = x.shape[0]\n",
        "    out = F.conv2d(x, self.weight * self.mask, self.bias, self.stride,\n",
        "                   self.padding, self.dilation, self.groups)\n",
        "    #print(out.shape)\n",
        "    temp = self.condition_transformation(condition)\n",
        "    #print(temp.shape)\n",
        "    return out + temp.view(batch_size, -1, 1, 1)\n",
        "\n",
        "  def create_mask(self, mask_type):\n",
        "    k = self.kernel_size[0]\n",
        "    # C_out, C_in/groups, H, W\n",
        "    self.mask[:, :, :k // 2] = 1 # all rows in the upper half\n",
        "    self.mask[:, :, k // 2, :k // 2] = 1 # all elements in the left half of the center row\n",
        "\n",
        "    if self.color_conditioning:\n",
        "      assert self.in_channels % 3 ==0 and self.out_channels % 3 == 0\n",
        "      c_in_each_color = self.in_channels // 3\n",
        "      c_out_each_color = self.out_channels // 3\n",
        "      if mask_type == 'B':\n",
        "        self.mask[:c_out_each_color, :c_in_each_color, k//2, k//2 ] = 1\n",
        "        self.mask[c_out_each_color:(2*c_out_each_color), :(2 * c_in_each_color), k//2, k//2 ] = 1\n",
        "        self.mask[(2*c_out_each_color):, :, k//2, k//2 ] = 1\n",
        "      \n",
        "      else:\n",
        "        self.mask[c_out_each_color:(2*c_out_each_color), :c_in_each_color, k//2, k//2] = 1\n",
        "        self.mask[(2*c_out_each_color):, :(2 * c_in_each_color), k//2, k//2] = 1\n",
        "    \n",
        "    else:\n",
        "      if mask_type == 'B':\n",
        "        # add the center\n",
        "        self.mask[:, :, k // 2, k // 2] = 1\n",
        "\n",
        "class ResidualBlock(nn.Module):\n",
        "  def __init__(self, color_conditioning, conditional_size, in_channels=128):\n",
        "    super().__init__()\n",
        "    self.net = nn.ModuleList([nn.ReLU(),\n",
        "                              MaskedCon2d(mask_type='B', color_conditioning=color_conditioning, conditional_size=conditional_size,\n",
        "                                         in_channels=in_channels, out_channels=in_channels // 2, kernel_size=1),\n",
        "                              nn.ReLU(),\n",
        "                              MaskedCon2d(mask_type='B', color_conditioning=color_conditioning, conditional_size=conditional_size,\n",
        "                                         in_channels=in_channels // 2, out_channels=in_channels // 2, kernel_size=9, padding=4),\n",
        "                              nn.ReLU(),\n",
        "                              MaskedCon2d(mask_type='B', color_conditioning=color_conditioning, conditional_size=conditional_size,\n",
        "                                         in_channels=in_channels // 2, out_channels=in_channels, kernel_size=1)\n",
        "        ])\n",
        "    # self.conditional_size = conditional_size\n",
        "    # self.condition_transformation = nn.Linear(conditional_size, self.out_channels)\n",
        "\n",
        "  def forward(self, x, condition):\n",
        "    out = x\n",
        "    for l in self.net:\n",
        "      if isinstance(l, MaskedCon2d):\n",
        "        out = l(out, condition)\n",
        "      else:\n",
        "        out = l(out)\n",
        "    return out + x\n",
        "\n",
        "\n",
        "class PixelCNN_V2(nn.Module):\n",
        "\n",
        "  def __init__(self, input_shape, d, conditional_size, n_filters=128,\n",
        "               color_conditioning=False):\n",
        "    super().__init__()\n",
        "    n_channels = input_shape[0]\n",
        "    self.net = nn.ModuleList([MaskedCon2d(mask_type='A', color_conditioning=color_conditioning, conditional_size=conditional_size,\n",
        "                                          in_channels=n_channels, out_channels=n_filters, kernel_size=7, padding=7//2)])\n",
        "    for _ in range(2):\n",
        "      self.net.extend([ResidualBlock(color_conditioning, conditional_size=conditional_size, in_channels=n_filters)])\n",
        "\n",
        "    self.net.extend([nn.ReLU(),\n",
        "                  MaskedCon2d(mask_type='B', color_conditioning=color_conditioning, conditional_size=conditional_size,\n",
        "                                          in_channels=n_filters, out_channels=d * n_channels, kernel_size=1)])\n",
        "  \n",
        "    self.input_shape = input_shape\n",
        "    self.d = d\n",
        "    self.n_channels = n_channels\n",
        "    self.color_conditioning = color_conditioning\n",
        "\n",
        "\n",
        "  def forward(self, x, condition):\n",
        "    batch_size = x.shape[0]\n",
        "    out = x.float() \n",
        "    for layer in self.net:\n",
        "      if isinstance(layer, MaskedCon2d) or isinstance(layer, ResidualBlock):\n",
        "        out = layer(out, condition)\n",
        "      else:\n",
        "        out = layer(out)\n",
        "    return out.view(batch_size, self.d, *self.input_shape)\n",
        "\n",
        "  def loss(self, x, condition):\n",
        "    return F.cross_entropy(self(x, condition), x.long())\n",
        "\n",
        "  def sample(self, n, condition):\n",
        "    samples = torch.zeros(n, *self.input_shape).cuda()\n",
        "    with torch.no_grad():\n",
        "      for r in range(self.input_shape[1]):\n",
        "        for c in range(self.input_shape[2]):\n",
        "          for k in range(self.n_channels):\n",
        "            logits = self(samples, condition)[:, :, k, r, c]\n",
        "            probs = F.softmax(logits, dim=1)\n",
        "            samples[:, k, r, c] = torch.multinomial(probs, 1).squeeze(-1)\n",
        "    return samples.permute(0, 2, 3, 1).cpu().numpy()\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zhM5BTyGGKcs"
      },
      "source": [
        "def train(model, train_loader, test_loader, param):\n",
        "  n_epochs = param['epochs']\n",
        "  lr = param['lr']\n",
        "  optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n",
        "\n",
        "  t = []\n",
        "  e = [eval_loss(model, test_loader, optimizer)]\n",
        "  for i in range(n_epochs):\n",
        "    train_loss_ = train_loss(model, train_loader, optimizer)\n",
        "    t.extend(train_loss_)\n",
        "    eval_loss_ = eval_loss(model, test_loader, optimizer)\n",
        "    e.append(eval_loss_)\n",
        "  return t, e"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LPp_IuC3GdlZ"
      },
      "source": [
        "\n",
        "def train_loss(model, train_loader, optimizer):\n",
        "  model.train()\n",
        "  loss = []\n",
        "  for x, y in train_loader:\n",
        "    y = y.cuda().float()\n",
        "    x = x.cuda().contiguous()\n",
        "    l = model.loss(x, y)\n",
        "    loss.append(l.item())\n",
        "    optimizer.zero_grad()\n",
        "    l.backward()\n",
        "    optimizer.step()\n",
        "  return loss\n",
        "\n",
        "\n",
        "def eval_loss(model, test_loader, optimizer):\n",
        "  model.eval()\n",
        "  loss = 0\n",
        "  for x, y in test_loader:\n",
        "    y = y.cuda().float()\n",
        "    x = x.cuda().contiguous()\n",
        "    l = model.loss(x, y)\n",
        "    loss += l * x.shape[0]\n",
        "\n",
        "  return (loss/len(test_loader.dataset)).item()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wutvuhHTEvML"
      },
      "source": [
        "class XYDataset(data.Dataset):\n",
        "  def __init__(self, x, y):\n",
        "    super().__init__()\n",
        "    self.x = x\n",
        "    self.y = y\n",
        "\n",
        "  def __len__(self):\n",
        "    return len(self.x)\n",
        "\n",
        "  def __getitem__(self, index):\n",
        "    return self.x[index], self.y[index]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VIMqae7EGdno"
      },
      "source": [
        "def q3_d(train_data, train_labels, test_data, test_labels, image_shape, n_classes, dset_id):\n",
        "  \"\"\"\n",
        "  train_data: A (n_train, H, W, 1) numpy array of binary images with values in {0, 1}\n",
        "  train_labels: A (n_train,) numpy array of class labels\n",
        "  test_data: A (n_test, H, W, 1) numpy array of binary images with values in {0, 1}\n",
        "  test_labels: A (n_test,) numpy array of class labels\n",
        "  image_shape: (H, W), height and width\n",
        "  n_classes: number of classes (4 or 10)\n",
        "  dset_id: An identifying number of which dataset is given (1 or 2). Most likely\n",
        "           used to set different hyperparameters for different datasets\n",
        "\n",
        "  Returns\n",
        "  - a (# of training iterations,) numpy array of train_losses evaluated every minibatch\n",
        "  - a (# of epochs + 1,) numpy array of test_losses evaluated once at initialization and after each epoch\n",
        "  - a numpy array of size (100, H, C, 1) of samples with values in {0, 1}\n",
        "    where an even number of images of each class are sampled with 100 total\n",
        "  \"\"\"\n",
        "  \n",
        "  \"\"\" YOUR CODE HERE \"\"\"\n",
        "  def preprocess(data, labels, n_classes):\n",
        "    data = np.transpose(data, (0, 3, 1, 2))\n",
        "    labels_oh = np.zeros((len(labels), n_classes))\n",
        "    labels_oh[np.arange(len(labels)), labels] = 1\n",
        "    return data, labels_oh.astype(float)\n",
        "\n",
        "  train_x, train_y = preprocess(train_data, train_labels, n_classes)\n",
        "  test_x, test_y = preprocess(test_data, test_labels, n_classes)\n",
        "\n",
        "  H, W = image_shape\n",
        "  model = PixelCNN_V2((1, H, W), 2, (n_classes,), n_filters=32).cuda()\n",
        "  train_loader = data.DataLoader(XYDataset(train_x, train_y), batch_size=128, shuffle=True)\n",
        "  test_loader = data.DataLoader(XYDataset(test_x, test_y), batch_size=128)\n",
        "  train_losses, test_losses = train(model, train_loader, test_loader, \n",
        "                                           dict(epochs=10, lr=1e-3))\n",
        "  \n",
        "  to_sample_label = np.zeros((100, n_classes))\n",
        "  for i in range(n_classes):\n",
        "    to_sample_label[ (i) * (100//n_classes) : (i + 1) * (100//n_classes),i] = 1\n",
        "  \n",
        "  label_tensor = torch.FloatTensor(to_sample_label).cuda()\n",
        "  print(label_tensor)\n",
        "  sample = model.sample(100, label_tensor)\n",
        "  return train_losses, test_losses, sample"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gmyj3MDqHmxb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "4bc596cf-7a05-4ad5-899d-11bf1166434e"
      },
      "source": [
        "q3d_save_results(1, q3_d)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [1., 0., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 1., 0., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 1., 0.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.],\n",
            "        [0., 0., 0., 1.]], device='cuda:0')\n",
            "Final Test Loss: 0.0576\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UD02YxYqtm_Z",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "9319b17b-8b02-48a2-e871-8dab94a2415a"
      },
      "source": [
        "q3d_save_results(2, q3_d)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tensor([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]], device='cuda:0')\n",
            "Final Test Loss: 0.0809\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4CQZDYWXNSIf"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}