Complaint Classification_Pre-Trained.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d44907a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d21c66da",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c4d404d3ba254ef9b0208592b7559794",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading (…)solve/main/vocab.txt:   0%|          | 0.00/232k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "587d4a2596604c2b87f62b14e8631253",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading (…)okenizer_config.json:   0%|          | 0.00/28.0 [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cf28204da98b4a3b91efca034929185c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading (…)lve/main/config.json:   0%|          | 0.00/570 [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3e8cab97d2c647c4b071ef91828a68e6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Downloading pytorch_model.bin:   0%|          | 0.00/440M [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertForSequenceClassification: ['cls.predictions.bias', 'cls.seq_relationship.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.dense.bias']\n",
      "- This IS expected if you are initializing BertForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
      "Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-uncased and are newly initialized: ['classifier.weight', 'classifier.bias']\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": [
      "Input Text: This is an example sentence for classification.\n",
      "Predicted Class: Class 1\n",
      "Predicted Probabilities: tensor([0.3553, 0.6447], grad_fn=<SqueezeBackward0>)\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "from transformers import BertTokenizer, BertForSequenceClassification\n",
    "\n",
    "# Load pre-trained model and tokenizer\n",
    "model_name = 'bert-base-uncased'\n",
    "tokenizer = BertTokenizer.from_pretrained(model_name)\n",
    "model = BertForSequenceClassification.from_pretrained(model_name)\n",
    "\n",
    "# Example text for classification\n",
    "text = \"This is an example sentence for classification.\"\n",
    "\n",
    "# Tokenize input text\n",
    "tokens = tokenizer.encode_plus(\n",
    "    text,\n",
    "    add_special_tokens=True,\n",
    "    padding='max_length',\n",
    "    \n",
    "    max_length=128,\n",
    "    truncation=True,\n",
    "    return_tensors='pt'\n",
    ")\n",
    "\n",
    "# Perform classification\n",
    "input_ids = tokens['input_ids']\n",
    "attention_mask = tokens['attention_mask']\n",
    "outputs = model(input_ids, attention_mask=attention_mask)\n",
    "\n",
    "# Get predicted probabilities and predicted label\n",
    "probs = torch.softmax(outputs.logits, dim=1).squeeze()\n",
    "predicted_label = torch.argmax(probs).item()\n",
    "\n",
    "# Convert predicted label to class name\n",
    "class_names = ['Class 0', 'Class 1']  # Add your class names here\n",
    "predicted_class = class_names[predicted_label]\n",
    "\n",
    "# Print results\n",
    "print(\"Input Text:\", text)\n",
    "print(\"Predicted Class:\", predicted_class)\n",
    "print(\"Predicted Probabilities:\", probs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "84138e6d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertForSequenceClassification: ['cls.predictions.bias', 'cls.seq_relationship.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.dense.bias']\n",
      "- This IS expected if you are initializing BertForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
      "Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-uncased and are newly initialized: ['classifier.weight', 'classifier.bias']\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": [
      "Input Text: I have issue with my upi id\n",
      "Predicted Class: Debit\n",
      "Predicted Probabilities: tensor([0.5419, 0.4581], grad_fn=<SqueezeBackward0>)\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "from transformers import BertTokenizer, BertForSequenceClassification\n",
    "\n",
    "# Load pre-trained model and tokenizer\n",
    "model_name = 'bert-base-uncased'\n",
    "tokenizer = BertTokenizer.from_pretrained(model_name)\n",
    "model = BertForSequenceClassification.from_pretrained(model_name)\n",
    "\n",
    "# Example text for classification\n",
    "text = \"I have issue with my upi id\"\n",
    "\n",
    "# Tokenize input text\n",
    "tokens = tokenizer.encode_plus(\n",
    "    text,\n",
    "    add_special_tokens=True,\n",
    "    padding='max_length',\n",
    "    max_length=128,\n",
    "    truncation=True,\n",
    "    return_tensors='pt'\n",
    ")\n",
    "\n",
    "# Perform classification\n",
    "input_ids = tokens['input_ids']\n",
    "attention_mask = tokens['attention_mask']\n",
    "outputs = model(input_ids, attention_mask=attention_mask)\n",
    "\n",
    "# Get predicted probabilities and predicted label\n",
    "probs = torch.softmax(outputs.logits, dim=1).squeeze()\n",
    "predicted_label = torch.argmax(probs).item()\n",
    "\n",
    "# Convert predicted label to class name\n",
    "class_names = ['Debit', 'Credit','Upi']  # Add your class names here\n",
    "predicted_class = class_names[predicted_label]\n",
    "\n",
    "# Print results\n",
    "print(\"Input Text:\", text)\n",
    "print(\"Predicted Class:\", predicted_class)\n",
    "print(\"Predicted Probabilities:\", probs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "af3c5833",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertForSequenceClassification: ['cls.predictions.bias', 'cls.seq_relationship.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.dense.bias']\n",
      "- This IS expected if you are initializing BertForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
      "Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-uncased and are newly initialized: ['classifier.weight', 'classifier.bias']\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": [
      "Input Text: I am very dissatisfied with the customer service of the bank. They have been unresponsive to my queries.\n",
      "Predicted Class: Loan Problem\n",
      "Predicted Probabilities: tensor([0.1499, 0.2707, 0.2117, 0.1696, 0.1981], grad_fn=<SqueezeBackward0>)\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "from transformers import BertTokenizer, BertForSequenceClassification\n",
    "\n",
    "# Load pre-trained model and tokenizer\n",
    "model_name = 'bert-base-uncased'\n",
    "tokenizer = BertTokenizer.from_pretrained(model_name)\n",
    "model = BertForSequenceClassification.from_pretrained(model_name, num_labels=5)\n",
    "\n",
    "# Example bank complaint/feedback text\n",
    "text = \"I am very dissatisfied with the customer service of the bank. They have been unresponsive to my queries.\"\n",
    "\n",
    "# Tokenize input text\n",
    "tokens = tokenizer.encode_plus(\n",
    "    text,\n",
    "    add_special_tokens=True,\n",
    "    padding='max_length',\n",
    "    max_length=128,\n",
    "    truncation=True,\n",
    "    return_tensors='pt'\n",
    ")\n",
    "\n",
    "# Perform classification\n",
    "input_ids = tokens['input_ids']\n",
    "attention_mask = tokens['attention_mask']\n",
    "outputs = model(input_ids, attention_mask=attention_mask)\n",
    "\n",
    "# Get predicted probabilities and predicted label\n",
    "probs = torch.softmax(outputs.logits, dim=1).squeeze()\n",
    "predicted_label = torch.argmax(probs).item()\n",
    "\n",
    "# Convert predicted label to class name\n",
    "class_names = ['Account Issue', 'Loan Problem', 'Card Complaint', 'Service Disruption', 'Others']\n",
    "predicted_class = class_names[predicted_label]\n",
    "\n",
    "# Print results\n",
    "print(\"Input Text:\", text)\n",
    "print(\"Predicted Class:\", predicted_class)\n",
    "print(\"Predicted Probabilities:\", probs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "575cb164",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertForSequenceClassification: ['cls.predictions.bias', 'cls.seq_relationship.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.dense.bias']\n",
      "- This IS expected if you are initializing BertForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing BertForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
      "Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-uncased and are newly initialized: ['classifier.weight', 'classifier.bias']\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": [
      "Input Text: I am extremely frustrated with the bank's service. They charged me excessive fees and did not provide any explanation.\n",
      "Predicted Class: Account Issue\n",
      "Predicted Probabilities: tensor([0.2576, 0.2172, 0.2346, 0.1868, 0.1038], grad_fn=<SqueezeBackward0>)\n"
     ]
    }
   ],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "import torch\n",
    "from transformers import BertTokenizer, BertForSequenceClassification\n",
    "\n",
    "# Load pre-trained model and tokenizer\n",
    "model_name = 'bert-base-uncased'\n",
    "tokenizer = BertTokenizer.from_pretrained(model_name)\n",
    "model = BertForSequenceClassification.from_pretrained(model_name, num_labels=5)\n",
    "\n",
    "# Example bank complaint/feedback text\n",
    "text = \"I am extremely frustrated with the bank's service. They charged me excessive fees and did not provide any explanation.\"\n",
    "\n",
    "# Tokenize input text\n",
    "tokens = tokenizer.encode_plus(\n",
    "    text,\n",
    "    add_special_tokens=True,\n",
    "    padding='max_length',\n",
    "    max_length=128,\n",
    "    truncation=True,\n",
    "    return_tensors='pt'\n",
    ")\n",
    "\n",
    "# Perform classification\n",
    "input_ids = tokens['input_ids']\n",
    "attention_mask = tokens['attention_mask']\n",
    "outputs = model(input_ids, attention_mask=attention_mask)\n",
    "\n",
    "# Get predicted probabilities and predicted label\n",
    "probs = torch.softmax(outputs.logits, dim=1).squeeze()\n",
    "predicted_label = torch.argmax(probs).item()\n",
    "\n",
    "# Convert predicted label to class name\n",
    "class_names = ['Account Issue', 'Loan Problem', 'Card Complaint', 'Service Disruption', 'Others']\n",
    "predicted_class = class_names[predicted_label]\n",
    "\n",
    "# Print results\n",
    "print(\"Input Text:\", text)\n",
    "print(\"Predicted Class:\", predicted_class)\n",
    "print(\"Predicted Probabilities:\", probs)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "aa64a1c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some weights of the model checkpoint at roberta-base were not used when initializing RobertaForSequenceClassification: ['lm_head.decoder.weight', 'lm_head.dense.weight', 'lm_head.layer_norm.bias', 'lm_head.bias', 'lm_head.dense.bias', 'roberta.pooler.dense.bias', 'roberta.pooler.dense.weight', 'lm_head.layer_norm.weight']\n",
      "- This IS expected if you are initializing RobertaForSequenceClassification from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing RobertaForSequenceClassification from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
      "Some weights of RobertaForSequenceClassification were not initialized from the model checkpoint at roberta-base and are newly initialized: ['classifier.out_proj.bias', 'classifier.out_proj.weight', 'classifier.dense.bias', 'classifier.dense.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": [
      "Input Text: I am extremely frustrated with the bank's service. They charged me excessive fees and did not provide any explanation.\n",
      "Predicted Class: Loan Problem\n",
      "Predicted Probabilities: tensor([0.4945, 0.5055], grad_fn=<SqueezeBackward0>)\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "from transformers import RobertaTokenizer, RobertaForSequenceClassification\n",
    "\n",
    "# Load pre-trained model and tokenizer\n",
    "model_name = 'roberta-base'\n",
    "tokenizer = RobertaTokenizer.from_pretrained(model_name)\n",
    "model = RobertaForSequenceClassification.from_pretrained(model_name, num_labels=2)\n",
    "\n",
    "# Example text for classification\n",
    "text = \"I am extremely frustrated with the bank's service. They charged me excessive fees and did not provide any explanation.\"\n",
    "\n",
    "# Tokenize input text\n",
    "tokens = tokenizer.encode_plus(\n",
    "    text,\n",
    "    add_special_tokens=True,\n",
    "    padding='max_length',\n",
    "    max_length=128,\n",
    "    truncation=True,\n",
    "    return_tensors='pt'\n",
    ")\n",
    "\n",
    "# Perform classification\n",
    "input_ids = tokens['input_ids']\n",
    "attention_mask = tokens['attention_mask']\n",
    "outputs = model(input_ids, attention_mask=attention_mask)\n",
    "\n",
    "# Get predicted probabilities and predicted label\n",
    "probs = torch.softmax(outputs.logits, dim=1).squeeze()\n",
    "predicted_label = torch.argmax(probs).item()\n",
    "\n",
    "# Convert predicted label to class name\n",
    "class_names = ['Account Issue', 'Loan Problem', 'Card Complaint', 'Service Disruption', 'Others']\n",
    "predicted_class = class_names[predicted_label]\n",
    "\n",
    "# Print results\n",
    "print(\"Input Text:\", text)\n",
    "print(\"Predicted Class:\", predicted_class)\n",
    "print(\"Predicted Probabilities:\", probs)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}