Spaces:

SamarthPujari
/

AI-Chatbot

Sleeping

App Files Files Community

SamarthPujari commited on Mar 15, 2025

Commit

d5e5fbf

verified ·

1 Parent(s): 678fea5

Initial Commit

Browse files

Files changed (21) hide show

.gitattributes +3 -35
.ipynb_checkpoints/ChatBot_Training-checkpoint.ipynb +681 -0
.ipynb_checkpoints/ChatBot_using_NLP-checkpoint.ipynb +330 -0
.ipynb_checkpoints/chatbot-training-checkpoint.ipynb +1 -0
ChatBot_using_NLP.ipynb +322 -0
Images/Bot Image.jpeg +3 -0
README.md +2 -14
Trained Model/bert_chatbot_model.pth +3 -0
Trained Model/bert_chatbot_tokenizer/special_tokens_map.json +7 -0
Trained Model/bert_chatbot_tokenizer/tokenizer_config.json +58 -0
Trained Model/bert_chatbot_tokenizer/vocab.txt +0 -0
Trained Model/chatbot_model/config.json +576 -0
Trained Model/chatbot_model/model.safetensors +3 -0
Trained Model/chatbot_model/special_tokens_map.json +7 -0
Trained Model/chatbot_model/tokenizer_config.json +58 -0
Trained Model/chatbot_model/vocab.txt +0 -0
chat_history.json +1 -0
chatbot-training.ipynb +659 -0
chatbot.py +188 -0
intents.json +0 -0
requirements.txt +5 -0

.gitattributes CHANGED Viewed

@@ -1,35 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

+Trained[[:space:]]Model/bert_chatbot_model.pth filter=lfs diff=lfs merge=lfs -text
+Trained[[:space:]]Model/chatbot_model/model.safetensors filter=lfs diff=lfs merge=lfs -text
+Images/Bot[[:space:]]Image.jpeg filter=lfs diff=lfs merge=lfs -text

.ipynb_checkpoints/ChatBot_Training-checkpoint.ipynb ADDED Viewed

	@@ -0,0 +1,681 @@

+{
+ "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
+}

