submit_nn_dual_objective.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "import seaborn as sns\n",
    "import datetime\n",
    "import tqdm\n",
    "import re\n",
    "import time\n",
    "from string import punctuation\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "import lightgbm as lgb\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "import torch, torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "sns.set_style('darkgrid')\n",
    "mpl.rcParams['figure.figsize'] = [15,10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from kaggle.competitions import nflrush"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from string import punctuation\n",
    "import datetime\n",
    "import re\n",
    "import torch\n",
    "import math\n",
    "\n",
    "def crps(y_true, y_pred):\n",
    "    return np.mean(np.square(y_true - y_pred), axis=1)\n",
    "\n",
    "def yard_to_cdf(yard):\n",
    "    yard = np.round(yard).astype(int)\n",
    "    indices = yard+99\n",
    "    cdfs = np.zeros((yard.shape[0], 199))\n",
    "    for i in range(len(cdfs)):\n",
    "        cdfs[i, indices[i]:] = 1\n",
    "    return cdfs\n",
    "\n",
    "def cdf_to_yard(cdf):\n",
    "    yard_index = (cdf==1).argmax(axis=1)\n",
    "    yard = yard_index-99\n",
    "    return yard\n",
    "\n",
    "\n",
    "def cdf_to_yard_torch(cdf):\n",
    "    yard_index = torch.sum((torch.as_tensor(cdf) <= 0),dim=1)\n",
    "    yard = yard_index-99\n",
    "    return yard\n",
    "\n",
    "def crps_torch(y_true, y_pred):\n",
    "    y_true = torch.as_tensor(y_true)\n",
    "    y_pred = torch.as_tensor(y_pred)\n",
    "    return torch.mean((y_true - y_pred).pow(2), dim=1)\n",
    "\n",
    "def crps_loss(y_true, y_pred_pdf):\n",
    "    y_pred_cdf = torch.cumsum(torch.as_tensor(y_pred_pdf), dim=1)\n",
    "    return crps_torch(y_true, y_pred_cdf).mean()\n",
    "\n",
    "def crps_loss_cdf(y_true, y_pred_cdf):\n",
    "    return crps_torch(y_true, y_pred_cdf).mean()\n",
    "    \n",
    "def clean_StadiumType(txt):\n",
    "    if pd.isna(txt):\n",
    "        return np.nan\n",
    "    txt = txt.lower()\n",
    "    txt = ''.join([c for c in txt if c not in punctuation])\n",
    "    txt = re.sub(' +', ' ', txt)\n",
    "    txt = txt.strip()\n",
    "    txt = txt.replace('outside', 'outdoor')\n",
    "    txt = txt.replace('outdor', 'outdoor')\n",
    "    txt = txt.replace('outddors', 'outdoor')\n",
    "    txt = txt.replace('outdoors', 'outdoor')\n",
    "    txt = txt.replace('oudoor', 'outdoor')\n",
    "    txt = txt.replace('indoors', 'indoor')\n",
    "    txt = txt.replace('ourdoor', 'outdoor')\n",
    "    txt = txt.replace('retractable', 'rtr.')\n",
    "    return txt\n",
    "\n",
    "def transform_StadiumType(txt):\n",
    "    if pd.isna(txt):\n",
    "        return np.nan\n",
    "    if 'outdoor' in txt or 'open' in txt:\n",
    "        return 1\n",
    "    if 'indoor' in txt or 'closed' in txt:\n",
    "        return 0\n",
    "    return np.nan\n",
    "\n",
    "def str_to_seconds(txt):\n",
    "    txt = txt.split(':')\n",
    "    ans = int(txt[0])*60 + int(txt[1]) + int(txt[2])/60\n",
    "    return ans\n",
    "\n",
    "def str_to_float(txt):\n",
    "    try:\n",
    "        return float(txt)\n",
    "    except Exception as e:\n",
    "        return np.NaN\n",
    "\n",
    "def map_weather(txt):\n",
    "    ans = 1\n",
    "    if pd.isna(txt):\n",
    "        return 0\n",
    "    if 'partly' in txt:\n",
    "        ans*=0.5\n",
    "    if 'climate controlled' in txt or 'indoor' in txt:\n",
    "        return ans*3\n",
    "    if 'sunny' in txt or 'sun' in txt:\n",
    "        return ans*2\n",
    "    if 'clear' in txt:\n",
    "        return ans\n",
    "    if 'cloudy' in txt:\n",
    "        return -ans\n",
    "    if 'rain' in txt or 'rainy' in txt:\n",
    "        return -2*ans\n",
    "    if 'snow' in txt:\n",
    "        return -3*ans\n",
    "    return 0\n",
    "\n",
    "def final_drop_cols(df):\n",
    "    \"\"\"\n",
    "        Drop columns not used in X\n",
    "    \"\"\"\n",
    "    cols_to_drop = [\n",
    "        'Yards',\n",
    "        'PlayDirection', \n",
    "        'TeamOnOffense', 'NflId', 'NflIdRusher',\n",
    "        'TimeHandoff', 'TimeSnap', 'PlayerBirthDate',\n",
    "        'FieldPosition',\n",
    "         'DisplayName',\n",
    "         'PossessionTeam',\n",
    "         'PlayerCollegeName',\n",
    "         'Position',\n",
    "         'HomeTeamAbbr',\n",
    "         'VisitorTeamAbbr',\n",
    "         'Stadium',\n",
    "         'Location',\n",
    "         'GameId', 'PlayId', 'IsRusher', 'Team',\n",
    "         'IsRusher']\n",
    "    cols_to_drop = list(set(cols_to_drop).intersection(set(list(df.columns))))\n",
    "    df = df.drop(cols_to_drop, axis=1)\n",
    "    return df\n",
    "\n",
    "def standartize_orientations(df):\n",
    "    \"\"\"\n",
    "        https://www.kaggle.com/cpmpml/initial-wrangling-voronoi-areas-in-python\n",
    "    \n",
    "        Make sure the offensive team is always moving left to right.\n",
    "    \"\"\"\n",
    "    df['ToLeft'] = df.PlayDirection == \"left\"\n",
    "    df['TeamOnOffense'] = \"home\"\n",
    "    df.loc[df.PossessionTeam != df.HomeTeamAbbr, 'TeamOnOffense'] = \"away\"\n",
    "    df['IsOnOffense'] = df.Team == df.TeamOnOffense # Is player on offense?\n",
    "    df['HomeOnOffense'] = (df['TeamOnOffense'] == 'home').astype(int)\n",
    "\n",
    "    df['YardLine_std'] = 100 - df.YardLine\n",
    "    df.loc[df.FieldPosition.fillna('') == df.PossessionTeam,  \n",
    "              'YardLine_std'\n",
    "             ] = df.loc[df.FieldPosition.fillna('') == df.PossessionTeam,  \n",
    "              'YardLine']\n",
    "    df['X_std'] = df.X\n",
    "    df.loc[df.ToLeft, 'X_std'] = 120 - df.loc[df.ToLeft, 'X'] \n",
    "    df['Y_std'] = df.Y\n",
    "    df.loc[df.ToLeft, 'Y_std'] = 160/3 - df.loc[df.ToLeft, 'Y'] \n",
    "    \n",
    "    df['Dir_rad'] = np.mod(90 - df.Dir, 360) * math.pi/180.0\n",
    "    df['Dir_std'] = df.Dir_rad\n",
    "    df.loc[df.ToLeft, 'Dir_std'] = np.mod(np.pi + df.loc[df.ToLeft, 'Dir_rad'], 2*np.pi)\n",
    "\n",
    "    df['Orientation_rad'] = np.mod(df.Orientation, 360) * math.pi/180.0\n",
    "\n",
    "    df.loc[df.Season >= 2018, 'Orientation_rad'\n",
    "         ] = np.mod(df.loc[df.Season >= 2018, 'Orientation'] - 90, 360) * math.pi/180.0\n",
    "\n",
    "    df['Orientation_rad'] = np.mod(df.Orientation, 360) * math.pi/180.0\n",
    "    df.loc[df.Season >= 2018, 'Orientation_rad'\n",
    "             ] = np.mod(df.loc[df.Season >= 2018, 'Orientation'] - 90, 360) * math.pi/180.0\n",
    "    df['Orientation_std'] = df.Orientation_rad\n",
    "    df.loc[df.ToLeft, 'Orientation_std'] = np.mod(math.pi + df.loc[df.ToLeft, 'Orientation_rad'], 2*math.pi)\n",
    "    \n",
    "    replace_cols = ['YardLine', 'X', 'Y', 'Dir', 'Orientation']\n",
    "    for col in replace_cols:\n",
    "        df[col] = df[col+'_std']\n",
    "        df.drop([col+'_std'], axis=1, inplace=True)\n",
    "\n",
    "    drop_cols = ['Dir_rad', 'Orientation_rad']\n",
    "    for col in drop_cols:\n",
    "        df.drop([col], axis=1, inplace=True)\n",
    "\n",
    "    return df\n",
    "\n",
    "def clean_turf(df):\n",
    "    Turf = {'Field Turf':'Artificial', 'A-Turf Titan':'Artificial', 'Grass':'Natural', 'UBU Sports Speed S5-M':'Artificial', \n",
    "        'Artificial':'Artificial', 'DD GrassMaster':'Artificial', 'Natural Grass':'Natural', \n",
    "        'UBU Speed Series-S5-M':'Artificial', 'FieldTurf':'Artificial', 'FieldTurf 360':'Artificial', 'Natural grass':'Natural', 'grass':'Natural', \n",
    "        'Natural':'Natural', 'Artifical':'Artificial', 'FieldTurf360':'Artificial', 'Naturall Grass':'Natural', 'Field turf':'Artificial', \n",
    "        'SISGrass':'Artificial', 'Twenty-Four/Seven Turf':'Artificial', 'natural grass':'Natural'} \n",
    "\n",
    "    turf_type = df['Turf'].map(Turf)\n",
    "    df['TurfIsNatural'] = (turf_type == 'Natural')\n",
    "    df = df.drop(['Turf'], axis=1)\n",
    "    return df\n",
    "\n",
    "def clean_abbrs(df):\n",
    "    # CAREFUL. What if a new team appears?\n",
    "    map_abbr = {'ARI': 'ARZ', 'BAL': 'BLT', 'CLE': 'CLV', 'HOU': 'HST'}\n",
    "    for abb in df['PossessionTeam'].unique():\n",
    "        map_abbr[abb] = abb\n",
    "\n",
    "    def safe_map(val):\n",
    "        if map_abbr.get('val'):\n",
    "            return map_abbr[val]\n",
    "        else:\n",
    "            return val\n",
    "\n",
    "    df['PossessionTeam'] = df['PossessionTeam'].apply(safe_map)\n",
    "    df['HomeTeamAbbr'] = df['HomeTeamAbbr'].apply(safe_map)\n",
    "    df['VisitorTeamAbbr'] = df['VisitorTeamAbbr'].apply(safe_map)\n",
    "    return df\n",
    "\n",
    "def encode_formations(df):\n",
    "    # Formation columns\n",
    "    df = pd.concat([df.drop(['OffenseFormation'], axis=1), pd.get_dummies(df['OffenseFormation'], prefix='OffenseFormation')], axis=1)\n",
    "    # Filling missing dummy columns at test stage\n",
    "    expected_columns = ['OffenseFormation_ACE',\n",
    "         'OffenseFormation_EMPTY',\n",
    "         'OffenseFormation_JUMBO',\n",
    "         'OffenseFormation_PISTOL',\n",
    "         'OffenseFormation_SHOTGUN',\n",
    "         'OffenseFormation_SINGLEBACK',\n",
    "         'OffenseFormation_WILDCAT',\n",
    "         'OffenseFormation_I_FORM']\n",
    "    for col in expected_columns:\n",
    "        if not col in df.columns:\n",
    "            df[col] = 0\n",
    "    return df \n",
    "\n",
    "def clean_weather(df):\n",
    "    df['WindSpeed'] = df['WindSpeed'].apply(lambda x: x.lower().replace('mph', '').strip() if not pd.isna(x) else x)\n",
    "    df['WindSpeed'] = df['WindSpeed'].apply(lambda x: (int(x.split('-')[0])+int(x.split('-')[1]))/2 if not pd.isna(x) and '-' in x else x)\n",
    "    df['WindSpeed'] = df['WindSpeed'].apply(lambda x: (int(x.split()[0])+int(x.split()[-1]))/2 if not pd.isna(x) and type(x)!=float and 'gusts up to' in x else x)\n",
    "    df['WindSpeed'] = df['WindSpeed'].apply(str_to_float)\n",
    "\n",
    "    df = df.drop(['WindDirection'], axis=1)\n",
    "\n",
    "    df['GameWeather'] = df['GameWeather'].str.lower()\n",
    "    indoor = \"indoor\"\n",
    "    df['GameWeather'] = df['GameWeather'].apply(lambda x: indoor if not pd.isna(x) and indoor in x else x)\n",
    "    df['GameWeather'] = df['GameWeather'].apply(lambda x: x.replace('coudy', 'cloudy').replace('clouidy', 'cloudy').replace('party', 'partly') if not pd.isna(x) else x)\n",
    "    df['GameWeather'] = df['GameWeather'].apply(lambda x: x.replace('clear and sunny', 'sunny and clear') if not pd.isna(x) else x)\n",
    "    df['GameWeather'] = df['GameWeather'].apply(lambda x: x.replace('skies', '').replace(\"mostly\", \"\").strip() if not pd.isna(x) else x)\n",
    "    df['GameWeather'] = df['GameWeather'].apply(map_weather)\n",
    "    return df\n",
    "\n",
    "def encode_personell(df):\n",
    "    # DefensePersonnel\n",
    "    counts = []\n",
    "    for i, val in df['DefensePersonnel'].str.split(',').iteritems():\n",
    "        row = {'OL': 0, 'RB': 0, 'TE': 0, 'WR': 0, 'DL': 0, 'DB': 0, 'LB': 0, 'QB': 0}\n",
    "        if val is np.NaN:\n",
    "            counts.append({})\n",
    "            continue\n",
    "        for item in val:\n",
    "            name, number = item.strip().split(' ')[::-1]\n",
    "            row[name] = int(number)\n",
    "        counts.append(row)\n",
    "    defense_presonell_df = pd.DataFrame(counts)\n",
    "    defense_presonell_df.columns = ['defense_'+x for x in defense_presonell_df.columns]\n",
    "    defense_presonell_df = defense_presonell_df.fillna(0).astype(int)\n",
    "    defense_presonell_df.index = df.index\n",
    "    df = pd.concat([df.drop(['DefensePersonnel'], axis=1), defense_presonell_df], axis=1)\n",
    "\n",
    "\n",
    "    # OffensePersonnel\n",
    "    counts = []\n",
    "    for i, val in df['OffensePersonnel'].str.split(',').iteritems():\n",
    "        row = {'OL': 0, 'RB': 0, 'TE': 0, 'WR': 0, 'DL': 0, 'DB': 0, 'LB': 0, 'QB': 0}\n",
    "        if val is np.NaN:\n",
    "            counts.append({})\n",
    "            continue\n",
    "        for item in val:\n",
    "            name, number = item.strip().split(' ')[::-1]\n",
    "            row[name] = int(number)\n",
    "        counts.append(row)\n",
    "    offense_personnel_df = pd.DataFrame(counts)\n",
    "    offense_personnel_df.columns = ['offense_'+x for x in offense_personnel_df.columns]\n",
    "    offense_personnel_df = offense_personnel_df.fillna(0).astype(int)\n",
    "    offense_personnel_df.index = df.index\n",
    "    df = pd.concat([df.drop(['OffensePersonnel'], axis=1), offense_personnel_df], axis=1)\n",
    "    return df\n",
    "\n",
    "def engineer_features(df):\n",
    "    df['DefendersInTheBox_vs_Distance'] = (df['DefendersInTheBox'] / df['Distance'])\n",
    "    return df\n",
    "\n",
    "\n",
    "def preprocess_features(df):\n",
    "    \"\"\"Accepts df like train data, returns cleaned, standartized and enriched df\"\"\"\n",
    "\n",
    "    df = clean_abbrs(df)\n",
    "\n",
    "    df = standartize_orientations(df)\n",
    "\n",
    "    df = clean_turf(df)\n",
    "\n",
    "\n",
    "    df['StadiumType'] = df['StadiumType'].apply(clean_StadiumType)\n",
    "    df['StadiumTypeShort'] = df['StadiumType'].apply(transform_StadiumType)\n",
    "    df = df.drop(['StadiumType'], axis=1)\n",
    "\n",
    "    df['HomeField'] = df['FieldPosition'] == df['HomeTeamAbbr']\n",
    "    df['Field_eq_Possession'] = df['FieldPosition'] == df['PossessionTeam']\n",
    "    df['HomePossesion'] = (df['PossessionTeam'] == df['HomeTeamAbbr'])\n",
    "\n",
    "    df = encode_formations(df)\n",
    "\n",
    "    df['GameClock'] = df['GameClock'].apply(str_to_seconds)\n",
    "\n",
    "    df['PlayerHeight'] = df['PlayerHeight'].apply(lambda x: 12*int(x.split('-')[0])+int(x.split('-')[1]))\n",
    "    df['PlayerBMI'] = 703*(df['PlayerWeight']/(df['PlayerHeight'])**2)\n",
    "\n",
    "    df['TimeHandoff'] = pd.to_datetime(df['TimeHandoff'], utc=True)\n",
    "    df['TimeSnap'] = pd.to_datetime(df['TimeSnap'], utc=True)\n",
    "    df['TimeDelta'] = (df['TimeHandoff']-df['TimeSnap']).apply(lambda x: x.total_seconds())\n",
    "    df['PlayerBirthDate'] = df['PlayerBirthDate'].apply(lambda x: datetime.datetime.strptime(x, \"%m/%d/%Y\"))\n",
    "    df['PlayerBirthDate'] = pd.to_datetime(df['PlayerBirthDate'], utc=True)\n",
    "\n",
    "    seconds_in_year = 60*60*24*365.25\n",
    "    df['PlayerAge'] = (df['TimeHandoff']-df['PlayerBirthDate']).apply(lambda x: x.total_seconds())/seconds_in_year\n",
    "    # df = df.drop([], axis=1)\n",
    "\n",
    "    df = clean_weather(df)\n",
    "\n",
    "    df['IsRusher'] = df['NflId'] == df['NflIdRusher']\n",
    "    \n",
    "\n",
    "    df = encode_personell(df)\n",
    "\n",
    "    # Feature engineering\n",
    "    df = engineer_features(df)\n",
    "\n",
    "    df = sort_df(df)\n",
    "    \n",
    "    return df\n",
    "\n",
    "def sort_df(df):\n",
    "    df.sort_values(by=['PlayId', 'IsOnOffense', 'IsRusher'], inplace=True)\n",
    "    return df\n",
    "\n",
    "def make_x(df, fillna=True):\n",
    "    source_play_id = df['PlayId']\n",
    "\n",
    "    df = final_drop_cols(df)\n",
    "\n",
    "    if fillna:\n",
    "        df.fillna(-999, inplace=True)\n",
    "\n",
    "    # Player features\n",
    "    cols_player = ['X',\n",
    "         'Y',\n",
    "         'S',\n",
    "         'A',\n",
    "         'Dis',\n",
    "         'Orientation',\n",
    "         'Dir',\n",
    "         'JerseyNumber',\n",
    "         'PlayerHeight',\n",
    "         'PlayerWeight',\n",
    "         'PlayerBMI',\n",
    "         'PlayerAge']\n",
    "\n",
    "    all_cols_player = np.array([[f'pl{num}_'+x for x in cols_player] for num in range(1, 23)]).flatten()\n",
    "    # print('cols player', all_cols_player)\n",
    "\n",
    "    X = np.array(df[cols_player]).reshape(-1, len(cols_player)*22)\n",
    "\n",
    "    play_id_index = source_play_id[::22]\n",
    "    X_df = pd.DataFrame(X, columns=all_cols_player, index=play_id_index)\n",
    "\n",
    "    assert df[cols_player].shape[0] == X_df.shape[0] * 22\n",
    "    assert df[cols_player].shape[1] == X_df.shape[1] / 22\n",
    "\n",
    "    # Play features\n",
    "    # print(list(df.drop(cols_player, axis=1).columns))\n",
    "    cols_play = ['Season', 'YardLine', 'Quarter', 'GameClock', 'Down', 'Distance', 'HomeScoreBeforePlay', 'VisitorScoreBeforePlay', 'DefendersInTheBox', 'Week', 'GameWeather', 'Temperature', 'Humidity', 'WindSpeed', 'ToLeft', 'IsOnOffense', 'HomeOnOffense', 'TurfIsNatural', 'StadiumTypeShort', 'HomeField', 'Field_eq_Possession', 'HomePossesion', 'OffenseFormation_ACE', 'OffenseFormation_EMPTY', 'OffenseFormation_I_FORM', 'OffenseFormation_JUMBO', 'OffenseFormation_PISTOL', 'OffenseFormation_SHOTGUN', 'OffenseFormation_SINGLEBACK', 'OffenseFormation_WILDCAT', 'TimeDelta', 'defense_DB', 'defense_DL', 'defense_LB', 'defense_OL', 'defense_QB', 'defense_RB', 'defense_TE', 'defense_WR', 'offense_DB', 'offense_DL', 'offense_LB', 'offense_OL', 'offense_QB', 'offense_RB', 'offense_TE', 'offense_WR', 'DefendersInTheBox_vs_Distance']\n",
    "\n",
    "    X_play_col = np.zeros(shape=(X.shape[0], len(cols_play)))\n",
    "    for i, col in enumerate(cols_play):\n",
    "        X_play_col[:, i] = df[col][::22]\n",
    "\n",
    "    X_play_col_df = pd.DataFrame(X_play_col, columns=cols_play, index=play_id_index)\n",
    "    assert X_df.shape[0] == X_play_col_df.shape[0]\n",
    "    X_df = pd.concat([X_df, X_play_col_df], axis=1)\n",
    "\n",
    "    assert X_df.shape[0] == source_play_id.drop_duplicates().count()\n",
    "    return X_df\n",
    "\n",
    "def make_y(X, df):\n",
    "    y = np.zeros(shape=(X.shape[0], 199))\n",
    "    for i, yard in enumerate(df['Yards'][::22]):\n",
    "        y[i, yard+99:] = np.ones(shape=(1, 100-yard))\n",
    "    return y\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df_train = pd.read_csv('/kaggle/input/nfl-big-data-bowl-2020/train.csv', dtype={'WindSpeed': 'object'})\n",
    "df_train = pd.read_csv('data/train.csv', dtype={'WindSpeed': 'object'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train_preprocessed = preprocess_features(df_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = make_x(df_train_preprocessed, fillna=True)\n",
    "y_train = make_y(X_train, df_train_preprocessed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((23171, 312), (23171, 199))"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape, y_train.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "N_FEATURES = X_train.shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def iterate_minibatches(X, y, batchsize):\n",
    "    X = torch.as_tensor(X)\n",
    "    y = torch.as_tensor(y)\n",
    "    indices = np.random.permutation(np.arange(len(X)))\n",
    "    for start in range(0, len(indices), batchsize):\n",
    "        ix = indices[start: start + batchsize]\n",
    "        yield X[ix], y[ix]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "DEVICE = 'cpu'\n",
    "BATCH_SIZE = 32\n",
    "LEARNING_RATE = 0.002\n",
    "NUM_EPOCHS = 100\n",
    "EARLY_STOP_AFTER = 10\n",
    "WEIGHT_DECAY = 0.0002\n",
    "SCHEDULER_PATIENCE = 5\n",
    "L1_LOSS_WEIGHT = 0.001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NeuralNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.seq = nn.Sequential(\n",
    "            nn.Linear(N_FEATURES, N_FEATURES),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.1),\n",
    "            nn.BatchNorm1d(N_FEATURES),\n",
    "            nn.Linear(N_FEATURES, N_FEATURES),\n",
    "            nn.ReLU(),\n",
    "            nn.BatchNorm1d(N_FEATURES),\n",
    "            nn.Linear(N_FEATURES, N_FEATURES),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.1),\n",
    "            nn.BatchNorm1d(N_FEATURES),\n",
    "        )\n",
    "        self.head_classifier = nn.Sequential(\n",
    "            nn.Linear(N_FEATURES, 199),\n",
    "            nn.Softmax()\n",
    "        )\n",
    "        self.head_regressor = nn.Sequential(\n",
    "            nn.Linear(N_FEATURES, 1),\n",
    "        )\n",
    "\n",
    "    def forward(self, x_batch):\n",
    "        latent_out = self.seq.forward(x_batch)\n",
    "        return self.head_classifier(latent_out), self.head_regressor(latent_out)\n",
    "\n",
    "    def loss(self, x_batch, y_batch):\n",
    "        y_batch = torch.as_tensor(y_batch).double().to(device=DEVICE)\n",
    "        y_pdf, y_yard = self(x_batch)\n",
    "        loss_crps = crps_loss(y_batch, y_pdf)\n",
    "        \n",
    "        y_yard = y_yard.flatten().double()\n",
    "        y_batch_yard = cdf_to_yard_torch(y_batch).double()\n",
    "        loss_mae = torch.mean(torch.abs(y_batch_yard-y_yard))\n",
    "        return loss_crps + loss_mae*L1_LOSS_WEIGHT\n",
    "\n",
    "    def predict_pdf(self, x_batch):\n",
    "        y_pdf, y_yard = self(x_batch)\n",
    "        return y_pdf\n",
    "    \n",
    "    def predict_cdf(self, x_batch):\n",
    "        y_pred_pdf = self.predict_pdf(x_batch)\n",
    "        y_pred_pdf = y_pred_pdf.cpu().data\n",
    "        y_pred_cdf = torch.cumsum(y_pred_pdf, dim=1).data.numpy()\n",
    "        y_pred_cdf = np.round(np.clip(y_pred_cdf, 0, 1), 10)\n",
    "        return y_pred_cdf\n",
    "\n",
    "model = NeuralNet()\n",
    "model = model.double().to(device=DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, opt, scheduler, X_train, y_train, X_val, y_val, early_stop_patience, batch_size, n_epochs):\n",
    "    train_loss = []\n",
    "    train_loss_stds = []\n",
    "    val_accuracy = []\n",
    "    val_accuracy_stds = []\n",
    "\n",
    "    best_val_acc = None\n",
    "    best_model = None\n",
    "    patience = 0\n",
    "\n",
    "    for epoch in range(n_epochs):\n",
    "        try:\n",
    "            opt.zero_grad()\n",
    "\n",
    "            start_time = time.time()\n",
    "            model.train(True)\n",
    "            epoch_loss = []\n",
    "\n",
    "            for X_batch, y_batch in iter(iterate_minibatches(X_train, y_train, batch_size)):\n",
    "                loss = model.loss(X_batch, y_batch)\n",
    "                epoch_loss.append(float(loss.item()))\n",
    "                loss.backward()\n",
    "                opt.step()\n",
    "                opt.zero_grad()\n",
    "\n",
    "            train_loss.append(np.mean(epoch_loss))\n",
    "            train_loss_stds.append(np.std(epoch_loss))\n",
    "            model.train(False)\n",
    "\n",
    "            epoch_val_acc = []\n",
    "            for X_batch, y_batch in iter(iterate_minibatches(X_val, y_val, batch_size)): \n",
    "                y_val_pred_cdf = model.predict_cdf(X_batch)\n",
    "                val_loss = crps_loss_cdf(y_batch, y_val_pred_cdf)\n",
    "                epoch_val_acc.append(val_loss.item())\n",
    "            val_acc = np.mean(epoch_val_acc)\n",
    "            val_accuracy.append(val_acc)\n",
    "            val_accuracy_stds.append(np.std(epoch_val_acc))\n",
    "\n",
    "\n",
    "            scheduler.step(val_acc)\n",
    "\n",
    "            # Then we print the results for this epoch:\n",
    "            print(\"Epoch {} of {} took {:.3f}s\".format(\n",
    "                epoch + 1, n_epochs, time.time() - start_time))\n",
    "            print(\"  training loss: \\t{:.6f}\".format(train_loss[-1]))\n",
    "            print(\"  validation score: \\t\\t\\t{:.6f}\".format(val_accuracy[-1]))\n",
    "\n",
    "            if best_val_acc is None or val_acc < best_val_acc:\n",
    "                best_val_acc = val_acc\n",
    "                patience = 0\n",
    "                torch.save(model.state_dict(), 'best_model')\n",
    "            else:\n",
    "                patience += 1\n",
    "                print(f'Validation score has not improved for {patience} epochs.')\n",
    "            if patience >= early_stop_patience:\n",
    "                print('Early stopping.')\n",
    "                break\n",
    "        except KeyboardInterrupt:\n",
    "            break\n",
    "    model.load_state_dict(torch.load('best_model'))\n",
    "    model.train(False)\n",
    "\n",
    "    history = {\n",
    "        'train_loss': train_loss,\n",
    "        'train_loss_stds': train_loss_stds,\n",
    "        'val_accuracy': val_accuracy,\n",
    "        'val_accuracy_stds': val_accuracy_stds,\n",
    "    }\n",
    "    \n",
    "    return model, history\n",
    "\n",
    "def train_nn_pipeline(model, X, y, early_stop_after=EARLY_STOP_AFTER, batch_size=BATCH_SIZE, n_epochs=NUM_EPOCHS):\n",
    "    scaler = MinMaxScaler()\n",
    "    X = scaler.fit_transform(X)\n",
    "    X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.1)\n",
    "    \n",
    "    opt = torch.optim.Adamax(model.parameters(), lr=LEARNING_RATE, weight_decay=WEIGHT_DECAY)\n",
    "    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(opt, mode='min', patience=SCHEDULER_PATIENCE, verbose=True, threshold=1e-6, eps=1e-9)\n",
    "\n",
    "    model, train_history = train(model, opt, scheduler, X_train, y_train, X_val, y_val, early_stop_after, batch_size, n_epochs)\n",
    "    \n",
    "    return model, scaler, train_history\n",
    "\n",
    "def nn_pipeline_predict(model, scaler, X):\n",
    "    X = torch.as_tensor(scaler.transform(X)).to(device=DEVICE)\n",
    "    y_pred = model.predict_cdf(X)\n",
    "    return y_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 of 100 took 17.961s\n",
      "  training loss: \t0.020740\n",
      "  validation score: \t\t\t0.014938\n",
      "Epoch 2 of 100 took 17.954s\n",
      "  training loss: \t0.018619\n",
      "  validation score: \t\t\t0.015204\n",
      "Validation score has not improved for 1 epochs.\n"
     ]
    }
   ],
   "source": [
    "model, scaler, history = train_nn_pipeline(model, X_train, y_train, n_epochs=NUM_EPOCHS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmYAAAEICAYAAAD1Ojg9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeXyU5b3//9dkspN9vbNAAiFcIckAAgKKCqhYQGBoq3U5tlqXtp5ae7qcnnpOv13P+Z7aRVu3c/o72lZtLaW2ZcKOC6htFQW3ycIFYVGWTMKuyB7y+2MGv2kOyLAkcyd5Px8PHo+Zua/7uq/bj5N8ct3X/bk9HR0diIiIiEjsxcV6ACIiIiISpsRMRERExCWUmImIiIi4hBIzEREREZdQYiYiIiLiEkrMRERERFxCiZmIxJQxptwY02GMiY+8X2KMuTmatmdxrH81xjx6LuM9Rb+3GGP+cr777Q7GmJXGmNtjPQ4RObmz+uEmInKCMWYp8Kq19ttdPvcDvwBKrbXHou3PWjv9PI1rMvAba21pp77/7/no262MMSsJn/N5Tz5FpGdoxkxEztXjwE3GGE+Xzz8N/PZMkjIRkf5OM2Yicq7mA/8NXAq8CGCMyQZmAuMj768G/h2oAPYBj1lrv3uyzjrP+hhjvMC9wC3Ae8BPu7T9LPANoBTYAdxrrf2FMWYAsARIMsbsjzQfBnwOGGqtvSmy/2zgP4ES4E3gTmttU2TbZuAh4DNAGbAUuNlae+h0/0GMMRcDP48ccx3wZWvt3yLbbgG+DeQDO4FvWWt/a4wZCjwGjAKOAs9Za687Sd/JwKPAdMALrCf83/puwjGYYIz5GfBra+1dxpipwINAEfAk0DWBFhEX0YyZiJwTa+1BYB7hBOaETwFrrbVvRd5/ENmeBVwN3GmMmRNF93cQTjouAMYC13TZ3hbZngF8FrjfGDPaWvsB4cRlu7U2LfJve+cdjTHDgN8B/0Q4SVoMLDDGJHY5j2nAYGAE4QTxIxljcoBFwANALnAfsMgYkxtJGB8Apltr04GLCSeEAD8AlgPZhBPNB09xiJuBTGBgpP8vAAettf8GvATcFTnfu4wxecCfgG8BecAGYOLpzkFEYkczZiJyPjwOLDTG3BWZUfpM5DMArLUrO7V92xjzO2AS4dm2j/Ip4GfW2i0Axpj/BCZ36ndRp7YvGGOWE541ej2KMV8HLLLWPhPp+yfAlwknSyfG+8CJhM4Ys4DwbNbpXA2st9Y+GXn/O2PM3cAs4A/AcaDWGPOutbYFaIm0O0p4Zq7YWrsVONXNBEcJJ2RDrbVvA2s+YiwzgAZr7dORc/gZ8LUozkFEYkQzZiJyzqy1fyF8WW6OMaYCGAc8dWK7MWa8MWaFMWaHMWYf4VmevCi6Lga2dHr/TueNxpjpxphXjDG7jTF7CSci0fR7ou8P+7PWHo8cq6RTm1Cn1weAtDPtt9O4SyIzedcRPv8WY8wiY0xVpM03CF9mfNUY02CMufUU/T8JLAPmGmO2G2N+ZIxJ+IixfPjfz1rbwd//9xQRl1FiJiLnyxOEZ8puApZZa1s7bXsKqAMGWmszCa9Ji2atUwvhS3YnDDrxwhiTBPwR+AlQaK3NInw58kS/HafpezvhGaoT/Xkix9oWxbii7jdi0Il+rbXLrLVTCa/5Wgv8T+TzkLX2DmttMfB54JHIurO/Y609aq39nrW2mvDs3kz+32Xkruf8d//9Op2jiLiULmWKyPnyBOG1TCOAr3TZlg7sttYeMsaMA24kvJ7qdOYBdxtjFhJep/bNTtsSgSTCi/6PGWOmA1cB9ZHtrUCuMSbTWrvvFH1/0xhzBeGbFr4MHAb+FsW4Pspi4EFjzI2RY3wSqCZ8qbcQmAA8CxwE9hO+tIkx5lrg5chlzD2Ek6zjXTs3xkwhPDvZSPiGiKOd2rUCQzo1XwQ8ZIz5BOHE+IuAc47nJyLdSDNmInJeWGs3E05qBhBOAjr7R+D7xpj3Cd+ROC/Kbv+H8GW7twivG/tTp+O9T/hOxHmEE5kbOx/XWruW8OL+jcaYvcaY4i7jtYRn9x4knOjMAmZZa49EObaTstbuIjyL9TVgF+FLlDOttTsJ/8z9KuFZtd2E19ndGdn1QmBV5C7SOsJ3cm48ySEc4GnCSVkT8ALhy5sQvhP0GmPMHmPMA5FjXgv8MDKWSuCv53J+ItK9PB0dp5vtFxEREZGeoBkzEREREZdQYiYiIiLiEkrMRERERFxCiZmIiIiIS/SJchnHjx/vaG/v3psYvF4P3X0MOXOKi/soJu6kuLiPYuI+PRWThATvTsKPgvtfokrMjDHTCN+G7QUetdb+sMv2JMI1jMYQviX7usit8xhj7gFuA9qBu621yzrt5wVWA9ustTO79PkAcKu19rSVttvbO9i790A0p3LWsrJSu/0YcuYUF/dRTNxJcXEfxcR9eiom+fnpXZ8O8qHTXsqMJE8PE34gcDVwgzGmukuz24A91tqhwP3AvZF9q4HrgRrCDwJ+JNLfCV8mXIen6zHHEn6Qr4iIiEi/Ec0as3FAs7V2Y6Tw4lzA36WNn//3wOKngSsij/7wA3OttYettZuA5kh/GGNKCT/s99HOHUUStx8TLsooIiIi0m9EcymzhL9/6O1WYPyp2lhrj0UeUpwb+fyVLvueeEDwzwgnX+ld+roLqLPWthhjojkHvF4PWVmpUbU9W15vXLcfQ86c4uI+iok7KS7uo5i4jxtiEpPF/8aYmUCbtXaNMWZyp8+LCT8+ZPIpdj0prTHrvxQX91FM3ElxcR/FxH16cI3ZKbdFcylzGzCw0/vSyGcnbWOMiQcyCd8EcKp9JwKzjTGbCV8avdwY8xvgAmAo0BzZlmqMaY5ijCIiIiK9XjQzZq8BlcaYwYSTqusJPyy4szrgZuBl4BrgeWtthzGmDnjKGHMfUEz4AbqvWmtfBu4BiMyYfd1ae1OkL+dEp8aY/ZEbCkRERET6vNPOmFlrjxFe97WM8B2U86y1DcaY7xtjZkeaPQbkRma3vgp8M7JvAzAPaASWAl+01raf/9MQERER6f08HR29v7jd0aPtHd15TXj7vkM07DzA2KI0slMTu+04cua0RsN9FBN3UlzcRzFxnx5cY7YGGHuybX2i8n93e3PbPr6zxBIf52Hy0Fz8PodxZdnEeTyxHpqIiIj0IUrMojCjupCxFXn85m+bWdzYyrPrduKkJzG71mFWbSFORnKshygiIiJ9gC5lRunE9OaRY8d5YcMuAsEWVr2zFw8woTwbv8/hsopcErx6LnxP0qUA91FM3ElxcR/FxH10KbMXSoyPY6rJZ6rJZ/u+QyyoD1FXH+KbC5rITklgRnUhfp/D4FwVDRQREZEzo8TsHBRnJvP5ieXcflEZr7yzh0AwxNw3tvHbNVsZWZzBbJ/DVJNPSoL39J2JiIhIv6fE7DzwxnmYODiHiYNz2PXBERY3thIIhvjBsnXct2IDV1Xl4/cVUV2Yhkc3DIiIiMgpKDE7z3IHJPLpCwdy09hS3tr2HoH6EIsb2/jz2yEq8wcwu9Zh+vACMlMSYj1UERERcRklZt3E4/EwqjSTUaWZfG1KBcvXtjE/GOKnKzbw4IsbmVKZh9/nMGZglspuiIiICKDErEekJcXziZHFfGJkMeva9lMXmUVbtnYHxZnJ+GsdZtYUUpCeFOuhioiISAypXEaUzvcttIeOtrOyeReB+hCr391LnAcuHpyDv9bhkiE5xKvsRlR0u7n7KCbupLi4j2LiPiqX0Y8lJ3iZNryAacML2Lr3IHX1IRbUt/KXjY3kpCYws8bB73MYlJ0S66GKiIhID1Fi5gKlWSn84yWD+dzF5by8aTeBYIjfrt7CE69t4YLSTOb4HC6vzCNZZTdERET6NCVmLhIf5+HSilwurchl5/7DLGxoJVAf4jtLLD9+vplpVQX4fQ5VhemxHqqIiIh0AyVmLpWXlsQt4wdx87iBvL51H4FgiAUNrTz9VgumIA2/z2FaVQHpyQqhiIhIX6Hf6i7n8XgYMzCLMQOz+Pqhoyxt2kEg2MKPnmvm5y9s5PJI2Y3RpZkqXisiItLLKTHrRTKSE/jUBcV86oJi1ra+z/xgiKVNbSxpamNQdgqzax2urikkb0BirIcqIiIiZ0HlMqLk1tuaDx1t57l1OwnUh3hj6z68HrhkSC5+n8NFg3OIj+vbs2hujUt/ppi4k+LiPoqJ+6hchpyz5AQvV9cUcnVNIZt3H2BBfYiFDa28sGEX+WmJzKwpZHatQ2mWym6IiIi4nRKzPqQ8J5UvXTaEOyeW85eNuwnUh3j81S38atUWxg7KYk6tw+TKPJLiVbxWRETEjZSY9UHx3jgmV+YxuTKP1vcPs7AhRF19K99avJaM5HimDw+X3ajMT4v1UEVERKQTJWZ9XGF6ErdNKOOz4wex+t29BIIh/vR2C79/YzvVTjr+2kKuqiogLUn/K4iIiMSafhv3E3EeD+PKshlXls3eg0dZ2tTG/GAL//lsM/ev3MiVJp85PocRxRkquyEiIhIjSsz6oayUBK4fXcJ1FxTTGAqX3Vi+dgcLG1opy07B7wuX3chJVdkNERGRnqTErB/zeDzUFGVQU5TBVyZX8Oy6HQSCIR54cRMP/2UzkyrCZTfGl2Xj7eNlN0RERNxAiZkAkJroZXatw+xah027DhAIhljU2Mrz63dSmJ7ErJpCZtU6FGcmx3qoIiIifZYKzEapPxYCPNp+nBc37GJ+MMSqzXsAGF+WzWyfw6SKXBJdUHajP8bF7RQTd1Jc3EcxcR8VmBVXS/DGccWwfK4Ylk/ovUMsqG+lrj7Evy5sIjM5nqsjxWsr8gbEeqgiIiJ9ghIziYqTkcwdF5dx64RBvPruHuqCIea9sZ2n1mzDV5SO3+cw1RSQmuiN9VBFRER6LSVmcka8cR4uKs/hovIc9hw4wuLGNgLBEP++fD33rdjI1Kp8/LUOtUXpKrshIiJyhqJKzIwx04CfA17gUWvtD7tsTwKeAMYAu4DrrLWbI9vuAW4D2oG7rbXLOu3nBVYD26y1MyOf/ZbwddejwKvA5621R8/hHKWbZKcm8g9jS7lxTAnBlvcJBFtY1hRO1IbkpuL3OcwYXkhWakKshyoiItIrnHb1diR5ehiYDlQDNxhjqrs0uw3YY60dCtwP3BvZtxq4HqgBpgGPRPo74ctAU5e+fgtUAT4gBbj9DM9JepjH42FEcQb/52OGJV+YwL9OrSQ10cv9Kzcy4/97hXsWNLFq8x6O94EbTURERLpTNDNm44Bma+1GAGPMXMAPNHZq4we+G3n9NPCQMcYT+XyutfYwsMkY0xzp72VjTClwNfAfwFdPdGStXXzitTHmVaD07E5NYiEtKZ6Pjyji4yOKaN7xAYH6EEsaW3l23Q6KM5KYVesws6YQJ0NlN0RERLqKJjErAbZ0er8VGH+qNtbaY8aYfUBu5PNXuuxbEnn9M+AbQPrJDmqMSQA+TXhW7SN5vR6yslJPeyLnwuuN6/Zj9DVjs1IZW5nPt2ZW8+zaNuat2cov/vYO//PyO1w6NI9rx5QyxRScU9kNxcV9FBN3UlzcRzFxHzfEJCaL/40xM4E2a+0aY8zkUzR7BHjRWvvS6fprb+/o9rojqjdzbiYOzGTiwEy27j3IgoZWFtaHuGvum+SkJjCjuhB/rUN57pl/GRQX91FM3ElxcR/FxH16sI7ZKbdFk5htAwZ2el8a+exkbbYaY+KBTMI3AZxq39nAbGPMDCAZyDDG/MZaexOAMeY7QD7w+SjGJ71IaVYKd04s53MXlfHK5j3MD7bwu9e38ZvVWxlVkoHf53DFsHxSElR2Q0RE+p9oErPXgEpjzGDCSdX1wI1d2tQBNwMvA9cAz1trO4wxdcBTxpj7gGKgEnjVWvsycA9AZMbs652SstuBjwFXWGuPn+P5iUt54zxMHJLDxCE57PzgCIsbWgnUh/je0nX85PkNfKyqAL/PYXhhmspuiIhIv3HaxCyyZuwuYBnhchm/tNY2GGO+D6y21tYBjwFPRhb37yacvBFpN4/wjQLHgC9aa9tPc8j/Bt4hfIMAwJ+std8/u9OT3iBvQCKfGTeQT19Yypvb3iMQbGFRYyt/eruFyvwB+Gsdpg0vIDNFZTdERKRv07Myo6S1AD1r/+FjLFsbronW1LqfRK+HKZV5zPEVMXpgJnGRWTTFxX0UE3dSXNxHMXEfPStT5BTSkuL55MhiPjmyGNu6n0B9iKVNbSxbu4OSzGT8vnDZjVjfPSMiInI+acYsSvrLJvYOHW1nRfNOAsEQa7bsI84Dk4flM6Mqn4mDc4j3nn3ZDTl/9F1xJ8XFfRQT99GMmcgZSE7wMn14IdOHF7Jlz0Hq6kMsamzjebuD3AGJzKwJl90YmJ0S66GKiIicFc2YRUl/2bhTWnoyi97YRiDYwt827aa9A8YMzMTvc5gyNI9kld3ocfquuJPi4j6KiftoxkzkHMV745g0NJdJQ3PZsf8wCxtaqasP8e3FlvSkDUwbHi67YQrSYj1UERGR01JiJn1GfloSnx0/iJvHDeT1LfsI1IcIBFv4w5vbGV6YxuxI2Y20JP1vLyIi7qRLmVHSlLM7nS4u7x06ytKmNuYHQ6zf8QFJ8XFcOSwPv6+IUSUZKl7bDfRdcSfFxX0UE/fRpUyRbpaRnMCnLijh2lHFrG3bTyAYLruxqLGNQdkp+Gsdrq4pJHdAYqyHKiIiosRM+gePx8PwwnSGF6bz5UlDeG7dDuqCIR58aROP/HUzlw7Jwe9zmFCeQ3ycZtFERCQ2lJhJv5OS4GVmjcPMGofNuw5Eym60srJ5FwVpicysdZhdW0hJpspuiIhIz1JiJv1aeW4qd08awj9eUs5LG3cTCIb49ap3+eUr73LhoCzm+BwmDc0jKV7Fa0VEpPspMRMhXHZjSmUeUyrzCL13iIUNrSyoD/Fvi9aSmRzP9Opw8dqh+QNiPVQREenDlJiJdOFkJHP7RWXcOmEQr727l0AwxB/f2s7c17dR46Tj9zlcVZXPgER9fURE5PzSbxaRU4jzeBhfls34smz2HjzKkqY25r/dwv99Zj33r9zAlcPy8fscRhSr7IaIiJwfSsxEopCVksANo0u4/oJiGkLvMz8Y4pm1O1jQ0MrgnFT8PocZ1QVkp6rshoiInD0lZiJnwOPxUFuUQW1RBl+dXMGzdgfzgyF+9sJGHnppE5OG5uL3OYwblI1XZTdEROQMKTETOUupiV5m+xxm+xw27PwgXHajoZXn1u3ESU9iVm0hs2odijKSYz1UERHpJfRIpijp0Rnu5La4HDl2nBc37CIQDLHqnT0AjC/PZo7P4bKKXBK8fb/shttiImGKi/soJu6jRzKJ9DGJ8XFcafK50uSzfd8hFtSHWNDQyjcXNJGVksCM6gL8PochuSq7ISIi/5sSM5FuUpyZzOcnlnP7RWWsemcPgWCI37+xnafWbGNEcQb+WocrTT6pid5YD1VERFxCiZlIN/PGebh4cA4XD85h94EjLG5sIxBs4QfL1/HTFRu4qiqfOT6HaiddZTdERPo5JWYiPSgnNZGbxpbyD2NKeHv7e8wPhlja1Mb8YIiheQOY7XOYPryArJSEWA9VRERiQImZSAx4PB5GlmQysiSTr02pYLndQSAY4r4VG3jwxY1MGZqH3+cwdlAWcZpFExHpN5SYicRYWlI8nxhRxCdGFLF+x34CwRBLmtpYbndQnJnM7NpCZtY4FKYnxXqoIiLSzVQuI0q6rdmd+mpcDh87zsr1O5lfH2L1u3uJ88DFg3OYXetw6ZAc4l1cdqOvxqS3U1zcRzFxH5XLEJGTSoqP42PDC/jY8AK27j34YdmNb9Q1kpOawMyaQmbXOpTlpMZ6qCIich4pMRNxudKsFO68ZDB3XFzOy5t2U1cf4rert/LEa1u5oCQDv6+IK4blkZygshsiIr2dEjORXiI+zsOlFblcWpHLzg+OsKihlUCwhe8utfz4+WamDS9gjs+hqjA91kMVEZGzFFViZoyZBvwc8AKPWmt/2GV7EvAEMAbYBVxnrd0c2XYPcBvQDtxtrV3WaT8vsBrYZq2dGflsMDAXyAXWAJ+21h45h3MU6XPyBiRy87iBfObCUt7Yto9AMMTChlb++FYLw/IH4PcVMW14PhnJKrshItKbnHYFcSR5ehiYDlQDNxhjqrs0uw3YY60dCtwP3BvZtxq4HqgBpgGPRPo74ctAU5e+7gXuj/S1J9K3iJyEx+NhdGkW35texZLPT+AbVwwlzuPhx883M+MXq/j24rWs2bKXvnCTj4hIfxDNrV3jgGZr7cbIzNVcwN+ljR94PPL6aeAKY4wn8vlca+1ha+0moDnSH8aYUuBq4NETnUT2uTzSB5E+55zNiYn0N+nJ8Vw7qpgnPz2aJ2+6gFk1hby0cRdfmPc2n/zla/x61bvs3H841sMUEZGPEM2lzBJgS6f3W4Hxp2pjrT1mjNlH+FJkCfBKl31LIq9/BnwD6LwgJhfYa609dpL2p+T1esjK6t6707zeuG4/hpw5xeXkJmSlMsEU8u0j7SxvbGXemi08/JfN/Pff3mHysHyuHVPKpMq8bim7oZi4k+LiPoqJ+7ghJjFZ/G+MmQm0WWvXGGMmn2t/7e0d3V53RPVm3ElxOb1J5VlMKs/ind0HqKtvZWFDiOfWtpE3IJFZteGyG6VZKefteIqJOyku7qOYuE8P1jE75bZo/lzeBgzs9L408tlJ2xhj4oFMwjcBnGrficBsY8xmwpdGLzfG/CayT1akj1MdS0TOQllOKl+6bDCLPjeen/irqSpM4/FXt/Dxx17jznlvsbSpjcPHjsd6mCIi/Vo0M2avAZWRuyW3EV7Mf2OXNnXAzcDLwDXA89baDmNMHfCUMeY+oBioBF611r4M3AMQmTH7urX2psj7FZE+5kb6DJzTGYrI34n3xjFpaB6ThubR9v5hFjW2EgiG+D+L15KRHM+0qgL8PodhBWmxHqqISL9z2sQssmbsLmAZ4XIZv7TWNhhjvg+sttbWAY8BTxpjmoHdhJM3Iu3mAY3AMeCL1tr20xzyX4C5xph/B96I9C0i3aAgPYnPjh/EzeMGsmbLXgLBEPODLcx7czvDC9OY43O4qqqAtCSVPBQR6Ql6VmaUtBbAnRSX82/fwaMsbWpjfjBE884PSIqP40qTz5xah5ElGXg8no/cXzFxJ8XFfRQT99GzMkXEdTJTErhudAmfuqCYxtb9BIItLF+7g0UNrZRlp+D3OcyoLiR3QGKshyoi0ucoMRORk/J4PNQ46dQ46XxlcgXP2h0EgiEeeHETD/9lM5dV5OL3OUwoy8Yb99GzaCIiEh0lZiJyWikJXmbVOsyqddi06wCBYIjFja2sWL+TgrREZtU6zK51KM5MjvVQRUR6Na0xi5LWAriT4hI7R9uP89KGXcwPhnhl8x4AxpVlceP4MsYWpZMYf/6L18rZ03fFfRQT99EaMxHptRK8cVw+LJ/Lh+UTeu8QCxpaqQuG+PK8t8hMjmdGdSGzfQ5D8wbEeqgiIr2GEjMROWdORjJ3XFTGreMH0bj7IE+9vJk/vLmd372+DV9ROrNrHaZW5TMgUT9yREQ+in5Kish5443zcOnQPHx5qew5cIQlkbIb//HMeu5buYGrTLh4bW1R+mnLboiI9EdKzESkW2SnJnLjmFJuGF1CsOV96oIhlts2AvUhBuemMsfnMGN4IVmpCbEeqoiIaygxE5Fu5fF4GFGcwYjiDL4yZQjPrN1BoD7E/Ss38uCLm5g8NA+/r5BxZdnEaRZNRPo5JWYi0mMGJMYzZ0QRc0YU0bzzA+oiZTeeXbeDooykcEmOmkKcDJXdEJH+SeUyoqTbmt1JcXGfM43JkWPHWdm8k7r6EKve2YsHmFCezRyfw6UVuSR4VXbjfNB3xX0UE/dRuQwR6fcS4+O4qqqAq6oK2LbvIAvqW1lQH+JfFjSRnZLA1TWF+GsdynNTYz1UEZFup8RMRFyjJDOFL0ws546LynjlnT0EgiF+9/o2frN6KyOLM/D7HK40+aQkeGM9VBGRbqHETERcxxvnYeLgHCYOzmHXB0dY3NhKIBji+8vW8dMVG7iqKh+/r4jqwjSV3RCRPkWJmYi4Wu6ARD594UBuGlvKW9veY359iMWNbfz57RCV+QPw1zpMG15AZorKbohI76fETER6BY/Hw6jSTEaVZvL1KRUsXxsuXvuTFRt44MWNTKnMw+9zGDMwS2U3RKTXUmImIr1OWlI8nxhZzCdGFmPb9lMXDLGkqY1la3dQkpnM7FqHmTWFFKQnxXqoIiJnROUyoqTbmt1JcXGfWMXk0NF2VjbvIhBsYfWWfcR54OLBOczxOUwcnEN8Py+7oe+K+ygm7qNyGSIi50lygpdpwwuYNryArXsPUlcfYkF9K1/f2EhOagIzaxz8PodB2SmxHqqIyCkpMRORPqc0K4V/vGQwn7u4nL9t2k0gGOK3q7fwxGtbGF2aid/ncHllHskquyEiLqPETET6rPg4D5dV5HJZRS479x9mYUMrgfoQ31li+fHzzUyrKmCOrwhTmBbroYqIAErMRKSfyEtL4pbxg/jMuIG8sXUf84MhFjS08vRbLVQVpOH3OXysqoD0ZP1YFJHY0U8gEelX4jwexgzMYszALN47dJSlTTuYH2zh3uea+dkLG7liWLjsxgUlmSpeKyI9TomZiPRbGckJfOqCYq4dVcTatv0EgiGWNrWxuLGNQdkpzK51uLqmkLwBibEeqoj0E0rMRKTf83g8DC9MZ3hhOv80aQjPrdtJINjCQy9t4r/+solLK3Lx+xwmlOcQH6dZNBHpPkrMREQ6SU7wcnVNIVfXFLJ59wEW1IdY2NDKyuZd5KclMqumkFm1DqVZKrshIuefEjMRkVMoz0nlS5cN4c6J5by0cTd19SF+/eoWfrlqCxcOysJf6zC5Mo+k+P5dvFZEzh8lZiIipxHvjWNKZR5TKvNoff8wCxtC1AVDfGvxWjKS45k+vAC/z6EyX2U3ROTcKDETETkDhelJ3DahjM+OH8Tqd/cSCIb409st/P6N7VQ76fh9DleZfNKS9ONVRM5cVD85jDHTgJ8DXuBRa1aBJ1QAABx9SURBVO0Pu2xPAp4AxgC7gOustZsj2+4BbgPagbuttcuMMcnAi0BSZAxPW2u/E2l/BfBjIA7YD9xirW0+x/MUETmv4jwexpVlM64sm70Hj7KkqY1AsIX/fGY996/YwFSTj9/nMKI4Q2U3RCRqp10YYYzxAg8D04Fq4AZjTHWXZrcBe6y1Q4H7gXsj+1YD1wM1wDTgkUh/h4HLrbUjgVHANGPMhEhf/wX8g7V2FPAU8K1zO0URke6VlZLADaNL+N1nxvDrG0cxbXgBz63bye1z3+JTv17Nb1ZvZfeBI7Eepoj0AtHMmI0Dmq21GwGMMXMBP9DYqY0f+G7k9dPAQ8YYT+Tzudbaw8AmY0wzMM5a+zLh2TCAhMi/jsj7DiAj8joT2H4W5yUi0uM8Hg81RRnUFGXwlckVPLtuB4FgiJ+/sJGHX9rEZZGyG+PLsvGq7IaInEQ0iVkJsKXT+63A+FO1sdYeM8bsA3Ijn7/SZd8S+HAmbg0wFHjYWrsq0uZ2YLEx5iDwHjCB0/B6PWRlpUZxKmfP643r9mPImVNc3EcxCcsCPlOQzmcuGcL6tv08vWYrf35zG8+v30lRZjLXjC7hk6NLKemhshuKi/soJu7jhpjEbHWqtbYdGGWMyQL+bIyptdbWA18BZlhrVxlj/hm4j3Cydkrt7R3s3XugW8eblZXa7ceQM6e4uI9i8r/lJ8Zx50WDuH1cKS9u2MX8YIiHVmzgoRUbGF+Wjd/ncFlFLondWHZDcXEfxcR9eiom+fnpp9wWTWK2DRjY6X1p5LOTtdlqjIknfAlyVzT7Wmv3GmNWEF5n1gqM7DR79ntgaRRjFBFxvQRvHFcMy+eKYfm0vHeIhfWt1NWHuGdhE1kpCcyoLmB2rUNF3oBYD1VEYiSaP89eAyqNMYONMYmEF/PXdWlTB9wceX0N8Ly1tiPy+fXGmCRjzGCgEnjVGJMfmSnDGJMCTAXWAnuATGPMsEhfU4Gmsz89ERF3KspI5o6Ly5h/+zge+GQtYwZmMu+N7Vz/+BpufepN6oIhDhxpj/UwRaSHnXbGLLJm7C5gGeFyGb+01jYYY74PrLbW1gGPAU9GFvfvJpy8EWk3j/CNAseAL1pr240xRcDjkXVmccA8a+1CAGPMHcAfjTHHCSdqt57ncxYRcQ1vnIeLynO4qDyHPQeOsLixjUAwxA+Wr+OnKzYwtSqfOT6HGiddZTdE+gFPR0fH6Vu53NGj7R1aY9Y/KS7uo5icu46ODt7e/h519SGWr93BoWPHqchLxe8rYvrwArJSEs64T8XFfRQT9+nBNWZrgLEn26bS1CIiLuPxeBhZksnIkky+MrmCZ2y47MZ9Kzbw4IsbmTw0D7/P4cJBWcRpFk2kT1FiJiLiYmlJ8Xx8RBEfH1FE844PCNSHWNLYyjN2B8UZScyqdZhV61CYnhTroYrIeaBLmVHSlLM7KS7uo5h0v8PHjvNC804CwRCvvruXOA9cVJ6D3+dw6ZAc4r3/+74uxcV9FBP30aVMERE5Y0nxcVxVVcBVVQVs3XuQBQ2tLKgP8Y26RnJSE7i6upDZPofyHBUvFeltlJiJiPRipVkp3DmxnDsuKuOVzbsJBEM89fo2nly9lQtKMpjtc7hyWH6shykiUVJiJiLSB8THebhkSC6XDMll5wdHWNzQSqA+xPeWruMnz29g9shipps8qgrSVHZDxMWUmImI9DF5AxL5zLiBfPrCUt7Yto+6YIg/v7mN3722hcr8AczxOUwbXkBG8pmX3RCR7qXF/1HSIk13UlzcRzFxp7ikBOateodAMMTatv0kej1cPiwff63D6IGZKrsRA/quuI8W/4uISI/ISEngmlHFXDOqGNu6P1x2o6mVpU1tlGYlM7vWYWZNIflpKrshEkuaMYuS/rJxJ8XFfRQTdzpZXA4dbef59Tupqw+xZss+vB64eHAOfl8RE4fkEB+nWbTupO+K+2jGTEREYiY5wcuM6kJmVBfy7p6D1NWHWNjQyksbG8gbkMjMmkJm1zoMzE6J9VBF+g0lZiIiwqDsFO66dDBfuLiMv27aQyDYwhOvbeHXr25hzMBM/D6HKUPzSE7wxnqoIn2aEjMREflQvDeOSUNzmTQ0l7b3D7OosZVAMMS3F1vSkzYwbXgBfp+DKUiL9VBF+iQlZiIiclIF6Ul8dvwgbh43kNe37GN+sIVAsIU/vLmd4YVp+H0OH6sqIC1Jv0pEzhd9m0RE5CPFeTyMHZTF2EFZ7Dt4lGVr25gfDPHDZ5u5f+VGrhyWh99XxKiSDBWvFTlHSsxERCRqmSkJfOqCEq4dVUxT634CwRDL1raxqLGNQdkp+Gsdrq4pJHdAYqyHKtIrKTETEZEz5vF4qHbSqXbS+afJQ3hu3Q4CwRAPvrSJR/66mUuH5DDHV8SE8my8KrshEjUlZiIick5SErzMrHGYWeOwedeBD8turGzeRUFaIrNqHWbVFlKSqbIbIqejxExERM6b8txU7p40hDsvKeeljbsJBFv41ap3eeyVdxk3KAu/z2Hy0DwS4+NiPVQRV1JiJiIi512CN47LK/O4vDKP0HuHWNjQSl19iH9btJbM5HimVxfi9zkMzRsQ66GKuIoSMxER6VZORjK3X1TGrRMG8do7ewnUh/jjW9uZ+/o2aovS8dc6TK3KZ0CifiWJ6FsgIiI9Is7jYXx5NuPLs9l74CiLm8LFa//jmfXct3IDU00+fl8RvqJ0ld2QfkuJmYiI9Lis1ARuHFPKDaNLaAi9z/xgiOVr26irb2Vwbir+WocZ1QVkp6rshvQvSsxERCRmPB4PtUUZ1BZl8JXJQ3jW7iAQbOVnL2zkoZc2MXloLn6fw7iybOI0iyb9gBIzERFxhQGJ8fh9Rfh9RWzY+QF19SEWNbTy7LqdOOlJzI6U3XAykmM9VJFu4+no6Ij1GM7Z0aPtHXv3HujWY2RlpdLdx5Azp7i4j2LiTr01LkeOHeeFDbuoC4ZY9c4eACaUZ+P3OVxWkUuCt/eW3eitMenLeiom+fnpa4CxJ9umGTMREXGtxPg4ppp8ppp8tu87xIL6EHX1Ib65oInslARmRMpuDM5NjfVQRc4LJWYiItIrFGcm8/mJ5dx+URmr3tlDIBhi7hvb+O2arYwozsDvc5hq8klJ8MZ6qCJnLarEzBgzDfg54AUetdb+sMv2JOAJYAywC7jOWrs5su0e4DagHbjbWrvMGJMMvAgkRcbwtLX2O5H2HuDfgWsj+/yXtfaBczxPERHpI7xxHi4enMPFg3PYfeAIiyLFa3+wbB33rdjAVVX5+Gsdqh2V3ZDe57QX540xXuBhYDpQDdxgjKnu0uw2YI+1dihwP3BvZN9q4HqgBpgGPBLp7zBwubV2JDAKmGaMmRDp6xZgIFBlrR0OzD2nMxQRkT4rJzWRT184kHm3jOXR60cypTKPJY1t3PLUm9z4xOvMfX0b+w4ejfUwRaIWzYzZOKDZWrsRwBgzF/ADjZ3a+IHvRl4/DTwUmfnyA3OttYeBTcaYZmCctfZlYH+kfULk34m7EO4EbrTWHgew1rad5bmJiEg/4fF4GFmSyciSTL42pYLldgeBYIifrtjAgy9uZPLQPPw+h7GDslR2Q1wtmsSsBNjS6f1WYPyp2lhrjxlj9gG5kc9f6bJvCXw4E7cGGAo8bK1dFWlTAVxnjPk4sIPw5c/1HzVAr9dDVlb3Lvz0euO6/Rhy5hQX91FM3Kk/xSULuLUwg1svq6Cp5T3+8PpW6t5qYbndQWl2CteOLuUTo0tiXnajP8Wkt3BDTGK2+N9a2w6MMsZkAX82xtRaa+sJrzs7ZK0da4z5BPBL4NKP6qu9vaPbb2/Vbc3upLi4j2LiTv01LkUp8dw9sZzPjx/EyvU7mV8f4v7n1vPz59dz8eAc/LUOlwzJIT4GZTf6a0zcrAfLZZxyWzSJ2TbCa75OKI18drI2W40x8UAm4ZsATruvtXavMWYF4TVo9YRn1f4U2fxn4FdRjFFEROSUkuLj+NjwAj42vICtew+yoD7EgoZW/rmukZzUBGbWFDK71qEsRzNYElvR/InwGlBpjBlsjEkkvJi/rkubOuDmyOtrgOettR2Rz683xiQZYwYDlcCrxpj8yEwZxpgUYCqwNrL/fGBK5PUkYN3ZnZqIiMj/VpqVwp2XDKbujvHcN6cGX1EGv129lWt+tZrP/f4tFje2cuhoe6yHKf3UaWfMImvG7gKWES6X8UtrbYMx5vvAamttHfAY8GRkcf9uwskbkXbzCN8ocAz4orW23RhTBDweWWcWB8yz1i6MHPKHwG+NMV8hfIPA7efzhEVERADi4zxcWpHLpRW57Nx/mEWNbQSCLXxnieVHzzUzbXgBc3wOVYWnvuwkcr7pkUxR0loAd1Jc3EcxcSfFJTodHR28vnUfdfUhnlu3k8PHjmMK0vD7HKZVFZCefP6WZism7qNHMomIiLiIx+NhzMAsxgzM4utTjrF0bRuBYIgfPdfMz1/YyOWV4bIbo0szVbxWuoUSMxERkZNIT47n2lHFXDuqmLWt7xMIhli6to0lTW0Myk5hdq3D1TWF5A1IjPVQpQ9RYiYiInIaVYXpVBWm8+VJQ3h+/U7mB0M89NIm/usvm7hkSC5+n8NFg3OIj9MsmpwbJWYiIiJRSk7wMqO6kBnVhbyz+wB19a0sbAjxwoZd5Kclflh2ozQrJdZDlV5KiZmIiMhZKMtJ5UuXDebOiWX8ZeNuAvUhHn91C79atYWxg7KYU+swuTKPpPieL14rvZcSMxERkXMQ741jcmUekyvzaHv/MAsbWgnUh/jW4rVkJMczfXgBfp9DZX5arIcqvYASMxERkfOkID2JWycM4pbxA1mzZS+BYIg/vd3C79/YTrWTjr+2kKuqCkhL0q9fOTn9nyEiInKexXk8XDgomwsHZbP34FGWNoXLbvzns83cv3IjV5p8brqonCEZiSq7IX9HiZmIiEg3ykpJ4PrRJVx3QTGNrfsJBFtY1rSDhQ2tlGWn4PeFy27kpKrshqjyf9RUodmdFBf3UUzcSXFxlwNH2vnb1n3MXfUub21/D2+ch0kVucz2OUwoy8arshsxocr/IiIi/VBqopdrRpdy5ZAcNu06QCAYYlFjK8+v30lBWiKzax1m1ToUZybHeqjSwzRjFiX9telOiov7KCbupLi4T9eYHG0/zksbdjE/GOKVzXsAGFeWhd9XxKSKXBJVdqPbacZMREREAEjwxnH5sHwuH5ZP6L1DLKhvpa4+xL8ubCIzOZ6rI8VrK/IGxHqo0o2UmImIiLiMk5HMHReXceuEQbz27h4CwRDz3tjOU2u24StKx+9zmGoKSE30xnqocp4pMRMREXEpb5yHCeU5TCjPYc+BIyxpamN+MMS/L1/PfSs2MtXk4/c51Balq+xGH6HETEREpBfITk3kxjGl3DC6hGDL+wSCLSy3bQTqQwzJTcXvc5gxvJCs1IRYD1XOgRIzERGRXsTj8TCiOIMRxRl8dUoFz6zdQaA+xP0rN/LQS5uYVJHHHJ/DhWVZxGkWrddRYiYiItJLDUiMZ86IIuaMKKJ55wfUBUMsbmzl2XU7KM5IYlatw8yaQpwMld3oLVQuI0q61dydFBf3UUzcSXFxn+6KyZFjx1nZvJNAMMSr7+4lzgMTyrPx+4q4dEgOCV6V3TgVlcsQERGR8yoxPo6rqgq4qqqAbfsOsqC+lQX1If6lrpGc1ARmVBfir3Uoz02N9VDlJJSYiYiI9FElmSl8YWI5d1xUxiub9xCoD/G717fxm9VbGVWSgd/ncMWwfFISVHbDLZSYiYiI9HHeOA8Th+QwcUgOuz44wuLGVuYHQ3xv6Tp+8vwGPlZVgN/nMLwwTWU3YkyJmYiISD+SOyCRT184kJvGlvLWtveYXx9+Tuef3m6hMn8A/lqHacMLyExR2Y1YUGImIiLSD3k8HkaVZjKqNJOvT6lg2do2AsEQP1mxgQde3MiUyjzm+IoYPTBTZTd6kBIzERGRfi4tKZ5PjizmkyOLsW37qQuGWNLUxrK1OyjJTMbvC5fdyE9LivVQ+zyVy4iSbjV3J8XFfRQTd1Jc3MftMTl0tJ2VzbsIBFtYvWUfcR6YODgHv89h4uAc4vtg2Q2VyxARERFXSk7wMm14AdOGF7Blz0Hq6kMsbGjlpY2N5A5IZGZNIbNrHQZlp8R6qH2KEjMRERH5SAOzU/jipYP5/MRy/rZpN4FgiN+8toXHX93C6NJM/D6HyyvzSFbZjXOmxExERESiEh/n4bKKXC6ryGXn/sMsbGglUB/iO0ssP36+menDw8VrTWFarIfaa0WVmBljpgE/B7zAo9baH3bZngQ8AYwBdgHXWWs3R7bdA9wGtAN3W2uXGWOSgReBpMgYnrbWfqdLnw8At1prFV0RERGXyUtL4pbxg/jMuIG8sXUf84MhAsEW/vDmdqoK0vD7HD5WVUB6suaAzsRpV+4ZY7zAw8B0oBq4wRhT3aXZbcAea+1Q4H7g3si+1cD1QA0wDXgk0t9h4HJr7UhgFDDNGDOh0zHHAtnneG4iIiLSzeI8HsYMzOIHM6pY8oUJ/PPlFbR3dHDvc81M/8UrfGfJWl7fupe+cLNhT4gmjR0HNFtrNwIYY+YCfqCxUxs/8N3I66eBh4wxnsjnc621h4FNxphmYJy19mVgf6R9QuRfR6R/L/Bj4Ebg42d/aiIiItKTMpIT+NQFJVw7qpi1bfsJBEMsbWpjcWMbg7JT8Nc6zKgpJG9AYqyH6lrRJGYlwJZO77cC40/Vxlp7zBizD8iNfP5Kl31L4MMEbA0wFHjYWrsq0uYuoM5a22KMieokvF4PWVnd+zBWrzeu248hZ05xcR/FxJ0UF/fp6zG5KHsAF5lCvnOknaUNIeat2cqDL23ikb9u5nKTz7VjSrl0aJ6rym64ISYxu/BrrW0HRhljsoA/G2Nqgd3AtcDkM+mrvb2j2+uOuL3eTH+luLiPYuJOiov79KeYTBmczZTB2WzefYC6YPgRUM80tVGQFi67MavWoTQr9mU3erCO2Sm3RZOmbgMGdnpfGvnspG2MMfFAJuGbAE67r7V2L7CC8Bq0CwjPoDUbYzYDqZHLnyIiItLLleekcvekISz63Hh+NLuayvw0fv3qFj7+2Gv84x/eZvnaNg4fOx7rYcZUNDNmrwGVxpjBhJOq6wmv/+qsDrgZeBm4BnjeWtthjKkDnjLG3AcUA5XAq8aYfOCotXavMSYFmArca61dBDgnOjXG7I/cUCAiIiJ9RLw3jimVeUypzKP1/cMsbAhRFwzxb4vWkpkcz/TqcNmNofkDYj3UHnfaxCyyZuwuYBnhchm/tNY2GGO+D6y21tYBjwFPRma3dhNO3oi0m0f4RoFjwBette3GmCLg8cg6szhgnrV2YXecoIiIiLhXYXoSt00o47PjB/Hau3sJBEP88a3tzH19GzVOOn6fw1VV+QxI7B9lN/SszCj1p7UAvYni4j6KiTspLu6jmJza3oNHWdLURiDYwoadB0hJiOPKYfn4fQ4jijPweDzdclw9K1NERESki6yUBG4YXcL1FxTTEHqfQDDE8rU7WNDQyuCcVPw+hxnVBWSn9r2yG0rMRERExJU8Hg+1RRnUFmXwlckVPGt3MD8Y4mcvbOShlzYxaWgufp/DuEHZeOO6ZxatpykxExEREddLTfQy2+cw2+ewcdcHBIIhFje28dy6nTjpScyqDZfdKMpIjvVQz4nWmEVJawHcSXFxH8XEnRQX91FMzt2RY8d5ccMuAvUhVm3eA8D48mzm+Bwuq8gl4QyL12qNmYiIiMhZSoyP40qTz5Umn5b3DrGgPkRdfSvfXNBEVkoCM6oL8PschuT2nrIbSsxERESk1yvKSOZzF5dz24QyXn13D4FgiHlvbOepNdsYUZyBv9bhSpNPaqI31kP9SErMREREpM/wxnm4qDyHi8pz2H3gCIsb26gLhvjB8nX8dMUGrqrKZ47PodpJ77ayG+dCiZmIiIj0STmpidw0tpR/GFPC29vfIxAMsbSpjfnBEBV5qfh9RUwfXkBWSkKsh/ohJWYiIiLSp3k8HkaWZDKyJJOvTqngGbuDQDDEfSs28OCLG5kyNI/ZPoepGbF/kLoSMxEREek30pLi+fiIIj4+ooj1O/Z/OIu23O5gyMqNPHb9SNKSYpceKTETERGRfqkyP42vXz6UL102hBead7JhzyGS4s+sxMb5psRMRERE+rWk+DiuqipwRW252KaFIiIiIvIhJWYiIiIiLqHETERERMQllJiJiIiIuIQSMxERERGXUGImIiIi4hJKzERERERcQomZiIiIiEt4Ojo6Yj2G82EH8E6sByEiIiIShTIg/2Qb+kpiJiIiItLr6VKmiIiIiEsoMRMRERFxCSVmIiIiIi6hxExERETEJZSYiYiIiLiEEjMRERERl4iP9QDcxhgzDfg54AUetdb+sMv2JOAJYAywC7jOWru5p8fZn0QRk68CtwPHCNe0u9Vaq7p23ex0cenU7pPA08CF1trVPTjEfieamBhjPgV8F+gA3rLW3tijg+yHovgZNgh4HMiKtPmmtXZxjw+0HzHG/BKYCbRZa2tPst1DOGYzgAPALdba13tibJox68QY4wUeBqYD1cANxpjqLs1uA/ZYa4cC9wP39uwo+5coY/IGMNZaO4JwAvCjnh1l/xNlXDDGpANfBlb17Aj7n2hiYoypBO4BJlpra4B/6vGB9jNRfle+Bcyz1l4AXA880rOj7Jd+DUz7iO3TgcrIv88B/9UDYwKUmHU1Dmi21m601h4B5gL+Lm38hP+ygXAScEUks5bucdqYWGtXWGsPRN6+ApT28Bj7o2i+KwA/IPzHy6GeHFw/FU1M7gAettbuAbDWtvXwGPujaOLSAWREXmcC23twfP2StfZFYPdHNPEDT1hrO6y1rwBZxpiinhibErO/VwJs6fR+a+Szk7ax1h4D9gG5PTK6/imamHR2G7CkW0ckEEVcjDGjgYHW2kU9ObB+LJrvyjBgmDHmr8aYVyKX2KR7RROX7wI3GWO2AouBL/XM0OQjnOnvnvNGiZn0GcaYm4CxwI9jPZb+zhgTB9wHfC3WY5G/E0/40sxk4Abgf4wxWTEdkUA4Fr+21pYSXtP0ZOQ7JP2QAv/3tgEDO70vjXx20jbGmHjC0867emR0/VM0McEYcyXwb8Bsa+3hHhpbf3a6uKQDtcBKY8xmYAJQZ4wZ21MD7Iei+a5sBeqstUettZuAdYQTNek+0cTlNmAegLX2ZSAZyOuR0cmpRPW7pzvorsy/9xpQaYwZTDgA1wNd71iqA24GXgauAZ631upJ8N3ntDExxlwA/AKYpjUzPeYj42Kt3UenXyzGmJXA13VXZreK5ufXfMKzM78yxuQRvrS5sUdH2f9EE5d3gSuAXxtjhhNOzHb06CilqzrgLmPMXGA8sM9a29ITB9aMWSeRNWN3AcuAJv7/du4YpcEgiqLwsbdzEWc3bkKEYKkI1rYuQaxT2FkIVm5BC4VAStusIRZ/FvA3SQZyvnqKB7e582BmeiXzoz6ql7tjL8CFugZugYfjTHsaZmbyBJwDr+qX+nakcU/GzFxyQDMz+QA26i/wCdyvVqs2/ns0M5c74Fr9BpZMXzN04d8jdcm0YFH9U6/UhbrYHXlnurSsgWfg5lCznW23ZZ8kSTKCNmZJkiSDqJglSZIMomKWJEkyiIpZkiTJICpmSZIkg6iYJUmSDKJiliRJMoh/Tvglc/2UKNQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 4))\n",
    "sns.lineplot(range(len(history['train_loss'])), history['train_loss'])\n",
    "plt.title('Train loss')\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=(10, 4))\n",
    "sns.lineplot(range(len(history['val_accuracy'])), history['val_accuracy'])\n",
    "plt.title('Validation loss')\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=(10, 4))\n",
    "sns.lineplot(range(len(history['train_loss_stds'])), history['train_loss_stds'])\n",
    "plt.title('Train loss std')\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=(10, 4))\n",
    "sns.lineplot(range(len(history['val_accuracy_stds'])), history['val_accuracy_stds'])\n",
    "plt.title('Validation loss std')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SUBMIT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "ename": "Exception",
     "evalue": "You can only call `make_env()` once.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mException\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-58-849564dbc694>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0menv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnflrush\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmake_env\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/study/NFL BIG DATA/nfl-big-data-bowl-2020/kaggle/competitions/nflrush/competition.cpython-36m-x86_64-linux-gnu.so\u001b[0m in \u001b[0;36mcompetition.make_env\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;31mException\u001b[0m: You can only call `make_env()` once."
     ]
    }
   ],
   "source": [
    "env = nflrush.make_env()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def get_predictions(df_test, y_test, model):\n",
    "    X = make_x(preprocess_features(df_test), fillna=True)\n",
    "    y_pred = nn_pipeline_predict(model, scaler, X)\n",
    "    return y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# preprocess_features(df_test).columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set(make_x(df_train_preprocessed).columns).difference(set(make_x(preprocess_features(df_test), fillna=True)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# set(make_x(preprocess_features(df_test), fillna=True).columns).difference(set(make_x(df_train_preprocessed).columns))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "iter_test = env.iter_test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = get_predictions(df_test, y_cdf_test, model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "0it [00:00, ?it/s]\u001b[A"
     ]
    }
   ],
   "source": [
    "for df_test, y_cdf_test in tqdm.tqdm(iter_test):\n",
    "    y_pred = get_predictions(df_test, y_cdf_test, model)\n",
    "    env.predict(pd.DataFrame(data=y_pred,columns=y_cdf_test.columns))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "env.write_submission_file()"
   ]
  },
  {
   "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}