chatbot-training.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-14T06:02:34.158602Z",
     "iopub.status.busy": "2025-03-14T06:02:34.158188Z",
     "iopub.status.idle": "2025-03-14T06:02:34.361502Z",
     "shell.execute_reply": "2025-03-14T06:02:34.360367Z",
     "shell.execute_reply.started": "2025-03-14T06:02:34.158571Z"
    }
   },
   "outputs": [],
   "source": [
    "# Importing HuggingFace Token\n",
    "from kaggle_secrets import UserSecretsClient\n",
    "user_secrets = UserSecretsClient()\n",
    "secret_value_0 = user_secrets.get_secret(\"HF_Token\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
    "execution": {
     "iopub.execute_input": "2025-03-14T06:02:34.363000Z",
     "iopub.status.busy": "2025-03-14T06:02:34.362718Z",
     "iopub.status.idle": "2025-03-14T06:12:26.502668Z",
     "shell.execute_reply": "2025-03-14T06:12:26.501655Z",
     "shell.execute_reply.started": "2025-03-14T06:02:34.362977Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cuda\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7824a999787d4bd1b195d7d91c77b73d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "tokenizer_config.json:   0%|          | 0.00/48.0 [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d429c8c5a09d44acabf466ce018c6bcd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "vocab.txt:   0%|          | 0.00/232k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0a455715281a4842b2b84fb392994a9a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "tokenizer.json:   0%|          | 0.00/466k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cb3a2c53b638478c9aebbcb91ba50d1a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "config.json:   0%|          | 0.00/570 [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e7ab9075f9a542439774f2c2fba440a1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "model.safetensors:   0%|          | 0.00/440M [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-uncased and are newly initialized: ['classifier.bias', 'classifier.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/90 - Average Loss: 5.6662\n",
      "Epoch 2/90 - Average Loss: 5.6118\n",
      "Epoch 3/90 - Average Loss: 5.5608\n",
      "Epoch 4/90 - Average Loss: 5.4642\n",
      "Epoch 5/90 - Average Loss: 5.3513\n",
      "Epoch 6/90 - Average Loss: 5.1811\n",
      "Epoch 7/90 - Average Loss: 5.0176\n",
      "Epoch 8/90 - Average Loss: 4.8236\n",
      "Epoch 9/90 - Average Loss: 4.6535\n",
      "Epoch 10/90 - Average Loss: 4.4724\n",
      "Epoch 11/90 - Average Loss: 4.3279\n",
      "Epoch 12/90 - Average Loss: 4.1504\n",
      "Epoch 13/90 - Average Loss: 4.0176\n",
      "Epoch 14/90 - Average Loss: 3.8612\n",
      "Epoch 15/90 - Average Loss: 3.7189\n",
      "Epoch 16/90 - Average Loss: 3.5748\n",
      "Epoch 17/90 - Average Loss: 3.4296\n",
      "Epoch 18/90 - Average Loss: 3.3193\n",
      "Epoch 19/90 - Average Loss: 3.1704\n",
      "Epoch 20/90 - Average Loss: 3.0567\n",
      "Epoch 21/90 - Average Loss: 2.9273\n",
      "Epoch 22/90 - Average Loss: 2.7933\n",
      "Epoch 23/90 - Average Loss: 2.6832\n",
      "Epoch 24/90 - Average Loss: 2.5414\n",
      "Epoch 25/90 - Average Loss: 2.4337\n",
      "Epoch 26/90 - Average Loss: 2.3230\n",
      "Epoch 27/90 - Average Loss: 2.2094\n",
      "Epoch 28/90 - Average Loss: 2.0913\n",
      "Epoch 29/90 - Average Loss: 1.9798\n",
      "Epoch 30/90 - Average Loss: 1.8935\n",
      "Epoch 31/90 - Average Loss: 1.7755\n",
      "Epoch 32/90 - Average Loss: 1.6802\n",
      "Epoch 33/90 - Average Loss: 1.5814\n",
      "Epoch 34/90 - Average Loss: 1.5013\n",
      "Epoch 35/90 - Average Loss: 1.4134\n",
      "Epoch 36/90 - Average Loss: 1.3328\n",
      "Epoch 37/90 - Average Loss: 1.2458\n",
      "Epoch 38/90 - Average Loss: 1.1845\n",
      "Epoch 39/90 - Average Loss: 1.1036\n",
      "Epoch 40/90 - Average Loss: 1.0327\n",
      "Epoch 41/90 - Average Loss: 0.9679\n",
      "Epoch 42/90 - Average Loss: 0.9215\n",
      "Epoch 43/90 - Average Loss: 0.8682\n",
      "Epoch 44/90 - Average Loss: 0.8089\n",
      "Epoch 45/90 - Average Loss: 0.7654\n",
      "Epoch 46/90 - Average Loss: 0.7181\n",
      "Epoch 47/90 - Average Loss: 0.6696\n",
      "Epoch 48/90 - Average Loss: 0.6318\n",
      "Epoch 49/90 - Average Loss: 0.5918\n",
      "Epoch 50/90 - Average Loss: 0.5542\n",
      "Epoch 51/90 - Average Loss: 0.5274\n",
      "Epoch 52/90 - Average Loss: 0.4944\n",
      "Epoch 53/90 - Average Loss: 0.4631\n",
      "Epoch 54/90 - Average Loss: 0.4428\n",
      "Epoch 55/90 - Average Loss: 0.4125\n",
      "Epoch 56/90 - Average Loss: 0.3950\n",
      "Epoch 57/90 - Average Loss: 0.3698\n",
      "Epoch 58/90 - Average Loss: 0.3491\n",
      "Epoch 59/90 - Average Loss: 0.3309\n",
      "Epoch 60/90 - Average Loss: 0.3142\n",
      "Epoch 61/90 - Average Loss: 0.2992\n",
      "Epoch 62/90 - Average Loss: 0.2829\n",
      "Epoch 63/90 - Average Loss: 0.2706\n",
      "Epoch 64/90 - Average Loss: 0.2552\n",
      "Epoch 65/90 - Average Loss: 0.2451\n",
      "Epoch 66/90 - Average Loss: 0.2355\n",
      "Epoch 67/90 - Average Loss: 0.2219\n",
      "Epoch 68/90 - Average Loss: 0.2122\n",
      "Epoch 69/90 - Average Loss: 0.2063\n",
      "Epoch 70/90 - Average Loss: 0.1950\n",
      "Epoch 71/90 - Average Loss: 0.1860\n",
      "Epoch 72/90 - Average Loss: 0.1758\n",
      "Epoch 73/90 - Average Loss: 0.1675\n",
      "Epoch 74/90 - Average Loss: 0.1630\n",
      "Epoch 75/90 - Average Loss: 0.1607\n",
      "Epoch 76/90 - Average Loss: 0.1525\n",
      "Epoch 77/90 - Average Loss: 0.1441\n",
      "Epoch 78/90 - Average Loss: 0.1364\n",
      "Epoch 79/90 - Average Loss: 0.1326\n",
      "Epoch 80/90 - Average Loss: 0.1293\n",
      "Epoch 81/90 - Average Loss: 0.1269\n",
      "Epoch 82/90 - Average Loss: 0.1199\n",
      "Epoch 83/90 - Average Loss: 0.1129\n",
      "Epoch 84/90 - Average Loss: 0.1095\n",
      "Epoch 85/90 - Average Loss: 0.1076\n",
      "Epoch 86/90 - Average Loss: 0.1030\n",
      "Epoch 87/90 - Average Loss: 0.0984\n",
      "Epoch 88/90 - Average Loss: 0.0944\n",
      "Epoch 89/90 - Average Loss: 0.0919\n",
      "Epoch 90/90 - Average Loss: 0.0880\n"
     ]
    }
   ],
   "source": [
    "# Importing Libraries\n",
    "import json\n",
    "import torch\n",
    "import os\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from transformers import BertTokenizer, BertForSequenceClassification\n",
    "import torch.nn.functional as F\n",
    "from sklearn.utils.class_weight import compute_class_weight\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "# Load JSON data\n",
    "with open(\"/kaggle/input/intents1/intents.json\", \"r\") as file:\n",
    "    intents = json.load(file)\n",
    "\n",
    "# Remove duplicate intent tags\n",
    "unique_intents = []\n",
    "seen_tags = set()\n",
    "for intent in intents:\n",
    "    if intent[\"tag\"] not in seen_tags:\n",
    "        unique_intents.append(intent)\n",
    "        seen_tags.add(intent[\"tag\"])\n",
    "\n",
    "# Ensure unique intent tags\n",
    "intent_tags = [intent[\"tag\"] for intent in unique_intents]\n",
    "num_labels = len(intent_tags)\n",
    "\n",
    "# Create label mapping\n",
    "label_map = {tag: i for i, tag in enumerate(intent_tags)}\n",
    "\n",
    "# Check for GPU availability\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "# Load BERT tokenizer & model\n",
    "tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', token=secret_value_0)\n",
    "model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=num_labels, token=secret_value_0)\n",
    "model.to(device)\n",
    "\n",
    "# Define Dataset\n",
    "class IntentDataset(Dataset):\n",
    "    def __init__(self, intents, tokenizer):\n",
    "        self.texts = []\n",
    "        self.labels = []\n",
    "        self.label_map = label_map\n",
    "\n",
    "        for intent in intents:\n",
    "            for pattern in intent[\"patterns\"]:\n",
    "                self.texts.append(pattern)\n",
    "                self.labels.append(self.label_map[intent[\"tag\"]])\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.labels)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        text = self.texts[idx]\n",
    "        label = torch.tensor(self.labels[idx], dtype=torch.long).to(device)\n",
    "\n",
    "        encoding = tokenizer(text, truncation=True, padding=\"max_length\", max_length=32, return_tensors=\"pt\")\n",
    "        item = {key: val.squeeze(0).to(device) for key, val in encoding.items()}  # Remove batch dim\n",
    "\n",
    "        return item, label\n",
    "\n",
    "# Load dataset & dataloader\n",
    "dataset = IntentDataset(unique_intents, tokenizer)\n",
    "dataloader = DataLoader(dataset, batch_size=16, shuffle=True)  # Increased batch size\n",
    "\n",
    "# Compute class weights\n",
    "labels = [dataset.label_map[intent[\"tag\"]] for intent in unique_intents for _ in intent[\"patterns\"]]\n",
    "class_weights = compute_class_weight(\"balanced\", classes=np.unique(labels), y=labels)\n",
    "class_weights = torch.tensor(class_weights, dtype=torch.float).to(device)\n",
    "\n",
    "# Define optimizer & loss function\n",
    "optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5)  # Lower learning rate\n",
    "loss_fn = torch.nn.CrossEntropyLoss(weight=class_weights)  # Use class-weighted loss\n",
    "\n",
    "# Training loop\n",
    "epochs = 90  # Increased from 20 to 50 for better training\n",
    "model.train()\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    total_loss = 0\n",
    "    for batch in dataloader:\n",
    "        inputs, labels = batch\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(**inputs)\n",
    "        loss = loss_fn(outputs.logits, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        total_loss += loss.item()\n",
    "    \n",
    "    avg_loss = total_loss / len(dataloader)\n",
    "    print(f\"Epoch {epoch+1}/{epochs} - Average Loss: {avg_loss:.4f}\")\n",
    "\n",
    "# Function to predict intent\n",
    "def predict_intent(user_input):\n",
    "    model.eval()\n",
    "    inputs = tokenizer(user_input, return_tensors=\"pt\", truncation=True, padding=True, max_length=32)\n",
    "    inputs = {key: val.to(device) for key, val in inputs.items()}  # Move input to GPU\n",
    "\n",
    "    with torch.no_grad():\n",
    "        outputs = model(**inputs)\n",
    "\n",
    "    predicted_label = torch.argmax(outputs.logits).item()\n",
    "    \n",
    "    # Map predicted label to intent\n",
    "    intent_tag = list(dataset.label_map.keys())[predicted_label]\n",
    "\n",
    "    # Fetch a random response for the predicted intent\n",
    "    for intent in unique_intents:\n",
    "        if intent[\"tag\"] == intent_tag:\n",
    "            return random.choice(intent[\"responses\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-14T06:12:26.505510Z",
     "iopub.status.busy": "2025-03-14T06:12:26.504747Z",
     "iopub.status.idle": "2025-03-14T06:12:26.934471Z",
     "shell.execute_reply": "2025-03-14T06:12:26.933341Z",
     "shell.execute_reply.started": "2025-03-14T06:12:26.505474Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy: 1.0000\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "from torch.utils.data import random_split\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "# Split dataset into training (80%) and test (20%) sets\n",
    "train_size = int(0.8 * len(dataset))\n",
    "test_size = len(dataset) - train_size\n",
    "train_dataset, test_dataset = random_split(dataset, [train_size, test_size])\n",
    "\n",
    "# Create test dataloader\n",
    "test_dataloader = DataLoader(test_dataset, batch_size=16, shuffle=False)\n",
    "\n",
    "# Function to evaluate model accuracy\n",
    "def evaluate_model(model, test_dataloader):\n",
    "    model.eval()\n",
    "    all_preds, all_labels = [], []\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for batch in test_dataloader:\n",
    "            inputs, labels = batch\n",
    "            outputs = model(**inputs)\n",
    "            preds = torch.argmax(outputs.logits, dim=1)\n",
    "\n",
    "            all_preds.extend(preds.cpu().numpy())\n",
    "            all_labels.extend(labels.cpu().numpy())\n",
    "\n",
    "    accuracy = accuracy_score(all_labels, all_preds)\n",
    "    return accuracy\n",
    "\n",
    "# Compute accuracy\n",
    "test_accuracy = evaluate_model(model, test_dataloader)\n",
    "print(f\"Test Accuracy: {test_accuracy:.4f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-14T06:12:26.936897Z",
     "iopub.status.busy": "2025-03-14T06:12:26.936431Z",
     "iopub.status.idle": "2025-03-14T06:12:28.400809Z",
     "shell.execute_reply": "2025-03-14T06:12:28.399868Z",
     "shell.execute_reply.started": "2025-03-14T06:12:26.936850Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Accuracy: 0.9939\n"
     ]
    }
   ],
   "source": [
    "def evaluate_train_accuracy(model, train_dataloader):\n",
    "    model.eval()\n",
    "    all_preds, all_labels = [], []\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for batch in train_dataloader:\n",
    "            inputs, labels = batch\n",
    "            outputs = model(**inputs)\n",
    "            preds = torch.argmax(outputs.logits, dim=1)\n",
    "\n",
    "            all_preds.extend(preds.cpu().numpy())\n",
    "            all_labels.extend(labels.cpu().numpy())\n",
    "\n",
    "    accuracy = accuracy_score(all_labels, all_preds)\n",
    "    return accuracy\n",
    "\n",
    "# Compute Training Accuracy\n",
    "train_dataloader = DataLoader(train_dataset, batch_size=16, shuffle=False)\n",
    "train_accuracy = evaluate_train_accuracy(model, train_dataloader)\n",
    "print(f\"Training Accuracy: {train_accuracy:.4f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-14T06:12:28.401902Z",
     "iopub.status.busy": "2025-03-14T06:12:28.401654Z",
     "iopub.status.idle": "2025-03-14T06:20:24.794528Z",
     "shell.execute_reply": "2025-03-14T06:20:24.793362Z",
     "shell.execute_reply.started": "2025-03-14T06:12:28.401882Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Assuming you store losses during training like this:\n",
    "train_losses = []\n",
    "test_losses = []\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    total_train_loss = 0\n",
    "    total_test_loss = 0\n",
    "\n",
    "    model.train()\n",
    "    for batch in train_dataloader:\n",
    "        inputs, labels = batch\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(**inputs)\n",
    "        loss = loss_fn(outputs.logits, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        total_train_loss += loss.item()\n",
    "    \n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        for batch in test_dataloader:\n",
    "            inputs, labels = batch\n",
    "            outputs = model(**inputs)\n",
    "            loss = loss_fn(outputs.logits, labels)\n",
    "            total_test_loss += loss.item()\n",
    "\n",
    "    train_losses.append(total_train_loss / len(train_dataloader))\n",
    "    test_losses.append(total_test_loss / len(test_dataloader))\n",
    "\n",
    "# Plot the loss curves\n",
    "plt.plot(range(1, epochs+1), train_losses, label=\"Train Loss\")\n",
    "plt.plot(range(1, epochs+1), test_losses, label=\"Test Loss\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "plt.title(\"Training vs. Test Loss\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-14T06:20:24.796070Z",
     "iopub.status.busy": "2025-03-14T06:20:24.795687Z",
     "iopub.status.idle": "2025-03-14T06:20:24.907652Z",
     "shell.execute_reply": "2025-03-14T06:20:24.906513Z",
     "shell.execute_reply.started": "2025-03-14T06:20:24.796036Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User: Tell me a joke\n",
      "Bot: Did you hear about the mathematician who’s afraid of negative numbers? He’ll stop at nothing to avoid them!\n",
      "\n",
      "User: Recommend a good book\n",
      "Bot: As an AI, I don't have personal preferences, but there are countless amazing books in various genres. Some popular ones include Harry Potter, To Kill a Mockingbird, and 1984.\n",
      "\n",
      "User: What's the weather like today?\n",
      "Bot: I'm sorry, I cannot provide real-time weather information.\n",
      "\n",
      "User: How can I save money?\n",
      "Bot: Investing in stocks, mutual funds, or real estate can help grow your wealth over time.\n",
      "\n",
      "User: How do I meditate?\n",
      "Bot: Meditation can reduce stress, improve focus, and promote emotional well-being.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Testing on New Data to test model generalization\n",
    "test_inputs = [\n",
    "    \"Tell me a joke\", \n",
    "    \"Recommend a good book\", \n",
    "    \"What's the weather like today?\", \n",
    "    \"How can I save money?\", \n",
    "    \"How do I meditate?\"\n",
    "]\n",
    "\n",
    "for input_text in test_inputs:\n",
    "    response = predict_intent(input_text)\n",
    "    print(f\"User: {input_text}\\nBot: {response}\\n\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-14T06:20:24.909244Z",
     "iopub.status.busy": "2025-03-14T06:20:24.908862Z",
     "iopub.status.idle": "2025-03-14T06:20:25.664937Z",
     "shell.execute_reply": "2025-03-14T06:20:25.664169Z",
     "shell.execute_reply.started": "2025-03-14T06:20:24.909206Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model saved to bert_chatbot_model.pth\n",
      "Tokenizer saved to bert_chatbot_tokenizer\n"
     ]
    }
   ],
   "source": [
    "# Define save paths\n",
    "model_path = \"bert_chatbot_model.pth\"\n",
    "tokenizer_path = \"bert_chatbot_tokenizer\"\n",
    "\n",
    "# Save model state dictionary\n",
    "torch.save(model.state_dict(), model_path)\n",
    "\n",
    "# Save tokenizer\n",
    "tokenizer.save_pretrained(tokenizer_path)\n",
    "\n",
    "print(f\"Model saved to {model_path}\")\n",
    "print(f\"Tokenizer saved to {tokenizer_path}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-14T06:20:25.666894Z",
     "iopub.status.busy": "2025-03-14T06:20:25.666633Z",
     "iopub.status.idle": "2025-03-14T06:20:26.840930Z",
     "shell.execute_reply": "2025-03-14T06:20:26.839944Z",
     "shell.execute_reply.started": "2025-03-14T06:20:25.666873Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('chatbot_model/tokenizer_config.json',\n",
       " 'chatbot_model/special_tokens_map.json',\n",
       " 'chatbot_model/vocab.txt',\n",
       " 'chatbot_model/added_tokens.json')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.save_pretrained(\"chatbot_model\")\n",
    "tokenizer.save_pretrained(\"chatbot_model\")"
   ]
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "nvidiaTeslaT4",
   "dataSources": [
    {
     "datasetId": 6860959,
     "sourceId": 11018742,
     "sourceType": "datasetVersion"
    }
   ],
   "dockerImageVersionId": 30919,
   "isGpuEnabled": true,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook"
  },
  "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.8.20"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}