StackOverflow Questions Quality.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Лабораторная работа по курсу NLP. Классификация вопросов Stackoverflow\n",
    "## Репин Владимир 382006-3м"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Загрузка и анализ данных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import sklearn\n",
    "import numpy as np  \n",
    "import seaborn as sns \n",
    "import gensim\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from gensim.models import Word2Vec, KeyedVectors\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.linear_model import PassiveAggressiveClassifier\n",
    "from sklearn.ensemble import AdaBoostClassifier, VotingClassifier\n",
    "import nltk\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "import torch.optim as optim\n",
    "from tqdm import tqdm, tqdm_notebook\n",
    "\n",
    "sns.set_theme()\n",
    "sns.set_style(\"whitegrid\")\n",
    "sns.set_palette(\"tab10\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_parquet('train.parquet') #https://www.kaggle.com/datasets/imoore/60k-stack-overflow-questions-with-quality-rate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим на размер датасета и число признаков."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(48000, 4)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Кажется, что нет большого смысла разделять текстовые признаки и обрабатывать их можно все вместе целиком. Особенно это касатеся заголовка + тела вопроса, но на самом деле отдельно обрабатывать теги и делать OHE тоже не удастся, потому что уникальных тегов около 7000, как можно будет увидеть ниже."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['total'] = data['Title'] + data['Body'] + data['Tags']\n",
    "data['length'] = data['Body'].str.len()\n",
    "data['total'] = data['total'].str.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Датасет идеально сбалансирован, данные по классам распределены поровну с точностью до единицы."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.histplot(x='target',data=data)\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Выше было добавлен признак \"Длина вопроса\", тут было интересно посмотреть как длина вопроса влияет на его статус. Определенно, более длинные запросы оцениваются положительно чаще."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.histplot(x='length',hue='target',data=data, binrange=[0, 3000], palette='tab10')\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Просто небольшой sanity-check перед дальнейшей работой на предмет того, как выглядит датасет."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Body</th>\n",
       "      <th>Tags</th>\n",
       "      <th>Title</th>\n",
       "      <th>target</th>\n",
       "      <th>total</th>\n",
       "      <th>length</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Id</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>34862324</th>\n",
       "      <td>Algorithmm:\\r\\n\\r\\n**input :** Graph G\\r\\n\\r\\n...</td>\n",
       "      <td>&lt;java&gt;&lt;algorithm&gt;&lt;graph-algorithm&gt;</td>\n",
       "      <td>I am implementing a Minimum Spanning Forrest a...</td>\n",
       "      <td>2</td>\n",
       "      <td>i am implementing a minimum spanning forrest a...</td>\n",
       "      <td>564</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>47303682</th>\n",
       "      <td>While converting the data frame to HTML, Date ...</td>\n",
       "      <td>&lt;html&gt;&lt;r&gt;&lt;dataframe&gt;</td>\n",
       "      <td>R Studio: Date is getting converted to number,...</td>\n",
       "      <td>2</td>\n",
       "      <td>r studio: date is getting converted to number,...</td>\n",
       "      <td>109</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>46431243</th>\n",
       "      <td>&lt;p&gt;This should be an easy one, but somehow I c...</td>\n",
       "      <td>&lt;python&gt;&lt;pandas&gt;&lt;dataframe&gt;&lt;pandas-groupby&gt;</td>\n",
       "      <td>Pandas - dataframe groupby - how to get sum of...</td>\n",
       "      <td>0</td>\n",
       "      <td>pandas - dataframe groupby - how to get sum of...</td>\n",
       "      <td>1365</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>45306324</th>\n",
       "      <td>&lt;p&gt;Let say I have a component in Angular 2 tha...</td>\n",
       "      <td>&lt;angular&gt;&lt;typescript&gt;&lt;rxjs&gt;</td>\n",
       "      <td>Casting results from Observable.forkJoin to th...</td>\n",
       "      <td>0</td>\n",
       "      <td>casting results from observable.forkjoin to th...</td>\n",
       "      <td>1721</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49479547</th>\n",
       "      <td>&lt;p&gt;I'm setting a var using \\n&lt;code&gt;set TEST_VA...</td>\n",
       "      <td>&lt;c&gt;&lt;windows&gt;&lt;batch-file&gt;</td>\n",
       "      <td>Environment variable set in batch file cannot ...</td>\n",
       "      <td>1</td>\n",
       "      <td>environment variable set in batch file cannot ...</td>\n",
       "      <td>165</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                       Body  \\\n",
       "Id                                                            \n",
       "34862324  Algorithmm:\\r\\n\\r\\n**input :** Graph G\\r\\n\\r\\n...   \n",
       "47303682  While converting the data frame to HTML, Date ...   \n",
       "46431243  <p>This should be an easy one, but somehow I c...   \n",
       "45306324  <p>Let say I have a component in Angular 2 tha...   \n",
       "49479547  <p>I'm setting a var using \\n<code>set TEST_VA...   \n",
       "\n",
       "                                                 Tags  \\\n",
       "Id                                                      \n",
       "34862324           <java><algorithm><graph-algorithm>   \n",
       "47303682                         <html><r><dataframe>   \n",
       "46431243  <python><pandas><dataframe><pandas-groupby>   \n",
       "45306324                  <angular><typescript><rxjs>   \n",
       "49479547                     <c><windows><batch-file>   \n",
       "\n",
       "                                                      Title  target  \\\n",
       "Id                                                                    \n",
       "34862324  I am implementing a Minimum Spanning Forrest a...       2   \n",
       "47303682  R Studio: Date is getting converted to number,...       2   \n",
       "46431243  Pandas - dataframe groupby - how to get sum of...       0   \n",
       "45306324  Casting results from Observable.forkJoin to th...       0   \n",
       "49479547  Environment variable set in batch file cannot ...       1   \n",
       "\n",
       "                                                      total  length  \n",
       "Id                                                                   \n",
       "34862324  i am implementing a minimum spanning forrest a...     564  \n",
       "47303682  r studio: date is getting converted to number,...     109  \n",
       "46431243  pandas - dataframe groupby - how to get sum of...    1365  \n",
       "45306324  casting results from observable.forkjoin to th...    1721  \n",
       "49479547  environment variable set in batch file cannot ...     165  "
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classic Machine Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В разделе собраны только лучшие попытки применения ML, перепробовано было довольно много разных вещей, но в виде \"наброска\", без сохранения результатов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_train, data_val = train_test_split(data, test_size=0.05, random_state = 666, stratify = data['target'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Одна из таких идей, которые пришли в самом конце - пунктуацию и разметки лучше не удалять, их наличие по идее сильно должно радовать отвечающих на вопрос. Поэтому используется токенизатор из nltk, который всё это сохраняет. Используется он в составе Bag-of-Words векторизатора."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "bow_vectorizer = CountVectorizer(analyzer='word',tokenizer=nltk.word_tokenize)\n",
    "train_vec = bow_vectorizer.fit_transform(data_train[\"total\"])\n",
    "val_vec = bow_vectorizer.transform(data_val[\"total\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В общем и целом модель линейной регрессии даёт на этой задаче лучшие результаты, чем другие модели, причём с большим отрывом.\n",
    "Сразу как данный факт был обнаружен, также было и замечено, что последний класс (заминусованные, но не закрытые вопросы) предсказывается почти идеально и пришла идея его отбросить и рассматривать задачу бинарной классификации."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.86625 0.13125 0.0025 ]\n",
      " [0.1025  0.88625 0.01125]\n",
      " [0.0025  0.0025  0.995  ]]\n",
      "0.9156750137893969\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Soft\\Anaconda\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:762: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    }
   ],
   "source": [
    "clf = LogisticRegression(max_iter=500)\n",
    "clf.fit(train_vec, data_train['target'])\n",
    "y_pr = clf.predict(val_vec)\n",
    "print(confusion_matrix(data_val['target'],y_pr,normalize='true'))\n",
    "print(f1_score(data_val['target'],y_pr,average='macro'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Тут как раз это и происходит, создаётся новый подсет, который в дальнейшем везде будет использоваться, где класс с лейблом 2 выброшен из рассмотрения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_exp = data_train.drop(data_train[data_train['target'] == 2].index)\n",
    "tfidf_vectorizer = TfidfVectorizer(analyzer='word',tokenizer=nltk.word_tokenize)\n",
    "train_vec_exp = tfidf_vectorizer.fit_transform(data_exp[\"total\"])\n",
    "val_vec_exp = tfidf_vectorizer.transform(data_val[\"total\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Тут как раз получилось так, что до токенизации с сохранением символов подход ниже давал существенное улучшение результата, используется ансамбль классификаторов, показавших приемлемые результаты. И уже намного позже оказалось, что сохранения пунктуации для простой линейной регрессии достаточно."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.8825  0.115   0.0025 ]\n",
      " [0.11875 0.87    0.01125]\n",
      " [0.0025  0.0025  0.995  ]]\n",
      "0.915661981436394\n"
     ]
    }
   ],
   "source": [
    "clf1 = LogisticRegression(max_iter = 300)\n",
    "clf2 = PassiveAggressiveClassifier(C=0.01,max_iter=5000)\n",
    "clf3 = AdaBoostClassifier(n_estimators=70)\n",
    "clf_exp = VotingClassifier(estimators=[('lr', clf1),('pac',clf2),('ab',clf3)], voting='hard')\n",
    "clf_exp = clf_exp.fit(train_vec_exp, data_exp['target'])\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "y_pr_exp = clf_exp.predict(val_vec_exp)\n",
    "final = [i if i == 2 else j for i,j in zip(y_pr,y_pr_exp)]\n",
    "print(confusion_matrix(data_val['target'],final,normalize='true'))\n",
    "print(f1_score(data_val['target'],final,average='macro'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Далее был попробован эмбеддинг Word2Vec также с классическим МЛ. Предобученная модель, очень удобно натренированная на сете stackoverflow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "w2v_model = KeyedVectors.load_word2vec_format('SO_vectors_200.bin', binary=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "vectorizer = TfidfVectorizer(stop_words='english',use_idf=True)\n",
    "tokenizer = vectorizer.build_tokenizer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['raw_tokens'] = data['total'].apply(tokenizer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def w2vectorizer(tokens):\n",
    "    tmp = []\n",
    "    for w in tokens:\n",
    "        if w in w2v_model.key_to_index:\n",
    "            tmp.append(w2v_model[w])\n",
    "    return np.mean(tmp,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from nltk.corpus import stopwords\n",
    "stop = stopwords.words('english')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "И тогда как в векторизациях выше от различных слов текст я не очищал, то тут убрана и пунктуация и стоп-слова, получившийся набор токенов далее векторизуется взятием среднего от векторов всех слов. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Использовался не только этот наивный подход. Изначально идея была такой: разбить текст на предложения, для каждого предложения брать взвешенное среднее по векторам слов, где весом выступал Inverse Document Frequency слова. Казалось, что так можно уменьшить влияние часто встречаемых слов и улучшить векторизацию. Число предложений, конечно, должно было стать одинаковым, поэтому брался 99 процентиль, это всего 16 предложений, а чего не хватало - заполнялось нулевыми векторами. К сожалению, этот подход дал результат крайне ниже ожидаемого (что-то вроде 0.6 fscore для линейной регрессии, которая уже тогда считалась собственным baseline). Времени было потрачено много, а код решено было убрать вовсе."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Id\n",
       "34862324    [implementing, minimum, spanning, forrest, alg...\n",
       "47303682    [studio, date, getting, converted, number, mak...\n",
       "46431243    [pandas, dataframe, groupby, get, sum, multipl...\n",
       "45306324    [casting, results, observable, forkjoin, respe...\n",
       "49479547    [environment, variable, set, batch, file, cann...\n",
       "                                  ...                        \n",
       "35488105    [textbox, user, control, displaying, date, dd,...\n",
       "37045803    [something, based, image, detection, making, p...\n",
       "43601747    [kafkaproducer, difference, callback, returned...\n",
       "40505904    [way, make, github, un, approve, pull, request...\n",
       "40415937    [delete, two, array, objects, tableview, ios, ...\n",
       "Name: raw_tokens, Length: 48000, dtype: object"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data['raw_tokens'].apply(lambda x: [item for item in x if item not in stop])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "data['vect'] = data['raw_tokens'].apply(w2vectorizer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_train_u, data_val_u = train_test_split(data, test_size=0.05, random_state = 666, stratify = data['target'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_train_ = np.stack(data_train_u['vect'].to_numpy())\n",
    "data_val_ = np.stack(data_val_u['vect'].to_numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Soft\\Anaconda\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:762: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.875   0.0875  0.0375 ]\n",
      " [0.23375 0.56125 0.205  ]\n",
      " [0.08875 0.11875 0.7925 ]]\n",
      "0.7367690239315285\n"
     ]
    }
   ],
   "source": [
    "clf1 = LogisticRegression(max_iter = 300)\n",
    "clf2 = PassiveAggressiveClassifier(C=0.01,max_iter=5000)\n",
    "clf3 = AdaBoostClassifier(n_estimators=70)\n",
    "clf_exp_ = VotingClassifier(estimators=[('lr', clf1),('pac',clf2),('ab',clf3)], voting='hard')\n",
    "clf_exp_ = clf_exp_.fit(data_train_, data_train_u['target'])\n",
    "\n",
    "y_pr = clf_exp_.predict(data_val_)\n",
    "print(confusion_matrix(data_val_u['target'],y_pr,normalize='true'))\n",
    "print(f1_score(data_val_u['target'],y_pr,average='macro'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видно, наивный подход хоть и лучше озвученного выше, но всё равно плох. Скорее всего это связано с потерей кучи информации о качестве вопроса по разметке и пунктуации. Но в модели word2vec её не выразить."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_train_nn, data_val_nn = train_test_split(data_exp, test_size=0.05, random_state = 666, stratify = data_exp['target'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using cuda device\n"
     ]
    }
   ],
   "source": [
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "print(f'Using {device} device')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для нейросети сразу было решено натренировать свой эмбеддинг, это казалось более приемлемым, позволяло сохранить пунктуацию и локальные для данной модели вещи."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Датасет обрабатывается классом ниже, для представления в модель pytorch, это один из двух видов, второй - итератор. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Sequences(Dataset):\n",
    "    def __init__(self, path, max_seq_len):\n",
    "        self.max_seq_len = max_seq_len\n",
    "        df = path\n",
    "        \n",
    "        vectorizer = CountVectorizer(stop_words='english', min_df=0.015,tokenizer=nltk.word_tokenize)\n",
    "        vectorizer.fit(df['total'].tolist())\n",
    "        \n",
    "        self.token2idx = vectorizer.vocabulary_\n",
    "        \n",
    "        self.token2idx['<PAD>'] = max(self.token2idx.values()) + 1\n",
    "\n",
    "        tokenizer = vectorizer.build_analyzer()\n",
    "        self.encode = lambda x: [self.token2idx[token] for token in tokenizer(x)\n",
    "                                 if token in self.token2idx]\n",
    "        self.pad = lambda x: x + (max_seq_len - len(x)) * [self.token2idx['<PAD>']]\n",
    "        \n",
    "        sequences = [self.encode(sequence)[:max_seq_len] for sequence in df['total'].tolist()]\n",
    "        sequences, self.labels = zip(*[(sequence, label) for sequence, label\n",
    "                                    in zip(sequences, df['target'].tolist()) if sequence])\n",
    "        self.sequences = [self.pad(sequence) for sequence in sequences]\n",
    "\n",
    "    def __getitem__(self, i):\n",
    "        assert len(self.sequences[i]) == self.max_seq_len\n",
    "        return self.sequences[i], self.labels[i]\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.sequences)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Soft\\Anaconda\\lib\\site-packages\\sklearn\\feature_extraction\\text.py:484: UserWarning: The parameter 'token_pattern' will not be used since 'tokenizer' is not None'\n",
      "  warnings.warn(\"The parameter 'token_pattern' will not be used\"\n"
     ]
    }
   ],
   "source": [
    "dataset = Sequences(data_train_nn, max_seq_len=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def collate(batch):\n",
    "    inputs = torch.LongTensor([item[0] for item in batch])\n",
    "    target = torch.FloatTensor([item[1] for item in batch])\n",
    "    return inputs, target\n",
    "\n",
    "batch_size = 200\n",
    "train_loader = DataLoader(dataset, batch_size=batch_size, collate_fn=collate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Решено было попробовать простейшую рекуррентную нейронную сеть с архитектурой LSTM. Это не первое что было сделано, сначала была простая Fully Connected с 3 скрытыми слоями, как раз с подходом к векторизации по предложениям. Там тоже всё было ужасно и тоже не сохранено. Классификация по прежнему бинарная, учитывая достоверную классификацию другого класса."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RNN(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        vocab_size,\n",
    "        batch_size,\n",
    "        embedding_dimension=300,\n",
    "        hidden_size=300, \n",
    "        n_layers=1,\n",
    "        device='cuda'\n",
    "    ):\n",
    "        super(RNN, self).__init__()\n",
    "        self.n_layers = n_layers\n",
    "        self.hidden_size = hidden_size\n",
    "        self.device = device\n",
    "        self.batch_size = batch_size\n",
    "        self.encoder = nn.Embedding(vocab_size, embedding_dimension)\n",
    "        self.rnn = nn.LSTM(\n",
    "            embedding_dimension,\n",
    "            hidden_size,\n",
    "            num_layers=n_layers,\n",
    "            batch_first=True,\n",
    "        )\n",
    "        self.dropout = nn.Dropout(0.15)\n",
    "        self.decoder = nn.Linear(hidden_size, 1)\n",
    "        \n",
    "    def init_hidden(self ):\n",
    "        \n",
    "        return (torch.randn(self.n_layers, self.batch_size, self.hidden_size).to(self.device),\n",
    "                torch.randn(self.n_layers, self.batch_size, self.hidden_size).to(self.device) )\n",
    "       \n",
    "    \n",
    "    def forward(self, inputs):\n",
    "        batch_size = inputs.size(0)\n",
    "        if batch_size != self.batch_size:\n",
    "            self.batch_size = batch_size\n",
    "            \n",
    "        encoded = self.encoder(inputs)\n",
    "        output, hidden = self.rnn(encoded, self.init_hidden())\n",
    "        output = self.dropout(output)\n",
    "        output = self.decoder(output[:, :, -1]).squeeze()\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RNN(\n",
       "  (encoder): Embedding(495, 300)\n",
       "  (rnn): LSTM(300, 300, batch_first=True)\n",
       "  (dropout): Dropout(p=0.15, inplace=False)\n",
       "  (decoder): Linear(in_features=300, out_features=1, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = RNN(\n",
    "    vocab_size=len(dataset.token2idx),\n",
    "    device=device,\n",
    "    batch_size=batch_size\n",
    ")\n",
    "model = model.to(device)\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.BCEWithLogitsLoss()\n",
    "optimizer = optim.Adam([p for p in model.parameters() if p.requires_grad], lr=0.005)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-55-57d28b47c4ff>:4: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
      "  progress_bar = tqdm_notebook(train_loader, leave=False)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #1\tTrain Loss: 0.455\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #2\tTrain Loss: 0.302\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #3\tTrain Loss: 0.266\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #4\tTrain Loss: 0.241\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #5\tTrain Loss: 0.217\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #6\tTrain Loss: 0.193\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #7\tTrain Loss: 0.174\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #8\tTrain Loss: 0.162\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #9\tTrain Loss: 0.158\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #10\tTrain Loss: 0.156\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #11\tTrain Loss: 0.137\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #12\tTrain Loss: 0.128\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #13\tTrain Loss: 0.110\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #14\tTrain Loss: 0.111\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #15\tTrain Loss: 0.113\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #16\tTrain Loss: 0.112\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #17\tTrain Loss: 0.109\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #18\tTrain Loss: 0.104\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #19\tTrain Loss: 0.093\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #20\tTrain Loss: 0.082\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #21\tTrain Loss: 0.090\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #22\tTrain Loss: 0.086\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #23\tTrain Loss: 0.079\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #24\tTrain Loss: 0.084\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(HTML(value=''), FloatProgress(value=0.0, max=145.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch #25\tTrain Loss: 0.093\n"
     ]
    }
   ],
   "source": [
    "model.train()\n",
    "train_losses = []\n",
    "for epoch in range(25):\n",
    "    progress_bar = tqdm_notebook(train_loader, leave=False)\n",
    "    losses = []\n",
    "    total = 0\n",
    "    for inputs, target in progress_bar:\n",
    "        inputs, target = inputs.to(device), target.to(device)\n",
    "        model.zero_grad()\n",
    "        \n",
    "        output = model(inputs)\n",
    "    \n",
    "        loss = criterion(output, target)\n",
    "        \n",
    "        loss.backward()\n",
    "              \n",
    "        nn.utils.clip_grad_norm_(model.parameters(), 3)\n",
    "\n",
    "        optimizer.step()\n",
    "        \n",
    "        progress_bar.set_description(f'Loss: {loss.item():.3f}')\n",
    "        \n",
    "        losses.append(loss.item())\n",
    "        total += 1\n",
    "    \n",
    "    epoch_loss = sum(losses) / total\n",
    "    train_losses.append(epoch_loss)\n",
    "\n",
    "    tqdm.write(f'Epoch #{epoch + 1}\\tTrain Loss: {epoch_loss:.3f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_sentiment(text):\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        test_vector = torch.LongTensor([dataset.pad(dataset.encode(text)[:300])]).to(device)\n",
    "        output = model(test_vector)\n",
    "        prediction = torch.sigmoid(output).item()\n",
    "\n",
    "        if prediction > 0.5:\n",
    "            return 1\n",
    "        else:\n",
    "            return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "pr = []\n",
    "for i, row in data_val_nn.iterrows():\n",
    "    pr.append(predict_sentiment(row['total']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.83026316 0.16973684]\n",
      " [0.13552632 0.86447368]]\n"
     ]
    }
   ],
   "source": [
    "print(confusion_matrix(data_val_nn['target'],pr,normalize='true'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видно, результат хоть и не очень плохой, но до baseline не дотянул. Используется то, что выдало лучший результат - classic ml."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ответ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data = pd.read_parquet('test.parquet')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data['total'] = test_data['Title'] + test_data['Body'] + test_data['Tags']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_vec = bow_vectorizer.transform(test_data[\"total\"])\n",
    "test_vec_exp = tfidf_vectorizer.transform(test_data[\"total\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "pr2 = clf.predict(test_vec)\n",
    "pr01 = clf_exp.predict(test_vec_exp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "res = []\n",
    "for i,j in zip(pr2,pr01):\n",
    "    if(i == 2):\n",
    "        res.append(i)\n",
    "    else:\n",
    "        res.append(j)\n",
    "answer = pd.DataFrame(data={'Id':test_data.index.tolist(), 'Predicted': res})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Id</th>\n",
       "      <th>Predicted</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>46785369</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>38908667</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>44703012</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>34910435</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>51632121</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11995</th>\n",
       "      <td>37771316</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11996</th>\n",
       "      <td>59044957</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11997</th>\n",
       "      <td>57190511</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11998</th>\n",
       "      <td>35228310</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11999</th>\n",
       "      <td>46390083</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>12000 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "             Id  Predicted\n",
       "0      46785369          2\n",
       "1      38908667          0\n",
       "2      44703012          0\n",
       "3      34910435          0\n",
       "4      51632121          2\n",
       "...         ...        ...\n",
       "11995  37771316          0\n",
       "11996  59044957          1\n",
       "11997  57190511          0\n",
       "11998  35228310          2\n",
       "11999  46390083          1\n",
       "\n",
       "[12000 rows x 2 columns]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer.to_csv(\"result.csv\", index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Выводы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Разумеется, в данном случае нейросеть в теории должна была показывать лучшие результаты. Проблема, как мне кажется, в отсутствии опыта построения и поиска оптимальных параметров для обучения. Модели, которые я пытался использовать были довольно наивны и просты, скорее всего, более сложная модель, тем более для бинарной классификации, могла улучшить качество. Тем не менее, 0.91 fscore довольно прилично для классического ML, это при условии, что были сохранены критические вещи, влияющие на оценку вопроса. Не могу сказать, что будет с грамотной сетью при таких входных, но ML сильно просаживался в качестве при сохранении только слов."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}