6_Задача_NLP.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "6. Задача_NLP.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/kkattt51/ArtInt/blob/main/6_%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_NLP.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X2Mhe-AueOVW"
      },
      "source": [
        "## Задача классификации твитов: обучаем рекурентную нейронную сеть на GPU"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JOWI6wLQhN4b"
      },
      "source": [
        "<font size=2 color=grey> Вдохновлено семинарами по NLP Максима Рябина из BigData Team https://bigdatateam.org/ru"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EmFA8OwieTue"
      },
      "source": [
        "В данном ноутбуке приводится простой пример, как создать неплохую модель классификации твитов с помощью нейронных сетей в фреймворке PyTorch. Внеся всего несколько изменений в первую модель машинного обучения (`Моя первая модель.ipynb`), мы перейдем от задачи регрессии к задаче классификации, и от простой линейной регрессии к целой нейронной сети!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-g5QwEkJeTw-"
      },
      "source": [
        "Также мы увидим, насколько гибкими являются алгоритмы машинного обучения, и что они могут быть адаптированы для таких сложно формализуемых задач как работа с текстом. При этом единственное, что нужно, это создать словарь вида \"слово\" - \"числовой индекс\" и закодировать им последовательность токенов (слов и знаков препинания): например, \n",
        "\n",
        "$$\"\\text{Мама мыла раму, видишь}\" как \\text{ } [5, 2, 4, 3, 1]$$\n",
        "\n",
        "При этом наша модель сама научится искать взаимосвязи между словами и даже понимать некоторую семантику (смысл)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Drql_ZxKemFX"
      },
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "from sklearn.feature_extraction.text import TfidfVectorizer\n",
        "from sklearn.model_selection import train_test_split\n",
        "from nltk.tokenize import TweetTokenizer\n",
        "\n",
        "from sklearn.metrics import roc_auc_score, roc_curve, accuracy_score\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "from IPython import display\n",
        "%matplotlib inline"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RMOcCkMzeTzg"
      },
      "source": [
        "### <font color=green> Импортирование данных"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pjz804eke0nv"
      },
      "source": [
        "Качаем общедоступные данные для задачи классификации токсичных твитов. Выборка представляет собой набор текстов на английском языке и метки классов для различных задач. Нас интересует задача по классификации текстов на \"токсичный\" или \"нет\", поэтому будем использовать метку `toxic`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YJC9oc_GeLj-"
      },
      "source": [
        "!wget -q -nc https://raw.githubusercontent.com/tianqwang/Toxic-Comment-Classification-Challenge/master/data/train.csv"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zhA54KpSeb3A"
      },
      "source": [
        "kaggle_data = pd.read_csv(\"train.csv\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 111
        },
        "id": "plnamxGEf4ZP",
        "outputId": "d6560e67-6bdd-4959-abf7-17929918e8c9"
      },
      "source": [
        "kaggle_data.head(2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>id</th>\n",
              "      <th>comment_text</th>\n",
              "      <th>toxic</th>\n",
              "      <th>severe_toxic</th>\n",
              "      <th>obscene</th>\n",
              "      <th>threat</th>\n",
              "      <th>insult</th>\n",
              "      <th>identity_hate</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0000997932d777bf</td>\n",
              "      <td>Explanation\\nWhy the edits made under my usern...</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>000103f0d9cfb60f</td>\n",
              "      <td>D'aww! He matches this background colour I'm s...</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                 id  ... identity_hate\n",
              "0  0000997932d777bf  ...             0\n",
              "1  000103f0d9cfb60f  ...             0\n",
              "\n",
              "[2 rows x 8 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ngfWUrs1f15o"
      },
      "source": [
        "### <font color=green> Токенизация текстов"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gAuIE7wLgMta"
      },
      "source": [
        "Как писалось выше, нужно создать словарь слов и сопоставить словам какие-то числа, а затем \"закодировать\" последовательность токенов в тексте этими числами. Чтобы это сделать нужно сперва перевести каждый цельный текст в последовательность отдельных слов. Будем использовать `nltk.tokenize.TweetTokenizer`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xDVRolPRgpVD",
        "outputId": "df13e2b1-1a72-47cd-cb4a-be7b932b40b9"
      },
      "source": [
        "tokenizer = TweetTokenizer()\n",
        "preprocess = lambda text: ' '.join(tokenizer.tokenize(text.lower()))\n",
        "\n",
        "text = \"It's the lecture for Russian Programming School!\"\n",
        "print(\"До токенизации:\", text,)\n",
        "print(\"После токенизации:\", preprocess(text))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "До токенизации: It's the lecture for Russian Programming School!\n",
            "После токенизации: it's the lecture for russian programming school !\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i6YP9_RmiEnj"
      },
      "source": [
        "Отделяем целевую метку классов от текстов и формируем списки текстов и их меток после токенизации"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fo97ME60h9qT",
        "outputId": "1826b3ff-e421-4e99-ed2d-60c0d8b2cf93"
      },
      "source": [
        "%%time\n",
        "texts = kaggle_data['comment_text']\n",
        "target = kaggle_data['toxic']\n",
        "\n",
        "texts_train, texts_test, y_train, y_test = train_test_split(texts, target, test_size=1000, random_state=42)\n",
        "\n",
        "texts_train = [preprocess(text) for text in texts_train.tolist()]\n",
        "texts_test = [preprocess(text) for text in texts_test.tolist()]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 29 s, sys: 172 ms, total: 29.2 s\n",
            "Wall time: 29.2 s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "70g8brtlitps"
      },
      "source": [
        "### <font color=green> Определение словаря"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oG-ydkEZi1w8"
      },
      "source": [
        "Т.к. фреймворк `PyTorch`, реализующий удобный инструмент обучения нейронных сетей, не обрабатывает каждый конкретный текст отдельно, а сразу вместе, то требуется, чтобы тексты были одинаковой длины. Но к сожалению, в природе тексты встречаются  разной длины, поэтому придется \"выровнять\" последовательности токенов, добавив токен `<PAD>` к слишком коротким последовательностям. Кроме того, нужно научить модель работать со словами, которые ей не знакомы, для этого вводится ещё один специальный токен `<UNK>`, который будет всегда вставать на место того слова, которое не знакомо модели. Добавляем эти два токена в словарь. Будем формировать словарь с помощью инструмента `sklearn.feature_extraction.text.TfidfVectorizer`, который не только умеет считать tf-idf, но и формировать словари."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VoPjlZNOkCjd",
        "outputId": "23269d1a-6371-4c6f-ad40-b122646e4610"
      },
      "source": [
        "%%time\n",
        "# создаю инстанс класса векторайзера\n",
        "tfidf=TfidfVectorizer()\n",
        "# скармливаю в него обучающую выборку\n",
        "tfidf.fit(texts_train)\n",
        "\n",
        "# забираю сформированный словарь\n",
        "vocab=['<PAD>', '<UNK>']+list(tfidf.vocabulary_.keys())\n",
        "token_to_index={token:i for i, token in enumerate(vocab)}"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 9.57 s, sys: 207 ms, total: 9.78 s\n",
            "Wall time: 9.78 s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qWmKf9U2lhqu"
      },
      "source": [
        "Немного магии: фреймворк `PyTorch` работает не с обычными питоновскими типами данных, а со своим собственным - `torch.tensors`. Класс ниже подготавливает выборку в формате пригодными для `PyTorch`, кодируя последовательности индексами из словаря и создавая тензоры"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A4ce37PYl5LP"
      },
      "source": [
        "class Dataset(torch.utils.data.Dataset):\n",
        "  def __init__(self, texts, labels, vocab):\n",
        "    self.text_tensors=[]\n",
        "    self.labels=[]\n",
        "\n",
        "    for text, label in zip(texts, labels):\n",
        "      indices = [token_to_index.get(token, 1) for token in text.split()]\n",
        "\n",
        "      self.text_tensors.append(torch.tensor(indices,dtype=torch.long))\n",
        "      self.labels.append(label)\n",
        "\n",
        "    self.lengths=[tensor.size(0) for tensor in self.text_tensors]\n",
        "\n",
        "  def __len__(self):\n",
        "    return len(self.text_tensors)\n",
        "\n",
        "  def __getitem__(self, idx):\n",
        "    return self.text_tensors[idx], self.lengths[idx], self.labels[idx]\n",
        "\n",
        "train_dataset=Dataset(texts_train, y_train.values, vocab)\n",
        "test_dataset=Dataset(texts_test, y_test.values, vocab)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5DjgC3I7l9z1",
        "outputId": "cfb248bd-cdfc-4b89-fdb9-c6387d900f11"
      },
      "source": [
        "def collate_fn(samples):\n",
        "  text_tensors=[]\n",
        "  lengths=[]\n",
        "  labels=[]\n",
        "\n",
        "  for text_tensor, length, label in samples:\n",
        "    text_tensors.append(text_tensor)\n",
        "    lengths.append(length)\n",
        "    labels.append(label)\n",
        "\n",
        "  padded_tensors = nn.utils.rnn.pad_sequence(text_tensors, padding_value=0, batch_first=True)\n",
        "\n",
        "  return padded_tensors, torch.tensor(lengths), torch.tensor(labels, dtype=torch.float)\n",
        "\n",
        "train_loader=torch.utils.data.DataLoader(train_dataset, batch_size=512, shuffle=True, collate_fn=collate_fn, num_workers=4)\n",
        "test_loader=torch.utils.data.DataLoader(test_dataset, batch_size=512, shuffle=False, collate_fn=collate_fn, num_workers=4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:477: 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",
            "  cpuset_checked))\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kfzw0_vlmf9Q"
      },
      "source": [
        "### <font color=green> Задание модели и обучение"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a8EJ1X6KmqNY"
      },
      "source": [
        "Мы подготовили данные, теперь самое время описать модель, функцию потерь, и провести обучение, оптимизируя функцию потерь, по полной аналогии с тем, как мы это делали с первой моделью регрессии, за исключением того, что теперь в качестве данных у нас тексты и предсказываем мы не непрерывную величину, а метку класса (либо токсичный твит, либо нет), а для этого мы на линейную модель сверху накинули функцию активации:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9D41EbfYoDWZ"
      },
      "source": [
        "Функция активации принимает в себя выход линейного слоя и затем преобразует значение в число от 0 до 1, которое можно интерпретировать как вероятность токсичности твита, если он токсичный, то (правильное) предсказание модели будет стремиться к единице, если нет - к нулю"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lZljnjX0nrtB"
      },
      "source": [
        "![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z5fI9huRquj0"
      },
      "source": [
        "<font color=red size=6>!</font> <font color=red> Чтобы обучать модель на видео-карте, нужно предварительно подцепить её во вкладке `Среда выполнения/Сменить среду выполнения/GPU` в меню Колаба"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h8bNGqayrlg9",
        "outputId": "a4e2443a-d5b9-419c-91f8-da2837a751ac"
      },
      "source": [
        "!nvidia-smi"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mon May 17 14:28:55 2021       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 465.19.01    Driver Version: 460.32.03    CUDA Version: 11.2     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla K80           Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   43C    P8    31W / 149W |      0MiB / 11441MiB |      0%      Default |\n",
            "|                               |                      |                  N/A |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w3Nv2DTtqlPC",
        "outputId": "d799df07-b3c5-42aa-ef2a-1b8f9c5a5d46"
      },
      "source": [
        "# мы будем обучать модель на видеокарте, укажем эту опцию\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "print('Модель обучается на', device)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Модель обучается на cuda\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "unijz08pmBiX",
        "outputId": "1d31146d-4e7a-42aa-b788-5b75e1d22190"
      },
      "source": [
        "# описываю модель\n",
        "class RNNClassifier(torch.nn.Module):\n",
        "  def __init__(self, vocab_size, embedding_dim, hidden_dim):\n",
        "    super().__init__()\n",
        "    self.embedding=nn.Embedding(vocab_size, embedding_dim, padding_idx=0) # параметры (num_embeddings, embedding_dim) и индекс, которым\n",
        "    # небольшое дополнение к знакомой структуре модели:\n",
        "    # перед линейным слоем будет стоять рекурентный блок, который прогоняет через себя текст\n",
        "    # и аккумулирует \"смысл\" текста\n",
        "    self.rnn=nn.GRU(embedding_dim,hidden_dim,num_layers=1,batch_first=True)\n",
        "    self.classifier=nn.Linear(hidden_dim, 1)\n",
        "\n",
        "  def forward(self, inputs, lengths):\n",
        "    embeddings=self.embedding(inputs)\n",
        "    packed_inputs=nn.utils.rnn.pack_padded_sequence(embeddings,lengths,\n",
        "                                        batch_first=True,enforce_sorted=False)\n",
        "    outputs, final_hiddens = self.rnn(packed_inputs)\n",
        "    return self.classifier(final_hiddens.view(inputs.size(0),-1))\n",
        "\n",
        "# создаю экземпляр модели\n",
        "rnn_model=RNNClassifier(len(vocab),32,32)\n",
        "\n",
        "# отправлю модель на GPU (видео-карту)\n",
        "rnn_model.to(device)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "RNNClassifier(\n",
              "  (embedding): Embedding(187367, 32, padding_idx=0)\n",
              "  (rnn): GRU(32, 32, batch_first=True)\n",
              "  (classifier): Linear(in_features=32, out_features=1, bias=True)\n",
              ")"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hOnSoWg_pPve"
      },
      "source": [
        "Определяю функцию потерь: это будет логлосс - специальная функция потерь, разработанная для бинарной классификации, она наказывает модель, если та ошибается в своем прогнозе"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5XJ0LN59mLwP"
      },
      "source": [
        "criterion = nn.BCEWithLogitsLoss()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oxnAAC7vp0E4"
      },
      "source": [
        "Определяю оптимизатор - функцию которая будет делать шаги в сторону минимума функции потерь (логлосса). Будем использовать ту же самую вариацию `Adam`, что и в ноутбуке по предсказанию цены дома с помощью линейной регресии"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t7LZ94SGp0Ni"
      },
      "source": [
        "optimizer=torch.optim.Adam(rnn_model.parameters(), lr=1e-2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MQH4h_z5mLy3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 367
        },
        "outputId": "a52f3ef9-6778-47ae-e626-a743cc591696"
      },
      "source": [
        "%%time\n",
        "torch.manual_seed(0)\n",
        "\n",
        "NUM_EPOCHS=1\n",
        "loss_history=[]\n",
        "\n",
        "rnn_model.train()\n",
        "for _ in range(NUM_EPOCHS):\n",
        "  for batch_tokens, batch_lengths, batch_labels in train_loader:\n",
        "    batch_tokens=batch_tokens.to(device)\n",
        "    batch_labels=batch_labels.to(device).view(-1,1)\n",
        "\n",
        "    output=rnn_model(batch_tokens, batch_lengths)\n",
        "    loss=criterion(output, batch_labels)\n",
        "    \n",
        "    optimizer.zero_grad()\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "    loss_history.append(loss.item())\n",
        "\n",
        "plt.plot(loss_history)\n",
        "plt.xlabel('Training iteration')\n",
        "plt.ylabel('Loss')\n",
        "plt.grid()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:477: 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",
            "  cpuset_checked))\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "CPU times: user 37.6 s, sys: 10.2 s, total: 47.8 s\n",
            "Wall time: 48.9 s\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RdVbtvMcvLP6"
      },
      "source": [
        "Модель обучилась, можно посмотреть качество предсказания токсичности твита на тестовой выборке"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ObCT7CHImL13",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 387
        },
        "outputId": "c4abd256-a0b5-494e-bed5-50e020de7e6d"
      },
      "source": [
        "rnn_model.eval()\n",
        "\n",
        "for name, loader in [\n",
        "    ('train', train_loader),\n",
        "    ('test ', test_loader)\n",
        "]:\n",
        "    all_preds=[]\n",
        "    all_labels=[]\n",
        "    for batch_tokens, batch_lengths, batch_labels in loader:\n",
        "      batch_tokens=batch_tokens.to(device)\n",
        "\n",
        "      with torch.no_grad():\n",
        "        class_probs=torch.sigmoid(rnn_model(batch_tokens, batch_lengths))\n",
        "        all_preds.extend(class_probs.cpu().numpy())\n",
        "        all_labels.extend(batch_labels.cpu().numpy())\n",
        "\n",
        "    auc = roc_auc_score(all_labels, all_preds)\n",
        "    accuracy = accuracy_score(all_labels, [1 if x>0.5 else 0 for x in all_preds])\n",
        "    print('Accuracy на ', name, accuracy)\n",
        "    plt.plot(*roc_curve(all_labels, all_preds)[:2], label='%s AUC=%.4f' % (name, auc))\n",
        "\n",
        "plt.plot([0, 1], [0, 1], '--', color='black',)\n",
        "plt.legend(fontsize='large')\n",
        "plt.grid()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:477: 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",
            "  cpuset_checked))\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Accuracy на  train 0.9686638792717458\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:477: 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",
            "  cpuset_checked))\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Accuracy на  test  0.955\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CHU5H_-KxdHM"
      },
      "source": [
        "Получили хороший результат - модель правильно обработала 95% тестовых твитов, предсказав верную метку (см. метрику Accuracy). При этом модель не просто неплохо предсказывает токсичность, как таковую, но и умеетнеплохо ранжировать твиты от \"наиболее токсичных\" к \"менее токсичным\", проставляю маленькую вероятность \"токсичности\" хорошим твитам и высокую вероятность плохим.\n",
        "\n",
        "В домашнем задании вам предстоит построить модель на признаках [Tf-Idf](https://ru.wikipedia.org/wiki/TF-IDF) и сравнить её качество с полученной нами нейросетевой"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o5BMPu6OmL4D"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}