Performance_Recording.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recording Machine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1 Data Understanding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/ConradKang/anaconda3/lib/python3.7/site-packages/lightgbm/__init__.py:46: UserWarning: Starting from version 2.2.1, the library file in distribution wheels for macOS is built by the Apple Clang (Xcode_9.4.1) compiler.\n",
      "This means that in case of installing LightGBM from PyPI via the ``pip install lightgbm`` command, you don't need to install the gcc compiler anymore.\n",
      "Instead of that, you need to install the OpenMP library, which is required for running LightGBM on the system with the Apple Clang compiler.\n",
      "You can install the OpenMP library by the following command: ``brew install libomp``.\n",
      "  \"You can install the OpenMP library by the following command: ``brew install libomp``.\", UserWarning)\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.pyplot import figure\n",
    "from datetime import datetime, timedelta\n",
    "\n",
    "# show the plots\n",
    "%matplotlib inline\n",
    "# show all columns\n",
    "pd.set_option('display.max_columns', None)\n",
    "# set the backgraound\n",
    "sns.set_context(\"paper\", rc={\"font.size\":12,\"axes.titlesize\":20,\"axes.labelsize\":18,\n",
    "                             \"xtick.labelsize\":15,\"ytick.labelsize\":15}) \n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis as QDA\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, BaggingClassifier, VotingClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.tree import DecisionTreeClassifier \n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.metrics import confusion_matrix, accuracy_score\n",
    "from sklearn.model_selection import GridSearchCV, RandomizedSearchCV, cross_val_score, TimeSeriesSplit, RepeatedKFold\n",
    "from sklearn.feature_selection import VarianceThreshold, RFE, SelectKBest, chi2\n",
    "from sklearn.preprocessing import StandardScaler, MinMaxScaler\n",
    "from mlxtend.classifier import StackingClassifier\n",
    "from xgboost import XGBClassifier\n",
    "from lightgbm import LGBMClassifier\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "warnings.simplefilter(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_results(gap, win):\n",
    "\n",
    "    total = pd.read_csv('alldata.csv', parse_dates=['time'], index_col='time')\n",
    "    \n",
    "    count = total[['ua_count','nike_count']].resample(gap).sum()\n",
    "    price = total[['ua_price','nike_price']].resample(gap).last()\n",
    "    stkv = total[['ua_stkv','nike_stkv']].resample(gap).sum()\n",
    "    tweet = total[['ua_tweet','nike_tweet']].resample(gap).mean()\n",
    "    twtcount = total[['ua_twtcount','nike_twtcount']].resample(gap).sum()\n",
    "    total = pd.concat([count, price, stkv, tweet, twtcount], axis = 1)\n",
    "    \n",
    "    total['count_ratio'] = total.ua_count / total.nike_count\n",
    "    total['price_ratio'] = total.ua_price / total.nike_price\n",
    "    total['tweet_diff'] = total.ua_tweet - total.nike_tweet\n",
    "    total['stkv_ratio'] = total.ua_stkv / total.nike_stkv\n",
    "    total['twtcount_ratio'] = total.ua_twtcount / total.nike_twtcount\n",
    "    \n",
    "    # add rate of returns\n",
    "    return_ua = total.ua_price/total.ua_price.shift(1) - 1\n",
    "    return_nike = total.nike_price/total.nike_price.shift(1) - 1\n",
    "    return_diff = return_ua - return_nike\n",
    "    \n",
    "    # create labels for classification (results for tomorrow)\n",
    "    value_ua = total.ua_price.shift(-1) - total.ua_price\n",
    "    value_nike = total.nike_price.shift(-1) - total.nike_price\n",
    "    value_ratio = total.price_ratio.shift(-1) - total.price_ratio\n",
    "    \n",
    "    value_ua = np.where(value_ua>=0, 1, 0)\n",
    "    value_nike = np.where(value_nike>=0, 1, 0)\n",
    "    value_ratio = np.where(value_ratio>=0, 1, 0)\n",
    "    \n",
    "    total = total.rolling(min_periods=1, window=win, center=False).mean() # rolling analysis\n",
    "    \n",
    "    total = total.rename(columns={\n",
    "        'ua_count':'geo_ua_count',\n",
    "        'nike_count':'geo_nike_count',\n",
    "        'count_ratio':'geo_count_ratio'\n",
    "    })\n",
    "    \n",
    "    # add labels and rate of returns to the dataframe\n",
    "    total['return_ua'] = return_ua\n",
    "    total['return_nike'] = return_nike\n",
    "    total['return_diff'] = return_diff\n",
    "    total['value_ua'] = value_ua\n",
    "    total['value_nike'] = value_nike\n",
    "    total['value_ratio'] = value_ratio\n",
    "    \n",
    "    total[['ua_tweet','nike_tweet','tweet_diff']] = total[['ua_tweet','nike_tweet','tweet_diff']].fillna(method = 'ffill')\n",
    "    \n",
    "    def outlier_eliminate(df):\n",
    "        s_mean = df.replace([np.inf, -np.inf], np.nan).dropna().mean(axis = 0)\n",
    "        s_std = df.replace([np.inf, -np.inf], np.nan).dropna().std(axis = 0)\n",
    "        Q1 = s_mean - 3 * s_std\n",
    "        Q2 = s_mean + 3 * s_std\n",
    "        return df[~((df < Q1) | (df > Q2)).any(axis = 1)]\n",
    "    \n",
    "    total = outlier_eliminate(total)\n",
    "    \n",
    "    total.dropna(inplace = True)\n",
    "    \n",
    "    X = total.drop(total.columns[[18,19,20]], axis=1) # drop the target\n",
    "    y = total.value_ratio.astype('category')\n",
    "    \n",
    "    out_feature = int(0.5 * X.shape[1])\n",
    "    \n",
    "    threshold = 0.8 # frequently used threshold\n",
    "    vt = VarianceThreshold().fit(X)\n",
    "    \n",
    "    feat_var_threshold = X.columns[vt.variances_ > threshold * (1 - threshold)]\n",
    "    \n",
    "    modelr = RandomForestClassifier(random_state = 42)\n",
    "    modelr.fit(X, y)\n",
    "    \n",
    "    feature_impr = pd.DataFrame(modelr.feature_importances_, index=X.columns, columns=[\"importance\"])\n",
    "    feat_imp_rf = feature_impr.sort_values(\"importance\", ascending=False).head(out_feature).index\n",
    "    \n",
    "    modela = AdaBoostClassifier(random_state = 42)\n",
    "    modela.fit(X, y)\n",
    "    \n",
    "    feature_impa = pd.DataFrame(modela.feature_importances_, index=X.columns, columns=[\"importance\"])\n",
    "    feat_imp_ada = feature_impa.sort_values(\"importance\", ascending=False).head(out_feature).index\n",
    "    \n",
    "    X_minmax = MinMaxScaler().fit_transform(X)\n",
    "    X_scored = SelectKBest(score_func=chi2, k='all').fit(X_minmax, y)\n",
    "    feature_scoring = pd.DataFrame({\n",
    "            'feature': X.columns,\n",
    "            'score': X_scored.scores_\n",
    "        })\n",
    "    \n",
    "    feat_scored = feature_scoring.sort_values('score', ascending=False).head(out_feature)['feature'].values\n",
    "    \n",
    "    rfe = RFE(LogisticRegression(), out_feature)\n",
    "    rfe.fit(X, y)\n",
    "    \n",
    "    feature_rfe_scoring = pd.DataFrame({\n",
    "            'feature': X.columns,\n",
    "            'score': rfe.ranking_\n",
    "        })\n",
    "    \n",
    "    feat_rfe = feature_rfe_scoring[feature_rfe_scoring['score'] == 1]['feature'].values\n",
    "    \n",
    "    features = np.hstack([\n",
    "        feat_var_threshold,\n",
    "        feat_imp_rf, \n",
    "        feat_imp_ada,\n",
    "        feat_scored,\n",
    "        feat_rfe\n",
    "        ])\n",
    "    \n",
    "    fc = pd.DataFrame(pd.Series(features).value_counts(), \n",
    "                      columns = ['count']).reset_index().rename(columns = {'index':'feature'})\n",
    "    \n",
    "    features = fc.feature[fc['count'] > 2].tolist()\n",
    "    \n",
    "    print('Final features set:\\n')\n",
    "    \n",
    "    for f in features:\n",
    "        print(\"\\t-{}\".format(f))\n",
    "        \n",
    "    print('\\n')\n",
    "\n",
    "    random_state = 42\n",
    "    processors = -1\n",
    "    scoring = 'accuracy'\n",
    "    kfold = TimeSeriesSplit(n_splits=10)\n",
    "    \n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, stratify = y, random_state = random_state)\n",
    "    \n",
    "    scaler = StandardScaler()\n",
    "    X_train = scaler.fit_transform(X_train)\n",
    "    X_test = scaler.transform(X_test)\n",
    "    \n",
    "    lgb_mod = LGBMClassifier(objective = 'binary', learning_rate = 0.01, n_estimators = 40, num_leaves = 20, scoring = scoring, n_jobs = processors, seed = random_state)\n",
    "    lgb_mod.fit(X_train, y_train)\n",
    "    y_pred = lgb_mod.predict(X_test)\n",
    "    print('Accuracy: %.3f'%(accuracy_score(y_test, y_pred)))\n",
    "    \n",
    "    print('='*30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_table(gap, win):\n",
    "\n",
    "    total = pd.read_csv('alldata.csv', parse_dates=['time'], index_col='time')\n",
    "    \n",
    "    count = total[['ua_count','nike_count']].resample(gap).sum()\n",
    "    price = total[['ua_price','nike_price']].resample(gap).last()\n",
    "    stkv = total[['ua_stkv','nike_stkv']].resample(gap).sum()\n",
    "    tweet = total[['ua_tweet','nike_tweet']].resample(gap).mean()\n",
    "    twtcount = total[['ua_twtcount','nike_twtcount']].resample(gap).sum()\n",
    "    total = pd.concat([count, price, stkv, tweet, twtcount], axis = 1)\n",
    "    \n",
    "    total['count_ratio'] = total.ua_count / total.nike_count\n",
    "    total['price_ratio'] = total.ua_price / total.nike_price\n",
    "    total['tweet_diff'] = total.ua_tweet - total.nike_tweet\n",
    "    total['stkv_ratio'] = total.ua_stkv / total.nike_stkv\n",
    "    total['twtcount_ratio'] = total.ua_twtcount / total.nike_twtcount\n",
    "    \n",
    "    # add rate of returns\n",
    "    return_ua = total.ua_price/total.ua_price.shift(1) - 1\n",
    "    return_nike = total.nike_price/total.nike_price.shift(1) - 1\n",
    "    return_diff = return_ua - return_nike\n",
    "    \n",
    "    # create labels for classification (results for tomorrow)\n",
    "    value_ua = total.ua_price.shift(-1) - total.ua_price\n",
    "    value_nike = total.nike_price.shift(-1) - total.nike_price\n",
    "    value_ratio = total.price_ratio.shift(-1) - total.price_ratio\n",
    "    \n",
    "    value_ua = np.where(value_ua>=0, 1, 0)\n",
    "    value_nike = np.where(value_nike>=0, 1, 0)\n",
    "    value_ratio = np.where(value_ratio>=0, 1, 0)\n",
    "    \n",
    "    total = total.rolling(min_periods=1, window=win, center=False).mean() # rolling analysis\n",
    "    \n",
    "    total = total.rename(columns={\n",
    "        'ua_count':'geo_ua_count',\n",
    "        'nike_count':'geo_nike_count',\n",
    "        'count_ratio':'geo_count_ratio'\n",
    "    })\n",
    "    \n",
    "    # add labels and rate of returns to the dataframe\n",
    "    total['return_ua'] = return_ua\n",
    "    total['return_nike'] = return_nike\n",
    "    total['return_diff'] = return_diff\n",
    "    total['value_ua'] = value_ua\n",
    "    total['value_nike'] = value_nike\n",
    "    total['value_ratio'] = value_ratio\n",
    "    \n",
    "    total[['ua_tweet','nike_tweet','tweet_diff']] = total[['ua_tweet','nike_tweet','tweet_diff']].fillna(method = 'ffill')\n",
    "    \n",
    "    def outlier_eliminate(df):\n",
    "        s_mean = df.replace([np.inf, -np.inf], np.nan).dropna().mean(axis = 0)\n",
    "        s_std = df.replace([np.inf, -np.inf], np.nan).dropna().std(axis = 0)\n",
    "        Q1 = s_mean - 3 * s_std\n",
    "        Q2 = s_mean + 3 * s_std\n",
    "        return df[~((df < Q1) | (df > Q2)).any(axis = 1)]\n",
    "    \n",
    "    total = outlier_eliminate(total)\n",
    "    \n",
    "    total.dropna(inplace = True)\n",
    "    \n",
    "    X = total.drop(total.columns[[18,19,20]], axis=1) # drop the target\n",
    "    y = total.value_ratio.astype('category')\n",
    "    \n",
    "    out_feature = int(0.5 * X.shape[1])\n",
    "    \n",
    "    threshold = 0.8 # frequently used threshold\n",
    "    vt = VarianceThreshold().fit(X)\n",
    "    \n",
    "    feat_var_threshold = X.columns[vt.variances_ > threshold * (1 - threshold)]\n",
    "    \n",
    "    modelr = RandomForestClassifier(random_state = 42)\n",
    "    modelr.fit(X, y)\n",
    "    \n",
    "    feature_impr = pd.DataFrame(modelr.feature_importances_, index=X.columns, columns=[\"importance\"])\n",
    "    feat_imp_rf = feature_impr.sort_values(\"importance\", ascending=False).head(out_feature).index\n",
    "    \n",
    "    modela = AdaBoostClassifier(random_state = 42)\n",
    "    modela.fit(X, y)\n",
    "    \n",
    "    feature_impa = pd.DataFrame(modela.feature_importances_, index=X.columns, columns=[\"importance\"])\n",
    "    feat_imp_ada = feature_impa.sort_values(\"importance\", ascending=False).head(out_feature).index\n",
    "    \n",
    "    X_minmax = MinMaxScaler().fit_transform(X)\n",
    "    X_scored = SelectKBest(score_func=chi2, k='all').fit(X_minmax, y)\n",
    "    feature_scoring = pd.DataFrame({\n",
    "            'feature': X.columns,\n",
    "            'score': X_scored.scores_\n",
    "        })\n",
    "    \n",
    "    feat_scored = feature_scoring.sort_values('score', ascending=False).head(out_feature)['feature'].values\n",
    "    \n",
    "    rfe = RFE(LogisticRegression(), out_feature)\n",
    "    rfe.fit(X, y)\n",
    "    \n",
    "    feature_rfe_scoring = pd.DataFrame({\n",
    "            'feature': X.columns,\n",
    "            'score': rfe.ranking_\n",
    "        })\n",
    "    \n",
    "    feat_rfe = feature_rfe_scoring[feature_rfe_scoring['score'] == 1]['feature'].values\n",
    "    \n",
    "    features = np.hstack([\n",
    "        feat_var_threshold,\n",
    "        feat_imp_rf, \n",
    "        feat_imp_ada,\n",
    "        feat_scored,\n",
    "        feat_rfe\n",
    "        ])\n",
    "    \n",
    "    fc = pd.DataFrame(pd.Series(features).value_counts(), \n",
    "                      columns = ['count']).reset_index().rename(columns = {'index':'feature'})\n",
    "    \n",
    "    features = fc.feature[fc['count'] > 2].tolist()\n",
    "    \n",
    "    return features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_plot(gap, win):\n",
    "\n",
    "    total = pd.read_csv('alldata.csv', parse_dates=['time'], index_col='time')\n",
    "    \n",
    "    count = total[['ua_count','nike_count']].resample(gap).sum()\n",
    "    price = total[['ua_price','nike_price']].resample(gap).last()\n",
    "    stkv = total[['ua_stkv','nike_stkv']].resample(gap).sum()\n",
    "    tweet = total[['ua_tweet','nike_tweet']].resample(gap).mean()\n",
    "    twtcount = total[['ua_twtcount','nike_twtcount']].resample(gap).sum()\n",
    "    total = pd.concat([count, price, stkv, tweet, twtcount], axis = 1)\n",
    "    \n",
    "    total['count_ratio'] = total.ua_count / total.nike_count\n",
    "    total['price_ratio'] = total.ua_price / total.nike_price\n",
    "    total['tweet_diff'] = total.ua_tweet - total.nike_tweet\n",
    "    total['stkv_ratio'] = total.ua_stkv / total.nike_stkv\n",
    "    total['twtcount_ratio'] = total.ua_twtcount / total.nike_twtcount\n",
    "    \n",
    "    # add rate of returns\n",
    "    return_ua = total.ua_price/total.ua_price.shift(1) - 1\n",
    "    return_nike = total.nike_price/total.nike_price.shift(1) - 1\n",
    "    return_diff = return_ua - return_nike\n",
    "    \n",
    "    # create labels for classification (results for tomorrow)\n",
    "    value_ua = total.ua_price.shift(-1) - total.ua_price\n",
    "    value_nike = total.nike_price.shift(-1) - total.nike_price\n",
    "    value_ratio = total.price_ratio.shift(-1) - total.price_ratio\n",
    "    \n",
    "    value_ua = np.where(value_ua>=0, 1, 0)\n",
    "    value_nike = np.where(value_nike>=0, 1, 0)\n",
    "    value_ratio = np.where(value_ratio>=0, 1, 0)\n",
    "    \n",
    "    total = total.rolling(min_periods=1, window=win, center=False).mean() # rolling analysis\n",
    "    \n",
    "    total = total.rename(columns={\n",
    "        'ua_count':'geo_ua_count',\n",
    "        'nike_count':'geo_nike_count',\n",
    "        'count_ratio':'geo_count_ratio'\n",
    "    })\n",
    "    \n",
    "    # add labels and rate of returns to the dataframe\n",
    "    total['return_ua'] = return_ua\n",
    "    total['return_nike'] = return_nike\n",
    "    total['return_diff'] = return_diff\n",
    "    total['value_ua'] = value_ua\n",
    "    total['value_nike'] = value_nike\n",
    "    total['value_ratio'] = value_ratio\n",
    "    \n",
    "    total[['ua_tweet','nike_tweet','tweet_diff']] = total[['ua_tweet','nike_tweet','tweet_diff']].fillna(method = 'ffill')\n",
    "    \n",
    "    def outlier_eliminate(df):\n",
    "        s_mean = df.replace([np.inf, -np.inf], np.nan).dropna().mean(axis = 0)\n",
    "        s_std = df.replace([np.inf, -np.inf], np.nan).dropna().std(axis = 0)\n",
    "        Q1 = s_mean - 3 * s_std\n",
    "        Q2 = s_mean + 3 * s_std\n",
    "        return df[~((df < Q1) | (df > Q2)).any(axis = 1)]\n",
    "    \n",
    "    total = outlier_eliminate(total)\n",
    "    \n",
    "    total.dropna(inplace = True)\n",
    "    \n",
    "    X = total.drop(total.columns[[18,19,20]], axis=1) # drop the target\n",
    "    y = total.value_ratio.astype('category')\n",
    "    \n",
    "    out_feature = int(0.5 * X.shape[1])\n",
    "    \n",
    "    threshold = 0.8 # frequently used threshold\n",
    "    vt = VarianceThreshold().fit(X)\n",
    "    \n",
    "    feat_var_threshold = X.columns[vt.variances_ > threshold * (1 - threshold)]\n",
    "    \n",
    "    modelr = RandomForestClassifier(random_state = 42)\n",
    "    modelr.fit(X, y)\n",
    "    \n",
    "    feature_impr = pd.DataFrame(modelr.feature_importances_, index=X.columns, columns=[\"importance\"])\n",
    "    feat_imp_rf = feature_impr.sort_values(\"importance\", ascending=False).head(out_feature).index\n",
    "    \n",
    "    modela = AdaBoostClassifier(random_state = 42)\n",
    "    modela.fit(X, y)\n",
    "    \n",
    "    feature_impa = pd.DataFrame(modela.feature_importances_, index=X.columns, columns=[\"importance\"])\n",
    "    feat_imp_ada = feature_impa.sort_values(\"importance\", ascending=False).head(out_feature).index\n",
    "    \n",
    "    X_minmax = MinMaxScaler().fit_transform(X)\n",
    "    X_scored = SelectKBest(score_func=chi2, k='all').fit(X_minmax, y)\n",
    "    feature_scoring = pd.DataFrame({\n",
    "            'feature': X.columns,\n",
    "            'score': X_scored.scores_\n",
    "        })\n",
    "    \n",
    "    feat_scored = feature_scoring.sort_values('score', ascending=False).head(out_feature)['feature'].values\n",
    "    \n",
    "    rfe = RFE(LogisticRegression(), out_feature)\n",
    "    rfe.fit(X, y)\n",
    "    \n",
    "    feature_rfe_scoring = pd.DataFrame({\n",
    "            'feature': X.columns,\n",
    "            'score': rfe.ranking_\n",
    "        })\n",
    "    \n",
    "    feat_rfe = feature_rfe_scoring[feature_rfe_scoring['score'] == 1]['feature'].values\n",
    "    \n",
    "    features = np.hstack([\n",
    "        feat_var_threshold,\n",
    "        feat_imp_rf, \n",
    "        feat_imp_ada,\n",
    "        feat_scored,\n",
    "        feat_rfe\n",
    "        ])\n",
    "    \n",
    "    fc = pd.DataFrame(pd.Series(features).value_counts(), \n",
    "                      columns = ['count']).reset_index().rename(columns = {'index':'feature'})\n",
    "    \n",
    "    features = fc.feature[fc['count'] > 2].tolist()\n",
    "\n",
    "    random_state = 42\n",
    "    processors = -1\n",
    "    scoring = 'accuracy'\n",
    "    kfold = TimeSeriesSplit(n_splits=10)\n",
    "    \n",
    "    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, stratify = y, random_state = random_state)\n",
    "    \n",
    "    scaler = StandardScaler()\n",
    "    X_train = scaler.fit_transform(X_train)\n",
    "    X_test = scaler.transform(X_test)\n",
    "    \n",
    "    lgb_mod = LGBMClassifier(objective = 'binary', learning_rate = 0.01, n_estimators = 40, num_leaves = 20, scoring = scoring, n_jobs = processors, seed = random_state)\n",
    "    lgb_mod.fit(X_train, y_train)\n",
    "    y_pred = lgb_mod.predict(X_test)\n",
    "    return round(accuracy_score(y_test, y_pred), 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final features set:\n",
      "\n",
      "\t-nike_stkv\n",
      "\t-nike_price\n",
      "\t-stkv_ratio\n",
      "\t-ua_price\n",
      "\t-ua_twtcount\n",
      "\t-geo_count_ratio\n",
      "\t-twtcount_ratio\n",
      "\t-return_ua\n",
      "\t-return_diff\n",
      "\t-geo_nike_count\n",
      "\t-ua_stkv\n",
      "\t-nike_twtcount\n",
      "\t-geo_ua_count\n",
      "\n",
      "\n",
      "Accuracy: 0.491\n",
      "==============================\n",
      "Final features set:\n",
      "\n",
      "\t-nike_twtcount\n",
      "\t-geo_nike_count\n",
      "\t-stkv_ratio\n",
      "\t-nike_stkv\n",
      "\t-nike_price\n",
      "\t-ua_stkv\n",
      "\t-geo_count_ratio\n",
      "\t-twtcount_ratio\n",
      "\t-return_ua\n",
      "\t-geo_ua_count\n",
      "\n",
      "\n",
      "Accuracy: 0.590\n",
      "==============================\n",
      "Final features set:\n",
      "\n",
      "\t-stkv_ratio\n",
      "\t-geo_count_ratio\n",
      "\t-twtcount_ratio\n",
      "\t-geo_ua_count\n",
      "\t-ua_twtcount\n",
      "\t-nike_twtcount\n",
      "\t-ua_stkv\n",
      "\t-nike_price\n",
      "\t-return_ua\n",
      "\t-nike_stkv\n",
      "\n",
      "\n",
      "Accuracy: 0.553\n",
      "==============================\n",
      "Final features set:\n",
      "\n",
      "\t-stkv_ratio\n",
      "\t-return_diff\n",
      "\t-ua_stkv\n",
      "\t-nike_twtcount\n",
      "\t-nike_tweet\n",
      "\t-twtcount_ratio\n",
      "\t-nike_price\n",
      "\t-tweet_diff\n",
      "\t-return_ua\n",
      "\t-nike_stkv\n",
      "\n",
      "\n",
      "Accuracy: 0.553\n",
      "==============================\n",
      "Final features set:\n",
      "\n",
      "\t-stkv_ratio\n",
      "\t-return_diff\n",
      "\t-twtcount_ratio\n",
      "\t-ua_twtcount\n",
      "\t-nike_twtcount\n",
      "\t-nike_tweet\n",
      "\t-ua_stkv\n",
      "\t-nike_price\n",
      "\t-return_ua\n",
      "\t-nike_stkv\n",
      "\n",
      "\n",
      "Accuracy: 0.559\n",
      "==============================\n",
      "Final features set:\n",
      "\n",
      "\t-twtcount_ratio\n",
      "\t-return_diff\n",
      "\t-nike_twtcount\n",
      "\t-ua_stkv\n",
      "\t-return_ua\n",
      "\t-nike_tweet\n",
      "\t-tweet_diff\n",
      "\t-nike_stkv\n",
      "\n",
      "\n",
      "Accuracy: 0.551\n",
      "==============================\n"
     ]
    }
   ],
   "source": [
    "for w in range(1, 7):\n",
    "    show_results('H', w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>feature</th>\n",
       "      <th>count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>nike_twtcount</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>twtcount_ratio</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>return_ua</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>nike_stkv</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>ua_stkv</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>nike_price</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>stkv_ratio</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>return_diff</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>nike_tweet</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>geo_count_ratio</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>ua_twtcount</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>geo_ua_count</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>tweet_diff</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>geo_nike_count</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>ua_price</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            feature  count\n",
       "0     nike_twtcount      6\n",
       "1    twtcount_ratio      6\n",
       "2         return_ua      6\n",
       "3         nike_stkv      6\n",
       "4           ua_stkv      6\n",
       "5        nike_price      5\n",
       "6        stkv_ratio      5\n",
       "7       return_diff      4\n",
       "8        nike_tweet      3\n",
       "9   geo_count_ratio      3\n",
       "10      ua_twtcount      3\n",
       "11     geo_ua_count      3\n",
       "12       tweet_diff      2\n",
       "13   geo_nike_count      2\n",
       "14         ua_price      1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "feat = []\n",
    "\n",
    "for w in range(1, 7):\n",
    "    feat = np.hstack([feat, show_table('H', w)])\n",
    "\n",
    "pd.DataFrame(pd.Series(feat).value_counts(), \n",
    "             columns = ['count']).reset_index().rename(columns = {'index':'feature'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Test Set Accuracy')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc = []\n",
    "\n",
    "for w in range(1, 13):\n",
    "    acc = np.hstack([acc, show_plot('H', w)])\n",
    "    \n",
    "plt.plot(range(1, 13), acc, linestyle='--', marker='o')\n",
    "plt.title('Accuracy Using Different Windows')\n",
    "plt.xlabel('Number of Windows')\n",
    "plt.ylabel('Test Set Accuracy')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}