c2c_search_eval.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Dict\n",
    "import torch\n",
    "from src import datasets_loader\n",
    "from src.utils import retrieval_eval, pool_and_normalize\n",
    "from src.constants import GFG_DATA_PATH\n",
    "from transformers import AutoModel, AutoTokenizer\n",
    "from src.datasets_loader import prepare_tokenizer\n",
    "from src.preprocessing_utils import truncate_sentences\n",
    "from abc import ABC, abstractmethod\n",
    "from matplotlib import pyplot as plt\n",
    "import matplotlib.colors as mcolors\n",
    "import numpy as np\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "DEVICE = \"cuda:0\"\n",
    "\n",
    "EVAL_CONFIGS =[\n",
    "    {\"model_path\": \"starencoder\", \"maximum_raw_length\": 10000, \"maximum_input_length\": 1024, \"device\": DEVICE},\n",
    "    {\"model_path\": \"codebert\", \"maximum_raw_length\": 10000, \"maximum_input_length\": 512, \"device\": DEVICE}\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_device(inputs: Dict[str, torch.Tensor], device: str) -> Dict[str, torch.Tensor]:\n",
    "    output_data = {}\n",
    "    for k, v in inputs.items():\n",
    "        output_data[k] = v.to(device)\n",
    "\n",
    "    return output_data\n",
    "\n",
    "\n",
    "def get_dataset(maximum_raw_length):\n",
    "    test_data = datasets_loader.get_dataset(  # Geeks4Geeks data\n",
    "        dataset_name=\"gfg\",\n",
    "        path_to_cache=GFG_DATA_PATH,\n",
    "        split=\"test\",\n",
    "        maximum_raw_length=maximum_raw_length,\n",
    "    )\n",
    "\n",
    "    return test_data\n",
    "\n",
    "\n",
    "class BaseEncoder(torch.nn.Module, ABC):\n",
    "    def __init__(self, device, max_input_len, maximum_token_len, model_name):\n",
    "        super().__init__()\n",
    "\n",
    "        self.model_name = model_name\n",
    "        self.tokenizer = prepare_tokenizer(model_name)\n",
    "        self.encoder = (\n",
    "            AutoModel.from_pretrained(model_name, use_auth_token=True).to(DEVICE).eval()\n",
    "        )\n",
    "        self.device = device\n",
    "        self.max_input_len = max_input_len\n",
    "        self.maximum_token_len = maximum_token_len\n",
    "\n",
    "    @abstractmethod\n",
    "    def forward(\n",
    "        self,\n",
    "    ):\n",
    "        pass\n",
    "\n",
    "    def encode(self, input_sentences, batch_size=32, **kwargs):\n",
    "        truncated_input_sentences = truncate_sentences(\n",
    "            input_sentences, self.max_input_len\n",
    "        )\n",
    "\n",
    "        n_batches = len(truncated_input_sentences) // batch_size + int(\n",
    "            len(truncated_input_sentences) % batch_size > 0\n",
    "        )\n",
    "\n",
    "        embedding_batch_list = []\n",
    "\n",
    "        for i in range(n_batches):\n",
    "            start_idx = i * batch_size\n",
    "            end_idx = min((i + 1) * batch_size, len(truncated_input_sentences))\n",
    "\n",
    "            with torch.no_grad():\n",
    "                embedding_batch_list.append(\n",
    "                    self.forward(truncated_input_sentences[start_idx:end_idx])\n",
    "                    .detach()\n",
    "                    .cpu()\n",
    "                )\n",
    "\n",
    "        return torch.cat(embedding_batch_list)\n",
    "\n",
    "\n",
    "class StarEncoder(BaseEncoder):\n",
    "    def __init__(self, device, max_input_len, maximum_token_len):\n",
    "        super().__init__(\n",
    "            device,\n",
    "            max_input_len,\n",
    "            maximum_token_len,\n",
    "            model_name=\"bigcode/starencoder\",\n",
    "        )\n",
    "\n",
    "    def forward(self, input_sentences):\n",
    "        inputs = self.tokenizer(\n",
    "            [\n",
    "                f\"{self.tokenizer.cls_token}{sentence}{self.tokenizer.sep_token}\"\n",
    "                for sentence in input_sentences\n",
    "            ],\n",
    "            padding=\"longest\",\n",
    "            max_length=self.maximum_token_len,\n",
    "            truncation=True,\n",
    "            return_tensors=\"pt\",\n",
    "        )\n",
    "\n",
    "        outputs = self.encoder(**set_device(inputs, self.device))\n",
    "        embedding = pool_and_normalize(outputs.hidden_states[-1], inputs.attention_mask)\n",
    "\n",
    "        return embedding\n",
    "\n",
    "\n",
    "class CodeBERT(BaseEncoder):\n",
    "    def __init__(self, device, max_input_len, maximum_token_len):\n",
    "        super().__init__(\n",
    "            device,\n",
    "            max_input_len,\n",
    "            maximum_token_len,\n",
    "            model_name=\"microsoft/codebert-base\",\n",
    "        )\n",
    "\n",
    "        self.tokenizer = AutoTokenizer.from_pretrained(\"microsoft/codebert-base\")\n",
    "\n",
    "    def forward(self, input_sentences):\n",
    "        inputs = self.tokenizer(\n",
    "            [sentence for sentence in input_sentences],\n",
    "            padding=\"longest\",\n",
    "            max_length=self.maximum_token_len,\n",
    "            truncation=True,\n",
    "            return_tensors=\"pt\",\n",
    "        )\n",
    "\n",
    "        inputs = set_device(inputs, self.device)\n",
    "\n",
    "        outputs = self.encoder(inputs[\"input_ids\"], inputs[\"attention_mask\"])\n",
    "\n",
    "        embedding = outputs[\"pooler_output\"]\n",
    "\n",
    "        return torch.cat([torch.nn.functional.normalize(torch.Tensor(el)[None, :]) for el in embedding])\n",
    "\n",
    "\n",
    "def evaluate(model_path, maximum_raw_length, maximum_input_length, device):\n",
    "    if \"starencoder\" in model_path.lower():\n",
    "        model = StarEncoder(\n",
    "            device, maximum_raw_length, maximum_input_length\n",
    "        )\n",
    "    elif \"codebert\" in model_path.lower():\n",
    "        model = CodeBERT(\n",
    "            device, maximum_raw_length, maximum_input_length\n",
    "        )\n",
    "    else:\n",
    "        raise ValueError(\n",
    "            \"Unsupported model type. We currently support starencoder and codebert.\"\n",
    "        )\n",
    "\n",
    "    model = model.to(device)\n",
    "    model.eval()\n",
    "\n",
    "    test_data = get_dataset(maximum_raw_length)\n",
    "\n",
    "    source_entries, target_entries = [], []\n",
    "    for source, target in test_data:\n",
    "        source_entries.append(source)\n",
    "        target_entries.append(target)\n",
    "\n",
    "    source_embeddings = model.encode(source_entries)\n",
    "    target_embeddings = model.encode(target_entries)\n",
    "\n",
    "    recall_at_1, recall_at_5, mean_reciprocal_rank, similarities = retrieval_eval(\n",
    "        source_embeddings, target_embeddings, return_similarities=True\n",
    "    )\n",
    "\n",
    "    print(\n",
    "        f\"\\n{model_path}: R@1: {recall_at_1.item()}, R@5: {recall_at_5.item()}, MRR: {mean_reciprocal_rank.item()}\"\n",
    "        )\n",
    "    \n",
    "    return similarities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at bigcode/starencoder were not used when initializing BertModel: ['cls.seq_relationship.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.seq_relationship.weight', 'cls.predictions.decoder.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.transform.dense.weight', 'cls.predictions.decoder.bias', 'cls.predictions.bias']\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",
      "Loading cached shuffled indices for dataset at /mnt/home/bigcode-encoder/resources/data/transcoder_evaluation_gfg/cache-e9f62aa12abed28d.arrow\n",
      "Loading cached processed dataset at /mnt/home/bigcode-encoder/resources/data/transcoder_evaluation_gfg/cache-62c8dbaa90db85ee_*_of_00096.arrow\n",
      "Loading cached shuffled indices for dataset at /mnt/home/bigcode-encoder/resources/data/transcoder_evaluation_gfg/cache-f652c1e33d8c1a14.arrow\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "starencoder: R@1: 0.7222222089767456, R@5: 0.8784722089767456, MRR: 0.7927579879760742\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading cached shuffled indices for dataset at /mnt/home/bigcode-encoder/resources/data/transcoder_evaluation_gfg/cache-e9f62aa12abed28d.arrow\n",
      "Loading cached processed dataset at /mnt/home/bigcode-encoder/resources/data/transcoder_evaluation_gfg/cache-62c8dbaa90db85ee_*_of_00096.arrow\n",
      "Loading cached shuffled indices for dataset at /mnt/home/bigcode-encoder/resources/data/transcoder_evaluation_gfg/cache-f652c1e33d8c1a14.arrow\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "codebert: R@1: 0.2725694477558136, R@5: 0.4826388955116272, MRR: 0.3659176826477051\n"
     ]
    }
   ],
   "source": [
    "model_to_similarities = {}\n",
    "\n",
    "with torch.no_grad():\n",
    "    for eval_cfg in EVAL_CONFIGS:\n",
    "        similarities = evaluate(**eval_cfg)\n",
    "        model_to_similarities[eval_cfg[\"model_path\"]] = similarities.ravel().detach().cpu().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def summarize_sequence(sequence):\n",
    "    def ci95(seq):\n",
    "        return 1.96 * np.std(seq) / np.sqrt(len(seq))\n",
    "\n",
    "    return f\"{100*np.mean(sequence):.2f}+-{100*ci95(sequence):.2f}\"\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(6,6), facecolor=\"white\")\n",
    "\n",
    "ax.set_title(\"Python-Java cross-language similarities\")\n",
    "ax.get_xaxis().set_visible(False)\n",
    "ax.set_ylabel(\"Similarity Scores\")\n",
    "\n",
    "color_list = [k for k in mcolors.BASE_COLORS.keys()]\n",
    "\n",
    "for i, (k, v) in enumerate(model_to_similarities.items()):\n",
    "\n",
    "    score_ci = summarize_sequence(v)\n",
    "    center, error = score_ci.split(\"+-\")\n",
    "\n",
    "    try:\n",
    "        color = color_list[i]\n",
    "    except IndexError:\n",
    "        break\n",
    "\n",
    "    plt.plot(i+1, float(center), color=color, label=k)\n",
    "    plt.errorbar(i+1, float(center), yerr=float(error), fmt ='-o', color=color, capsize=8)\n",
    "\n",
    "\n",
    "plt.legend(loc=\"upper right\")\n",
    "plt.show()\n",
    "        "
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "ae635839a86c404533bb974203baf1bd26d9dc49bfbf145b45e9350c30045fdd"
  },
  "kernelspec": {
   "display_name": "Python 3.9.13 64-bit ('accelerate')",
   "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.10.9"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}