{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-13T10:03:08.356914Z",
     "iopub.status.busy": "2025-03-13T10:03:08.356580Z",
     "iopub.status.idle": "2025-03-13T10:03:08.533121Z",
     "shell.execute_reply": "2025-03-13T10:03:08.532252Z",
     "shell.execute_reply.started": "2025-03-13T10:03:08.356884Z"
    }
   },
   "outputs": [],
   "source": [
    "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-13T10:03:08.534578Z",
     "iopub.status.busy": "2025-03-13T10:03:08.534321Z",
     "iopub.status.idle": "2025-03-13T10:14:01.403519Z",
     "shell.execute_reply": "2025-03-13T10:14:01.402735Z",
     "shell.execute_reply.started": "2025-03-13T10:03:08.534558Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cuda\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a9551b71420a46b3ba4ccabf52a6a351",
       "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": "96393c771e0042a788fc15c2462b3ad7",
       "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": "dab3bf2fa5d6417c9a88cdda11a6f120",
       "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": "aaecc1d18c2147f78fa59a05c5c0aa94",
       "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": "6e7825fd462a4dffb7aeb8fc78cf76b0",
       "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.6619\n",
      "Epoch 2/90 - Average Loss: 5.5883\n",
      "Epoch 3/90 - Average Loss: 5.5470\n",
      "Epoch 4/90 - Average Loss: 5.4290\n",
      "Epoch 5/90 - Average Loss: 5.2496\n",
      "Epoch 6/90 - Average Loss: 5.0645\n",
      "Epoch 7/90 - Average Loss: 4.8741\n",
      "Epoch 8/90 - Average Loss: 4.7122\n",
      "Epoch 9/90 - Average Loss: 4.5314\n",
      "Epoch 10/90 - Average Loss: 4.3852\n",
      "Epoch 11/90 - Average Loss: 4.2249\n",
      "Epoch 12/90 - Average Loss: 4.0838\n",
      "Epoch 13/90 - Average Loss: 3.9303\n",
      "Epoch 14/90 - Average Loss: 3.7829\n",
      "Epoch 15/90 - Average Loss: 3.6581\n",
      "Epoch 16/90 - Average Loss: 3.5259\n",
      "Epoch 17/90 - Average Loss: 3.3789\n",
      "Epoch 18/90 - Average Loss: 3.2480\n",
      "Epoch 19/90 - Average Loss: 3.1250\n",
      "Epoch 20/90 - Average Loss: 2.9910\n",
      "Epoch 21/90 - Average Loss: 2.8648\n",
      "Epoch 22/90 - Average Loss: 2.7338\n",
      "Epoch 23/90 - Average Loss: 2.6204\n",
      "Epoch 24/90 - Average Loss: 2.5009\n",
      "Epoch 25/90 - Average Loss: 2.3891\n",
      "Epoch 26/90 - Average Loss: 2.2775\n",
      "Epoch 27/90 - Average Loss: 2.1512\n",
      "Epoch 28/90 - Average Loss: 2.0413\n",
      "Epoch 29/90 - Average Loss: 1.9370\n",
      "Epoch 30/90 - Average Loss: 1.8393\n",
      "Epoch 31/90 - Average Loss: 1.7441\n",
      "Epoch 32/90 - Average Loss: 1.6401\n",
      "Epoch 33/90 - Average Loss: 1.5407\n",
      "Epoch 34/90 - Average Loss: 1.4577\n",
      "Epoch 35/90 - Average Loss: 1.3693\n",
      "Epoch 36/90 - Average Loss: 1.2951\n",
      "Epoch 37/90 - Average Loss: 1.2153\n",
      "Epoch 38/90 - Average Loss: 1.1336\n",
      "Epoch 39/90 - Average Loss: 1.0695\n",
      "Epoch 40/90 - Average Loss: 1.0081\n",
      "Epoch 41/90 - Average Loss: 0.9498\n",
      "Epoch 42/90 - Average Loss: 0.8879\n",
      "Epoch 43/90 - Average Loss: 0.8284\n",
      "Epoch 44/90 - Average Loss: 0.7808\n",
      "Epoch 45/90 - Average Loss: 0.7360\n",
      "Epoch 46/90 - Average Loss: 0.6892\n",
      "Epoch 47/90 - Average Loss: 0.6492\n",
      "Epoch 48/90 - Average Loss: 0.6026\n",
      "Epoch 49/90 - Average Loss: 0.5694\n",
      "Epoch 50/90 - Average Loss: 0.5378\n",
      "Epoch 51/90 - Average Loss: 0.5075\n",
      "Epoch 52/90 - Average Loss: 0.4727\n",
      "Epoch 53/90 - Average Loss: 0.4481\n",
      "Epoch 54/90 - Average Loss: 0.4278\n",
      "Epoch 55/90 - Average Loss: 0.4013\n",
      "Epoch 56/90 - Average Loss: 0.3765\n",
      "Epoch 57/90 - Average Loss: 0.3588\n",
      "Epoch 58/90 - Average Loss: 0.3379\n",
      "Epoch 59/90 - Average Loss: 0.3237\n",
      "Epoch 60/90 - Average Loss: 0.3053\n",
      "Epoch 61/90 - Average Loss: 0.2887\n",
      "Epoch 62/90 - Average Loss: 0.2751\n",
      "Epoch 63/90 - Average Loss: 0.2624\n",
      "Epoch 64/90 - Average Loss: 0.2491\n",
      "Epoch 65/90 - Average Loss: 0.2376\n",
      "Epoch 66/90 - Average Loss: 0.2225\n",
      "Epoch 67/90 - Average Loss: 0.2182\n",
      "Epoch 68/90 - Average Loss: 0.2059\n",
      "Epoch 69/90 - Average Loss: 0.1965\n",
      "Epoch 70/90 - Average Loss: 0.1880\n",
      "Epoch 71/90 - Average Loss: 0.1791\n",
      "Epoch 72/90 - Average Loss: 0.1692\n",
      "Epoch 73/90 - Average Loss: 0.1649\n",
      "Epoch 74/90 - Average Loss: 0.1574\n",
      "Epoch 75/90 - Average Loss: 0.1575\n",
      "Epoch 76/90 - Average Loss: 0.1470\n",
      "Epoch 77/90 - Average Loss: 0.1394\n",
      "Epoch 78/90 - Average Loss: 0.1344\n",
      "Epoch 79/90 - Average Loss: 0.1296\n",
      "Epoch 80/90 - Average Loss: 0.1253\n",
      "Epoch 81/90 - Average Loss: 0.1209\n",
      "Epoch 82/90 - Average Loss: 0.1161\n",
      "Epoch 83/90 - Average Loss: 0.1113\n",
      "Epoch 84/90 - Average Loss: 0.1074\n",
      "Epoch 85/90 - Average Loss: 0.1038\n",
      "Epoch 86/90 - Average Loss: 0.1011\n",
      "Epoch 87/90 - Average Loss: 0.0969\n",
      "Epoch 88/90 - Average Loss: 0.0925\n",
      "Epoch 89/90 - Average Loss: 0.0914\n",
      "Epoch 90/90 - Average Loss: 0.0881\n",
      "🤖 Chatbot is ready! Type 'exit' to stop.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "You:  exit\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bot: Goodbye! 👋\n"
     ]
    }
   ],
   "source": [
    "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/intents/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\"])\n",
    "\n",
    "# Run chatbot interaction\n",
    "print(\"🤖 Chatbot is ready! Type 'exit' to stop.\")\n",
    "while True:\n",
    "    user_input = input(\"You: \")\n",
    "    if user_input.lower() in [\"exit\", \"quit\"]:\n",
    "        print(\"Bot: Goodbye! 👋\")\n",
    "        break\n",
    "    response = predict_intent(user_input)\n",
    "    print(\"Bot:\", response)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-03-13T10:14:01.405815Z",
     "iopub.status.busy": "2025-03-13T10:14:01.405308Z",
     "iopub.status.idle": "2025-03-13T10:14:01.867874Z",
     "shell.execute_reply": "2025-03-13T10:14:01.866999Z",
     "shell.execute_reply.started": "2025-03-13T10:14:01.405792Z"
    }
   },
   "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-13T10:14:01.869228Z",
     "iopub.status.busy": "2025-03-13T10:14:01.868962Z",
     "iopub.status.idle": "2025-03-13T10:14:03.262649Z",
     "shell.execute_reply": "2025-03-13T10:14:03.261892Z",
     "shell.execute_reply.started": "2025-03-13T10:14:01.869205Z"
    }
   },
   "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-13T10:14:03.263629Z",
     "iopub.status.busy": "2025-03-13T10:14:03.263411Z",
     "iopub.status.idle": "2025-03-13T10:22:02.539404Z",
     "shell.execute_reply": "2025-03-13T10:22:02.538512Z",
     "shell.execute_reply.started": "2025-03-13T10:14:03.263611Z"
    }
   },
   "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-13T10:22:02.540339Z",
     "iopub.status.busy": "2025-03-13T10:22:02.540114Z",
     "iopub.status.idle": "2025-03-13T10:22:02.642619Z",
     "shell.execute_reply": "2025-03-13T10:22:02.642022Z",
     "shell.execute_reply.started": "2025-03-13T10:22:02.540320Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User: Tell me a joke\n",
      "Bot: Why don't skeletons fight each other? They don't have the guts!\n",
      "\n",
      "User: Recommend a good book\n",
      "Bot: Reading books can broaden your knowledge, enhance creativity, and provide a great way to relax.\n",
      "\n",
      "User: What's the weather like today?\n",
      "Bot: You can check the weather on a weather app or website.\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": [
    "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-13T10:33:46.308702Z",
     "iopub.status.busy": "2025-03-13T10:33:46.308278Z",
     "iopub.status.idle": "2025-03-13T10:33:46.964362Z",
     "shell.execute_reply": "2025-03-13T10:33:46.963545Z",
     "shell.execute_reply.started": "2025-03-13T10:33:46.308678Z"
    }
   },
   "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-13T10:38:56.933623Z",
     "iopub.status.busy": "2025-03-13T10:38:56.933265Z",
     "iopub.status.idle": "2025-03-13T10:38:57.968705Z",
     "shell.execute_reply": "2025-03-13T10:38:57.967785Z",
     "shell.execute_reply.started": "2025-03-13T10:38:56.933591Z"
    }
   },
   "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": 6859551,
     "sourceId": 11016856,
     "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
}