radekosmulski/Alpaca_with_LoRA_bf16.ipynb

## Alpaca_with_LoRA_bf16.ipynb
{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a5ccac1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "if not os.environ.get('TRANSFORMERS_CACHE'):\n",
    "    os.environ['TRANSFORMERS_CACHE'] = '/raid/transformers_cache'\n",
    "    \n",
    "\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = \"6\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2221804b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.10/dist-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": [
    "import copy\n",
    "from dataclasses import dataclass, field\n",
    "from typing import Dict, Optional, Sequence\n",
    "import warnings\n",
    "\n",
    "from tqdm import tqdm\n",
    "from pdb import set_trace\n",
    "\n",
    "import torch\n",
    "import numpy as np\n",
    "import transformers\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from transformers import AutoModelForCausalLM, AutoTokenizer\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a51d944d",
   "metadata": {},
   "source": [
    "Let's grab the dataset straight from `datasets`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4dd95b68",
   "metadata": {},
   "outputs": [],
   "source": [
    "from datasets import load_dataset, DatasetDict\n",
    "dataset = load_dataset(\"tatsu-lab/alpaca\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "549878ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading checkpoint shards: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:06<00:00,  3.15s/it]\n"
     ]
    }
   ],
   "source": [
    "model = AutoModelForCausalLM.from_pretrained('meta-llama/Llama-2-7b-hf', torch_dtype=torch.bfloat16)\n",
    "tokenizer = AutoTokenizer.from_pretrained('meta-llama/Llama-2-7b-hf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8d6ddb3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets = dataset['train'].train_test_split(test_size=2002, seed=42)\n",
    "datasets = DatasetDict({'train': datasets['train'], 'valid': datasets['test']})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "43b496fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "You are resizing the embedding layer without providing a `pad_to_multiple_of` parameter. This means that the new embeding dimension will be 32001. This might induce some performance reduction as *Tensor Cores* will not be available. For more details  about this, or help on choosing the correct value for resizing, refer to this guide: https://docs.nvidia.com/deeplearning/performance/dl-performance-matrix-multiplication/index.html#requirements-tc\n"
     ]
    }
   ],
   "source": [
    "# code from Stanford Alpaca https://github.com/tatsu-lab/stanford_alpaca\n",
    "\n",
    "PROMPT_DICT = {\n",
    "    \"prompt_input\": (\n",
    "        \"Below is an instruction that describes a task, paired with an input that provides further context. \"\n",
    "        \"Write a response that appropriately completes the request.\\n\\n\"\n",
    "        \"### Instruction:\\n{instruction}\\n\\n### Input:\\n{input}\\n\\n### Response:\"\n",
    "    ),\n",
    "    \"prompt_no_input\": (\n",
    "        \"Below is an instruction that describes a task. \"\n",
    "        \"Write a response that appropriately completes the request.\\n\\n\"\n",
    "        \"### Instruction:\\n{instruction}\\n\\n### Response:\"\n",
    "    ),\n",
    "}\n",
    "\n",
    "def smart_tokenizer_and_embedding_resize(\n",
    "    special_tokens_dict: Dict,\n",
    "    tokenizer: transformers.PreTrainedTokenizer,\n",
    "    model: transformers.PreTrainedModel,\n",
    "):\n",
    "    \"\"\"Resize tokenizer and embedding.\n",
    "\n",
    "    Note: This is the unoptimized version that may make your embedding size not be divisible by 64.\n",
    "    \"\"\"\n",
    "    num_new_tokens = tokenizer.add_special_tokens(special_tokens_dict)\n",
    "    model.resize_token_embeddings(len(tokenizer))\n",
    "\n",
    "    if num_new_tokens > 0:\n",
    "        input_embeddings = model.get_input_embeddings().weight.data\n",
    "        output_embeddings = model.get_output_embeddings().weight.data\n",
    "\n",
    "        input_embeddings_avg = input_embeddings[:-num_new_tokens].mean(dim=0, keepdim=True)\n",
    "        output_embeddings_avg = output_embeddings[:-num_new_tokens].mean(dim=0, keepdim=True)\n",
    "\n",
    "        input_embeddings[-num_new_tokens:] = input_embeddings_avg\n",
    "        output_embeddings[-num_new_tokens:] = output_embeddings_avg\n",
    "        \n",
    "special_tokens_dict = dict()\n",
    "special_tokens_dict[\"pad_token\"] = \"[PAD]\"\n",
    "\n",
    "smart_tokenizer_and_embedding_resize(special_tokens_dict, tokenizer, model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ca648e3d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 32000]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenizer.encode('[PAD]')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5f3b7326",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'[PAD]'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenizer.decode([32000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "edfd9e7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_example(example):\n",
    "    template = PROMPT_DICT[\"prompt_input\"]\n",
    "    if not example['input']:\n",
    "        template = PROMPT_DICT[\"prompt_no_input\"] + '\\n\\n'\n",
    "\n",
    "    prompt = template.format_map(example)\n",
    "    prompt_toks = tokenizer(prompt)['input_ids']\n",
    "    input_ids = tokenizer(prompt + example[\"output\"] + tokenizer.eos_token, return_tensors='pt')['input_ids'][0]\n",
    "    labels = input_ids.clone().detach()\n",
    "    labels[:len(prompt_toks)] = -100 # loss will not be calculated for labels set to -100\n",
    "    return input_ids, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "36c9cd51",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SupervisedDataset(Dataset):\n",
    "    def __init__(self, dataset):\n",
    "        super().__init__()\n",
    "        discarded_examples_count = 0\n",
    "        self.examples = []\n",
    "        for example in tqdm(dataset):\n",
    "            input_ids, labels = process_example(example)\n",
    "            if input_ids.shape[0] > 512:\n",
    "                discarded_examples_count += 1\n",
    "            else:\n",
    "                self.examples.append((input_ids, labels))\n",
    "        print(f'Discarded {discarded_examples_count} examples due to length > 512.')\n",
    "            \n",
    "    def __getitem__(self, idx):\n",
    "        return {\"input_ids\": self.examples[idx][0], \"labels\": self.examples[idx][1]}\n",
    "    def __len__(self):\n",
    "        return len(self.examples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "4a4bf62b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 50000/50000 [00:36<00:00, 1354.51it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Discarded 94 examples due to length > 512.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2002/2002 [00:01<00:00, 1332.97it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Discarded 3 examples due to length > 512.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "train_ds = SupervisedDataset(datasets['train'])\n",
    "valid_ds = SupervisedDataset(datasets['valid'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5e3628de",
   "metadata": {},
   "outputs": [],
   "source": [
    "def collate_fn(examples):\n",
    "    input_ids, labels = tuple([example[key] for example in examples] for key in (\"input_ids\", \"labels\"))\n",
    "    input_ids = torch.nn.utils.rnn.pad_sequence(\n",
    "        input_ids, batch_first=True, padding_value=tokenizer.pad_token_id\n",
    "    )\n",
    "    labels = torch.nn.utils.rnn.pad_sequence(labels, batch_first=True, padding_value=-100)\n",
    "    return dict(\n",
    "        input_ids=input_ids,\n",
    "        labels=labels,\n",
    "        attention_mask=input_ids.ne(tokenizer.pad_token_id)\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a802eed6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from peft import LoraConfig, TaskType\n",
    "# from peft import get_peft_model\n",
    "\n",
    "# peft_config = LoraConfig(task_type=\"a_random_string\", inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1)\n",
    "\n",
    "# model = get_peft_model(model, peft_config)\n",
    "# model.print_trainable_parameters()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e59e53e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_batch_size = 2\n",
    "lr = 2e-5\n",
    "num_epochs = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c07a2e76",
   "metadata": {},
   "outputs": [],
   "source": [
    "from accelerate import Accelerator\n",
    "\n",
    "accelerator = Accelerator(mixed_precision='bf16', gradient_accumulation_steps=128//train_batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "bc81f95f",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dl = DataLoader(train_ds, batch_size=train_batch_size, shuffle=True, collate_fn=collate_fn)\n",
    "valid_dl = DataLoader(valid_ds, batch_size=2*train_batch_size, shuffle=False, collate_fn=collate_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "aa58ff68",
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=0)\n",
    "lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(\n",
    "    optimizer,\n",
    "    lr,\n",
    "    epochs=num_epochs,\n",
    "    steps_per_epoch=len(train_dl)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "eb6dd55a",
   "metadata": {},
   "outputs": [],
   "source": [
    "model, train_dl, valid_dl, optimizer, lr_scheduler = accelerator.prepare(\n",
    "    model, train_dl, valid_dl, optimizer, lr_scheduler\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4e622a19",
   "metadata": {},
   "outputs": [],
   "source": [
    "lrs = []\n",
    "train_losses = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6a88692a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                                                                                                                                                                                                                                                                                          \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train loss: 1.057822191549571\tVal loss: 1.04\ttoken accuracy: 0.00\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch:  1\tTrain loss: 1.04:   8%|█████████████████████████▉                                                                                                                                                                                                                                                                                        | 2120/24953 [13:08<2:21:31,  2.69it/s]IOPub message rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_msg_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_msg_rate_limit=1000.0 (msgs/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n",
      "Epoch:  1\tTrain loss: 1.03:  37%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████▋                                                                                                                                                                                               | 9354/24953 [58:01<1:37:03,  2.68it/s]IOPub data rate exceeded.\n",
      "The notebook server will temporarily stop sending output\n",
      "to the client in order to avoid crashing it.\n",
      "To change this limit, set the config variable\n",
      "`--NotebookApp.iopub_data_rate_limit`.\n",
      "\n",
      "Current values:\n",
      "NotebookApp.iopub_data_rate_limit=1000000.0 (bytes/sec)\n",
      "NotebookApp.rate_limit_window=3.0 (secs)\n",
      "\n",
      "                                                                                                                                                                                                                                                                                                                                                                                          \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train loss: 0.9418507915359349\tVal loss: 1.02\ttoken accuracy: 0.00\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                                                                                                                                                                                                                                                                                          "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train loss: 0.8698465522636847\tVal loss: 1.03\ttoken accuracy: 0.00\n",
      "CPU times: user 5h 29min 50s, sys: 2h 38min 3s, total: 8h 7min 54s\n",
      "Wall time: 8h 7min 30s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "for i in range(num_epochs):\n",
    "    model.train()\n",
    "    pbar = tqdm(train_dl, leave=False)\n",
    "    for batch in pbar:\n",
    "        outputs = model(**batch)\n",
    "        loss = outputs.loss\n",
    "\n",
    "        train_losses.append(loss.item())\n",
    "        lrs.append(optimizer.param_groups[0]['lr'])\n",
    "\n",
    "        accelerator.backward(loss)\n",
    "        \n",
    "        optimizer.step()\n",
    "        optimizer.zero_grad()\n",
    "        lr_scheduler.step()\n",
    "        pbar.set_description(f'Epoch: {i:2d}\\tTrain loss: {np.mean(train_losses[-20:]) :.2f}')\n",
    "\n",
    "    model.eval()\n",
    "    preds = []\n",
    "    labels = []\n",
    "    val_losses = []\n",
    "    for batch in tqdm(valid_dl, leave=False):\n",
    "        with torch.no_grad():\n",
    "            outputs = model(**batch)\n",
    "\n",
    "        logits = outputs.logits\n",
    "        val_losses.append(outputs.loss.item())\n",
    "\n",
    "        preds.append(outputs.logits.argmax(-1).cpu().detach())\n",
    "        labels.append(batch['labels'].cpu().detach())\n",
    "\n",
    "    hits = 0\n",
    "    chances = 0\n",
    "    for p, l in zip(preds, labels):\n",
    "        hits += (p == l).sum().item()\n",
    "        chances += (l != -100).sum().item()\n",
    "    print(f'Train loss: {np.mean(train_losses[-len(train_dl):])}\\tVal loss: {np.mean(val_losses):3.02f}\\ttoken accuracy: {hits/chances:3.02f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "673395f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fc54e6236d0>]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(lrs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "da5e3cab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fbf45767b50>]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a88dc232",
   "metadata": {},
   "outputs": [],
   "source": [
    "accelerator.free_memory()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "87ddc33d",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save_pretrained('/raid/models/lora_apaca_llama2_FT_bfloat16')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ec39dd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os._exit(00)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}