bert_transforming_with_bert.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/muhammadalihussnain/Volume_Controller/blob/master/bert_transforming_with_bert.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3RBsrava6WcE"
      },
      "source": [
        "# bert-transforming-with-bert\n",
        "\n",
        "Use the \"Run\" button to execute the code."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 65,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UFYAeN8v6WcI",
        "outputId": "23a01c94-89bd-4bdd-a27a-9a705a597066"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello World\n"
          ]
        }
      ],
      "source": [
        "print('Hello World')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 66,
      "metadata": {
        "id": "Abc_1VPx6XCZ"
      },
      "outputs": [],
      "source": [
        "!pip install -qq transformers"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 67,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jy8nFFLa6YLx",
        "outputId": "385a18aa-fd26-4f33-ae5c-ed74db42551b"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cuda', index=0)"
            ]
          },
          "metadata": {},
          "execution_count": 67
        }
      ],
      "source": [
        "#@title Setup & Config\n",
        "import transformers\n",
        "from transformers import BertModel, BertTokenizer, AdamW, get_linear_schedule_with_warmup\n",
        "import torch\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "from pylab import rcParams\n",
        "import matplotlib.pyplot as plt\n",
        "from matplotlib import rc\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import confusion_matrix, classification_report\n",
        "from collections import defaultdict\n",
        "from textwrap import wrap\n",
        "\n",
        "from torch import nn, optim\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "import torch.nn.functional as F\n",
        "\n",
        "%matplotlib inline\n",
        "%config InlineBackend.figure_format='retina'\n",
        "\n",
        "sns.set(style='whitegrid', palette='muted', font_scale=1.2)\n",
        "\n",
        "HAPPY_COLORS_PALETTE = [\"#01BEFE\", \"#FFDD00\", \"#FF7D00\", \"#FF006D\", \"#ADFF02\", \"#8F00FF\"]\n",
        "\n",
        "sns.set_palette(sns.color_palette(HAPPY_COLORS_PALETTE))\n",
        "\n",
        "rcParams['figure.figsize'] = 12, 8\n",
        "\n",
        "RANDOM_SEED = 42\n",
        "np.random.seed(RANDOM_SEED)\n",
        "torch.manual_seed(RANDOM_SEED)\n",
        "\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "device"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 68,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "adgbDSLcL2Ay",
        "outputId": "dd259b17-0f34-4870-d11b-521ad89853b0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 69,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0rPfCkEWKzR7",
        "outputId": "55bee2fb-a2d8-46f7-c06f-624932d7cf88"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ],
      "source": [
        "df= pd.read_csv('/content/drive/MyDrive/reviews.csv')\n",
        "\n",
        "df.content.isnull().sum()\n",
        "df.score.isnull().sum()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 69,
      "metadata": {
        "id": "P3_SvCSYK4uG"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": 70,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CcEBgjaaK4pR",
        "outputId": "f88ec65c-e3b6-497a-bcba-03b1d41efd45"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Index(['reviewId', 'userName', 'userImage', 'content', 'score',\n",
              "       'thumbsUpCount', 'reviewCreatedVersion', 'at', 'replyContent',\n",
              "       'repliedAt', 'sortOrder', 'appId'],\n",
              "      dtype='object')"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ],
      "source": [
        "df.columns"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 71,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 580
        },
        "id": "jSJDwaMMK4l-",
        "outputId": "a22150f9-b056-487d-b6c7-ac35e8ddaf37"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.8/dist-packages/seaborn/_decorators.py:36: FutureWarning: Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 0, 'Reviews')"
            ]
          },
          "metadata": {},
          "execution_count": 71
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x576 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "image/png": {
              "width": 745,
              "height": 489
            }
          }
        }
      ],
      "source": [
        "sns.countplot(df.score)\n",
        "plt.xlabel('Reviews')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "conditions= [(df.score<=2),(df.score==3),(df.score>3)]\n",
        "choices= [0,1,2]\n",
        "df['score'] =np.select(conditions,choices)\n",
        "df.score.value_counts()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i5ZIeTdTN8Z0",
        "outputId": "f0a14ccb-2340-47f6-c1aa-609272604256"
      },
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2    5990\n",
              "0    5786\n",
              "1    5622\n",
              "Name: score, dtype: int64"
            ]
          },
          "metadata": {},
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 73,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 580
        },
        "id": "NwTRg2C9K4j4",
        "outputId": "42e74043-c307-459d-a53e-a02650252677"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.8/dist-packages/seaborn/_decorators.py:36: FutureWarning: Pass the following variable as a keyword arg: x. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 0, 'Reviews')"
            ]
          },
          "metadata": {},
          "execution_count": 73
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x576 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "image/png": {
              "width": 745,
              "height": 489
            }
          }
        }
      ],
      "source": [
        "\n",
        "sns.countplot(df.score)\n",
        "plt.xlabel('Reviews')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 74,
      "metadata": {
        "id": "pbn2DUmbLEJH"
      },
      "outputs": [],
      "source": [
        "PRE_TRAINED_MODEL =   'bert-base-uncased'\n",
        "tokenizer= BertTokenizer.from_pretrained(PRE_TRAINED_MODEL)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 75,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LC4PnBkRK4gx",
        "outputId": "b6bf17c1-c505-46f0-d7a2-15487b6f1d25"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "simple_text:hi how are you i think you are find \n",
            "Tokens:['hi', 'how', 'are', 'you', 'i', 'think', 'you', 'are', 'find']\n",
            "token_ids:[7632, 2129, 2024, 2017, 1045, 2228, 2017, 2024, 2424]\n"
          ]
        }
      ],
      "source": [
        "simple_text = \"hi how are you i think you are find \"\n",
        "tokens = tokenizer.tokenize(simple_text)\n",
        "token_ids = tokenizer.convert_tokens_to_ids(tokens)\n",
        "print(f\"simple_text:{simple_text}\")\n",
        "print(f'Tokens:{tokens}')\n",
        "print(f\"token_ids:{token_ids}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zLCOvlWvK4eh",
        "outputId": "83b37669-287f-425c-a164-3db689c9e41c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[SEP] 102\n",
            "[CLS] 101\n",
            "[PAD] 0\n"
          ]
        }
      ],
      "source": [
        "print(tokenizer.sep_token,tokenizer.sep_token_id)\n",
        "print(tokenizer.cls_token,tokenizer.cls_token_id)\n",
        "print(tokenizer.pad_token,tokenizer.pad_token_id)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 77,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YvoaGpu9K4cQ",
        "outputId": "828f5812-ebbf-41ca-f927-23597968fa4b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "Keyword arguments {'return_tensor': True} not recognized.\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_keys(['input_ids', 'attention_mask'])"
            ]
          },
          "metadata": {},
          "execution_count": 77
        }
      ],
      "source": [
        "encoding = tokenizer.encode_plus(\n",
        "                                simple_text,\n",
        "                                max_length=32,\n",
        "                                add_special_tokens=True,\n",
        "                                return_token_type_ids=False,\n",
        "                                return_attention_mask=True,\n",
        "                                pad_to_max_length=True,\n",
        "                                return_tensor=True)\n",
        "encoding.keys()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 78,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "869diqjQK4Zn",
        "outputId": "767e4de5-ee0a-45d4-ac48-f522cb4479a4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[101, 7632, 2129, 2024, 2017, 1045, 2228, 2017, 2024, 2424, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
            "[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n",
            "32\n",
            "32\n"
          ]
        }
      ],
      "source": [
        "print(encoding.input_ids)\n",
        "print(encoding.attention_mask)\n",
        "print(len(encoding['input_ids']))\n",
        "print(len(encoding['attention_mask']))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 562
        },
        "id": "VYbhC5H3K4Wr",
        "outputId": "81fbec10-b5a8-4ae7-b678-3867fdbba8d9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.8/dist-packages/seaborn/distributions.py:2619: FutureWarning: `distplot` is a deprecated function and will be removed in a future version. Please adapt your code to use either `displot` (a figure-level function with similar flexibility) or `histplot` (an axes-level function for histograms).\n",
            "  warnings.warn(msg, FutureWarning)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f1a6ab59ee0>"
            ]
          },
          "metadata": {},
          "execution_count": 79
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x576 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "image/png": {
              "width": 749,
              "height": 471
            }
          }
        }
      ],
      "source": [
        "len_tokens=[]\n",
        "for text in df.content:\n",
        "  tokens= tokenizer.encode(text,max_length=512)\n",
        "  len_tokens.append(len(tokens))\n",
        "sns.distplot(len_tokens)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 80,
      "metadata": {
        "id": "k6s-Wnk_K4P6"
      },
      "outputs": [],
      "source": [
        "class GPReviews(Dataset):\n",
        "  def __init__(self,reviews,targets,tokenizer,max_length):\n",
        "    self.reviews=reviews\n",
        "    self.targets=targets\n",
        "    self.tokenizer=tokenizer\n",
        "    self.max_length=max_length\n",
        "\n",
        "\n",
        "  def __len__(self):\n",
        "    return len(self.reviews)\n",
        "  \n",
        "  def __getitem__( self, index):\n",
        "    \n",
        "    review=str(self.reviews[index])\n",
        "    target=self.targets[index]\n",
        "    encoding = self.tokenizer.encode_plus(review,\n",
        "                                max_length=self.max_length,\n",
        "                                add_special_tokens=True,\n",
        "                                return_token_type_ids=False,\n",
        "                                return_attention_mask=True,\n",
        "                                pad_to_max_length=True,\n",
        "                                return_tensors='pt')\n",
        "    return {\n",
        "        'Review_text':review,\n",
        "        \"encoding_Ids\":encoding['input_ids'].flatten(),\n",
        "        \"attention_mask\":encoding['attention_mask'].flatten(),\n",
        "        \"Target\":torch.tensor(target,dtype=torch.long)\n",
        "            }"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 81,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "81YcHbqAK4Nq",
        "outputId": "1a75bec7-9ef6-417a-ee38-15ed6de61d73"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(14788, 12) (1305, 12) (1305, 12)\n"
          ]
        }
      ],
      "source": [
        "train_df,test_df= train_test_split(df,test_size=.15,random_state=42)\n",
        "val_df,test_df= train_test_split(test_df,train_size=.5,random_state=42)\n",
        "print(train_df.shape,val_df.shape,test_df.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 82,
      "metadata": {
        "id": "bOQflIpgK4KM"
      },
      "outputs": [],
      "source": [
        "def create_data_loader(data,tokenizer,batch_size,max_len):\n",
        "  ds=GPReviews(\n",
        "      reviews=data.content.to_numpy(),\n",
        "      targets = data.score.to_numpy(),\n",
        "      tokenizer=tokenizer,\n",
        "      max_length=max_len\n",
        "  )\n",
        "  return DataLoader(ds,batch_size=batch_size,num_workers=4)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 83,
      "metadata": {
        "id": "h9dmwJ_1K4IJ"
      },
      "outputs": [],
      "source": [
        "PRE_TRAINED_MODEL_NAME='bert-base-cased'\n",
        "TOKENIZER=BertTokenizer.from_pretrained(PRE_TRAINED_MODEL_NAME)\n",
        "BATCH_SIZE=16\n",
        "MAX_LEN=160\n",
        "NUM_EPOCHS=10\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 84,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W2UqXtukK32G",
        "outputId": "7dd5e5d7-3655-4e97-a7f3-2ddf5fdfeba0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.8/dist-packages/torch/utils/data/dataloader.py:554: UserWarning: This DataLoader will create 4 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
            "  warnings.warn(_create_warning_msg(\n"
          ]
        }
      ],
      "source": [
        "TRAIN_LOADER=create_data_loader(train_df,TOKENIZER,BATCH_SIZE,MAX_LEN)\n",
        "VAL_LOADER=create_data_loader(val_df,TOKENIZER,BATCH_SIZE,MAX_LEN)\n",
        "TEST_LOADER=create_data_loader(test_df,TOKENIZER,BATCH_SIZE,MAX_LEN)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "data=next(iter(TRAIN_LOADER))\n",
        "data.keys()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e_3kko_KNxEB",
        "outputId": "a5b77c82-9e85-49c9-ea4b-3c5ad4751710"
      },
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_keys(['Review_text', 'encoding_Ids', 'attention_mask', 'Target'])"
            ]
          },
          "metadata": {},
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model=BertModel.from_pretrained(PRE_TRAINED_MODEL_NAME)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TFcghGxsP3Uk",
        "outputId": "bf3733e2-299c-4892-ff76-23b0b9cebd58"
      },
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Some weights of the model checkpoint at bert-base-cased were not used when initializing BertModel: ['cls.seq_relationship.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.dense.weight', 'cls.seq_relationship.weight', 'cls.predictions.bias']\n",
            "- This IS expected if you are initializing BertModel 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 BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "output=model(data['encoding_Ids'],data['attention_mask'])\n",
        "output.keys()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R6yqZBz4Qauu",
        "outputId": "24cef73f-7633-490e-bedb-c935a809bc8c"
      },
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "odict_keys(['last_hidden_state', 'pooler_output'])"
            ]
          },
          "metadata": {},
          "execution_count": 87
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model.config.hidden_size"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "roxaaaOQQig8",
        "outputId": "2fbd9c2b-f379-4e53-c6d5-31c29d37a109"
      },
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "768"
            ]
          },
          "metadata": {},
          "execution_count": 88
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class SentimentClassifier(nn.Module):\n",
        "  def __init__(self,n_classes):\n",
        "    super(SentimentClassifier,self).__init__()\n",
        "    self.bert=BertModel.from_pretrained(PRE_TRAINED_MODEL_NAME)\n",
        "    self.drop=nn.Dropout(p=0.3)\n",
        "    self.linear=nn.Linear(model.config.hidden_size,n_classes)\n",
        "    self.softmax=nn.Softmax(dim=1)\n",
        "\n",
        "  def forward(self,input_ids,attention_mask):\n",
        "    output=self.bert(input_ids,attention_mask)\n",
        "    output=self.drop(output[1])\n",
        "    output = self.linear(output)\n",
        "    return self.softmax(output)\n"
      ],
      "metadata": {
        "id": "zvVDsVUNQ6bz"
      },
      "execution_count": 89,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_model = SentimentClassifier(3)\n",
        "input_ids=data['encoding_Ids'].to(device)\n",
        "attention_mask=data['attention_mask'].to(device)\n",
        "print(input_ids.shape)\n",
        "print(attention_mask.shape)\n",
        "my_model=my_model.to(device)\n",
        "print(type(input_ids),type(attention_mask))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZecYCZswUR_c",
        "outputId": "52f6542c-7d99-4dd5-90ff-b55c44bd78e4"
      },
      "execution_count": 90,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Some weights of the model checkpoint at bert-base-cased were not used when initializing BertModel: ['cls.seq_relationship.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.dense.weight', 'cls.seq_relationship.weight', 'cls.predictions.bias']\n",
            "- This IS expected if you are initializing BertModel 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 BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([16, 160])\n",
            "torch.Size([16, 160])\n",
            "<class 'torch.Tensor'> <class 'torch.Tensor'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "output=my_model(data['encoding_Ids'].to(device),data['attention_mask'].to(device))\n",
        "EPOCHS = 10\n",
        "optimizer = AdamW(model.parameters(), lr=2e-5, correct_bias=False)\n",
        "total_steps = len(TRAIN_LOADER) * EPOCHS\n",
        "scheduler = get_linear_schedule_with_warmup(optimizer,num_warmup_steps=0,num_training_steps=total_steps)\n",
        "loss_fn = nn.CrossEntropyLoss().to(device)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ysZHWOOVVb8y",
        "outputId": "33cc1cd6-d5d2-47b2-d054-22b5510214dc"
      },
      "execution_count": 91,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.8/dist-packages/transformers/optimization.py:306: FutureWarning: This implementation of AdamW is deprecated and will be removed in a future version. Use the PyTorch implementation torch.optim.AdamW instead, or set `no_deprecation_warning=True` to disable this warning\n",
            "  warnings.warn(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from transformers.models.layoutlmv2.tokenization_layoutlmv2 import LAYOUTLMV2_ENCODE_PLUS_ADDITIONAL_KWARGS_DOCSTRING\n",
        "def train_epoch(data,model,device,optimizer,loss_fn,scheduler,n_examples):\n",
        "\n",
        "  model.train()\n",
        "  losses=[]\n",
        "  correct_preds=0\n",
        "\n",
        "  for d in data:\n",
        "\n",
        "    input_ids=d['encoding_Ids'].to(device)\n",
        "    attention_mask=d['attention_mask'].to(device)\n",
        "    target=d['Target'].to(device)\n",
        "\n",
        "\n",
        "    output=model(input_ids,attention_mask)  \n",
        "     \n",
        "    _,preds=torch.max(output,dim=1)\n",
        "    loss=loss_fn(output,target)\n",
        "\n",
        "    losses.append(loss.item())\n",
        "    correct_preds+=torch.sum(preds==target)\n",
        "    loss.backward()\n",
        "\n",
        "    nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n",
        "    optimizer.step()\n",
        "    scheduler.step()\n",
        "    optimizer.zero_grad()\n",
        "\n",
        "  return correct_preds.double() / n_examples, np.mean(losses)\n"
      ],
      "metadata": {
        "id": "u_A7nrE3W13A"
      },
      "execution_count": 92,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def val_epoch(data,model,device,optimizer,loss_fn,scheduler,n_examples):\n",
        "\n",
        "  model.eval()\n",
        "  losses=[]\n",
        "  correct_preds=0\n",
        "  with torch.no_grad():\n",
        "      for d in data:\n",
        "\n",
        "          input_ids=d['encoding_Ids'].to(device)\n",
        "          attention_mask=d['attention_mask'].to(device)\n",
        "          target=d['Target'].to(device)\n",
        "\n",
        "\n",
        "          output=model(input_ids,attention_mask)  \n",
        "          \n",
        "          _,preds=torch.max(output,dim=1)\n",
        "          loss=loss_fn(output,target)\n",
        "\n",
        "          losses.append(loss.item())\n",
        "          correct_preds+=torch.sum(preds==target)\n",
        "         \n",
        "  return correct_preds.double() / n_examples, np.mean(losses)"
      ],
      "metadata": {
        "id": "dsyD7ntAmibV"
      },
      "execution_count": 93,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "history=defaultdict(list)\n",
        "for epoch in range(NUM_EPOCHS):\n",
        "  print(f\"{epoch+1}//{NUM_EPOCHS}\")\n",
        "  print('-'*200)\n",
        "  train_accuracy,train_loss=train_epoch(TRAIN_LOADER,my_model,device,optimizer,loss_fn,scheduler,len(train_df))\n",
        "  print(f\"train_accuracy:{train_accuracy}          train_loss:{train_loss}\")\n",
        "\n",
        "  val_accuracy,val_loss=train_epoch(VAL_LOADER,my_model,device,optimizer,loss_fn,scheduler,len(val_df))\n",
        "  print(f\"Val_accuracy:{val_accuracy}          Val_loss:{val_loss}\")\n",
        "  history['train_acc'].append(train_accuracy)\n",
        "  history['val_accuracy'].append(val_accuracy)\n",
        "  history['train_loss'].append(train_loss)\n",
        "  history['val_loss'].append(val_loss)\n",
        " \n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gn7m3Sssb818",
        "outputId": "ddbae9a4-c1f6-42ec-ce81-5f84f512fb49"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1//10\n",
            "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.8/dist-packages/torch/utils/data/dataloader.py:554: UserWarning: This DataLoader will create 4 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
            "  warnings.warn(_create_warning_msg(\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train_accuracy:0.3341222612929402          train_loss:1.103813432100657\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Val_accuracy:0.3210727969348659          Val_loss:1.1056172426153974\n",
            "val_accuracty:0.3210727969348659       val_loss::1.1056172426153974\n",
            "2//10\n",
            "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train_accuracy:0.33648904517176087          train_loss:1.1033695025057406\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Val_accuracy:0.34406130268199236          Val_loss:1.1049374967086605\n",
            "val_accuracty:0.34406130268199236       val_loss::1.1049374967086605\n",
            "3//10\n",
            "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train_accuracy:0.3320935893968082          train_loss:1.1043607318723523\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Val_accuracy:0.34099616858237547          Val_loss:1.1022972842542136\n",
            "val_accuracty:0.34099616858237547       val_loss::1.1022972842542136\n",
            "4//10\n",
            "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train_accuracy:0.3314173654314309          train_loss:1.104296630910925\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Val_accuracy:0.34099616858237547          Val_loss:1.1039548516273499\n",
            "val_accuracty:0.34099616858237547       val_loss::1.1039548516273499\n",
            "5//10\n",
            "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train_accuracy:0.3345279956721666          train_loss:1.1034504899463138\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Val_accuracy:0.3578544061302682          Val_loss:1.0985286337573354\n",
            "val_accuracty:0.3578544061302682       val_loss::1.0985286337573354\n",
            "6//10\n",
            "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "train_accuracy:0.3351365972410062          train_loss:1.103488125027837\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n",
            "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
            "/usr/local/lib/python3.8/dist-packages/transformers/tokenization_utils_base.py:2336: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
            "  warnings.warn(\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "wAsso9kRcLfL"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.7.6"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}