01_Москаленко_Андрей_Test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import tqdm\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import scipy\n",
    "import catboost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from catboost import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = CatBoost()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = model.load_model('./model_last')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import dask.dataframe as dd\n",
    "types = {}\n",
    "for key in dict(dd.read_csv('G:/TEST.csv').dtypes).keys():\n",
    "    types[key] = np.float32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = pd.read_csv('G:/TEST.csv', dtype=types)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Винрейты и плейрейты не давали прироста, а только ухудшали финальное предсказание"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# X['1HERO_1_WINRATE'] = 0.0\n",
    "# X['1HERO_2_WINRATE'] = 0.0\n",
    "# X['1HERO_3_WINRATE'] = 0.0\n",
    "# X['1HERO_4_WINRATE'] = 0.0\n",
    "# X['1HERO_5_WINRATE'] = 0.0\n",
    "# X['1HERO_6_WINRATE'] = 0.0\n",
    "# X['1HERO_7_WINRATE'] = 0.0\n",
    "# X['1HERO_8_WINRATE'] = 0.0\n",
    "\n",
    "\n",
    "# X['2HERO_1_WINRATE'] = 0.0\n",
    "# X['2HERO_2_WINRATE'] = 0.0\n",
    "# X['2HERO_3_WINRATE'] = 0.0\n",
    "# X['2HERO_4_WINRATE'] = 0.0\n",
    "# X['2HERO_5_WINRATE'] = 0.0\n",
    "# X['2HERO_6_WINRATE'] = 0.0\n",
    "# X['2HERO_7_WINRATE'] = 0.0\n",
    "# X['2HERO_8_WINRATE'] = 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "hero_winrates = np.load('hero_winrates.npy', allow_pickle=True).item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\andry\\Anaconda3\\envs\\subjectify\\lib\\site-packages\\ipykernel_launcher.py:1: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8ee2d5c7d1bc408a95acf95d41b3c725",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', layout=Layout(width='20px'), max=1.0), HTML(value=''…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# for idx, row in tqdm.tqdm_notebook(X.iterrows()):\n",
    "#     X.at[idx, '1HERO_1_WINRATE'] = hero_winrates[row['X5']]\n",
    "#     X.at[idx, '1HERO_2_WINRATE'] = hero_winrates[row['X6']]\n",
    "#     X.at[idx, '1HERO_3_WINRATE'] = hero_winrates[row['X7']]\n",
    "#     X.at[idx, '1HERO_4_WINRATE'] = hero_winrates[row['X8']]\n",
    "#     X.at[idx, '1HERO_5_WINRATE'] = hero_winrates[row['X9']]\n",
    "#     X.at[idx, '1HERO_6_WINRATE'] = hero_winrates[row['X10']]\n",
    "#     X.at[idx, '1HERO_7_WINRATE'] = hero_winrates[row['X11']]\n",
    "#     X.at[idx, '1HERO_8_WINRATE'] = hero_winrates[row['X12']]\n",
    "    \n",
    "#     X.at[idx, '2HERO_1_WINRATE'] = hero_winrates[row['X13']]\n",
    "#     X.at[idx, '2HERO_2_WINRATE'] = hero_winrates[row['X14']]\n",
    "#     X.at[idx, '2HERO_3_WINRATE'] = hero_winrates[row['X15']]\n",
    "#     X.at[idx, '2HERO_4_WINRATE'] = hero_winrates[row['X16']]\n",
    "#     X.at[idx, '2HERO_5_WINRATE'] = hero_winrates[row['X17']]\n",
    "#     X.at[idx, '2HERO_6_WINRATE'] = hero_winrates[row['X18']]\n",
    "#     X.at[idx, '2HERO_7_WINRATE'] = hero_winrates[row['X19']]\n",
    "#     X.at[idx, '2HERO_8_WINRATE'] = hero_winrates[row['X20']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rates = np.load('./rates.npy', allow_pickle=True).item()\n",
    "# heroes_stats_total = np.load('./heroes_stats_total.npy', allow_pickle=True).item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\andry\\Anaconda3\\envs\\subjectify\\lib\\site-packages\\ipykernel_launcher.py:1: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8d4ca94d0b2140ff8af645750fa85744",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', layout=Layout(width='20px'), max=1.0), HTML(value=''…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# for idx, row in tqdm.tqdm_notebook(X.iterrows()):\n",
    "#     if row['X1'] not in rates:\n",
    "#         rates[row['X1']] = [0, 0]\n",
    "#     if row['X3'] not in rates:\n",
    "#         rates[row['X3']] = [0, 0]\n",
    "        \n",
    "#     if row['X1'] not in heroes_stats_total:\n",
    "#         heroes_stats_total[row['X1']] = {}\n",
    "#     if row['X3'] not in heroes_stats_total:\n",
    "#         heroes_stats_total[row['X3']] = {}\n",
    "        \n",
    "#     first_rate = rates[row['X1']]\n",
    "#     second_rate = rates[row['X3']]\n",
    "#     first_hero_rate = heroes_stats_total[row['X1']]\n",
    "#     second_hero_rate = heroes_stats_total[row['X3']]\n",
    "\n",
    "    \n",
    "#     if row['X5'] in first_hero_rate and first_rate[1] >= 5:\n",
    "#         X.at[idx, '1HERO_1_PLAYRATE'] = first_hero_rate[row['X5']][0] / first_rate[1]\n",
    "#     else:\n",
    "#         X.at[idx, '1HERO_1_PLAYRATE'] = -1\n",
    "    \n",
    "#     if row['X6'] in first_hero_rate and first_rate[1] >= 5:\n",
    "#         X.at[idx, '1HERO_2_PLAYRATE'] = first_hero_rate[row['X6']][0] / first_rate[1]\n",
    "#     else:\n",
    "#         X.at[idx, '1HERO_2_PLAYRATE'] = -1\n",
    "        \n",
    "#     if row['X7'] in first_hero_rate and first_rate[1] >= 5:\n",
    "#         X.at[idx, '1HERO_3_PLAYRATE'] = first_hero_rate[row['X7']][0] / first_rate[1]\n",
    "#     else:\n",
    "#         X.at[idx, '1HERO_3_PLAYRATE'] = -1\n",
    "        \n",
    "#     if row['X8'] in first_hero_rate and first_rate[1] >= 5:\n",
    "#         X.at[idx, '1HERO_4_PLAYRATE'] = first_hero_rate[row['X8']][0] / first_rate[1]\n",
    "#     else:\n",
    "#         X.at[idx, '1HERO_4_PLAYRATE'] = -1\n",
    "        \n",
    "#     if row['X9'] in first_hero_rate and first_rate[1] >= 5:\n",
    "#         X.at[idx, '1HERO_5_PLAYRATE'] = first_hero_rate[row['X9']][0] / first_rate[1]\n",
    "#     else:\n",
    "#         X.at[idx, '1HERO_5_PLAYRATE'] = -1\n",
    "    \n",
    "#     if row['X10'] in first_hero_rate and first_rate[1] >= 5:\n",
    "#         X.at[idx, '1HERO_6_PLAYRATE'] = first_hero_rate[row['X10']][0] / first_rate[1]\n",
    "#     else:\n",
    "#         X.at[idx, '1HERO_6_PLAYRATE'] = -1\n",
    "        \n",
    "#     if row['X11'] in first_hero_rate and first_rate[1] >= 5:\n",
    "#         X.at[idx, '1HERO_7_PLAYRATE'] = first_hero_rate[row['X11']][0] / first_rate[1]\n",
    "#     else:\n",
    "#         X.at[idx, '1HERO_7_PLAYRATE'] = -1\n",
    "        \n",
    "#     if row['X12'] in first_hero_rate and first_rate[1] >= 5:\n",
    "#         X.at[idx, '1HERO_8_PLAYRATE'] = first_hero_rate[row['X12']][0] / first_rate[1]\n",
    "#     else:\n",
    "#         X.at[idx, '1HERO_8_PLAYRATE'] = -1\n",
    "        \n",
    "        \n",
    "        \n",
    "#     if row['X13'] in second_hero_rate and second_rate[1] >= 5:\n",
    "#         X.at[idx, '2HERO_1_PLAYRATE'] = second_hero_rate[row['X13']][0] / second_rate[1]\n",
    "#     else:\n",
    "#         X.at[idx, '2HERO_1_PLAYRATE'] = -1\n",
    "    \n",
    "#     if row['X14'] in second_hero_rate and second_rate[1] >= 5:\n",
    "#         X.at[idx, '2HERO_2_PLAYRATE'] = second_hero_rate[row['X14']][0] / second_rate[1]\n",
    "#     else:\n",
    "#         X.at[idx, '2HERO_2_PLAYRATE'] = -1\n",
    "        \n",
    "#     if row['X15'] in second_hero_rate and second_rate[1] >= 5:\n",
    "#         X.at[idx, '2HERO_3_PLAYRATE'] = second_hero_rate[row['X15']][0] / second_rate[1]\n",
    "#     else:\n",
    "#         X.at[idx, '2HERO_3_PLAYRATE'] = -1\n",
    "        \n",
    "#     if row['X16'] in second_hero_rate and second_rate[1] >= 5:\n",
    "#         X.at[idx, '2HERO_4_PLAYRATE'] = second_hero_rate[row['X16']][0] / second_rate[1]\n",
    "#     else:\n",
    "#         X.at[idx, '2HERO_4_PLAYRATE'] = -1\n",
    "        \n",
    "#     if row['X17'] in second_hero_rate and second_rate[1] >= 5:\n",
    "#         X.at[idx, '2HERO_5_PLAYRATE'] = second_hero_rate[row['X17']][0] / second_rate[1]\n",
    "#     else:\n",
    "#         X.at[idx, '2HERO_5_PLAYRATE'] = -1\n",
    "    \n",
    "#     if row['X18'] in second_hero_rate and second_rate[1] >= 5:\n",
    "#         X.at[idx, '2HERO_6_PLAYRATE'] = second_hero_rate[row['X18']][0] / second_rate[1]\n",
    "#     else:\n",
    "#         X.at[idx, '2HERO_6_PLAYRATE'] = -1\n",
    "        \n",
    "#     if row['X19'] in second_hero_rate and second_rate[1] >= 5:\n",
    "#         X.at[idx, '2HERO_7_PLAYRATE'] = second_hero_rate[row['X19']][0] / second_rate[1]\n",
    "#     else:\n",
    "#         X.at[idx, '2HERO_7_PLAYRATE'] = -1\n",
    "        \n",
    "#     if row['X20'] in second_hero_rate and second_rate[1] >= 5:\n",
    "#         X.at[idx, '2HERO_8_PLAYRATE'] = second_hero_rate[row['X20']][0] / second_rate[1]\n",
    "#     else:\n",
    "#         X.at[idx, '2HERO_8_PLAYRATE'] = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# X['1HERO_AVG_WINRATE'] = (X['1HERO_1_WINRATE'] + \n",
    "#                          X['1HERO_2_WINRATE'] +\n",
    "#                          X['1HERO_3_WINRATE'] + \n",
    "#                          X['1HERO_4_WINRATE'] + \n",
    "#                          X['1HERO_5_WINRATE'] + \n",
    "#                          X['1HERO_6_WINRATE'] + \n",
    "#                          X['1HERO_7_WINRATE'] + \n",
    "#                          X['1HERO_8_WINRATE']) / 8   \n",
    "                            \n",
    "# X['2HERO_AVG_WINRATE'] = (X['2HERO_1_WINRATE'] + \n",
    "#                          X['2HERO_2_WINRATE'] +\n",
    "#                          X['2HERO_3_WINRATE'] + \n",
    "#                          X['2HERO_4_WINRATE'] + \n",
    "#                          X['2HERO_5_WINRATE'] + \n",
    "#                          X['2HERO_6_WINRATE'] + \n",
    "#                          X['2HERO_7_WINRATE'] + \n",
    "#                          X['2HERO_8_WINRATE']) / 8   \n",
    "\n",
    "\n",
    "# X['1HERO_AVG_PLAYRATE'] = (X['1HERO_1_PLAYRATE'] + \n",
    "#                          X['1HERO_2_PLAYRATE'] +\n",
    "#                          X['1HERO_3_PLAYRATE'] + \n",
    "#                          X['1HERO_4_PLAYRATE'] + \n",
    "#                          X['1HERO_5_PLAYRATE'] + \n",
    "#                          X['1HERO_6_PLAYRATE'] + \n",
    "#                          X['1HERO_7_PLAYRATE'] + \n",
    "#                          X['1HERO_8_PLAYRATE']) / 8   \n",
    "                            \n",
    "# X['2HERO_AVG_PLAYRATE'] = (X['2HERO_1_PLAYRATE'] + \n",
    "#                          X['2HERO_2_PLAYRATE'] +\n",
    "#                          X['2HERO_3_PLAYRATE'] + \n",
    "#                          X['2HERO_4_PLAYRATE'] + \n",
    "#                          X['2HERO_5_PLAYRATE'] + \n",
    "#                          X['2HERO_6_PLAYRATE'] + \n",
    "#                          X['2HERO_7_PLAYRATE'] + \n",
    "#                          X['2HERO_8_PLAYRATE']) / 8   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# X['HERO_WINRATE_DIFF'] = X['1HERO_AVG_WINRATE'] - X['2HERO_AVG_WINRATE']\n",
    "# X['HERO_PLAYRATE_DIFF'] = X['1HERO_AVG_PLAYRATE'] - X['2HERO_AVG_PLAYRATE']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Локальные рейтинги"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "X['MEAN_PREV_LEFT'] = 0.0\n",
    "X['MIN_PREV_LEFT'] = 0.0\n",
    "X['MAX_PREV_LEFT'] = 0.0\n",
    "X['STD_PREV_LEFT'] = 0.0\n",
    "X['PERCENTILE_PREV_LEFT'] = 0.0\n",
    "X['MEAN_PREV_RIGHT'] = 0.0\n",
    "X['MIN_PREV_RIGHT'] = 0.0\n",
    "X['MAX_PREV_RIGHT'] = 0.0\n",
    "X['STD_PREV_RIGHT'] = 0.0\n",
    "X['PERCENTILE_PREV_RIGHT'] = 0.0\n",
    "X['MEAN_CURR_LEFT'] = 0.0\n",
    "X['MIN_CURR_LEFT'] = 0.0\n",
    "X['MAX_CURR_LEFT'] = 0.0\n",
    "X['STD_CURR_LEFT'] = 0.0\n",
    "X['PERCENTILE_CURR_LEFT'] = 0.0\n",
    "X['MEAN_CURR_RIGHT'] = 0.0\n",
    "X['MIN_CURR_RIGHT'] = 0.0\n",
    "X['MAX_CURR_RIGHT'] = 0.0\n",
    "X['STD_CURR_RIGHT'] = 0.0\n",
    "X['PERCENTILE_CURR_RIGHT'] = 0.0\n",
    "X['MEAN_NEXT_LEFT'] = 0.0\n",
    "X['MIN_NEXT_LEFT'] = 0.0\n",
    "X['MAX_NEXT_LEFT'] = 0.0\n",
    "X['STD_NEXT_LEFT'] = 0.0\n",
    "X['PERCENTILE_NEXT_LEFT'] = 0.0\n",
    "X['MEAN_NEXT_RIGHT'] = 0.0\n",
    "X['MIN_NEXT_RIGHT'] = 0.0\n",
    "X['MAX_NEXT_RIGHT'] = 0.0\n",
    "X['STD_NEXT_RIGHT'] = 0.0\n",
    "X['PERCENTILE_NEXT_RIGHT'] = 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "day_by_day = np.load('./day_by_day_ratings.npy', allow_pickle=True).item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bisect import *\n",
    "def index(a, x):\n",
    "    'Locate the leftmost value exactly equal to x'\n",
    "    i = bisect_left(a, x)\n",
    "    if i != len(a) and a[i] == x:\n",
    "        return i\n",
    "    raise ValueError\n",
    "\n",
    "def find_lt(a, x):\n",
    "    'Find rightmost value less than x'\n",
    "    i = bisect_left(a, x)\n",
    "    if i:\n",
    "        return a[i-1]\n",
    "    raise ValueError\n",
    "\n",
    "def find_le(a, x):\n",
    "    'Find rightmost value less than or equal to x'\n",
    "    i = bisect_right(a, x)\n",
    "    if i:\n",
    "        return a[i-1]\n",
    "    raise ValueError\n",
    "\n",
    "def find_gt(a, x):\n",
    "    'Find leftmost value greater than x'\n",
    "    i = bisect_right(a, x)\n",
    "    if i != len(a):\n",
    "        return a[i]\n",
    "    raise ValueError\n",
    "\n",
    "def find_ge(a, x):\n",
    "    'Find leftmost item greater than or equal to x'\n",
    "    i = bisect_left(a, x)\n",
    "    if i != len(a):\n",
    "        return a[i]\n",
    "    raise ValueError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "908252it [10:07, 1494.95it/s]\n"
     ]
    }
   ],
   "source": [
    "for idx, row in tqdm.tqdm(X.iterrows()):\n",
    "    left = day_by_day[row['X1']]\n",
    "    right = day_by_day[row['X3']]\n",
    "    \n",
    "    left_keys = list(left.keys())\n",
    "    right_keys = list(right.keys())\n",
    "    \n",
    "    curr_day_left = left[int(row['X21'])]\n",
    "    curr_day_right = right[int(row['X21'])]\n",
    "    \n",
    "    \n",
    "    try:\n",
    "        next_day_left = left[find_gt(left_keys, int(row['X21']))]\n",
    "    except:\n",
    "        next_day_left = curr_day_left\n",
    "        \n",
    "    try:\n",
    "        next_day_right = left[find_gt(right_keys, int(row['X21']))]\n",
    "    except:\n",
    "        next_day_right = curr_day_right\n",
    "        \n",
    "    try:\n",
    "        prev_day_left = left[find_lt(left_keys, int(row['X21']))]\n",
    "    except:\n",
    "        prev_day_left = curr_day_left\n",
    "        \n",
    "    try:\n",
    "        prev_day_right = left[find_lt(right_keys, int(row['X21']))]\n",
    "    except:\n",
    "        prev_day_right = curr_day_right    \n",
    "    \n",
    "    X.at[idx, 'MEAN_CURR_LEFT'] = np.mean(curr_day_left)\n",
    "    X.at[idx, 'MIN_CURR_LEFT'] = np.min(curr_day_left)\n",
    "    X.at[idx, 'MAX_CURR_LEFT'] = np.max(curr_day_left)\n",
    "    X.at[idx, 'STD_CURR_LEFT'] = np.std(curr_day_left)\n",
    "    X.at[idx, 'PERCENTILE_CURR_LEFT'] = scipy.stats.percentileofscore(curr_day_left, row['X2'])\n",
    "    X.at[idx, 'MEAN_CURR_RIGHT'] = np.mean(curr_day_right)\n",
    "    X.at[idx, 'MIN_CURR_RIGHT'] = np.min(curr_day_right)\n",
    "    X.at[idx, 'MAX_CURR_RIGHT'] = np.max(curr_day_right)\n",
    "    X.at[idx, 'STD_CURR_RIGHT'] = np.std(curr_day_right)\n",
    "    X.at[idx, 'PERCENTILE_CURR_RIGHT'] = scipy.stats.percentileofscore(curr_day_right, row['X4'])\n",
    "    X.at[idx, 'MEAN_PREV_LEFT'] = np.mean(prev_day_left)\n",
    "    X.at[idx, 'MIN_PREV_LEFT'] = np.min(prev_day_left)\n",
    "    X.at[idx, 'MAX_PREV_LEFT'] = np.max(prev_day_left)\n",
    "    X.at[idx, 'STD_PREV_LEFT'] = np.std(prev_day_left)\n",
    "    X.at[idx, 'PERCENTILE_PREV_LEFT'] = scipy.stats.percentileofscore(prev_day_left, row['X2'])\n",
    "    X.at[idx, 'MEAN_PREV_RIGHT'] = np.mean(prev_day_right)\n",
    "    X.at[idx, 'MIN_PREV_RIGHT'] = np.min(prev_day_right)\n",
    "    X.at[idx, 'MAX_PREV_RIGHT'] = np.max(prev_day_right)\n",
    "    X.at[idx, 'STD_PREV_RIGHT'] = np.std(prev_day_right)\n",
    "    X.at[idx, 'PERCENTILE_PREV_RIGHT'] = scipy.stats.percentileofscore(prev_day_right, row['X4'])\n",
    "    X.at[idx, 'MEAN_NEXT_LEFT'] = np.mean(next_day_left)\n",
    "    X.at[idx, 'MIN_NEXT_LEFT'] = np.min(next_day_left)\n",
    "    X.at[idx, 'MAX_NEXT_LEFT'] = np.max(next_day_left)\n",
    "    X.at[idx, 'STD_NEXT_LEFT'] = np.std(next_day_left)\n",
    "    X.at[idx, 'PERCENTILE_NEXT_LEFT'] = scipy.stats.percentileofscore(next_day_left, row['X2'])\n",
    "    X.at[idx, 'MEAN_NEXT_RIGHT'] = np.mean(next_day_right)\n",
    "    X.at[idx, 'MIN_NEXT_RIGHT'] = np.min(next_day_right)\n",
    "    X.at[idx, 'MAX_NEXT_RIGHT'] = np.max(next_day_right)\n",
    "    X.at[idx, 'STD_NEXT_RIGHT'] = np.std(next_day_right)\n",
    "    X.at[idx, 'PERCENTILE_NEXT_RIGHT'] = scipy.stats.percentileofscore(next_day_right, row['X4'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "X['MAX_MIN_PREV_LEFT'] = (X['MAX_PREV_LEFT'] - X['MIN_PREV_LEFT']) / X['MEAN_PREV_LEFT']\n",
    "X['MAX_TO_MEAN_PREV_LEFT'] = X['MAX_PREV_LEFT'] / X['MEAN_PREV_LEFT']\n",
    "X['MIN_TO_MEAN_PREV_LEFT'] = X['MIN_PREV_LEFT'] / X['MEAN_PREV_LEFT']\n",
    "X['STD_TO_MEAN_PREV_LEFT'] = X['STD_PREV_LEFT'] / X['MEAN_PREV_LEFT']\n",
    "\n",
    "X['MAX_MIN_PREV_RIGHT'] = (X['MAX_PREV_RIGHT'] - X['MIN_PREV_RIGHT']) / X['MEAN_PREV_RIGHT']\n",
    "X['MAX_TO_MEAN_PREV_RIGHT'] = X['MAX_PREV_RIGHT'] / X['MEAN_PREV_RIGHT']\n",
    "X['MIN_TO_MEAN_PREV_RIGHT'] = X['MIN_PREV_RIGHT'] / X['MEAN_PREV_RIGHT']\n",
    "X['STD_TO_MEAN_PREV_RIGHT'] = X['STD_PREV_RIGHT'] / X['MEAN_PREV_RIGHT']\n",
    "\n",
    "\n",
    "\n",
    "X['MAX_MIN_CURR_LEFT'] = (X['MAX_CURR_LEFT'] - X['MIN_CURR_LEFT']) / X['MEAN_CURR_LEFT']\n",
    "X['MAX_TO_MEAN_CURR_LEFT'] = X['MAX_CURR_LEFT'] / X['MEAN_CURR_LEFT']\n",
    "X['MIN_TO_MEAN_CURR_LEFT'] = X['MIN_CURR_LEFT'] / X['MEAN_CURR_LEFT']\n",
    "X['STD_TO_MEAN_CURR_LEFT'] = X['STD_CURR_LEFT'] / X['MEAN_CURR_LEFT']\n",
    "\n",
    "X['MAX_MIN_CURR_RIGHT'] = (X['MAX_CURR_RIGHT'] - X['MIN_CURR_RIGHT']) / X['MEAN_CURR_RIGHT']\n",
    "X['MAX_TO_MEAN_CURR_RIGHT'] = X['MAX_CURR_RIGHT'] / X['MEAN_CURR_RIGHT']\n",
    "X['MIN_TO_MEAN_CURR_RIGHT'] = X['MIN_CURR_RIGHT'] / X['MEAN_CURR_RIGHT']\n",
    "X['STD_TO_MEAN_CURR_RIGHT'] = X['STD_CURR_RIGHT'] / X['MEAN_CURR_RIGHT']\n",
    "\n",
    "\n",
    "\n",
    "X['MAX_MIN_NEXT_LEFT'] = (X['MAX_NEXT_LEFT'] - X['MIN_NEXT_LEFT']) / X['MEAN_NEXT_LEFT']\n",
    "X['MAX_TO_MEAN_NEXT_LEFT'] = X['MAX_NEXT_LEFT'] / X['MEAN_NEXT_LEFT']\n",
    "X['MIN_TO_MEAN_NEXT_LEFT'] = X['MIN_NEXT_LEFT'] / X['MEAN_NEXT_LEFT']\n",
    "X['STD_TO_MEAN_NEXT_LEFT'] = X['STD_NEXT_LEFT'] / X['MEAN_NEXT_LEFT']\n",
    "\n",
    "X['MAX_MIN_NEXT_RIGHT'] = (X['MAX_NEXT_RIGHT'] - X['MIN_NEXT_RIGHT']) / X['MEAN_NEXT_RIGHT']\n",
    "X['MAX_TO_MEAN_NEXT_RIGHT'] = X['MAX_NEXT_RIGHT'] / X['MEAN_NEXT_RIGHT']\n",
    "X['MIN_TO_MEAN_NEXT_RIGHT'] = X['MIN_NEXT_RIGHT'] / X['MEAN_NEXT_RIGHT']\n",
    "X['STD_TO_MEAN_NEXT_RIGHT'] = X['STD_NEXT_RIGHT'] / X['MEAN_NEXT_RIGHT']\n",
    "\n",
    "X['PREV_MAX_DIV_MIN_LEFT'] = X['MAX_PREV_LEFT'] / X['MIN_PREV_LEFT']\n",
    "X['PREV_MAX_DIV_MIN_RIGHT'] = X['MAX_PREV_RIGHT'] / X['MIN_PREV_RIGHT']\n",
    "\n",
    "X['PREV_MAX_DIV_MEAN_LEFT'] = X['MAX_PREV_LEFT'] / X['MEAN_PREV_LEFT']\n",
    "X['PREV_MAX_DIV_MEAN_RIGHT'] = X['MAX_PREV_RIGHT'] / X['MEAN_PREV_RIGHT']\n",
    "\n",
    "X['PREV_MIN_DIV_MEAN_LEFT'] = X['MIN_PREV_LEFT'] / X['MEAN_PREV_LEFT']\n",
    "X['PREV_MIN_DIV_MEAN_RIGHT'] = X['MIN_PREV_RIGHT'] / X['MEAN_PREV_RIGHT']\n",
    "\n",
    "X['PREV_MAX_MINUS_MIN_LEFT'] = X['MAX_PREV_LEFT'] - X['MIN_PREV_LEFT']\n",
    "X['PREV_MAX_MINUS_MIN_RIGHT'] = X['MAX_PREV_RIGHT'] - X['MIN_PREV_RIGHT']\n",
    "\n",
    "X['PREV_MAX_MINUS_MEAN_LEFT'] = X['MAX_PREV_LEFT'] - X['MEAN_PREV_LEFT']\n",
    "X['PREV_MAX_MINUS_MEAN_RIGHT'] = X['MAX_PREV_RIGHT'] - X['MEAN_PREV_RIGHT']\n",
    "\n",
    "X['PREV_MEAN_MINUS_MIN_LEFT'] = X['MEAN_PREV_LEFT'] - X['MIN_PREV_LEFT']\n",
    "X['PREV_MEAN_MINUS_MIN_RIGHT'] = X['MEAN_PREV_RIGHT'] - X['MIN_PREV_RIGHT']\n",
    "\n",
    "X['PREV_CURR_DIV_MEAN_LEFT'] = X['X2'] / X['MEAN_PREV_LEFT']\n",
    "X['PREV_CURR_DIV_MEAN_RIGHT'] = X['X4'] / X['MEAN_PREV_RIGHT']\n",
    "\n",
    "X['PREV_MEAN_MINUS_CURR_LEFT'] = X['MEAN_PREV_LEFT'] - X['X2']\n",
    "X['PREV_MEAN_MINUS_CURR_RIGHT'] = X['MEAN_PREV_RIGHT'] - X['X4']\n",
    "\n",
    "X['PREV_MAX_MINUS_CURR_LEFT'] = (X['MAX_PREV_LEFT'] - X['X2']) / X['MEAN_PREV_LEFT']\n",
    "X['PREV_MAX_MINUS_CURR_RIGHT'] = (X['MAX_PREV_RIGHT'] - X['X4']) / X['MEAN_PREV_RIGHT']\n",
    "\n",
    "X['PREV_MIN_MINUS_CURR_LEFT'] = (X['MIN_PREV_LEFT'] - X['X2']) / X['MEAN_PREV_LEFT']\n",
    "X['PREV_MIN_MINUS_CURR_RIGHT'] = (X['MIN_PREV_RIGHT'] - X['X4']) / X['MEAN_PREV_RIGHT']\n",
    "\n",
    "X['PREV_STD_DIV_MEAN_LEFT'] = X['STD_PREV_LEFT'] / X['MEAN_PREV_LEFT']\n",
    "X['PREV_STD_DIV_MEAN_RIGHT'] = X['STD_PREV_RIGHT'] / X['MEAN_PREV_RIGHT']\n",
    "\n",
    "\n",
    "X['PREV_STD_DIV_CURR_LEFT'] = X['STD_PREV_LEFT'] / X['X2']\n",
    "X['PREV_STD_DIV_CURR_RIGHT'] = X['STD_PREV_RIGHT'] / X['X4']\n",
    "\n",
    "\n",
    "X['PREV_MAX_MINUS_MIN_NORMALIZED_LEFT'] = (X['MAX_PREV_LEFT'] - X['MIN_PREV_LEFT']) / X['MEAN_PREV_LEFT']\n",
    "X['PREV_MAX_MINUS_MIN_NORMALIZED_RIGHT'] = (X['MAX_PREV_RIGHT'] - X['MIN_PREV_RIGHT']) / X['MEAN_PREV_RIGHT']\n",
    "\n",
    "X['PREV_MAX_MINUS_CURR_NN_LEFT'] = X['MAX_PREV_LEFT'] - X['X2']\n",
    "X['PREV_MAX_MINUS_CURR_NN_RIGHT'] = X['MAX_PREV_RIGHT'] - X['X4']\n",
    "\n",
    "X['PREV_MIN_MINUS_CURR_NN_LEFT'] = X['MIN_PREV_LEFT'] - X['X2']\n",
    "X['PREV_MIN_MINUS_CURR_NN_RIGHT'] = X['MIN_PREV_RIGHT'] - X['X4']\n",
    "\n",
    "X['PREV_MAX_DIV_CURR_LEFT'] = X['MAX_PREV_LEFT'] / X['X2']\n",
    "X['PREV_MAX_DIV_CURR_RIGHT'] = X['MAX_PREV_RIGHT'] / X['X4']\n",
    "\n",
    "X['PREV_MIN_DIV_CURR_LEFT'] = X['MIN_PREV_LEFT'] / X['X2']\n",
    "X['PREV_MIN_DIV_CURR_RIGHT'] = X['MIN_PREV_RIGHT'] / X['X4']\n",
    "\n",
    "X['CURR_MAX_DIV_MIN_LEFT'] = X['MAX_CURR_LEFT'] / X['MIN_CURR_LEFT']\n",
    "X['CURR_MAX_DIV_MIN_RIGHT'] = X['MAX_CURR_RIGHT'] / X['MIN_CURR_RIGHT']\n",
    "\n",
    "X['CURR_MAX_DIV_MEAN_LEFT'] = X['MAX_CURR_LEFT'] / X['MEAN_CURR_LEFT']\n",
    "X['CURR_MAX_DIV_MEAN_RIGHT'] = X['MAX_CURR_RIGHT'] / X['MEAN_CURR_RIGHT']\n",
    "\n",
    "X['CURR_MIN_DIV_MEAN_LEFT'] = X['MIN_CURR_LEFT'] / X['MEAN_CURR_LEFT']\n",
    "X['CURR_MIN_DIV_MEAN_RIGHT'] = X['MIN_CURR_RIGHT'] / X['MEAN_CURR_RIGHT']\n",
    "\n",
    "X['CURR_MAX_MINUS_MIN_LEFT'] = X['MAX_CURR_LEFT'] - X['MIN_CURR_LEFT']\n",
    "X['CURR_MAX_MINUS_MIN_RIGHT'] = X['MAX_CURR_RIGHT'] - X['MIN_CURR_RIGHT']\n",
    "\n",
    "X['CURR_MAX_MINUS_MEAN_LEFT'] = X['MAX_CURR_LEFT'] - X['MEAN_CURR_LEFT']\n",
    "X['CURR_MAX_MINUS_MEAN_RIGHT'] = X['MAX_CURR_RIGHT'] - X['MEAN_CURR_RIGHT']\n",
    "\n",
    "X['CURR_MEAN_MINUS_MIN_LEFT'] = X['MEAN_CURR_LEFT'] - X['MIN_CURR_LEFT']\n",
    "X['CURR_MEAN_MINUS_MIN_RIGHT'] = X['MEAN_CURR_RIGHT'] - X['MIN_CURR_RIGHT']\n",
    "\n",
    "X['CURR_CURR_DIV_MEAN_LEFT'] = X['X2'] / X['MEAN_CURR_LEFT']\n",
    "X['CURR_CURR_DIV_MEAN_RIGHT'] = X['X4'] / X['MEAN_CURR_RIGHT']\n",
    "\n",
    "X['CURR_MEAN_MINUS_CURR_LEFT'] = X['MEAN_CURR_LEFT'] - X['X2']\n",
    "X['CURR_MEAN_MINUS_CURR_RIGHT'] = X['MEAN_CURR_RIGHT'] - X['X4']\n",
    "\n",
    "X['CURR_MAX_MINUS_CURR_LEFT'] = (X['MAX_CURR_LEFT'] - X['X2']) / X['MEAN_CURR_LEFT']\n",
    "X['CURR_MAX_MINUS_CURR_RIGHT'] = (X['MAX_CURR_RIGHT'] - X['X4']) / X['MEAN_CURR_RIGHT']\n",
    "\n",
    "X['CURR_MIN_MINUS_CURR_LEFT'] = (X['MIN_CURR_LEFT'] - X['X2']) / X['MEAN_CURR_LEFT']\n",
    "X['CURR_MIN_MINUS_CURR_RIGHT'] = (X['MIN_CURR_RIGHT'] - X['X4']) / X['MEAN_CURR_RIGHT']\n",
    "\n",
    "X['CURR_STD_DIV_MEAN_LEFT'] = X['STD_CURR_LEFT'] / X['MEAN_CURR_LEFT']\n",
    "X['CURR_STD_DIV_MEAN_RIGHT'] = X['STD_CURR_RIGHT'] / X['MEAN_CURR_RIGHT']\n",
    "\n",
    "\n",
    "X['CURR_STD_DIV_CURR_LEFT'] = X['STD_CURR_LEFT'] / X['X2']\n",
    "X['CURR_STD_DIV_CURR_RIGHT'] = X['STD_CURR_RIGHT'] / X['X4']\n",
    "\n",
    "\n",
    "X['CURR_MAX_MINUS_MIN_NORMALIZED_LEFT'] = (X['MAX_CURR_LEFT'] - X['MIN_CURR_LEFT']) / X['MEAN_CURR_LEFT']\n",
    "X['CURR_MAX_MINUS_MIN_NORMALIZED_RIGHT'] = (X['MAX_CURR_RIGHT'] - X['MIN_CURR_RIGHT']) / X['MEAN_CURR_RIGHT']\n",
    "\n",
    "X['CURR_MAX_MINUS_CURR_NN_LEFT'] = X['MAX_CURR_LEFT'] - X['X2']\n",
    "X['CURR_MAX_MINUS_CURR_NN_RIGHT'] = X['MAX_CURR_RIGHT'] - X['X4']\n",
    "\n",
    "X['CURR_MIN_MINUS_CURR_NN_LEFT'] = X['MIN_CURR_LEFT'] - X['X2']\n",
    "X['CURR_MIN_MINUS_CURR_NN_RIGHT'] = X['MIN_CURR_RIGHT'] - X['X4']\n",
    "\n",
    "X['CURR_MAX_DIV_CURR_LEFT'] = X['MAX_CURR_LEFT'] / X['X2']\n",
    "X['CURR_MAX_DIV_CURR_RIGHT'] = X['MAX_CURR_RIGHT'] / X['X4']\n",
    "\n",
    "X['CURR_MIN_DIV_CURR_LEFT'] = X['MIN_CURR_LEFT'] / X['X2']\n",
    "X['CURR_MIN_DIV_CURR_RIGHT'] = X['MIN_CURR_RIGHT'] / X['X4']\n",
    "\n",
    "X['NEXT_MAX_DIV_MIN_LEFT'] = X['MAX_NEXT_LEFT'] / X['MIN_NEXT_LEFT']\n",
    "X['NEXT_MAX_DIV_MIN_RIGHT'] = X['MAX_NEXT_RIGHT'] / X['MIN_NEXT_RIGHT']\n",
    "\n",
    "X['NEXT_MAX_DIV_MEAN_LEFT'] = X['MAX_NEXT_LEFT'] / X['MEAN_NEXT_LEFT']\n",
    "X['NEXT_MAX_DIV_MEAN_RIGHT'] = X['MAX_NEXT_RIGHT'] / X['MEAN_NEXT_RIGHT']\n",
    "\n",
    "X['NEXT_MIN_DIV_MEAN_LEFT'] = X['MIN_NEXT_LEFT'] / X['MEAN_NEXT_LEFT']\n",
    "X['NEXT_MIN_DIV_MEAN_RIGHT'] = X['MIN_NEXT_RIGHT'] / X['MEAN_NEXT_RIGHT']\n",
    "\n",
    "X['NEXT_MAX_MINUS_MIN_LEFT'] = X['MAX_NEXT_LEFT'] - X['MIN_NEXT_LEFT']\n",
    "X['NEXT_MAX_MINUS_MIN_RIGHT'] = X['MAX_NEXT_RIGHT'] - X['MIN_NEXT_RIGHT']\n",
    "\n",
    "X['NEXT_MAX_MINUS_MEAN_LEFT'] = X['MAX_NEXT_LEFT'] - X['MEAN_NEXT_LEFT']\n",
    "X['NEXT_MAX_MINUS_MEAN_RIGHT'] = X['MAX_NEXT_RIGHT'] - X['MEAN_NEXT_RIGHT']\n",
    "\n",
    "X['NEXT_MEAN_MINUS_MIN_LEFT'] = X['MEAN_NEXT_LEFT'] - X['MIN_NEXT_LEFT']\n",
    "X['NEXT_MEAN_MINUS_MIN_RIGHT'] = X['MEAN_NEXT_RIGHT'] - X['MIN_NEXT_RIGHT']\n",
    "\n",
    "X['NEXT_CURR_DIV_MEAN_LEFT'] = X['X2'] / X['MEAN_NEXT_LEFT']\n",
    "X['NEXT_CURR_DIV_MEAN_RIGHT'] = X['X4'] / X['MEAN_NEXT_RIGHT']\n",
    "\n",
    "X['NEXT_MEAN_MINUS_CURR_LEFT'] = X['MEAN_NEXT_LEFT'] - X['X2']\n",
    "X['NEXT_MEAN_MINUS_CURR_RIGHT'] = X['MEAN_NEXT_RIGHT'] - X['X4']\n",
    "\n",
    "X['NEXT_MAX_MINUS_CURR_LEFT'] = (X['MAX_NEXT_LEFT'] - X['X2']) / X['MEAN_NEXT_LEFT']\n",
    "X['NEXT_MAX_MINUS_CURR_RIGHT'] = (X['MAX_NEXT_RIGHT'] - X['X4']) / X['MEAN_CURR_RIGHT']\n",
    "\n",
    "X['NEXT_MIN_MINUS_CURR_LEFT'] = (X['MIN_NEXT_LEFT'] - X['X2']) / X['MEAN_NEXT_LEFT']\n",
    "X['NEXT_MIN_MINUS_CURR_RIGHT'] = (X['MIN_NEXT_RIGHT'] - X['X4']) / X['MEAN_NEXT_RIGHT']\n",
    "\n",
    "X['NEXT_STD_DIV_MEAN_LEFT'] = X['STD_NEXT_LEFT'] / X['MEAN_NEXT_LEFT']\n",
    "X['NEXT_STD_DIV_MEAN_RIGHT'] = X['STD_NEXT_RIGHT'] / X['MEAN_NEXT_RIGHT']\n",
    "\n",
    "\n",
    "X['NEXT_STD_DIV_CURR_LEFT'] = X['STD_NEXT_LEFT'] / X['X2']\n",
    "X['NEXT_STD_DIV_CURR_RIGHT'] = X['STD_NEXT_RIGHT'] / X['X4']\n",
    "\n",
    "\n",
    "X['NEXT_MAX_MINUS_MIN_NORMALIZED_LEFT'] = (X['MAX_NEXT_LEFT'] - X['MIN_NEXT_LEFT']) / X['MEAN_NEXT_LEFT']\n",
    "X['NEXT_MAX_MINUS_MIN_NORMALIZED_RIGHT'] = (X['MAX_NEXT_RIGHT'] - X['MIN_NEXT_RIGHT']) / X['MEAN_NEXT_RIGHT']\n",
    "\n",
    "X['NEXT_MAX_MINUS_CURR_NN_LEFT'] = X['MAX_NEXT_LEFT'] - X['X2']\n",
    "X['NEXT_MAX_MINUS_CURR_NN_RIGHT'] = X['MAX_NEXT_RIGHT'] - X['X4']\n",
    "\n",
    "X['NEXT_MIN_MINUS_CURR_NN_LEFT'] = X['MIN_NEXT_LEFT'] - X['X2']\n",
    "X['NEXT_MIN_MINUS_CURR_NN_RIGHT'] = X['MIN_NEXT_RIGHT'] - X['X4']\n",
    "\n",
    "X['NEXT_MAX_DIV_CURR_LEFT'] = X['MAX_NEXT_LEFT'] / X['X2']\n",
    "X['NEXT_MAX_DIV_CURR_RIGHT'] = X['MAX_NEXT_RIGHT'] / X['X4']\n",
    "\n",
    "X['NEXT_MIN_DIV_CURR_LEFT'] = X['MIN_NEXT_LEFT'] / X['X2']\n",
    "X['NEXT_MIN_DIV_CURR_RIGHT'] = X['MIN_NEXT_RIGHT'] / X['X4']\n",
    "\n",
    "X['NEXT_PREV_MAX_DIV_MIN_LEFT'] = X['MAX_NEXT_LEFT'] / X['MIN_PREV_LEFT']\n",
    "X['NEXT_PREV_MAX_DIV_MIN_RIGHT'] = X['MAX_NEXT_RIGHT'] / X['MIN_PREV_RIGHT']\n",
    "\n",
    "X['NEXT_PREV_MAX_DIV_MEAN_LEFT'] = X['MAX_NEXT_LEFT'] / X['MEAN_PREV_LEFT']\n",
    "X['NEXT_PREV_MAX_DIV_MEAN_RIGHT'] = X['MAX_NEXT_RIGHT'] / X['MEAN_PREV_RIGHT']\n",
    "\n",
    "X['NEXT_PREV_MIN_DIV_MEAN_LEFT'] = X['MIN_NEXT_LEFT'] / X['MEAN_PREV_LEFT']\n",
    "X['NEXT_PREV_MIN_DIV_MEAN_RIGHT'] = X['MIN_NEXT_RIGHT'] / X['MEAN_PREV_RIGHT']\n",
    "\n",
    "X['NEXT_PREV_MAX_MINUS_MIN_LEFT'] = X['MAX_NEXT_LEFT'] - X['MIN_PREV_LEFT']\n",
    "X['NEXT_PREV_MAX_MINUS_MIN_RIGHT'] = X['MAX_NEXT_RIGHT'] - X['MIN_PREV_RIGHT']\n",
    "\n",
    "X['NEXT_PREV_MAX_MINUS_MEAN_LEFT'] = X['MAX_NEXT_LEFT'] - X['MEAN_PREV_LEFT']\n",
    "X['NEXT_PREV_MAX_MINUS_MEAN_RIGHT'] = X['MAX_NEXT_RIGHT'] - X['MEAN_PREV_RIGHT']\n",
    "\n",
    "X['NEXT_PREV_MEAN_MINUS_MIN_LEFT'] = X['MEAN_NEXT_LEFT'] - X['MIN_PREV_LEFT']\n",
    "X['NEXT_PREV_MEAN_MINUS_MIN_RIGHT'] = X['MEAN_NEXT_RIGHT'] - X['MIN_PREV_RIGHT']\n",
    "\n",
    "X['NEXT_PREV_STD_DIV_MEAN_LEFT'] = X['STD_NEXT_LEFT'] / X['MEAN_PREV_LEFT']\n",
    "X['NEXT_PREV_STD_DIV_MEAN_RIGHT'] = X['STD_NEXT_RIGHT'] / X['MEAN_PREV_RIGHT']\n",
    "\n",
    "X['NEXT_PREV_MAX_MINUS_MIN_NORMALIZED_LEFT'] = (X['MAX_NEXT_LEFT'] - X['MIN_PREV_LEFT']) / X['MEAN_NEXT_LEFT']\n",
    "X['NEXT_PREV_MAX_MINUS_MIN_NORMALIZED_RIGHT'] = (X['MAX_NEXT_RIGHT'] - X['MIN_PREV_RIGHT']) / X['MEAN_NEXT_RIGHT']\n",
    "\n",
    "X['PREV_MAX_DIV_MIN_DIFF'] = X['PREV_MAX_DIV_MIN_LEFT'] - X['PREV_MAX_DIV_MIN_RIGHT']\n",
    "X['PREV_MAX_DIV_MEAN_DIFF'] = X['PREV_MAX_DIV_MEAN_LEFT'] - X['PREV_MAX_DIV_MEAN_RIGHT']\n",
    "X['PREV_MIN_DIV_MEAN_DIFF'] = X['PREV_MIN_DIV_MEAN_LEFT'] - X['PREV_MIN_DIV_MEAN_RIGHT']\n",
    "X['PREV_MAX_MINUS_MIN_DIFF'] = X['PREV_MAX_MINUS_MIN_LEFT'] - X['PREV_MAX_MINUS_MIN_RIGHT']\n",
    "X['PREV_MAX_MINUS_MEAN_DIFF'] = X['PREV_MAX_MINUS_MEAN_LEFT'] - X['PREV_MAX_MINUS_MEAN_RIGHT']\n",
    "X['PREV_MEAN_MINUS_MIN_DIFF'] = X['PREV_MEAN_MINUS_MIN_LEFT'] - X['PREV_MEAN_MINUS_MIN_RIGHT']\n",
    "X['PREV_CURR_DIV_MEAN_DIFF'] = X['PREV_CURR_DIV_MEAN_LEFT'] - X['PREV_CURR_DIV_MEAN_RIGHT']\n",
    "X['PREV_MEAN_MINUS_CURR_DIFF'] = X['PREV_MEAN_MINUS_CURR_LEFT'] - X['PREV_MEAN_MINUS_CURR_RIGHT']\n",
    "X['PREV_MAX_MINUS_CURR_DIFF'] = X['PREV_MAX_MINUS_CURR_LEFT'] - X['PREV_MAX_MINUS_CURR_RIGHT']\n",
    "X['PREV_MIN_MINUS_CURR_DIFF'] = X['PREV_MIN_MINUS_CURR_LEFT'] - X['PREV_MIN_MINUS_CURR_RIGHT']\n",
    "\n",
    "##############################\n",
    "\n",
    "X['PREV_STD_DIV_MEAN_DIFF'] = X['PREV_STD_DIV_MEAN_LEFT'] - X['PREV_STD_DIV_MEAN_RIGHT']\n",
    "X['PREV_STD_DIV_CURR_DIFF'] = X['PREV_STD_DIV_CURR_LEFT'] - X['PREV_STD_DIV_CURR_RIGHT']\n",
    "X['PREV_MAX_MINUS_MIN_NORMALIZED_DIFF'] = X['PREV_MAX_MINUS_MIN_NORMALIZED_LEFT'] - X['PREV_MAX_MINUS_MIN_NORMALIZED_RIGHT']\n",
    "X['PREV_MAX_MINUS_CURR_NN_DIFF'] = X['PREV_MAX_MINUS_CURR_NN_LEFT'] - X['PREV_MAX_MINUS_CURR_NN_RIGHT']\n",
    "X['PREV_MIN_MINUS_CURR_NN_DIFF'] = X['PREV_MIN_MINUS_CURR_NN_LEFT'] - X['PREV_MIN_MINUS_CURR_NN_RIGHT']\n",
    "X['PREV_MAX_DIV_CURR_DIFF'] = X['PREV_MAX_DIV_CURR_LEFT'] - X['PREV_MAX_DIV_CURR_RIGHT']\n",
    "X['PREV_MIN_DIV_CURR_DIFF'] = X['PREV_MIN_DIV_CURR_LEFT'] - X['PREV_MIN_DIV_CURR_RIGHT']\n",
    "\n",
    "X['PREV_LEFT_CURR_DIV_RIGHT_MEAN'] = X['X2'] / X['MEAN_PREV_RIGHT']\n",
    "X['PREV_RIGHT_CURR_DIV_LEFT_MEAN'] = X['X4'] / X['MEAN_PREV_LEFT']\n",
    "\n",
    "X['PREV_LEFT_CURR_MINUS_RIGHT_MEAN'] = X['X2'] - X['MEAN_PREV_RIGHT']\n",
    "X['PREV_RIGHT_CURR_MINUS_LEFT_MEAN'] = X['X4'] - X['MEAN_PREV_LEFT']\n",
    "\n",
    "X['PREV_RIGHT_CURR_MINUS_LEFT_MAX'] = X['X4'] - X['MAX_PREV_LEFT']\n",
    "X['PREV_LEFT_CURR_MINUS_RIGHT_MAX'] = X['X2'] - X['MAX_PREV_RIGHT']\n",
    "\n",
    "X['PREV_RIGHT_CURR_MINUS_LEFT_MIN'] = X['X4'] - X['MIN_PREV_LEFT']\n",
    "X['PREV_LEFT_CURR_MINUS_RIGHT_MIN'] = X['X2'] - X['MIN_PREV_RIGHT']\n",
    "\n",
    "X['PREV_LEFT_STD_DIV_RIGHT_CURR'] = X['STD_PREV_LEFT'] / X['X4']\n",
    "X['PREV_RIGHT_STD_DIV_RIGHT_CURR'] = X['STD_PREV_RIGHT'] / X['X2']\n",
    "\n",
    "X['PREV_LEFT_STD_DIV_RIGHT_MEAN'] = X['STD_PREV_LEFT'] / X['MEAN_PREV_RIGHT']\n",
    "X['PREV_RIGHT_STD_DIV_LEFT_MEAN'] = X['STD_PREV_RIGHT'] / X['MEAN_PREV_LEFT']\n",
    "\n",
    "X['PREV_LEFT_CURR_DIV_RIGHT_MEAN_DIFF'] = X['PREV_LEFT_CURR_DIV_RIGHT_MEAN'] - X['PREV_RIGHT_CURR_DIV_LEFT_MEAN']\n",
    "X['PREV_LEFT_CURR_MINUS_RIGHT_MEAN_DIFF'] = X['PREV_LEFT_CURR_MINUS_RIGHT_MEAN'] - X['PREV_RIGHT_CURR_MINUS_LEFT_MEAN']\n",
    "X['PREV_RIGHT_CURR_MINUS_LEFT_MAX_DIFF'] = X['PREV_RIGHT_CURR_MINUS_LEFT_MAX'] - X['PREV_LEFT_CURR_MINUS_RIGHT_MAX']\n",
    "X['PREV_RIGHT_CURR_MINUS_LEFT_MIN_DIFF'] = X['PREV_RIGHT_CURR_MINUS_LEFT_MIN'] - X['PREV_LEFT_CURR_MINUS_RIGHT_MIN']\n",
    "X['PREV_LEFT_STD_DIV_RIGHT_CURR_DIFF'] = X['PREV_LEFT_STD_DIV_RIGHT_CURR'] - X['PREV_RIGHT_STD_DIV_RIGHT_CURR']\n",
    "X['PREV_LEFT_STD_DIV_RIGHT_MEAN'] = X['PREV_LEFT_STD_DIV_RIGHT_MEAN'] - X['PREV_RIGHT_STD_DIV_LEFT_MEAN']\n",
    "\n",
    "##############################\n",
    "X['PREV_MEAN_DIFF'] = X['MEAN_PREV_LEFT'] - X['MEAN_PREV_RIGHT']\n",
    "X['PREV_MAX_MIN_DIFF'] = X['MAX_MIN_PREV_LEFT'] - X['MAX_MIN_PREV_RIGHT']\n",
    "X['PREV_MAX_DIFF'] = X['MAX_PREV_LEFT'] - X['MAX_PREV_RIGHT']\n",
    "X['PREV_MIN_DIFF'] = X['MIN_PREV_LEFT'] - X['MIN_PREV_RIGHT']\n",
    "\n",
    "X['CURR_MAX_DIV_MIN_DIFF'] = X['CURR_MAX_DIV_MIN_LEFT'] - X['CURR_MAX_DIV_MIN_RIGHT']\n",
    "X['CURR_MAX_DIV_MEAN_DIFF'] = X['CURR_MAX_DIV_MEAN_LEFT'] - X['CURR_MAX_DIV_MEAN_RIGHT']\n",
    "X['CURR_MIN_DIV_MEAN_DIFF'] = X['CURR_MIN_DIV_MEAN_LEFT'] - X['CURR_MIN_DIV_MEAN_RIGHT']\n",
    "X['CURR_MAX_MINUS_MIN_DIFF'] = X['CURR_MAX_MINUS_MIN_LEFT'] - X['CURR_MAX_MINUS_MIN_RIGHT']\n",
    "X['CURR_MAX_MINUS_MEAN_DIFF'] = X['CURR_MAX_MINUS_MEAN_LEFT'] - X['CURR_MAX_MINUS_MEAN_RIGHT']\n",
    "X['CURR_MEAN_MINUS_MIN_DIFF'] = X['CURR_MEAN_MINUS_MIN_LEFT'] - X['CURR_MEAN_MINUS_MIN_RIGHT']\n",
    "X['CURR_CURR_DIV_MEAN_DIFF'] = X['CURR_CURR_DIV_MEAN_LEFT'] - X['CURR_CURR_DIV_MEAN_RIGHT']\n",
    "X['CURR_MEAN_MINUS_CURR_DIFF'] = X['CURR_MEAN_MINUS_CURR_LEFT'] - X['CURR_MEAN_MINUS_CURR_RIGHT']\n",
    "X['CURR_MAX_MINUS_CURR_DIFF'] = X['CURR_MAX_MINUS_CURR_LEFT'] - X['CURR_MAX_MINUS_CURR_RIGHT']\n",
    "X['CURR_MIN_MINUS_CURR_DIFF'] = X['CURR_MIN_MINUS_CURR_LEFT'] - X['CURR_MIN_MINUS_CURR_RIGHT']\n",
    "\n",
    "##############################\n",
    "\n",
    "X['CURR_STD_DIV_MEAN_DIFF'] = X['CURR_STD_DIV_MEAN_LEFT'] - X['CURR_STD_DIV_MEAN_RIGHT']\n",
    "X['CURR_STD_DIV_CURR_DIFF'] = X['CURR_STD_DIV_CURR_LEFT'] - X['CURR_STD_DIV_CURR_RIGHT']\n",
    "X['CURR_MAX_MINUS_MIN_NORMALIZED_DIFF'] = X['CURR_MAX_MINUS_MIN_NORMALIZED_LEFT'] - X['CURR_MAX_MINUS_MIN_NORMALIZED_RIGHT']\n",
    "X['CURR_MAX_MINUS_CURR_NN_DIFF'] = X['CURR_MAX_MINUS_CURR_NN_LEFT'] - X['CURR_MAX_MINUS_CURR_NN_RIGHT']\n",
    "X['CURR_MIN_MINUS_CURR_NN_DIFF'] = X['CURR_MIN_MINUS_CURR_NN_LEFT'] - X['CURR_MIN_MINUS_CURR_NN_RIGHT']\n",
    "X['CURR_MAX_DIV_CURR_DIFF'] = X['CURR_MAX_DIV_CURR_LEFT'] - X['CURR_MAX_DIV_CURR_RIGHT']\n",
    "X['CURR_MIN_DIV_CURR_DIFF'] = X['CURR_MIN_DIV_CURR_LEFT'] - X['CURR_MIN_DIV_CURR_RIGHT']\n",
    "\n",
    "X['CURR_LEFT_CURR_DIV_RIGHT_MEAN'] = X['X2'] / X['MEAN_CURR_RIGHT']\n",
    "X['CURR_RIGHT_CURR_DIV_LEFT_MEAN'] = X['X4'] / X['MEAN_CURR_LEFT']\n",
    "\n",
    "X['CURR_LEFT_CURR_MINUS_RIGHT_MEAN'] = X['X2'] - X['MEAN_CURR_RIGHT']\n",
    "X['CURR_RIGHT_CURR_MINUS_LEFT_MEAN'] = X['X4'] - X['MEAN_CURR_LEFT']\n",
    "\n",
    "X['CURR_RIGHT_CURR_MINUS_LEFT_MAX'] = X['X4'] - X['MAX_CURR_LEFT']\n",
    "X['CURR_LEFT_CURR_MINUS_RIGHT_MAX'] = X['X2'] - X['MAX_CURR_RIGHT']\n",
    "\n",
    "X['CURR_RIGHT_CURR_MINUS_LEFT_MIN'] = X['X4'] - X['MIN_CURR_LEFT']\n",
    "X['CURR_LEFT_CURR_MINUS_RIGHT_MIN'] = X['X2'] - X['MIN_CURR_RIGHT']\n",
    "\n",
    "X['CURR_LEFT_STD_DIV_RIGHT_CURR'] = X['STD_CURR_LEFT'] / X['X4']\n",
    "X['CURR_RIGHT_STD_DIV_RIGHT_CURR'] = X['STD_CURR_RIGHT'] / X['X2']\n",
    "\n",
    "X['CURR_LEFT_STD_DIV_RIGHT_MEAN'] = X['STD_CURR_LEFT'] / X['MEAN_CURR_RIGHT']\n",
    "X['CURR_RIGHT_STD_DIV_LEFT_MEAN'] = X['STD_CURR_RIGHT'] / X['MEAN_CURR_LEFT']\n",
    "\n",
    "X['CURR_LEFT_CURR_DIV_RIGHT_MEAN_DIFF'] = X['CURR_LEFT_CURR_DIV_RIGHT_MEAN'] - X['CURR_RIGHT_CURR_DIV_LEFT_MEAN']\n",
    "X['CURR_LEFT_CURR_MINUS_RIGHT_MEAN_DIFF'] = X['CURR_LEFT_CURR_MINUS_RIGHT_MEAN'] - X['CURR_RIGHT_CURR_MINUS_LEFT_MEAN']\n",
    "X['CURR_RIGHT_CURR_MINUS_LEFT_MAX_DIFF'] = X['CURR_RIGHT_CURR_MINUS_LEFT_MAX'] - X['CURR_LEFT_CURR_MINUS_RIGHT_MAX']\n",
    "X['CURR_RIGHT_CURR_MINUS_LEFT_MIN_DIFF'] = X['CURR_RIGHT_CURR_MINUS_LEFT_MIN'] - X['CURR_LEFT_CURR_MINUS_RIGHT_MIN']\n",
    "X['CURR_LEFT_STD_DIV_RIGHT_CURR_DIFF'] = X['CURR_LEFT_STD_DIV_RIGHT_CURR'] - X['CURR_RIGHT_STD_DIV_RIGHT_CURR']\n",
    "X['CURR_LEFT_STD_DIV_RIGHT_MEAN'] = X['CURR_LEFT_STD_DIV_RIGHT_MEAN'] - X['CURR_RIGHT_STD_DIV_LEFT_MEAN']\n",
    "\n",
    "##############################\n",
    "X['CURR_MEAN_DIFF'] = X['MEAN_CURR_LEFT'] - X['MEAN_CURR_RIGHT']\n",
    "X['CURR_MAX_MIN_DIFF'] = X['MAX_MIN_CURR_LEFT'] - X['MAX_MIN_CURR_RIGHT']\n",
    "X['CURR_MAX_DIFF'] = X['MAX_CURR_LEFT'] - X['MAX_CURR_RIGHT']\n",
    "X['CURR_MIN_DIFF'] = X['MIN_CURR_LEFT'] - X['MIN_CURR_RIGHT']\n",
    "\n",
    "X['NEXT_MAX_DIV_MIN_DIFF'] = X['NEXT_MAX_DIV_MIN_LEFT'] - X['NEXT_MAX_DIV_MIN_RIGHT']\n",
    "X['NEXT_MAX_DIV_MEAN_DIFF'] = X['NEXT_MAX_DIV_MEAN_LEFT'] - X['NEXT_MAX_DIV_MEAN_RIGHT']\n",
    "X['NEXT_MIN_DIV_MEAN_DIFF'] = X['NEXT_MIN_DIV_MEAN_LEFT'] - X['NEXT_MIN_DIV_MEAN_RIGHT']\n",
    "X['NEXT_MAX_MINUS_MIN_DIFF'] = X['NEXT_MAX_MINUS_MIN_LEFT'] - X['NEXT_MAX_MINUS_MIN_RIGHT']\n",
    "X['NEXT_MAX_MINUS_MEAN_DIFF'] = X['NEXT_MAX_MINUS_MEAN_LEFT'] - X['NEXT_MAX_MINUS_MEAN_RIGHT']\n",
    "X['NEXT_MEAN_MINUS_MIN_DIFF'] = X['NEXT_MEAN_MINUS_MIN_LEFT'] - X['NEXT_MEAN_MINUS_MIN_RIGHT']\n",
    "X['NEXT_CURR_DIV_MEAN_DIFF'] = X['NEXT_CURR_DIV_MEAN_LEFT'] - X['NEXT_CURR_DIV_MEAN_RIGHT']\n",
    "X['NEXT_MEAN_MINUS_CURR_DIFF'] = X['NEXT_MEAN_MINUS_CURR_LEFT'] - X['NEXT_MEAN_MINUS_CURR_RIGHT']\n",
    "X['NEXT_MAX_MINUS_CURR_DIFF'] = X['NEXT_MAX_MINUS_CURR_LEFT'] - X['NEXT_MAX_MINUS_CURR_RIGHT']\n",
    "X['NEXT_MIN_MINUS_CURR_DIFF'] = X['NEXT_MIN_MINUS_CURR_LEFT'] - X['NEXT_MIN_MINUS_CURR_RIGHT']\n",
    "\n",
    "##############################\n",
    "\n",
    "X['NEXT_STD_DIV_MEAN_DIFF'] = X['NEXT_STD_DIV_MEAN_LEFT'] - X['NEXT_STD_DIV_MEAN_RIGHT']\n",
    "X['NEXT_STD_DIV_CURR_DIFF'] = X['NEXT_STD_DIV_CURR_LEFT'] - X['NEXT_STD_DIV_CURR_RIGHT']\n",
    "X['NEXT_MAX_MINUS_MIN_NORMALIZED_DIFF'] = X['NEXT_MAX_MINUS_MIN_NORMALIZED_LEFT'] - X['NEXT_MAX_MINUS_MIN_NORMALIZED_RIGHT']\n",
    "X['NEXT_MAX_MINUS_CURR_NN_DIFF'] = X['NEXT_MAX_MINUS_CURR_NN_LEFT'] - X['NEXT_MAX_MINUS_CURR_NN_RIGHT']\n",
    "X['NEXT_MIN_MINUS_CURR_NN_DIFF'] = X['NEXT_MIN_MINUS_CURR_NN_LEFT'] - X['NEXT_MIN_MINUS_CURR_NN_RIGHT']\n",
    "X['NEXT_MAX_DIV_CURR_DIFF'] = X['NEXT_MAX_DIV_CURR_LEFT'] - X['NEXT_MAX_DIV_CURR_RIGHT']\n",
    "X['NEXT_MIN_DIV_CURR_DIFF'] = X['NEXT_MIN_DIV_CURR_LEFT'] - X['NEXT_MIN_DIV_CURR_RIGHT']\n",
    "\n",
    "X['NEXT_LEFT_CURR_DIV_RIGHT_MEAN'] = X['X2'] / X['MEAN_NEXT_RIGHT']\n",
    "X['NEXT_RIGHT_CURR_DIV_LEFT_MEAN'] = X['X4'] / X['MEAN_NEXT_LEFT']\n",
    "\n",
    "X['NEXT_LEFT_CURR_MINUS_RIGHT_MEAN'] = X['X2'] - X['MEAN_NEXT_RIGHT']\n",
    "X['NEXT_RIGHT_CURR_MINUS_LEFT_MEAN'] = X['X4'] - X['MEAN_NEXT_LEFT']\n",
    "\n",
    "X['NEXT_RIGHT_CURR_MINUS_LEFT_MAX'] = X['X4'] - X['MAX_NEXT_LEFT']\n",
    "X['NEXT_LEFT_CURR_MINUS_RIGHT_MAX'] = X['X2'] - X['MAX_NEXT_RIGHT']\n",
    "\n",
    "X['NEXT_RIGHT_CURR_MINUS_LEFT_MIN'] = X['X4'] - X['MIN_NEXT_LEFT']\n",
    "X['NEXT_LEFT_CURR_MINUS_RIGHT_MIN'] = X['X2'] - X['MIN_NEXT_RIGHT']\n",
    "\n",
    "X['NEXT_LEFT_STD_DIV_RIGHT_CURR'] = X['STD_NEXT_LEFT'] / X['X4']\n",
    "X['NEXT_RIGHT_STD_DIV_RIGHT_CURR'] = X['STD_NEXT_RIGHT'] / X['X2']\n",
    "\n",
    "X['NEXT_LEFT_STD_DIV_RIGHT_MEAN'] = X['STD_NEXT_LEFT'] / X['MEAN_NEXT_RIGHT']\n",
    "X['NEXT_RIGHT_STD_DIV_LEFT_MEAN'] = X['STD_NEXT_RIGHT'] / X['MEAN_NEXT_LEFT']\n",
    "\n",
    "X['NEXT_LEFT_CURR_DIV_RIGHT_MEAN_DIFF'] = X['NEXT_LEFT_CURR_DIV_RIGHT_MEAN'] - X['NEXT_RIGHT_CURR_DIV_LEFT_MEAN']\n",
    "X['NEXT_LEFT_CURR_MINUS_RIGHT_MEAN_DIFF'] = X['NEXT_LEFT_CURR_MINUS_RIGHT_MEAN'] - X['NEXT_RIGHT_CURR_MINUS_LEFT_MEAN']\n",
    "X['NEXT_RIGHT_CURR_MINUS_LEFT_MAX_DIFF'] = X['NEXT_RIGHT_CURR_MINUS_LEFT_MAX'] - X['NEXT_LEFT_CURR_MINUS_RIGHT_MAX']\n",
    "X['NEXT_RIGHT_CURR_MINUS_LEFT_MIN_DIFF'] = X['NEXT_RIGHT_CURR_MINUS_LEFT_MIN'] - X['NEXT_LEFT_CURR_MINUS_RIGHT_MIN']\n",
    "X['NEXT_LEFT_STD_DIV_RIGHT_CURR_DIFF'] = X['NEXT_LEFT_STD_DIV_RIGHT_CURR'] - X['NEXT_RIGHT_STD_DIV_RIGHT_CURR']\n",
    "X['NEXT_LEFT_STD_DIV_RIGHT_MEAN'] = X['NEXT_LEFT_STD_DIV_RIGHT_MEAN'] - X['NEXT_RIGHT_STD_DIV_LEFT_MEAN']\n",
    "\n",
    "##############################\n",
    "X['NEXT_MEAN_DIFF'] = X['MEAN_NEXT_LEFT'] - X['MEAN_NEXT_RIGHT']\n",
    "X['NEXT_MAX_MIN_DIFF'] = X['MAX_MIN_NEXT_LEFT'] - X['MAX_MIN_NEXT_RIGHT']\n",
    "X['NEXT_MAX_DIFF'] = X['MAX_NEXT_LEFT'] - X['MAX_NEXT_RIGHT']\n",
    "X['NEXT_MIN_DIFF'] = X['MIN_NEXT_LEFT'] - X['MIN_NEXT_RIGHT']\n",
    "\n",
    "X['PERCENTILE_PREV_DIFF'] = X['PERCENTILE_PREV_LEFT'] - X['PERCENTILE_PREV_RIGHT']\n",
    "X['PERCENTILE_CURR_DIFF'] = X['PERCENTILE_CURR_LEFT'] - X['PERCENTILE_CURR_RIGHT']\n",
    "X['PERCENTILE_NEXT_DIFF'] = X['PERCENTILE_NEXT_LEFT'] - X['PERCENTILE_NEXT_RIGHT']\n",
    "X['PERCENTILE_NEXT_PREV_CROSS_DIFF'] = X['PERCENTILE_NEXT_LEFT'] - X['PERCENTILE_PREV_RIGHT']\n",
    "X['PERCENTILE_NEXT_PREV_LEFT'] = X['PERCENTILE_NEXT_LEFT'] - X['PERCENTILE_PREV_LEFT']\n",
    "X['PERCENTILE_NEXT_PREV_RIGHT'] = X['PERCENTILE_NEXT_RIGHT'] - X['PERCENTILE_PREV_RIGHT']\n",
    "X['PERCENTILE_NEXT_PREV_DIFF'] = X['PERCENTILE_NEXT_PREV_LEFT'] - X['PERCENTILE_NEXT_PREV_RIGHT']\n",
    "\n",
    "\n",
    "X['NEXT_PREV_MAX_DIV_MIN_DIFF'] = X['NEXT_PREV_MAX_DIV_MIN_LEFT'] - X['NEXT_PREV_MAX_DIV_MIN_RIGHT']\n",
    "X['NEXT_PREV_MAX_DIV_MEAN_DIFF'] = X['NEXT_PREV_MAX_DIV_MEAN_LEFT'] - X['NEXT_PREV_MAX_DIV_MEAN_RIGHT']\n",
    "X['NEXT_PREV_MIN_DIV_MEAN_DIFF'] = X['NEXT_PREV_MIN_DIV_MEAN_LEFT'] - X['NEXT_PREV_MIN_DIV_MEAN_RIGHT']\n",
    "X['NEXT_PREV_MAX_MINUS_MIN_DIFF'] = X['NEXT_PREV_MAX_MINUS_MIN_LEFT'] - X['NEXT_PREV_MAX_MINUS_MIN_RIGHT']\n",
    "X['NEXT_PREV_MAX_MINUS_MEAN_DIFF'] = X['NEXT_PREV_MAX_MINUS_MEAN_LEFT'] - X['NEXT_PREV_MAX_MINUS_MEAN_RIGHT']\n",
    "X['NEXT_PREV_MEAN_MINUS_MIN_DIFF'] = X['NEXT_PREV_MEAN_MINUS_MIN_LEFT'] - X['NEXT_PREV_MEAN_MINUS_MIN_RIGHT']\n",
    "\n",
    "##############################\n",
    "\n",
    "X['NEXT_PREV_STD_DIV_MEAN_DIFF'] = X['NEXT_PREV_STD_DIV_MEAN_LEFT'] - X['NEXT_PREV_STD_DIV_MEAN_RIGHT']\n",
    "X['NEXT_PREV_MAX_MINUS_MIN_NORMALIZED_DIFF'] = X['NEXT_PREV_MAX_MINUS_MIN_NORMALIZED_LEFT'] - X['NEXT_PREV_MAX_MINUS_MIN_NORMALIZED_RIGHT']\n",
    "\n",
    "##############################\n",
    "X['NEXT_PREV_MEAN_LEFT']= X['MEAN_NEXT_LEFT'] - X['MEAN_PREV_LEFT']\n",
    "X['NEXT_PREV_MEAN_RIGHT']= X['MEAN_NEXT_RIGHT'] - X['MEAN_PREV_RIGHT']\n",
    "X['NEXT_PREV_MAX_LEFT']= X['MAX_NEXT_LEFT'] - X['MAX_PREV_LEFT']\n",
    "X['NEXT_PREV_MAX_RIGHT']= X['MAX_NEXT_RIGHT'] - X['MAX_PREV_RIGHT']\n",
    "X['NEXT_PREV_MIN_LEFT']= X['MIN_NEXT_LEFT'] - X['MIN_PREV_LEFT']\n",
    "X['NEXT_PREV_MIN_RIGHT']= X['MIN_NEXT_RIGHT'] - X['MIN_PREV_RIGHT']\n",
    "\n",
    "X['NEXT_PREV_MEAN_DIFF'] = X['NEXT_PREV_MEAN_LEFT'] - X['NEXT_PREV_MEAN_RIGHT']\n",
    "X['NEXT_PREV_MAX_DIFF'] = X['NEXT_PREV_MAX_LEFT'] - X['NEXT_PREV_MAX_RIGHT']\n",
    "X['NEXT_PREV_MIN_DIFF'] = X['NEXT_PREV_MIN_LEFT'] - X['NEXT_PREV_MIN_RIGHT']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "COUNTERINGS = np.load('./counterings_test.npy')[:, 0]\n",
    "X['counterings'] = COUNTERINGS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Глобальные рейтинги"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "X['MEAN_LEFT'] = 0.0\n",
    "X['MIN_LEFT'] = 0.0\n",
    "X['MAX_LEFT'] = 0.0\n",
    "X['STD_LEFT'] = 0.0\n",
    "X['MAX_MIN_LEFT'] = 0.0\n",
    "X['MAX_TO_MEAN_LEFT'] = 0.0\n",
    "X['MIN_TO_MEAN_LEFT'] = 0.0\n",
    "X['STD_TO_MEAN_LEFT'] = 0.0\n",
    "\n",
    "\n",
    "X['MEAN_RIGHT'] = 0.0\n",
    "X['MIN_RIGHT'] = 0.0\n",
    "X['MAX_RIGHT'] = 0.0\n",
    "X['STD_RIGHT'] = 0.0\n",
    "X['MAX_MIN_RIGHT'] = 0.0\n",
    "X['MAX_TO_MEAN_RIGHT'] = 0.0\n",
    "X['MIN_TO_MEAN_RIGHT'] = 0.0\n",
    "X['STD_TO_MEAN_RIGHT'] = 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "user_rating_stats = np.load('./user_rating_stats_full.npy', allow_pickle=True).item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\andry\\Anaconda3\\envs\\subjectify\\lib\\site-packages\\ipykernel_launcher.py:1: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d68235654b55459696356448008da0d7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', layout=Layout(width='20px'), max=1.0), HTML(value=''…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "for idx, row in tqdm.tqdm_notebook(X.iterrows()):\n",
    "    left = user_rating_stats[row['X1']]\n",
    "    right = user_rating_stats[row['X3']]\n",
    "    X.at[idx, 'MEAN_LEFT'] = left[0]\n",
    "    X.at[idx, 'MAX_LEFT'] = left[1]\n",
    "    X.at[idx, 'MIN_LEFT'] = left[2]\n",
    "    X.at[idx, 'STD_LEFT'] = left[3]\n",
    "    X.at[idx, 'MAX_MIN_LEFT'] = (left[1] - left[2]) / left[0]\n",
    "    X.at[idx, 'MAX_TO_MEAN_LEFT'] = left[1] / left[0]\n",
    "    X.at[idx, 'MIN_TO_MEAN_LEFT'] = left[2] / left[0]\n",
    "    X.at[idx, 'STD_TO_MEAN_LEFT'] = left[3] / left[0]\n",
    "    \n",
    "    X.at[idx, 'MEAN_RIGHT'] = right[0]\n",
    "    X.at[idx, 'MAX_RIGHT'] = right[1]\n",
    "    X.at[idx, 'MIN_RIGHT'] = right[2]\n",
    "    X.at[idx, 'STD_RIGHT'] = right[3]\n",
    "    X.at[idx, 'MAX_MIN_RIGHT'] = (right[1] - right[2]) / right[0]\n",
    "    X.at[idx, 'MAX_TO_MEAN_RIGHT'] = right[1] / right[0]\n",
    "    X.at[idx, 'MIN_TO_MEAN_RIGHT'] = right[2] / right[0]\n",
    "    X.at[idx, 'STD_TO_MEAN_RIGHT'] = right[3] / right[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\andry\\Anaconda3\\envs\\subjectify\\lib\\site-packages\\ipykernel_launcher.py:3: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "696371bfc9734b3881c01906f6a368f6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=970949.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "user_outs = np.load('./user_outs.npy', allow_pickle=True)\n",
    "user_history = {}\n",
    "for usr, data in tqdm.tqdm_notebook(user_outs):\n",
    "    user_history[usr] = data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\andry\\Anaconda3\\envs\\subjectify\\lib\\site-packages\\ipykernel_launcher.py:4: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
      "  after removing the cwd from sys.path.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b2f0dfbb4de042678970486fa4f90b09",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=1.0, bar_style='info', layout=Layout(width='20px'), max=1.0), HTML(value=''…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "X['PERCENTILE_LEFT'] = 0.0\n",
    "X['PERCENTILE_RIGHT'] = 0.0\n",
    "\n",
    "for idx, row in tqdm.tqdm_notebook(X.iterrows()):\n",
    "    left = user_history[row['X1']]\n",
    "    right = user_history[row['X3']]\n",
    "    X.at[idx, 'PERCENTILE_LEFT'] = scipy.stats.percentileofscore(left, row['X2'])\n",
    "    X.at[idx, 'PERCENTILE_RIGHT'] = scipy.stats.percentileofscore(right, row['X4'])\n",
    "    \n",
    "X['PERCENTILE_DIFF'] = X['PERCENTILE_LEFT'] - X['PERCENTILE_RIGHT']    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "X['MAX_DIV_MIN_LEFT'] = X['MAX_LEFT'] / X['MIN_LEFT']\n",
    "X['MAX_DIV_MIN_RIGHT'] = X['MAX_RIGHT'] / X['MIN_RIGHT']\n",
    "\n",
    "X['MAX_DIV_MEAN_LEFT'] = X['MAX_LEFT'] / X['MEAN_LEFT']\n",
    "X['MAX_DIV_MEAN_RIGHT'] = X['MAX_RIGHT'] / X['MEAN_RIGHT']\n",
    "\n",
    "X['MIN_DIV_MEAN_LEFT'] = X['MIN_LEFT'] / X['MEAN_LEFT']\n",
    "X['MIN_DIV_MEAN_RIGHT'] = X['MIN_RIGHT'] / X['MEAN_RIGHT']\n",
    "\n",
    "X['MAX_MINUS_MIN_LEFT'] = X['MAX_LEFT'] - X['MIN_LEFT']\n",
    "X['MAX_MINUS_MIN_RIGHT'] = X['MAX_RIGHT'] - X['MIN_RIGHT']\n",
    "\n",
    "X['MAX_MINUS_MEAN_LEFT'] = X['MAX_LEFT'] - X['MEAN_LEFT']\n",
    "X['MAX_MINUS_MEAN_RIGHT'] = X['MAX_RIGHT'] - X['MEAN_RIGHT']\n",
    "\n",
    "X['MEAN_MINUS_MIN_LEFT'] = X['MEAN_LEFT'] - X['MIN_LEFT']\n",
    "X['MEAN_MINUS_MIN_RIGHT'] = X['MEAN_RIGHT'] - X['MIN_RIGHT']\n",
    "\n",
    "X['CURR_DIV_MEAN_LEFT'] = X['X2'] / X['MEAN_LEFT']\n",
    "X['CURR_DIV_MEAN_RIGHT'] = X['X4'] / X['MEAN_RIGHT']\n",
    "\n",
    "X['MEAN_MINUS_CURR_LEFT'] = X['MEAN_LEFT'] - X['X2']\n",
    "X['MEAN_MINUS_CURR_RIGHT'] = X['MEAN_RIGHT'] - X['X4']\n",
    "\n",
    "X['MAX_MINUS_CURR_LEFT'] = (X['MAX_LEFT'] - X['X2']) / X['MEAN_LEFT']\n",
    "X['MAX_MINUS_CURR_RIGHT'] = (X['MAX_RIGHT'] - X['X4']) / X['MEAN_RIGHT']\n",
    "\n",
    "X['MIN_MINUS_CURR_LEFT'] = (X['MIN_LEFT'] - X['X2']) / X['MEAN_LEFT']\n",
    "X['MIN_MINUS_CURR_RIGHT'] = (X['MIN_RIGHT'] - X['X4']) / X['MEAN_RIGHT']\n",
    "\n",
    "######################################################\n",
    "X['STD_DIV_MEAN_LEFT'] = X['STD_LEFT'] / X['MEAN_LEFT']\n",
    "X['STD_DIV_MEAN_RIGHT'] = X['STD_RIGHT'] / X['MEAN_RIGHT']\n",
    "\n",
    "\n",
    "X['STD_DIV_CURR_LEFT'] = X['STD_LEFT'] / X['X2']\n",
    "X['STD_DIV_CURR_RIGHT'] = X['STD_RIGHT'] / X['X4']\n",
    "\n",
    "\n",
    "X['MAX_MINUS_MIN_NORMALIZED_LEFT'] = (X['MAX_LEFT'] - X['MIN_LEFT']) / X['MEAN_LEFT']\n",
    "X['MAX_MINUS_MIN_NORMALIZED_RIGHT'] = (X['MAX_RIGHT'] - X['MIN_RIGHT']) / X['MEAN_RIGHT']\n",
    "\n",
    "X['MAX_MINUS_CURR_NN_LEFT'] = X['MAX_LEFT'] - X['X2']\n",
    "X['MAX_MINUS_CURR_NN_RIGHT'] = X['MAX_RIGHT'] - X['X4']\n",
    "\n",
    "X['MIN_MINUS_CURR_NN_LEFT'] = X['MIN_LEFT'] - X['X2']\n",
    "X['MIN_MINUS_CURR_NN_RIGHT'] = X['MIN_RIGHT'] - X['X4']\n",
    "\n",
    "X['MAX_DIV_CURR_LEFT'] = X['MAX_LEFT'] / X['X2']\n",
    "X['MAX_DIV_CURR_RIGHT'] = X['MAX_RIGHT'] / X['X4']\n",
    "\n",
    "X['MIN_DIV_CURR_LEFT'] = X['MIN_LEFT'] / X['X2']\n",
    "X['MIN_DIV_CURR_RIGHT'] = X['MIN_RIGHT'] / X['X4']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "X['MAX_DIV_MIN_DIFF'] = X['MAX_DIV_MIN_LEFT'] - X['MAX_DIV_MIN_RIGHT']\n",
    "X['MAX_DIV_MEAN_DIFF'] = X['MAX_DIV_MEAN_LEFT'] - X['MAX_DIV_MEAN_RIGHT']\n",
    "X['MIN_DIV_MEAN_DIFF'] = X['MIN_DIV_MEAN_LEFT'] - X['MIN_DIV_MEAN_RIGHT']\n",
    "X['MAX_MINUS_MIN_DIFF'] = X['MAX_MINUS_MIN_LEFT'] - X['MAX_MINUS_MIN_RIGHT']\n",
    "X['MAX_MINUS_MEAN_DIFF'] = X['MAX_MINUS_MEAN_LEFT'] - X['MAX_MINUS_MEAN_RIGHT']\n",
    "X['MEAN_MINUS_MIN_DIFF'] = X['MEAN_MINUS_MIN_LEFT'] - X['MEAN_MINUS_MIN_RIGHT']\n",
    "X['CURR_DIV_MEAN_DIFF'] = X['CURR_DIV_MEAN_LEFT'] - X['CURR_DIV_MEAN_RIGHT']\n",
    "X['MEAN_MINUS_CURR_DIFF'] = X['MEAN_MINUS_CURR_LEFT'] - X['MEAN_MINUS_CURR_RIGHT']\n",
    "X['MAX_MINUS_CURR_DIFF'] = X['MAX_MINUS_CURR_LEFT'] - X['MAX_MINUS_CURR_RIGHT']\n",
    "X['MIN_MINUS_CURR_DIFF'] = X['MIN_MINUS_CURR_LEFT'] - X['MIN_MINUS_CURR_RIGHT']\n",
    "\n",
    "##############################\n",
    "\n",
    "X['STD_DIV_MEAN_DIFF'] = X['STD_DIV_MEAN_LEFT'] - X['STD_DIV_MEAN_RIGHT']\n",
    "X['STD_DIV_CURR_DIFF'] = X['STD_DIV_CURR_LEFT'] - X['STD_DIV_CURR_RIGHT']\n",
    "X['MAX_MINUS_MIN_NORMALIZED_DIFF'] = X['MAX_MINUS_MIN_NORMALIZED_LEFT'] - X['MAX_MINUS_MIN_NORMALIZED_RIGHT']\n",
    "X['MAX_MINUS_CURR_NN_DIFF'] = X['MAX_MINUS_CURR_NN_LEFT'] - X['MAX_MINUS_CURR_NN_RIGHT']\n",
    "X['MIN_MINUS_CURR_NN_DIFF'] = X['MIN_MINUS_CURR_NN_LEFT'] - X['MIN_MINUS_CURR_NN_RIGHT']\n",
    "X['MAX_DIV_CURR_DIFF'] = X['MAX_DIV_CURR_LEFT'] - X['MAX_DIV_CURR_RIGHT']\n",
    "X['MIN_DIV_CURR_DIFF'] = X['MIN_DIV_CURR_LEFT'] - X['MIN_DIV_CURR_RIGHT']\n",
    "\n",
    "X['LEFT_CURR_DIV_RIGHT_MEAN'] = X['X2'] / X['MEAN_RIGHT']\n",
    "X['RIGHT_CURR_DIV_LEFT_MEAN'] = X['X4'] / X['MEAN_LEFT']\n",
    "\n",
    "X['LEFT_CURR_MINUS_RIGHT_MEAN'] = X['X2'] - X['MEAN_RIGHT']\n",
    "X['RIGHT_CURR_MINUS_LEFT_MEAN'] = X['X4'] - X['MEAN_LEFT']\n",
    "\n",
    "X['RIGHT_CURR_MINUS_LEFT_MAX'] = X['X4'] - X['MAX_LEFT']\n",
    "X['LEFT_CURR_MINUS_RIGHT_MAX'] = X['X2'] - X['MAX_RIGHT']\n",
    "\n",
    "X['RIGHT_CURR_MINUS_LEFT_MIN'] = X['X4'] - X['MIN_LEFT']\n",
    "X['LEFT_CURR_MINUS_RIGHT_MIN'] = X['X2'] - X['MIN_RIGHT']\n",
    "\n",
    "X['LEFT_STD_DIV_RIGHT_CURR'] = X['STD_LEFT'] / X['X4']\n",
    "X['RIGHT_STD_DIV_RIGHT_CURR'] = X['STD_RIGHT'] / X['X2']\n",
    "\n",
    "X['LEFT_STD_DIV_RIGHT_MEAN'] = X['STD_LEFT'] / X['MEAN_RIGHT']\n",
    "X['RIGHT_STD_DIV_LEFT_MEAN'] = X['STD_RIGHT'] / X['MEAN_LEFT']\n",
    "\n",
    "X['LEFT_CURR_DIV_RIGHT_MEAN_DIFF'] = X['LEFT_CURR_DIV_RIGHT_MEAN'] - X['RIGHT_CURR_DIV_LEFT_MEAN']\n",
    "X['LEFT_CURR_MINUS_RIGHT_MEAN_DIFF'] = X['LEFT_CURR_MINUS_RIGHT_MEAN'] - X['RIGHT_CURR_MINUS_LEFT_MEAN']\n",
    "X['RIGHT_CURR_MINUS_LEFT_MAX_DIFF'] = X['RIGHT_CURR_MINUS_LEFT_MAX'] - X['LEFT_CURR_MINUS_RIGHT_MAX']\n",
    "X['RIGHT_CURR_MINUS_LEFT_MIN_DIFF'] = X['RIGHT_CURR_MINUS_LEFT_MIN'] - X['LEFT_CURR_MINUS_RIGHT_MIN']\n",
    "X['LEFT_STD_DIV_RIGHT_CURR_DIFF'] = X['LEFT_STD_DIV_RIGHT_CURR'] - X['RIGHT_STD_DIV_RIGHT_CURR']\n",
    "X['LEFT_STD_DIV_RIGHT_MEAN'] = X['LEFT_STD_DIV_RIGHT_MEAN'] - X['RIGHT_STD_DIV_LEFT_MEAN']\n",
    "\n",
    "##############################\n",
    "X['MEAN_DIFF'] = X['MEAN_LEFT'] - X['MEAN_RIGHT']\n",
    "X['MAX_MIN_DIFF'] = X['MAX_MIN_LEFT'] - X['MAX_MIN_RIGHT']\n",
    "X['MAX_DIFF'] = X['MAX_LEFT'] - X['MAX_RIGHT']\n",
    "X['MIN_DIFF'] = X['MIN_LEFT'] - X['MIN_RIGHT']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "X['DIFF'] = X['X2'] - X['X4']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "X.drop(['Unnamed: 0', 'X1', 'X3', 'X5', 'X6', 'X7', 'X8', 'X9', 'X10', 'X11', 'X12', 'X13', 'X14', 'X15', 'X16', 'X17','X18', 'X19', 'X20',], axis=1, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "X['X0'] = X['X0'].astype(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_test = Pool(X, cat_features=['X0'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "converted_model = to_classifier(model)\n",
    "y_pred = converted_model.predict_proba(dataset_test)[:, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample = pd.read_csv('./sample_submission.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample['target'] = y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample.to_csv('./my_pred_new.csv', index=False)"
   ]
  },
  {
   "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}