random_forest_fitting.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import os\n",
    "import numpy as np\n",
    "import csv\n",
    "import geopy\n",
    "from geopy.distance import great_circle\n",
    "import matplotlib.pylab as plt\n",
    "import pandas as pd\n",
    "import pickle\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def match_iata_code(code,reader):\n",
    "    for row in reader:\n",
    "        if(row['iata_code'] == code):\n",
    "            if row['id']!='326459':   #CDG weirdness\n",
    "                return row['latitude_deg'],row['longitude_deg'],row['name']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def monthToNum(month):\n",
    "    monthNum = {\n",
    "                    'Jan' : 1,\n",
    "                    'Feb' : 2,\n",
    "                    'Mar' : 3,\n",
    "                    'Apr' : 4,\n",
    "                    'May' : 5,\n",
    "                    'Jun' : 6,\n",
    "                    'Jul' : 7,\n",
    "                    'Aug' : 8,\n",
    "                    'Sep' : 9, \n",
    "                    'Oct' : 10,\n",
    "                    'Nov' : 11,\n",
    "                    'Dec' : 12\n",
    "            }\n",
    "    return monthNum[month]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_faredetective(flag='all'):\n",
    "    ### flag = 'all': load all data, even if there are multiple prices per month\n",
    "    ### flag = 'min': only load the lowest price each month\n",
    "    ### flag = 'interp': load all data, but give each datum a different time code in the month\n",
    "    origin = np.zeros(0,dtype='a32')\n",
    "    destination = np.zeros(0,dtype='a32')\n",
    "    year = np.zeros(0)\n",
    "    month = np.zeros(0)\n",
    "    fare = np.zeros(0)\n",
    "    for root, dirs, files in os.walk(\"./faredetective\"):  \n",
    "        for filename in files:\n",
    "            org = filename[:3]\n",
    "            dst = filename[4:7]\n",
    "            with open('./faredetective/'+filename) as json_file:\n",
    "                data = json.load(json_file)\n",
    "                for i in range(len(data)):\n",
    "                    if flag == 'all' or flag == 'interp':\n",
    "                        origin = np.append(origin,org)\n",
    "                        destination = np.append(destination,dst)\n",
    "                        [mn,yr] = data[i]['year'].split('\\n') \n",
    "                        year = np.append(year,yr)\n",
    "                        month = np.append(month,mn)\n",
    "                        fare = np.append(fare,data[i]['price'])\n",
    "                    elif flag == 'min':\n",
    "                        [mn,yr] = data[i]['year'].split('\\n') \n",
    "                        if len(month) > 0:\n",
    "                            if (mn == month[-1]) and (yr == year[-1]):\n",
    "                                if data[i]['price'] < fare[-1]:\n",
    "                                    fare[-1] = data[i]['price']\n",
    "                                else:\n",
    "                                    pass\n",
    "                            else:\n",
    "                                origin = np.append(origin,org)\n",
    "                                destination = np.append(destination,dst)\n",
    "                                [mn,yr] = data[i]['year'].split('\\n') \n",
    "                                year = np.append(year,yr)\n",
    "                                month = np.append(month,mn)\n",
    "                                fare = np.append(fare,data[i]['price'])\n",
    "                        else:\n",
    "                            origin = np.append(origin,org)\n",
    "                            destination = np.append(destination,dst)\n",
    "                            [mn,yr] = data[i]['year'].split('\\n') \n",
    "                            year = np.append(year,yr)\n",
    "                            month = np.append(month,mn)\n",
    "                            fare = np.append(fare,data[i]['price'])\n",
    "                    else:\n",
    "                        print('flag is broken')\n",
    "                        stop\n",
    "    unique_codes = np.unique(np.concatenate([origin,destination]))\n",
    "    code_name_dict = {}\n",
    "    code_lat_dict = {}\n",
    "    code_lon_dict = {}\n",
    "    for code in unique_codes: \n",
    "        with open('airports.csv') as csvfile:\n",
    "            reader = csv.DictReader(csvfile)\n",
    "            lat,lon,name = match_iata_code(code,reader)\n",
    "            code_name_dict[code] = name\n",
    "            code_lat_dict[code] = np.float(lat)\n",
    "            code_lon_dict[code] = np.float(lon)\n",
    "    gc_list = []\n",
    "    N = len(origin)\n",
    "    for i in range(N):\n",
    "        c1 = (code_lat_dict[origin[i]],code_lon_dict[origin[i]])\n",
    "        c2 = (code_lat_dict[destination[i]],code_lon_dict[destination[i]])\n",
    "        gcd = great_circle(c1,c2).miles\n",
    "        gc_list.append(gcd)\n",
    "    gc_distance = np.array(gc_list)\n",
    "    month_num = ([monthToNum(month[i]) for i in range(N)])\n",
    "    date_code = ([np.float(year[i]) + np.float(month_num[i])/12.0 for i in range(N)])\n",
    "    df = pd.DataFrame({'Origin lat' : [code_lat_dict[origin[i]] for i in range(N)],        #0\n",
    "                   'Origin lon' : [code_lon_dict[origin[i]] for i in range(N)],\n",
    "                   'Destination lat' : [code_lat_dict[destination[i]] for i in range(N)],\n",
    "                   'Destination lon' : [code_lon_dict[destination[i]] for i in range(N)],\n",
    "                   'distance' : [gc_list[i] for i in range(N)],\n",
    "                   'year' : [year[i] for i in range(N)],\n",
    "                   'month' : [month_num[i] for i in range(N)],\n",
    "                   'date' : [date_code[i] for i in range(N)],\n",
    "                    'within 100 days' : [0.0 for i in range(N)],\n",
    "                   'airfare' : [fare[i].astype(float) for i in range(N)]})\n",
    "    if flag == 'interp':\n",
    "        dupes = df.duplicated(subset=['Origin lat','Origin lon','Destination lat','Destination lon','date'], keep=False)\n",
    "        dupe_count = np.zeros(len(dupes))\n",
    "        for i in range(len(dupes)):\n",
    "            if dupes[i]:\n",
    "                j = i; dc = 0\n",
    "                while dupes[j]:\n",
    "                    j += 1\n",
    "                    dc += 1\n",
    "                dupe_count[i] = dc\n",
    "        date_corr = 1 / (dupe_count+0.8)\n",
    "        date_corr[np.where(date_corr> 1)] = 0\n",
    "        df['date'] = df['date'] + date_corr/12.0\n",
    "    return df.sort_values(by='date')\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_skypicker():\n",
    "    origin = np.zeros(0,dtype='a32')\n",
    "    destination = np.zeros(0,dtype='a32')\n",
    "    year = np.zeros(0)\n",
    "    month = np.zeros(0)\n",
    "    day = np.zeros(0)\n",
    "    fare = np.zeros(0)\n",
    "    for root, dirs, files in os.walk(\"./skypicker\"):  \n",
    "        for filename in files:\n",
    "            org = filename[:3]\n",
    "            dst = filename[4:7]\n",
    "            fre, yr, mn, dy = np.loadtxt('./skypicker/'+filename,unpack=True)\n",
    "            for i in range(len(fre)):\n",
    "                origin = np.append(origin,org)\n",
    "                destination = np.append(destination,dst)\n",
    "                year = np.append(year,yr[i])\n",
    "                month = np.append(month,mn[i])\n",
    "                day = np.append(day,dy[i])\n",
    "                fare = np.append(fare,fre[i])\n",
    "    unique_codes = np.unique(np.concatenate([origin,destination]))\n",
    "    code_name_dict = {}\n",
    "    code_lat_dict = {}\n",
    "    code_lon_dict = {}\n",
    "    for code in unique_codes: \n",
    "        with open('airports.csv') as csvfile:\n",
    "            reader = csv.DictReader(csvfile)\n",
    "            lat,lon,name = match_iata_code(code,reader)\n",
    "            code_name_dict[code] = name\n",
    "            code_lat_dict[code] = np.float(lat)\n",
    "            code_lon_dict[code] = np.float(lon)\n",
    "    gc_list = []\n",
    "    N = len(origin)\n",
    "    for i in range(N):\n",
    "        c1 = (code_lat_dict[origin[i]],code_lon_dict[origin[i]])\n",
    "        c2 = (code_lat_dict[destination[i]],code_lon_dict[destination[i]])\n",
    "        gcd = great_circle(c1,c2).miles\n",
    "        gc_list.append(gcd)\n",
    "    gc_distance = np.array(gc_list)\n",
    "    date_code = ([np.float(year[i]) + np.float(month[i])/12.0 + np.float(day[i])/365.0 for i in range(N)])\n",
    "    #within_100_days = (year == 2018)*(month < 10)*(1./(np.array(date_code) - 2018.5))\n",
    "    within_100_days = (np.array(date_code) > 2018.5)*(2018.8-np.array(date_code))*(np.array(date_code) < 2018.8)\n",
    "    df = pd.DataFrame({'Origin lat' : [code_lat_dict[origin[i]] for i in range(N)],        #0\n",
    "                   'Origin lon' : [code_lon_dict[origin[i]] for i in range(N)],\n",
    "                   'Destination lat' : [code_lat_dict[destination[i]] for i in range(N)],\n",
    "                   'Destination lon' : [code_lon_dict[destination[i]] for i in range(N)],\n",
    "                   'distance' : [gc_list[i] for i in range(N)],\n",
    "                   'year' : [year[i] for i in range(N)],\n",
    "                   'month' : [month[i] for i in range(N)],\n",
    "                   'date' : [date_code[i] for i in range(N)],\n",
    "                    'within 100 days' : [within_100_days[i] for i in range(N)],\n",
    "                   'airfare' : [fare[i].astype(float) for i in range(N)]})\n",
    "    return df.sort_values(by='date')\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp = load_skypicker()\n",
    "fd_interp = load_faredetective(flag='interp')\n",
    "fd_min = load_faredetective(flag='min')\n",
    "fd_all = load_faredetective(flag='all')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_all = pd.concat([fd_all,sp])\n",
    "df_min = pd.concat([fd_min,sp])\n",
    "df_interp = pd.concat([fd_interp,sp])\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neural_network import MLPRegressor\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "#from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import TimeSeriesSplit\n",
    "from sklearn.preprocessing import StandardScaler  \n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.datasets import make_regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_airfares(route,reg,N_months=18):\n",
    "    #### route = 'MUC-YVR', for example\n",
    "    origin = route[:3]\n",
    "    destination = route[-3:]\n",
    "    print(origin)\n",
    "    print(destination)\n",
    "    with open('airports.csv') as csvfile:\n",
    "        reader = csv.DictReader(csvfile)\n",
    "        origin_lat,origin_lon,_ = match_iata_code(origin,reader)\n",
    "    with open('airports.csv') as csvfile:\n",
    "        reader = csv.DictReader(csvfile)\n",
    "        destination_lat,destination_lon,_ = match_iata_code(destination,reader)\n",
    "    print(origin_lat)\n",
    "    c1 = (origin_lat,origin_lon)\n",
    "    c2 = (destination_lat,destination_lon)\n",
    "    gcd = great_circle(c1,c2).miles\n",
    "    from datetime import datetime, timedelta, date, time\n",
    "    a = pd.date_range(start=datetime.today(), periods=N_months,freq='m')\n",
    "    month_num = a.month\n",
    "    year= a.year\n",
    "    date_code = a.year + a.month/12.0 + 1.0/24.0\n",
    "    #within_100_days = (year.values == 2018).astype(float)*(month_num < 10).astype(float)* (1./(date_code - 2018.5))\n",
    "    within_100_days = (date_code > 2018.5).astype(float)*(2018.8-date_code.astype(float))*(date_code < 2018.80).astype(float)\n",
    "    X_extrapolate = pd.DataFrame({'Origin lat' : [np.float(origin_lat) for i in range(N_months)],        #0\n",
    "                       'Origin lon' : [np.float(origin_lon) for i in range(N_months)],\n",
    "                       'Destination lat' : [np.float(destination_lat) for i in range(N_months)],\n",
    "                       'Destination lon' : [np.float(destination_lon) for i in range(N_months)],\n",
    "                       'distance' : [gcd for i in range(N_months)],\n",
    "                       'year' : [year[i] for i in range(N_months)],\n",
    "                       'month' : [month_num[i] for i in range(N_months)],\n",
    "                        'date' : [date_code[i] for i in range(N_months)],\n",
    "                        'within 100 days' : [within_100_days[i] for i in range(N_months)]})\n",
    "    Y_new = reg.predict(X_extrapolate)\n",
    "    return date_code,Y_new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_timeseries(X,Y,n_splits=5,name='neural'):\n",
    "    count = 0\n",
    "    tscv = TimeSeriesSplit(n_splits=n_splits)\n",
    "    for train_index, test_index in tscv.split(X):\n",
    "        X_train = X.iloc[train_index]\n",
    "        X_test = X.iloc[test_index]\n",
    "        Y_train = Y.iloc[train_index]\n",
    "        Y_test = Y.iloc[test_index]\n",
    "        reg = fit_timeseries(X_train,Y_train)#MLPRegressor(hidden_layer_sizes=(15,20,20),max_iter=10000)\n",
    "        #reg.fit(X_train, Y_train)\n",
    "        Y_pred = reg.predict(X_test)\n",
    "        plt.figure()\n",
    "        plt.clf()\n",
    "        plt.hist(Y_pred/Y_test,bins=20)\n",
    "        plt.xlabel('predicted / true airfare',size=14)\n",
    "        plt.ylabel('N',size=14)\n",
    "        ratio = Y_pred/Y_test\n",
    "        plt.title(\"mean: %0.2f (+/- %0.2f)\" % (ratio.mean(), ratio.std()))\n",
    "        plt.savefig(name+'_'+str(count)+'.pdf')\n",
    "        count += 1\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit_timeseries(X,Y):\n",
    "    reg = RandomForestRegressor()\n",
    "    print(X.shape)\n",
    "    print(Y.shape)\n",
    "    #reg = MLPRegressor(hidden_layer_sizes=(20,20,20),max_iter=20000)#,verbose=True)\n",
    "    reg.fit(X, Y)\n",
    "    return reg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_test_fit(df,prefix,route):\n",
    "    X = df.drop([\"airfare\"], axis=1)\n",
    "    Y = df[\"airfare\"]\n",
    "    test_timeseries(X,Y,n_splits=5,name=prefix)\n",
    "    #X,Y,encoder,scaler,kmeans = prepare_df_kmeans(df)\n",
    "    #test_timeseries(X,Y,n_splits=5,name=prefix+'_scaled')\n",
    "    reg = fit_timeseries(X,Y)\n",
    "    result = reg.score(X,Y)\n",
    "    print(\"R2 score: \"+str(result))\n",
    "    filename = prefix+'_network.sav'\n",
    "    pickle.dump(reg, open(filename, 'wb'))\n",
    "    #filename = prefix+'_encoder.sav'\n",
    "    #pickle.dump(encoder, open(filename, 'wb'))\n",
    "    #filename = prefix+'_scaler.sav'\n",
    "    #pickle.dump(scaler, open(filename, 'wb'))\n",
    "    #filename = prefix+'_kmeans.sav'\n",
    "    #pickle.dump(kmeans, open(filename, 'wb'))\n",
    "    filename = prefix+'_df.sav'\n",
    "    pickle.dump(df, open(filename, 'wb'))\n",
    "    dates,preds = predict_airfares(route,reg,N_months=18)\n",
    "    origin = route[:3]\n",
    "    destination = route[-3:]\n",
    "    with open('airports.csv') as csvfile:\n",
    "        reader = csv.DictReader(csvfile)\n",
    "        origin_lat,origin_lon,_ = match_iata_code(origin,reader)\n",
    "    with open('airports.csv') as csvfile:\n",
    "        reader = csv.DictReader(csvfile)\n",
    "        destination_lat,destination_lon,_ = match_iata_code(destination,reader)\n",
    "    matches = df.loc[(df['Origin lon'] == np.float(origin_lon)) *\n",
    "                         (df['Destination lat'] == np.float(destination_lat))]\n",
    "    #print(matches)\n",
    "    plt.figure()\n",
    "    plt.clf()\n",
    "    plt.plot(matches['date'],matches['airfare'],'ok')\n",
    "    plt.plot(dates,preds,'-r',lw=2,alpha=0.7)\n",
    "    plt.savefig('/Users/michevan/Desktop/insight/'+prefix+'_'+route+'_pred.pdf')\n",
    "    plt.xlim([2018.4,2020])\n",
    "    plt.savefig('/Users/michevan/Desktop/insight/'+prefix+'_'+route+'_pred_zoom.pdf')\n",
    "    return dates,preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4268, 9)\n",
      "(4268,)\n",
      "(8535, 9)\n",
      "(8535,)\n",
      "(12802, 9)\n",
      "(12802,)\n",
      "(17069, 9)\n",
      "(17069,)\n",
      "(21336, 9)\n",
      "(21336,)\n",
      "(25603, 9)\n",
      "(25603,)\n",
      "R2 score: 0.947568914722\n",
      "ORD\n",
      "MUC\n",
      "41.97859955\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/envs/insight/lib/python3.6/site-packages/pandas/core/computation/expressions.py:180: UserWarning: evaluating in Python space because the '*' operator is not supported by numexpr for the bool dtype, use '&' instead\n",
      "  .format(op=op_str, alt_op=unsupported[op_str]))\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEaCAYAAAA7YdFPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAHtVJREFUeJzt3XuYXFWd7vHvC+FiuBggDcQk0KARBLwQWy6DMtGMQAgSzgAeUCECj9FHvCJCZHRQlJl45Ih6xuEYSSQZuYiAhygRjFzEWwLhfolADIE0CaSZkEi4iJHf+WOvkm2lurvSq9O7mryf56mna6+99q5fF029tdbe2VsRgZmZWV9tVnUBZmY2uDlIzMwsi4PEzMyyOEjMzCyLg8TMzLI4SMzMLIuDxMzMsjhIzAYBSVtJelDSrlXX0l8k3SZp36rrsHwOErMmSXq/pN9Jel7SLb30nSjpN5JWS3pS0vclbVdaP1LStZJWSeqU9LFeXn4KcGtEPNnH2h+W9MYm+35A0mOSnpP0/yTt2E2/d0laW/cIScem9SdIekjSGkkrJc2StH1pFxcA5/Xl97HW4iAxa94q4FvAtCb6vhb4GvA64E3AKOAbpfU/BB4FdgEmAv8m6d097O+jwH81WiFpXE/BJun1wGYR8XBvRacRwveAk1JtzwP/2ahvRPw6IratPYCjgLXA9anLb4FDIuK1wJ7AEIr3pGYO8G5JI3qry1qbg8QqJ2mppM9Lujd9C54haRdJP5f0rKRfStqh1P+gNDJYLekeSeNK606RtChtt0TSR0vrxqVv/59L35BXSDql2Toj4pcRcSWwvIm+l0XE9RHxfEQ8A3wfOCTVsS0wDjg/Iv4SEfcAVwGndvP+7Aa8HljQbK11JgJzm+z7QeCnEXFrRKwFvgT8c3k01YPJwFUR8RxARCyLiKdL6/8KvKG2EBEvAncAhzVZm7UoB4m1imOB9wJvBN4H/Bw4BxhO8Xf6KSimhIDrKL7Z7gicCVwtqS3tZyXFN+PtgVOACyWNLb3OrhSjhZHAacB3ayGVpnTu3Ui/36HAA+m56n7Wnu/XzbZvBpZExLo+vvaRFO9ZM/YF7qktRMQfgZco/rt0S9JQ4DhgVl37OyWtAZ6l+G/8rbpNFwFvbbI2a1EOEmsV/ycinoqIJ4BfAwsi4q6I+DPwE2D/1O9DwNyImBsRL0fEPGAhxYclEXFdRPwxCr8CfgG8q/Q6fwHOSyOBuRRTMXulbS+LiLf09y8m6b0U39b/Nb3OsxTTPl+StHUKumOBod3sYhjFB3FfXnso8A7gV01usi2wpq5tDdDbiORY4On614mI36SprdrU3tK67Z6l+P1sEHOQWKt4qvT8hQbL26bnuwPHp2mt1ZJWA+8ERgBImiBpfjqIvZoiYIaX9vXfdd/sny/tu99JOgi4DDiu7hjFB4E9gGXARcClQGc3u3mGug9ySVNLv//PgHfWvSc144HfRcSLknYrHxjv5rXWUozmyran9yCbDMyObi4nnr4gXA9cUbdqO2D1+lvYYOIgscFmGfBfETGs9NgmIqZJ2gq4muJsoF0iYhjFsQH1tMONRdL+FAeUT42IG8vrIuKxiDgqItoi4kBgJ+C2bnZ1L7CnpCGl7afVfn+KqbzflN+T0rZ/m9aKiMfrDo438gClqSZJewJbAd0eqJc0muKYz+zu+iRDKI71lL2J0lSaDU4OEhtsfgi8T9LhkjZPU0PjJI0CtqT40OsC1kmaQD8eyK29HsUH4mbptbfopu9+FN/APxkRP22w/k2StpO0paQPpTq/2WhfEdEJPAIc0IeyJ9D8gXYoRkbvS6f2bkNxeu41aTquOydRjHr+WG6U9ME0CpKk3YHzgRtL67cC3g7M24D6rAU5SGxQiYhlwCSKA/FdFCOUz1Oc3vosxUH5Kymmgz5AMSJoSvrge6CHLidRTLNdRHHc5QWKs7Fq26+VVDse8zmgDZhRmk4q7/twYEmq82PAERHR1cNr107JbVoKs7UR8Xiz20TEA6meSylOXNgO+Hhpnz+XdE7dZidTd5A92Qf4HcV02W+Bh4CPlNYfDdwSEb2eBWetTb5DolnrS9/e7wLGR8SKJrc5CxgeEWdt1OL6SNIC4LSIuL/qWiyPg8TsVUrS+4H7ImJR1bXYq5uDxMzMsvgYiZmZZRnSe5fBb/jw4dHe3l51GWZmg8odd9zxdES09dZvkwiS9vZ2Fi5cWHUZZmaDiqTHmunnqS0zM8viIDEzsywOEjMzy+IgMTOzLA4SMzPL4iAxM7MsDhIzM8viIDEzsywOEjMzy7JJ/Mv2wap96nV93nbptIn9WImZWfc8IjEzsywOEjMzy+IgMTOzLA4SMzPL4iAxM7MsDhIzM8viIDEzsywOEjMzy+IgMTOzLA4SMzPL4iAxM7MsAxYkkmZKWinp/gbrzpQUkoanZUn6jqTFku6VNLbUd7KkR9Jj8kDVb2ZmjQ3kiOQS4Ij6RkmjgfcCj5eaJwBj0mMKcFHquyNwLnAgcABwrqQdNmrVZmbWowELkoi4FVjVYNWFwFlAlNomAbOjMB8YJmkEcDgwLyJWRcQzwDwahJOZmQ2cSo+RSDoaeCIi7qlbNRJYVlruTG3dtTfa9xRJCyUt7Orq6seqzcysrLIgkTQU+BfgXxutbtAWPbSv3xgxPSI6IqKjra2t74WamVmPqhyRvB7YA7hH0lJgFHCnpF0pRhqjS31HAct7aDczs4pUFiQRcV9E7BwR7RHRThESYyPiSWAOcHI6e+sgYE1ErABuAA6TtEM6yH5YajMzs4oM5Om/lwO/B/aS1CnptB66zwWWAIuB7wMfB4iIVcBXgdvT47zUZmZmFRmwe7ZHxIm9rG8vPQ/g9G76zQRm9mtxZmbWZ/6X7WZmlsVBYmZmWRwkZmaWZcCOkWyq2qdeV3UJZmYblUckZmaWxUFiZmZZHCRmZpbFQWJmZlkcJGZmlsVBYmZmWRwkZmaWxUFiZmZZHCRmZpbFQWJmZlkcJGZmlsVBYmZmWRwkZmaWxUFiZmZZBvKe7TMlrZR0f6ntG5L+IOleST+RNKy07guSFkt6SNLhpfYjUttiSVMHqn4zM2tsIEcklwBH1LXNA/aLiLcADwNfAJC0D3ACsG/a5j8lbS5pc+C7wARgH+DE1NfMzCoyYEESEbcCq+rafhER69LifGBUej4JuCIi/hwRjwKLgQPSY3FELImIl4ArUl8zM6tIKx0jORX4eXo+ElhWWteZ2rprX4+kKZIWSlrY1dW1Eco1MzNokSCR9C/AOuDSWlODbtFD+/qNEdMjoiMiOtra2vqnUDMzW0/l92yXNBk4ChgfEbVQ6ARGl7qNApan5921m5lZBSodkUg6AjgbODoini+tmgOcIGkrSXsAY4DbgNuBMZL2kLQlxQH5OQNdt5mZvWLARiSSLgfGAcMldQLnUpyltRUwTxLA/Ij4WEQ8IOlK4EGKKa/TI+KvaT+fAG4ANgdmRsQDA/U7mJnZ+gYsSCLixAbNM3rofz5wfoP2ucDcfizNzMwytMTBdjMzG7wcJGZmlsVBYmZmWRwkZmaWxUFiZmZZHCRmZpbFQWJmZlkcJGZmlsVBYmZmWRwkZmaWxUFiZmZZHCRmZpbFQWJmZlkcJGZmlsVBYmZmWRwkZmaWxUFiZmZZHCRmZpbFQWJmZlkGLEgkzZS0UtL9pbYdJc2T9Ej6uUNql6TvSFos6V5JY0vbTE79H5E0eaDqNzOzxgZyRHIJcERd21TgxogYA9yYlgEmAGPSYwpwERTBA5wLHAgcAJxbCx8zM6vGgAVJRNwKrKprngTMSs9nAceU2mdHYT4wTNII4HBgXkSsiohngHmsH05mZjaAqj5GsktErABIP3dO7SOBZaV+namtu/b1SJoiaaGkhV1dXf1euJmZFaoOku6oQVv00L5+Y8T0iOiIiI62trZ+Lc7MzF5RdZA8laasSD9XpvZOYHSp3yhgeQ/tZmZWkaqDZA5QO/NqMnBtqf3kdPbWQcCaNPV1A3CYpB3SQfbDUpuZmVVkyEC9kKTLgXHAcEmdFGdfTQOulHQa8DhwfOo+FzgSWAw8D5wCEBGrJH0VuD31Oy8i6g/gm5nZABqwIImIE7tZNb5B3wBO72Y/M4GZ/ViamZllqHpqy8zMBjkHiZmZZXGQmJlZFgeJmZllcZCYmVkWB4mZmWVxkJiZWRYHiZmZZXGQmJlZFgeJmZllcZCYmVkWB4mZmWVxkJiZWRYHiZmZZXGQmJlZFgeJmZllcZCYmVkWB4mZmWVpiSCR9FlJD0i6X9LlkraWtIekBZIekfQjSVumvlul5cVpfXu11ZuZbdoqDxJJI4FPAR0RsR+wOXAC8HXgwogYAzwDnJY2OQ14JiLeAFyY+pmZWUWaChJJOzbzyKhjCPAaSUOAocAK4D3AVWn9LOCY9HxSWiatHy9JGa9tZmYZhjTZ72kgeukTG7C/VzaKeELSBcDjwAvAL4A7gNURsS516wRGpucjgWVp23WS1gA7pRr/RtIUYArAbrvttqFlmZlZk5r94H93D+uOAD4NrOuhT7ck7UAxytgDWA38GJjQoGstyBqNPtYLuYiYDkwH6Ojo6C0Ezcysj5oKkoj4VX2bpLEUxycOBb4HfLWPNfwT8GhEdKX9XgP8AzBM0pA0KhkFLE/9O4HRQGeaCnstsKqPr21mZpk2+GB7OpvqMmABxQf4PhHxqVoQ9MHjwEGShqZjHeOBB4GbgeNSn8nAten5nLRMWn9TRHjEYWZWkaaDRNJOkr4N/AHYFTg4Iv5nRPwxp4CIWEBx0PxO4L5U03TgbOAMSYspjoHMSJvMAHZK7WcAU3Ne38zM8jQ1tSXpHOAsYCkwKSKu788iIuJc4Ny65iXAAQ36vggc35+vb2ZmfdfswfavUZxR1Ql8XNLHG3WKiKP7qzAzMxscmg2S2fR++q+ZmW2Cmj1r68MbuQ4zMxukKr9EipmZDW4OEjMzy+IgMTOzLA4SMzPL4iAxM7MsDhIzM8viIDEzsywOEjMzy+IgMTOzLA4SMzPL4iAxM7MsDhIzM8viIDEzsywOEjMzy+IgMTOzLC0RJJKGSbpK0h8kLZJ0sKQdJc2T9Ej6uUPqK0nfkbRY0r2SxlZdv5nZpqwlggT4NnB9ROwNvBVYBEwFboyIMcCNaRlgAjAmPaYAFw18uWZmVtPsrXY3GknbA4cCHwaIiJeAlyRNAsalbrOAW4CzgUnA7IgIYH4azYyIiBUDXHpLa596Xdb2S6dN7KdKzOzVrhVGJHsCXcAPJN0l6WJJ2wC71MIh/dw59R8JLCtt35nazMysAq0QJEOAscBFEbE/8ByvTGM1ogZtsV4naYqkhZIWdnV19U+lZma2nlYIkk6gMyIWpOWrKILlKUkjANLPlaX+o0vbjwKW1+80IqZHREdEdLS1tW204s3MNnWVB0lEPAksk7RXahoPPAjMASantsnAten5HODkdPbWQcAaHx8xM6tO5Qfbk08Cl0raElgCnEIRcldKOg14HDg+9Z0LHAksBp5Pfc3MrCItESQRcTfQ0WDV+AZ9Azh9oxdlZmZNqXxqy8zMBjcHiZmZZXGQmJlZFgeJmZllcZCYmVkWB4mZmWVxkJiZWRYHiZmZZXGQmJlZFgeJmZllcZCYmVkWB4mZmWVxkJiZWRYHiZmZZXGQmJlZFgeJmZllcZCYmVkWB4mZmWVxkJiZWZaWCRJJm0u6S9LP0vIekhZIekTSjyRtmdq3SsuL0/r2Kus2M9vUtUyQAJ8GFpWWvw5cGBFjgGeA01L7acAzEfEG4MLUz8zMKtISQSJpFDARuDgtC3gPcFXqMgs4Jj2flJZJ68en/mZmVoGWCBLgW8BZwMtpeSdgdUSsS8udwMj0fCSwDCCtX5P6/x1JUyQtlLSwq6trY9ZuZrZJqzxIJB0FrIyIO8rNDbpGE+teaYiYHhEdEdHR1tbWD5WamVkjQ6ouADgEOFrSkcDWwPYUI5RhkoakUccoYHnq3wmMBjolDQFeC6wa+LLNzAxaYEQSEV+IiFER0Q6cANwUER8EbgaOS90mA9em53PSMmn9TRGx3ojEzMwGRuVB0oOzgTMkLaY4BjIjtc8AdkrtZwBTK6rPzMxojamtv4mIW4Bb0vMlwAEN+rwIHD+ghZmZWbdaeURiZmaDgIPEzMyyOEjMzCyLg8TMzLI4SMzMLIuDxMzMsjhIzMwsi4PEzMyyOEjMzCyLg8TMzLI4SMzMLIuDxMzMsjhIzMwsi4PEzMyytNRl5K11tE+9rs/bLp02sR8rMbNW5xGJmZllcZCYmVkWB4mZmWWpPEgkjZZ0s6RFkh6Q9OnUvqOkeZIeST93SO2S9B1JiyXdK2lstb+BmdmmrRUOtq8DPhcRd0raDrhD0jzgw8CNETFN0lRgKnA2MAEYkx4HAhelnxtNzoFnM7NXu8pHJBGxIiLuTM+fBRYBI4FJwKzUbRZwTHo+CZgdhfnAMEkjBrhsMzNLKg+SMkntwP7AAmCXiFgBRdgAO6duI4Flpc06U1v9vqZIWihpYVdX18Ys28xsk9YyQSJpW+Bq4DMR8aeeujZoi/UaIqZHREdEdLS1tfVXmWZmVqclgkTSFhQhcmlEXJOan6pNWaWfK1N7JzC6tPkoYPlA1WpmZn+v8iCRJGAGsCgivllaNQeYnJ5PBq4ttZ+czt46CFhTmwIzM7OB1wpnbR0CnATcJ+nu1HYOMA24UtJpwOPA8WndXOBIYDHwPHDKwJZrZmZllQdJRPyGxsc9AMY36B/A6Ru1KDMza1rlU1tmZja4OUjMzCyLg8TMzLI4SMzMLIuDxMzMslR+1pa9+vjuimabFo9IzMwsi4PEzMyyOEjMzCyLg8TMzLI4SMzMLIvP2rKW4jO+zAYfj0jMzCyLg8TMzLI4SMzMLIuDxMzMsvhgu71q+EC9WTU8IjEzsywekZiRN5oBj2hs0zZog0TSEcC3gc2BiyNiWsUl2SYsN4j6ygFmrWBQTm1J2hz4LjAB2Ac4UdI+1VZlZrZpGqwjkgOAxRGxBEDSFcAk4MFKqzIbYFWNhKrkUVjrGaxBMhJYVlruBA4sd5A0BZiSFtdKeqiXfQ4Hnu63CvtPK9bVijWB69oQrVgTNFGXvj5Alfy9Vny/BqKm3ZvpNFiDRA3a4u8WIqYD05veobQwIjpyC+tvrVhXK9YErmtDtGJN4Lo2RCvVNCiPkVCMQEaXlkcByyuqxcxskzZYg+R2YIykPSRtCZwAzKm4JjOzTdKgnNqKiHWSPgHcQHH678yIeCBzt01Pgw2wVqyrFWsC17UhWrEmcF0bomVqUkT03svMzKwbg3Vqy8zMWoSDxMzMsjhIKC63IukhSYslTa26HgBJMyWtlHR/1bXUSBot6WZJiyQ9IOnTVdcEIGlrSbdJuifV9ZWqa6qRtLmkuyT9rOpaaiQtlXSfpLslLay6HgBJwyRdJekP6e/r4Baoaa/0HtUef5L0marrApD02fS3fr+kyyVtXWk9m/oxknS5lYeB91KcVnw7cGJEVPqv5CUdCqwFZkfEflXWUiNpBDAiIu6UtB1wB3BMC7xXAraJiLWStgB+A3w6IuZXWReApDOADmD7iDiq6nqgCBKgIyJa5h/YSZoF/DoiLk5nYg6NiNVV11WTPieeAA6MiMcqrmUkxd/4PhHxgqQrgbkRcUlVNXlEUrrcSkS8BNQut1KpiLgVWFV1HWURsSIi7kzPnwUWUVxloFJRWJsWt0iPyr8hSRoFTAQurrqWViZpe+BQYAZARLzUSiGSjAf+WHWIlAwBXiNpCDCUiv8dnYOk8eVWKv9wbHWS2oH9gQXVVlJIU0h3AyuBeRHRCnV9CzgLeLnqQuoE8AtJd6RLCVVtT6AL+EGaBrxY0jZVF1XnBODyqosAiIgngAuAx4EVwJqI+EWVNTlImrjciv09SdsCVwOfiYg/VV0PQET8NSLeRnGVgwMkVTodKOkoYGVE3FFlHd04JCLGUlw9+/Q0jVqlIcBY4KKI2B94DmiJY5UAaartaODHVdcCIGkHilmTPYDXAdtI+lCVNTlIfLmVDZKOQVwNXBoR11RdT700JXILcETFpRwCHJ2OR1wBvEfSD6stqRARy9PPlcBPKKZ3q9QJdJZGkVdRBEurmADcGRFPVV1I8k/AoxHRFRF/Aa4B/qHKghwkvtxK09JB7RnAooj4ZtX11EhqkzQsPX8Nxf9of6iypoj4QkSMioh2ir+pmyKi0m+NAJK2SSdKkKaPDgMqPTMwIp4ElknaKzWNp7VuCXEiLTKtlTwOHCRpaPp/cjzF8crKDMpLpPSnjXS5lWySLgfGAcMldQLnRsSMaqviEOAk4L50PALgnIiYW2FNACOAWenMms2AKyOiZU63bTG7AD8pPn8YAlwWEddXWxIAnwQuTV/mlgCnVFwPAJKGUpzR+dGqa6mJiAWSrgLuBNYBd1Hx5VI2+dN/zcwsj6e2zMwsi4PEzMyyOEjMzCyLg8TMzLI4SMzMLIuDxAYlSWemf+xXW/5yVVdKTldg/XIVrz3QJLVLCkkdTfSdIulxSS9vKu/PpspBYq8WFwD/2Gzn9GF43Easp9FrniDprm7WjUs1DR/ImvpgGcW/27m7p07pMh7fBb5Bce26CzZ+aVaVTf4fJFp1JG2ZrricLV39d22vHas1Cbg2Zwf9+Z71RUT8FXiypz7pMjq7U3y+/CwiVvT19ar+fa05HpFYv5B0i6T/K+nbkp5Jj29I2qzUZ2magpopaTVwaWofKemK0nbXSRpTt/+zJD0paa2k2cC2devXm9qSNDndwOnPkp6SdEmtjtTlx2kUsLS0zfvSVXFflPSopPPTv7aurd9Z0rWSXpD0mKRTm3x/tqC4ZtN6QZKupHxzWuxKNdVqvUXSRZIukNQF/Da1rzeiSu/vmaXl10qaruIGac9K+lVvU1KSPiTp9tR/paQfq7j/xd9qLU9tlUZSR6q4udhLFP8KvDbyWpLWt0t6fXrvnpT0nKQ7VVzcsv536NPfiFXHQWL96YMUf1MHU3yYTAHq7yh3BsV1sDqAc9IlKG4GXqSYmjqY4tLYv0zrkPR+4GvAuRQX83so7adbkj4KfA/4AfAW4Eigdumbd6SfH6GYpnlH2uZwig+u/wD2BU4FjgP+rbTrS4A3UFzP6xjgZKC9x3el8G6Ky303mtpaBhybnu+bairfffJDFFepfld6vV5JEnAdxbTSURSX/L8VuEnFDcq6syXF+/zWtN1wmrvO1NeBLwJ7U4Rl7aKZB6TfZxlF+P+c4pIjb6W4+Oc1kvau29cG/41YxSLCDz+yHxRX3H2YdNmd1PZFiqu61paXAj+t2+5U4JG67TYH/ht4f1r+HfD9uu1+CSwtLX8ZuL+03AlM66HeAI6ra7sV+FJd2zEUU2YC3pi2O6S0fnfgr8CXe3l/vgt8p4f149K+hzd4X+9tsv6lwJnp+XtS3a+p63M3cNYG/HfdO73WqLTcnpY76uo+tm67jtTe3sv+5wNfzP0b8aPah4+RWH+aH+n/8uT3wFclbR+v3Lek/h7hb6e4r8KzxZfovxkKvD49fxPr32Xw9xQjg/VI2pnim/iNG1j/2ynuZXJ2qW0z4DXArqmOl4Hbaisj4jFJzdx24GjgwxtYT01f7mnydor3sKvufd2aV97X9UgaSzEieRuwI6/cr2c3inDuTq/3fldxteFzKUY6IyjuZLk1cG8v+2rmb8Qq5CCxgfZc3fJmFN+ST2jQt6+3Gm50s7JmbAZ8hcY3MOrq637T8YRtgV/1sa769wyKb/v19WxRer4Z8BTFdFi9hjcjSx/0N1CM9k6iuNvkcODXFFNeG1pjvQsoprzOpBhhPA/MbrDvgfgbsX7kILH+dKAklUYlBwHLo+e7KN5Jcb+Hp6P7+3QvSvuaWWo7qLsdRsRTkp6guE/DvG66/YVieqS+lr0jYnGjDSQtovhQewfFdBuSdqO4S11PJgHXRcS6HvrUzkyqr6k7XRTf6mu17VJepvhddgFejoglTe5zb4rgOCciHk37/ecmt23GO4HZEXF12ndtdPRwL9s18zdiFfLBdutPrwO+JWmvdEbR54ELe9nmUopvztdK+kcVNxg7VNL/Lp2V821gsqSPSBoj6QvAgb3s93zgM5I+K+mNkt4m6XOl9UuB8ZJ2VfFvHgDOAz4g6TxJ+0naW9Jxkv4XQEQ8BFwPfE/SwZLeRnHw/YVeamnmtN/HKEYZE1XcqGvbXvrfRHGb3A5J+6c6Xiyt/yXFGV7XSpqQ3teDJX1FUqNRChQ3TPoz8AlJe0qaCHy1lzo2xMPA/5A0VtKbgR9STG31ppm/EauQg8T606UU36gXAN+nuJtij0ESEc8Dh1LczOjHFGfrzAJ2AJ5JfX5EcTD9fIrTSt8M9HiHxoi4CDid4sys+ykCYN9Sl89RnEm1LO2TiLgBmJjab0uPqRQfsDUfBh6l+CD/KXAZRSg1JGkPioP0Pd48KiKeoDh+cD7Fh+Z/9NQ/1b+E4mD8VRTHkFaW9hcUZ6rdRPHf4iHgSmAvurmVdER0AZMpTjB4MNXT49lxG+iMVOOvKc7emp+e96iZvxGrlm9sZf1C0i0UZ019oupaWomkzwLvjYgjq67FbGPxiMRs43oC+PeqizDbmHyw3Wwjiogrq67BbGPz1JaZmWXx1JaZmWVxkJiZWRYHiZmZZXGQmJlZFgeJmZll+f/ALtaAr6P0pQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEaCAYAAAA7YdFPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAHkVJREFUeJzt3XuUXGWd7vHvkwuIoCZIgzHJ2FGjCDoGbEM4HBVBIQQ1OKIDCgbkTJhlOF4GdQLLWSCYGZxBER1Ao0RgRDECDlGiGG6KZ+TSQIwJAWkgkCYhaU3AhJsm/M4f71ukqK7urvTu1O6mn89atbr2u9+967d3KvXUvtTeigjMzMz6a0TZBZiZ2dDmIDEzs0IcJGZmVoiDxMzMCnGQmJlZIQ4SMzMrxEFiZmaFOEjMhgBJLZLuk/SSsmsZCJL2krRS0s5l12LFOUjMGiTpI5L+R9JTkm5uoP9HJT0s6UlJ/y1p96pxp0hql/SspEsaePm5wPci4pl+1L2TpD9K2q3B/p+V9JikJyQt6OnDXtI+eRk25sf1kvbp4fXvldRZaYuIdcBNwOztXR4bfBwkZo3bAHwdOKevjpL2Bb4NHA/sBTwFXFjVZQ3wZWBBA/PaGZgFfL+H8Sf0EUbvBJZGxOYGXutwUmgdCrQCrwW+1EP3NcDRwO7AHsAi4Io6/T4PrK/Tfjlwcl812eDnILHSSVol6fOSluVv7xfnXR8/l7Qpf9MdW9V/Wt4yeFzS7yQdXDXuxLzLZJOkByWdXDXuYEmdkk6VtF7SWkknNlpnRFwfEQtJH6B9+Rjw04j4df4A/xfg7yS9LM/r6oj4b+BPDczrAODxiOjss2d9M4DFDfadBVwcESsiYiNwNnBCvY4R8XhErIp0nSUBW4HXV/eRNAk4Dvi3OrO4DXitpNc0WJsNUg4SGyw+BLwXeAPwfuDnwOmkb7ojgE8BSBoPXEv6Nr878DngKkkteT7rgfcBLwdOBM6TtH/V67wKeAUwHjgJuKASUnlX1LIBWp59gd9VBiLiAeAvefm211uA+wrUMoO0zhrxgrrz870kvbKnCSQ9DjwDfBP415rR3yT9Oz5dO11EbAE6gLc2WJsNUg4SGyy+GRHrIuJR4Bbgtoi4OyKeBX4C7Jf7HQcsjojFEfFcRCwB2kkflkTEtRHxQCS/An4JvKPqdf4KnBURf42IxcBm4I152h9ExN8O0PLsBjxR0/YE8LJ+zGsMsKk/RUh6LTA6IhoNotq6K897rDsixpDC+RTg7qrX/iAwKiJ+0svrbSItnw1ho8ouwCxbV/X86TrDlQPFrwE+LOn9VeNHkw7cIukI4AzSN/8RwEuB31f1/VP+JlzxVNW8B9Jm0lZRtZfTv0DYSM0HuaQLgY/mwZ2AUZKOysOPVAXikeTdWpLeQdrSA3g4IvZtoO7K817rjognJX0L6JL0JuBJ4N/JAd+LlwGP99HHBjlvkdhQsxr4r4gYU/XYNSLOyQelrwLOBfbK35QXk/bfN9sKqnbZ5C2DnYE/9GNey6jZJRYRn6wsP/BJ4AdV66N6q+r53VoRcUtE7JYf9UKkW935+bqIaORYTiW4xwOTSQfrb5H0GHA1MC6fDdYKIGkU6ZjK7+rNzIYOB4kNNd8H3i/pcEkjJb0kH0SfQPpmvjPQBWzJWyeHDdQLV16PtCU/Ir/26B66X57rfIekXYGzgKsjYlOe16g8r5FAZTl62kNwOzAmHx/annp3AaYCN2/HZJcBJ+VTe8cCXwQu6WH+75W0X14vLwe+Rtp6WgksByYCU/Lj/5C2MqeQvgyQa1sVEQ9vz3LZ4OMgsSElIlYDM0kHcLtIH0qfB0bkD+lPAQtJH2gfJZ2S2hBJH5O0opcux5N2s11EOu7yNPCdquk3591HRMQK4B9JgbKetAvnk1Xz+mKefi7puM/Tua3eMv+F9GF+XKPLkh0K/HZ7fnsSEb8g7ZK6CXg4P86ojJe0QtLH8uAY4Iek4ygPkLYupkfEMxGxJSIeqzxIp04/l4e35uk/BnxrO5fJBiH5Dolmg18+K+0WYL+I6HYGVA/TXAgsj4gL++zcZJL2BH5FWp7t/pGlDS4OErMXKUmzSb9lWVt2Lfbi5iAxM7NCfIzEzMwKGRa/I9ljjz2itbW17DLMzIaUO++8848R0dJXv2ERJK2trbS3t5ddhpnZkCKpoVOzvWvLzMwKcZCYmVkhDhIzMyvEQWJmZoU4SMzMrBAHiZmZFeIgMTOzQpoWJPky2bfne2yvkPSl3H6JpIckLc2PKbldkr4hqSPfy3v/qnnNknR/fsxq1jKYmVl3zfxB4rPAIRGxOd/D4TeSKndr+3xEXFnT/wjSzXEmAweQLt19gKTdSZe1bgMCuFPSoojY2JSlMDOzF2hakES6OuTmPDg6P3q7YuRM4LI83a2SxkgaBxwMLImIDQCSlgDTSfdFGHRa517b72lXnXPkAFZiZrZjNPUYSb6T2lLSjX6WRMRtedS8vPvqvHy7VEi361xdNXlnbuupvfa1Zktql9Te1dU14MtiZmZJU4MkIrZGxBRgAjBV0puB04C9gbcDuwP/nLvXu8929NJe+1rzI6ItItpaWvq85piZmfVTKWdtRcTjpPtIT4+ItZE8C3yPdB9nSFsaE6smmwCs6aXdzMxK0MyztlokjcnPdwHeA9ybj3sgScBRwPI8ySLg4/nsrWnAE/lOb9cBh0kaK2kscFhuMzOzEjTzrK1xwKWSRpICbGFE/EzSjfl+1AKWAv+Y+y8GZgAdwFPAiQARsUHS2cAdud9ZlQPvZmbWfM08a2sZsF+d9kN66B/AnB7GLQAWDGiBZmbWL/5lu5mZFeIgMTOzQhwkZmZWiIPEzMwKcZCYmVkhDhIzMyvEQWJmZoU4SMzMrBAHiZmZFeIgMTOzQhwkZmZWiIPEzMwKcZCYmVkhDhIzMyvEQWJmZoU4SMzMrBAHiZmZFeIgMTOzQhwkZmZWiIPEzMwKaVqQSHqJpNsl/U7SCklfyu2TJN0m6X5JP5K0U27fOQ935PGtVfM6LbffJ+nwZi2DmZl118wtkmeBQyLircAUYLqkacBXgPMiYjKwETgp9z8J2BgRrwfOy/2QtA9wDLAvMB24UNLIJi6HmZlVaVqQRLI5D47OjwAOAa7M7ZcCR+XnM/MwefyhkpTbr4iIZyPiIaADmNqERTAzszqaeoxE0khJS4H1wBLgAeDxiNiSu3QC4/Pz8cBqgDz+CeCV1e11pql+rdmS2iW1d3V17YjFMTMzmhwkEbE1IqYAE0hbEW+q1y3/VQ/jemqvfa35EdEWEW0tLS39LdnMzPpQyllbEfE4cDMwDRgjaVQeNQFYk593AhMB8vhXABuq2+tMY2ZmTdbMs7ZaJI3Jz3cB3gOsBG4Cjs7dZgHX5OeL8jB5/I0REbn9mHxW1yRgMnB7c5bCzMxqjeq7y4AZB1yaz7AaASyMiJ9Juge4QtKXgbuBi3P/i4H/ktRB2hI5BiAiVkhaCNwDbAHmRMTWJi6HmZlVaVqQRMQyYL867Q9S56yriHgG+HAP85oHzBvoGs3MbPv5l+1mZlaIg8TMzApxkJiZWSEOEjMzK8RBYmZmhThIzMysEAeJmZkV4iAxM7NCHCRmZlaIg8TMzApxkJiZWSEOEjMzK8RBYmZmhThIzMysEAeJmZkV4iAxM7NCHCRmZlaIg8TMzApxkJiZWSEOEjMzK8RBYmZmhTQtSCRNlHSTpJWSVkj6dG4/U9Kjkpbmx4yqaU6T1CHpPkmHV7VPz20dkuY2axnMzKy7UU18rS3AqRFxl6SXAXdKWpLHnRcR51Z3lrQPcAywL/Bq4HpJb8ijLwDeC3QCd0haFBH3NGUpzMzsBZoWJBGxFlibn2+StBIY38skM4ErIuJZ4CFJHcDUPK4jIh4EkHRF7usgMTMrQSnHSCS1AvsBt+WmUyQtk7RA0tjcNh5YXTVZZ27rqb32NWZLapfU3tXVNcBLYGZmFU0PEkm7AVcBn4mIPwMXAa8DppC2WL5a6Vpn8uil/YUNEfMjoi0i2lpaWgakdjMz666Zx0iQNJoUIpdHxNUAEbGuavx3gJ/lwU5gYtXkE4A1+XlP7WZm1mTNPGtLwMXAyoj4WlX7uKpuHwSW5+eLgGMk7SxpEjAZuB24A5gsaZKknUgH5Bc1YxnMzKy7Zm6RHAQcD/xe0tLcdjpwrKQppN1Tq4CTASJihaSFpIPoW4A5EbEVQNIpwHXASGBBRKxo4nKYmVmVZp619RvqH99Y3Ms084B5ddoX9zadmZk1j3/ZbmZmhThIzMysEAeJmZkV4iAxM7NCHCRmZlaIg8TMzApxkJiZWSEOEjMzK8RBYmZmhThIzMysEAeJmZkV4iAxM7NCHCRmZlaIg8TMzApxkJiZWSEOEjMzK8RBYmZmhThIzMysEAeJmZkV4iAxM7NCmhYkkiZKuknSSkkrJH06t+8uaYmk+/Pfsbldkr4hqUPSMkn7V81rVu5/v6RZzVoGMzPrrplbJFuAUyPiTcA0YI6kfYC5wA0RMRm4IQ8DHAFMzo/ZwEWQggc4AzgAmAqcUQkfMzNrvqYFSUSsjYi78vNNwEpgPDATuDR3uxQ4Kj+fCVwWya3AGEnjgMOBJRGxISI2AkuA6c1aDjMze6FSjpFIagX2A24D9oqItZDCBtgzdxsPrK6arDO39dRe+xqzJbVLau/q6hroRTAzs6zpQSJpN+Aq4DMR8efeutZpi17aX9gQMT8i2iKiraWlpX/FmplZn5oaJJJGk0Lk8oi4Ojevy7usyH/X5/ZOYGLV5BOANb20m5lZCZp51paAi4GVEfG1qlGLgMqZV7OAa6raP57P3poGPJF3fV0HHCZpbD7IflhuMzOzEoxq4msdBBwP/F7S0tx2OnAOsFDSScAjwIfzuMXADKADeAo4ESAiNkg6G7gj9zsrIjY0ZxHMzKxW04IkIn5D/eMbAIfW6R/AnB7mtQBYMHDVmZlZf/mX7WZmVkhDWyT5R4B98i4mM7Php9FdW3+kzim2NWI75mdmZi8SjX7wv7uXcdOBT5MugWJmZsNMQ0ESEb+qbcsXUfwK8E7g28DZA1uamZkNBdt9sF3SJEk/IF3eZAOwT0R8KiJ8HRIzs2Go4SCR9EpJ5wP3Aq8CDoyIv4+IB3ZYdWZmNug1FCSSTgceAN4FzIyIQyKifYdWZmZmQ0KjB9u/DDxNus7VJyV9sl6niPjAQBVmZmZDQ6NBchl9n/5rZmbDUKNnbZ2wg+swM7MhypdIMTOzQhwkZmZWiIPEzMwKcZCYmVkhDhIzMyvEQWJmZoU4SMzMrBAHiZmZFeIgMTOzQpoWJJIWSFovaXlV25mSHpW0ND9mVI07TVKHpPskHV7VPj23dUia26z6zcysvmZukVxCuptirfMiYkp+LAaQtA9wDLBvnuZCSSMljQQuAI4A9gGOzX3NzKwkTbvHekT8WlJrg91nAldExLPAQ5I6gKl5XEdEPAgg6Yrc954BLtfMzBo0GI6RnCJpWd71NTa3jQdWV/XpzG09tZuZWUnKDpKLgNcBU4C1wFdzu+r0jV7au5E0W1K7pPauLt8F2MxsRyk1SCJiXURsjYjngO+wbfdVJzCxqusEYE0v7fXmPT8i2iKiraWlZeCLNzMzoOQgkTSuavCDQOWMrkXAMZJ2ljQJmAzcDtwBTJY0SdJOpAPyi5pZs5mZvVDTDrZL+iFwMLCHpE7gDOBgSVNIu6dWAScDRMQKSQtJB9G3AHMiYmuezynAdcBIYEFErGjWMpiZWXfNPGvr2DrNF/fSfx4wr077YmDxAJZmZmYFlH2w3czMhjgHiZmZFeIgMTOzQhwkZmZWiIPEzMwKcZCYmVkhDhIzMyvEQWJmZoU4SMzMrBAHiZmZFeIgMTOzQhwkZmZWiIPEzMwKcZCYmVkhDhIzMyvEQWJmZoU4SMzMrBAHiZmZFeIgMTOzQhwkZmZWiIPEzMwKaVqQSFogab2k5VVtu0taIun+/Hdsbpekb0jqkLRM0v5V08zK/e+XNKtZ9ZuZWX3N3CK5BJhe0zYXuCEiJgM35GGAI4DJ+TEbuAhS8ABnAAcAU4EzKuFjZmblaFqQRMSvgQ01zTOBS/PzS4Gjqtovi+RWYIykccDhwJKI2BARG4EldA8nMzNrorKPkewVEWsB8t89c/t4YHVVv87c1lN7N5JmS2qX1N7V1TXghZuZWVJ2kPREddqil/bujRHzI6ItItpaWloGtDgzM9um7CBZl3dZkf+uz+2dwMSqfhOANb20m5lZScoOkkVA5cyrWcA1Ve0fz2dvTQOeyLu+rgMOkzQ2H2Q/LLeZmVlJRjXrhST9EDgY2ENSJ+nsq3OAhZJOAh4BPpy7LwZmAB3AU8CJABGxQdLZwB2531kRUXsA38zMmqhpQRIRx/Yw6tA6fQOY08N8FgALBrA0MzMroOxdW2ZmNsQ5SMzMrBAHiZmZFeIgMTOzQhwkZmZWiIPEzMwKcZCYmVkhDhIzMyvEQWJmZoU4SMzMrBAHiZmZFeIgMTOzQhwkZmZWiIPEzMwKcZCYmVkhDhIzMyvEQWJmZoU4SMzMrBAHiZmZFeIgMTOzQkaVXQCApFXAJmArsCUi2iTtDvwIaAVWAR+JiI2SBJwPzACeAk6IiLvKqHtHa517bb+nXXXOkQNYiZlZzwbTFsm7I2JKRLTl4bnADRExGbghDwMcAUzOj9nARU2v1MzMnjeYgqTWTODS/PxS4Kiq9ssiuRUYI2lcGQWamdngCZIAfinpTkmzc9teEbEWIP/dM7ePB1ZXTduZ215A0mxJ7ZLau7q6dmDpZmbD26A4RgIcFBFrJO0JLJF0by99VactujVEzAfmA7S1tXUbb2ZmA2NQbJFExJr8dz3wE2AqsK6yyyr/XZ+7dwITqyafAKxpXrVmZlat9CCRtKukl1WeA4cBy4FFwKzcbRZwTX6+CPi4kmnAE5VdYGZm1nyDYdfWXsBP0lm9jAJ+EBG/kHQHsFDSScAjwIdz/8WkU387SKf/ntj8ks3MrKL0IImIB4G31mn/E3BonfYA5jShNDMza0Dpu7bMzGxoc5CYmVkhDhIzMyvEQWJmZoU4SMzMrBAHiZmZFeIgMTOzQhwkZmZWiIPEzMwKcZCYmVkhDhIzMyvEQWJmZoU4SMzMrBAHiZmZFeIgMTOzQhwkZmZWiIPEzMwKKf0OiUNB69xryy7BzGzQ8haJmZkV4iAxM7NCHCRmZlbIkD1GImk6cD4wEvhuRJxTckmDStHjOqvOOXKAKjGzF7shuUUiaSRwAXAEsA9wrKR9yq3KzGx4GqpbJFOBjoh4EEDSFcBM4J5Sq3oRKetMNW8JmQ09QzVIxgOrq4Y7gQOqO0iaDczOg5sl3dfgvPcA/li4wheHpq8LfaWZr9Ywvye28brYZjisi9c00mmoBonqtMULBiLmA/O3e8ZSe0S09bewFxOvi8TrYRuvi228LrYZksdISFsgE6uGJwBrSqrFzGxYG6pBcgcwWdIkSTsBxwCLSq7JzGxYGpK7tiJii6RTgOtIp/8uiIgVAzT77d4d9iLmdZF4PWzjdbGN10WmiOi7l5mZWQ+G6q4tMzMbJBwkZmZWiIMkkzRd0n2SOiTNLbueskiaKOkmSSslrZD06bJrKpukkZLulvSzsmspk6Qxkq6UdG9+fxxYdk1lkfTZ/P9juaQfSnpJ2TWVyUGCL7lSYwtwakS8CZgGzBnG66Li08DKsosYBM4HfhERewNvZZiuE0njgU8BbRHxZtIJP8eUW1W5HCTJ85dciYi/AJVLrgw7EbE2Iu7KzzeRPizGl1tVeSRNAI4Evlt2LWWS9HLgncDFABHxl4h4vNyqSjUK2EXSKOClDPPfsTlIknqXXBm2H54VklqB/YDbyq2kVF8HvgA8V3YhJXst0AV8L+/m+66kXcsuqgwR8ShwLvAIsBZ4IiJ+WW5V5XKQJH1ecmW4kbQbcBXwmYj4c9n1lEHS+4D1EXFn2bUMAqOA/YGLImI/4ElgWB5LlDSWtMdiEvBqYFdJx5VbVbkcJIkvuVJF0mhSiFweEVeXXU+JDgI+IGkVaXfnIZK+X25JpekEOiOisnV6JSlYhqP3AA9FRFdE/BW4GvhfJddUKgdJ4kuuZJJE2g++MiK+VnY9ZYqI0yJiQkS0kt4TN0bEsPzmGRGPAaslvTE3HcrwvW3DI8A0SS/N/18OZZieeFAxJC+RMtB28CVXhpqDgOOB30tamttOj4jFJdZkg8P/BS7PX7YeBE4suZ5SRMRtkq4E7iKd5Xg3w/xyKb5EipmZFeJdW2ZmVoiDxMzMCnGQmJlZIQ4SMzMrxEFiZmaFOEhsSJL0ufxDwcrwmZKWl1TLcklnlvHazSapVVJIamug72xJj0h6brisn+HKQWIvFucC72q0c/4wPHoH1lPvNY+RdHcP4w7ONe3RzJr6YTUwDljaW6d8GZELgP8gXbfu3B1fmpXFP0i00kjaKV9tubCI2AxsHoh57UAzgWuKzGAg11l/RMRW4LHe+uRL7LyG9Pnys4hY29/XK3t5rTHeIrEBIelmSd+SdL6kjfnxH5JGVPVZlXdBLZD0OHB5bh8v6Yqq6a6VNLlm/l+Q9JikzZIuA3arGd9t15akWZJ+L+lZSeskXVKpI3f5cd4KWFU1zfsl3SnpGUkPSZqXf8ldGb+npGskPS3pYUmfaHD9jCbd76ZbkOSrLN+UB7tyTZVab5Z0kaRzJXUB/y+3d9uiyuv3c1XDr5A0X9J6SZsk/aqvXVKSjpN0R+6/XtKP8/03nq+1etdW1ZbUDEm3S/oLcDLp194AD+bxrZJel9fdY5KelHRXvjBm7TL06z1i5XGQ2ED6GOk9dSDpw2Q28JmaPv8E3Au0AadLeinpQ/QZ0q6pA0mX5r4+j0PSR4AvA2eQLhR4X55PjySdDHwb+B7wt8AMoHLZm7fnv/9A2k3z9jzN4aQPrv8E9gU+ARwN/GvVrC8BXk+6cN9RwMeB1l7XSvJu0uXG6+3aWg18KD/fN9dUfWfK40hXqH5Hfr0+SRJwLWm30vtItwP4NXCjpHG9TLoTaT2/NU+3B/DDBl7yK8AXgb1JYTk9t0/Ny7OaFP4/B96b538VcLWkvWvmtd3vEStZRPjhR+EHcDPwB/Jld3LbF0lXjK0MrwJ+WjPdJ4D7a6YbCfwJ+Ege/h/gOzXTXQ+sqho+E1heNdwJnNNLvQEcXdP2a+BfatqOIu0yE/CGPN1BVeNfA2wFzuxj/VwAfKOX8Qfnee9RZ70ua7D+VcDn8vNDct271PRZCnxhO/5d986vNSEPt+bhtpq6P1QzXVtub+1j/rcCXyz6HvGj3IePkdhAujXy//Lst8DZkl4e2+5p0l4zzdtI93XYlL5EP++lwOvy8zfR/Q6FvyVtGXQjaU/SN/EbtrP+twFTJf1zVdsIYBfgVbmO54DbKyMj4mFJjdxy4APACdtZT0V/7ofyNtI67KpZry9h23rtRtL+pC2SKcDubLtXz9+Qwrkntf+u9ea9a573+0hbKaNzPcv6mFcj7xErkYPEmu3JmuERpG/J9e55vaGfr1HvRmWNGAF8CfhxnXFd/Z1vPp6wG/CrftZVu84gfduvrWd01fMRwDrS7rBadW9Ulj/oryNt7R0PrCft2rqFtMtre2usdS5pl9fnSFsYTwGX1Zl3M94jNoAcJDaQDpCkqq2SacCa6P0Oi3cBxwJ/jJ7vAb4yz2tBVdu0nmYYEeskPUq6T8SSHrr9lbR7pLaWvSOio94EklaSPtTeTtrdhqS/Id0lrzczgWsjYksvfSpnJtXW1JMu0rf6Sm17VQ+TlmUv4LmIeLDBee5NCo7TI+KhPN+/a3DaRvxv4LKIuCrPu7J19Ic+pmvkPWIl8sF2G0ivBr4u6Y35jKLPA+f1Mc3lpG/O10h6l9LNxd4p6atVZ+WcD8yS9A+SJks6DTigj/nOAz4j6bOS3iBpiqRTq8avAg6V9Cql3zwAnAV8VNJZkt4saW9JR0v6d4CIuA/4BfBtSQdKmkI6+P50H7U0ctrvw6StjCMltSjd6rg3NwJzJLVJ2i/X8UzV+OtJZ3hdI+mIvF4PlPQlSfW2UiDdsOlZ4BRJr5V0JHB2H3Vsjz8AH5S0v6S3AN8n7drqSyPvESuRg8QG0uWkb9S3Ad8h3Wmx1yCJiKeAd5JulPRj0tk6lwJjgY25z49IB9PnkU4rfQvQ690bI+IiYA7pzKzlpADYt6rLqaQzqVbneRIR1wFH5vbb82Mu6QO24gTgIdIH+U+BH5BCqS5Jk0gH6X/RR72Pko4fzCN9aP5nb/1z/Q+SDsZfSTqGtL5qfkE6U+1G0r/FfcBC4I30cBvpiOgCZpFOMLgn19Pr2XHb6Z9yjbeQzt66NT/vVSPvESuXb2xlA0LSzaSzpk4pu5bBRNJngfdGxIyyazHbUbxFYrZjPQr8W9lFmO1IPthutgNFxMKyazDb0bxry8zMCvGuLTMzK8RBYmZmhThIzMysEAeJmZkV4iAxM7NC/j+8ipnKfYuf8AAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dates,preds = test_test_fit(df_all,'k_all_direct_rf','ORD-MUC')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3603, 9)\n",
      "(3603,)\n",
      "(7204, 9)\n",
      "(7204,)\n",
      "(10805, 9)\n",
      "(10805,)\n",
      "(14406, 9)\n",
      "(14406,)\n",
      "(18007, 9)\n",
      "(18007,)\n",
      "(21608, 9)\n",
      "(21608,)\n",
      "R2 score: 0.979248644448\n",
      "ORD\n",
      "MUC\n",
      "41.97859955\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/envs/insight/lib/python3.6/site-packages/pandas/core/computation/expressions.py:180: UserWarning: evaluating in Python space because the '*' operator is not supported by numexpr for the bool dtype, use '&' instead\n",
      "  .format(op=op_str, alt_op=unsupported[op_str]))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dates,preds = test_test_fit(df_min,'k_min_direct_rf','ORD-MUC')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4268, 9)\n",
      "(4268,)\n",
      "(8535, 9)\n",
      "(8535,)\n",
      "(12802, 9)\n",
      "(12802,)\n",
      "(17069, 9)\n",
      "(17069,)\n",
      "(21336, 9)\n",
      "(21336,)\n",
      "(25603, 9)\n",
      "(25603,)\n",
      "R2 score: 0.97472227047\n",
      "ORD\n",
      "MUC\n",
      "41.97859955\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/envs/insight/lib/python3.6/site-packages/pandas/core/computation/expressions.py:180: UserWarning: evaluating in Python space because the '*' operator is not supported by numexpr for the bool dtype, use '&' instead\n",
      "  .format(op=op_str, alt_op=unsupported[op_str]))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZMAAAEaCAYAAADUo7pxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAHZ9JREFUeJzt3XuYHHWd7/H3h3BVZIlmwJgAE9gAC6gBRi6HA4IsdxXwtsELAXkMrvCsdxc47AOC7EHBCxwxGiRCVi6LGzmgRDCogJ7lNkAICRcJEMiQmAxXE7lo4Hv+qN9AZaZnppPfTFd35vN6nn7S9atfVX+7GPrT9avqKkUEZmZmOdarugAzM2t9DhMzM8vmMDEzs2wOEzMzy+YwMTOzbA4TMzPL5jAxM7NsDhOzFiCpTdLDkjauupahIGlLSQ9K2qjqWmxoOEzM6iTpY5L+W9KLkm4epO8Bku6X9LykZyRdI2lcaf5GkmZI+rOkP0n60iAvfwrwk4h4eS3q3lDS05I2rbP/F1NNL6Qaa37gS2qXFJJWlh7/Vpp/vqRHJK2Q9JCkY3vmRcQy4HfA1DV9P9acHCZm9XsW+B5wbh19HwAOiYjNgXcAjwDTSvPPBCYC2wAHAF+TdGitFaUP8ynAT/uZf5ykSweoZT9gbkSsHKxoSYdQBNeBQDuwLfD1QRbbPCI2TY+zS+1/AT4A/F2q/wJJ/6M0/3LgxMFqstbgMLHKSVok6auS5kn6i6RL0jDIr9K32pskjS713yvtITwv6T5J+5fmHZ+GT1ZIekzSiaV5+0vqkvRlScslLZV0fL11RsRNEXE1sKSOvssiotzvVeDvS9PHAmdHxHMR8SBwMXBcP6vbE3g+IrrqrbWXw4HZdfadAlwSEQsi4jng7AHqGlBEnBERD0XEaxFxB/B7YO9SlzuAbSVtszbrt+biMLFm8WHgIGB7im+zvwJOA8ZQ/J3+C0AaKroe+AbwVuArwCxJbWk9y4H3A5sBxwPflbRb6XXeTvFNeRxwAnBRT1BJ+rikeUP1hiRtLel54KVU57dS+2iKvZX7St3vA3buZ1XvBB7OKOVwim1Wj51r1LWlpLcNsMwTKaR/ImlMrQ6SNgHeAyzoaYuIVcBC4N111mZNzGFizeL/pG/zT1F8g70jIu6NiFeAa4BdU79PArMjYnb6xjsH6KT4wCQiro+IR6NwC/BrYN/S6/wNOCsi/hYRs4GVwA5p2Ssi4l1D9YYi4sk0zDUGOB14KM3qOXbxQqn7C8Bb+lnV5sCKtalB0rbABhFRbxhtWqMu+qntaYqA2AbYPfW5vJ/1/pAimG7s1b6C4v1Zi1u/6gLMkmWl5y/VmO75AN4G+KikD5Tmb0BxMBdJhwFnUOzhrAe8Cbi/1PeZ9I24x4uldQ+LiHhW0mXAfWnPqufYxWbAy6Xn/QXGc/T6MJf0A+DjaXJDYH1JR6XpJ0uheARpiEvSvhR7fABPREStPaGVqZYePc/71JaOwXSmyWWSTgaWStosIv5cqvU8YBfggOh7mfK3AM/XqMNajPdMrNUsBv4jIjYvPd4cEeemA9WzgPOBLdNewWxAVRacrA9sAWyWjkUsZfXhnXdTGgLqZR5FOL4uIj7X8/6BzwFXlLZHee/q9SGuiPh96UB5f0NqC2rUtSwinqnjPfYExevbW9LXgcOAg8sBk+atT3EcqTysZi3KYWKt5qfAByQdImmUpI3TgfXxFN/QNwK6gVVpL+XgoXrhntejCIb10mtv0E/fD0naQdJ66XjOd4B7I+LZ1GUmcLqk0ZJ2BD4DXNrPS98JbF4+tbjOejcB9gBuXoPFZgInSNopHds5vb+6JO1Zeo9vAy4Ebo6IF9L8Uyn2ng7qJ4z2ABZFxBNrUJ81KYeJtZSIWAwcSXFwvptiT+WrwHoRsYLiQP3VFENDHweuq3fdkj4hqb+9A4BPUQy5TaM4DvMSxVlYPcuvTENJUBzgv4FieOh+4DXg6NK6zgAeBZ4AbgHOi4gb+nnPf6X4QP9kve8lORC4bU1+m5Jq+BbFsOET6XFGz3xJCyR9Ik1uyxvvcT7wCnBMaXX/DmwNPFL6HcpppfmfoDiWYusA+U6LZs0v7d38Htg1Il6qc5kfAPMj4gfDWtxakLQFRYjuujY/xLTm4zAxW0dJmgr8IiKWVl2LrfscJmZmls3HTMzMLNuI+Z3JmDFjor29veoyzMxaxt133/10RLQN3nMEhUl7ezudnZ2DdzQzMwAk1X3atoe5zMwsm8PEzMyyOUzMzCybw8TMzLI1LEzS7T+XS5pfavtPSXPTY5Gkuam9XdJLpXk/LC2zu4rboS6UdKGkZriIn5nZiNbIs7kuBb5PcSE5ACLin3qeS/o2q99H4dGImFRjPdMo7ht9O8UVYQ/ljctqm5lZBRq2ZxIRt1LcQ7uPtHfxMeDKgdYhaSzFJbxvS/dFmAkcNdAyZmY2/JrlmMm+FPdMeKTUNkHSvZJu6XUl1vJ9sLtSm5mZVahZfrR4DKvvlSwFto6IZyTtDvxfSTtT+yZH/V5cLF3obirA1ltvPYTlmplZWeVhku629iGKe0gDkO77/Up6frekRynuNNcFjC8tPh5Y0t+6I2I6MB2go6Oj5a5o2X7K9Wu97KJzjxjCSszMBtYMw1z/CDwUEa8PX0lqkzQqPd8WmAg8li6lvULSXuk4y7HAtVUUbWZmb2jkqcFXArcBO0jqknRCmjWZvgfe9wPmSboP+C/gs6Xbnf4z8GNgIcWd6nwml5lZxRo2zBURx/TTflyNtlnArH76dwK7DGlxZmaWpRmGuczMrMU5TMzMLJvDxMzMsjlMzMwsm8PEzMyyOUzMzCybw8TMzLI5TMzMLJvDxMzMsjlMzMwsm8PEzMyyOUzMzCybw8TMzLI5TMzMLJvDxMzMsjlMzMwsm8PEzMyyOUzMzCybw8TMzLI5TMzMLJvDxMzMsjUsTCTNkLRc0vxS25mSnpI0Nz0OL807VdJCSQ9LOqTUfmhqWyjplEbVb2Zm/WvknsmlwKE12r8bEZPSYzaApJ2AycDOaZkfSBolaRRwEXAYsBNwTOprZmYVWr9RLxQRt0pqr7P7kcBVEfEK8LikhcAead7CiHgMQNJVqe8DQ1yumZmtgWY4ZnKypHlpGGx0ahsHLC716Upt/bXXJGmqpE5Jnd3d3UNdt5mZJVWHyTRgO2ASsBT4dmpXjb4xQHtNETE9IjoioqOtrS23VjMz60fDhrlqiYhlPc8lXQz8Mk12AVuVuo4HlqTn/bWbmVlFKt0zkTS2NHk00HOm13XAZEkbSZoATATuBO4CJkqaIGlDioP01zWyZjMz66theyaSrgT2B8ZI6gLOAPaXNIliqGoRcCJARCyQdDXFgfVVwEkR8Wpaz8nAjcAoYEZELGjUezAzs9oaeTbXMTWaLxmg/znAOTXaZwOzh7A0MzPLVPUBeDMzWwc4TMzMLJvDxMzMsjlMzMwsm8PEzMyyOUzMzCybw8TMzLI5TMzMLJvDxMzMsjlMzMwsm8PEzMyyOUzMzCybw8TMzLI5TMzMLJvDxMzMsjlMzMwsm8PEzMyyOUzMzCybw8TMzLI5TMzMLJvDxMzMsjUsTCTNkLRc0vxS23mSHpI0T9I1kjZP7e2SXpI0Nz1+WFpmd0n3S1oo6UJJatR7MDOz2hq5Z3IpcGivtjnALhHxLuCPwKmleY9GxKT0+GypfRowFZiYHr3XaWZmDdawMImIW4Fne7X9OiJWpcnbgfEDrUPSWGCziLgtIgKYCRw1HPWamVn9mumYyaeBX5WmJ0i6V9ItkvZNbeOArlKfrtRWk6SpkjoldXZ3dw99xWZmBjRJmEj6X8Aq4PLUtBTYOiJ2Bb4EXCFpM6DW8ZHob70RMT0iOiKio62tbajLNjOzZP2qC5A0BXg/cGAauiIiXgFeSc/vlvQosD3Fnkh5KGw8sKSxFZuZWW+V7plIOhT4V+CDEfFiqb1N0qj0fFuKA+2PRcRSYIWkvdJZXMcC11ZQupmZlTRsz0TSlcD+wBhJXcAZFGdvbQTMSWf43p7O3NoPOEvSKuBV4LMR0XPw/p8pzgzbhOIYS/k4i5mZVaBhYRIRx9RovqSfvrOAWf3M6wR2GcLSzMwsU1McgDczs9bmMDEzs2wOEzMzy+YwMTOzbA4TMzPL5jAxM7NsDhMzM8vmMDEzs2wOEzMzy+YwMTOzbA4TMzPL5jAxM7NsDhMzM8vmMDEzs2wOEzMzy+YwMTOzbA4TMzPL5jAxM7NsDhMzM8vmMDEzs2wOEzMzy9bQMJE0Q9JySfNLbW+VNEfSI+nf0aldki6UtFDSPEm7lZaZkvo/ImlKI9+DmZn11eg9k0uBQ3u1nQL8JiImAr9J0wCHARPTYyowDYrwAc4A9gT2AM7oCSAzM6tGQ8MkIm4Fnu3VfCRwWXp+GXBUqX1mFG4HNpc0FjgEmBMRz0bEc8Ac+gaUmZk1UDMcM9kyIpYCpH+3SO3jgMWlfl2prb/2PiRNldQpqbO7u3vICzczs0IzhEl/VKMtBmjv2xgxPSI6IqKjra1tSIszM7M3NEOYLEvDV6R/l6f2LmCrUr/xwJIB2s3MrCLNECbXAT1nZE0Bri21H5vO6toLeCENg90IHCxpdDrwfnBqMzOziqzfyBeTdCWwPzBGUhfFWVnnAldLOgF4Evho6j4bOBxYCLwIHA8QEc9KOhu4K/U7KyJ6H9Q3M7MGamiYRMQx/cw6sEbfAE7qZz0zgBlDWJqZmWVohmEuMzNrcQ4TMzPLVtcwV/rV+aB87MLMbGSq95jJ0/TzW46SWIP1mZnZOqTeD/8DBph3KPB5YFV+OWZm1orqCpOIuKV3W7qK7zeB/YAfAWcPbWlmZtYq1vgAvKQJkq4A7qC4aONOEfEvEeGLX5mZjVB1h4mkt0m6AHgIeDuwd0T8U0Q8OmzVmZlZS6grTCSdBjwKvBc4MiLeFxGdw1qZmZm1jHoPwH8DeIniIoufk/S5Wp0i4oNDVZjlaT/l+qzlF517xBBVYmYjQb1hMpPBTw02M7MRqt6zuY4b5jrMzKyF+XIqZmaWzWFiZmbZHCZmZpbNYWJmZtkcJmZmls1hYmZm2RwmZmaWzWFiZmbZKg8TSTtImlt6/FnSFySdKempUvvhpWVOlbRQ0sOSDqmyfjMza4I7I0bEw8AkAEmjgKeAa4Djge9GxPnl/pJ2AiYDOwPvAG6StH1EvNrQws3M7HWV75n0ciDwaEQ8MUCfI4GrIuKViHgcWAjs0ZDqzMyspmYLk8nAlaXpkyXNkzRD0ujUNg5YXOrTldrMzKwiTRMmkjYEPgj8LDVNA7ajGAJbCny7p2uNxWte0VjSVEmdkjq7u30jSDOz4dI0YQIcBtwTEcsAImJZRLwaEa8BF/PGUFYXsFVpufHAklorjIjpEdERER1tbW3DWLqZ2cjWTGFyDKUhLkljS/OOBuan59cBkyVtJGkCMBG4s2FVmplZH5WfzQUg6U3AQcCJpeZvSZpEMYS1qGdeRCyQdDXwALAKOMlncpmZVaspwiQiXgTe1qvtUwP0Pwc4Z7jrMjOz+jTTMJeZmbUoh4mZmWVzmJiZWTaHiZmZZXOYmJlZNoeJmZllc5iYmVk2h4mZmWVzmJiZWTaHiZmZZXOYmJlZNoeJmZllc5iYmVk2h4mZmWVzmJiZWTaHiZmZZXOYmJlZNoeJmZllc5iYmVk2h4mZmWVzmJiZWbamCRNJiyTdL2mupM7U9lZJcyQ9kv4dndol6UJJCyXNk7RbtdWbmY1sTRMmyQERMSkiOtL0KcBvImIi8Js0DXAYMDE9pgLTGl6pmZm9rtnCpLcjgcvS88uAo0rtM6NwO7C5pLFVFGhmZs0VJgH8WtLdkqamti0jYilA+neL1D4OWFxatiu1rUbSVEmdkjq7u7uHsXQzs5Ft/aoLKNknIpZI2gKYI+mhAfqqRlv0aYiYDkwH6Ojo6DPfzMyGRtOESUQsSf8ul3QNsAewTNLYiFiahrGWp+5dwFalxccDSxpa8Dqu/ZTr13rZReceMYSVmFkraIphLklvlvSWnufAwcB84DpgSuo2Bbg2Pb8OODad1bUX8ELPcJiZmTVes+yZbAlcIwmKmq6IiBsk3QVcLekE4Engo6n/bOBwYCHwInB840s2M7MeTREmEfEY8O4a7c8AB9ZoD+CkBpRmZmZ1aIphLjMza20OEzMzy+YwMTOzbA4TMzPL5jAxM7NsDhMzM8vmMDEzs2wOEzMzy+YwMTOzbA4TMzPL5jAxM7NsDhMzM8vmMDEzs2wOEzMzy+YwMTOzbA4TMzPL5jAxM7NsTXGnRVu3tJ9y/Vovu+jcI4awEjNrFO+ZmJlZNoeJmZllc5iYmVm2ysNE0laSfifpQUkLJH0+tZ8p6SlJc9Pj8NIyp0paKOlhSYdUV72ZmUFzHIBfBXw5Iu6R9Bbgbklz0rzvRsT55c6SdgImAzsD7wBukrR9RLza0KrNzOx1le+ZRMTSiLgnPV8BPAiMG2CRI4GrIuKViHgcWAjsMfyVmplZfyoPkzJJ7cCuwB2p6WRJ8yTNkDQ6tY0DFpcW66Kf8JE0VVKnpM7u7u5hqtrMzJomTCRtCswCvhARfwamAdsBk4ClwLd7utZYPGqtMyKmR0RHRHS0tbUNQ9VmZgbNccwESRtQBMnlEfFzgIhYVpp/MfDLNNkFbFVafDywpEGl2jDzDx7NWlPleyaSBFwCPBgR3ym1jy11OxqYn55fB0yWtJGkCcBE4M5G1WtmZn01w57JPsCngPslzU1tpwHHSJpEMYS1CDgRICIWSLoaeIDiTLCTfCaXmVm1Kg+TiPgDtY+DzB5gmXOAc4atqCGUM2xjZtYqKh/mMjOz1ucwMTOzbA4TMzPL5jAxM7NsDhMzM8vmMDEzs2wOEzMzy+YwMTOzbA4TMzPLVvkv4M2GSu7VBnyhSLO15z0TMzPL5jAxM7NsDhMzM8vmMDEzs2w+AG+W+C6PZmvPeyZmZpbNYWJmZtkcJmZmls1hYmZm2XwA3mwI+OC9jXQOE7OKVRVEvvyMDaWWDRNJhwIXAKOAH0fEucP1Wrn/05mZretaMkwkjQIuAg4CuoC7JF0XEQ9UW5lZY1X5RcdDe1bWkmEC7AEsjIjHACRdBRwJOEzMWoD39tdMK4Rvq4bJOGBxaboL2LN3J0lTgalpcqWkhxtQWxXGAE9XXUQT8fZYnbfH6lpue+ibw7bqwbbFNvWuqFXDRDXaok9DxHRg+vCXUy1JnRHRUXUdzcLbY3XeHqvz9njDUG6LVv2dSRewVWl6PLCkolrMzEa8Vg2Tu4CJkiZI2hCYDFxXcU1mZiNWSw5zRcQqSScDN1KcGjwjIhZUXFaV1vmhvDXk7bE6b4/VeXu8Yci2hSL6HGowMzNbI606zGVmZk3EYWJmZtkcJi1M0gxJyyXNr7qWqknaStLvJD0oaYGkz1ddU5UkbSzpTkn3pe3x9apragaSRkm6V9Ivq66lapIWSbpf0lxJndnr8zGT1iVpP2AlMDMidqm6nipJGguMjYh7JL0FuBs4aqReYkeSgDdHxEpJGwB/AD4fEbdXXFqlJH0J6AA2i4j3V11PlSQtAjoiYkh+wOk9kxYWEbcCz1ZdRzOIiKURcU96vgJ4kOJKCSNSFFamyQ3SY0R/c5Q0HjgC+HHVtayLHCa2zpHUDuwK3FFtJdVKQzpzgeXAnIgY0dsD+B7wNeC1qgtpEgH8WtLd6dJTWRwmtk6RtCkwC/hCRPy56nqqFBGvRsQkiitE7CFpxA6FSno/sDwi7q66liayT0TsBhwGnJSGzdeaw8TWGenYwCzg8oj4edX1NIuIeB64GTi04lKqtA/wwXSc4CrgfZJ+Wm1J1YqIJenf5cA1FFdjX2sOE1snpAPOlwAPRsR3qq6napLaJG2enm8C/CPwULVVVSciTo2I8RHRTnH5pd9GxCcrLqsykt6cTlRB0puBg4Gss0IdJi1M0pXAbcAOkroknVB1TRXaB/gUxTfOuelxeNVFVWgs8DtJ8yiuZTcnIkb86bD2ui2BP0i6D7gTuD4ibshZoU8NNjOzbN4zMTOzbA4TMzPL5jAxM7NsDhMzM8vmMDEzs2wOE2tJkr6SfoDWM31mVVdPljRf0plVvHajSWqXFJI66ug7VdKTkl4bKdtnJHOY2LrifOC99XZOH4gfGcZ6ar3mZEn39jNv/1TTmEbWtBYWU/yGZe5AnSSNBi4CzqO44Ob5w1+aVakl7wFv6wZJG0bEX4diXekKuSsH7VitI4Frc1YwlNtsbUTEq8CfBuqTLmuzDcXnyy8jYunavl7V79fq5z0TGxKSbpb0Q0kXSHouPc6TtF6pz6I0HDVD0vPA5al9nKSrSstdL2lir/V/TdKfJK2UNBPYtNf8PsNckqakm/+8ImmZpEt76khdfpb2BhaVlvlAuorqy5Iel3SOpA1L87eQdK2klyQ9IenTdW6fDSguqNcnTNJVjn+XJrtTTT213ixpmqTzJXUD/y+199mzStv3K6Xpv5M0XcUN1FZIumWw4SlJn5R0V+q/XNLPJI0rzV9tmKu0R3W4iptx/RU4EejZA3sszW+XtF3adn+S9BdJ96i4AGPv97BWfyNWLYeJDaVPUPxN7U3xgTIV+EKvPl+iuEZUB3CapDdRfJC+TDFMtTewFLgpzUPSx4BvAGcAuwEPp/X0S9KJwI+AnwDvAg4HFqTZ70n/foZiyOY9aZlDKD68vg/sDHwa+Ajw76VVXwr8PcW1ro4CjgXaB9wqhQOAFyKi1jDXYuDD6fnOqabynSI/CQjYN73eoCQJuJ5iiOn9FJfkvxX4rYobifVnQ4rt/O603Bjgyjpe8pvA6cCOFIHZc1HJPdL7WUzxBeBXwEFp/bOAn0vasde61vhvxJpARPjhR/aD4qq0fyRdoie1nQ50laYXAb/otdyngUd6LTcKeAb4WJr+b+DiXsvdBCwqTZ8JzC9NdwHnDlBvAB/p1XYr8G+92o6iGD4TsH1abp/S/G2AV4EzB9k+FwEXDjB//7TuMTW267w6618EfCU9f1+qe5NefeYCX1uD/647ptcan6bb03RHr7o/3Gu5jtTePsj6bwdOz/0b8aP6h4+Z2FC6PdL/6cltwNmSNos37i3S+17TuwMTgBXFl+nXvQnYLj3/B/reHe82ij2EPiRtQfGN/DdrWP/uFPf9+NdS23rAJsDbUx2vUVwYD4CIeELSkjrW/UHguDWsp8fa3INjd4pt2N1ru27MG9u1D0m7UeyZTALeShGiAFtTBHR/Br2HuIqr055BscczluLujxsD8wZZVz1/I1Yxh4k12l96Ta9H8W15co2+a3tLYg3epab1gK8DP6sxr3tt15uOL2wK3LKWdfXeZlB86+9dzwal5+sByyiGxnqredOw9GF/I8Ve36co7tA4Bvg9xfDXmtbY2/kUw19fodjTeBGYWWPdjfgbsSHmMLGhtKcklfZO9gKWxMB3PLwHOAZ4OoqbONXyYFrXjFLbXv2tMCKWSXoKOBCY00+3v1EMlfSuZceIWFhrAUkPUnywvYdi6A1JWwPv6K+W5EiKS3yvGqBPzxlLvWvqTzfFt/ue2rYsT1O8ly2B1yLisTrXuSNFeJwWEY+n9X6ozmXr8T+BmRExK627Zy/pj4MsV8/fiFXMB+BtKL0D+J6kHdKZRl8FvjvIMpdTfIO+VtJ7JU2QtJ+kb5fO1rkAmCLpM5ImSjoV2HOQ9Z4DfEHSFyVtL2mSpC+X5i8CDpT0dhW/iQA4C/i4pLMk7SJpR0kfkfQtgIh4GLgB+JGkvSVNojgg/9IgtdRzSvATFHsbR6i4sdWmg/T/LcWtVjsk7ZrqeLk0/yaKM7+ulXRY2q57S/q6pFp7KwBPAq8AJ0vaVtIRwNmD1LEm/ggcLWk3Se8EfkoxzDWYev5GrGIOExtKl1N8s74DuJjizocDhklEvAjsBzxGMbz0EHAZMBp4LvX5T4oD7OdQnHL6TmDAuylGxDTgJIoztuZThMDOpS5fpjjDanFaJxFxI3BEar8zPU6h+JDtcRzwOMWH+S+AKyiCqSZJEygO3A9446GIeIrieMI5FB+c3x+of6r/MYoD9P9FcUxpeWl9QXEG228p/ls8DFwN7ADUPMYTEd3AFIqTDh5I9Qx41twa+lKq8fcUZ3Xdnp4PqJ6/Eaueb45lQ0LSzRRnU51cdS3NRNIXgYMiYiTf9dFGAO+ZmA2vp4D/XXURZsPNB+DNhlFEXF11DWaN4GEuMzPL5mEuMzPL5jAxM7NsDhMzM8vmMDEzs2wOEzMzy/b/Ad4sS+gCEBZ6AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dates,preds = test_test_fit(df_interp,'k_interp_direct_rf','ORD-MUC')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3090, 9)\n",
      "(3090,)\n",
      "(6175, 9)\n",
      "(6175,)\n",
      "(9260, 9)\n",
      "(9260,)\n",
      "(12345, 9)\n",
      "(12345,)\n",
      "(15430, 9)\n",
      "(15430,)\n",
      "(18515, 9)\n",
      "(18515,)\n",
      "R2 score: 0.990021158442\n",
      "ORD\n",
      "MUC\n",
      "41.97859955\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/envs/insight/lib/python3.6/site-packages/pandas/core/computation/expressions.py:180: UserWarning: evaluating in Python space because the '*' operator is not supported by numexpr for the bool dtype, use '&' instead\n",
      "  .format(op=op_str, alt_op=unsupported[op_str]))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dates,preds = test_test_fit(sp,'k_sp_direct_rf','ORD-MUC')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_all_data(route):\n",
    "    count = 0\n",
    "    plt.figure()\n",
    "    plt.clf()\n",
    "    for prefix in ['k_sp_direct_rf','k_interp_direct_rf','k_min_direct_rf','k_all_direct_rf']:\n",
    "        reg = pickle.load(open(prefix+'_network.sav', 'rb'))\n",
    "        #encoder = pickle.load(open(prefix+'_encoder.sav', 'rb'))\n",
    "        #scaler = pickle.load(open(prefix+'_scaler.sav', 'rb'))\n",
    "        #kmeans = pickle.load(open(prefix+'_kmeans.sav', 'rb'))\n",
    "        df = pickle.load(open(prefix+'_df.sav', 'rb'))\n",
    "        dates,preds = predict_airfares(route,reg,N_months=18)\n",
    "        if count == 0:\n",
    "            plt.plot(dates,preds,'-k',lw=2,alpha=0.7)\n",
    "        elif count == 1:\n",
    "            plt.plot(dates,preds,'-r',lw=2,alpha=0.7)\n",
    "        elif count == 2:\n",
    "            plt.plot(dates,preds,'-b',lw=2,alpha=0.7)\n",
    "        else:\n",
    "            plt.plot(dates,preds,'-g',lw=2,alpha=0.7)\n",
    "        count += 1\n",
    "    origin = route[:3]\n",
    "    destination = route[-3:]\n",
    "    with open('airports.csv') as csvfile:\n",
    "        reader = csv.DictReader(csvfile)\n",
    "        origin_lat,origin_lon,_ = match_iata_code(origin,reader)\n",
    "    with open('airports.csv') as csvfile:\n",
    "        reader = csv.DictReader(csvfile)\n",
    "        destination_lat,destination_lon,_ = match_iata_code(destination,reader)         \n",
    "    matches = df.loc[(df['Origin lon'] == np.float(origin_lon)) *\n",
    "                         (df['Destination lat'] == np.float(destination_lat))]\n",
    "    #print(matches)\n",
    "    plt.plot(matches['date'],matches['airfare'],'ok')\n",
    "    plt.savefig('/Users/michevan/Desktop/insight/'+route+'_pred.pdf')\n",
    "    #plt.xlim([2018.4,2020])\n",
    "    #plt.savefig('/Users/michevan/Desktop/insight/'+prefix+'_'+route+'_pred_zoom.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LAX\n",
      "ICN\n",
      "33.94250107\n",
      "LAX\n",
      "ICN\n",
      "33.94250107\n",
      "LAX\n",
      "ICN\n",
      "33.94250107\n",
      "LAX\n",
      "ICN\n",
      "33.94250107\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/envs/insight/lib/python3.6/site-packages/pandas/core/computation/expressions.py:180: UserWarning: evaluating in Python space because the '*' operator is not supported by numexpr for the bool dtype, use '&' instead\n",
      "  .format(op=op_str, alt_op=unsupported[op_str]))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_all_data('LAX-ICN')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LAS\n",
      "ICN\n",
      "36.08010101\n",
      "LAS\n",
      "ICN\n",
      "36.08010101\n",
      "LAS\n",
      "ICN\n",
      "36.08010101\n",
      "LAS\n",
      "ICN\n",
      "36.08010101\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/envs/insight/lib/python3.6/site-packages/pandas/core/computation/expressions.py:180: UserWarning: evaluating in Python space because the '*' operator is not supported by numexpr for the bool dtype, use '&' instead\n",
      "  .format(op=op_str, alt_op=unsupported[op_str]))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_all_data('LAS-ICN')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime, timedelta, date, time\n",
    "a = pd.date_range(start=datetime.today(), periods=20,freq='m')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Origin lat          51.4706\n",
       "Origin lon        -0.461941\n",
       "Destination lat     36.0801\n",
       "Destination lon    -115.152\n",
       "distance            5216.42\n",
       "year                   2018\n",
       "month                     6\n",
       "date                2018.57\n",
       "within 100 days    0.231507\n",
       "airfare                1520\n",
       "Name: 2760, dtype: object"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_all.iloc[7500]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MUC\n",
      "ICN\n",
      "48.353802\n",
      "MUC\n",
      "ICN\n",
      "48.353802\n",
      "MUC\n",
      "ICN\n",
      "48.353802\n",
      "MUC\n",
      "ICN\n",
      "48.353802\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/envs/insight/lib/python3.6/site-packages/pandas/core/computation/expressions.py:180: UserWarning: evaluating in Python space because the '*' operator is not supported by numexpr for the bool dtype, use '&' instead\n",
      "  .format(op=op_str, alt_op=unsupported[op_str]))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_all_data('MUC-ICN')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}