mnist_ijepa.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simplified image-based implementation of JEPA (Joint-Embedding Predictive Architecture)\n",
    "\n",
    "Paper: https://arxiv.org/pdf/2301.08243.pdf",
    "\n",
    "JEPA (Joint-Embedding Predictive Architecture) is an alternative to auto-regressive LLM architectures pioneered by Prof. Yann LeCun. I-JEPA predicts image segment representations (Target) based on representations of other segments within the same image (Context)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0e89cf7ae1304374a6757951016167aa",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Training:   0%|          | 0/1876 [00:00<?, ?batch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3dfc9f4e461441a9a60bf865cd345438",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "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",
    "import time\n",
    "from tqdm.notebook import tqdm\n",
    "from IPython.display import display\n",
    "import ipywidgets as widgets\n",
    "from torch.optim.lr_scheduler import ReduceLROnPlateau\n",
    "from scipy.interpolate import make_interp_spline\n",
    "\n",
    "class SimplifiedViT(nn.Module):\n",
    "    \"\"\"Simplified Vision Transformer (ViT) implementation\"\"\"\n",
    "    def __init__(self, image_size, patch_size, dim, depth, heads, mlp_dim, in_channels):\n",
    "        super(SimplifiedViT, self).__init__()\n",
    "        self.image_size = image_size\n",
    "        self.patch_size = patch_size\n",
    "        self.in_channels = in_channels\n",
    "        self.num_patches = (image_size // patch_size) ** 2\n",
    "        patch_dim = in_channels * patch_size * patch_size\n",
    "\n",
    "        # Embed patches to vectors\n",
    "        self.patch_embedding = nn.Linear(patch_dim, dim)\n",
    "        # Learnable position embeddings\n",
    "        self.pos_embedding = nn.Parameter(torch.randn(1, self.num_patches, dim))\n",
    "\n",
    "        # Transformer encoder layers\n",
    "        self.layers = nn.ModuleList([])\n",
    "        for _ in range(depth):\n",
    "            self.layers.append(nn.TransformerEncoderLayer(d_model=dim, nhead=heads, dim_feedforward=mlp_dim))\n",
    "\n",
    "        # Layer normalization\n",
    "        self.norm = nn.LayerNorm(dim)\n",
    "\n",
    "    def forward(self, img):\n",
    "        # Handle different input shapes\n",
    "        if img.dim() == 3 and img.size(1) == self.num_patches:\n",
    "            x = img\n",
    "        else:\n",
    "            if img.dim() == 3:\n",
    "                img = img.unsqueeze(1)\n",
    "            \n",
    "            b, c, h, w = img.shape\n",
    "            assert h == w == self.image_size, f\"Input image size ({h}*{w}) doesn't match model ({self.image_size}*{self.image_size}).\"\n",
    "            assert c == self.in_channels, f\"Input channels {c} doesn't match expected {self.in_channels}\"\n",
    "\n",
    "            # Convert image to patches\n",
    "            x = img.unfold(2, self.patch_size, self.patch_size).unfold(3, self.patch_size, self.patch_size)\n",
    "            x = x.contiguous().view(b, c, -1, self.patch_size * self.patch_size)\n",
    "            x = x.permute(0, 2, 1, 3).contiguous().view(b, -1, c * self.patch_size * self.patch_size)\n",
    "            x = self.patch_embedding(x)\n",
    "\n",
    "        # Add position embeddings\n",
    "        x = x + self.pos_embedding\n",
    "\n",
    "        # Pass through transformer layers\n",
    "        for layer in self.layers:\n",
    "            x = layer(x)\n",
    "\n",
    "        # Apply final normalization\n",
    "        x = self.norm(x)\n",
    "        return x\n",
    "\n",
    "class IJEPA(nn.Module):\n",
    "    \"\"\"Simplified IJEPA (Image-based Joint-Embedding Predictive Architecture)\"\"\"\n",
    "    def __init__(self, image_size, patch_size, dim, context_depth, predictor_depth, heads, mlp_dim, in_channels):\n",
    "        super(IJEPA, self).__init__()\n",
    "        # Context and target encoders (sharing architecture but not weights)\n",
    "        self.context_encoder = SimplifiedViT(image_size, patch_size, dim, context_depth, heads, mlp_dim, in_channels)\n",
    "        self.target_encoder = SimplifiedViT(image_size, patch_size, dim, context_depth, heads, mlp_dim, in_channels)\n",
    "\n",
    "        # Predictor network\n",
    "        predictor_layers = []\n",
    "        for _ in range(predictor_depth):\n",
    "            predictor_layers.extend([\n",
    "                nn.Linear(dim, dim),\n",
    "                nn.GELU(),\n",
    "                nn.LayerNorm(dim)\n",
    "            ])\n",
    "        self.predictor = nn.Sequential(*predictor_layers)\n",
    "        \n",
    "        self.patch_size = patch_size\n",
    "        self.image_size = image_size\n",
    "        self.num_patches = (image_size // patch_size) ** 2\n",
    "        self.in_channels = in_channels\n",
    "\n",
    "        # Decoder for visualizing predictions\n",
    "        self.decoder = nn.Sequential(\n",
    "            nn.Linear(dim, 512),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(512, 512),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(512, in_channels * patch_size * patch_size),\n",
    "            nn.Sigmoid()\n",
    "        )\n",
    "\n",
    "    def forward(self, context, target):\n",
    "        # Encode context and target\n",
    "        context_features = self.context_encoder(context)\n",
    "        with torch.no_grad():\n",
    "            target_features = self.target_encoder(target)\n",
    "        \n",
    "        # Predict target features from context\n",
    "        predicted_features = self.predictor(context_features)\n",
    "        \n",
    "        return predicted_features, target_features\n",
    "\n",
    "    def predict_target_features(self, features):\n",
    "        # Decode features to image patches\n",
    "        patches = self.decoder(features)\n",
    "        \n",
    "        b, n, _ = patches.shape\n",
    "        patches = patches.view(b, n, self.in_channels, self.patch_size, self.patch_size)\n",
    "        patches = patches.permute(0, 2, 1, 3, 4)\n",
    "        \n",
    "        # predict image from patches\n",
    "        images = patches.contiguous().view(b, self.in_channels, self.image_size, self.image_size)\n",
    "        return images\n",
    "\n",
    "def generate_masks(image, patch_size, mask_size_ratio=0.6, border_width=1):\n",
    "    \"\"\"Randomly generate square-shaped masks for context and target\"\"\"\n",
    "    b, c, h, w = image.shape\n",
    "    num_patches = h // patch_size\n",
    "    mask_size = max(1, int(num_patches * mask_size_ratio))\n",
    "    \n",
    "    patches = image.view(b, c, num_patches, patch_size, num_patches, patch_size)\n",
    "    patch_means = patches.mean(dim=(1, 3, 5))\n",
    "    \n",
    "    masks = []\n",
    "    for i in range(b):\n",
    "        # Find the patch with maximum intensity\n",
    "        max_patch = torch.argmax(patch_means[i].view(-1))\n",
    "        max_y, max_x = max_patch // num_patches, max_patch % num_patches\n",
    "        \n",
    "        # Center the mask around the maximum intensity patch\n",
    "        start_y = max(0, min(num_patches - mask_size, max_y - mask_size // 2))\n",
    "        start_x = max(0, min(num_patches - mask_size, max_x - mask_size // 2))\n",
    "        \n",
    "        mask = torch.zeros(h, w, dtype=torch.float, device=image.device)\n",
    "        \n",
    "        # Square-shaped mask\n",
    "        mask[start_y*patch_size:(start_y+mask_size)*patch_size, \n",
    "             start_x*patch_size:(start_x+mask_size)*patch_size] = 1\n",
    "        \n",
    "        # Add blue border\n",
    "        mask[start_y*patch_size:(start_y+mask_size)*patch_size, \n",
    "             start_x*patch_size:start_x*patch_size+border_width] = 2  # Left border\n",
    "        mask[start_y*patch_size:(start_y+mask_size)*patch_size, \n",
    "             (start_x+mask_size)*patch_size-border_width:(start_x+mask_size)*patch_size] = 2  # Right border\n",
    "        mask[start_y*patch_size:start_y*patch_size+border_width, \n",
    "             start_x*patch_size:(start_x+mask_size)*patch_size] = 2  # Top border\n",
    "        mask[(start_y+mask_size)*patch_size-border_width:(start_y+mask_size)*patch_size, \n",
    "             start_x*patch_size:(start_x+mask_size)*patch_size] = 2  # Bottom border\n",
    "        \n",
    "        masks.append(mask)\n",
    "    \n",
    "    return torch.stack(masks).unsqueeze(1)\n",
    "\n",
    "def train(model, dataloader, optimizer, device, num_epochs):\n",
    "    \"\"\"Train and live preview logic\"\"\"\n",
    "    model.train()\n",
    "    criterion_features = nn.MSELoss(reduction='sum')\n",
    "    criterion_reconstruction = nn.MSELoss(reduction='sum')\n",
    "    scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=5, verbose=True)\n",
    "    \n",
    "    losses, feature_losses, reconstruction_losses, times, learning_rates = [], [], [], [], []\n",
    "    start_time = time.time()\n",
    "    \n",
    "    total_batches = len(dataloader) * num_epochs\n",
    "    \n",
    "    progress_bar = tqdm(total=total_batches, desc=\"Training\", unit=\"batch\")\n",
    "    out = widgets.Output()\n",
    "    display(out)\n",
    "    \n",
    "    fig, axs = plt.subplots(1, 4, figsize=(20, 5))\n",
    "    plt.close(fig)\n",
    "    \n",
    "    for epoch in range(num_epochs):\n",
    "        epoch_loss = epoch_feature_loss = epoch_reconstruction_loss = 0\n",
    "        for batch_idx, (data, _) in enumerate(dataloader):\n",
    "            data = data.to(device)\n",
    "            \n",
    "            # Generate masks for this batch\n",
    "            mask = generate_masks(data, model.patch_size)\n",
    "            \n",
    "            context_mask = (mask == 0).float()\n",
    "            target_mask = (mask == 1).float()\n",
    "            border_mask = (mask > 1).float()\n",
    "            \n",
    "            # Create context and target\n",
    "            context = data * context_mask + 0.8 * target_mask + torch.tensor([0.0, 0.0, 1.0]).view(1, 3, 1, 1).to(device) * border_mask\n",
    "            target = data * target_mask + 0.8 * context_mask + torch.tensor([0.0, 0.0, 1.0]).view(1, 3, 1, 1).to(device) * border_mask\n",
    "            \n",
    "            optimizer.zero_grad()\n",
    "            \n",
    "            # Forward pass\n",
    "            pred_features, target_features = model(context, target)\n",
    "            \n",
    "            # Prepare masks for loss calculation\n",
    "            target_mask_patches = target_mask.view(target_mask.size(0), target_mask.size(1), -1, model.patch_size, model.patch_size).any(dim=(3, 4)).float()\n",
    "            target_mask_patches = target_mask_patches.view(target_mask_patches.size(0), -1, 1)\n",
    "            \n",
    "            # Calculate losses\n",
    "            pred_features_masked = pred_features * target_mask_patches\n",
    "            target_features_masked = target_features * target_mask_patches\n",
    "            \n",
    "            loss_features = criterion_features(pred_features_masked, target_features_masked) / (target_mask_patches.sum() * pred_features.size(-1) + 1e-6)\n",
    "            \n",
    "            pred_image = model.predict_target_features(pred_features)\n",
    "            loss_reconstruction = criterion_reconstruction(pred_image * target_mask, data * target_mask) / (target_mask.sum() + 1e-6)\n",
    "            \n",
    "            loss = loss_features + 0.1 * loss_reconstruction\n",
    "            \n",
    "            # Backward pass and optimization\n",
    "            loss.backward()\n",
    "            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n",
    "            optimizer.step()\n",
    "            \n",
    "            # Update running losses\n",
    "            epoch_loss += loss.item()\n",
    "            epoch_feature_loss += loss_features.item()\n",
    "            epoch_reconstruction_loss += loss_reconstruction.item()\n",
    "            \n",
    "            # Update target encoder with momentum\n",
    "            momentum = 0.996 + (1.0 - 0.996) * (epoch / num_epochs)\n",
    "            for param, target_param in zip(model.context_encoder.parameters(), model.target_encoder.parameters()):\n",
    "                target_param.data = momentum * target_param.data + (1 - momentum) * param.data\n",
    "            \n",
    "            progress_bar.update(1)\n",
    "            progress_bar.set_postfix({\"Epoch\": epoch+1, \"Loss\": f\"{loss.item():.4f}\"})\n",
    "            \n",
    "            # Visualize (live preview)\n",
    "            if batch_idx % 2 == 0:\n",
    "                with out:\n",
    "                    out.clear_output(wait=True)\n",
    "                    \n",
    "                    with torch.no_grad():\n",
    "                        combined_image = context * context_mask + pred_image * target_mask + torch.tensor([0.0, 0.0, 1.0]).view(1, 3, 1, 1).to(device) * border_mask\n",
    "                    \n",
    "                    for i, (title, img) in enumerate([('Original', data.repeat(1, 3, 1, 1)), ('Context (Masked)', context), ('Target (Masked)', target), ('Predicted', combined_image)]):\n",
    "                        axs[i].clear()\n",
    "                        axs[i].imshow(img[0].permute(1, 2, 0).detach().cpu(), vmin=0, vmax=1)\n",
    "                        axs[i].set_title(title)\n",
    "                        axs[i].axis('off')\n",
    "                    \n",
    "                    plt.tight_layout()\n",
    "                    display(fig)\n",
    "        \n",
    "        # Compute epoch averages and update lists\n",
    "        avg_loss = epoch_loss / len(dataloader)\n",
    "        avg_feature_loss = epoch_feature_loss / len(dataloader)\n",
    "        avg_reconstruction_loss = epoch_reconstruction_loss / len(dataloader)\n",
    "        losses.append(avg_loss)\n",
    "        feature_losses.append(avg_feature_loss)\n",
    "        reconstruction_losses.append(avg_reconstruction_loss)\n",
    "        times.append(time.time() - start_time)\n",
    "        learning_rates.append(optimizer.param_groups[0]['lr'])\n",
    "        \n",
    "        scheduler.step(avg_loss)\n",
    "        \n",
    "        progress_bar.set_postfix({\"Epoch\": epoch+1, \"Avg Loss\": f\"{avg_loss:.4f}\"})\n",
    "    \n",
    "    progress_bar.close()\n",
    "    return losses, feature_losses, reconstruction_losses, times, learning_rates\n",
    "\n",
    "# Main\n",
    "if __name__ == \"__main__\":\n",
    "    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "    \n",
    "    # Transform data to tensors\n",
    "    transform = transforms.Compose([\n",
    "        transforms.ToTensor(),\n",
    "    ])\n",
    "    \n",
    "    # Load MNIST dataset\n",
    "    mnist_train = datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n",
    "    train_loader = DataLoader(mnist_train, batch_size=64, shuffle=True)\n",
    "\n",
    "    # Initialize model\n",
    "    model = IJEPA(image_size=28, patch_size=4, dim=256, context_depth=6, predictor_depth=6, heads=8, mlp_dim=512, in_channels=3).to(device)\n",
    "\n",
    "    # Set up optimizer\n",
    "    optimizer = optim.AdamW(\n",
    "        list(model.context_encoder.parameters()) + \n",
    "        list(model.predictor.parameters()) + \n",
    "        list(model.decoder.parameters()), \n",
    "        lr=1e-3, \n",
    "        weight_decay=1e-4\n",
    "    )\n",
    "    \n",
    "    num_epochs = 2\n",
    "    losses, feature_losses, reconstruction_losses, times, learning_rates = train(model, train_loader, optimizer, device, num_epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plots(losses, feature_losses, reconstruction_losses):\n",
    "    \"\"\"\n",
    "    Plot training metrics: Loss vs Epoch and Loss Ratio vs Epoch\n",
    "    \n",
    "    Args:\n",
    "    losses (list): Total losses for each epoch\n",
    "    feature_losses (list): Feature losses for each epoch\n",
    "    reconstruction_losses (list): Reconstruction losses for each epoch\n",
    "    \"\"\"\n",
    "    fig, axs = plt.subplots(1, 2, figsize=(20, 7))\n",
    "    \n",
    "    # Loss vs Epoch\n",
    "    axs[0].plot(range(1, len(losses) + 1), losses, label='Total Loss')\n",
    "    axs[0].plot(range(1, len(feature_losses) + 1), feature_losses, label='Feature Loss')\n",
    "    axs[0].plot(range(1, len(reconstruction_losses) + 1), reconstruction_losses, label='Prediction Loss')\n",
    "    axs[0].set_xlabel('Epoch')\n",
    "    axs[0].set_ylabel('Loss')\n",
    "    axs[0].set_title('Loss vs Epoch')\n",
    "    axs[0].legend()\n",
    "    \n",
    "    # Loss Ratio vs Epoch\n",
    "    loss_ratios = [r / f for r, f in zip(reconstruction_losses, feature_losses)]\n",
    "    axs[1].plot(range(1, len(loss_ratios) + 1), loss_ratios)\n",
    "    axs[1].set_xlabel('Epoch')\n",
    "    axs[1].set_ylabel('Prediction Loss / Feature Loss')\n",
    "    axs[1].set_title('Loss Ratio vs Epoch')\n",
    "    \n",
    "    plt.tight_layout()  # Corrected spelling here\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x700 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plots(losses, feature_losses, reconstruction_losses)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}