MainCode1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard",
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {}
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# 3 - Main"
      ],
      "metadata": {
        "id": "nzCu0otFgeax"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.1"
      ],
      "metadata": {
        "id": "qOv6KPdnkPUJ"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 718,
          "referenced_widgets": [
            "6cb52c3d35fd4003a44202713bb6e1e9",
            "4ff62a04be894cbcabd9d38e21f5b111",
            "38a5b9156b4e4ee68a0c0e0d6bc24fab",
            "d09daaae4e464b06bbf11adbec3da99e",
            "c5bfb20d2d7148918edabecfade3c93e",
            "60bf6ecc1a06438495d0a10e60cb5b5f",
            "c4b23f7072ce44b388fc7a7e6b8d1bcd",
            "f796f611caf14ae9b465a3c548b94c83",
            "1502856e74de464fa9c1544c4ef59fe3",
            "855f91adb6a64e9a9ae971aae8196350",
            "fc77fa7d9f404450ab20c293a3712fe7",
            "6ec0952e26ef46f1a8c1398e971fd284",
            "cd55caecef4745af8f63f237ea0303e0",
            "f7dab4686f6b484587f546b4b8b70cf5",
            "0c1415d3feb748249eadbfbf4fc902dd",
            "f54a49e9f7454bdba737a0af9d266b82",
            "e6ed2c6570b4467d99f431e08bef2417",
            "2bb3a89cfa534817b6750b616f17e3f7",
            "38dfcd1da9d24c84b24ead0144794767",
            "472d48bc8fdd4d51a1d112811f88319a",
            "0b02ed7fd6f84169bc39ac63791079ef",
            "757faacf8c7a4c3eb0b31de0570eee69",
            "2559343a4edd45d79c6de1179abaf6ba",
            "93667346785d491c986a7f3cafc3f427",
            "dc3cac94b649419c980a53765bc5041e",
            "14b62dc7d8d045828a644f809a8a3c4f",
            "72a769a4a4c74b54812f7b4461b20548",
            "29de4eca92524f7baafaf39e473a171c",
            "56273ee818ab4446b1d8672afe1494d2",
            "4a8225b75a614de495b84605f5b39041",
            "56258fe577b647cfb85d439d419ab739",
            "87e9498d38f94e39a06b6a9e720f08f3",
            "7f7ef9259d424c45bbbe291c72c2b39b",
            "d35a7c3183404a6098081e7301da39ec",
            "2684cba5af3647beb00dd648d4b85d93",
            "57c51394a2ae406dbb05fef02d5361a0",
            "2aa3ab2528444ef9bf891f49fd5d2aaf",
            "4aa6422df1754d1eb352369d2c4711a0",
            "16d71b5044f64aa79fe0813cd9de325a",
            "d117b8c2c0604764a254dfba1e69596f",
            "4ed6e60381004419b76ae8f34e04f1b1",
            "d549b7aee5534a468de8fdc23cd5ae51",
            "344bfcfa7b4448eaab3ab2b9d319a138",
            "9210e9c12015458fbfbbbdf16de0c2e1"
          ]
        },
        "id": "kO8fHo4CiW3C",
        "outputId": "c0d01362-ca62-49b9-cd18-7b51613b6d15"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./data/MNIST/raw/train-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/9912422 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "6cb52c3d35fd4003a44202713bb6e1e9"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./data/MNIST/raw/train-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/28881 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "6ec0952e26ef46f1a8c1398e971fd284"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/1648877 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "2559343a4edd45d79c6de1179abaf6ba"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/4542 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "d35a7c3183404a6098081e7301da39ec"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "import torch\n",
        "import torchvision\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Load MNIST training dataset\n",
        "trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True)\n",
        "\n",
        "# Get labels for each image in the dataset\n",
        "labels = [trainset[i][1] for i in range(len(trainset))]\n",
        "\n",
        "# Count the number of images in each class\n",
        "counts = [labels.count(i) for i in range(10)]\n",
        "\n",
        "# Define color map for different classes\n",
        "colors = ['red', 'blue', 'green', 'purple', 'orange',\n",
        "          'brown', 'pink', 'gray', 'olive', 'cyan']\n",
        "\n",
        "# Plot the number-class graph\n",
        "plt.bar(range(10), counts, color=colors)\n",
        "\n",
        "# Add text labels for each class\n",
        "for i in range(10):\n",
        "    plt.text(i, counts[i] + 100, str(counts[i]), ha='center', fontsize=8)\n",
        "#     plt.text(i, 4000, str(i), ha='center', fontsize=12)\n",
        "\n",
        "# Set plot title, axis labels, and limits\n",
        "plt.title('Number of Images in each Class (MNIST Trainset)')\n",
        "plt.xlabel('Class')\n",
        "plt.ylabel('Number of Images')\n",
        "plt.ylim(0, 10000)\n",
        "\n",
        "# Set x-axis ticks and labels\n",
        "plt.xticks(range(10), [str(i) for i in range(10)])\n",
        "\n",
        "# Save and show plot\n",
        "plt.savefig('numberclassgraph.pdf')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torchvision\n",
        "import random\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Load MNIST training dataset\n",
        "trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True)\n",
        "\n",
        "# Get 5 random images and their labels\n",
        "indices = random.sample(range(len(trainset)), 5)\n",
        "images = [trainset[i][0] for i in indices]\n",
        "labels = [trainset[i][1] for i in indices]\n",
        "\n",
        "# Plot the images\n",
        "fig, axs = plt.subplots(1, 5, figsize=(10, 5))\n",
        "for i in range(5):\n",
        "    img = images[i]\n",
        "    if hasattr(img, 'shape'):\n",
        "        if len(img.shape) == 3 and img.shape[0] == 1:\n",
        "            img = img.squeeze(0)\n",
        "    axs[i].imshow(img, cmap='gray')\n",
        "    axs[i].axis('off')\n",
        "    axs[i].set_title(str(labels[i]))\n",
        "\n",
        "# Save and show plot\n",
        "plt.savefig('fiverand.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 143
        },
        "id": "YDKkmJoPleNB",
        "outputId": "b14736af-1537-42bc-c329-3931d0dd206f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x360 with 5 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torchvision\n",
        "import random\n",
        "import matplotlib.pyplot as plt\n",
        "import torchvision.transforms as transforms\n",
        "\n",
        "# Load MNIST training dataset\n",
        "trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True)\n",
        "\n",
        "# Calculate mean and standard deviation of the training set\n",
        "train_data = trainset.data.numpy()\n",
        "mean = train_data.mean() / 255.0\n",
        "std = train_data.std() / 255.0\n",
        "\n",
        "# Define data transformations\n",
        "transform = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean, std)\n",
        "])\n",
        "\n",
        "# Get 5 random images and their labels\n",
        "indices = random.sample(range(len(trainset)), 5)\n",
        "images = [trainset[i][0] for i in indices]\n",
        "labels = [trainset[i][1] for i in indices]\n",
        "\n",
        "# Apply the data transformation to the images\n",
        "images_normalized = [transform(img) for img in images]\n",
        "\n",
        "# Plot the images\n",
        "fig, axs = plt.subplots(1, 5, figsize=(10, 5))\n",
        "for i in range(5):\n",
        "    img = images_normalized[i].numpy().squeeze()\n",
        "    axs[i].imshow(img, cmap='gray')\n",
        "    axs[i].axis('off')\n",
        "    axs[i].set_title(str(labels[i]))\n",
        "\n",
        "# Save and show plot\n",
        "plt.savefig('fiverandnormal.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 143
        },
        "id": "oa_K58LTmfXe",
        "outputId": "ed70af06-8f24-4f10-8379-69af7371e8b2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x360 with 5 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torchvision.datasets as datasets\n",
        "\n",
        "# Load MNIST training dataset\n",
        "trainset = datasets.MNIST(root='./data', train=True, download=True)\n",
        "\n",
        "# Get the first image in the dataset\n",
        "image, label = trainset[0]\n",
        "\n",
        "# Calculate the height and width of the image\n",
        "height, width = image.size\n",
        "\n",
        "# Print the result\n",
        "print(\"Each data of MNIST has {} x {} = {} features.\".format(height, width, height*width))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KoRMdW8hnMxb",
        "outputId": "576f7961-5b5b-4749-fee6-7f1276f09844"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Each data of MNIST has 28 x 28 = 784 features.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.2"
      ],
      "metadata": {
        "id": "Us7WkTIhnifN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchvision.datasets as dsets\n",
        "import torchvision.transforms as transforms\n",
        "from torch.autograd import Variable\n",
        "\n",
        "# Hyperparameters\n",
        "num_epochs = 20\n",
        "batch_size = 128\n",
        "learning_rate = 0.0003\n",
        "\n",
        "# MNIST dataset\n",
        "train_dataset = dsets.MNIST(root='./data',\n",
        "                            train=True,\n",
        "                            transform=transforms.ToTensor(),\n",
        "                            download=True)\n",
        "\n",
        "test_dataset = dsets.MNIST(root='./data',\n",
        "                           train=False,\n",
        "                           transform=transforms.ToTensor())\n",
        "\n",
        "# Data loader\n",
        "train_loader = torch.utils.data.DataLoader(dataset=train_dataset,\n",
        "                                           batch_size=batch_size,\n",
        "                                           shuffle=True)\n",
        "\n",
        "test_loader = torch.utils.data.DataLoader(dataset=test_dataset,\n",
        "                                          batch_size=batch_size,\n",
        "                                          shuffle=False)\n",
        "\n",
        "# Autoencoder model\n",
        "class Autoencoder(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Autoencoder, self).__init__()\n",
        "        self.encoder = nn.Sequential(\n",
        "            nn.Linear(784, 500),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(500, 300),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(300, 100),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(100, 30),\n",
        "            nn.ReLU(True))\n",
        "        self.decoder = nn.Sequential(\n",
        "            nn.Linear(30, 100),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(100, 300),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(300, 500),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(500, 784),\n",
        "            nn.Sigmoid())\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.encoder(x)\n",
        "        x = self.decoder(x)\n",
        "        return x\n",
        "\n",
        "# Create autoencoder object\n",
        "autoencoder = Autoencoder()\n",
        "\n",
        "# Loss function and optimizer\n",
        "criterion = nn.MSELoss()\n",
        "optimizer = torch.optim.Adam(autoencoder.parameters(), lr=learning_rate)\n",
        "\n",
        "# Train the model\n",
        "train_loss = []\n",
        "valid_loss = []\n",
        "\n",
        "for epoch in range(num_epochs):\n",
        "    # Train\n",
        "    total_loss = 0\n",
        "    for i, (images, _) in enumerate(train_loader):\n",
        "        images = Variable(images.view(-1, 28*28))\n",
        "        optimizer.zero_grad()\n",
        "        outputs = autoencoder(images)\n",
        "        loss = criterion(outputs, images)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        total_loss += loss.item()\n",
        "\n",
        "    train_loss.append(total_loss/len(train_loader))\n",
        "\n",
        "    # Validation\n",
        "    total_loss = 0\n",
        "    for i, (images, _) in enumerate(test_loader):\n",
        "        images = Variable(images.view(-1, 28*28))\n",
        "        outputs = autoencoder(images)\n",
        "        loss = criterion(outputs, images)\n",
        "        total_loss += loss.item()\n",
        "\n",
        "    valid_loss.append(total_loss/len(test_loader))\n",
        "\n",
        "    print('Epoch [{}/{}], Train Loss: {:.4f}, Valid Loss: {:.4f}'\n",
        "          .format(epoch+1, num_epochs, train_loss[-1], valid_loss[-1]))\n",
        "\n",
        "# Save the trained model weights\n",
        "torch.save(autoencoder.state_dict(), 'autoencoder.pth')\n",
        "\n",
        "\n",
        "# Plot loss\n",
        "import matplotlib.pyplot as plt\n",
        "plt.plot(train_loss, label='Train Loss')\n",
        "plt.plot(valid_loss, label='Valid Loss')\n",
        "plt.legend()\n",
        "plt.savefig('Loss.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 634
        },
        "id": "NVkahfavFDxm",
        "outputId": "cf83792d-59c9-4e2f-a236-1b3df26e2dc5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/20], Train Loss: 0.0691, Valid Loss: 0.0520\n",
            "Epoch [2/20], Train Loss: 0.0432, Valid Loss: 0.0343\n",
            "Epoch [3/20], Train Loss: 0.0315, Valid Loss: 0.0286\n",
            "Epoch [4/20], Train Loss: 0.0271, Valid Loss: 0.0251\n",
            "Epoch [5/20], Train Loss: 0.0245, Valid Loss: 0.0230\n",
            "Epoch [6/20], Train Loss: 0.0224, Valid Loss: 0.0210\n",
            "Epoch [7/20], Train Loss: 0.0204, Valid Loss: 0.0193\n",
            "Epoch [8/20], Train Loss: 0.0191, Valid Loss: 0.0181\n",
            "Epoch [9/20], Train Loss: 0.0180, Valid Loss: 0.0172\n",
            "Epoch [10/20], Train Loss: 0.0169, Valid Loss: 0.0161\n",
            "Epoch [11/20], Train Loss: 0.0161, Valid Loss: 0.0157\n",
            "Epoch [12/20], Train Loss: 0.0155, Valid Loss: 0.0151\n",
            "Epoch [13/20], Train Loss: 0.0150, Valid Loss: 0.0147\n",
            "Epoch [14/20], Train Loss: 0.0146, Valid Loss: 0.0143\n",
            "Epoch [15/20], Train Loss: 0.0142, Valid Loss: 0.0140\n",
            "Epoch [16/20], Train Loss: 0.0139, Valid Loss: 0.0137\n",
            "Epoch [17/20], Train Loss: 0.0135, Valid Loss: 0.0133\n",
            "Epoch [18/20], Train Loss: 0.0132, Valid Loss: 0.0131\n",
            "Epoch [19/20], Train Loss: 0.0129, Valid Loss: 0.0127\n",
            "Epoch [20/20], Train Loss: 0.0125, Valid Loss: 0.0125\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.3"
      ],
      "metadata": {
        "id": "TMgOCCKCUILj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchvision.datasets as dsets\n",
        "import torchvision.transforms as transforms\n",
        "from torch.autograd import Variable\n",
        "from sklearn.metrics import confusion_matrix, f1_score, precision_score, recall_score\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Hyperparameters\n",
        "num_epochs = 20\n",
        "batch_size = 128\n",
        "learning_rate = 0.0003\n",
        "\n",
        "# MNIST dataset\n",
        "train_dataset = dsets.MNIST(root='./data',\n",
        "                            train=True,\n",
        "                            transform=transforms.ToTensor(),\n",
        "                            download=True)\n",
        "\n",
        "test_dataset = dsets.MNIST(root='./data',\n",
        "                           train=False,\n",
        "                           transform=transforms.ToTensor())\n",
        "\n",
        "# Data loader\n",
        "train_loader = torch.utils.data.DataLoader(dataset=train_dataset,\n",
        "                                           batch_size=batch_size,\n",
        "                                           shuffle=True)\n",
        "\n",
        "test_loader = torch.utils.data.DataLoader(dataset=test_dataset,\n",
        "                                          batch_size=batch_size,\n",
        "                                          shuffle=False)\n",
        "\n",
        "# Autoencoder model\n",
        "class Autoencoder(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Autoencoder, self).__init__()\n",
        "        self.encoder = nn.Sequential(\n",
        "            nn.Linear(784, 500),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(500, 300),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(300, 100),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(100, 30),\n",
        "            nn.ReLU(True))\n",
        "        self.decoder = nn.Sequential(\n",
        "            nn.Linear(30, 100),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(100, 300),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(300, 500),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(500, 784),\n",
        "            nn.Sigmoid())\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.encoder(x)\n",
        "        x = self.decoder(x)\n",
        "        return x\n",
        "\n",
        "# Create autoencoder object and load trained parameters\n",
        "autoencoder = Autoencoder()\n",
        "autoencoder.load_state_dict(torch.load('autoencoder.pth'))\n",
        "encoder = autoencoder.encoder\n",
        "\n",
        "# Classifier model\n",
        "class Classifier(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Classifier, self).__init__()\n",
        "        self.layer1 = nn.Linear(30, 256)\n",
        "        self.layer2 = nn.Linear(256, 128)\n",
        "        self.layer3 = nn.Linear(128, 10)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.layer1(x)\n",
        "        x = nn.functional.relu(x)\n",
        "        x = self.layer2(x)\n",
        "        x = nn.functional.relu(x)\n",
        "        x = self.layer3(x)\n",
        "        return x\n",
        "\n",
        "# Create classifier object\n",
        "classifier = Classifier()\n",
        "\n",
        "# Loss function and optimizer\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.Adam(classifier.parameters(), lr=learning_rate)\n",
        "\n",
        "# Train the model\n",
        "train_loss = []\n",
        "valid_loss = []\n",
        "train_acc = []\n",
        "valid_acc = []\n",
        "\n",
        "for epoch in range(num_epochs):\n",
        "    # Train\n",
        "    total_loss = 0\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    for images, labels in train_loader:\n",
        "        images = Variable(images.view(-1, 28*28))\n",
        "        labels = Variable(labels)\n",
        "        features = encoder(images)\n",
        "        outputs = classifier(features)\n",
        "        loss = criterion(outputs, labels)\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        total_loss += loss.item()\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        correct += (predicted == labels).sum().item()\n",
        "        total += labels.size(0)\n",
        "\n",
        "    train_loss.append(total_loss/len(train_loader))\n",
        "    train_acc.append(correct/total)\n",
        "\n",
        "    # Validation\n",
        "    total_loss = 0\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    with torch.no_grad():\n",
        "        for images, labels in test_loader:\n",
        "            images = Variable(images.view(-1, 28*28))\n",
        "            labels = Variable(labels)\n",
        "            features = encoder(images)\n",
        "            outputs = classifier(features)\n",
        "            loss = criterion(outputs, labels)\n",
        "            total_loss += loss.item()\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "            total += labels.size(0)\n",
        "\n",
        "    valid_loss.append(total_loss/len(test_loader))\n",
        "    valid_acc.append(correct/total)\n",
        "\n",
        "    # Print statistics\n",
        "    print ('Epoch [{}/{}], Train Loss: {:.4f}, Valid Loss: {:.4f}, Train Acc: {:.4f}, Valid Acc: {:.4f}'\n",
        "           .format(epoch+1, num_epochs, train_loss[-1], valid_loss[-1], train_acc[-1], valid_acc[-1]))\n",
        "\n",
        "# Save the trained model weights\n",
        "torch.save(classifier.state_dict(), 'classifier.pth')\n",
        "\n",
        "# Plot loss and accuracy\n",
        "plt.figure(figsize=(10, 5))\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(train_loss, label='Train')\n",
        "plt.plot(valid_loss, label='Validation')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(train_acc, label='Train')\n",
        "plt.plot(valid_acc, label='Validation')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.savefig('LossAccur2.pdf')\n",
        "plt.show()\n",
        "\n",
        "# Evaluate the model\n",
        "y_true = []\n",
        "y_pred = []\n",
        "with torch.no_grad():\n",
        "    for images, labels in test_loader:\n",
        "        images = Variable(images.view(-1, 28*28))\n",
        "        labels = labels.numpy().tolist()\n",
        "        features = encoder(images)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        predicted = predicted.numpy().tolist()\n",
        "        y_true.extend(labels)\n",
        "        y_pred.extend(predicted)\n",
        "\n",
        "# Plot confusion matrix\n",
        "cm = confusion_matrix(y_true, y_pred)\n",
        "plt.figure(figsize=(10, 10))\n",
        "sns.heatmap(cm, annot=True, fmt='g')\n",
        "plt.xlabel('Predicted')\n",
        "plt.ylabel('Actual')\n",
        "plt.savefig('conf.pdf')\n",
        "plt.show()\n",
        "\n",
        "# Report metrics\n",
        "f1 = f1_score(y_true, y_pred, average='weighted')\n",
        "precision = precision_score(y_true, y_pred, average='weighted')\n",
        "recall = recall_score(y_true, y_pred, average='weighted')\n",
        "print('F1 Score:', f1)\n",
        "print('Precision:', precision)\n",
        "print('Recall:', recall)\n",
        "\n",
        "   \n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "TehxNmwRHnuw",
        "outputId": "570513e1-f386-494d-e5c8-1e0b455c7940"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/20], Train Loss: 0.5192, Valid Loss: 0.2528, Train Acc: 0.8578, Valid Acc: 0.9220\n",
            "Epoch [2/20], Train Loss: 0.2342, Valid Loss: 0.1974, Train Acc: 0.9282, Valid Acc: 0.9392\n",
            "Epoch [3/20], Train Loss: 0.1941, Valid Loss: 0.1733, Train Acc: 0.9408, Valid Acc: 0.9472\n",
            "Epoch [4/20], Train Loss: 0.1704, Valid Loss: 0.1598, Train Acc: 0.9482, Valid Acc: 0.9507\n",
            "Epoch [5/20], Train Loss: 0.1571, Valid Loss: 0.1454, Train Acc: 0.9509, Valid Acc: 0.9547\n",
            "Epoch [6/20], Train Loss: 0.1447, Valid Loss: 0.1384, Train Acc: 0.9548, Valid Acc: 0.9564\n",
            "Epoch [7/20], Train Loss: 0.1378, Valid Loss: 0.1295, Train Acc: 0.9574, Valid Acc: 0.9591\n",
            "Epoch [8/20], Train Loss: 0.1295, Valid Loss: 0.1292, Train Acc: 0.9594, Valid Acc: 0.9590\n",
            "Epoch [9/20], Train Loss: 0.1247, Valid Loss: 0.1256, Train Acc: 0.9610, Valid Acc: 0.9600\n",
            "Epoch [10/20], Train Loss: 0.1189, Valid Loss: 0.1200, Train Acc: 0.9625, Valid Acc: 0.9607\n",
            "Epoch [11/20], Train Loss: 0.1152, Valid Loss: 0.1140, Train Acc: 0.9634, Valid Acc: 0.9631\n",
            "Epoch [12/20], Train Loss: 0.1106, Valid Loss: 0.1121, Train Acc: 0.9652, Valid Acc: 0.9642\n",
            "Epoch [13/20], Train Loss: 0.1067, Valid Loss: 0.1130, Train Acc: 0.9659, Valid Acc: 0.9645\n",
            "Epoch [14/20], Train Loss: 0.1038, Valid Loss: 0.1092, Train Acc: 0.9673, Valid Acc: 0.9639\n",
            "Epoch [15/20], Train Loss: 0.1014, Valid Loss: 0.1065, Train Acc: 0.9679, Valid Acc: 0.9659\n",
            "Epoch [16/20], Train Loss: 0.0970, Valid Loss: 0.1023, Train Acc: 0.9692, Valid Acc: 0.9664\n",
            "Epoch [17/20], Train Loss: 0.0960, Valid Loss: 0.1024, Train Acc: 0.9695, Valid Acc: 0.9673\n",
            "Epoch [18/20], Train Loss: 0.0938, Valid Loss: 0.0957, Train Acc: 0.9701, Valid Acc: 0.9688\n",
            "Epoch [19/20], Train Loss: 0.0917, Valid Loss: 0.0983, Train Acc: 0.9704, Valid Acc: 0.9684\n",
            "Epoch [20/20], Train Loss: 0.0892, Valid Loss: 0.0928, Train Acc: 0.9711, Valid Acc: 0.9701\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x360 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x720 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "F1 Score: 0.9700930692196958\n",
            "Precision: 0.9701794432716815\n",
            "Recall: 0.9701\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "import requests\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "\n",
        "# Define a function to predict the class of an input image\n",
        "def predict_image(image_path, encoder, classifier):\n",
        "    # Open and preprocess the image\n",
        "    img = Image.open(image_path).convert('L')\n",
        "    img = img.resize((28, 28))\n",
        "    img_tensor = transforms.ToTensor()(img)\n",
        "    img_tensor = img_tensor.view(-1, 28*28)\n",
        "    # Pass the image through the encoder and classifier\n",
        "    with torch.no_grad():\n",
        "        features = encoder(img_tensor)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "    # Return the predicted class\n",
        "    return predicted.item()\n",
        "\n",
        "# Upload an image and predict its class\n",
        "from google.colab import files\n",
        "\n",
        "# Upload the image\n",
        "uploaded = files.upload()\n",
        "\n",
        "# Predict the class\n",
        "image_path = next(iter(uploaded))\n",
        "predicted_class = predict_image(io.BytesIO(uploaded[image_path]), encoder, classifier)\n",
        "\n",
        "# Print the predicted class\n",
        "print('Predicted class:', predicted_class)\n",
        "\n",
        "# Open the uploaded image\n",
        "img = Image.open(io.BytesIO(uploaded[image_path]))\n",
        "\n",
        "# Create a figure with the image and the predicted class as the title\n",
        "fig, ax = plt.subplots()\n",
        "ax.imshow(img)\n",
        "ax.set_title('Predicted Class: {}'.format(predicted_class))\n",
        "\n",
        "# Save the plot as a pdf\n",
        "plt.savefig('prediction0.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        },
        "id": "73DODOJeSOPb",
        "outputId": "990bd571-5073-491a-f4ab-1f7911461cd6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-1bb79094-c7f5-405a-ac30-762d20a7c1dd\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-1bb79094-c7f5-405a-ac30-762d20a7c1dd\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving test_image.jpg to test_image (37).jpg\n",
            "Predicted class: 0\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "import requests\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "\n",
        "# Define a function to predict the class of an input image\n",
        "def predict_image(image_path, encoder, classifier):\n",
        "    # Open and preprocess the image\n",
        "    img = Image.open(image_path).convert('L')\n",
        "    img = img.resize((28, 28))\n",
        "    img_tensor = transforms.ToTensor()(img)\n",
        "    img_tensor = img_tensor.view(-1, 28*28)\n",
        "    # Pass the image through the encoder and classifier\n",
        "    with torch.no_grad():\n",
        "        features = encoder(img_tensor)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "    # Return the predicted class\n",
        "    return predicted.item()\n",
        "\n",
        "# Upload an image and predict its class\n",
        "from google.colab import files\n",
        "\n",
        "# Upload the image\n",
        "uploaded = files.upload()\n",
        "\n",
        "# Predict the class\n",
        "image_path = next(iter(uploaded))\n",
        "predicted_class = predict_image(io.BytesIO(uploaded[image_path]), encoder, classifier)\n",
        "\n",
        "# Print the predicted class\n",
        "print('Predicted class:', predicted_class)\n",
        "\n",
        "# Open the uploaded image\n",
        "img = Image.open(io.BytesIO(uploaded[image_path]))\n",
        "\n",
        "# Create a figure with the image and the predicted class as the title\n",
        "fig, ax = plt.subplots()\n",
        "ax.imshow(img)\n",
        "ax.set_title('Predicted Class: {}'.format(predicted_class))\n",
        "\n",
        "# Save the plot as a pdf\n",
        "plt.savefig('prediction1.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        },
        "id": "FUCzaeYoPVaK",
        "outputId": "a096aeb9-5df1-4533-d96c-4608ef5f4df6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-8b398eac-0918-4915-b40b-b9d05197ab57\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-8b398eac-0918-4915-b40b-b9d05197ab57\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving test_image.jpg to test_image (6).jpg\n",
            "Predicted class: 1\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "import requests\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "\n",
        "# Define a function to predict the class of an input image\n",
        "def predict_image(image_path, encoder, classifier):\n",
        "    # Open and preprocess the image\n",
        "    img = Image.open(image_path).convert('L')\n",
        "    img = img.resize((28, 28))\n",
        "    img_tensor = transforms.ToTensor()(img)\n",
        "    img_tensor = img_tensor.view(-1, 28*28)\n",
        "    # Pass the image through the encoder and classifier\n",
        "    with torch.no_grad():\n",
        "        features = encoder(img_tensor)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "    # Return the predicted class\n",
        "    return predicted.item()\n",
        "\n",
        "# Upload an image and predict its class\n",
        "from google.colab import files\n",
        "\n",
        "# Upload the image\n",
        "uploaded = files.upload()\n",
        "\n",
        "# Predict the class\n",
        "image_path = next(iter(uploaded))\n",
        "predicted_class = predict_image(io.BytesIO(uploaded[image_path]), encoder, classifier)\n",
        "\n",
        "# Print the predicted class\n",
        "print('Predicted class:', predicted_class)\n",
        "\n",
        "# Open the uploaded image\n",
        "img = Image.open(io.BytesIO(uploaded[image_path]))\n",
        "\n",
        "# Create a figure with the image and the predicted class as the title\n",
        "fig, ax = plt.subplots()\n",
        "ax.imshow(img)\n",
        "ax.set_title('Predicted Class: {}'.format(predicted_class))\n",
        "\n",
        "# Save the plot as a pdf\n",
        "plt.savefig('prediction2.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        },
        "id": "60AsPVS3PNsb",
        "outputId": "6b93f09f-3dde-4d84-88e5-4906a1696d06"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-0a1d0419-ba24-4926-aa6f-afa6581d376b\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-0a1d0419-ba24-4926-aa6f-afa6581d376b\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving test_image.jpg to test_image (7).jpg\n",
            "Predicted class: 2\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "import requests\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "\n",
        "# Define a function to predict the class of an input image\n",
        "def predict_image(image_path, encoder, classifier):\n",
        "    # Open and preprocess the image\n",
        "    img = Image.open(image_path).convert('L')\n",
        "    img = img.resize((28, 28))\n",
        "    img_tensor = transforms.ToTensor()(img)\n",
        "    img_tensor = img_tensor.view(-1, 28*28)\n",
        "    # Pass the image through the encoder and classifier\n",
        "    with torch.no_grad():\n",
        "        features = encoder(img_tensor)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "    # Return the predicted class\n",
        "    return predicted.item()\n",
        "\n",
        "# Upload an image and predict its class\n",
        "from google.colab import files\n",
        "\n",
        "# Upload the image\n",
        "uploaded = files.upload()\n",
        "\n",
        "# Predict the class\n",
        "image_path = next(iter(uploaded))\n",
        "predicted_class = predict_image(io.BytesIO(uploaded[image_path]), encoder, classifier)\n",
        "\n",
        "# Print the predicted class\n",
        "print('Predicted class:', predicted_class)\n",
        "\n",
        "# Open the uploaded image\n",
        "img = Image.open(io.BytesIO(uploaded[image_path]))\n",
        "\n",
        "# Create a figure with the image and the predicted class as the title\n",
        "fig, ax = plt.subplots()\n",
        "ax.imshow(img)\n",
        "ax.set_title('Predicted Class: {}'.format(predicted_class))\n",
        "\n",
        "# Save the plot as a pdf\n",
        "plt.savefig('prediction3.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        },
        "id": "bAV-8SrmNbM2",
        "outputId": "f7573ebc-9c4a-4823-a604-1cf459af4bc4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-00feaddf-961b-4094-9588-e72f33b7ad68\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-00feaddf-961b-4094-9588-e72f33b7ad68\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving test_image.jpg to test_image (14).jpg\n",
            "Predicted class: 3\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "import requests\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "\n",
        "# Define a function to predict the class of an input image\n",
        "def predict_image(image_path, encoder, classifier):\n",
        "    # Open and preprocess the image\n",
        "    img = Image.open(image_path).convert('L')\n",
        "    img = img.resize((28, 28))\n",
        "    img_tensor = transforms.ToTensor()(img)\n",
        "    img_tensor = img_tensor.view(-1, 28*28)\n",
        "    # Pass the image through the encoder and classifier\n",
        "    with torch.no_grad():\n",
        "        features = encoder(img_tensor)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "    # Return the predicted class\n",
        "    return predicted.item()\n",
        "\n",
        "# Upload an image and predict its class\n",
        "from google.colab import files\n",
        "\n",
        "# Upload the image\n",
        "uploaded = files.upload()\n",
        "\n",
        "# Predict the class\n",
        "image_path = next(iter(uploaded))\n",
        "predicted_class = predict_image(io.BytesIO(uploaded[image_path]), encoder, classifier)\n",
        "\n",
        "# Print the predicted class\n",
        "print('Predicted class:', predicted_class)\n",
        "\n",
        "# Open the uploaded image\n",
        "img = Image.open(io.BytesIO(uploaded[image_path]))\n",
        "\n",
        "# Create a figure with the image and the predicted class as the title\n",
        "fig, ax = plt.subplots()\n",
        "ax.imshow(img)\n",
        "ax.set_title('Predicted Class: {}'.format(predicted_class))\n",
        "\n",
        "# Save the plot as a pdf\n",
        "plt.savefig('prediction4.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        },
        "id": "GErlJlChP1vi",
        "outputId": "fccd079e-fdd7-4392-ae8c-19b9931d4818"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-e7c5bb30-d423-4958-925c-f7119d12a08a\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-e7c5bb30-d423-4958-925c-f7119d12a08a\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving test_image.jpg to test_image (17).jpg\n",
            "Predicted class: 4\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "import requests\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "\n",
        "# Define a function to predict the class of an input image\n",
        "def predict_image(image_path, encoder, classifier):\n",
        "    # Open and preprocess the image\n",
        "    img = Image.open(image_path).convert('L')\n",
        "    img = img.resize((28, 28))\n",
        "    img_tensor = transforms.ToTensor()(img)\n",
        "    img_tensor = img_tensor.view(-1, 28*28)\n",
        "    # Pass the image through the encoder and classifier\n",
        "    with torch.no_grad():\n",
        "        features = encoder(img_tensor)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "    # Return the predicted class\n",
        "    return predicted.item()\n",
        "\n",
        "# Upload an image and predict its class\n",
        "from google.colab import files\n",
        "\n",
        "# Upload the image\n",
        "uploaded = files.upload()\n",
        "\n",
        "# Predict the class\n",
        "image_path = next(iter(uploaded))\n",
        "predicted_class = predict_image(io.BytesIO(uploaded[image_path]), encoder, classifier)\n",
        "\n",
        "# Print the predicted class\n",
        "print('Predicted class:', predicted_class)\n",
        "\n",
        "# Open the uploaded image\n",
        "img = Image.open(io.BytesIO(uploaded[image_path]))\n",
        "\n",
        "# Create a figure with the image and the predicted class as the title\n",
        "fig, ax = plt.subplots()\n",
        "ax.imshow(img)\n",
        "ax.set_title('Predicted Class: {}'.format(predicted_class))\n",
        "\n",
        "# Save the plot as a pdf\n",
        "plt.savefig('prediction5.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        },
        "id": "JsGYmUeeQvpu",
        "outputId": "69f985b5-e31d-4ad3-85d7-7e4e0856fee6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-6dae56a9-8c2c-4f7b-9734-fc19d118d47e\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-6dae56a9-8c2c-4f7b-9734-fc19d118d47e\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving test_image.jpg to test_image (22).jpg\n",
            "Predicted class: 5\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "import requests\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "\n",
        "# Define a function to predict the class of an input image\n",
        "def predict_image(image_path, encoder, classifier):\n",
        "    # Open and preprocess the image\n",
        "    img = Image.open(image_path).convert('L')\n",
        "    img = img.resize((28, 28))\n",
        "    img_tensor = transforms.ToTensor()(img)\n",
        "    img_tensor = img_tensor.view(-1, 28*28)\n",
        "    # Pass the image through the encoder and classifier\n",
        "    with torch.no_grad():\n",
        "        features = encoder(img_tensor)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "    # Return the predicted class\n",
        "    return predicted.item()\n",
        "\n",
        "# Upload an image and predict its class\n",
        "from google.colab import files\n",
        "\n",
        "# Upload the image\n",
        "uploaded = files.upload()\n",
        "\n",
        "# Predict the class\n",
        "image_path = next(iter(uploaded))\n",
        "predicted_class = predict_image(io.BytesIO(uploaded[image_path]), encoder, classifier)\n",
        "\n",
        "# Print the predicted class\n",
        "print('Predicted class:', predicted_class)\n",
        "\n",
        "# Open the uploaded image\n",
        "img = Image.open(io.BytesIO(uploaded[image_path]))\n",
        "\n",
        "# Create a figure with the image and the predicted class as the title\n",
        "fig, ax = plt.subplots()\n",
        "ax.imshow(img)\n",
        "ax.set_title('Predicted Class: {}'.format(predicted_class))\n",
        "\n",
        "# Save the plot as a pdf\n",
        "plt.savefig('prediction6.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        },
        "id": "5HVpu-SSRHvD",
        "outputId": "1e546b61-5dee-4838-9b4d-b227cb0a4753"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-bf254700-ec5b-48d5-b58f-fdf957490b68\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-bf254700-ec5b-48d5-b58f-fdf957490b68\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving test_image.jpg to test_image (23).jpg\n",
            "Predicted class: 6\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "import requests\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "\n",
        "# Define a function to predict the class of an input image\n",
        "def predict_image(image_path, encoder, classifier):\n",
        "    # Open and preprocess the image\n",
        "    img = Image.open(image_path).convert('L')\n",
        "    img = img.resize((28, 28))\n",
        "    img_tensor = transforms.ToTensor()(img)\n",
        "    img_tensor = img_tensor.view(-1, 28*28)\n",
        "    # Pass the image through the encoder and classifier\n",
        "    with torch.no_grad():\n",
        "        features = encoder(img_tensor)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "    # Return the predicted class\n",
        "    return predicted.item()\n",
        "\n",
        "# Upload an image and predict its class\n",
        "from google.colab import files\n",
        "\n",
        "# Upload the image\n",
        "uploaded = files.upload()\n",
        "\n",
        "# Predict the class\n",
        "image_path = next(iter(uploaded))\n",
        "predicted_class = predict_image(io.BytesIO(uploaded[image_path]), encoder, classifier)\n",
        "\n",
        "# Print the predicted class\n",
        "print('Predicted class:', predicted_class)\n",
        "\n",
        "# Open the uploaded image\n",
        "img = Image.open(io.BytesIO(uploaded[image_path]))\n",
        "\n",
        "# Create a figure with the image and the predicted class as the title\n",
        "fig, ax = plt.subplots()\n",
        "ax.imshow(img)\n",
        "ax.set_title('Predicted Class: {}'.format(predicted_class))\n",
        "\n",
        "# Save the plot as a pdf\n",
        "plt.savefig('prediction7.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        },
        "id": "MKgpWA8bRNHH",
        "outputId": "21e91e58-b95c-4db9-ac8c-1ae7c8abb7ad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-d7d85618-01b3-4d8e-b78d-4edf7bd7c2bf\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-d7d85618-01b3-4d8e-b78d-4edf7bd7c2bf\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving test_image.jpg to test_image (29).jpg\n",
            "Predicted class: 7\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "import requests\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "\n",
        "# Define a function to predict the class of an input image\n",
        "def predict_image(image_path, encoder, classifier):\n",
        "    # Open and preprocess the image\n",
        "    img = Image.open(image_path).convert('L')\n",
        "    img = img.resize((28, 28))\n",
        "    img_tensor = transforms.ToTensor()(img)\n",
        "    img_tensor = img_tensor.view(-1, 28*28)\n",
        "    # Pass the image through the encoder and classifier\n",
        "    with torch.no_grad():\n",
        "        features = encoder(img_tensor)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "    # Return the predicted class\n",
        "    return predicted.item()\n",
        "\n",
        "# Upload an image and predict its class\n",
        "from google.colab import files\n",
        "\n",
        "# Upload the image\n",
        "uploaded = files.upload()\n",
        "\n",
        "# Predict the class\n",
        "image_path = next(iter(uploaded))\n",
        "predicted_class = predict_image(io.BytesIO(uploaded[image_path]), encoder, classifier)\n",
        "\n",
        "# Print the predicted class\n",
        "print('Predicted class:', predicted_class)\n",
        "\n",
        "# Open the uploaded image\n",
        "img = Image.open(io.BytesIO(uploaded[image_path]))\n",
        "\n",
        "# Create a figure with the image and the predicted class as the title\n",
        "fig, ax = plt.subplots()\n",
        "ax.imshow(img)\n",
        "ax.set_title('Predicted Class: {}'.format(predicted_class))\n",
        "\n",
        "# Save the plot as a pdf\n",
        "plt.savefig('prediction8.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        },
        "id": "-Ft-epj9R5IH",
        "outputId": "68c6c04b-0cc5-4a70-c26f-8e152f4450e7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-e5b1f918-f510-4586-ac05-a21f4aff5528\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-e5b1f918-f510-4586-ac05-a21f4aff5528\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving test_image.jpg to test_image (31).jpg\n",
            "Predicted class: 8\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "import requests\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "\n",
        "# Define a function to predict the class of an input image\n",
        "def predict_image(image_path, encoder, classifier):\n",
        "    # Open and preprocess the image\n",
        "    img = Image.open(image_path).convert('L')\n",
        "    img = img.resize((28, 28))\n",
        "    img_tensor = transforms.ToTensor()(img)\n",
        "    img_tensor = img_tensor.view(-1, 28*28)\n",
        "    # Pass the image through the encoder and classifier\n",
        "    with torch.no_grad():\n",
        "        features = encoder(img_tensor)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "    # Return the predicted class\n",
        "    return predicted.item()\n",
        "\n",
        "# Upload an image and predict its class\n",
        "from google.colab import files\n",
        "\n",
        "# Upload the image\n",
        "uploaded = files.upload()\n",
        "\n",
        "# Predict the class\n",
        "image_path = next(iter(uploaded))\n",
        "predicted_class = predict_image(io.BytesIO(uploaded[image_path]), encoder, classifier)\n",
        "\n",
        "# Print the predicted class\n",
        "print('Predicted class:', predicted_class)\n",
        "\n",
        "# Open the uploaded image\n",
        "img = Image.open(io.BytesIO(uploaded[image_path]))\n",
        "\n",
        "# Create a figure with the image and the predicted class as the title\n",
        "fig, ax = plt.subplots()\n",
        "ax.imshow(img)\n",
        "ax.set_title('Predicted Class: {}'.format(predicted_class))\n",
        "\n",
        "# Save the plot as a pdf\n",
        "plt.savefig('prediction9.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        },
        "id": "CdIZekfSSGnL",
        "outputId": "72577b66-3145-409d-d6d6-ba74696817dd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-fa25ca2f-b4ef-4015-a5d7-7b899653c598\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-fa25ca2f-b4ef-4015-a5d7-7b899653c598\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving test_image (32).jpg to test_image (32) (1).jpg\n",
            "Predicted class: 9\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 3 - Main"
      ],
      "metadata": {
        "id": "ohweqaCsgl8I"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.1"
      ],
      "metadata": {
        "id": "eTIYt03Bgl8I"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 718,
          "referenced_widgets": [
            "6cb52c3d35fd4003a44202713bb6e1e9",
            "4ff62a04be894cbcabd9d38e21f5b111",
            "38a5b9156b4e4ee68a0c0e0d6bc24fab",
            "d09daaae4e464b06bbf11adbec3da99e",
            "c5bfb20d2d7148918edabecfade3c93e",
            "60bf6ecc1a06438495d0a10e60cb5b5f",
            "c4b23f7072ce44b388fc7a7e6b8d1bcd",
            "f796f611caf14ae9b465a3c548b94c83",
            "1502856e74de464fa9c1544c4ef59fe3",
            "855f91adb6a64e9a9ae971aae8196350",
            "fc77fa7d9f404450ab20c293a3712fe7",
            "6ec0952e26ef46f1a8c1398e971fd284",
            "cd55caecef4745af8f63f237ea0303e0",
            "f7dab4686f6b484587f546b4b8b70cf5",
            "0c1415d3feb748249eadbfbf4fc902dd",
            "f54a49e9f7454bdba737a0af9d266b82",
            "e6ed2c6570b4467d99f431e08bef2417",
            "2bb3a89cfa534817b6750b616f17e3f7",
            "38dfcd1da9d24c84b24ead0144794767",
            "472d48bc8fdd4d51a1d112811f88319a",
            "0b02ed7fd6f84169bc39ac63791079ef",
            "757faacf8c7a4c3eb0b31de0570eee69",
            "2559343a4edd45d79c6de1179abaf6ba",
            "93667346785d491c986a7f3cafc3f427",
            "dc3cac94b649419c980a53765bc5041e",
            "14b62dc7d8d045828a644f809a8a3c4f",
            "72a769a4a4c74b54812f7b4461b20548",
            "29de4eca92524f7baafaf39e473a171c",
            "56273ee818ab4446b1d8672afe1494d2",
            "4a8225b75a614de495b84605f5b39041",
            "56258fe577b647cfb85d439d419ab739",
            "87e9498d38f94e39a06b6a9e720f08f3",
            "7f7ef9259d424c45bbbe291c72c2b39b",
            "d35a7c3183404a6098081e7301da39ec",
            "2684cba5af3647beb00dd648d4b85d93",
            "57c51394a2ae406dbb05fef02d5361a0",
            "2aa3ab2528444ef9bf891f49fd5d2aaf",
            "4aa6422df1754d1eb352369d2c4711a0",
            "16d71b5044f64aa79fe0813cd9de325a",
            "d117b8c2c0604764a254dfba1e69596f",
            "4ed6e60381004419b76ae8f34e04f1b1",
            "d549b7aee5534a468de8fdc23cd5ae51",
            "344bfcfa7b4448eaab3ab2b9d319a138",
            "9210e9c12015458fbfbbbdf16de0c2e1"
          ]
        },
        "outputId": "c0d01362-ca62-49b9-cd18-7b51613b6d15",
        "id": "f0N0kNaVgl8J"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./data/MNIST/raw/train-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/9912422 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "6cb52c3d35fd4003a44202713bb6e1e9"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./data/MNIST/raw/train-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/28881 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "6ec0952e26ef46f1a8c1398e971fd284"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/1648877 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "2559343a4edd45d79c6de1179abaf6ba"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw\n",
            "\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
            "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/4542 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "d35a7c3183404a6098081e7301da39ec"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "import torch\n",
        "import torchvision\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Load MNIST training dataset\n",
        "trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True)\n",
        "\n",
        "# Get labels for each image in the dataset\n",
        "labels = [trainset[i][1] for i in range(len(trainset))]\n",
        "\n",
        "# Count the number of images in each class\n",
        "counts = [labels.count(i) for i in range(10)]\n",
        "\n",
        "# Define color map for different classes\n",
        "colors = ['red', 'blue', 'green', 'purple', 'orange',\n",
        "          'brown', 'pink', 'gray', 'olive', 'cyan']\n",
        "\n",
        "# Plot the number-class graph\n",
        "plt.bar(range(10), counts, color=colors)\n",
        "\n",
        "# Add text labels for each class\n",
        "for i in range(10):\n",
        "    plt.text(i, counts[i] + 100, str(counts[i]), ha='center', fontsize=8)\n",
        "#     plt.text(i, 4000, str(i), ha='center', fontsize=12)\n",
        "\n",
        "# Set plot title, axis labels, and limits\n",
        "plt.title('Number of Images in each Class (MNIST Trainset)')\n",
        "plt.xlabel('Class')\n",
        "plt.ylabel('Number of Images')\n",
        "plt.ylim(0, 10000)\n",
        "\n",
        "# Set x-axis ticks and labels\n",
        "plt.xticks(range(10), [str(i) for i in range(10)])\n",
        "\n",
        "# Save and show plot\n",
        "plt.savefig('numberclassgraph.pdf')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torchvision\n",
        "import random\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Load MNIST training dataset\n",
        "trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True)\n",
        "\n",
        "# Get 5 random images and their labels\n",
        "indices = random.sample(range(len(trainset)), 5)\n",
        "images = [trainset[i][0] for i in indices]\n",
        "labels = [trainset[i][1] for i in indices]\n",
        "\n",
        "# Plot the images\n",
        "fig, axs = plt.subplots(1, 5, figsize=(10, 5))\n",
        "for i in range(5):\n",
        "    img = images[i]\n",
        "    if hasattr(img, 'shape'):\n",
        "        if len(img.shape) == 3 and img.shape[0] == 1:\n",
        "            img = img.squeeze(0)\n",
        "    axs[i].imshow(img, cmap='gray')\n",
        "    axs[i].axis('off')\n",
        "    axs[i].set_title(str(labels[i]))\n",
        "\n",
        "# Save and show plot\n",
        "plt.savefig('fiverand.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 143
        },
        "outputId": "b14736af-1537-42bc-c329-3931d0dd206f",
        "id": "SDDJzPL-gl8J"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x360 with 5 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torchvision\n",
        "import random\n",
        "import matplotlib.pyplot as plt\n",
        "import torchvision.transforms as transforms\n",
        "\n",
        "# Load MNIST training dataset\n",
        "trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True)\n",
        "\n",
        "# Calculate mean and standard deviation of the training set\n",
        "train_data = trainset.data.numpy()\n",
        "mean = train_data.mean() / 255.0\n",
        "std = train_data.std() / 255.0\n",
        "\n",
        "# Define data transformations\n",
        "transform = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean, std)\n",
        "])\n",
        "\n",
        "# Get 5 random images and their labels\n",
        "indices = random.sample(range(len(trainset)), 5)\n",
        "images = [trainset[i][0] for i in indices]\n",
        "labels = [trainset[i][1] for i in indices]\n",
        "\n",
        "# Apply the data transformation to the images\n",
        "images_normalized = [transform(img) for img in images]\n",
        "\n",
        "# Plot the images\n",
        "fig, axs = plt.subplots(1, 5, figsize=(10, 5))\n",
        "for i in range(5):\n",
        "    img = images_normalized[i].numpy().squeeze()\n",
        "    axs[i].imshow(img, cmap='gray')\n",
        "    axs[i].axis('off')\n",
        "    axs[i].set_title(str(labels[i]))\n",
        "\n",
        "# Save and show plot\n",
        "plt.savefig('fiverandnormal.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 143
        },
        "outputId": "ed70af06-8f24-4f10-8379-69af7371e8b2",
        "id": "r3BIWvrtgl8J"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x360 with 5 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torchvision.datasets as datasets\n",
        "\n",
        "# Load MNIST training dataset\n",
        "trainset = datasets.MNIST(root='./data', train=True, download=True)\n",
        "\n",
        "# Get the first image in the dataset\n",
        "image, label = trainset[0]\n",
        "\n",
        "# Calculate the height and width of the image\n",
        "height, width = image.size\n",
        "\n",
        "# Print the result\n",
        "print(\"Each data of MNIST has {} x {} = {} features.\".format(height, width, height*width))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "576f7961-5b5b-4749-fee6-7f1276f09844",
        "id": "O7kTQc8Ogl8K"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Each data of MNIST has 28 x 28 = 784 features.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.2"
      ],
      "metadata": {
        "id": "b4kzifZ_gl8K"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchvision.datasets as dsets\n",
        "import torchvision.transforms as transforms\n",
        "from torch.autograd import Variable\n",
        "\n",
        "# Hyperparameters\n",
        "num_epochs = 30\n",
        "batch_size = 64\n",
        "learning_rate = 0.0001\n",
        "\n",
        "# MNIST dataset\n",
        "train_dataset = dsets.MNIST(root='./data',\n",
        "                            train=True,\n",
        "                            transform=transforms.ToTensor(),\n",
        "                            download=True)\n",
        "\n",
        "test_dataset = dsets.MNIST(root='./data',\n",
        "                           train=False,\n",
        "                           transform=transforms.ToTensor())\n",
        "\n",
        "# Data loader\n",
        "train_loader = torch.utils.data.DataLoader(dataset=train_dataset,\n",
        "                                           batch_size=batch_size,\n",
        "                                           shuffle=True)\n",
        "\n",
        "test_loader = torch.utils.data.DataLoader(dataset=test_dataset,\n",
        "                                          batch_size=batch_size,\n",
        "                                          shuffle=False)\n",
        "\n",
        "# Autoencoder model\n",
        "class Autoencoder(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Autoencoder, self).__init__()\n",
        "        self.encoder = nn.Sequential(\n",
        "            nn.Linear(784, 500),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(500, 300),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(300, 100),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(100, 30),\n",
        "            nn.ReLU(True))\n",
        "        self.decoder = nn.Sequential(\n",
        "            nn.Linear(30, 100),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(100, 300),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(300, 500),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(500, 784),\n",
        "            nn.Sigmoid())\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.encoder(x)\n",
        "        x = self.decoder(x)\n",
        "        return x\n",
        "\n",
        "# Create autoencoder object\n",
        "autoencoder = Autoencoder()\n",
        "\n",
        "# Loss function and optimizer\n",
        "criterion = nn.MSELoss()\n",
        "optimizer = torch.optim.Adam(autoencoder.parameters(), lr=learning_rate)\n",
        "\n",
        "# Train the model\n",
        "train_loss = []\n",
        "valid_loss = []\n",
        "\n",
        "for epoch in range(num_epochs):\n",
        "    # Train\n",
        "    total_loss = 0\n",
        "    for i, (images, _) in enumerate(train_loader):\n",
        "        images = Variable(images.view(-1, 28*28))\n",
        "        optimizer.zero_grad()\n",
        "        outputs = autoencoder(images)\n",
        "        loss = criterion(outputs, images)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        total_loss += loss.item()\n",
        "\n",
        "    train_loss.append(total_loss/len(train_loader))\n",
        "\n",
        "    # Validation\n",
        "    total_loss = 0\n",
        "    for i, (images, _) in enumerate(test_loader):\n",
        "        images = Variable(images.view(-1, 28*28))\n",
        "        outputs = autoencoder(images)\n",
        "        loss = criterion(outputs, images)\n",
        "        total_loss += loss.item()\n",
        "\n",
        "    valid_loss.append(total_loss/len(test_loader))\n",
        "\n",
        "    print('Epoch [{}/{}], Train Loss: {:.4f}, Valid Loss: {:.4f}'\n",
        "          .format(epoch+1, num_epochs, train_loss[-1], valid_loss[-1]))\n",
        "\n",
        "# Save the trained model weights\n",
        "torch.save(autoencoder.state_dict(), 'autoencoder.pth')\n",
        "\n",
        "# Plot loss\n",
        "import matplotlib.pyplot as plt\n",
        "plt.plot(train_loss, label='Train Loss')\n",
        "plt.plot(valid_loss, label='Valid Loss')\n",
        "plt.legend()\n",
        "plt.savefig('Loss.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 819
        },
        "outputId": "b49351c9-349d-43cd-cc2a-0cc4cfb97474",
        "id": "7hBU8c3Rgl8K"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/30], Train Loss: 0.0734, Valid Loss: 0.0571\n",
            "Epoch [2/30], Train Loss: 0.0478, Valid Loss: 0.0387\n",
            "Epoch [3/30], Train Loss: 0.0352, Valid Loss: 0.0328\n",
            "Epoch [4/30], Train Loss: 0.0317, Valid Loss: 0.0300\n",
            "Epoch [5/30], Train Loss: 0.0291, Valid Loss: 0.0278\n",
            "Epoch [6/30], Train Loss: 0.0271, Valid Loss: 0.0258\n",
            "Epoch [7/30], Train Loss: 0.0252, Valid Loss: 0.0238\n",
            "Epoch [8/30], Train Loss: 0.0232, Valid Loss: 0.0220\n",
            "Epoch [9/30], Train Loss: 0.0217, Valid Loss: 0.0208\n",
            "Epoch [10/30], Train Loss: 0.0207, Valid Loss: 0.0199\n",
            "Epoch [11/30], Train Loss: 0.0197, Valid Loss: 0.0189\n",
            "Epoch [12/30], Train Loss: 0.0188, Valid Loss: 0.0182\n",
            "Epoch [13/30], Train Loss: 0.0181, Valid Loss: 0.0175\n",
            "Epoch [14/30], Train Loss: 0.0175, Valid Loss: 0.0170\n",
            "Epoch [15/30], Train Loss: 0.0169, Valid Loss: 0.0165\n",
            "Epoch [16/30], Train Loss: 0.0165, Valid Loss: 0.0161\n",
            "Epoch [17/30], Train Loss: 0.0160, Valid Loss: 0.0156\n",
            "Epoch [18/30], Train Loss: 0.0156, Valid Loss: 0.0152\n",
            "Epoch [19/30], Train Loss: 0.0152, Valid Loss: 0.0149\n",
            "Epoch [20/30], Train Loss: 0.0149, Valid Loss: 0.0146\n",
            "Epoch [21/30], Train Loss: 0.0145, Valid Loss: 0.0143\n",
            "Epoch [22/30], Train Loss: 0.0142, Valid Loss: 0.0139\n",
            "Epoch [23/30], Train Loss: 0.0138, Valid Loss: 0.0136\n",
            "Epoch [24/30], Train Loss: 0.0134, Valid Loss: 0.0132\n",
            "Epoch [25/30], Train Loss: 0.0130, Valid Loss: 0.0128\n",
            "Epoch [26/30], Train Loss: 0.0127, Valid Loss: 0.0125\n",
            "Epoch [27/30], Train Loss: 0.0124, Valid Loss: 0.0123\n",
            "Epoch [28/30], Train Loss: 0.0121, Valid Loss: 0.0121\n",
            "Epoch [29/30], Train Loss: 0.0119, Valid Loss: 0.0118\n",
            "Epoch [30/30], Train Loss: 0.0116, Valid Loss: 0.0116\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.3"
      ],
      "metadata": {
        "id": "XCv5JAytgl8L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchvision.datasets as dsets\n",
        "import torchvision.transforms as transforms\n",
        "from torch.autograd import Variable\n",
        "from sklearn.metrics import confusion_matrix, f1_score, precision_score, recall_score\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Hyperparameters\n",
        "num_epochs = 30\n",
        "batch_size = 64\n",
        "learning_rate = 0.0001\n",
        "\n",
        "# MNIST dataset\n",
        "train_dataset = dsets.MNIST(root='./data',\n",
        "                            train=True,\n",
        "                            transform=transforms.ToTensor(),\n",
        "                            download=True)\n",
        "\n",
        "test_dataset = dsets.MNIST(root='./data',\n",
        "                           train=False,\n",
        "                           transform=transforms.ToTensor())\n",
        "\n",
        "# Data loader\n",
        "train_loader = torch.utils.data.DataLoader(dataset=train_dataset,\n",
        "                                           batch_size=batch_size,\n",
        "                                           shuffle=True)\n",
        "\n",
        "test_loader = torch.utils.data.DataLoader(dataset=test_dataset,\n",
        "                                          batch_size=batch_size,\n",
        "                                          shuffle=False)\n",
        "\n",
        "# Autoencoder model\n",
        "class Autoencoder(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Autoencoder, self).__init__()\n",
        "        self.encoder = nn.Sequential(\n",
        "            nn.Linear(784, 500),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(500, 300),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(300, 100),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(100, 30),\n",
        "            nn.ReLU(True))\n",
        "        self.decoder = nn.Sequential(\n",
        "            nn.Linear(30, 100),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(100, 300),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(300, 500),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(500, 784),\n",
        "            nn.Sigmoid())\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.encoder(x)\n",
        "        x = self.decoder(x)\n",
        "        return x\n",
        "\n",
        "# Create autoencoder object and load trained parameters\n",
        "autoencoder = Autoencoder()\n",
        "autoencoder.load_state_dict(torch.load('autoencoder.pth'))\n",
        "encoder = autoencoder.encoder\n",
        "\n",
        "# Classifier model\n",
        "class Classifier(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Classifier, self).__init__()\n",
        "        self.layer1 = nn.Linear(30, 256)\n",
        "        self.layer2 = nn.Linear(256, 128)\n",
        "        self.layer3 = nn.Linear(128, 10)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.layer1(x)\n",
        "        x = nn.functional.relu(x)\n",
        "        x = self.layer2(x)\n",
        "        x = nn.functional.relu(x)\n",
        "        x = self.layer3(x)\n",
        "        return x\n",
        "\n",
        "# Create classifier object\n",
        "classifier = Classifier()\n",
        "\n",
        "# Loss function and optimizer\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.Adam(classifier.parameters(), lr=learning_rate)\n",
        "\n",
        "# Train the model\n",
        "train_loss = []\n",
        "valid_loss = []\n",
        "train_acc = []\n",
        "valid_acc = []\n",
        "\n",
        "for epoch in range(num_epochs):\n",
        "    # Train\n",
        "    total_loss = 0\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    for images, labels in train_loader:\n",
        "        images = Variable(images.view(-1, 28*28))\n",
        "        labels = Variable(labels)\n",
        "        features = encoder(images)\n",
        "        outputs = classifier(features)\n",
        "        loss = criterion(outputs, labels)\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        total_loss += loss.item()\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        correct += (predicted == labels).sum().item()\n",
        "        total += labels.size(0)\n",
        "\n",
        "    train_loss.append(total_loss/len(train_loader))\n",
        "    train_acc.append(correct/total)\n",
        "\n",
        "    # Validation\n",
        "    total_loss = 0\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    with torch.no_grad():\n",
        "        for images, labels in test_loader:\n",
        "            images = Variable(images.view(-1, 28*28))\n",
        "            labels = Variable(labels)\n",
        "            features = encoder(images)\n",
        "            outputs = classifier(features)\n",
        "            loss = criterion(outputs, labels)\n",
        "            total_loss += loss.item()\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "            total += labels.size(0)\n",
        "\n",
        "    valid_loss.append(total_loss/len(test_loader))\n",
        "    valid_acc.append(correct/total)\n",
        "\n",
        "    # Print statistics\n",
        "    print ('Epoch [{}/{}], Train Loss: {:.4f}, Valid Loss: {:.4f}, Train Acc: {:.4f}, Valid Acc: {:.4f}'\n",
        "           .format(epoch+1, num_epochs, train_loss[-1], valid_loss[-1], train_acc[-1], valid_acc[-1]))\n",
        "\n",
        "# Save the trained model weights\n",
        "torch.save(classifier.state_dict(), 'classifier.pth')\n",
        "\n",
        "# Plot loss and accuracy\n",
        "plt.figure(figsize=(10, 5))\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(train_loss, label='Train')\n",
        "plt.plot(valid_loss, label='Validation')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(train_acc, label='Train')\n",
        "plt.plot(valid_acc, label='Validation')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.savefig('LossAccur2.pdf')\n",
        "plt.show()\n",
        "\n",
        "# Evaluate the model\n",
        "y_true = []\n",
        "y_pred = []\n",
        "with torch.no_grad():\n",
        "    for images, labels in test_loader:\n",
        "        images = Variable(images.view(-1, 28*28))\n",
        "        labels = labels.numpy().tolist()\n",
        "        features = encoder(images)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        predicted = predicted.numpy().tolist()\n",
        "        y_true.extend(labels)\n",
        "        y_pred.extend(predicted)\n",
        "\n",
        "# Plot confusion matrix\n",
        "cm = confusion_matrix(y_true, y_pred)\n",
        "plt.figure(figsize=(10, 10))\n",
        "sns.heatmap(cm, annot=True, fmt='g')\n",
        "plt.xlabel('Predicted')\n",
        "plt.ylabel('Actual')\n",
        "plt.savefig('conf.pdf')\n",
        "plt.show()\n",
        "\n",
        "# Report metrics\n",
        "f1 = f1_score(y_true, y_pred, average='weighted')\n",
        "precision = precision_score(y_true, y_pred, average='weighted')\n",
        "recall = recall_score(y_true, y_pred, average='weighted')\n",
        "print('F1 Score:', f1)\n",
        "print('Precision:', precision)\n",
        "print('Recall:', recall)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "fdbae775-ad7e-4080-9ff8-5d5ad8903edd",
        "id": "zusdqJEJgl8L"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/30], Train Loss: 0.6023, Valid Loss: 0.2837, Train Acc: 0.8417, Valid Acc: 0.9136\n",
            "Epoch [2/30], Train Loss: 0.2620, Valid Loss: 0.2341, Train Acc: 0.9217, Valid Acc: 0.9285\n",
            "Epoch [3/30], Train Loss: 0.2250, Valid Loss: 0.1993, Train Acc: 0.9312, Valid Acc: 0.9383\n",
            "Epoch [4/30], Train Loss: 0.2000, Valid Loss: 0.1851, Train Acc: 0.9383, Valid Acc: 0.9444\n",
            "Epoch [5/30], Train Loss: 0.1831, Valid Loss: 0.1685, Train Acc: 0.9443, Valid Acc: 0.9482\n",
            "Epoch [6/30], Train Loss: 0.1681, Valid Loss: 0.1600, Train Acc: 0.9484, Valid Acc: 0.9519\n",
            "Epoch [7/30], Train Loss: 0.1566, Valid Loss: 0.1536, Train Acc: 0.9521, Valid Acc: 0.9540\n",
            "Epoch [8/30], Train Loss: 0.1481, Valid Loss: 0.1383, Train Acc: 0.9544, Valid Acc: 0.9585\n",
            "Epoch [9/30], Train Loss: 0.1398, Valid Loss: 0.1351, Train Acc: 0.9571, Valid Acc: 0.9574\n",
            "Epoch [10/30], Train Loss: 0.1335, Valid Loss: 0.1296, Train Acc: 0.9584, Valid Acc: 0.9590\n",
            "Epoch [11/30], Train Loss: 0.1281, Valid Loss: 0.1325, Train Acc: 0.9601, Valid Acc: 0.9592\n",
            "Epoch [12/30], Train Loss: 0.1231, Valid Loss: 0.1278, Train Acc: 0.9612, Valid Acc: 0.9608\n",
            "Epoch [13/30], Train Loss: 0.1185, Valid Loss: 0.1166, Train Acc: 0.9631, Valid Acc: 0.9638\n",
            "Epoch [14/30], Train Loss: 0.1144, Valid Loss: 0.1123, Train Acc: 0.9640, Valid Acc: 0.9653\n",
            "Epoch [15/30], Train Loss: 0.1112, Valid Loss: 0.1123, Train Acc: 0.9649, Valid Acc: 0.9657\n",
            "Epoch [16/30], Train Loss: 0.1088, Valid Loss: 0.1092, Train Acc: 0.9654, Valid Acc: 0.9659\n",
            "Epoch [17/30], Train Loss: 0.1050, Valid Loss: 0.1103, Train Acc: 0.9664, Valid Acc: 0.9658\n",
            "Epoch [18/30], Train Loss: 0.1028, Valid Loss: 0.1075, Train Acc: 0.9677, Valid Acc: 0.9677\n",
            "Epoch [19/30], Train Loss: 0.1001, Valid Loss: 0.1120, Train Acc: 0.9685, Valid Acc: 0.9630\n",
            "Epoch [20/30], Train Loss: 0.0984, Valid Loss: 0.1040, Train Acc: 0.9692, Valid Acc: 0.9680\n",
            "Epoch [21/30], Train Loss: 0.0956, Valid Loss: 0.1015, Train Acc: 0.9702, Valid Acc: 0.9677\n",
            "Epoch [22/30], Train Loss: 0.0945, Valid Loss: 0.1038, Train Acc: 0.9699, Valid Acc: 0.9668\n",
            "Epoch [23/30], Train Loss: 0.0925, Valid Loss: 0.0974, Train Acc: 0.9701, Valid Acc: 0.9698\n",
            "Epoch [24/30], Train Loss: 0.0905, Valid Loss: 0.0995, Train Acc: 0.9716, Valid Acc: 0.9683\n",
            "Epoch [25/30], Train Loss: 0.0891, Valid Loss: 0.0985, Train Acc: 0.9712, Valid Acc: 0.9687\n",
            "Epoch [26/30], Train Loss: 0.0872, Valid Loss: 0.0950, Train Acc: 0.9722, Valid Acc: 0.9702\n",
            "Epoch [27/30], Train Loss: 0.0854, Valid Loss: 0.0975, Train Acc: 0.9726, Valid Acc: 0.9691\n",
            "Epoch [28/30], Train Loss: 0.0841, Valid Loss: 0.0958, Train Acc: 0.9739, Valid Acc: 0.9691\n",
            "Epoch [29/30], Train Loss: 0.0831, Valid Loss: 0.0975, Train Acc: 0.9736, Valid Acc: 0.9683\n",
            "Epoch [30/30], Train Loss: 0.0818, Valid Loss: 0.0922, Train Acc: 0.9739, Valid Acc: 0.9707\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x360 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x720 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "F1 Score: 0.9707119583033161\n",
            "Precision: 0.9708467316384838\n",
            "Recall: 0.9707\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "import requests\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "\n",
        "# Define a function to predict the class of an input image\n",
        "def predict_image(image_path, encoder, classifier):\n",
        "    # Open and preprocess the image\n",
        "    img = Image.open(image_path).convert('L')\n",
        "    img = img.resize((28, 28))\n",
        "    img_tensor = transforms.ToTensor()(img)\n",
        "    img_tensor = img_tensor.view(-1, 28*28)\n",
        "    # Pass the image through the encoder and classifier\n",
        "    with torch.no_grad():\n",
        "        features = encoder(img_tensor)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "    # Return the predicted class\n",
        "    return predicted.item()\n",
        "\n",
        "# Upload an image and predict its class\n",
        "from google.colab import files\n",
        "\n",
        "# Upload the image\n",
        "uploaded = files.upload()\n",
        "\n",
        "# Predict the class\n",
        "image_path = next(iter(uploaded))\n",
        "predicted_class = predict_image(io.BytesIO(uploaded[image_path]), encoder, classifier)\n",
        "\n",
        "# Print the predicted class\n",
        "print('Predicted class:', predicted_class)\n",
        "\n",
        "# Open the uploaded image\n",
        "img = Image.open(io.BytesIO(uploaded[image_path]))\n",
        "\n",
        "# Create a figure with the image and the predicted class as the title\n",
        "fig, ax = plt.subplots()\n",
        "ax.imshow(img)\n",
        "ax.set_title('Predicted Class: {}'.format(predicted_class))\n",
        "\n",
        "# Save the plot as a pdf\n",
        "plt.savefig('prediction22.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        },
        "outputId": "a0554a7b-1f85-4187-ee63-b91283850e75",
        "id": "iwc2jlyqgl8L"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-7d6f596e-34fa-4dc7-a097-39e23bcab3fc\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-7d6f596e-34fa-4dc7-a097-39e23bcab3fc\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving test_image.jpg to test_image (1).jpg\n",
            "Predicted class: 2\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "import requests\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "\n",
        "# Define a function to predict the class of an input image\n",
        "def predict_image(image_path, encoder, classifier):\n",
        "    # Open and preprocess the image\n",
        "    img = Image.open(image_path).convert('L')\n",
        "    img = img.resize((28, 28))\n",
        "    img_tensor = transforms.ToTensor()(img)\n",
        "    img_tensor = img_tensor.view(-1, 28*28)\n",
        "    # Pass the image through the encoder and classifier\n",
        "    with torch.no_grad():\n",
        "        features = encoder(img_tensor)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "    # Return the predicted class\n",
        "    return predicted.item()\n",
        "\n",
        "# Upload an image and predict its class\n",
        "from google.colab import files\n",
        "\n",
        "# Upload the image\n",
        "uploaded = files.upload()\n",
        "\n",
        "# Predict the class\n",
        "image_path = next(iter(uploaded))\n",
        "predicted_class = predict_image(io.BytesIO(uploaded[image_path]), encoder, classifier)\n",
        "\n",
        "# Print the predicted class\n",
        "print('Predicted class:', predicted_class)\n",
        "\n",
        "# Open the uploaded image\n",
        "img = Image.open(io.BytesIO(uploaded[image_path]))\n",
        "\n",
        "# Create a figure with the image and the predicted class as the title\n",
        "fig, ax = plt.subplots()\n",
        "ax.imshow(img)\n",
        "ax.set_title('Predicted Class: {}'.format(predicted_class))\n",
        "\n",
        "# Save the plot as a pdf\n",
        "plt.savefig('prediction555.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        },
        "outputId": "c3fd6bf1-7e2c-4edd-fb64-1a9bb86b10f5",
        "id": "SdKeSeokgl8M"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-5a84ef01-9192-4339-8293-19ce47997ef9\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-5a84ef01-9192-4339-8293-19ce47997ef9\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving test_image.jpg to test_image (9).jpg\n",
            "Predicted class: 5\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 3 - Main"
      ],
      "metadata": {
        "id": "pmzoV6tBsub_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.2"
      ],
      "metadata": {
        "id": "58nfrkh6sucd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchvision.datasets as dsets\n",
        "import torchvision.transforms as transforms\n",
        "from torch.autograd import Variable\n",
        "\n",
        "# Hyperparameters\n",
        "num_epochs = 100\n",
        "batch_size = 64\n",
        "learning_rate = 0.0001\n",
        "\n",
        "# MNIST dataset\n",
        "train_dataset = dsets.MNIST(root='./data',\n",
        "                            train=True,\n",
        "                            transform=transforms.ToTensor(),\n",
        "                            download=True)\n",
        "\n",
        "test_dataset = dsets.MNIST(root='./data',\n",
        "                           train=False,\n",
        "                           transform=transforms.ToTensor())\n",
        "\n",
        "# Data loader\n",
        "train_loader = torch.utils.data.DataLoader(dataset=train_dataset,\n",
        "                                           batch_size=batch_size,\n",
        "                                           shuffle=True)\n",
        "\n",
        "test_loader = torch.utils.data.DataLoader(dataset=test_dataset,\n",
        "                                          batch_size=batch_size,\n",
        "                                          shuffle=False)\n",
        "\n",
        "# Autoencoder model\n",
        "class Autoencoder(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Autoencoder, self).__init__()\n",
        "        self.encoder = nn.Sequential(\n",
        "            nn.Linear(784, 500),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(500, 250),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(250, 100),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(100, 30),\n",
        "            nn.ReLU(True))\n",
        "        self.decoder = nn.Sequential(\n",
        "            nn.Linear(30, 100),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(100, 250),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(250, 500),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(500, 784),\n",
        "            nn.Sigmoid())\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.encoder(x)\n",
        "        x = self.decoder(x)\n",
        "        return x\n",
        "\n",
        "# Create autoencoder object\n",
        "autoencoder = Autoencoder()\n",
        "\n",
        "# Loss function and optimizer\n",
        "criterion = nn.MSELoss()\n",
        "optimizer = torch.optim.Adam(autoencoder.parameters(), lr=learning_rate)\n",
        "\n",
        "# Train the model\n",
        "train_loss = []\n",
        "valid_loss = []\n",
        "\n",
        "for epoch in range(num_epochs):\n",
        "    # Train\n",
        "    total_loss = 0\n",
        "    for i, (images, _) in enumerate(train_loader):\n",
        "        images = Variable(images.view(-1, 28*28))\n",
        "        optimizer.zero_grad()\n",
        "        outputs = autoencoder(images)\n",
        "        loss = criterion(outputs, images)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        total_loss += loss.item()\n",
        "\n",
        "    train_loss.append(total_loss/len(train_loader))\n",
        "\n",
        "    # Validation\n",
        "    total_loss = 0\n",
        "    for i, (images, _) in enumerate(test_loader):\n",
        "        images = Variable(images.view(-1, 28*28))\n",
        "        outputs = autoencoder(images)\n",
        "        loss = criterion(outputs, images)\n",
        "        total_loss += loss.item()\n",
        "\n",
        "    valid_loss.append(total_loss/len(test_loader))\n",
        "\n",
        "    print('Epoch [{}/{}], Train Loss: {:.4f}, Valid Loss: {:.4f}'\n",
        "          .format(epoch+1, num_epochs, train_loss[-1], valid_loss[-1]))\n",
        "\n",
        "# Save the trained model weights\n",
        "torch.save(autoencoder.state_dict(), 'autoencoder.pth')\n",
        "\n",
        "# Plot loss\n",
        "import matplotlib.pyplot as plt\n",
        "plt.plot(train_loss, label='Train Loss')\n",
        "plt.plot(valid_loss, label='Valid Loss')\n",
        "plt.legend()\n",
        "plt.savefig('Loss.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "6214c3f6-6044-491c-89d8-fdf4b8034ef6",
        "id": "rnrw5O3Gsucd"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/100], Train Loss: 0.0738, Valid Loss: 0.0586\n",
            "Epoch [2/100], Train Loss: 0.0476, Valid Loss: 0.0397\n",
            "Epoch [3/100], Train Loss: 0.0356, Valid Loss: 0.0328\n",
            "Epoch [4/100], Train Loss: 0.0313, Valid Loss: 0.0291\n",
            "Epoch [5/100], Train Loss: 0.0282, Valid Loss: 0.0266\n",
            "Epoch [6/100], Train Loss: 0.0260, Valid Loss: 0.0248\n",
            "Epoch [7/100], Train Loss: 0.0246, Valid Loss: 0.0238\n",
            "Epoch [8/100], Train Loss: 0.0234, Valid Loss: 0.0222\n",
            "Epoch [9/100], Train Loss: 0.0217, Valid Loss: 0.0206\n",
            "Epoch [10/100], Train Loss: 0.0203, Valid Loss: 0.0195\n",
            "Epoch [11/100], Train Loss: 0.0194, Valid Loss: 0.0188\n",
            "Epoch [12/100], Train Loss: 0.0187, Valid Loss: 0.0182\n",
            "Epoch [13/100], Train Loss: 0.0181, Valid Loss: 0.0177\n",
            "Epoch [14/100], Train Loss: 0.0175, Valid Loss: 0.0171\n",
            "Epoch [15/100], Train Loss: 0.0171, Valid Loss: 0.0168\n",
            "Epoch [16/100], Train Loss: 0.0166, Valid Loss: 0.0164\n",
            "Epoch [17/100], Train Loss: 0.0162, Valid Loss: 0.0160\n",
            "Epoch [18/100], Train Loss: 0.0159, Valid Loss: 0.0157\n",
            "Epoch [19/100], Train Loss: 0.0156, Valid Loss: 0.0154\n",
            "Epoch [20/100], Train Loss: 0.0153, Valid Loss: 0.0151\n",
            "Epoch [21/100], Train Loss: 0.0150, Valid Loss: 0.0149\n",
            "Epoch [22/100], Train Loss: 0.0147, Valid Loss: 0.0146\n",
            "Epoch [23/100], Train Loss: 0.0144, Valid Loss: 0.0143\n",
            "Epoch [24/100], Train Loss: 0.0141, Valid Loss: 0.0140\n",
            "Epoch [25/100], Train Loss: 0.0138, Valid Loss: 0.0138\n",
            "Epoch [26/100], Train Loss: 0.0136, Valid Loss: 0.0135\n",
            "Epoch [27/100], Train Loss: 0.0133, Valid Loss: 0.0132\n",
            "Epoch [28/100], Train Loss: 0.0130, Valid Loss: 0.0129\n",
            "Epoch [29/100], Train Loss: 0.0128, Valid Loss: 0.0128\n",
            "Epoch [30/100], Train Loss: 0.0125, Valid Loss: 0.0126\n",
            "Epoch [31/100], Train Loss: 0.0123, Valid Loss: 0.0123\n",
            "Epoch [32/100], Train Loss: 0.0121, Valid Loss: 0.0122\n",
            "Epoch [33/100], Train Loss: 0.0119, Valid Loss: 0.0121\n",
            "Epoch [34/100], Train Loss: 0.0117, Valid Loss: 0.0118\n",
            "Epoch [35/100], Train Loss: 0.0115, Valid Loss: 0.0116\n",
            "Epoch [36/100], Train Loss: 0.0113, Valid Loss: 0.0114\n",
            "Epoch [37/100], Train Loss: 0.0111, Valid Loss: 0.0113\n",
            "Epoch [38/100], Train Loss: 0.0109, Valid Loss: 0.0111\n",
            "Epoch [39/100], Train Loss: 0.0108, Valid Loss: 0.0109\n",
            "Epoch [40/100], Train Loss: 0.0106, Valid Loss: 0.0108\n",
            "Epoch [41/100], Train Loss: 0.0105, Valid Loss: 0.0107\n",
            "Epoch [42/100], Train Loss: 0.0103, Valid Loss: 0.0105\n",
            "Epoch [43/100], Train Loss: 0.0102, Valid Loss: 0.0104\n",
            "Epoch [44/100], Train Loss: 0.0101, Valid Loss: 0.0102\n",
            "Epoch [45/100], Train Loss: 0.0099, Valid Loss: 0.0102\n",
            "Epoch [46/100], Train Loss: 0.0098, Valid Loss: 0.0101\n",
            "Epoch [47/100], Train Loss: 0.0097, Valid Loss: 0.0099\n",
            "Epoch [48/100], Train Loss: 0.0096, Valid Loss: 0.0099\n",
            "Epoch [49/100], Train Loss: 0.0094, Valid Loss: 0.0098\n",
            "Epoch [50/100], Train Loss: 0.0093, Valid Loss: 0.0096\n",
            "Epoch [51/100], Train Loss: 0.0092, Valid Loss: 0.0095\n",
            "Epoch [52/100], Train Loss: 0.0091, Valid Loss: 0.0094\n",
            "Epoch [53/100], Train Loss: 0.0090, Valid Loss: 0.0093\n",
            "Epoch [54/100], Train Loss: 0.0089, Valid Loss: 0.0091\n",
            "Epoch [55/100], Train Loss: 0.0088, Valid Loss: 0.0091\n",
            "Epoch [56/100], Train Loss: 0.0087, Valid Loss: 0.0090\n",
            "Epoch [57/100], Train Loss: 0.0086, Valid Loss: 0.0090\n",
            "Epoch [58/100], Train Loss: 0.0085, Valid Loss: 0.0088\n",
            "Epoch [59/100], Train Loss: 0.0084, Valid Loss: 0.0088\n",
            "Epoch [60/100], Train Loss: 0.0083, Valid Loss: 0.0087\n",
            "Epoch [61/100], Train Loss: 0.0082, Valid Loss: 0.0086\n",
            "Epoch [62/100], Train Loss: 0.0082, Valid Loss: 0.0085\n",
            "Epoch [63/100], Train Loss: 0.0081, Valid Loss: 0.0085\n",
            "Epoch [64/100], Train Loss: 0.0080, Valid Loss: 0.0083\n",
            "Epoch [65/100], Train Loss: 0.0079, Valid Loss: 0.0083\n",
            "Epoch [66/100], Train Loss: 0.0078, Valid Loss: 0.0082\n",
            "Epoch [67/100], Train Loss: 0.0078, Valid Loss: 0.0082\n",
            "Epoch [68/100], Train Loss: 0.0077, Valid Loss: 0.0081\n",
            "Epoch [69/100], Train Loss: 0.0076, Valid Loss: 0.0080\n",
            "Epoch [70/100], Train Loss: 0.0076, Valid Loss: 0.0080\n",
            "Epoch [71/100], Train Loss: 0.0075, Valid Loss: 0.0079\n",
            "Epoch [72/100], Train Loss: 0.0074, Valid Loss: 0.0079\n",
            "Epoch [73/100], Train Loss: 0.0074, Valid Loss: 0.0078\n",
            "Epoch [74/100], Train Loss: 0.0073, Valid Loss: 0.0078\n",
            "Epoch [75/100], Train Loss: 0.0073, Valid Loss: 0.0077\n",
            "Epoch [76/100], Train Loss: 0.0072, Valid Loss: 0.0077\n",
            "Epoch [77/100], Train Loss: 0.0072, Valid Loss: 0.0076\n",
            "Epoch [78/100], Train Loss: 0.0071, Valid Loss: 0.0076\n",
            "Epoch [79/100], Train Loss: 0.0071, Valid Loss: 0.0075\n",
            "Epoch [80/100], Train Loss: 0.0070, Valid Loss: 0.0075\n",
            "Epoch [81/100], Train Loss: 0.0070, Valid Loss: 0.0075\n",
            "Epoch [82/100], Train Loss: 0.0069, Valid Loss: 0.0074\n",
            "Epoch [83/100], Train Loss: 0.0069, Valid Loss: 0.0074\n",
            "Epoch [84/100], Train Loss: 0.0068, Valid Loss: 0.0073\n",
            "Epoch [85/100], Train Loss: 0.0068, Valid Loss: 0.0073\n",
            "Epoch [86/100], Train Loss: 0.0067, Valid Loss: 0.0072\n",
            "Epoch [87/100], Train Loss: 0.0067, Valid Loss: 0.0073\n",
            "Epoch [88/100], Train Loss: 0.0066, Valid Loss: 0.0072\n",
            "Epoch [89/100], Train Loss: 0.0066, Valid Loss: 0.0071\n",
            "Epoch [90/100], Train Loss: 0.0066, Valid Loss: 0.0071\n",
            "Epoch [91/100], Train Loss: 0.0065, Valid Loss: 0.0071\n",
            "Epoch [92/100], Train Loss: 0.0065, Valid Loss: 0.0070\n",
            "Epoch [93/100], Train Loss: 0.0065, Valid Loss: 0.0070\n",
            "Epoch [94/100], Train Loss: 0.0064, Valid Loss: 0.0070\n",
            "Epoch [95/100], Train Loss: 0.0064, Valid Loss: 0.0069\n",
            "Epoch [96/100], Train Loss: 0.0064, Valid Loss: 0.0069\n",
            "Epoch [97/100], Train Loss: 0.0063, Valid Loss: 0.0069\n",
            "Epoch [98/100], Train Loss: 0.0063, Valid Loss: 0.0069\n",
            "Epoch [99/100], Train Loss: 0.0063, Valid Loss: 0.0069\n",
            "Epoch [100/100], Train Loss: 0.0062, Valid Loss: 0.0069\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3.3"
      ],
      "metadata": {
        "id": "A2gxWVfTsucg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchvision.datasets as dsets\n",
        "import torchvision.transforms as transforms\n",
        "from torch.autograd import Variable\n",
        "from sklearn.metrics import confusion_matrix, f1_score, precision_score, recall_score\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Hyperparameters\n",
        "num_epochs = 100\n",
        "batch_size = 64\n",
        "learning_rate = 0.0001\n",
        "\n",
        "# MNIST dataset\n",
        "train_dataset = dsets.MNIST(root='./data',\n",
        "                            train=True,\n",
        "                            transform=transforms.ToTensor(),\n",
        "                            download=True)\n",
        "\n",
        "test_dataset = dsets.MNIST(root='./data',\n",
        "                           train=False,\n",
        "                           transform=transforms.ToTensor())\n",
        "\n",
        "# Data loader\n",
        "train_loader = torch.utils.data.DataLoader(dataset=train_dataset,\n",
        "                                           batch_size=batch_size,\n",
        "                                           shuffle=True)\n",
        "\n",
        "test_loader = torch.utils.data.DataLoader(dataset=test_dataset,\n",
        "                                          batch_size=batch_size,\n",
        "                                          shuffle=False)\n",
        "\n",
        "# Autoencoder model\n",
        "class Autoencoder(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Autoencoder, self).__init__()\n",
        "        self.encoder = nn.Sequential(\n",
        "            nn.Linear(784, 500),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(500, 250),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(250, 100),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(100, 30),\n",
        "            nn.ReLU(True))\n",
        "        self.decoder = nn.Sequential(\n",
        "            nn.Linear(30, 100),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(100, 250),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(250, 500),\n",
        "            nn.ReLU(True),\n",
        "            nn.Linear(500, 784),\n",
        "            nn.Sigmoid())\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.encoder(x)\n",
        "        x = self.decoder(x)\n",
        "        return x\n",
        "\n",
        "# Create autoencoder object and load trained parameters\n",
        "autoencoder = Autoencoder()\n",
        "autoencoder.load_state_dict(torch.load('autoencoder.pth'))\n",
        "encoder = autoencoder.encoder\n",
        "\n",
        "# Classifier model\n",
        "class Classifier(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Classifier, self).__init__()\n",
        "        self.layer1 = nn.Linear(30, 128)\n",
        "        self.layer2 = nn.Linear(128, 64)\n",
        "        self.layer3 = nn.Linear(64, 10)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.layer1(x)\n",
        "        x = nn.functional.relu(x)\n",
        "        x = self.layer2(x)\n",
        "        x = nn.functional.relu(x)\n",
        "        x = self.layer3(x)\n",
        "        return x\n",
        "\n",
        "# Create classifier object\n",
        "classifier = Classifier()\n",
        "\n",
        "# Loss function and optimizer\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.Adam(classifier.parameters(), lr=learning_rate)\n",
        "\n",
        "# Train the model\n",
        "train_loss = []\n",
        "valid_loss = []\n",
        "train_acc = []\n",
        "valid_acc = []\n",
        "\n",
        "for epoch in range(num_epochs):\n",
        "    # Train\n",
        "    total_loss = 0\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    for images, labels in train_loader:\n",
        "        images = Variable(images.view(-1, 28*28))\n",
        "        labels = Variable(labels)\n",
        "        features = encoder(images)\n",
        "        outputs = classifier(features)\n",
        "        loss = criterion(outputs, labels)\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        total_loss += loss.item()\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        correct += (predicted == labels).sum().item()\n",
        "        total += labels.size(0)\n",
        "\n",
        "    train_loss.append(total_loss/len(train_loader))\n",
        "    train_acc.append(correct/total)\n",
        "\n",
        "    # Validation\n",
        "    total_loss = 0\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    with torch.no_grad():\n",
        "        for images, labels in test_loader:\n",
        "            images = Variable(images.view(-1, 28*28))\n",
        "            labels = Variable(labels)\n",
        "            features = encoder(images)\n",
        "            outputs = classifier(features)\n",
        "            loss = criterion(outputs, labels)\n",
        "            total_loss += loss.item()\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "            total += labels.size(0)\n",
        "\n",
        "    valid_loss.append(total_loss/len(test_loader))\n",
        "    valid_acc.append(correct/total)\n",
        "\n",
        "    # Print statistics\n",
        "    print ('Epoch [{}/{}], Train Loss: {:.4f}, Valid Loss: {:.4f}, Train Acc: {:.4f}, Valid Acc: {:.4f}'\n",
        "           .format(epoch+1, num_epochs, train_loss[-1], valid_loss[-1], train_acc[-1], valid_acc[-1]))\n",
        "\n",
        "# Save the trained model weights\n",
        "torch.save(classifier.state_dict(), 'classifier.pth')\n",
        "\n",
        "# Plot loss and accuracy\n",
        "plt.figure(figsize=(10, 5))\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(train_loss, label='Train')\n",
        "plt.plot(valid_loss, label='Validation')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(train_acc, label='Train')\n",
        "plt.plot(valid_acc, label='Validation')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.savefig('LossAccur2.pdf')\n",
        "plt.show()\n",
        "\n",
        "# Evaluate the model\n",
        "y_true = []\n",
        "y_pred = []\n",
        "with torch.no_grad():\n",
        "    for images, labels in test_loader:\n",
        "        images = Variable(images.view(-1, 28*28))\n",
        "        labels = labels.numpy().tolist()\n",
        "        features = encoder(images)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        predicted = predicted.numpy().tolist()\n",
        "        y_true.extend(labels)\n",
        "        y_pred.extend(predicted)\n",
        "\n",
        "# Plot confusion matrix\n",
        "cm = confusion_matrix(y_true, y_pred)\n",
        "plt.figure(figsize=(10, 10))\n",
        "sns.heatmap(cm, annot=True, fmt='g')\n",
        "plt.xlabel('Predicted')\n",
        "plt.ylabel('Actual')\n",
        "plt.savefig('conf.pdf')\n",
        "plt.show()\n",
        "\n",
        "# Report metrics\n",
        "f1 = f1_score(y_true, y_pred, average='weighted')\n",
        "precision = precision_score(y_true, y_pred, average='weighted')\n",
        "recall = recall_score(y_true, y_pred, average='weighted')\n",
        "print('F1 Score:', f1)\n",
        "print('Precision:', precision)\n",
        "print('Recall:', recall)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "cb89275c-6d5a-45fd-a84a-908149e35987",
        "id": "qPN9G9Ybsucg"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/100], Train Loss: 0.9578, Valid Loss: 0.3639, Train Acc: 0.7529, Valid Acc: 0.9123\n",
            "Epoch [2/100], Train Loss: 0.3094, Valid Loss: 0.2589, Train Acc: 0.9131, Valid Acc: 0.9288\n",
            "Epoch [3/100], Train Loss: 0.2498, Valid Loss: 0.2266, Train Acc: 0.9263, Valid Acc: 0.9347\n",
            "Epoch [4/100], Train Loss: 0.2232, Valid Loss: 0.2046, Train Acc: 0.9333, Valid Acc: 0.9399\n",
            "Epoch [5/100], Train Loss: 0.2058, Valid Loss: 0.1866, Train Acc: 0.9382, Valid Acc: 0.9448\n",
            "Epoch [6/100], Train Loss: 0.1925, Valid Loss: 0.1758, Train Acc: 0.9427, Valid Acc: 0.9499\n",
            "Epoch [7/100], Train Loss: 0.1813, Valid Loss: 0.1651, Train Acc: 0.9459, Valid Acc: 0.9521\n",
            "Epoch [8/100], Train Loss: 0.1708, Valid Loss: 0.1604, Train Acc: 0.9489, Valid Acc: 0.9541\n",
            "Epoch [9/100], Train Loss: 0.1621, Valid Loss: 0.1508, Train Acc: 0.9516, Valid Acc: 0.9559\n",
            "Epoch [10/100], Train Loss: 0.1540, Valid Loss: 0.1454, Train Acc: 0.9541, Valid Acc: 0.9565\n",
            "Epoch [11/100], Train Loss: 0.1479, Valid Loss: 0.1389, Train Acc: 0.9554, Valid Acc: 0.9576\n",
            "Epoch [12/100], Train Loss: 0.1407, Valid Loss: 0.1356, Train Acc: 0.9581, Valid Acc: 0.9607\n",
            "Epoch [13/100], Train Loss: 0.1356, Valid Loss: 0.1370, Train Acc: 0.9592, Valid Acc: 0.9571\n",
            "Epoch [14/100], Train Loss: 0.1309, Valid Loss: 0.1225, Train Acc: 0.9611, Valid Acc: 0.9619\n",
            "Epoch [15/100], Train Loss: 0.1264, Valid Loss: 0.1222, Train Acc: 0.9624, Valid Acc: 0.9637\n",
            "Epoch [16/100], Train Loss: 0.1216, Valid Loss: 0.1181, Train Acc: 0.9637, Valid Acc: 0.9638\n",
            "Epoch [17/100], Train Loss: 0.1183, Valid Loss: 0.1137, Train Acc: 0.9656, Valid Acc: 0.9666\n",
            "Epoch [18/100], Train Loss: 0.1152, Valid Loss: 0.1122, Train Acc: 0.9657, Valid Acc: 0.9661\n",
            "Epoch [19/100], Train Loss: 0.1121, Valid Loss: 0.1177, Train Acc: 0.9667, Valid Acc: 0.9618\n",
            "Epoch [22/100], Train Loss: 0.1037, Valid Loss: 0.1050, Train Acc: 0.9689, Valid Acc: 0.9667\n",
            "Epoch [23/100], Train Loss: 0.1015, Valid Loss: 0.1007, Train Acc: 0.9695, Valid Acc: 0.9695\n",
            "Epoch [24/100], Train Loss: 0.0994, Valid Loss: 0.0986, Train Acc: 0.9706, Valid Acc: 0.9710\n",
            "Epoch [25/100], Train Loss: 0.0972, Valid Loss: 0.0949, Train Acc: 0.9709, Valid Acc: 0.9706\n",
            "Epoch [26/100], Train Loss: 0.0949, Valid Loss: 0.0996, Train Acc: 0.9713, Valid Acc: 0.9684\n",
            "Epoch [27/100], Train Loss: 0.0937, Valid Loss: 0.0923, Train Acc: 0.9716, Valid Acc: 0.9714\n",
            "Epoch [28/100], Train Loss: 0.0912, Valid Loss: 0.0979, Train Acc: 0.9726, Valid Acc: 0.9695\n",
            "Epoch [29/100], Train Loss: 0.0896, Valid Loss: 0.0927, Train Acc: 0.9730, Valid Acc: 0.9710\n",
            "Epoch [30/100], Train Loss: 0.0884, Valid Loss: 0.0898, Train Acc: 0.9734, Valid Acc: 0.9724\n",
            "Epoch [31/100], Train Loss: 0.0869, Valid Loss: 0.0873, Train Acc: 0.9738, Valid Acc: 0.9723\n",
            "Epoch [32/100], Train Loss: 0.0850, Valid Loss: 0.0886, Train Acc: 0.9747, Valid Acc: 0.9720\n",
            "Epoch [33/100], Train Loss: 0.0837, Valid Loss: 0.0879, Train Acc: 0.9750, Valid Acc: 0.9725\n",
            "Epoch [34/100], Train Loss: 0.0828, Valid Loss: 0.0908, Train Acc: 0.9748, Valid Acc: 0.9731\n",
            "Epoch [35/100], Train Loss: 0.0816, Valid Loss: 0.0845, Train Acc: 0.9753, Valid Acc: 0.9732\n",
            "Epoch [36/100], Train Loss: 0.0797, Valid Loss: 0.0854, Train Acc: 0.9758, Valid Acc: 0.9741\n",
            "Epoch [37/100], Train Loss: 0.0790, Valid Loss: 0.0812, Train Acc: 0.9764, Valid Acc: 0.9747\n",
            "Epoch [38/100], Train Loss: 0.0776, Valid Loss: 0.0853, Train Acc: 0.9765, Valid Acc: 0.9734\n",
            "Epoch [39/100], Train Loss: 0.0767, Valid Loss: 0.0803, Train Acc: 0.9768, Valid Acc: 0.9732\n",
            "Epoch [40/100], Train Loss: 0.0758, Valid Loss: 0.0816, Train Acc: 0.9768, Valid Acc: 0.9753\n",
            "Epoch [41/100], Train Loss: 0.0745, Valid Loss: 0.0811, Train Acc: 0.9772, Valid Acc: 0.9742\n",
            "Epoch [43/100], Train Loss: 0.0731, Valid Loss: 0.0795, Train Acc: 0.9777, Valid Acc: 0.9759\n",
            "Epoch [44/100], Train Loss: 0.0721, Valid Loss: 0.0790, Train Acc: 0.9783, Valid Acc: 0.9739\n",
            "Epoch [45/100], Train Loss: 0.0712, Valid Loss: 0.0784, Train Acc: 0.9780, Valid Acc: 0.9750\n",
            "Epoch [46/100], Train Loss: 0.0711, Valid Loss: 0.0776, Train Acc: 0.9780, Valid Acc: 0.9755\n",
            "Epoch [47/100], Train Loss: 0.0690, Valid Loss: 0.0761, Train Acc: 0.9791, Valid Acc: 0.9760\n",
            "Epoch [48/100], Train Loss: 0.0688, Valid Loss: 0.0779, Train Acc: 0.9786, Valid Acc: 0.9758\n",
            "Epoch [49/100], Train Loss: 0.0678, Valid Loss: 0.0803, Train Acc: 0.9792, Valid Acc: 0.9743\n",
            "Epoch [50/100], Train Loss: 0.0671, Valid Loss: 0.0744, Train Acc: 0.9797, Valid Acc: 0.9766\n",
            "Epoch [51/100], Train Loss: 0.0663, Valid Loss: 0.0732, Train Acc: 0.9801, Valid Acc: 0.9765\n",
            "Epoch [52/100], Train Loss: 0.0654, Valid Loss: 0.0756, Train Acc: 0.9800, Valid Acc: 0.9768\n",
            "Epoch [53/100], Train Loss: 0.0647, Valid Loss: 0.0745, Train Acc: 0.9799, Valid Acc: 0.9766\n",
            "Epoch [54/100], Train Loss: 0.0640, Valid Loss: 0.0757, Train Acc: 0.9807, Valid Acc: 0.9758\n",
            "Epoch [55/100], Train Loss: 0.0636, Valid Loss: 0.0711, Train Acc: 0.9806, Valid Acc: 0.9786\n",
            "Epoch [56/100], Train Loss: 0.0623, Valid Loss: 0.0755, Train Acc: 0.9808, Valid Acc: 0.9774\n",
            "Epoch [57/100], Train Loss: 0.0622, Valid Loss: 0.0716, Train Acc: 0.9807, Valid Acc: 0.9776\n",
            "Epoch [58/100], Train Loss: 0.0617, Valid Loss: 0.0734, Train Acc: 0.9810, Valid Acc: 0.9772\n",
            "Epoch [59/100], Train Loss: 0.0612, Valid Loss: 0.0691, Train Acc: 0.9813, Valid Acc: 0.9774\n",
            "Epoch [60/100], Train Loss: 0.0603, Valid Loss: 0.0731, Train Acc: 0.9814, Valid Acc: 0.9776\n",
            "Epoch [61/100], Train Loss: 0.0596, Valid Loss: 0.0697, Train Acc: 0.9817, Valid Acc: 0.9775\n",
            "Epoch [62/100], Train Loss: 0.0593, Valid Loss: 0.0723, Train Acc: 0.9817, Valid Acc: 0.9771\n",
            "Epoch [63/100], Train Loss: 0.0591, Valid Loss: 0.0696, Train Acc: 0.9819, Valid Acc: 0.9786\n",
            "Epoch [64/100], Train Loss: 0.0582, Valid Loss: 0.0677, Train Acc: 0.9820, Valid Acc: 0.9777\n",
            "Epoch [65/100], Train Loss: 0.0575, Valid Loss: 0.0706, Train Acc: 0.9825, Valid Acc: 0.9785\n",
            "Epoch [66/100], Train Loss: 0.0572, Valid Loss: 0.0694, Train Acc: 0.9823, Valid Acc: 0.9782\n",
            "Epoch [67/100], Train Loss: 0.0572, Valid Loss: 0.0701, Train Acc: 0.9822, Valid Acc: 0.9785\n",
            "Epoch [68/100], Train Loss: 0.0561, Valid Loss: 0.0667, Train Acc: 0.9829, Valid Acc: 0.9785\n",
            "Epoch [69/100], Train Loss: 0.0553, Valid Loss: 0.0675, Train Acc: 0.9832, Valid Acc: 0.9784\n",
            "Epoch [70/100], Train Loss: 0.0550, Valid Loss: 0.0674, Train Acc: 0.9833, Valid Acc: 0.9790\n",
            "Epoch [71/100], Train Loss: 0.0548, Valid Loss: 0.0670, Train Acc: 0.9831, Valid Acc: 0.9795\n",
            "Epoch [72/100], Train Loss: 0.0541, Valid Loss: 0.0669, Train Acc: 0.9834, Valid Acc: 0.9785\n",
            "Epoch [73/100], Train Loss: 0.0539, Valid Loss: 0.0662, Train Acc: 0.9835, Valid Acc: 0.9797\n",
            "Epoch [74/100], Train Loss: 0.0536, Valid Loss: 0.0645, Train Acc: 0.9833, Valid Acc: 0.9798\n",
            "Epoch [75/100], Train Loss: 0.0530, Valid Loss: 0.0698, Train Acc: 0.9839, Valid Acc: 0.9779\n",
            "Epoch [76/100], Train Loss: 0.0525, Valid Loss: 0.0679, Train Acc: 0.9838, Valid Acc: 0.9789\n",
            "Epoch [77/100], Train Loss: 0.0521, Valid Loss: 0.0662, Train Acc: 0.9839, Valid Acc: 0.9797\n",
            "Epoch [78/100], Train Loss: 0.0516, Valid Loss: 0.0662, Train Acc: 0.9841, Valid Acc: 0.9784\n",
            "Epoch [79/100], Train Loss: 0.0515, Valid Loss: 0.0678, Train Acc: 0.9841, Valid Acc: 0.9797\n",
            "Epoch [80/100], Train Loss: 0.0510, Valid Loss: 0.0659, Train Acc: 0.9844, Valid Acc: 0.9796\n",
            "Epoch [81/100], Train Loss: 0.0502, Valid Loss: 0.0653, Train Acc: 0.9846, Valid Acc: 0.9793\n",
            "Epoch [82/100], Train Loss: 0.0502, Valid Loss: 0.0683, Train Acc: 0.9845, Valid Acc: 0.9777\n",
            "Epoch [83/100], Train Loss: 0.0497, Valid Loss: 0.0682, Train Acc: 0.9852, Valid Acc: 0.9788\n",
            "Epoch [84/100], Train Loss: 0.0494, Valid Loss: 0.0667, Train Acc: 0.9850, Valid Acc: 0.9782\n",
            "Epoch [85/100], Train Loss: 0.0494, Valid Loss: 0.0647, Train Acc: 0.9850, Valid Acc: 0.9793\n",
            "Epoch [86/100], Train Loss: 0.0487, Valid Loss: 0.0643, Train Acc: 0.9849, Valid Acc: 0.9800\n",
            "Epoch [87/100], Train Loss: 0.0484, Valid Loss: 0.0654, Train Acc: 0.9856, Valid Acc: 0.9797\n",
            "Epoch [88/100], Train Loss: 0.0482, Valid Loss: 0.0645, Train Acc: 0.9852, Valid Acc: 0.9793\n",
            "Epoch [89/100], Train Loss: 0.0472, Valid Loss: 0.0667, Train Acc: 0.9858, Valid Acc: 0.9792\n",
            "Epoch [90/100], Train Loss: 0.0471, Valid Loss: 0.0647, Train Acc: 0.9851, Valid Acc: 0.9813\n",
            "Epoch [91/100], Train Loss: 0.0470, Valid Loss: 0.0666, Train Acc: 0.9859, Valid Acc: 0.9788\n",
            "Epoch [92/100], Train Loss: 0.0467, Valid Loss: 0.0660, Train Acc: 0.9856, Valid Acc: 0.9796\n",
            "Epoch [93/100], Train Loss: 0.0466, Valid Loss: 0.0664, Train Acc: 0.9853, Valid Acc: 0.9796\n",
            "Epoch [94/100], Train Loss: 0.0458, Valid Loss: 0.0685, Train Acc: 0.9858, Valid Acc: 0.9803\n",
            "Epoch [95/100], Train Loss: 0.0456, Valid Loss: 0.0639, Train Acc: 0.9861, Valid Acc: 0.9810\n",
            "Epoch [96/100], Train Loss: 0.0451, Valid Loss: 0.0667, Train Acc: 0.9861, Valid Acc: 0.9797\n",
            "Epoch [97/100], Train Loss: 0.0448, Valid Loss: 0.0687, Train Acc: 0.9864, Valid Acc: 0.9788\n",
            "Epoch [98/100], Train Loss: 0.0444, Valid Loss: 0.0657, Train Acc: 0.9868, Valid Acc: 0.9805\n",
            "Epoch [99/100], Train Loss: 0.0437, Valid Loss: 0.0683, Train Acc: 0.9865, Valid Acc: 0.9785\n",
            "Epoch [100/100], Train Loss: 0.0440, Valid Loss: 0.0651, Train Acc: 0.9868, Valid Acc: 0.9803\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x360 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmEAAAFACAYAAAD07atFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAABRzklEQVR4nO3dd5xU5dn/8c81M9t3WdhCkQWX3lSk2BtYYo1G1AgpQsxjyZMYjTFGjYn9lzyJSYyJMSF2oxLFSNBYEgmosQKKiCCC1KWzwPYy5f79cWaXFSkL7DA7Z7/v12teO3PmnJlrRvfw3evc5z7mnENEREREDqxAsgsQERER6YgUwkRERESSQCFMREREJAkUwkRERESSQCFMREREJAkUwkRERESSIGEhzMweMrONZrZgF8+bmd1rZkvNbL6ZjUxULSIiIiLtTSI7YY8AZ+zm+TOBAfHb5cD9CaxFREREpF1JWAhzzr0ObNnNKucBjznPO0BnM+uRqHpERERE2pNQEt+7J7C6xeOy+LJ1u9uoqKjIlZaWJrAsEWlv5s6du9k5V5zsOvaX9l8iHc/u9l/JDGGtZmaX4x2ypHfv3syZMyfJFYnIgWRmK5NdQ1soLS3V/kukg9nd/iuZZ0euAXq1eFwSX/YFzrnJzrnRzrnRxcUp/8ewiIiISFJD2HTgkvhZkkcDFc653R6KFBEREfGLhB2ONLOngDFAkZmVAbcAaQDOuT8BLwJnAUuBWuBbiapFREREpL1JWAhzzk3Yw/MO+G6i3l8k0cLhMGVlZdTX1ye7FN/IzMykpKSEtLS0ZJciIpJwKTEwX6Q9KisrIy8vj9LSUsws2eWkPOcc5eXllJWV0adPn2SXIyKScLpskcg+qq+vp7CwUAGsjZgZhYWF6iyKSIehECayHxTA2pa+TxHpSBTCRFJUeXk5hx9+OIcffjjdu3enZ8+ezY8bGxt3u+2cOXP4/ve/f4AqFRGRndGYMJEUVVhYyLx58wC49dZbyc3N5brrrmt+PhKJEArt/Fd89OjRjB49+kCUKSIiu+DbTlhFXZgn313Fis01yS5F5ICZNGkSV155JUcddRTXX3897733HscccwwjRozg2GOPZfHixQDMmjWLc845B/AC3KWXXsqYMWPo27cv9957bzI/gohI0jnnWFdRxxtLNvHW0s2s3lLLpqoG3l1WzhPvrmR9RduMXfVtJ6y8uoGbnvuIey4+nNKinGSXI3LAlJWV8dZbbxEMBqmsrOSNN94gFArx6quvctNNN/Hss89+YZtPPvmEmTNnUlVVxaBBg/jOd76jaSJEpN2KRGNsqWmkOC8DMyMSjbFoXRXZGUH6FuVgZmysrOe/SzfTOTuN3gXZlHTJJjMtCMC6ijo+XF3B6i21lG2tpbI+QmM0Rk1DhHXb6lmzrY7qhsgu37/L19M569Ae+/05fBvCQgGvyReNuSRXIh3Bbc9/zMK1lW36mkMP6sQtXx6219tddNFFBIPejqaiooKJEyeyZMkSzIxwOLzTbc4++2wyMjLIyMiga9eubNiwgZKSkv2qX0SkNaIxRzBgRGOOOSu2MOOTjWypaaRzVhq5mSEM74SdnIwgeZkh5pdV8PKC9ZTXNNIpM0RpUQ6fbaympjEKQK+CLLp3ymTOyq24HSJAUW46wYCxobKheVleZogu2emkBY3s9BC9C7M5pl8h/Ypz6Nc1F+dg9ZZa6sJR+hbn0q84h4Pys9rks/s2hMUzmEKYdDg5Ods7vz/96U8ZO3Yszz33HCtWrGDMmDE73SYjI6P5fjAYJBLZ9V+AIiItOedYUV7LpxuqyMsIkZeZRl04SkVdmPLqBjZWNbCtNowZOAcbq7xO08bKBrbUNFIXjpIWNAJmNERipAcDFOamU1EXpjYerFrKSgtyypCuHN6rM8s317B8cw0XjCrhiNICKurCzFq8kXUV9Vx18gC+NLQbDZEYq7bUULaljjXb6miIxDisJJ/hvTrTryiX/Ozkdf19G8KCAS85R3eMwSIJsC8dqwOhoqKCnj17AvDII48ktxgRabc2VTUwb/U2Pt1QxcryGmobo9SHY3TKClGcm0E05lhXUc+Gynq21DZSWRcmJyNEUW4G67bVsXYPY6RyM7y44ZyjKC+Dnp2zOKpPAQU56eRmhmiIxAhHYozo3YWTBhU3rx+LN1JizlHTGKWqPkxhTgZZ6cFdvtc3jj74C8tGHdxlX7+ahPJ/CFMnTDqw66+/nokTJ3LnnXdy9tlnJ7scETkAYjFHRV2YTdUNbK7yOlFLNlbxyboqqhoiFGSn0zk7jez0EKGg8e7yLXy4elvz9l3zMsjNCJEeClC5Nszm6kYCATgoP4tunTIZ0qMTnTLTqG6IsLmqgeG9OvOdsUUc2jOfunhQykoP0jkrnYLcdIpzM0gP7dt5gIH4v+UBjPysAPlZ/hqrai7FOkWjR492c+bM2eN65dUNjLrzVW47dxgTjy1NfGHS4SxatIghQ4Ykuwzf2dn3amZznXMpP6dGa/dfIk3/NpsZzjk2VTWwaH0VKzbXsGpLLVtrG4nGHDUNUVZt8ZZFY460YIDGSIzIDg2IUMDoV5xLflYa2+oa2VYbjne7ogzrmc+pg7tybP9CBnbLIy8zbZe1pIQNH8OKN+GI/9k+NmlXnIMtyyC7ALIS0y3b3f7Lt50wDcwXEZH2IBpzLN1YzdKN1WRnBMnPSiMnPURWWpBPN1Qx/cO1vLOsnLRggIy0ALUNUbbEQ1ZOehAzo6Ju+0k1mWkBCnMySAsaGaEgvQtyOGFAMemhAOFIjPRQgKLcDIryMijOzaA4L51eBdlkhHZ9CG932lX4qtoAkTroVALBnUSYVe/AExdBQyVUroHTbvviOrEYrP0AFk2HT16A8qWQkQ9jb/KCW9PrNtbCzLugaCCMmugta6iCGXfA2BvbJLT5NoRpYL6IiBwIW2saKa9poG9RLoGAUVkf5o1PNzNv9VYWrKnkozUVu53uoHN2GmMGFhMMBKiPRMlJD9IlO51Q0KhpiBKOxujfNZfB3TvRrzineVqGhNu2Gla/C6vfg6zOMPrbkFMMC6bCm7+DyrUQroXex8CFD3ndJIC6bbDwH7DgWW/ZKT+DLn1g4TR4/dcQqYf0HO+1CvpAj+EwfAIEdhES6ytg7qPea66Jd5IDIehSCt2GQdehkF0I0TD85w7odBAMPhvevAfyukPn3vDRM1Cxxtu2YjVUrfNeo/R4OOIy+PRlePnHMPsBOPJy6HUE/ON7sGGBt83WFTDiGzDl67D5U+h7kvce+8m3IUwD80VEpC3Uh6PML6ugvLqB7vmZzSGouj7ClNmreOq9VdSHY3TOTqO0MIcFayqIxBzpoQBDenTiKyMOYmTvLgzqnkd9OEZl/Ky/unCUotx0jutfRFowAJFG+NdPoHgwjLwEgvsx/mnJv+HjaTDoDBh4phc6FkyF6k1eeMkp9ELWtlUQjV/mLJgGadkQroPlr3kdIti+7L+/9QJN+VLodigcMg4s4AWkB06Fs++GRc/DvCe9oFXQD8rmwCcvQtchsG6eF5i6DYPGGqhe73Wu3psM856CcZO90PPGb7xw13cMhDK85+sroMfhcPLNkNsNtiz3wtD6j2DhdCD+b323Q+Cbz3mhrL4CXr7BW55T7L0vBr2PhoFnwMDTt3ezjrrC64q98Wt46Ufesqwu8LWnYfGL8N/fwFu/h4xc+ObfvdragP9DmDphIiKyB+FojBWba/h0QzVLNlaxfHMNW2vDbKtt5JP1VTRGYjvdLhQwvjKiJ0eUdmHuyq0s21TDZSf25dQhXTmspLMXrlrr5RtgzoPe/Xf+CMPGQW25F0gK+3shIhaFmo1emKre4AWNtExIz4WCvl7Y+egZeP8xCKbDvL96YaJua7zgLO9wXpPMzl7IAi+MhWsBg9LjvM5X6XHQdRhsWwlv3wfrPoRxf4FDLtx+yOmQC+CpCfD4+d57HnYxjP4WHDQSqtbDv38GZe/B2b+GUd/6fMfLOfjwKfjndfC7wyAWgc4HQ34veOd+iIVh0Nkw5sdex2yn//HqvcOE4ZrPH6a84EF4+w9eeOt38s4PXzYxgyFf9m5r3vdC6CEXeKFzwJcgvwQ+mwXn/cHr3rUR3w7Mj0Rj9P/JS1x72kC+f8qAA1CZdDQamJ8YGpgvba2iNsxbn21mY1UD9eEoW2vDrNlWx/qKOqobotQ2Rli7rY5wtGkAuncmYFFuOp2y0hjcPY8j+xRyUOdM1lfUs7m6AcMIBY0j+xRQ0iV712++9FVY/BKkZYEFvc7TtlVehyen2OsMHXqh1xH6x//Csd/3Du/NuA02feIFqFAWVK394mtndfFCVKTBCyGNVd5yC3ivc9KPYdks77Bg0UA47KteF6x6gxfu8ksgM79tvuQty72O0SEXQl63vd9+81KY9XOvwzR8vNeVa6iG+m1enSmsQw7MVydMRKRj2lBZzwertvLB6m3MXeH9bPlvQVrQOKhzFj3yM+nZOYuDrJwuQ7tTelBXBnTNo19xLlkNm7yO0sJ/QP7ZMOQaMGPYQfnewO5Nn3jjpWa95/2s3eyFqs4Hw8k/gZ6jYNEL8PQlXgBzMa/TlF/irRMNxw+l/QNm/T8vOPU5EU65xevYDDrT6wo1HZKsr4BNn3qPc7tCdhGE0rd/aOe8cLV+AXTqET/0Bgw+y7u1lNfdu7Wlgj5wzHf3ffui/nDhg59flpHr3XzMtyHMzAiYQpj419ixY7nhhhs4/fTTm5fdc889LF68mPvvv/8L648ZM4a7776b0aNHc9ZZZ/Hkk0/SuXPnz61z6623kpuby3XXXbfL9502bRoDBw5k6NChAPzsZz/jxBNP5NRTT22bDyayB/XhKP+cv443l25m5ZZa1lfUk5cZonN2Gqvjs6KDF7YO75HJL4Zv5ri0xeT2PZLQkLPITAs1zz/F4pfg6YmwLhs6XQU5h8Drj3gDtV3MOyz26q3eIPQTf+Qdkpv7sBeKwAteJUdCfk+o2eR1tB44DQ6fAPOfhoNGwCXTICNv5x+mYo03VmvtPDjrV9sPmZl9fkxYZr43WHxXzBITriShfBvCwOuGaWC++NWECROYMmXK50LYlClT+OUvf7nHbV988cV9ft9p06ZxzjnnNIew22+/fZ9fS6Q1yqsbWLSuiiUbq1i8voqXFqynoi5M17wM+hbncERpF6obomypaeDwXp259LhSjs9aQf9VTxNcOA02x8dAzQc+Otk7TNe5N6x8C567ArofCjldYUb8/+WcYjjuahj+NW8s1r9/6o0tmv2A13Ea9hVvYHfJEd44rJZnKtZtg5dvhA/+6r3uN6buOoCBF96OuzoxX5y0e/4PYeqEiU9deOGF3HzzzTQ2NpKens6KFStYu3YtTz31FNdeey11dXVceOGF3HbbF+fJKS0tZc6cORQVFXHXXXfx6KOP0rVrV3r16sWoUaMA+Mtf/sLkyZNpbGykf//+PP7448ybN4/p06fz2muvceedd/Lss89yxx13cM4553DhhRcyY8YMrrvuOiKRCEcccQT3338/GRkZlJaWMnHiRJ5//nnC4TDPPPMMgwcPPtBfmaQA5xzvr9rK25+VM2/1Nj5aU8GGygZKbBMAlpHDCf1L+doxfTimbyFWt9XrPi2bCVWvwap1sLQGXNQbrD78Ym9gd++jvDPwZv4/eGj7Hy4cfBxMmAKZnby5o6rWQ79TPn+o7/S7vEOI6z+EY6+G4oG7/gBZneH8++HIy6CwX9uNuRJf8ncIM4Uw8a+CggKOPPJIXnrpJc477zymTJnCV7/6VW666SYKCgqIRqOccsopzJ8/n8MOO2ynrzF37lymTJnCvHnziEQijBw5sjmEjRs3jssuuwyAm2++mQcffJCrrrqKc889tzl0tVRfX8+kSZOYMWMGAwcO5JJLLuH+++/nmmuuAaCoqIj333+fP/7xj9x999088MADiftyJKVUN0RYs7WOhas28tC76/hojXeor19xDmf0NiZWPkTfja9u32B5OmyNXx+wfIn3My3bC1T9Tob0bC80HTLu812oo6+EQy+CVW97ZxjGonD41731wTt0uCtHXb53H6rnyL1bXzokf4cwdcLkQHnpBm+QbVvqfiic+YvdrtJ0SLIphD344IM8/fTTTJ48mUgkwrp161i4cOEuQ9gbb7zB+eefT3a294/Queee2/zcggULuPnmm9m2bRvV1dWfO+y5M4sXL6ZPnz4MHOh1CSZOnMh9993XHMLGjRsHwKhRo/j73//eqq9A/CW2/mPKX/0tG6J5LIr15pXGQ/lws3fx6NMCc7gv7XdUZ1zA+K/8hHMOO4j8T/4Gr/zEm3PqxOuhy8He/FKVa7yz8WIRb+xVr6O8Q4OhjD0XkVMIQ85J/IcVaQWFMJEUdt555/GDH/yA999/n9raWgoKCrj77ruZPXs2Xbp0YdKkSdTX1+/Ta0+aNIlp06YxfPhwHnnkEWbNmrVftWZkeP9ABoNBIpFdzx4u/tPQ2Minz/2cQYvuJcuFGEiYQyzKscGePNDv9/Qp6MT4uQ8StBy+2fg0lEXhs2pY8gocfDyce693aE/EZ/wfwjQwXw6EPXSsEiU3N5exY8dy6aWXMmHCBCorK8nJySE/P58NGzbw0ksvMWbMmF1uf+KJJzJp0iRuvPFGIpEIzz//PFdccQUAVVVV9OjRg3A4zBNPPEHPnj0ByMvLo6qq6guvNWjQIFasWMHSpUubx5CddNJJCfnc0r6t2FzDJ+urWLqxitnLt3D+yjv5SuB1/hs6hopTf8nIgQfTvfw9ej4ziVvKr4faLmBRuOJ179I2M2735sY64/+8S8js6SLMIinK/yEsqhAm/jZhwgTOP/98pkyZwuDBgxkxYgSDBw+mV69eHHfccbvdduTIkVx88cUMHz6crl27csQR20+Bv+OOOzjqqKMoLi7mqKOOag5e48eP57LLLuPee+9l6tSpzetnZmby8MMPc9FFFzUPzL/yyisT86Gl3XHOMevTTfztP+8xYs2TPBc9gU9cb67Nn8VXAq+zYth3OXbcnQSaZpAvOA2+PhWeuNC7DM64B7xu1wk/hN7HehN+FvRN7ocSSTDfzpgPcOzPZ3Bs/yLuvmgXlzoQ2Q+aMT8xNGN+OxeLfa4ztaGynqlzy3hmzmo6bfmIBzN+SzFbcBYictgE0j56CvqfCuOf2nlHa+082PAxjPj6gfsMIgdQh5wxHyAYNGIaEyYi0jb+9VPcu38i2m04m4tGc0/9uUxdsI1IzHH5Qcv4cdYdBPK6w/mPY/OeIm3e41436/w/7/qQ4kGHezeRDsjfIcyMiEKYiMh+i3z4NKG37uXN2CFklFUwas2fGEgZ3zzmRi45qhd9/nYLFJTCt172zkAsPR6O/B/I7e7NnSUiX+DrEBbQwHwRkf0TaaR69TzSpn2PubHB/PPQ3zPwoC50X/RTvrX+VWzMr2Hlv735ui56xAtgTXY375aI+DuEhTQwXxLMOYe1vGSJ7JdUG6Pqawv/Ac9fDXVbyQU2uM5s+NKf+Pnx8WA1+Db4w4vwxq9h+etQPBiGnJfUkkVSja9DWMDUCZPEyczMpLy8nMLCQgWxNuCco7y8nMzMzGSX0rHFYjDr5/D6L1meMZip4dPIysnj+LO/wbnDW3S2Cvt5E6W+92fv8bgHNJWEyF7ydQgLaWC+JFBJSQllZWVs2rQp2aX4RmZmJiUlJckuo0NrnPUr0l//JVNjY7it9ttcccoQLjuxLxmh4BdXPvF6+PBv3kz2h4w78MWKpDhfhzANzJdESktLo0+fPskuQ2TfVa6Dl66Hk34M3Q9hQ3k5mW/8gdejI3hz2K3868zB9MjP2vX2XQ6Grz4GnXpAYCchTUR2y98hLGDEdDhSROSLYjGYdiUsmwXbVrHk3H/w/IM/51pXScHpP+a3x7dyUP3gsxJapoif+foAfjBgRDQwX0Tki975IyybRU3fM2HdPJ7+481cHPkHtV1HMfL4M5NdnUiH4OtOmAbmi4jsxNIZMOM2yktO5ahPvsmjoTJuDD5BgBiM/W2yqxPpMHzdCdPAfBGRuMYaWPwyPHIO/HUckZzuXLBmAn2Lcxny7ckEgiEo7A+DdHhR5EDxfSdMA/NFpEPbsgz+eR2seAOijZDbjcZT/x8XzRnEFhdl+jdHU1CUA9+cBjlFmmZC5ADydQgLaWC+iHRkn82EZyZ594+6Atf3ZGbU9uP//Ws5y8treGjSEZQW5XjPlx6XtDJFOipfhzANzBeRDmvOQ14HrGggTHiScH4p333iff61cAF9i3N4aNIRjB3UNdlVinRovg5hAVMnTEQ6GOfgtf/zZr0f8CW48CFcei43TZ3PvxZu4MdnDOZ/TuhDWlCHHUWSzde/haGgEdWYMBHZDTM7w8wWm9lSM7thJ88fbGYzzGy+mc0ys5IWz0XNbF78Nv3AVr4TsRi8+CMvgA3/Gox/EjLy+P1/lvLM3DKuPmUA3xnTTwFMpJ3wfSdMIUxEdsXMgsB9wGlAGTDbzKY75xa2WO1u4DHn3KNmdjLwc+Cb8efqnHOHH8iadykWg39eC3MfhmOvgtPuADOe/3Atv/n3p1wwsoRrTh2Q7CpFpAVf/zkUCmieMBHZrSOBpc65Zc65RmAKcN4O6wwF/hO/P3Mnzyefc9sD2PE/aA5gC9ZU8KOpH3JEaRd+Pu5QXWhepJ1JaAhrRZu/t5nNNLMP4q3+Np2gJqCB+SKyez2B1S0el8WXtfQh0HR16vOBPDMrjD/ONLM5ZvaOmX1lZ29gZpfH15mTsIu9L5u5vQN2yi1gxubqBq54fC4F2en88eujSA/5+m9ukZSUsN/KFm3+M/H+kpxgZkN3WO1m4Gnn3AhgPPDHtqwhqIH5IrL/rgNOMrMPgJOANUA0/tzBzrnRwNeAe8ys344bO+cmO+dGO+dGFxcXJ6bCd/4EOV3h5J+CeZNU/+Bv89hc3cCfvzma4ryMxLyviOyXRP5p1Jo2vwM6xe/nA2vbsgANzBeRPVgD9GrxuCS+rJlzbq1zblz8j8WfxJdti/9cE/+5DJgFtPKq122o/DNY8gqMvhRCXtj68+vLeGPJZm49dxiHluQf8JJEpHUSGcJa0+a/FfiGmZUBLwJXtWUBGpgvInswGxhgZn3MLB2vI/+5sxzNrMjMmvaVNwIPxZd3MbOMpnWA44CWA/oPjHf/DIE0L4QBc1du5e5/Lebsw3ow/ohee9hYRJIp2YMEJgCPOOdKgLOAx1vs7Jrt65gKDcwXkd1xzkWA7wGvAIvwhkd8bGa3m9m58dXGAIvN7FOgG3BXfPkQYI6ZfYg3YP8XO5xVmXj1lTDvCThkHOR1o6o+zDV/+4Ae+ZkaiC+SAhI5RcUe2/zAt4EzAJxzb5tZJlAEbGy5knNuMjAZYPTo0a1OVYGAEdXAfBHZDefci3id+JbLftbi/lRg6k62ews4NOEF7s4Hf4XGajjqSgDueGEha7bW8cyVx9ApMy2ppYnIniWyE7bHNj+wCjgFwMyGAJlAm50+FDR1wkTEp6IReOd+6H0M9BzJvz5ez9NzyvjOmH6MOrgg2dWJSCskLIS1ss3/Q+CyeDv/KWCSc22XmoIamC8ifrVoOlSsgmO+R0VtmBv//hHDDurE1acMTHZlItJKCZ0xvxVt/oV4g1kTIqiB+SLiR87BW7+Hgr4w6EwemvEZ5TWNPHrpkZoPTCSF+Pq3VQPzRcSXVr0Na9+HY75LZWOMh95czunDunFIT01HIZJKfB3CAgHDOYipGyYifvL2fZBVAMO/xqNvrqCqPsJVJ+u6kCKpxtchLBg/PVvdMBHxja0rYfGLMPpbVLt0Hvjvck4d0lVdMJEU5O8QFoyHMHXCRMQv5jwIGIy+lL++s5KKurC6YCIpyt8hzBTCRMRHwnXw/mMw+GzCuQfxyJsrOLZfIcN7dU52ZSKyD/wdwgI6HCkiPvLRVKjbCkddwYsfrWN9ZT3/c0KfZFclIvuoY4QwzZovIqnOOXjvz9B1KK73sTz43+X0Lc5hzMCuya5MRPZRxwhh6oSJSKpb8z6s/wiO+B9mr9zG/LIKLj2uD4GArg8pkqo6RgjTmDARSXXznoBQFhx6IQ+/uZzO2WlcMLIk2VWJyH7wdwjTwHwR8YNwPSyYCkPOodpymLFoI+eP6ElWejDZlYnIfvB3CFMnTET84NOXoL4CDv8ary3eRGM0xhnDuie7KhHZTwphIiLt3bwnoVNP6HMSr3y8noKcdEaXFiS7KhHZTx0jhGlgvoikqqr1sPRVGD6expgx85ONnDqka/P+TURSV8cIYeqEiUiqWvQ8uBgMn8Dby8qpaohwug5FiviCv0OYBuaLSKrbtBgy86FoAK98vJ7s9CDH9S9KdlUi0gb8HcLUCRORVLd1BXQpJRZz/HvhBsYMKiYzTWdFiviBQpiISHsWD2GfbapmU1UDJw/uluyKRKSN+DqEBTQwX0RSWSwG21ZCl1IWb6gCYEiPvCQXJSJtxdchLKROmIiksqp1EG2ELqV8uqGagEG/4txkVyUibcTXIUwD80UkpW1d7v3sUsqSDVUcXJij8WAiPuLvEBbvhMUUwkQkFW1d4f3s0odPN1QxoKu6YCJ+0iFCWEQhTERS0dYVYEEacw5iRXktA7tpPJiIn/g6hGlgvoiktK0rIL+E5VsbicYcA7qpEybiJ74OYc0D86MKYSKSgrYsjw/K986MHNBVnTARP/F1CAuYOmEiksLic4Qt2VBFwKBvcU6yKxKRNuTrEBYKamC+iKSohiqo3dw8PUWpzowU8R1fh7CmKSo0MF9EUs7Wld7Pgj58urFK48FEfMjXIaxpYH5MhyNFJNXEp6do7NSblTozUsSXfB3CmgbmRzQwX0RSTXyi1hWxYqIxR3/NESbiO74OYRqYLyIpa+sKyMznk20hAHXCRHzI1yFMA/NFJGXFz4xct60OgF4F2cmtR0TaXCjZBSSSBuaLSMrKKoDOvZv3X2nxPypFxD98HcI0MF9EUtYFfwEgOmMJsP2PShHxD38fjtTAfBFJcdF4J6zpWrgi4h++DmHqhIlIqovGHAEDUydMxHd8HcKarx2pMWEikqKizhEK+HpXLdJh+fo3O6CB+SKS4qIxhzKYiD/5+le7aQyFpqgQkVQVjakTJuJXvv7N1hQVIpLqmsaEiYj/+DqEBQKGmQbmi0jqisYcoaCvd9UiHZbvf7NDAdPAfBHZJTM7w8wWm9lSM7thJ88fbGYzzGy+mc0ys5IWz000syXx28RE1BeJuebxrSLiL74PYQFTCBORnTOzIHAfcCYwFJhgZkN3WO1u4DHn3GHA7cDP49sWALcARwFHAreYWZe2rjEaizWf6S0i/uL7EBZUJ0xEdu1IYKlzbplzrhGYApy3wzpDgf/E789s8fzpwL+dc1ucc1uBfwNntHWB0ZgmahXxqw4RwjQwX0R2oSewusXjsviylj4ExsXvnw/kmVlhK7fdb9FYTCFMxKc6RAjTwHwR2Q/XASeZ2QfAScAaINrajc3scjObY2ZzNm3atNdvHnXqhIn4VUJD2J4GvMbX+aqZLTSzj83sybauQQPzRWQ31gC9WjwuiS9r5pxb65wb55wbAfwkvmxba7aNrzvZOTfaOTe6uLh4rwtUJ0zEvxIWwloz4NXMBgA3Asc554YB17R1HRqYLyK7MRsYYGZ9zCwdGA9Mb7mCmRWZWdO+8kbgofj9V4AvmVmX+ID8L8WXtalozDXPeSgi/pLITlhrBrxeBtwXH9SKc25jWxehTpiI7IpzLgJ8Dy88LQKeds59bGa3m9m58dXGAIvN7FOgG3BXfNstwB14QW42cHt8WZuKxpw6YSI+FUrga+9s0OpRO6wzEMDM3gSCwK3OuZfbsoiAQpiI7IZz7kXgxR2W/azF/anA1F1s+xDbO2MJoRAm4l+JDGGtff8BeH9plgCvm9mh8fEWzczscuBygN69e+/VGwQDRlQD80UkRUUUwkR8K5GHI1szaLUMmO6cCzvnlgOf4oWyz9mfga2aJ0xEUlnMOU3WKuJTiQxhexzwCkzD64JhZkV4hyeXtWURQQ3MF5EUFok6AgphIr6UsBDWygGvrwDlZrYQbybqHznnytuyDnXCRCSVqRMm4l8JHRPWigGvDrg2fksIhTARSWWRmCMzTSFMxI86xIz5GpgvIqkqpoH5Ir7VMUKYOmEivmZmX24xoaqvRDRZq4hv+XKn1ZIG5ot0CBcDS8zsl2Y2ONnFtCXNEybiX/4PYeqEifiec+4bwAjgM+ARM3s7fuHsvCSXtt8UwkT8SyFMRHzBOVeJN7P9FKAHcD7wvpldldTC9lPUKYSJ+FXHCGEamC/ia2Z2rpk9B8wC0oAjnXNnAsOBHyaztv2lTpiIfyX7skUJp06YSIdwAfBb59zrLRc652rN7NtJqqlNKISJ+Jf/Q5gG5ot0BLcC65oemFkW0M05t8I5NyNpVbWBqM6OFPGtjnE4UiFMxO+eAWItHkfjy1JeJOYIBRXCRPxIIUxE/CDknGtsehC/n57EetpMLOYIqBMm4ku+D2EBDcwX6Qg2tbgmLWZ2HrA5ifW0mUhM144U8SvfjwkLqRMm0hFcCTxhZn8ADFgNXJLcktpGLOYIKISJ+JLvQ5gG5ov4n3PuM+BoM8uNP65OckltRp0wEf9qVQgzsxygzjkXM7OBwGDgJedcOKHVtYFgwIgphIn4npmdDQwDMi0+hso5d3tSi2oDUadOmIhftXZM2Ot4O7aewL+AbwKPJKqothQMGBGFMBFfM7M/4V0/8iq8w5EXAQcntag2ElUnTMS3WhvCzDlXC4wD/uicuwjvL852LxAwYhqYL+J3xzrnLgG2OuduA44BBia5pv3mnNM8YSI+1uoQZmbHAF8H/hlfFkxMSW0rpE6YSEdQH/9Za2YHAWG860emtKZdVzDg+xPZRTqk1g7Mvwa4EXjOOfexmfUFZiasqjYU0MB8kY7geTPrDPwKeB9wwF+SWlEbaNp3abJWEX9qVQhzzr0GvAZgZgFgs3Pu+4ksrK2ENDBfxNfi+6QZzrltwLNm9gKQ6ZyrSG5l+68phGmyVhF/alWP28yeNLNO8bMkFwALzexHiS2tbWhgvoi/OediwH0tHjf4IYABzRNNa2C+iD+1dqDBUOdcJfAV4CWgD94Zku2eBuaLdAgzzOwCM3+1jKLReCdMIUzEl1obwtLMLA0vhE2Pzw+WEslGA/NFOoQr8C7Y3WBmlWZWZWaVyS5qf6kTJuJvrR2Y/2dgBfAh8LqZHQykxA4uYIZz3qnePvsjWUTinHN5ya4hESKxGKBOmIhftXZg/r3AvS0WrTSzsYkpqW01/QUZjTmdYSTiU2Z24s6WO+deP9C1tKV4BlMnTMSnWnvZonzgFqBpR/cacDvQ7ge/Nv0FGYk5Qikxs5mI7IOWJwplAkcCc4GTk1NO22jqhGmyVhF/au3hyIfwzor8avzxN4GH8WbQb9eC8RCmwfki/uWc+3LLx2bWC7gnOdW0naZOWFCdMBFfam0I6+ecu6DF49vMbF4C6mlzoRadMBHpMMqAIckuYn81d8IUwkR8qbUhrM7MjnfO/RfAzI4D6hJXVttpmuRQE7aK+JeZ/Z7tZ2wHgMPxZs5PaU0dfIUwEX9qbQi7EngsPjYMYCswMTElta2mwfi6dJGIr81pcT8CPOWcezNZxbSVpg6+QpiIP7X27MgPgeFm1in+uNLMrgHmJ7C2NtHUCVMIE/G1qUC9cy4KYGZBM8t2ztUmua79EokqhIn4WWsnawW88BWfOR/g2gTU0+aadl5RDcwX8bMZQFaLx1nAq0mqpc00H47U2ZEivrRXIWwHKbFXaAphTX9RiogvZTrnqpsexO9nJ7GeNtF8OFJzHIr40v6EsJRINU1/QWqKChFfqzGzkU0PzGwUKXLy0O40nVCkTpiIP+12TJiZVbHzsGV8vvXfbmlgvkiHcA3wjJmtxds/dQcuTmpFbaCpE6YZ80X8abchzA/XY9PAfBH/c87NNrPBwKD4osXOuXAya2oLTZ0wXTtSxJ/253BkStDAfBH/M7PvAjnOuQXOuQVArpn9b7Lr2l/qhIn4W4cJYRqYL+JrlznntjU9cM5tBS5LXjltI6rJWkV8zf8hTAPzRTqCoNn20etmFgTSk1hPm4hqnjARX2vtjPkpK6iB+SIdwcvA38zsz/HHVwAvJbGeNqFOmIi/dZhOmEKYiK/9GPgP3iXWrgQ+opVncJvZGWa22MyWmtkNO3m+t5nNNLMPzGy+mZ0VX15qZnVmNi9++1Mbfh5g+35LIUzEn/zfCQsohIn4nXMuZmbvAv2ArwJFwLN72i5+2PI+4DSgDJhtZtOdcwtbrHYz8LRz7n4zGwq8CJTGn/vMOXd4m32QHUQ1MF/E1xTCRCRlmdlAYEL8thn4G4BzbmwrX+JIYKlzbln89aYA5wEtQ5gDOsXv5wNr97/y1mnabwU0WauIL/n/cKSmqBDxs0+Ak4FznHPHO+d+D0T3YvuewOoWj8viy1q6FfiGmZXhdcGuavFcn/hhytfM7IS9rn4PtnfCfL+rFumQfP+brU6YiK+NA9YBM83sL2Z2Cm1/XdsJwCPOuRLgLOBxMwvE37e3c24EcC3wpJl12nFjM7vczOaY2ZxNmzbt1Rs3d8J8v6cW6Zh8/6utgfki/uWcm+acGw8MBmbiXb6oq5ndb2ZfasVLrAF6tXhcEl/W0reBp+Pv9zaQCRQ55xqcc+Xx5XOBz4CBO6lxsnNutHNudHFx8V59vqYOvjphIv6U0N/sPZ111GK9C8zMmdnotq5BnTAR/3PO1TjnnnTOfRkvSH2Ad8bknswGBphZHzNLB8YD03dYZxVwCoCZDcELYZvMrDg+sB8z6wsMAJa1yQeKi6gTJuJrCfvVbnHW0ZnAUGBC/MyiHdfLA64G3k1EHQphIh2Lc25rvPt0SivWjQDfA14BFuGdBfmxmd1uZufGV/shcJmZfQg8BUxyzjngRGC+mc0DpgJXOue2tOVniWlMmIivJfLsyNacdQRwB/B/wI8SUYQG5ovI7jjnXsQbcN9y2c9a3F8IHLeT7Z6lFdNg7I+mTlhQZ0eK+FIi/7za41lHZjYS6OWc+2eiilAnTERSVVMnrOnKHyLiL0nrccfPLvoNXqt/T+vu89lFGpgvIqlKnTARf0tkCNvTWUd5wCHALDNbARwNTN/Z4Pz9ObtInTARSVXRWAzQZYtE/CqRIWy3Zx055yqcc0XOuVLnXCnwDnCuc25OWxahECYiqSrqZTCFMBGfSlgIa+VZRwmngfkikqqaOmHKYCL+lNBrR+7prKMdlo9JRA1NISymTpiIpJiocwQDhmlMmIgv+X7ymaYBrRGFMBFJMZGY06FIER/zfQgLaEyYiKSoWMzpzEgRH/N9CAsphIlIiorEXPM+TET8x/chTAPzRSRVxWJOE7WK+Jh/Q1j5Z/C74YSWvgxANKoQJiKpJaLDkSK+5t8QlpYNW1cQqFoPqBMmIqkn5jQwX8TP/BvCsgsBCNSVY6YpKkQk9USiCmEifubfEBZKh4x8qNlM0ExTVIhIyomqEybia/4NYQA5hVC7mUDAdDhSRFJOVPOEifiav0NYdhHUbCYUMA3MF5GUoxAm4m/+DmE5RVBbTtDUCROR1BPV2ZEivubvEJZd6I0JC5oG5otIylEnTMTf/B3Cmjph6NqRIpJ6FMJE/M3fISy7CGJhOgXqiOlwpIikmKjTZYtE/MzfISynCIAiqySigfkikmKiMUdAIUzEt/wdwrK9EFZgVRqYLyIpJ6oLeIv4mr9DWI43a36hVWpgvoiknEjMEdDZkSK+5e8Q1tQJo1ID80Uk5URjjlBQIUzEr/wdwuJjwrpQqYH5IpJyouqEifiav0NYWhak5dCFShojsWRXIyKyVzQmTMTf/B3CAHIK6R6qoWxrXbIrERHZK5onTMTf/B/CsovoGqxiRXmNBueLSEpRCBPxN/+HsJwiulBJfTjGhqr6ZFcjItJq3mSt/t9Ni3RU/v/tzi4iJ7INgOWba5Jbi4jIXtBkrSL+5v8QllNIesNWwLFic22yqxERaTUNzBfxN/+HsOwiAtF6OgfDrChXJ0xEUoemqBDxN/+HsPhcYYd0adThSBFJKeqEifib/0NYfNb8IZ3CrFAIE5EUEtGYMBFf838Ii3fC+ufUsXJLraapEJGUEXPqhIn4mf9DWLZ3Ee/emXU0RmKsrdCkrSKSGiLRmOYJE/Ex/4eweCesR6gaQGdIikjKiDkUwkR8zP8hLD0XghkUBSoBWK4zJEUkRURi6oSJ+Jn/Q5gZ5HgTtmaEAhqcLyIpIxZTJ0zEz/wfwgDyS7DyzygtzFEIE5GUEYnFCGqeMBHf6hghrPR4WDOXwV1iOhwpIinBOacxYSI+1zFCWN+x4KKckP4pq7fUUh+OJrsiEZHdisan01EIE/GvjhHCeh0JoSyOZj7hqOO/SzYnuyIRkd2KKISJ+F7HCGGhDDj4WHqWv0teZoiXFqxPdkUiIrsVcwphIn7XMUIYQL+xWPmnXNDfeHXRBsLRWLIrEpF2wMzOMLPFZrbUzG7YyfO9zWymmX1gZvPN7KwWz90Y326xmZ3elnU1dcI0Y76If3WcENZ3DAAXdPmMirow7ywrT249IpJ0ZhYE7gPOBIYCE8xs6A6r3Qw87ZwbAYwH/hjfdmj88TDgDOCP8ddrE02XWAvo7EgR3+o4IazrMMgpZmjdXLLTgzokKSIARwJLnXPLnHONwBTgvB3WcUCn+P18YG38/nnAFOdcg3NuObA0/nptorkTFlQIE/GrjhPCAgHocxLB5a9x8sAi/vXx+uazj0Skw+oJrG7xuCy+rKVbgW+YWRnwInDVXmy7z2IamC/iex0nhAEMOhNqNvL1bivYXN3Iu8t1SFJE9mgC8IhzrgQ4C3jczFq97zSzy81sjpnN2bRpU6vftPnsSB2OFPGtjhXCBp8DmZ05YssLdMlO48+vLUt2RSKSXGuAXi0el8SXtfRt4GkA59zbQCZQ1Mptcc5Nds6Nds6NLi4ubnVhmidMxP86VghLy4Th4wl9+k++e3QBr326iXmrtyW7KhFJntnAADPrY2bpeAPtp++wzirgFAAzG4IXwjbF1xtvZhlm1gcYALzXVoUphIn4X0JDWCtO/b7WzBbGT/ueYWYHJ7IeAEZ8E6KNfDP7XTpnp3HvjCUJf0sRaZ+ccxHge8ArwCK8syA/NrPbzezc+Go/BC4zsw+Bp4BJzvMxXodsIfAy8F3nXJtdjiOqecJEfC+UqBducer3aXgDVmeb2XTn3MIWq30AjHbO1ZrZd4BfAhcnqiYAuh8CB40kY/5f+Z/jHuXufy9hftk2DivpnNC3FZH2yTn3It6A+5bLftbi/kLguF1sexdwVyLqUidMxP8S2Qnb46nfzrmZzrna+MN38MZUJN7IS2DjQr5Vupn8rDR+8dInOKczJUWk/YhqslYR30tkCNvb07e/DbyUwHq2O/RCyMwnZ/Z9XHf6IN76rJxn5pYdkLcWEWmNqCZrFfG9djEw38y+AYwGfrWL5/fpFO9dysiDI6+AT17g66U1HFlawJ0vLGRjZf3+v7aISBuIarJWEd9LZAhr1enbZnYq8BPgXOdcw85eaF9P8d6to78DaTkE3vwtv7jgUOojMW6etkCHJUWkXYioEybie4kMYXs89dvMRgB/xgtgGxNYyxdlF8ARl8KCqfQNbuSHpw3kXws38Nd3Vh7QMkREdibmmsaEtYsDFiKSAAn77W7lqd+/AnKBZ8xsnpntOD9PYh3zPQikwYw7uOz4PowdVMztLyzU3GEiknSRaLwTpgwm4lsJ/fV2zr3onBvonOsXP5Ub59zPnHPT4/dPdc51c84dHr+du/tXbGN53eHEH8HHfycwezK/vfhwunXK5H//OpctNY0HtBQRkZbUCRPxP/12n/BDGHQWvHITnTe+x/1fH8Xmmkb+94m5hKOxZFcnIh1U87UjtZcW8S39egcCcP6foaAvPD2RQ3Mr+b8LDuWdZVu4/fmFe95eRCQBYs0hTLtpEb/SbzdAZicY/yREGuBv3+D8Qwq54qS+PP7OSh59a0WyqxORDqi5E6azI0V8SyGsSfFAGDcZ1s2DF37A9V8axKlDunHL9I/52+xVya5ORDqYaMwbDqHLFon4l0JYS4PPgpNugA+fIvjkBdx3coiTBhZzw98/4unZq/e8vYhIG2kakqoQJuJfCmE7OunH8KW7YM37ZDw4hgdLXuT4foVc/+x8Hn97RbKrE5EOIqJOmIjvKYTtKBCAY78HV38II75O6K3f8tCgdzh1SFd++o+PuW/m0mRXKCIdQNMUFQphIv6lELYrWZ3hy7+HYeeTNuMW/nTYUs47/CB+9cpirpnyAZX14WRXKCI+1jRZa0ghTMS3FMJ2p2n6itITCP3jSu7Jfpgfn9SV5+ev48x73mDuyi3JrlBEfEqdMBH/Uwjbk1AGfO1vcMz3sA/+ync+Gs8rZ9USDBgTJr/Ls3PLkl2hiPjQ9slaFcJE/EohrDXSc+D0u+CK16BTD/q/+m3+dcirHNk7jx8+8yG/eOkT6sPRZFcpIj4SUwgT8T2FsL3R/VD49qsw+lIy3/sDj9f9L38+eCbvvf4Sv/nVrSyZeguubmuyqxQRH9BkrSL+F0p2ASknLRPO+S30Pw17935OX/4XTs8AGoEF8OqyT+n+9T9xSM/8ZFcqIiks2hTCggph0vbC4TBlZWXU19cnuxTfyMzMpKSkhLS0tFZvoxC2rwaf5d3KP4NNiwl36ceSf97Dyaue4tw/PEa/4cfzg1MHUlqUk+xKRSQFRdUJkwQqKysjLy+P0tJSTP+P7TfnHOXl5ZSVldGnT59Wb6fDkfursB8MPou0boMY+rVfQE4xfy6cwr8+Xsupv3mNm577iI1V+ktDRPZOVGdHSgLV19dTWFioANZGzIzCwsK97iwqhLWlzHwCp91Oz+oFfDD4SR7r+Rw5c//Ml3/1T377708pr25IdoUikiKiUYUwSSwFsLa1L9+nDke2tcMuhs/+Q+aymRwbaeDYUCXXBv7Og6+dyhmzzmb0kP5cNLqEEwYUkxYMQCwKa96HnqO8eclERGjRCdM/lOJD5eXlnHLKKQCsX7+eYDBIcXExAO+99x7p6em73HbOnDk89thj3HvvvQek1kRSCGtrgQBc8Jftj9d9SNYbv+a7C6dzWeDfPPrZ2fzs4+Opz+rBtwfWM7H8N2RvmgfHXQ2n3Z60skWkfYnGHGYQUCdMfKiwsJB58+YBcOutt5Kbm8t1113X/HwkEiEU2nlEGT16NKNHjz4QZSacQlii9RgOX30M27iIjJn/j8sXPcPlGc9Q7zIJLgpTQQ4fhUZx1Ju/Y3PuEIqOmZDsikWkHYjGnC5ZJB3KpEmTyMzM5IMPPuC4445j/PjxXH311dTX15OVlcXDDz/MoEGDmDVrFnfffTcvvPACt956K6tWrWLZsmWsWrWKa665hu9///vJ/iitphB2oHQdAhc/DhsXwap3yNz0CQ2xIK/nj+eZBdu4du0PGfby1fzkvWqGHX06Zx/ag/zs1p/mKiL+Eo05AjoUKQfAbc9/zMK1lW36mkMP6sQtXx6219uVlZXx1ltvEQwGqays5I033iAUCvHqq69y00038eyzz35hm08++YSZM2dSVVXFoEGD+M53vrNX00Qkk0LYgdZ1iHcDMoBxwLjjYd2aqcQeO427tl7H2y88xAPPD+PYrNX0C26ksv+5dD3tajrlFyS1dBE5cNQJk47ooosuIhgMAlBRUcHEiRNZsmQJZkY4HN7pNmeffTYZGRlkZGTQtWtXNmzYQElJyYEse58phLUTPXoeDNe8h3v/MUa9dT/H1DzDuthBrGzsxBEL7mHbR3/hxawx1JccR+GwUxgxpB+dMtPAOVg6A4oGQJeDk/0xRKSNRGJO48HkgNiXjlWi5ORsn1vzpz/9KWPHjuW5555jxYoVjBkzZqfbZGRkNN8PBoNEIpFEl9lmFMLak6zO2HHfJ/3o/4XGanpkdaYgEmX++2+Q+c49nLx1BplL/0nDkhAv/v1olnU+lgnunxxU/TGxzM4ELv4r9D4G3vodvDsZjvi2N+A/lLHn9xaRdiXm1AmTjq2iooKePXsC8MgjjyS3mARRCGuPgiHI6gxARijIYUeOgSPHQDRMw6o5bHnnKc5aOpWMqv+yzhVwS2Qi34i9Sumj57E+1JNekVXUdxlI5sy74MOn4ITrYPDZza8pIu1fJOY0R5h0aNdffz0TJ07kzjvv5Oyzz052OQlhLj4XTaoYPXq0mzNnTrLLSL76SiibTVW3I5i9po6Va9Zx7LwfU1y9mJsaJvJy7EjGpn3E7emP0ytaRtTSKO92LAz8EgVDxhKqL/cuuRQIQnYRVK6Bj6fB+o/ghGvh2O9r3jJpN8xsrnMu5c9J35v914+nzmfWpxt596ZTE1yVdESLFi1iyJAhyS7Dd3b2ve5u/6VOWKrK7AT9TyEPOHlwJxjcDU5+GVyM26rDnP7ZZhau7cONa8eQsXEeR9e9xmlr51K6/jV4fecv6YoGYT1HwKu3wPLXYNBZULUOsrrAyEsgMx9qyuGjp6HrUOh70gH9yCIdSdQ5TdQq4nMKYX5iBhakW6cg548o4fwRTU8cTV3jZXy2sYqXP/uIhuXv8mFFNq9tzqM+HKXAqqglg1XrSiiuTOdb+cOZtOx+0j77D86CmIvCa7+CAafC4pcgXOu97JAvw+HfgG0roaIM0rK9oHbwMdDjcK+efRVphNpy6NRjP78UkdQUjTmCQYUwET9TCOsgstKDHFLSmUNKToCTTuA8vJ386i21LNlYzaottWyubmB9RT0vlp/OY2449fX1bKYTwwIruYbpnLDgeebmnMiigZcwsnE2h336AMFFzwPggulYtHH7G3YdCt2GwYaPYcsySMuCjDwvpGV2huxCyOsOeT2geLB3dmflWlgzF1a+CSvehHCN14H70l1e50+kA/GmqNCQABE/UwjrwIIBo7Qoh9KinC8855xj9ZY63l+1lWWbB/F67RierWpg2aYals+roTF6DMUMpo+tZ7nrzrZgF/oUZDG8IMqJsXcZte1l8j99neoug4kNPIbckCPb1RBsqIC6bbBhgTe1RmPVFwsr6AeHf80br/beZPhsFhz2VSjsB/UV8NlML9zldYf8nlC7BcqXQm43OPmn0HcMzP8bzHnQC4PHfM8LeZs+geqNUHqCd/IDQOU6iEWgc6+WH37/ungibcCbrDXZVYhIIimEyU6ZGb0Ls+ldmP2F56Ixx6aqBtZW1LG+op5NVQ2sq6jns03VzN1UzStVR1DVMALngApgRdNrQmFOOsV5meRnhQhlBSgI1nFSl3JG5Wwkt6gE12MEuQU9yEr3JuvjkAvgxevgv78FF/WWFfTzDnnWbPLCWFaBF7xWvgVPXOA9rtsCRYPgo2fgg8e9Q6VNh1EL+8Mx34VV73rPuyj0ORH6nBTvwv0XCgd4Z5T2P9W79FQwHVa/A0v+Dek5UNDX6+7VbQUMBp3hjZ3bH+s/gprN3sXcU73z55x3cfqgdjH7Sp0wEf/THlL2WjBgdM/PpHt+5i7XicYc22ob2VzdyMaqetZtq2dtRR0bKhvYVFVPZV2EumiUBRUwfXEm0Du+5YfAh3TOTqN7p0wKctLpknsPXYcH6Je2hYJOuXTq3pdunTIoyEmnc3b69tP4I40w5yFYNgtGfMMLUbVbYO7DXges5yivu/bGb+CFH3jB7KgrvND2/mOw/HUvfI28xLu81Bt3w+u/hECadyi1bgsEQl7nbEehTO/90nO9IBWpAwuABb2wlpYNwTRv+/QcyCmCvIOgx2GQUwwzbvfqBMC8qyr0ONx7Pj3HCzWVa7ygVlvuPVcy2jucm5kPa9+Hj6bCmve9tBtM84Jit2Fw0AjodRQUD9l+xmukESrLvHryekC0EVa9DWvneR3HXkd7n6FsrrdeZj5kdIJwHTRUwfr53iHjaAOc8EMY9S3vJI5F070Qu/o9iNTDwNOh38ne6372H697edhXYdj5+x9afU6TtYr4n6aokKQrr25g7sqtbKsLE47G2FYbZl28y7a1NszWmkY2VTdQVf/F8GMGnbPSmgNZdnqQ/Kw0ehdkc3BhNrkZaQQDRmZagLzMNPIyQ+SmB8jf8iHZ3QdiOUXeC8ViULsZcrtuf/Gacq/7tfo9qFoPA07zQgUGW1d4AaSp6zbvSfj4OS/U5BR7wcvFIBr2wkhjrRfeYmEvxLQcPwdeWDv6O9BvLJTN8W7r5nndvuZ1Al4XL6vAC0FNnb0mhf2h3yleDZF62Pyp1yms2+I9H0jzAl0w3fusLtb0wt5rN3UaWyO7CA4+1usErnjDG+dXv817rmgg9DrSe79F073QmJYDfU6ALcth82Iv0F33qfc9tUJHnKLi0kdms6mqgeevOj7BVUlH1B6mqBg7diw33HADp59+evOye+65h8WLF3P//fd/Yf0xY8Zw9913M3r0aM466yyefPJJOnfu/Ll1br31VnJzc7nuuut2+b7Tpk1j4MCBDB06FICf/exnnHjiiZx66v5PB6MpKiTlFOZm8KVh3fe4Xl1jlA2V9d6tqoGtNY2U1zSypaaB8upGKuvDVNVHWL2llpcXrCcS2/0fGBmh2XTPz6RrXgZFuRl0yUknK20zGaEA6aEAacEAeZnD6NpjFN0GxTtvsXRy0oOEuh/S4pX6eF22s3/dug/snBfEKlbDug9h8xIY9hXvsCd4h0Cb1qvZtD2wZRVAevzwcDTihazazd4Yuy4HQ/fDvjiWzTnYutw79LrpEy+4Reoht7u3TSzqnRARi3ihqucob3zd6vcgLRN6jvY6ag1V0FDphab0XK+LZRa/bNar8MFfvY7bsK9Al9Lt73/W3d77Fg3wrtzgnBcu1y9odQDrqNQJE7+bMGECU6ZM+VwImzJlCr/85S/3uO2LL764z+87bdo0zjnnnOYQdvvtt+/za+0vhTBJGVnpwV2eSLCjSDTGuop66sJRIlFHXThKVTyk1TREqKwPN49l21TVwJKN1WytaaQ+HKU+EiO6hwAXChhpwQBmkB4K0CM/i56dM+nWKZPunTLplJVGeihAetALdBmhAF1y0inISScvI0R6KJO0zoNILxpCKGDYzk4EMPt8Z66lYAi6Dd3zl2bmhaiCvntet0nJaO/WUkYusJPpQsy8DuGA03ZdZ8vAauaFtYNG7Hx9aRbTBbzF5y688EJuvvlmGhsbSU9PZ8WKFaxdu5annnqKa6+9lrq6Oi688EJuu+22L2xbWlrKnDlzKCoq4q677uLRRx+la9eu9OrVi1GjRgHwl7/8hcmTJ9PY2Ej//v15/PHHmTdvHtOnT+e1117jzjvv5Nlnn+WOO+7gnHPO4cILL2TGjBlcd911RCIRjjjiCO6//34yMjIoLS1l4sSJPP/884TDYZ555hkGDx6839+BQpj4UigYoFfBF08qaK1YzNEYjVFZH2ZjZQMbq+rZWhNma20jtY3ReLiL4RzUR6Ks21ZP2dY65q7cytba8F69VzBg5GWG6JyVRqes+CHTjBC5GWnkZgTJzQyRl5lGRihAwLzw5y0LUZiTTlFuBtnpQcyMtKCRlRbceaiTlBKJxTRZqxwYL93gjTdtS90PhTN/sdtVCgoKOPLII3nppZc477zzmDJlCl/96le56aabKCgoIBqNcsoppzB//nwOO+ywnb7G3LlzmTJlCvPmzSMSiTBy5MjmEDZu3Dguu+wyAG6++WYefPBBrrrqKs4999zm0NVSfX09kyZNYsaMGQwcOJBLLrmE+++/n2uuuQaAoqIi3n//ff74xz9y991388ADD+znl6QQJrJTgYCRGQiSmRaka14mkN/qbevDUWoaIjRGYzRGvFtdOMq22jBbahqpaYw0L2+MxKiPRKmsi7CtLtzcrdtUVUNNQ5TqhgjVDZE9duZaagp1WWlBL7gFDJy3vDA3ncKcDLLSg5877JqVFqRHfibd8jObw14oYATjHb/MtCCZaQFCgQCBAORlpG0/g1USIhZD144U32s6JNkUwh588EGefvppJk+eTCQSYd26dSxcuHCXIeyNN97g/PPPJzvb+6P73HPPbX5uwYIF3HzzzWzbto3q6urPHfbcmcWLF9OnTx8GDhwIwMSJE7nvvvuaQ9i4ceMAGDVqFH//+9/396MDCmEibc4LLG0XUJzzDqc2xg+TNkZj1DREqKiLsKWmkc3VDdQ1RnFAYyRGdYMX5OrDUerDMaLOETAjHIlRXtPAovWV1Dd6h13DkRjhWIyGiNfV2xu5GSE6Z3sduoxQkJyMINnpIbLTvc+flR4kJz1IbkYaXXK8kycMoy4cxTnHRaN77flNOrBILEZ6SLtoOQD20LFKpPPOO48f/OAHvP/++9TW1lJQUMDdd9/N7Nmz6dKlC5MmTaK+vn6fXnvSpElMmzaN4cOH88gjjzBr1qz9qjUjIwOAYDBIJLKTs+T3gX7DRdo5M4uHm8S9Rzgaaz7pIRx1xGKOqHNEYo5wJEZ9JEZ9Y5RIfHllXZjN1Q1sqw173bxwlNrGKFtrG1m7LUp9JEpdY5SaBu/Q7Y7yMkPtJoSZ2RnA74Ag8IBz7hc7PP9bYGz8YTbQ1TnXOf5cFGg6jrPKOXcubSTq1AkT/8vNzWXs2LFceumlTJgwgcrKSnJycsjPz2fDhg289NJLjBkzZpfbn3jiiUyaNIkbb7yRSCTC888/zxVXXAFAVVUVPXr0IBwO88QTT9CzZ08A8vLyqKr64kThgwYNYsWKFSxdurR5DNlJJyX2GskKYSJCWjBASZdsSrrs+zi6XYlEY2yr8w7FAmS1cadwf5hZELgPOA0oA2ab2XTn3MKmdZxzP2ix/lVAy7MK6pxzhyeitt98dTgBjQmTDmDChAmcf/75TJkyhcGDBzNixAgGDx5Mr169OO6443a77ciRI7n44osZPnw4Xbt25Ygjjmh+7o477uCoo46iuLiYo446qjl4jR8/nssuu4x7772XqVOnNq+fmZnJww8/zEUXXdQ8MP/KK69MzIeO0zxhItLuJWqeMDM7BrjVOXd6/PGNAM65n+9i/beAW5xz/44/rnbO5bb2/bT/kvaiPcwT5kd7O0+YrokhIh1ZT2B1i8dl8WVfYGYHA32A/7RYnGlmc8zsHTP7SsKqFBFf0uFIEZHWGQ9Mde5zlxY42Dm3xsz6Av8xs4+cc5+13MjMLgcuB+jduzciIk3UCRORjmwN0PIMgZL4sp0ZDzzVcoFzbk385zJgFp8fL9a0zmTn3Gjn3Oji4uK2qFlEfEIhTEQ6stnAADPrY2bpeEFr+o4rmdlgoAvwdotlXcwsI36/CDgOWLjjtiLtVaqNCW/v9uX7VAgTkQ7LORcBvge8AiwCnnbOfWxmt5tZy+kmxgNT3Of3skOAOWb2ITAT+EXLsypF2rPMzEzKy8sVxNqIc47y8nIyMzP3ajuNCRORDs059yLw4g7LfrbD41t3st1bwKEJLU4kQUpKSigrK2PTpk3JLsU3MjMzKSkp2attEhrCWjEJYgbwGDAKKAcuds6tSGRNIiIiHV1aWhp9+vRJdhkdXsIOR7aYBPFMYCgwwcyG7rDat4Gtzrn+wG+B/0tUPSIiIiLtSSLHhB0JLHXOLXPONQJTgPN2WOc84NH4/anAKWaaIlpERET8L5EhrDWTIDavEx8gWwEU7vhCZnZ5fELEOTp+LSIiIn6QEgPznXOTgckAZrbJzFbuxeZFwOaEFJZYqVo3pG7tqVo3+L/2gw9EIYk2d+7czR1k/wWpW3uq1g2pW3uq1g37uf9KZAhrzSSITeuUmVkIyMcboL9Lzrm9mu3QzOYk4ppziZaqdUPq1p6qdYNqTxUdZf8FqVt7qtYNqVt7qtYN+197Ig9HtmYSxOnAxPj9C4H/OE1aIiIiIh1AwjphzrmImTVNghgEHmqaBBGY45ybDjwIPG5mS4EteEFNRERExPcSOiZsT5MgOufqgYsSWQPxsWQpKFXrhtStPVXrBtXuV6n83aRq7alaN6Ru7alaN+xn7aajfyIiIiIHnq4dKSIiIpIEvg1hZnaGmS02s6VmdkOy69kdM+tlZjPNbKGZfWxmV8eXF5jZv81sSfxnl2TXujNmFjSzD8zshfjjPmb2bvy7/1v8xIx2x8w6m9lUM/vEzBaZ2TGp8J2b2Q/i/58sMLOnzCyzvX7nZvaQmW00swUtlu30OzbPvfHPMN/MRiav8uTS/uvA0f7rwNM+bDtfhjBr3SWT2pMI8EPn3FDgaOC78XpvAGY45wYAM+KP26OrgUUtHv8f8Nv45ai24l2eqj36HfCyc24wMBzvM7Tr79zMegLfB0Y75w7BO+llPO33O38EOGOHZbv6js8EBsRvlwP3H6Aa2xXtvw447b8OIO3DduCc890NOAZ4pcXjG4Ebk13XXtT/D+A0YDHQI76sB7A42bXtpNaS+P+EJwMvAIY3cV1oZ/8t2ssNb0665cTHRbZY3q6/c7ZfZaIA78SaF4DT2/N3DpQCC/b0HQN/BibsbL2OdNP+64DWqv3Xga9d+7AWN192wmjdJZPaJTMrBUYA7wLdnHPr4k+tB7olq67duAe4HojFHxcC25x3GSpov999H2AT8HD8UMQDZpZDO//OnXNrgLuBVcA6vEt9zSU1vvMmu/qOU/b3to2l7Peg/dcBk5L7L9A+bEd+DWEpycxygWeBa5xzlS2fc16sblensprZOcBG59zcZNeyD0LASOB+59wIoIYdWvft9Dvvgnfh+z7AQUAOX2yVp4z2+B3LvtH+64BKyf0XaB+2I7+GsNZcMqldMbM0vB3YE865v8cXbzCzHvHnewAbk1XfLhwHnGtmK4ApeC393wGdzbsMFbTf774MKHPOvRt/PBVvp9bev/NTgeXOuU3OuTDwd7z/DqnwnTfZ1Xeccr+3CZJy34P2Xwdcqu6/QPuwz/FrCGvNJZPaDTMzvKsHLHLO/abFUy0v6zQRb6xFu+Gcu9E5V+KcK8X7jv/jnPs6MBPvMlTQDusGcM6tB1ab2aD4olOAhbTz7xyvhX+0mWXH/79pqrvdf+ct7Oo7ng5cEj/D6GigokXLvyPR/usA0P4rabQPaynZA94SOJDuLOBT4DPgJ8muZw+1Ho/XzpwPzIvfzsIbnzADWAK8ChQku9bdfIYxwAvx+32B94ClwDNARrLr20XNhwNz4t/7NKBLKnznwG3AJ8AC4HEgo71+58BTeOM+wnh/vX97V98x3qDo++K/sx/hnT2V9M+QpO9N+68D+xm0/zqwtWsfFr9pxnwRERGRJPDr4UgRERGRdk0hTERERCQJFMJEREREkkAhTERERCQJFMJEREREkkAhTA4IM4ua2bwWtza7sKyZlba8wr2ISFvS/ksSJbTnVUTaRJ1z7vBkFyEisg+0/5KEUCdMksrMVpjZL83sIzN7z8z6x5eXmtl/zGy+mc0ws97x5d3M7Dkz+zB+Ozb+UkEz+4uZfWxm/zKzrPj63zezhfHXmZKkjykiPqT9l+wvhTA5ULJ2aOdf3OK5CufcocAfgHviy34PPOqcOwx4Arg3vvxe4DXn3HC8a6V9HF8+ALjPOTcM2AZcEF9+AzAi/jpXJuajiYjPaf8lCaEZ8+WAMLNq51zuTpavAE52zi2LXwR4vXOu0Mw2Az2cc+H48nXOuSIz2wSUOOcaWrxGKfBv59yA+OMfA2nOuTvN7GWgGu+yHtOcc9UJ/qgi4jPaf0miqBMm7YHbxf290dDifpTt4x3PxruW10hgtplpHKSItCXtv2SfKYRJe3Bxi59vx++/BYyP3/868Eb8/gzgOwBmFjSz/F29qJkFgF7OuZnAj4F84At/zYqI7Aftv2SfKVXLgZJlZvNaPH7ZOdd0mncXM5uP99fghPiyq4CHzexHwCbgW/HlVwOTzezbeH8xfgfvCvc7EwT+Gt/RGXCvc25bG30eEek4tP+ShNCYMEmq+JiK0c65zcmuRURkb2j/JftLhyNFREREkkCdMBEREZEkUCdMREREJAkUwkRERESSQCFMREREJAkUwkRERESSQCFMREREJAkUwkRERESS4P8DCj5sl8xyZAwAAAAASUVORK5CYII=\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x720 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "F1 Score: 0.9802860641202584\n",
            "Precision: 0.980346785543814\n",
            "Recall: 0.9803\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "import requests\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "\n",
        "# Define a function to predict the class of an input image\n",
        "def predict_image(image_path, encoder, classifier):\n",
        "    # Open and preprocess the image\n",
        "    img = Image.open(image_path).convert('L')\n",
        "    img = img.resize((28, 28))\n",
        "    img_tensor = transforms.ToTensor()(img)\n",
        "    img_tensor = img_tensor.view(-1, 28*28)\n",
        "    # Pass the image through the encoder and classifier\n",
        "    with torch.no_grad():\n",
        "        features = encoder(img_tensor)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "    # Return the predicted class\n",
        "    return predicted.item()\n",
        "\n",
        "# Upload an image and predict its class\n",
        "from google.colab import files\n",
        "\n",
        "# Upload the image\n",
        "uploaded = files.upload()\n",
        "\n",
        "# Predict the class\n",
        "image_path = next(iter(uploaded))\n",
        "predicted_class = predict_image(io.BytesIO(uploaded[image_path]), encoder, classifier)\n",
        "\n",
        "# Print the predicted class\n",
        "print('Predicted class:', predicted_class)\n",
        "\n",
        "# Open the uploaded image\n",
        "img = Image.open(io.BytesIO(uploaded[image_path]))\n",
        "\n",
        "# Create a figure with the image and the predicted class as the title\n",
        "fig, ax = plt.subplots()\n",
        "ax.imshow(img)\n",
        "ax.set_title('Predicted Class: {}'.format(predicted_class))\n",
        "\n",
        "# Save the plot as a pdf\n",
        "plt.savefig('prediction22.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        },
        "outputId": "db6c5bac-5ea1-4ca7-ea04-871528f9bc52",
        "id": "IAAhLWPlsuci"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-9e6ce6f4-2abe-4375-b516-c755cb3e1629\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-9e6ce6f4-2abe-4375-b516-c755cb3e1629\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving test_image (32).jpg to test_image (32) (3).jpg\n",
            "Predicted class: 2\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAARcAAAEICAYAAAB1U7CaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAABxPElEQVR4nO29d6AkVZn+/3nPqepw40TikJMkiRKNIEYU14gRFGVNq666a1j1u8nfuq5rWteAooJrxoQIBlAySBBQMkicgWGYfFN3V53z/v44p/r2zNwLd2Du3FQP9NzqquqqU+mtNz6vqColSpQosaVhpnoAJUqUmJ0ohUuJEiUmBaVwKVGixKSgFC4lSpSYFJTCpUSJEpOCUriUKFFiUlAKlzkEEfm2iPx7nH6GiNyxlfarIrLnE/ztqSJy+ZYeU4nJRylcphlE5D4RGRGRQRF5JAqEni29H1W9TFX3mcB4Jv3hFpHni8ilIjIgIo+KyCUi8tLJ3OcEx1UVkTNF5P44thtF5IVTPa6ZglK4TE+8RFV7gEOBw4GPbbyCiCRbfVSTABF5JfBj4GxgCbAt8AngJVM5rogEeBB4FtBPuA4/EpFdp3JQMwWlcJnGUNVlwAXAAdA2L94lIncBd8V5J8Y36loRuVJEnlr8XkQOEZE/xbfuD4Fax7Jni8jSju87ichPo+awSkS+JCL7Al8Fjo6a1Nq4blVEPiMiD0Tt6qsiUu/Y1j+IyMMi8pCIvGW84xMRAT4L/JuqfkNV16mqV9VLVPVt4/zmCyLyoIisF5HrReQZHcuOEJHr4rJHROSzcX5NRP4vHtdaEblWRLadwPkfUtV/VtX74rjOA+4FDnu835Yohcu0hojsBLwIuKFj9suAI4H9ROQQ4JvA3wILga8B58aHvwL8HPgOsICgHbxinP1Y4DzgfmBXYEfgB6p6G/B24CpV7VHVefEnnwL2Bg4G9ozrfyJu6wXAB4ETgL2A5z7GIe4D7ASc8/hno41r434XAN8DfiwihdD8AvAFVe0D9gB+FOefQtA8diKcp7cDI3G8HxaR8yay4yiQ9gZu2Yzxzl2oavmZRh/gPmAQWEt42L8M1OMyBY7rWPcrhLd+5+/vIKjxzwQeAqRj2ZXAv8fpZwNL4/TRwKNAMsZ4TgUu7/guwBCwR8e8o4F74/Q3gU91LNs7jnvPMbZ9bFxWe4zzscH+x1i+BjgoTl8K/AuwaKN13hKP/alP4rqkwIXA16b6Hpkpn1JzmZ54marOU9VdVPWdqjrSsezBjuldgA9EVX9tNFt2AnaIn2Uan4yI+8fZ307A/aqaT2Bsi4Eu4PqOff46zifut3OM4+0TYFX8u/0E9guAiHxQRG4TkXVx3/3Aorj4NIIwuz2aPifG+d8BfgP8IJpqnxaRdDP2aeI2WsC7J/q7uY5SuMw8dAqLB4FPRkFUfLpU9fvAw8CO0a9RYOdxtvkgsPM4TuKNy+ZXEkyK/Tv22a/BAU3c704T2CcELetBxjHXNkb0r/wj8GpgvgYzbR1Bm0JV71LV1wLbAP8JnCMi3aqaqeq/qOp+wDHAicCbJrhPAc4kOJpfoarZRH5XohQuMx1fB94uIkdKQLeIvFhEeoGrgBx4j4ikIvJy4IhxtnMNQSh8Km6jJiLHxmWPAEuiDwdV9XG/nxORbQBEZEcReX5c/0fAqSKyn4h0Af9vvMFHrer9wMdF5M0i0iciRkSeLiJnjPGT3nhMjwKJiHwC6CsWisgbRGRxHOPaONuLyHNE5MDoW1oPZIAfb1wb4SvAvoQI3sjjrVxiFKVwmcFQ1euAtwFfIvge7ib4KFDVFvDy+H018Brgp+NsxxFCv3sCDwBL4/oAvyc4MJeLyMo470NxX1eLyHqCL2KfuK0LgM/H390d/z7WMZwT9/UWgo/oEeDfgV+MsfpvCCbYnQRzq8GGJtgLgFtEZJDg3D05CoTtCE7j9cBtwCUEMwcR+aiIXDDW2ERkF4Kz/OB4/IPx8/rHOqYSAbKhSV6iRIkSWwal5lKiRIlJwaQIFxF5gYjcISJ3i8iHJ2MfJUqUmN7Y4mZRdJrdSUiiWkpIenqtqt66RXdUokSJaY3J0FyOAO5W1XuiU/EHwEmTsJ8SJUpMY0xG8duObOjBX0pIVx8XC43VnZIJ5zSVKLFFISiKbDBPRUFlg7kqiuiG65WAm7LmSlVdvPH8KausFZHTgdMBltiEC7fd6XF+UaLElocqGE0AJbMeREm8kjiDYsisICjWe6x6MgNIKWA6sXjp3WNmYU+GWbSMDTM0l8R5G0BVz1DVw1X18IXGTsIwSpR4fAjgjMeZnIrmGHVYD7lRmmmO1RZeMjLraVmDloJlwpgMzeVaYC8R2Y0gVE4GXjcJ+ylR4klDRbG0sN6QmwpJVx8jOyzCArWHHiEfWk/VOTID3ijGaam5TBBbXLioai4i7yZkU1rgm6palqiXmLZoWcF1L6B20omYN76URdtvBwjN5cvhu79g6Ke/pHv9WlQ9eSlYJoxJ8bmo6vnA+ZOx7RIlniiC21YRBbB4AaNKYvtI/uHtzHv9a6DSBQpOhdq8xcjH96S51y5k/9/nca31VJxBFDLrsV7xYgChFDmboszQLTGHIJt8UxF43rOYf/LLMWk3KmBFsVYRI9hKNwtf80rsK08k9SktG34pWvhfDKLlYzQWyrNSYs5AVEAtTgxePMZ7sp4eam98DXm9ByWEpUGwGj7eKNRqdL31zbR22hVQcqMkzpJLBVGDKevzxkQpXErMIShoCDEjIbPF7LSE6v77k0iCCFgEEJwIKAgOL0Ky867U3nwyXT4lVYezeRQqDm/cFB/X9EQpXErMGagoIoF+UdTjxJDtvhtS78IriAeQ4ItBUaMIhkQNxgi9J72Y4cMPwashtzkV5/BG0U34tEpAKVxKzCkooJiYeetFMIsXYYxgUXILqGBQBB+0FgTxikqGW7SQ6rtPJevpx6hgVHBisaXPZUyUZ6XEnIFVpWUFVPFaoeoybLWOMQYjEkKnUvxjgASDgBWMpFTE0HPM0zEvPp7EVcmtp+JyXPkYjYnyrJSYUxBVVBQVwRvIm83gZRGJn87pzk94VGxape/tp9HceQeyaDapmQiv+dxDKVxKzCFIDD8H+txMlGztmlBgNEF4Eczue1B56+tJpIbiMGUx45gohUuJOQNFQoRHfBAIBipr1kI+cc3DGMEaQ/9JL8c97TAQQbSsjRsLpXApMYcgMTvXYzygUF29Fs02z6xRAdvfT/XvTqPRuwgvZSh6LJTCpcScQWH8hOxaj1GDrlyFH27Q0gz1ijolV8+4DI3q8YAXpXbk00hfcDyCKQJRoGB86Fsy1wPUpXApMXcg8YNFjQcMft0ahu+9PwgNDe2NHYwjGQTEYPEghrRSo/8tryHbdkmkblBURmNNpXApUWIuY3iE7KILSXKDALmNWbpj+WgldGSTmAuDCnafvam98sV4myDi8JKTGSHxRSnB3EUpXErMaVj1NH/7W/KVq/CiGBTL2LIFDRwiipBLpHVJanS9+iRaOy6hmoNVQojbzG3BAqVwKTHH4QWS+x5k+MKLwDtsDCuPLRoUo4yy0UkQJsnOu1B55Utp2WrQaryQm4LaYe6iFC4l5jySzDHyre/RevBBcgHFBd+s6uinLW5CjkyiEqbFI5LS88oTyXZdgool8ZSV0pTCpUQJnFW6b7+HtX//cZqXXko+MIhrtfAjI2S33c7ayy5D8zzIFTEdD40JH1GSHXam+vrXYiTBmRzrkzlPITVl7P8lSkwXeKBRyahcfx1Dp9/J2n33pLLjQmRNRnb7HeR9Vapnf53KTkswSPgvyg0l5L0YUXpffhJrz7sAuek6nFhEdU4LmFK4lJjTEA0fxGNwpEMrqV2zKlIpWNRmdK1I0W/9FP2nd4JNocNIkig+nCh+wULqb30jrff/mTzzc1qwQGkWlSgBIiiGXCwNkzCSJDRMDXBUs4QRU2HduT8mu/026PDDAJG3zmPEUPFQec6z8YcejqiUDt2pHkCJElMJlcJFKxhvsN6QeKHioGUClWXiPdUVDzF8xneh0QzazgZdAEJ2nlgl7emjeuop5LVq6No4h1EKlxJzHoGZTlHxeHEIOYZmzFnxiGQ4Afebixi4/AocigaJhI89BUQdLVG8KpVjjsUedlj4veQYH6inROcWZ10pXErMaUhREyDBe2IQVAzO2OhPCWUCRhPM8HqGvnwGfvUqNAasxUfTSIUExTrB9dfo/dtTyXvnY4JYITeR4W4O0TOUwqVEic1A7fpbaPzsZ6A5ogoFUZSE8gE1UFOLPfow/NFHkOYVcuMRievPISdvKVxKlNgM5LTIz/oJrYcfQpyQIagSzCaE3HoQSJNuzEFPITcWg1LNPV40dBWYIyiFS4kSmwn/4IMM/OhneJ9hvcVoLAPwhkRD3ZEawblWoNTEBHoHYU45eR9XuIjIN0VkhYjc3DFvgYj8TkTuin/nx/kiIl8UkbtF5M8icuhkDr5Eia0JQbGqiG/B939KfvudwaFrMhBwBlAhVQ8jDbjuFlLnaBmhZQ0KpL4ULp34NvCCjeZ9GLhIVfcCLorfAV4I7BU/pwNf2TLDLFFiGkBDzZCKkixfzqpPfx5Zvhz14DQHB06Vpmsw9MtfI9f9idxA4n27P/Vcihc9rnBR1UuB1RvNPgk4K06fBbysY/7ZGnA1ME9Ett9CYy1RYkqhIjGt35IbT+Wyq1j1kX+l8Ze/0Bxp0cgbyCMP0/rW92n+23+TDg2hIiHUDeHfueNyecLp/9uq6sNxejmwbZzeEXiwY72lcd7DbAQROZ2g3bDEllUIJaY/RDUQRolQy4VmMoL5w4WMXHcd7LIEqXcxsHwlbvlDpPkwGDOnSwCe9FOtqiqy+V4qVT0DOAPg4Ept7uiKJWYsAoWlw0tCIzF0ZcpIIsjAGsxfVqJYjDFUveJlrvPQPfFo0SOFuRP/rojzlwE7day3JM4rUWLGQxSMQupC76OBajCV0rxKThdKSlcWm8HKqDE0V/FEhcu5wClx+hTgFx3z3xSjRkcB6zrMpxIlZjRUoGUtiVfqmZJ4T+odraQFpkFuWzSSHC/MqUzc8fC4ZpGIfB94NrBIRJYC/w/4FPAjETkNuB94dVz9fOBFwN3AMPDmSRhziRJTAiEQb+cWiLkrPvpoRUO+yyjmulE0AeGiqq8dZ9HxY6yrwLue7KBKlCgx81Fm6JYoUWJSUAqXEiVKTApmbYJJYNkAYisI0VDXUQTNVWIGQmelaumD27oYwy2hQsc1Gvs3mzT/mEPFgDMJs1ZzKWgGrSqpV3IDXjxIE0RxVPBAqjmCjH0jl5hcSPin4FRREYwKiSpCrCKOd6jV4oUhiBqMCgYX+VZKTEfMXs1FoGUSrGYkmoOkVPJuEEPTNEj9CCpCJhVGUqg65jzn6daGojjrQutTDQLGiSEz0o7MGB1NRqv7nOHU47Ck3iKaoOJLATNNMauES0GaLCIISs1lNGyKbLMTlRc8C/u0gxBTIb/pFuS832KWLcXj6W8ImR1HDS8xaRAVUlcJ7TlQjI9N3I1HKNpyKCrhW0NqpC4nkRxnMtCgxcxiBXxGY1YJlwIaa0CQnOqBR9H1Hx+luvee5JUE65Xu55/A8Gv/hpFPfAp/xaUohjIvYetDUBKf00zCuTeeQF1QreN6exjpruAqCeIF08pIGw16Vg9hM0MmnkQN4j1aypZpiVklXApGdlUFFQZ234tFn/kwZq99C/cuzoBgqey8B+bj72f4jffD8gcomkSU2HrwAs0EfFIjXbgd7qB9McceSG2fA6kv3gHt64bUBqHTynEDa2k++BD5VX+CP1xKfu8d2DxHSs1lWmJmCRftmBBihqSLzO0WX6uT1Wrk8/ro22NXtn3t6zF7PQWrgrcOS2gSHmx9Q233vRl80fNIzzyDllEEEwiWjWBUkaiSlxgbio9RuFBPY+M5A0MuDg1d2zHeInic8RgVrDNkXXXynban6/AjMccdSfWgAzELtsWmaYgYRQdYUVWsgGy3mGTPvXDPeTr6ttfQ+tXvGfj290juvwuriicBcVgfY4XltZtSzCzhIuFtp4SH34vSqNWQgw6m67nPoX7gPsg222H75pH29iL1alubsfFQvYmM7QJqU3pOPI7155xDum5V2IExWPWIhghT+U4cH4kzZDaco4pTWhacMYh6RA2VXDDqadkcTBXb00++9274ow6l65ijSPfem3ThQoy1wMa9gMZAXGzVwuLtqb7p9VSOOoRV//U57O+voJrn5MaQG8VoqYdONWaUcAnvIyXNE3ILrruLrnefTs/rX4Ppnxf6hKuSoOQy/sGpQOo9Xgzm4P1I3vEW+OxXkdYInhw1SuJDaLR0xYwPbwSrJggV8VScC45Yn2AV8kqFxpIdSA7ZH3vM06kd+lRYsj3VSh0Q8uSJt9pQATGQ7rsPiz79H6z9+CfR3/wCySskLkUlK6XLFGNGCRdRwWPxtoUxXdj3/C3z3vwmtFLHSCARjAEGzGNIBSdFLgVUpE7faW9ifaNJ8j9fJ6OBzbvJjSP1TbxUttrxzTRIbCJWdQBCy0KCJdtmEc2nH0bXC55L36GHYRZugySKEfCkwWRRJVUNEmICGO3NXOxbYsJdgl20mAX//CFWrluHvfJSrHdobPVRYuowo4QLQOKEPPG4A/ah7+RX4pM6mfFUY/BSI5XgeDeWABbwxmAAZwVjuuh5+5sZWraU5JxzSbxhxDrUSHAmlhgTXiugjsw28V29sO9B6POeS+9xR1PbeUfySg0RCx5MbFEokURJRXBqsEzAHOpAyDZok0aSi8fgMdtsz8J/+hBr37UUf99fEV/6XKYaM0y4KJgmmemh9vznkfT24q0n1WAwGdFIgBybgIu0c18CQmPgzECiRQ5FyKdIKj10/eN7WXPPMvwNV2EwGFcH8nY7CIkBJWWWkhcWzdWlUACLZurhwIOmMDrtU0+2ZCe6nvkcqieeQHrAPphaLTjXjSFBA6G1IfYdJPhj4jn0Hftty4wxfCXa8TdsYzQnKVFCE3kDZr+9qX74Awx98GNU1q+LpR+jOk+gqZyVV25aYkYJl/CmstgE6k/dm9QkFK04i1yVQhkuGowbD9441BmMQG48iQfE4iTe9ALWOpJtljDvw+9n7Xv/nnT5UiCn6qCRhG1UnOJI20JmNsKgZEaxPrTDqOWezAY/F+IRY8nmL0AP3Z/KC5/PoqOPRrbbBk2SwGciii/S9OM1icn9YQcF/aMGp2vQNBXwoV0hglfwoqiCjYu9CKI+jlBRbZFLhZTIBuchE6F63DMZOO003Je+SH0ERiotrDfBv4YrXWhbETNKuAQIVsDM6++w1xUb61RGoajmKAk5FjEeox6LIMbgAZuDsVHTITStqh5+ID3/8C7yD3+aLBtk0ELqDNYLTkC8QWV22koqQosa1czhbZOeLMdLSqXexciCXmT/vak98+n0H3EMduedMUmKEQFTFH4GkWKh41KECb+RRuI7zFfxgooll/CKEAHxQSA5CZqO8YIXixclQfBUsErQtiQ43xNVNE3Z7pRXseLu2xj51W8QDKlXmonDYR7TF1diy2JGCZeQQaGg4JwDws3pxyyvDXUpTiHJHPnAaly9m6TSFW5qo/gkCInixjWqtJKUyktPxN9yH+ab3wGagGB8ElRv8cxe1UVRM0ySG0b6F9E64Ri6nnscdpc96Fq0iGReLyaphkLPUEk4qolMaOtBYIh6rPiYJ2PxxuIITeCt9/hWi+a6dZiHV5I9vIrMtUgX9VE7cH+Seh0VwYsEh7AJAqmglhSf0Fi4gAUf+gCr77+f2p9vw4vgRak48GVuwVbDjBIubThHtnwV9cK/Ms5q+fohhi69kvyPl9O65iaSo45l/j/8LdLbT+Il5rFI0MY15MBU1OCSHrrf9SbW3HI7tSuuJEsyfGzXmSU5xs/eSIQRR2vvfej+5D9RO+IwNKmCF8Q6BBtMTWKh4ajCEvAYUqbtq0FQbAxBR6GSO8z6dWR3383a666ncc212Dv+Sn3lOiRrouLJkgrDL38FCz/6fujpx1qHGhMY96NFlRuoqFDzgi7ZmXkffj/D7/gH/PoBEgdIi+DOL7E1MKOES8iWFSRvoX+6newFx5GadEzxooAfGWbt579E119voqIGe+d9NLoN9fe8nazaQ+pilpwUv4kJdwoyf1vqH3g7a+/8K7XVy0BcO818tgoWEMy2+9H92U/CQQfH8+rxBqwakOLRDAmMbb9KR5x445DxKEJ5okfwziHDQ+SPrGDkz7fhrvoTeuOfyR+6DzMyQC2H3BiGrCdVH7KmfYPKD3/Cuh23p++dp2K1AoS+zEYkdkIEDDHBEipHHUXjbW/Ef+4MnDaRUm3Zqpi+wmUjwiCJNruXoD5nK1bi1eFJMGo2CQIIglmwgJ79D8TceQfGJzRtzsi3fwA774F5zUnYaIEb9SCCjc7F3CpGLV2HHkLrtS/Hf/kMlAwA45NYbrDVzsTkIJ5PJ2AIKcuaVkj+/lQqBx0QTYng77BecEax6tscLIEKQWmnO8dIj4/apIE2EZcDspEhWLaM/OY7GLzmT5g/34w+8AAytBZxeWjkrgY0RVGqXsGBL0oLHKgM0/zm2WQH74c8/RlgQPDtnJYkXpdMQLzD2Aq9J5/Myosvxt5wIxBC53GoG5CHlVGkLY9pK1zG0rQFJVFP9rSnMf+9b8WYWhQMY21BkSSh92/fwNpbbyK94y5EDNWhdQx99n/p22UJ7qinYaJ5lI6mZ5EUnkZbpe/Nr2HNZVdh/nwjKi74G2aB7iIUp81gNMdLQn7AU1h4wgsRm0YNJb7pTSFTwrE7gg9XFDRKWdUoVjRoKHhLs9XCPXAv7qI/MHjZlbTu+Ct9j66lrjktS9R8BEjwxXiis9zF/UEs1QC8pKRrlrP2019k/h67kW63BLWC+FCQGgQaJCJggumlixfR+863Mvh3H8UMDaFCm6XfCaQatKkSWx7TVk/0Ej4FiofBdXfT9YG/Q3ffOUR+dHwbWoDKvvvQ+9+fxO++J1WX40hJH7mfwY/9K3r77XjTChoLIZmr8+ONh0Xb0f2+v8X19KAImfVh/gyHE3CiJD5oaUpC+vxnIfO7NzkPAYIjPMhJXjRk9ygOjeaOqKBNR3bXg6w567sMvO3tDJ78Rob/63PUL7uWRY+sQmgxUnF440hjg/a2kBEZvdAdn0LTSJwiaqjfdCsDn/1ffHOAJN4ojtBmVTSK/0i7IQjp059O+oxnUPFKbjzNJEQOC+E6mw3dqcS0FS7QQd5UJFkpsNcu1A88gMQb8hCvHNePqMYgRqg99WB6//Ofae20hKpzZEbRe+5g+N8/h1m9blyXsFGDN4bqs44lfdUrUCNU886BzWwIoXNgyyRIklI9+NDYKXBTqOYIDm88aoNPo7guzTzHPbyMoXN+xKr3vIuVrz+Z1r//f8hlVyFr1pF4JUscI6lHJWRZG7XkZvNuP2dAsTgZwf78PLIfnkeTHG+U1AefWdvPXFwi47HVXuqnnUzW20viwXpth6RdaQ5NGqa1cBnNDg32cZ5YzOFHYbvq+LYa7BkvGBoizcHxaJ52OLV3nQZJQjWvAAa54lLWfuuH5K459gA02PGSVul62xtxu+2BYrGzQLiETFdBxeFEkN4a9e2WhNyRsdbXBOMsqoLDo0MNWvcsZd3PzqP1no/SPOmN5P/4z9TOv5jeh9eQugYqI1h1GJ+QOIv1Ic3RqMX60FRsc9Cy0s7OzfwwQ1/+Ftx+GyoZooolCj1CUqUn5CUZgdqBB9J41tFASsUZnEhM4ps174pph2ksXIKzrQh5qoDO66P2ypeRJz4+HCa+qTa9O8Jb2eE1wYtijKF2/HMY3mkJLavUMkNTmjS/8y3yy/8U9qi64ccUif5CZfsdSN52Kj6tBKJvDXem0vF3BkERnIkE5g5aPSmt+f1jqoFKCNNrY5Dm5Zcx+Pn/YcVb38HAK96Af/9HaF7wU4ZW3Y/zjtwkNBNwkiK+jmiCNznO5ORGyY3GJESHl9HSiokg5KkoxqekLsGtvI/1//sdGB4hs45OwksTRx48QBm+XqfvpS9iuFZF1dBIwHrGFaYlnjweV7iIyE4i8gcRuVVEbhGR98b5C0TkdyJyV/w7P84XEfmiiNwtIn8WkUOfyMBUPEYNuQlvuFqekT/7OGp774mlEgveYLyq2pDfVWSBKsY7ZP5imjvugMGj4klcQrJ2Hev/+7/wy1fgaEYWOwAf62E8iuKMpf8lJ5AfcRhgYmQi+GUSb2GGkURbVYw35JJipIVsuxu2Vhn3jpAMBh9dTuPdH8V99ivYK6/ErF4OPsM6QyWzqChecoxXjC9Cz4XDNBB12ZiDqI9hzo4HaQvyINtTp3DRbxn54w3hZRB9LUU5WcjGBiMJYiyVI4+me5edaaWeemZxMeO35NWYHExEc8mBD6jqfsBRwLtEZD/gw8BFqroXcFH8DvBCYK/4OR34yhMdmsGR+tASZKh/HvNf8VJMmmAk+FJEBLOB07EDIngKRjkTC+ks0tcV2OikOHyDu/VWVp3xTWjFMKUA3oRHQwQb0r6Q3j56Tj0ZX+8jMxrC4jGnYuZp1oW5GUd+wL5UqtVx1hXECLpiBcm69WTWYX1BoV04YkN4ekPHbHCqBpfp6HpFvpJpR4smgKi9mjhNvH6+MUTz7HMwjVYIpxOvn3Q66A1WDOn8fuR5zwg5Ogre+BA5Ku2iScHjChdVfVhV/xSnB4DbgB2Bk4Cz4mpnAS+L0ycBZ2vA1cA8Edl+cwcmanEmJ3WKNyBHHUN62FM3dzPtUEMuBlWHHx5q53d4CYWN1ZZDf/BDGhddiVdoEfUQlfYrNmwmofasZ8Jxzwg+Hy1KBzQWTs4chCpkh6jHm4T6kQeiYscMswtKbhytW+/A+xxD8Gf5aeAMTbyBqy+ndfOdoLpBhHFjqFjs806Arl6ceJzJsbM423qqsVlPhIjsChwC/BHYVlUfjouWA9vG6R2BBzt+tjTO23hbp4vIdSJy3SrvxtyfYmgmikm66XrtK6DWPfHBajg4Hx+XVKE1MkD3Q49ssJpBsArVgbWMfP7LZCseIYgWBwQHYi6CigZTrN5N9aXPpaKGxBM7N/oxH8rpjOJlbVBcdzdm111izsrYTheXt7BX3UCGI/GKM4qZBm98o4prrmXkgovAu1DH2DZtN4QI1PfYC/bZFySYUG5mvRNmFCZ8akWkB/gJ8D5VXd+5TFU323BV1TNU9XBVPXyh2TRXRXAoKc4o+WEHUTn6aU/A+SZtl56o4h54EPvQw7HIrTOZSsjFIrffwtA3v0OSNQlmGTHUPdoO1nhw2+yAlZBb4UVQ8TMwgiShIEeFZl831b75j0kKZ1evwv3llrbWB0wLc8JLiEZll1xMvubRaCKPF/KCpFan8uzn4I3B+iQ450ufy6RgQsJFRFKCYPmuqv40zn6kMHfi3xVx/jJgp46fL4nzNm9g6kN9CBW6X/cyku4e8igNVENkx7cjOx6nPmSJqsdFWVe8xRxKhmPwkj/imyOjuRAUkZCQP5GLw//457Tuujv+NkPFYVC8Qk4gl0qXPUIm0n7rKSHyMNNQnIOsu47p6omujE0fNBXIHlpJvnIl1vuQDdvZ1HkKYQDxCZX77qd16814xnetK6AW6sccga93hbIRnfpjmK2YSLRIgDOB21T1sx2LzgVOidOnAL/omP+mGDU6CljXYT5NGKIJVls0Dtqf7mc8JzpWTaxfIUYNwltHNWSOelW8p53cFUKeJkR9Vq5Efvk7xAdnXqeqZXzQYqwCq1ax7qtnoSPrycRCnK8qwVIaGmLdr39J5hNSDf2MrZoZp16Hh8pHousEn5pxw8IekBWPYlyGF0hzE/0tY5uzWxOqFmcypOkZvvwqrMvHXdcQyhbSPXZCttsp1EGJYYZZtDMGE3kkjgXeCBwnIjfGz4uATwEniMhdwHPjd4DzgXuAu4GvA+98IgPzKFlSp+fkl0F/H14DE1kotFMQjT2IgunjRTfoM1w8Jl4NkjmaPzgXf88dwYkJG6aYE4rzjAeVnPS8i1l/9g9geC0tDBmCx0FjLeu/dw5y0VVU8xzwMTM0lPvPNLRFScfbe9znrJVREDNNp4cxdG0Mpml21Z+Dw34c/lyN2qf09MBuO5BZGc3+LrHF8biFi6p6OePfTsePsb4C73qS4yK3HrPb7tROeDaYkGVZaCJ4H6p0seQotFokNkUEEgHEoTggRXzO4GV/QL/xLYxrYF26CWGQCowkIS/Cqse59ehnz2D9DTfT/cLjyXfYFvPQCoZ++3uyP1xKz+AguQ0CLfXSbmky41BYNl43EDBjrIY6334TKdNHvnijJC4hszn23qVky5ZR3ad/VBBuBEHAWpJdl+CwGG1Ni6jXbMS0rYpOVGkduj9J/+I28ZtrtzYDR6BZMCMDPPJf32D+Mw7DHHsYie3GqMWo4NetZOCXv2bdl79G/5rlGElp2YREN1WdDSFT1YtQ9Y7cr8f99tcMXHQhuUlBIc2bdPkMb0KvnsSHXJpgGsl08G9uFgohIapBwDwWnGsnsBW/nQ4o0gCEFjq8nvyu+zH77Et1nKztoto732EbrGM0o2+GXbuZgGkrXAC03kdmElLjEW+wsVdNwdUqqjRvuQX90Q9Zd873qBxzFPq0g0m6u8keeIjhy66m65bbmdds0LK1QHXoW5sU54kqqXqchIxgcbEGWMHkDiSnngsjCbRMSuICgXUl19CczShpruQz9Q3o/aifCjZRTQTwzo/6qqaHLxcIRYioIfEeLxn27gfw42gtodMDIWq0zcLA22so28dMEqatcFGg8tf7cVkD62tkiaMSU7tzEWxmyXyLwR/8kq61a0L25i8vxP/qwqBJeEcPBsSHFqMoqffj6vS+XVGrMRoSBJCT4IvJY9Kc9SH5znqNrWXDzelmnFwp2PQt6R77IEkVRxCamJjlE5MHPeDV4YwncYLDgGjozzzFxy2agAQiduOV5iMP0d0m4xwDUUupzFtEy0oRKiw1l0nAtHVDOgF/401kN10PEomcSUIhnFjUONzNN+EuvJQsCVEPZ0PNkEfxxsQ0jqK4Mazjxyrzj2npQqS4ZFRTtqpIzOYNVQHadgT7GGgwFCntMwcqoTaqse9TWPiJd2F7aqRqUBNbyWvBlVvU8QjWa2jyLkVj3ak/ZiUw5oVqa2BoMJZ8jIeQB2PTWEc102zZGYRpK1wqzuCHVtP8xGfI/3IT1mV4zUP6uctp3XYLrX/6NH7dCtK8vEE2F0Y9Ignpq19BumQPXAictF0voUgw5gsB+dBIu6BTxYXWuhNsxTqZ8NKZbQym0cT48e2cwvQzxsYuAltjlHMT09Ys8mIQHOktNzN82ofITzoee/heoVvf9ffAuReRPPRXTEWDajzDqpKnGrmFilqqB+6HmDRUihtGSwk1ao+A8Y7soQdoiccYAziMTk9T0OVu3MCX0hFJn4nRvRmGaSxcFOssLevR1feSfv1bmK9Fpn/JGElzvBWst8FUKbFZaLcGccM4U/golKR4AolveFXkkTU0r7gyEGf5BDEhD1aZ+sa2hV8I4uulkjAeB1VHWhN5liGPFyEr8aQw9XrtODDqo7qbkHqPpUkjzWklOd42sepIXBJ14qnPFJ1pEBWcdwz/8U+YPMO64F8KvLix97ZXTCtjxbm/o3bnPVS8Bo5aDd0ApoHLJdJVBhHnDLDNYpx5rHdmCHk1hobAuykXjrMZ01a4aHS8GXV4LLmkpN6H7xocu8646Kgtb5DNRZG+7378S5p33B74iCO9hFNQ52gMr2H4nB+RffXLeJ/jsOQ2az+O0yMc7chN4N7JqhWSY47EynhNW0PsS4HW6jWIbwFa3j+ThGlrFhXRm/hlo7ektPMVpFheYrOQOoIJtOxeRt73MSoffDc87TDSWh1Ghhi6/gayb/yQ1g3X0j8yFOqspDjbbfEyZeMvkBtDxTty47G77EHtaYcRcqbHqrQHvCXDUbv/YTzhPMy0urCZgukrXEpMKpwhsukp9s47aL3z4wztuiOtRV2YNWup3bMMWg0sSstUYJp29zE+QWiQqEWf93x0wYIxK7shVsADkjfxN9+GQ+MDMB2PbOajFC5zFEYV8WCokjqhwRqSu1eQ3FXBqpCbHCM+LEtMSK6bhg9h4gVvPVn/YuY9/3gS4THczIo3gi59iJG7bqMKOAtFZ8gSWxalQjhHoRKyj8Nj5UhU8VRRJNRYkZBJipeiafwUIyaoBJK58F+gtcwRTWgddjDp7rsETkAdR3dRj3pP84obkdUrQzcBpovvaPahFC5zFRqEiFFPywaGfusDWUUj8VSckjpB1WD99OhKaH0CArkpyg6ULPE0Kgn9z302rl4LTHTjFQuJQrPB8EWXUG81cWLa7WlKbHmUZtFchYy2y20nzolvO8h9bLys7XWmHs4EdsKqCwLPCVRzR779znQ9+2jEhhKAcXsh+YT8/jvRP93YLgsJmA5HN/tQCpcSMwOihC43oVuiN5FuUxJ4xUuR7ZeguNg7fMPoosZsXAWal11N1+rlNK2N/aJL5X2yUJ7ZEjMCgQpCSJ3BqsMlTZxV5Jgj6Tn1VYikgeu4o0smjAoWAN8cIbvoCnLbirl0EgpTS5/LpKAULiVmBIwGUvDMghOlkldIDzySnn/9COmChYFyQxOIFKhj0Vm5u+/A33w7uaRYXKiuj8maJbY8SuFSYtpBI/U6WtCHhpiWN4ozHkuF7Lhn0f0//4bdfW+MCNa7wK+s4ddFTgvECJP3NC68GDOwntSlFJm6ZVX05KH0uZSYdhCNHDlAIQSK92BVU/KTXsC8j/0DZpttsCJAAjbm5IoNuoiGbt8oiBOy1Q8zdP5FVLQZhU6C1Sh+SgEzKSiFS4lpB9EqKjmJNmnYCs4Yqr6Jr3ZRfe3r6X7/6bi++YAJ5F5mQ+kQWC4Vqy6QSQHDP/8V9TvvCoIl1o5sUF5SYoujFC4lph2cyUm9MpIE561xgvRuQ+Uf30HXq1+Jr3WTqAutXK2MeRN7VbwI4i2tu26Eb3wX95gMdSW2NErhUmLaQU0LVUs9q9BMPMmuu5N+4n10PfM5SJJi8YTaBTNGeSIU7HnGGfzqVQz/x2fRR5bhqJHQ2roHM4dRCpcS0w6JszgDjYqhesyzqH3sPaR77oPBoCbDYzA+DbXPRd+ZjWBUcSMN1n/xi2SXX02XE0Zss+TM3YoohUuJqYOCYMhshgokzgRnroJ2L6DrlJOp/e2bSPsWAiBGEQyKBRPI1ENtkEdccAA7C1YzXLPFum+dhf/+OeCjJoOjvOW3HsozXWLqIB7ISPM6iUJmWzhrYbenkH747dSOew4VW8O3ewsJIgmdWfuiDsWEDiGao+pxDc/QGWdjv/h1Gn6EvlaKM4WxVGJrYSKN6Gsico2I3CQit4jIv8T5u4nIH0XkbhH5oYhU4vxq/H53XL7rJB9DiZkKFRSLM57MtiBJ8C8+keo3P0/3c59PamogYPDjEjqJWlSFwLopyMgIA1/6FiNf/io+W0tPBsNp0IhsmdSyVTGRJLomcJyqHgQcDLxARI4C/hP4nKruCawBTovrnwasifM/F9crUWIMhK5P3uaY/sVUP/gB5n/qE3TtvBtWDLkFLx58caOOIRxUKTqDs26Q9f/9NfzX/hfTGEY1ZSSpkHjIrQu8vyW2Gh5XuGjAYPyaxo8CxwHnxPlnAS+L0yfF78Tlx4uUJKUlNoVGZ6zZ51CSL3+W2tveTKXWA1EQtCuEZDxuudCkzqrHr1rB6n/5D1pnfRvbHKbihIqzVHIw5LGpXXkbbk1MyOciIha4HtgT+F/gr8Ba1XZH96XAjnF6R+BBAFXNRWQdsBBYudE2TwdOB1hiS9fPrEGUAoHrezSvZDSmE7oHqIBPU3jJi5n/vnciu+wM4skRrApGAlm4iMGLxregorphLZCq4B98gHX//EnsRZeTeoczBm8cmQ0dIltWSbzBeFO2odmKmNBTraoOOFhE5gE/A57yZHesqmcAZwAcXKmVV3w2QULDtCQSUrWskKgjswZRoeJgaNvF1N51Kn2veR22qx4Z+E2beB1ARFC0mBtS+sVjvZKLYhw0br+ddZ/4FN3X/JFGAjVn8eKQ2LxIJZBghbav5W22NbFZKoOqrhWRPwBHA/NEJInayxJgWVxtGbATsFREEqAfWLUFx1xiGkNFQXzQFNSSGcF6j5BgPKgV8iMPpO/D76Vy6JEYYzfp4rCBgOmgTvAFp4smkCtDl/2BoX/+DD333YMzDZQqEKqnteO3JSfU1OBxhYuILAayKFjqwAkEJ+0fgFcCPwBOAX4Rf3Ju/H5VXP571bJ35lxBoRw4A9Z5VJTceIxaWLwTtVNeR/31J2HnLwy9kzoe+Md79o33KJas1aBx1k9xX/of0oHlNBIBTag4S248Kh507NzdElsPE9FctgfOin4XA/xIVc8TkVuBH4jIvwM3AGfG9c8EviMidwOrgZMnYdwlpik0Vimn3pNbj/EJjb4FpCc9l743vI50z6cgqQU8xktshfT4rtags1jM8qWs/Z8voT/5BdLMSFwV64LrNxdw1pH6ktB/OuBxhYuq/hk4ZIz59wBHjDG/Abxqi4yuxIyEiqLqydMayWFHMe9dp1E96jAkSfEC1oMzgZ+lspEEKFTcjeWCqKd1058Z+uRnkOuuRtSR+JQ8Om0D/5ynlitO0g2cySWmBmWYpsTjYlQJCGaOEhvZI4iG1iNq8khuICQO3Ha70n36G6md/BK0d0EIK4tgFdTEhvcUfb4tmcQOkBSOW0XFBXOq1WDwt79n6P/7DMmyh0ANNrbzVfF4MUCgq8xFyMzotkpMHUrhUmICULz4yDlrMT4kuCUevGnhgcRVyQWoW/xxz6X7fW+mttd+iE3Bg6CBd6WjD69XJUOoaFiOFOxwCmqxeUI+tJ61Z5yJnvkdkuHB9s+9eATB+g7fSlRV0tLFNy1QCpcSjwvRoAl4DEqCoFScBxw5IaekQgb7H0zt9LdQf96zsbUaKrHfkSnMlo22C1RCURDW+rYhIyqoV1oP3sPgv3+B/OKLSLKRwOxf5mPOGJTCpcTjwouQmYR6Bt7kjCQOi8f6FCOW6s57Y9/wKvr/5kXIwkVYItWkFMz6Mo5zVXBG8XgSDLjYLyl3jFx/FY1//STmlrtIvQVCv+oSMwelcCnxuDAKSW7IbY7iqTmDSJ3WbjtQf80rqb78JJLF22Ak8NZ6UaSoQRaJoRsYk3eFsC4qtAyYxnpavziPxn9+FVm9jIyUmjNkaRPUlCn8MwhzTri0nZMdnfkEYkZnYJ3X9ot2w3imttdlnDfxzEH7cdcN5whBU6HtB4mRHRyKklAh33VX5FUvpv9lLyXdfgcwYKToEWSwKjiRdldVNZG9X3WjYjaFSMado8iKFaz9n6/hf3wOptFEfAUxDpfkiLclz9MMw5wTLoVgCCX8oVQ/daEXTm7CWzSJ0QpnwkNmVTA+hE5FZ0+XG9EYvRFtt+UwagElM1B1QSBY46FSxx18EOakFzP/uGdittsOsXYDYdFZn2oRJHKoiEhs7xEKDcXHbkFecSLkroVefi3rPv81zF+uI3EZaBKjRaGP9WwR6nMJc064hOZZQto234WRBKy2MIDR0JzcqCF1iheHFyVRocnsqawtGN9cFLRKSIAzDlpWsXhEU/KufsyxT6P+updTP+ogpLcP8Qk+Mu4/XsF7+3ypw0YjyBuP9dAQQZbez/CZ/wc/+RnV9evIpYJqBenoW935p8TMwZwTLkYjI5l4DJ6WhYoTMklIvUGBVgJGPXhPMym6/XlaVqjmMmt69Klom4Qp8eH5bSZK1YGahJEj9qfnHadTPfaZSHcd0dBELLfE8PHE4cRgRAP5nFiykXVk5/6Kwa+djb13KYnPiKSXMcu3lCYzHXNOuLjoT8kFwFKVGs1dF+P22AOd34dzLczSh3H3PIBZtZ5qJjTSHC9KbwsyQ+QGmfnwweoj9UrihNwIxjuaixZTe/1rWfTG16LbLMSIx+BCEhzSwbg/8bMgZODDyWv99VYGP/sVkt9dQlerEcxPBCc25MPoZkquEtMSc064mJgYniR9JMcehbzhJPoOPhAzbz5VSXHiaTZHsH9dxvrv/5TWuedSX7uekTToKk46621nMoJ/SeJ/uRUG6pb08KOZ/753YA87DGMSjPcggRC7iAR7E4RzAuO09tgUogYdGmDg/N8w8sUzSB58IGxDDEZd1IgE6w2JtmNNJWYwZq1w0ZgObhUyI6iB1IUbdmSXXej74LupPe/Z+HovSW4wsSzTKtTrFfTAPubv+36GjjqAkY/9F9W1D2N8BZfkMbQ6Q9psR+7YVuIBj1VDbpTEK6IGIUHJaC1YQM8pr6fv1DeRzusPjlcAY9rRM2ciMaUGs4io+cRIMp7gFJbo9Va0yOVn+I7bWPflb1C94PfUWsM4IyReyIxv861UcwBfssbNEsxa4SIxlJrZ6JhFUDWM7L078z/9/6gefDhiElQ8JgEkVuh2cItI2kXf81+E3v5X9H+/Sm7DgzqzQqIaG7grtdyQOItPwHqPE8jSFn6P/en/0PupPOMoTFpFOpuNdZiAScc8ABfPsUoQRFYLs1Mit63A2jUM/fxnrP32D6g+sJw0y2gmkJvg67J+dB86wQrpEjMDs1a4ENnQCidk4qDR3U//B99F7eCnkVtLqsFM8jK2HqIoeS2h/rKXsPqHPyNd9RCJS2najfM1pjEEnPgYBUtoJIpRJTeAGGpHH0v3v32UdKc9yW2Mpk102xpD2AiiGljjfDCbtNEgv/QKhs48E3fD9cxvBEOsmThAqTiZVWH9Epti1gqXULkbws7OeMDQOvxgFj3jWDCWVIPj0GFIwuJNEHIrhGSXXTHHHo384sfkEjlLZkhxnBJD787SSJSurEUjBUwNXvpC+j/8DySLtkMTpVJ0aZ+g6hAagwheA5etAzKX4a//C80zvolecik0mtScie1DHIJSzcO1adnRxL0Ssw+zVriIBnnRsFB3SmaE9HnHot39qAkleBnBeViQP298m4sGj4SvVug64TgGf/VLjMtJZ1C2qMTAS2agK/OoUcT2I29+HfP+7q2Yvn5ygVSFdkrthKWLxIQ4R94YIL/hVoa/90vySy4kWTcMktOyHi+W1BkSF1lXYjg7N0rqNmN/JWYUZq1wUQlMIYkPLCMWobbbrqCGhBiCjY20vBnbzCkY7I1X0r12xXT3kqxfPX0jGVGbUimqiwEELz7m6Sha7SN5+2n0vP0t2Fo34EhwoUWqBo9tMHHCb+OGR3fRMde5HFm1iqErr6Pxs1+h1/yRZHgt7QogNVRzA5LhjGA05BHlRrGqdLeC0H8ysmXsK6EdZQ0dkA3Hrxss2koCLjq/JVLlaaxFMdF8N1oUnoR5KsX1k5CpLBvefcU11id3GicFs1a4oMFBK+pxYkmtwfcFrYVYtRtLaDDjXpXRqJCppiQoo3mm0+1SRjMOpWWCo7RNUO0TvM2RShfJ2/6W3nechtRtZC+woz8mZupGv4lHgyBWBXV4CUdO1sTdchdrzz+X1u8vo/veZZi8QW60XVwYyLR1lFSK8MCEDOmwo2z8Ez/xY9biuIlcMB3CdaN1fXxZ2NhkTeNDuXVfFeHcVLziMTgjWM1ppi1SenC77YXuvyfpwn50uMHIbXfRfesdaHOkfURC6G6QGyUhRP0yMdhpZqrPWuGy8Y0lYsDEvn2y8Xpj3+TtTFxR8A5EY9vQ6YmgFQipVyo5DFUCR0rFQZ5WSd/yJvrf/XryumDipe9M31cttgFCaOEBoEZQTTDOkd93L+vP/D/c+RdQXbmeLlVyk+MTJfEhAtQyjJ5kaf+zoTtnC/GyeDGhbCH60IKwGZuaIfGAmhg2D+HvcIHdVruo4Z4ScgMqjsRbRBPM4j2ovvuNpC96HpV5CxAsXj39Q4MM3/hnml/5Bvm1V1JvhvJR1FDxQm4dIo6KC/2aphNmrXDpRNA89Qk7YVVAmxnOuQknjU0NCpU60FF6EWq5UnEG97znMe8db4VKLyoe60Ju3MYohKeogAT/iKqSr1/N0E/Pw33zO9gH7gERmkloWGZRKrkiGJq2eHy2Dqz6DldRiFiFy7zpgxaKUUMeTShaDZXbW/NlIapYDbw1VefJJaGx/74s+K9Pkuy3F84mGFUgBxTT20fXsc+gsv++ND/3ZYbO+T6atRAVapklcZbcahAy00txmRvCJWjhT1CwEEyNfP0ImmVM9/zcxIdkt0YiMdxrGThoHxZ+5H3Q24+zQkoCdix2uGC2ZISevV4VdS2y6/7Cmv/5IubqG6g0M3JTwagLbVRltOgxE8gsVNzWO14Vj4uCNNi5JtJF+E20UtHCzxYEcNEk1mHYWiJGoj8odYITQ2P+QhZ86D1UD9gTisilGDwSaCzEY4zHLlhA7Z/ej+udh55xJkm2jlbiMK5G4g0t66fdi29OCBeISot/YgLGoLg1A5BlGzjjphsKf4bRYNpU84TVC3tZ9A/vIdlhRzJLJKkc32cUKCeCxpINrGbouz+AL3+X7jXLySU0HUu0RaibNrEOSEKHRQ9VF+gatp5/VPDG4myCtyleLIgBk2+wFoRwufFQyXJMngGh4n1rmrohOxpyY3Ai1F/+QpKnHw1aCQ7nwvcVSccLJzhGMfU6PX/3Nla5Fu7M72Dy9bSspysL9+h0w6wVLiG/IzjxwqvKg7r222pi2wimlFfBPvQQqfPkxRtymsJFAVNxwR6vHfcc6sccgxhLikROlEL/2vQ4vBfAkS1fzvpPfY3qz86jaQbIbRdCixCDMwi+nUMjUePJLTHnpTBJoue2jQ7/Tvxr2rph1DoQVPIQFheLiAWxmCTF9Xbhe3tozp+HXbyI+qKFVLfZhnThAsy8PrSvF1+votUqSDX4kwTwHpyHvIk2hmHlWvSRR8mXPszAPfdTuelm/MBqEm0irk5uPalv4cyWfzyU0NLWGYft35bqa/4GY1I0RiwLg9IW50gE8aErpRWPdlVZ9J7TWeca6He+R9oImptKIMzJjYTSDghZSFNYBDprhQsxOzf0LVfAY7J8s86zEB6eETzr77+bbqdgLB6dlvKlEBwqodl7q6dG/6teiq3WESMdvtXxFejcgM09rcEh7AuOwh2xF27VSurLHkJXrMavWI0MDKJ5C++D1lLUF4GSOYfPM3yWo1kL4310tgbnsUdQY5BKSlKrIrUefE8XsnAeZvEC/MJ5+P5F2L75VPp7Mf3dMK8Pensw9S6Sri6k1oUkKWJsOK6OqNNj8cto4aCOUSPNM7qaDbI772bwS2ehv7+AXByiNlZqb3kIIRJnVJGnH05ttz3BhFwrEbPB/dkW/jaYqWDDuHt66X//e1hbq5F89Vs03QjGpxiFehaSRp3xiPpwL0zKkTw+Zq9wYfTtGByUYFrZZv4+5H1U16/H3HRbtJeLkMf0U0NhlAAqF0F23hU9cJ/NGmoCiEnp220v2GOvtq/KqaJekdxhGg18qwXObeDXUFWcy9FmA9fK8MNNZGgknHcRSC1aqeDrFWy9QlKvYXr7kXoNtTZE84wgIhsIifbp1vjGiLkegZR04ry6efQPJYB4AVvBd6WYpx5Cz2d3Z/jjlsrPfknDKkme4M2Wv8aFNuzSbrpOPA5jUxpiqG/WVjx5Tx8L3vUO1lQt+uVvkwwN4yXQZngJdRxecqxuRRt1I0xYuMR2rtcBy1T1RBHZjdAneiFwPfBGVW2JSBU4GziM0ID+Nap63xYf+WZCALLNEy6i0NKc7LbbkTvvwZmc4TShkk9Hj0swLjJTUHcqzX33w3b1blYBd5H/g5XIJzwqPsQANoFaBSuMaWImgENIGTWKimCOiR/pWGbVb2BmjpJAdEA7NhDDx1JUpm/Ub/qxkMT6J8G0a6gMQm5z0vo80ve8m0evu4nkofvQsUJpWwDF8ec77kj1sMNQK1Q24/cCWDVYcVDvpvft72So3kf+31/CjqxDxZGbCt3NhMza4FOalCN5fGzOft8L3Nbx/T+Bz6nqnsAa4LQ4/zRgTZz/ubjelKJ46fnNlAhOws0//JtrSAZzlITUBwfgdIUz0Rw0it9xeyqkm6G4BLMll8hbIz5EhXCjIWqJ6roKihnzYwmGVxKjM1UPNVVSQmauiaUZFmI8PDzmqibaLEXaQKCJCF0VXcf3QBruTMhxEdlU23ks5KLkotEfpxgczVRhl51JnvMMvBLDwVseqmHslUMPwi7YltGqi4mNXQE1LvSQEpBKQu+pJ5N+/EMMz9uW1BlqucPq5t/vWxoTEi4isgR4MfCN+F2A44Bz4ipnAS+L0yfF78Tlx8tEr/oWRJG5CVGwGIP09GxWBkagxEzof8OJDL/pReR9i0jyEG/x8b+g5kLxJ/zVDeZvLSihD7NRaKZK2t2N2s2zua1GQnIEE0WAYhHRQFNJjPi28+J0gw9RN1Ci41sEjAnJbjqqu0g0Z9q/UW2fNy9FNq1QOJ5N+50fjidsaTScvMmJ0FEZ1f6IgBgs0lFTJqBVKihqDd377ImRSghtTwLUQGYT6kcdTpYkWLSdsqzF/TLm+DV2VwA0QVQQ9aF/VFqn+9WvoOtfP8rwNkvIjaGRuHh+ivtyow1uhRtzoprL54F/ZFTDXQisVdUi3rcU2DFO7wg8CBCXr4vrbwAROV1ErhOR61b5yUiMCG8+TzATWgt6qc7fJmTqThAikBhDsscebPcvH6f721/Ev+ZlNJbsQJJUSF3gdymcOl6ExBucUXJTcNZvXdiYpp84Qz44HM2HiTUTKwSHKbQTZNQR3P4e90MhJswGn/DvqAVTfOJzvaFtFMWEwWDFkBQfDDbO79x2+8dioqZixoncbfSUxlmFwRXS/qUtvIKJFM2stCuGpycnWUfIsb2LqR1yCAkueHeLUzHGYfjOI9EggCRyD4kxGEkRMSSpoe/E59P9H59EFmyHNy1QE+7PeIwiOTZmI2+Nd97j+lxE5ERghapeLyLP3lI7VtUzgDMADq7UJuVYQxq7YFXId9kFu8PCzXrcA5F3yDXA1qgefji1g5+Ke2Qt2R33kt13N42bb8ZeeTV+xUOkeXg7Gh8eBS8+1tZsLQi+qH1ST/X+5bScUjUT9B/ImJObPsCPeUgyxtQ4P9rMU/O424sI4lTba208oo17J4m6kC+jOdl994Rweru8dctCVHD774ZZsh2CwUX2w2J4ndZY0bEyusvJRNsPrHT4wgA8Fm89tRMOQ1sfpvnRT5KvX0WiGoseE4ZTS09L2y1yJhsTcegeC7xURF4E1IA+4AvAPBFJonayBFgW118G7AQsFZEE6Cc4drc6VIQ0BzBUD3savl4jiXkVE0EhGFygrEc0wdkEu30NXbIdNX80NZ+h99zL0Ke+TOOS3yE+o68pZMaQW9+OZ2wNhAfJIDicKMk995JlI1TSnmnpgJ5MbCDUo4TZoNZbab/BRQNxuKxbQXbxZXS3PC1rxja5ngBUtcMflJA+82lQq4OGRDpBQ/8oRscIQO5ojQxS6e7Cm4QkNu4bT04nalFTo+f5L8AMNhn5l//Aj6zBGU93K0GwWB94dTYWu5OBx7URVPUjqrpEVXcFTgZ+r6qvB/4AvDKudgrwizh9bvxOXP571Unyjj0OrA8mUaO7SvWYY0JC1mZAhXjxifmoPrQstRpY7MRgbZXKXk+h5z/+EfvUQ0mcpWWVzAqJ29qGUVGmD6ih8fADpA8/OOcEC7CB0uEZNS+EaF7EcLYn0HVmrsnAd36E3nkXzTRw1GwphKZwwWeS9c6j+5ijsWrafiq3yRUKmkX+8Aoe/Oh/0bz3TnIy3GO6ShTEYJzFJQmVV76Eyt+/larto+KglWSoeBqJY7zCzi2NJxOl+hDwfhG5m+BTOTPOPxNYGOe/H/jwkxviE0ORCp9Z8LttR/LUfUn8Rm+Gx0EI+wVtIBcTWm8AYFExuBjmEwcs2pauU1+HsVVyE4rpvJitahaFYsVgEFRyS77uUUZ+dVHITp1j8OLxmqM+CykIrRbSzCArTILoGHYOXfUwg1/5Jv5r3yDNMlKXtFv9bgl0vlvlgH2we+wdqqLJMISaoFEHedS6POQ33Ej3Becx8MF/R++6myRXWsaPcwcH3hdfROfThN43vo7GKa9CpU5uY5ABG4jZp4lZ1IaqXgxcHKfvAY4YY50G8KotMLYnhZiUjoqj9oynw7x+8OCjg9IDxoemYEY9fiRUmtKVjkYRim15wZoo7wUSr6gJl8rEClejKcmh+9Ps6yVZPYSq4M2GSWaTDW3/G5zMFecZ+d459JxwPHbvvVFjQ0mECe/ynNBZMvFK68H70SuvxaxcFQoWKwna143fcTvMtttQWbgt9HTj0jQku8UeRqNcTx3HqJ6Cu6VoRN8ZpZOOAQsmunR01GlZHEt822uMwHnvSfKMZKSBG26QDTfwI4PIwFpkYAgzOIwZGMINDuGGBsmaTVwzg9yBczgM1b4+aosXwOJ5YAzN+5cycPEVdP3lTkTWk5kEJbT0fTLvheIYbLwPEmfJE+h9/vOx3d3kEsyxwmRWVZyEUL3DYHyL1ZdeQldzPf66Gxj4+3+Fz3wMu8e+eKuIRNNGTSQ7CwEEL6EHlVrwXb30vec0Bu9/AHvRH7DqkOh/UZn8F87szdAt4vz1Ol0nnEBqEsREmsU2sXQIWXv1rP3xj8nueID+vz+VZOEO0SJ1GDGoCVqQ1Zg/YoooB2CKh0Jw1QoJJiSy+Rim1a3XLUA6FNHcBlLu9KGHWPHxz7Dgkx9E9twTkZTEBY3KAAyvY91vL2LgS2dSu+9u0DDmRAVnLM0khVqNencP2YI+zPaLMQvm4bp7cN1d+EoKaYrUK1S661R6e2HeIqRex1WSkHkrEgrxTPAIoYp6D60W6fAAOjREvm6Q1toh8vWD2KH12MYQZriBaTRhpIUbHg5lB40G2hohb4yQNUfQhsc4CdQL6kKUxwcjaGOj1KDkalhnLMMVAVG6Wo6aD7m+opX4Cx8LB58cDECsvcqNwOIFJM96BsaYkDgnaQwVj95DaBDDbvlyksuuJTMpRpX0xutZ975P0Pff/0a6336h55P3OBNTDr1grQ25QwlIrCsy/YsxH/8A6+9/mMZfbyHxHQ7kScbsFS6iCJ58730w++4dtBYbCIVUDBaHRrNFR5q0zv8VXVfdQOO2W6h+4H2kRxyCVoLqGi5ZAkK7KXrBu+vVxwcG5OFHcI2R+FZQxG+dN8RY6FTF7bVXsPr0ZfS98mXYY47EL5wPA8NkN95M44Jfo9deS601iPHgjIlsbiCaUclaaGuIfHAl8gjorUJexJKNC2lzXrDxHZxHIaImaIlBjwphYxETH+JQSqCqtFxoU6caamFSUawPzeqLdrOOkMWbuJBjhECCkkiIChWtTUSLXBsYm88lJEVWnGKaQbOteA3dNycjr0UB8RifkBmDPeggWLLtOKtKeBjFgCqDl19FdfnDtDTUieU2p37zX1j3wY+w4LOfJtl7b3JjMOoRQh7RWB5Frx63y550feTvGHjvx5D163CStcPyk4lZK1xC1oKhdtTRSE9f1FNH3xM22t1N8eR/uY3kz3eTq2Kuu5aBd76b9MSX0P2m11LdZTfyqsGbkD5uc4c3IddCY+jXKkirQfPnF5I3R6jnykjiSVwy5dymImC1Se2vd9H4zBcY7qljqlVoNpHmIGnuSXMQUnJjIvuc4mOlrdGQd+s77HQvSm5CexCjgo+UCyF3RLEuD34oogMV8DL62Bd9jcKXUS+lSjClnDVgA7uc0eA8xyu5bcVV44OhIcWvyGEJuuIo3frGJz5kBofjsZH3pmWYtMfMGSH1OblU6MogO/zQcO7HQMiNDuRbNEbIzv8DlkESreIk5Dx7lOrNt7P6E59k4Rc+iWy/M6IWLwXj1RhHYS0VBH3mM6i+5AXI/303tjKefEwvXrwtjFatTuWoI4PmIYWabDA6SnEovkXz/POR4dU4qZBRo7bmUfz3zmbFG09j+T9/nOZlF+HXrCD3jhFjcZLjcTgBh0PzQdb+4be0zvk5RvMQ2mw/VlODIh0+qNp1cqnigOrgIN2PPkptcB09DU+aW5SUYFS1Yqp9aBriSXCxGC4Xg4tZcIkXurJg3zcST2Y9iMd6R8W7dnKaaFSBCFE762MGcSyhMBrIrIxPSJylmid0ZQm1zFDNQ2tXxdIylqa1oAmQhL8atEktnOsYnNj2ZyxTtLjuuYxy7QZqyMl52kQFb3y4HypQPXB/zDg5+UIRhPC4wSHyZavbCZmGUKndsgm5CNU//pGBj/8Xbu0KiOfRjhkBkkKfJDFV6qedTGPHHbYaY92s1VxEQbdZRPqUPTFoeGhIwk3toJGY0JL00ZWMXHIJPc6Qm0boTugNTqHrkYfRH/yIwZ9egOy0C5VDDsTvvyey11707rgT0l0nX/YgQ784n9ZPzyVduwpEaFgbGMWI1INTyc8gipcmldh10vrQwygzQtO2g7Hh7e0rwc9EfCAonJpKEoVpHqkIjAatpeLYgORao+6wQfkFY2sSxFBscBlIR0i2MwEudmWEtskTlNANNyYSOXTj97HKdYrMXC8eq8HxaaO2taXlS9FKuJkq9VwZWmDpXjhv3NeNL+ieRDAL59PzrtfS/NDtmOYI3nhS58hFMLiQeHfhRQx/eh7ysX/EdPWGF2ihDG60basWn3hkj71IXvoy5GtfHk3W2/CUb9HzMGuFC0B1990wi+fhREg0CTkqoVMaNt6qzT/fSOXB5bQKTo3ogDXFE6OGpDmE3Hkr7q5byY0glQrrajXEWnyjgQ6PUFHdkHV+6pSWTWDUxKhYGFbTapvQGggO1+Dqbps2SGcWZ6R00k5nYBEB2jDVrF1hNFailxbr0L6JNzxNY33rlFKy4cKNvm68z02HELZo4gD8ZF4oUby0SLMeWskwttUP+XhpecEEzERJir7Zxz+bkT33xNxyM6Ih7SGQcklIhDM5cs7PaO61J/U3vR61wScoYwiNkDIRBGntb57DyHd/ghlYMem36Kw1i1SEypKdwKYkRaFWtM19TLm2maNx8Z8wWcH+Xljf0q6NKV6QhaWTqGKbTVi3Dl29GhkejppR/EFhvxdOwilmlZKOY2ofUOEHao9vdMzC6FnY4BjG/HT+hk2+b/zZaAgd+5rYf2McxmN+xjgZHVdIHmflJ4cgjC1IhvEGM9JCVy8ft6JeJVCQigRfUKXeg9t39zjMjnOuQsizUqSRM/zFM2ldczW5xCJO0baQ7TwsiZpmdZddyPbfi453xKig3sLnYfYKFyDv6w3qsRbOQh3tT+yhmTcwN98ZaADmXp5ZiUmEFELANAFDknlGrvxTcL5usjJtzbBoX+OtRbpqm6yqhIhc6iBRobJqKcP//t/w0HKKiqp2aLut+0WN2oPWu5HDDww85jJqRo661bccZq1wEcA0mxQ2ffAuhLdVoBQUMt9AR9aHAsPJeH2VmNPw8eFtpGC0QmXhorFzTDTGuCSYmtYpLmvAPUs3XVdom0dOHK0kx992G41v/AhtZZEGBApxIVK0AAQMGJPQt8+eo5r2JFbmzF7hokp2x52YZiOW1IektyLvAgPpQ4/CI48GguOpHnCJWYVQPuAxPqXiPAN77Uz9xcczvu3hYg5QzBG666/YW24fa8sEDUVw1lPNajgVVl11Ca2hkQ22XmgvBTWrMw6rQq2vv90gkEnk2J29wgVo/elm1l9zLeSK90FIe5Qc8K1h1pxzHunqddFOLcVLiS0Hif49J4GbpvaKF8F22yNjqS7SEW1TJXM5jR/+HFm3dsxta6TySBygltTDvOOfTrWnO5BIdWw4pFz4GBP0oDk+c7EfuE6KOVRg1goXBSrDaxn6f//J0B9+T94YQHwOWYZf+QiDX/k2/N85KC7wtZQosUUhMfLoyXbeld6XvpBUkrEfZAUwoA71yvDlV9H8+c/HzEcRLbarWDVkVrHdNbqf+3xIK7GDwAZu6+AK0MC9q94zvGo14kIEaROn/BbErA1Fh3wGS/Wee2i++0MMHnYA1f2eghtpodffhL/zbtK8EZp/iYkRpRIltiRyhJTaq16B23l7ksjusykEpx7jM9y6JtnnvkJlYC1ekzGfeKOGzIQ+RohF673kO25LpTPRJYaM2g3wRLG5xbsWg1dfQZEnvCHXzJbFrBUuQGTBF/LhIZLLr0IvuyJQI6qhgqNlla7YEMAVIb8SJbYAQmRS0F12o/qKE0klpZ07tMltFhy6TanQPO9c0j/fRK4VRPKxVm5vo805rA6yPG6JDVKDCi+jQ3FWcDfcApde3hYqk0lvPWvtAUERGaKVtPBiQFO8JJFTV8gl8FoMp6GJ1HRm9C8xM9FMa1Rf+yrMDttjtSNXZwwIoCvW4M/+LsMmC1m1Y9pF4IyPWcsG8Pih1citd4PrTIyMfzQk7hkMNNbTOONs0jVrJyW3Z2PMWuGCCsZ1gyYYMhJaENnic5sjKLXcYL3FeMtWOdslZiVGOz1o/ESH7t6703XSi7AikZojxCvbHDUdjP6ZevxPzsPdcyvWC96MYPymj6cSOHATX2jaHmkOsP6cX+FGmm2tRTuyrwUF72lcfDnNSy/GerZKfdGsFS4aJbwQkoicSPuEmlgdnZsOSV+ixBNEMDxs+2FKXY28mpC84Y3INrGeSNu0UKgPHbe9V1oEJ27+wAMMff9HiHPUM4uT8dnwjA/lAJ6ixquG+d3vGPnGt2k11uNzxfmw/dwpLd+ide1VrP3P/6Ey1MSbscsztjRmrc9Fxvq2kVa6VYn5S8xaBNqJEB4OFeIt3P4Hsej5z0KTpKO9RxAWzkDiQI2QqsH7nIHv/wyWPog3hjzemInXTXpWS8e9PPpd8G4tg1/+ItW7bqPy2leQ7rknzWoFWbmc/NdXMPKdc+h5+EEsOcbHItFJvv9nrXApUWJrQVRw1mG8DQGEmqHvDa8nW7yQVEN+bGe2Q2fWeC6Kv+Nu+MkvSPMGuTUxV8WxOd0HUmfRhsOf+1sGL7yMru5+smoF1g/QGlqP0MJLHhn2JqmgaiOUwqVEiSeJglQLlIpL4KBDqDzvmSRacBYHMygFUIOJxYVeIGkNs/rsH5CuWI6zivUW6zU21pu4APAS6DSEnLy5juHmOmz02VQIAQsnBiWJ7gE/6fJl1vpcSpTYWghhZxP6infXqZx2Ctrbv0FRoA39ZPEC4pVcPIkqjT/eiPvV+dEpnOBFIv9x6B4xUTjjUckoYkOJS1DC9lQNeUGroUFwbQ2XQClcILIxKIoDFOtsiCtJuMi5WBwJSmAGC/UansByH/hyjXogJze+XSMSNl06jGc7jCqqCYIgxxxO+sxjsapt7iCDth80j7Y7uLqBAQbOPJt03WoUE3tOabtT6OZEdKwXnCQ4sRgf7t1EMxJP7HsdOGMET+qnT8fFWY/gzbdglMSFm8KLUs89za4KyS67wG47oa2M6r0P0lqxEjc8QhprNryCJzQHr+QexOE3cLiVmM3wBoxTWj29dJ96MtVaN966QFpeFAbG2yD0zgozhi68GHfllaQEUm5klNvZb6a/NbqMY5FusY2wheJ7QWa2tV53pXAhXBjrhUwqeGmS2RES7WbgiCPpf9sbqR59KKarB5MrQ60G9fvuIvvjDbQuvQa96WbS9WsQLZxlIWFP8HjjNsqWLDEb4dUgtoV95gnUjjocbxSbm3GeLgk1zSseZeTrZ1EdDl08ddzSgJmLUrgAoKhp4SXQHItU8H9zItv+43tJtl0EkuAwaEXprleRpx6BHvg09E2vpXH37Yz89hJav7kUe+9daJYHbUVDb+mt1TqzxNQh9ZZ8Xp2eU04mr/eSKngrY4sKCW2Vhn/yE+xtt0YTyW8YTpolmJBwEZH7gAGC0ztX1cNFZAHwQ2BX4D7g1aq6RkKxwheAFwHDwKmq+qctP/QtB5UQEkzIMZqQH/w0+v/pvfiFO+IIlJiGkJdAfMvkKth6H7X9nkZtv8Nonnoa+RXX0PzJT/HXX40ZGKKaWzIzK++bEh1QwB9/PJXDDgrs/kbjK2UMndV73L330Py/HyKa4YyNL6LZZ0Bvzm3/HFU9WFUPj98/DFykqnsBFzHaE/qFwF7xczrwlS012MmCqJDmVTzQSqrUX/dyKgu2JYlCJTPRMecLjq/Y7hNoJeAsVBf0U3/pCcz/2ufpOevbcOqbGdllB1xq26nhBX/GqAN5w3md89kKfBslNg+d1674oijZvC563nAyvtodOhBo4f/Qdop/8cmdZ/Bb30MfWkbFCRWniBZ08bMLT8YsOgl4dpw+i9BD+kNx/tkaihuuFpF5IrK9qj78ZAY6mSja6yTqafb1UTnoqQgWTI6QkHbQBAbHmQ2UgUANAQl9kQwC9S5qhx9K/eADyd7+FgZ/fyHZub+jcsMt0BgIIcPoXLM+lCAAJGranRoj1z4aHXtlUeU0gcb6ZWlifRUvObkFOeEF1A84OERg7KgTVdUBlpwc44LJnd1wHYMXXECPt3gc3niMH+W5nU2YqHBR4LciosDXVPUMYNsOgbEcKPpU7gg82PHbpXHetBUuAZ7EC600xdYSvBGst4gd/6KPWWJADE3ahHSHHeh73RuRl72Cxs030Tj/1+hFV5AsXYZxLXITmoGpcTjTwvoE61O8hAiEqG9HpKa6i0CJcIVzoySahLo0HNKzLf2vezmmkkLsKikSuGlFTbtNjUfQkUHWfvP71Feuo+JCv/LiRTMLFZcJC5enq+oyEdkG+J2IbEDuqaoaBc+EISKnE8wmltip9ys3E09TDMn6IVprVlJfsgvaLjbbfATXk2LEQXeN2uFHUTn8afi3r6Zx9XUM/+Z87DV/wq5eDd5gtAeVYXLbQiUBFSwh89OXgmVaQEVJ2jkteeBlPv447FMPCP2xO7Pmwg/wEpgOvVFaV11B8vtLqeR5sbjtb5mN+VATeqpVdVn8u0JEfgYcATxSmDsisj2wIq6+DNip4+dL4ryNt3kGcAbAwZXalJ5ZUcWqUskNWT6C+83FuP32wyXd1J/I9kRiyXswmQyCs2AxJNsvwvzN86i/+ATcA/eS//5iGr+5CHPr3ZghaFnFaEbFCbmFkSR0NSzFy/RA4iAz4I2ifdtSO+XVSFLtrI2lmPJG21X5sn4lI2d8B20OkNlizdDmVnTrZMxubTyuQ1dEukWkt5gGngfcDJwLnBJXOwX4RZw+F3iTBBwFrJvO/pYCiQ+l7N5kDP/oF+i1N1LRJx5GLhi+gj2tmCK5SSwGQ1KB2h770HXa21jw7TOonf0V9G3vxOx2KInpp5kYcoGuzLSzfUtMLUSF3NiQwySCvvj51PffDzGemFNLZ9pkFB+Ap3n+7+CGG9umUkjFD1wrIXV/9mkuoo/DZyIiuwM/i18T4Huq+kkRWQj8CNgZuJ8Qil4dQ9FfAl5ACEW/WVWve6x9HFyp6YXb7vRYq0wqFI0ZteFGEARdsjc9H38vtWceS16vk0C7bgOI9A0xqiOmnQK1YTtNZcOOSHE6ZmN6BBfNH4DcOVi3msYNf8KffxHNK67DPrIC6xohJVxHU8JFfPREJ+3w+AbtWNHIW1P0IJ7MMzg3EB6VFDUNWLgd3d/5OtV998YYwWxkBAT6yRzRhOzRFaw89a10/+Vmcqki5GjUWryEWh9TMNXNQCxeevf1HVHkNh5XuGwNTLVw6UQnYXGrqxtz0KFUDz4Q7UoQKyRHH0ay575UerpClakYLEG1FYnhpMh4F2AnxFOqqjhiD2sFzRvkDz3IyNXXMHjBJdg//YXK2lU48SgJYLDehSpYq6AW620Ukg4bm2PlxmA8PHHvUYk2FJyxpJohp72Nrn/6AKkBTILZ6BqrKt41cT5l4Mwz0f/8bzJ11HLBzbK8p1K4bCZUlUQc4j25qaDi8KKYWh/Z3ntTOe5Z1I5/DtU9d8fUAu96uME8bc7S2IxqosLF44O2EatnVRXjPT5rkt/zV0YuvJTWhZdibv8rpjHQbg0qBF7g4BiMH1GMOiyOXEy7rqTEE4cqeOPRHXdk4Xe+idltD4LT3iNmI81FFe+V7P4HWfOmN1O79wEaNiXVBrMtMX484TK7jnILoJMVPVeLs0FLSL2g4rCDI5gbr8XddCOD3/gujcMOIX3J86gfeySyeBvE2LAd8Yg0gSoTtUkEE8wlceSx6A0xmKRKZf8DSfc9AE55bQhr/+YSWpdeQ+2BB5GsgTPBgYg0SV2o4M6skMVq21K0bAEIVHyCvvokzK67huyAyEJnx1g5cy1G/u9skgceBJS6y2jZZM7kLZXCZSN0ahnOCFaFeu5p2KAhZNZjfBdWG9iBB8kuWU7jyj/Q2m4H7LOOpfKi46kccCBJdx/OpIGceYIInpJge1c01ptISNwSPGrAzVtAesyzSY96Bj2rVtG65jqaF/wOd+21yMqVpFmKQcmtQ0Wotyze+Fmnik8FRGFkjz1Y9IpXIGLwolgv5FgsHaTYEf6WW2n99GeByEkMKhnW11BxU3MAWxmlcHkMVBwgymDFYbzBqpCow0uDTBIgpeod1ZEW/r4H0PsfZPjHP2Vk770wJzyX6vHPoXuP3dBaob2E6MCGt2Bn8p0HEfxoKnDM1S3WDHkWElnEdPFi5CUvJn3BCciDSxm68hqGL7+S5Ia/kD6yHNGMVuLiFnR0bx0JGZ25GVLsZQx5WDiSi2UbOq5nIbSTYzmWfSQJ1Te8ArPDzohkCLbNg7vxVdVmk8Gvn4VZtb79gmiZhIqbO4Wspc/lsaCjE4XPQnSU/5QYTgRiKDH4XKyH3Fpcfy/JAftSOe6ZpMccS2XXXaFaDcxlAMaGOpToBC72KYTEOUUomnOOPsUaBdQoN0exxKH4VgvzyKMM/fkvtK6+Bn/9Dbj778cODZM4H7J/RTBesITsX42dEWLjCyBklSrgjeCi+p9EKkcvRBIiZmV+BoD1IedIMNEXBv7AA9nm7K8jCxcSLlS4ETJC6YgTwtreMnLh7xh6zz+QDI8AsUHaZnK0zBSUPpcnAhmdGJ2UjRZ1aATxUfcmaCFmzTq47BoaV1xHo/9MzAEHYE54FvVjj6S2ZCek7mPjqwTUBAEVyYUMjlCELkDSkf2/aS5FAevBmipuyRKqO+1I/QUnIMPDZH+9l9a1N9K44mrM7bdhVj6C5BmZpjG+qqgphEawn1rGI6JYH4o0Q2sMZThVujOhZQ1eIJ2lL2InBqFF6sCJhSpU3/J6ZOGCaDqPZs0FbVKwCqoJZv1K1n/r+1SHGvG6SfH/nEIpXCYZogajGWbtUuyly3BXXMbQvPkMH7g35rnHUT3mGNKdd8JU0kBNiI2FRRYvwU04YZ5mgVhTSaogRpCeOnLQAdSeeiC9b3oNrdUryZc+hL/3AfzSe2HZCtKV65D1g5DlaJ6T5y1ss4GMDOEGB/DNjHpLGEkdifekLmg+TkKm6qyEKBVnyIzijCN92lFUTziesURE+3UjhEbyv/4VXVddFzS+OYxSuEwmREGGo2pdxxmD8YqsWYW/7CrspVfT7JvHwFOfSu05z6R29JHIHjuS12okMWFOTchhmehrz8dM4JjDBxDZ5gUqNSrb7Ehlmx3gsMOpiWKcIs7j1OMilUBVwbZamPWDtB5dg1+6jObll5Ccfxlu4FGGUxdMJtFZq7lAxoitUvE5vt5F/fTTSXr6x1zTRzc8qjSXLyX72vfwOoxsxnWbjSiFy2RCBbQGsVeMiENNhuCxvkImgqxbj7n8EoavvphGz0Ls/vuQPPdYup5+NJWd9oBqnTHinONiQ7oGi2IxZIgG8vHcBo9NAlTUojbILkv4BNevQq2G6e+la8m2uIOfgn3hM+D4Sxj6yKfxqx/CaOxXPEvzZ4y3uMQFZfCEE0iPPALIUZJNMmkVQTzgM7KzvoO79wFC2mKnR2zuoRQukwgVRSUPbSUQchFEK212diQHFKsG27LomlX4K68kv/JaBvq+Q+Pgp9B7/NPpOupozK474Gt1Eg3kUz7WsxCdvsRSBCA6nCMvjBY+nfBIpHF5ER7aKCASnY6FPyEKKFVSLOa5z6R131Jan/o8xjcQLTKCZy4KB7ZKKK+wsarCqKXbtRjZZlsWvOUUTK0CEnqM++hjCc7t4Kz1Au4vt+F++FM8jsQnQD6lxzbVKIXLJKLdajM+gME94dutJUzkv1SB8OqTuE4O6x6hdskjNC+7jMF586jufyDpc55N5RlHwM47kqZVjBFy0XZhpJcQ3QjvUhcjWRYnikRBIgWJWtsxvSE7fcfg2zCAs4qji9rzTmDwzLOorliO+NEQ90xHUX+lMRLYSnJSX6H+6leT7L8vRgSVFG1H9WLrkNh4Pm8Mse5r3yZZsyYy/gf2/Rkue58USuEyzWGcp7J6Dfnll2EuvZLBefNoHbIX1eOeTd8RR2J33RlfC6ZXMIaC6q7x0qooJj4QvrPVxajiMyFYL3gjyIJuKv3z0BUrZsmDEzU6r+TG00yK9h8e3eMpdL/hVWSpUCiKHgmaaNTwRAVVT+PCC5GLLsFphUTzkIs0S87QE0UpXKY7JCTNWXJyo9h1DXovXIX7/R9ZvaAPs/8+JEceTnrkEVT33AP65pFUFFUf38YGxaIaAttGiFXYhZYzMTgB6yAfWI9ZO4z4TRPHZioKgWEjR3LiBWwd847XIzvsSEVDhnOiRQZ3HikTLCOi2EcfofXls7CtteC7cNaPao5zWL6UwmW6QwWjNrT2NJ7MQKviSNRh1q2EK9eQX3ENefUbZIsXovvthzn8IJJDDiLdbXfSeX2QBA4ZqxL8KEZxosH/MrFBhEI8cYxcdQV+9aMx487PimprAXIThEqSC02bkB12KNue8GxAEG8xMQQXaBJANWgzVhsMf//H6B13AIranJDlHEzGuWwYlcJlmkNFcZIDFnyCFY8hB01H6RXU4xuObOkyzNKl6G8vJK/UWLfjdiQHPoXaIQdj992HdJedSBcsRJIKqZHHZf5u+yEA6x3DN95G9oWzwA2BJiTxQZvJiB1XaSZBXhpnGeyqsfgNr0T6+xHNyE2KKfhz2kmMobbI//k2Rv7vRyQuDyYRTYQqLnIDzWWUwmUGQAi9qWNVUWgd2zZJYttODf2VvMSOfq0Ravfeg7nnbprn/RZXqZD2z8cs6IdF83HbLMZttz22rxdTqyJpGgJLTlFjSPt6qCxeSD6vH98YonH1ZeT/92vm37uMoWqg7pwdkVYNHRK9Dc3hyak+ZU+qz3kWYitI23tVFJF6BIMTxQ8N0PjCV0kfXRliR6J4tQRDKyZvz/jz88RRCpdpDolpt0UNjxldMJoZ2vFnQy+K4MQi6kgbI9jhEfzy5eQmPAhVl+PE4IxgYn1R0SuphSE3CUZCD+x60+MlY6ga6pOMn/laS0AQkgkOh6FZtdT/5oWkfX3tNP92VVfBi6wOvGXk/F8zfOVVVAreHog5TcX0rDhBTxilcJnlEB19gwY6RUfVFXk3KSAYF/hIjA/lkB5Q43GuRWZawQgwQmYdFeepeUPTBuFiZ7hPtwjLG58jahhZsgM9J5yAjwyDGyN04BT04YcZ/to3qTRa7XS5EhuiFC5zACa2rvAm9N0xqoGWk5AboyZQbAZJYRGNrPSMpvcXgiSzQssGP8WsKCuK+UFOQlg5PeYYqttsP24czaiSexj+7g8w99yN8VWQEcpHaVOUZ2QOwIvGDFSg/ZYVEh9IjrxESm8ZrZEJq0hcFiqmKy78zgvtdhgznXJBNFR9ZzZBkgpdxz8XzGM8Fgp6/wNkP/kZKBh15GY2xMy2PErhMstRZJwGB2ORASyRvHs0mtE2n8K34tftsgGrIVzbFk4m/mbrHMakwiq0BMzixVT33w81DjTkBhUtP4pc5FyVkZ+ei3/0ESp5gjdZrDeaDWrclkVJfjjLsXESrtKZsK+jn7ak6JinG29l1IU8W9rsqAi5WFKf4ffck2TBfMCP1lop7RR/ALNyFYMXXIDNQ59vFZnxfqfJQqm5zAHIJhPF1zH0jsdQRWaDljIW1HisWiqHHoCvJjg00lZo0fWpTQPa+NONJPcvI7NKxYVluZn5ju3JQClcSsxphPC7h6SL6qFPRcRgtYgia7QMJYbfHUNXXEmlNRL7dwcn+WzR4rY0SrOoxJyHIDS3W0y6zz6jpmA7A05wENiGBwfRP92Iisf60JbVoyRzOxF3XJTCpcScQWRuCX87EgY9gj/kKciCBYiEyJgvUvejBpN4z8B9y/APLAvk3abIitZZay4+WUxIuIjIPBE5R0RuF5HbRORoEVkgIr8Tkbvi3/lxXRGRL4rI3SLyZxE5dHIPoUSJiSJkIefGBjInCR2H8oMPZ/5bT0UrIRvZAjkGfBA+Vj0tDO7qq7EDAyHruaBU0MCXU2JTTFRz+QLwa1V9CnAQcBvwYeAiVd0LuCh+B3ghsFf8nA58ZYuOuESJJ4ggKIIjNjMe6y2Now9j/lf/Azn4EIw3bY3GKqiJAWhvyfIm7oqrSb1HJZJVCLRZuEpsgscVLiLSDzwTOBNAVVuquhY4CTgrrnYW8LI4fRJwtgZcDcwTke238LhLlNhsiAaq0cQ7vHFk9V7m/e1pVBfvTNUlGELujymSgxRE8yCU7ruf5s1/KbNZNgMT0Vx2Ax4FviUiN4jIN0SkG9hWVR+O6ywHto3TOwIPdvx+aZy3AUTkdBG5TkSuW+XnRnvLElMLq0ozKULHnnzJYuTgA8lS8EngJU7QdkaPI1SZqzqGf/Ubuh5dzWyh9dwamIhwSYBDga+o6iHAEKMmEACqumFu1gSgqmeo6uGqevhCsxn09iVKPGEEweHEYlQwXVWSSkqqHutDF8u201cE6x2qCfk9d8APzoleltIGmigmIlyWAktV9Y/x+zkEYfNIYe7Evyvi8mVAZ2/WJXFeiRJTChUldSGj1hvFr1iDX7WGTEKJt1EJTCzqETxePPngOgY+/TV0+VJymS00E1sHjytcVHU58KCI7BNnHQ/cCpwLnBLnnQL8Ik6fC7wpRo2OAtZ1mE8lSkwZQuzHYFTx4qkvX8vAry7A5MOo5LRQ1Asej6rDrVvPyGf+l+ziP4BajHpKs2jimGiG7t8B3xWRCnAP8GaCYPqRiJwG3A+8Oq57PvAi4G5gOK5bosSUo6CYcGIw3uK1hf/K9xhctIjeE59LWu/HIUgOjTtvY/i/z8D8/jKsDJF6JSuIdEtMCKI69ZL44EpNL9x2p8dfsUSJJwHRoLlkxmI1x+BIc8NwTy9yxGGkRx2KTSs0b7uT4Sv/SLriEbrzDG8cDov1NvQqKuXLBli89O7rVfXwjeeXtUUl5hCCVDC40FXRGdbVPZXWGnouvJjhSy9HRam7JlXASUJmABJEDS0rZUbuZqAULiXmEAyZ9VRzR2aCadTVMojC2pqSeocDWpJ2cPebyGXjSVXR2J6lxOOjFC4l5gwUH4nFA3Ncbj2iwQ9T9YAqRiVqK6FUIPGBcS+03S6FyuagFC4l5g4k9nKLLW1HaTqLDgqhYqiTm6Xd13u03UKJCaKsii5RosSkYFpEi0RkALhjqscRsQhYOdWDoBzHWJguY5ku44DpMZZdVHXxxjOni1l0x1ihrKmAiFw3HcZSjmNTTJexTJdxwPQay8YozaISJUpMCkrhUqJEiUnBdBEuZ0z1ADowXcZSjmNTTJexTJdxwPQaywaYFg7dEiVKzD5MF82lRIkSswylcClRosSkYMqFi4i8QETuiN0CPvz4v3hS+/qmiKwQkZs75m31LgYispOI/EFEbhWRW0TkvVM4lpqIXCMiN8Wx/Eucv5uI/DHu84eRbgMRqcbvd8flu26pscTt20inet4Uj+M+EfmLiNwoItfFeVNxfWZu5w1VnbIPYIG/ArsDFeAmYL9J3N8zCSx6N3fM+zTw4Tj9YeA/4/SLgAsISd9HAX/cguPYHjg0TvcCdwL7TdFYBOiJ0ynwx7iPHwEnx/lfBd4Rp98JfDVOnwz8cAtfo/cD3wPOi9+nahz3AYs2mjcV1+cs4K1xugLMm4pxPKGxT+nO4WjgNx3fPwJ8ZJL3uetGwuUOYPs4vT0hoQ/ga8Brx1pvEsb0C+CEqR4L0AX8CTiSkPWZbHydgN8AR8fpJK4nW2j/Swhtao4DzosPyVYfR9zmWMJlq14foB+4d+Pjmur7ZKKfqTaLJtQpYJLxpLoYPFlEdf4QgsYwJWOJpsiNBB7k3xG0ybWqmo+xv/ZY4vJ1wMItNJTPA/9IwXYQtjsV44DAZ/lbEbleRE6P87b29ZmUzhtbC1MtXKYVNIj7rRabF5Ee4CfA+1R1/VSNRVWdqh5M0ByOAJ6yNfbbCRE5EVihqtdv7X2Pg6er6qGEJn/vEpFndi7cStdnUjpvbC1MtXCZDp0CpqSLgYikBMHyXVX96VSOpYCGZnd/IJgf80SkqD3r3F97LHF5P7BqC+z+WOClInIf8AOCafSFKRgHAKq6LP5dAfyMIHS39vWZ0Z03plq4XAvsFSMCFYJj7tytPIat3sVARITQwfI2Vf3sFI9lsYjMi9N1gu/nNoKQeeU4YynG+Erg9/Ht+aSgqh9R1SWquivhPvi9qr5+a48DQES6RaS3mAaeB9zMVr4+OtM7b0yVs6fD6fQiQrTkr8A/TfK+vg88DGSEt8JpBDv9IuAu4EJgQVxXgP+N4/oLcPgWHMfTCarsn4Eb4+dFUzSWpwI3xLHcDHwizt8duIbQxeHHQDXOr8Xvd8flu0/CdXo2o9GirT6OuM+b4ueW4r6coutzMHBdvD4/B+ZPxTieyKdM/y9RosSkYKrNohIlSsxSlMKlRIkSk4JSuJQoUWJSUAqXEiVKTApK4VKiRIlJQSlcSpQoMSkohUuJEiUmBf8/UoLFAEWM0toAAAAASUVORK5CYII=\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import io\n",
        "import requests\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "\n",
        "# Define a function to predict the class of an input image\n",
        "def predict_image(image_path, encoder, classifier):\n",
        "    # Open and preprocess the image\n",
        "    img = Image.open(image_path).convert('L')\n",
        "    img = img.resize((28, 28))\n",
        "    img_tensor = transforms.ToTensor()(img)\n",
        "    img_tensor = img_tensor.view(-1, 28*28)\n",
        "    # Pass the image through the encoder and classifier\n",
        "    with torch.no_grad():\n",
        "        features = encoder(img_tensor)\n",
        "        outputs = classifier(features)\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "    # Return the predicted class\n",
        "    return predicted.item()\n",
        "\n",
        "# Upload an image and predict its class\n",
        "from google.colab import files\n",
        "\n",
        "# Upload the image\n",
        "uploaded = files.upload()\n",
        "\n",
        "# Predict the class\n",
        "image_path = next(iter(uploaded))\n",
        "predicted_class = predict_image(io.BytesIO(uploaded[image_path]), encoder, classifier)\n",
        "\n",
        "# Print the predicted class\n",
        "print('Predicted class:', predicted_class)\n",
        "\n",
        "# Open the uploaded image\n",
        "img = Image.open(io.BytesIO(uploaded[image_path]))\n",
        "\n",
        "# Create a figure with the image and the predicted class as the title\n",
        "fig, ax = plt.subplots()\n",
        "ax.imshow(img)\n",
        "ax.set_title('Predicted Class: {}'.format(predicted_class))\n",
        "\n",
        "# Save the plot as a pdf\n",
        "plt.savefig('prediction000.pdf')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        },
        "outputId": "599f98db-08cb-49ed-a88c-316660e43585",
        "id": "QwBYDB07sucj"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-48eaece8-b49e-40bf-a51f-6859170ff1fe\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-48eaece8-b49e-40bf-a51f-6859170ff1fe\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving test_image (32).jpg to test_image (32) (17).jpg\n",
            "Predicted class: 0\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}