TANGOS_quickstart.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "[![open in colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/alanjeffares/TANGOS/blob/main/TANGOS_quickstart.ipynb)"
      ],
      "metadata": {
        "id": "8mgNk6CZwB2r"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# TANGOS quickstart guide\n",
        "This script provides a simple example of applying TANGOS as a drop in regularizer in a standard pytorch workflow. We begin by defining a dataloader and a simple MLP architecture before providing a straightforward function for calculating the two TANGOS loss terms - specialization loss and orthogonalization loss. We then provide an example of this loss being applied to train a model in a standard training loop."
      ],
      "metadata": {
        "id": "zorOJBNUG7Cr"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "2FGTU5LWGYXR"
      },
      "outputs": [],
      "source": [
        "# !pip install functorch\n",
        "from functorch import jacrev\n",
        "from functorch import vmap\n",
        "import pandas as pd\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from torch.utils.data import DataLoader, TensorDataset\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torch import optim\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from typing import Callable"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# download a dataset from the UCI repository\n",
        "!wget https://archive.ics.uci.edu/ml/machine-learning-databases/00510/Grisoni_et_al_2016_EnvInt88.csv"
      ],
      "metadata": {
        "id": "uJ3SBBJmGkPX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ZM3mM_rxGw7E"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## First define a simple data loader "
      ],
      "metadata": {
        "id": "1MJLYMjnGyFK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# a data loader for the data\n",
        "def load_bioconcentration(seed, train_prop=0.8, batch_size=64):\n",
        "    \"\"\"Returns dataloaders for the bioconcentration dataset\"\"\"\n",
        "    data = pd.read_csv('Grisoni_et_al_2016_EnvInt88.csv', sep=',')\n",
        "\n",
        "    # apply onehotencoding where appropriate\n",
        "    X = data[['nHM', 'piPC09', 'PCD', 'X2Av', 'MLOGP', 'ON1V', 'N-072', 'B02[C-N]', 'F04[C-O]']]\n",
        "    for var in ['nHM', 'N-072', 'B02[C-N]', 'F04[C-O]']:\n",
        "        one_hot = pd.get_dummies(X[var], prefix=var) # onehotencode categorical columns\n",
        "        X = X.drop(var, axis=1)\n",
        "        X = X.join(one_hot)\n",
        "\n",
        "    y = data['logBCF']\n",
        "    X, y = X.to_numpy(), y.to_numpy()\n",
        "\n",
        "    # split data\n",
        "    X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=train_prop, random_state=seed)\n",
        "\n",
        "    # rescale data\n",
        "    X_scaler = StandardScaler()\n",
        "    X_train = X_scaler.fit_transform(X_train)\n",
        "    X_test = X_scaler.transform(X_test)\n",
        "    y_scaler = StandardScaler()\n",
        "    y_train = y_scaler.fit_transform(y_train.reshape(-1,1)).reshape(-1)\n",
        "    y_test = y_scaler.transform(y_test.reshape(-1,1)).reshape(-1)\n",
        "\n",
        "    train_dataset = TensorDataset(torch.Tensor(X_train), torch.Tensor(y_train))\n",
        "    test_dataset = TensorDataset(torch.Tensor(X_test), torch.Tensor(y_test))\n",
        "\n",
        "    loaders = {\n",
        "        'train': DataLoader(train_dataset,\n",
        "                           batch_size=batch_size,\n",
        "                           shuffle=True,\n",
        "                           num_workers=1),\n",
        "\n",
        "        'test': DataLoader(test_dataset,\n",
        "                           batch_size=batch_size,\n",
        "                           shuffle=False,\n",
        "                           num_workers=1)\n",
        "    }\n",
        "    return loaders\n",
        "     \n"
      ],
      "metadata": {
        "id": "ACmrnDmbGxUN"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Next design a simple MLP architecture"
      ],
      "metadata": {
        "id": "b5nbQ-5ZdV7y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class SimpleMLP(nn.Module):\n",
        "    def __init__(self, num_features):\n",
        "        super(SimpleMLP, self).__init__()\n",
        "        d = num_features + 1\n",
        "        num_outputs = 1\n",
        "        self.fc1 = nn.Linear(num_features, d)\n",
        "        self.bn1 = nn.BatchNorm1d(d)\n",
        "        self.relu1 = nn.ReLU(inplace=False)\n",
        "        self.fc2 = nn.Linear(d, d)\n",
        "        self.bn2 = nn.BatchNorm1d(d)\n",
        "        self.relu2 = nn.ReLU(inplace=False)\n",
        "        self.fc3 = nn.Linear(d, num_outputs)\n",
        "\n",
        "    def forward(self, x):\n",
        "        out = self.fc1(x)\n",
        "        out = self.relu1(out)\n",
        "        out = self.fc2(out)\n",
        "        h_output = self.relu2(out)\n",
        "        out = self.fc3(h_output)\n",
        "        return out, h_output  # note that we ensure the model outputs both predictions and a latent representation"
      ],
      "metadata": {
        "id": "aFjcO1xHHhvM"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Finally, we define a drop in function that calculates the TANGOS loss - outputting both the specialization and the orthogonalization components."
      ],
      "metadata": {
        "id": "S29uMPHFdkLR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def TANGOS_loss(forward_func: Callable, data_input: torch.tensor, \n",
        "                subsample: int = 50, device: str ='cpu'):\n",
        "    \"\"\"\n",
        "    A drop in function for calculating the TANGOS regularization loss. The loss\n",
        "    consists of two components (specialization and orthogonalization) which are\n",
        "    described in more detail in the main paper.\n",
        "\n",
        "    Args:\n",
        "        forward_func (Callable): The forward function from a pytorch model with \n",
        "            an output tuple consisting of (_, latent_representation).\n",
        "        data_input (torch.tensor): A batch of data.\n",
        "        subsample (int): Number of pairs to subsample for the orthogonalization\n",
        "            component.\n",
        "        device (str): Indicating what device to run on.\n",
        "\n",
        "    Returns:\n",
        "        tuple containing the specialization loss and the orthogonalization loss\n",
        "            both in torch tensor format.\n",
        "    \"\"\"\n",
        "\n",
        "    batch_size = data_input.shape[0]\n",
        "    def wrapper(input_):\n",
        "        \"\"\"A simple wrapper required by functools\"\"\"\n",
        "        _, h_out = forward_func(input_)\n",
        "        return h_out\n",
        "    data_input = data_input.clone().requires_grad_(True)\n",
        "    jacobian = vmap(jacrev(wrapper))(data_input)\n",
        "    neuron_attr = jacobian.swapaxes(0,1)\n",
        "    h_dim = neuron_attr.shape[0]\n",
        "    \n",
        "    if len(neuron_attr.shape) > 3:\n",
        "        # h_dim x batch_size x features\n",
        "        neuron_attr = neuron_attr.flatten(start_dim=2)\n",
        "\n",
        "    # calculate specialization loss component\n",
        "    spec_loss = torch.norm(neuron_attr, p=1)/(batch_size*h_dim*neuron_attr.shape[2])\n",
        "\n",
        "    cos = nn.CosineSimilarity(dim=1, eps=1e-6)    \n",
        "    orth_loss = torch.tensor(0., requires_grad=True).to(device)\n",
        "    \n",
        "    # apply subsampling routine for orthogonalization loss\n",
        "    if subsample > 0 and subsample < h_dim*(h_dim-1)/2:\n",
        "        tensor_pairs = [list(np.random.choice(h_dim, size=(2), replace=False)) for i in range(subsample)]\n",
        "        for tensor_pair in tensor_pairs:\n",
        "            pairwise_corr = cos(neuron_attr[tensor_pair[0], :, :], \n",
        "                                neuron_attr[tensor_pair[1], :, :]).norm(p=1)\n",
        "            orth_loss = orth_loss + pairwise_corr\n",
        "\n",
        "        orth_loss = orth_loss/(batch_size*subsample)\n",
        "\n",
        "    else:\n",
        "        for neuron_i in range(1, h_dim):\n",
        "            for neuron_j in range(0, neuron_i):\n",
        "                pairwise_corr = cos(neuron_attr[neuron_i, :, :],\n",
        "                                    neuron_attr[neuron_j, :, :]).norm(p=1)\n",
        "                orth_loss = orth_loss + pairwise_corr\n",
        "        num_pairs = h_dim*(h_dim-1)/2\n",
        "        orth_loss = orth_loss/(batch_size*num_pairs)\n",
        "\n",
        "    return spec_loss, orth_loss\n"
      ],
      "metadata": {
        "id": "8FEPP5KKH9bt"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "S5Yr13ebH3p-"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Train a model with TANGOS regularization and another with L2 regularization. "
      ],
      "metadata": {
        "id": "Rr1EkGx4okOr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# set seed for reproducablility\n",
        "torch.manual_seed(0)\n",
        "torch.cuda.manual_seed(0)\n",
        "np.random.seed(0)\n",
        "\n",
        "loss_func = nn.MSELoss()\n",
        "data = load_bioconcentration(0)\n",
        "train_loader = data['train']\n",
        "val_loader = data['test']\n",
        "\n",
        "lambda_1, lambda_2 = 100, 0.1\n",
        "lr = 0.001\n",
        "device = 'cuda'\n",
        "n_epochs = 100\n",
        "\n",
        "# instantiate models and optimimizers \n",
        "TANGOS_model = SimpleMLP(num_features=45).to(device)\n",
        "L2_model = SimpleMLP(num_features=45).to(device)\n",
        "TANGOS_optimiser = optim.Adam(TANGOS_model.parameters(), lr=lr, weight_decay=0)\n",
        "L2_optimiser = optim.Adam(L2_model.parameters(), lr=lr, weight_decay=0.1)\n",
        "\n",
        "TANGOS_train_loss_ls = []; L2_train_loss_ls = []\n",
        "TANGOS_val_loss_ls = []; L2_val_loss_ls = []\n",
        "\n",
        "for epoch in range(n_epochs):\n",
        "  TANGOS_running_loss = 0; L2_running_loss = 0\n",
        "  # training epoch\n",
        "  for data, label in train_loader:\n",
        "      TANGOS_model.train(); L2_model.train()\n",
        "      data, label = data.to(device), label.to(device)\n",
        "      TANGOS_optimiser.zero_grad(); L2_optimiser.zero_grad()\n",
        "\n",
        "      # forward and backward pass for TANGOS model\n",
        "      TANGOS_output, _ = TANGOS_model(data)\n",
        "      MSE_loss = loss_func(TANGOS_output.squeeze(), label)\n",
        "\n",
        "      spec_loss, orth_loss = TANGOS_loss(TANGOS_model, data, subsample=50,\n",
        "                                         device=device)  # calculate TANGOS loss\n",
        "      TANGOS_reg_loss = lambda_1 * spec_loss + lambda_2 * orth_loss  # weight the two terms\n",
        "      TANGOS_loss_val = MSE_loss + TANGOS_reg_loss  # add TANGOS loss to MSE loss\n",
        "\n",
        "      TANGOS_running_loss += MSE_loss.item()\n",
        "      TANGOS_loss_val.backward()\n",
        "      TANGOS_optimiser.step()\n",
        "\n",
        "      # forward and backward pass for L2 model\n",
        "      L2_output, _ = L2_model(data)\n",
        "      MSE_loss = loss_func(L2_output.squeeze(), label)\n",
        "\n",
        "      L2_running_loss += MSE_loss.item()\n",
        "      MSE_loss.backward()\n",
        "      L2_optimiser.step()\n",
        "\n",
        "  TANGOS_train_loss_ls.append(TANGOS_running_loss)\n",
        "  L2_train_loss_ls.append(L2_running_loss)\n",
        "\n",
        "  TANGOS_running_val_loss = 0; L2_running_val_loss = 0\n",
        "  # validation epoch\n",
        "  for data, label in val_loader:\n",
        "      TANGOS_model.eval(); L2_model.eval()\n",
        "      data, label = data.to(device), label.to(device)\n",
        "\n",
        "      # evaluate TANGOS model\n",
        "      TANGOS_output, _ = TANGOS_model(data)\n",
        "      TANGOS_reg_loss = loss_func(TANGOS_output.squeeze(), label)\n",
        "      TANGOS_running_val_loss += TANGOS_reg_loss.item()\n",
        "\n",
        "      # evaluate l2 model\n",
        "      L2_output, _ = L2_model(data)\n",
        "      L2_loss = loss_func(L2_output.squeeze(), label)\n",
        "      L2_running_val_loss += L2_loss.item()\n",
        "\n",
        "  TANGOS_val_loss_ls.append(TANGOS_running_val_loss)\n",
        "  L2_val_loss_ls.append(L2_running_val_loss)"
      ],
      "metadata": {
        "id": "P-Ky9Km1H3sQ"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "tZM6XeeHK4f-"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Plot the training and validation loss plots"
      ],
      "metadata": {
        "id": "Yu_PgrtZow1w"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(15,4))\n",
        "\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.title('Train Loss')\n",
        "plt.plot(TANGOS_train_loss_ls, label='TANGOS')\n",
        "plt.plot(L2_train_loss_ls, label='L2')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.ylim(1.5,6)\n",
        "plt.legend()\n",
        "\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.title('Val Loss')\n",
        "plt.plot(TANGOS_val_loss_ls, label='TANGOS')\n",
        "plt.plot(L2_val_loss_ls, label='L2')\n",
        "plt.legend()\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.ylim(.6,1.8)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "PubGcagQJj5_",
        "outputId": "9e253623-9b5b-4cb9-88f3-759dfe2972a5"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1080x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "gbixC9QHSxF1"
      },
      "execution_count": 7,
      "outputs": []
    }
  ]
}