.ipynb_checkpoints/ChatBot_using_NLP-checkpoint.ipynb ADDED Viewed

	@@ -0,0 +1,330 @@

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f0ce57f4-5984-43e6-b3bb-60f2d9251d75",
+   "metadata": {},
+   "source": [
+    "# Implementation of Chatbot using Natural Language Processing(NLP)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3c062c6e-0773-4af8-bcb9-aa33f7afeb25",
+   "metadata": {},
+   "source": [
+    "### Importing necessary libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "23417a10-2691-4887-b02e-2448f6200cd1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import nltk\n",
+    "import random\n",
+    "import os\n",
+    "import ssl\n",
+    "import streamlit as st\n",
+    "from sklearn.svm import SVC\n",
+    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
+    "from sklearn.linear_model import LogisticRegression"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1dc3d789-6567-4266-bd33-005aed1d4e93",
+   "metadata": {},
+   "source": [
+    "### Bypass SSL verification for NLTK downloads"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "298e3201-b127-4c68-b041-2a22ace29340",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[nltk_data] Downloading package punkt to\n",
+      "[nltk_data]     C:\\Users\\LENOVO\\AppData\\Roaming\\nltk_data...\n",
+      "[nltk_data]   Package punkt is already up-to-date!\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ssl._create_default_https_context = ssl._create_unverified_context\n",
+    "nltk.data.path.append(os.path.abspath('nltk_data'))\n",
+    "nltk.download('punkt')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "62d1be3d-37b1-4ab3-a527-9185e183ac98",
+   "metadata": {},
+   "source": [
+    "### Intent dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "a4c238c5-fe25-4802-9328-70ec7b064044",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "intents = [\n",
+    "    {\n",
+    "        \"tag\": \"greeting\", \"patterns\": [\"Hi\", \"Hello\", \"Hey\", \"What's up\", \"How are you\"],\n",
+    "         \"responses\": [\"Hi there!\", \"Hello!\", \"Hey!\", \"Nothing much.\", \"I'm fine, thank you.\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"goodbye\", \"patterns\": [\"Bye\", \"See you later\", \"Goodbye\", \"Take care\"],\n",
+    "         \"responses\": [\"Goodbye!\", \"See you later!\", \"Take care!\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"thanks\", \"patterns\": [\"Thank you\", \"Thanks\", \"Thanks a lot\", \"I appreciate it\"],\n",
+    "         \"responses\": [\"You're welcome!\", \"No problem!\", \"Glad I could help!\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"about\", \"patterns\": [\"What can you do\", \"Who are you\", \"What are you\", \"What is your purpose\"],\n",
+    "         \"responses\": [\"I am a chatbot.\", \"My purpose is to assist you.\", \"I can answer questions and provide assistance.\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"help\", \"patterns\": [\"Help\", \"I need help\", \"Can you help me\", \"What should I do\"],\n",
+    "         \"responses\": [\"Sure, what do you need help with?\", \"I'm here to help. What's the problem?\", \"How can I assist you?\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"age\", \"patterns\": [\"How old are you\", \"What's your age\"],\n",
+    "         \"responses\": [\"I don't have an age. I'm a chatbot.\", \"I was just born in the digital world.\", \"Age is just a number for me.\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"weather\", \"patterns\": [\"What's the weather like\", \"How's the weather today\"],\n",
+    "         \"responses\": [\"I'm sorry, I cannot provide real-time weather information.\", \"You can check the weather on a weather app or website.\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"budget\", \"patterns\": [\"How can I make a budget\", \"What's a good budgeting strategy\", \"How do I create a budget\"],\n",
+    "        \"responses\": [\"Start by tracking your income and expenses. Allocate money for essentials, savings, and discretionary spending.\",\n",
+    "         \"A good strategy is the 50/30/20 rule: 50% for needs, 30% for wants, and 20% for savings and debt.\",\n",
+    "         \"Set financial goals, monitor expenses, and adjust your budget as needed.\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"credit_score\", \"patterns\": [\"What is a credit score\", \"How do I check my credit score\", \"How can I improve my credit score\"],\n",
+    "        \"responses\": [\"A credit score reflects your creditworthiness and is used by lenders to assess loans.\",\n",
+    "         \"Check your credit score on platforms like Credit Karma or Credit Sesame.\",\n",
+    "         \"Improve your credit score by paying bills on time, reducing debt, and maintaining good credit utilization.\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"food\", \"patterns\": [\"What should I eat\", \"Suggest me some food\", \"I am hungry\"],\n",
+    "        \"responses\": [\"You could try a healthy salad, a sandwich, or some pasta!\", \"How about some homemade pizza?\", \"A nice bowl of soup and bread would be great!\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"exercise\", \"patterns\": [\"What exercises should I do\", \"How to stay fit\", \"Suggest a workout\"],\n",
+    "        \"responses\": [\"Try a mix of cardio and strength training!\", \"A daily walk and some stretching would help.\", \"Yoga is great for both mind and body!\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"movies\", \"patterns\": [\"Suggest me a movie\", \"What are some good movies\", \"I want to watch a film\"],\n",
+    "         \"responses\": [\"How about an action thriller?\", \"A comedy might lift your mood!\", \"Sci-fi movies are always exciting!\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"music\", \"patterns\": [\"Suggest me some music\", \"What should I listen to\", \"Recommend a song\"],\n",
+    "        \"responses\": [\"Try some relaxing jazz or lo-fi music!\", \"Pop songs are always fun!\", \"How about some classic rock?\"]\n",
+    "    }\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3ece2689-d741-48ea-9659-be9cf20e3033",
+   "metadata": {},
+   "source": [
+    "### Create the vectorizer and classifier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "18d6ccb9-639c-4053-981a-69e2fa7cccca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vectorizer = TfidfVectorizer()\n",
+    "clf = SVC(kernel='linear', random_state=0)\n",
+    "#clf = LogisticRegression(random_state=0, max_iter=10000)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "09e70e89-e826-432a-9c22-b4097b5ac07f",
+   "metadata": {},
+   "source": [
+    "### Preprocess the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "aca02fbf-201b-47a6-b46c-ca9e0d4e9334",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tags = []\n",
+    "patterns = []\n",
+    "for intent in intents:\n",
+    "    for pattern in intent['patterns']:\n",
+    "        tags.append(intent['tag'])\n",
+    "        patterns.append(pattern)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e33f4599-2a6b-4b9b-805a-7875b1840eb4",
+   "metadata": {},
+   "source": [
+    "### Training the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "6d11f50c-7062-46e3-89d2-f6e252e5cf12",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style>#sk-container-id-1 {color: black;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>SVC(kernel=&#x27;linear&#x27;, random_state=0)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">SVC</label><div class=\"sk-toggleable__content\"><pre>SVC(kernel=&#x27;linear&#x27;, random_state=0)</pre></div></div></div></div></div>"
+      ],
+      "text/plain": [
+       "SVC(kernel='linear', random_state=0)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x = vectorizer.fit_transform(patterns)\n",
+    "y = tags\n",
+    "clf.fit(x, y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a75b5c8f-cc42-4afc-b261-bfdbe6c79913",
+   "metadata": {},
+   "source": [
+    "### Python function to chat with the chatbot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "12ac8a47-eac5-440f-ab0e-93686944b34b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def chatbot(input_text):\n",
+    "    input_text = vectorizer.transform([input_text])\n",
+    "    tag = clf.predict(input_text)[0]\n",
+    "    for intent in intents:\n",
+    "        if intent['tag'] == tag:\n",
+    "            response = random.choice(intent['responses'])\n",
+    "            return response"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cf1ff963-ebbe-4fac-af82-26d3e3336c33",
+   "metadata": {},
+   "source": [
+    "### Checking our chatbot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "8f469e8a-c8a0-4683-9be0-0aefa67c8cea",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hey!\n"
+     ]
+    }
+   ],
+   "source": [
+    "user_input = \"Hello\"\n",
+    "response = chatbot(user_input)\n",
+    "print(response)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "f49306db-d7da-4e79-860e-cd6e2985ca58",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Try a mix of cardio and strength training!\n"
+     ]
+    }
+   ],
+   "source": [
+    "user_input = \"What exercises should I do\"\n",
+    "response = chatbot(user_input)\n",
+    "print(response)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "edcde051-3bbe-444f-9318-77fb7dc161bf",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "GPU(sam)",
+   "language": "python",
+   "name": "sam"
+  },
+  "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": 5
+}

.ipynb_checkpoints/chatbot-training-checkpoint.ipynb ADDED Viewed

	@@ -0,0 +1 @@

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

ChatBot_using_NLP.ipynb ADDED Viewed

	@@ -0,0 +1,322 @@

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f0ce57f4-5984-43e6-b3bb-60f2d9251d75",
+   "metadata": {},
+   "source": [
+    "# Implementation of Chatbot using Natural Language Processing(NLP)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3c062c6e-0773-4af8-bcb9-aa33f7afeb25",
+   "metadata": {},
+   "source": [
+    "### Importing necessary libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "23417a10-2691-4887-b02e-2448f6200cd1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import nltk\n",
+    "import random\n",
+    "import os\n",
+    "import ssl\n",
+    "import streamlit as st\n",
+    "from sklearn.svm import SVC\n",
+    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
+    "from sklearn.linear_model import LogisticRegression"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1dc3d789-6567-4266-bd33-005aed1d4e93",
+   "metadata": {},
+   "source": [
+    "### Bypass SSL verification for NLTK downloads"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "298e3201-b127-4c68-b041-2a22ace29340",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[nltk_data] Downloading package punkt to\n",
+      "[nltk_data]     C:\\Users\\LENOVO\\AppData\\Roaming\\nltk_data...\n",
+      "[nltk_data]   Package punkt is already up-to-date!\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ssl._create_default_https_context = ssl._create_unverified_context\n",
+    "nltk.data.path.append(os.path.abspath('nltk_data'))\n",
+    "nltk.download('punkt')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "62d1be3d-37b1-4ab3-a527-9185e183ac98",
+   "metadata": {},
+   "source": [
+    "### Intent dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "a4c238c5-fe25-4802-9328-70ec7b064044",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "intents = [\n",
+    "    {\n",
+    "        \"atag\": \"greeting\", \"patterns\": [\"Hi\", \"Hello\", \"Hey\", \"What's up\", \"How are you\"],\n",
+    "         \"responses\": [\"Hi there!\", \"Hello!\", \"Hey!\", \"Nothing much.\", \"I'm fine, thank you.\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"goodbye\", \"patterns\": [\"Bye\", \"See you later\", \"Goodbye\", \"Take care\"],\n",
+    "         \"responses\": [\"Goodbye!\", \"See you later!\", \"Take care!\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"thanks\", \"patterns\": [\"Thank you\", \"Thanks\", \"Thanks a lot\", \"I appreciate it\"],\n",
+    "         \"responses\": [\"You're welcome!\", \"No problem!\", \"Glad I could help!\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"about\", \"patterns\": [\"What can you do\", \"Who are you\", \"What are you\", \"What is your purpose\"],\n",
+    "         \"responses\": [\"I am a chatbot.\", \"My purpose is to assist you.\", \"I can answer questions and provide assistance.\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"help\", \"patterns\": [\"Help\", \"I need help\", \"Can you help me\", \"What should I do\"],\n",
+    "         \"responses\": [\"Sure, what do you need help with?\", \"I'm here to help. What's the problem?\", \"How can I assist you?\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"age\", \"patterns\": [\"How old are you\", \"What's your age\"],\n",
+    "         \"responses\": [\"I don't have an age. I'm a chatbot.\", \"I was just born in the digital world.\", \"Age is just a number for me.\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"weather\", \"patterns\": [\"What's the weather like\", \"How's the weather today\"],\n",
+    "         \"responses\": [\"I'm sorry, I cannot provide real-time weather information.\", \"You can check the weather on a weather app or website.\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"budget\", \"patterns\": [\"How can I make a budget\", \"What's a good budgeting strategy\", \"How do I create a budget\"],\n",
+    "        \"responses\": [\"Start by tracking your income and expenses. Allocate money for essentials, savings, and discretionary spending.\",\n",
+    "         \"A good strategy is the 50/30/20 rule: 50% for needs, 30% for wants, and 20% for savings and debt.\",\n",
+    "         \"Set financial goals, monitor expenses, and adjust your budget as needed.\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"credit_score\", \"patterns\": [\"What is a credit score\", \"How do I check my credit score\", \"How can I improve my credit score\"],\n",
+    "        \"responses\": [\"A credit score reflects your creditworthiness and is used by lenders to assess loans.\",\n",
+    "         \"Check your credit score on platforms like Credit Karma or Credit Sesame.\",\n",
+    "         \"Improve your credit score by paying bills on time, reducing debt, and maintaining good credit utilization.\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"food\", \"patterns\": [\"What should I eat\", \"Suggest me some food\", \"I am hungry\"],\n",
+    "        \"responses\": [\"You could try a healthy salad, a sandwich, or some pasta!\", \"How about some homemade pizza?\", \"A nice bowl of soup and bread would be great!\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"exercise\", \"patterns\": [\"What exercises should I do\", \"How to stay fit\", \"Suggest a workout\"],\n",
+    "        \"responses\": [\"Try a mix of cardio and strength training!\", \"A daily walk and some stretching would help.\", \"Yoga is great for both mind and body!\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"movies\", \"patterns\": [\"Suggest me a movie\", \"What are some good movies\", \"I want to watch a film\"],\n",
+    "         \"responses\": [\"How about an action thriller?\", \"A comedy might lift your mood!\", \"Sci-fi movies are always exciting!\"]\n",
+    "    },\n",
+    "    {\n",
+    "        \"tag\": \"music\", \"patterns\": [\"Suggest me some music\", \"What should I listen to\", \"Recommend a song\"],\n",
+    "        \"responses\": [\"Try some relaxing jazz or lo-fi music!\", \"Pop songs are always fun!\", \"How about some classic rock?\"]\n",
+    "    }\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3ece2689-d741-48ea-9659-be9cf20e3033",
+   "metadata": {},
+   "source": [
+    "### Create the vectorizer and classifier"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "18d6ccb9-639c-4053-981a-69e2fa7cccca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vectorizer = TfidfVectorizer()\n",
+    "clf = SVC(kernel='linear', random_state=0)\n",
+    "#clf = LogisticRegression(random_state=0, max_iter=10000)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "09e70e89-e826-432a-9c22-b4097b5ac07f",
+   "metadata": {},
+   "source": [
+    "### Preprocess the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "aca02fbf-201b-47a6-b46c-ca9e0d4e9334",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tags = []\n",
+    "patterns = []\n",
+    "for intent in intents:\n",
+    "    for pattern in intent['patterns']:\n",
+    "        tags.append(intent['tag'])\n",
+    "        patterns.append(pattern)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e33f4599-2a6b-4b9b-805a-7875b1840eb4",
+   "metadata": {},
+   "source": [
+    "### Training the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "6d11f50c-7062-46e3-89d2-f6e252e5cf12",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style>#sk-container-id-1 {color: black;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>SVC(kernel=&#x27;linear&#x27;, random_state=0)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">SVC</label><div class=\"sk-toggleable__content\"><pre>SVC(kernel=&#x27;linear&#x27;, random_state=0)</pre></div></div></div></div></div>"
+      ],
+      "text/plain": [
+       "SVC(kernel='linear', random_state=0)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x = vectorizer.fit_transform(patterns)\n",
+    "y = tags\n",
+    "clf.fit(x, y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a75b5c8f-cc42-4afc-b261-bfdbe6c79913",
+   "metadata": {},
+   "source": [
+    "### Python function to chat with the chatbot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "12ac8a47-eac5-440f-ab0e-93686944b34b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def chatbot(input_text):\n",
+    "    input_text = vectorizer.transform([input_text])\n",
+    "    tag = clf.predict(input_text)[0]\n",
+    "    for intent in intents:\n",
+    "        if intent['tag'] == tag:\n",
+    "            response = random.choice(intent['responses'])\n",
+    "            return response"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cf1ff963-ebbe-4fac-af82-26d3e3336c33",
+   "metadata": {},
+   "source": [
+    "### Checking our chatbot"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "8f469e8a-c8a0-4683-9be0-0aefa67c8cea",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hey!\n"
+     ]
+    }
+   ],
+   "source": [
+    "user_input = \"Hello\"\n",
+    "response = chatbot(user_input)\n",
+    "print(response)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "f49306db-d7da-4e79-860e-cd6e2985ca58",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Try a mix of cardio and strength training!\n"
+     ]
+    }
+   ],
+   "source": [
+    "user_input = \"What exercises should I do\"\n",
+    "response = chatbot(user_input)\n",
+    "print(response)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "GPU(sam)",
+   "language": "python",
+   "name": "sam"
+  },
+  "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": 5
+}

Images/Bot Image.jpeg ADDED Viewed

Git LFS Details

SHA256: 2f1760f6c71098287ba8dbe6d5c7a645b89154c2189355aba3b0da13515a4f27
Pointer size: 131 Bytes
Size of remote file: 370 kB

README.md CHANGED Viewed

@@ -1,14 +1,2 @@
----
-title: Chatbot On Intents Data
-emoji: 📚
-colorFrom: pink
-colorTo: yellow
-sdk: streamlit
-sdk_version: 1.43.2
-app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: The System on Real Time Intent Recognition and Conversations
----
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference


1	+ # Implementation of Chatbot using Natural Language Processing (NLP)
2	+ Welcome!

Trained Model/bert_chatbot_model.pth ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:cfae148072dd42387f8b37e25dd6145fba9fbb1f4d85598dc0d57af6f42d0537
+size 438852591

Trained Model/bert_chatbot_tokenizer/special_tokens_map.json ADDED Viewed

	@@ -0,0 +1,7 @@

+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

Trained Model/bert_chatbot_tokenizer/tokenizer_config.json ADDED Viewed

	@@ -0,0 +1,58 @@

+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "100": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "101": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "102": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "103": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "extra_special_tokens": {},
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}

Trained Model/bert_chatbot_tokenizer/vocab.txt ADDED Viewed

The diff for this file is too large to render. See raw diff

Trained Model/chatbot_model/config.json ADDED Viewed

	@@ -0,0 +1,576 @@

+{
+  "_name_or_path": "bert-base-uncased",
+  "architectures": [
+    "BertForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "LABEL_0",
+    "1": "LABEL_1",
+    "2": "LABEL_2",
+    "3": "LABEL_3",
+    "4": "LABEL_4",
+    "5": "LABEL_5",
+    "6": "LABEL_6",
+    "7": "LABEL_7",
+    "8": "LABEL_8",
+    "9": "LABEL_9",
+    "10": "LABEL_10",
+    "11": "LABEL_11",
+    "12": "LABEL_12",
+    "13": "LABEL_13",
+    "14": "LABEL_14",
+    "15": "LABEL_15",
+    "16": "LABEL_16",
+    "17": "LABEL_17",
+    "18": "LABEL_18",
+    "19": "LABEL_19",
+    "20": "LABEL_20",
+    "21": "LABEL_21",
+    "22": "LABEL_22",
+    "23": "LABEL_23",
+    "24": "LABEL_24",
+    "25": "LABEL_25",
+    "26": "LABEL_26",
+    "27": "LABEL_27",
+    "28": "LABEL_28",
+    "29": "LABEL_29",
+    "30": "LABEL_30",
+    "31": "LABEL_31",
+    "32": "LABEL_32",
+    "33": "LABEL_33",
+    "34": "LABEL_34",
+    "35": "LABEL_35",
+    "36": "LABEL_36",
+    "37": "LABEL_37",
+    "38": "LABEL_38",
+    "39": "LABEL_39",
+    "40": "LABEL_40",
+    "41": "LABEL_41",
+    "42": "LABEL_42",
+    "43": "LABEL_43",
+    "44": "LABEL_44",
+    "45": "LABEL_45",
+    "46": "LABEL_46",
+    "47": "LABEL_47",
+    "48": "LABEL_48",
+    "49": "LABEL_49",
+    "50": "LABEL_50",
+    "51": "LABEL_51",
+    "52": "LABEL_52",
+    "53": "LABEL_53",
+    "54": "LABEL_54",
+    "55": "LABEL_55",
+    "56": "LABEL_56",
+    "57": "LABEL_57",
+    "58": "LABEL_58",
+    "59": "LABEL_59",
+    "60": "LABEL_60",
+    "61": "LABEL_61",
+    "62": "LABEL_62",
+    "63": "LABEL_63",
+    "64": "LABEL_64",
+    "65": "LABEL_65",
+    "66": "LABEL_66",
+    "67": "LABEL_67",
+    "68": "LABEL_68",
+    "69": "LABEL_69",
+    "70": "LABEL_70",
+    "71": "LABEL_71",
+    "72": "LABEL_72",
+    "73": "LABEL_73",
+    "74": "LABEL_74",
+    "75": "LABEL_75",
+    "76": "LABEL_76",
+    "77": "LABEL_77",
+    "78": "LABEL_78",
+    "79": "LABEL_79",
+    "80": "LABEL_80",
+    "81": "LABEL_81",
+    "82": "LABEL_82",
+    "83": "LABEL_83",
+    "84": "LABEL_84",
+    "85": "LABEL_85",
+    "86": "LABEL_86",
+    "87": "LABEL_87",
+    "88": "LABEL_88",
+    "89": "LABEL_89",
+    "90": "LABEL_90",
+    "91": "LABEL_91",
+    "92": "LABEL_92",
+    "93": "LABEL_93",
+    "94": "LABEL_94",
+    "95": "LABEL_95",
+    "96": "LABEL_96",
+    "97": "LABEL_97",
+    "98": "LABEL_98",
+    "99": "LABEL_99",
+    "100": "LABEL_100",
+    "101": "LABEL_101",
+    "102": "LABEL_102",
+    "103": "LABEL_103",
+    "104": "LABEL_104",
+    "105": "LABEL_105",
+    "106": "LABEL_106",
+    "107": "LABEL_107",
+    "108": "LABEL_108",
+    "109": "LABEL_109",
+    "110": "LABEL_110",
+    "111": "LABEL_111",
+    "112": "LABEL_112",
+    "113": "LABEL_113",
+    "114": "LABEL_114",
+    "115": "LABEL_115",
+    "116": "LABEL_116",
+    "117": "LABEL_117",
+    "118": "LABEL_118",
+    "119": "LABEL_119",
+    "120": "LABEL_120",
+    "121": "LABEL_121",
+    "122": "LABEL_122",
+    "123": "LABEL_123",
+    "124": "LABEL_124",
+    "125": "LABEL_125",
+    "126": "LABEL_126",
+    "127": "LABEL_127",
+    "128": "LABEL_128",
+    "129": "LABEL_129",
+    "130": "LABEL_130",
+    "131": "LABEL_131",
+    "132": "LABEL_132",
+    "133": "LABEL_133",
+    "134": "LABEL_134",
+    "135": "LABEL_135",
+    "136": "LABEL_136",
+    "137": "LABEL_137",
+    "138": "LABEL_138",
+    "139": "LABEL_139",
+    "140": "LABEL_140",
+    "141": "LABEL_141",
+    "142": "LABEL_142",
+    "143": "LABEL_143",
+    "144": "LABEL_144",
+    "145": "LABEL_145",
+    "146": "LABEL_146",
+    "147": "LABEL_147",
+    "148": "LABEL_148",
+    "149": "LABEL_149",
+    "150": "LABEL_150",
+    "151": "LABEL_151",
+    "152": "LABEL_152",
+    "153": "LABEL_153",
+    "154": "LABEL_154",
+    "155": "LABEL_155",
+    "156": "LABEL_156",
+    "157": "LABEL_157",
+    "158": "LABEL_158",
+    "159": "LABEL_159",
+    "160": "LABEL_160",
+    "161": "LABEL_161",
+    "162": "LABEL_162",
+    "163": "LABEL_163",
+    "164": "LABEL_164",
+    "165": "LABEL_165",
+    "166": "LABEL_166",
+    "167": "LABEL_167",
+    "168": "LABEL_168",
+    "169": "LABEL_169",
+    "170": "LABEL_170",
+    "171": "LABEL_171",
+    "172": "LABEL_172",
+    "173": "LABEL_173",
+    "174": "LABEL_174",
+    "175": "LABEL_175",
+    "176": "LABEL_176",
+    "177": "LABEL_177",
+    "178": "LABEL_178",
+    "179": "LABEL_179",
+    "180": "LABEL_180",
+    "181": "LABEL_181",
+    "182": "LABEL_182",
+    "183": "LABEL_183",
+    "184": "LABEL_184",
+    "185": "LABEL_185",
+    "186": "LABEL_186",
+    "187": "LABEL_187",
+    "188": "LABEL_188",
+    "189": "LABEL_189",
+    "190": "LABEL_190",
+    "191": "LABEL_191",
+    "192": "LABEL_192",
+    "193": "LABEL_193",
+    "194": "LABEL_194",
+    "195": "LABEL_195",
+    "196": "LABEL_196",
+    "197": "LABEL_197",
+    "198": "LABEL_198",
+    "199": "LABEL_199",
+    "200": "LABEL_200",
+    "201": "LABEL_201",
+    "202": "LABEL_202",
+    "203": "LABEL_203",
+    "204": "LABEL_204",
+    "205": "LABEL_205",
+    "206": "LABEL_206",
+    "207": "LABEL_207",
+    "208": "LABEL_208",
+    "209": "LABEL_209",
+    "210": "LABEL_210",
+    "211": "LABEL_211",
+    "212": "LABEL_212",
+    "213": "LABEL_213",
+    "214": "LABEL_214",
+    "215": "LABEL_215",
+    "216": "LABEL_216",
+    "217": "LABEL_217",
+    "218": "LABEL_218",
+    "219": "LABEL_219",
+    "220": "LABEL_220",
+    "221": "LABEL_221",
+    "222": "LABEL_222",
+    "223": "LABEL_223",
+    "224": "LABEL_224",
+    "225": "LABEL_225",
+    "226": "LABEL_226",
+    "227": "LABEL_227",
+    "228": "LABEL_228",
+    "229": "LABEL_229",
+    "230": "LABEL_230",
+    "231": "LABEL_231",
+    "232": "LABEL_232",
+    "233": "LABEL_233",
+    "234": "LABEL_234",
+    "235": "LABEL_235",
+    "236": "LABEL_236",
+    "237": "LABEL_237",
+    "238": "LABEL_238",
+    "239": "LABEL_239",
+    "240": "LABEL_240",
+    "241": "LABEL_241",
+    "242": "LABEL_242",
+    "243": "LABEL_243",
+    "244": "LABEL_244",
+    "245": "LABEL_245",
+    "246": "LABEL_246",
+    "247": "LABEL_247",
+    "248": "LABEL_248",
+    "249": "LABEL_249",
+    "250": "LABEL_250",
+    "251": "LABEL_251",
+    "252": "LABEL_252",
+    "253": "LABEL_253",
+    "254": "LABEL_254",
+    "255": "LABEL_255",
+    "256": "LABEL_256",
+    "257": "LABEL_257",
+    "258": "LABEL_258",
+    "259": "LABEL_259",
+    "260": "LABEL_260",
+    "261": "LABEL_261",
+    "262": "LABEL_262",
+    "263": "LABEL_263",
+    "264": "LABEL_264",
+    "265": "LABEL_265",
+    "266": "LABEL_266",
+    "267": "LABEL_267",
+    "268": "LABEL_268",
+    "269": "LABEL_269",
+    "270": "LABEL_270",
+    "271": "LABEL_271",
+    "272": "LABEL_272"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "LABEL_0": 0,
+    "LABEL_1": 1,
+    "LABEL_10": 10,
+    "LABEL_100": 100,
+    "LABEL_101": 101,
+    "LABEL_102": 102,
+    "LABEL_103": 103,
+    "LABEL_104": 104,
+    "LABEL_105": 105,
+    "LABEL_106": 106,
+    "LABEL_107": 107,
+    "LABEL_108": 108,
+    "LABEL_109": 109,
+    "LABEL_11": 11,
+    "LABEL_110": 110,
+    "LABEL_111": 111,
+    "LABEL_112": 112,
+    "LABEL_113": 113,
+    "LABEL_114": 114,
+    "LABEL_115": 115,
+    "LABEL_116": 116,
+    "LABEL_117": 117,
+    "LABEL_118": 118,
+    "LABEL_119": 119,
+    "LABEL_12": 12,
+    "LABEL_120": 120,
+    "LABEL_121": 121,
+    "LABEL_122": 122,
+    "LABEL_123": 123,
+    "LABEL_124": 124,
+    "LABEL_125": 125,
+    "LABEL_126": 126,
+    "LABEL_127": 127,
+    "LABEL_128": 128,
+    "LABEL_129": 129,
+    "LABEL_13": 13,
+    "LABEL_130": 130,
+    "LABEL_131": 131,
+    "LABEL_132": 132,
+    "LABEL_133": 133,
+    "LABEL_134": 134,
+    "LABEL_135": 135,
+    "LABEL_136": 136,
+    "LABEL_137": 137,
+    "LABEL_138": 138,
+    "LABEL_139": 139,
+    "LABEL_14": 14,
+    "LABEL_140": 140,
+    "LABEL_141": 141,
+    "LABEL_142": 142,
+    "LABEL_143": 143,
+    "LABEL_144": 144,
+    "LABEL_145": 145,
+    "LABEL_146": 146,
+    "LABEL_147": 147,
+    "LABEL_148": 148,
+    "LABEL_149": 149,
+    "LABEL_15": 15,
+    "LABEL_150": 150,
+    "LABEL_151": 151,
+    "LABEL_152": 152,
+    "LABEL_153": 153,
+    "LABEL_154": 154,
+    "LABEL_155": 155,
+    "LABEL_156": 156,
+    "LABEL_157": 157,
+    "LABEL_158": 158,
+    "LABEL_159": 159,
+    "LABEL_16": 16,
+    "LABEL_160": 160,
+    "LABEL_161": 161,
+    "LABEL_162": 162,
+    "LABEL_163": 163,
+    "LABEL_164": 164,
+    "LABEL_165": 165,
+    "LABEL_166": 166,
+    "LABEL_167": 167,
+    "LABEL_168": 168,
+    "LABEL_169": 169,
+    "LABEL_17": 17,
+    "LABEL_170": 170,
+    "LABEL_171": 171,
+    "LABEL_172": 172,
+    "LABEL_173": 173,
+    "LABEL_174": 174,
+    "LABEL_175": 175,
+    "LABEL_176": 176,
+    "LABEL_177": 177,
+    "LABEL_178": 178,
+    "LABEL_179": 179,
+    "LABEL_18": 18,
+    "LABEL_180": 180,
+    "LABEL_181": 181,
+    "LABEL_182": 182,
+    "LABEL_183": 183,
+    "LABEL_184": 184,
+    "LABEL_185": 185,
+    "LABEL_186": 186,
+    "LABEL_187": 187,
+    "LABEL_188": 188,
+    "LABEL_189": 189,
+    "LABEL_19": 19,
+    "LABEL_190": 190,
+    "LABEL_191": 191,
+    "LABEL_192": 192,
+    "LABEL_193": 193,
+    "LABEL_194": 194,
+    "LABEL_195": 195,
+    "LABEL_196": 196,
+    "LABEL_197": 197,
+    "LABEL_198": 198,
+    "LABEL_199": 199,
+    "LABEL_2": 2,
+    "LABEL_20": 20,
+    "LABEL_200": 200,
+    "LABEL_201": 201,
+    "LABEL_202": 202,
+    "LABEL_203": 203,
+    "LABEL_204": 204,
+    "LABEL_205": 205,
+    "LABEL_206": 206,
+    "LABEL_207": 207,
+    "LABEL_208": 208,
+    "LABEL_209": 209,
+    "LABEL_21": 21,
+    "LABEL_210": 210,
+    "LABEL_211": 211,
+    "LABEL_212": 212,
+    "LABEL_213": 213,
+    "LABEL_214": 214,
+    "LABEL_215": 215,
+    "LABEL_216": 216,
+    "LABEL_217": 217,
+    "LABEL_218": 218,
+    "LABEL_219": 219,
+    "LABEL_22": 22,
+    "LABEL_220": 220,
+    "LABEL_221": 221,
+    "LABEL_222": 222,
+    "LABEL_223": 223,
+    "LABEL_224": 224,
+    "LABEL_225": 225,
+    "LABEL_226": 226,
+    "LABEL_227": 227,
+    "LABEL_228": 228,
+    "LABEL_229": 229,
+    "LABEL_23": 23,
+    "LABEL_230": 230,
+    "LABEL_231": 231,
+    "LABEL_232": 232,
+    "LABEL_233": 233,
+    "LABEL_234": 234,
+    "LABEL_235": 235,
+    "LABEL_236": 236,
+    "LABEL_237": 237,
+    "LABEL_238": 238,
+    "LABEL_239": 239,
+    "LABEL_24": 24,
+    "LABEL_240": 240,
+    "LABEL_241": 241,
+    "LABEL_242": 242,
+    "LABEL_243": 243,
+    "LABEL_244": 244,
+    "LABEL_245": 245,
+    "LABEL_246": 246,
+    "LABEL_247": 247,
+    "LABEL_248": 248,
+    "LABEL_249": 249,
+    "LABEL_25": 25,
+    "LABEL_250": 250,
+    "LABEL_251": 251,
+    "LABEL_252": 252,
+    "LABEL_253": 253,
+    "LABEL_254": 254,
+    "LABEL_255": 255,
+    "LABEL_256": 256,
+    "LABEL_257": 257,
+    "LABEL_258": 258,
+    "LABEL_259": 259,
+    "LABEL_26": 26,
+    "LABEL_260": 260,
+    "LABEL_261": 261,
+    "LABEL_262": 262,
+    "LABEL_263": 263,
+    "LABEL_264": 264,
+    "LABEL_265": 265,
+    "LABEL_266": 266,
+    "LABEL_267": 267,
+    "LABEL_268": 268,
+    "LABEL_269": 269,
+    "LABEL_27": 27,
+    "LABEL_270": 270,
+    "LABEL_271": 271,
+    "LABEL_272": 272,
+    "LABEL_28": 28,
+    "LABEL_29": 29,
+    "LABEL_3": 3,
+    "LABEL_30": 30,
+    "LABEL_31": 31,
+    "LABEL_32": 32,
+    "LABEL_33": 33,
+    "LABEL_34": 34,
+    "LABEL_35": 35,
+    "LABEL_36": 36,
+    "LABEL_37": 37,
+    "LABEL_38": 38,
+    "LABEL_39": 39,
+    "LABEL_4": 4,
+    "LABEL_40": 40,
+    "LABEL_41": 41,
+    "LABEL_42": 42,
+    "LABEL_43": 43,
+    "LABEL_44": 44,
+    "LABEL_45": 45,
+    "LABEL_46": 46,
+    "LABEL_47": 47,
+    "LABEL_48": 48,
+    "LABEL_49": 49,
+    "LABEL_5": 5,
+    "LABEL_50": 50,
+    "LABEL_51": 51,
+    "LABEL_52": 52,
+    "LABEL_53": 53,
+    "LABEL_54": 54,
+    "LABEL_55": 55,
+    "LABEL_56": 56,
+    "LABEL_57": 57,
+    "LABEL_58": 58,
+    "LABEL_59": 59,
+    "LABEL_6": 6,
+    "LABEL_60": 60,
+    "LABEL_61": 61,
+    "LABEL_62": 62,
+    "LABEL_63": 63,
+    "LABEL_64": 64,
+    "LABEL_65": 65,
+    "LABEL_66": 66,
+    "LABEL_67": 67,
+    "LABEL_68": 68,
+    "LABEL_69": 69,
+    "LABEL_7": 7,
+    "LABEL_70": 70,
+    "LABEL_71": 71,
+    "LABEL_72": 72,
+    "LABEL_73": 73,
+    "LABEL_74": 74,
+    "LABEL_75": 75,
+    "LABEL_76": 76,
+    "LABEL_77": 77,
+    "LABEL_78": 78,
+    "LABEL_79": 79,
+    "LABEL_8": 8,
+    "LABEL_80": 80,
+    "LABEL_81": 81,
+    "LABEL_82": 82,
+    "LABEL_83": 83,
+    "LABEL_84": 84,
+    "LABEL_85": 85,
+    "LABEL_86": 86,
+    "LABEL_87": 87,
+    "LABEL_88": 88,
+    "LABEL_89": 89,
+    "LABEL_9": 9,
+    "LABEL_90": 90,
+    "LABEL_91": 91,
+    "LABEL_92": 92,
+    "LABEL_93": 93,
+    "LABEL_94": 94,
+    "LABEL_95": 95,
+    "LABEL_96": 96,
+    "LABEL_97": 97,
+    "LABEL_98": 98,
+    "LABEL_99": 99
+  },
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "torch_dtype": "float32",
+  "transformers_version": "4.47.0",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 30522
+}

Trained Model/chatbot_model/model.safetensors ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:da4b23741fbf40b8ee8f054fb977dabf7ec19fbf607330b1778949d53c6d2315
+size 438792244

Trained Model/chatbot_model/special_tokens_map.json ADDED Viewed

	@@ -0,0 +1,7 @@

+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

Trained Model/chatbot_model/tokenizer_config.json ADDED Viewed

	@@ -0,0 +1,58 @@

+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "100": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "101": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "102": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "103": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "extra_special_tokens": {},
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}

Trained Model/chatbot_model/vocab.txt ADDED Viewed

The diff for this file is too large to render. See raw diff

chat_history.json ADDED Viewed

	@@ -0,0 +1 @@


1	+ ["[2025-03-15 12:02:53] You: Hi", "[2025-03-15 12:02:53] Bot: Hi there"]

chatbot-training.ipynb ADDED Viewed

	@@ -0,0 +1,659 @@

+{
+ "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
+}

chatbot.py ADDED Viewed

	@@ -0,0 +1,188 @@

+import streamlit as st
+import torch
+from transformers import BertTokenizer, BertForSequenceClassification
+import json
+import os
+import time
+import datetime
+import random
+from streamlit_extras.add_vertical_space import add_vertical_space
+from streamlit_extras.let_it_rain import rain
+from streamlit_modal import Modal
+# Streamlit UI
+st.set_page_config(page_title="ChatBot", layout="wide")
+# Load BERT Model & Tokenizer
+MODEL_PATH = "Trained Model/chatbot_model"  # Path where your model & tokenizer are saved
+# Set device
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+# Load model & tokenizer
+tokenizer = BertTokenizer.from_pretrained(MODEL_PATH)
+model = BertForSequenceClassification.from_pretrained(MODEL_PATH)
+model.to(device)
+model.eval()
+# Load intents
+with open("intents.json", "r") as file:
+    intents = json.load(file)
+intent_mapping = {i: intent['tag'] for i, intent in enumerate(intents)}
+# Chat history file
+CHAT_HISTORY_FILE = "chat_history.json"
+# Load Chat History (Ensuring Persistence)
+def load_chat_history():
+    if os.path.exists(CHAT_HISTORY_FILE):
+        with open(CHAT_HISTORY_FILE, "r") as file:
+            return json.load(file)
+    return []
+# Save Chat History
+def save_chat_history():
+    with open(CHAT_HISTORY_FILE, "w") as file:
+        json.dump(st.session_state.chat_history, file)
+# Initialize session state variables
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = load_chat_history()
+if "show_history" not in st.session_state:
+    st.session_state.show_history = False
+if "show_about" not in st.session_state:
+    st.session_state.show_about = False
+if "chat_input" not in st.session_state:
+    st.session_state.chat_input = ""
+def predict_intent(text):
+    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True).to(device)
+    with torch.no_grad():
+        outputs = model(**inputs)
+    predicted_index = torch.argmax(outputs.logits, dim=1).item()
+    return intent_mapping.get(predicted_index, "unknown")
+def get_response(intent_label):
+    for intent in intents:
+        if intent_label == intent['tag']:
+            return random.choice(intent['responses'])
+    return "I'm not sure how to respond to that."
+# Sidebar menu
+with st.sidebar:
+    st.image("Images/Bot Image.jpeg", use_container_width=True)
+    st.title("💬 Chatbot Menu")
+    add_vertical_space(1)
+    if st.button("🆕 New Chat"):
+        st.session_state.chat_input = ""
+        save_chat_history()
+    if st.button("📜 Chat History"):
+        st.session_state.show_history = True
+    if st.button("ℹ️ About"):
+        st.session_state.show_about = True
+    st.caption("🚀 Built with ❤️ by AI Enthusiast")
+# Modal Windows (Chat History & About)
+history_modal = Modal("📜Chat History", key="history_modal")
+about_modal = Modal("ℹ️About", key="about_modal")
+# Display chat history without affecting the chat window
+if st.session_state.show_history:
+    with history_modal.container():
+        if st.session_state.chat_history:
+            for chat in st.session_state.chat_history[-10:]:  # Show last 10 messages
+                st.write(chat)
+        else:
+            st.info("No chat history available.")
+        # Clear History Button
+        if st.button("🗑 Clear History", key="clear_history"):
+            st.session_state.chat_history = []  # Clear session history
+            if os.path.exists(CHAT_HISTORY_FILE):
+                os.remove(CHAT_HISTORY_FILE)  # Delete saved file
+            st.rerun()  # Refresh UI to reflect changes
+        # Close Modal Button
+        if st.button("Close", key="close_history"):
+            st.session_state.show_history = False
+            st.rerun()
+if st.session_state.show_about:
+    with about_modal.container():
+        st.info("""This chatbot is powered by a deep learning approach using Hugging Face Transformers and a BERT model for intent recognition.
+It understands user queries by predicting intent and responding with predefined answers based on a trained dataset.
+✅ Natural Language Processing (NLP)
+🔹 Transformers (Hugging Face) 🤖 – BERT-based intent classification
+✅ Deep Learning
+🔹 PyTorch 🔥 – Model training & fine-tuning
+""")
+        if st.button("Close", key="close_about"):
+            st.session_state.show_about = False  # Close modal without resetting UI
+            st.rerun()
+# Chat UI
+st.title("🤖 AI Chatbot")
+st.markdown("### Talk to me, I'm listening...")
+rain(emoji="💬", font_size=10, falling_speed=5, animation_length="infinite")
+rain(emoji="❄️", font_size=10, falling_speed=5, animation_length="infinite")
+# Chat Input with Enter Button
+with st.form("chat_form", clear_on_submit=True):
+    chat_input = st.text_input("You:", key="chat_input")
+    submit_button = st.form_submit_button("Enter")
+if submit_button and chat_input:
+    intent_label = predict_intent(chat_input)
+    response = get_response(intent_label)
+    chat_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    # Append messages to chat history (User & Bot)
+    st.session_state.chat_history.append(f"[{chat_time}] You: {chat_input}")
+    st.session_state.chat_history.append(f"[{chat_time}] Bot: {response}")
+    # Save chat history persistently
+    save_chat_history()
+    # Display conversation immediately
+    with st.chat_message("user"):
+        st.markdown(f"**You:** {chat_input}")
+        time.sleep(0.5)
+    with st.chat_message("assistant"):
+        st.markdown(f"**Bot:** {response}")
+# Style customization
+st.markdown("""
+<style>
+    /* Fix Modal Height & Enable Scroll */
+    div[data-modal-container="true"] {
+        position: fixed !important;
+        top: 5% !important;  /* Adjust this value to position it higher */
+        color: #000000;
+        max-height: 1000px !important;  /* Set max height */
+    }
+    /* Ensure the close button stays visible */
+    div[data-modal-container="true"] button {
+        position: sticky;
+        bottom: 10px;
+        background-color: #000000;
+        color: white;
+    }
+    .stChatMessage {padding: 10px; border-radius: 10px; background-color: #900C3F;}
+    .stChatMessageUser {background-color: #900C3F;}
+    .stChatMessageAssistant {background-color: #900C3F;}
+</style>
+""", unsafe_allow_html=True)

intents.json ADDED Viewed

The diff for this file is too large to render. See raw diff

requirements.txt ADDED Viewed

	@@ -0,0 +1,5 @@

+streamlit
+torch
+transformers
+streamlit_extras
+streamlit_modal