Semantic_Similarity/Semantic Similarity-base.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Semantic Textual Similarity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Model Named on My HuggingFace Profile: 'sentence-t5-base-FT-Quora_Sentence_Similarity-LG'\n",
    "\n",
    "\n",
    "Source for Dataset: https://www.kaggle.com/datasets/quora/question-pairs-dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exploratory Data Analysis (EDA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Import Necessary Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/leedunn/Documents/nlpnn/nlp/lib/python3.9/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import os, math, random, re, logging\n",
    "os.environ['TOKENIZERS_PARALLELISM']='false'\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n",
    "\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.utils.data import DataLoader, random_split\n",
    "\n",
    "from sentence_transformers import SentenceTransformer, models, util, losses, LoggingHandler, evaluation, InputExample\n",
    "from sentence_transformers.evaluation import EmbeddingSimilarityEvaluator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Versions of Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pandas:    1.4.4\n",
      "Torch:     1.12.1\n"
     ]
    }
   ],
   "source": [
    "print(\"Pandas:\".ljust(10), pd.__version__)\n",
    "print(\"Torch:\".ljust(10), torch.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ingesting Data into Pandas DataFrame & Preprocessing Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 404348 entries, 0 to 404350\n",
      "Data columns (total 5 columns):\n",
      " #   Column  Non-Null Count   Dtype \n",
      "---  ------  --------------   ----- \n",
      " 0   qid1    404348 non-null  int64 \n",
      " 1   qid2    404348 non-null  int64 \n",
      " 2   q1      404348 non-null  object\n",
      " 3   q2      404348 non-null  object\n",
      " 4   labels  404348 non-null  int64 \n",
      "dtypes: int64(3), object(2)\n",
      "memory usage: 18.5+ MB\n"
     ]
    }
   ],
   "source": [
    "cols2use = ['qid1', 'qid2', 'question1', 'question2', 'is_duplicate']\n",
    "col_types = {'qid1' : int, 'qid2' : int, 'question1' : str, 'question2' : str, 'is_duplicate' : int}\n",
    "\n",
    "data = pd.read_csv('~/Documents/nlpnn/Datasets/Semantic_Similarity/questions.csv', usecols=cols2use, dtype=col_types)\n",
    "data.rename(columns={'question1' : 'q1', 'question2' : 'q2', 'is_duplicate' : 'labels'}, inplace=True)\n",
    "\n",
    "data.dropna(inplace=True)\n",
    "data.drop_duplicates(inplace=True)\n",
    "\n",
    "data.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualization of Length of First Question (Sorted by Result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data['q1_len'] = data['q1'].str.split().apply(len)\n",
    "\n",
    "data.boxplot(\"q1_len\", by=\"labels\", grid=False, showfliers=False, color=\"Blue\")\n",
    "plt.suptitle('')\n",
    "plt.title('Question 1 Length')\n",
    "plt.xlabel('Result Type')\n",
    "plt.ylabel('Length (in Words)')\n",
    "plt.show()\n",
    "\n",
    "data.drop(columns=['q1_len'], inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualization of Length of Second Question (Sorted by Result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data['q2_len'] = data['q2'].str.split().apply(len)\n",
    "\n",
    "data.boxplot(\"q2_len\", by=\"labels\", grid=False, showfliers=False, color=\"Blue\")\n",
    "plt.suptitle('')\n",
    "plt.title('Question 2 Length')\n",
    "plt.xlabel('Result Type')\n",
    "plt.ylabel('Length (in Words)')\n",
    "plt.show()\n",
    "\n",
    "data.drop(columns=['q2_len'], inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Limit Size of Dataset \n",
    "\n",
    "* Remove values that are too small or too large"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total samples: 373815\n",
      "0    227614\n",
      "1    146201\n",
      "Name: labels, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "data = data[data['q1'].str.split().apply(len) < 24]\n",
    "\n",
    "data = data[data['q2'].str.split().apply(len) < 24]\n",
    "\n",
    "print(\"Total samples:\", data['labels'].shape[0])\n",
    "print(data['labels'].value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Start of the Actual Project"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train/Test/Valid Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Data Shape: (299052, 5)\n",
      "Testing Data Shape: (37381, 5)\n",
      "Validation Data Shape: (37382, 5)\n"
     ]
    }
   ],
   "source": [
    "train_ds, testvalid = train_test_split(data, test_size=0.20, random_state=42)\n",
    "test_ds, valid_ds = train_test_split(testvalid, test_size=0.50, random_state=42)\n",
    "\n",
    "print(f\"Training Data Shape: {train_ds.shape}\")\n",
    "print(f\"Testing Data Shape: {test_ds.shape}\")\n",
    "print(f\"Validation Data Shape: {valid_ds.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Instantiate Logging Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "logging.basicConfig(format='%(asctime)s - %(message)s',\n",
    "                    datefmt='%Y-%m-%d %H:%M:%S',\n",
    "                    level=logging.INFO,\n",
    "                    handlers=[LoggingHandler()])\n",
    "logger = logging.getLogger(__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Encode Dataset & Instantiate the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-09-17 12:46:07 - Load pretrained SentenceTransformer: sentence-transformers/sentence-t5-base\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Batches: 100%|██████████| 1/1 [00:00<00:00, 10.15it/s]\n"
     ]
    }
   ],
   "source": [
    "model_ckpt = \"sentence-transformers/sentence-t5-base\"\n",
    "device=\"cpu\"\n",
    "\n",
    "model = SentenceTransformer(model_ckpt, device=device)\n",
    "model.max_seq_length = 34\n",
    "\n",
    "embeddings = model.encode(['q1', 'q2'], show_progress_bar=True)\n",
    "\n",
    "distance_metric = losses.SiameseDistanceMetric.COSINE_DISTANCE\n",
    "\n",
    "margin = 0.50\n",
    "\n",
    "num_of_epochs = 1\n",
    "\n",
    "training_batch_size = 64\n",
    "testing_batch_size = 16\n",
    "\n",
    "model_save_path = f\"{model_ckpt.split('/')[-1]}-FT-Quora_Sentence_Similarity-LG\"\n",
    "\n",
    "dataset_path = '/Users/briandunn/Documents/nlpnn/nlp_ch4/bin/sentence-t5-base-FT-Quora_Sentence_Similarity-LG/'\n",
    "os.makedirs(model_save_path, exist_ok=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Assign Training Samples to DataLoader (InputExample)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_samples = []\n",
    "\n",
    "for index, row in train_ds.iterrows():\n",
    "    sample = InputExample(texts=[row['q1'], row['q2']], label=int(row['labels']))\n",
    "    train_samples.append(sample)\n",
    "\n",
    "train_dataloader = DataLoader(train_samples, shuffle=True, batch_size=training_batch_size)\n",
    "train_loss = losses.OnlineContrastiveLoss(model=model, distance_metric=distance_metric, margin=margin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set Up Validation Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "dev_sentences1 = []\n",
    "dev_sentences2 = []\n",
    "dev_labels = []\n",
    "\n",
    "for index, row in valid_ds.iterrows(): \n",
    "    dev_sentences1.append(row['q1'])\n",
    "    dev_sentences2.append(row['q2'])\n",
    "    dev_labels.append(row['labels'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Create Function to Compute Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "binary_acc_evaluator = evaluation.BinaryClassificationEvaluator(dev_sentences1, \n",
    "                                                                dev_sentences2, \n",
    "                                                                dev_labels, \n",
    "                                                                show_progress_bar=True, \n",
    "                                                                batch_size=testing_batch_size,\n",
    "                                                                name=\"Quora_Sentence_Similarity_Metrics-LG\",\n",
    "                                                                write_csv=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration: 100%|██████████| 4673/4673 [56:17:12<00:00, 43.36s/it]\n",
      "Epoch:   0%|          | 0/1 [56:17:12<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-09-19 21:03:46 - Binary Accuracy Evaluation of the model on Quora_Sentence_Similarity_Metrics-LG dataset after epoch 0:\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Batches: 100%|██████████| 4214/4214 [1:00:09<00:00,  1.17it/s]\n",
      "Epoch:   0%|          | 0/1 [57:17:29<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-09-19 22:04:02 - Accuracy with Cosine-Similarity:           85.93\t(Threshold: 0.8320)\n",
      "2022-09-19 22:04:02 - F1 with Cosine-Similarity:                 82.89\t(Threshold: 0.8178)\n",
      "2022-09-19 22:04:02 - Precision with Cosine-Similarity:          77.43\n",
      "2022-09-19 22:04:02 - Recall with Cosine-Similarity:             89.18\n",
      "2022-09-19 22:04:02 - Average Precision with Cosine-Similarity:  87.13\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch:   0%|          | 0/1 [57:17:29<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-09-19 22:04:03 - Accuracy with Manhattan-Distance:           85.95\t(Threshold: 12.7721)\n",
      "2022-09-19 22:04:03 - F1 with Manhattan-Distance:                 82.89\t(Threshold: 13.5008)\n",
      "2022-09-19 22:04:03 - Precision with Manhattan-Distance:          76.91\n",
      "2022-09-19 22:04:03 - Recall with Manhattan-Distance:             89.89\n",
      "2022-09-19 22:04:03 - Average Precision with Manhattan-Distance:  87.13\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch:   0%|          | 0/1 [57:17:29<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-09-19 22:04:03 - Accuracy with Euclidean-Distance:           85.93\t(Threshold: 0.5797)\n",
      "2022-09-19 22:04:03 - F1 with Euclidean-Distance:                 82.89\t(Threshold: 0.6037)\n",
      "2022-09-19 22:04:03 - Precision with Euclidean-Distance:          77.43\n",
      "2022-09-19 22:04:03 - Recall with Euclidean-Distance:             89.18\n",
      "2022-09-19 22:04:03 - Average Precision with Euclidean-Distance:  87.13\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch:   0%|          | 0/1 [57:17:30<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-09-19 22:04:03 - Accuracy with Dot-Product:           85.93\t(Threshold: 0.8320)\n",
      "2022-09-19 22:04:03 - F1 with Dot-Product:                 82.89\t(Threshold: 0.8178)\n",
      "2022-09-19 22:04:03 - Precision with Dot-Product:          77.43\n",
      "2022-09-19 22:04:03 - Recall with Dot-Product:             89.18\n",
      "2022-09-19 22:04:03 - Average Precision with Dot-Product:  87.14\n",
      "\n",
      "2022-09-19 22:04:03 - Save model to sentence-t5-base-FT-Quora_Sentence_Similarity-LG\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch: 100%|██████████| 1/1 [57:17:31<00:00, 206251.34s/it]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-09-19 22:04:04 - Save model to checkpoints_LG/4673\n"
     ]
    }
   ],
   "source": [
    "model.fit(train_objectives=[(train_dataloader, train_loss)],  \n",
    "          evaluator = binary_acc_evaluator, \n",
    "          epochs=num_of_epochs, \n",
    "          warmup_steps=2,\n",
    "          output_path=model_save_path, \n",
    "          show_progress_bar=True,\n",
    "          checkpoint_path='checkpoints_LG/', \n",
    "          checkpoint_save_steps=5000,\n",
    "          checkpoint_save_total_limit=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Saving Model to HuggingFace Hub (My Profile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/leedunn/Documents/nlpnn/nlp/lib/python3.9/site-packages/huggingface_hub/utils/_deprecation.py:38: FutureWarning: Deprecated positional argument(s) used in 'create_repo': pass token='sentence-t5-base-FT-Quora_Sentence_Similarity-LG' as keyword args. From version 0.12 passing these as positional arguments will result in an error,\n",
      "  warnings.warn(\n",
      "/Users/leedunn/Documents/nlpnn/nlp/lib/python3.9/site-packages/huggingface_hub/hf_api.py:681: FutureWarning: `create_repo` now takes `token` as an optional positional argument. Be sure to adapt your code!\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-09-19 22:04:07 - Create repository and clone it if it exists\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Cloning https://huggingface.co/DunnBC22/sentence-t5-base-FT-Quora_Sentence_Similarity-LG into local empty directory.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-09-19 22:04:08 - Cloning https://huggingface.co/DunnBC22/sentence-t5-base-FT-Quora_Sentence_Similarity-LG into local empty directory.\n",
      "2022-09-19 22:04:11 - Save model to /var/folders/vb/6w_1xfss7_zgtx5g93jlj0z80000gn/T/tmpu4y40r3g\n",
      "2022-09-19 22:04:12 - Track files with git lfs: pytorch_model.bin\n",
      "2022-09-19 22:04:12 - Push model to the hub. This might take a while\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Upload file pytorch_model.bin:   0%|          | 32.0k/418M [00:00<?, ?B/s]\n",
      "\u001b[A\n",
      "Upload file pytorch_model.bin:   0%|          | 960k/418M [00:01<08:01, 909kB/s]\n",
      "Upload file pytorch_model.bin:   1%|          | 2.69M/418M [00:03<07:54, 918kB/s]\n",
      "Upload file pytorch_model.bin:   1%|          | 3.53M/418M [00:04<08:06, 895kB/s]\n",
      "Upload file pytorch_model.bin:   6%|▌         | 24.8M/418M [00:22<05:02, 1.36MB/s]\n",
      "Upload file pytorch_model.bin: 100%|█████████▉| 418M/418M [05:32<00:00, 1.42MB/s] remote: Scanning LFS files for validity, may be slow...        \n",
      "remote: LFS file scan complete.        \n",
      "To https://huggingface.co/DunnBC22/sentence-t5-base-FT-Quora_Sentence_Similarity-LG\n",
      "   1fb0f90..6dcef6e  main -> main\n",
      "\n",
      "                                                                                 \n",
      "\n",
      "\u001b[A\u001b[A                                                                     \n",
      "Upload file pytorch_model.bin: 100%|██████████| 418M/418M [05:34<00:00, 1.42MB/s]         \n",
      "\u001b[A"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-09-19 22:09:55 - remote: Scanning LFS files for validity, may be slow...        \n",
      "remote: LFS file scan complete.        \n",
      "To https://huggingface.co/DunnBC22/sentence-t5-base-FT-Quora_Sentence_Similarity-LG\n",
      "   1fb0f90..6dcef6e  main -> main\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Upload file pytorch_model.bin: 100%|██████████| 418M/418M [05:35<00:00, 1.31MB/s]\n",
      "Upload file 2_Dense/pytorch_model.bin: 100%|██████████| 2.25M/2.25M [05:35<00:00, 6.93kB/s]\n",
      "\n",
      "\u001b[A\n",
      "Upload file spiece.model: 100%|██████████| 773k/773k [05:35<00:00, 2.26kB/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'https://huggingface.co/DunnBC22/sentence-t5-base-FT-Quora_Sentence_Similarity-LG/commit/6dcef6e0ef8a61b92030514c3dbce5b9f84fb9e3'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.save_to_hub(repo_name=model_save_path, commit_message='All Dunn!')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  },
  "vscode": {
   "interpreter": {
    "hash": "41bc52750e0704433c7c40a5c68d8f60e760babe95f2dffc82e8c3790208ff57"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}