BERT_newsheadline.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a96c067",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5ad2f98c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\tqdm\\auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "# This Python 3 environment comes with many helpful analytics libraries installed\n",
    "# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n",
    "# For example, here's several helpful packages to load\n",
    "\n",
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import plotly.express as px\n",
    "\n",
    "import nltk\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from nltk.corpus import stopwords\n",
    "from wordcloud import WordCloud,STOPWORDS\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "from nltk.tokenize import word_tokenize\n",
    "from bs4 import BeautifulSoup\n",
    "import re,string,unicodedata\n",
    "from sklearn.metrics import classification_report,confusion_matrix,accuracy_score,f1_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "from string import punctuation\n",
    "from nltk import pos_tag\n",
    "from nltk.corpus import wordnet\n",
    "\n",
    "\n",
    "import keras\n",
    "import tensorflow as tf\n",
    "import tensorflow_hub as hub\n",
    "from tensorflow import keras \n",
    "from keras import backend as K\n",
    "from tensorflow.keras.preprocessing import sequence\n",
    "from tensorflow.keras.preprocessing.text import Tokenizer\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "from keras.layers import LSTM,Dense,Bidirectional,Input\n",
    "from keras.models import Model\n",
    "import torch\n",
    "import transformers\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b5d12c07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>is_sarcastic</th>\n",
       "      <th>headline</th>\n",
       "      <th>article_link</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>thirtysomething scientists unveil doomsday clo...</td>\n",
       "      <td>https://www.theonion.com/thirtysomething-scien...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>dem rep. totally nails why congress is falling...</td>\n",
       "      <td>https://www.huffingtonpost.com/entry/donna-edw...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>eat your veggies: 9 deliciously different recipes</td>\n",
       "      <td>https://www.huffingtonpost.com/entry/eat-your-...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>inclement weather prevents liar from getting t...</td>\n",
       "      <td>https://local.theonion.com/inclement-weather-p...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>mother comes pretty close to using word 'strea...</td>\n",
       "      <td>https://www.theonion.com/mother-comes-pretty-c...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   is_sarcastic                                           headline  \\\n",
       "0             1  thirtysomething scientists unveil doomsday clo...   \n",
       "1             0  dem rep. totally nails why congress is falling...   \n",
       "2             0  eat your veggies: 9 deliciously different recipes   \n",
       "3             1  inclement weather prevents liar from getting t...   \n",
       "4             1  mother comes pretty close to using word 'strea...   \n",
       "\n",
       "                                        article_link  \n",
       "0  https://www.theonion.com/thirtysomething-scien...  \n",
       "1  https://www.huffingtonpost.com/entry/donna-edw...  \n",
       "2  https://www.huffingtonpost.com/entry/eat-your-...  \n",
       "3  https://local.theonion.com/inclement-weather-p...  \n",
       "4  https://www.theonion.com/mother-comes-pretty-c...  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_json(\"./news_dataset/Sarcasm_Headlines_Dataset_v2.json\", lines=True)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ae23845d",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.drop('article_link', axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e5480957",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2. Basic Data Cleaning\n",
    "\n",
    "# import nltk\n",
    "# nltk.download('stopwords')\n",
    "\n",
    "stop = set(stopwords.words('english'))\n",
    "punctuation = list(string.punctuation)\n",
    "stop.update(punctuation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "bd6023d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\bs4\\__init__.py:435: MarkupResemblesLocatorWarning: The input looks more like a filename than markup. You may want to open this file and pass the filehandle into Beautiful Soup.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "def strip_html(text):\n",
    "    soup = BeautifulSoup(text, \"html.parser\")\n",
    "    return soup.get_text()\n",
    "\n",
    "#Removing the square brackets\n",
    "def remove_between_square_brackets(text):\n",
    "    return re.sub('\\[[^]]*\\]', '', text)\n",
    "# Removing URL's\n",
    "def remove_between_square_brackets(text):\n",
    "    return re.sub(r'http\\S+', '', text)\n",
    "#Removing the stopwords from text\n",
    "def remove_stopwords(text):\n",
    "    final_text = []\n",
    "    for i in text.split():\n",
    "        if i.strip().lower() not in stop and i.strip().lower().isalpha():\n",
    "            final_text.append(i.strip().lower())\n",
    "    return \" \".join(final_text)\n",
    "#Removing the noisy text\n",
    "def denoise_text(text):\n",
    "    text = strip_html(text)\n",
    "    text = remove_between_square_brackets(text)\n",
    "    text = remove_stopwords(text)\n",
    "    return text\n",
    "#Apply function on review column\n",
    "df['headline']=df['headline'].apply(denoise_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c23212d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['thirtysomething', 'scientists', 'unveil', 'doomsday', 'clock']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 3. Creating the vocabulary\n",
    "\n",
    "\n",
    "def get_corpus(text):\n",
    "    words = []\n",
    "    for i in text:\n",
    "        for j in i.split():\n",
    "            words.append(j.strip())\n",
    "    return words\n",
    "corpus = get_corpus(df.headline)\n",
    "corpus[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "73fdf0e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'new': 1637,\n",
       " 'man': 1351,\n",
       " 'trump': 1284,\n",
       " 'one': 527,\n",
       " 'area': 494,\n",
       " 'woman': 483,\n",
       " 'says': 482,\n",
       " 'donald': 472,\n",
       " 'day': 435,\n",
       " 'like': 428}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "counter = Counter(corpus)\n",
    "most_common = counter.most_common(10)\n",
    "most_common = dict(most_common)\n",
    "most_common"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0655adeb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 4. Model Building\n",
    "\n",
    "X = df['headline']\n",
    "y = df['is_sarcastic']\n",
    "\n",
    "X_train,X_test,y_train,y_test = train_test_split(X,y,random_state = 0 , stratify = y)\n",
    "\n",
    "\n",
    "## pip install transformers\n",
    "## If transformers library is not installed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6daeadf8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Tokenizer(vocabulary_size=30522, model=BertWordPiece, unk_token=[UNK], sep_token=[SEP], cls_token=[CLS], pad_token=[PAD], mask_token=[MASK], clean_text=True, handle_chinese_chars=True, strip_accents=None, lowercase=True, wordpieces_prefix=##)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from tokenizers import BertWordPieceTokenizer\n",
    "# First load the real tokenizer\n",
    "tokenizer = transformers.DistilBertTokenizer.from_pretrained('distilbert-base-uncased' , lower = True)\n",
    "# Save the loaded tokenizer locally\n",
    "tokenizer.save_pretrained('.')\n",
    "# Reload it with the huggingface tokenizers library\n",
    "fast_tokenizer = BertWordPieceTokenizer('vocab.txt', lowercase=True)\n",
    "fast_tokenizer\n"
   ]
  },
  {
   "attachments": {
    "embedding_type.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "99b03c60",
   "metadata": {},
   "source": [
    "![embedding_type.png](attachment:embedding_type.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c0984889",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Before any sentence is passed into the BERT model, it has to go through some tokenization steps.\n",
    "\n",
    "# Firstly, tokenize all words in the sentence corpus\n",
    "# Next, all the tokens are embedded using the learned embeddings from a WordPiece Tokenizer. For each word we get 786 dim. vector representation.\n",
    "# Segment Embedding - Helps in distinguishing the words belonging to different sentences.\n",
    "# Positional Embedding - This is used to provide the positional understanding for each word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "74f440dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformers import BertTokenizer, BertTokenizerFast\n",
    "\n",
    "def fast_encode(texts, tokenizer, chunk_size=256, maxlen=400):\n",
    "\n",
    "    tokenizer.enable_truncation(max_length=maxlen)\n",
    "    tokenizer.enable_padding(length=maxlen)\n",
    "    all_ids = []\n",
    "    \n",
    "    for i in range(0, len(texts), chunk_size):\n",
    "        text_chunk = texts[i:i+chunk_size].tolist()\n",
    "        encs = tokenizer.encode_batch(text_chunk)\n",
    "        all_ids.extend([enc.ids for enc in encs])\n",
    "    \n",
    "    return np.array(all_ids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ba7f155d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tokenizer = AutoTokenizer.from_pretrained('bert-base-cased')\n",
    "\n",
    "# batch = tokenizer(batch_sentences, padding=True, truncation=True, return_tensors=\"tf\")\n",
    "\n",
    "x_train = fast_encode(X_train.values, fast_tokenizer, maxlen=100)\n",
    "x_test = fast_encode(X_test.values, fast_tokenizer, maxlen=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1807651d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We shall be using the pre-trained BERT model which has been extensively trained on huge text corpuses of Wikipedia. \n",
    "# Now after getting the pre-trained model, we can fine-tune the model for our own specific task.\n",
    "\n",
    "# The key thing to notice is here is that for our final prediction we would only be using the output generated by the first \n",
    "# token ([CLS]), after which we use a sigmoid activation for final prediction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2897dd15",
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_model(transformer, max_len=400):\n",
    "    \n",
    "    input_word_ids = Input(shape=(max_len,), dtype=tf.int32, name=\"input_word_ids\")\n",
    "    sequence_output = transformer(input_word_ids)[0]\n",
    "    cls_token = sequence_output[:, 0, :]\n",
    "    out = Dense(1, activation='sigmoid')(cls_token)\n",
    "    \n",
    "    model = Model(inputs=input_word_ids, outputs=out)\n",
    "    model.compile(Adam(lr=2e-5), loss='binary_crossentropy', metrics=['accuracy'])\n",
    "    \n",
    "    return model\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6ba583e",
   "metadata": {},
   "source": [
    "Downloading the pre-trained BERT model. We can use either the CASED or the UNCASED version for model building.\n",
    "\n",
    "To explain the BERT training in simple words: The BERT pre-training consists of two steps which happen parallely, these include:\n",
    "\n",
    "1. Masked Language Model\n",
    "In this the model is provided with sentences and some of the words are masked with a [MASK] tag (15% of all words), the model is then asked to predict those masked words. The BERT loss function takes into consideration only the prediction of the masked values and ignores the prediction of the non-masked words. As a consequence, the model converges slower than directional models, a characteristic which is offset by its increased context awareness.\n",
    "\n",
    "2. Next Sentence Prediction\n",
    "In the BERT training process, the model receives pairs of sentences as input and learns to predict if the second sentence in the pair is the subsequent sentence in the original document. This helps the model to understand the relationships between"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f29632bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some layers from the model checkpoint at distilbert-base-uncased were not used when initializing TFDistilBertModel: ['activation_13', 'vocab_transform', 'vocab_projector', 'vocab_layer_norm']\n",
      "- This IS expected if you are initializing TFDistilBertModel 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 TFDistilBertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
      "All the layers of TFDistilBertModel were initialized from the model checkpoint at distilbert-base-uncased.\n",
      "If your task is similar to the task the model of the checkpoint was trained on, you can already use TFDistilBertModel for predictions without further training.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_word_ids (InputLayer)  [(None, 100)]            0         \n",
      "                                                                 \n",
      " tf_distil_bert_model (TFDis  TFBaseModelOutput(last_h  66362880 \n",
      " tilBertModel)               idden_state=(None, 100,             \n",
      "                             768),                               \n",
      "                              hidden_states=None, att            \n",
      "                             entions=None)                       \n",
      "                                                                 \n",
      " tf.__operators__.getitem (S  (None, 768)              0         \n",
      " licingOpLambda)                                                 \n",
      "                                                                 \n",
      " dense (Dense)               (None, 1)                 769       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 66,363,649\n",
      "Trainable params: 66,363,649\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\optimizers\\optimizer_v2\\adam.py:110: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
      "  super(Adam, self).__init__(name, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "bert_model = transformers.TFDistilBertModel.from_pretrained('distilbert-base-uncased')\n",
    "\n",
    "model = build_model(bert_model, max_len=100)\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e94d57e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/3\n"
     ]
    },
    {
     "ename": "ResourceExhaustedError",
     "evalue": "Graph execution error:\n\nDetected at node 'model/tf_distil_bert_model/distilbert/transformer/layer_._2/ffn/lin2/Tensordot/MatMul' defined at (most recent call last):\n    File \"C:\\Users\\Furqan Ali\\AppData\\Local\\Programs\\Python\\Python38\\lib\\runpy.py\", line 194, in _run_module_as_main\n      return _run_code(code, main_globals, None,\n    File \"C:\\Users\\Furqan Ali\\AppData\\Local\\Programs\\Python\\Python38\\lib\\runpy.py\", line 87, in _run_code\n      exec(code, run_globals)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\ipykernel_launcher.py\", line 17, in <module>\n      app.launch_new_instance()\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\traitlets\\config\\application.py\", line 846, in launch_instance\n      app.start()\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\ipykernel\\kernelapp.py\", line 712, in start\n      self.io_loop.start()\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\tornado\\platform\\asyncio.py\", line 199, in start\n      self.asyncio_loop.run_forever()\n    File \"C:\\Users\\Furqan Ali\\AppData\\Local\\Programs\\Python\\Python38\\lib\\asyncio\\base_events.py\", line 570, in run_forever\n      self._run_once()\n    File \"C:\\Users\\Furqan Ali\\AppData\\Local\\Programs\\Python\\Python38\\lib\\asyncio\\base_events.py\", line 1859, in _run_once\n      handle._run()\n    File \"C:\\Users\\Furqan Ali\\AppData\\Local\\Programs\\Python\\Python38\\lib\\asyncio\\events.py\", line 81, in _run\n      self._context.run(self._callback, *self._args)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 504, in dispatch_queue\n      await self.process_one()\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 493, in process_one\n      await dispatch(*args)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 400, in dispatch_shell\n      await result\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 724, in execute_request\n      reply_content = await reply_content\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\ipykernel\\ipkernel.py\", line 390, in do_execute\n      res = shell.run_cell(code, store_history=store_history, silent=silent)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\ipykernel\\zmqshell.py\", line 528, in run_cell\n      return super().run_cell(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2863, in run_cell\n      result = self._run_cell(\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2909, in _run_cell\n      return runner(coro)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\IPython\\core\\async_helpers.py\", line 129, in _pseudo_sync_runner\n      coro.send(None)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3106, in run_cell_async\n      has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3309, in run_ast_nodes\n      if await self.run_code(code, result, async_=asy):\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3369, in run_code\n      exec(code_obj, self.user_global_ns, self.user_ns)\n    File \"C:\\Users\\Furqan Ali\\AppData\\Local\\Temp\\ipykernel_20184\\1581764096.py\", line 1, in <cell line: 1>\n      history = model.fit(x_train,y_train,batch_size = 32 ,validation_data=(x_test,y_test),epochs = 3)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\training.py\", line 1409, in fit\n      tmp_logs = self.train_function(iterator)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\training.py\", line 1051, in train_function\n      return step_function(self, iterator)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\training.py\", line 1040, in step_function\n      outputs = model.distribute_strategy.run(run_step, args=(data,))\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\training.py\", line 1030, in run_step\n      outputs = model.train_step(data)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\training.py\", line 889, in train_step\n      y_pred = self(x, training=True)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\training.py\", line 490, in __call__\n      return super().__call__(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\functional.py\", line 458, in call\n      return self._run_internal_graph(\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\functional.py\", line 596, in _run_internal_graph\n      outputs = node.layer(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\training.py\", line 490, in __call__\n      return super().__call__(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\transformers\\modeling_tf_utils.py\", line 544, in run_call_with_unpacked_inputs\n      f\" {main_input_name}.\"\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\transformers\\models\\distilbert\\modeling_tf_distilbert.py\", line 546, in call\n      outputs = self.distilbert(\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\transformers\\modeling_tf_utils.py\", line 544, in run_call_with_unpacked_inputs\n      f\" {main_input_name}.\"\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\transformers\\models\\distilbert\\modeling_tf_distilbert.py\", line 401, in call\n      tfmr_output = self.transformer(\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\transformers\\models\\distilbert\\modeling_tf_distilbert.py\", line 313, in call\n      for i, layer_module in enumerate(self.layer):\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\transformers\\models\\distilbert\\modeling_tf_distilbert.py\", line 317, in call\n      layer_outputs = layer_module(hidden_state, attn_mask, head_mask[i], output_attentions, training=training)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\transformers\\models\\distilbert\\modeling_tf_distilbert.py\", line 274, in call\n      ffn_output = self.ffn(sa_output, training=training)  # (bs, seq_length, dim)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\transformers\\models\\distilbert\\modeling_tf_distilbert.py\", line 229, in call\n      x = self.lin2(x)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\layers\\core\\dense.py\", line 224, in call\n      outputs = tf.tensordot(inputs, self.kernel, [[rank - 1], [0]])\nNode: 'model/tf_distil_bert_model/distilbert/transformer/layer_._2/ffn/lin2/Tensordot/MatMul'\nOOM when allocating tensor with shape[3200,768] and type float on /job:localhost/replica:0/task:0/device:GPU:0 by allocator GPU_0_bfc\n\t [[{{node model/tf_distil_bert_model/distilbert/transformer/layer_._2/ffn/lin2/Tensordot/MatMul}}]]\nHint: If you want to see a list of allocated tensors when OOM happens, add report_tensor_allocations_upon_oom to RunOptions for current allocation info. This isn't available when running in Eager mode.\n [Op:__inference_train_function_14364]",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mResourceExhaustedError\u001b[0m                    Traceback (most recent call last)",
      "Input \u001b[1;32mIn [16]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m history \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43my_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m32\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m,\u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mx_test\u001b[49m\u001b[43m,\u001b[49m\u001b[43my_test\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43mepochs\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32mc:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py:67\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m     65\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:  \u001b[38;5;66;03m# pylint: disable=broad-except\u001b[39;00m\n\u001b[0;32m     66\u001b[0m   filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n\u001b[1;32m---> 67\u001b[0m   \u001b[38;5;28;01mraise\u001b[39;00m e\u001b[38;5;241m.\u001b[39mwith_traceback(filtered_tb) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28mNone\u001b[39m\n\u001b[0;32m     68\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[0;32m     69\u001b[0m   \u001b[38;5;28;01mdel\u001b[39;00m filtered_tb\n",
      "File \u001b[1;32mc:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\tensorflow\\python\\eager\\execute.py:54\u001b[0m, in \u001b[0;36mquick_execute\u001b[1;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[0;32m     52\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m     53\u001b[0m   ctx\u001b[38;5;241m.\u001b[39mensure_initialized()\n\u001b[1;32m---> 54\u001b[0m   tensors \u001b[38;5;241m=\u001b[39m pywrap_tfe\u001b[38;5;241m.\u001b[39mTFE_Py_Execute(ctx\u001b[38;5;241m.\u001b[39m_handle, device_name, op_name,\n\u001b[0;32m     55\u001b[0m                                       inputs, attrs, num_outputs)\n\u001b[0;32m     56\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_NotOkStatusException \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m     57\u001b[0m   \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
      "\u001b[1;31mResourceExhaustedError\u001b[0m: Graph execution error:\n\nDetected at node 'model/tf_distil_bert_model/distilbert/transformer/layer_._2/ffn/lin2/Tensordot/MatMul' defined at (most recent call last):\n    File \"C:\\Users\\Furqan Ali\\AppData\\Local\\Programs\\Python\\Python38\\lib\\runpy.py\", line 194, in _run_module_as_main\n      return _run_code(code, main_globals, None,\n    File \"C:\\Users\\Furqan Ali\\AppData\\Local\\Programs\\Python\\Python38\\lib\\runpy.py\", line 87, in _run_code\n      exec(code, run_globals)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\ipykernel_launcher.py\", line 17, in <module>\n      app.launch_new_instance()\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\traitlets\\config\\application.py\", line 846, in launch_instance\n      app.start()\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\ipykernel\\kernelapp.py\", line 712, in start\n      self.io_loop.start()\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\tornado\\platform\\asyncio.py\", line 199, in start\n      self.asyncio_loop.run_forever()\n    File \"C:\\Users\\Furqan Ali\\AppData\\Local\\Programs\\Python\\Python38\\lib\\asyncio\\base_events.py\", line 570, in run_forever\n      self._run_once()\n    File \"C:\\Users\\Furqan Ali\\AppData\\Local\\Programs\\Python\\Python38\\lib\\asyncio\\base_events.py\", line 1859, in _run_once\n      handle._run()\n    File \"C:\\Users\\Furqan Ali\\AppData\\Local\\Programs\\Python\\Python38\\lib\\asyncio\\events.py\", line 81, in _run\n      self._context.run(self._callback, *self._args)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 504, in dispatch_queue\n      await self.process_one()\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 493, in process_one\n      await dispatch(*args)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 400, in dispatch_shell\n      await result\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\ipykernel\\kernelbase.py\", line 724, in execute_request\n      reply_content = await reply_content\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\ipykernel\\ipkernel.py\", line 390, in do_execute\n      res = shell.run_cell(code, store_history=store_history, silent=silent)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\ipykernel\\zmqshell.py\", line 528, in run_cell\n      return super().run_cell(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2863, in run_cell\n      result = self._run_cell(\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 2909, in _run_cell\n      return runner(coro)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\IPython\\core\\async_helpers.py\", line 129, in _pseudo_sync_runner\n      coro.send(None)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3106, in run_cell_async\n      has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3309, in run_ast_nodes\n      if await self.run_code(code, result, async_=asy):\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\IPython\\core\\interactiveshell.py\", line 3369, in run_code\n      exec(code_obj, self.user_global_ns, self.user_ns)\n    File \"C:\\Users\\Furqan Ali\\AppData\\Local\\Temp\\ipykernel_20184\\1581764096.py\", line 1, in <cell line: 1>\n      history = model.fit(x_train,y_train,batch_size = 32 ,validation_data=(x_test,y_test),epochs = 3)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\training.py\", line 1409, in fit\n      tmp_logs = self.train_function(iterator)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\training.py\", line 1051, in train_function\n      return step_function(self, iterator)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\training.py\", line 1040, in step_function\n      outputs = model.distribute_strategy.run(run_step, args=(data,))\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\training.py\", line 1030, in run_step\n      outputs = model.train_step(data)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\training.py\", line 889, in train_step\n      y_pred = self(x, training=True)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\training.py\", line 490, in __call__\n      return super().__call__(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\functional.py\", line 458, in call\n      return self._run_internal_graph(\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\functional.py\", line 596, in _run_internal_graph\n      outputs = node.layer(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\training.py\", line 490, in __call__\n      return super().__call__(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\transformers\\modeling_tf_utils.py\", line 544, in run_call_with_unpacked_inputs\n      f\" {main_input_name}.\"\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\transformers\\models\\distilbert\\modeling_tf_distilbert.py\", line 546, in call\n      outputs = self.distilbert(\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\transformers\\modeling_tf_utils.py\", line 544, in run_call_with_unpacked_inputs\n      f\" {main_input_name}.\"\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\transformers\\models\\distilbert\\modeling_tf_distilbert.py\", line 401, in call\n      tfmr_output = self.transformer(\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\transformers\\models\\distilbert\\modeling_tf_distilbert.py\", line 313, in call\n      for i, layer_module in enumerate(self.layer):\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\transformers\\models\\distilbert\\modeling_tf_distilbert.py\", line 317, in call\n      layer_outputs = layer_module(hidden_state, attn_mask, head_mask[i], output_attentions, training=training)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\transformers\\models\\distilbert\\modeling_tf_distilbert.py\", line 274, in call\n      ffn_output = self.ffn(sa_output, training=training)  # (bs, seq_length, dim)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\transformers\\models\\distilbert\\modeling_tf_distilbert.py\", line 229, in call\n      x = self.lin2(x)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 64, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\engine\\base_layer.py\", line 1014, in __call__\n      outputs = call_fn(inputs, *args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\utils\\traceback_utils.py\", line 92, in error_handler\n      return fn(*args, **kwargs)\n    File \"c:\\users\\furqan ali\\desktop\\python\\env\\lib\\site-packages\\keras\\layers\\core\\dense.py\", line 224, in call\n      outputs = tf.tensordot(inputs, self.kernel, [[rank - 1], [0]])\nNode: 'model/tf_distil_bert_model/distilbert/transformer/layer_._2/ffn/lin2/Tensordot/MatMul'\nOOM when allocating tensor with shape[3200,768] and type float on /job:localhost/replica:0/task:0/device:GPU:0 by allocator GPU_0_bfc\n\t [[{{node model/tf_distil_bert_model/distilbert/transformer/layer_._2/ffn/lin2/Tensordot/MatMul}}]]\nHint: If you want to see a list of allocated tensors when OOM happens, add report_tensor_allocations_upon_oom to RunOptions for current allocation info. This isn't available when running in Eager mode.\n [Op:__inference_train_function_14364]"
     ]
    }
   ],
   "source": [
    "history = model.fit(x_train,y_train,batch_size = 32 ,validation_data=(x_test,y_test),epochs = 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "e37fd6e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.eager.context._EagerDeviceContext at 0x24206137100>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a0ded04",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Accuracy of the model on Testing Data is - \" , model.evaluate(x_test,y_test)[1]*100 , \"%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ccc64243",
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs = [i for i in range(3)]\n",
    "fig , ax = plt.subplots(1,2)\n",
    "train_acc = history.history['accuracy']\n",
    "train_loss = history.history['loss']\n",
    "val_acc = history.history['val_accuracy']\n",
    "val_loss = history.history['val_loss']\n",
    "fig.set_size_inches(20,10)\n",
    "\n",
    "ax[0].plot(epochs , train_acc , 'go-' , label = 'Training Accuracy')\n",
    "ax[0].plot(epochs , val_acc , 'ro-' , label = 'Testing Accuracy')\n",
    "ax[0].set_title('Training & Testing Accuracy')\n",
    "ax[0].legend()\n",
    "ax[0].set_xlabel(\"Epochs\")\n",
    "ax[0].set_ylabel(\"Accuracy\")\n",
    "\n",
    "ax[1].plot(epochs , train_loss , 'go-' , label = 'Training Loss')\n",
    "ax[1].plot(epochs , val_loss , 'ro-' , label = 'Testing Loss')\n",
    "ax[1].set_title('Training & Testing Loss')\n",
    "ax[1].legend()\n",
    "ax[1].set_xlabel(\"Epochs\")\n",
    "ax[1].set_ylabel(\"Loss\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db800550",
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = model.predict(x_test)\n",
    "pred[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a216588",
   "metadata": {},
   "outputs": [],
   "source": [
    "pred = np.round(pred).astype(int)\n",
    "pred[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfa5aea7",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(classification_report(y_test, pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d183270",
   "metadata": {},
   "outputs": [],
   "source": [
    "cm = confusion_matrix(y_test,pred)\n",
    "print(cm)\n",
    "\n",
    "plt.figure(figsize = (10,10))\n",
    "sns.heatmap(cm,cmap= \"Blues\", linecolor = 'black' , linewidth = 1 , annot = True, fmt='')\n",
    "plt.xlabel(\"Predicted\")\n",
    "plt.ylabel(\"Actual\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3820b65a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5bef1b2a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db972c41",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9dad3e3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}