BERT.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 74
        },
        "id": "1MAnruLCmDAl",
        "outputId": "8e43a293-0a54-47bf-917b-9b4ed12054a1"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-d63c7256-3b16-4850-889f-3c04ae639175\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-d63c7256-3b16-4850-889f-3c04ae639175\">\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 tr_off_lang-53004.csv to tr_off_lang-53004.csv\n"
          ]
        }
      ],
      "source": [
        "from google.colab import files\n",
        "\n",
        "upload = files.upload()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install emoji\n",
        "!pip install wordcloud\n",
        "!pip install transformers\n",
        "!pip install tqdm\n",
        "!pip install more-itertools"
      ],
      "metadata": {
        "id": "jdSaUjmxPXhV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Importing Data"
      ],
      "metadata": {
        "id": "pa0ApCSXnrM6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Kullandığımız veri setindeki satırları \"|\" ayıracı ile ayırıyoruz. \n",
        "df = pd.read_csv('tr_off_lang-53004.csv')\n",
        "df = df[[\"text\", \"label\"]]\n",
        "df.head()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "YBYJbRj6mb_U",
        "outputId": "23118219-de22-4f19-cab3-66c3f66a6f79"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                                                text  label\n",
              "0  Gerçekten sizin hikayelerinizi izleyerek mi ye...      0\n",
              "1            @USER Çoook çok bi baklava bi sen zaten      0\n",
              "2  1) Sn. DÜKEL; Atatürk'ün, Karma E. M. ile başl...      0\n",
              "3  Konfederasyonumuzun Aile ve Sosyal Politikalar...      0\n",
              "4  @USER @USER @USER @USER @USER @USER @USER @USE...      0"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-9ebc4298-ead3-48e0-87d9-245cc436613c\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>text</th>\n",
              "      <th>label</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>Gerçekten sizin hikayelerinizi izleyerek mi ye...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>@USER Çoook çok bi baklava bi sen zaten</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>1) Sn. DÜKEL; Atatürk'ün, Karma E. M. ile başl...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>Konfederasyonumuzun Aile ve Sosyal Politikalar...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>@USER @USER @USER @USER @USER @USER @USER @USE...</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-9ebc4298-ead3-48e0-87d9-245cc436613c')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-9ebc4298-ead3-48e0-87d9-245cc436613c button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-9ebc4298-ead3-48e0-87d9-245cc436613c');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 93
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Veri seti hakkında bilgileri yazdırdık.\n",
        "df.info()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xX9CLWljnzXS",
        "outputId": "ab7161f9-3842-4bd3-dd1c-5e79d8b6af52"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 53005 entries, 0 to 53004\n",
            "Data columns (total 2 columns):\n",
            " #   Column  Non-Null Count  Dtype \n",
            "---  ------  --------------  ----- \n",
            " 0   text    53005 non-null  object\n",
            " 1   label   53005 non-null  int64 \n",
            "dtypes: int64(1), object(1)\n",
            "memory usage: 828.3+ KB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "plt.rcParams['figure.figsize'] = (15, 5)\n",
        "\n",
        "# OTHER kategorisindeki veri adetini hesapladik.\n",
        "positive = len(df[df['label'] == 0])\n",
        "# (RACIST+INSULT+PROFANITY+SEXIST) kategorisindeki veri adetini hesapladik.\n",
        "negative = len(df[df['label'] == 1])\n",
        "# Dairesel grafikteki verilerimizi ayarladık.\n",
        "pie_y = [positive, negative]\n",
        "# Dairesel grafikteki verilerimizin adını ayarladık.\n",
        "pie_labels = [\"Zararsiz\", \"Zararli\"]\n",
        "\n",
        "# Dairesel grafiğimizi oluşturduk.\n",
        "plt.pie(pie_y, labels=pie_labels, startangle=90, autopct='%1.1f%%')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 532
        },
        "id": "DIPEA9OPn493",
        "outputId": "91f8e82e-b3f1-446d-e9df-7b6dff442385"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "([<matplotlib.patches.Wedge at 0x7fd77b369a50>,\n",
              "  <matplotlib.patches.Wedge at 0x7fd77b36a110>],\n",
              " [Text(-1.0928518594066863, -0.12519909501010199, 'Zararsiz'),\n",
              "  Text(1.0928518711286668, 0.1251989926899263, 'Zararli')],\n",
              " [Text(-0.5961010142218288, -0.06829041546005563, '53.6%'),\n",
              "  Text(0.5961010206156363, 0.0682903596490507, '46.4%')])"
            ]
          },
          "metadata": {},
          "execution_count": 95
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Her bir kategorideki veri adeti"
      ],
      "metadata": {
        "id": "ATtugYUJoWnq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from collections import Counter\n",
        "# TARGET sütunundaki kategorileri bulduk.\n",
        "tags = Counter(df[\"label\"]).keys()\n",
        "# TARGET sütunundaki kategorilerin adetini bulduk.\n",
        "tags_len = Counter(df[\"label\"]).values()\n",
        "\n",
        "# Kategori ismi ve adet sayısını veri seti haline getirdik.\n",
        "tag_df = pd.DataFrame(zip(tags, tags_len), columns=[\"Sinif\", \"Toplam\"])\n",
        "# Plot grafiğimizi oluşturduk.\n",
        "tag_df.plot(x=\"Sinif\", y=\"Toplam\", kind=\"bar\", legend=False, grid=False, figsize=(15,5))\n",
        "# Plot grafiğimizin başlığını ayarladık.\n",
        "plt.title(\"Etiket Sayılarının Görselleştirilmesi\", fontsize=18)\n",
        "# Plot grafiğimizin x ekseni başlığını ayarladık.\n",
        "plt.xlabel(\"Etiketler\", fontsize=15)\n",
        "# Plot grafiğimizin y ekseni başlığını ayarladık.\n",
        "plt.ylabel(\"Toplam\", fontsize=15)\n",
        "# Plot grafiğimizi ekrana yazdırdık.\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 493
        },
        "id": "4pTObUuaoC6i",
        "outputId": "46c81ae6-9594-4ba9-ca51-771698ca1686"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Temizlemeden önceki en sık kullanılan kelimeler"
      ],
      "metadata": {
        "id": "F7kGF4wNo0YL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import nltk\n",
        "import string\n",
        "nltk.download('punkt')\n",
        "\n",
        "# Bir kategorideki en sık geçen kelimeleri bulmaya yarayan fonksiyonumuzu tanımladık.\n",
        "def word_freq(CATEGORY):\n",
        "  # Parametre olarak verilen kategoriyi kullanarak veri setimizi oluşturduk.\n",
        "  freq_df = df[df['label'] == CATEGORY]\n",
        "  # Kategorimizin text sınıfındaki satırlardaki kelimeleri bir değişkene aktardık.\n",
        "  freq_words = freq_df[\"text\"].tolist()\n",
        "  freq_words = [i.lower() for i in freq_words]\n",
        "  freq_punc = []\n",
        "  # Dizimizdeki kelimelerin sıklığındaki noktalama işaretlerini saydık.\n",
        "  for o in freq_words:\n",
        "    freq_punc += nltk.word_tokenize(o)\n",
        "  freq_punc = [o for o in freq_punc if o not in string.punctuation]\n",
        "  freq_freq = Counter(freq_punc)\n",
        "  # En sık geçen 15 kelimeyi bir değişkene atadık.\n",
        "  freq_top = freq_freq.most_common(15)\n",
        "\n",
        "\n",
        "  words = [word for word, _ in freq_top]\n",
        "  \n",
        "  counts = [counts for _, counts in freq_top]\n",
        "\n",
        "  # Sütun grafiğimizi oluşturduk.\n",
        "  plt.bar(words, counts)\n",
        "  # Sütun grafiğimizin başlığını ayarladık.\n",
        "  plt.title(f\"{CATEGORY} SINIFINDAKI EN SIK GECEN 15 KELIME\")\n",
        "  # Sütun grafiğimizin y ekseni başlığını ayarladık.\n",
        "  plt.ylabel(\"Frekans\")\n",
        "  # Sütun grafiğimizin x ekseni başlığını ayarladık.\n",
        "  plt.xlabel(\"Kelimeler\")\n",
        "  # Sütün grafiğimizi ekrana bastırdık.\n",
        "  plt.show()\n",
        "\n",
        "  # WordCloud'da kullanmak için en sık geçen kelimeleri döndürdük.\n",
        "  return freq_top"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1AFrfNSCol5F",
        "outputId": "67b1b6aa-98d9-448f-b06e-70d7a675e4b5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[nltk_data] Downloading package punkt to /root/nltk_data...\n",
            "[nltk_data]   Package punkt is already up-to-date!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 1 kategorisindeki en sık geçen 15 kelimeyi gösteren grafiği ekrana yazdırdık.\n",
        "negative_top = word_freq(1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 487
        },
        "id": "qafX1tTRo-bT",
        "outputId": "88fc5376-52ba-43f0-8ea5-f6d5c3bb2fd5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 0 kategorisindeki en sık geçen 15 kelimeyi gösteren grafiği ekrana yazdırdık.\n",
        "positive_top = word_freq(0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 487
        },
        "id": "u8VlMjmmpEA6",
        "outputId": "98ff2480-6f4b-4c32-d5e8-e40187ad288f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from wordcloud import WordCloud\n",
        "\n",
        "# En sık geçen kelimeleri sözcük bulutu şeklinde yazdıran fonksiyonu tanımladık.\n",
        "def print_wordcloud(dict_top):\n",
        "  # Liste halindeki verileri \n",
        "  dict_top = dict(dict_top)\n",
        "  # Sözcük bulutumuzu oluşturduk.\n",
        "  wordcloud = WordCloud(width=350, height=350, background_color='black', min_font_size=5).generate_from_frequencies(dict_top)\n",
        "\n",
        "  # Grafik boyutunu ayarladık.\n",
        "  plt.figure(figsize=(5,9), facecolor=None)\n",
        "  plt.imshow(wordcloud)\n",
        "  plt.axis(\"off\")\n",
        "  plt.tight_layout(pad=0)\n",
        "  # Grafiğimizi ekrana yazdırdık.\n",
        "  plt.show()"
      ],
      "metadata": {
        "id": "N6HQNDgcpP9N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 1 kategorisindeki en sık kullanılan 15 kelimeyi sözcük bulutu halinde ekrana yazdırdık.\n",
        "print_wordcloud(negative_top)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 536
        },
        "id": "6FaLB8cKpvLJ",
        "outputId": "2e9186f9-c633-4245-9299-0926faa97d56"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 500x900 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 10 kategorisindeki en sık kullanılan 15 kelimeyi sözcük bulutu halinde ekrana yazdırdık.\n",
        "print_wordcloud(positive_top)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 536
        },
        "id": "0OK_2rIppxcV",
        "outputId": "fbf8fcac-c296-405c-e206-1d9a7d41a515"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 500x900 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Preprocess"
      ],
      "metadata": {
        "id": "R9KgOqndp2D2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import nltk\n",
        "from nltk.corpus import stopwords\n",
        "\n",
        "# NLTK kütüphanesini kullanarak türkçe dilindeki etkisiz kelimeleri (stopwords) indiriyoruz.\n",
        "nltk.download('stopwords')\n",
        "# İndirilen etkisiz kelimeleri \"stop_words_list\" değişkenine atıyoruz.\n",
        "stop_words_list = stopwords.words('turkish')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OmDrx-Vtpz7R",
        "outputId": "47936a00-f379-4e13-a0e9-c0394b85ef4d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[nltk_data] Downloading package stopwords to /root/nltk_data...\n",
            "[nltk_data]   Package stopwords is already up-to-date!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import re\n",
        "\n",
        "# Ön işleme adımlarını yapmak için fonksiyonumuzu tanımlıyoruz.\n",
        "def preprocess_text(text):\n",
        "    # Küçük harflere çevirme\n",
        "    text = text.lower()\n",
        "    # Satır sonu karakterlerini kaldırma\n",
        "    text = re.sub(r'\\n', ' ', text)\n",
        "    # Rakamları kaldırma\n",
        "    text = re.sub(r'\\d', '', text)\n",
        "    # Noktalama işaretlerini kaldırma\n",
        "    import string\n",
        "    text = text.translate(str.maketrans(\"\", \"\", string.punctuation))\n",
        "    # Stop-words'leri kaldırma\n",
        "    words = text.split()\n",
        "    words = [word for word in words if not word in stop_words_list]\n",
        "    # Tekrarlanan karakterlerin kaldırılması\n",
        "    words = [re.sub(r'(.)\\1{1,}', r'\\1\\1', word) for word in words]\n",
        "    # Tekrarlanan boşlukların kaldırılması\n",
        "    words = [word.strip() for word in words if len(word.strip()) > 1]\n",
        "    \n",
        "    text = \" \".join(words)\n",
        "    return text"
      ],
      "metadata": {
        "id": "QgmxJ9cHp4iO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Veri setindeki sütün başlıklarını yazdırdık.\n",
        "df.columns"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mcMSE-58p6V4",
        "outputId": "1712d07e-c157-4a52-844c-6e2719474f72"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Index(['text', 'label'], dtype='object')"
            ]
          },
          "metadata": {},
          "execution_count": 105
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "regex = r'@\\w+\\s?'\n",
        "\n",
        "# \"mesaj\" sütunundaki \"@\" sembolü ile başlayan kelimeleri temizle\n",
        "df['clean_text'] = df['text'].apply(lambda x: re.sub(regex, '', x))"
      ],
      "metadata": {
        "id": "Z1rSI-MPusnV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Veri setimizde \"clean_text\" adında bir sütün oluşturarak ön işleme fonksiyonumuz olan \"preprocess_text\" fonksiyonunu \"text\" sütünü altındaki verilere uygulayarak \"clean_text\" sütünuna aktardık. \n",
        "df['clean_text'] = df['clean_text'].apply(preprocess_text)"
      ],
      "metadata": {
        "id": "twxoBNJ6p8MW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import emoji\n",
        "\n",
        "df['clean_text'] = df['clean_text'].apply(lambda s: emoji.replace_emoji(s, ''))"
      ],
      "metadata": {
        "id": "eawULUa1VRTl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Ön işleme işleminden sonra veri setinimizin ilk 5 satırına bakalım.\n",
        "df.sample(10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 363
        },
        "id": "dMvx9xzDp9eS",
        "outputId": "993a7063-51b2-486d-9842-6787737631f5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                                                    text  label  \\\n",
              "15396  Uzun yola çıkmışsın kulağında kulaklık müzik d...      0   \n",
              "46757                    Aq rusları onu da iptal ettiler      1   \n",
              "34636  @USER @USER Ulan gerizekali beyinsiz, yasal ol...      1   \n",
              "51477  En sonunda kilicdaroglu imamogluna İBB başkanl...      1   \n",
              "4198                     Son 1 gün... sonra 9 gün tatil.      0   \n",
              "43151  Bu adama türk dedi amına koduğumun rusu  https...      1   \n",
              "49315  @USER Bunlara inanan gerizekalılar var şimdi. ...      1   \n",
              "38235  Herkes her konuda doğru, bir tek ben yanlışım ...      1   \n",
              "27552  Elimde durduk yere sim kartı okumayan telefonu...      0   \n",
              "24575  #ZehraZumrutS    #abdulhamitgul   #ctekurumsal...      0   \n",
              "\n",
              "                                              clean_text  \n",
              "15396  uzun yola çıkmışsın kulağında kulaklık müzik d...  \n",
              "46757                       aq rusları onu iptal ettiler  \n",
              "34636  ulan gerizekali beyinsiz yasal olarak bir enge...  \n",
              "51477  sonunda kilicdaroglu imamogluna i̇bb başkanlığ...  \n",
              "4198                             son gün sonra gün tatil  \n",
              "43151  adama türk dedi amına koduğumun rusu httpstcof...  \n",
              "49315  bunlara inanan gerizekalılar var şimdi adam ya...  \n",
              "38235  herkes konuda doğru bir tek ben yanlışım koduğ...  \n",
              "27552  elimde durduk yere sim kartı okumayan telefonu...  \n",
              "24575  zehrazumruts abdulhamitgul ctekurumsal sizden ...  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-ad9a74f4-f538-4ede-8501-44d446df2761\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>text</th>\n",
              "      <th>label</th>\n",
              "      <th>clean_text</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>15396</th>\n",
              "      <td>Uzun yola çıkmışsın kulağında kulaklık müzik d...</td>\n",
              "      <td>0</td>\n",
              "      <td>uzun yola çıkmışsın kulağında kulaklık müzik d...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>46757</th>\n",
              "      <td>Aq rusları onu da iptal ettiler</td>\n",
              "      <td>1</td>\n",
              "      <td>aq rusları onu iptal ettiler</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>34636</th>\n",
              "      <td>@USER @USER Ulan gerizekali beyinsiz, yasal ol...</td>\n",
              "      <td>1</td>\n",
              "      <td>ulan gerizekali beyinsiz yasal olarak bir enge...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>51477</th>\n",
              "      <td>En sonunda kilicdaroglu imamogluna İBB başkanl...</td>\n",
              "      <td>1</td>\n",
              "      <td>sonunda kilicdaroglu imamogluna i̇bb başkanlığ...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4198</th>\n",
              "      <td>Son 1 gün... sonra 9 gün tatil.</td>\n",
              "      <td>0</td>\n",
              "      <td>son gün sonra gün tatil</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>43151</th>\n",
              "      <td>Bu adama türk dedi amına koduğumun rusu  https...</td>\n",
              "      <td>1</td>\n",
              "      <td>adama türk dedi amına koduğumun rusu httpstcof...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>49315</th>\n",
              "      <td>@USER Bunlara inanan gerizekalılar var şimdi. ...</td>\n",
              "      <td>1</td>\n",
              "      <td>bunlara inanan gerizekalılar var şimdi adam ya...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>38235</th>\n",
              "      <td>Herkes her konuda doğru, bir tek ben yanlışım ...</td>\n",
              "      <td>1</td>\n",
              "      <td>herkes konuda doğru bir tek ben yanlışım koduğ...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>27552</th>\n",
              "      <td>Elimde durduk yere sim kartı okumayan telefonu...</td>\n",
              "      <td>0</td>\n",
              "      <td>elimde durduk yere sim kartı okumayan telefonu...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>24575</th>\n",
              "      <td>#ZehraZumrutS    #abdulhamitgul   #ctekurumsal...</td>\n",
              "      <td>0</td>\n",
              "      <td>zehrazumruts abdulhamitgul ctekurumsal sizden ...</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-ad9a74f4-f538-4ede-8501-44d446df2761')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-ad9a74f4-f538-4ede-8501-44d446df2761 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-ad9a74f4-f538-4ede-8501-44d446df2761');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 114
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.preprocessing import LabelEncoder\n",
        "# LabelEncoder kullanarak \"target\" sütunumuza dönüşüm yaptırdık.\n",
        "le = LabelEncoder().fit(df[\"label\"])\n",
        "# \"Name Mapping\" işlemini tanımladık.\n",
        "le_nm = dict(zip(le.classes_, le.transform(le.classes_)))\n",
        "# Veri setimizde \"labels\" adında sütun oluşturarak \"target\" sütununa \"Name Mapping\" işlemi yaparak \"labels\" sütunu altına aktardık.\n",
        "df[\"labels\"] = df[\"label\"].apply(lambda x: le_nm[x])\n",
        "# \"id\", \"text\", \"target\" sütunlarını veri setimizden çıkardık.\n",
        "df = df.drop(['text', 'label'], axis=1)"
      ],
      "metadata": {
        "id": "M__oj8sRUO_C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import torch\n",
        "from transformers import BertTokenizer, BertModel\n",
        "\n",
        "# Verilerimizi BERT'e uygun biçimde dönüştürmemiz gerekiyor. Bunu da Hugging Face'den önceden eğitilmiş \"bert-base-turkish-uncased\" modelini kullanarak yapıyoruz.\n",
        "tokenizer = BertTokenizer.from_pretrained(\"dbmdz/bert-base-turkish-uncased\")\n",
        "labels = le_nm\n",
        "\n",
        "class Dataset(torch.utils.data.Dataset):\n",
        "    def __init__(self, df):\n",
        "      # Kategorik sınıflar.\n",
        "      self.labels = [label for label in df['labels']]\n",
        "      # text = Modeli eğitmek için kullanılacak veri setindeki \"clean_text\" sütunundaki her bir satır.\n",
        "      # padding = Her bir diziyi belirttiğimiz maksimum uzunluga kadar doldurmak için.\n",
        "      # max_length = Her bir dizinin maksimum uzunluğu\n",
        "      # truncation = Eğer değeri \"True\" ise dizimiz maksimum uzunluğu aşar ise onu keser.\n",
        "      # return_tensors = Döndürelecek tensörlerin türü. Pytorch kullandığımız için \"pt\" yazıyoruz. Tensorflow kullansaydık \"tf\" yazmamız gerekirdi.\n",
        "      self.text = [tokenizer(text, padding='max_length', max_length=512, truncation=True, return_tensors=\"pt\") for text in df['clean_text']]\n",
        "\n",
        "    def classes(self):\n",
        "      return self.labels\n",
        "\n",
        "    def __len__(self):\n",
        "      return len(self.labels)\n",
        "\n",
        "    def get_batch_labels(self, idx):\n",
        "      # Bir grup etiket getir.\n",
        "      return np.array(self.labels[idx])\n",
        "\n",
        "    def get_batch_texts(self, idx):\n",
        "      # Bir grup girdi getir.\n",
        "      return self.text[idx]\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "      batch_texts = self.get_batch_texts(idx)\n",
        "      batch_y = self.get_batch_labels(idx)\n",
        "\n",
        "      return batch_texts, batch_y"
      ],
      "metadata": {
        "id": "EqMZzOELqDpc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train_validate_test_split(df):\n",
        "    # Rastgelelik durumu.\n",
        "    np.random.seed(4242)\n",
        "    # Diziyi rastgele permute eder.\n",
        "    perm = np.random.permutation(df.index)\n",
        "    # Veri setinin %60'ının sayısal değeri hesaplandı.\n",
        "    train_end = int(.6 * len(df.index))\n",
        "    # Veri setinin %20'sinin sayısal değeri hesaplandı.\n",
        "    validate_end = int(.2 * len(df.index)) + train_end\n",
        "    # Veri setinin %60'ını train etmek için ayırdık.\n",
        "    train = df.iloc[perm[:train_end]]\n",
        "    # Veri setinin %20'sini validation etmek için ayırdık.\n",
        "    validate = df.iloc[perm[train_end:validate_end]]\n",
        "    # Veri setinin %20'sini test etmek için ayırdık.\n",
        "    test = df.iloc[perm[validate_end:]]\n",
        "    # train, validation, test veri setlerini döndür.\n",
        "    return train, validate, test\n",
        "\n",
        "# Train, Validation ve Test için veri setlerimiz oluşturduk.\n",
        "df_train, df_validation, df_test = train_validate_test_split(df)\n",
        "# Train, Validation ve Test için oluşturduğumuz veri setlerinin uzunluğunu ekrana yazdırdık. (%60 - %20 - %20)\n",
        "print(len(df_train), len(df_validation), len(df_test))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cdf2b2f3-a30b-4b36-adae-e7d2a9073cdd",
        "id": "SnTm6kd_v-87"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "31803 10601 10601\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class BertClassifier(torch.nn.Module):\n",
        "  def __init__(self, dropout=0.5):\n",
        "    super(BertClassifier, self).__init__()\n",
        "    \n",
        "    self.bert = BertModel.from_pretrained(\"dbmdz/bert-base-turkish-uncased\")\n",
        "    self.dropout = torch.nn.Dropout(dropout)\n",
        "    # Kullandığımız önceden eğilmiş model \"base\" sınıfına ait bir BERT modelidir. Yani;\n",
        "    # 12 layers of Transformer encoder, 12 attention heads, 768 hidden size, 110M parameters.\n",
        "    # 768, BERT-base modelindeki hidden size'yi, 5 ise veri setimizdeki toplam kategori sayısını temsil ediyor.\n",
        "    self.linear = torch.nn.Linear(768, 5)\n",
        "    self.relu = torch.nn.ReLU()\n",
        "\n",
        "  def forward(self, input_id, mask):\n",
        "    # _ değişkeni dizideki tüm belirteçlerin gömme vektörlerini içerir.\n",
        "    # pooled_output değişkeni [CLS] belirtecinin gömme vektörünü içerir.\n",
        "    # Metin sınıflandırma için polled_output değişkenini girdi olarak kullanmak yeterlidir.\n",
        "\n",
        "    # Attention mask, bir belirtecin gercek bir kelimemi yoksa dolgu mu olduğunu tanımlar.\n",
        "    # Eğer gerçek bir kelime ise attention_mask=1, eğer dolgu ise attention_mask=0 olacaktır.\n",
        "    # return_dict, değeri \"True ise\" bir BERT modeli tahmin, eğitim veya değerlendirme sırasında ortaya çıkan\n",
        "    # loss, logits, hidden_states ve attentions dan oluşan bir tuple oluşturacaktır.\n",
        "    _, pooled_output = self.bert(input_ids=input_id, attention_mask=mask, return_dict=False)\n",
        "    dropout_output = self.dropout(pooled_output)\n",
        "    linear_output = self.linear(dropout_output)\n",
        "    final_layer = self.relu(linear_output)\n",
        "\n",
        "    return final_layer"
      ],
      "metadata": {
        "id": "y8gUKIFgwBRu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Eğitim tur sayısı\n",
        "EPOCHS = 2\n",
        "# BERT model tanımlaması.\n",
        "model = BertClassifier()\n",
        "# Öğrenme oranı\n",
        "LR = 1e-6\n",
        "\n",
        "# Train ve Validation için ayırdığımız veri setlerini \n",
        "train, validation = Dataset(df_train), Dataset(df_validation)\n",
        "\n",
        "# Verilerin toplu olarak içe aktarılması için DataLoader kullanıyoruz.\n",
        "# batch_size, model güncellenmeden önce işlenen örnek sayısıdır.\n",
        "# shuffle, karıştır.\n",
        "tdl = torch.utils.data.DataLoader(train, batch_size=2, shuffle=True)\n",
        "vdl = torch.utils.data.DataLoader(validation, batch_size=2)\n",
        "device = torch.device(\"cuda\")\n",
        "\n",
        "# Çok sınıflı sınıflandırma kullandığımız için çapraz entropi kullanmamız gerekiyor.\n",
        "criterion = torch.nn.CrossEntropyLoss().cuda()\n",
        "# Optimizer için Adam kullanıyoruz.\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=LR)\n",
        "model = model.cuda()\n",
        "\n",
        "for EPOCH in range(EPOCHS):\n",
        "    # Toplam eğitim doğruluğu\n",
        "    total_train_accuracy = 0\n",
        "    # Toplam eğitim kaybı\n",
        "    total_train_loss = 0\n",
        "    # Toplam validation doğruluğu\n",
        "    total_validation_accuracy = 0\n",
        "    # Toplam validation kaybı\n",
        "    total_validation_loss = 0\n",
        "    \n",
        "    # tqdm kütüphanesi, \"Progress Bar\" oluşturmaya yarar.\n",
        "    from tqdm import tqdm\n",
        "    for train_input, train_label in tqdm(tdl):\n",
        "        # Modelin verileri işleyebilmesi için hem modelin hem de verilerin CPU veya GPU olmak üzere aynı cihazda olması gerekir.\n",
        "        # Örneğin veriler CPU'da, model GPU'da olursa çalışma zamanı hatası oluşacaktır. \n",
        "        # Bunu önlemek için pytorch kütüphanesinden \"to\" fonksiyonunu kullanıyoruz.\n",
        "        train_label = train_label.to(device)\n",
        "\n",
        "        # Attention mask, bir belirtecin gercek bir kelimemi yoksa dolgu mu olduğunu tanımlar.\n",
        "        # Eğer gerçek bir kelime ise attention_mask=1, eğer dolgu ise attention_mask=0 olacaktır.\n",
        "        mask = train_input['attention_mask'].to(device)\n",
        "        # input_ids, her bir tokenin id gösterimidir.\n",
        "        input_id = train_input['input_ids'].squeeze(1).to(device)\n",
        "\n",
        "        # Modelin eğitim verileri üzerindeki tahminlerinin sonuçları saklanır.\n",
        "        output = model(input_id, mask)\n",
        "        \n",
        "        # Çapraz entropi ile örneklem kaybını hesaplıyoruz.\n",
        "        batch_loss = criterion(output, train_label.long())\n",
        "        # Her bir epoch için toplam train kaybını bulmak için her bir örneklemin train kaybını topluyoruz.\n",
        "        total_train_loss += batch_loss.item()\n",
        "        \n",
        "        # \"output\" değişkenindeki her bir veri örneği için çıktı tensöründe en yüksek olasılığa sahip\n",
        "        # sınıfın indexini döndürür. Daha sonra \"train_label\" adlı tensörde modein doğru sınıf tahmilnerinin\n",
        "        # bulunduğu etiketleri saklanır. Doğru tahmin edilen sınıfların sayısı hesaplanır ve \"item\"\n",
        "        # fonksiyonu ile sayısal bir değere dönüştürülür.\n",
        "        train_accuracy = (output.argmax(dim=1) == train_label).sum().item()\n",
        "        # Her bir epoch için toplam train doğruluğunu bulmak için her bir örneklemin doğruluk kaybını topluyoruz.\n",
        "        total_train_accuracy += train_accuracy\n",
        "\n",
        "        # Gradyanlar, modelin kaybını optimize etmek için geriye doğru hesaplanır ve eğitim adımlarında kullanılır.\n",
        "        # Pytorch'da Gradyanlar biriktirilir ve önceki gradyan üzerine eklenir. Bu nedenle, modelin bir sonraki eğitim\n",
        "        # adımında geçerli gradyan değerlerini kullanabilmesi için, gradyanların önce sıfırlanması gerekir.\n",
        "        # Bu işlemi de \"zero_grad\" fonksiyonunu kullanarak yapıyoruz.\n",
        "        model.zero_grad()\n",
        "\n",
        "        # Kayıp fonksiyonunun gradyanını hesaplamak ve bu gradyanı kullanarak modelin ağırlıklarının güncellenmesi için\n",
        "        # geriye doğru geçiş (backpropagation) işlemini başlatıyoruz.\n",
        "        batch_loss.backward()\n",
        "        \n",
        "        #step(), optimize edicinin güncellemesi gereken tüm tensörler üzerinde yineleme yapmasını ve değerlerini güncellemek için dahili olarak depolanan gradlarını kullanmasını sağlar\n",
        "        optimizer.step()\n",
        "\n",
        "    # Doğrulama işlemi sırasında model ağırlıklarını değiştirmeyeceğimiz modelin gradyanlara ihtiyacı yoktur\n",
        "    # \"no_grad\" fonksiyonu ile gradyan hesaplarını devre dışı bırakıyoruz.\n",
        "    with torch.no_grad():\n",
        "        # tqdm kütüphanesi, \"Progress Bar\" oluşturmaya yarar.\n",
        "        for val_input, val_label in tqdm(vdl):\n",
        "            # Modelin verileri işleyebilmesi için hem modelin hem de verilerin CPU veya GPU olmak üzere aynı cihazda olması gerekir.\n",
        "            # Örneğin veriler CPU'da, model GPU'da olursa çalışma zamanı hatası oluşacaktır. \n",
        "            # Bunu önlemek için pytorch kütüphanesinden \"to\" fonksiyonunu kullanıyoruz.\n",
        "            val_label = val_label.to(device)\n",
        "\n",
        "            # Attention mask, bir belirtecin gercek bir kelimemi yoksa dolgu mu olduğunu tanımlar.\n",
        "            # Eğer gerçek bir kelime ise attention_mask=1, eğer dolgu ise attention_mask=0 olacaktır.\n",
        "            mask = val_input['attention_mask'].to(device)\n",
        "            input_id = val_input['input_ids'].squeeze(1).to(device)\n",
        "\n",
        "            # Modelin eğitim verileri üzerindeki tahminlerinin sonuçları saklanır.\n",
        "            output = model(input_id, mask)\n",
        "\n",
        "            # Çapraz entropi ile örneklem kaybını hesaplıyoruz.\n",
        "            batch_loss = criterion(output, val_label.long())\n",
        "            # Her bir epoch için toplam train kaybını bulmak için her bir örneklemin train kaybını topluyoruz.\n",
        "            total_validation_loss += batch_loss.item()\n",
        "\n",
        "            # \"output\" değişkenindeki her bir veri örneği için çıktı tensöründe en yüksek olasılığa sahip\n",
        "            # sınıfın indexini döndürür. Daha sonra \"train_label\" adlı tensörde modein doğru sınıf tahmilnerinin\n",
        "            # bulunduğu etiketleri saklanır. Doğru tahmin edilen sınıfların sayısı hesaplanır ve \"item\"\n",
        "            # fonksiyonu ile sayısal bir değere dönüştürülür.\n",
        "            validation_accuracy = (output.argmax(dim=1) == val_label).sum().item()\n",
        "            # Her bir epoch için toplam train doğruluğunu bulmak için her bir örneklemin doğruluk kaybını topluyoruz.\n",
        "            total_validation_accuracy += validation_accuracy\n",
        "    \n",
        "    # Mevcut Epoch\n",
        "    print(f'Epochs: {EPOCH + 1}')\n",
        "    # Train Kaybı\n",
        "    print(f'Train Loss: {total_train_loss / len(df_train): .4f}')\n",
        "    # Train Dogruluk\n",
        "    print(f'Train Accuracy: {total_train_accuracy / len(df_train): .4f}')\n",
        "    # Validation Kaybı\n",
        "    print(f'Validation Loss: {total_validation_loss / len(df_validation): .4f}')\n",
        "    # Validation Dogruluk\n",
        "    print(f'Validation Accuracy: {total_validation_accuracy / len(df_validation): .4f}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LF__SR-hwFbB",
        "outputId": "dabf1910-d085-4cf9-e0c1-41568341f448"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Some weights of the model checkpoint at dbmdz/bert-base-turkish-uncased were not used when initializing BertModel: ['cls.predictions.decoder.weight', 'cls.predictions.transform.dense.bias', 'cls.predictions.transform.LayerNorm.bias', 'cls.seq_relationship.bias', 'cls.predictions.transform.dense.weight', 'cls.seq_relationship.weight', 'cls.predictions.bias', 'cls.predictions.decoder.bias', 'cls.predictions.transform.LayerNorm.weight']\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",
            "100%|██████████| 15902/15902 [55:40<00:00,  4.76it/s]\n",
            "100%|██████████| 5301/5301 [05:58<00:00, 14.78it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epochs: 1\n",
            "Train Loss:  0.1522\n",
            "Train Accuracy:  0.8893\n",
            "Validation Loss:  0.1092\n",
            "Validation Accuracy:  0.9139\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 15902/15902 [55:39<00:00,  4.76it/s]\n",
            "100%|██████████| 5301/5301 [05:58<00:00, 14.80it/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epochs: 2\n",
            "Train Loss:  0.0905\n",
            "Train Accuracy:  0.9322\n",
            "Validation Loss:  0.1110\n",
            "Validation Accuracy:  0.9151\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Test için ayırdığımız veri setlerini \n",
        "test = Dataset(df_test)\n",
        "\n",
        "# Verilerin toplu olarak içe aktarılması için DataLoader kullanıyoruz.\n",
        "# batch_size, model güncellenmeden önce işlenen örnek sayısıdır.\n",
        "# shuffle, karıştır.\n",
        "tdl = torch.utils.data.DataLoader(test, batch_size=2)\n",
        "device = torch.device(\"cuda\")\n",
        "model = model.cuda()\n",
        "\n",
        "# Toplam test doğruluğu\n",
        "total_test_accuracy = 0\n",
        "\n",
        "# Test işlemi sırasında model ağırlıklarını değiştirmeyeceğimiz modelin gradyanlara ihtiyacı yoktur\n",
        "# \"no_grad\" fonksiyonu ile gradyan hesaplarını devre dışı bırakıyoruz.\n",
        "with torch.no_grad():\n",
        "  for test_input, test_label in tdl:\n",
        "    # Modelin verileri işleyebilmesi için hem modelin hem de verilerin CPU veya GPU olmak üzere aynı cihazda olması gerekir.\n",
        "    # Örneğin veriler CPU'da, model GPU'da olursa çalışma zamanı hatası oluşacaktır. \n",
        "    # Bunu önlemek için pytorch kütüphanesinden \"to\" fonksiyonunu kullanıyoruz.\n",
        "    test_label = test_label.to(device)\n",
        "\n",
        "    # Attention mask, bir belirtecin gercek bir kelimemi yoksa dolgu mu olduğunu tanımlar.\n",
        "    # Eğer gerçek bir kelime ise attention_mask=1, eğer dolgu ise attention_mask=0 olacaktır.\n",
        "    mask = test_input['attention_mask'].to(device)\n",
        "    # squeeze() fonksiyonu ile \"input_ids\" özelliğindeki tensörlerin boyutu 1 olan boyutları\n",
        "    # kaldırarak, tensörün boyutunu azaltıyoruz.\n",
        "    input_id = test_input['input_ids'].squeeze(1).to(device)\n",
        "\n",
        "    # Modelin eğitim verileri üzerindeki tahminlerinin sonuçları saklanır.\n",
        "    output = model(input_id, mask)\n",
        "\n",
        "    # \"output\" değişkenindeki her bir veri örneği için çıktı tensöründe en yüksek olasılığa sahip\n",
        "    # sınıfın indexini döndürür. Daha sonra \"test_label\" adlı tensörde modein doğru sınıf tahmilnerinin\n",
        "    # bulunduğu etiketleri saklanır. Doğru tahmin edilen sınıfların sayısı hesaplanır ve \"item\"\n",
        "    # fonksiyonu ile sayısal bir değere dönüştürülür.\n",
        "    test_accuracy = (output.argmax(dim=1) == test_label).sum().item()\n",
        "    # Her bir epoch için toplam test doğruluğunu bulmak için her bir örneklemin doğruluk kaybını topluyoruz.\n",
        "    total_test_accuracy += test_accuracy\n",
        "\n",
        "# Test Dogruluğu\n",
        "print(f'Test Accuracy: {total_test_accuracy / len(tdl): .3f}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SoXrfcfewIwc",
        "outputId": "a8c38d7b-7964-47d6-e0c7-5cb65f897d6b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Accuracy:  1.849\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Prediction fonksiyonunu tanımladık.\n",
        "def predict(model, sentence):\n",
        "  device = torch.device(\"cuda\")\n",
        "  model = model.cuda()\n",
        "  # Prediction işlemi sırasında model ağırlıklarını değiştirmeyeceğimiz modelin gradyanlara ihtiyacı yoktur\n",
        "  # \"no_grad\" fonksiyonu ile gradyan hesaplarını devre dışı bırakıyoruz.\n",
        "  with torch.no_grad():\n",
        "    # text = Modeli eğitmek için kullanılacak veri setindeki \"clean_text\" sütunundaki her bir satır.\n",
        "    # padding = Her bir diziyi belirttiğimiz maksimum uzunluga kadar doldurmak için.\n",
        "    # max_length = Her bir dizinin maksimum uzunluğu\n",
        "    # truncation = Eğer değeri \"True\" ise dizimiz maksimum uzunluğu aşar ise onu keser.\n",
        "    # return_tensors = Döndürelecek tensörlerin türü. Pytorch kullandığımız için \"pt\" yazıyoruz. Tensorflow kullansaydık \"tf\" yazmamız gerekirdi.\n",
        "    input_id = tokenizer(sentence, padding='max_length', max_length = 512, truncation=True, return_tensors=\"pt\")\n",
        "    \n",
        "    # Attention mask, bir belirtecin gercek bir kelimemi yoksa dolgu mu olduğunu tanımlar.\n",
        "    # Eğer gerçek bir kelime ise attention_mask=1, eğer dolgu ise attention_mask=0 olacaktır.\n",
        "    mask = input_id['attention_mask'].to(device)\n",
        "    \n",
        "    # squeeze() fonksiyonu ile \"input_ids\" özelliğindeki tensörlerin boyutu 1 olan boyutları\n",
        "    # kaldırarak, tensörün boyutunu azaltıyoruz.\n",
        "    input_id = input_id['input_ids'].squeeze(1).to(device)\n",
        "    \n",
        "    # Modelin eğitim verileri üzerindeki tahminlerinin sonuçları saklanır.\n",
        "    output = model(input_id, mask)\n",
        "    \n",
        "    # Kategorik sınıfı döndür.\n",
        "    return output.argmax(dim=1).item() "
      ],
      "metadata": {
        "id": "W1HEnB56Ochs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import classification_report\n",
        "\n",
        "# Her bir dizi için tahmin yapılır\n",
        "actuals = df_test.labels\n",
        "predicted = [predict(model, df_test.clean_text.iloc[i]) for i in range(len(df_test.clean_text))]\n",
        "\n",
        "print(classification_report(actuals, predicted))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dd1vW1wGMrp1",
        "outputId": "2bcb68a8-ce5e-4660-ad00-ee52d884afc8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.92      0.94      0.93      5699\n",
            "           1       0.93      0.91      0.92      4902\n",
            "\n",
            "    accuracy                           0.93     10601\n",
            "   macro avg       0.93      0.92      0.92     10601\n",
            "weighted avg       0.93      0.93      0.93     10601\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "predict(model, \"ya olum skerim anaıo\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4tUlbpOYOWae",
        "outputId": "3b5451fd-7f15-49e1-fa5a-4d1c8b9699f2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 132
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import itertools\n",
        "from sklearn.metrics import confusion_matrix\n",
        "\n",
        "def plot_confusion_matrix(predicted, actuals, sub_classes, title='Confusion matrix', cmap=plt.cm.Blues):\n",
        "    # Confusion Matrix oluştur.\n",
        "    confusion = confusion_matrix(predicted, actuals)\n",
        "\n",
        "    # interpolation -> Grafikte kullanılacak renklerin aralığı\n",
        "    # cmap -> Grafikte kullanılacak renk\n",
        "    plt.imshow(confusion, interpolation='nearest', cmap=cmap)\n",
        "    plt.title(title)\n",
        "    plt.colorbar()\n",
        "    # Alt sınıfların sayısına göre bir numpy dizisi oluşturduk.\n",
        "    # Bu diziyi sınıf etiketlerinin eksenlerdeki konumlarını belirlemek için kullanacağız.\n",
        "    tick_marks = np.arange(len(sub_classes))\n",
        "    # rotation -> X ekseni işaretleyicilerinin açısı\n",
        "    plt.xticks(tick_marks, sub_classes, rotation=90)\n",
        "    plt.yticks(tick_marks, sub_classes)\n",
        "\n",
        "    for i, j in itertools.product(range(confusion.shape[0]), range(confusion.shape[1])):\n",
        "        # horizontalalignment, yazılacak sayısal değerin hücre ortasında yer almasını sağlar.\n",
        "        # color, yazı rengini belirler.\n",
        "        # j -> x koordinatı\n",
        "        # i -> y koordinatı\n",
        "        # confusion[i, j] -> yazılacak sayısal değer\n",
        "        plt.text(j, i, confusion[i, j], horizontalalignment=\"center\", color=\"black\")\n",
        "\n",
        "    # Figür boyutu\n",
        "    plt.rcParams[\"figure.figsize\"] = (15,5)\n",
        "    # y Ekseni adı\n",
        "    plt.ylabel('Actuals')\n",
        "    # x Ekseni adı\n",
        "    plt.xlabel('Predicted')\n",
        "    #plt.savefig(\"cm_matrix.png\")\n",
        "    plt.show()\n",
        "    \n",
        "plot_confusion_matrix(predicted, actuals, sub_classes=le_nm.keys())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 482
        },
        "id": "Mr5pWQolQNMU",
        "outputId": "20cf4cfd-5f56-43fc-bfb4-b443a7a6b8e7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1500x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')\n",
        "\n",
        "# Modelimize isim vererek Drive'a kaydettik.\n",
        "model_name = \"tubitak2.pt\"\n",
        "path = F\"/content/gdrive/My Drive/{model_name}\"\n",
        "\n",
        "torch.save(model.state_dict(), path)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "63PtrJHbQQuu",
        "outputId": "c136b51a-1d50-433e-b4b4-cda07c7cf881"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/gdrive; to attempt to forcibly remount, call drive.mount(\"/content/gdrive\", force_remount=True).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "vJcEwTAp5rpI"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}