dataset_masker.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path = './Wiki-Hades/train.txt'\n",
    "import json\n",
    "# parse the json data into a list of dictionaries\n",
    "data = []\n",
    "with open(data_path, 'r') as f:\n",
    "    for line in f:\n",
    "        data.append(json.loads(line))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "masked_data = []\n",
    "for datapoint in data:\n",
    "    replaced_sent = datapoint['replaced']\n",
    "    lower_id = datapoint['replaced_ids'][0]\n",
    "    upper_id = datapoint['replaced_ids'][1]\n",
    "    replaced_sent = replaced_sent.split()\n",
    "    for i in range(lower_id, upper_id+1):\n",
    "        replaced_sent[i] = '[MASK]'\n",
    "    masked_sent = ' '.join(replaced_sent)\n",
    "    masked_data.append({'sentence': masked_sent, 'label': datapoint['hallucination'], 'replaced_ids': datapoint['replaced_ids']})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertForMaskedLM: ['bert.pooler.dense.bias', 'bert.pooler.dense.weight', 'cls.seq_relationship.bias', 'cls.seq_relationship.weight']\n",
      "- This IS expected if you are initializing BertForMaskedLM 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 BertForMaskedLM from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
     ]
    }
   ],
   "source": [
    "# # load a bertformaskedlm model\n",
    "# from transformers import BertForMaskedLM, AutoTokenizer\n",
    "# import torch\n",
    "# model = BertForMaskedLM.from_pretrained('bert-base-uncased').to('cuda')\n",
    "# tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "100\n",
      "200\n",
      "300\n",
      "400\n",
      "500\n",
      "600\n",
      "700\n",
      "800\n",
      "900\n",
      "1000\n",
      "1100\n",
      "1200\n",
      "1300\n",
      "1400\n",
      "1500\n",
      "1600\n",
      "1700\n",
      "1800\n",
      "1900\n",
      "2000\n",
      "2100\n",
      "2200\n",
      "2300\n",
      "2400\n",
      "2500\n",
      "2600\n",
      "2700\n",
      "2800\n",
      "2900\n",
      "3000\n",
      "3100\n",
      "3200\n",
      "3300\n",
      "3400\n",
      "3500\n",
      "3600\n",
      "3700\n",
      "3800\n",
      "3900\n",
      "4000\n",
      "4100\n",
      "4200\n",
      "4300\n",
      "4400\n",
      "4500\n",
      "4600\n",
      "4700\n",
      "4800\n",
      "4900\n",
      "5000\n",
      "5100\n",
      "5200\n",
      "5300\n",
      "5400\n",
      "5500\n",
      "5600\n",
      "5700\n",
      "5800\n",
      "5900\n",
      "6000\n",
      "6100\n",
      "6200\n",
      "6300\n",
      "6400\n",
      "6500\n",
      "6600\n",
      "6700\n",
      "6800\n",
      "6900\n",
      "7000\n",
      "7100\n",
      "7200\n",
      "7300\n",
      "7400\n",
      "7500\n",
      "7600\n",
      "7700\n",
      "7800\n",
      "7900\n",
      "8000\n",
      "8100\n",
      "8200\n",
      "8300\n",
      "8400\n",
      "8500\n",
      "8600\n",
      "8700\n"
     ]
    }
   ],
   "source": [
    "# # for each sentence in the masked data, predict the top 20 words that could fill in the mask`sa`\n",
    "\n",
    "# labeled_multisample_data = []\n",
    "# counter = 0\n",
    "# for datapoint in masked_data:\n",
    "#     input_ids = tokenizer.encode(datapoint['sentence'], return_tensors='pt').to('cuda')\n",
    "#     mask_id = torch.where(input_ids == tokenizer.mask_token_id)[1].to('cuda')\n",
    "#     predictions = model(input_ids)[0][:,mask_id,:].topk(10).indices.tolist()[0]\n",
    "#     sentences = []\n",
    "#     for i in range(10):\n",
    "#         sentence = datapoint['sentence'].split()\n",
    "#         for j in range(len(predictions)):\n",
    "#             sentence[datapoint['replaced_ids'][0] + j] = tokenizer.decode(predictions[j][i])\n",
    "#         sentences.append(' '.join(sentence))\n",
    "#     labeled_multisample_data.append({'original':datapoint['sentence'], 'replaced_ids': datapoint['replaced_ids'],'sentences' : sentences, 'label': datapoint['label']})\n",
    "\n",
    "#     if counter % 100 == 0:\n",
    "#         print(counter)\n",
    "#     counter += 1\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "100\n",
      "200\n",
      "300\n",
      "400\n",
      "500\n",
      "600\n",
      "700\n",
      "800\n",
      "900\n",
      "1000\n",
      "1100\n",
      "1200\n",
      "1300\n",
      "1400\n",
      "1500\n",
      "1600\n",
      "1700\n",
      "1800\n",
      "1900\n",
      "2000\n",
      "2100\n",
      "2200\n",
      "2300\n",
      "2400\n",
      "2500\n",
      "2600\n",
      "2700\n",
      "2800\n",
      "2900\n",
      "3000\n",
      "3100\n",
      "3200\n",
      "3300\n",
      "3400\n",
      "3500\n",
      "3600\n",
      "3700\n",
      "3800\n",
      "3900\n",
      "4000\n",
      "4100\n",
      "4200\n",
      "4300\n",
      "4400\n",
      "4500\n",
      "4600\n",
      "4700\n",
      "4800\n",
      "4900\n",
      "5000\n",
      "5100\n",
      "5200\n",
      "5300\n",
      "5400\n",
      "5500\n",
      "5600\n",
      "5700\n",
      "5800\n",
      "5900\n",
      "6000\n",
      "6100\n",
      "6200\n",
      "6300\n",
      "6400\n",
      "6500\n",
      "6600\n",
      "6700\n",
      "6800\n",
      "6900\n",
      "7000\n",
      "7100\n",
      "7200\n",
      "7300\n",
      "7400\n",
      "7500\n",
      "7600\n",
      "7700\n",
      "7800\n",
      "7900\n",
      "8000\n",
      "8100\n",
      "8200\n",
      "8300\n",
      "8400\n",
      "8500\n",
      "8600\n",
      "8700\n"
     ]
    }
   ],
   "source": [
    "# # for each sentence in the masked data, predict the top 20 words that could fill in the mask`sa`\n",
    "\n",
    "# labeled_multisample_data2 = []\n",
    "# counter = 0\n",
    "# for datapoint in masked_data:\n",
    "#     input_ids = tokenizer.encode(datapoint['sentence'], return_tensors='pt').to('cuda')\n",
    "#     mask_id = torch.where(input_ids == tokenizer.mask_token_id)[1].to('cuda')\n",
    "#     predictions = model(input_ids)[0][:,mask_id,:].topk(20).indices.tolist()[0]\n",
    "#     sentences = []\n",
    "#     for i in range(10):\n",
    "#         sentence = datapoint['sentence'].split()\n",
    "#         for j in range(len(predictions)):\n",
    "#             sentence[datapoint['replaced_ids'][0] + j] = tokenizer.decode(predictions[j][i])\n",
    "#         sentences.append(' '.join(sentence))\n",
    "#     labeled_multisample_data2.append({'original':datapoint['sentence'], 'replaced_ids': datapoint['replaced_ids'],'sentences' : sentences, 'label': datapoint['label']})\n",
    "\n",
    "#     if counter % 100 == 0:\n",
    "#         print(counter)\n",
    "#     counter += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "with open('hades_aug_10_samples.pkl', 'rb') as f:\n",
    "    labeled_multisample_data = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of RobertaModel were not initialized from the model checkpoint at FacebookAI/roberta-base and are newly initialized: ['roberta.pooler.dense.weight', 'roberta.pooler.dense.bias']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
     ]
    }
   ],
   "source": [
    "from transformers import RobertaModel, RobertaTokenizer, AutoTokenizer\n",
    "import numpy as np\n",
    "embedding_model = RobertaModel.from_pretrained(\"FacebookAI/roberta-base\").to('cuda:2')\n",
    "embedding_tokenizer = AutoTokenizer.from_pretrained(\"FacebookAI/roberta-base\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def top_k_variances(sentences , k=10, model=embedding_model, tokenizer=embedding_tokenizer):\n",
    "    embeddings = []\n",
    "    for sentence in sentences:\n",
    "        tokens = ['[CLS]'] + tokenizer.tokenize(sentence) + ['[SEP]']\n",
    "        if 50 > len(tokens):\n",
    "            tokens = tokens + ['[PAD]'] * (50 - len(tokens))\n",
    "        else:\n",
    "            tokens = tokens[:200]\n",
    "        attention_mask = [1 if i != '[PAD]' else 0 for i in tokens]\n",
    "        \n",
    "        token_ids = tokenizer.convert_tokens_to_ids(tokens)\n",
    "        token_ids = torch.tensor(token_ids).unsqueeze(0)\n",
    "        attention_mask = torch.tensor(attention_mask).unsqueeze(0)\n",
    "        with torch.no_grad():\n",
    "            output = model(token_ids.to(\"cuda:2\"), attention_mask=attention_mask.to(\"cuda:2\"))\n",
    "        final_reps = output.last_hidden_state.detach().cpu()\n",
    "        cls_rep = final_reps[0][0].unsqueeze(0)\n",
    "        \n",
    "        with torch.no_grad():\n",
    "            embeddings.append(cls_rep)\n",
    "    \n",
    "    embeddings = np.array(embeddings, dtype=np.float32)\n",
    "    topk = np.var(embeddings, axis=0).squeeze()\n",
    "    topk = np.sort(topk)[-k:]\n",
    "    return topk[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# utils.py from HADES\n",
    "from torch import nn\n",
    "import torch\n",
    "from torch.nn import functional as F\n",
    "import codecs\n",
    "import json\n",
    "import spacy\n",
    "from sklearn.metrics import classification_report, accuracy_score, hamming_loss, \\\n",
    "    f1_score, precision_score, recall_score, average_precision_score, roc_auc_score, confusion_matrix, \\\n",
    "    brier_score_loss\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "def binary_eval(predy, testy, verbose=True, return_f1=False, predscore=None):\n",
    "    acc = accuracy_score(testy, predy)\n",
    "    f1 = f1_score(testy, predy, average=None)\n",
    "    precision = precision_score(testy, predy, average=None)\n",
    "    recall = recall_score(testy, predy, average=None)\n",
    "    epsilon = 1e-8\n",
    "\n",
    "    htn, hfp, hfn, htp = confusion_matrix(testy, predy).ravel()\n",
    "    hsensi = htp / (htp + hfn + epsilon)\n",
    "    hspec = htn / (hfp + htn + epsilon)\n",
    "    gmean = np.sqrt(hsensi*hspec)\n",
    "\n",
    "\n",
    "    info = \"Acc : {}\\nf1 : {}\\nprecision : {}\\nrecall : {}\\nG-mean : {}\".format(acc,\n",
    "            \" \".join([str(x) for x in f1]), \" \".join([str(x) for x in precision]),\n",
    "            \" \".join([str(x) for x in recall]), gmean)\n",
    "\n",
    "    if predscore is not None:\n",
    "        bss = brier_score_loss(testy, predscore)\n",
    "        roc_auc = roc_auc_score(testy, predscore)\n",
    "        info += \"\\nbss : {}\\nROC-AUC : {}\".format(bss, roc_auc)\n",
    "\n",
    "    if verbose:\n",
    "        print(info)\n",
    "\n",
    "    if return_f1:\n",
    "        return acc, f1, precision, recall, gmean, bss, roc_auc, info\n",
    "    else:\n",
    "        return acc, info\n",
    "\n",
    "\n",
    "def subsets(nums):\n",
    "    \"\"\"\n",
    "    :type nums: List[int]\n",
    "    :rtype: List[List[int]]\n",
    "    \"\"\"\n",
    "    ans = []\n",
    "    def dfs(curpos, tmp):\n",
    "        if tmp:\n",
    "            ans.append(tmp[:])\n",
    "        for i in range(curpos, len(nums)):\n",
    "            tmp.append(nums[i])\n",
    "            dfs(i+1, tmp)\n",
    "            tmp.pop(-1)\n",
    "    dfs(0, [])\n",
    "    return ans\n",
    "\n",
    "\n",
    "def sent_ner_bounds(sen, nlp=None):\n",
    "    if nlp is None:\n",
    "        nlp = spacy.load('en')\n",
    "    tokens, tags = [], []\n",
    "    print(sen)\n",
    "    for doc in nlp.pipe([sen]):\n",
    "        for token in doc:\n",
    "            tags.append(token.ent_iob_)\n",
    "            tokens.append(str(token))\n",
    "\n",
    "    rep_pos = []\n",
    "    vis = [False for _ in range(len(tags))]\n",
    "    for idx, tag in enumerate(tags):\n",
    "        if tag == 'O':\n",
    "            rep_pos.append([idx, idx])\n",
    "            vis[idx] = True\n",
    "        elif tag == 'B':\n",
    "            end = idx\n",
    "            for j in range(idx+1, len(tags)):\n",
    "                if tags[j] == 'I':\n",
    "                    end = j\n",
    "                else:\n",
    "                    break\n",
    "            rep_pos.append([idx, end])\n",
    "        elif tag == 'I':\n",
    "            continue\n",
    "\n",
    "    return ' '.join(tokens), rep_pos\n",
    "\n",
    "\n",
    "def remove_marked_sen(sen, start_id, end_id):\n",
    "    tokens = sen if type(sen) == list else sen.strip().split()\n",
    "    if tokens[start_id].startswith(\"===\") and tokens[end_id].endswith(\"===\"):\n",
    "        tokens[start_id] = tokens[start_id][3:]\n",
    "        tokens[end_id] = tokens[end_id][:-3]\n",
    "    return tokens\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\ntrainpath=\"../data_collections/wiki5k+sequential+topk_10+temp_1+context_1+rep_0.6+sample_1.annotate.finish\"\\n# trainpath=\"../data_collections/wiki5k+sequential+topk_10+temp_1+context_1+rep_0.6+sample_1.annotate\"\\ndp = DataProcessor()\\ntrain_examples = dp.get_examples(trainpath)\\nprint(len(train_examples))\\nprint(train_examples[2].sen)\\nprint(train_examples[2].idxs)\\nprint(train_examples[2].guid)\\nprint(dp.get_label_dist())\\n\\ntokenizer = BertTokenizer.from_pretrained(\"bert-base-uncased\")\\ntrain_dataset = HalluDataset(train_examples,tokenizer, 512, \"bert\")\\n\\ntrain_dataloader = data.DataLoader(dataset=train_dataset,\\n                                   batch_size=32,\\n                                   shuffle=False,\\n                                   num_workers=4,\\n                                   collate_fn=HalluDataset.pad)\\n\\nfor step, batch in enumerate(train_dataloader):\\n    input_ids, input_mask, segment_ids, predict_mask, label_ids, guids = batch\\n    print(\"id {} mask {} segment {}, pmask {}, label {}\".format(input_ids.size(), input_mask.size(),\\n                                                                segment_ids.size(), predict_mask.size(), label_ids.size()))\\n    print(\"guid {}\".format(\" \".join([str(guid) for guid in guids])))\\n'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dataloader.py from HADES\n",
    "from torch.utils import data\n",
    "import torch\n",
    "import numpy as np\n",
    "from tqdm import tqdm, trange\n",
    "import collections\n",
    "import codecs\n",
    "import json\n",
    "\n",
    "\n",
    "class InputExample(object):\n",
    "\n",
    "    def __init__(self, guid, sen, idxs, label):\n",
    "        self.guid = guid\n",
    "        self.sen = sen\n",
    "        self.idxs = idxs\n",
    "        self.label = label\n",
    "\n",
    "\n",
    "class InputFeatures(object):\n",
    "\n",
    "    def __init__(self, guid, input_ids, input_mask, segment_ids,  predict_mask, label_id):\n",
    "        self.guid = guid\n",
    "        self.input_ids = input_ids\n",
    "        self.input_mask = input_mask\n",
    "        self.segment_ids = segment_ids\n",
    "        self.predict_mask = predict_mask\n",
    "        self.label_id = label_id\n",
    "\n",
    "\n",
    "class DataProcessor(object):\n",
    "    def __init__(self):\n",
    "        self.num_consist = 0\n",
    "        self.num_hallu = 0\n",
    "\n",
    "    def _read_data(self, input_file, require_uidx=False):\n",
    "        with open(input_file) as f:\n",
    "            # out_lines = []\n",
    "            out_lists = []\n",
    "            entries = f.read().strip().split(\"\\n\")\n",
    "            for entry in entries:\n",
    "                example = json.loads(entry.strip())\n",
    "                if \"hallucination\" not in example:\n",
    "                    label = -1\n",
    "                else:\n",
    "                    label = example[\"hallucination\"]\n",
    "                    if label not in [0, 1]:\n",
    "                        continue\n",
    "                if require_uidx:\n",
    "                    sen, token_ids, uidx = example[\"replaced\"], example[\"replaced_ids\"], example[\"idx\"]\n",
    "                    out_lists.append([sen, token_ids, label, uidx])\n",
    "                else:\n",
    "                    sen, token_ids = example[\"replaced\"], example[\"replaced_ids\"]\n",
    "                    out_lists.append([sen, token_ids, label])\n",
    "        return out_lists\n",
    "\n",
    "    def _create_examples(self, all_lists):\n",
    "        examples = []\n",
    "        for (i, one_lists) in enumerate(all_lists):\n",
    "            guid = i\n",
    "            if len(one_lists) == 3:  # Don't contain key \"idx\" in json file\n",
    "                sen, token_ids, label = one_lists\n",
    "            elif len(one_lists) == 4:  # Contain key \"idx\" in json file\n",
    "                sen, token_ids, label, guid = one_lists\n",
    "            else:\n",
    "                assert len(one_lists) == 3 or len(one_lists) == 4\n",
    "\n",
    "            if label == 0:\n",
    "                self.num_consist += 1\n",
    "            elif label == 1:\n",
    "                self.num_hallu += 1\n",
    "\n",
    "            examples.append(InputExample(\n",
    "                guid=guid, sen=sen, idxs=token_ids, label=label))\n",
    "        return examples\n",
    "\n",
    "    def get_examples(self, path, require_uidx=False):\n",
    "        return self._create_examples(\n",
    "            self._read_data(path, require_uidx))\n",
    "\n",
    "    def get_label_dist(self):\n",
    "        return [self.num_consist, self.num_hallu]\n",
    "\n",
    "def truncate(rep_subtokens, predict_mask, max_seq_length, rep_start_id, rep_end_id, mode=\"offline\"):\n",
    "    '''\n",
    "    Truncate the sequence if given a fixed context window. For example, given the following input sentence:\n",
    "    \"he signed a professional contract and promoted to the ===senior team=== where he managed to play for almost 3 years .\"\n",
    "    if the context window length is set as 4, the function will truncate the input as follows:\n",
    "\n",
    "    online mode: \"and promoted to the ===senior team===\"\n",
    "    offline mode: \"to the ===senior team=== where he\"\n",
    "    '''\n",
    "    if mode == \"offline\":\n",
    "        if len(rep_subtokens) > max_seq_length - 2:\n",
    "            mid_pt = int((rep_start_id + rep_end_id) / 2)\n",
    "            left_seq_length = int(max_seq_length / 2)\n",
    "            right_seq_length = max_seq_length - left_seq_length\n",
    "            if mid_pt - left_seq_length >= 0 and mid_pt + right_seq_length < len(rep_subtokens):\n",
    "                left_pt = mid_pt - left_seq_length\n",
    "                right_pt = mid_pt + right_seq_length\n",
    "            elif mid_pt - left_seq_length < 0 and mid_pt + right_seq_length < len(rep_subtokens):\n",
    "                left_pt = 0\n",
    "                right_pt = max_seq_length\n",
    "            elif mid_pt - left_seq_length >= 0 and mid_pt + right_seq_length >= len(rep_subtokens):\n",
    "                right_pt = len(rep_subtokens)\n",
    "                left_pt = len(rep_subtokens) - max_seq_length\n",
    "            elif mid_pt - left_seq_length < 0 and mid_pt + right_seq_length >= len(rep_subtokens):\n",
    "                left_pt = 0\n",
    "                right_pt = len(rep_subtokens)\n",
    "            rep_subtokens = rep_subtokens[left_pt:right_pt - 1]\n",
    "            predict_mask = predict_mask[left_pt:right_pt - 1]\n",
    "    else: # online\n",
    "        left_pt, right_pt = 0, rep_end_id + 1\n",
    "        if right_pt > max_seq_length - 2:\n",
    "            left_pt = right_pt - (max_seq_length - 2)\n",
    "        rep_subtokens = rep_subtokens[left_pt:right_pt]\n",
    "        predict_mask = predict_mask[left_pt:right_pt]\n",
    "    return rep_subtokens, predict_mask\n",
    "\n",
    "\n",
    "def example2feature(example, tokenizer, max_seq_length, model_name, mode=\"offline\"):\n",
    "    rep_start_id, rep_end_id = example.idxs\n",
    "    rep_tokens = remove_marked_sen(example.sen, rep_start_id, rep_end_id)\n",
    "\n",
    "    if 'xlnet' in model_name.lower():\n",
    "        rep_subtokens = []\n",
    "        predict_mask = []\n",
    "\n",
    "        for id, rep_token in enumerate(rep_tokens):\n",
    "            rep_subtoken = tokenizer.tokenize(rep_token)\n",
    "            if id >= rep_start_id and id <= rep_end_id:\n",
    "                rep_subtokens.extend(rep_subtoken)\n",
    "                predict_mask.extend(len(rep_subtoken) * [1])\n",
    "            else:\n",
    "                rep_subtokens.extend(rep_subtoken)\n",
    "                predict_mask.extend(len(rep_subtoken) * [0])\n",
    "\n",
    "        rep_subtokens, predict_mask = truncate(rep_subtokens, predict_mask, max_seq_length, rep_start_id, rep_end_id, mode=mode)\n",
    "\n",
    "        rep_subtokens.extend([\"<sep>\", \"<cls>\"])\n",
    "        predict_mask.extend([0, 0])\n",
    "\n",
    "    elif 'gpt' not in model_name.lower():\n",
    "\n",
    "        rep_subtokens = []\n",
    "        predict_mask = []\n",
    "        for id, rep_token in enumerate(rep_tokens):\n",
    "            rep_subtoken = tokenizer.tokenize(rep_token)\n",
    "            if id >= rep_start_id and id <= rep_end_id:\n",
    "                rep_subtokens.extend(rep_subtoken)\n",
    "                predict_mask.extend(len(rep_subtoken) * [1])\n",
    "            else:\n",
    "                rep_subtokens.extend(rep_subtoken)\n",
    "                predict_mask.extend(len(rep_subtoken) * [0])\n",
    "\n",
    "        rep_subtokens, predict_mask = truncate(rep_subtokens, predict_mask, max_seq_length, rep_start_id, rep_end_id, mode=mode)\n",
    "\n",
    "        rep_subtokens.insert(0, \"[CLS]\")\n",
    "        predict_mask.insert(0, 0)\n",
    "        rep_subtokens.append('[SEP]')\n",
    "        predict_mask.append(0)\n",
    "\n",
    "    elif 'gpt' in model_name.lower():\n",
    "        rep_subtokens = []\n",
    "        predict_mask = []\n",
    "\n",
    "        for id, rep_token in enumerate(rep_tokens):\n",
    "            rep_token = \" \"+rep_token if id!=0 else rep_token\n",
    "            rep_subtoken = tokenizer.tokenize(rep_token)\n",
    "            if id >= rep_start_id and id <= rep_end_id:\n",
    "                rep_subtokens.extend(rep_subtoken)\n",
    "                predict_mask.extend(len(rep_subtoken) * [1])\n",
    "            else:\n",
    "                rep_subtokens.extend(rep_subtoken)\n",
    "                predict_mask.extend(len(rep_subtoken) * [0])\n",
    "\n",
    "        rep_subtokens, predict_mask = truncate(rep_subtokens, predict_mask, max_seq_length, rep_start_id, rep_end_id, mode=mode)\n",
    "\n",
    "    input_ids = tokenizer.convert_tokens_to_ids(rep_subtokens)\n",
    "    segment_ids = [0] * len(input_ids)\n",
    "    input_mask = [1] * len(input_ids)\n",
    "\n",
    "    feat=InputFeatures(\n",
    "                guid=example.guid,\n",
    "                # tokens=tokens,\n",
    "                input_ids=input_ids,\n",
    "                input_mask=input_mask,\n",
    "                segment_ids=segment_ids,\n",
    "                predict_mask=predict_mask,\n",
    "                label_id=example.label)\n",
    "    return feat\n",
    "\n",
    "def get_examples_from_sen_tuple(sen, rep_pos):\n",
    "    examples = []\n",
    "    for uid, pos in enumerate(rep_pos):\n",
    "        examples.append(InputExample(guid=uid, sen=sen, idxs=pos, label=0))\n",
    "    return examples\n",
    "\n",
    "class HalluDataset(data.Dataset):\n",
    "    def __init__(self, examples, tokenizer, max_seq_length, model_name, task_mode=\"offline\"):\n",
    "        self.examples=examples\n",
    "        self.tokenizer=tokenizer\n",
    "        self.max_seq_length=max_seq_length\n",
    "        self.model_name = model_name\n",
    "        self.task_mode = task_mode\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.examples)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        feat=example2feature(self.examples[idx], self.tokenizer, self.max_seq_length,\n",
    "                             self.model_name, self.task_mode)\n",
    "        return feat.input_ids, feat.input_mask, feat.segment_ids, feat.predict_mask, feat.label_id, feat.guid\n",
    "\n",
    "    @classmethod\n",
    "    def pad(cls, batch):\n",
    "\n",
    "        seqlen_list = [len(sample[0]) for sample in batch]\n",
    "        maxlen = np.array(seqlen_list).max()\n",
    "\n",
    "        f = lambda x, seqlen: [sample[x] + [0] * (seqlen - len(sample[x])) for sample in batch] # 0: X for padding\n",
    "        input_ids_list = torch.LongTensor(f(0, maxlen))\n",
    "        input_mask_list = torch.LongTensor(f(1, maxlen))\n",
    "        segment_ids_list = torch.LongTensor(f(2, maxlen))\n",
    "        predict_mask_list = torch.ByteTensor(f(3, maxlen))\n",
    "        label_id = torch.LongTensor([sample[4] for sample in batch])\n",
    "        guids = [sample[5] for sample in batch]\n",
    "\n",
    "        return input_ids_list, input_mask_list, segment_ids_list, predict_mask_list, label_id, guids\n",
    "\n",
    "'''\n",
    "trainpath=\"../data_collections/wiki5k+sequential+topk_10+temp_1+context_1+rep_0.6+sample_1.annotate.finish\"\n",
    "# trainpath=\"../data_collections/wiki5k+sequential+topk_10+temp_1+context_1+rep_0.6+sample_1.annotate\"\n",
    "dp = DataProcessor()\n",
    "train_examples = dp.get_examples(trainpath)\n",
    "print(len(train_examples))\n",
    "print(train_examples[2].sen)\n",
    "print(train_examples[2].idxs)\n",
    "print(train_examples[2].guid)\n",
    "print(dp.get_label_dist())\n",
    "\n",
    "tokenizer = BertTokenizer.from_pretrained(\"bert-base-uncased\")\n",
    "train_dataset = HalluDataset(train_examples,tokenizer, 512, \"bert\")\n",
    "\n",
    "train_dataloader = data.DataLoader(dataset=train_dataset,\n",
    "                                   batch_size=32,\n",
    "                                   shuffle=False,\n",
    "                                   num_workers=4,\n",
    "                                   collate_fn=HalluDataset.pad)\n",
    "\n",
    "for step, batch in enumerate(train_dataloader):\n",
    "    input_ids, input_mask, segment_ids, predict_mask, label_ids, guids = batch\n",
    "    print(\"id {} mask {} segment {}, pmask {}, label {}\".format(input_ids.size(), input_mask.size(),\n",
    "                                                                segment_ids.size(), predict_mask.size(), label_ids.size()))\n",
    "    print(\"guid {}\".format(\" \".join([str(guid) for guid in guids])))\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformers import BertModel\n",
    "hades_model = BertModel.from_pretrained('google-bert/bert-base-uncased').to('cuda:2')\n",
    "hades_tokenizer = AutoTokenizer.from_pretrained('google-bert/bert-base-uncased')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils import data\n",
    "train_datapath = './Wiki-Hades/train.txt'\n",
    "dp = DataProcessor()\n",
    "train_examples = dp.get_examples(train_datapath)\n",
    "train_dataset = HalluDataset(train_examples, hades_tokenizer, 200, 'bert-base-uncased', \"offline\")\n",
    "train_dataloader = data.DataLoader(train_dataset, batch_size=1, num_workers=1, collate_fn=HalluDataset.pad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# currently using bert-base-uncased for reps\n",
    "# for other models, reinitialize the model variable\n",
    "\n",
    "vector_reps = []\n",
    "\n",
    "for i, sample in enumerate(train_dataloader):\n",
    "    sample = tuple(t for t in sample[:-1])\n",
    "    input_ids, input_mask, _, _, _= sample\n",
    "    with torch.no_grad():\n",
    "        outputs = hades_model(input_ids, input_mask)\n",
    "    cls_rep = outputs.last_hidden_state[0][0]\n",
    "    cls_rep = cls_rep.detach().cpu().numpy()\n",
    "\n",
    "    datapoint = labeled_multisample_data[i]\n",
    "    sentences = datapoint['sentences']\n",
    "    topk_vars = top_k_variances(sentences)\n",
    "    \n",
    "    train_x = np.concatenate([cls_rep, topk_vars])[np.newaxis, :]\n",
    "    vector_reps.append({'representation': train_x, 'label': datapoint['label']})\n",
    "    if i % 100 == 0:\n",
    "        print(f\"Stored {i} vectors\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('bert_training_data.pkl', 'wb') as f:\n",
    "    pickle.dump(vector_reps, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('bert_training_data.pkl', 'rb') as f:\n",
    "    bert_train = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "for d in bert_train:\n",
    "    d[\"representation\"] = torch.tensor(d[\"representation\"], dtype=torch.float32)\n",
    "    d[\"label\"] = torch.tensor([d[\"label\"], 1-d[\"label\"]], dtype=torch.float32)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('bert_validation_data.pkl', 'rb') as f:\n",
    "    bert_valid = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "for d in bert_valid:\n",
    "    d[\"representation\"] = torch.tensor(d[\"representation\"], dtype=torch.float32)\n",
    "    d[\"label\"] = torch.tensor([d[\"label\"], 1-d[\"label\"]], dtype=torch.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0., 1.])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bert_train[4]['label']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/10], Loss: 0.5529, Validation Loss:  0.8051\n",
      "Epoch [2/10], Loss: 0.5512, Validation Loss:  0.8346\n",
      "Epoch [3/10], Loss: 0.5977, Validation Loss:  0.6931\n",
      "Epoch [4/10], Loss: 0.5525, Validation Loss:  0.7932\n",
      "Epoch [5/10], Loss: 0.6835, Validation Loss:  0.6931\n",
      "Epoch [6/10], Loss: 0.5422, Validation Loss:  0.8199\n",
      "Epoch [7/10], Loss: 0.6805, Validation Loss:  0.6931\n",
      "Epoch [8/10], Loss: 0.5452, Validation Loss:  0.8061\n",
      "Epoch [9/10], Loss: 0.6901, Validation Loss:  0.6931\n",
      "Epoch [10/10], Loss: 0.5569, Validation Loss:  0.7861\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "\n",
    "class MLP(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(MLP, self).__init__()\n",
    "        self.fc1 = nn.Linear(778, 200)\n",
    "        self.fc2 = nn.Linear(200, 2)\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "        self.dropout = nn.Dropout(p=0.5)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.fc1(x)\n",
    "        x = self.dropout(x)\n",
    "        x = self.fc2(x)\n",
    "        x = self.dropout(x)\n",
    "        x = self.sigmoid(x)\n",
    "        return x\n",
    "\n",
    "# Define your dataset\n",
    "\n",
    "# Hyperparameters\n",
    "learning_rate = 0.01\n",
    "num_epochs = 10\n",
    "\n",
    "# Initialize the model\n",
    "model = MLP()\n",
    "\n",
    "# Define loss function and optimizer\n",
    "criterion = nn.BCELoss()\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
    "losses = []\n",
    "valid_losses = []\n",
    "# Training loop\n",
    "for epoch in range(num_epochs):\n",
    "    epoch_loss = 0\n",
    "    epoch_valid_loss = 0\n",
    "    model.train()\n",
    "    for d in bert_train:\n",
    "        # Forward pass\n",
    "        outputs = model(d[\"representation\"])\n",
    "        loss = criterion(outputs, d[\"label\"].unsqueeze(0))  # BCELoss expects a batch dimension\n",
    "        \n",
    "        \n",
    "        l2_reg = 0\n",
    "        if epoch % 2 == 0:\n",
    "            for param in model.parameters():\n",
    "                l2_reg += torch.norm(param, 2)\n",
    "        \n",
    "        total_loss = loss + 0.3*l2_reg\n",
    "        \n",
    "        epoch_loss += loss\n",
    "        # Backward and optimize\n",
    "        optimizer.zero_grad()\n",
    "        total_loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "    epoch_loss /= len(bert_train)\n",
    "    losses.append(epoch_loss)\n",
    "    \n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        for d in bert_valid:\n",
    "            valid_outputs = model(d[\"representation\"])\n",
    "            loss = criterion(valid_outputs, d['label'].unsqueeze(0))\n",
    "            epoch_valid_loss += loss\n",
    "    epoch_valid_loss /= len(bert_valid)\n",
    "    valid_losses.append(epoch_valid_loss)\n",
    "        \n",
    "    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {epoch_loss.item():.4f}, Validation Loss: {epoch_valid_loss.item(): .4f}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('BCELoss')\n",
    "plt.xticks([i for i in range(10)])\n",
    "plt.plot([i.detach().cpu().numpy() for i in losses], label='train losses')\n",
    "plt.plot([i.detach().cpu().numpy() for i in valid_losses], label='validation losses')\n",
    "plt.legend()\n",
    "plt.savefig('bert_10epochs_dropout_l2reg_alternate_relaxed.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('roberta_training_data.pkl', 'rb') as f:\n",
    "    roberta_train = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "for d in roberta_train:\n",
    "    d[\"representation\"] = torch.tensor(d[\"representation\"], dtype=torch.float32)\n",
    "    d[\"label\"] = torch.tensor([d[\"label\"], 1-d[\"label\"]], dtype=torch.float32)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('roberta_validation_data.pkl', 'rb') as f:\n",
    "    roberta_valid = pickle.load(f)\n",
    "roberta_valid = roberta_valid[:len(roberta_valid)//2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "for d in roberta_valid:\n",
    "    d[\"representation\"] = torch.tensor(d[\"representation\"], dtype=torch.float32)\n",
    "    d[\"label\"] = torch.tensor([d[\"label\"], 1-d[\"label\"]], dtype=torch.float32)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_roberta = MLP()\n",
    "learning_rate = 0.01\n",
    "weight_decay = 1e-5\n",
    "\n",
    "# Define loss function and optimizer\n",
    "criterion = nn.BCELoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=weight_decay)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/10], Loss: 0.7113, Validation Loss:  0.7027\n",
      "Epoch [2/10], Loss: 0.7106, Validation Loss:  0.7027\n",
      "Epoch [3/10], Loss: 0.7110, Validation Loss:  0.7027\n",
      "Epoch [4/10], Loss: 0.7088, Validation Loss:  0.7027\n",
      "Epoch [5/10], Loss: 0.7085, Validation Loss:  0.7027\n",
      "Epoch [6/10], Loss: 0.7116, Validation Loss:  0.7027\n",
      "Epoch [7/10], Loss: 0.7132, Validation Loss:  0.7027\n",
      "Epoch [8/10], Loss: 0.7107, Validation Loss:  0.7027\n",
      "Epoch [9/10], Loss: 0.7079, Validation Loss:  0.7027\n",
      "Epoch [10/10], Loss: 0.7112, Validation Loss:  0.7027\n"
     ]
    }
   ],
   "source": [
    "num_epochs = 10\n",
    "losses = []\n",
    "valid_losses = []\n",
    "# Training loop\n",
    "for epoch in range(num_epochs):\n",
    "    epoch_loss = 0\n",
    "    epoch_valid_loss = 0\n",
    "    model_roberta.train()\n",
    "    for d in roberta_train:\n",
    "        # Forward pass\n",
    "        outputs = model_roberta(d[\"representation\"])\n",
    "        loss = criterion(outputs, d[\"label\"].unsqueeze(0))  # BCELoss expects a batch dimension\n",
    "        \n",
    "        \n",
    "        l2_reg = 0\n",
    "        if epoch % 2 == 0:\n",
    "            for param in model.parameters():\n",
    "                l2_reg += torch.norm(param, 2)\n",
    "        \n",
    "        total_loss = loss + 0.3*l2_reg\n",
    "        \n",
    "        epoch_loss += loss\n",
    "        # Backward and optimize\n",
    "        optimizer.zero_grad()\n",
    "        total_loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "    epoch_loss /= len(roberta_train)\n",
    "    losses.append(epoch_loss)\n",
    "    \n",
    "    model_roberta.eval()\n",
    "    with torch.no_grad():\n",
    "        for d in roberta_valid:\n",
    "            valid_outputs = model_roberta(d[\"representation\"])\n",
    "            loss = criterion(valid_outputs, d['label'].unsqueeze(0))\n",
    "            epoch_valid_loss += loss\n",
    "    epoch_valid_loss /= len(roberta_valid)\n",
    "    valid_losses.append(epoch_valid_loss)\n",
    "        \n",
    "    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {epoch_loss.item():.4f}, Validation Loss: {epoch_valid_loss.item(): .4f}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('BCELoss')\n",
    "plt.xticks([i for i in range(10)])\n",
    "plt.plot([i.detach().cpu().numpy() for i in losses], label='train losses')\n",
    "plt.plot([i.detach().cpu().numpy() for i in valid_losses], label='validation losses')\n",
    "plt.legend()\n",
    "plt.savefig('roberta_10epochs_dropout_l2reg_alternate_relaxed.png')"
   ]
  }
 ],
 "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.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}