Value_Network.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zOahaUUH2_r1",
        "outputId": "9345a9a4-50c7-4b63-93da-066ae9a1b775"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Device:  cuda\n"
          ]
        }
      ],
      "source": [
        "import torchvision\n",
        "import torch\n",
        "import numpy as np\n",
        "from collections import defaultdict\n",
        "import torch.nn as nn\n",
        "from ast import Continue\n",
        "\n",
        "import pandas as pd\n",
        "from sklearn.model_selection import train_test_split\n",
        "from torchsummary import summary\n",
        "from tqdm import tqdm\n",
        "\n",
        "DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
        "print(\"Device: \", DEVICE)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IxkFAuKC3ggP"
      },
      "outputs": [],
      "source": [
        "#mnist = torchvision.datasets.MNIST(root = './data/',download=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qOOVIpUlm8Oj",
        "outputId": "687ea4f1-58b8-401f-cb1e-8db8d4af1277"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "!cp '/content/drive/MyDrive/11-785 Project/MNIST_CSV.zip' MNIST_CSV.zip"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YDSWbKbx7QMi"
      },
      "outputs": [],
      "source": [
        "# !unzip MNIST_CSV.zip"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "POb7_hvA4hFx"
      },
      "outputs": [],
      "source": [
        "n_epochs = 3\n",
        "batch_size_train = 32\n",
        "batch_size_test = 1000\n",
        "learning_rate = 0.01\n",
        "momentum = 0.5\n",
        "log_interval = 10\n",
        "random_seed = 1\n",
        "torch.backends.cudnn.enabled = False\n",
        "torch.manual_seed(random_seed)\n",
        "HYPER_GRAYSCALE = True"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "be_xMhZO5tfl"
      },
      "outputs": [],
      "source": [
        "train_set = pd.read_csv(\"mnist_train.csv\")\n",
        "test_images = pd.read_csv(\"mnist_test.csv\")\n",
        "\n",
        "train_images, val_images, train_labels, val_labels = train_test_split(train_set.iloc[:, 1:],\n",
        "                                                                     train_set.iloc[:, 0],\n",
        "                                                                     test_size=0.3)\n",
        "\n",
        "train_images.reset_index(drop=True, inplace=True)\n",
        "val_images.reset_index(drop=True, inplace=True)\n",
        "train_labels.reset_index(drop=True, inplace=True)\n",
        "val_labels.reset_index(drop=True, inplace=True)\n",
        "\n",
        "train_images = train_images.to_numpy(dtype='float32')\n",
        "train_labels = train_labels.to_numpy(dtype='float32')\n",
        "\n",
        "val_images = val_images.to_numpy(dtype='float32')\n",
        "val_labels = val_labels.to_numpy(dtype='float32')\n",
        "\n",
        "test_images = test_images.to_numpy(dtype='float32')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aoi__a7H96Pm"
      },
      "source": [
        "## Jigsaw Datasets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gC4n7TMa7Yof"
      },
      "outputs": [],
      "source": [
        "class JigsawDataset(torch.utils.data.Dataset):\n",
        "    def __init__(self, images, labels, permutations=10, img_transformer=None):\n",
        "        self.images = images\n",
        "        self.labels = labels\n",
        "        self.permutations = permutations\n",
        "\n",
        "        self.N = len(self.images)\n",
        "        self.grid_size = 3\n",
        "\n",
        "    def __retrieve_permutations(self):\n",
        "        nums = range(self.grid_size * self.grid_size)\n",
        "\n",
        "        \"\"\"\n",
        "        permutations = []\n",
        "        for i in range(self.permutations):\n",
        "            permutations.append(np.random.permutation(nums))\n",
        "        \"\"\"\n",
        "\n",
        "        return np.random.permutation(nums)\n",
        "\n",
        "    def __get_image(self, index):\n",
        "        return self.images[index]\n",
        "\n",
        "    def __get_tiles(self, index):\n",
        "        img = self.__get_image(index).reshape(28, 28)\n",
        "        tiles = np.zeros((9, 9, 9), dtype='float32')\n",
        "\n",
        "        for i in range(3):\n",
        "            for j in range(3):\n",
        "                tiles[i * 3 + j] = img[i*9:i*9+9, j*9:j*9+9]\n",
        "\n",
        "        return tiles\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        n_grids = self.grid_size ** 2\n",
        "        tiles = self.__get_tiles(index)\n",
        "\n",
        "        order = self.__retrieve_permutations()\n",
        "\n",
        "        data_index = torch.from_numpy(np.array(order))\n",
        "\n",
        "        data = [torch.from_numpy(tiles[order[t]]) for t in range(n_grids)]\n",
        "\n",
        "        item = torch.stack(data, 0)\n",
        "        return item, order, int(self.labels[index])\n",
        "\n",
        "    def __len__(self):\n",
        "        return self.N"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "nscImNp2utw9"
      },
      "outputs": [],
      "source": [
        "class JigsawDataset_State(torch.utils.data.Dataset):\n",
        "    def __init__(self, images, labels, permutations=10, img_transformer=None, img_grayscale = HYPER_GRAYSCALE):\n",
        "        self.images = images\n",
        "        self.labels = labels\n",
        "        self.permutations = permutations\n",
        "\n",
        "        self.N = len(self.images)\n",
        "        self.grid_size = 3\n",
        "        self.GRAYSCALE = HYPER_GRAYSCALE\n",
        "\n",
        "    def __retrieve_permutations(self):\n",
        "        nums = range(self.grid_size * self.grid_size)\n",
        "\n",
        "        \"\"\"\n",
        "        permutations = []\n",
        "        for i in range(self.permutations):\n",
        "            permutations.append(np.random.permutation(nums))\n",
        "        \"\"\"\n",
        "\n",
        "        return np.random.permutation(nums)\n",
        "\n",
        "    def __get_image(self, index):\n",
        "        img = self.images[index].reshape(28, 28)\n",
        "        if self.GRAYSCALE:\n",
        "          img = np.repeat(img[ np.newaxis, :, :], 3, axis=0)\n",
        "        return img\n",
        "\n",
        "    def __get_state(self, index, current_pieces, piece_list, order, tile_list):\n",
        "        img = self.__get_image(index)\n",
        "        tiles = np.zeros((9, 3, 9, 9), dtype='float32')\n",
        "\n",
        "        for i in range(3):\n",
        "          for j in range(3):\n",
        "\n",
        "            a = i * 3 + j\n",
        "            tiles[a] = img[:,i*9:i*9+9, j*9:j*9+9]\n",
        "            if a not in piece_list:\n",
        "              img[:,i*9:i*9+9, j*9:j*9+9] = 0\n",
        "\n",
        "        return img, tiles\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        n_grids = self.grid_size ** 2\n",
        "\n",
        "        current_pieces = np.random.randint(0,9)\n",
        "        current_pieces = 8\n",
        "        order = self.__retrieve_permutations()\n",
        "\n",
        "        piece_list = np.random.choice(9, current_pieces, replace=False)\n",
        "        # piece_list = [piece_list_unshuffled[x] for x in order]\n",
        "        tile_list = [i for i in order if i not in piece_list]\n",
        "\n",
        "\n",
        "        img, tiles = self.__get_state(index, current_pieces, piece_list, order, tile_list)\n",
        "\n",
        "        data_index = torch.from_numpy(np.array(order))\n",
        "\n",
        "        tiles_shuffl = [torch.from_numpy(tiles[x]) for x in tile_list]\n",
        "\n",
        "\n",
        "        return img, current_pieces, tiles, tiles_shuffl[0], tile_list[0], order, int(self.labels[index])\n",
        "\n",
        "    def __len__(self):\n",
        "        return self.N"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zEuQwsYrg8du"
      },
      "source": [
        "### Value Network Datasets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JhZ8YdkweDzO"
      },
      "outputs": [],
      "source": [
        "class ValueDataset_random_shuffle(torch.utils.data.Dataset):\n",
        "    def __init__(self, images, labels, permutations=10, img_transformer=None):\n",
        "        self.images = images\n",
        "        self.labels = labels\n",
        "        self.permutations = permutations\n",
        "\n",
        "        self.N = len(self.images)\n",
        "        self.grid_size = 3\n",
        "\n",
        "    def __retrieve_permutations(self):\n",
        "        nums = range(self.grid_size * self.grid_size)\n",
        "\n",
        "        \"\"\"\n",
        "        permutations = []\n",
        "        for i in range(self.permutations):\n",
        "            permutations.append(np.random.permutation(nums))\n",
        "        \"\"\"\n",
        "\n",
        "        return np.random.permutation(nums)\n",
        "\n",
        "    def __get_image(self, index):\n",
        "        return self.images[index]\n",
        "\n",
        "    def __get_shuffled_image(self, index, order):\n",
        "        img = self.__get_image(index).reshape(28, 28)\n",
        "        shuffle_image = np.zeros((27, 27), dtype='float32')\n",
        "\n",
        "        for i in range(3):\n",
        "            for j in range(3):\n",
        "              perm = order[i*3+j]\n",
        "              a, b = perm//3, perm % 3\n",
        "              shuffle_image[a*9:a*9+9, b*9:b*9+9] = img[i*9:i*9+9, j*9:j*9+9]\n",
        "\n",
        "        return shuffle_image\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        n_grids = self.grid_size ** 2\n",
        "\n",
        "        order = self.__retrieve_permutations()\n",
        "        item = self.__get_shuffled_image(index, order)\n",
        "\n",
        "        data_index = torch.from_numpy(np.array(order))\n",
        "        # data = [torch.from_numpy(tiles[order[t]]) for t in range(n_grids)]\n",
        "        # item = torch.stack(data, 0)\n",
        "        return item, order, int(self.labels[index])\n",
        "\n",
        "    def __len__(self):\n",
        "        return self.N"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iXZ6ORaMeBgf"
      },
      "outputs": [],
      "source": [
        "class ValueDataset(torch.utils.data.Dataset):\n",
        "    def __init__(self, images, labels, permutations=10, img_transformer=None):\n",
        "        self.images = images\n",
        "        self.labels = labels\n",
        "        self.permutations = permutations\n",
        "\n",
        "        self.N = len(self.images)\n",
        "        self.grid_size = 3\n",
        "        self.GRAYSCALE = True\n",
        "\n",
        "    def __retrieve_permutations(self):\n",
        "        nums = range(self.grid_size * self.grid_size)\n",
        "\n",
        "        return np.random.permutation(nums)\n",
        "\n",
        "    def __get_image(self, index):\n",
        "        return self.images[index]\n",
        "\n",
        "    def __get_shuffled_image(self, index,  shuffles):\n",
        "        img = self.__get_image(index).reshape(28, 28)[:27,:27]\n",
        "        shuffle_image = np.zeros((27, 27), dtype='float32')\n",
        "\n",
        "        shuff_list = np.random.choice(9, 2*shuffles, replace=False)\n",
        "        for i in range(shuffles):\n",
        "          q, w = shuff_list[i*2], shuff_list[i*2+1]\n",
        "          a, b = q//3, q % 3\n",
        "          i, j = w//3, w % 3\n",
        "          k, l = np.copy(img[a*9:a*9+9, b*9:b*9+9]) , np.copy(img[i*9:i*9+9, j*9:j*9+9])\n",
        "          img[i*9:i*9+9, j*9:j*9+9], img[a*9:a*9+9, b*9:b*9+9] =  k, l\n",
        "\n",
        "        return img\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        n_grids = self.grid_size ** 2\n",
        "        shuffles = np.random.randint(0,5)\n",
        "\n",
        "        # order = self.__retrieve_permutations()\n",
        "        item = self.__get_shuffled_image(index, shuffles)\n",
        "\n",
        "        # data_index = torch.from_numpy(np.array(order))\n",
        "        # data = [torch.from_numpy(tiles[order[t]]) for t in range(n_grids)]\n",
        "        # item = torch.stack(data, 0)\n",
        "        if self.GRAYSCALE:\n",
        "          item = np.repeat(item[ np.newaxis, :, :], 3, axis=0)\n",
        "\n",
        "        return item, torch.tensor(1 - 0.25*shuffles, dtype = torch.float32), int(self.labels[index])\n",
        "\n",
        "    def __len__(self):\n",
        "        return self.N"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aIR4ZOdCgWZa"
      },
      "source": [
        "### Test Datasets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "AZGnjAUKv-f7"
      },
      "outputs": [],
      "source": [
        "class ValueDatasetTest(torch.utils.data.Dataset):\n",
        "    def __init__(self, images, permutations=10, img_transformer=None):\n",
        "        self.images = images\n",
        "        self.permutations = permutations\n",
        "\n",
        "        self.N = len(self.images)\n",
        "        self.grid_size = 3\n",
        "        self.GRAYSCALE = True\n",
        "\n",
        "    def __retrieve_permutations(self):\n",
        "        nums = range(self.grid_size * self.grid_size)\n",
        "\n",
        "        return np.random.permutation(nums)\n",
        "\n",
        "    def __get_image(self, index):\n",
        "        return self.images[index]\n",
        "\n",
        "    def __get_shuffled_image(self, index,  shuffles):\n",
        "        img = self.__get_image(index).reshape(28, 28)[:27,:27]\n",
        "        shuffle_image = np.zeros((27, 27), dtype='float32')\n",
        "\n",
        "        shuff_list = np.random.choice(9, 2*shuffles, replace=False)\n",
        "        for i in range(shuffles):\n",
        "          q, w = shuff_list[i*2], shuff_list[i*2+1]\n",
        "          a, b = q//3, q % 3\n",
        "          i, j = w//3, w % 3\n",
        "          k, l = np.copy(img[a*9:a*9+9, b*9:b*9+9]) , np.copy(img[i*9:i*9+9, j*9:j*9+9])\n",
        "          img[i*9:i*9+9, j*9:j*9+9], img[a*9:a*9+9, b*9:b*9+9] = k, l\n",
        "\n",
        "        return img\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        n_grids = self.grid_size ** 2\n",
        "        shuffles = np.random.randint(0,5)\n",
        "\n",
        "        item = self.__get_shuffled_image(index, shuffles)\n",
        "\n",
        "\n",
        "        if self.GRAYSCALE:\n",
        "          item = np.repeat(item[ np.newaxis, :, :], 3, axis=0)\n",
        "\n",
        "        return item, torch.tensor(1 - 0.25*shuffles, dtype = torch.float32)\n",
        "\n",
        "    def __len__(self):\n",
        "        return self.N"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FlSRW7vV_On7"
      },
      "outputs": [],
      "source": [
        "class JigsawDatasetTest(torch.utils.data.Dataset):\n",
        "    def __init__(self, images, permutations=10, img_transformer=None):\n",
        "        self.images = images\n",
        "        self.permutations = permutations\n",
        "\n",
        "        self.N = len(self.images)\n",
        "        self.grid_size = 3\n",
        "\n",
        "    def __retrieve_permutations(self):\n",
        "        nums = range(self.grid_size * self.grid_size)\n",
        "\n",
        "        \"\"\"\n",
        "        permutations = []\n",
        "        for i in range(self.permutations):\n",
        "            permutations.append(np.random.permutation(nums))\n",
        "        \"\"\"\n",
        "\n",
        "        return np.random.permutation(nums)\n",
        "\n",
        "    def __get_image(self, index):\n",
        "        return self.images[index]\n",
        "\n",
        "    def __get_tiles(self, index):\n",
        "        img = self.__get_image(index).reshape(28, 28)\n",
        "        tiles = np.zeros((9, 9, 9), dtype='float32')\n",
        "\n",
        "        for i in range(3):\n",
        "            for j in range(3):\n",
        "                tiles[i * 3 + j] = img[i*9:i*9+9, j*9:j*9+9]\n",
        "\n",
        "        return tiles\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        n_grids = self.grid_size ** 2\n",
        "        tiles = self.__get_tiles(index)\n",
        "\n",
        "        order = self.__retrieve_permutations()\n",
        "\n",
        "        data_index = torch.from_numpy(np.array(order))\n",
        "\n",
        "        data = [torch.from_numpy(tiles[order[t]]) for t in range(n_grids)]\n",
        "\n",
        "        item = torch.stack(data, 0)\n",
        "        return item, order\n",
        "\n",
        "    def __len__(self):\n",
        "        return self.N"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pCbZylM9uqP8"
      },
      "outputs": [],
      "source": [
        "class JigsawDatasetTest_State(torch.utils.data.Dataset):\n",
        "    def __init__(self, images, permutations=10, img_transformer=None):\n",
        "        self.images = images\n",
        "        self.permutations = permutations\n",
        "\n",
        "        self.N = len(self.images)\n",
        "        self.grid_size = 3\n",
        "\n",
        "    def __retrieve_permutations(self):\n",
        "        nums = range(self.grid_size * self.grid_size)\n",
        "\n",
        "        \"\"\"\n",
        "        permutations = []\n",
        "        for i in range(self.permutations):\n",
        "            permutations.append(np.random.permutation(nums))\n",
        "        \"\"\"\n",
        "\n",
        "        return np.random.permutation(nums)\n",
        "\n",
        "    def __get_image(self, index):\n",
        "        return self.images[index]\n",
        "\n",
        "    def __get_tiles(self, index):\n",
        "        img = self.__get_image(index).reshape(28, 28)\n",
        "        tiles = np.zeros((9, 9, 9), dtype='float32')\n",
        "\n",
        "        for i in range(3):\n",
        "            for j in range(3):\n",
        "                tiles[i * 3 + j] = img[i*9:i*9+9, j*9:j*9+9]\n",
        "\n",
        "        return tiles\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        n_grids = self.grid_size ** 2\n",
        "        tiles = self.__get_tiles(index)\n",
        "\n",
        "        order = self.__retrieve_permutations()\n",
        "\n",
        "        data_index = torch.from_numpy(np.array(order))\n",
        "\n",
        "        data = [torch.from_numpy(tiles[order[t]]) for t in range(n_grids)]\n",
        "\n",
        "        item = torch.stack(data, 0)\n",
        "        return item, order\n",
        "\n",
        "    def __len__(self):\n",
        "        return self.N"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VK-uiBAdgdm7"
      },
      "source": [
        "# Initialize the Datasets"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9WZ_Zfxy7fK-",
        "outputId": "9c095e50-46d6-43ae-b502-3d19dff327cf"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train dataset samples = 41999, batches = 41999\n",
            "Val dataset samples = 18000, batches = 18000\n",
            "Test dataset samples = 9999, batches = 9999\n"
          ]
        }
      ],
      "source": [
        "train_data = JigsawDataset(train_images, train_labels)\n",
        "val_data = JigsawDataset(val_images, val_labels)\n",
        "test_data = JigsawDatasetTest(test_images)\n",
        "train_data_value = ValueDataset(train_images, train_labels)\n",
        "val_data_value = ValueDataset(val_images, val_labels)\n",
        "test_data_value = ValueDatasetTest(test_images)\n",
        "\n",
        "train_loader = torch.utils.data.DataLoader(\n",
        "        dataset     = train_data,\n",
        "        num_workers = 2,\n",
        "        batch_size  = 1,\n",
        "        pin_memory  = True,\n",
        "        shuffle     = True,\n",
        ")\n",
        "\n",
        "val_loader = torch.utils.data.DataLoader(\n",
        "        dataset     = val_data,\n",
        "        num_workers = 1,\n",
        "        batch_size  = 1,\n",
        "        pin_memory  = True,\n",
        "        shuffle     = False,\n",
        "    )\n",
        "\n",
        "test_loader = torch.utils.data.DataLoader(\n",
        "        dataset     = test_data,\n",
        "        num_workers = 1,\n",
        "        batch_size  = 1,\n",
        "        pin_memory  = True,\n",
        "        shuffle     = False,\n",
        "    )\n",
        "\n",
        "print(\"Train dataset samples = {}, batches = {}\".format(train_data.__len__(), len(train_loader)))\n",
        "print(\"Val dataset samples = {}, batches = {}\".format(val_data.__len__(), len(val_loader)))\n",
        "print(\"Test dataset samples = {}, batches = {}\".format(test_data.__len__(), len(test_loader)))\n",
        "\n",
        "\n",
        "train_loader_value = torch.utils.data.DataLoader(\n",
        "        dataset     = train_data_value,\n",
        "        num_workers = 2,\n",
        "        batch_size  = 32,\n",
        "        pin_memory  = True,\n",
        "        shuffle     = True,\n",
        ")\n",
        "\n",
        "val_loader_value = torch.utils.data.DataLoader(\n",
        "        dataset     = val_data_value,\n",
        "        num_workers = 2,\n",
        "        batch_size  = 32,\n",
        "        pin_memory  = True,\n",
        "        shuffle     = False,\n",
        "    )\n",
        "\n",
        "test_loader_value = torch.utils.data.DataLoader(\n",
        "        dataset     = test_data_value,\n",
        "        num_workers = 1,\n",
        "        batch_size  = 32,\n",
        "        pin_memory  = True,\n",
        "        shuffle     = False,\n",
        "    )"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "H6JLpkFB9GoO"
      },
      "outputs": [],
      "source": [
        "train_data_state = JigsawDataset_State(train_images, train_labels)\n",
        "val_data_state = JigsawDataset_State(val_images, val_labels)\n",
        "test_data_state = JigsawDatasetTest_State(test_images)\n",
        "\n",
        "train_loader_state = torch.utils.data.DataLoader(\n",
        "        dataset     = train_data_state,\n",
        "        num_workers = 2,\n",
        "        batch_size  = batch_size_train,\n",
        "        pin_memory  = True,\n",
        "        shuffle     = True,\n",
        ")\n",
        "\n",
        "val_loader_state = torch.utils.data.DataLoader(\n",
        "        dataset     = val_data_state,\n",
        "        num_workers = 1,\n",
        "        batch_size  = batch_size_train,\n",
        "        pin_memory  = True,\n",
        "        shuffle     = False,\n",
        "    )\n",
        "\n",
        "test_loader_state = torch.utils.data.DataLoader(\n",
        "        dataset     = test_data_state,\n",
        "        num_workers = 1,\n",
        "        batch_size  = batch_size_test,\n",
        "        pin_memory  = True,\n",
        "        shuffle     = False,\n",
        "    )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B_Q6JFn5-ARo"
      },
      "source": [
        "### Test the Datasets and Plot some inputs"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "c9eq7V3D8XjL",
        "outputId": "f0b98f26-6f33-4081-bae9-5bc575605cf7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[4, 7, 3, 2, 6, 0, 5, 8, 1]])\n",
            "tensor([0])\n",
            "tensor([5])\n",
            "tensor([8])\n",
            "tensor([3])\n",
            "tensor([2])\n",
            "tensor([0])\n",
            "tensor([6])\n",
            "tensor([4])\n",
            "tensor([1])\n",
            "tensor([7])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x800 with 9 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x800 with 9 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "for tiles, order, label in train_loader:\n",
        "  fig, ax = plt.subplots(nrows=3, ncols=3, figsize=(8,8))\n",
        "  fig.subplots_adjust(hspace=.2)\n",
        "\n",
        "  for i in range(3):\n",
        "      for j in range(3):\n",
        "          ax[i][j].axis('off')\n",
        "          ax[i][j].imshow(tiles[0][i * 3 + j], cmap='gray')\n",
        "  print(order)\n",
        "  print(label)\n",
        "\n",
        "  fig, ax = plt.subplots(nrows=3, ncols=3, figsize=(8,8))\n",
        "  fig.subplots_adjust(hspace=.2)\n",
        "\n",
        "  for i in range(3):\n",
        "      for j in range(3):\n",
        "          ax[i][j].axis('off')\n",
        "          print((order[0]==i * 3 + j).nonzero(as_tuple=True)[0])\n",
        "          ax[i][j].imshow(tiles[0][(order[0]==i * 3 + j).nonzero(as_tuple=True)[0].item()], cmap='gray')\n",
        "\n",
        "  break"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 465
        },
        "id": "cv2dahQ1OamZ",
        "outputId": "e700695e-ecb8-4608-cf84-cf075ad77c47"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([32, 3, 27, 27])\n",
            "tensor(0.7500)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "for img, shuffles, label in train_loader_value:\n",
        "  print(img.shape)\n",
        "  plt.imshow(img[0,0,:,:], cmap='gray')\n",
        "  print(shuffles[0])\n",
        "\n",
        "  break"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 711
        },
        "id": "Of2vuSQx9hN_",
        "outputId": "fbd7371d-429f-49a3-be94-2b5ea84cfeee"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([32, 3, 28, 28])\n",
            "torch.Size([32, 3, 9, 9])\n",
            "tensor([8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,\n",
            "        8, 8, 8, 8, 8, 8, 8, 8])\n",
            "tensor([0, 8, 8, 8, 6, 3, 6, 0, 4, 6, 4, 1, 3, 7, 2, 0, 5, 3, 3, 1, 4, 6, 7, 1,\n",
            "        2, 1, 3, 6, 4, 7, 0, 4])\n",
            "tensor([3, 5, 2, 7, 8, 4, 1, 6, 0])\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x1500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "for img, cur_pieces, tiles, tiles_shuffl, tile_list, order, label in train_loader_state:\n",
        "  fig, ax = plt.subplots( ncols=2, figsize=(15,15))\n",
        "  fig.subplots_adjust(hspace=.2)\n",
        "\n",
        "  print(img.shape)\n",
        "  print(tiles_shuffl.shape)\n",
        "  # print(cur_pieces[0])\n",
        "  ax[0].axis('off')\n",
        "  ax[0].imshow(img[0,0,:,:], cmap='gray')\n",
        "  print(cur_pieces)\n",
        "  print(tile_list)\n",
        "  print(order[0])\n",
        "  ax[1].imshow(tiles_shuffl[0,0,:,:], cmap='gray')\n",
        "\n",
        "  break"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EbSUEtvaiezt"
      },
      "source": [
        "## Value Network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xmA8xL9yc-xx"
      },
      "outputs": [],
      "source": [
        "class ValueNetwork(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "\n",
        "        self.resnet = torchvision.models.resnet18(pretrained=True)\n",
        "        self.linear = nn.Linear(1000, 16)\n",
        "        self.linear2 = nn.Linear(16, 1)\n",
        "        self.softmax = nn.Softmax()\n",
        "        self.flat = nn.Flatten()\n",
        "\n",
        "\n",
        "\n",
        "    def forward(self, x):\n",
        "\n",
        "        x = self.resnet(x)\n",
        "        x = self.linear(x)\n",
        "        x = self.linear2(x)\n",
        "        # x = self.softmax(x)\n",
        "        x = self.flat(x)\n",
        "        x = torch.squeeze(x)\n",
        "\n",
        "        return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HPoT1R-fuTc6"
      },
      "outputs": [],
      "source": [
        "# class ValueNetwork(nn.Module):\n",
        "#     def __init__(self):\n",
        "#         super().__init__()\n",
        "#         self.conv1 = nn.Conv2d(3, 28, kernel_size=(3,3), stride=1, padding=1)\n",
        "#         self.act1 = nn.ReLU()\n",
        "#         # self.drop1 = nn.Dropout(0.3)\n",
        "\n",
        "#         self.conv2 = nn.Conv2d(28, 28, kernel_size=(3,3), stride=1, padding=1)\n",
        "#         self.act2 = nn.ReLU()\n",
        "#         self.pool2 = nn.MaxPool2d(kernel_size=(2, 2))\n",
        "\n",
        "#         self.flat = nn.Flatten()\n",
        "\n",
        "#         self.fc3 = nn.Linear(128, 16)\n",
        "#         self.act3 = nn.ReLU()\n",
        "#         # self.drop3 = nn.Dropout(0.1)\n",
        "\n",
        "#         self.fc4 = nn.Linear(16, 1)\n",
        "#         self.act4 = nn.Sigmoid()\n",
        "\n",
        "#     def forward(self, x):\n",
        "#         # input 3x32x32, output 32x32x32\n",
        "#         x = self.act1(self.conv1(x))\n",
        "#         # x = self.drop1(x)\n",
        "#         # input 32x32x32, output 32x32x32\n",
        "#         x = self.act2(self.conv2(x))\n",
        "#         # input 32x32x32, output 32x16x16\n",
        "#         x = self.pool2(x)\n",
        "#         # input 32x16x16, output 8192\n",
        "#         x = self.flat(x)\n",
        "#         # input 8192, output 512\n",
        "#         x = self.act3(self.fc3(x))\n",
        "#         x = self.fc4(x)\n",
        "#         x = self.act4(x)\n",
        "#         return x"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "164y5CEXjEAi"
      },
      "source": [
        "# Model Training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9Sh-rXAHosMH"
      },
      "outputs": [],
      "source": [
        "Model_val = ValueNetwork()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "umu8TKiGlNfm"
      },
      "outputs": [],
      "source": [
        "criterion_state = torch.nn.CrossEntropyLoss()\n",
        "Model_state = JigsawModel()\n",
        "optimizer_state = torch.optim.SGD(Model_state.parameters(), lr=0.01, momentum=0.9, weight_decay=0.0001)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "y6-o3RdYx1PZ"
      },
      "outputs": [],
      "source": [
        "def train_value(model, dataloader, optimizer, criterion, iter_number):\n",
        "\n",
        "    model.train()\n",
        "    optimizer.zero_grad()\n",
        "    # Progress Bar\n",
        "    batch_bar   = tqdm(total=len(dataloader), dynamic_ncols=True, leave=False, position=0, desc='Train', ncols=5)\n",
        "\n",
        "    tot_error = 0\n",
        "    total_loss  = 0\n",
        "    error_percs = []\n",
        "    losses = []\n",
        "    for i, (images, labels, num_label) in enumerate(dataloader):\n",
        "\n",
        "        # optimizer.zero_grad() # Zero gradients\n",
        "        images, labels = images.to(DEVICE), labels.to(DEVICE)\n",
        "        # labels = torch.zeros((32,1), dtype=torch.float32)\n",
        "        with torch.cuda.amp.autocast(): # This implements mixed precision. Thats it!\n",
        "            outputs = model(images)\n",
        "            loss    = criterion(outputs, labels)\n",
        "\n",
        "        # print(outputs.shape)\n",
        "        # print(labels.shape)\n",
        "        tot_error     += float(sum((outputs - labels)**2))\n",
        "        total_loss      += float(loss.item())\n",
        "        error_perc         =100 * tot_error / (batch_size_train*(i + 1))\n",
        "        # tqdm lets you add some details so you can monitor training as you train.\n",
        "        batch_bar.set_postfix(\n",
        "            error_perc         = \"{:.04f}%\".format(100 * tot_error / (batch_size_train*(i + 1))),\n",
        "            loss        = \"{:.04f}\".format(float(total_loss / (i + 1))),\n",
        "            tot_error = tot_error,\n",
        "            iter_number = iter_number\n",
        "            # lr          = \"{:.04f}\".format(float(optimizer.param_groups[0]['lr']))\n",
        "        )\n",
        "\n",
        "        if i % 10 == 0:\n",
        "          losses.append(loss)\n",
        "          error_percs.append(error_perc)\n",
        "        # scaler.scale(loss).backward() # This is a replacement for loss.backward()\n",
        "        # scaler.step(optimizer) # This is a replacement for optimizer.step()\n",
        "        # scaler.update()\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        # for param in model.parameters():\n",
        "        #   print(param.grad.data.sum())\n",
        "\n",
        "\n",
        "        batch_bar.update() # Update tqdm bar\n",
        "\n",
        "    batch_bar.close() # You need this to close the tqdm bar\n",
        "\n",
        "    error_perc         = 100 * tot_error / (batch_size_train* len(dataloader))\n",
        "    total_loss  = float(total_loss / len(dataloader))\n",
        "\n",
        "    return error_perc, total_loss, losses, error_percs"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def validate_value(model, dataloader, criterion):\n",
        "\n",
        "    model.eval()\n",
        "    batch_bar = tqdm(total=len(dataloader), dynamic_ncols=True, position=0, leave=False, desc='Val', ncols=5)\n",
        "\n",
        "    tot_error = 0.0\n",
        "    total_loss = 0.0\n",
        "\n",
        "    for i, (images, labels, num_label) in enumerate(dataloader):\n",
        "\n",
        "        # Move images to device\n",
        "\n",
        "\n",
        "        # Get model outputs\n",
        "        with torch.inference_mode():\n",
        "          images, labels = images.to(DEVICE), labels.to(DEVICE)\n",
        "          outputs = model(images)\n",
        "          loss = criterion(outputs, labels)\n",
        "\n",
        "\n",
        "        tot_error     += float(sum((outputs - labels)**2))\n",
        "        total_loss      += float(loss.item())\n",
        "        error_perc         =100 * tot_error / (batch_size_train*(i + 1))\n",
        "\n",
        "        batch_bar.set_postfix(\n",
        "            error_perc         = \"{:.04f}%\".format(100 * tot_error / (batch_size_train*(i + 1))),\n",
        "            loss        = \"{:.04f}\".format(float(total_loss / (i + 1))),\n",
        "            tot_error = tot_error\n",
        "            # lr          = \"{:.04f}\".format(float(optimizer.param_groups[0]['lr']))\n",
        "        )\n",
        "\n",
        "        batch_bar.update()\n",
        "\n",
        "    batch_bar.close()\n",
        "    error_perc         = 100 * tot_error / (batch_size_train* len(dataloader))\n",
        "    total_loss  = float(total_loss / len(dataloader))\n",
        "    return error_perc, total_loss"
      ],
      "metadata": {
        "id": "uh8QmQACk9Ja"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2tucOphM_M4b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a1e31123-6576-427a-f91f-a787a808e1ec"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet18_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet18_Weights.DEFAULT` to get the most up-to-date weights.\n",
            "  warnings.warn(msg)\n"
          ]
        }
      ],
      "source": [
        "criterion_value = torch.nn.MSELoss()\n",
        "Model_val = ValueNetwork().to(DEVICE)\n",
        "# summary(Model_val, (3, 27, 27))\n",
        "optimizer_val = torch.optim.SGD(Model_val.parameters(), lr=0.001, momentum=0.9, weight_decay=0.0001)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Y2_Wv7DiKjZJ"
      },
      "outputs": [],
      "source": [
        "train_errors = []\n",
        "train_losses = []\n",
        "val_errors = []\n",
        "val_losses = []\n",
        "test_errors = []\n",
        "test_losses = []\n",
        "a = []\n",
        "b = []"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XJxLoHIuP51-",
        "outputId": "8e593c73-eec3-4841-9ace-ba9d2301448f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": []
        }
      ],
      "source": [
        "for i in range(11):\n",
        "  err, total_loss, losses, error_percs = train_value(Model_val, train_loader_value, optimizer_val, criterion_value, i)\n",
        "  train_errors.append(err)\n",
        "  train_losses.append(total_loss)\n",
        "  a.append(losses)\n",
        "  b += error_percs\n",
        "  torch.save({'model_state_dict':Model_val.state_dict(),\n",
        "              'optimizer_state_dict':optimizer_val.state_dict()}, '/content/drive/MyDrive/11-785 Project/Models/model_value.pth')\n",
        "  val_error, val_loss = validate_value(Model_val, val_loader_value, criterion_value)\n",
        "  val_errors.append(val_error)\n",
        "  val_losses.append(val_loss)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Training Results"
      ],
      "metadata": {
        "id": "3vyG38W3iaFj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(validate_value(Model_val, val_loader_value, criterion_value))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qzu3qqaDl1eE",
        "outputId": "f8a63639-b303-473e-c35c-117fa4043d1a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "                                                                                                      "
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(2.901614982581848, 0.029040089178148848)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(val_errors)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XKMPtIUJ-Bgc",
        "outputId": "6e7ec9bc-9519-4b08-e6d1-70477fe0e4aa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2.8552196835553136, 2.4872643932647223, 2.2019749694234205, 2.1665470060920526, 2.051487016668593, 1.9604710644097803, 2.0658194419942784, 1.8474590303756786, 1.7901631805807563, 1.744661505332425, 1.7458351841775392, 1.7073726824933058, 1.624394588413951, 1.6464488797525, 1.636039430265634, 1.5593960576444255, 1.5990722464599363, 1.538544831190384, 1.5803497043135535, 1.5517863890794676, 1.5303495162221243, 1.5418388222412043, 1.5049932532005845, 1.4647004481563823, 1.4675821280222696, 1.463381384729307, 1.4592129239220284, 1.414381028698893, 1.397715718361349, 1.4206637615969877, 1.4623172444723163, 1.4208944489580595, 1.383787328931528, 1.4259359731502685, 1.350958836240095, 1.4337450551649897, 1.440598416848515, 1.3339378777560555, 1.3726230536225263, 1.3300907093416205, 1.336803371012277, 1.2745342379498756, 1.4101082276301475, 1.356644120206312, 1.331032165218654, 1.30441839323705, 1.313134039740606, 1.3536622488894376, 1.3134708961382588, 1.2827646444248926, 1.3118763586595574]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(train_errors)"
      ],
      "metadata": {
        "id": "nfLkIm_J_euD",
        "outputId": "ada33f2b-514a-4d0a-e53c-a39cab311dfe",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[5.320916808744423, 3.1038962643641783, 2.6996521131679563, 2.58978751912906, 2.4938651000242467, 2.3739806109697468, 2.2917548129980516, 2.1713490642590187, 2.1819295808502672, 2.0960447010325276, 2.0132173956793884, 2.0456956057920657, 1.9867964184318825, 1.9067411355657244, 1.8778552306547862, 1.8311375236778498, 1.8221320453903553, 1.7871125422486211, 1.7591849787292686, 1.7216038914654128, 1.723500807795841, 1.688065034034467, 1.6579895226394095, 1.641130223529809, 1.6106221892623414, 1.5818960114218357, 1.5792026324233115, 1.5598164010588689, 1.5130468619375945, 1.531852074254727, 1.527639098397349, 1.5424039449453388, 1.5192268834423106, 1.4788599060288001, 1.5058873115945821, 1.4727084155876107, 1.4419506798354342, 1.432227413152307, 1.4531445002533716, 1.426189652341223, 1.4094234822262632, 1.4151988999835823, 1.412462737228259, 1.3885617965296115, 1.4061067194833228, 1.3677416847038502, 1.396380851392103, 1.362262432791877, 1.3826503259146137, 1.3649019971277114, 1.334846620600435]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YMgxUMz7Kj91"
      },
      "outputs": [],
      "source": [
        "# model = ValueNetwork()\n",
        "# model.load_state_dict('/content/drive/MyDrive/11-785 Project/Models/model_policy.pth')\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_1UhK2LxjDe7"
      },
      "outputs": [],
      "source": [
        "# torch.save({'model_state_dict':Model_val.state_dict(),\n",
        "#             'optimizer_state_dict':optimizer_val.state_dict()}, '/content/drive/MyDrive/11-785 Project/Models/model_value.pth')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "95ndcGEtILMo"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.plot(errors)\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Mean Squared Error (%)')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 453
        },
        "id": "xLH26A6zKObn",
        "outputId": "7a73e5a6-0bc2-473a-9c0b-ab377d1a38f0"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.plot(train_losses, label = 'Training Loss')\n",
        "plt.plot(val_losses, label = 'Validation Loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('MSE Loss')\n",
        "plt.legend()\n",
        "plt.show()"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [
        "IxQyWD50iZ6o",
        "EbSUEtvaiezt"
      ],
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}