from_kaggle_predict_movies_step_by_step_without_extremes.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "pd.set_option('display.float_format', lambda x: '%.10Ef' % x)\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from statistics import mean\n",
    "\n",
    "from sklearn import metrics\n",
    "from sklearn.utils import shuffle\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.neural_network import MLPRegressor\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.preprocessing import PowerTransformer\n",
    "from sklearn.experimental import enable_iterative_imputer\n",
    "from sklearn.impute import IterativeImputer\n",
    "from sklearn.impute import KNNImputer\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.feature_selection import RFECV\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.dummy import DummyRegressor\n",
    "\n",
    "from impyute.imputation import cs\n",
    "pd.options.display.float_format = '{:20,.15f}'.format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_train_test_revenue(df):\n",
    "    df['revenue'] = df['META__revenue']\n",
    "#     dff = df[[col for col in df.columns if not 'META' in col and not 'PROCESS' in col and not 'profitability' in col and not 'cast' in col and not 'crew' in col]]\n",
    "    dff = df[[col for col in df.columns if not 'META' in col and not 'PROCESS' in col and not 'profitability' in col]]\n",
    "    X = dff.drop(['revenue'], axis=1)\n",
    "    y = dff['revenue']\n",
    "    return X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "def discard_extremes(df, n, col):\n",
    "    return df[(~df[col].isin(df.nlargest(n, col)[col]))&(~df[col].isin(df.nsmallest(n, col)[col]))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/stas/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "df = pd.read_csv('savedcsv/17_homepage.csv')\n",
    "df = discard_extremes(df, 10, 'META__revenue')\n",
    "\n",
    "num_in_train = int(df.shape[0]*0.8)\n",
    "df_train = df[:num_in_train]\n",
    "df_test = df[num_in_train:]\n",
    "X_train, y_train = get_train_test_revenue(df_train)\n",
    "X_test, y_test = get_train_test_revenue(df_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a model\n",
    "from sklearn.linear_model import ElasticNet, Lasso,  BayesianRidge, LassoLarsIC\n",
    "from sklearn.ensemble import RandomForestRegressor,  GradientBoostingRegressor\n",
    "from catboost import CatBoostRegressor\n",
    "from sklearn.kernel_ridge import KernelRidge\n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.preprocessing import RobustScaler\n",
    "from sklearn.base import BaseEstimator, TransformerMixin, RegressorMixin, clone\n",
    "from sklearn.model_selection import KFold, cross_val_score, train_test_split\n",
    "from sklearn.metrics import mean_squared_error\n",
    "import xgboost as xgb\n",
    "import lightgbm as lgb\n",
    "\n",
    "mod_mlp = MLPRegressor(\n",
    "    solver='adam',\n",
    "    hidden_layer_sizes=(100,),\n",
    "    activation='relu',\n",
    "    max_iter=10000)\n",
    "\n",
    "mod_lasso = make_pipeline(RobustScaler(), Lasso(alpha=0.005, random_state=1))\n",
    "\n",
    "mod_enet = make_pipeline(RobustScaler(), ElasticNet(alpha=0.0005, l1_ratio=.9, random_state=3))\n",
    "\n",
    "mod_cat = CatBoostRegressor(iterations=10000, learning_rate=0.01,\n",
    "                            depth=5, eval_metric='RMSE',\n",
    "                            colsample_bylevel=0.7, random_seed = 17, silent=True,\n",
    "                            bagging_temperature = 0.2, early_stopping_rounds=200)\n",
    "\n",
    "mod_gboost = GradientBoostingRegressor(n_estimators=3000, learning_rate=0.05,\n",
    "                                   max_depth=5, max_features='sqrt',\n",
    "                                   min_samples_leaf=15, min_samples_split=10, \n",
    "                                   loss='huber', random_state=5)\n",
    "\n",
    "mod_xgb = xgb.XGBRegressor(colsample_bytree=0.4603, gamma=0.0468, \n",
    "                             learning_rate=0.05, max_depth=3, \n",
    "                             min_child_weight=1.7817, n_estimators=2200,\n",
    "                             reg_alpha=0.4640, reg_lambda=0.8571,\n",
    "                             subsample=0.5213, silent=1,\n",
    "                             random_state=7, nthread=-1)\n",
    "\n",
    "mod_lgb = lgb.LGBMRegressor(objective='regression',num_leaves=8,\n",
    "                              learning_rate=0.05, n_estimators=650,\n",
    "                              max_bin=58, bagging_fraction=0.80,\n",
    "                              bagging_freq=5, feature_fraction=0.2319,\n",
    "                              feature_fraction_seed=9, bagging_seed=9,\n",
    "                              min_data_in_leaf=7, min_sum_hessian_in_leaf=11)\n",
    "\n",
    "class StackingAveragedModels(BaseEstimator, RegressorMixin, TransformerMixin):\n",
    "    def __init__(self, base_models, meta_model, n_folds=5):\n",
    "        self.base_models = base_models\n",
    "        self.meta_model = meta_model\n",
    "        self.n_folds = n_folds\n",
    "   \n",
    "    # We again fit the data on clones of the original models\n",
    "    def fit(self, X, y):\n",
    "        self.base_models_ = [list() for x in self.base_models]\n",
    "        self.meta_model_ = clone(self.meta_model)\n",
    "        kfold = KFold(n_splits=self.n_folds, shuffle=True, random_state=156)\n",
    "        \n",
    "        # Train cloned base models then create out-of-fold predictions\n",
    "        # that are needed to train the cloned meta-model\n",
    "        out_of_fold_predictions = np.zeros((X.shape[0], len(self.base_models)))\n",
    "        for i, model in enumerate(self.base_models):\n",
    "            for train_index, holdout_index in kfold.split(X, y):\n",
    "                instance = clone(model)\n",
    "                self.base_models_[i].append(instance)\n",
    "                instance.fit(X[train_index], y[train_index])\n",
    "                y_pred = instance.predict(X[holdout_index])\n",
    "                out_of_fold_predictions[holdout_index, i] = y_pred\n",
    "                \n",
    "        # Now train the cloned  meta-model using the out-of-fold predictions as new feature\n",
    "        self.meta_model_.fit(out_of_fold_predictions, y)\n",
    "        return self\n",
    "   \n",
    "    #Do the predictions of all base models on the test data and use the averaged predictions as \n",
    "    #meta-features for the final prediction which is done by the meta-model\n",
    "    def predict(self, X):\n",
    "        meta_features = np.column_stack([\n",
    "            np.column_stack([model.predict(X) for model in base_models]).mean(axis=1)\n",
    "            for base_models in self.base_models_ ])\n",
    "        return self.meta_model_.predict(meta_features)\n",
    "    \n",
    "mod_rfr = RandomForestRegressor(n_estimators=100, min_samples_split=3, random_state=0, n_jobs=-1)\n",
    "\n",
    "# mod_dummy = DummyRegressor(strategy='median')\n",
    "mod_dummy = DummyRegressor()\n",
    "    \n",
    "mod_stacked = StackingAveragedModels(base_models = (mod_cat, mod_xgb, mod_gboost, mod_lgb), meta_model = mod_lasso)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Process:\n",
    "    def __init__(self, \n",
    "                 X_train, X_test, y_train, y_test, \n",
    "                 imputer='mean', \n",
    "                 minmaxrange=(0,1), \n",
    "                 standardize_X=True,\n",
    "                 standardize_y=True,\n",
    "                ):\n",
    "        self.X_train = X_train.copy()\n",
    "        self.X_test = X_test.copy()\n",
    "        self.y_train = y_train.copy().values.reshape(-1, 1)\n",
    "        self.y_test = y_test.copy().values.reshape(-1, 1)\n",
    "        self.imputer = imputer\n",
    "        self.X_minmaxscaler = MinMaxScaler(feature_range=minmaxrange)\n",
    "        self.y_minmaxscaler = MinMaxScaler(feature_range=minmaxrange)\n",
    "        self.skewer_X = PowerTransformer(standardize=standardize_X)\n",
    "        self.skewer_y = PowerTransformer(standardize=standardize_y)\n",
    "\n",
    "    def fill_nan(self):\n",
    "        def fill_train_test(imputer):\n",
    "            imputer.fit(self.X_train)\n",
    "            self.X_train[:] = imputer.transform(self.X_train)\n",
    "            self.X_test[:] = imputer.transform(self.X_test)\n",
    "\n",
    "        if (self.imputer == 'mean'):\n",
    "            fill_train_test(SimpleImputer(strategy='mean'))\n",
    "        elif (self.imputer == 'median'):\n",
    "            fill_train_test(SimpleImputer(strategy='median'))\n",
    "        elif (self.imputer == 'knn'):\n",
    "            fill_train_test(KNNImputer())\n",
    "        elif (self.imputer == 'iterative'):\n",
    "            fill_train_test(IterativeImputer(verbose=0, max_iter=50))\n",
    "        elif (self.imputer == 'iterative_mlp'):\n",
    "            fill_train_test(\n",
    "                IterativeImputer(\n",
    "                    estimator=MLPRegressor(learning_rate='adaptive', random_state=0),\n",
    "                    verbose=2,\n",
    "                )\n",
    "            )\n",
    "        return self\n",
    "        \n",
    "    def minmaxscale_X(self, inverse=False):\n",
    "        def scaler_transform(obj):\n",
    "            return self.X_minmaxscaler.transform(obj)\n",
    "        \n",
    "        def scaler_transform_inverse(obj):\n",
    "            return self.X_minmaxscaler.inverse_transform(obj)\n",
    "        \n",
    "        if inverse:\n",
    "            self.X_train[:] = scaler_transform_inverse(self.X_train)\n",
    "            self.X_test[:] = scaler_transform_inverse(self.X_test)\n",
    "        else:\n",
    "            self.X_minmaxscaler.fit(self.X_train)\n",
    "            self.X_train[:] = scaler_transform(self.X_train)\n",
    "            self.X_test[:] = scaler_transform(self.X_test)\n",
    "        return self\n",
    "    \n",
    "    def minmaxscale_Y(self, inverse=False):\n",
    "        def scaler_transform(obj):\n",
    "            return self.y_minmaxscaler.transform(obj)\n",
    "        \n",
    "        def scaler_transform_inverse(obj):\n",
    "            return self.y_minmaxscaler.inverse_transform(obj)\n",
    "        \n",
    "        if inverse:\n",
    "            self.y_train[:] = scaler_transform_inverse(self.y_train)\n",
    "            self.y_test[:] = scaler_transform_inverse(self.y_test)\n",
    "        else:\n",
    "            self.y_minmaxscaler.fit(self.y_train)\n",
    "            self.y_train[:] = scaler_transform(self.y_train)\n",
    "            self.y_test[:] = scaler_transform(self.y_test)\n",
    "        return self\n",
    "    \n",
    "    def make_target_positive(self):\n",
    "        self.min_y_train = min(self.y_train)\n",
    "        self.y_train = self.y_train - self.min_y_train + 1\n",
    "        self.y_test = self.y_test - self.min_y_train + 1\n",
    "        return self\n",
    "        \n",
    "    def return_target_back_from_positive(self):\n",
    "        self.y_train = self.y_train + self.min_y_train - 1\n",
    "        self.y_test = self.y_test + self.min_y_train - 1\n",
    "        return self\n",
    "    \n",
    "    def return_target_back_from_positive(self, obj):\n",
    "        return obj + self.min_y_train - 1\n",
    "    \n",
    "    def skew_X(self, inverse=False):\n",
    "        self.skewer_X.fit(self.X_train)\n",
    "        self.X_train[:] = self.skewer_X.transform(self.X_train)\n",
    "        self.X_test[:] = self.skewer_X.transform(self.X_test)\n",
    "        return self\n",
    "    \n",
    "    def skew_X_inverse(self, data):\n",
    "        return self.skewer_X.inverse_transform(data)\n",
    "    \n",
    "    def skew_y(self):\n",
    "        self.skewer_y.fit(self.y_train)\n",
    "        self.y_train = self.skewer_y.transform(self.y_train)\n",
    "        self.y_test = self.skewer_y.transform(self.y_test)\n",
    "        return self\n",
    "\n",
    "    def skew_y_inverse(self, data): # data is 1d ndarray\n",
    "        return self.skewer_y.inverse_transform(data.reshape(-1, 1)).flatten()\n",
    "\n",
    "    def return_processed(self):\n",
    "        return self.X_train, self.X_test, self.y_train.flatten(), self.y_test.flatten()       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Validation function\n",
    "n_folds = 10\n",
    "def rmsle_cv(model, X, y):\n",
    "    kf = KFold(n_folds, shuffle=True, random_state=42).get_n_splits(X.values)\n",
    "    return np.sqrt(-cross_val_score(model, X.values, y, scoring=\"neg_mean_squared_error\", cv=kf, n_jobs=-1))\n",
    "\n",
    "def eval_model(model, name, X, y):\n",
    "    start_time = time.time()\n",
    "    score = rmsle_cv(model, X, y)\n",
    "    print(\"{} score: {:.4f} ({:.4f}),     execution time: {:.1f}\".format(name, score.mean(), score.std(), time.time()-start_time))\n",
    "\n",
    "\n",
    "def eval_models(X, y):\n",
    "#     eval_model(mod_mlp, \"mlp\", X, y)\n",
    "#     eval_model(mod_lasso, \"lasso\", X, y)\n",
    "#     eval_model(mod_enet, \"enet\", X, y)\n",
    "    eval_model(mod_cat, \"cat\", X, y)\n",
    "    eval_model(mod_gboost, \"gboost\", X, y)\n",
    "    eval_model(mod_xgb, \"xgb\", X, y)\n",
    "    eval_model(mod_lgb, \"lgb\", X, y)\n",
    "#     eval_model(mod_stacked, \"stacked\", X, y)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# ---------------------------------------------------------------------\n",
    "def get_metrics(y_test, y_pred, cols):\n",
    "    SS_Residual = sum((y_test - y_pred)**2)\n",
    "    SS_Total = sum((y_test - np.mean(y_test))**2)\n",
    "    r2 = 1 - (float(SS_Residual))/SS_Total\n",
    "    adj_r2 = 1 - (1-r2)*(len(y_test) - 1)/(len(y_test) - cols -1)\n",
    "    return  {\n",
    "        'mape': sum(abs((y_test - y_pred)/y_test)),\n",
    "        'mae': metrics.mean_absolute_error(y_test, y_pred),\n",
    "        'mse': metrics.mean_squared_error(y_test, y_pred),\n",
    "        'rmse': np.sqrt(metrics.mean_squared_error(y_test, y_pred)),\n",
    "        'r2': r2,\n",
    "        'adj_r2': adj_r2,\n",
    "    }\n",
    "\n",
    "def print_metrics(data, y_test, y_pred, cols):\n",
    "    print(data)\n",
    "    res = get_metrics(y_test, y_pred, cols)\n",
    "    for key in res:\n",
    "        print(f'{key}: {res[key]}')\n",
    "    return res\n",
    "\n",
    "def predict(model, model_name, X_train, y_train, X_test, y_test):\n",
    "    print()\n",
    "    print(model_name)\n",
    "    model.fit(X_train.values, y_train)\n",
    "    pred_train = model.predict(X_train.values)\n",
    "    pred_test = model.predict(X_test.values)\n",
    "    return {\n",
    "        'res': {\n",
    "            'train': print_metrics('train', y_train, pred_train, X_train.shape[1]),\n",
    "            'test': print_metrics('test', y_test, pred_test, X_test.shape[1]),\n",
    "        },\n",
    "        'predictions':{\n",
    "            'train': pred_train,\n",
    "            'test': pred_test,\n",
    "        },\n",
    "        'actual': {\n",
    "            'train': y_train,\n",
    "            'test': y_test,\n",
    "        },\n",
    "    }\n",
    "\n",
    "\n",
    "def predict_test(X_train, y_train, X_test, y_test):\n",
    "    prediction_results = {}\n",
    "    prediction_results['dummy'] = predict(mod_dummy, 'dummy', X_train, y_train, X_test, y_test)\n",
    "#     prediction_results['mlp'] = predict(mod_mlp, 'mlp', X_train, y_train, X_test, y_test)        \n",
    "#     prediction_results['lasso'] = predict(mod_lasso, 'lasso', X_train, y_train, X_test, y_test)\n",
    "#     prediction_results['enet'] = predict(mod_enet, 'enet', X_train, y_train, X_test, y_test)\n",
    "#     prediction_results['xgb'] = predict(mod_xgb, 'xgb', X_train, y_train, X_test, y_test)\n",
    "#     prediction_results['gboost'] = predict(mod_gboost, 'gboost', X_train, y_train, X_test, y_test)\n",
    "#     prediction_results['lgb'] = predict(mod_lgb, 'lgb', X_train, y_train, X_test, y_test)\n",
    "#     prediction_results['rfr'] = predict(mod_rfr, 'rfr', X_train, y_train, X_test, y_test)\n",
    "#     prediction_results['mod_stacked'] = predict(mod_stacked, 'mod', X_train, y_train, X_test, y_test)\n",
    "    return prediction_results\n",
    "\n",
    "# ---------------------------------------------------------------------\n",
    "def print_graphs(actual, predicted, print_log=False):\n",
    "    length = len(actual)\n",
    "    res_df = pd.DataFrame({'actual':actual, 'predicted': predicted}).astype(float)\n",
    "    res_df.sort_values(by='actual', inplace=True)\n",
    "\n",
    "    plt.figure()\n",
    "    x = np.linspace(0, length, length)\n",
    "    plt.plot(x, res_df['actual'], label='actual')\n",
    "    plt.plot(x, res_df['predicted'], label='predicted')\n",
    "\n",
    "    plt.ticklabel_format(useOffset=False, style='plain')\n",
    "    plt.rcParams[\"figure.figsize\"] = (8,8)\n",
    "    if print_log:\n",
    "        plt.yscale('log')\n",
    "    plt.show()\n",
    "    \n",
    "def print_sorted_actual_to_predicted_graphs(res, process=None):\n",
    "    for i in res:\n",
    "        print('^^^^^^^^^^^^^^^^^^^^^^^^^^^^')\n",
    "        print(i)\n",
    "        print('train')\n",
    "        print_graphs(res[i]['actual']['train'], res[i]['predictions']['train'])\n",
    "        print('test')        \n",
    "        print_graphs(res[i]['actual']['test'], res[i]['predictions']['test'])\n",
    "        \n",
    "        if process:\n",
    "            train_real = process.skew_y_inverse(res[i]['actual']['train'])\n",
    "            test_real = process.skew_y_inverse(res[i]['actual']['test'])\n",
    "            pred_train_real = process.skew_y_inverse(res[i]['predictions']['train'])\n",
    "            pred_test_real = process.skew_y_inverse(res[i]['predictions']['test'])\n",
    "\n",
    "            print('train real values')\n",
    "            print_graphs(train_real, pred_train_real)\n",
    "            print('test real values')\n",
    "            print_graphs(test_real, pred_test_real)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "pixiedust": {
     "displayParams": {}
    }
   },
   "outputs": [],
   "source": [
    "data = {}\n",
    "process = Process(X_train, X_test, y_train, y_test, imputer='mean').skew_X().skew_y().minmaxscale_X().fill_nan()\n",
    "Xh_train, Xh_test, yh_train, yh_test = process.return_processed()\n",
    "data['X_train'] = Xh_train\n",
    "data['X_test'] = Xh_test\n",
    "data['y_train'] = yh_train\n",
    "data['y_test'] = yh_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "dummy\n",
      "train\n",
      "mape: 5987.507038293008\n",
      "mae: 0.7999768487720232\n",
      "mse: 1.0000011498020471\n",
      "rmse: 1.0000005749008583\n",
      "r2: -1.149802050237625e-06\n",
      "adj_r2: -0.0391112243206424\n",
      "test\n",
      "mape: 1495.3476342313095\n",
      "mae: 1.0186195008085746\n",
      "mse: 1.4915596858177058\n",
      "rmse: 1.221294266676834\n",
      "r2: -0.04858538586862027\n",
      "adj_r2: -0.23450478052617707\n",
      "^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "dummy\n",
      "train\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train real values\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test real values\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "results = predict_test(data['X_train'], data['y_train'], data['X_test'], data['y_test'])\n",
    "print_sorted_actual_to_predicted_graphs(results, process)"
   ]
  },
  {
   "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": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {}\n",
    "process = Process(X_train, X_test, y_train, y_test, imputer='mean').skew_X().minmaxscale_X().fill_nan()\n",
    "Xh_train, Xh_test, yh_train, yh_test = process.return_processed()\n",
    "data['X_train'] = Xh_train\n",
    "data['X_test'] = Xh_test\n",
    "data['y_train'] = yh_train\n",
    "data['y_test'] = yh_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "dummy\n",
      "train\n",
      "mape: 1165879.5811588648\n",
      "mae: 82466862.75219868\n",
      "mse: 1.9888365932268976e+16\n",
      "rmse: 141026117.9082406\n",
      "r2: 0.0\n",
      "adj_r2: -0.03911002954980014\n",
      "test\n",
      "mape: 883883.6651071146\n",
      "mae: 97249780.4033559\n",
      "mse: 2.9127522684428908e+16\n",
      "rmse: 170667872.44361168\n",
      "r2: -0.000455149774845065\n",
      "adj_r2: -0.17784081462854107\n",
      "^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
      "dummy\n",
      "train\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "results = predict_test(data['X_train'], data['y_train'], data['X_test'], data['y_test'])\n",
    "print_sorted_actual_to_predicted_graphs(results)"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "process = Process(X_train, X_test, y_train, y_test, imputer='knn').skew_X().minmaxscaleX().fill_nan()\n",
    "Xh_train, Xh_test, yh_train, yh_test = process.return_processed()\n",
    "yh_train = np.log1p(yh_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimator = RandomForestRegressor(n_estimators=100, min_samples_split=3, random_state=0, n_jobs=-1)\n",
    "selector = RFECV(estimator, verbose=10, n_jobs=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "selector = selector.fit(Xh_train, yh_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import joblib\n",
    "joblib.dump(selector, 'rfecv_selector_joblib_2.sav')\n",
    "import pickle\n",
    "pickle.dump(selector, open('rfecv_selector_pickle_2.sav', 'wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "selector.n_features_\n",
    "selector.support_\n",
    "selector.ranking_"
   ]
  },
  {
   "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": [
    "ind = selector.get_support()\n",
    "not_ind = [not val for val in ind]\n",
    "list(Xh_train.columns[ind])"
   ]
  },
  {
   "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": [
    "pd.options.display.float_format = '{:20,.15f}'.format\n",
    "print(Xh_train.astype(float).describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.options.display.float_format = '{:20,.15f}'.format\n",
    "print(Xh_train.astype(float).describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(X_train.columns[not_ind])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "selector.score(Xh_test, yh_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "selector.score(Xh_train, yh_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "selector.ranking_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "selector.estimator_.feature_importances_ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rank = [(list(X_train.columns)[i], list(selector.ranking_)[i]) for i in range(len(X_train.columns))]\n",
    "rank = [(list(X_train.columns)[i], list(selector.estimator_.feature_importances_)[i]) for i in range(len(X_train.columns))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_names = list(X_train.columns.values)\n",
    "print(sorted(zip(map(lambda x: round(x, 4), selector.ranking_), feature_names)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted(rank, key=lambda tup: tup[1])"
   ]
  },
  {
   "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": 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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import cross_validate\n",
    "from sklearn.model_selection import cross_val_predict\n",
    "scoring = ['neg_mean_squared_error']\n",
    "\n",
    "def predict_cv_model(model, name, X, y):\n",
    "    return cross_val_predict(model, X.values, y, cv=20, n_jobs=-1)\n",
    "\n",
    "\n",
    "def eval_models(X, y):\n",
    "#     eval_model(mod_mlp, \"mlp\", X, y)\n",
    "    return predict_cv_model(mod_lasso, \"lasso\", X, y)\n",
    "#     eval_model(mod_enet, \"enet\", X, y)\n",
    "#     eval_model(mod_cat, \"cat\", X, y)\n",
    "#     eval_model(mod_gboost, \"gboost\", X, y)\n",
    "#     eval_model(mod_xgb, \"xgb\", X, y)\n",
    "#     eval_model(mod_lgb, \"lgb\", X, y)\n",
    "#     eval_model(mod_stacked, \"stacked\", X, y)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# ---------------------------------------------------------------------\n",
    "def get_metrics(y_test, y_pred, cols):\n",
    "    SS_Residual = sum((y_test - y_pred)**2)\n",
    "    SS_Total = sum((y_test - np.mean(y_test))**2)\n",
    "    r2 = 1 - (float(SS_Residual))/SS_Total\n",
    "    adj_r2 = 1 - (1-r2)*(len(y_test) - 1)/(len(y_test) - cols -1)\n",
    "    return  {\n",
    "        'mape': sum(abs((y_test - y_pred)/y_test)),\n",
    "        'mae': metrics.mean_absolute_error(y_test, y_pred),\n",
    "        'mse': metrics.mean_squared_error(y_test, y_pred),\n",
    "        'rmse': np.sqrt(metrics.mean_squared_error(y_test, y_pred)),\n",
    "        'r2': r2,\n",
    "        'adj_r2': adj_r2,\n",
    "    }\n",
    "\n",
    "def print_metrics(data, y_test, y_pred, cols):\n",
    "    print(data)\n",
    "    res = get_metrics(y_test, y_pred, cols)\n",
    "    for key in res:\n",
    "        print(f'{key}: {res[key]}')\n",
    "    return res\n",
    "\n",
    "def predict_not_log(model, model_name, X_train, y_train, X_test, y_test):\n",
    "    print()\n",
    "    print(model_name)\n",
    "    model.fit(X_train.values, y_train)\n",
    "    pred_train = model.predict(X_train.values)\n",
    "    pred_test = model.predict(X_test.values)\n",
    "    return {\n",
    "        'res': {\n",
    "            'train': print_metrics('train', y_train, pred_train, X_train.shape[1]),\n",
    "            'test': print_metrics('test', y_test, pred_test, X_test.shape[1]),\n",
    "        },\n",
    "        'predictions':{\n",
    "            'train': pred_train,\n",
    "            'test': pred_test,\n",
    "        },\n",
    "        'actual': {\n",
    "            'train': y_train,\n",
    "            'test': y_test,\n",
    "        },\n",
    "    }\n",
    "\n",
    "\n",
    "def predict_test(X_train, y_train, X_test, y_test):\n",
    "    prediction_results = {}\n",
    "#     prediction_results['mlp'] = predict(mod_mlp, 'mlp', X_train, y_train, X_test, y_test)        \n",
    "    prediction_results['lasso'] = predict(mod_lasso, 'lasso', X_train, y_train, X_test, y_test)\n",
    "#     prediction_results['enet'] = predict(mod_enet, 'enet', X_train, y_train, X_test, y_test)\n",
    "#     prediction_results['xgb'] = predict(mod_xgb, 'xgb', X_train, y_train, X_test, y_test)\n",
    "#     prediction_results['gboost'] = predict(mod_gboost, 'gboost', X_train, y_train, X_test, y_test)\n",
    "#     prediction_results['lgb'] = predict(mod_lgb, 'lgb', X_train, y_train, X_test, y_test)\n",
    "#     prediction_results['mod_stacked'] = predict(mod_stacked, 'mod', X_train, y_train, X_test, y_test)\n",
    "    return prediction_results\n",
    "\n",
    "# ---------------------------------------------------------------------\n",
    "def print_graphs(actual, predicted, log=False):\n",
    "    plt.clf()\n",
    "    length = len(actual)\n",
    "    res_df = pd.DataFrame({'actual':actual, 'predicted': predicted}).astype(float)\n",
    "    res_df.sort_values(by='actual', inplace=True)\n",
    "\n",
    "    plt.figure()\n",
    "    x = np.linspace(0, length, length)\n",
    "    plt.plot(x, res_df['actual'], label='actual')\n",
    "    plt.plot(x, res_df['predicted'], label='predicted')\n",
    "\n",
    "    plt.ticklabel_format(useOffset=False, style='plain')\n",
    "    plt.rcParams[\"figure.figsize\"] = (8,8)\n",
    "    if log:\n",
    "        plt.yscale('log')\n",
    "    plt.show()\n",
    "    \n",
    "def print_sorted_actual_to_predicted_graphs(res):\n",
    "    print('train')\n",
    "    print_graphs(res['actual']['train'], res['predictions']['train'])\n",
    "    print('test')\n",
    "    print_graphs(res['actual']['test'], res['predictions']['test'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('savedcsv/17_homepage.csv')\n",
    "num_in_train = int(df.shape[0]*0.8)\n",
    "df_train = df[:num_in_train]\n",
    "df_test = df[num_in_train:]\n",
    "X_train, y_train = get_train_test_revenue(df_train)\n",
    "X_test, y_test = get_train_test_revenue(df_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "process = Process(X_train, X_test, y_train, y_test, imputer='knn').skew_X().minmaxscaleX().fill_nan()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "skew = PowerTransformer()\n",
    "Xh_train, Xh_test, y_train, yh_test = process.return_processed()\n",
    "yh_train = skew.fit_transform(y_train.reshape(-1, 1)).flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mod_cat.fit(Xh_train.values, yh_train)\n",
    "pred_train = mod_cat.predict(Xh_train.values)\n",
    "pred_skew = mod_cat.predict(Xh_test.values)\n",
    "pred_test = skew.inverse_transform(pred_skew.reshape(-1, 1)).flatten()\n",
    "result = {\n",
    "    'res': {\n",
    "        'train': print_metrics('train', yh_train, pred_train, Xh_train.shape[1]),\n",
    "        'test': print_metrics('test', yh_test, pred_test, Xh_test.shape[1]),\n",
    "    },\n",
    "    'predictions':{\n",
    "        'train': pred_train,\n",
    "        'test': pred_test,\n",
    "    },\n",
    "    'actual': {\n",
    "        'train': yh_train,\n",
    "        'test': yh_test,\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_sorted_actual_to_predicted_graphs(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mod_enet.fit(Xh_train.values, yh_train)\n",
    "pred_train = mod_enet.predict(Xh_train.values)\n",
    "pred_skew = mod_enet.predict(Xh_test.values)\n",
    "pred_test = skew.inverse_transform(pred_skew.reshape(-1, 1)).flatten()\n",
    "result = {\n",
    "    'res': {\n",
    "        'train': print_metrics('train', yh_train, pred_train, Xh_train.shape[1]),\n",
    "        'test': print_metrics('test', yh_test, pred_test, Xh_test.shape[1]),\n",
    "    },\n",
    "    'predictions':{\n",
    "        'train': skew.inverse_transform(pred_train.reshape(-1, 1)).flatten(),\n",
    "        'test': pred_test,\n",
    "    },\n",
    "    'actual': {\n",
    "        'train': skew.inverse_transform(yh_train.reshape(-1, 1)).flatten(),\n",
    "        'test': yh_test,\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_sorted_actual_to_predicted_graphs(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_describe = pd.DataFrame(pred_train)\n",
    "df_describe.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_describe = pd.DataFrame(pred_test)\n",
    "df_describe.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(np.sort(pred_train))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(np.sort(pred_test))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "yh_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_describe = pd.DataFrame(yh_test)\n",
    "df_describe.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_graphs(y_train, y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}