model_tests_conv.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras import Sequential\n",
    "from tensorflow.keras.layers import Dense\n",
    "from tensorflow.keras.wrappers.scikit_learn import KerasClassifier\n",
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix, precision_recall_fscore_support, accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.base import BaseEstimator, ClassifierMixin\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "from itertools import combinations\n",
    "import numpy as np\n",
    "from math import ceil\n",
    "SEED = 25\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>av_depth</th>\n",
       "      <th>max_depth</th>\n",
       "      <th>min_depth</th>\n",
       "      <th>num_acl</th>\n",
       "      <th>num_rel_cl</th>\n",
       "      <th>num_advcl</th>\n",
       "      <th>num_sent</th>\n",
       "      <th>num_tok</th>\n",
       "      <th>av_tok_before_root</th>\n",
       "      <th>av_len_sent</th>\n",
       "      <th>...</th>\n",
       "      <th>num_linkings</th>\n",
       "      <th>num_4grams</th>\n",
       "      <th>num_func_ngrams</th>\n",
       "      <th>num_shell_noun</th>\n",
       "      <th>num_misspelled_tokens</th>\n",
       "      <th>million_mistake</th>\n",
       "      <th>text</th>\n",
       "      <th>class</th>\n",
       "      <th>type</th>\n",
       "      <th>sum_punct</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3.56</td>\n",
       "      <td>6</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>18</td>\n",
       "      <td>244</td>\n",
       "      <td>4.39</td>\n",
       "      <td>13.56</td>\n",
       "      <td>...</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>This two line graphs illustrates monthly avera...</td>\n",
       "      <td>6</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5.43</td>\n",
       "      <td>10</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>7</td>\n",
       "      <td>175</td>\n",
       "      <td>6.29</td>\n",
       "      <td>25.00</td>\n",
       "      <td>...</td>\n",
       "      <td>6</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>﻿We have two graphics, which show us the popul...</td>\n",
       "      <td>6</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2 rows × 62 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   av_depth  max_depth  min_depth  num_acl  num_rel_cl  num_advcl  num_sent  \\\n",
       "0      3.56          6          2        2           0          1        18   \n",
       "1      5.43         10          4        1           3          1         7   \n",
       "\n",
       "   num_tok  av_tok_before_root  av_len_sent  ...  num_linkings  num_4grams  \\\n",
       "0      244                4.39        13.56  ...             5           1   \n",
       "1      175                6.29        25.00  ...             6           1   \n",
       "\n",
       "   num_func_ngrams  num_shell_noun  num_misspelled_tokens  million_mistake  \\\n",
       "0                0               0                      2                0   \n",
       "1                0               0                      3                0   \n",
       "\n",
       "                                                text  class  type  sum_punct  \n",
       "0  This two line graphs illustrates monthly avera...      6     1          0  \n",
       "1  ﻿We have two graphics, which show us the popul...      6     1          0  \n",
       "\n",
       "[2 rows x 62 columns]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv(r'D:\\hse_iot\\VKR\\my_inspector\\data\\classification_dataset.csv')\n",
    "df['class'] = round(df['class'] / 10).astype(int)\n",
    "df = df[df['class'] != 1]\n",
    "_type = df['type'].to_list()\n",
    "df = df.drop(['name', 'side_mistake',\n",
    "              'vs', 'squared_vs', 'ttr', 'root_ttr',\n",
    "              'log_ttr', 'uber_ttr', 'd', 'vvi',\n",
    "              'squared_vv', 'punct_mistakes_pp',\n",
    "              'punct_mistakes_because',\n",
    "              'punct_mistakes_but', 'punct_mistakes_compare'], axis=1)\n",
    "\n",
    "df.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3440, 62)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 3440 entries, 0 to 3440\n",
      "Data columns (total 62 columns):\n",
      " #   Column                 Non-Null Count  Dtype  \n",
      "---  ------                 --------------  -----  \n",
      " 0   av_depth               3440 non-null   float64\n",
      " 1   max_depth              3440 non-null   int64  \n",
      " 2   min_depth              3440 non-null   int64  \n",
      " 3   num_acl                3440 non-null   int64  \n",
      " 4   num_rel_cl             3440 non-null   int64  \n",
      " 5   num_advcl              3440 non-null   int64  \n",
      " 6   num_sent               3440 non-null   int64  \n",
      " 7   num_tok                3440 non-null   int64  \n",
      " 8   av_tok_before_root     3440 non-null   float64\n",
      " 9   av_len_sent            3440 non-null   float64\n",
      " 10  num_cl                 3440 non-null   int64  \n",
      " 11  num_tu                 3440 non-null   int64  \n",
      " 12  num_compl_tu           3440 non-null   int64  \n",
      " 13  num_coord              3440 non-null   int64  \n",
      " 14  num_poss               3440 non-null   int64  \n",
      " 15  num_prep               3440 non-null   int64  \n",
      " 16  num_adj_noun           3440 non-null   int64  \n",
      " 17  num_part_noun          3440 non-null   int64  \n",
      " 18  num_noun_inf           3440 non-null   int64  \n",
      " 19  pos_sim_nei            3440 non-null   float64\n",
      " 20  pos_sim_all            3440 non-null   float64\n",
      " 21  lemma_sim_all          3440 non-null   float64\n",
      " 22  lemma_sim_nei          3440 non-null   float64\n",
      " 23  density                3440 non-null   float64\n",
      " 24  ls                     3440 non-null   float64\n",
      " 25  corrected_vs           3440 non-null   float64\n",
      " 26  lfp_1000               3440 non-null   float64\n",
      " 27  lfp_2000               3440 non-null   float64\n",
      " 28  lfp_uwl                3440 non-null   float64\n",
      " 29  lfp_rest               3440 non-null   float64\n",
      " 30  ndw                    3440 non-null   int64  \n",
      " 31  corrected_ttr          3440 non-null   float64\n",
      " 32  lv                     3440 non-null   float64\n",
      " 33  corrected_vv           3440 non-null   float64\n",
      " 34  vvii                   3440 non-null   float64\n",
      " 35  nv                     3440 non-null   float64\n",
      " 36  adjv                   3440 non-null   float64\n",
      " 37  advv                   3440 non-null   float64\n",
      " 38  modv                   3440 non-null   float64\n",
      " 39  der_level3             3440 non-null   float64\n",
      " 40  der_level4             3440 non-null   float64\n",
      " 41  der_level5             3440 non-null   float64\n",
      " 42  der_level6             3440 non-null   float64\n",
      " 43  mci                    3440 non-null   float64\n",
      " 44  freq_finite_forms      3440 non-null   float64\n",
      " 45  freq_aux               3440 non-null   float64\n",
      " 46  num_inf                3440 non-null   int64  \n",
      " 47  num_gerunds            3440 non-null   int64  \n",
      " 48  num_pres_sing          3440 non-null   int64  \n",
      " 49  num_pres_plur          3440 non-null   int64  \n",
      " 50  num_past_part          3440 non-null   int64  \n",
      " 51  num_past_simple        3440 non-null   int64  \n",
      " 52  num_linkings           3440 non-null   int64  \n",
      " 53  num_4grams             3440 non-null   int64  \n",
      " 54  num_func_ngrams        3440 non-null   int64  \n",
      " 55  num_shell_noun         3440 non-null   int64  \n",
      " 56  num_misspelled_tokens  3440 non-null   int64  \n",
      " 57  million_mistake        3440 non-null   int64  \n",
      " 58  text                   3440 non-null   object \n",
      " 59  class                  3440 non-null   int32  \n",
      " 60  type                   3440 non-null   int64  \n",
      " 61  sum_punct              3440 non-null   int64  \n",
      "dtypes: float64(29), int32(1), int64(31), object(1)\n",
      "memory usage: 1.6+ MB\n"
     ]
    }
   ],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6    2680\n",
       "7     308\n",
       "5     215\n",
       "4     122\n",
       "8      77\n",
       "2      24\n",
       "3      14\n",
       "Name: class, dtype: int64"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['class'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set(rc={'figure.figsize':(20,10)})\n",
    "sns_plt = sns.countplot(x='class', data=df, palette=\"Set2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_columns = [col for col in df.columns if col not in ['class', 'name', 'text', 'type']]\n",
    "X = df[feature_columns]\n",
    "y = df['class'] - 2\n",
    "y.loc[y == 1] = 3\n",
    "y.loc[y == 0] = 3\n",
    "y.loc[y == 2] = 3\n",
    "y.loc[y == 5] = 6\n",
    "\n",
    "y.loc[y == 3] = 0\n",
    "y.loc[y == 4] = 1\n",
    "y.loc[y == 6] = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_x, test_x, train_y, test_y = train_test_split(X, y, test_size=0.2, random_state = SEED)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Так как количество элементов в классах не равномерно то объединим классы 2,3,4,5; 7, 8; и уберем часть элементов из 6 класса"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    2139\n",
       "2     322\n",
       "0     291\n",
       "Name: class, dtype: int64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "train_y.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    322\n",
       "1    315\n",
       "0    291\n",
       "Name: class, dtype: int64"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dummy = train_y.loc[train_y == 1][:315]\n",
    "train_y.drop(train_y.loc[train_y == 1].index, inplace=True)\n",
    "train_y = pd.concat([train_y, dummy], ignore_index=True)\n",
    "train_y.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_idx = train_y.index\n",
    "train_x = train_x.iloc[y_idx.to_list()]\n",
    "train_x.reset_index(inplace=True, drop=True)\n",
    "test_x.reset_index(inplace=True, drop=True)\n",
    "train_y = train_y.reset_index(drop=True)\n",
    "test_y = test_y.reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_y2 = []\n",
    "for y in train_y:\n",
    "    y2 = np.zeros(3)\n",
    "    y2[y] = 1\n",
    "    train_y2.append(y2)\n",
    "    \n",
    "test_y2 = []\n",
    "for y in test_y:\n",
    "    y2 = np.zeros(3)\n",
    "    y2[y] = 1\n",
    "    test_y2.append(y2)\n",
    "    \n",
    "train_y2 = np.array(train_y2)\n",
    "test_y2 = np.array(test_y2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import make_scorer, accuracy_score\n",
    "def custom_scorer(y_true, y_pred):\n",
    "    y_true = [np.argmax(y) for y in y_true]\n",
    "    y_true = np.array(y_true)\n",
    "    return accuracy_score(y_true, y_pred)\n",
    "scorer = make_scorer(custom_scorer, greater_is_better=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_x2 = np.array(train_x)\n",
    "test_x2 = np.array(test_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_x3 = train_x2.reshape(-1, 59, 1)\n",
    "test_x3 = test_x2.reshape(-1, 59, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_model_conv(neurons1=None, neurons2=None, neurons3=None, core=3, activation=\"relu\", optimizer='Adam', loss=keras.losses.MeanSquaredError()):\n",
    "    model = keras.Sequential()\n",
    "    if neurons1:\n",
    "        model.add(layers.Conv1D(neurons1, core, activation=activation))\n",
    "    if neurons2:\n",
    "        model.add(layers.Conv1D(neurons2, core, activation=activation))\n",
    "    if neurons3:\n",
    "        model.add(layers.Conv1D(neurons3, core, activation=activation))\n",
    "    model.add(layers.Flatten())\n",
    "    model.add(Dense(3, activation=\"softmax\"))\n",
    "    model.compile(optimizer=optimizer, \n",
    "                  loss=loss,\n",
    "                  metrics=[keras.metrics.categorical_accuracy]\n",
    "         )\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'neurons1': [8, 16, 32, 64],\n",
       " 'neurons2': [8, 16, 32, 64],\n",
       " 'neurons3': [8, 16, 32, 64],\n",
       " 'core': [3, 4, 5, 10],\n",
       " 'activation': ['relu', 'tanh'],\n",
       " 'optimizer': ['Adam', 'SGD'],\n",
       " 'loss': ['mse'],\n",
       " 'batch_size': [5, 10, 15, 20]}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "neurons1 = [2**i for i in range(3, 7)]\n",
    "neurons2 = [2**i for i in range(3, 7)]\n",
    "neurons3 = [2**i for i in range(3, 7)]\n",
    "core = [3, 4, 5, 10]\n",
    "activation = [\"relu\", \"tanh\"]\n",
    "optimizer = ['Adam', 'SGD']\n",
    "loss = ['mse']\n",
    "batch_size= [5, 10, 15, 20]\n",
    "\n",
    "param_grid_conv = dict(neurons1=neurons1, \n",
    "                  neurons2=neurons2, \n",
    "                  neurons3=neurons3,\n",
    "                  core=core,\n",
    "                  activation=activation, \n",
    "                  optimizer=optimizer,\n",
    "                  loss=loss,\n",
    "                  batch_size=batch_size)\n",
    "param_grid_conv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_conv = KerasClassifier(build_fn=create_model_conv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def first_round_search(est, param_grid, num_iter=100):\n",
    "    early_stopping = EarlyStopping(monitor='categorical_accuracy', patience=5)\n",
    "    grid_conv = RandomizedSearchCV(estimator=model_conv,\n",
    "                               param_distributions=param_grid_conv,\n",
    "                               n_iter = num_iter,\n",
    "                               scoring=scorer,\n",
    "                               verbose=1,\n",
    "                               cv=5,\n",
    "                               n_jobs=-1)\n",
    "    grid_result = grid_conv.fit(train_x3, train_y2, callbacks=[early_stopping], epochs=100)\n",
    "    rs_df = pd.DataFrame(grid_result.cv_results_).sort_values('rank_test_score').reset_index(drop=True)\n",
    "    rs_df = rs_df.drop([\n",
    "            'mean_fit_time', \n",
    "            'std_fit_time', \n",
    "            'mean_score_time',\n",
    "            'std_score_time', \n",
    "            'params',\n",
    "            'split0_test_score', \n",
    "            'split1_test_score', \n",
    "            'split2_test_score', \n",
    "            'std_test_score'],\n",
    "            axis=1)\n",
    "    params_labels = [param for param in rs_df.columns if 'param' in param]\n",
    "    \n",
    "    cols = ceil(np.sqrt(len(params_labels)))\n",
    "    lines = ceil(len(params_labels)/cols)\n",
    "    fig, axs = plt.subplots(ncols=cols, nrows=lines)\n",
    "    sns.set(style=\"whitegrid\", color_codes=True, font_scale = 2)\n",
    "    fig.set_size_inches(30,30)\n",
    "    \n",
    "    col = 0\n",
    "    line = 0\n",
    "    for param in params_labels:\n",
    "        sns.barplot(x=param, y='mean_test_score', data=rs_df, ax=axs[line, col])\n",
    "        axs[line, col].set_ylim([rs_df.groupby(param).mean()['mean_test_score'].min()*0.95,\n",
    "                                 rs_df.groupby(param).mean()['mean_test_score'].max()*1.05])\n",
    "        axs[line, col].set_title(label = param.replace('param_', ''), size=25, weight='bold')\n",
    "        \n",
    "        if col < cols - 1:\n",
    "            col += 1\n",
    "        else:\n",
    "            line += 1\n",
    "            col = 0\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 300 candidates, totalling 1500 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 12 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  26 tasks      | elapsed:   40.5s\n",
      "[Parallel(n_jobs=-1)]: Done 176 tasks      | elapsed:  4.8min\n",
      "[Parallel(n_jobs=-1)]: Done 426 tasks      | elapsed: 12.8min\n",
      "[Parallel(n_jobs=-1)]: Done 776 tasks      | elapsed: 22.8min\n",
      "[Parallel(n_jobs=-1)]: Done 1226 tasks      | elapsed: 35.4min\n",
      "[Parallel(n_jobs=-1)]: Done 1500 out of 1500 | elapsed: 43.6min finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/100\n",
      "47/47 [==============================] - 0s 4ms/step - loss: 0.4228 - categorical_accuracy: 0.3481\n",
      "Epoch 2/100\n",
      "47/47 [==============================] - 0s 3ms/step - loss: 0.4243 - categorical_accuracy: 0.3438\n",
      "Epoch 3/100\n",
      "47/47 [==============================] - 0s 2ms/step - loss: 0.4377 - categorical_accuracy: 0.3351\n",
      "Epoch 4/100\n",
      "47/47 [==============================] - 0s 2ms/step - loss: 0.4318 - categorical_accuracy: 0.3438\n",
      "Epoch 5/100\n",
      "47/47 [==============================] - 0s 2ms/step - loss: 0.4140 - categorical_accuracy: 0.3405\n",
      "Epoch 6/100\n",
      "47/47 [==============================] - 0s 3ms/step - loss: 0.3496 - categorical_accuracy: 0.3534\n",
      "Epoch 7/100\n",
      "47/47 [==============================] - 0s 2ms/step - loss: 0.2643 - categorical_accuracy: 0.3567\n",
      "Epoch 8/100\n",
      "47/47 [==============================] - 0s 3ms/step - loss: 0.2339 - categorical_accuracy: 0.3545\n",
      "Epoch 9/100\n",
      "47/47 [==============================] - 0s 2ms/step - loss: 0.2267 - categorical_accuracy: 0.3416\n",
      "Epoch 10/100\n",
      "47/47 [==============================] - 0s 2ms/step - loss: 0.2286 - categorical_accuracy: 0.3373\n",
      "Epoch 11/100\n",
      "47/47 [==============================] - 0s 2ms/step - loss: 0.2258 - categorical_accuracy: 0.3459\n",
      "Epoch 12/100\n",
      "47/47 [==============================] - 0s 2ms/step - loss: 0.2237 - categorical_accuracy: 0.3438\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x2160 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "first_round_search(KerasClassifier(build_fn=create_model_conv), param_grid_conv, 300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'neurons1': [12, 14, 16, 18, 20, 22, 24],\n",
       " 'neurons2': [25, 27, 29, 31, 33, 35, 37, 39],\n",
       " 'neurons3': [25, 29, 33, 37, 41, 45, 49, 53, 57, 61, 65, 69, 73, 77],\n",
       " 'core': [4],\n",
       " 'activation': ['tanh'],\n",
       " 'optimizer': ['Adam'],\n",
       " 'loss': ['mse'],\n",
       " 'batch_size': [5]}"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "neurons1 = [i for i in range(12, 25, 2)]\n",
    "neurons2 = [i for i in range(25, 40, 2)]\n",
    "neurons3 = [i for i in range(25, 80, 4)]\n",
    "core = [4,]\n",
    "activation = ['tanh',]\n",
    "optimizer = ['Adam',]\n",
    "loss = ['mse']\n",
    "batch_size= [5,]\n",
    "\n",
    "param_grid_conv = dict(neurons1=neurons1, \n",
    "                  neurons2=neurons2, \n",
    "                  neurons3=neurons3,\n",
    "                  core=core,\n",
    "                  activation=activation, \n",
    "                  optimizer=optimizer,\n",
    "                  loss=loss,\n",
    "                  batch_size=batch_size)\n",
    "param_grid_conv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 784 candidates, totalling 3920 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 12 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  26 tasks      | elapsed:  2.0min\n",
      "[Parallel(n_jobs=-1)]: Done 176 tasks      | elapsed: 10.6min\n",
      "[Parallel(n_jobs=-1)]: Done 426 tasks      | elapsed: 23.6min\n",
      "[Parallel(n_jobs=-1)]: Done 776 tasks      | elapsed: 42.0min\n",
      "[Parallel(n_jobs=-1)]: Done 1226 tasks      | elapsed: 67.8min\n",
      "[Parallel(n_jobs=-1)]: Done 1776 tasks      | elapsed: 101.4min\n",
      "[Parallel(n_jobs=-1)]: Done 2426 tasks      | elapsed: 141.5min\n",
      "[Parallel(n_jobs=-1)]: Done 3176 tasks      | elapsed: 189.7min\n",
      "[Parallel(n_jobs=-1)]: Done 3920 out of 3920 | elapsed: 240.1min finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/200\n",
      "186/186 [==============================] - 1s 3ms/step - loss: 0.2653 - categorical_accuracy: 0.3330\n",
      "Epoch 2/200\n",
      "186/186 [==============================] - 0s 3ms/step - loss: 0.2305 - categorical_accuracy: 0.3545\n",
      "Epoch 3/200\n",
      "186/186 [==============================] - 0s 3ms/step - loss: 0.2275 - categorical_accuracy: 0.3858\n",
      "Epoch 4/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2282 - categorical_accuracy: 0.3761\n",
      "Epoch 5/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2316 - categorical_accuracy: 0.3599\n",
      "Epoch 6/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2220 - categorical_accuracy: 0.4149\n",
      "Epoch 7/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2220 - categorical_accuracy: 0.4009\n",
      "Epoch 8/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2245 - categorical_accuracy: 0.3750\n",
      "Epoch 9/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2190 - categorical_accuracy: 0.4203\n",
      "Epoch 10/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2211 - categorical_accuracy: 0.4019\n",
      "Epoch 11/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2200 - categorical_accuracy: 0.4267\n",
      "Epoch 12/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2192 - categorical_accuracy: 0.4062\n",
      "Epoch 13/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2204 - categorical_accuracy: 0.4256\n",
      "Epoch 14/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2212 - categorical_accuracy: 0.4224\n",
      "Epoch 15/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2172 - categorical_accuracy: 0.4278\n",
      "Epoch 16/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2173 - categorical_accuracy: 0.4235\n",
      "Epoch 17/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2171 - categorical_accuracy: 0.4310\n",
      "Epoch 18/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2165 - categorical_accuracy: 0.4407\n",
      "Epoch 19/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2183 - categorical_accuracy: 0.4203\n",
      "Epoch 20/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2179 - categorical_accuracy: 0.4138\n",
      "Epoch 21/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2148 - categorical_accuracy: 0.4612\n",
      "Epoch 22/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2157 - categorical_accuracy: 0.4623\n",
      "Epoch 23/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2116 - categorical_accuracy: 0.4644\n",
      "Epoch 24/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2166 - categorical_accuracy: 0.4440\n",
      "Epoch 25/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2161 - categorical_accuracy: 0.4246\n",
      "Epoch 26/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2163 - categorical_accuracy: 0.4429\n",
      "Epoch 27/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2137 - categorical_accuracy: 0.4612\n",
      "Epoch 28/200\n",
      "186/186 [==============================] - 0s 2ms/step - loss: 0.2108 - categorical_accuracy: 0.4634\n"
     ]
    }
   ],
   "source": [
    "early_stopping = EarlyStopping(monitor='categorical_accuracy', patience=5)\n",
    "grid_conv = GridSearchCV(estimator=model_conv,\n",
    "                               param_grid=param_grid_conv,\n",
    "                               scoring=scorer,\n",
    "                               verbose=1,\n",
    "                               cv=5,\n",
    "                               n_jobs=-1)\n",
    "grid_result_conv = grid_conv.fit(train_x3, train_y2, callbacks=[early_stopping], epochs=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best: 0.433264 using {'activation': 'tanh', 'batch_size': 5, 'core': 4, 'loss': 'mse', 'neurons1': 20, 'neurons2': 39, 'neurons3': 61, 'optimizer': 'Adam'}\n"
     ]
    }
   ],
   "source": [
    "print(\"Best: %f using %s\" % (grid_result_conv.best_score_, grid_result_conv.best_params_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_y = grid_result_conv.best_estimator_.predict(test_x3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 84,   0,   0],\n",
       "       [541,   0,   0],\n",
       "       [ 63,   0,   0]], dtype=int64)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pred_y = [np.argmax(y) for y in pred_y]\n",
    "pred_y = np.array(pred_y)\n",
    "confusion_matrix(test_y, pred_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.12209302325581395"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(test_y, pred_y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Попробуем обучить модели на сгенерированных данных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>av_depth</th>\n",
       "      <th>max_depth</th>\n",
       "      <th>min_depth</th>\n",
       "      <th>num_acl</th>\n",
       "      <th>num_rel_cl</th>\n",
       "      <th>num_advcl</th>\n",
       "      <th>num_sent</th>\n",
       "      <th>num_tok</th>\n",
       "      <th>av_tok_before_root</th>\n",
       "      <th>av_len_sent</th>\n",
       "      <th>...</th>\n",
       "      <th>num_pres_sing</th>\n",
       "      <th>num_pres_plur</th>\n",
       "      <th>num_past_part</th>\n",
       "      <th>num_past_simple</th>\n",
       "      <th>num_linkings</th>\n",
       "      <th>num_4grams</th>\n",
       "      <th>num_func_ngrams</th>\n",
       "      <th>million_mistake</th>\n",
       "      <th>sum_punct</th>\n",
       "      <th>cls</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>idx</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></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>0</th>\n",
       "      <td>3.69</td>\n",
       "      <td>7</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>13</td>\n",
       "      <td>189</td>\n",
       "      <td>4.23</td>\n",
       "      <td>14.54</td>\n",
       "      <td>...</td>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3.93</td>\n",
       "      <td>7</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>15</td>\n",
       "      <td>244</td>\n",
       "      <td>4.80</td>\n",
       "      <td>16.27</td>\n",
       "      <td>...</td>\n",
       "      <td>14</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>13</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2 rows × 67 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     av_depth  max_depth  min_depth  num_acl  num_rel_cl  num_advcl  num_sent  \\\n",
       "idx                                                                             \n",
       "0        3.69          7          2        2           2          0        13   \n",
       "1        3.93          7          2        1           3          1        15   \n",
       "\n",
       "     num_tok  av_tok_before_root  av_len_sent  ...  num_pres_sing  \\\n",
       "idx                                            ...                  \n",
       "0        189                4.23        14.54  ...              7   \n",
       "1        244                4.80        16.27  ...             14   \n",
       "\n",
       "     num_pres_plur  num_past_part  num_past_simple  num_linkings  num_4grams  \\\n",
       "idx                                                                            \n",
       "0                0              2                4             6           3   \n",
       "1                0              3                0            13           2   \n",
       "\n",
       "     num_func_ngrams  million_mistake  sum_punct  cls  \n",
       "idx                                                    \n",
       "0                  1                0          0    4  \n",
       "1                  0                0          0    4  \n",
       "\n",
       "[2 rows x 67 columns]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_gen = pd.read_csv(r'D:\\hse_iot\\VKR\\my_inspector\\data\\generated_data.csv', index_col='idx')\n",
    "df_gen.drop(['text',],  inplace=True, axis=1)\n",
    "df_gen.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 9100 entries, 0 to 9099\n",
      "Data columns (total 67 columns):\n",
      " #   Column              Non-Null Count  Dtype  \n",
      "---  ------              --------------  -----  \n",
      " 0   av_depth            9100 non-null   float64\n",
      " 1   max_depth           9100 non-null   int64  \n",
      " 2   min_depth           9100 non-null   int64  \n",
      " 3   num_acl             9100 non-null   int64  \n",
      " 4   num_rel_cl          9100 non-null   int64  \n",
      " 5   num_advcl           9100 non-null   int64  \n",
      " 6   num_sent            9100 non-null   int64  \n",
      " 7   num_tok             9100 non-null   int64  \n",
      " 8   av_tok_before_root  9100 non-null   float64\n",
      " 9   av_len_sent         9100 non-null   float64\n",
      " 10  num_cl              9100 non-null   int64  \n",
      " 11  num_tu              9100 non-null   int64  \n",
      " 12  num_compl_tu        9100 non-null   int64  \n",
      " 13  num_coord           9100 non-null   int64  \n",
      " 14  num_poss            9100 non-null   int64  \n",
      " 15  num_prep            9100 non-null   int64  \n",
      " 16  num_adj_noun        9100 non-null   int64  \n",
      " 17  num_part_noun       9100 non-null   int64  \n",
      " 18  num_noun_inf        9100 non-null   int64  \n",
      " 19  pos_sim_nei         9100 non-null   float64\n",
      " 20  pos_sim_all         9100 non-null   float64\n",
      " 21  lemma_sim_all       9100 non-null   float64\n",
      " 22  lemma_sim_nei       9100 non-null   float64\n",
      " 23  density             9100 non-null   float64\n",
      " 24  ls                  9100 non-null   float64\n",
      " 25  vs                  9100 non-null   float64\n",
      " 26  corrected_vs        9100 non-null   float64\n",
      " 27  squared_vs          9100 non-null   float64\n",
      " 28  lfp_1000            9100 non-null   float64\n",
      " 29  lfp_2000            9100 non-null   float64\n",
      " 30  lfp_uwl             9100 non-null   float64\n",
      " 31  lfp_rest            9100 non-null   float64\n",
      " 32  ndw                 9100 non-null   int64  \n",
      " 33  ttr                 9100 non-null   float64\n",
      " 34  corrected_ttr       9100 non-null   float64\n",
      " 35  root_ttr            9100 non-null   float64\n",
      " 36  log_ttr             9100 non-null   float64\n",
      " 37  uber_ttr            9100 non-null   float64\n",
      " 38  d                   9100 non-null   float64\n",
      " 39  lv                  9100 non-null   float64\n",
      " 40  vvi                 9100 non-null   float64\n",
      " 41  squared_vv          9100 non-null   float64\n",
      " 42  corrected_vv        9100 non-null   float64\n",
      " 43  vvii                9100 non-null   float64\n",
      " 44  nv                  9100 non-null   float64\n",
      " 45  adjv                9100 non-null   float64\n",
      " 46  advv                9100 non-null   float64\n",
      " 47  modv                9100 non-null   float64\n",
      " 48  der_level3          9100 non-null   float64\n",
      " 49  der_level4          9100 non-null   float64\n",
      " 50  der_level5          9100 non-null   float64\n",
      " 51  der_level6          9100 non-null   float64\n",
      " 52  mci                 9100 non-null   float64\n",
      " 53  freq_finite_forms   9100 non-null   float64\n",
      " 54  freq_aux            9100 non-null   float64\n",
      " 55  num_inf             9100 non-null   int64  \n",
      " 56  num_gerunds         9100 non-null   int64  \n",
      " 57  num_pres_sing       9100 non-null   int64  \n",
      " 58  num_pres_plur       9100 non-null   int64  \n",
      " 59  num_past_part       9100 non-null   int64  \n",
      " 60  num_past_simple     9100 non-null   int64  \n",
      " 61  num_linkings        9100 non-null   int64  \n",
      " 62  num_4grams          9100 non-null   int64  \n",
      " 63  num_func_ngrams     9100 non-null   int64  \n",
      " 64  million_mistake     9100 non-null   int64  \n",
      " 65  sum_punct           9100 non-null   int64  \n",
      " 66  cls                 9100 non-null   int64  \n",
      "dtypes: float64(38), int64(29)\n",
      "memory usage: 4.7 MB\n"
     ]
    }
   ],
   "source": [
    "df_gen.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5    2441\n",
       "4    2386\n",
       "3    2257\n",
       "2    2016\n",
       "Name: cls, dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_gen['cls'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set(rc={'figure.figsize':(20,10)})\n",
    "sns_plt = sns.countplot(x='cls', data=df_gen, palette=\"Set2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Т.к. сгенерированны данные только для тренировочной выборки, то тестовую выборку получим из начальных данных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(r'D:\\hse_iot\\VKR\\my_inspector\\data\\classification_dataset.csv')\n",
    "df.drop(['num_misspelled_tokens', 'num_shell_noun', 'name', 'type', 'punct_mistakes_pp', 'punct_mistakes_because', 'punct_mistakes_but', 'punct_mistakes_compare', 'side_mistake', 'text'],  inplace=True, axis=1)\n",
    "df['class'] = round(df['class'] / 10).astype(int)\n",
    "df.loc[df['class'] == 1, 'class'] = 2\n",
    "df.loc[df['class'] == 3, 'class'] = 2\n",
    "df.loc[df['class'] == 4, 'class'] = 3\n",
    "df.loc[df['class'] == 5, 'class'] = 3\n",
    "df.loc[df['class'] == 6, 'class'] = 4\n",
    "df.loc[df['class'] == 7, 'class'] = 4\n",
    "df.loc[df['class'] == 8, 'class'] = 5\n",
    "\n",
    "df = df.rename(columns = {'class': 'cls'})\n",
    "feature_columns = [col for col in df.columns if col not in ['cls',]]\n",
    "X = df[feature_columns]\n",
    "y = df['cls']\n",
    "train_x, test_x, train_y, test_y = train_test_split(X, y, test_size=0.2, random_state = SEED)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_columns = [col for col in df_gen.columns if col not in ['cls',]]\n",
    "train_x = df_gen[feature_columns]\n",
    "train_y = df_gen['cls']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}