AMLCode_Tasks.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "machine_shape": "hm",
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import torch\n",
        "from torchvision import datasets, transforms\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "def permute_dataset(dataset, permutation):\n",
        "    permuted_data = dataset.data.view(-1, 28*28)[:, permutation]\n",
        "    permuted_data = permuted_data.view(-1, 28, 28)\n",
        "    dataset.data = permuted_data\n",
        "    return dataset\n",
        "\n",
        "transform = transforms.Compose([transforms.ToTensor()])\n",
        "mnist_train = datasets.MNIST(root='.', train=True, download=True, transform=transform)\n",
        "mnist_test = datasets.MNIST(root='.', train=False, download=True, transform=transform)\n",
        "\n",
        "num_tasks = 5\n",
        "input_size = 28 * 28\n",
        "permutations = [np.random.permutation(input_size) for _ in range(num_tasks)]\n",
        "\n",
        "permuted_datasets_train = []\n",
        "permuted_datasets_test = []\n",
        "\n",
        "for permutation in permutations:\n",
        "    permuted_train = permute_dataset(datasets.MNIST(root='.', train=True, download=True, transform=transform), permutation)\n",
        "    permuted_test = permute_dataset(datasets.MNIST(root='.', train=False, download=True, transform=transform), permutation)\n",
        "    permuted_datasets_train.append(permuted_train)\n",
        "    permuted_datasets_test.append(permuted_test)\n",
        "\n",
        "first_task_train_loader = DataLoader(permuted_datasets_train[0], batch_size=64, shuffle=True)\n",
        "\n",
        "for images, labels in first_task_train_loader:\n",
        "    print(images.shape, labels.shape)\n",
        "    break\n",
        "\n",
        "class BaselineCNN(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(BaselineCNN, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(1, 32, kernel_size=5, stride=1, padding=2)\n",
        "        self.conv2 = nn.Conv2d(32, 64, kernel_size=5, stride=1, padding=2)\n",
        "        self.fc1 = nn.Linear(64 * 7 * 7, 1024)\n",
        "        self.fc2 = nn.Linear(1024, 10)\n",
        "        self.relu = nn.ReLU()\n",
        "        self.pool = nn.MaxPool2d(2, 2)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.pool(self.relu(self.conv1(x)))\n",
        "        x = self.pool(self.relu(self.conv2(x)))\n",
        "        x = x.view(-1, 64 * 7 * 7)\n",
        "        x = self.relu(self.fc1(x))\n",
        "        x = self.fc2(x)\n",
        "        return x\n",
        "\n",
        "def train(model, train_loader, criterion, optimizer):\n",
        "    model.train()\n",
        "    for images, labels in train_loader:\n",
        "        images, labels = images.to(device), labels.to(device)\n",
        "        optimizer.zero_grad()\n",
        "        outputs = model(images)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "def evaluate(model, test_loader, criterion):\n",
        "    model.eval()\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    with torch.no_grad():\n",
        "        for images, labels in test_loader:\n",
        "            images, labels = images.to(device), labels.to(device)\n",
        "            outputs = model(images)\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "    return 100.0 * (total - correct) / total\n",
        "\n",
        "def flatness_penalty(model, dataloader, alpha=0.01, num_samples=10):\n",
        "    original_loss = 0\n",
        "    perturbed_losses = []\n",
        "\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    model.eval()\n",
        "\n",
        "    with torch.no_grad():\n",
        "        for images, labels in dataloader:\n",
        "            images, labels = images.to(device), labels.to(device)\n",
        "            outputs = model(images)\n",
        "            loss = criterion(outputs, labels)\n",
        "            original_loss += loss.item()\n",
        "    original_loss /= len(dataloader)\n",
        "\n",
        "    # Perturb weights and compute perturbed losses\n",
        "    for _ in range(num_samples):\n",
        "        perturbed_loss = 0\n",
        "        perturbed_model = BaselineCNN().to(device)\n",
        "        perturbed_model.load_state_dict(model.state_dict())\n",
        "\n",
        "        for param in perturbed_model.parameters():\n",
        "            perturbation = torch.normal(0, alpha, size=param.shape).to(device)\n",
        "            param.data += perturbation\n",
        "\n",
        "        with torch.no_grad():\n",
        "            for images, labels in dataloader:\n",
        "                images, labels = images.to(device), labels.to(device)\n",
        "                outputs = perturbed_model(images)\n",
        "                loss = criterion(outputs, labels)\n",
        "                perturbed_loss += loss.item()\n",
        "        perturbed_loss /= len(dataloader)\n",
        "        perturbed_losses.append(perturbed_loss)\n",
        "\n",
        "    # Average of all perturbed losses\n",
        "    average_perturbed_loss = np.mean(perturbed_losses)\n",
        "\n",
        "    # Flatness penalty\n",
        "    return (average_perturbed_loss - original_loss) / len(list(model.parameters()))\n",
        "# Elastic Weight Consolidation (EWC) class\n",
        "class EWC(object):\n",
        "    def __init__(self, model, dataloader):\n",
        "        self.model = model\n",
        "        self.dataloader = dataloader\n",
        "        self.device = next(model.parameters()).device\n",
        "        self.params = {n: p for n, p in self.model.named_parameters() if p.requires_grad}\n",
        "        self._precision_matrices = self._diag_fisher()\n",
        "        self._means = {n: p.clone().detach() for n, p in self.params.items()}\n",
        "\n",
        "    def _diag_fisher(self):\n",
        "        precision_matrices = {n: torch.zeros_like(p, device=self.device) for n, p in self.params.items()}\n",
        "        self.model.eval()\n",
        "        for input, target in self.dataloader:\n",
        "            input, target = input.to(self.device), target.to(self.device)\n",
        "            self.model.zero_grad()\n",
        "            output = self.model(input)\n",
        "            loss = nn.functional.nll_loss(nn.functional.log_softmax(output, dim=1), target)\n",
        "            loss.backward()\n",
        "            for n, p in self.params.items():\n",
        "                precision_matrices[n].data += p.grad.data ** 2 / len(self.dataloader)\n",
        "        return precision_matrices\n",
        "\n",
        "    def penalty(self, model):\n",
        "        loss = 0\n",
        "        for n, p in model.named_parameters():\n",
        "            if p.requires_grad:\n",
        "                _loss = self._precision_matrices[n] * (p - self._means[n]) ** 2\n",
        "                loss += lambda_flat*flatness_penalty(model, self.dataloader)\n",
        "                loss += _loss.sum()\n",
        "        return loss\n",
        "\n",
        "# Adaptive EWC Optimizer class\n",
        "class AdaptiveEWCOptimizer:\n",
        "    def __init__(self, ewc, lambda_min=1000, lambda_max=5000, alpha=1.1, beta=0.9):\n",
        "        self.ewc = ewc\n",
        "        self.lambda_min = lambda_min\n",
        "        self.lambda_max = lambda_max\n",
        "        self.alpha = alpha\n",
        "        self.beta = beta\n",
        "        self.ewc_lambda = lambda_min\n",
        "\n",
        "    def adjust_lambda(self, model):\n",
        "        grad_magnitudes = []\n",
        "        for n, p in model.named_parameters():\n",
        "            if p.grad is not None and p.requires_grad:\n",
        "                grad_magnitudes.append(torch.norm(p.grad.data).item())\n",
        "        avg_grad = np.mean(grad_magnitudes)\n",
        "\n",
        "        if avg_grad > 1:\n",
        "            self.ewc_lambda = min(self.ewc_lambda * self.alpha, self.lambda_max)\n",
        "        else:\n",
        "            self.ewc_lambda = max(self.ewc_lambda * self.beta, self.lambda_min)\n",
        "\n",
        "    def penalty(self, model):\n",
        "        return self.ewc_lambda * self.ewc.penalty(model)\n",
        "\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "baseline_errors = []\n",
        "\n",
        "for task in range(num_tasks):\n",
        "    train_loader = DataLoader(permuted_datasets_train[task], batch_size=64, shuffle=True)\n",
        "    test_loader = DataLoader(permuted_datasets_test[task], batch_size=64, shuffle=False)\n",
        "\n",
        "    # Re-initialize the model and optimizer for each task\n",
        "    model = BaselineCNN().to(device)\n",
        "    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)\n",
        "\n",
        "    # Train for a fixed number of epochs\n",
        "    num_epochs = 50\n",
        "    for epoch in range(num_epochs):\n",
        "        train(model, train_loader, nn.CrossEntropyLoss(), optimizer)\n",
        "\n",
        "    # Evaluate the model on all tasks seen so far\n",
        "    total_error = 0\n",
        "    for eval_task in range(task + 1):\n",
        "        test_loader = DataLoader(permuted_datasets_test[eval_task], batch_size=64, shuffle=False)\n",
        "        total_error += evaluate(model, test_loader, nn.CrossEntropyLoss())\n",
        "\n",
        "    baseline_errors.append(total_error / (task + 1))\n",
        "\n",
        "plt.plot(range(1, num_tasks + 1), baseline_errors, marker='o', label='Baseline CNN', color='blue')\n",
        "\n",
        "lambda_ewc = 50  # Adjust this value as needed\n",
        "lambda_flat = 0.01\n",
        "\n",
        "ewc_errors = []\n",
        "\n",
        "model = BaselineCNN().to(device)\n",
        "optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "\n",
        "ewc = None\n",
        "for task in range(num_tasks):\n",
        "    train_loader = DataLoader(permuted_datasets_train[task], batch_size=64, shuffle=True)\n",
        "    test_loader = DataLoader(permuted_datasets_test[task], batch_size=64, shuffle=False)\n",
        "\n",
        "    if task > 0:\n",
        "        ewc = EWC(model, train_loader)\n",
        "\n",
        "    num_epochs = 5\n",
        "    for epoch in range(num_epochs):\n",
        "        model.train()\n",
        "        for images, labels in train_loader:\n",
        "            images, labels = images.to(device), labels.to(device)\n",
        "            optimizer.zero_grad()\n",
        "            outputs = model(images)\n",
        "            loss = criterion(outputs, labels)\n",
        "            if ewc is not None:\n",
        "                loss += lambda_ewc * ewc.penalty(model)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "    total_error = 0\n",
        "    for eval_task in range(task + 1):\n",
        "        test_loader = DataLoader(permuted_datasets_test[eval_task], batch_size=64, shuffle=False)\n",
        "        total_error += evaluate(model, test_loader, criterion)\n",
        "\n",
        "    ewc_errors.append(total_error / (task + 1))\n",
        "\n",
        "plt.plot(range(1, num_tasks + 1), ewc_errors, marker='o', label='EWC', color='orange')\n",
        "\n",
        "adaptive_ewc_errors = []\n",
        "\n",
        "model = BaselineCNN().to(device)\n",
        "optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "\n",
        "ewc = None\n",
        "adaptive_ewc_optimizer = None\n",
        "for task in range(num_tasks):\n",
        "    train_loader = DataLoader(permuted_datasets_train[task], batch_size=64, shuffle=True)\n",
        "    test_loader = DataLoader(permuted_datasets_test[task], batch_size=64, shuffle=False)\n",
        "\n",
        "    if task > 0:\n",
        "        ewc = EWC(model, train_loader)\n",
        "        adaptive_ewc_optimizer = AdaptiveEWCOptimizer(ewc, lambda_min=0, lambda_max=10, alpha=1.1, beta=0.9)\n",
        "\n",
        "    num_epochs = 5\n",
        "    for epoch in range(num_epochs):\n",
        "        model.train()\n",
        "        for images, labels in train_loader:\n",
        "            images, labels = images.to(device), labels.to(device)\n",
        "            optimizer.zero_grad()\n",
        "            outputs = model(images)\n",
        "            loss = criterion(outputs, labels)\n",
        "            if adaptive_ewc_optimizer is not None:\n",
        "                loss += adaptive_ewc_optimizer.penalty(model)\n",
        "                adaptive_ewc_optimizer.adjust_lambda(model)\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "    total_error = 0\n",
        "    for eval_task in range(task + 1):\n",
        "        test_loader = DataLoader(permuted_datasets_test[eval_task], batch_size=64, shuffle=False)\n",
        "        total_error += evaluate(model, test_loader, criterion)\n",
        "\n",
        "    adaptive_ewc_errors.append(total_error / (task + 1))\n",
        "\n",
        "plt.plot(range(1, num_tasks + 1), adaptive_ewc_errors, marker='o', label='Adaptive EWC', color='green')\n",
        "\n",
        "plt.xlabel('Number of Tasks')\n",
        "plt.ylabel('Average Error (%)')\n",
        "plt.title('Average Error vs. Number of Tasks (Baseline CNN, EWC & Adaptive EWC on Permuted MNIST)')\n",
        "plt.legend()\n",
        "plt.grid(True)\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 579
        },
        "id": "8buwrCZC23LI",
        "outputId": "f57b8f69-b1ce-4f39-f9d8-88f289dfbc8e"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([64, 1, 28, 28]) torch.Size([64])\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/numpy/core/fromnumeric.py:3504: RuntimeWarning: Mean of empty slice.\n",
            "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
            "/usr/local/lib/python3.10/dist-packages/numpy/core/_methods.py:129: RuntimeWarning: invalid value encountered in scalar divide\n",
            "  ret = ret.dtype.type(ret / rcount)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}