Inferecne.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.base import BaseEstimator,TransformerMixin, ClassifierMixin\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "import xgboost as xgb\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "from sklearn.linear_model import ElasticNetCV, LassoLarsCV\n",
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "from sklearn.pipeline import make_pipeline, make_union\n",
    "from sklearn.utils import check_array\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.random_projection import GaussianRandomProjection\n",
    "from sklearn.random_projection import SparseRandomProjection\n",
    "from sklearn.decomposition import PCA, FastICA\n",
    "from sklearn.decomposition import TruncatedSVD\n",
    "from sklearn.metrics import r2_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "from matplotlib import pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.preprocessing import LabelEncoder,OneHotEncoder\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from tqdm import tqdm\n",
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "from scipy.sparse import hstack\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import StackingRegressor\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "from sklearn.linear_model import Lasso\n",
    "from sklearn.model_selection import cross_validate\n",
    "import copy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Please run the run mode11 and run model2 in the last cell</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def DataCleaning(train):\n",
    "    \"\"\"Take Dataset clean it and return it back\"\"\"\n",
    "    print(\"CLEANING STARTED.........\")\n",
    "    clipped_y  =[]\n",
    "    [clipped_y.append(130) if i>180 else clipped_y.append(i) for i in train['y']]\n",
    "    train['y'] = clipped_y\n",
    "    actual_y = train[\"y\"]\n",
    "    train.drop(\"y\",inplace=True,axis=1)\n",
    "    print(\"CLEANING DONE.........\")\n",
    "    return [train,actual_y]\n",
    "    \n",
    "def Label_encoding_function(train,test):\n",
    "    \"\"\"Take Dataset decompose it and concatenate it with original data and return it back\"\"\"\n",
    "    print(\"LABEL ENCODING STARTED.........\")\n",
    "    for c in train.columns:\n",
    "        if c in ['X0', 'X1', 'X2', 'X3', 'X4', 'X5', 'X6', 'X8']:\n",
    "            lbl = LabelEncoder()\n",
    "            lbl.fit(list(train[c].values)+ list(test[c].values))\n",
    "            train[c] = lbl.transform(list(train[c].values))\n",
    "            test[c] = lbl.transform(list(test[c].values))\n",
    "            # Fixing the type of the coloumns\n",
    "    columns = train.columns\n",
    "    train[columns] = train[columns].apply(pd.to_numeric)\n",
    "    test[columns] = test[columns].apply(pd.to_numeric)\n",
    "    print(\"LABEL ENCODING DONE.........\")\n",
    "    return [train,test]\n",
    "\n",
    "def decomposed_features(train_,test_):\n",
    "    n_comp = 12\n",
    "    print(\"DECOMPOSITION STARTED.........\")\n",
    "    # tSVD\n",
    "    tsvd = TruncatedSVD(n_components=n_comp, random_state=420)\n",
    "    tsvd_results_train = tsvd.fit_transform(train_)\n",
    "    tsvd_results_test = tsvd.transform(test_)\n",
    "\n",
    "    # PCA\n",
    "    pca = PCA(n_components=n_comp, random_state=420)\n",
    "    pca2_results_train = pca.fit_transform(train_)\n",
    "    pca2_results_test = pca.transform(test_)\n",
    "\n",
    "    # ICA\n",
    "    ica = FastICA(n_components=n_comp, random_state=420)\n",
    "    ica2_results_train = ica.fit_transform(train_)\n",
    "    ica2_results_test = ica.transform(test_)\n",
    "\n",
    "    # GRP\n",
    "    grp = GaussianRandomProjection(n_components=n_comp, eps=0.1, random_state=420)\n",
    "    grp_results_train = grp.fit_transform(train_)\n",
    "    grp_results_test = grp.transform(test_)\n",
    "\n",
    "    # SRP\n",
    "    srp = SparseRandomProjection(n_components=n_comp, dense_output=True, random_state=420)\n",
    "    srp_results_train = srp.fit_transform(train_)\n",
    "    srp_results_test = srp.transform(test_)                                \n",
    "\n",
    "    #save columns list before adding the decomposition components\n",
    "\n",
    "    usable_columns = list(set(train_.columns) - set(['y']))\n",
    "\n",
    "    # Append decomposition components to datasets\n",
    "    for i in range(1, n_comp + 1):\n",
    "        train_['pca_' + str(i)] = pca2_results_train[:, i - 1]\n",
    "        test_['pca_' + str(i)] = pca2_results_test[:, i - 1]\n",
    "\n",
    "        train_['ica_' + str(i)] = ica2_results_train[:, i - 1]\n",
    "        test_['ica_' + str(i)] = ica2_results_test[:, i - 1]\n",
    "\n",
    "        train_['tsvd_' + str(i)] = tsvd_results_train[:, i - 1]\n",
    "        test_['tsvd_' + str(i)] = tsvd_results_test[:, i - 1]\n",
    "\n",
    "        train_['grp_' + str(i)] = grp_results_train[:, i - 1]\n",
    "        test_['grp_' + str(i)] = grp_results_test[:, i - 1]\n",
    "\n",
    "        train_['srp_' + str(i)] = srp_results_train[:, i - 1]\n",
    "        test_['srp_' + str(i)] = srp_results_test[:, i - 1]\n",
    "    print(\"DECOMPOSITION DONE.........\")    \n",
    "    return [train_,test_]\n",
    "\n",
    "class StackingEstimator(BaseEstimator, TransformerMixin):\n",
    "    \n",
    "    def __init__(self, estimator):\n",
    "        self.estimator = estimator\n",
    "\n",
    "    \n",
    "    def fit(self, X, y=None, **fit_params):\n",
    "        self.estimator.fit(X, y, **fit_params)\n",
    "        return self\n",
    "    \n",
    "    def transform(self, X):\n",
    "        X = check_array(X)\n",
    "        X_transformed = np.copy(X)\n",
    "        # add class probabilities as a synthetic feature\n",
    "        if issubclass(self.estimator.__class__, ClassifierMixin) and hasattr(self.estimator, 'predict_proba'):\n",
    "            X_transformed = np.hstack((self.estimator.predict_proba(X), X))\n",
    "        # add class prodiction as a synthetic feature\n",
    "        X_transformed = np.hstack((np.reshape(self.estimator.predict(X), (-1, 1)), X_transformed))\n",
    "        return X_transformed\n",
    "    \n",
    "def Training(train,test):\n",
    "    '''                     DATA CLEANING                  \n",
    "    '''\n",
    "    Data = DataCleaning(train)\n",
    "    train = Data[0]\n",
    "    actual_y = Data[1]\n",
    "    '''                     DATA DECOMPOSING                  \n",
    "    '''\n",
    "    b = Label_encoding_function(train,test)\n",
    "    train = b[0]\n",
    "    test = b[1]\n",
    "    # creating a deep copy and calling decompose function\n",
    "    decomposed_train = copy.deepcopy(train)\n",
    "    decomposed_test= copy.deepcopy(test)\n",
    "    decomposed_train,decomposed_test = decomposed_features(decomposed_train,decomposed_test)\n",
    "    \n",
    "    \n",
    "    '''                      MODEL ARCHITECTURE                  \n",
    "                    Train the xgb model then predict the test data\n",
    "    '''\n",
    "    xgb_params = {'n_trees': 520,'eta': 0.0045,'max_depth': 4,'subsample': 0.93,'objective': 'reg:linear','eval_metric': 'rmse','silent': 1}\n",
    "    dtrain = xgb.DMatrix(decomposed_train, actual_y)\n",
    "    dtest = xgb.DMatrix(decomposed_test)\n",
    "    # NOTE: Make sure that the class is labeled 'class' in the data file\n",
    "    num_boost_rounds = 1250\n",
    "    # train model\n",
    "    print(\"TRAINING STARTED\")\n",
    "    model = xgb.train(dict(xgb_params, silent=0), dtrain, num_boost_round=num_boost_rounds)\n",
    "    \n",
    "    # Pipeline of the model\n",
    "    stacked_pipeline = make_pipeline(\n",
    "    StackingEstimator(estimator=LassoLarsCV(normalize=True,cv=5)),\n",
    "    StackingEstimator(estimator=GradientBoostingRegressor(alpha=0.9, criterion='friedman_mse', init=None,learning_rate=0.1,\\\n",
    "                          loss='ls', max_depth=3,max_features=0.55, max_leaf_nodes=None,\\\n",
    "                          min_impurity_decrease=0.0, min_impurity_split=None,\\\n",
    "                          min_samples_leaf=14, min_samples_split=16,\\\n",
    "                          min_weight_fraction_leaf=0.0, n_estimators=100,\\\n",
    "                          n_iter_no_change=None, presort='auto',\\\n",
    "                          random_state=19, subsample=0.8, tol=0.0001,\\\n",
    "                          validation_fraction=0.1, verbose=0, warm_start=False)),\n",
    "    LassoLarsCV(normalize=True,cv=5)\n",
    ")\n",
    "\n",
    "    stacked_pipeline.fit(train, actual_y)\n",
    "    print(\"TRAINING DONE\")\n",
    "    return [model,stacked_pipeline,actual_y,dtest,dtrain]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def MercedesGrennerFunction1(train,test):\n",
    "    '''                     THIS FUNCTION RETURNS TEST PREDICTION\n",
    "    '''\n",
    "    models = Training(train,test)\n",
    "    model = models[0]\n",
    "    stacked_pipeline = models[1]\n",
    "    actual_y = models[2]\n",
    "    dtest = models[3]\n",
    "    \n",
    "    y_pred = model.predict(dtest)\n",
    "    results = stacked_pipeline.predict(test)\n",
    "    '''R2 Score on the entire Train data when averaging'''\n",
    "    i = .62\n",
    "    '''Average the preditionon test data  of both models then save it on a csv file'''\n",
    "    sub = pd.DataFrame()\n",
    "    prediction = y_pred*(1-i) + results*i\n",
    "    return prediction\n",
    "\n",
    "\n",
    "def MercedesGrennerFunction2(train,test):\n",
    "    '''                     THIS FUNCTION RETURNS TRAIN PREDICTION\n",
    "    '''\n",
    "    models = Training(train,test)\n",
    "    model = models[0]\n",
    "    stacked_pipeline = models[1]\n",
    "    actual_y = models[2]\n",
    "    dtrain = models[4]\n",
    "    i = .62\n",
    "    prediction = stacked_pipeline.predict(train)*i + model.predict(dtrain)*(1-i)\n",
    "    return prediction "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CLEANING STARTED.........\n",
      "CLEANING DONE.........\n",
      "LABEL ENCODING STARTED.........\n",
      "LABEL ENCODING DONE.........\n",
      "DECOMPOSITION STARTED.........\n",
      "DECOMPOSITION DONE.........\n",
      "TRAINING STARTED\n",
      "[23:34:02] WARNING: C:/Jenkins/workspace/xgboost-win64_release_0.90/src/objective/regression_obj.cu:152: reg:linear is now deprecated in favor of reg:squarederror.\n",
      "TRAINING DONE\n"
     ]
    },
    {
     "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": [
    "def RunModel1():\n",
    "    '''                     THIS FUNCTION RETURNS TEST PREDICTION\n",
    "    '''\n",
    "    train = pd.read_csv(\"./train/train.csv\")\n",
    "    test = pd.read_csv(\"./test/test.csv\")\n",
    "    prediction = MercedesGrennerFunction1(train,test)\n",
    "    sns.distplot(prediction)\n",
    "    plt.show()\n",
    "RunModel1()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CLEANING STARTED.........\n",
      "CLEANING DONE.........\n",
      "LABEL ENCODING STARTED.........\n",
      "LABEL ENCODING DONE.........\n",
      "DECOMPOSITION STARTED.........\n",
      "DECOMPOSITION DONE.........\n",
      "TRAINING STARTED\n",
      "[23:41:58] WARNING: C:/Jenkins/workspace/xgboost-win64_release_0.90/src/objective/regression_obj.cu:152: reg:linear is now deprecated in favor of reg:squarederror.\n",
      "TRAINING DONE\n"
     ]
    },
    {
     "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": [
    "def RunModel2():\n",
    "    '''                     THIS FUNCTION RETURNS TRAIN PREDICTION\n",
    "    '''\n",
    "    train = pd.read_csv(\"./train/train.csv\")\n",
    "    test = pd.read_csv(\"./test/test.csv\")\n",
    "    prediction = MercedesGrennerFunction2(train,test)\n",
    "    sns.distplot(prediction)\n",
    "    plt.show()\n",
    "RunModel2()    "
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}