Simple_autoregressive_gen_model.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 621
        },
        "id": "oGm-NqvB5o26",
        "outputId": "f3fb075d-40d7-4db2-a5c0-f7f05b458078"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/10], Loss: 0.0844\n",
            "Epoch [2/10], Loss: 0.0755\n",
            "Epoch [3/10], Loss: 0.0666\n",
            "Epoch [4/10], Loss: 0.0664\n",
            "Epoch [5/10], Loss: 0.0677\n",
            "Epoch [6/10], Loss: 0.0653\n",
            "Epoch [7/10], Loss: 0.0679\n",
            "Epoch [8/10], Loss: 0.0635\n",
            "Epoch [9/10], Loss: 0.0706\n",
            "Epoch [10/10], Loss: 0.0634\n",
            "Test Loss: 0.0647\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Import Libraries\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torchvision import datasets, transforms\n",
        "from torch.utils.data import DataLoader\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Load and Preprocess the Data\n",
        "transform = transforms.Compose([\n",
        "    transforms.ToTensor(),  # Convert images to tensors\n",
        "    transforms.Normalize((0.5,), (0.5,))  # Normalize to [-1, 1]\n",
        "])\n",
        "\n",
        "train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n",
        "test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)\n",
        "\n",
        "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)\n",
        "\n",
        "# Define the Model Architecture\n",
        "class AutoregressiveModel(nn.Module):\n",
        "    def __init__(self, input_dim, hidden_dim, output_dim):\n",
        "        super(AutoregressiveModel, self).__init__()\n",
        "        self.fc1 = nn.Linear(input_dim, hidden_dim)\n",
        "        self.fc2 = nn.Linear(hidden_dim, output_dim)\n",
        "        self.relu = nn.ReLU()\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.relu(self.fc1(x))\n",
        "        x = torch.sigmoid(self.fc2(x))  # Ensure outputs are between 0 and 1\n",
        "        return x\n",
        "\n",
        "input_dim = 784  # 28x28 images flattened\n",
        "hidden_dim = 256\n",
        "output_dim = 784\n",
        "\n",
        "model = AutoregressiveModel(input_dim, hidden_dim, output_dim)\n",
        "\n",
        "# Define the Loss Function and Optimizer\n",
        "criterion = nn.BCELoss()\n",
        "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
        "\n",
        "# Train the Model\n",
        "num_epochs = 10\n",
        "\n",
        "for epoch in range(num_epochs):\n",
        "    model.train()\n",
        "    for images, _ in train_loader:\n",
        "        images = (images.view(-1, 784) + 1) / 2  # Flatten and transform to [0, 1]\n",
        "\n",
        "        # Forward pass\n",
        "        outputs = model(images)\n",
        "        loss = criterion(outputs, images)\n",
        "\n",
        "        # Backward pass and optimization\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')\n",
        "\n",
        "# Evaluate the Model\n",
        "model.eval()\n",
        "with torch.no_grad():\n",
        "    test_loss = 0\n",
        "    for images, _ in test_loader:\n",
        "        images = (images.view(-1, 784) + 1) / 2  # Flatten and transform to [0, 1]\n",
        "        outputs = model(images)\n",
        "        loss = criterion(outputs, images)\n",
        "        test_loss += loss.item()\n",
        "\n",
        "    print(f'Test Loss: {test_loss / len(test_loader):.4f}')\n",
        "\n",
        "# Generate Samples\n",
        "def generate_image(model):\n",
        "    model.eval()\n",
        "    with torch.no_grad():\n",
        "        generated_image = torch.zeros(1, 784)  # Start with a blank image\n",
        "        for i in range(784):\n",
        "            output = model(generated_image)\n",
        "            generated_image[0, i] = output[0, i]\n",
        "    generated_image = generated_image.view(28, 28).numpy()\n",
        "    plt.imshow(generated_image, cmap='gray')\n",
        "    plt.show()\n",
        "\n",
        "generate_image(model)\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "jcDdL5WE5pbx"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}