Simple class-conditional denoiser with cross attention, minimal eval

cross-attention.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "title:\n",
        "author: Sam Buchanan\n",
        "format:\n",
        "    html:\n",
        "        code-fold: show\n",
        "---\n",
        "\n",
        "## Code imports"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model Size Comparison:\n",
            "Baseline model (no cross-attn): 605,584 parameters\n",
            "Cross-attention model: 811,536 parameters\n",
            "Large model (embed_dim=384): 5,355,664 parameters\n",
            "\n",
            "Input shape: torch.Size([2, 1, 28, 28])\n",
            "Class labels: tensor([2, 6])\n",
            "Baseline output shape: torch.Size([2, 1, 28, 28])\n",
            "Cross-attention output shape: torch.Size([2, 1, 28, 28])\n"
          ]
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import math\n",
        "from typing import Optional\n",
        "\n",
        "class PatchEmbedding(nn.Module):\n",
        "    def __init__(self, img_size: int = 28, patch_size: int = 4, embed_dim: int = 128):\n",
        "        super().__init__()\n",
        "        self.img_size = img_size\n",
        "        self.patch_size = patch_size\n",
        "        self.num_patches = (img_size // patch_size) ** 2\n",
        "        self.embed_dim = embed_dim\n",
        "\n",
        "        self.proj = nn.Conv2d(1, embed_dim, kernel_size=patch_size, stride=patch_size)\n",
        "\n",
        "    def forward(self, x):\n",
        "        # x: (batch_size, 1, 28, 28)\n",
        "        B, C, H, W = x.shape\n",
        "        x = self.proj(x)  # (batch_size, embed_dim, num_patches_h, num_patches_w)\n",
        "        x = x.flatten(2).transpose(1, 2)  # (batch_size, num_patches, embed_dim)\n",
        "        return x\n",
        "\n",
        "class MultiHeadAttention(nn.Module):\n",
        "    def __init__(self, embed_dim: int = 128, num_heads: int = 4):\n",
        "        super().__init__()\n",
        "        self.embed_dim = embed_dim\n",
        "        self.num_heads = num_heads\n",
        "        self.head_dim = embed_dim // num_heads\n",
        "\n",
        "        assert embed_dim % num_heads == 0\n",
        "\n",
        "        self.qkv = nn.Linear(embed_dim, embed_dim * 3)\n",
        "        self.proj = nn.Linear(embed_dim, embed_dim)\n",
        "        self.dropout = nn.Dropout(0.1)\n",
        "\n",
        "    def forward(self, x):\n",
        "        B, N, C = x.shape\n",
        "        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)\n",
        "        q, k, v = qkv[0], qkv[1], qkv[2]\n",
        "\n",
        "        attn = (q @ k.transpose(-2, -1)) * (self.head_dim ** -0.5)\n",
        "        attn = attn.softmax(dim=-1)\n",
        "        attn = self.dropout(attn)\n",
        "\n",
        "        x = (attn @ v).transpose(1, 2).reshape(B, N, C)\n",
        "        x = self.proj(x)\n",
        "        return x\n",
        "\n",
        "class CrossAttention(nn.Module):\n",
        "    def __init__(self, embed_dim: int = 128, num_heads: int = 4):\n",
        "        super().__init__()\n",
        "        self.embed_dim = embed_dim\n",
        "        self.num_heads = num_heads\n",
        "        self.head_dim = embed_dim // num_heads\n",
        "\n",
        "        assert embed_dim % num_heads == 0\n",
        "\n",
        "        self.q = nn.Linear(embed_dim, embed_dim)\n",
        "        self.k = nn.Linear(embed_dim, embed_dim)\n",
        "        self.v = nn.Linear(embed_dim, embed_dim)\n",
        "        self.proj = nn.Linear(embed_dim, embed_dim)\n",
        "        self.dropout = nn.Dropout(0.1)\n",
        "\n",
        "    def forward(self, x, kv_input):\n",
        "        \"\"\"\n",
        "        x: query input (B, N_patches, embed_dim) - from image patches\n",
        "        kv_input: key-value input (B, N_class_tokens, embed_dim) - from class embeddings (N_class_tokens tokens per class)\n",
        "        \"\"\"\n",
        "        B, N_patches, C = x.shape\n",
        "        _, N_class_tokens, _ = kv_input.shape\n",
        "\n",
        "        # Compute Q from patches, K,V from class embeddings\n",
        "        q = self.q(x).reshape(B, N_patches, self.num_heads, self.head_dim).permute(0, 2, 1, 3)\n",
        "        k = self.k(kv_input).reshape(B, N_class_tokens, self.num_heads, self.head_dim).permute(0, 2, 3, 1)\n",
        "        v = self.v(kv_input).reshape(B, N_class_tokens, self.num_heads, self.head_dim).permute(0, 2, 1, 3)\n",
        "\n",
        "        attn = (q @ k) * (self.head_dim**-0.5)\n",
        "        attn = attn.softmax(dim=-1)\n",
        "        attn = self.dropout(attn)\n",
        "\n",
        "        x = (attn @ v).transpose(1, 2).reshape(B, N_patches, C)\n",
        "        x = self.proj(x)\n",
        "        return x\n",
        "\n",
        "class MLP(nn.Module):\n",
        "    def __init__(self, embed_dim: int = 128, mlp_ratio: int = 4):\n",
        "        super().__init__()\n",
        "        hidden_dim = int(embed_dim * mlp_ratio)\n",
        "        self.fc1 = nn.Linear(embed_dim, hidden_dim)\n",
        "        self.fc2 = nn.Linear(hidden_dim, embed_dim)\n",
        "        self.dropout = nn.Dropout(0.1)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.fc1(x)\n",
        "        x = F.gelu(x)\n",
        "        x = self.dropout(x)\n",
        "        x = self.fc2(x)\n",
        "        x = self.dropout(x)\n",
        "        return x\n",
        "\n",
        "class TransformerBlock(nn.Module):\n",
        "    def __init__(self, embed_dim: int = 128, num_heads: int = 4, mlp_ratio: int = 4,\n",
        "                 use_cross_attn: bool = False):\n",
        "        super().__init__()\n",
        "        self.use_cross_attn = use_cross_attn\n",
        "\n",
        "        self.norm1 = nn.LayerNorm(embed_dim)\n",
        "        self.attn = MultiHeadAttention(embed_dim, num_heads)\n",
        "\n",
        "        if use_cross_attn:\n",
        "            self.norm_cross = nn.LayerNorm(embed_dim)\n",
        "            self.cross_attn = CrossAttention(embed_dim, num_heads)\n",
        "\n",
        "        self.norm2 = nn.LayerNorm(embed_dim)\n",
        "        self.mlp = MLP(embed_dim, mlp_ratio)\n",
        "\n",
        "    def forward(self, x, class_embeddings=None):\n",
        "        # Self-attention\n",
        "        x = x + self.attn(self.norm1(x))\n",
        "\n",
        "        # Cross-attention (if enabled and class embeddings provided)\n",
        "        if self.use_cross_attn and class_embeddings is not None:\n",
        "            x = x + self.cross_attn(self.norm_cross(x), class_embeddings)\n",
        "\n",
        "        # MLP\n",
        "        x = x + self.mlp(self.norm2(x))\n",
        "        return x\n",
        "\n",
        "class VisionTransformerDenoiser(nn.Module):\n",
        "    def __init__(self, img_size: int = 28, patch_size: int = 4, embed_dim: int = 128,\n",
        "                 num_layers: int = 3, num_heads: int = 4, mlp_ratio: int = 4,\n",
        "                 cross_attn_config: str = \"none\", num_classes: int = 10, num_class_tokens: int = 5):\n",
        "        super().__init__()\n",
        "        self.img_size = img_size\n",
        "        self.patch_size = patch_size\n",
        "        self.embed_dim = embed_dim\n",
        "        self.num_patches = (img_size // patch_size) ** 2\n",
        "        self.cross_attn_config = cross_attn_config\n",
        "        self.num_classes = num_classes\n",
        "        self.num_class_tokens = num_class_tokens\n",
        "\n",
        "        self.patch_embed = PatchEmbedding(img_size, patch_size, embed_dim)\n",
        "        self.pos_embed = nn.Parameter(torch.randn(1, self.num_patches, embed_dim) * 0.02)\n",
        "\n",
        "        # Class embeddings for cross-attention: efficient implementation of K independent embeddings\n",
        "        if cross_attn_config != \"none\":\n",
        "            self.class_embed = nn.Embedding(num_classes, num_class_tokens * embed_dim)\n",
        "            # Positional embeddings for class tokens (like patch positional embeddings)\n",
        "            self.class_pos_embed = nn.Parameter(torch.randn(1, num_class_tokens, embed_dim) * 0.02)\n",
        "\n",
        "        use_cross_attn = cross_attn_config != \"none\"\n",
        "        self.blocks = nn.ModuleList([\n",
        "            TransformerBlock(embed_dim, num_heads, mlp_ratio, use_cross_attn)\n",
        "            for _ in range(num_layers)\n",
        "        ])\n",
        "\n",
        "        self.norm = nn.LayerNorm(embed_dim)\n",
        "\n",
        "        # Unembedding: project back to patch pixels\n",
        "        pixels_per_patch = patch_size * patch_size\n",
        "        self.unembed = nn.Linear(embed_dim, pixels_per_patch)\n",
        "\n",
        "    def forward(self, x, class_labels=None):\n",
        "        # x: (batch_size, 1, 28, 28)\n",
        "        # class_labels: (batch_size,) - optional for cross-attention\n",
        "        B = x.shape[0]\n",
        "\n",
        "        # Patch embedding\n",
        "        x = self.patch_embed(x)  # (B, num_patches, embed_dim)\n",
        "\n",
        "        # Add positional embeddings\n",
        "        x = x + self.pos_embed\n",
        "\n",
        "        # Prepare class embeddings for cross-attention\n",
        "        class_embeddings = None\n",
        "        if self.cross_attn_config != \"none\" and class_labels is not None:\n",
        "            # Get class embeddings: (B, num_class_tokens, embed_dim)\n",
        "            # Efficient implementation: embed to (B, num_class_tokens*embed_dim) then reshape\n",
        "            class_embeds_flat = self.class_embed(class_labels)  # (B, num_class_tokens*embed_dim)\n",
        "            class_embeddings = class_embeds_flat.reshape(B, self.num_class_tokens, self.embed_dim)\n",
        "            # Add positional embeddings to class tokens (like patch embeddings)\n",
        "            class_embeddings = class_embeddings + self.class_pos_embed\n",
        "\n",
        "        # Apply transformer blocks\n",
        "        for block in self.blocks:\n",
        "            x = block(x, class_embeddings)\n",
        "\n",
        "        x = self.norm(x)\n",
        "\n",
        "        # Unembed to patches\n",
        "        x = self.unembed(x)  # (B, num_patches, pixels_per_patch)\n",
        "\n",
        "        # Reshape back to image\n",
        "        patches_per_side = self.img_size // self.patch_size\n",
        "        x = x.reshape(B, patches_per_side, patches_per_side, self.patch_size, self.patch_size)\n",
        "        x = x.permute(0, 1, 3, 2, 4).contiguous()\n",
        "        x = x.reshape(B, 1, self.img_size, self.img_size)\n",
        "\n",
        "        return x\n",
        "\n",
        "# Example usage and model size comparison\n",
        "model_baseline = VisionTransformerDenoiser(img_size=28, patch_size=4, embed_dim=128, num_layers=3, cross_attn_config=\"none\")\n",
        "model_cross_attn = VisionTransformerDenoiser(img_size=28, patch_size=4, embed_dim=128, num_layers=3, cross_attn_config=\"enabled\", num_classes=10)\n",
        "model_large = VisionTransformerDenoiser(img_size=28, patch_size=4, embed_dim=384, num_layers=3, num_heads=6, cross_attn_config=\"none\")\n",
        "\n",
        "print(\"Model Size Comparison:\")\n",
        "print(f\"Baseline model (no cross-attn): {sum(p.numel() for p in model_baseline.parameters()):,} parameters\")\n",
        "print(f\"Cross-attention model: {sum(p.numel() for p in model_cross_attn.parameters()):,} parameters\")\n",
        "print(f\"Large model (embed_dim=384): {sum(p.numel() for p in model_large.parameters()):,} parameters\")\n",
        "\n",
        "# Test with random input\n",
        "x = torch.randn(2, 1, 28, 28)\n",
        "class_labels = torch.randint(0, 10, (2,))\n",
        "\n",
        "print(f\"\\nInput shape: {x.shape}\")\n",
        "print(f\"Class labels: {class_labels}\")\n",
        "\n",
        "# Test baseline model\n",
        "output_baseline = model_baseline(x)\n",
        "print(f\"Baseline output shape: {output_baseline.shape}\")\n",
        "\n",
        "# Test cross-attention model\n",
        "output_cross_attn = model_cross_attn(x, class_labels)\n",
        "print(f\"Cross-attention output shape: {output_cross_attn.shape}\")\n",
        "\n",
        "# Use the baseline model for training (can be switched to cross-attention later)\n",
        "model = model_baseline"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Dataset Setup"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Training samples: 60000\n",
            "Test samples: 10000\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "import torch.optim as optim\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "from torch.utils.data import DataLoader\n",
        "\n",
        "# Download and prepare MNIST dataset\n",
        "transform = transforms.Compose(\n",
        "    [\n",
        "        transforms.ToTensor(),\n",
        "    ]\n",
        ")\n",
        "\n",
        "train_dataset = torchvision.datasets.MNIST(\n",
        "    root=\"./data\", train=True, transform=transform, download=True\n",
        ")\n",
        "test_dataset = torchvision.datasets.MNIST(\n",
        "    root=\"./data\", train=False, transform=transform, download=True\n",
        ")\n",
        "\n",
        "batch_size = 512\n",
        "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
        "\n",
        "print(f\"Training samples: {len(train_dataset)}\")\n",
        "print(f\"Test samples: {len(test_dataset)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "─\n",
        "## Noise Addition and Helper Functions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Original range: [0.000, 1.000]\n",
            "Noisy range: [0.000, 1.000]\n"
          ]
        }
      ],
      "source": [
        "def add_gaussian_noise(images, noise_std=0.2):\n",
        "    \"\"\"Add Gaussian noise to images\"\"\"\n",
        "    noise = torch.randn_like(images) * noise_std\n",
        "    noisy_images = images + noise\n",
        "    return torch.clamp(noisy_images, 0.0, 1.0)\n",
        "\n",
        "def evaluate_model(model, data_loader, noise_std=0.2, device='cpu', use_class_labels=False):\n",
        "    \"\"\"Evaluate model on test set\"\"\"\n",
        "    model.eval()\n",
        "    total_loss = 0.0\n",
        "    num_batches = 0\n",
        "\n",
        "    with torch.no_grad():\n",
        "        for images, labels in data_loader:\n",
        "            images = images.to(device)\n",
        "            labels = labels.to(device)\n",
        "            noisy_images = add_gaussian_noise(images, noise_std)\n",
        "\n",
        "            if use_class_labels:\n",
        "                outputs = model(noisy_images, labels)\n",
        "            else:\n",
        "                outputs = model(noisy_images)\n",
        "            loss = F.mse_loss(outputs, images)\n",
        "\n",
        "            total_loss += loss.item()\n",
        "            num_batches += 1\n",
        "\n",
        "    return total_loss / num_batches\n",
        "\n",
        "# Test noise addition\n",
        "sample_batch, _ = next(iter(train_loader))\n",
        "noisy_batch = add_gaussian_noise(sample_batch, 0.2)\n",
        "print(f\"Original range: [{sample_batch.min():.3f}, {sample_batch.max():.3f}]\")\n",
        "print(f\"Noisy range: [{noisy_batch.min():.3f}, {noisy_batch.max():.3f}]\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Training Loop"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Using device: cpu\n",
            "Baseline model parameters: 605,584\n",
            "Conditional model parameters: 811,536\n",
            "Starting dual model training...\n",
            "Epoch 1/10, Batch 0:\n",
            "  Baseline Loss: 0.589925\n",
            "  Conditional Loss: 0.605246\n",
            "Epoch 1/10, Batch 100:\n",
            "  Baseline Loss: 0.014165\n",
            "  Conditional Loss: 0.014485\n",
            "Epoch 1/10 Results:\n",
            "  Baseline - Train: 0.053855, Test: 0.009175\n",
            "  Conditional - Train: 0.047980, Test: 0.009853\n",
            "\n",
            "Epoch 2/10, Batch 0:\n",
            "  Baseline Loss: 0.011881\n",
            "  Conditional Loss: 0.012587\n",
            "Epoch 2/10, Batch 100:\n",
            "  Baseline Loss: 0.008089\n",
            "  Conditional Loss: 0.008545\n",
            "Epoch 2/10 Results:\n",
            "  Baseline - Train: 0.009310, Test: 0.006402\n",
            "  Conditional - Train: 0.009884, Test: 0.006695\n",
            "\n",
            "Epoch 3/10, Batch 0:\n",
            "  Baseline Loss: 0.007999\n",
            "  Conditional Loss: 0.008325\n",
            "Epoch 3/10, Batch 100:\n",
            "  Baseline Loss: 0.006997\n",
            "  Conditional Loss: 0.007027\n",
            "Epoch 3/10 Results:\n",
            "  Baseline - Train: 0.007326, Test: 0.005807\n",
            "  Conditional - Train: 0.007506, Test: 0.005720\n",
            "\n",
            "Epoch 4/10, Batch 0:\n",
            "  Baseline Loss: 0.006903\n",
            "  Conditional Loss: 0.006876\n",
            "Epoch 4/10, Batch 100:\n",
            "  Baseline Loss: 0.006435\n",
            "  Conditional Loss: 0.006302\n",
            "Epoch 4/10 Results:\n",
            "  Baseline - Train: 0.006622, Test: 0.005496\n",
            "  Conditional - Train: 0.006545, Test: 0.005232\n",
            "\n",
            "Epoch 5/10, Batch 0:\n",
            "  Baseline Loss: 0.006404\n",
            "  Conditional Loss: 0.006246\n",
            "Epoch 5/10, Batch 100:\n",
            "  Baseline Loss: 0.005970\n",
            "  Conditional Loss: 0.005712\n",
            "Epoch 5/10 Results:\n",
            "  Baseline - Train: 0.006207, Test: 0.005271\n",
            "  Conditional - Train: 0.006014, Test: 0.004947\n",
            "\n",
            "Epoch 6/10, Batch 0:\n",
            "  Baseline Loss: 0.006038\n",
            "  Conditional Loss: 0.005783\n",
            "Epoch 6/10, Batch 100:\n",
            "  Baseline Loss: 0.005747\n",
            "  Conditional Loss: 0.005415\n",
            "Epoch 6/10 Results:\n",
            "  Baseline - Train: 0.005912, Test: 0.005131\n",
            "  Conditional - Train: 0.005625, Test: 0.004747\n",
            "\n",
            "Epoch 7/10, Batch 0:\n",
            "  Baseline Loss: 0.005777\n",
            "  Conditional Loss: 0.005478\n",
            "Epoch 7/10, Batch 100:\n",
            "  Baseline Loss: 0.005559\n",
            "  Conditional Loss: 0.005242\n",
            "Epoch 7/10 Results:\n",
            "  Baseline - Train: 0.005674, Test: 0.004941\n",
            "  Conditional - Train: 0.005353, Test: 0.004561\n",
            "\n",
            "Epoch 8/10, Batch 0:\n",
            "  Baseline Loss: 0.005522\n",
            "  Conditional Loss: 0.005220\n",
            "Epoch 8/10, Batch 100:\n",
            "  Baseline Loss: 0.005412\n",
            "  Conditional Loss: 0.005134\n",
            "Epoch 8/10 Results:\n",
            "  Baseline - Train: 0.005451, Test: 0.004751\n",
            "  Conditional - Train: 0.005147, Test: 0.004432\n",
            "\n",
            "Epoch 9/10, Batch 0:\n",
            "  Baseline Loss: 0.005348\n",
            "  Conditional Loss: 0.005100\n",
            "Epoch 9/10, Batch 100:\n",
            "  Baseline Loss: 0.005188\n",
            "  Conditional Loss: 0.004924\n",
            "Epoch 9/10 Results:\n",
            "  Baseline - Train: 0.005254, Test: 0.004590\n",
            "  Conditional - Train: 0.004992, Test: 0.004340\n",
            "\n",
            "Epoch 10/10, Batch 0:\n",
            "  Baseline Loss: 0.005163\n",
            "  Conditional Loss: 0.004878\n",
            "Epoch 10/10, Batch 100:\n",
            "  Baseline Loss: 0.005044\n",
            "  Conditional Loss: 0.004792\n",
            "Epoch 10/10 Results:\n",
            "  Baseline - Train: 0.005085, Test: 0.004460\n",
            "  Conditional - Train: 0.004854, Test: 0.004259\n",
            "\n",
            "Training completed!\n"
          ]
        }
      ],
      "source": [
        "# Set device\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "print(f\"Using device: {device}\")\n",
        "\n",
        "# Initialize both models\n",
        "model_baseline = VisionTransformerDenoiser(img_size=28, patch_size=4, embed_dim=128, num_layers=3,\n",
        "                                          cross_attn_config=\"none\")\n",
        "model_conditional = VisionTransformerDenoiser(img_size=28, patch_size=4, embed_dim=128, num_layers=3,\n",
        "                                             cross_attn_config=\"enabled\", num_classes=10, num_class_tokens=5)\n",
        "\n",
        "model_baseline = model_baseline.to(device)\n",
        "model_conditional = model_conditional.to(device)\n",
        "\n",
        "print(f\"Baseline model parameters: {sum(p.numel() for p in model_baseline.parameters()):,}\")\n",
        "print(f\"Conditional model parameters: {sum(p.numel() for p in model_conditional.parameters()):,}\")\n",
        "\n",
        "# Training parameters\n",
        "learning_rate = 1e-3\n",
        "num_epochs = 10\n",
        "noise_std = 0.2\n",
        "\n",
        "# Optimizers and loss function\n",
        "optimizer_baseline = optim.Adam(model_baseline.parameters(), lr=learning_rate)\n",
        "optimizer_conditional = optim.Adam(model_conditional.parameters(), lr=learning_rate)\n",
        "criterion = nn.MSELoss()\n",
        "\n",
        "# Training history\n",
        "train_losses_baseline = []\n",
        "test_losses_baseline = []\n",
        "train_losses_conditional = []\n",
        "test_losses_conditional = []\n",
        "\n",
        "print(\"Starting dual model training...\")\n",
        "for epoch in range(num_epochs):\n",
        "    model_baseline.train()\n",
        "    model_conditional.train()\n",
        "\n",
        "    epoch_loss_baseline = 0.0\n",
        "    epoch_loss_conditional = 0.0\n",
        "    num_batches = 0\n",
        "\n",
        "    for batch_idx, (images, labels) in enumerate(train_loader):\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "\n",
        "        # Add noise to create input\n",
        "        noisy_images = add_gaussian_noise(images, noise_std)\n",
        "\n",
        "        # Train baseline model (unconditional)\n",
        "        optimizer_baseline.zero_grad()\n",
        "        outputs_baseline = model_baseline(noisy_images)\n",
        "        loss_baseline = criterion(outputs_baseline, images)\n",
        "        loss_baseline.backward()\n",
        "        optimizer_baseline.step()\n",
        "\n",
        "        # Train conditional model (with class labels)\n",
        "        optimizer_conditional.zero_grad()\n",
        "        outputs_conditional = model_conditional(noisy_images, labels)\n",
        "        loss_conditional = criterion(outputs_conditional, images)\n",
        "        loss_conditional.backward()\n",
        "        optimizer_conditional.step()\n",
        "\n",
        "        epoch_loss_baseline += loss_baseline.item()\n",
        "        epoch_loss_conditional += loss_conditional.item()\n",
        "        num_batches += 1\n",
        "\n",
        "        if batch_idx % 100 == 0:\n",
        "            print(f'Epoch {epoch+1}/{num_epochs}, Batch {batch_idx}:')\n",
        "            print(f'  Baseline Loss: {loss_baseline.item():.6f}')\n",
        "            print(f'  Conditional Loss: {loss_conditional.item():.6f}')\n",
        "\n",
        "    # Calculate average training losses\n",
        "    avg_train_loss_baseline = epoch_loss_baseline / num_batches\n",
        "    avg_train_loss_conditional = epoch_loss_conditional / num_batches\n",
        "    train_losses_baseline.append(avg_train_loss_baseline)\n",
        "    train_losses_conditional.append(avg_train_loss_conditional)\n",
        "\n",
        "    # Evaluate on test set\n",
        "    test_loss_baseline = evaluate_model(model_baseline, test_loader, noise_std, device, use_class_labels=False)\n",
        "    test_loss_conditional = evaluate_model(model_conditional, test_loader, noise_std, device, use_class_labels=True)\n",
        "    test_losses_baseline.append(test_loss_baseline)\n",
        "    test_losses_conditional.append(test_loss_conditional)\n",
        "\n",
        "    print(f'Epoch {epoch+1}/{num_epochs} Results:')\n",
        "    print(f'  Baseline - Train: {avg_train_loss_baseline:.6f}, Test: {test_loss_baseline:.6f}')\n",
        "    print(f'  Conditional - Train: {avg_train_loss_conditional:.6f}, Test: {test_loss_conditional:.6f}')\n",
        "    print()\n",
        "\n",
        "print(\"Training completed!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Learning Curves"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1500x500 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Final Results:\n",
            "Baseline - Train: 0.005085, Test: 0.004460\n",
            "Conditional - Train: 0.004854, Test: 0.004259\n"
          ]
        }
      ],
      "source": [
        "# Plot learning curves for both models\n",
        "plt.figure(figsize=(15, 5))\n",
        "\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(range(1, num_epochs+1), train_losses_baseline, 'b-', label='Baseline Train')\n",
        "plt.plot(range(1, num_epochs+1), test_losses_baseline, 'b--', label='Baseline Test')\n",
        "plt.plot(range(1, num_epochs+1), train_losses_conditional, 'r-', label='Conditional Train')\n",
        "plt.plot(range(1, num_epochs+1), test_losses_conditional, 'r--', label='Conditional Test')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('MSE Loss')\n",
        "plt.yscale('log')\n",
        "plt.title('Learning Curves Comparison (Log Scale)')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(range(1, num_epochs+1), train_losses_baseline, 'b-', label='Baseline')\n",
        "plt.plot(range(1, num_epochs+1), train_losses_conditional, 'r-', label='Conditional')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Training MSE Loss')\n",
        "plt.yscale('log')\n",
        "plt.title('Training Loss Comparison (Log Scale)')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n",
        "\n",
        "# Final evaluation summary\n",
        "print(\"Final Results:\")\n",
        "print(f\"Baseline - Train: {train_losses_baseline[-1]:.6f}, Test: {test_losses_baseline[-1]:.6f}\")\n",
        "print(f\"Conditional - Train: {train_losses_conditional[-1]:.6f}, Test: {test_losses_conditional[-1]:.6f}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Baseline Model Denoising Results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1600x600 with 24 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Visualize baseline model denoising results\n",
        "model_baseline.eval()\n",
        "with torch.no_grad():\n",
        "    # Get a batch of test images\n",
        "    test_images, test_labels = next(iter(test_loader))\n",
        "    test_images = test_images[:8].to(device)\n",
        "    test_labels = test_labels[:8]\n",
        "\n",
        "    # Add noise\n",
        "    noisy_images = add_gaussian_noise(test_images, noise_std)\n",
        "\n",
        "    # Denoise with baseline model\n",
        "    denoised_images = model_baseline(noisy_images)\n",
        "\n",
        "    # Move to CPU for plotting\n",
        "    test_images = test_images.cpu()\n",
        "    noisy_images = noisy_images.cpu()\n",
        "    denoised_images = denoised_images.cpu()\n",
        "\n",
        "    # Plot comparison\n",
        "    fig, axes = plt.subplots(3, 8, figsize=(16, 6))\n",
        "\n",
        "    for i in range(8):\n",
        "        # Original\n",
        "        axes[0, i].imshow(test_images[i, 0], cmap='gray')\n",
        "        axes[0, i].set_title(f'Orig: {test_labels[i].item()}' if i < 4 else '')\n",
        "        axes[0, i].axis('off')\n",
        "\n",
        "        # Noisy\n",
        "        axes[1, i].imshow(noisy_images[i, 0], cmap='gray')\n",
        "        axes[1, i].set_title('Noisy' if i == 0 else '')\n",
        "        axes[1, i].axis('off')\n",
        "\n",
        "        # Denoised\n",
        "        axes[2, i].imshow(denoised_images[i, 0], cmap='gray')\n",
        "        axes[2, i].set_title('Baseline' if i == 0 else '')\n",
        "        axes[2, i].axis('off')\n",
        "\n",
        "    plt.suptitle('Baseline Model (Unconditional) Denoising')\n",
        "    plt.tight_layout()\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Conditional Model Denoising Results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1600x600 with 24 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Visualize conditional model denoising results\n",
        "model_conditional.eval()\n",
        "with torch.no_grad():\n",
        "    # Use same test images for fair comparison\n",
        "    test_images, test_labels = next(iter(test_loader))\n",
        "    test_images = test_images[:8].to(device)\n",
        "    test_labels = test_labels[:8].to(device)\n",
        "\n",
        "    # Add noise\n",
        "    noisy_images = add_gaussian_noise(test_images, noise_std)\n",
        "\n",
        "    # Denoise with conditional model (using correct class labels)\n",
        "    denoised_images = model_conditional(noisy_images, test_labels)\n",
        "\n",
        "    # Move to CPU for plotting\n",
        "    test_images = test_images.cpu()\n",
        "    noisy_images = noisy_images.cpu()\n",
        "    denoised_images = denoised_images.cpu()\n",
        "    test_labels = test_labels.cpu()\n",
        "\n",
        "    # Plot comparison\n",
        "    fig, axes = plt.subplots(3, 8, figsize=(16, 6))\n",
        "\n",
        "    for i in range(8):\n",
        "        # Original\n",
        "        axes[0, i].imshow(test_images[i, 0], cmap='gray')\n",
        "        axes[0, i].set_title(f'Orig: {test_labels[i].item()}' if i < 4 else '')\n",
        "        axes[0, i].axis('off')\n",
        "\n",
        "        # Noisy\n",
        "        axes[1, i].imshow(noisy_images[i, 0], cmap='gray')\n",
        "        axes[1, i].set_title('Noisy' if i == 0 else '')\n",
        "        axes[1, i].axis('off')\n",
        "\n",
        "        # Denoised\n",
        "        axes[2, i].imshow(denoised_images[i, 0], cmap='gray')\n",
        "        axes[2, i].set_title('Conditional' if i == 0 else '')\n",
        "        axes[2, i].axis('off')\n",
        "\n",
        "    plt.suptitle('Conditional Model (Cross-Attention) Denoising')\n",
        "    plt.tight_layout()\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Per-Class Test Error Analysis"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Calculating per-class test errors...\n",
            "\n",
            "Per-Class Test Errors (MSE):\n",
            "Class | Baseline  | Conditional | Improvement\n",
            "------|-----------|-------------|------------\n",
            "  0   | 0.005144 | 0.004942  | +0.000202 (+3.9%)\n",
            "  1   | 0.002510 | 0.002312  | +0.000198 (+7.9%)\n",
            "  2   | 0.004917 | 0.004758  | +0.000159 (+3.2%)\n",
            "  3   | 0.004828 | 0.004662  | +0.000166 (+3.4%)\n",
            "  4   | 0.004371 | 0.004185  | +0.000187 (+4.3%)\n",
            "  5   | 0.004803 | 0.004592  | +0.000211 (+4.4%)\n",
            "  6   | 0.004783 | 0.004596  | +0.000187 (+3.9%)\n",
            "  7   | 0.003980 | 0.003791  | +0.000189 (+4.7%)\n",
            "  8   | 0.005209 | 0.005017  | +0.000192 (+3.7%)\n",
            "  9   | 0.004379 | 0.004194  | +0.000186 (+4.2%)\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1200x500 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Overall Comparison:\n",
            "Baseline average: 0.004492\n",
            "Conditional average: 0.004305\n",
            "Overall improvement: +0.000188 (+4.2%)\n"
          ]
        }
      ],
      "source": [
        "def evaluate_per_class(model, data_loader, noise_std=0.2, device='cpu', use_class_labels=False):\n",
        "    \"\"\"Evaluate model per class\"\"\"\n",
        "    model.eval()\n",
        "    class_losses = {i: [] for i in range(10)}\n",
        "\n",
        "    with torch.no_grad():\n",
        "        for images, labels in data_loader:\n",
        "            images = images.to(device)\n",
        "            labels = labels.to(device)\n",
        "            noisy_images = add_gaussian_noise(images, noise_std)\n",
        "\n",
        "            if use_class_labels:\n",
        "                outputs = model(noisy_images, labels)\n",
        "            else:\n",
        "                outputs = model(noisy_images)\n",
        "\n",
        "            # Calculate loss for each sample\n",
        "            losses = F.mse_loss(outputs, images, reduction='none').mean(dim=[1,2,3])\n",
        "\n",
        "            # Group by class\n",
        "            for i, label in enumerate(labels):\n",
        "                class_losses[label.item()].append(losses[i].item())\n",
        "\n",
        "    # Calculate mean loss per class\n",
        "    class_mean_losses = {}\n",
        "    for class_id in range(10):\n",
        "        if class_losses[class_id]:\n",
        "            class_mean_losses[class_id] = np.mean(class_losses[class_id])\n",
        "        else:\n",
        "            class_mean_losses[class_id] = 0.0\n",
        "\n",
        "    return class_mean_losses\n",
        "\n",
        "# Calculate per-class errors\n",
        "print(\"Calculating per-class test errors...\")\n",
        "baseline_class_errors = evaluate_per_class(model_baseline, test_loader, noise_std, device, use_class_labels=False)\n",
        "conditional_class_errors = evaluate_per_class(model_conditional, test_loader, noise_std, device, use_class_labels=True)\n",
        "\n",
        "# Display results\n",
        "print(\"\\nPer-Class Test Errors (MSE):\")\n",
        "print(\"Class | Baseline  | Conditional | Improvement\")\n",
        "print(\"------|-----------|-------------|------------\")\n",
        "for class_id in range(10):\n",
        "    baseline_err = baseline_class_errors[class_id]\n",
        "    conditional_err = conditional_class_errors[class_id]\n",
        "    improvement = baseline_err - conditional_err\n",
        "    improvement_pct = (improvement / baseline_err * 100) if baseline_err > 0 else 0\n",
        "    print(f\"  {class_id}   | {baseline_err:.6f} | {conditional_err:.6f}  | {improvement:+.6f} ({improvement_pct:+.1f}%)\")\n",
        "\n",
        "# Plot comparison\n",
        "plt.figure(figsize=(12, 5))\n",
        "\n",
        "plt.subplot(1, 2, 1)\n",
        "classes = list(range(10))\n",
        "baseline_errors = [baseline_class_errors[i] for i in classes]\n",
        "conditional_errors = [conditional_class_errors[i] for i in classes]\n",
        "\n",
        "x = np.arange(len(classes))\n",
        "width = 0.35\n",
        "\n",
        "plt.bar(x - width/2, baseline_errors, width, label='Baseline', alpha=0.8)\n",
        "plt.bar(x + width/2, conditional_errors, width, label='Conditional', alpha=0.8)\n",
        "plt.xlabel('Digit Class')\n",
        "plt.ylabel('MSE Loss')\n",
        "plt.title('Per-Class Test Error Comparison')\n",
        "plt.xticks(x, classes)\n",
        "plt.legend()\n",
        "plt.grid(True, alpha=0.3)\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "improvements = [baseline_class_errors[i] - conditional_class_errors[i] for i in classes]\n",
        "colors = ['green' if imp > 0 else 'red' for imp in improvements]\n",
        "plt.bar(classes, improvements, color=colors, alpha=0.7)\n",
        "plt.xlabel('Digit Class')\n",
        "plt.ylabel('Error Reduction (Baseline - Conditional)')\n",
        "plt.title('Per-Class Improvement')\n",
        "plt.grid(True, alpha=0.3)\n",
        "plt.axhline(y=0, color='black', linestyle='-', alpha=0.5)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n",
        "\n",
        "# Overall comparison\n",
        "overall_baseline = np.mean(list(baseline_class_errors.values()))\n",
        "overall_conditional = np.mean(list(conditional_class_errors.values()))\n",
        "overall_improvement = overall_baseline - overall_conditional\n",
        "print(f\"\\nOverall Comparison:\")\n",
        "print(f\"Baseline average: {overall_baseline:.6f}\")\n",
        "print(f\"Conditional average: {overall_conditional:.6f}\")\n",
        "print(f\"Overall improvement: {overall_improvement:+.6f} ({overall_improvement/overall_baseline*100:+.1f}%)\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Experimental Cross-Class Conditioning"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1600x800 with 32 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Cross-Class Conditioning Analysis:\n",
            "Digit 7: Correct=0.002774, Wrong=0.002977, Diff=+0.000203\n",
            "Digit 1: Correct=0.001754, Wrong=0.001750, Diff=-0.000004\n",
            "Digit 1: Correct=0.002420, Wrong=0.002650, Diff=+0.000230\n",
            "Digit 1: Correct=0.003456, Wrong=0.003633, Diff=+0.000176\n",
            "Digit 7: Correct=0.004570, Wrong=0.004869, Diff=+0.000299\n",
            "Digit 7: Correct=0.002819, Wrong=0.003031, Diff=+0.000212\n",
            "Digit 1: Correct=0.001746, Wrong=0.001936, Diff=+0.000190\n",
            "Digit 7: Correct=0.005002, Wrong=0.005136, Diff=+0.000134\n",
            "\n",
            "Average - Correct: 0.003068, Wrong: 0.003248\n",
            "Wrong conditioning increases error by +0.000180 on average\n"
          ]
        }
      ],
      "source": [
        "# Experiment: Condition model on wrong class labels to see learned effects\n",
        "model_conditional.eval()\n",
        "\n",
        "# Find some 7s and 1s in test set for the experiment\n",
        "sevens_and_ones = []\n",
        "for images, labels in test_loader:\n",
        "    for i, label in enumerate(labels):\n",
        "        if label.item() == 7 and len([x for x in sevens_and_ones if x[1] == 7]) < 4:\n",
        "            sevens_and_ones.append((images[i:i+1], label.item()))\n",
        "        elif label.item() == 1 and len([x for x in sevens_and_ones if x[1] == 1]) < 4:\n",
        "            sevens_and_ones.append((images[i:i+1], label.item()))\n",
        "        if len(sevens_and_ones) >= 8:\n",
        "            break\n",
        "    if len(sevens_and_ones) >= 8:\n",
        "        break\n",
        "\n",
        "with torch.no_grad():\n",
        "    fig, axes = plt.subplots(4, 8, figsize=(16, 8))\n",
        "\n",
        "    for idx, (image, true_label) in enumerate(sevens_and_ones):\n",
        "        image = image.to(device)\n",
        "        noisy_image = add_gaussian_noise(image, noise_std)\n",
        "\n",
        "        # Denoise with correct label\n",
        "        correct_label = torch.tensor([true_label]).to(device)\n",
        "        denoised_correct = model_conditional(noisy_image, correct_label)\n",
        "\n",
        "        # Denoise with wrong label (7->1, 1->7)\n",
        "        wrong_label = torch.tensor([1 if true_label == 7 else 7]).to(device)\n",
        "        denoised_wrong = model_conditional(noisy_image, wrong_label)\n",
        "\n",
        "        # Move to CPU\n",
        "        image = image.cpu()\n",
        "        noisy_image = noisy_image.cpu()\n",
        "        denoised_correct = denoised_correct.cpu()\n",
        "        denoised_wrong = denoised_wrong.cpu()\n",
        "\n",
        "        # Plot\n",
        "        # Original\n",
        "        axes[0, idx].imshow(image[0, 0], cmap='gray')\n",
        "        axes[0, idx].set_title(f'Original: {true_label}' if idx < 4 else '')\n",
        "        axes[0, idx].axis('off')\n",
        "\n",
        "        # Noisy\n",
        "        axes[1, idx].imshow(noisy_image[0, 0], cmap='gray')\n",
        "        axes[1, idx].set_title('Noisy' if idx == 0 else '')\n",
        "        axes[1, idx].axis('off')\n",
        "\n",
        "        # Correct conditioning\n",
        "        axes[2, idx].imshow(denoised_correct[0, 0], cmap='gray')\n",
        "        axes[2, idx].set_title(f'Cond: {true_label}' if idx < 4 else '')\n",
        "        axes[2, idx].axis('off')\n",
        "\n",
        "        # Wrong conditioning\n",
        "        axes[3, idx].imshow(denoised_wrong[0, 0], cmap='gray')\n",
        "        axes[3, idx].set_title(f'Cond: {wrong_label.item()}' if idx < 4 else '')\n",
        "        axes[3, idx].axis('off')\n",
        "\n",
        "    plt.suptitle('Cross-Class Conditioning Experiment: 7s vs 1s\\n(Row 3: Correct class, Row 4: Wrong class)', fontsize=14)\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "# Quantitative comparison for the experiment\n",
        "print(\"\\nCross-Class Conditioning Analysis:\")\n",
        "with torch.no_grad():\n",
        "    # Calculate MSE for correct vs wrong conditioning\n",
        "    correct_losses = []\n",
        "    wrong_losses = []\n",
        "\n",
        "    for image, true_label in sevens_and_ones:\n",
        "        image = image.to(device)\n",
        "        noisy_image = add_gaussian_noise(image, noise_std)\n",
        "\n",
        "        # Correct conditioning\n",
        "        correct_label = torch.tensor([true_label]).to(device)\n",
        "        denoised_correct = model_conditional(noisy_image, correct_label)\n",
        "        correct_loss = F.mse_loss(denoised_correct, image).item()\n",
        "        correct_losses.append(correct_loss)\n",
        "\n",
        "        # Wrong conditioning\n",
        "        wrong_label = torch.tensor([1 if true_label == 7 else 7]).to(device)\n",
        "        denoised_wrong = model_conditional(noisy_image, wrong_label)\n",
        "        wrong_loss = F.mse_loss(denoised_wrong, image).item()\n",
        "        wrong_losses.append(wrong_loss)\n",
        "\n",
        "        print(f\"Digit {true_label}: Correct={correct_loss:.6f}, Wrong={wrong_loss:.6f}, Diff={wrong_loss-correct_loss:+.6f}\")\n",
        "\n",
        "print(f\"\\nAverage - Correct: {np.mean(correct_losses):.6f}, Wrong: {np.mean(wrong_losses):.6f}\")\n",
        "print(f\"Wrong conditioning increases error by {np.mean(wrong_losses)-np.mean(correct_losses):+.6f} on average\")"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": ".venv",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.13.1"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 4
}