8_unsupervised_training_simcse.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7C3pqojKqV4V"
   },
   "source": [
    "# Unsupervised sentence embedding learning - SimCSE\n",
    "\n",
    "In this notebook we will implement [SimCSE](https://arxiv.org/pdf/2104.08821.pdf) by `Tianyu Gao, Xingcheng Yao and Danqi Chen`\n",
    ", a simple contrastive learning framework that works with both unlabeled and labeled data.\n",
    "\n",
    "> Unsupervised SimCSE simply takes an input sentence and predicts itself in a contrastive learning framework, with only standard dropout used as noise. Our supervised SimCSE incorporates annotated pairs from NLI datasets into contrastive learning by using entailment pairs as positives and contradiction pairs as hard negatives. The following figure is an illustration of our models.\n",
    ">\n",
    "> Source: https://github.com/princeton-nlp/SimCSE\n",
    "\n",
    "In TSDAE, the authors use aggressive deletion as the strategy for noise, here we depend on the dropout in the Transformer encoder architecture as noise. Essentially we pass the same sentence twice through the model(model set in the the `train()` mode) and after pooling we get slightly different embeddings. We then use the MNR loss over a batch of these embedding pairs to finetune the model.\n",
    "\n",
    "| ![](assets/simcse.png) | \n",
    "|:--:| \n",
    "| Fig. 1. Illustration of the training process of SimCSE(BERT model in the train() mode). |\n",
    "\n",
    "We will use a subset of the snli dataset to train an encoder for generating sentence embeddings using the unsupervised method described in SimCSE. We will use the MNR loss.\n",
    "\n",
    "> This loss expects as input a batch consisting of sentence pairs (a_1, p_1), (a_2, p_2)..., (a_n, p_n) where we assume that (a_i, p_i) are a positive pair and (a_i, p_j) for i!=j a negative pair.\n",
    ">\n",
    "> For each a_i, it uses all other p_j as negative samples, i.e., for a_i, we have 1 positive example (p_i) and n-1 negative examples (p_j). It then minimizes the negative log-likelihood for softmax normalized scores. This loss function works great to train embeddings for retrieval setups where you have positive pairs (e.g. (query, relevant_doc)) as it will sample in each batch n-1 negative docs randomly.\n",
    ">\n",
    "> The performance usually increases with increasing batch sizes.\n",
    ">\n",
    "> For more information, see: https://arxiv.org/pdf/1705.00652.pdf<br>\n",
    "(Efficient Natural Language Response Suggestion for Smart Reply, Section 4.4)\n",
    ">\n",
    "> You can also provide one or multiple hard negatives per anchor-positive pair by structuring the data like this: (a_1, p_1, n_1), (a_2, p_2, n_2)\n",
    ">\n",
    "> Here, n_1 is a hard negative for (a_1, p_1). The loss will use for the pair (a_i, p_i) all p_j (j!=i) and all n_j as negatives.\n",
    ">\n",
    "> Source: https://github.com/UKPLab/sentence-transformers/blob/master/sentence_transformers/losses/MultipleNegativesRankingLoss.py\n",
    "\n",
    "We will just use the (anchor, positive) pairs in our training here. We will discuss hard negatives later in the series.\n",
    "\n",
    "Since we just need the (anchor, positive) pairs, we will filter the snli dataset with label=0 for entails."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "qIsBo--EME-w"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "from typing import Callable, Iterable\n",
    "\n",
    "import datasets\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "from torch.utils.data import Dataset, DataLoader, random_split\n",
    "from tqdm import tqdm\n",
    "from transformers import BertTokenizerFast, BertModel\n",
    "from transformers.optimization import get_linear_schedule_with_warmup\n",
    "from scipy import stats\n",
    "from sentence_transformers import util\n",
    "from sklearn.metrics.pairwise import cosine_similarity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "5Ns-DN_pMJHq"
   },
   "outputs": [],
   "source": [
    "tokenizer = BertTokenizerFast.from_pretrained(\"bert-base-uncased\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "t3-KGSOMLqff"
   },
   "source": [
    "Let's start ...\n",
    "\n",
    "## Data preparation\n",
    "\n",
    "We will create a custom dataset for the that will give us positive and negative pairs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 138,
     "referenced_widgets": [
      "a7ea7fdf88ff455ba4b0567b843c9dbe",
      "f1adb1e4b7e348c3a74485ef33523ab0",
      "96867ec8368342a0ab95d30e41ac441d",
      "e7d20bf52192413b8da840a6c387fa8f",
      "fefa967e2337439e80a4bd2a9f239fb9",
      "41b3b3572cde4a9c968a1402fbe9877d",
      "4f6674089fcc485490fe213f48a6f665",
      "79237276f0cb4ad09ab571145f2c7608",
      "9a8df0d7a028403db52d35accf0ab5db",
      "a013ec76da6f495d8ffafc336b106be3",
      "7738ebbfdb38453c8fa0ae98bf454a15"
     ]
    },
    "id": "JK63Bw9bQPy0",
    "outputId": "fb3ef042-5cbb-4f1c-aa53-d997eb7a0d4b"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Reusing dataset snli (/home/utsav/.cache/huggingface/datasets/snli/plain_text/1.0.0/1f60b67533b65ae0275561ff7828aad5ee4282d0e6f844fd148d05d3c6ea251b)\n",
      "Parameter 'function'=<function <lambda> at 0x7f407b992940> of the transform datasets.arrow_dataset.Dataset.filter@2.0.1 couldn't be hashed properly, a random hash was used instead. Make sure your transforms and parameters are serializable with pickle or dill for the dataset fingerprinting and caching to work. If you reuse this transform, the caching mechanism will consider it to be different from the previous calls and recompute everything. This warning is only showed once. Subsequent hashing failures won't be showed.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5b0a4af8e80b419fa868f8a8b54fa310",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/551 [00:00<?, ?ba/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(27524,\n",
       " {'premise': \"Woman in white in foreground and a man slightly behind walking with a sign for John's Pizza and Gyro in the background.\",\n",
       "  'hypothesis': 'A woman ordering pizza.',\n",
       "  'label': 1})"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset = datasets.load_dataset(\"snli\", split=\"train\")\n",
    "\n",
    "# there are some pairs of \"premise\" and \"hypothesis\" which haven't been\n",
    "# labeled in this dataset, we will filter those out first\n",
    "dataset = dataset.filter(lambda x: True if random.random() > 0.95 else False)\n",
    "\n",
    "len(dataset), dataset[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at the distribution of the lengths of the sentences in our dataset to pick the max_length for our tokenizer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gYaY5GoYQT6z",
    "outputId": "3dba72e7-2df3-4d7e-b7e4-33d0c0d15351"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████| 27524/27524 [00:01<00:00, 18777.55it/s]\n"
     ]
    }
   ],
   "source": [
    "preimse_lengths = []\n",
    "\n",
    "for data in tqdm(dataset):\n",
    "    if random.random() > 0.9:\n",
    "        preimse_lengths.append(len(data[\"premise\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 463
    },
    "id": "P4Emr6bZQ0-8",
    "outputId": "5a0b227e-298f-40ef-ead0-a60202ad0ad1"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzwAAAFlCAYAAAAu6O34AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAVU0lEQVR4nO3df6zd933X8dcbewtdS0WiOFFmWzgg8yOJYN2uQqHSVBFEMjLm8EeQK20zI5JhyliHkJgz/sj+sWRgTIBEKoW11BVdIqvrFIu0W4PZVCFtzZw2onVMiFlCchcT31KNtSClJHvzx/2WHjn3Xrv3XN97/bmPh2Sdcz7n+z3fj6WPT/LU93u/t7o7AAAAI/ojWz0BAACAa0XwAAAAwxI8AADAsAQPAAAwLMEDAAAMS/AAAADD2r3VE7iSm2++uQ8cOLDV0wAAALap55577qvdvWel964YPFX1sSQ/nORSd981jf2zJH8jyTeT/LckP9Hdvz+990iSh5K8neSnu/vXp/EfSPLxJO9K8pkkH+6r+CVABw4cyNmzZ6+0GQAAsENV1X9f7b2ruaTt40nuu2zsmSR3dfefT/JfkzwyHeiOJIeT3Dnt81hV7Zr2+UiSo0kOTn8u/0wAAIANdcXg6e7PJ/naZWOf6+63ppe/nWTf9PxQkie7+83ufjnJhSR3V9VtSd7b3b81ndX5RJIHNujvAAAAsKKNuGnB30ny2en53iSvzby3OI3tnZ5fPr6iqjpaVWer6uzS0tIGTBEAANiJ5gqeqvrHSd5K8slvDa2wWa8xvqLufry7F7p7Yc+eFX/2CAAA4IrWfZe2qjqS5ZsZ3DNz84HFJPtnNtuX5PVpfN8K4wAAANfMus7wVNV9SX42yY909/+Zeet0ksNVdUNV3Z7lmxM8290Xk3y9qt5fVZXkx5M8NefcAQAA1nQ1t6V+IskHk9xcVYtJHs3yXdluSPLMcr/kt7v773X3uao6leSFLF/q9nB3vz191E/m27el/my+/XM/AAAA10Rdxa/C2VILCwvt9/AAAACrqarnunthpfc24i5tAAAA25LgAQAAhiV4AACAYQkeAABgWIIHAAAY1rp/8SjMOnDs6a2ewrb1yon7t3oKAAA7ljM8AADAsAQPAAAwLMEDAAAMS/AAAADDEjwAAMCwBA8AADAswQMAAAxL8AAAAMMSPAAAwLAEDwAAMCzBAwAADEvwAAAAwxI8AADAsAQPAAAwLMEDAAAMS/AAAADDEjwAAMCwBA8AADAswQMAAAxL8AAAAMMSPAAAwLAEDwAAMCzBAwAADEvwAAAAwxI8AADAsAQPAAAwLMEDAAAMS/AAAADDEjwAAMCwBA8AADAswQMAAAxL8AAAAMMSPAAAwLAEDwAAMCzBAwAADEvwAAAAwxI8AADAsAQPAAAwLMEDAAAM64rBU1Ufq6pLVfWVmbGbquqZqnpperxx5r1HqupCVb1YVffOjP9AVX15eu9fVVVt/F8HAADg267mDM/Hk9x32dixJGe6+2CSM9PrVNUdSQ4nuXPa57Gq2jXt85EkR5McnP5c/pkAAAAb6orB092fT/K1y4YPJTk5PT+Z5IGZ8Se7+83ufjnJhSR3V9VtSd7b3b/V3Z3kEzP7AAAAXBPr/RmeW7v7YpJMj7dM43uTvDaz3eI0tnd6fvn4iqrqaFWdraqzS0tL65wiAACw0230TQtW+rmcXmN8Rd39eHcvdPfCnj17NmxyAADAzrLe4Hljukwt0+OlaXwxyf6Z7fYleX0a37fCOAAAwDWz3uA5neTI9PxIkqdmxg9X1Q1VdXuWb07w7HTZ29er6v3T3dl+fGYfAACAa2L3lTaoqieSfDDJzVW1mOTRJCeSnKqqh5K8muTBJOnuc1V1KskLSd5K8nB3vz191E9m+Y5v70ry2ekPAADANXPF4OnuD63y1j2rbH88yfEVxs8mues7mh0AAMAcNvqmBQAAANuG4AEAAIYleAAAgGEJHgAAYFiCBwAAGJbgAQAAhiV4AACAYQkeAABgWIIHAAAYluABAACGJXgAAIBhCR4AAGBYggcAABiW4AEAAIYleAAAgGEJHgAAYFiCBwAAGJbgAQAAhiV4AACAYQkeAABgWIIHAAAYluABAACGJXgAAIBhCR4AAGBYggcAABiW4AEAAIYleAAAgGEJHgAAYFiCBwAAGJbgAQAAhiV4AACAYQkeAABgWIIHAAAYluABAACGJXgAAIBhCR4AAGBYggcAABiW4AEAAIYleAAAgGEJHgAAYFiCBwAAGJbgAQAAhiV4AACAYQkeAABgWHMFT1X9g6o6V1VfqaonquqPVtVNVfVMVb00Pd44s/0jVXWhql6sqnvnnz4AAMDq1h08VbU3yU8nWejuu5LsSnI4ybEkZ7r7YJIz0+tU1R3T+3cmuS/JY1W1a77pAwAArG7eS9p2J3lXVe1O8j1JXk9yKMnJ6f2TSR6Ynh9K8mR3v9ndLye5kOTuOY8PAACwqnUHT3f/XpJfSPJqkotJ/ld3fy7Jrd19cdrmYpJbpl32Jnlt5iMWpzEAAIBrYp5L2m7M8lmb25N8b5J3V9WPrrXLCmO9ymcfraqzVXV2aWlpvVMEAAB2uHkuafurSV7u7qXu/r9JPp3kLyd5o6puS5Lp8dK0/WKS/TP778vyJXDv0N2Pd/dCdy/s2bNnjikCAAA72TzB82qS91fV91RVJbknyfkkp5McmbY5kuSp6fnpJIer6oaquj3JwSTPznF8AACANe1e747d/YWq+lSSLyZ5K8mXkjye5D1JTlXVQ1mOogen7c9V1akkL0zbP9zdb885fwAAgFWtO3iSpLsfTfLoZcNvZvlsz0rbH09yfJ5jAgAAXK15b0sNAACwbQkeAABgWIIHAAAYluABAACGJXgAAIBhCR4AAGBYggcAABiW4AEAAIYleAAAgGEJHgAAYFiCBwAAGJbgAQAAhiV4AACAYQkeAABgWIIHAAAYluABAACGJXgAAIBhCR4AAGBYggcAABiW4AEAAIYleAAAgGEJHgAAYFiCBwAAGJbgAQAAhiV4AACAYQkeAABgWIIHAAAYluABAACGJXgAAIBhCR4AAGBYggcAABiW4AEAAIYleAAAgGEJHgAAYFiCBwAAGJbgAQAAhiV4AACAYQkeAABgWIIHAAAYluABAACGtXurJwCjO3Ds6a2ewrb1yon7t3oKAMDgnOEBAACGJXgAAIBhCR4AAGBYggcAABjWXMFTVX+8qj5VVf+lqs5X1V+qqpuq6pmqeml6vHFm+0eq6kJVvVhV984/fQAAgNXNe4bnXyb5te7+s0n+QpLzSY4lOdPdB5OcmV6nqu5IcjjJnUnuS/JYVe2a8/gAAACrWnfwVNV7k/xgko8mSXd/s7t/P8mhJCenzU4meWB6fijJk939Zne/nORCkrvXe3wAAIArmecMz59MspTk31bVl6rql6rq3Ulu7e6LSTI93jJtvzfJazP7L05j71BVR6vqbFWdXVpammOKAADATjZP8OxO8v1JPtLd70vyvzNdvraKWmGsV9qwux/v7oXuXtizZ88cUwQAAHayeYJnMclid39hev2pLAfQG1V1W5JMj5dmtt8/s/++JK/PcXwAAIA1rTt4uvt/JHmtqv7MNHRPkheSnE5yZBo7kuSp6fnpJIer6oaquj3JwSTPrvf4AAAAV7J7zv3/fpJPVtV3J/ndJD+R5Yg6VVUPJXk1yYNJ0t3nqupUlqPorSQPd/fbcx4fAABgVXMFT3c/n2RhhbfuWWX740mOz3NMAACAqzXv7+EBAADYtgQPAAAwLMEDAAAMS/AAAADDEjwAAMCwBA8AADAswQMAAAxL8AAAAMMSPAAAwLAEDwAAMCzBAwAADEvwAAAAwxI8AADAsAQPAAAwLMEDAAAMS/AAAADDEjwAAMCwBA8AADAswQMAAAxL8AAAAMMSPAAAwLAEDwAAMCzBAwAADEvwAAAAwxI8AADAsAQPAAAwLMEDAAAMS/AAAADDEjwAAMCwBA8AADAswQMAAAxL8AAAAMMSPAAAwLAEDwAAMCzBAwAADEvwAAAAwxI8AADAsAQPAAAwLMEDAAAMS/AAAADDEjwAAMCwBA8AADAswQMAAAxL8AAAAMOaO3iqaldVfamq/v30+qaqeqaqXpoeb5zZ9pGqulBVL1bVvfMeGwAAYC0bcYbnw0nOz7w+luRMdx9McmZ6naq6I8nhJHcmuS/JY1W1awOODwAAsKK5gqeq9iW5P8kvzQwfSnJyen4yyQMz409295vd/XKSC0nunuf4AAAAa5n3DM+/SPKPkvzhzNit3X0xSabHW6bxvUlem9lucRoDAAC4JtYdPFX1w0kudfdzV7vLCmO9ymcfraqzVXV2aWlpvVMEAAB2uHnO8HwgyY9U1StJnkzyV6rq3yV5o6puS5Lp8dK0/WKS/TP770vy+kof3N2Pd/dCdy/s2bNnjikCAAA72bqDp7sf6e593X0gyzcj+I/d/aNJTic5Mm12JMlT0/PTSQ5X1Q1VdXuSg0meXffMAQAArmD3NfjME0lOVdVDSV5N8mCSdPe5qjqV5IUkbyV5uLvfvgbHv2YOHHt6q6cAAAB8BzYkeLr7N5P85vT8fya5Z5Xtjic5vhHHBAAAuJKN+D08AAAA25LgAQAAhiV4AACAYQkeAABgWIIHAAAYluABAACGJXgAAIBhCR4AAGBYggcAABjW7q2eALBzHTj29FZPYdt65cT9Wz0FABiCMzwAAMCwBA8AADAswQMAAAxL8AAAAMMSPAAAwLAEDwAAMCzBAwAADEvwAAAAwxI8AADAsAQPAAAwLMEDAAAMS/AAAADDEjwAAMCwBA8AADAswQMAAAxL8AAAAMMSPAAAwLAEDwAAMCzBAwAADEvwAAAAwxI8AADAsAQPAAAwLMEDAAAMS/AAAADDEjwAAMCwBA8AADAswQMAAAxL8AAAAMMSPAAAwLAEDwAAMCzBAwAADEvwAAAAwxI8AADAsAQPAAAwLMEDAAAMa93BU1X7q+o3qup8VZ2rqg9P4zdV1TNV9dL0eOPMPo9U1YWqerGq7t2IvwAAAMBq5jnD81aSf9jdfy7J+5M8XFV3JDmW5Ex3H0xyZnqd6b3DSe5Mcl+Sx6pq1zyTBwAAWMu6g6e7L3b3F6fnX09yPsneJIeSnJw2O5nkgen5oSRPdveb3f1ykgtJ7l7v8QEAAK5kQ36Gp6oOJHlfki8kubW7LybLUZTklmmzvUlem9ltcRpb6fOOVtXZqjq7tLS0EVMEAAB2oLmDp6rek+RXkvxMd//BWpuuMNYrbdjdj3f3Qncv7NmzZ94pAgAAO9RcwVNV35Xl2Plkd396Gn6jqm6b3r8tyaVpfDHJ/pnd9yV5fZ7jAwAArGWeu7RVko8mOd/dvzjz1ukkR6bnR5I8NTN+uKpuqKrbkxxM8ux6jw8AAHAlu+fY9wNJfizJl6vq+Wns55KcSHKqqh5K8mqSB5Oku89V1akkL2T5Dm8Pd/fbcxwfAABgTesOnu7+T1n553KS5J5V9jme5Ph6jwkAAPCd2JC7tAEAAGxHggcAABiW4AEAAIYleAAAgGEJHgAAYFiCBwAAGJbgAQAAhiV4AACAYQkeAABgWIIHAAAYluABAACGJXgAAIBhCR4AAGBYggcAABjW7q2eAADvdODY01s9hW3rlRP3b/UUALiOOMMDAAAMS/AAAADDEjwAAMCwBA8AADAswQMAAAxL8AAAAMMSPAAAwLAEDwAAMCzBAwAADEvwAAAAwxI8AADAsAQPAAAwLMEDAAAMS/AAAADDEjwAAMCwBA8AADAswQMAAAxL8AAAAMMSPAAAwLAEDwAAMCzBAwAADGv3Vk8AAL4TB449vdVT2LZeOXH/Vk8BYNtxhgcAABiW4AEAAIYleAAAgGEJHgAAYFhuWgAAg3BDh9W5oQPsXM7wAAAAwxI8AADAsDY9eKrqvqp6saouVNWxzT4+AACwc2xq8FTVriT/OskPJbkjyYeq6o7NnAMAALBzbPYZnruTXOju3+3ubyZ5MsmhTZ4DAACwQ2z2Xdr2Jnlt5vVikr+4yXMAAHYYd7BbnTvYrc66Wd31tG42O3hqhbF+x0ZVR5McnV5+o6pevKaz4npzc5KvbvUkGIo1xUayntho13RN1T+5Vp/MNjb3mtqG6+ZPrPbGZgfPYpL9M6/3JXn98o26+/Ekj2/WpLi+VNXZ7l7Y6nkwDmuKjWQ9sdGsKTbaTltTm/0zPL+T5GBV3V5V353kcJLTmzwHAABgh9jUMzzd/VZV/VSSX0+yK8nHuvvcZs4BAADYOTb7krZ092eSfGazj8tQXO7IRrOm2EjWExvNmmKj7ag1Vd3vuGcAAADAEDb7Z3gAAAA2jeBh26uqV6rqy1X1fFWdncZuqqpnquql6fHGrZ4n21NVfayqLlXVV2bGVl0/VfVIVV2oqher6t6tmTXb2Spr6uer6vem76nnq+qvz7xnTbGqqtpfVb9RVeer6lxVfXga9z3Fuqyxpnbs95RL2tj2quqVJAvd/dWZsX+a5GvdfaKqjiW5sbt/dqvmyPZVVT+Y5BtJPtHdd01jK66fqrojyRNJ7k7yvUn+Q5I/3d1vb9H02YZWWVM/n+Qb3f0Ll21rTbGmqrotyW3d/cWq+mNJnkvyQJK/Hd9TrMMaa+pvZYd+TznDw/XqUJKT0/OTWf6HDO/Q3Z9P8rXLhldbP4eSPNndb3b3y0kuZPk/APD/rbKmVmNNsabuvtjdX5yefz3J+SR743uKdVpjTa1m+DUleLgedJLPVdVzVXV0Gru1uy8my/+wk9yyZbPjerTa+tmb5LWZ7Raz9n8kYNZPVdV/ni55+9blR9YUV62qDiR5X5IvxPcUG+CyNZXs0O8pwcP14APd/f1JfijJw9PlJHAt1ApjrvvlanwkyZ9K8n1JLib559O4NcVVqar3JPmVJD/T3X+w1qYrjFlTvMMKa2rHfk8JHra97n59eryU5FezfJr1jeka1W9dq3pp62bIdWi19bOYZP/MdvuSvL7Jc+M61N1vdPfb3f2HSf5Nvn05iDXFFVXVd2X5f0w/2d2fnoZ9T7FuK62pnfw9JXjY1qrq3dMP3KWq3p3kryX5SpLTSY5Mmx1J8tTWzJDr1Grr53SSw1V1Q1XdnuRgkme3YH5cZ771P6aTv5nl76nEmuIKqqqSfDTJ+e7+xZm3fE+xLqutqZ38PbV7qycAV3Brkl9d/reb3Ul+ubt/rap+J8mpqnooyatJHtzCObKNVdUTST6Y5OaqWkzyaJITWWH9dPe5qjqV5IUkbyV5eKS71LAxVllTH6yq78vyZSCvJPm7iTXFVflAkh9L8uWqen4a+7n4nmL9VltTH9qp31NuSw0AAAzLJW0AAMCwBA8AADAswQMAAAxL8AAAAMMSPAAAwLAEDwAAMCzBAwAADEvwAAAAw/p/Q+EHV1nclDIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1008x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(14, 6))\n",
    "ax.hist(preimse_lengths);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "aZrUqkodLT1E",
    "outputId": "f1ed0877-3692-4a10-c25e-b97521d0de52"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4.32 s, sys: 792 ms, total: 5.11 s\n",
      "Wall time: 2.91 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "MAX_LENGTH = 128\n",
    "\n",
    "# anchors\n",
    "tokenized_premises = tokenizer([data[\"premise\"] for data in dataset],\n",
    "                               max_length=MAX_LENGTH, padding=\"max_length\",\n",
    "                               truncation=True, verbose=True, return_tensors=\"pt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "vCNDoCE7MKXM"
   },
   "outputs": [],
   "source": [
    "seed = 10\n",
    "\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed_all(seed)\n",
    "\n",
    "torch.backends.cudnn.deterministic = True\n",
    "torch.backends.cudnn.benchmark = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-LBbaDtePIoZ"
   },
   "source": [
    "Now we will create out custom dataset and dataloaders with train/validation split for training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "XArky0MCML_-"
   },
   "outputs": [],
   "source": [
    "class SnliDataset(Dataset):\n",
    "    def __init__(self, premise_tokens: dict):\n",
    "        self.premise_tokens = premise_tokens\n",
    "\n",
    "    def __getitem__(self, ix: int) -> dict[str, torch.tensor]:\n",
    "        return {\"input_ids\": self.premise_tokens[\"input_ids\"][ix],\n",
    "                \"attention_mask\": self.premise_tokens[\"attention_mask\"][ix]}\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return len(self.premise_tokens[\"input_ids\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "X0qGF8eQMntT",
    "outputId": "dc14c89a-6a27-4232-8328-3e716bdd4e80"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4 µs, sys: 0 ns, total: 4 µs\n",
      "Wall time: 7.15 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "snli_dataset = SnliDataset(tokenized_premises)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "IOsjYf-oMpvw"
   },
   "outputs": [],
   "source": [
    "train_ratio = 0.8\n",
    "n_total = len(snli_dataset)\n",
    "n_train = int(n_total * train_ratio)\n",
    "n_val = n_total - n_train\n",
    "\n",
    "train_dataset, val_dataset = random_split(snli_dataset, [n_train, n_val])\n",
    "\n",
    "batch_size = 16  # mentioned in the paper\n",
    "train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "val_dataloader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Us3v9ug1M9wX",
    "outputId": "34a13a19-158c-402c-830a-a71634ae5873"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'input_ids': tensor([[ 101, 2048, 4004,  ...,    0,    0,    0],\n",
       "         [ 101, 1037, 2450,  ...,    0,    0,    0],\n",
       "         [ 101, 2048, 2273,  ...,    0,    0,    0],\n",
       "         ...,\n",
       "         [ 101, 1037, 2158,  ...,    0,    0,    0],\n",
       "         [ 101, 2048, 3455,  ...,    0,    0,    0],\n",
       "         [ 101, 1037, 2158,  ...,    0,    0,    0]]),\n",
       " 'attention_mask': tensor([[1, 1, 1,  ..., 0, 0, 0],\n",
       "         [1, 1, 1,  ..., 0, 0, 0],\n",
       "         [1, 1, 1,  ..., 0, 0, 0],\n",
       "         ...,\n",
       "         [1, 1, 1,  ..., 0, 0, 0],\n",
       "         [1, 1, 1,  ..., 0, 0, 0],\n",
       "         [1, 1, 1,  ..., 0, 0, 0]])}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(iter(train_dataloader))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pfHThuIeNDO9"
   },
   "source": [
    "## Model config\n",
    "\n",
    "Here we will setup out custom SBERT model as detailed in the diagram from the paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "tdD2iPt8NAW2",
    "outputId": "0668e457-eb1e-4460-cfbd-08b4344914f7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cuda'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "device"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "m2pvMzMZPIob"
   },
   "source": [
    "The method mean_pool() implements the mean token pooling strategy mentioned in the paper. The implementation has been picked up from the sentence_transformers library.\n",
    "\n",
    "We will use the encode() method to compute pooled embeddings using the finetuned and the bert-base models later to evaluate the results on STS tasks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "PC9pe_oSNMfe"
   },
   "outputs": [],
   "source": [
    "def mean_pool(token_embeds: torch.tensor, attention_mask: torch.tensor) -> torch.tensor:\n",
    "    in_mask = attention_mask.unsqueeze(-1).expand(token_embeds.size()).float()\n",
    "    pool = torch.sum(token_embeds * in_mask, 1) / torch.clamp(in_mask.sum(1), min=1e-9)\n",
    "    return pool\n",
    "\n",
    "\n",
    "def encode(\n",
    "    input_texts: list[str], tokenizer: BertTokenizerFast, model: BertModel, device: str = \"cpu\"\n",
    ") -> torch.tensor:\n",
    "\n",
    "    model.eval()\n",
    "    tokenized_texts = tokenizer(input_texts, max_length=MAX_LENGTH,\n",
    "                                padding='max_length', truncation=True, return_tensors=\"pt\")\n",
    "    token_embeds = model(tokenized_texts[\"input_ids\"].to(device),\n",
    "                         tokenized_texts[\"attention_mask\"].to(device)).last_hidden_state\n",
    "    pooled_embeds = mean_pool(token_embeds, tokenized_texts[\"attention_mask\"].to(device))\n",
    "    return pooled_embeds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "abYBoikzNOMf"
   },
   "outputs": [],
   "source": [
    "class Sbert(torch.nn.Module):\n",
    "    def __init__(self, max_length: int = MAX_LENGTH):\n",
    "        super().__init__()\n",
    "        self.max_length = max_length\n",
    "        self.bert_model = BertModel.from_pretrained('bert-base-uncased')\n",
    "        self.bert_tokenizer = BertTokenizerFast.from_pretrained('bert-base-uncased')\n",
    "\n",
    "\n",
    "    def forward(self, data: datasets.arrow_dataset.Dataset) -> tuple[torch.tensor, torch.tensor]:\n",
    "        input_ids = data[\"input_ids\"].to(device)\n",
    "        attention_mask = data[\"attention_mask\"].to(device)\n",
    "\n",
    "        out_premise = self.bert_model(input_ids, attention_mask)\n",
    "        embeds1 = out_premise.last_hidden_state\n",
    "        out_premise = self.bert_model(input_ids, attention_mask)\n",
    "        embeds2 = out_premise.last_hidden_state\n",
    "\n",
    "        pooled_embeds1 = mean_pool(embeds1, attention_mask)\n",
    "        pooled_embeds2 = mean_pool(embeds2, attention_mask)\n",
    "\n",
    "        return pooled_embeds1, pooled_embeds2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "un_1u6WxNl5V",
    "outputId": "8bc9e9e8-5560-48cd-afd8-8cad6d8b35ad"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.predictions.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.seq_relationship.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.decoder.weight', 'cls.seq_relationship.weight']\n",
      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
     ]
    }
   ],
   "source": [
    "model = Sbert()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "kIWqkMw0NnRY"
   },
   "outputs": [],
   "source": [
    "# optimizer, lr, num_warmup steps have been picked from the paper\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=2e-5)\n",
    "total_steps = len(train_dataset) // batch_size\n",
    "warmup_steps = int(0.1 * total_steps)\n",
    "scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=warmup_steps,\n",
    "                                            num_training_steps=total_steps - warmup_steps)\n",
    "\n",
    "loss_fn = torch.nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "hAwA7NkuNonQ"
   },
   "outputs": [],
   "source": [
    "model = model.to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "djG942tZRWbh"
   },
   "source": [
    "## Training loop\n",
    "\n",
    "While calculating the loss per batch, using the similarity matrix(from anchors and positives) and the target tensor, we scale the similarity matrix by a constant first. We are using a scaling factor of 20 as used in the sentence_transformer library.\n",
    "\n",
    "The reason for this scaling(from what i can tell) is the same as using temperature while decoding from seq2seq models. Essentially we want to make the distribution of scores(similarity in this case) more peaky(this amounts to lowering the temperature while decoding).\n",
    "\n",
    "For example, consider a batch size 4 with similarity scores [0.8, 0.75, 0.5, 0.4] with `similarity(anchor, positive)` = 0.8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 390
    },
    "id": "lJe8bUeSPIoc",
    "outputId": "0e402e8c-d31b-4fa1-9ba0-12ba55011f88"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "similarity_scores = np.array([0.8, 0.75, 0.5, 0.4])\n",
    "softmax_scores = np.exp(similarity_scores) / np.exp(similarity_scores).sum()\n",
    "scaled_softmax_scores = np.exp(similarity_scores*20) / np.exp(similarity_scores*20).sum()\n",
    "\n",
    "fix, ax = plt.subplots(1, 2, figsize=(14, 6))\n",
    "ax[0].bar(range(len(softmax_scores)), softmax_scores)\n",
    "ax[0].set_title(\"non-scaled similarity scores\")\n",
    "ax[1].bar(range(len(scaled_softmax_scores)), scaled_softmax_scores)\n",
    "ax[1].set_title(\"scaled similarity scores\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "id": "qfT_sTq3Np7x"
   },
   "outputs": [],
   "source": [
    "def get_train_step_fn(\n",
    "    model: torch.nn.Module, optimizer: torch.optim.Optimizer, \n",
    "    scheduler: torch.optim.lr_scheduler.LambdaLR, loss_fn: torch.nn.CrossEntropyLoss\n",
    ") -> Callable[[torch.tensor], float]:\n",
    "\n",
    "    def train_step_fn(x: torch.tensor) -> float:\n",
    "        model.train()\n",
    "        anchor_encodings, positive_encodings = model(x)\n",
    "        similarity_matrix = util.cos_sim(anchor_encodings, positive_encodings)\n",
    "        target = torch.tensor(range(len(anchor_encodings)), dtype=torch.long, device=device)\n",
    "        loss = loss_fn(similarity_matrix * 20, target)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        scheduler.step()\n",
    "        optimizer.zero_grad()\n",
    "        return loss.item()\n",
    "\n",
    "    return train_step_fn\n",
    "\n",
    "\n",
    "def get_val_step_fn(\n",
    "    model: torch.nn.Module, loss_fn: torch.nn.CrossEntropyLoss\n",
    ") -> Callable[[torch.tensor], float]:\n",
    "\n",
    "    def val_step_fn(x: torch.tensor) -> float:\n",
    "        model.eval()\n",
    "        anchor_encodings, postiive_encodings = model(x)\n",
    "        similarity_matrix = util.cos_sim(anchor_encodings, postiive_encodings)\n",
    "        target = torch.tensor(range(len(anchor_encodings)), dtype=torch.long, device=device)\n",
    "        loss = loss_fn(similarity_matrix * 20, target)\n",
    "        return loss.item()\n",
    "\n",
    "    return val_step_fn\n",
    "\n",
    "\n",
    "def mini_batch(\n",
    "    dataloader: DataLoader, step_fn: Callable[[torch.tensor], float], is_training: bool = True\n",
    ") -> tuple[np.array, list[float]]:\n",
    "\n",
    "    mini_batch_losses = []\n",
    "\n",
    "    if is_training:\n",
    "        print(\"\\nTraining ...\")\n",
    "    else:\n",
    "        print(\"\\nValidating ...\")\n",
    "    n_steps = len(dataloader)\n",
    "    for i, data in enumerate(dataloader):\n",
    "        loss = step_fn(data)\n",
    "        mini_batch_losses.append(loss)\n",
    "        if i % (batch_size * 20) == 0:\n",
    "            print(f\"step {i:>5}/{n_steps}, loss = {loss: .3f}\")\n",
    "\n",
    "    return np.mean(mini_batch_losses), mini_batch_losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hGpo6OdvOPfQ",
    "outputId": "7fc6a80c-1222-4773-fbd6-a71be55d1911"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Training ...\n",
      "step     0/1377, loss =  0.130\n",
      "step   320/1377, loss =  0.000\n",
      "step   640/1377, loss =  0.000\n",
      "step   960/1377, loss =  0.000\n",
      "step  1280/1377, loss =  0.000\n",
      "\n",
      "Validating ...\n",
      "step     0/345, loss =  0.000\n",
      "step   320/345, loss =  0.000\n",
      "CPU times: user 3min 16s, sys: 57.7 s, total: 4min 14s\n",
      "Wall time: 4min 14s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "n_epochs = 1\n",
    "\n",
    "train_step_fn = get_train_step_fn(model, optimizer, scheduler, loss_fn)\n",
    "val_step_fn = get_val_step_fn(model, loss_fn)\n",
    "\n",
    "train_losses, train_mini_batch_losses = [], []\n",
    "val_losses, val_mini_batch_losses = [], []\n",
    "\n",
    "for epoch in range(1, n_epochs + 1):\n",
    "    train_loss, _train_mini_batch_losses = mini_batch(train_dataloader, train_step_fn)\n",
    "    train_mini_batch_losses += _train_mini_batch_losses\n",
    "    train_losses.append(train_loss)\n",
    "\n",
    "    with torch.no_grad():\n",
    "        val_loss, _val_mini_batch_losses = mini_batch(val_dataloader, val_step_fn, is_training=False)\n",
    "        val_mini_batch_losses += _val_mini_batch_losses\n",
    "        val_losses.append(val_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "FjKQUeXdQu2t",
    "outputId": "33c0611e-ab54-4113-900e-21550b74d16b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.002556561377214833, 2.7032296759938144e-05)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_loss, val_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JMwXpvXXPIod"
   },
   "source": [
    "Normally we look at losses over multiple epochs, but here we have only 1 epoch. One way to look at the mini batch losses is to use a running mean(smoothing) to reduce noise from per batch loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "id": "TdZNZXuzpI9O"
   },
   "outputs": [],
   "source": [
    "window_size = 32\n",
    "\n",
    "train_mb_running_loss = []\n",
    "for i in range(len(train_mini_batch_losses)-window_size):\n",
    "    train_mb_running_loss.append(np.mean(train_mini_batch_losses[i:i+window_size]))\n",
    "\n",
    "val_mb_running_loss = []\n",
    "for i in range(len(val_mini_batch_losses)-window_size):\n",
    "    val_mb_running_loss.append(np.mean(val_mini_batch_losses[i:i+window_size]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 483
    },
    "id": "uIT6QOkVRdX9",
    "outputId": "2580a80e-ad6b-402e-c0f0-eaa1ab5651a6"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fix, ax = plt.subplots(figsize=(14, 8))\n",
    "ax.plot(range(len(train_mb_running_loss)), train_mb_running_loss);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UwsWPXh_RrwB"
   },
   "source": [
    "## Evaluation\n",
    "\n",
    "Here we will manually inspect the performance of our finetuned model as well as use a STS dataset for evaluation on a similar task as mentioned in the paper.\n",
    "\n",
    "For manual inspection, we have taken few texts which fall neatly into three clusters. We want to see how neatly our finetuned model(and the bert-base model) is able to find these clusters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "5MtxNRoKRjmK"
   },
   "outputs": [],
   "source": [
    "def plot_heatmap(similarity_matrix: np.array, sentences: List[str]) -> None:\n",
    "    fig, ax = plt.subplots(figsize=(10, 10))\n",
    "    im = ax.imshow(similarity_matrix, cmap='YlGn', interpolation='nearest')\n",
    "\n",
    "    ax.set_yticks(np.arange(len(sentences)), labels=[txt[:50] + \"...\" for txt in sentences])\n",
    "    ax.set_xticks(np.arange(len(sentences)), labels=[txt[:50] + \"...\" for txt in sentences])\n",
    "\n",
    "    plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\", rotation_mode=\"anchor\")\n",
    "\n",
    "    for i in range(len(sentences)):\n",
    "        for j in range(len(sentences)):\n",
    "            text = ax.text(j, i, round(similarity_matrix[i, j], 2),\n",
    "                           ha=\"center\", va=\"center\", color=\"w\")\n",
    "\n",
    "    fig.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "id": "OlxZsGVYRuJo"
   },
   "outputs": [],
   "source": [
    "sentences = [\n",
    "    \"What should I do to improve my English ?\",\n",
    "    \"What should I do to improve my spoken English?\",\n",
    "    \"Can I improve my English?\",\n",
    "    \"How can I earn money online?\",\n",
    "    \"How do I earn money online?\",\n",
    "    \"Can I earn money online?\",\n",
    "    \"What are some mind-blowing Mobile gadgets that exist that most people don't know about?\",\n",
    "    \"What are some mind-blowing gadgets and technologies that exist that most people don't know about?\",\n",
    "    \"What are some mind-blowing mobile technology tools that exist that most people don't know about?\"\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "kOV-JHeyRwUG"
   },
   "outputs": [],
   "source": [
    "pooled_embeds = encode(sentences, model.bert_tokenizer, model.bert_model, device)\n",
    "pooled_embeds = pooled_embeds.cpu().detach().numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "b9rtTd3LPIoe"
   },
   "source": [
    "Our finetuned model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 911
    },
    "id": "GmWmduDFRxzq",
    "outputId": "87a4ddc6-899b-4b39-fd46-d4cb7f3ce592"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "similarity_matrix = cosine_similarity(pooled_embeds)\n",
    "plot_heatmap(similarity_matrix, sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EL1aHfC7PIoe"
   },
   "source": [
    "Next we import the original bert-base model again for comparison."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "AVnAOPD4RzJd",
    "outputId": "151b834a-0a23-435b-bd0f-419b6dcd3922"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.predictions.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.seq_relationship.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.decoder.weight', 'cls.seq_relationship.weight']\n",
      "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
     ]
    }
   ],
   "source": [
    "bert_model = BertModel.from_pretrained(\"bert-base-uncased\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "id": "GkzJSeoaR2PQ"
   },
   "outputs": [],
   "source": [
    "pooled_embeds = encode(sentences, tokenizer, bert_model, \"cpu\")\n",
    "pooled_embeds = pooled_embeds.detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 911
    },
    "id": "pfsUkigzR4cb",
    "outputId": "24c76665-0a87-48fe-fc4e-0a0af2363e49"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "similarity_matrix = cosine_similarity(pooled_embeds)\n",
    "plot_heatmap(similarity_matrix, sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Cop9UxnUPIof"
   },
   "source": [
    "On a visual inspection we can see that our finetuned model is doing a better job in encoding the texts so that the clusters are clearly visible. Specifically it's doing a better job in pushing down the scores for non similar text pairs.\n",
    "\n",
    "Let's evaluate the models on a STS dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "id": "JJFcbhZGR56a"
   },
   "outputs": [],
   "source": [
    "sbert_model = model.bert_model\n",
    "bert_model = bert_model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "wG-zMln3R7_b",
    "outputId": "3dab9928-926c-40e2-9364-906481812b0c"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Reusing dataset glue (/home/utsav/.cache/huggingface/datasets/glue/stsb/1.0.0/dacbe3125aa31d7f70367a07a8a9e72a5a0bfeb5fc42e75c9db75b96da6053ad)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(1500,\n",
       " {'sentence1': 'A man with a hard hat is dancing.',\n",
       "  'sentence2': 'A man wearing a hard hat is dancing.',\n",
       "  'label': 5.0,\n",
       "  'idx': 0})"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sts = datasets.load_dataset(\"glue\", \"stsb\", split=\"validation\")\n",
    "len(sts), sts[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "id": "hskIzKNsR9IU"
   },
   "outputs": [],
   "source": [
    "sentence1s = [data[\"sentence1\"] for data in sts]\n",
    "sentence2s = [data[\"sentence2\"] for data in sts]\n",
    "normalized_labels = [data[\"label\"] / 5 for data in sts]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "id": "rkjz8EzhR-6i"
   },
   "outputs": [],
   "source": [
    "def cos_sim_in_batches(\n",
    "    batch_size: int, s1_texts: list[str], s2_texts: list[str],\n",
    "    tokenizer: BertTokenizerFast, model: BertModel,\n",
    "    cos_sim_f: Callable[[torch.tensor, torch.tensor], torch.tensor]\n",
    ") -> torch.tensor:\n",
    "\n",
    "    cos_sims = None\n",
    "    n_batches = len(s1_texts) // batch_size + int(len(s1_texts) % batch_size != 0)\n",
    "    for i in range(n_batches):\n",
    "        s1_batch = s1_texts[i*batch_size: (i+1)*batch_size]\n",
    "        s2_batch = s2_texts[i*batch_size: (i+1)*batch_size]\n",
    "        if i == 0:\n",
    "            cos_sims = cos_sim_f(encode(s1_batch, tokenizer, model, \"cuda\").detach(),\n",
    "                                 encode(s2_batch, tokenizer, model, \"cuda\").detach())\n",
    "        else:\n",
    "            _cos_sims = cos_sim_f(encode(s1_batch, tokenizer, model, \"cuda\").detach(),\n",
    "                                  encode(s2_batch, tokenizer, model, \"cuda\").detach())\n",
    "            cos_sims = torch.cat([cos_sims, _cos_sims])\n",
    "    \n",
    "    return cos_sims"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "id": "TIthKdWeSANc"
   },
   "outputs": [],
   "source": [
    "cos_sim_f = torch.nn.CosineSimilarity()\n",
    "sbert_cos_sims = cos_sim_in_batches(16, sentence1s, sentence2s, tokenizer, sbert_model, cos_sim_f)\n",
    "bert_cos_sims = cos_sim_in_batches(16, sentence1s, sentence2s, tokenizer, bert_model, cos_sim_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hyGchXbWSEfw",
    "outputId": "b369a61a-4058-41ef-d605-96abcdc6aa0d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SpearmanrResult(correlation=0.7535440057938854, pvalue=3.49275227046797e-275)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.spearmanr(sbert_cos_sims.cpu().detach().numpy(), np.array(normalized_labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "BYs9Dfn-SF2y",
    "outputId": "e943deed-95f3-44a2-bae3-cb6cd875268a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SpearmanrResult(correlation=0.5931769556210932, pvalue=3.0261969816970313e-143)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stats.spearmanr(bert_cos_sims.cpu().detach().numpy(), np.array(normalized_labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The authors report spearman rank correlation of `76.25` with `princeton-nlp/unsup-simcse-bert-base-uncased` model. We came pretty close with very little amount of training.\n",
    "\n",
    "SimCSE works great with little training but it does not do well when used in the `adaptive pre-training` setting.\n",
    "\n",
    "What is `adaptive pre-training` ?<br>\n",
    "What we typically expect is to finetune a model on some labeled data(MS MARCO) and adapt it to our domain using unsupervised target domain training. This does not work out well in practice (https://arxiv.org/pdf/2104.06979, https://arxiv.org/pdf/2112.07577). What works is doing a pre-training on the target domain and then finetune the model on some labeled dataset(MS MARCO).\n",
    "\n",
    "| ![](assets/pre_training.png) | \n",
    "|:--:| \n",
    "| Fig. 2. Results from adaptive pre-training. (Image source: https://www.youtube.com/watch?v=xbdLowiQTlk&t=1575s) |\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "## References\n",
    "\n",
    "[1] Tianyu Gao, Xingcheng Yao and Danqi Chen. \"[SimCSE: Simple Contrastive Learning of Sentence Embeddings](https://arxiv.org/abs/2104.08821)\"\n",
    "\n",
    "[2] https://github.com/princeton-nlp/SimCSE\n",
    "\n",
    "[3] https://github.com/UKPLab/sentence-transformers"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "simCSE.ipynb",
   "provenance": []
  },
  "gpuClass": "standard",
  "kernelspec": {
   "display_name": "Python 3",
   "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"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "41b3b3572cde4a9c968a1402fbe9877d": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "4f6674089fcc485490fe213f48a6f665": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "7738ebbfdb38453c8fa0ae98bf454a15": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "DescriptionStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "DescriptionStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "description_width": ""
     }
    },
    "79237276f0cb4ad09ab571145f2c7608": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "96867ec8368342a0ab95d30e41ac441d": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "FloatProgressModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "FloatProgressModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "ProgressView",
      "bar_style": "success",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_79237276f0cb4ad09ab571145f2c7608",
      "max": 551,
      "min": 0,
      "orientation": "horizontal",
      "style": "IPY_MODEL_9a8df0d7a028403db52d35accf0ab5db",
      "value": 551
     }
    },
    "9a8df0d7a028403db52d35accf0ab5db": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "ProgressStyleModel",
     "state": {
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "ProgressStyleModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "StyleView",
      "bar_color": null,
      "description_width": ""
     }
    },
    "a013ec76da6f495d8ffafc336b106be3": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    },
    "a7ea7fdf88ff455ba4b0567b843c9dbe": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HBoxModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HBoxModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HBoxView",
      "box_style": "",
      "children": [
       "IPY_MODEL_f1adb1e4b7e348c3a74485ef33523ab0",
       "IPY_MODEL_96867ec8368342a0ab95d30e41ac441d",
       "IPY_MODEL_e7d20bf52192413b8da840a6c387fa8f"
      ],
      "layout": "IPY_MODEL_fefa967e2337439e80a4bd2a9f239fb9"
     }
    },
    "e7d20bf52192413b8da840a6c387fa8f": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_a013ec76da6f495d8ffafc336b106be3",
      "placeholder": "​",
      "style": "IPY_MODEL_7738ebbfdb38453c8fa0ae98bf454a15",
      "value": " 551/551 [00:03&lt;00:00, 134.99ba/s]"
     }
    },
    "f1adb1e4b7e348c3a74485ef33523ab0": {
     "model_module": "@jupyter-widgets/controls",
     "model_module_version": "1.5.0",
     "model_name": "HTMLModel",
     "state": {
      "_dom_classes": [],
      "_model_module": "@jupyter-widgets/controls",
      "_model_module_version": "1.5.0",
      "_model_name": "HTMLModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/controls",
      "_view_module_version": "1.5.0",
      "_view_name": "HTMLView",
      "description": "",
      "description_tooltip": null,
      "layout": "IPY_MODEL_41b3b3572cde4a9c968a1402fbe9877d",
      "placeholder": "​",
      "style": "IPY_MODEL_4f6674089fcc485490fe213f48a6f665",
      "value": "100%"
     }
    },
    "fefa967e2337439e80a4bd2a9f239fb9": {
     "model_module": "@jupyter-widgets/base",
     "model_module_version": "1.2.0",
     "model_name": "LayoutModel",
     "state": {
      "_model_module": "@jupyter-widgets/base",
      "_model_module_version": "1.2.0",
      "_model_name": "LayoutModel",
      "_view_count": null,
      "_view_module": "@jupyter-widgets/base",
      "_view_module_version": "1.2.0",
      "_view_name": "LayoutView",
      "align_content": null,
      "align_items": null,
      "align_self": null,
      "border": null,
      "bottom": null,
      "display": null,
      "flex": null,
      "flex_flow": null,
      "grid_area": null,
      "grid_auto_columns": null,
      "grid_auto_flow": null,
      "grid_auto_rows": null,
      "grid_column": null,
      "grid_gap": null,
      "grid_row": null,
      "grid_template_areas": null,
      "grid_template_columns": null,
      "grid_template_rows": null,
      "height": null,
      "justify_content": null,
      "justify_items": null,
      "left": null,
      "margin": null,
      "max_height": null,
      "max_width": null,
      "min_height": null,
      "min_width": null,
      "object_fit": null,
      "object_position": null,
      "order": null,
      "overflow": null,
      "overflow_x": null,
      "overflow_y": null,
      "padding": null,
      "right": null,
      "top": null,
      "visibility": null,
      "width": null
     }
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}