Upload Instruction_finetuning_on_domain_specific_dataset.ipynb

Instruction_finetuning_on_domain_specific_dataset.ipynb

@@ -0,0 +1,870 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "kV67ewlS_iQQ"
+      },
+      "source": [
+        "Pretrain model(LLAMA)\n",
+        "\n",
+        "Non-instruction finetuning on plaine text\n",
+        "\n",
+        "intruction finetuning on instruciton dataset\n",
+        "\n",
+        "prefrence aligment\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "y6yvA3-vQeJp"
+      },
+      "outputs": [],
+      "source": [
+        "from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer\n",
+        "from peft import LoraConfig, get_peft_model, TaskType\n",
+        "from datasets import load_dataset"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "1RGTcD2-SZNY"
+      },
+      "outputs": [],
+      "source": [
+        "model = \"TinyLlama/TinyLlama-1.1B-intermediate-step-1431k-3T\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "NiYmDvVESKuk"
+      },
+      "outputs": [],
+      "source": [
+        "tokenizer = AutoTokenizer.from_pretrained(model)\n",
+        "if tokenizer.pad_token is None:\n",
+        "    tokenizer.pad_token = tokenizer.eos_token"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "mIJF6oYdHrnY"
+      },
+      "outputs": [],
+      "source": [
+        "import zipfile\n",
+        "import os\n",
+        "# Path to your zip file\n",
+        "zip_path = \"/content/tinyllama-lora.zip\"\n",
+        "\n",
+        "# Extract all files\n",
+        "with zipfile.ZipFile(zip_path, 'r') as zip_ref:\n",
+        "    zip_ref.extractall()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "AHrg04tQQUZD"
+      },
+      "outputs": [],
+      "source": [
+        "model_path = \"/content/checkpoint-5\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "w2tCUu_4QV_d"
+      },
+      "outputs": [],
+      "source": [
+        "non_instruction_model = AutoModelForCausalLM.from_pretrained(model_path, device_map=\"auto\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "LEFPopA0QXjO"
+      },
+      "outputs": [],
+      "source": [
+        "prompt = \"Clinical trials demonstrated that combining Atorvastatin with Ezetimibe\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "I18lSYjBQY1l"
+      },
+      "outputs": [],
+      "source": [
+        "inputs = tokenizer(prompt, return_tensors=\"pt\").to(\"cuda\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "NJuadbIZQaG1"
+      },
+      "outputs": [],
+      "source": [
+        "outputs = non_instruction_model.generate(\n",
+        "    **inputs,\n",
+        "    max_new_tokens=100,\n",
+        "    temperature=0.8,\n",
+        "    top_p=0.9,\n",
+        "    do_sample=True,\n",
+        "    repetition_penalty=1.1\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "c7OfbSZ7QbS4"
+      },
+      "outputs": [],
+      "source": [
+        "print(\"\\nModel Output:\\n\")\n",
+        "print(tokenizer.decode(outputs[0], skip_special_tokens=True))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "FK3-vj54UzZq"
+      },
+      "source": [
+        "We have learn till here"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "9yQMIiioU3yv"
+      },
+      "source": [
+        "Now lets start with instructin finetuning"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "fvpQ1lq4U8Np"
+      },
+      "source": [
+        "first of all lets inspect the data"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "92-j9pKfVAvT"
+      },
+      "source": [
+        "I am starting with inbuilt data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "2-HVtooZSjCG"
+      },
+      "outputs": [],
+      "source": [
+        "from datasets import load_dataset\n",
+        "dataset = load_dataset(\"Amod/mental_health_counseling_conversations\", split=\"train\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "YgUFGjLiBEhC"
+      },
+      "outputs": [],
+      "source": [
+        "dataset"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "26GpStv1VAIU"
+      },
+      "outputs": [],
+      "source": [
+        "def format_row(example):\n",
+        "    question = example[\"Context\"]\n",
+        "    answer = example[\"Response\"]\n",
+        "    example[\"Text\"] = f\"[INST] {question} [/INST] {answer}\"\n",
+        "    return example"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "_pEGrNoDBoUe"
+      },
+      "outputs": [],
+      "source": [
+        "def format_row(example):\n",
+        "    question = example[\"Context\"]\n",
+        "    answer = example[\"Response\"]\n",
+        "    example[\"Text\"] = f\"[Context] {question} [/Response] {answer}\"\n",
+        "    return example"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ScCStp6aVHFV"
+      },
+      "outputs": [],
+      "source": [
+        "formatted_dataset = dataset.map(format_row)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "nN3Hz7OIVJIt"
+      },
+      "outputs": [],
+      "source": [
+        "formatted_dataset"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ld4UtoM8VKQR"
+      },
+      "outputs": [],
+      "source": [
+        "print(formatted_dataset[0][\"Text\"])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "sy2s0SMbVRCO"
+      },
+      "outputs": [],
+      "source": [
+        "import pandas as pd\n",
+        "\n",
+        "# Convert dataset to DataFrame\n",
+        "df = pd.DataFrame(dataset)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "HYdm2MP2Vf8R"
+      },
+      "outputs": [],
+      "source": [
+        "df"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "9nsdheiLVgxo"
+      },
+      "outputs": [],
+      "source": [
+        "df.to_csv(\"mental_health_counseling_conversations.csv\", index=False)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "k1V1mePAWEBF"
+      },
+      "outputs": [],
+      "source": [
+        "df.to_json(\"mental_health_counseling_conversations.jsonl\", orient=\"records\", lines=True)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "13tKjSG-WlKp"
+      },
+      "outputs": [],
+      "source": [
+        "from datasets import load_dataset\n",
+        "\n",
+        "dataset = load_dataset(\"csv\", data_files=\"mental_health_counseling_conversations.csv\",split=\"train\")\n",
+        "dataset\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "WQu6WGXyXVK4"
+      },
+      "outputs": [],
+      "source": [
+        "from datasets import load_dataset\n",
+        "\n",
+        "dataset = load_dataset(\"json\", data_files=\"mental_health_counseling_conversations.jsonl\", split=\"train\")\n",
+        "dataset"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "AvbovRSOXl1Q"
+      },
+      "source": [
+        "till here the data loading part is clear i think"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "FJrndn2NXp4s"
+      },
+      "source": [
+        "# now lets load our data"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "mYCsSPovXbNB"
+      },
+      "outputs": [],
+      "source": [
+        "from datasets import load_dataset\n",
+        "\n",
+        "dataset = load_dataset(\"csv\", data_files=\"/content/pharma_instruction_data.csv\",split=\"train\")\n",
+        "dataset\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "zUfbnBXoZb_i"
+      },
+      "outputs": [],
+      "source": [
+        "def format_example(example):\n",
+        "    prompt = f\"### Instruction:\\n{example['instruction']}\\n### Input:\\n{example['input']}\\n### Response:\\n{example['output']}\"\n",
+        "    return {\"text\": prompt}"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "ndwidNYcZgJ4"
+      },
+      "outputs": [],
+      "source": [
+        "dataset = dataset.map(format_example)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "0-pbUgN_ZifL"
+      },
+      "outputs": [],
+      "source": [
+        "dataset"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Jn90WJ82Esks"
+      },
+      "outputs": [],
+      "source": [
+        "dataset['text'][0]"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "6l2f_4CuFK7K"
+      },
+      "source": [
+        "### Instruction:\\nExplain the mechanism of action of Metformin.\\n### Input:\\nNone\\n### Response:\\nMetformin activates AMP-activated protein kinase (AMPK), which increases glucose uptake and fatty-acid oxidation while inhibiting hepatic gluconeogenesis, thereby lowering blood glucose."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "zexcb9pkZmmk"
+      },
+      "outputs": [],
+      "source": [
+        "if tokenizer.pad_token is None:\n",
+        "    tokenizer.pad_token = tokenizer.eos_token"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "O3Iik8n6ZrTt"
+      },
+      "outputs": [],
+      "source": [
+        "def tokenize_fn(example):\n",
+        "    tokens = tokenizer(example[\"text\"], truncation=True, padding=\"max_length\", max_length=512)\n",
+        "    tokens[\"labels\"] = tokens[\"input_ids\"].copy()\n",
+        "    return tokens"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "dgKLwnftZuDm"
+      },
+      "outputs": [],
+      "source": [
+        "tokenized = dataset.map(tokenize_fn, batched=True)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "mABCpJCVZwH9"
+      },
+      "outputs": [],
+      "source": [
+        "from peft import LoraConfig, get_peft_model, TaskType"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Pr7zXzwwDeKB"
+      },
+      "source": [
+        "| Parameter        | Meaning                     | Typical Value         | Effect                           |\n",
+        "| ---------------- | --------------------------- | --------------------- | -------------------------------- |\n",
+        "| `task_type`      | Model type (Causal/Seq2Seq) | `CAUSAL_LM`           | Ensures correct integration      |\n",
+        "| `r`              | Rank of LoRA matrix         | 4–16                  | Controls trainable param size    |\n",
+        "| `lora_alpha`     | Scaling factor              | 16–64                 | Balances adaptation strength     |\n",
+        "| `lora_dropout`   | Dropout probability         | 0.05                  | Regularization                   |\n",
+        "| `target_modules` | Which layers to tune        | `[\"q_proj\",\"v_proj\"]` | Trade-off between cost & quality |\n",
+        "| `bias`           | Bias fine-tuning            | `\"none\"`              | Keep simple                      |\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "MyvVjtxQZyRe"
+      },
+      "outputs": [],
+      "source": [
+        "lora_config = LoraConfig(\n",
+        "    task_type=TaskType.CAUSAL_LM,\n",
+        "    r=8,\n",
+        "    lora_alpha=16,\n",
+        "    lora_dropout=0.05,\n",
+        "    target_modules=[\"q_proj\", \"v_proj\"],\n",
+        "    bias=\"none\"\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "dklTp_ClZz2W"
+      },
+      "outputs": [],
+      "source": [
+        "instruction_model = get_peft_model(non_instruction_model, lora_config)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# #STEP A: Load base model\n",
+        "# model = AutoModelForCausalLM.from_pretrained(...)\n",
+        "# #STEP B: Load Stage-1 LoRA\n",
+        "# model = PeftModel.from_pretrained(model, non_instruction_model)\n",
+        "# model = model.merge_and_unload()\n",
+        "# # Why merge?\n",
+        "# # → Model clean + LoRA applied inside weights\n",
+        "# # → Now you can attach SECOND LoRA cleanly\n",
+        "# #STEP C: Attach NEW LoRA for instruction\n",
+        "# instruction_model_lora = get_peft_model(model, lora_config)"
+      ],
+      "metadata": {
+        "id": "AIA9IiyAjdVg"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Vv7jx-oiZ1XW"
+      },
+      "outputs": [],
+      "source": [
+        "args = TrainingArguments(\n",
+        "    output_dir=\"./tinyllama-instruction\",\n",
+        "    num_train_epochs=3,\n",
+        "    per_device_train_batch_size=1,\n",
+        "    gradient_accumulation_steps=8,\n",
+        "    learning_rate=2e-4,\n",
+        "    fp16=True,\n",
+        "    logging_steps=20,\n",
+        "    save_total_limit=1,\n",
+        "    report_to=\"none\"\n",
+        ")\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "LS33JYr2aEgh"
+      },
+      "outputs": [],
+      "source": [
+        "trainer = Trainer(\n",
+        "    model=instruction_model_lora,\n",
+        "    args=args,\n",
+        "    train_dataset=tokenized,\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "b_G3mkjNaF9Z"
+      },
+      "outputs": [],
+      "source": [
+        "trainer.train()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "8JSOmCudaIgw"
+      },
+      "outputs": [],
+      "source": [
+        "model_path = \"/content/tinyllama-instruction/checkpoint-3\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "8Jvb8S2YaSqS"
+      },
+      "outputs": [],
+      "source": [
+        "instruction_model = AutoModelForCausalLM.from_pretrained(model_path, device_map=\"auto\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "-fTJep9PjuKI"
+      },
+      "outputs": [],
+      "source": [
+        "prompt = \"Explain the mechanism of action of Metformin.\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "cE9wb66VaUyC"
+      },
+      "outputs": [],
+      "source": [
+        "inputs = tokenizer(prompt, return_tensors=\"pt\").to(\"cuda\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "_GD65ONCageB"
+      },
+      "outputs": [],
+      "source": [
+        "outputs = instruction_model.generate(\n",
+        "    **inputs,\n",
+        "    max_new_tokens=100,\n",
+        "    temperature=0.8,\n",
+        "    top_p=0.9,\n",
+        "    do_sample=True,\n",
+        "    repetition_penalty=1.1\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "xL1hUGXLahx7"
+      },
+      "outputs": [],
+      "source": [
+        "print(\"\\nModel Output:\\n\")\n",
+        "print(tokenizer.decode(outputs[0], skip_special_tokens=True))"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ezmpbNmMbAIC"
+      },
+      "source": [
+        "![image.png](data:image/png;base64,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)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Can_M-CqeqVh"
+      },
+      "outputs": [],
+      "source": [
+        "from datasets import load_dataset\n",
+        "from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer\n",
+        "from peft import LoraConfig, get_peft_model, TaskType\n",
+        "import torch\n",
+        "\n",
+        "# Load dataset\n",
+        "dataset = load_dataset(\"csv\", data_files=\"/content/pharma_instruction_data.csv\", split=\"train\")\n",
+        "print(dataset)\n",
+        "\n",
+        "\n",
+        "# Format dataset to Alpaca-style text\n",
+        "def format_example(example):\n",
+        "    # Build unified instruction-style prompt\n",
+        "    prompt = f\"### Instruction:\\n{example['instruction']}\\n### Input:\\n{example['input']}\\n### Response:\\n{example['output']}\"\n",
+        "    return {\"text\": prompt}\n",
+        "\n",
+        "dataset = dataset.map(format_example)\n",
+        "print(dataset[0][\"text\"])\n",
+        "\n",
+        "\n",
+        "# Tokenizer setup\n",
+        "tokenizer = AutoTokenizer.from_pretrained(\"TinyLlama/TinyLlama-1.1B-Chat-v1.0\")\n",
+        "\n",
+        "if tokenizer.pad_token is None:\n",
+        "    tokenizer.pad_token = tokenizer.eos_token\n",
+        "\n",
+        "\n",
+        "# Tokenization with Response Masking\n",
+        "def tokenize_and_mask(example):\n",
+        "    text = example[\"text\"]\n",
+        "\n",
+        "    # Tokenize full text\n",
+        "    enc = tokenizer(text, truncation=True, padding=\"max_length\", max_length=512)\n",
+        "    input_ids = enc[\"input_ids\"]\n",
+        "\n",
+        "    # Find where '### Response:' starts\n",
+        "    response_marker = \"### Response:\"\n",
+        "    response_start = text.find(response_marker)\n",
+        "\n",
+        "    if response_start != -1:\n",
+        "        # Token index where response begins\n",
+        "        response_token_start = len(tokenizer(text[:response_start])[\"input_ids\"])\n",
+        "    else:\n",
+        "        response_token_start = 0  # if marker not found\n",
+        "\n",
+        "    # Clone labels and mask out everything before 'Response'\n",
+        "    labels = input_ids.copy()\n",
+        "    labels[:response_token_start] = [-100] * response_token_start\n",
+        "\n",
+        "    enc[\"labels\"] = labels\n",
+        "    return enc\n",
+        "\n",
+        "# Apply tokenization\n",
+        "tokenized = dataset.map(tokenize_and_mask, batched=False)\n",
+        "print(\"Tokenization + masking done.\")\n",
+        "\n",
+        "\n",
+        "# LoRA config\n",
+        "lora_config = LoraConfig(\n",
+        "    task_type=TaskType.CAUSAL_LM,\n",
+        "    r=8,\n",
+        "    lora_alpha=16,\n",
+        "    lora_dropout=0.05,\n",
+        "    target_modules=[\"q_proj\", \"v_proj\"],\n",
+        "    bias=\"none\"\n",
+        ")\n",
+        "\n",
+        "\n",
+        "# Load base model (previously non-instructional trained)\n",
+        "non_instructional_trained_model = AutoModelForCausalLM.from_pretrained(\n",
+        "    \"path_to_your_non_instruction_model\",\n",
+        "    torch_dtype=torch.float16,\n",
+        "    device_map=\"auto\"\n",
+        ")\n",
+        "\n",
+        "model = get_peft_model(non_instructional_trained_model, lora_config)\n",
+        "\n",
+        "# Training setup\n",
+        "args = TrainingArguments(\n",
+        "    output_dir=\"./tinyllama-instruction\",\n",
+        "    num_train_epochs=3,\n",
+        "    per_device_train_batch_size=1,\n",
+        "    gradient_accumulation_steps=8,\n",
+        "    learning_rate=2e-4,\n",
+        "    fp16=True,\n",
+        "    logging_steps=20,\n",
+        "    save_total_limit=1,\n",
+        "    report_to=\"none\"\n",
+        ")\n",
+        "\n",
+        "trainer = Trainer(\n",
+        "    model=model,\n",
+        "    args=args,\n",
+        "    train_dataset=tokenized,\n",
+        ")\n",
+        "\n",
+        "\n",
+        "# Train the model\n",
+        "trainer.train()\n",
+        "\n",
+        "\n",
+        "# Save & test the model\n",
+        "trainer.save_model(\"/content/tinyllama-instruction\")\n",
+        "tokenizer.save_pretrained(\"/content/tinyllama-instruction\")\n",
+        "\n",
+        "# Test generation\n",
+        "trained_model = AutoModelForCausalLM.from_pretrained(\"/content/tinyllama-instruction\", device_map=\"auto\")\n",
+        "\n",
+        "prompt = \"### Instruction:\\nWhat is Ezetimibe?\\n### Input:\\n\\n### Response:\\n\"\n",
+        "inputs = tokenizer(prompt, return_tensors=\"pt\").to(\"cuda\")\n",
+        "\n",
+        "outputs = trained_model.generate(\n",
+        "    **inputs,\n",
+        "    max_new_tokens=100,\n",
+        "    temperature=0.8,\n",
+        "    top_p=0.9,\n",
+        "    do_sample=True,\n",
+        "    repetition_penalty=1.1\n",
+        ")\n",
+        "\n",
+        "print(\"\\nModel Output:\\n\")\n",
+        "print(tokenizer.decode(outputs[0], skip_special_tokens=True))\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "cvDTWo_jkFTf"
+      },
+      "outputs": [],
+      "source": [
+        "questions = [\n",
+        "    \"Explain the mechanism of action of Metformin.\",\n",
+        "    \"List two advantages of combining Atorvastatin with Ezetimibe.\",\n",
+        "    \"Summarize how mRNA vaccines work and mention one current research focus.\"\n",
+        "]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "jcgu-t4mfnHW"
+      },
+      "outputs": [],
+      "source": [
+        "for q in questions:\n",
+        "    print(\"Question:\", q)\n",
+        "    print(\"\\n--- Non-instruction model ---\")\n",
+        "    inputs = tokenizer(q, return_tensors=\"pt\").to(\"cuda\")\n",
+        "    outputs = non_instruction_model.generate(**inputs, max_new_tokens=80)\n",
+        "    print(tokenizer.decode(outputs[0], skip_special_tokens=True))\n",
+        "\n",
+        "    print(\"\\n--- Instruction-tuned model ---\")\n",
+        "    prompt = f\"### Instruction:\\n{q}\\n### Input:\\n\\n### Response:\\n\"\n",
+        "    inputs = tokenizer(prompt, return_tensors=\"pt\").to(\"cuda\")\n",
+        "    outputs = instruction_model.generate(**inputs, max_new_tokens=100)\n",
+        "    print(tokenizer.decode(outputs[0], skip_special_tokens=True))\n",
+        "    print(\"=\"*80, \"\\n\")\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "2OKfm-kEkKUq"
+      },
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}