model_fusion_optimal_transport_parallelization.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformer import TransformerClassifier\n",
    "from dataloader import *\n",
    "import torch\n",
    "import ot\n",
    "from copy import deepcopy\n",
    "from tqdm import tqdm\n",
    "import optuna\n",
    "from torchmetrics.classification import F1Score\n",
    "from sklearn.calibration import CalibrationDisplay\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.gridspec import GridSpec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dataset initializing start\n",
      "Length of data after first step of preprocessing:  35832\n",
      "Tokenizing the data...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\atace\\OneDrive\\Desktop\\ETH\\9.Semester\\Deep Learning\\project\\Exploring-Model-Fusion-with-Optimal-Transport-on-Transformers\\dataloader.py:80: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  data[\"len\"] = data.iloc[:, 0].apply(lambda x : len(self.tokenize(x)))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length of the data :  29544\n",
      "0\n",
      "review       [[CLS], one, of, the, many, silent, comedies, ...\n",
      "sentiment                                                    0\n",
      "len                                                        186\n",
      "Name: 46539, dtype: object\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 23635/23635 [00:01<00:00, 19311.09it/s]\n",
      "100%|██████████| 2954/2954 [00:00<00:00, 17275.07it/s]\n",
      "100%|██████████| 2955/2955 [00:00<00:00, 19694.60it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dataset initializing done\n",
      "Vocabulary Size :  23050\n"
     ]
    }
   ],
   "source": [
    "#init\n",
    "tokenizer = Tokenizer()\n",
    "loader = DataLoader(tokenize = tokenizer.tokenize)\n",
    "\n",
    "# import data (combine train/test as we split afterwards anyways)\n",
    "data = pd.read_csv(\"./Data/IMDB Dataset.csv\", encoding='ISO-8859-1')\n",
    "# convert string label to binary (int) label (spam:1, non-spam:0)\n",
    "data[\"sentiment\"] = data['sentiment'].apply(lambda x : int(x == \"positive\"))\n",
    "\n",
    "# train, test, val split\n",
    "train, valid, test = loader.make_dataset(data)\n",
    "vocab = loader.get_vocab(train.iloc[:, 0])\n",
    "train_iter, valid_iter, test_iter = loader.make_iter(train, valid, test,\n",
    "                                                     batch_size=512,\n",
    "                                                     device=device)\n",
    "\n",
    "# NLP stuff\n",
    "pad_idx = vocab['__PAD__']\n",
    "voc_size = len(vocab)\n",
    "print(\"Vocabulary Size : \", voc_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def validation(model, iterator, criterion, device):\n",
    "    # set model into evaluation mode\n",
    "    model.eval()\n",
    "\n",
    "    # validation\n",
    "    # loss, metrics for current epoch\n",
    "    val_epoch_loss = 0\n",
    "    val_epoch_accuracy = 0\n",
    "\n",
    "    labels_val = []\n",
    "    preds_val = []\n",
    "    f1_scorer = F1Score(task='binary').to(device)\n",
    "\n",
    "    with torch.no_grad(): # stop graph\n",
    "        # batches\n",
    "        for i, batch in enumerate(iterator):\n",
    "            src = batch[0] # X\n",
    "            trg = batch[1] # y\n",
    "            src, trg = torch.tensor(src).to(device), torch.tensor(trg).to(device) # put to cpu/gpu\n",
    "            output = model(src)\n",
    "            y_pred = torch.argmax(output, dim=-1) # logits -> labels\n",
    "            output_reshape = output.contiguous().view(-1, output.shape[-1])\n",
    "            trg = trg.to(torch.int64)\n",
    "\n",
    "            loss = criterion(output_reshape, trg) # calculate loss\n",
    "            agreements = torch.eq(y_pred, trg)\n",
    "            accuracy = torch.mean(agreements.double()) # calculate accuracy\n",
    "\n",
    "            labels_val.append(trg)\n",
    "            preds_val.append(y_pred)\n",
    "\n",
    "            val_epoch_loss += loss.item()\n",
    "            val_epoch_accuracy += accuracy\n",
    "\n",
    "    # put to numpy\n",
    "    labels_val = torch.cat(labels_val)\n",
    "    preds_val = torch.cat(preds_val)\n",
    "    # return mean loss w.r.t. batches\n",
    "    return val_epoch_loss / len(iterator), val_epoch_accuracy / len(iterator), f1_scorer(preds_val, labels_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the embedding matrix\n",
    "embeddingA = torch.load(\"Models/embeddingA_16_trained_parallelization.pt\")\n",
    "embeddingB = torch.load(\"Models/embeddingB_16_trained_parallelization.pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "embeddingA.weight.requires_grad = False\n",
    "embeddingB.weight.requires_grad = False"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load the Model Weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TransformerClassifier(\n",
       "  (encoder): Encoder(\n",
       "    (emb): TransformerEmbedding(\n",
       "      (tok_emb): TokenEmbedding(\n",
       "        (embedding): Embedding(23050, 16)\n",
       "      )\n",
       "      (pos_emb): PositionalEncoding()\n",
       "      (drop_out): Dropout(p=0.5, inplace=False)\n",
       "    )\n",
       "    (layers): ModuleList(\n",
       "      (0): EncoderLayer(\n",
       "        (attention): MultiHeadAttention(\n",
       "          (attention): ScaleDotProductAttention(\n",
       "            (softmax): Softmax(dim=-1)\n",
       "          )\n",
       "          (w_q): Linear(in_features=16, out_features=16, bias=True)\n",
       "          (w_k): Linear(in_features=16, out_features=16, bias=True)\n",
       "          (w_v): Linear(in_features=16, out_features=16, bias=True)\n",
       "          (w_concat): Linear(in_features=16, out_features=16, bias=True)\n",
       "        )\n",
       "        (norm1): LayerNorm()\n",
       "        (dropout1): Dropout(p=0.5, inplace=False)\n",
       "        (ffn): PositionwiseFeedForward(\n",
       "          (linear1): Linear(in_features=16, out_features=32, bias=True)\n",
       "          (linear2): Linear(in_features=32, out_features=16, bias=True)\n",
       "          (relu): ReLU()\n",
       "          (dropout): Dropout(p=0.5, inplace=False)\n",
       "        )\n",
       "        (norm2): LayerNorm()\n",
       "        (dropout2): Dropout(p=0.5, inplace=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (linear): Linear(in_features=4096, out_features=2, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "modelA = TransformerClassifier(src_pad_idx = pad_idx,\n",
    "                              embedding=embeddingA,\n",
    "                              enc_voc_size = voc_size,\n",
    "                              max_len = 256,\n",
    "                              d_model = 16,\n",
    "                              ffn_hidden = 32,\n",
    "                              n_head = 1,\n",
    "                              n_layers = 1,\n",
    "                              drop_prob = 0.5,\n",
    "                              device = device)\n",
    "\n",
    "modelA.load_state_dict(torch.load(\"Models\\modelA_IMDB_256_parallelization\"))\n",
    "modelA.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TransformerClassifier(\n",
       "  (encoder): Encoder(\n",
       "    (emb): TransformerEmbedding(\n",
       "      (tok_emb): TokenEmbedding(\n",
       "        (embedding): Embedding(23050, 16)\n",
       "      )\n",
       "      (pos_emb): PositionalEncoding()\n",
       "      (drop_out): Dropout(p=0.5, inplace=False)\n",
       "    )\n",
       "    (layers): ModuleList(\n",
       "      (0): EncoderLayer(\n",
       "        (attention): MultiHeadAttention(\n",
       "          (attention): ScaleDotProductAttention(\n",
       "            (softmax): Softmax(dim=-1)\n",
       "          )\n",
       "          (w_q): Linear(in_features=16, out_features=16, bias=True)\n",
       "          (w_k): Linear(in_features=16, out_features=16, bias=True)\n",
       "          (w_v): Linear(in_features=16, out_features=16, bias=True)\n",
       "          (w_concat): Linear(in_features=16, out_features=16, bias=True)\n",
       "        )\n",
       "        (norm1): LayerNorm()\n",
       "        (dropout1): Dropout(p=0.5, inplace=False)\n",
       "        (ffn): PositionwiseFeedForward(\n",
       "          (linear1): Linear(in_features=16, out_features=32, bias=True)\n",
       "          (linear2): Linear(in_features=32, out_features=16, bias=True)\n",
       "          (relu): ReLU()\n",
       "          (dropout): Dropout(p=0.5, inplace=False)\n",
       "        )\n",
       "        (norm2): LayerNorm()\n",
       "        (dropout2): Dropout(p=0.5, inplace=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (linear): Linear(in_features=4096, out_features=2, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "modelB = TransformerClassifier(src_pad_idx = pad_idx,\n",
    "                              embedding=embeddingB,\n",
    "                              enc_voc_size = voc_size,\n",
    "                              max_len = 256,\n",
    "                              d_model = 16,\n",
    "                              ffn_hidden = 32,\n",
    "                              n_head = 1,\n",
    "                              n_layers = 1,\n",
    "                              drop_prob = 0.5,\n",
    "                              device = device)\n",
    "\n",
    "modelB.load_state_dict(torch.load(\"Models\\modelB_IMDB_256_parallelization\"))\n",
    "modelB.eval()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OT Functions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getSupport(model, trainloader, l, alignment = \"acts\", numOfBatches= 10):\n",
    "    '''\n",
    "    Get the support matrices using Activation-based (\"acts\") or Weight-based (\"wts\") alignment \n",
    "    '''\n",
    "    if alignment == \"acts\":\n",
    "        activation = None\n",
    "        for i, data in enumerate(trainloader, 0):\n",
    "            if i >= numOfBatches:\n",
    "                break\n",
    "            \n",
    "            inputs, targets = data\n",
    "            outputs = model(inputs)\n",
    "\n",
    "            if activation is None:\n",
    "                activation = model.actMatrix[l]\n",
    "            else:\n",
    "                activation = torch.cat((activation, model.actMatrix[l]))\n",
    "\n",
    "        return activation\n",
    "    elif alignment == \"wts\":\n",
    "        return model.state_dict()[l]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fusion(nameA, nameB, weightA, weightB, transport_matrix, beta):\n",
    "    support_y = getSupport(modelB, train_iter, nameB, alignment=\"wts\")\n",
    "    # Get the weights at layer \"idx\" from the first model\n",
    "    W_A = weightA\n",
    "    W_B = weightB\n",
    "    # Align the weights from the first model\n",
    "    aligned_W = torch.matmul(W_A, torch.matmul(transport_matrix, torch.diag(1 / beta)))\n",
    "    # Get the X-Support\n",
    "    n = W_A.shape[0]\n",
    "    alpha = torch.ones(n) * (1/n)\n",
    "    support_x = getSupport(modelA, train_iter, nameA, alignment=\"wts\")\n",
    "    # Calculate the euclidean distance between the supports\n",
    "    distance = ot.dist(support_x, support_y)\n",
    "    # Calculate beta\n",
    "    m = W_B.shape[0]\n",
    "    beta = torch.ones(m) * (1/m)\n",
    "    # Calculate the transport matrix using optimal transport\n",
    "    transport_matrix = torch.from_numpy(ot.emd(alpha.numpy(), beta.numpy(), distance.detach().numpy())).float().reshape((n, m))\n",
    "    # Align model neurons\n",
    "    aligned_model = torch.matmul(torch.diag(1 / beta), torch.matmul(transport_matrix.T, aligned_W))\n",
    "    # Get the weights at layer \"idx\" from the second model\n",
    "    fused = (aligned_model + W_B) / 2 \n",
    "    return  fused, transport_matrix, beta"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fusion via Optimal Transport"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "fusedModel = TransformerClassifier(src_pad_idx = pad_idx,\n",
    "                              embedding = embeddingB,\n",
    "                              enc_voc_size = voc_size,\n",
    "                              max_len = 256,\n",
    "                              d_model = 16,\n",
    "                              ffn_hidden = 32,\n",
    "                              n_head = 1,\n",
    "                              n_layers = 1,\n",
    "                              drop_prob = 0.2,\n",
    "                              device = device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def obj(trial):\n",
    "    a = trial.suggest_float('a', 0, 1)\n",
    "    \n",
    "    # Create the fused weights matrix\n",
    "    W_fusion = dict.fromkeys(list(modelA.state_dict().keys()))\n",
    "    # Initialize the algorithm\n",
    "    m = list(modelB.state_dict().items())[1][1].shape[1]\n",
    "    beta = torch.ones(m) * (1/m)\n",
    "    transport_matrix = torch.matmul(torch.diag(beta), torch.eye(m))\n",
    "\n",
    "    # Fusion via Optimal Transport\n",
    "    for (nameA, weightA), (nameB, weightB) in zip(modelA.named_parameters(), modelB.named_parameters()):\n",
    "        if nameA == \"encoder.emb.tok_emb.embedding.weight\":\n",
    "            W_fusion[nameA] = weightA\n",
    "        else:\n",
    "            if \"weight\" in nameA:\n",
    "                if \"encoder\" in nameA:\n",
    "                    if \"concat\" not in nameA and \"linear\" not in nameA: \n",
    "                        W_fusion[nameA], transport_matrix_triplet, _ = fusion(nameA, nameB, weightA, weightB, transport_matrix, beta)\n",
    "                    else:\n",
    "                        W_fusion[nameA], transport_matrix, beta = fusion(nameA, nameB, weightA, weightB, transport_matrix, beta)\n",
    "\n",
    "                else:\n",
    "                    W_fusion[nameA] = a * weightA + (1-a) * weightB\n",
    "            elif \"bias\" in nameA:\n",
    "                if \"encoder\" in nameA: \n",
    "                    if \"concat\" not in nameA and \"linear\" not in nameA: \n",
    "                        m = weightB.shape[0]\n",
    "                        beta_bias = torch.ones(m) * (1/m)\n",
    "                        W_A_bias = weightA.reshape(m, 1)\n",
    "                        aligned_bias = torch.matmul(torch.diag(1 / beta_bias), torch.matmul(transport_matrix_triplet.T, W_A_bias))\n",
    "                        aligned_bias = aligned_bias.reshape(m)\n",
    "                        W_fusion[nameA] = (aligned_bias + weightB) / 2\n",
    "                    else:\n",
    "                        m = weightB.shape[0]\n",
    "                        beta_bias = torch.ones(m) * (1/m)\n",
    "                        W_A_bias = weightA.reshape(m, 1)\n",
    "                        aligned_bias = torch.matmul(torch.diag(1 / beta_bias), torch.matmul(transport_matrix.T, W_A_bias))\n",
    "                        aligned_bias = aligned_bias.reshape(m)\n",
    "                        W_fusion[nameA] = (aligned_bias + weightB) / 2\n",
    "                else:\n",
    "                    W_fusion[nameA] = a * weightA + (1-a) * weightB\n",
    "            else:\n",
    "                W_fusion[nameA] = a * weightA + (1-a) * weightB\n",
    "\n",
    "    # Assign the weights\n",
    "    with torch.no_grad():\n",
    "        for name, param in fusedModel.named_parameters():\n",
    "            param.data = torch.nn.Parameter(W_fusion[name])\n",
    "\n",
    "    # Validate the fused model\n",
    "    criterion = torch.nn.CrossEntropyLoss()\n",
    "    val_loss, val_acc, val_f1 = validation(fusedModel, valid_iter, criterion, device)\n",
    "    return val_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32m[I 2023-01-16 14:17:37,776]\u001b[0m A new study created in memory with name: no-name-578baa6f-0fbc-44d5-9ba7-5b5e9ed73226\u001b[0m\n",
      "C:\\Users\\atace\\AppData\\Local\\Temp/ipykernel_22372/896423794.py:19: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  src, trg = torch.tensor(src).to(device), torch.tensor(trg).to(device) # put to cpu/gpu\n",
      "\u001b[32m[I 2023-01-16 14:17:42,314]\u001b[0m Trial 0 finished with value: 0.8116160134474436 and parameters: {'a': 0.026949756371994038}. Best is trial 0 with value: 0.8116160134474436.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:17:46,328]\u001b[0m Trial 1 finished with value: 0.5824048717816671 and parameters: {'a': 0.46875990383240096}. Best is trial 1 with value: 0.5824048717816671.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:17:50,265]\u001b[0m Trial 2 finished with value: 0.6198879977067312 and parameters: {'a': 0.754669883588677}. Best is trial 1 with value: 0.5824048717816671.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:17:54,082]\u001b[0m Trial 3 finished with value: 0.8002831240495046 and parameters: {'a': 0.037826660360429254}. Best is trial 1 with value: 0.5824048717816671.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:17:57,983]\u001b[0m Trial 4 finished with value: 0.5775375068187714 and parameters: {'a': 0.5450347918834243}. Best is trial 4 with value: 0.5775375068187714.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:18:02,246]\u001b[0m Trial 5 finished with value: 0.5812076429526011 and parameters: {'a': 0.6271729763747308}. Best is trial 4 with value: 0.5775375068187714.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:18:06,800]\u001b[0m Trial 6 finished with value: 0.7410715619723002 and parameters: {'a': 0.11122694824455703}. Best is trial 4 with value: 0.5775375068187714.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:18:11,252]\u001b[0m Trial 7 finished with value: 0.5794112583001455 and parameters: {'a': 0.5325426729148589}. Best is trial 4 with value: 0.5775375068187714.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:18:16,229]\u001b[0m Trial 8 finished with value: 0.5813057919343313 and parameters: {'a': 0.6024894067394362}. Best is trial 4 with value: 0.5775375068187714.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:18:22,551]\u001b[0m Trial 9 finished with value: 0.5887546042601267 and parameters: {'a': 0.6543742740127555}. Best is trial 4 with value: 0.5775375068187714.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:18:27,711]\u001b[0m Trial 10 finished with value: 0.767104814449946 and parameters: {'a': 0.9921594070673794}. Best is trial 4 with value: 0.5775375068187714.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:18:32,230]\u001b[0m Trial 11 finished with value: 0.6084452370802561 and parameters: {'a': 0.35941133355268595}. Best is trial 4 with value: 0.5775375068187714.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:18:36,268]\u001b[0m Trial 12 finished with value: 0.6235556403795878 and parameters: {'a': 0.313232396551258}. Best is trial 4 with value: 0.5775375068187714.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:18:40,328]\u001b[0m Trial 13 finished with value: 0.6477718452612559 and parameters: {'a': 0.8205237345756103}. Best is trial 4 with value: 0.5775375068187714.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:18:44,366]\u001b[0m Trial 14 finished with value: 0.6366214056809744 and parameters: {'a': 0.2835207416451596}. Best is trial 4 with value: 0.5775375068187714.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:18:48,450]\u001b[0m Trial 15 finished with value: 0.5864436626434326 and parameters: {'a': 0.4450111368249343}. Best is trial 4 with value: 0.5775375068187714.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:18:52,889]\u001b[0m Trial 16 finished with value: 0.6745879650115967 and parameters: {'a': 0.20259080776923855}. Best is trial 4 with value: 0.5775375068187714.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:18:57,316]\u001b[0m Trial 17 finished with value: 0.5809299151102701 and parameters: {'a': 0.5478973947452678}. Best is trial 4 with value: 0.5775375068187714.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:19:01,861]\u001b[0m Trial 18 finished with value: 0.6197466850280762 and parameters: {'a': 0.7646205940686506}. Best is trial 4 with value: 0.5775375068187714.\u001b[0m\n",
      "\u001b[32m[I 2023-01-16 14:19:06,336]\u001b[0m Trial 19 finished with value: 0.5831421116987864 and parameters: {'a': 0.4484808045266342}. Best is trial 4 with value: 0.5775375068187714.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "study = optuna.create_study()\n",
    "study.optimize(obj, n_trials=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\atace\\AppData\\Local\\Temp/ipykernel_22372/896423794.py:19: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  src, trg = torch.tensor(src).to(device), torch.tensor(trg).to(device) # put to cpu/gpu\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Loss:      0.5773945252100626\n",
      "Validation Accuracy:      0.7738753833544839\n",
      "Validation F1:      0.7738659381866455\n"
     ]
    }
   ],
   "source": [
    "a = study.best_params[\"a\"]\n",
    "\n",
    "# Create the fused weights matrix\n",
    "W_fusion = dict.fromkeys(list(modelA.state_dict().keys()))\n",
    "# Initialize the algorithm\n",
    "m = list(modelB.state_dict().items())[1][1].shape[1]\n",
    "beta = torch.ones(m) * (1/m)\n",
    "transport_matrix = torch.matmul(torch.diag(beta), torch.eye(m))\n",
    "# Fusion via Optimal Transport\n",
    "for (nameA, weightA), (nameB, weightB) in zip(modelA.named_parameters(), modelB.named_parameters()):\n",
    "    if nameA == \"encoder.emb.tok_emb.embedding.weight\":\n",
    "        W_fusion[nameA] = weightA\n",
    "    else:\n",
    "        if \"weight\" in nameA:\n",
    "            if \"encoder\" in nameA:\n",
    "                if \"concat\" not in nameA and \"linear\" not in nameA: \n",
    "                    W_fusion[nameA], transport_matrix_triplet, _ = fusion(nameA, nameB, weightA, weightB, transport_matrix, beta)\n",
    "                else:\n",
    "                    W_fusion[nameA], transport_matrix, beta = fusion(nameA, nameB, weightA, weightB, transport_matrix, beta)\n",
    "            else:\n",
    "                W_fusion[nameA] = a * weightA + (1-a) * weightB\n",
    "        elif \"bias\" in nameA:\n",
    "            if \"encoder\" in nameA: \n",
    "                if \"concat\" not in nameA and \"linear\" not in nameA: \n",
    "                    m = weightB.shape[0]\n",
    "                    beta_bias = torch.ones(m) * (1/m)\n",
    "                    W_A_bias = weightA.reshape(m, 1)\n",
    "                    aligned_bias = torch.matmul(torch.diag(1 / beta_bias), torch.matmul(transport_matrix_triplet.T, W_A_bias))\n",
    "                    aligned_bias = aligned_bias.reshape(m)\n",
    "                    W_fusion[nameA] = (aligned_bias + weightB) / 2\n",
    "                else:\n",
    "                    m = weightB.shape[0]\n",
    "                    beta_bias = torch.ones(m) * (1/m)\n",
    "                    W_A_bias = weightA.reshape(m, 1)\n",
    "                    aligned_bias = torch.matmul(torch.diag(1 / beta_bias), torch.matmul(transport_matrix.T, W_A_bias))\n",
    "                    aligned_bias = aligned_bias.reshape(m)\n",
    "                    W_fusion[nameA] = (aligned_bias + weightB) / 2\n",
    "            else:\n",
    "                W_fusion[nameA] = a * weightA + (1-a) * weightB\n",
    "        else:\n",
    "            W_fusion[nameA] = a * weightA + (1-a) * weightB\n",
    "                \n",
    "# Assign the weights\n",
    "with torch.no_grad():\n",
    "    for name, param in fusedModel.named_parameters():\n",
    "        param.data = torch.nn.Parameter(W_fusion[name])\n",
    "# Validate the fused model\n",
    "criterion = torch.nn.CrossEntropyLoss()\n",
    "val_loss, val_acc, val_f1 = validation(fusedModel, valid_iter, criterion, device)\n",
    "print(\"Validation Loss:     \", val_loss)\n",
    "print(\"Validation Accuracy:     \", val_acc.item())\n",
    "print(\"Validation F1:     \", val_f1.item())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recalibrate the normalization layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/47 [00:00<?, ?it/s]C:\\Users\\atace\\AppData\\Local\\Temp/ipykernel_22372/1843898165.py:14: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  src, trg = torch.tensor(src).to(device), torch.tensor(trg).to(device) # put to cpu/gpu\n",
      "100%|██████████| 47/47 [00:54<00:00,  1.15s/it]\n"
     ]
    }
   ],
   "source": [
    "optimizer = torch.optim.Adam(fusedModel.parameters(), lr=0.01)\n",
    "criterion = torch.nn.CrossEntropyLoss()\n",
    "\n",
    "clip = 1\n",
    "\n",
    "fusedModel.train()\n",
    "for name, param in fusedModel.named_parameters():\n",
    "    if \"weight\" in name or \"bias\" in name:\n",
    "        param.requires_grad = False\n",
    "    \n",
    "for i, batch in enumerate(tqdm(train_iter)):\n",
    "            src = batch[0] # X\n",
    "            trg = batch[1] # y\n",
    "            src, trg = torch.tensor(src).to(device), torch.tensor(trg).to(device) # put to cpu/gpu\n",
    "            optimizer.zero_grad() # reset optimizer\n",
    "            output = fusedModel(src) # predict\n",
    "            y_pred = torch.argmax(output, dim=-1) # logits -> labels\n",
    "            output_reshape = output.contiguous().view(-1, output.shape[-1])\n",
    "            trg = trg.to(torch.int64)\n",
    "            loss = criterion(output_reshape, trg) # calculate loss\n",
    "            agreements = torch.eq(y_pred, trg)\n",
    "            accuracy = torch.mean(agreements.double()) # calculate accuracy\n",
    "            loss.backward() # backward pass\n",
    "\n",
    "            torch.nn.utils.clip_grad_norm_(fusedModel.parameters(), clip)\n",
    "            optimizer.step() # optimize model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\atace\\AppData\\Local\\Temp/ipykernel_22372/896423794.py:19: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  src, trg = torch.tensor(src).to(device), torch.tensor(trg).to(device) # put to cpu/gpu\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Loss:      0.6197755038738251\n",
      "Validation Accuracy:      0.7476387346658205\n",
      "Validation F1:      0.7467840313911438\n"
     ]
    }
   ],
   "source": [
    "# Validate the fused model\n",
    "criterion = torch.nn.CrossEntropyLoss()\n",
    "val_loss, val_acc, val_f1 = validation(fusedModel, valid_iter, criterion, device)\n",
    "print(\"Validation Loss:     \", val_loss)\n",
    "print(\"Validation Accuracy:     \", val_acc.item())\n",
    "print(\"Validation F1:     \", val_f1.item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "for name, param in fusedModel.named_parameters():\n",
    "    param.requires_grad = True"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train the last layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/47 [00:00<?, ?it/s]C:\\Users\\atace\\AppData\\Local\\Temp/ipykernel_22372/2213785333.py:14: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  src, trg = torch.tensor(src).to(device), torch.tensor(trg).to(device) # put to cpu/gpu\n",
      "100%|██████████| 47/47 [00:47<00:00,  1.01s/it]\n"
     ]
    }
   ],
   "source": [
    "optimizer = torch.optim.Adam(fusedModel.parameters(), lr=0.0001)\n",
    "criterion = torch.nn.CrossEntropyLoss()\n",
    "\n",
    "clip = 1\n",
    "\n",
    "fusedModel.train()\n",
    "for name, param in fusedModel.named_parameters():\n",
    "    if \"encoder\" in name:\n",
    "        param.requires_grad = False\n",
    "    \n",
    "for i, batch in enumerate(tqdm(train_iter)):\n",
    "            src = batch[0] # X\n",
    "            trg = batch[1] # y\n",
    "            src, trg = torch.tensor(src).to(device), torch.tensor(trg).to(device) # put to cpu/gpu\n",
    "            optimizer.zero_grad() # reset optimizer\n",
    "            output = fusedModel(src) # predict\n",
    "            y_pred = torch.argmax(output, dim=-1) # logits -> labels\n",
    "            output_reshape = output.contiguous().view(-1, output.shape[-1])\n",
    "            trg = trg.to(torch.int64)\n",
    "            loss = criterion(output_reshape, trg) # calculate loss\n",
    "            agreements = torch.eq(y_pred, trg)\n",
    "            accuracy = torch.mean(agreements.double()) # calculate accuracy\n",
    "            loss.backward() # backward pass\n",
    "\n",
    "            torch.nn.utils.clip_grad_norm_(fusedModel.parameters(), clip)\n",
    "            optimizer.step() # optimize model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\atace\\AppData\\Local\\Temp/ipykernel_22372/896423794.py:19: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  src, trg = torch.tensor(src).to(device), torch.tensor(trg).to(device) # put to cpu/gpu\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Loss:      0.5180663615465164\n",
      "Validation Accuracy:      0.7805791296531304\n",
      "Validation F1:      0.7796208262443542\n"
     ]
    }
   ],
   "source": [
    "# Validate the fused model\n",
    "criterion = torch.nn.CrossEntropyLoss()\n",
    "val_loss, val_acc, val_f1 = validation(fusedModel, valid_iter, criterion, device)\n",
    "print(\"Validation Loss:     \", val_loss)\n",
    "print(\"Validation Accuracy:     \", val_acc.item())\n",
    "print(\"Validation F1:     \", val_f1.item())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\atace\\AppData\\Local\\Temp/ipykernel_22372/896423794.py:19: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  src, trg = torch.tensor(src).to(device), torch.tensor(trg).to(device) # put to cpu/gpu\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Loss Fused Model:      0.5053754846254984\n",
      "Validation Accuracy Fused Model:      0.78772662842827\n",
      "Validation F1 Fused Model:      0.787140429019928\n",
      "Validation Loss Model A:      0.4919586628675461\n",
      "Validation Accuracy Model A:      0.8364097112341772\n",
      "Validation F1 Model A:      0.8365482091903687\n",
      "Validation Loss Model B:      0.48370615144570667\n",
      "Validation Accuracy Model B:      0.830212453850211\n",
      "Validation F1 Model B:      0.8291031718254089\n"
     ]
    }
   ],
   "source": [
    "# Test the models\n",
    "criterion = torch.nn.CrossEntropyLoss()\n",
    "\n",
    "test_loss_fused, test_acc_fused, test_f1_fused = validation(fusedModel, test_iter, criterion, device)\n",
    "test_loss_A, test_acc_A, test_f1_A = validation(modelA, test_iter, criterion, device)\n",
    "test_loss_B, test_acc_B, test_f1_B = validation(modelB, test_iter, criterion, device)\n",
    "\n",
    "print(\"Validation Loss Fused Model:     \", test_loss_fused)\n",
    "print(\"Validation Accuracy Fused Model:     \", test_acc_fused.item())\n",
    "print(\"Validation F1 Fused Model:     \", test_f1_fused.item())\n",
    "print(\"Validation Loss Model A:     \", test_loss_A)\n",
    "print(\"Validation Accuracy Model A:     \", test_acc_A.item())\n",
    "print(\"Validation F1 Model A:     \", test_f1_A.item())\n",
    "print(\"Validation Loss Model B:     \", test_loss_B)\n",
    "print(\"Validation Accuracy Model B:     \", test_acc_B.item())\n",
    "print(\"Validation F1 Model B:     \", test_f1_B.item())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting the Calibration Curves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_calibration_curve(model, iterator, name, ax, color):\n",
    "    labels_val = []\n",
    "    preds_val = []\n",
    "\n",
    "    softmax = torch.nn.Softmax(dim=1)\n",
    "\n",
    "    with torch.no_grad(): # stop graph\n",
    "        # batches\n",
    "        for i, batch in enumerate(iterator):\n",
    "            src = batch[0] # X\n",
    "            trg = batch[1] # y\n",
    "            src, trg = torch.tensor(src).to(device), torch.tensor(trg).to(device) # put to cpu/gpu\n",
    "            output = model(src)\n",
    "            \n",
    "            y_pred = softmax(output)[:, 1].tolist()\n",
    "            trg = trg.tolist()\n",
    "            labels_val += trg\n",
    "            preds_val += y_pred\n",
    "\n",
    "    # put to numpy\n",
    "    labels_val = np.array(labels_val)\n",
    "    preds_val = np.array(preds_val)\n",
    "    return CalibrationDisplay.from_predictions(\n",
    "        labels_val,\n",
    "        preds_val,\n",
    "        n_bins=10,\n",
    "        name=name,\n",
    "        ax=ax,\n",
    "        color=color\n",
    "    )\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\atace\\AppData\\Local\\Temp/ipykernel_22372/91110932.py:12: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  src, trg = torch.tensor(src).to(device), torch.tensor(trg).to(device) # put to cpu/gpu\n",
      "C:\\Users\\atace\\AppData\\Local\\Temp/ipykernel_22372/91110932.py:12: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  src, trg = torch.tensor(src).to(device), torch.tensor(trg).to(device) # put to cpu/gpu\n",
      "C:\\Users\\atace\\AppData\\Local\\Temp/ipykernel_22372/91110932.py:12: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  src, trg = torch.tensor(src).to(device), torch.tensor(trg).to(device) # put to cpu/gpu\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "clf_list = [\n",
    "    (fusedModel, \"OT with TLL\"),\n",
    "    (modelA, \"Model A\"),\n",
    "    (modelB, \"Model B\")\n",
    "]\n",
    "\n",
    "fig = plt.figure(figsize=(10, 10))\n",
    "gs = GridSpec(4, 2)\n",
    "colors = plt.cm.get_cmap(\"Dark2\")\n",
    "ax_calibration_curve = fig.add_subplot(gs[:2, :2])\n",
    "calibration_displays = {}\n",
    "for i, (clf, name) in enumerate(clf_list):\n",
    "    display = plot_calibration_curve(\n",
    "        clf,\n",
    "        valid_iter,\n",
    "        name=name,\n",
    "        ax=ax_calibration_curve,\n",
    "        color=colors(i),\n",
    "    )\n",
    "    calibration_displays[name] = display\n",
    "ax_calibration_curve.grid()\n",
    "ax_calibration_curve.set_title(\"Calibration plots\")\n",
    "# Add histogram\n",
    "# grid_positions = [(2, 0), (2, 1), (3, 0), (3, 1)]\n",
    "# for i, (_, name) in enumerate(clf_list):\n",
    "#     row, col = grid_positions[i]\n",
    "#     ax = fig.add_subplot(gs[row, col])\n",
    "#     ax.hist(\n",
    "#         calibration_displays[name].y_prob,\n",
    "#         range=(0, 1),\n",
    "#         bins=10,\n",
    "#         label=name,\n",
    "#         color=colors(i),\n",
    "#     )\n",
    "#     ax.set(title=name, xlabel=\"Mean predicted probability\", ylabel=\"Count\")\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.5"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "b1744cd9dc0832a8d503a2c77e6bee76d4493b3bf33a738cf38afd0bb2e60262"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}