Upload folder using huggingface_hub

OVM/.ipynb_checkpoints/create_mc_dataset-checkpoint.ipynb

@@ -0,0 +1,620 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "477e1474-49ab-4c29-8c32-eac32c231679",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/jovyan/nas_comm/1_user/[email protected]/research/math/math-mistral/docker/extractive-qa-mrc\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/conda/envs/mistral/lib/python3.10/site-packages/IPython/core/magics/osm.py:417: UserWarning: using dhist requires you to install the `pickleshare` library.\n",
+      "  self.shell.db['dhist'] = compress_dhist(dhist)[-100:]\n"
+     ]
+    }
+   ],
+   "source": [
+    "%cd extractive-qa-mrc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "8282b3fd-e955-4021-857e-1cb721f6a04e",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Token will not been saved to git credential helper. Pass `add_to_git_credential=True` if you want to set the git credential as well.\n",
+      "Token is valid (permission: write).\n",
+      "Your token has been saved to /home/jovyan/.cache/huggingface/token\n",
+      "Login successful\n"
+     ]
+    }
+   ],
+   "source": [
+    "from huggingface_hub import login\n",
+    "from transformers import AutoTokenizer\n",
+    "from datasets import load_dataset\n",
+    "import re\n",
+    "import torch\n",
+    "from tqdm.auto import tqdm\n",
+    "import random\n",
+    "random.seed(42)\n",
+    "login(token = \"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\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "b3230e48-d2f8-4be6-8fa5-b5018f493685",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Downloading readme: 100%|██████████| 475/475 [00:00<00:00, 1.26MB/s]\n",
+      "Downloading data files:   0%|          | 0/1 [00:00<?, ?it/s]\n",
+      "Downloading data:   0%|          | 0.00/2.75M [00:00<?, ?B/s]\u001b[A\n",
+      "Downloading data: 100%|██████████| 2.75M/2.75M [00:01<00:00, 1.52MB/s]\u001b[A\n",
+      "Downloading data files: 100%|██████████| 1/1 [00:01<00:00,  1.82s/it]\n",
+      "Extracting data files: 100%|██████████| 1/1 [00:00<00:00, 988.52it/s]\n",
+      "Generating train split: 100%|██████████| 8792/8792 [00:00<00:00, 47323.69 examples/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "gsm8k = load_dataset(\"longhoang06/Vi-GSM8K\")[\"train\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "a973c559-1d0f-4978-8648-4049f82c49a7",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "def add_labels(dataset):\n",
+    "    answer = dataset[\"answer\"]\n",
+    "    label = answer.split(\"Đáp án:\")[-1].strip()\n",
+    "    dataset[\"label\"] = label\n",
+    "    return dataset\n",
+    "\n",
+    "gsm8k = gsm8k.map(add_labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a1f08265-6a52-44b3-a7f0-0900e6f0ccce",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2023-11-25 16:32:31,497] [INFO] [real_accelerator.py:158:get_accelerator] Setting ds_accelerator to cuda (auto detect)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from infer import tokenize_function, data_collator, extract_answer\n",
+    "from model.mrc_model import MRCQuestionAnswering\n",
+    "from transformers import AutoTokenizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "2942f780-4621-4c80-a63d-5ab8b4e886c3",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "model_checkpoint = \"nguyenvulebinh/vi-mrc-large\"\n",
+    "tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)\n",
+    "model = MRCQuestionAnswering.from_pretrained(model_checkpoint)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "22820d8e-33cd-4a8a-9f28-730b1f49ea82",
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "MRCQuestionAnswering(\n",
+       "  (roberta): RobertaModel(\n",
+       "    (embeddings): RobertaEmbeddings(\n",
+       "      (word_embeddings): Embedding(250002, 1024, padding_idx=1)\n",
+       "      (position_embeddings): Embedding(514, 1024, padding_idx=1)\n",
+       "      (token_type_embeddings): Embedding(1, 1024)\n",
+       "      (LayerNorm): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n",
+       "      (dropout): Dropout(p=0.1, inplace=False)\n",
+       "    )\n",
+       "    (encoder): RobertaEncoder(\n",
+       "      (layer): ModuleList(\n",
+       "        (0-23): 24 x RobertaLayer(\n",
+       "          (attention): RobertaAttention(\n",
+       "            (self): RobertaSelfAttention(\n",
+       "              (query): Linear(in_features=1024, out_features=1024, bias=True)\n",
+       "              (key): Linear(in_features=1024, out_features=1024, bias=True)\n",
+       "              (value): Linear(in_features=1024, out_features=1024, bias=True)\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "            (output): RobertaSelfOutput(\n",
+       "              (dense): Linear(in_features=1024, out_features=1024, bias=True)\n",
+       "              (LayerNorm): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n",
+       "              (dropout): Dropout(p=0.1, inplace=False)\n",
+       "            )\n",
+       "          )\n",
+       "          (intermediate): RobertaIntermediate(\n",
+       "            (dense): Linear(in_features=1024, out_features=4096, bias=True)\n",
+       "            (intermediate_act_fn): GELUActivation()\n",
+       "          )\n",
+       "          (output): RobertaOutput(\n",
+       "            (dense): Linear(in_features=4096, out_features=1024, bias=True)\n",
+       "            (LayerNorm): LayerNorm((1024,), eps=1e-05, elementwise_affine=True)\n",
+       "            (dropout): Dropout(p=0.1, inplace=False)\n",
+       "          )\n",
+       "        )\n",
+       "      )\n",
+       "    )\n",
+       "  )\n",
+       "  (qa_outputs): Linear(in_features=1024, out_features=2, bias=True)\n",
+       ")"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.to(\"cuda:1\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "ea6ffa65-e01f-44f7-840f-702e70110095",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "04a45697b6f348b7a72f54b8b6c2302e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/8792 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ground_truths = []\n",
+    "questions = gsm8k[\"question\"]\n",
+    "answers = contexts = gsm8k[\"answer\"]\n",
+    "labels = gsm8k[\"label\"]\n",
+    "\n",
+    "progress_bar = tqdm(range(len(questions)))\n",
+    "for ques, cont, lab in zip(questions, contexts, labels):\n",
+    "    cont = cont.split(\"Đáp án:\")[0].strip()\n",
+    "    QA_input = {\n",
+    "        \"question\": ques,\n",
+    "        \"context\": cont,\n",
+    "    }\n",
+    "    inputs = [tokenize_function(QA_input, tokenizer)]\n",
+    "    inputs_ids = data_collator(inputs, tokenizer)\n",
+    "    inputs_ids = {k:v.to(\"cuda:1\") for k, v in inputs_ids.items()}\n",
+    "    with torch.no_grad():\n",
+    "        outputs = model(**inputs_ids)\n",
+    "    text = extract_answer(inputs, outputs, tokenizer)[0][\"answer\"]\n",
+    "    normalize_text = re.findall(r'-?\\d+[., ]\\d+|-?\\d+', text)\n",
+    "    if 0 < len(normalize_text) <=1 and normalize_text[0] == lab:\n",
+    "        ground_truths.append(text)\n",
+    "    else:\n",
+    "        ground_truths.append(lab)\n",
+    "    \n",
+    "    progress_bar.update(1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "2f2c7ae7-7faf-4f6e-8b87-16b1bb316fc9",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# 7 + x = Y năm\n",
+    "# m=80\n",
+    "# 85 dặm xa hơn\n",
+    "# 20 vàng\n",
+    "# Tổng cộng là 7 đô la\n",
+    "# 28 rùa .\n",
+    "check_ground_truths = [\"7 + x = Y năm\", \"m=80\", \"85 dặm xa hơn\", \"20 vàng\", \"Tổng cộng là 7 đô la\", \"28 rùa .\"]\n",
+    "for check_gr in check_ground_truths:\n",
+    "    check_id = ground_truths.index(check_gr)\n",
+    "    if check_gr == check_ground_truths[0]:\n",
+    "        ground_truths[check_id] = \"7 tuổi\"\n",
+    "    elif check_gr == check_ground_truths[1]:\n",
+    "        ground_truths[check_id] = \"80 viên bi\"\n",
+    "    elif check_gr == check_ground_truths[2]:\n",
+    "        ground_truths[check_id] = \"85 dặm\"\n",
+    "    elif check_gr == check_ground_truths[3]:\n",
+    "        ground_truths[check_id] = \"20\"\n",
+    "    elif check_gr == check_ground_truths[4]:\n",
+    "        ground_truths[check_id] = \"7 đô la\"\n",
+    "    elif check_gr == check_ground_truths[5]:\n",
+    "        ground_truths[check_id] = \"28 con rùa\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "a823330a-4164-4f33-a4af-233288f07463",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Đầu ngày, Hiệu trưởng Kumar hướng dẫn Harold treo cờ lên cột cờ. Cột cờ dài 60 feet và khi được kéo lên hoàn toàn, lá cờ nằm trên đỉnh cột cờ. Cuối buổi sáng hôm đó, Hiệu phó Zizi đã chỉ thị cho Harold hạ cờ xuống nửa cột. Vì vậy, Harold đã hạ lá cờ xuống giữa cột. Sau đó, Hiệu trưởng Kumar bảo Harold kéo lá cờ lên đỉnh cột một lần nữa và Harold đã làm đúng như vậy. Vào cuối ngày, Hiệu phó Zizi hướng dẫn Harold hạ cờ xuống hoàn toàn, tháo nó ra khỏi cột và cất vào buổi tối. Trong suốt ngày, lá cờ đã di chuyển lên xuống cột bao xa, tính bằng feet?\n",
+      " Một nửa quãng đường lên cột cờ là 60/2 = 30 feet. Do đó, Harold đã di chuyển lá cờ 60 lên + 30 xuống + 30 lên + 60 xuống = 180 feet. Đáp án: 180\n",
+      "180\n",
+      "180\n"
+     ]
+    }
+   ],
+   "source": [
+    "i = 4670\n",
+    "print(questions[i])\n",
+    "print(answers[i])\n",
+    "print(labels[i])\n",
+    "print(ground_truths[i])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "61e31821-d1cd-4829-8278-ce7a9369055a",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "def create_multi_choices(ground_truths: list, labels: list) -> list:\n",
+    "    special_numbers = [\"3,888\", \"9,492\", \"3,472\", \"4,582\", \"1,600\"]\n",
+    "    choices = []\n",
+    "    progress_bar = tqdm(range(len(ground_truths)))\n",
+    "    for i in range(len(ground_truths)):\n",
+    "        label = re.findall(r'-?\\d+[., ]\\d+|-?\\d+', labels[i])[0]\n",
+    "        if label not in special_numbers:\n",
+    "            number = int(label)\n",
+    "            epsilon = int((number - 1) / 2) + 1\n",
+    "            if number > 2:\n",
+    "                lower_bound = max(0, number - epsilon)\n",
+    "                upper_bound = number + epsilon\n",
+    "            elif 0 < number <= 2:\n",
+    "                lower_bound = 1\n",
+    "                upper_bound = 6\n",
+    "            else:\n",
+    "                if epsilon > 0:\n",
+    "                    lower_bound = number - epsilon\n",
+    "                    upper_bound = number + epsilon\n",
+    "                else:\n",
+    "                    lower_bound = number + epsilon\n",
+    "                    upper_bound = number - epsilon\n",
+    "\n",
+    "                if upper_bound - lower_bound < 3:\n",
+    "                    upper_bound += 3\n",
+    "\n",
+    "            random_numbers = []\n",
+    "            while 0 <= len(random_numbers) <= 3:\n",
+    "                random_number = random.randint(lower_bound, upper_bound)\n",
+    "                if random_number not in random_numbers and random_number != number:\n",
+    "                    random_numbers.append(random_number)\n",
+    "\n",
+    "            ground_truth = ground_truths[i]\n",
+    "            option_0 = ground_truth.replace(label, str(random_numbers[0]))\n",
+    "            option_1 = ground_truth.replace(label, str(random_numbers[1]))\n",
+    "            option_2 = ground_truth.replace(label, str(random_numbers[2]))\n",
+    "        else:\n",
+    "            number = float(label.replace(\",\", \".\"))\n",
+    "            epsilon = round(float((number - 1) / 2), 3)\n",
+    "            lower_bound = max(0, number - epsilon)\n",
+    "            upper_bound = number + epsilon\n",
+    "\n",
+    "            random_numbers = []\n",
+    "            while 0 <= len(random_numbers) <= 3:\n",
+    "                random_number = round(random.uniform(lower_bound, upper_bound), 3)\n",
+    "                if random_number not in random_numbers and random_number != number:\n",
+    "                    random_numbers.append(random_number)\n",
+    "\n",
+    "            ground_truth = ground_truths[i]\n",
+    "            option_0 = ground_truth.replace(label, str(random_numbers[0]).replace(\".\", \",\"))\n",
+    "            option_1 = ground_truth.replace(label, str(random_numbers[1]).replace(\".\", \",\"))\n",
+    "            option_2 = ground_truth.replace(label, str(random_numbers[2]).replace(\".\", \",\"))\n",
+    "\n",
+    "        option_list = [ground_truth, option_0, option_1, option_2]\n",
+    "        random.shuffle(option_list)\n",
+    "\n",
+    "        option_list[0] = \"A. \" + option_list[0]\n",
+    "        option_list[1] = \"B. \" + option_list[1]\n",
+    "        option_list[2] = \"C. \" + option_list[2]\n",
+    "        option_list[3] = \"D. \" + option_list[3]\n",
+    "        gold_choice = [option for option in option_list if option.split(\". \")[-1] == ground_truth]\n",
+    "        choices.append((option_list, gold_choice[0]))\n",
+    "        progress_bar.update(1)\n",
+    "        \n",
+    "    return choices"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "08520704-ce76-45d2-bddc-b3dcb0ff6b16",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "01b888c5bca64fcaa9b1ddbd6da88155",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/8792 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "multi_choices = create_multi_choices(ground_truths, labels)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "56a00daa-7cf2-43e1-b3e9-96fa5a7b77c8",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(['A. 71', 'B. 39', 'C. 72', 'D. 50'], 'C. 72')"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "multi_choices[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "0eee0ae7-ecb7-4905-876f-09728c1bdd34",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "gsm8k_multi_choices = []\n",
+    "for i in range(len(ground_truths)):\n",
+    "    gsm8k_multi_choices.append(\n",
+    "        {\"question\": questions[i],\n",
+    "         \"choices\": multi_choices[i][0],\n",
+    "         \"explanation\": answers[i],\n",
+    "         \"answer\": multi_choices[i][1],\n",
+    "        }\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "eb3bbc6d-e4a6-40a1-96cf-76d41d031eb7",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/home/jovyan/nas_comm/1_user/[email protected]/research/math/math-mistral\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/conda/envs/main/lib/python3.10/site-packages/IPython/core/magics/osm.py:417: UserWarning: using dhist requires you to install the `pickleshare` library.\n",
+      "  self.shell.db['dhist'] = compress_dhist(dhist)[-100:]\n"
+     ]
+    }
+   ],
+   "source": [
+    "%cd ..\n",
+    "with open(\"math_train.json\", \"r\") as f:\n",
+    "    zac_dataset = json.load(f)\n",
+    "zac_dataset = zac_dataset[\"data\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "a780cd12-6a12-44f0-b795-d69232e93f65",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "zac_dataset = [d for d in zac_dataset if \"explanation\" in d.keys()]\n",
+    "for d in zac_dataset:\n",
+    "    del d[\"id\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "f44ba9cc-7af8-48e3-bf98-c17b18e2902e",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "full_dataset = gsm8k_multi_choices + zac_dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "8e0704b5-7379-4c91-91ec-6948bfe39f99",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "9328"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(full_dataset)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "1ecb76e1-65dd-41f4-b70b-bddc938e2e3d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "from datasets import Dataset\n",
+    "\n",
+    "df = pd.DataFrame(full_dataset)\n",
+    "dataset = Dataset.from_pandas(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "ba20bd40-473c-457e-b460-10d1c64cac36",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2ebec07ba4aa4a2f8fccb10804345982",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Pushing dataset shards to the dataset hub:   0%|          | 0/1 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6b9acd7e26564d58b5d38498e30efb29",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Creating parquet from Arrow format:   0%|          | 0/10 [00:00<?, ?ba/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dataset.push_to_hub(\"MC-ViMath\", private = True)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (mistral)",
+   "language": "python",
+   "name": "mistral"
+  },
+  "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.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

OVM/Dockerfile.ClickAI

@@ -0,0 +1,51 @@
+FROM nvcr.io/nvidia/pytorch:22.12-py3
+
+LABEL maintainer="ClickAI"
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN apt update
+RUN apt install -y git libsndfile1-dev tesseract-ocr espeak-ng python3 python3-pip ffmpeg
+RUN python3 -m pip install --no-cache-dir --upgrade pip
+
+ARG REF=main
+RUN git clone https://github.com/huggingface/transformers && cd transformers && git checkout $REF
+
+ARG PYTORCH='2.1.0'
+ARG TORCH_VISION=''
+ARG TORCH_AUDIO=''
+ARG CUDA='cu118'
+
+RUN [ ${#PYTORCH} -gt 0 ] && VERSION='torch=='$PYTORCH'.*' ||  VERSION='torch'; python3 -m pip install --no-cache-dir -U $VERSION --extra-index-url https://download.pytorch.org/whl/$CUDA
+RUN [ ${#TORCH_VISION} -gt 0 ] && VERSION='torchvision=='TORCH_VISION'.*' ||  VERSION='torchvision'; python3 -m pip install --no-cache-dir -U $VERSION --extra-index-url https://download.pytorch.org/whl/$CUDA
+RUN [ ${#TORCH_AUDIO} -gt 0 ] && VERSION='torchaudio=='TORCH_AUDIO'.*' ||  VERSION='torchaudio'; python3 -m pip install --no-cache-dir -U $VERSION --extra-index-url https://download.pytorch.org/whl/$CUDA
+
+RUN python3 -m pip install --no-cache-dir -e ./transformers[dev-torch,testing,video]
+RUN python3 -m pip uninstall -y tensorflow flax
+RUN python3 -m pip install --no-cache-dir git+https://github.com/facebookresearch/detectron2.git pytesseract
+RUN python3 -m pip install -U "itsdangerous<2.1.0"
+RUN cd transformers && python3 setup.py develop
+
+ADD requirements.txt /requirements.txt
+RUN cd / && pip install -r requirements.txt
+
+COPY extractive-qa-mrc /extractive-qa-mrc
+COPY checkpoint /checkpoint
+COPY data /data
+
+
+COPY create_mc_dataset.ipynb /create_mc_dataset.ipynb
+COPY math-mistral.py /math-mistral.py
+COPY math-mistral.sh /math-mistral.sh
+COPY mc-mistral.py /mc-mistral.py
+COPY mc-mistral.sh /mc-mistral.sh
+COPY predict_notebook.ipynb /predict_notebook.ipynb
+COPY predict.py /predict.py
+COPY predict.sh /predict.sh
+
+
+RUN python3 -m pip uninstall transformer-engine -y
+
+
+WORKDIR /
+ENTRYPOINT ["/bin/bash", "/predict.sh"]

OVM/OVM/.ipynb_checkpoints/Untitled-checkpoint.ipynb

@@ -0,0 +1,1309 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "a207d6b3-e0ac-4a02-8125-087244598d72",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "os.environ[\"CUDA_DEVICE_ORDER\"]=\"PCI_BUS_ID\"  \n",
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"4,5\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "4ab7f1af-89e5-4d04-ab32-761292e0fc40",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/opt/conda/envs/mistral/lib/python3.10/site-packages/tqdm/auto.py:21: 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": [
+    "from transformers import AutoTokenizer, AutoModelForCausalLM\n",
+    "import torch\n",
+    "import torch.nn as nn \n",
+    "from build_verifier import VerifierModel\n",
+    "from v_dataset import VerifierDataset\n",
+    "from torch.utils.data import DataLoader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4adc4982-6ab2-414f-a19e-b796f306ceb1",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading checkpoint shards: 100%|██████████| 2/2 [00:24<00:00, 12.19s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "model = AutoModelForCausalLM.from_pretrained(\"mistralai/Mistral-7B-v0.1\", device_map = \"auto\", torch_dtype = torch.bfloat16)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "e0f599b5-d3ca-4ebb-b6ba-a5a77936e1a1",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "tokenizer = AutoTokenizer.from_pretrained(\"mistralai/Mistral-7B-v0.1\")\n",
+    "tokenizer.pad_token = tokenizer.eos_token"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "d498bc4d-366f-4a7c-a189-9afe6a2d4889",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "VERIFIER = VerifierModel(backbone = model, checkpoint_dir = \"/home/jovyan/workspace/1_user/[email protected]/temp/check/model.pt\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "978eebc9-2cbc-42cf-8ca7-d582e0a83866",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "torch.cuda.empty_cache()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "c5bf1882-8e07-4fb3-a687-7726374bb0d7",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "torch.save(VERIFIER.state_dict(), \"/home/jovyan/workspace/1_user/[email protected]/temp/check/model.pt\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "5f8e83bf-f0f2-4fb1-adec-7935e7ab0987",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "device = model.device"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "c1a605f8-30d7-4bde-aa48-463754b4f309",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "verifier_cls = VerifierDataset(\n",
+    "    tokenizer = tokenizer,\n",
+    "    data_path = \"longhoang06/vi-ovm-dataset\",\n",
+    "    max_length = 512,\n",
+    "    load_data_method = \"hf_hub\",\n",
+    "    mapping = True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "3ab84d61-9e9a-42f5-9183-7e9267ccb6a6",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "dataset = verifier_cls.dataset[\"train\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "57b216f4-47b1-42ab-b451-ff01add4fc7c",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "dataset.set_format(\"torch\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "f8c90769-96a6-4770-901a-70ca6de1edb1",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "train_dataloader = DataLoader(dataset, batch_size = 2, pin_memory = True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "07185511-7530-4786-826d-95358d5800e5",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "VerifierModelOutput(loss=tensor(1.3851e+11, device='cuda:0', grad_fn=<AddBackward0>), v_scores=tensor([[[ 0.0583],\n",
+      "         [-1.9375],\n",
+      "         [-1.9609],\n",
+      "         ...,\n",
+      "         [-2.1094],\n",
+      "         [-0.7891],\n",
+      "         [-0.9062]],\n",
+      "\n",
+      "        [[ 0.1157],\n",
+      "         [-0.5586],\n",
+      "         [-0.6953],\n",
+      "         ...,\n",
+      "         [-2.4688],\n",
+      "         [-2.3594],\n",
+      "         [-0.6641]]], device='cuda:0', dtype=torch.bfloat16,\n",
+      "       grad_fn=<UnsafeViewBackward0>), all_losses={'llm_loss': tensor(1.0603, device='cuda:0', grad_fn=<NllLossBackward0>), 'v_loss': tensor(1.3851e+11, device='cuda:0', dtype=torch.bfloat16,\n",
+      "       grad_fn=<DivBackward0>)})\n"
+     ]
+    }
+   ],
+   "source": [
+    "for batch in train_dataloader:\n",
+    "    batch = {k:v.to(\"cuda\") for k, v in batch.items()}\n",
+    "    outputs = VERIFIER(\n",
+    "        input_ids = batch[\"input_ids\"],\n",
+    "        attention_mask = batch[\"attention_mask\"],\n",
+    "        labels = batch[\"labels\"],\n",
+    "        v_labels = batch[\"v_labels\"],\n",
+    "        output_all_losses = True,\n",
+    "    )\n",
+    "    print(outputs)\n",
+    "    break"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "28052242-89c8-44dc-867f-8d7c6bc4b080",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.bfloat16"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.dtype"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "6380f930-f00e-41d8-926c-57c76c9af69d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Help on class Linear in module torch.nn.modules.linear:\n",
+      "\n",
+      "class Linear(torch.nn.modules.module.Module)\n",
+      " |  Linear(in_features: int, out_features: int, bias: bool = True, device=None, dtype=None) -> None\n",
+      " |  \n",
+      " |  Applies a linear transformation to the incoming data: :math:`y = xA^T + b`\n",
+      " |  \n",
+      " |  This module supports :ref:`TensorFloat32<tf32_on_ampere>`.\n",
+      " |  \n",
+      " |  On certain ROCm devices, when using float16 inputs this module will use :ref:`different precision<fp16_on_mi200>` for backward.\n",
+      " |  \n",
+      " |  Args:\n",
+      " |      in_features: size of each input sample\n",
+      " |      out_features: size of each output sample\n",
+      " |      bias: If set to ``False``, the layer will not learn an additive bias.\n",
+      " |          Default: ``True``\n",
+      " |  \n",
+      " |  Shape:\n",
+      " |      - Input: :math:`(*, H_{in})` where :math:`*` means any number of\n",
+      " |        dimensions including none and :math:`H_{in} = \\text{in\\_features}`.\n",
+      " |      - Output: :math:`(*, H_{out})` where all but the last dimension\n",
+      " |        are the same shape as the input and :math:`H_{out} = \\text{out\\_features}`.\n",
+      " |  \n",
+      " |  Attributes:\n",
+      " |      weight: the learnable weights of the module of shape\n",
+      " |          :math:`(\\text{out\\_features}, \\text{in\\_features})`. The values are\n",
+      " |          initialized from :math:`\\mathcal{U}(-\\sqrt{k}, \\sqrt{k})`, where\n",
+      " |          :math:`k = \\frac{1}{\\text{in\\_features}}`\n",
+      " |      bias:   the learnable bias of the module of shape :math:`(\\text{out\\_features})`.\n",
+      " |              If :attr:`bias` is ``True``, the values are initialized from\n",
+      " |              :math:`\\mathcal{U}(-\\sqrt{k}, \\sqrt{k})` where\n",
+      " |              :math:`k = \\frac{1}{\\text{in\\_features}}`\n",
+      " |  \n",
+      " |  Examples::\n",
+      " |  \n",
+      " |      >>> m = nn.Linear(20, 30)\n",
+      " |      >>> input = torch.randn(128, 20)\n",
+      " |      >>> output = m(input)\n",
+      " |      >>> print(output.size())\n",
+      " |      torch.Size([128, 30])\n",
+      " |  \n",
+      " |  Method resolution order:\n",
+      " |      Linear\n",
+      " |      torch.nn.modules.module.Module\n",
+      " |      builtins.object\n",
+      " |  \n",
+      " |  Methods defined here:\n",
+      " |  \n",
+      " |  __init__(self, in_features: int, out_features: int, bias: bool = True, device=None, dtype=None) -> None\n",
+      " |      Initializes internal Module state, shared by both nn.Module and ScriptModule.\n",
+      " |  \n",
+      " |  extra_repr(self) -> str\n",
+      " |      Set the extra representation of the module\n",
+      " |      \n",
+      " |      To print customized extra information, you should re-implement\n",
+      " |      this method in your own modules. Both single-line and multi-line\n",
+      " |      strings are acceptable.\n",
+      " |  \n",
+      " |  forward(self, input: torch.Tensor) -> torch.Tensor\n",
+      " |      Defines the computation performed at every call.\n",
+      " |      \n",
+      " |      Should be overridden by all subclasses.\n",
+      " |      \n",
+      " |      .. note::\n",
+      " |          Although the recipe for forward pass needs to be defined within\n",
+      " |          this function, one should call the :class:`Module` instance afterwards\n",
+      " |          instead of this since the former takes care of running the\n",
+      " |          registered hooks while the latter silently ignores them.\n",
+      " |  \n",
+      " |  reset_parameters(self) -> None\n",
+      " |  \n",
+      " |  ----------------------------------------------------------------------\n",
+      " |  Data and other attributes defined here:\n",
+      " |  \n",
+      " |  __annotations__ = {'in_features': <class 'int'>, 'out_features': <clas...\n",
+      " |  \n",
+      " |  __constants__ = ['in_features', 'out_features']\n",
+      " |  \n",
+      " |  __slotnames__ = []\n",
+      " |  \n",
+      " |  ----------------------------------------------------------------------\n",
+      " |  Methods inherited from torch.nn.modules.module.Module:\n",
+      " |  \n",
+      " |  __call__ = _call_impl(self, *args, **kwargs)\n",
+      " |  \n",
+      " |  __delattr__(self, name)\n",
+      " |      Implement delattr(self, name).\n",
+      " |  \n",
+      " |  __dir__(self)\n",
+      " |      Default dir() implementation.\n",
+      " |  \n",
+      " |  __getattr__(self, name: str) -> Union[torch.Tensor, ForwardRef('Module')]\n",
+      " |  \n",
+      " |  __repr__(self)\n",
+      " |      Return repr(self).\n",
+      " |  \n",
+      " |  __setattr__(self, name: str, value: Union[torch.Tensor, ForwardRef('Module')]) -> None\n",
+      " |      Implement setattr(self, name, value).\n",
+      " |  \n",
+      " |  __setstate__(self, state)\n",
+      " |  \n",
+      " |  add_module(self, name: str, module: Optional[ForwardRef('Module')]) -> None\n",
+      " |      Adds a child module to the current module.\n",
+      " |      \n",
+      " |      The module can be accessed as an attribute using the given name.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          name (str): name of the child module. The child module can be\n",
+      " |              accessed from this module using the given name\n",
+      " |          module (Module): child module to be added to the module.\n",
+      " |  \n",
+      " |  apply(self: ~T, fn: Callable[[ForwardRef('Module')], NoneType]) -> ~T\n",
+      " |      Applies ``fn`` recursively to every submodule (as returned by ``.children()``)\n",
+      " |      as well as self. Typical use includes initializing the parameters of a model\n",
+      " |      (see also :ref:`nn-init-doc`).\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          fn (:class:`Module` -> None): function to be applied to each submodule\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          Module: self\n",
+      " |      \n",
+      " |      Example::\n",
+      " |      \n",
+      " |          >>> @torch.no_grad()\n",
+      " |          >>> def init_weights(m):\n",
+      " |          >>>     print(m)\n",
+      " |          >>>     if type(m) == nn.Linear:\n",
+      " |          >>>         m.weight.fill_(1.0)\n",
+      " |          >>>         print(m.weight)\n",
+      " |          >>> net = nn.Sequential(nn.Linear(2, 2), nn.Linear(2, 2))\n",
+      " |          >>> net.apply(init_weights)\n",
+      " |          Linear(in_features=2, out_features=2, bias=True)\n",
+      " |          Parameter containing:\n",
+      " |          tensor([[1., 1.],\n",
+      " |                  [1., 1.]], requires_grad=True)\n",
+      " |          Linear(in_features=2, out_features=2, bias=True)\n",
+      " |          Parameter containing:\n",
+      " |          tensor([[1., 1.],\n",
+      " |                  [1., 1.]], requires_grad=True)\n",
+      " |          Sequential(\n",
+      " |            (0): Linear(in_features=2, out_features=2, bias=True)\n",
+      " |            (1): Linear(in_features=2, out_features=2, bias=True)\n",
+      " |          )\n",
+      " |  \n",
+      " |  bfloat16(self: ~T) -> ~T\n",
+      " |      Casts all floating point parameters and buffers to ``bfloat16`` datatype.\n",
+      " |      \n",
+      " |      .. note::\n",
+      " |          This method modifies the module in-place.\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          Module: self\n",
+      " |  \n",
+      " |  buffers(self, recurse: bool = True) -> Iterator[torch.Tensor]\n",
+      " |      Returns an iterator over module buffers.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          recurse (bool): if True, then yields buffers of this module\n",
+      " |              and all submodules. Otherwise, yields only buffers that\n",
+      " |              are direct members of this module.\n",
+      " |      \n",
+      " |      Yields:\n",
+      " |          torch.Tensor: module buffer\n",
+      " |      \n",
+      " |      Example::\n",
+      " |      \n",
+      " |          >>> # xdoctest: +SKIP(\"undefined vars\")\n",
+      " |          >>> for buf in model.buffers():\n",
+      " |          >>>     print(type(buf), buf.size())\n",
+      " |          <class 'torch.Tensor'> (20L,)\n",
+      " |          <class 'torch.Tensor'> (20L, 1L, 5L, 5L)\n",
+      " |  \n",
+      " |  children(self) -> Iterator[ForwardRef('Module')]\n",
+      " |      Returns an iterator over immediate children modules.\n",
+      " |      \n",
+      " |      Yields:\n",
+      " |          Module: a child module\n",
+      " |  \n",
+      " |  cpu(self: ~T) -> ~T\n",
+      " |      Moves all model parameters and buffers to the CPU.\n",
+      " |      \n",
+      " |      .. note::\n",
+      " |          This method modifies the module in-place.\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          Module: self\n",
+      " |  \n",
+      " |  cuda(self: ~T, device: Union[int, torch.device, NoneType] = None) -> ~T\n",
+      " |      Moves all model parameters and buffers to the GPU.\n",
+      " |      \n",
+      " |      This also makes associated parameters and buffers different objects. So\n",
+      " |      it should be called before constructing optimizer if the module will\n",
+      " |      live on GPU while being optimized.\n",
+      " |      \n",
+      " |      .. note::\n",
+      " |          This method modifies the module in-place.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          device (int, optional): if specified, all parameters will be\n",
+      " |              copied to that device\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          Module: self\n",
+      " |  \n",
+      " |  double(self: ~T) -> ~T\n",
+      " |      Casts all floating point parameters and buffers to ``double`` datatype.\n",
+      " |      \n",
+      " |      .. note::\n",
+      " |          This method modifies the module in-place.\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          Module: self\n",
+      " |  \n",
+      " |  eval(self: ~T) -> ~T\n",
+      " |      Sets the module in evaluation mode.\n",
+      " |      \n",
+      " |      This has any effect only on certain modules. See documentations of\n",
+      " |      particular modules for details of their behaviors in training/evaluation\n",
+      " |      mode, if they are affected, e.g. :class:`Dropout`, :class:`BatchNorm`,\n",
+      " |      etc.\n",
+      " |      \n",
+      " |      This is equivalent with :meth:`self.train(False) <torch.nn.Module.train>`.\n",
+      " |      \n",
+      " |      See :ref:`locally-disable-grad-doc` for a comparison between\n",
+      " |      `.eval()` and several similar mechanisms that may be confused with it.\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          Module: self\n",
+      " |  \n",
+      " |  float(self: ~T) -> ~T\n",
+      " |      Casts all floating point parameters and buffers to ``float`` datatype.\n",
+      " |      \n",
+      " |      .. note::\n",
+      " |          This method modifies the module in-place.\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          Module: self\n",
+      " |  \n",
+      " |  get_buffer(self, target: str) -> 'Tensor'\n",
+      " |      Returns the buffer given by ``target`` if it exists,\n",
+      " |      otherwise throws an error.\n",
+      " |      \n",
+      " |      See the docstring for ``get_submodule`` for a more detailed\n",
+      " |      explanation of this method's functionality as well as how to\n",
+      " |      correctly specify ``target``.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          target: The fully-qualified string name of the buffer\n",
+      " |              to look for. (See ``get_submodule`` for how to specify a\n",
+      " |              fully-qualified string.)\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          torch.Tensor: The buffer referenced by ``target``\n",
+      " |      \n",
+      " |      Raises:\n",
+      " |          AttributeError: If the target string references an invalid\n",
+      " |              path or resolves to something that is not a\n",
+      " |              buffer\n",
+      " |  \n",
+      " |  get_extra_state(self) -> Any\n",
+      " |      Returns any extra state to include in the module's state_dict.\n",
+      " |      Implement this and a corresponding :func:`set_extra_state` for your module\n",
+      " |      if you need to store extra state. This function is called when building the\n",
+      " |      module's `state_dict()`.\n",
+      " |      \n",
+      " |      Note that extra state should be picklable to ensure working serialization\n",
+      " |      of the state_dict. We only provide provide backwards compatibility guarantees\n",
+      " |      for serializing Tensors; other objects may break backwards compatibility if\n",
+      " |      their serialized pickled form changes.\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          object: Any extra state to store in the module's state_dict\n",
+      " |  \n",
+      " |  get_parameter(self, target: str) -> 'Parameter'\n",
+      " |      Returns the parameter given by ``target`` if it exists,\n",
+      " |      otherwise throws an error.\n",
+      " |      \n",
+      " |      See the docstring for ``get_submodule`` for a more detailed\n",
+      " |      explanation of this method's functionality as well as how to\n",
+      " |      correctly specify ``target``.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          target: The fully-qualified string name of the Parameter\n",
+      " |              to look for. (See ``get_submodule`` for how to specify a\n",
+      " |              fully-qualified string.)\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          torch.nn.Parameter: The Parameter referenced by ``target``\n",
+      " |      \n",
+      " |      Raises:\n",
+      " |          AttributeError: If the target string references an invalid\n",
+      " |              path or resolves to something that is not an\n",
+      " |              ``nn.Parameter``\n",
+      " |  \n",
+      " |  get_submodule(self, target: str) -> 'Module'\n",
+      " |      Returns the submodule given by ``target`` if it exists,\n",
+      " |      otherwise throws an error.\n",
+      " |      \n",
+      " |      For example, let's say you have an ``nn.Module`` ``A`` that\n",
+      " |      looks like this:\n",
+      " |      \n",
+      " |      .. code-block:: text\n",
+      " |      \n",
+      " |          A(\n",
+      " |              (net_b): Module(\n",
+      " |                  (net_c): Module(\n",
+      " |                      (conv): Conv2d(16, 33, kernel_size=(3, 3), stride=(2, 2))\n",
+      " |                  )\n",
+      " |                  (linear): Linear(in_features=100, out_features=200, bias=True)\n",
+      " |              )\n",
+      " |          )\n",
+      " |      \n",
+      " |      (The diagram shows an ``nn.Module`` ``A``. ``A`` has a nested\n",
+      " |      submodule ``net_b``, which itself has two submodules ``net_c``\n",
+      " |      and ``linear``. ``net_c`` then has a submodule ``conv``.)\n",
+      " |      \n",
+      " |      To check whether or not we have the ``linear`` submodule, we\n",
+      " |      would call ``get_submodule(\"net_b.linear\")``. To check whether\n",
+      " |      we have the ``conv`` submodule, we would call\n",
+      " |      ``get_submodule(\"net_b.net_c.conv\")``.\n",
+      " |      \n",
+      " |      The runtime of ``get_submodule`` is bounded by the degree\n",
+      " |      of module nesting in ``target``. A query against\n",
+      " |      ``named_modules`` achieves the same result, but it is O(N) in\n",
+      " |      the number of transitive modules. So, for a simple check to see\n",
+      " |      if some submodule exists, ``get_submodule`` should always be\n",
+      " |      used.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          target: The fully-qualified string name of the submodule\n",
+      " |              to look for. (See above example for how to specify a\n",
+      " |              fully-qualified string.)\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          torch.nn.Module: The submodule referenced by ``target``\n",
+      " |      \n",
+      " |      Raises:\n",
+      " |          AttributeError: If the target string references an invalid\n",
+      " |              path or resolves to something that is not an\n",
+      " |              ``nn.Module``\n",
+      " |  \n",
+      " |  half(self: ~T) -> ~T\n",
+      " |      Casts all floating point parameters and buffers to ``half`` datatype.\n",
+      " |      \n",
+      " |      .. note::\n",
+      " |          This method modifies the module in-place.\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          Module: self\n",
+      " |  \n",
+      " |  ipu(self: ~T, device: Union[int, torch.device, NoneType] = None) -> ~T\n",
+      " |      Moves all model parameters and buffers to the IPU.\n",
+      " |      \n",
+      " |      This also makes associated parameters and buffers different objects. So\n",
+      " |      it should be called before constructing optimizer if the module will\n",
+      " |      live on IPU while being optimized.\n",
+      " |      \n",
+      " |      .. note::\n",
+      " |          This method modifies the module in-place.\n",
+      " |      \n",
+      " |      Arguments:\n",
+      " |          device (int, optional): if specified, all parameters will be\n",
+      " |              copied to that device\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          Module: self\n",
+      " |  \n",
+      " |  load_state_dict(self, state_dict: Mapping[str, Any], strict: bool = True)\n",
+      " |      Copies parameters and buffers from :attr:`state_dict` into\n",
+      " |      this module and its descendants. If :attr:`strict` is ``True``, then\n",
+      " |      the keys of :attr:`state_dict` must exactly match the keys returned\n",
+      " |      by this module's :meth:`~torch.nn.Module.state_dict` function.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          state_dict (dict): a dict containing parameters and\n",
+      " |              persistent buffers.\n",
+      " |          strict (bool, optional): whether to strictly enforce that the keys\n",
+      " |              in :attr:`state_dict` match the keys returned by this module's\n",
+      " |              :meth:`~torch.nn.Module.state_dict` function. Default: ``True``\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          ``NamedTuple`` with ``missing_keys`` and ``unexpected_keys`` fields:\n",
+      " |              * **missing_keys** is a list of str containing the missing keys\n",
+      " |              * **unexpected_keys** is a list of str containing the unexpected keys\n",
+      " |      \n",
+      " |      Note:\n",
+      " |          If a parameter or buffer is registered as ``None`` and its corresponding key\n",
+      " |          exists in :attr:`state_dict`, :meth:`load_state_dict` will raise a\n",
+      " |          ``RuntimeError``.\n",
+      " |  \n",
+      " |  modules(self) -> Iterator[ForwardRef('Module')]\n",
+      " |      Returns an iterator over all modules in the network.\n",
+      " |      \n",
+      " |      Yields:\n",
+      " |          Module: a module in the network\n",
+      " |      \n",
+      " |      Note:\n",
+      " |          Duplicate modules are returned only once. In the following\n",
+      " |          example, ``l`` will be returned only once.\n",
+      " |      \n",
+      " |      Example::\n",
+      " |      \n",
+      " |          >>> l = nn.Linear(2, 2)\n",
+      " |          >>> net = nn.Sequential(l, l)\n",
+      " |          >>> for idx, m in enumerate(net.modules()):\n",
+      " |          ...     print(idx, '->', m)\n",
+      " |      \n",
+      " |          0 -> Sequential(\n",
+      " |            (0): Linear(in_features=2, out_features=2, bias=True)\n",
+      " |            (1): Linear(in_features=2, out_features=2, bias=True)\n",
+      " |          )\n",
+      " |          1 -> Linear(in_features=2, out_features=2, bias=True)\n",
+      " |  \n",
+      " |  named_buffers(self, prefix: str = '', recurse: bool = True, remove_duplicate: bool = True) -> Iterator[Tuple[str, torch.Tensor]]\n",
+      " |      Returns an iterator over module buffers, yielding both the\n",
+      " |      name of the buffer as well as the buffer itself.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          prefix (str): prefix to prepend to all buffer names.\n",
+      " |          recurse (bool, optional): if True, then yields buffers of this module\n",
+      " |              and all submodules. Otherwise, yields only buffers that\n",
+      " |              are direct members of this module. Defaults to True.\n",
+      " |          remove_duplicate (bool, optional): whether to remove the duplicated buffers in the result. Defaults to True.\n",
+      " |      \n",
+      " |      Yields:\n",
+      " |          (str, torch.Tensor): Tuple containing the name and buffer\n",
+      " |      \n",
+      " |      Example::\n",
+      " |      \n",
+      " |          >>> # xdoctest: +SKIP(\"undefined vars\")\n",
+      " |          >>> for name, buf in self.named_buffers():\n",
+      " |          >>>     if name in ['running_var']:\n",
+      " |          >>>         print(buf.size())\n",
+      " |  \n",
+      " |  named_children(self) -> Iterator[Tuple[str, ForwardRef('Module')]]\n",
+      " |      Returns an iterator over immediate children modules, yielding both\n",
+      " |      the name of the module as well as the module itself.\n",
+      " |      \n",
+      " |      Yields:\n",
+      " |          (str, Module): Tuple containing a name and child module\n",
+      " |      \n",
+      " |      Example::\n",
+      " |      \n",
+      " |          >>> # xdoctest: +SKIP(\"undefined vars\")\n",
+      " |          >>> for name, module in model.named_children():\n",
+      " |          >>>     if name in ['conv4', 'conv5']:\n",
+      " |          >>>         print(module)\n",
+      " |  \n",
+      " |  named_modules(self, memo: Optional[Set[ForwardRef('Module')]] = None, prefix: str = '', remove_duplicate: bool = True)\n",
+      " |      Returns an iterator over all modules in the network, yielding\n",
+      " |      both the name of the module as well as the module itself.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          memo: a memo to store the set of modules already added to the result\n",
+      " |          prefix: a prefix that will be added to the name of the module\n",
+      " |          remove_duplicate: whether to remove the duplicated module instances in the result\n",
+      " |              or not\n",
+      " |      \n",
+      " |      Yields:\n",
+      " |          (str, Module): Tuple of name and module\n",
+      " |      \n",
+      " |      Note:\n",
+      " |          Duplicate modules are returned only once. In the following\n",
+      " |          example, ``l`` will be returned only once.\n",
+      " |      \n",
+      " |      Example::\n",
+      " |      \n",
+      " |          >>> l = nn.Linear(2, 2)\n",
+      " |          >>> net = nn.Sequential(l, l)\n",
+      " |          >>> for idx, m in enumerate(net.named_modules()):\n",
+      " |          ...     print(idx, '->', m)\n",
+      " |      \n",
+      " |          0 -> ('', Sequential(\n",
+      " |            (0): Linear(in_features=2, out_features=2, bias=True)\n",
+      " |            (1): Linear(in_features=2, out_features=2, bias=True)\n",
+      " |          ))\n",
+      " |          1 -> ('0', Linear(in_features=2, out_features=2, bias=True))\n",
+      " |  \n",
+      " |  named_parameters(self, prefix: str = '', recurse: bool = True, remove_duplicate: bool = True) -> Iterator[Tuple[str, torch.nn.parameter.Parameter]]\n",
+      " |      Returns an iterator over module parameters, yielding both the\n",
+      " |      name of the parameter as well as the parameter itself.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          prefix (str): prefix to prepend to all parameter names.\n",
+      " |          recurse (bool): if True, then yields parameters of this module\n",
+      " |              and all submodules. Otherwise, yields only parameters that\n",
+      " |              are direct members of this module.\n",
+      " |          remove_duplicate (bool, optional): whether to remove the duplicated\n",
+      " |              parameters in the result. Defaults to True.\n",
+      " |      \n",
+      " |      Yields:\n",
+      " |          (str, Parameter): Tuple containing the name and parameter\n",
+      " |      \n",
+      " |      Example::\n",
+      " |      \n",
+      " |          >>> # xdoctest: +SKIP(\"undefined vars\")\n",
+      " |          >>> for name, param in self.named_parameters():\n",
+      " |          >>>     if name in ['bias']:\n",
+      " |          >>>         print(param.size())\n",
+      " |  \n",
+      " |  parameters(self, recurse: bool = True) -> Iterator[torch.nn.parameter.Parameter]\n",
+      " |      Returns an iterator over module parameters.\n",
+      " |      \n",
+      " |      This is typically passed to an optimizer.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          recurse (bool): if True, then yields parameters of this module\n",
+      " |              and all submodules. Otherwise, yields only parameters that\n",
+      " |              are direct members of this module.\n",
+      " |      \n",
+      " |      Yields:\n",
+      " |          Parameter: module parameter\n",
+      " |      \n",
+      " |      Example::\n",
+      " |      \n",
+      " |          >>> # xdoctest: +SKIP(\"undefined vars\")\n",
+      " |          >>> for param in model.parameters():\n",
+      " |          >>>     print(type(param), param.size())\n",
+      " |          <class 'torch.Tensor'> (20L,)\n",
+      " |          <class 'torch.Tensor'> (20L, 1L, 5L, 5L)\n",
+      " |  \n",
+      " |  register_backward_hook(self, hook: Callable[[ForwardRef('Module'), Union[Tuple[torch.Tensor, ...], torch.Tensor], Union[Tuple[torch.Tensor, ...], torch.Tensor]], Union[NoneType, Tuple[torch.Tensor, ...], torch.Tensor]]) -> torch.utils.hooks.RemovableHandle\n",
+      " |      Registers a backward hook on the module.\n",
+      " |      \n",
+      " |      This function is deprecated in favor of :meth:`~torch.nn.Module.register_full_backward_hook` and\n",
+      " |      the behavior of this function will change in future versions.\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          :class:`torch.utils.hooks.RemovableHandle`:\n",
+      " |              a handle that can be used to remove the added hook by calling\n",
+      " |              ``handle.remove()``\n",
+      " |  \n",
+      " |  register_buffer(self, name: str, tensor: Optional[torch.Tensor], persistent: bool = True) -> None\n",
+      " |      Adds a buffer to the module.\n",
+      " |      \n",
+      " |      This is typically used to register a buffer that should not to be\n",
+      " |      considered a model parameter. For example, BatchNorm's ``running_mean``\n",
+      " |      is not a parameter, but is part of the module's state. Buffers, by\n",
+      " |      default, are persistent and will be saved alongside parameters. This\n",
+      " |      behavior can be changed by setting :attr:`persistent` to ``False``. The\n",
+      " |      only difference between a persistent buffer and a non-persistent buffer\n",
+      " |      is that the latter will not be a part of this module's\n",
+      " |      :attr:`state_dict`.\n",
+      " |      \n",
+      " |      Buffers can be accessed as attributes using given names.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          name (str): name of the buffer. The buffer can be accessed\n",
+      " |              from this module using the given name\n",
+      " |          tensor (Tensor or None): buffer to be registered. If ``None``, then operations\n",
+      " |              that run on buffers, such as :attr:`cuda`, are ignored. If ``None``,\n",
+      " |              the buffer is **not** included in the module's :attr:`state_dict`.\n",
+      " |          persistent (bool): whether the buffer is part of this module's\n",
+      " |              :attr:`state_dict`.\n",
+      " |      \n",
+      " |      Example::\n",
+      " |      \n",
+      " |          >>> # xdoctest: +SKIP(\"undefined vars\")\n",
+      " |          >>> self.register_buffer('running_mean', torch.zeros(num_features))\n",
+      " |  \n",
+      " |  register_forward_hook(self, hook: Union[Callable[[~T, Tuple[Any, ...], Any], Optional[Any]], Callable[[~T, Tuple[Any, ...], Dict[str, Any], Any], Optional[Any]]], *, prepend: bool = False, with_kwargs: bool = False) -> torch.utils.hooks.RemovableHandle\n",
+      " |      Registers a forward hook on the module.\n",
+      " |      \n",
+      " |      The hook will be called every time after :func:`forward` has computed an output.\n",
+      " |      \n",
+      " |      If ``with_kwargs`` is ``False`` or not specified, the input contains only\n",
+      " |      the positional arguments given to the module. Keyword arguments won't be\n",
+      " |      passed to the hooks and only to the ``forward``. The hook can modify the\n",
+      " |      output. It can modify the input inplace but it will not have effect on\n",
+      " |      forward since this is called after :func:`forward` is called. The hook\n",
+      " |      should have the following signature::\n",
+      " |      \n",
+      " |          hook(module, args, output) -> None or modified output\n",
+      " |      \n",
+      " |      If ``with_kwargs`` is ``True``, the forward hook will be passed the\n",
+      " |      ``kwargs`` given to the forward function and be expected to return the\n",
+      " |      output possibly modified. The hook should have the following signature::\n",
+      " |      \n",
+      " |          hook(module, args, kwargs, output) -> None or modified output\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          hook (Callable): The user defined hook to be registered.\n",
+      " |          prepend (bool): If ``True``, the provided ``hook`` will be fired\n",
+      " |              before all existing ``forward`` hooks on this\n",
+      " |              :class:`torch.nn.modules.Module`. Otherwise, the provided\n",
+      " |              ``hook`` will be fired after all existing ``forward`` hooks on\n",
+      " |              this :class:`torch.nn.modules.Module`. Note that global\n",
+      " |              ``forward`` hooks registered with\n",
+      " |              :func:`register_module_forward_hook` will fire before all hooks\n",
+      " |              registered by this method.\n",
+      " |              Default: ``False``\n",
+      " |          with_kwargs (bool): If ``True``, the ``hook`` will be passed the\n",
+      " |              kwargs given to the forward function.\n",
+      " |              Default: ``False``\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          :class:`torch.utils.hooks.RemovableHandle`:\n",
+      " |              a handle that can be used to remove the added hook by calling\n",
+      " |              ``handle.remove()``\n",
+      " |  \n",
+      " |  register_forward_pre_hook(self, hook: Union[Callable[[~T, Tuple[Any, ...]], Optional[Any]], Callable[[~T, Tuple[Any, ...], Dict[str, Any]], Optional[Tuple[Any, Dict[str, Any]]]]], *, prepend: bool = False, with_kwargs: bool = False) -> torch.utils.hooks.RemovableHandle\n",
+      " |      Registers a forward pre-hook on the module.\n",
+      " |      \n",
+      " |      The hook will be called every time before :func:`forward` is invoked.\n",
+      " |      \n",
+      " |      \n",
+      " |      If ``with_kwargs`` is false or not specified, the input contains only\n",
+      " |      the positional arguments given to the module. Keyword arguments won't be\n",
+      " |      passed to the hooks and only to the ``forward``. The hook can modify the\n",
+      " |      input. User can either return a tuple or a single modified value in the\n",
+      " |      hook. We will wrap the value into a tuple if a single value is returned\n",
+      " |      (unless that value is already a tuple). The hook should have the\n",
+      " |      following signature::\n",
+      " |      \n",
+      " |          hook(module, args) -> None or modified input\n",
+      " |      \n",
+      " |      If ``with_kwargs`` is true, the forward pre-hook will be passed the\n",
+      " |      kwargs given to the forward function. And if the hook modifies the\n",
+      " |      input, both the args and kwargs should be returned. The hook should have\n",
+      " |      the following signature::\n",
+      " |      \n",
+      " |          hook(module, args, kwargs) -> None or a tuple of modified input and kwargs\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          hook (Callable): The user defined hook to be registered.\n",
+      " |          prepend (bool): If true, the provided ``hook`` will be fired before\n",
+      " |              all existing ``forward_pre`` hooks on this\n",
+      " |              :class:`torch.nn.modules.Module`. Otherwise, the provided\n",
+      " |              ``hook`` will be fired after all existing ``forward_pre`` hooks\n",
+      " |              on this :class:`torch.nn.modules.Module`. Note that global\n",
+      " |              ``forward_pre`` hooks registered with\n",
+      " |              :func:`register_module_forward_pre_hook` will fire before all\n",
+      " |              hooks registered by this method.\n",
+      " |              Default: ``False``\n",
+      " |          with_kwargs (bool): If true, the ``hook`` will be passed the kwargs\n",
+      " |              given to the forward function.\n",
+      " |              Default: ``False``\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          :class:`torch.utils.hooks.RemovableHandle`:\n",
+      " |              a handle that can be used to remove the added hook by calling\n",
+      " |              ``handle.remove()``\n",
+      " |  \n",
+      " |  register_full_backward_hook(self, hook: Callable[[ForwardRef('Module'), Union[Tuple[torch.Tensor, ...], torch.Tensor], Union[Tuple[torch.Tensor, ...], torch.Tensor]], Union[NoneType, Tuple[torch.Tensor, ...], torch.Tensor]], prepend: bool = False) -> torch.utils.hooks.RemovableHandle\n",
+      " |      Registers a backward hook on the module.\n",
+      " |      \n",
+      " |      The hook will be called every time the gradients with respect to a module\n",
+      " |      are computed, i.e. the hook will execute if and only if the gradients with\n",
+      " |      respect to module outputs are computed. The hook should have the following\n",
+      " |      signature::\n",
+      " |      \n",
+      " |          hook(module, grad_input, grad_output) -> tuple(Tensor) or None\n",
+      " |      \n",
+      " |      The :attr:`grad_input` and :attr:`grad_output` are tuples that contain the gradients\n",
+      " |      with respect to the inputs and outputs respectively. The hook should\n",
+      " |      not modify its arguments, but it can optionally return a new gradient with\n",
+      " |      respect to the input that will be used in place of :attr:`grad_input` in\n",
+      " |      subsequent computations. :attr:`grad_input` will only correspond to the inputs given\n",
+      " |      as positional arguments and all kwarg arguments are ignored. Entries\n",
+      " |      in :attr:`grad_input` and :attr:`grad_output` will be ``None`` for all non-Tensor\n",
+      " |      arguments.\n",
+      " |      \n",
+      " |      For technical reasons, when this hook is applied to a Module, its forward function will\n",
+      " |      receive a view of each Tensor passed to the Module. Similarly the caller will receive a view\n",
+      " |      of each Tensor returned by the Module's forward function.\n",
+      " |      \n",
+      " |      .. warning ::\n",
+      " |          Modifying inputs or outputs inplace is not allowed when using backward hooks and\n",
+      " |          will raise an error.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          hook (Callable): The user-defined hook to be registered.\n",
+      " |          prepend (bool): If true, the provided ``hook`` will be fired before\n",
+      " |              all existing ``backward`` hooks on this\n",
+      " |              :class:`torch.nn.modules.Module`. Otherwise, the provided\n",
+      " |              ``hook`` will be fired after all existing ``backward`` hooks on\n",
+      " |              this :class:`torch.nn.modules.Module`. Note that global\n",
+      " |              ``backward`` hooks registered with\n",
+      " |              :func:`register_module_full_backward_hook` will fire before\n",
+      " |              all hooks registered by this method.\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          :class:`torch.utils.hooks.RemovableHandle`:\n",
+      " |              a handle that can be used to remove the added hook by calling\n",
+      " |              ``handle.remove()``\n",
+      " |  \n",
+      " |  register_full_backward_pre_hook(self, hook: Callable[[ForwardRef('Module'), Union[Tuple[torch.Tensor, ...], torch.Tensor]], Union[NoneType, Tuple[torch.Tensor, ...], torch.Tensor]], prepend: bool = False) -> torch.utils.hooks.RemovableHandle\n",
+      " |      Registers a backward pre-hook on the module.\n",
+      " |      \n",
+      " |      The hook will be called every time the gradients for the module are computed.\n",
+      " |      The hook should have the following signature::\n",
+      " |      \n",
+      " |          hook(module, grad_output) -> Tensor or None\n",
+      " |      \n",
+      " |      The :attr:`grad_output` is a tuple. The hook should\n",
+      " |      not modify its arguments, but it can optionally return a new gradient with\n",
+      " |      respect to the output that will be used in place of :attr:`grad_output` in\n",
+      " |      subsequent computations. Entries in :attr:`grad_output` will be ``None`` for\n",
+      " |      all non-Tensor arguments.\n",
+      " |      \n",
+      " |      For technical reasons, when this hook is applied to a Module, its forward function will\n",
+      " |      receive a view of each Tensor passed to the Module. Similarly the caller will receive a view\n",
+      " |      of each Tensor returned by the Module's forward function.\n",
+      " |      \n",
+      " |      .. warning ::\n",
+      " |          Modifying inputs inplace is not allowed when using backward hooks and\n",
+      " |          will raise an error.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          hook (Callable): The user-defined hook to be registered.\n",
+      " |          prepend (bool): If true, the provided ``hook`` will be fired before\n",
+      " |              all existing ``backward_pre`` hooks on this\n",
+      " |              :class:`torch.nn.modules.Module`. Otherwise, the provided\n",
+      " |              ``hook`` will be fired after all existing ``backward_pre`` hooks\n",
+      " |              on this :class:`torch.nn.modules.Module`. Note that global\n",
+      " |              ``backward_pre`` hooks registered with\n",
+      " |              :func:`register_module_full_backward_pre_hook` will fire before\n",
+      " |              all hooks registered by this method.\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          :class:`torch.utils.hooks.RemovableHandle`:\n",
+      " |              a handle that can be used to remove the added hook by calling\n",
+      " |              ``handle.remove()``\n",
+      " |  \n",
+      " |  register_load_state_dict_post_hook(self, hook)\n",
+      " |      Registers a post hook to be run after module's ``load_state_dict``\n",
+      " |      is called.\n",
+      " |      \n",
+      " |      It should have the following signature::\n",
+      " |          hook(module, incompatible_keys) -> None\n",
+      " |      \n",
+      " |      The ``module`` argument is the current module that this hook is registered\n",
+      " |      on, and the ``incompatible_keys`` argument is a ``NamedTuple`` consisting\n",
+      " |      of attributes ``missing_keys`` and ``unexpected_keys``. ``missing_keys``\n",
+      " |      is a ``list`` of ``str`` containing the missing keys and\n",
+      " |      ``unexpected_keys`` is a ``list`` of ``str`` containing the unexpected keys.\n",
+      " |      \n",
+      " |      The given incompatible_keys can be modified inplace if needed.\n",
+      " |      \n",
+      " |      Note that the checks performed when calling :func:`load_state_dict` with\n",
+      " |      ``strict=True`` are affected by modifications the hook makes to\n",
+      " |      ``missing_keys`` or ``unexpected_keys``, as expected. Additions to either\n",
+      " |      set of keys will result in an error being thrown when ``strict=True``, and\n",
+      " |      clearing out both missing and unexpected keys will avoid an error.\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          :class:`torch.utils.hooks.RemovableHandle`:\n",
+      " |              a handle that can be used to remove the added hook by calling\n",
+      " |              ``handle.remove()``\n",
+      " |  \n",
+      " |  register_module(self, name: str, module: Optional[ForwardRef('Module')]) -> None\n",
+      " |      Alias for :func:`add_module`.\n",
+      " |  \n",
+      " |  register_parameter(self, name: str, param: Optional[torch.nn.parameter.Parameter]) -> None\n",
+      " |      Adds a parameter to the module.\n",
+      " |      \n",
+      " |      The parameter can be accessed as an attribute using given name.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          name (str): name of the parameter. The parameter can be accessed\n",
+      " |              from this module using the given name\n",
+      " |          param (Parameter or None): parameter to be added to the module. If\n",
+      " |              ``None``, then operations that run on parameters, such as :attr:`cuda`,\n",
+      " |              are ignored. If ``None``, the parameter is **not** included in the\n",
+      " |              module's :attr:`state_dict`.\n",
+      " |  \n",
+      " |  register_state_dict_pre_hook(self, hook)\n",
+      " |      These hooks will be called with arguments: ``self``, ``prefix``,\n",
+      " |      and ``keep_vars`` before calling ``state_dict`` on ``self``. The registered\n",
+      " |      hooks can be used to perform pre-processing before the ``state_dict``\n",
+      " |      call is made.\n",
+      " |  \n",
+      " |  requires_grad_(self: ~T, requires_grad: bool = True) -> ~T\n",
+      " |      Change if autograd should record operations on parameters in this\n",
+      " |      module.\n",
+      " |      \n",
+      " |      This method sets the parameters' :attr:`requires_grad` attributes\n",
+      " |      in-place.\n",
+      " |      \n",
+      " |      This method is helpful for freezing part of the module for finetuning\n",
+      " |      or training parts of a model individually (e.g., GAN training).\n",
+      " |      \n",
+      " |      See :ref:`locally-disable-grad-doc` for a comparison between\n",
+      " |      `.requires_grad_()` and several similar mechanisms that may be confused with it.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          requires_grad (bool): whether autograd should record operations on\n",
+      " |                                parameters in this module. Default: ``True``.\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          Module: self\n",
+      " |  \n",
+      " |  set_extra_state(self, state: Any)\n",
+      " |      This function is called from :func:`load_state_dict` to handle any extra state\n",
+      " |      found within the `state_dict`. Implement this function and a corresponding\n",
+      " |      :func:`get_extra_state` for your module if you need to store extra state within its\n",
+      " |      `state_dict`.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          state (dict): Extra state from the `state_dict`\n",
+      " |  \n",
+      " |  share_memory(self: ~T) -> ~T\n",
+      " |      See :meth:`torch.Tensor.share_memory_`\n",
+      " |  \n",
+      " |  state_dict(self, *args, destination=None, prefix='', keep_vars=False)\n",
+      " |      Returns a dictionary containing references to the whole state of the module.\n",
+      " |      \n",
+      " |      Both parameters and persistent buffers (e.g. running averages) are\n",
+      " |      included. Keys are corresponding parameter and buffer names.\n",
+      " |      Parameters and buffers set to ``None`` are not included.\n",
+      " |      \n",
+      " |      .. note::\n",
+      " |          The returned object is a shallow copy. It contains references\n",
+      " |          to the module's parameters and buffers.\n",
+      " |      \n",
+      " |      .. warning::\n",
+      " |          Currently ``state_dict()`` also accepts positional arguments for\n",
+      " |          ``destination``, ``prefix`` and ``keep_vars`` in order. However,\n",
+      " |          this is being deprecated and keyword arguments will be enforced in\n",
+      " |          future releases.\n",
+      " |      \n",
+      " |      .. warning::\n",
+      " |          Please avoid the use of argument ``destination`` as it is not\n",
+      " |          designed for end-users.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          destination (dict, optional): If provided, the state of module will\n",
+      " |              be updated into the dict and the same object is returned.\n",
+      " |              Otherwise, an ``OrderedDict`` will be created and returned.\n",
+      " |              Default: ``None``.\n",
+      " |          prefix (str, optional): a prefix added to parameter and buffer\n",
+      " |              names to compose the keys in state_dict. Default: ``''``.\n",
+      " |          keep_vars (bool, optional): by default the :class:`~torch.Tensor` s\n",
+      " |              returned in the state dict are detached from autograd. If it's\n",
+      " |              set to ``True``, detaching will not be performed.\n",
+      " |              Default: ``False``.\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          dict:\n",
+      " |              a dictionary containing a whole state of the module\n",
+      " |      \n",
+      " |      Example::\n",
+      " |      \n",
+      " |          >>> # xdoctest: +SKIP(\"undefined vars\")\n",
+      " |          >>> module.state_dict().keys()\n",
+      " |          ['bias', 'weight']\n",
+      " |  \n",
+      " |  to(self, *args, **kwargs)\n",
+      " |      Moves and/or casts the parameters and buffers.\n",
+      " |      \n",
+      " |      This can be called as\n",
+      " |      \n",
+      " |      .. function:: to(device=None, dtype=None, non_blocking=False)\n",
+      " |         :noindex:\n",
+      " |      \n",
+      " |      .. function:: to(dtype, non_blocking=False)\n",
+      " |         :noindex:\n",
+      " |      \n",
+      " |      .. function:: to(tensor, non_blocking=False)\n",
+      " |         :noindex:\n",
+      " |      \n",
+      " |      .. function:: to(memory_format=torch.channels_last)\n",
+      " |         :noindex:\n",
+      " |      \n",
+      " |      Its signature is similar to :meth:`torch.Tensor.to`, but only accepts\n",
+      " |      floating point or complex :attr:`dtype`\\ s. In addition, this method will\n",
+      " |      only cast the floating point or complex parameters and buffers to :attr:`dtype`\n",
+      " |      (if given). The integral parameters and buffers will be moved\n",
+      " |      :attr:`device`, if that is given, but with dtypes unchanged. When\n",
+      " |      :attr:`non_blocking` is set, it tries to convert/move asynchronously\n",
+      " |      with respect to the host if possible, e.g., moving CPU Tensors with\n",
+      " |      pinned memory to CUDA devices.\n",
+      " |      \n",
+      " |      See below for examples.\n",
+      " |      \n",
+      " |      .. note::\n",
+      " |          This method modifies the module in-place.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          device (:class:`torch.device`): the desired device of the parameters\n",
+      " |              and buffers in this module\n",
+      " |          dtype (:class:`torch.dtype`): the desired floating point or complex dtype of\n",
+      " |              the parameters and buffers in this module\n",
+      " |          tensor (torch.Tensor): Tensor whose dtype and device are the desired\n",
+      " |              dtype and device for all parameters and buffers in this module\n",
+      " |          memory_format (:class:`torch.memory_format`): the desired memory\n",
+      " |              format for 4D parameters and buffers in this module (keyword\n",
+      " |              only argument)\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          Module: self\n",
+      " |      \n",
+      " |      Examples::\n",
+      " |      \n",
+      " |          >>> # xdoctest: +IGNORE_WANT(\"non-deterministic\")\n",
+      " |          >>> linear = nn.Linear(2, 2)\n",
+      " |          >>> linear.weight\n",
+      " |          Parameter containing:\n",
+      " |          tensor([[ 0.1913, -0.3420],\n",
+      " |                  [-0.5113, -0.2325]])\n",
+      " |          >>> linear.to(torch.double)\n",
+      " |          Linear(in_features=2, out_features=2, bias=True)\n",
+      " |          >>> linear.weight\n",
+      " |          Parameter containing:\n",
+      " |          tensor([[ 0.1913, -0.3420],\n",
+      " |                  [-0.5113, -0.2325]], dtype=torch.float64)\n",
+      " |          >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_CUDA1)\n",
+      " |          >>> gpu1 = torch.device(\"cuda:1\")\n",
+      " |          >>> linear.to(gpu1, dtype=torch.half, non_blocking=True)\n",
+      " |          Linear(in_features=2, out_features=2, bias=True)\n",
+      " |          >>> linear.weight\n",
+      " |          Parameter containing:\n",
+      " |          tensor([[ 0.1914, -0.3420],\n",
+      " |                  [-0.5112, -0.2324]], dtype=torch.float16, device='cuda:1')\n",
+      " |          >>> cpu = torch.device(\"cpu\")\n",
+      " |          >>> linear.to(cpu)\n",
+      " |          Linear(in_features=2, out_features=2, bias=True)\n",
+      " |          >>> linear.weight\n",
+      " |          Parameter containing:\n",
+      " |          tensor([[ 0.1914, -0.3420],\n",
+      " |                  [-0.5112, -0.2324]], dtype=torch.float16)\n",
+      " |      \n",
+      " |          >>> linear = nn.Linear(2, 2, bias=None).to(torch.cdouble)\n",
+      " |          >>> linear.weight\n",
+      " |          Parameter containing:\n",
+      " |          tensor([[ 0.3741+0.j,  0.2382+0.j],\n",
+      " |                  [ 0.5593+0.j, -0.4443+0.j]], dtype=torch.complex128)\n",
+      " |          >>> linear(torch.ones(3, 2, dtype=torch.cdouble))\n",
+      " |          tensor([[0.6122+0.j, 0.1150+0.j],\n",
+      " |                  [0.6122+0.j, 0.1150+0.j],\n",
+      " |                  [0.6122+0.j, 0.1150+0.j]], dtype=torch.complex128)\n",
+      " |  \n",
+      " |  to_empty(self: ~T, *, device: Union[str, torch.device]) -> ~T\n",
+      " |      Moves the parameters and buffers to the specified device without copying storage.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          device (:class:`torch.device`): The desired device of the parameters\n",
+      " |              and buffers in this module.\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          Module: self\n",
+      " |  \n",
+      " |  train(self: ~T, mode: bool = True) -> ~T\n",
+      " |      Sets the module in training mode.\n",
+      " |      \n",
+      " |      This has any effect only on certain modules. See documentations of\n",
+      " |      particular modules for details of their behaviors in training/evaluation\n",
+      " |      mode, if they are affected, e.g. :class:`Dropout`, :class:`BatchNorm`,\n",
+      " |      etc.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          mode (bool): whether to set training mode (``True``) or evaluation\n",
+      " |                       mode (``False``). Default: ``True``.\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          Module: self\n",
+      " |  \n",
+      " |  type(self: ~T, dst_type: Union[torch.dtype, str]) -> ~T\n",
+      " |      Casts all parameters and buffers to :attr:`dst_type`.\n",
+      " |      \n",
+      " |      .. note::\n",
+      " |          This method modifies the module in-place.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          dst_type (type or string): the desired type\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          Module: self\n",
+      " |  \n",
+      " |  xpu(self: ~T, device: Union[int, torch.device, NoneType] = None) -> ~T\n",
+      " |      Moves all model parameters and buffers to the XPU.\n",
+      " |      \n",
+      " |      This also makes associated parameters and buffers different objects. So\n",
+      " |      it should be called before constructing optimizer if the module will\n",
+      " |      live on XPU while being optimized.\n",
+      " |      \n",
+      " |      .. note::\n",
+      " |          This method modifies the module in-place.\n",
+      " |      \n",
+      " |      Arguments:\n",
+      " |          device (int, optional): if specified, all parameters will be\n",
+      " |              copied to that device\n",
+      " |      \n",
+      " |      Returns:\n",
+      " |          Module: self\n",
+      " |  \n",
+      " |  zero_grad(self, set_to_none: bool = True) -> None\n",
+      " |      Sets gradients of all model parameters to zero. See similar function\n",
+      " |      under :class:`torch.optim.Optimizer` for more context.\n",
+      " |      \n",
+      " |      Args:\n",
+      " |          set_to_none (bool): instead of setting to zero, set the grads to None.\n",
+      " |              See :meth:`torch.optim.Optimizer.zero_grad` for details.\n",
+      " |  \n",
+      " |  ----------------------------------------------------------------------\n",
+      " |  Data descriptors inherited from torch.nn.modules.module.Module:\n",
+      " |  \n",
+      " |  __dict__\n",
+      " |      dictionary for instance variables (if defined)\n",
+      " |  \n",
+      " |  __weakref__\n",
+      " |      list of weak references to the object (if defined)\n",
+      " |  \n",
+      " |  ----------------------------------------------------------------------\n",
+      " |  Data and other attributes inherited from torch.nn.modules.module.Module:\n",
+      " |  \n",
+      " |  T_destination = ~T_destination\n",
+      " |  \n",
+      " |  call_super_init = False\n",
+      " |  \n",
+      " |  dump_patches = False\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "help(nn.Linear)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "71647469-0803-425c-836d-7623abc7bdd6",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python (mistral)",
+   "language": "python",
+   "name": "mistral"
+  },
+  "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.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

OVM/OVM/.ipynb_checkpoints/build_verifier-checkpoint.py

@@ -0,0 +1,100 @@
+from transformers.generation.utils import ModelOutput
+from transformers import PreTrainedModel
+from typing import Optional, List, Dict
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from dataclasses import dataclass
+
+@dataclass
+class VerifierModelOutput(ModelOutput):
+    loss: Optional[torch.FloatTensor] = None
+    v_scores: torch.FloatTensor = None
+    all_losses: Optional[Dict[str, torch.FloatTensor]] = None
+
+class VerifierModel(nn.Module):
+    def __init__(self, backbone, checkpoint_dir = None):
+        super(VerifierModel, self).__init__()
+        self.backbone = backbone
+        
+        device = self.backbone.device
+        dtype = self.backbone.dtype
+
+        self.gain = nn.Parameter(
+            torch.randn((1,), device = device, dtype = dtype)
+        )
+        self.bias = nn.Parameter(
+            torch.randn((1,), device = device, dtype = dtype)
+        )
+        self.dropout = nn.Dropout(p = 0.2)
+        self.vscore_head = nn.Linear(self.backbone.get_input_embeddings().embedding_dim, 1, bias = False, device = device, dtype = dtype)
+        
+        if checkpoint_dir:
+            verifier_params = torch.load(checkpoint_dir)
+            self.load_state_dict(verifier_params, strict = False)
+            torch.cuda.empty_cache()
+        
+        else:
+            self.init_head_params()
+
+        self.pad_token_id = backbone.config.pad_token_id
+    
+    def init_head_params(self):
+        output_embeddings = self.backbone.get_output_embeddings().weight.data
+        output_embeddings_avg = output_embeddings.mean(dim = 0, keepdim = True)
+
+        self.vscore_head.weight = nn.Parameter(output_embeddings_avg)
+
+    def loss_fct(self, v_scores: torch.FloatTensor, v_labels: torch.LongTensor):
+        return self.mse_loss_with_mask(v_scores.squeeze(), v_labels.type_as(v_scores))
+    
+    def transform(self, last_hidden_states):
+        return self.gain * last_hidden_states + self.bias
+    
+    def forward(self,
+        input_ids: torch.LongTensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        labels: Optional[torch.LongTensor] = None,
+        v_labels: Optional[torch.LongTensor] = None,
+        output_all_losses: Optional[bool] = None,
+    ):
+        outputs = self.backbone(
+            input_ids = input_ids, 
+            attention_mask = attention_mask,
+            position_ids = position_ids,
+            past_key_values = past_key_values,
+            labels = labels, 
+            use_cache = False,
+            output_hidden_states = True, 
+            return_dict = True,
+        )
+        llm_logits = outputs.logits
+        llm_loss = outputs.loss
+        llm_hidden_states = outputs.hidden_states
+
+        v_hidden_states = self.transform(llm_hidden_states[-1])
+        v_scores = self.vscore_head(self.dropout(v_hidden_states))
+
+        v_loss, loss = None, None
+        if v_labels:
+            v_loss = self.loss_fct(v_scores, v_labels)
+            loss = v_loss + (llm_loss if labels is not None else 0)
+
+        all_losses = None
+        if output_all_losses:
+            all_losses = {'llm_loss': llm_loss, 'v_loss': v_loss}
+
+        return VerifierModelOutput(
+            loss = loss,
+            v_scores = v_scores,
+            all_losses = all_losses,
+        )
+
+    def mse_loss_with_mask(self, scores: torch.FloatTensor, labels: torch.FloatTensor, IGNORE_INDEX: int = -100):
+        scores = torch.where(labels.ne(IGNORE_INDEX), scores, 0)
+        labels = torch.where(labels.ne(IGNORE_INDEX), labels, 0)
+        return F.mse_loss(scores, labels, reduction = 'sum') / scores.shape[0]
+    
+

OVM/OVM/.ipynb_checkpoints/gen_solutions-1-checkpoint.py

@@ -0,0 +1,90 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"]="4,5,6,7"
+
+from datasets import load_dataset, Dataset
+import transformers
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from transformers import DataCollatorForSeq2Seq, get_scheduler
+import torch
+from peft import LoraConfig, PeftConfig, get_peft_model, PeftModel
+from torch.optim import AdamW
+from tqdm.auto import tqdm
+import os
+from prompt_template import Prompter
+
+dataset = load_dataset("longhoang06/Vi-GSM8K", split = "train")
+gen_size = 3750
+# gen_dataset = dataset.select(range(gen_size))
+# gen_dataset = dataset.select(range(1000))  # part 1
+gen_dataset = dataset.select(range(1000, 1500))  # part 2
+# gen_dataset = dataset.select(range(1500, 2500))  # part 3
+# gen_dataset = dataset.select(range(2500, 3750))  # part 4
+
+
+model_path = "mistralai/Mistral-7B-v0.1"
+peft_path = "checkpoint/generator"
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+tokenizer.pad_token = tokenizer.eos_token
+
+model = AutoModelForCausalLM.from_pretrained(model_path, device_map = "auto", torch_dtype = torch.bfloat16)
+model = PeftModel.from_pretrained(model, peft_path)
+model = model.merge_and_unload()
+
+def generator_and_save(dataset):
+    def get_answer(text):
+        return text.split("Đáp án:")[-1].strip()
+    
+    prompter = Prompter()
+    progress_bar = tqdm(range(len(dataset)))
+    results = []
+    
+    for d in dataset:
+        question = d["question"]
+        answer = d["answer"]
+        prompt = prompter.generate_prompt(instruction = question)
+        
+        input_ids = tokenizer(prompt, return_tensors = "pt").input_ids
+        with torch.no_grad():
+            outputs = model.generate(
+                input_ids = input_ids.to("cuda"),
+                max_new_tokens = 512,
+                temperature = 0.7,
+                top_k = 50,
+                top_p = 1,
+                num_return_sequences = 50,
+                bos_token_id = tokenizer.bos_token_id,
+                eos_token_id = tokenizer.eos_token_id,
+                do_sample = True,
+            ) 
+        outputs.to("cpu")
+        texts = tokenizer.batch_decode(outputs, skip_special_tokens = True)
+        texts = [prompter.get_response(text) for text in texts]
+        batch = [
+            {"question": question,
+             "answer": answer,
+             "candidate": candidate,
+             "label": True if get_answer(candidate) == get_answer(answer) else False
+            } for candidate in texts
+        ]
+        results.extend(batch)
+        del batch
+        del input_ids
+        progress_bar.update(1)
+    
+    new_dataset = Dataset.from_dict(
+        {"question": [d["question"] for d in results],
+         "answer": [d["answer"] for d in results],
+         "candidate": [d["candidate"] for d in results],
+         "label": [d["label"] for d in results],
+        }
+    )
+    
+    # new_dataset.save_to_disk("data/gen1")
+    new_dataset.save_to_disk("data/gen1-1000-1500")
+
+if __name__ == "__main__":
+    generator_and_save(gen_dataset)
+                
+        
+

OVM/OVM/.ipynb_checkpoints/gen_solutions-2-checkpoint.py

@@ -0,0 +1,83 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"]="2,3"
+
+from datasets import load_dataset, Dataset
+import transformers
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from transformers import DataCollatorForSeq2Seq, get_scheduler
+import torch
+from peft import LoraConfig, PeftConfig, get_peft_model, PeftModel
+from torch.optim import AdamW
+from tqdm.auto import tqdm
+import os
+from prompt_template import Prompter
+
+dataset = load_dataset("longhoang06/Vi-GSM8K", split = "train")
+gen_size = 3750
+gen_dataset = dataset.select(range(gen_size, 2*gen_size))
+
+model_path = "mistralai/Mistral-7B-v0.1"
+peft_path = "checkpoint/generator"
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+tokenizer.pad_token = tokenizer.eos_token
+
+model = AutoModelForCausalLM.from_pretrained(model_path, device_map = "auto", torch_dtype = torch.bfloat16)
+model = PeftModel.from_pretrained(model, peft_path)
+model = model.merge_and_unload()
+
+def generator_and_save(dataset):
+    def get_answer(text):
+        return text.split("Đáp án:")[-1].strip()
+    
+    prompter = Prompter()
+    progress_bar = tqdm(range(len(dataset)))
+    results = []
+    
+    for d in dataset:
+        question = d["question"]
+        answer = d["answer"]
+        prompt = prompter.generate_prompt(instruction = question)
+        
+        input_ids = tokenizer(prompt, return_tensors = "pt").input_ids
+        with torch.no_grad():
+            outputs = model.generate(
+                input_ids = input_ids.to("cuda"),
+                max_new_tokens = 512,
+                temperature = 0.7,
+                top_k = 50,
+                top_p = 1,
+                num_return_sequences = 50,
+                bos_token_id = tokenizer.bos_token_id,
+                eos_token_id = tokenizer.eos_token_id,
+                do_sample = True,
+            )
+        texts = tokenizer.batch_decode(outputs, skip_special_tokens = True)
+        texts = [prompter.get_response(text) for text in texts]
+        batch = [
+            {"question": question,
+             "answer": answer,
+             "candidate": candidate,
+             "label": True if get_answer(candidate) == get_answer(answer) else False
+            } for candidate in texts
+        ]
+        results.extend(batch)
+        del batch
+        del input_ids
+        progress_bar.update(1)
+    
+    new_dataset = Dataset.from_dict(
+        {"question": [d["question"] for d in results],
+         "answer": [d["answer"] for d in results],
+         "candidate": [d["candidate"] for d in results],
+         "label": [d["label"] for d in results],
+        }
+    )
+    
+    new_dataset.save_to_disk("data/gen2")
+
+if __name__ == "__main__":
+    generator_and_save(gen_dataset)
+                
+        
+

OVM/OVM/.ipynb_checkpoints/prompt_template-checkpoint.py

@@ -0,0 +1,29 @@
+class Prompter:
+    def __init__(self):
+        self.generator_template = "Dưới đây là một Instruction mô tả nhiệm vụ. Viết một Response hoàn thành yêu cầu một cách thích hợp.\n\n ### Instruction:\n{instruction}\n\n### Response: Hãy suy nghĩ từng bước.\n"
+        self.verifier_template = "### Câu hỏi: {question}\n### Trả lời: {answer}"
+        
+    def generator_prompt(
+        self,
+        instruction: str,
+        response: str = None,
+    ) -> str:
+        
+        prompt = self.generator_template.format(instruction = instruction)
+        if response:
+            prompt = f"{prompt}{response}"
+        return prompt
+    
+    def verifier_prompt(
+        self,
+        question: str,
+        answer: str,
+    ) -> str:
+        return self.verifier_template.format(question = question, answer = answer)
+    
+    def get_response(self, output: str) -> str:
+        parts = output.split("### Response: Hãy suy nghĩ từng bước.")
+        if len(parts) > 1:
+            return parts[1].strip()
+        else:
+            return ""

OVM/OVM/.ipynb_checkpoints/train_generator-checkpoint.py

@@ -0,0 +1,163 @@
+from datasets import load_dataset
+import transformers
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from transformers import DataCollatorForSeq2Seq, get_scheduler
+import torch
+from torch.utils.data import DataLoader
+from peft import LoraConfig, PeftConfig, get_peft_model
+from torch.optim import AdamW
+from tqdm import tqdm
+from torch.distributed import  destroy_process_group, init_process_group
+from torch.utils.data.distributed import DistributedSampler
+from torch.nn.utils import clip_grad_norm_
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data import SequentialSampler
+import os
+from prompt_template import Prompter
+
+backend = "nccl"
+init_process_group(backend = backend)
+local_rank = int(os.environ["LOCAL_RANK"])
+
+dataset = load_dataset("longhoang06/Vi-GSM8K", split = "train")
+train_size = 7500
+train_dataset = dataset.select(range(train_size))
+
+model_path = "mistralai/Mistral-7B-v0.1"
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+tokenizer.pad_token = tokenizer.eos_token
+
+prompter = Prompter() 
+max_length = 640
+train_dataset = train_dataset.filter(lambda x: len(tokenizer(prompter.generator_prompt(instruction = x["question"], response = x["answer"])).input_ids) + 1 <= max_length)
+
+def tokenize_fn(prompt: str):
+    result = tokenizer(
+        prompt,
+        truncation = True,
+        max_length = max_length,
+        padding = False,
+        return_tensors = None)
+    
+    if (   
+        result["input_ids"][-1] != tokenizer.eos_token_id
+        and len(result["input_ids"]) < max_length
+    ):    
+        result["input_ids"].append(tokenizer.eos_token_id)
+        result["attention_mask"].append(1)
+        
+    result["labels"] = result["input_ids"].copy()
+    return result
+
+def get_items(dataset):
+    full_prompt = prompter.generator_prompt(
+        dataset["question"],
+        dataset["answer"],
+    )
+        
+    tokenized_full_prompt = tokenize_fn(full_prompt)
+    return tokenized_full_prompt
+
+train_dataset = train_dataset.map(get_items, num_proc = 16)
+train_dataset = train_dataset.remove_columns(column_names = ["question", "answer"])
+
+train_dataloader = DataLoader(
+    train_dataset,
+    batch_size = 1,
+    sampler = DistributedSampler(train_dataset),
+    collate_fn = DataCollatorForSeq2Seq(
+        tokenizer = tokenizer,
+        padding = True,
+        return_tensors = "pt",
+    ),
+    pin_memory = True,
+)                    
+
+bnb_config = BitsAndBytesConfig(
+    load_in_4bit = True,
+    bnb_4bit_use_double_quant = False,
+    bnb_4bit_quant_type = "nf4",
+    bnb_4bit_compute_dtype = torch.bfloat16,
+)
+        
+model = AutoModelForCausalLM.from_pretrained(
+    model_path,
+    quantization_config = bnb_config,
+    device_map = {"": torch.device(f"cuda:{local_rank}")},
+    torch_dtype = torch.bfloat16,
+)
+
+r = 64
+lora_alpha = 16
+lora_dropout = 0.1
+
+lora_config = LoraConfig(
+    r = r,
+    lora_alpha = lora_alpha,
+    lora_dropout = lora_dropout,
+    bias = "none",
+    task_type = "CAUSAL_LM",
+    target_modules = [
+         "q_proj" , "k_proj" , "v_proj", "o_proj", "gate_proj" , "up_proj" ,"down_proj", "lm_head",
+    ]
+)
+
+model = get_peft_model(model, lora_config)
+
+model = model.to(f"cuda:{local_rank}")
+model = DDP(model, device_ids = [local_rank])
+
+def train():
+    
+    epochs = 3
+    lr = 2e-4
+    max_norm_value = 0.3
+    num_update_steps_per_epoch = len(train_dataloader)
+    num_steps = num_update_steps_per_epoch * epochs
+    warmup_ratio = 0.03
+    num_warmup_steps = int(warmup_ratio * num_steps)
+    optimizer = AdamW(model.parameters(), lr = lr, weight_decay = 0.001)
+    lr_scheduler = get_scheduler(
+        "cosine",
+        optimizer = optimizer,
+        num_warmup_steps = num_warmup_steps,
+        num_training_steps = num_steps,
+    )
+
+    def is_master_process():
+        ddp_rank = int(os.environ['RANK'])
+        return ddp_rank == 0
+        
+    logging_steps = 100
+    for epoch in range(epochs):
+        train_dataloader.sampler.set_epoch(epoch)
+        total_loss = 0
+        cur_steps = 0
+        model.train()
+        for batch in tqdm(train_dataloader):
+            batch = {k: v.to(local_rank) for k, v in batch.items()}        
+            outputs = model(**batch)
+
+            loss = outputs.loss
+            total_loss += loss.item()
+            loss.backward()
+            
+            clip_grad_norm_(model.parameters(), max_norm_value)
+            
+            optimizer.step()
+            lr_scheduler.step()
+            optimizer.zero_grad()
+            
+            cur_steps += 1
+
+            if cur_steps % logging_steps == 0 and is_master_process():
+                print(f"Epoch: {epoch + 1} -- cur_steps: {cur_steps} -- train_loss: {total_loss/cur_steps} -- lr: {optimizer.param_groups[0]['lr']}")
+                
+    if is_master_process():
+        print("SAVING......................................................................")
+        model.module.save_pretrained(f"checkpoint/generator")
+        print(f"----------------------------- END OF TRAINING -----------------------------")
+
+if __name__ == "__main__":
+    train()
+    destroy_process_group()

OVM/OVM/.ipynb_checkpoints/train_generator-checkpoint.sh

@@ -0,0 +1,2 @@
+export CUDA_VISIBLE_DEVICES="0,1,2,3"
+torchrun --nproc_per_node=4 train_generator.py 

OVM/OVM/.ipynb_checkpoints/v_dataset-checkpoint.py

@@ -0,0 +1,81 @@
+import torch
+import transformers
+from datasets import load_dataset, load_from_disk
+from prompt_template import Prompter
+
+class VerifierDataset:
+    def __init__(
+        self,
+        tokenizer: transformers.PreTrainedTokenizer = None,
+        data_path: str = None,
+        max_length: int = None,
+        load_data_method: str = None,
+        mapping: bool = False,
+    ):
+        self.tokenizer = tokenizer
+        if load_data_method == "hf_hub":
+            self.dataset = load_dataset(data_path)
+        elif load_data_method == "local":
+            self.dataset = load_from_disk(data_path)
+        else:
+            raise NotImplementedError
+            
+        self.max_length = max_length
+        self.prompter = Prompter()
+        
+        if mapping:
+            self.dataset = self.dataset.map(self.get_items, num_proc = 16)
+            self.dataset = self.dataset.remove_columns(["question", "answer", "candidate", "label"])
+            
+    def left_padding(
+        self,
+        input_ids: list,
+        attention_mask: list,
+        labels: list,
+        v_labels: list,
+        padding_value: int = -100,
+    ):
+        pad_length = self.max_length - len(input_ids)
+        input_ids = [self.tokenizer.pad_token_id]*pad_length + input_ids
+        attention_mask = [0]*pad_length + attention_mask
+        labels = [padding_value]*pad_length + labels
+        v_labels = [padding_value]*pad_length + v_labels
+        
+        return input_ids, attention_mask, labels, v_labels
+               
+    def get_items(self, dataset, IGNORE_INDEX : int = -100):
+        prompt = self.prompter.verifier_prompt(question = dataset["question"], answer = dataset["candidate"])
+        question = prompt.split("### Trả lời:")[0]
+        len_question = len(self.tokenizer(question).input_ids)
+        label = dataset["label"]
+        
+        result = self.tokenizer(
+            prompt,
+            truncation = True,
+            max_length = self.max_length,
+            padding = False,
+            return_tensors = None,
+        )
+        
+        if (   
+            result["input_ids"][-1] != self.tokenizer.eos_token_id
+            and len(result["input_ids"]) < self.max_length
+        ):    
+            result["input_ids"].append(self.tokenizer.eos_token_id)
+            result["attention_mask"].append(1)
+        
+        result["attention_mask"][:len_question] = [0]*len_question
+        
+        result["labels"] = result["input_ids"].copy()
+        result["labels"] = [token if mask != 0 else IGNORE_INDEX for token, mask in zip(result["labels"], result["attention_mask"])]
+        
+        v_labels = [int(label)] * len(result["input_ids"])
+        result["v_labels"] = [token if mask != 0 else IGNORE_INDEX for token, mask in zip(result["labels"], result["attention_mask"])]
+        
+        result["input_ids"], result["attention_mask"], result["labels"], result["v_labels"] = self.left_padding(
+            result["input_ids"], result["attention_mask"], result["labels"], result["v_labels"], padding_value = IGNORE_INDEX)
+        
+        return result
+    
+
+        

OVM/OVM/build_verifier.py

@@ -0,0 +1,100 @@
+from transformers.generation.utils import ModelOutput
+from transformers import PreTrainedModel
+from typing import Optional, List, Dict
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from dataclasses import dataclass
+
+@dataclass
+class VerifierModelOutput(ModelOutput):
+    loss: Optional[torch.FloatTensor] = None
+    v_scores: torch.FloatTensor = None
+    all_losses: Optional[Dict[str, torch.FloatTensor]] = None
+
+class VerifierModel(nn.Module):
+    def __init__(self, backbone, checkpoint_dir = None):
+        super(VerifierModel, self).__init__()
+        self.backbone = backbone
+        
+        device = self.backbone.device
+        dtype = self.backbone.dtype
+
+        self.gain = nn.Parameter(
+            torch.randn((1,), device = device, dtype = dtype)
+        )
+        self.bias = nn.Parameter(
+            torch.randn((1,), device = device, dtype = dtype)
+        )
+        self.dropout = nn.Dropout(p = 0.2)
+        self.vscore_head = nn.Linear(self.backbone.get_input_embeddings().embedding_dim, 1, bias = False, device = device, dtype = dtype)
+        
+        if checkpoint_dir:
+            verifier_params = torch.load(checkpoint_dir)
+            self.load_state_dict(verifier_params, strict = False)
+            torch.cuda.empty_cache()
+        
+        else:
+            self.init_head_params()
+
+        self.pad_token_id = backbone.config.pad_token_id
+    
+    def init_head_params(self):
+        output_embeddings = self.backbone.get_output_embeddings().weight.data
+        output_embeddings_avg = output_embeddings.mean(dim = 0, keepdim = True)
+
+        self.vscore_head.weight = nn.Parameter(output_embeddings_avg)
+
+    def loss_fct(self, v_scores: torch.FloatTensor, v_labels: torch.LongTensor):
+        return self.mse_loss_with_mask(v_scores.squeeze(), v_labels.type_as(v_scores))
+    
+    def transform(self, last_hidden_states):
+        return self.gain * last_hidden_states + self.bias
+    
+    def forward(self,
+        input_ids: torch.LongTensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        labels: Optional[torch.LongTensor] = None,
+        v_labels: Optional[torch.LongTensor] = None,
+        output_all_losses: Optional[bool] = None,
+    ):
+        outputs = self.backbone(
+            input_ids = input_ids, 
+            attention_mask = attention_mask,
+            position_ids = position_ids,
+            past_key_values = past_key_values,
+            labels = labels, 
+            use_cache = False,
+            output_hidden_states = True, 
+            return_dict = True,
+        )
+        llm_logits = outputs.logits
+        llm_loss = outputs.loss
+        llm_hidden_states = outputs.hidden_states
+
+        v_hidden_states = self.transform(llm_hidden_states[-1])
+        v_scores = self.vscore_head(self.dropout(v_hidden_states))
+
+        v_loss, loss = None, None
+        if v_labels:
+            v_loss = self.loss_fct(v_scores, v_labels)
+            loss = v_loss + (llm_loss if labels is not None else 0)
+
+        all_losses = None
+        if output_all_losses:
+            all_losses = {'llm_loss': llm_loss, 'v_loss': v_loss}
+
+        return VerifierModelOutput(
+            loss = loss,
+            v_scores = v_scores,
+            all_losses = all_losses,
+        )
+
+    def mse_loss_with_mask(self, scores: torch.FloatTensor, labels: torch.FloatTensor, IGNORE_INDEX: int = -100):
+        scores = torch.where(labels.ne(IGNORE_INDEX), scores, 0)
+        labels = torch.where(labels.ne(IGNORE_INDEX), labels, 0)
+        return F.mse_loss(scores, labels, reduction = 'sum') / scores.shape[0]
+    
+

OVM/OVM/checkpoint/generator/README.md

@@ -0,0 +1,220 @@
+---
+library_name: peft
+base_model: mistralai/Mistral-7B-v0.1
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure 
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]
+
+
+## Training procedure
+
+
+The following `bitsandbytes` quantization config was used during training:
+- quant_method: bitsandbytes
+- load_in_8bit: False
+- load_in_4bit: True
+- llm_int8_threshold: 6.0
+- llm_int8_skip_modules: None
+- llm_int8_enable_fp32_cpu_offload: False
+- llm_int8_has_fp16_weight: False
+- bnb_4bit_quant_type: nf4
+- bnb_4bit_use_double_quant: False
+- bnb_4bit_compute_dtype: bfloat16
+
+### Framework versions
+
+
+- PEFT 0.6.2

OVM/OVM/checkpoint/generator/adapter_config.json

@@ -0,0 +1,29 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": "mistralai/Mistral-7B-v0.1",
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "lora_alpha": 16,
+  "lora_dropout": 0.1,
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "r": 64,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "gate_proj",
+    "up_proj",
+    "down_proj",
+    "v_proj",
+    "q_proj",
+    "k_proj",
+    "o_proj",
+    "lm_head"
+  ],
+  "task_type": "CAUSAL_LM"
+}

OVM/OVM/checkpoint/generator/adapter_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53cf21d240f5ff6dbce9f68fdf039ccf390f6021457cb2a2ec257833b19a95a6
+size 680491413

OVM/OVM/data/.ipynb_checkpoints/merge-checkpoint.ipynb

@@ -0,0 +1,192 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "c633fee7-6770-4959-8248-cf7213606f36",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from glob import glob\n",
+    "from datasets import load_from_disk\n",
+    "from datasets import concatenate_datasets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "c8fca22d-51de-4641-87a0-6492beb88988",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "dataset_names = glob(\"./*/\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "c31ce749-c27e-4398-bc66-7788428cd3de",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "dataset_list = [load_from_disk(dataset_name) for dataset_name in dataset_names]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b3784b1a-aff8-4bdd-8b5a-13216d70f56d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(dataset_names)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "bcf3f458-71be-4a07-a1c6-6d07fd683e41",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "dataset = concatenate_datasets(dataset_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "9ccd8ca0-0f2d-4a80-8a8c-0bf0df42ffad",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Dataset({\n",
+       "    features: ['question', 'answer', 'candidate', 'label'],\n",
+       "    num_rows: 375000\n",
+       "})"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "86c7b496-c5c3-49d2-a9fd-d5d2236424ef",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "7500.0"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(dataset)/50"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "b693ac3b-c626-4a9a-b006-17a470dc0ca3",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "453243bb11274124b011818dcbc8f61e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Saving the dataset (0/1 shards):   0%|          | 0/375000 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dataset.save_to_disk(\"gen_all_375000\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "8955eedc-86cb-42cb-a776-63823634cea1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# dataset.push_to_hub(\"anhdungitvn/math_gen_ovm_7500_375000\", token=\"\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "afc86804-3a31-4772-89bf-1d10d5f8b9e8",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "lora_llama2",
+   "language": "python",
+   "name": "lora_llama2"
+  },
+  "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

OVM/OVM/data/gen1/data-00000-of-00001.arrow

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:512080e6220a5f95a33f41a32c18a19fd17db731cbc351c7e393faca25a60562
+size 169615856

OVM/OVM/data/gen1/dataset_info.json

@@ -0,0 +1,24 @@
+{
+  "citation": "",
+  "description": "",
+  "features": {
+    "question": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "answer": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "candidate": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "label": {
+      "dtype": "bool",
+      "_type": "Value"
+    }
+  },
+  "homepage": "",
+  "license": ""
+}

OVM/OVM/data/gen1/state.json

@@ -0,0 +1,18 @@
+{
+  "_data_files": [
+    {
+      "filename": "data-00000-of-00001.arrow"
+    }
+  ],
+  "_fingerprint": "c5cb50243754f927",
+  "_format_columns": [
+    "question",
+    "answer",
+    "candidate",
+    "label"
+  ],
+  "_format_kwargs": {},
+  "_format_type": null,
+  "_output_all_columns": false,
+  "_split": null
+}

OVM/OVM/data/gen2/data-00000-of-00001.arrow

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a581ca9cc18b2202b85baedebf93a7a9c3358931f584abb4be6e6c116abf6017
+size 171862696

OVM/OVM/data/gen2/dataset_info.json

@@ -0,0 +1,24 @@
+{
+  "citation": "",
+  "description": "",
+  "features": {
+    "question": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "answer": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "candidate": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "label": {
+      "dtype": "bool",
+      "_type": "Value"
+    }
+  },
+  "homepage": "",
+  "license": ""
+}

OVM/OVM/data/gen2/state.json

@@ -0,0 +1,13 @@
+{
+  "_data_files": [
+    {
+      "filename": "data-00000-of-00001.arrow"
+    }
+  ],
+  "_fingerprint": "307618c3fdb99a47",
+  "_format_columns": null,
+  "_format_kwargs": {},
+  "_format_type": null,
+  "_output_all_columns": false,
+  "_split": null
+}

OVM/OVM/data/gen_all_375000/data-00000-of-00001.arrow

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:96729c9f55738cad9ee92f1c26968759121fb749c0f93db468330c53c178a5a4
+size 341467688

OVM/OVM/data/gen_all_375000/dataset_info.json

@@ -0,0 +1,24 @@
+{
+  "citation": "",
+  "description": "",
+  "features": {
+    "question": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "answer": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "candidate": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "label": {
+      "dtype": "bool",
+      "_type": "Value"
+    }
+  },
+  "homepage": "",
+  "license": ""
+}

OVM/OVM/data/gen_all_375000/state.json

@@ -0,0 +1,18 @@
+{
+  "_data_files": [
+    {
+      "filename": "data-00000-of-00001.arrow"
+    }
+  ],
+  "_fingerprint": "393f29e5745cb559",
+  "_format_columns": [
+    "question",
+    "answer",
+    "candidate",
+    "label"
+  ],
+  "_format_kwargs": {},
+  "_format_type": null,
+  "_output_all_columns": false,
+  "_split": null
+}

OVM/OVM/data/merge.ipynb

@@ -0,0 +1,257 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "c633fee7-6770-4959-8248-cf7213606f36",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from glob import glob\n",
+    "from datasets import load_from_disk\n",
+    "from datasets import concatenate_datasets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "c8fca22d-51de-4641-87a0-6492beb88988",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "dataset_names = glob(\"./*/\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "c31ce749-c27e-4398-bc66-7788428cd3de",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "dataset_list = [load_from_disk(dataset_name) for dataset_name in dataset_names]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b3784b1a-aff8-4bdd-8b5a-13216d70f56d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(dataset_names)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "bcf3f458-71be-4a07-a1c6-6d07fd683e41",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "dataset = concatenate_datasets(dataset_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "9ccd8ca0-0f2d-4a80-8a8c-0bf0df42ffad",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Dataset({\n",
+       "    features: ['question', 'answer', 'candidate', 'label'],\n",
+       "    num_rows: 375000\n",
+       "})"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "86c7b496-c5c3-49d2-a9fd-d5d2236424ef",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "7500.0"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(dataset)/50"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "b693ac3b-c626-4a9a-b006-17a470dc0ca3",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "453243bb11274124b011818dcbc8f61e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Saving the dataset (0/1 shards):   0%|          | 0/375000 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dataset.save_to_disk(\"gen_all_375000\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "8955eedc-86cb-42cb-a776-63823634cea1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = load_from_disk(\"gen_all_375000\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "9e7d3a69-7a9c-4206-b5e3-e437e4a8bd82",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Dataset({\n",
+       "    features: ['question', 'answer', 'candidate', 'label'],\n",
+       "    num_rows: 375000\n",
+       "})"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "afc86804-3a31-4772-89bf-1d10d5f8b9e8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b951444583784176b097381066f45df0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Pushing dataset shards to the dataset hub:   0%|          | 0/1 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "1cbaa93e51af4999bb27261a6aebbb85",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Creating parquet from Arrow format:   0%|          | 0/375 [00:00<?, ?ba/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dataset.push_to_hub(\"vi-ovm-dataset\", token=\"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\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "84dca87a-1303-4928-88e7-10d3005b367f",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "lora_llama2",
+   "language": "python",
+   "name": "lora_llama2"
+  },
+  "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

OVM/OVM/gen_solutions-1.py

@@ -0,0 +1,90 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"]="4,5,6,7"
+
+from datasets import load_dataset, Dataset
+import transformers
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from transformers import DataCollatorForSeq2Seq, get_scheduler
+import torch
+from peft import LoraConfig, PeftConfig, get_peft_model, PeftModel
+from torch.optim import AdamW
+from tqdm.auto import tqdm
+import os
+from prompt_template import Prompter
+
+dataset = load_dataset("longhoang06/Vi-GSM8K", split = "train")
+gen_size = 3750
+# gen_dataset = dataset.select(range(gen_size))
+# gen_dataset = dataset.select(range(1000))  # part 1
+gen_dataset = dataset.select(range(1000, 1500))  # part 2
+# gen_dataset = dataset.select(range(1500, 2500))  # part 3
+# gen_dataset = dataset.select(range(2500, 3750))  # part 4
+
+
+model_path = "mistralai/Mistral-7B-v0.1"
+peft_path = "checkpoint/generator"
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+tokenizer.pad_token = tokenizer.eos_token
+
+model = AutoModelForCausalLM.from_pretrained(model_path, device_map = "auto", torch_dtype = torch.bfloat16)
+model = PeftModel.from_pretrained(model, peft_path)
+model = model.merge_and_unload()
+
+def generator_and_save(dataset):
+    def get_answer(text):
+        return text.split("Đáp án:")[-1].strip()
+    
+    prompter = Prompter()
+    progress_bar = tqdm(range(len(dataset)))
+    results = []
+    
+    for d in dataset:
+        question = d["question"]
+        answer = d["answer"]
+        prompt = prompter.generate_prompt(instruction = question)
+        
+        input_ids = tokenizer(prompt, return_tensors = "pt").input_ids
+        with torch.no_grad():
+            outputs = model.generate(
+                input_ids = input_ids.to("cuda"),
+                max_new_tokens = 512,
+                temperature = 0.7,
+                top_k = 50,
+                top_p = 1,
+                num_return_sequences = 50,
+                bos_token_id = tokenizer.bos_token_id,
+                eos_token_id = tokenizer.eos_token_id,
+                do_sample = True,
+            ) 
+        outputs.to("cpu")
+        texts = tokenizer.batch_decode(outputs, skip_special_tokens = True)
+        texts = [prompter.get_response(text) for text in texts]
+        batch = [
+            {"question": question,
+             "answer": answer,
+             "candidate": candidate,
+             "label": True if get_answer(candidate) == get_answer(answer) else False
+            } for candidate in texts
+        ]
+        results.extend(batch)
+        del batch
+        del input_ids
+        progress_bar.update(1)
+    
+    new_dataset = Dataset.from_dict(
+        {"question": [d["question"] for d in results],
+         "answer": [d["answer"] for d in results],
+         "candidate": [d["candidate"] for d in results],
+         "label": [d["label"] for d in results],
+        }
+    )
+    
+    # new_dataset.save_to_disk("data/gen1")
+    new_dataset.save_to_disk("data/gen1-1000-1500")
+
+if __name__ == "__main__":
+    generator_and_save(gen_dataset)
+                
+        
+

OVM/OVM/gen_solutions-2.py

@@ -0,0 +1,83 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"]="2,3"
+
+from datasets import load_dataset, Dataset
+import transformers
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from transformers import DataCollatorForSeq2Seq, get_scheduler
+import torch
+from peft import LoraConfig, PeftConfig, get_peft_model, PeftModel
+from torch.optim import AdamW
+from tqdm.auto import tqdm
+import os
+from prompt_template import Prompter
+
+dataset = load_dataset("longhoang06/Vi-GSM8K", split = "train")
+gen_size = 3750
+gen_dataset = dataset.select(range(gen_size, 2*gen_size))
+
+model_path = "mistralai/Mistral-7B-v0.1"
+peft_path = "checkpoint/generator"
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+tokenizer.pad_token = tokenizer.eos_token
+
+model = AutoModelForCausalLM.from_pretrained(model_path, device_map = "auto", torch_dtype = torch.bfloat16)
+model = PeftModel.from_pretrained(model, peft_path)
+model = model.merge_and_unload()
+
+def generator_and_save(dataset):
+    def get_answer(text):
+        return text.split("Đáp án:")[-1].strip()
+    
+    prompter = Prompter()
+    progress_bar = tqdm(range(len(dataset)))
+    results = []
+    
+    for d in dataset:
+        question = d["question"]
+        answer = d["answer"]
+        prompt = prompter.generate_prompt(instruction = question)
+        
+        input_ids = tokenizer(prompt, return_tensors = "pt").input_ids
+        with torch.no_grad():
+            outputs = model.generate(
+                input_ids = input_ids.to("cuda"),
+                max_new_tokens = 512,
+                temperature = 0.7,
+                top_k = 50,
+                top_p = 1,
+                num_return_sequences = 50,
+                bos_token_id = tokenizer.bos_token_id,
+                eos_token_id = tokenizer.eos_token_id,
+                do_sample = True,
+            )
+        texts = tokenizer.batch_decode(outputs, skip_special_tokens = True)
+        texts = [prompter.get_response(text) for text in texts]
+        batch = [
+            {"question": question,
+             "answer": answer,
+             "candidate": candidate,
+             "label": True if get_answer(candidate) == get_answer(answer) else False
+            } for candidate in texts
+        ]
+        results.extend(batch)
+        del batch
+        del input_ids
+        progress_bar.update(1)
+    
+    new_dataset = Dataset.from_dict(
+        {"question": [d["question"] for d in results],
+         "answer": [d["answer"] for d in results],
+         "candidate": [d["candidate"] for d in results],
+         "label": [d["label"] for d in results],
+        }
+    )
+    
+    new_dataset.save_to_disk("data/gen2")
+
+if __name__ == "__main__":
+    generator_and_save(gen_dataset)
+                
+        
+

OVM/OVM/generatation/.ipynb_checkpoints/main-checkpoint.py

@@ -0,0 +1,117 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
+# os.environ["CUDA_VISIBLE_DEVICES"]="0,1,2,3"
+os.environ["CUDA_VISIBLE_DEVICES"]="4,5,6,7"
+
+
+# START = 3300   # runing
+# START = 3310   # runing
+START = 3320   # runing
+# START = 3330   # runing
+# START = 3340   # runing
+
+
+
+WINDOW = 10
+
+
+from datasets import load_dataset, Dataset
+import transformers
+transformers.logging.set_verbosity_error()
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from transformers import DataCollatorForSeq2Seq, get_scheduler
+import torch
+from peft import LoraConfig, PeftConfig, get_peft_model, PeftModel
+from torch.optim import AdamW
+from tqdm.auto import tqdm
+import os
+from prompt_template import Prompter
+
+dataset = load_dataset("longhoang06/Vi-GSM8K", split = "train")
+# gen_size = 3750
+# gen_dataset = dataset.select(range(gen_size))
+# gen_dataset = dataset.select(range(1000))  # part 1
+# gen_dataset = dataset.select(range(1000, 1500))  # part 2
+# gen_dataset = dataset.select(range(1500, 2500))  # part 3
+# gen_dataset = dataset.select(range(2500, 3750))  # part 4
+
+# REMAIN: (1000, 1500)
+# REMAIN: (2500, 3750)
+
+
+END = START+WINDOW
+OUTPUT_DIR = f"output_dir/{START}_{END}"
+if os.path.isdir(OUTPUT_DIR):
+    raise Exception("OUTPUT_DIR EXISTED")                   
+
+gen_dataset = dataset.select(range(START, END))
+
+
+
+model_path = "mistralai/Mistral-7B-v0.1"
+peft_path = "./checkpoint/generator"
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+tokenizer.pad_token = tokenizer.eos_token
+
+model = AutoModelForCausalLM.from_pretrained(model_path, device_map = "auto", torch_dtype = torch.bfloat16)
+model = PeftModel.from_pretrained(model, peft_path)
+model = model.merge_and_unload()
+
+def generator_and_save(dataset):
+    def get_answer(text):
+        return text.split("Đáp án:")[-1].strip()
+    
+    prompter = Prompter()
+    progress_bar = tqdm(range(len(dataset)))
+    progress_bar.set_description(f"{START}_{END}")
+    results = []
+    
+    for d in dataset:
+        question = d["question"]
+        answer = d["answer"]
+        prompt = prompter.generate_prompt(instruction = question)
+        
+        input_ids = tokenizer(prompt, return_tensors = "pt").input_ids
+        with torch.no_grad():
+            outputs = model.generate(
+                input_ids = input_ids.to("cuda"),
+                max_new_tokens = 512,
+                temperature = 0.7,
+                top_k = 50,
+                top_p = 1,
+                num_return_sequences = 50,
+                bos_token_id = tokenizer.bos_token_id,
+                eos_token_id = tokenizer.eos_token_id,
+                do_sample = True,
+            ) 
+        outputs.to("cpu")
+        texts = tokenizer.batch_decode(outputs, skip_special_tokens = True)
+        texts = [prompter.get_response(text) for text in texts]
+        batch = [
+            {"question": question,
+             "answer": answer,
+             "candidate": candidate,
+             "label": True if get_answer(candidate) == get_answer(answer) else False
+            } for candidate in texts
+        ]
+        results.extend(batch)
+        del batch
+        del input_ids
+        progress_bar.update(1)
+    
+    new_dataset = Dataset.from_dict(
+        {"question": [d["question"] for d in results],
+         "answer": [d["answer"] for d in results],
+         "candidate": [d["candidate"] for d in results],
+         "label": [d["label"] for d in results],
+        }
+    )
+    
+    # new_dataset.save_to_disk("data/gen1")
+    new_dataset.save_to_disk(OUTPUT_DIR)
+
+if __name__ == "__main__":
+    generator_and_save(gen_dataset)
+                
+        
+

OVM/OVM/generatation/.ipynb_checkpoints/main_108-checkpoint.py

@@ -0,0 +1,108 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"]="2,3,4,5,6"
+
+START = 3500  # runing
+WINDOW = 100
+
+
+from datasets import load_dataset, Dataset
+import transformers
+transformers.logging.set_verbosity_error()
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from transformers import DataCollatorForSeq2Seq, get_scheduler
+import torch
+from peft import LoraConfig, PeftConfig, get_peft_model, PeftModel
+from torch.optim import AdamW
+from tqdm.auto import tqdm
+import os
+from prompt_template import Prompter
+
+dataset = load_dataset("longhoang06/Vi-GSM8K", split = "train")
+# gen_size = 3750
+# gen_dataset = dataset.select(range(gen_size))
+# gen_dataset = dataset.select(range(1000))  # part 1
+# gen_dataset = dataset.select(range(1000, 1500))  # part 2
+# gen_dataset = dataset.select(range(1500, 2500))  # part 3
+# gen_dataset = dataset.select(range(2500, 3750))  # part 4
+
+# REMAIN: (1000, 1500)
+# REMAIN: (2500, 3750)
+
+
+END = START+WINDOW
+OUTPUT_DIR = f"output_dir/{START}_{END}"
+if os.path.isdir(OUTPUT_DIR):
+    raise Exception("OUTPUT_DIR EXISTED")                   
+
+gen_dataset = dataset.select(range(START, END))
+
+
+
+model_path = "mistralai/Mistral-7B-v0.1"
+peft_path = "./checkpoint/generator"
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+tokenizer.pad_token = tokenizer.eos_token
+
+model = AutoModelForCausalLM.from_pretrained(model_path, device_map = "auto", torch_dtype = torch.bfloat16)
+model = PeftModel.from_pretrained(model, peft_path)
+model = model.merge_and_unload()
+
+def generator_and_save(dataset):
+    def get_answer(text):
+        return text.split("Đáp án:")[-1].strip()
+    
+    prompter = Prompter()
+    progress_bar = tqdm(range(len(dataset)))
+    progress_bar.set_description(f"{START}_{END}")
+    results = []
+    
+    for d in dataset:
+        question = d["question"]
+        answer = d["answer"]
+        prompt = prompter.generate_prompt(instruction = question)
+        
+        input_ids = tokenizer(prompt, return_tensors = "pt").input_ids
+        with torch.no_grad():
+            outputs = model.generate(
+                input_ids = input_ids.to("cuda"),
+                max_new_tokens = 512,
+                temperature = 0.7,
+                top_k = 50,
+                top_p = 1,
+                num_return_sequences = 50,
+                bos_token_id = tokenizer.bos_token_id,
+                eos_token_id = tokenizer.eos_token_id,
+                do_sample = True,
+            ) 
+        outputs.to("cpu")
+        texts = tokenizer.batch_decode(outputs, skip_special_tokens = True)
+        texts = [prompter.get_response(text) for text in texts]
+        batch = [
+            {"question": question,
+             "answer": answer,
+             "candidate": candidate,
+             "label": True if get_answer(candidate) == get_answer(answer) else False
+            } for candidate in texts
+        ]
+        results.extend(batch)
+        del batch
+        del input_ids
+        progress_bar.update(1)
+    
+    new_dataset = Dataset.from_dict(
+        {"question": [d["question"] for d in results],
+         "answer": [d["answer"] for d in results],
+         "candidate": [d["candidate"] for d in results],
+         "label": [d["label"] for d in results],
+        }
+    )
+    
+    # new_dataset.save_to_disk("data/gen1")
+    new_dataset.save_to_disk(OUTPUT_DIR)
+
+if __name__ == "__main__":
+    generator_and_save(gen_dataset)
+                
+        
+

OVM/OVM/generatation/.ipynb_checkpoints/main_121-checkpoint.py

@@ -0,0 +1,116 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
+# os.environ["CUDA_VISIBLE_DEVICES"]="0,1,2,3"
+os.environ["CUDA_VISIBLE_DEVICES"]="4,5,6,7"
+
+# START = 3300   # runing
+# START = 3310   # runing
+# START = 3320   # runing
+START = 3330   # runing
+# START = 3340   # runing
+
+
+
+WINDOW = 10
+
+
+from datasets import load_dataset, Dataset
+import transformers
+transformers.logging.set_verbosity_error()
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from transformers import DataCollatorForSeq2Seq, get_scheduler
+import torch
+from peft import LoraConfig, PeftConfig, get_peft_model, PeftModel
+from torch.optim import AdamW
+from tqdm.auto import tqdm
+import os
+from prompt_template import Prompter
+
+dataset = load_dataset("longhoang06/Vi-GSM8K", split = "train")
+# gen_size = 3750
+# gen_dataset = dataset.select(range(gen_size))
+# gen_dataset = dataset.select(range(1000))  # part 1
+# gen_dataset = dataset.select(range(1000, 1500))  # part 2
+# gen_dataset = dataset.select(range(1500, 2500))  # part 3
+# gen_dataset = dataset.select(range(2500, 3750))  # part 4
+
+# REMAIN: (1000, 1500)
+# REMAIN: (2500, 3750)
+
+
+END = START+WINDOW
+OUTPUT_DIR = f"output_dir/{START}_{END}"
+if os.path.isdir(OUTPUT_DIR):
+    raise Exception("OUTPUT_DIR EXISTED")                   
+
+gen_dataset = dataset.select(range(START, END))
+
+
+
+model_path = "mistralai/Mistral-7B-v0.1"
+peft_path = "./checkpoint/generator"
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+tokenizer.pad_token = tokenizer.eos_token
+
+model = AutoModelForCausalLM.from_pretrained(model_path, device_map = "auto", torch_dtype = torch.bfloat16)
+model = PeftModel.from_pretrained(model, peft_path)
+model = model.merge_and_unload()
+
+def generator_and_save(dataset):
+    def get_answer(text):
+        return text.split("Đáp án:")[-1].strip()
+    
+    prompter = Prompter()
+    progress_bar = tqdm(range(len(dataset)))
+    progress_bar.set_description(f"{START}_{END}")
+    results = []
+    
+    for d in dataset:
+        question = d["question"]
+        answer = d["answer"]
+        prompt = prompter.generate_prompt(instruction = question)
+        
+        input_ids = tokenizer(prompt, return_tensors = "pt").input_ids
+        with torch.no_grad():
+            outputs = model.generate(
+                input_ids = input_ids.to("cuda"),
+                max_new_tokens = 512,
+                temperature = 0.7,
+                top_k = 50,
+                top_p = 1,
+                num_return_sequences = 50,
+                bos_token_id = tokenizer.bos_token_id,
+                eos_token_id = tokenizer.eos_token_id,
+                do_sample = True,
+            ) 
+        outputs.to("cpu")
+        texts = tokenizer.batch_decode(outputs, skip_special_tokens = True)
+        texts = [prompter.get_response(text) for text in texts]
+        batch = [
+            {"question": question,
+             "answer": answer,
+             "candidate": candidate,
+             "label": True if get_answer(candidate) == get_answer(answer) else False
+            } for candidate in texts
+        ]
+        results.extend(batch)
+        del batch
+        del input_ids
+        progress_bar.update(1)
+    
+    new_dataset = Dataset.from_dict(
+        {"question": [d["question"] for d in results],
+         "answer": [d["answer"] for d in results],
+         "candidate": [d["candidate"] for d in results],
+         "label": [d["label"] for d in results],
+        }
+    )
+    
+    # new_dataset.save_to_disk("data/gen1")
+    new_dataset.save_to_disk(OUTPUT_DIR)
+
+if __name__ == "__main__":
+    generator_and_save(gen_dataset)
+                
+        
+

OVM/OVM/generatation/checkpoint/generator/README.md

@@ -0,0 +1,220 @@
+---
+library_name: peft
+base_model: mistralai/Mistral-7B-v0.1
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure 
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]
+
+
+## Training procedure
+
+
+The following `bitsandbytes` quantization config was used during training:
+- quant_method: bitsandbytes
+- load_in_8bit: False
+- load_in_4bit: True
+- llm_int8_threshold: 6.0
+- llm_int8_skip_modules: None
+- llm_int8_enable_fp32_cpu_offload: False
+- llm_int8_has_fp16_weight: False
+- bnb_4bit_quant_type: nf4
+- bnb_4bit_use_double_quant: False
+- bnb_4bit_compute_dtype: bfloat16
+
+### Framework versions
+
+
+- PEFT 0.6.2

OVM/OVM/generatation/checkpoint/generator/adapter_config.json

@@ -0,0 +1,29 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": "mistralai/Mistral-7B-v0.1",
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "lora_alpha": 16,
+  "lora_dropout": 0.1,
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "r": 64,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "gate_proj",
+    "up_proj",
+    "down_proj",
+    "v_proj",
+    "q_proj",
+    "k_proj",
+    "o_proj",
+    "lm_head"
+  ],
+  "task_type": "CAUSAL_LM"
+}

OVM/OVM/generatation/checkpoint/generator/adapter_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53cf21d240f5ff6dbce9f68fdf039ccf390f6021457cb2a2ec257833b19a95a6
+size 680491413

OVM/OVM/generatation/main.py

@@ -0,0 +1,117 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
+# os.environ["CUDA_VISIBLE_DEVICES"]="0,1,2,3"
+os.environ["CUDA_VISIBLE_DEVICES"]="4,5,6,7"
+
+
+# START = 3300   # runing
+# START = 3310   # runing
+START = 3320   # runing
+# START = 3330   # runing
+# START = 3340   # runing
+
+
+
+WINDOW = 10
+
+
+from datasets import load_dataset, Dataset
+import transformers
+transformers.logging.set_verbosity_error()
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from transformers import DataCollatorForSeq2Seq, get_scheduler
+import torch
+from peft import LoraConfig, PeftConfig, get_peft_model, PeftModel
+from torch.optim import AdamW
+from tqdm.auto import tqdm
+import os
+from prompt_template import Prompter
+
+dataset = load_dataset("longhoang06/Vi-GSM8K", split = "train")
+# gen_size = 3750
+# gen_dataset = dataset.select(range(gen_size))
+# gen_dataset = dataset.select(range(1000))  # part 1
+# gen_dataset = dataset.select(range(1000, 1500))  # part 2
+# gen_dataset = dataset.select(range(1500, 2500))  # part 3
+# gen_dataset = dataset.select(range(2500, 3750))  # part 4
+
+# REMAIN: (1000, 1500)
+# REMAIN: (2500, 3750)
+
+
+END = START+WINDOW
+OUTPUT_DIR = f"output_dir/{START}_{END}"
+if os.path.isdir(OUTPUT_DIR):
+    raise Exception("OUTPUT_DIR EXISTED")                   
+
+gen_dataset = dataset.select(range(START, END))
+
+
+
+model_path = "mistralai/Mistral-7B-v0.1"
+peft_path = "./checkpoint/generator"
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+tokenizer.pad_token = tokenizer.eos_token
+
+model = AutoModelForCausalLM.from_pretrained(model_path, device_map = "auto", torch_dtype = torch.bfloat16)
+model = PeftModel.from_pretrained(model, peft_path)
+model = model.merge_and_unload()
+
+def generator_and_save(dataset):
+    def get_answer(text):
+        return text.split("Đáp án:")[-1].strip()
+    
+    prompter = Prompter()
+    progress_bar = tqdm(range(len(dataset)))
+    progress_bar.set_description(f"{START}_{END}")
+    results = []
+    
+    for d in dataset:
+        question = d["question"]
+        answer = d["answer"]
+        prompt = prompter.generate_prompt(instruction = question)
+        
+        input_ids = tokenizer(prompt, return_tensors = "pt").input_ids
+        with torch.no_grad():
+            outputs = model.generate(
+                input_ids = input_ids.to("cuda"),
+                max_new_tokens = 512,
+                temperature = 0.7,
+                top_k = 50,
+                top_p = 1,
+                num_return_sequences = 50,
+                bos_token_id = tokenizer.bos_token_id,
+                eos_token_id = tokenizer.eos_token_id,
+                do_sample = True,
+            ) 
+        outputs.to("cpu")
+        texts = tokenizer.batch_decode(outputs, skip_special_tokens = True)
+        texts = [prompter.get_response(text) for text in texts]
+        batch = [
+            {"question": question,
+             "answer": answer,
+             "candidate": candidate,
+             "label": True if get_answer(candidate) == get_answer(answer) else False
+            } for candidate in texts
+        ]
+        results.extend(batch)
+        del batch
+        del input_ids
+        progress_bar.update(1)
+    
+    new_dataset = Dataset.from_dict(
+        {"question": [d["question"] for d in results],
+         "answer": [d["answer"] for d in results],
+         "candidate": [d["candidate"] for d in results],
+         "label": [d["label"] for d in results],
+        }
+    )
+    
+    # new_dataset.save_to_disk("data/gen1")
+    new_dataset.save_to_disk(OUTPUT_DIR)
+
+if __name__ == "__main__":
+    generator_and_save(gen_dataset)
+                
+        
+

OVM/OVM/generatation/main_108.py

@@ -0,0 +1,108 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
+os.environ["CUDA_VISIBLE_DEVICES"]="2,3,4,5,6"
+
+START = 3500  # runing
+WINDOW = 100
+
+
+from datasets import load_dataset, Dataset
+import transformers
+transformers.logging.set_verbosity_error()
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from transformers import DataCollatorForSeq2Seq, get_scheduler
+import torch
+from peft import LoraConfig, PeftConfig, get_peft_model, PeftModel
+from torch.optim import AdamW
+from tqdm.auto import tqdm
+import os
+from prompt_template import Prompter
+
+dataset = load_dataset("longhoang06/Vi-GSM8K", split = "train")
+# gen_size = 3750
+# gen_dataset = dataset.select(range(gen_size))
+# gen_dataset = dataset.select(range(1000))  # part 1
+# gen_dataset = dataset.select(range(1000, 1500))  # part 2
+# gen_dataset = dataset.select(range(1500, 2500))  # part 3
+# gen_dataset = dataset.select(range(2500, 3750))  # part 4
+
+# REMAIN: (1000, 1500)
+# REMAIN: (2500, 3750)
+
+
+END = START+WINDOW
+OUTPUT_DIR = f"output_dir/{START}_{END}"
+if os.path.isdir(OUTPUT_DIR):
+    raise Exception("OUTPUT_DIR EXISTED")                   
+
+gen_dataset = dataset.select(range(START, END))
+
+
+
+model_path = "mistralai/Mistral-7B-v0.1"
+peft_path = "./checkpoint/generator"
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+tokenizer.pad_token = tokenizer.eos_token
+
+model = AutoModelForCausalLM.from_pretrained(model_path, device_map = "auto", torch_dtype = torch.bfloat16)
+model = PeftModel.from_pretrained(model, peft_path)
+model = model.merge_and_unload()
+
+def generator_and_save(dataset):
+    def get_answer(text):
+        return text.split("Đáp án:")[-1].strip()
+    
+    prompter = Prompter()
+    progress_bar = tqdm(range(len(dataset)))
+    progress_bar.set_description(f"{START}_{END}")
+    results = []
+    
+    for d in dataset:
+        question = d["question"]
+        answer = d["answer"]
+        prompt = prompter.generate_prompt(instruction = question)
+        
+        input_ids = tokenizer(prompt, return_tensors = "pt").input_ids
+        with torch.no_grad():
+            outputs = model.generate(
+                input_ids = input_ids.to("cuda"),
+                max_new_tokens = 512,
+                temperature = 0.7,
+                top_k = 50,
+                top_p = 1,
+                num_return_sequences = 50,
+                bos_token_id = tokenizer.bos_token_id,
+                eos_token_id = tokenizer.eos_token_id,
+                do_sample = True,
+            ) 
+        outputs.to("cpu")
+        texts = tokenizer.batch_decode(outputs, skip_special_tokens = True)
+        texts = [prompter.get_response(text) for text in texts]
+        batch = [
+            {"question": question,
+             "answer": answer,
+             "candidate": candidate,
+             "label": True if get_answer(candidate) == get_answer(answer) else False
+            } for candidate in texts
+        ]
+        results.extend(batch)
+        del batch
+        del input_ids
+        progress_bar.update(1)
+    
+    new_dataset = Dataset.from_dict(
+        {"question": [d["question"] for d in results],
+         "answer": [d["answer"] for d in results],
+         "candidate": [d["candidate"] for d in results],
+         "label": [d["label"] for d in results],
+        }
+    )
+    
+    # new_dataset.save_to_disk("data/gen1")
+    new_dataset.save_to_disk(OUTPUT_DIR)
+
+if __name__ == "__main__":
+    generator_and_save(gen_dataset)
+                
+        
+

OVM/OVM/generatation/main_121.py

@@ -0,0 +1,116 @@
+import os
+os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
+# os.environ["CUDA_VISIBLE_DEVICES"]="0,1,2,3"
+os.environ["CUDA_VISIBLE_DEVICES"]="4,5,6,7"
+
+# START = 3300   # runing
+# START = 3310   # runing
+# START = 3320   # runing
+START = 3330   # runing
+# START = 3340   # runing
+
+
+
+WINDOW = 10
+
+
+from datasets import load_dataset, Dataset
+import transformers
+transformers.logging.set_verbosity_error()
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from transformers import DataCollatorForSeq2Seq, get_scheduler
+import torch
+from peft import LoraConfig, PeftConfig, get_peft_model, PeftModel
+from torch.optim import AdamW
+from tqdm.auto import tqdm
+import os
+from prompt_template import Prompter
+
+dataset = load_dataset("longhoang06/Vi-GSM8K", split = "train")
+# gen_size = 3750
+# gen_dataset = dataset.select(range(gen_size))
+# gen_dataset = dataset.select(range(1000))  # part 1
+# gen_dataset = dataset.select(range(1000, 1500))  # part 2
+# gen_dataset = dataset.select(range(1500, 2500))  # part 3
+# gen_dataset = dataset.select(range(2500, 3750))  # part 4
+
+# REMAIN: (1000, 1500)
+# REMAIN: (2500, 3750)
+
+
+END = START+WINDOW
+OUTPUT_DIR = f"output_dir/{START}_{END}"
+if os.path.isdir(OUTPUT_DIR):
+    raise Exception("OUTPUT_DIR EXISTED")                   
+
+gen_dataset = dataset.select(range(START, END))
+
+
+
+model_path = "mistralai/Mistral-7B-v0.1"
+peft_path = "./checkpoint/generator"
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+tokenizer.pad_token = tokenizer.eos_token
+
+model = AutoModelForCausalLM.from_pretrained(model_path, device_map = "auto", torch_dtype = torch.bfloat16)
+model = PeftModel.from_pretrained(model, peft_path)
+model = model.merge_and_unload()
+
+def generator_and_save(dataset):
+    def get_answer(text):
+        return text.split("Đáp án:")[-1].strip()
+    
+    prompter = Prompter()
+    progress_bar = tqdm(range(len(dataset)))
+    progress_bar.set_description(f"{START}_{END}")
+    results = []
+    
+    for d in dataset:
+        question = d["question"]
+        answer = d["answer"]
+        prompt = prompter.generate_prompt(instruction = question)
+        
+        input_ids = tokenizer(prompt, return_tensors = "pt").input_ids
+        with torch.no_grad():
+            outputs = model.generate(
+                input_ids = input_ids.to("cuda"),
+                max_new_tokens = 512,
+                temperature = 0.7,
+                top_k = 50,
+                top_p = 1,
+                num_return_sequences = 50,
+                bos_token_id = tokenizer.bos_token_id,
+                eos_token_id = tokenizer.eos_token_id,
+                do_sample = True,
+            ) 
+        outputs.to("cpu")
+        texts = tokenizer.batch_decode(outputs, skip_special_tokens = True)
+        texts = [prompter.get_response(text) for text in texts]
+        batch = [
+            {"question": question,
+             "answer": answer,
+             "candidate": candidate,
+             "label": True if get_answer(candidate) == get_answer(answer) else False
+            } for candidate in texts
+        ]
+        results.extend(batch)
+        del batch
+        del input_ids
+        progress_bar.update(1)
+    
+    new_dataset = Dataset.from_dict(
+        {"question": [d["question"] for d in results],
+         "answer": [d["answer"] for d in results],
+         "candidate": [d["candidate"] for d in results],
+         "label": [d["label"] for d in results],
+        }
+    )
+    
+    # new_dataset.save_to_disk("data/gen1")
+    new_dataset.save_to_disk(OUTPUT_DIR)
+
+if __name__ == "__main__":
+    generator_and_save(gen_dataset)
+                
+        
+

OVM/OVM/generatation/output_dir/.ipynb_checkpoints/merge-checkpoint.ipynb

@@ -0,0 +1,179 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "c633fee7-6770-4959-8248-cf7213606f36",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from glob import glob\n",
+    "from datasets import load_from_disk\n",
+    "from datasets import concatenate_datasets"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "c8fca22d-51de-4641-87a0-6492beb88988",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "dataset_names = glob(\"./*/\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "c31ce749-c27e-4398-bc66-7788428cd3de",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "dataset_list = [load_from_disk(dataset_name) for dataset_name in dataset_names]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "b3784b1a-aff8-4bdd-8b5a-13216d70f56d",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "26"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(dataset_names)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "bcf3f458-71be-4a07-a1c6-6d07fd683e41",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "dataset = concatenate_datasets(dataset_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "86c7b496-c5c3-49d2-a9fd-d5d2236424ef",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3750.0"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(dataset)/50"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b62b27bc-b7c1-4f66-9deb-24860ead220b",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1750"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "3750-2000"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "b693ac3b-c626-4a9a-b006-17a470dc0ca3",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a07ee12da7574b9680dda2c7e2a27e5e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Saving the dataset (0/1 shards):   0%|          | 0/187500 [00:00<?, ? examples/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "dataset.save_to_disk(\"/home/jovyan/nas_comm/1_user/[email protected]/research/math/math-mistral/OVM/data/gen1\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8955eedc-86cb-42cb-a776-63823634cea1",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "lora_llama2",
+   "language": "python",
+   "name": "lora_llama2"
+  },
+  "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

OVM/OVM/generatation/output_dir/1000_1100/data-00000-of-00001.arrow

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:421e72d9f485410815e24d051a9030d65993668104eb62bbe02a6711eb27222d
+size 4156512

OVM/OVM/generatation/output_dir/1000_1100/dataset_info.json

@@ -0,0 +1,24 @@
+{
+  "citation": "",
+  "description": "",
+  "features": {
+    "question": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "answer": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "candidate": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "label": {
+      "dtype": "bool",
+      "_type": "Value"
+    }
+  },
+  "homepage": "",
+  "license": ""
+}

OVM/OVM/generatation/output_dir/1000_1100/state.json

@@ -0,0 +1,13 @@
+{
+  "_data_files": [
+    {
+      "filename": "data-00000-of-00001.arrow"
+    }
+  ],
+  "_fingerprint": "51a575e0fbde2b43",
+  "_format_columns": null,
+  "_format_kwargs": {},
+  "_format_type": null,
+  "_output_all_columns": false,
+  "_split": null
+}