{"cells":[{"cell_type":"code","execution_count":null,"metadata":{"id":"eMSthPt-5jKX"},"outputs":[],"source":[]},{"cell_type":"markdown","source":["**BERT TOKENIZATION IMPLEMENTATION**"],"metadata":{"id":"oLhNYAvZmv59"}},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":73},"id":"4gJPGZBYtT4E","outputId":"76a89f39-0c16-4b0d-d476-ee1c0318475e","executionInfo":{"status":"ok","timestamp":1698405953146,"user_tz":-330,"elapsed":86775,"user":{"displayName":"RACHANA POTPELWAR","userId":"12339588403377734923"}}},"outputs":[{"output_type":"display_data","data":{"text/plain":["<IPython.core.display.HTML object>"],"text/html":["\n","     <input type=\"file\" id=\"files-a500fe42-0128-4ec8-b5b5-95bb2a3215e9\" name=\"files[]\" multiple disabled\n","        style=\"border:none\" />\n","     <output id=\"result-a500fe42-0128-4ec8-b5b5-95bb2a3215e9\">\n","      Upload widget is only available when the cell has been executed in the\n","      current browser session. Please rerun this cell to enable.\n","      </output>\n","      <script>// Copyright 2017 Google LLC\n","//\n","// Licensed under the Apache License, Version 2.0 (the \"License\");\n","// you may not use this file except in compliance with the License.\n","// You may obtain a copy of the License at\n","//\n","//      http://www.apache.org/licenses/LICENSE-2.0\n","//\n","// Unless required by applicable law or agreed to in writing, software\n","// distributed under the License is distributed on an \"AS IS\" BASIS,\n","// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n","// See the License for the specific language governing permissions and\n","// limitations under the License.\n","\n","/**\n"," * @fileoverview Helpers for google.colab Python module.\n"," */\n","(function(scope) {\n","function span(text, styleAttributes = {}) {\n","  const element = document.createElement('span');\n","  element.textContent = text;\n","  for (const key of Object.keys(styleAttributes)) {\n","    element.style[key] = styleAttributes[key];\n","  }\n","  return element;\n","}\n","\n","// Max number of bytes which will be uploaded at a time.\n","const MAX_PAYLOAD_SIZE = 100 * 1024;\n","\n","function _uploadFiles(inputId, outputId) {\n","  const steps = uploadFilesStep(inputId, outputId);\n","  const outputElement = document.getElementById(outputId);\n","  // Cache steps on the outputElement to make it available for the next call\n","  // to uploadFilesContinue from Python.\n","  outputElement.steps = steps;\n","\n","  return _uploadFilesContinue(outputId);\n","}\n","\n","// This is roughly an async generator (not supported in the browser yet),\n","// where there are multiple asynchronous steps and the Python side is going\n","// to poll for completion of each step.\n","// This uses a Promise to block the python side on completion of each step,\n","// then passes the result of the previous step as the input to the next step.\n","function _uploadFilesContinue(outputId) {\n","  const outputElement = document.getElementById(outputId);\n","  const steps = outputElement.steps;\n","\n","  const next = steps.next(outputElement.lastPromiseValue);\n","  return Promise.resolve(next.value.promise).then((value) => {\n","    // Cache the last promise value to make it available to the next\n","    // step of the generator.\n","    outputElement.lastPromiseValue = value;\n","    return next.value.response;\n","  });\n","}\n","\n","/**\n"," * Generator function which is called between each async step of the upload\n"," * process.\n"," * @param {string} inputId Element ID of the input file picker element.\n"," * @param {string} outputId Element ID of the output display.\n"," * @return {!Iterable<!Object>} Iterable of next steps.\n"," */\n","function* uploadFilesStep(inputId, outputId) {\n","  const inputElement = document.getElementById(inputId);\n","  inputElement.disabled = false;\n","\n","  const outputElement = document.getElementById(outputId);\n","  outputElement.innerHTML = '';\n","\n","  const pickedPromise = new Promise((resolve) => {\n","    inputElement.addEventListener('change', (e) => {\n","      resolve(e.target.files);\n","    });\n","  });\n","\n","  const cancel = document.createElement('button');\n","  inputElement.parentElement.appendChild(cancel);\n","  cancel.textContent = 'Cancel upload';\n","  const cancelPromise = new Promise((resolve) => {\n","    cancel.onclick = () => {\n","      resolve(null);\n","    };\n","  });\n","\n","  // Wait for the user to pick the files.\n","  const files = yield {\n","    promise: Promise.race([pickedPromise, cancelPromise]),\n","    response: {\n","      action: 'starting',\n","    }\n","  };\n","\n","  cancel.remove();\n","\n","  // Disable the input element since further picks are not allowed.\n","  inputElement.disabled = true;\n","\n","  if (!files) {\n","    return {\n","      response: {\n","        action: 'complete',\n","      }\n","    };\n","  }\n","\n","  for (const file of files) {\n","    const li = document.createElement('li');\n","    li.append(span(file.name, {fontWeight: 'bold'}));\n","    li.append(span(\n","        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n","        `last modified: ${\n","            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n","                                    'n/a'} - `));\n","    const percent = span('0% done');\n","    li.appendChild(percent);\n","\n","    outputElement.appendChild(li);\n","\n","    const fileDataPromise = new Promise((resolve) => {\n","      const reader = new FileReader();\n","      reader.onload = (e) => {\n","        resolve(e.target.result);\n","      };\n","      reader.readAsArrayBuffer(file);\n","    });\n","    // Wait for the data to be ready.\n","    let fileData = yield {\n","      promise: fileDataPromise,\n","      response: {\n","        action: 'continue',\n","      }\n","    };\n","\n","    // Use a chunked sending to avoid message size limits. See b/62115660.\n","    let position = 0;\n","    do {\n","      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n","      const chunk = new Uint8Array(fileData, position, length);\n","      position += length;\n","\n","      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n","      yield {\n","        response: {\n","          action: 'append',\n","          file: file.name,\n","          data: base64,\n","        },\n","      };\n","\n","      let percentDone = fileData.byteLength === 0 ?\n","          100 :\n","          Math.round((position / fileData.byteLength) * 100);\n","      percent.textContent = `${percentDone}% done`;\n","\n","    } while (position < fileData.byteLength);\n","  }\n","\n","  // All done.\n","  yield {\n","    response: {\n","      action: 'complete',\n","    }\n","  };\n","}\n","\n","scope.google = scope.google || {};\n","scope.google.colab = scope.google.colab || {};\n","scope.google.colab._files = {\n","  _uploadFiles,\n","  _uploadFilesContinue,\n","};\n","})(self);\n","</script> "]},"metadata":{}},{"output_type":"stream","name":"stdout","text":["Saving Phishing.csv to Phishing.csv\n"]}],"source":["import matplotlib.pyplot as plt\n","%matplotlib inline\n","from google.colab import files\n","upload = files.upload()\n","import pandas as pd\n","import numpy as np"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"szMKJ8D-tpMv"},"outputs":[],"source":["rachdatahug = pd.read_csv(\"RACH_URL_5000.csv\")"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"chwt8TE9tv0M"},"outputs":[],"source":["X=list(rachdatahug['URL'])"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"-L4ordBktz_N"},"outputs":[],"source":["y=list(rachdatahug['Label'])"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"qJIJ_zoDt5k9"},"outputs":[],"source":["y = list(pd.get_dummies(y,drop_first=True)['good'])"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"DxioXkNXt81V"},"outputs":[],"source":["from sklearn.model_selection import train_test_split\n","X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20, random_state= 0)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":5958,"status":"ok","timestamp":1690449517058,"user":{"displayName":"RACHANA POTPELWAR","userId":"12339588403377734923"},"user_tz":-330},"id":"qLh9nOZFuAlN","outputId":"37362513-1503-4793-cd66-4c9b63275ca9"},"outputs":[{"output_type":"stream","name":"stdout","text":["Requirement already satisfied: transformers in /usr/local/lib/python3.10/dist-packages (4.31.0)\n","Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from transformers) (3.12.2)\n","Requirement already satisfied: huggingface-hub<1.0,>=0.14.1 in /usr/local/lib/python3.10/dist-packages (from transformers) (0.16.4)\n","Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from transformers) (1.24.3)\n","Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from transformers) (23.1)\n","Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from transformers) (6.0.1)\n","Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.10/dist-packages (from transformers) (2022.10.31)\n","Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from transformers) (2.27.1)\n","Requirement already satisfied: tokenizers!=0.11.3,<0.14,>=0.11.1 in /usr/local/lib/python3.10/dist-packages (from transformers) (0.13.3)\n","Requirement already satisfied: safetensors>=0.3.1 in /usr/local/lib/python3.10/dist-packages (from transformers) (0.3.1)\n","Requirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.10/dist-packages (from transformers) (4.65.0)\n","Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from huggingface-hub<1.0,>=0.14.1->transformers) (2023.6.0)\n","Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub<1.0,>=0.14.1->transformers) (4.5.0)\n","Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (1.26.16)\n","Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (2023.7.22)\n","Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (2.0.12)\n","Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->transformers) (3.4)\n"]}],"source":["!pip install transformers"]},{"cell_type":"markdown","source":["**BERT TOKENIZATION IMPLEMENTATION**"],"metadata":{"id":"2KJ0TTw_m5ot"}},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":33055,"status":"ok","timestamp":1690449552464,"user":{"displayName":"RACHANA POTPELWAR","userId":"12339588403377734923"},"user_tz":-330},"id":"cJW_-FKav4FJ","outputId":"67915058-da1d-4525-f641-572edf24b561"},"outputs":[{"output_type":"stream","name":"stderr","text":["Some weights of the PyTorch model were not used when initializing the TF 2.0 model TFBertModel: ['cls.seq_relationship.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.dense.bias', 'cls.seq_relationship.bias']\n","- This IS expected if you are initializing TFBertModel from a PyTorch model trained on another task or with another architecture (e.g. initializing a TFBertForSequenceClassification model from a BertForPreTraining model).\n","- This IS NOT expected if you are initializing TFBertModel from a PyTorch model that you expect to be exactly identical (e.g. initializing a TFBertForSequenceClassification model from a BertForSequenceClassification model).\n","All the weights of TFBertModel were initialized from the PyTorch model.\n","If your task is similar to the task the model of the checkpoint was trained on, you can already use TFBertModel for predictions without further training.\n"]}],"source":["from transformers import BertTokenizer, TFBertModel\n","tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\n","model = TFBertModel.from_pretrained(\"bert-base-uncased\")"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"LehPr2o0wEEJ"},"outputs":[],"source":["train_encodings = tokenizer(X_train, truncation=True, padding=True)\n","test_encodings = tokenizer(X_test, truncation=True, padding=True)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"__qAgJQ5wLUh"},"outputs":[],"source":["import tensorflow as tf\n","\n","train_dataset = tf.data.Dataset.from_tensor_slices((\n","    dict(train_encodings),\n","    y_train\n","))\n","\n","test_dataset = tf.data.Dataset.from_tensor_slices((\n","    dict(test_encodings),\n","    y_test\n","))"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":358,"status":"ok","timestamp":1690449587891,"user":{"displayName":"RACHANA POTPELWAR","userId":"12339588403377734923"},"user_tz":-330},"id":"6fYis2PNx2XG","outputId":"3807f06f-4faf-47d8-d058-3560e209c9bc"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["<_TensorSliceDataset element_spec=({'input_ids': TensorSpec(shape=(408,), dtype=tf.int32, name=None), 'token_type_ids': TensorSpec(shape=(408,), dtype=tf.int32, name=None), 'attention_mask': TensorSpec(shape=(408,), dtype=tf.int32, name=None)}, TensorSpec(shape=(), dtype=tf.int32, name=None))>"]},"metadata":{},"execution_count":11}],"source":["train_dataset"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"DR_mDIgiwXSg"},"outputs":[],"source":["from transformers import TFBertForSequenceClassification, TFTrainer, TFTrainingArguments\n","\n","training_args = TFTrainingArguments(\n","    output_dir='./results',          # output directory\n","    num_train_epochs=2,              # total number of training epochs\n","    per_device_train_batch_size=8,  # batch size per device during training\n","    per_device_eval_batch_size=16,   # batch size for evaluation\n","    warmup_steps=500,                # number of warmup steps for learning rate scheduler\n","    weight_decay=0.01,               # strength of weight decay\n","    logging_dir='./logs',            # directory for storing logs\n","    eval_steps=10,\n",")"]},{"cell_type":"code","source":[],"metadata":{"id":"Ug5nfiE1diw0"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["!pip install --upgrade tensorflow"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"5-CEnjUGoZ-i","executionInfo":{"status":"ok","timestamp":1690449599295,"user_tz":-330,"elapsed":6434,"user":{"displayName":"RACHANA POTPELWAR","userId":"12339588403377734923"}},"outputId":"2d708e1b-d86f-43d3-a6d5-a5ce98327798"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Requirement already satisfied: tensorflow in /usr/local/lib/python3.10/dist-packages (2.13.0)\n","Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.4.0)\n","Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.6.3)\n","Requirement already satisfied: flatbuffers>=23.1.21 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (23.5.26)\n","Requirement already satisfied: gast<=0.4.0,>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (0.4.0)\n","Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (0.2.0)\n","Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.56.2)\n","Requirement already satisfied: h5py>=2.9.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (3.8.0)\n","Requirement already satisfied: keras<2.14,>=2.13.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (2.13.1)\n","Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (16.0.6)\n","Requirement already satisfied: numpy<=1.24.3,>=1.22 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.24.3)\n","Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (3.3.0)\n","Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from tensorflow) (23.1)\n","Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (3.20.3)\n","Requirement already satisfied: setuptools in /usr/local/lib/python3.10/dist-packages (from tensorflow) (67.7.2)\n","Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.16.0)\n","Requirement already satisfied: tensorboard<2.14,>=2.13 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (2.13.0)\n","Requirement already satisfied: tensorflow-estimator<2.14,>=2.13.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (2.13.0)\n","Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (2.3.0)\n","Requirement already satisfied: typing-extensions<4.6.0,>=3.6.6 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (4.5.0)\n","Requirement already satisfied: wrapt>=1.11.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.14.1)\n","Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (0.32.0)\n","Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.10/dist-packages (from astunparse>=1.6.0->tensorflow) (0.41.0)\n","Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.14,>=2.13->tensorflow) (2.17.3)\n","Requirement already satisfied: google-auth-oauthlib<1.1,>=0.5 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.14,>=2.13->tensorflow) (1.0.0)\n","Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.14,>=2.13->tensorflow) (3.4.3)\n","Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.14,>=2.13->tensorflow) (2.27.1)\n","Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.14,>=2.13->tensorflow) (0.7.1)\n","Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.14,>=2.13->tensorflow) (2.3.6)\n","Requirement already satisfied: cachetools<6.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.14,>=2.13->tensorflow) (5.3.1)\n","Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.14,>=2.13->tensorflow) (0.3.0)\n","Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.14,>=2.13->tensorflow) (4.9)\n","Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from google-auth-oauthlib<1.1,>=0.5->tensorboard<2.14,>=2.13->tensorflow) (1.3.1)\n","Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.14,>=2.13->tensorflow) (1.26.16)\n","Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.14,>=2.13->tensorflow) (2023.7.22)\n","Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.14,>=2.13->tensorflow) (2.0.12)\n","Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.14,>=2.13->tensorflow) (3.4)\n","Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.10/dist-packages (from werkzeug>=1.0.1->tensorboard<2.14,>=2.13->tensorflow) (2.1.3)\n","Requirement already satisfied: pyasn1<0.6.0,>=0.4.6 in /usr/local/lib/python3.10/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard<2.14,>=2.13->tensorflow) (0.5.0)\n","Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<1.1,>=0.5->tensorboard<2.14,>=2.13->tensorflow) (3.2.2)\n"]}]},{"cell_type":"code","source":["with training_args.strategy.scope():\n","    model = TFBertForSequenceClassification.from_pretrained(\"bert-base-uncased\")\n","\n","trainer = TFTrainer(\n","    model=model,                         # the instantiated 🤗 Transformers model to be trained\n","    args=training_args,                  # training arguments, defined above\n","    train_dataset=train_dataset,         # training dataset\n","    eval_dataset=test_dataset             # evaluation dataset\n",")\n","\n","trainer.train()"],"metadata":{"id":"3rZlYMeurarz"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":[],"metadata":{"id":"LuSy__xZmt6Q"}},{"cell_type":"code","source":["trainer.evaluate(test_dataset)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"XO9rZVJmTh9s","executionInfo":{"status":"ok","timestamp":1690199001753,"user_tz":-330,"elapsed":21101,"user":{"displayName":"RACHANA POTPELWAR","userId":"12339588403377734923"}},"outputId":"f834f67e-d198-4a1d-d3af-159a0acd333f"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["{'eval_loss': 0.07492480855999571}"]},"metadata":{},"execution_count":16}]},{"cell_type":"code","source":["trainer.predict(test_dataset)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"SQ3GH-V_TtkV","executionInfo":{"status":"ok","timestamp":1690199055253,"user_tz":-330,"elapsed":41424,"user":{"displayName":"RACHANA POTPELWAR","userId":"12339588403377734923"}},"outputId":"51c88fe7-e47c-4bd3-e3d5-1f1d00c12da5"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["PredictionOutput(predictions=array([[-3.1541142,  2.8970544],\n","       [-3.8023884,  3.4152956],\n","       [-3.8407516,  3.470047 ],\n","       ...,\n","       [ 3.3833935, -2.9478166],\n","       [-3.6145408,  3.3758733],\n","       [ 3.3220055, -2.9492233]], dtype=float32), label_ids=array([1, 1, 1, ..., 0, 1, 0], dtype=int32), metrics={'eval_loss': 0.07491695519649622})"]},"metadata":{},"execution_count":17}]},{"cell_type":"code","source":["trainer.predict(test_dataset)[1].shape"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"gxS5XUGsT6nA","executionInfo":{"status":"ok","timestamp":1690199076288,"user_tz":-330,"elapsed":18114,"user":{"displayName":"RACHANA POTPELWAR","userId":"12339588403377734923"}},"outputId":"d08e88ea-a65c-48f1-c3a6-ff9e0c34a78a"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["(1047,)"]},"metadata":{},"execution_count":18}]},{"cell_type":"code","source":["output=trainer.predict(test_dataset)[1]"],"metadata":{"id":"59COgBpSUIJq"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["from sklearn.metrics import confusion_matrix\n","\n","cm=confusion_matrix(y_test,output)\n","cm"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"z58IlkO9UYnb","executionInfo":{"status":"ok","timestamp":1690199101230,"user_tz":-330,"elapsed":393,"user":{"displayName":"RACHANA POTPELWAR","userId":"12339588403377734923"}},"outputId":"ef976110-54c5-4920-e04a-4f341ebdf4be"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["array([[507,   0],\n","       [  0, 540]])"]},"metadata":{},"execution_count":20}]},{"cell_type":"code","source":["from sklearn import metrics"],"metadata":{"id":"NjA5j3VIUeJ2"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["metrics.accuracy_score(y_test, output)"],"metadata":{"id":"VoDafYtXUpeO","executionInfo":{"status":"ok","timestamp":1690199110033,"user_tz":-330,"elapsed":390,"user":{"displayName":"RACHANA POTPELWAR","userId":"12339588403377734923"}},"outputId":"36d72e82-5b57-4847-9859-d6112bca3c92","colab":{"base_uri":"https://localhost:8080/"}},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["1.0"]},"metadata":{},"execution_count":22}]},{"cell_type":"code","source":["from sklearn.metrics import roc_curve\n","from sklearn.metrics import roc_auc_score\n","from sklearn.metrics import roc_curve, auc\n","from matplotlib import pyplot"],"metadata":{"id":"j4ZqgIHse0wP"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["fpr, tpr, _ = roc_curve(y_test,output)\n","roc_auc = auc(fpr, tpr)\n","\n","# Plot the ROC curve\n","plt.figure()\n","plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)\n","plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n","plt.xlim([0.0, 1.0])\n","plt.ylim([0.0, 1.05])\n","plt.xlabel('False Positive Rate')\n","plt.ylabel('True Positive Rate')\n","plt.title('Receiver Operating Characteristic (ROC)')\n","plt.legend(loc='lower right')\n","plt.show()"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":472},"id":"RruwkabmvdKa","executionInfo":{"status":"ok","timestamp":1690199951824,"user_tz":-330,"elapsed":1099,"user":{"displayName":"RACHANA POTPELWAR","userId":"12339588403377734923"}},"outputId":"028c3633-ac5b-4159-f2b5-16459488f11e"},"execution_count":null,"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}]}],"metadata":{"colab":{"provenance":[],"authorship_tag":"ABX9TyOPNebWsFwOMkgys65v9a3B"},"kernelspec":{"display_name":"Python 3","name":"python3"},"language_info":{"name":"python"}},"nbformat":4,"nbformat_minor":0}