Pipeline and prediction cross validation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Predicting product cancelations for sales retention\n",
    "Investigate machine learning techniques to predict the likely-hood of a product cancellation based on existing sales and amount spent in annual maintenance. To enable the targeting of retention resources and offers to those customers who are predicted as at risk. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# libaries, functions and pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pandas version is high enough\n"
     ]
    }
   ],
   "source": [
    "# get updated version on pandas\n",
    "import pandas as pd\n",
    "from distutils.version import LooseVersion, StrictVersion\n",
    "if LooseVersion(pd.__version__) < LooseVersion(\"0.22.0\"):\n",
    "    !pip install --upgrade pandas\n",
    "    pd.__version__\n",
    "    print(\"pandas version was: \" + pd.__version__ + \" It has been updated, please restart the kernel\")\n",
    "else:\n",
    "    print(\"pandas version is high enough\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: pdtransform in c:\\users\\nathan\\anaconda3\\lib\\site-packages (0.2)\n",
      "Requirement already satisfied: pandas in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from pdtransform) (0.23.0)\n",
      "Requirement already satisfied: scikit-learn in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from pdtransform) (0.19.1)\n",
      "Requirement already satisfied: python-dateutil>=2.5.0 in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from pandas->pdtransform) (2.7.3)\n",
      "Requirement already satisfied: numpy>=1.9.0 in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from pandas->pdtransform) (1.14.3)\n",
      "Requirement already satisfied: pytz>=2011k in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from pandas->pdtransform) (2018.4)\n",
      "Requirement already satisfied: six>=1.5 in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from python-dateutil>=2.5.0->pandas->pdtransform) (1.11.0)\n",
      "Requirement already satisfied: tabulate in c:\\users\\nathan\\anaconda3\\lib\\site-packages (0.8.2)\n",
      "Requirement already satisfied: seaborn==0.9.0 in c:\\users\\nathan\\anaconda3\\lib\\site-packages (0.9.0)\n",
      "Requirement already satisfied: pandas>=0.15.2 in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from seaborn==0.9.0) (0.23.0)\n",
      "Requirement already satisfied: scipy>=0.14.0 in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from seaborn==0.9.0) (1.1.0)\n",
      "Requirement already satisfied: matplotlib>=1.4.3 in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from seaborn==0.9.0) (2.2.2)\n",
      "Requirement already satisfied: numpy>=1.9.3 in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from seaborn==0.9.0) (1.14.3)\n",
      "Requirement already satisfied: pytz>=2011k in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from pandas>=0.15.2->seaborn==0.9.0) (2018.4)\n",
      "Requirement already satisfied: python-dateutil>=2.5.0 in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from pandas>=0.15.2->seaborn==0.9.0) (2.7.3)\n",
      "Requirement already satisfied: cycler>=0.10 in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from matplotlib>=1.4.3->seaborn==0.9.0) (0.10.0)\n",
      "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from matplotlib>=1.4.3->seaborn==0.9.0) (2.2.0)\n",
      "Requirement already satisfied: six>=1.10 in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from matplotlib>=1.4.3->seaborn==0.9.0) (1.11.0)\n",
      "Requirement already satisfied: kiwisolver>=1.0.1 in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from matplotlib>=1.4.3->seaborn==0.9.0) (1.0.1)\n",
      "Requirement already satisfied: setuptools in c:\\users\\nathan\\anaconda3\\lib\\site-packages (from kiwisolver>=1.0.1->matplotlib>=1.4.3->seaborn==0.9.0) (39.1.0)\n"
     ]
    }
   ],
   "source": [
    "#some extra libs that we need in the page:\n",
    "!pip install pdtransform\n",
    "!pip install tabulate\n",
    "!pip install seaborn==0.9.0 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# setup the notebook and import libs\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from scipy import stats, integrate\n",
    "from sklearn.model_selection import train_test_split, StratifiedKFold\n",
    "from sklearn.metrics import (\n",
    "    auc,\n",
    "    confusion_matrix,\n",
    "    precision_recall_curve,\n",
    "    precision_score,\n",
    "    recall_score,\n",
    "    roc_curve,\n",
    "    accuracy_score\n",
    "    )\n",
    "from tabulate import tabulate\n",
    "from sklearn.dummy import DummyClassifier\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.feature_selection import SelectFromModel\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.metrics import accuracy_score,recall_score,confusion_matrix, classification_report,make_scorer\n",
    "from sklearn.preprocessing import StandardScaler,RobustScaler,Normalizer,QuantileTransformer\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn import decomposition\n",
    "from sklearn.preprocessing import FunctionTransformer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn import preprocessing\n",
    "#from sklearn import cross_validation\n",
    "from pdtransform import DFTransform, DFFeatureUnion\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from scipy.stats import uniform\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.feature_selection import SelectKBest, chi2, f_classif\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.gaussian_process import GaussianProcessClassifier\n",
    "from sklearn.gaussian_process.kernels import RBF\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier\n",
    "from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "%matplotlib inline\n",
    "\n",
    "#Get the data from the same folder as the notebook and test the pandas version\n",
    "csvData = './ResultsGrid.csv'\n",
    "isCancelledKey = 'isCancelled'\n",
    "customerIdKey = 'customerId'\n",
    "adminAreaKey = 'administrativeArea'\n",
    "subCountryKey = 'subCountryArea'\n",
    "countryKey = 'country'\n",
    "avgDaysToPay='avgDaysToPay'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "#seaborn defaults - see http://www.jesshamrick.com/2016/04/13/reproducible-plots/\n",
    "sns.set_context(\"paper\") \n",
    "# Set the font to be serif, rather than sans\n",
    "sns.set(font='serif')\n",
    "# Make the background white, and specify the\n",
    "# specific font family\n",
    "sns.set_style(\"white\", {\n",
    "    \"font.family\": \"serif\",\n",
    "    \"font.serif\": [\"Times\", \"Palatino\", \"serif\"]\n",
    "})\n",
    "# configure seaborn https://seaborn.pydata.org/\n",
    "sns.set(color_codes=True)\n",
    "colors = [\"amber\", \"windows blue\", \"red\",\"green\", \"grey\", \"dusty purple\"]\n",
    "sns.set_palette(sns.xkcd_palette(colors))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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>customerId</th>\n",
       "      <th>amountTotal</th>\n",
       "      <th>salesTotal</th>\n",
       "      <th>annualTotal</th>\n",
       "      <th>monthlyTotalProduct1</th>\n",
       "      <th>monthlyTotalProduct2</th>\n",
       "      <th>extraItemsTotal</th>\n",
       "      <th>monthsSinceStarted</th>\n",
       "      <th>avgDaysToPay</th>\n",
       "      <th>creditedAmount</th>\n",
       "      <th>...</th>\n",
       "      <th>hasProduct7</th>\n",
       "      <th>hasProduct8</th>\n",
       "      <th>hasProduct9</th>\n",
       "      <th>hasProduct10</th>\n",
       "      <th>hasProduct11</th>\n",
       "      <th>hasProduct12</th>\n",
       "      <th>administrativeArea</th>\n",
       "      <th>subCountryArea</th>\n",
       "      <th>country</th>\n",
       "      <th>firstInvoiceDate</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>0 rows × 27 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [customerId, amountTotal, salesTotal, annualTotal, monthlyTotalProduct1, monthlyTotalProduct2, extraItemsTotal, monthsSinceStarted, avgDaysToPay, creditedAmount, isCancelled, hasProduct1, hasProduct2, hasProduct3, hasProduct4, hasProduct5, hasProduct6, hasProduct7, hasProduct8, hasProduct9, hasProduct10, hasProduct11, hasProduct12, administrativeArea, subCountryArea, country, firstInvoiceDate]\n",
       "Index: []\n",
       "\n",
       "[0 rows x 27 columns]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#load the dataframe in\n",
    "dataFrame = pd.read_csv(csvData)\n",
    "isCancelledIndex = dataFrame.columns.get_loc(isCancelledKey)\n",
    "dataFrame = dataFrame.infer_objects()\n",
    "nans = lambda df: df[df.isnull().any(axis=1)]\n",
    "nans(dataFrame)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getTrainTestSplit(df):\n",
    "    #remove the dependant variable and columns that have no value in training\n",
    "    data = df.drop([isCancelledKey], axis=1)\n",
    "    # Set monthsSinceStarted and avgDaysToPay to 0 if negative\n",
    "    df.loc[:, ['monthsSinceStarted','avgDaysToPay']]  = df[['monthsSinceStarted','avgDaysToPay']].clip(lower=0)\n",
    "    X_train, X_test, y_train, y_test = train_test_split( data, df[isCancelledKey], test_size=0.33, random_state=42, stratify=df[isCancelledKey])\n",
    "    \n",
    "    print('y_train class distribution')\n",
    "    print(y_train.value_counts(normalize=True))\n",
    "    print('y_test class distribution')\n",
    "    print(y_test.value_counts(normalize=True))\n",
    "    \n",
    "    return X_train, X_test, y_train, y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def printConfusionMatrix(confusion_matrix, printName = \"\", figsize = (10,7), fontsize=14):\n",
    "    classNames = ['false', 'true']\n",
    "    df_cm = pd.DataFrame(\n",
    "        confusion_matrix, index=classNames, columns=classNames, \n",
    "    )\n",
    "    fig = plt.figure(figsize=figsize)\n",
    "    try:\n",
    "        heatmap = sns.heatmap(df_cm, annot=True, fmt=\"d\")\n",
    "    except ValueError:\n",
    "        raise ValueError(\"Confusion matrix values must be integers.\")\n",
    "    heatmap.yaxis.set_ticklabels(heatmap.yaxis.get_ticklabels(), rotation=0, ha='right', fontsize=fontsize)\n",
    "    heatmap.xaxis.set_ticklabels(heatmap.xaxis.get_ticklabels(), rotation=45, ha='right', fontsize=fontsize)\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')\n",
    "    \n",
    "    if(printName != \"\"):\n",
    "        confusionMatrixfig = heatmap.get_figure()\n",
    "        confusionMatrixfig.savefig(printName, format='eps')\n",
    "    \n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def printDescribe(afterString, df):\n",
    "    print(f\"{afterString} - Number of features {len(df.columns)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getOneHotEncodeData(df):\n",
    "    categoryFeatures = [subCountryKey] #[adminAreaKey, subCountryKey,countryKey]\n",
    "    oneHotDataframe = pd.get_dummies(df,columns=categoryFeatures, dummy_na=True)\n",
    "    return oneHotDataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def printClassificationReport(y_test, y_pred, asLatex = False):\n",
    "    clfReport = classification_report(y_test, y_pred)\n",
    "    print(clfReport)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def GridSearchCVOnPipeline(X, y, pipeline, param_grid, refitScore):\n",
    "    skf = StratifiedKFold(n_splits=3)\n",
    "    scorers = {\n",
    "        'precision_score': make_scorer(precision_score),\n",
    "        'recall_score': make_scorer(recall_score),\n",
    "        'accuracy_score': make_scorer(accuracy_score)\n",
    "    }\n",
    "    \n",
    "    grid = GridSearchCV(\n",
    "        pipeline, \n",
    "        cv=skf,  \n",
    "        param_grid=param_grid,\n",
    "        scoring=scorers, \n",
    "        refit=refitScore,\n",
    "        return_train_score=True, \n",
    "        n_jobs=-1\n",
    "    )\n",
    "    bestModel = grid.fit(X, y)\n",
    "    #mean_scores = np.array(grid.cv_results_['mean_test_score'])\n",
    "    #print(mean_scores)\n",
    "    print(f\"Number of features {len(X.columns)}\")\n",
    "    return bestModel\n",
    "    \n",
    "def BestModelScore(X_test, y_test, grid, refitScore, printName=\"\"):\n",
    "    y_pred = grid.predict(X_test.values)\n",
    "\n",
    "    print('Best params for {}'.format(refitScore))\n",
    "    print(grid.best_params_)\n",
    "\n",
    "    print('\\nConfusion matrix for {} on the test data:'.format(refitScore))\n",
    "    print(pd.DataFrame(\n",
    "            confusion_matrix(y_test, y_pred),\n",
    "            columns=['pred_neg', 'pred_pos'], \n",
    "            index=['neg', 'pos'])\n",
    "         )\n",
    "    printConfusionMatrix(confusion_matrix(y_test,y_pred), printName)\n",
    "    printClassificationReport(y_test, y_pred)\n",
    "    \n",
    "    #return grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def RemoveSkew(df):\n",
    "    skewColumns = df.skew(numeric_only=\"true\")\n",
    "    skewRightColumns = skewColumns[lambda x : (x > 0.25)]\n",
    "    #note ignoring 'int64' gives better results - why?\n",
    "    skewRightDf = df[skewRightColumns.index].select_dtypes(include=['float64'])\n",
    "    # 1+ to get rid of -inf value\n",
    "    df[skewRightDf.columns] = np.log(1+skewRightDf)\n",
    "    #skewLeftColumns = skewColumns[lambda x : (x < -3.0)]\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def RemoveLeftSkew(df):\n",
    "    skewColumns = df.skew(numeric_only=\"true\")\n",
    "    skewLeftColumns = skewColumns[lambda x : (x < -0.25)]\n",
    "    skewLeftDf = df[skewLeftColumns.index].select_dtypes(include=['float64'])\n",
    "    # 1+ to get rid of -inf value\n",
    "    df[skewLeftDf.columns] = np.log(1+skewLeftDf)\n",
    "    return df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sklearn pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y_train class distribution\n",
      "False    0.555875\n",
      "True     0.444125\n",
      "Name: isCancelled, dtype: float64\n",
      "y_test class distribution\n",
      "False    0.556347\n",
      "True     0.443653\n",
      "Name: isCancelled, dtype: float64\n",
      "Number of features 21\n",
      "Best params for precision_score\n",
      "{'classifier__C': 1.4347788054641235, 'classifier__penalty': 'l1'}\n",
      "\n",
      "Confusion matrix for precision_score on the test data:\n",
      "     pred_neg  pred_pos\n",
      "neg       665       194\n",
      "pos       162       523\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\nathan\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\validation.py:475: DataConversionWarning: Data with input dtype object was converted to float64 by StandardScaler.\n",
      "  warnings.warn(msg, DataConversionWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "      False       0.80      0.77      0.79       859\n",
      "       True       0.73      0.76      0.75       685\n",
      "\n",
      "avg / total       0.77      0.77      0.77      1544\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_train, X_test, y_train, y_test = getTrainTestSplit(dataFrame)\n",
    "C = uniform(loc=0, scale=4).rvs(10)\n",
    "refitScore = 'precision_score'\n",
    "param_grid = [\n",
    "    {\n",
    "        'classifier__C': C,\n",
    "        'classifier__penalty':['l1', 'l2']\n",
    "    }\n",
    "]\n",
    "\n",
    "transformPipeline = Pipeline([\n",
    "    ('Initial drop cols', DFTransform(lambda X: X.drop([customerIdKey,'firstInvoiceDate'], axis=1))),\n",
    "    ('Remove catagorical', DFTransform(lambda X: X.select_dtypes(exclude=['object']))),\n",
    "])\n",
    "clfPipeline = Pipeline([\n",
    "    ('scaler',StandardScaler()),\n",
    "    ('classifier', LogisticRegression())\n",
    "])\n",
    "\n",
    "transformedDfX_test = transformPipeline.transform(X_train)\n",
    "bestModel = GridSearchCVOnPipeline(transformedDfX_test, y_train, clfPipeline, param_grid, refitScore)\n",
    "\n",
    "transformedDfX_test = transformPipeline.transform(X_test)\n",
    "BestModelScore(transformedDfX_test, y_test, bestModel, refitScore, \"initialScore.eps\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## One hot encode the dataframe before the pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y_train class distribution\n",
      "False    0.555875\n",
      "True     0.444125\n",
      "Name: isCancelled, dtype: float64\n",
      "y_test class distribution\n",
      "False    0.556347\n",
      "True     0.443653\n",
      "Name: isCancelled, dtype: float64\n",
      "Number of features 37\n",
      "Best params for precision_score\n",
      "{'classifier__C': 3.58212724143124, 'classifier__penalty': 'l2'}\n",
      "\n",
      "Confusion matrix for precision_score on the test data:\n",
      "     pred_neg  pred_pos\n",
      "neg       676       183\n",
      "pos       163       522\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "      False       0.81      0.79      0.80       859\n",
      "       True       0.74      0.76      0.75       685\n",
      "\n",
      "avg / total       0.78      0.78      0.78      1544\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\nathan\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\validation.py:475: DataConversionWarning: Data with input dtype object was converted to float64 by StandardScaler.\n",
      "  warnings.warn(msg, DataConversionWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "oneHotDataFrame = getOneHotEncodeData(dataFrame)\n",
    "X_train, X_test, y_train, y_test = getTrainTestSplit(oneHotDataFrame)\n",
    "C = uniform(loc=0, scale=4).rvs(10)\n",
    "refitScore = 'precision_score'\n",
    "param_grid = [\n",
    "    {\n",
    "        'classifier__C': C,\n",
    "        'classifier__penalty':['l1', 'l2']\n",
    "    }\n",
    "]\n",
    "\n",
    "transformPipeline = Pipeline([\n",
    "    ('Initial drop cols', DFTransform(lambda X: X.drop([customerIdKey,'firstInvoiceDate'], axis=1))),\n",
    "    ('Remove catagorical', DFTransform(lambda X: X.select_dtypes(exclude=['object']))),\n",
    "])\n",
    "clfPipeline = Pipeline([\n",
    "    ('scaler',StandardScaler()),\n",
    "    ('classifier', LogisticRegression())\n",
    "])\n",
    "\n",
    "transformedDfX_test = transformPipeline.transform(X_train)\n",
    "bestModel = GridSearchCVOnPipeline(transformedDfX_test, y_train, clfPipeline, param_grid, refitScore)\n",
    "\n",
    "transformedDfX_test = transformPipeline.transform(X_test)\n",
    "BestModelScore(transformedDfX_test, y_test, bestModel, refitScore)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Remove Skew on amount columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y_train class distribution\n",
      "False    0.555875\n",
      "True     0.444125\n",
      "Name: isCancelled, dtype: float64\n",
      "y_test class distribution\n",
      "False    0.556347\n",
      "True     0.443653\n",
      "Name: isCancelled, dtype: float64\n",
      "Number of features 37\n",
      "Best params for precision_score\n",
      "{'classifier__C': 1.6877276410267883, 'classifier__penalty': 'l2'}\n",
      "\n",
      "Confusion matrix for precision_score on the test data:\n",
      "     pred_neg  pred_pos\n",
      "neg       715       144\n",
      "pos       176       509\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "      False       0.80      0.83      0.82       859\n",
      "       True       0.78      0.74      0.76       685\n",
      "\n",
      "avg / total       0.79      0.79      0.79      1544\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\nathan\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\validation.py:475: DataConversionWarning: Data with input dtype object was converted to float64 by StandardScaler.\n",
      "  warnings.warn(msg, DataConversionWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "oneHotDataFrame = getOneHotEncodeData(dataFrame)\n",
    "X_train, X_test, y_train, y_test = getTrainTestSplit(oneHotDataFrame)\n",
    "C = uniform(loc=0, scale=4).rvs(10)\n",
    "refitScore = 'precision_score'\n",
    "param_grid = [\n",
    "    {\n",
    "        'classifier__C': C,\n",
    "        'classifier__penalty':['l1', 'l2']\n",
    "    }\n",
    "]\n",
    "\n",
    "transformPipeline = Pipeline([\n",
    "    ('Initial drop cols', DFTransform(lambda X: X.drop([customerIdKey,'firstInvoiceDate'], axis=1))),\n",
    "    ('Remove catagorical', DFTransform(lambda X: X.select_dtypes(exclude=['object']))),\n",
    "    ('Remove skew value cols',DFTransform(RemoveSkew))\n",
    "])\n",
    "clfPipeline = Pipeline([\n",
    "    ('scaler',StandardScaler()),\n",
    "    ('classifier', LogisticRegression())\n",
    "])\n",
    "\n",
    "transformedDfX_test = transformPipeline.transform(X_train)\n",
    "bestModel = GridSearchCVOnPipeline(transformedDfX_test, y_train, clfPipeline, param_grid, refitScore)\n",
    "\n",
    "transformedDfX_test = transformPipeline.transform(X_test)\n",
    "BestModelScore(transformedDfX_test, y_test, bestModel, refitScore)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PCA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y_train class distribution\n",
      "False    0.555875\n",
      "True     0.444125\n",
      "Name: isCancelled, dtype: float64\n",
      "y_test class distribution\n",
      "False    0.556347\n",
      "True     0.443653\n",
      "Name: isCancelled, dtype: float64\n",
      "Number of features 37\n",
      "Best params for precision_score\n",
      "{'classifier__C': 3.3821016284384915, 'classifier__penalty': 'l2', 'reduceDimensions__n_components': None, 'reduceDimensions__whiten': False}\n",
      "\n",
      "Confusion matrix for precision_score on the test data:\n",
      "     pred_neg  pred_pos\n",
      "neg       717       142\n",
      "pos       175       510\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "      False       0.80      0.83      0.82       859\n",
      "       True       0.78      0.74      0.76       685\n",
      "\n",
      "avg / total       0.79      0.79      0.79      1544\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkwAAAHHCAYAAABN+wdFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XtUVXX+//HXkQOIIhoK4oXU1LTR8jqZlpiOdzMVuzjeqKbGHMXUb0xeyEbKUck009GpNCU1ywylHMOcGp28lNcupmmmIiJxyQuicjtn//5oeX4RwrZpw4HD89Haa3E+e7P3e68W+Ob9/uzPthmGYQgAAADFquLuAAAAAMo7EiYAAAATJEwAAAAmSJgAAABMkDABAACYIGECAAAwQcIEAABggoQJAADABAkTAACACRImAAAAEyRMAAAAJkiYAAAATNjdHUBZy8884e4QgErJr35Xd4cAVFoFeSllej0r/631rnOLZef6LagwAQAAmKh0FSYAAFDKnA53R2A5EiYAAGAtw+nuCCxHSw4AAMAEFSYAAGAtp+dVmEiYAACApQwPbMmRMAEAgArv3Xff1erVq12fz5w5o0GDBqlnz56aPXu2cnNz1a9fP02aNEmSdOTIEU2fPl2XL19Wx44dNXPmTNntxadFzGECAADWcjqt227Qgw8+qISEBCUkJGjevHmqXbu2nnjiCU2bNk1LlizR5s2bdejQIW3fvl2SFBUVpRkzZmjLli0yDEPr1q0r8fwkTAAAwFqG07rtf/C3v/1NkyZNUnJysho1aqTQ0FDZ7XYNHDhQiYmJSklJUU5Ojtq2bStJCg8PV2JiYonnpCUHAADKraysLGVlZRUZDwgIUEBAQJHxXbt2KScnR/369dOmTZsUFBTk2hccHKy0tDSlp6cXGg8KClJaWlqJcZAwAQAAa1m4cGVcXJwWL15cZHz8+PGKjIwsMv7222/r0Ucf/SkMp1M2m821zzAM2Wy2YsdLQsIEAACsZeFTchERERoyZEiR8etVl/Ly8rR3717NmTNHkhQSEqKMjAzX/oyMDAUHBxcZz8zMVHBwcIlxkDABAIByq7jW2/UcPXpUjRs3VrVq1SRJbdq00cmTJ5WUlKSGDRtq06ZNGjp0qBo0aCBfX1/t379fHTp0UEJCgsLCwko8NwkTAACwlpsWrkxOTlZISIjrs6+vr+bMmaPIyEjl5uaqW7du6tu3ryRp3rx5io6OVnZ2tlq1aqXRo0eXeG6bYRhGqUZfzuRnnnB3CECl5Fe/q7tDACqtgryUMr1e7vefWXYu36Z3WXau34JlBQAAAEzQkgMAANbiXXIAAAAmPPBdcrTkAAAATFBhAgAA1rJw4crygoQJAABYi5YcAABA5UOFCQAAWIun5AAAAEzQkgMAAKh8qDABAABr0ZIDAAAomWF43rICtOQAAABMUGECAADW8sBJ3yRMAADAWh44h4mWHAAAgAkqTAAAwFq05AAAAEx44Mt3ackBAACYoMIEAACsRUsOAADABE/JAQAAVD5UmAAAgLVoyQEAAJigJQcAAFD5UGECAADW8sAKEwkTAACwlGGwcCUAAEClQ4UJAABYi5YcAACACQ9cVoCWHAAAgAkqTAAAwFq05AAAAEx4YEuOhAkAAFjLAytMzGECAAAwQYUJAABYi5YcAACACVpyAAAAlQ8VJgAAYC0PrDCRMAEAAGt54BwmWnIAAAAmqDABAABr0ZIDAAAwQUsOAACg8qHCBAAArEVLDgAAwAQtOQAAgMqHChMAALAWLTkAAAATHpgw0ZIDAAAwQYUJAABYyzDcHYHlSJgAAIC1aMkBAABUPlSYAACAtTywwkTCBAAArMXClQAAAJUPFSYAAGAtWnIAAAAmPHBZAVpyAADAI3zyyScKDw9Xv3799MILL0iSdu3apYEDB6p3795asGCB69gjR44oPDxcffr00fTp01VQUFDiuUmYAACAtZxO67YblJycrOeee05LlizR+++/r8OHD2v79u2aNm2alixZos2bN+vQoUPavn27JCkqKkozZszQli1bZBiG1q1bV+L5SZgAAIC1LEyYsrKydObMmSJbVlZWoUtu3bpV/fv3V0hIiLy9vbVgwQL5+fmpUaNGCg0Nld1u18CBA5WYmKiUlBTl5OSobdu2kqTw8HAlJiaWeEvMYQIAAOVWXFycFi9eXGR8/PjxioyMdH1OSkqSt7e3nnzySaWmpuree+9V8+bNFRQU5DomODhYaWlpSk9PLzQeFBSktLS0EuMgYQIAANaycB2miIgIDRkypMh4QEBAoc8Oh0P79u3TqlWrVK1aNY0dO1ZVq1aVzWb7/2EZhmw2m5xO53XHS0LCBAAALGU4rXtKLiAgoEhydD116tRR586dFRgYKEnq2bOnEhMT5eXl5TomIyNDwcHBCgkJUUZGhms8MzNTwcHBJZ6fOUwAAKDC6969u3bs2KGsrCw5HA59+umn6tu3r06ePKmkpCQ5HA5t2rRJYWFhatCggXx9fbV//35JUkJCgsLCwko8PxUmAABgLTcsXNmmTRs9/vjjGj58uPLz83X33Xfrj3/8o2655RZFRkYqNzdX3bp1U9++fSVJ8+bNU3R0tLKzs9WqVSuNHj26xPPbDMMDV5cqQX7mCXeHAFRKfvW7ujsEoNIqyEsp0+tdWRppftANqjZ2kWXn+i1oyQEAAJigJQcAAKxl4aTv8oKECQAAWMsDX75LSw4AAMAEFSYAAGAtD6wwkTABAABreeAD+LTkAAAATJRawnTkyBH94Q9/UJs2bbR9+/Zij4uPjzddXROVQ8KH/9bQiHGurc8Dj6ht2H3KPHdekpSalqEeg0bq/IWLkqTvTyYVOn7IqLFqfXc/bd220523AVRYbyx/WZMnjSky/u6617Xw5Rdcn5s2bazEzWu1b+9H+urL/2jSxKLfg0rO6bRuKydKrSW3aNEiNW7cWHFxcapTp05pXQYeZFC/nhrUr6ckKb+gQI/8JUp/GvmQ6gTepIQP/60ly1crPfNH1/FNmzTSe3H/cH1+cdHrat60sXrde3eZxw5UZC1bNtOihX/XnXe206FDRwrte/r/xuqeuztp3bvvu8beWLZAcW+u0xsr1iogoIY+271ZX3xxSP/hjxVc44HLCpRahenSpUtq3bq1GjZsqKpVq5bWZeCh3lj9rgJvqqWHBvdXesaP+uS/u/Xq/BeKPX7/F4f00X92aEbU+DKMEvAMY598RMtXvKX1720qNN4trLP69O6u115fVWj8jRVrtfbtDZKkrKxL+v74Sd18c4Myixdwh1JJmHr06KE9e/bon//8p3r06KGDBw9q+PDhatOmjdq2bas//elPSktLu+73Lly4UF27dtXtt9+uhx9+WAcPHnTt++677zR69Gjdcccd6tWrl9544w1Vsje7VArnL1xU3Nvx+uuEP0uSgoNqa+HsZ9X45obFfs9L/1imCWMi5F+9elmFCXiMpyZG6+23NxYaq1evrubPj9GoiPFyOByF9sW9uU5Xr+ZIkvr0vledO3fUlo+2lVW4qAgMp3VbOVEqCdP69evVrl07RUREaM2aNRozZoy6dOmiTZs2afny5Tpz5oyWLl1a5Pu2bt2qNWvWaN68edq8ebN+97vfacKECXI6ncrJydHjjz+utm3b6v3331d0dLTi4uK0evXq0rgFuNG7CR+q+z13KbRBvRs6/uDXh3XuwkUN6HVv6QYGVBJ2u11rVv1DTz/9N/3wQ3qxx40c+YDiVi7Sw8PGlHgcKiGnYd1WTpTKHKbAwEB5e3vLz89PdrtdY8aM0WOPPSabzabQ0FD17t27UOXompSUFNntdtWvX1+hoaH6v//7P/Xu3VtOp1MffPCBatasqcmTJ0uSGjdurIkTJ+of//iHRo0aVRq3ATdJ/OS/mjrxyRs//uP/6v5+PVWlCg99Albo2KGNmjRppBdffE6SFFI3SF5eXqpa1VdjnoySJL04d4bCwweoT79h+vLLb9wZLlAmSn0dpqCgIA0ZMkQrV67UkSNHdPz4cR09elR33HFHkWMHDhyo+Ph49erVS7fffrt69OihBx54QHa7XSdOnNDx48fVrl071/FOp1N5eXnKy8uTj49Pad8KysDFrEtKPnNWbW//3Q1/z76DX2v65LGlGBVQuXz2+X41afp71+cZz05W7dqBempitCRp7uxo3dO1kzp17qfMzHPuChPlmFGOnm6zSqknTGlpaRo6dKhuu+023XPPPXrooYe0bds27d+/v8ixtWvXVnx8vHbv3q3t27frnXfe0Zo1a/Tee++poKBAd955p2bOnFn0Juysv+kpTqecVZ3agfL+Ff9PT59JUf16dUsxKgDXNGhQTxMn/lmnT6co8cO3XeOLFi1T3Jvr3BgZypVy1EqzSqlnGlu3blX16tX1+uuvu8ZWrVp13cna27ZtU0pKikaMGKGuXbvq6aefVufOnbV//341adJEW7duVYMGDVwJUmJionbs2KEXXij+6SlULLff1kIfrnuj2P2Hdn5YZGzvxxuvcySAX+tPj0+67njM8/NdX6ekpMrX7+ayCgkoN0p90ketWrWUnp6unTt3Kjk5Wa+99po++ugj5eXlFTnW6XQqNjZWiYmJOnPmjD744APl5eWpZcuWuv/++5WXl6fo6Gh9//332rlzp2JiYlSzZs3SvgUAAPBreOBTcqVeYerXr5/27t2riRMnSpJuv/12TZ06VQsWLFBOTk6hY3v06KGJEycqNjZW6enpuvnmm/XSSy/plltukSQtW7ZMs2fP1pAhQxQQEKAhQ4Zo0qTr/0UEAADcxANbcjajki1klJ95wt0hAJWSX/2u7g4BqLQK8lLK9HqXY0ZYdq7qM9ZYdq7fgtnSAADAWjwlBwAAYMIDW3IkTAAAwFrlaLK2VVgaGQAAwAQVJgAAYC1acgAAACXzxFej0JIDAAAwQYUJAABYi5YcAACACQ9MmGjJAQAAmKDCBAAArOWB6zCRMAEAAGvRkgMAAKh8qDABAABLGR5YYSJhAgAA1vLAhImWHAAAgAkqTAAAwFoe+GoUEiYAAGAtWnIAAACVDxUmAABgLQ+sMJEwAQAASxmG5yVMtOQAAABMUGECAADWoiUHAABgwgMTJlpyAAAAJqgwAQAAS/EuOQAAADMemDDRkgMAADBBhQkAAFjL814lR8IEAACs5YlzmGjJAQAAmKDCBAAArOWBFSYSJgAAYC0PnMNESw4AAMAEFSYAAGApT5z0TcIEAACsRUsOAACg8qHCBAAALEVLDgAAwIybWnKjRo3SuXPnZLf/lN7ExMTo9OnTWrp0qQoKChQREaERI0ZIknbt2qXZs2crNzdX/fr106RJk0o8NwkTAACo8AzD0KlTp/Sf//zHlTClpaVp0qRJio+Pl4+Pj4YNG6ZOnTqpYcOGmjZtmlatWqV69eppzJgx2r59u7p161bs+UmYAACApQw3VJhOnDghSXrsscd04cIFPfTQQ6pevbruuusu1apVS5LUp08fJSYm6s4771SjRo0UGhoqSRo4cKASExNJmAAAQBmyMGHKyspSVlZWkfGAgAAFBAQUOq5z58569tlnlZ+fr9GjR6tfv34KCgpyHRMcHKyvvvpK6enpRcbT0tJKjIOECQAAlFtxcXFavHhxkfHx48crMjLS9bldu3Zq166d6/MDDzyg2bNna+zYsa4xwzBks9nkdDpls9mKjJeEhAkAAFjKypZcRESEhgwZUmT859UlSdq3b5/y8/PVuXPnn2IwDDVo0EAZGRmuYzIyMhQcHKyQkJDrjpeEdZgAAIC1nNZtAQEBatiwYZHtlwnTpUuXFBsbq9zcXGVnZ2vDhg168cUXtXv3bp07d05Xr17VRx99pLCwMLVp00YnT55UUlKSHA6HNm3apLCwsBJviQoTAACo8Lp3764vv/xSgwcPltPp1PDhw9WhQwdNmjRJo0ePVn5+vh544AHdcccdkqQ5c+YoMjJSubm56tatm/r27Vvi+W2GYXje6lIlyM884e4QgErJr35Xd4cAVFoFeSller2MXsU/bfZrBW3dbtm5fgsqTAAAwFLuWFagtDGHCQAAwAQVJgAAYClPrDCRMAEAAGsZJa9pVBHRkgMAADBBhQkAAFiKlhwAAIAJw0lLDgAAoNKhwgQAACxFSw4AAMCE4YFPyZEwAQAAS3lihYk5TAAAACaoMAEAAEt54lNyJEwAAMBShuHuCKxHSw4AAMAEFSYAAGCpStWSe+GFF0r8xujoaMuDAQAAFV+lSphq1apVlnEAAACUW8UmTOPHj3d9nZOTo6SkJDVv3ly5ubny8/Mrk+AAAEDFUyknfX/55Zfq2bOnxowZo/T0dN177706cOBAWcQGAAAqIMNps2wrL0wTprlz52rlypWqVauWQkJCFBsbq1mzZpVFbAAAAOWCacKUk5OjZs2auT5369ZNDoejVIMCAAAVl2HYLNvKC9NlBex2uy5evCib7aegT5w4UepBAQCAissT3yVnmjCNHTtWI0eOVEZGhiZPnqydO3cqJiamLGIDAAAoF0wTpu7du+uWW27Rzp075XQ6NW7cODVt2rQsYgMAABWQsxy10qxyQyt9FxQUyOl0ym63y25ncXAAAFC88jT3yCqmk77fe+89jR49Wl9//bX27dunESNGaMuWLWURGwAAQLlgWi5auXKlNmzYoODgYEnS2bNnNWbMGPXp06fUgwMAABVPeVo/ySqmCZO3t7crWZKk+vXry9vbu1SDAgAAFZcnrvRdbML0zTffSJJatGihmJgYPfzww/Ly8lJ8fLzat29fZgECAAC4W7EJU2RkZKHP27Ztc31ts9kUHR1dakEBAICKq1K15D755JOyjAMAAHiISrmswLlz5/T+++/r8uXLMgxDTqdTSUlJeumll8oiPgAAALczTZgmTpyoqlWr6vjx4+rSpYt27dqlDh06lEVsAACgAqqU6zCdPXtWr732msLCwjRy5EitXbuW98kBAIBiGYZ1W3lhmjDVqVNHktS4cWMdO3ZMdevWVUFBQakHBgAAUF6YtuRq166tZcuWqW3btlq0aJH8/f2Vk5NTFrEBAIAKyBMnfZtWmGJiYuTj46OOHTuqdevWeuWVV/T000+XRWwAAKACMgybZVt5YTOM8tQhLH35mcy/AtzBr35Xd4cAVFoFeSller2DNw+y7FztTidYdq7fotiWXLt27WSzFZ/ZHThwoFQCAgAAFZsnlmKKTZg2bdpUlnEAAAAP4YlzmIpNmBo0aFCWcZSZhk37uzsEoFLKGNjc3SEAwP/M9Ck5AACAX6M8Tda2CgkTAACwlCe25EyXFZCknJwcHT16VIZh6OrVq6UdEwAAQLlimjB98cUX6tmzp8aMGaO0tDTde++9PCEHAACKZVi4lRemCVNsbKxWrlypWrVqKSQkRLGxsZo1a1ZZxAYAACogp2GzbCsvTBOmnJwcNWvWzPW5W7ducjgcpRoUAABAeWI66dtut+vixYuuRSxPnGClbAAAULxK+ZTc2LFjNXLkSGVmZmry5MnauXOnYmJiyiI2AABQATndHUApME2YunfvrltuuUU7d+6U0+nUuHHj1LRp07KIDQAAoFwwTZguXLigmjVrqn///oXGatWqVaqBAQCAislQJWzJ3XXXXUVewhsUFKT//ve/pRYUAACouJzlaT0Ai5gmTN9++63r67y8PG3atEknT54s1aAAAADKkxta6fsaHx8fhYeHa+fOnaUVDwAAqOCcslm2lRc3NIfpGsMwdOjQIWVlZZVqUAAAoOKq1HOYDOOnhmTt2rU1ffr0Ug8MAACgvDBNmNavX6/WrVuXRSwAAMADuHMdprlz5+r8+fOaM2eOjhw5ounTp+vy5cvq2LGjZs6cKbvdrrNnzyoqKko//vijmjRponnz5ql69eolntd0DlNUVJRlNwEAADyfIZtl26+xe/dubdiwwfU5KipKM2bM0JYtW2QYhtatWydJmjlzpoYPH67ExES1bt1aS5YsMT23acLUokULffDBBzp79qwuXLjg2gAAAMqLCxcuaMGCBXryySclSSkpKcrJyVHbtm0lSeHh4UpMTFR+fr727t2rPn36FBo3Y9qS+/jjj4ucyGaz6ciRI7/6ZgAAgOezsiWXlZV13YfNAgICFBAQ4Po8Y8YMTZo0SampqZKk9PR0BQUFufYHBQUpLS1N58+fl7+/v+x2e6FxM8UmTHl5efLx8dHXX39943cFAAAqPSsTpri4OC1evLjI+Pjx4xUZGSlJevfdd1WvXj117txZ8fHxP8XgdBZaeNswDNdDbL9ckPuXn6+n2ITp4YcfLtQHBAAAKGsREREaMmRIkfGfV5c2b96sjIwMDRo0SBcvXtSVK1dks9mUkZHhOiYzM1PBwcEKDAzUpUuX5HA45OXlpYyMDAUHB5vGUWzCdG0ZAQAAgF/DynWYftl6u54VK1a4vo6Pj9eePXs0e/Zs3Xfffdq/f786dOighIQEhYWFydvbWx07dtTmzZs1cOBAbdy4UWFhYaZxFJsw5ebm6vDhw8UmTq1atTI9OQAAqHyc5WTdynnz5ik6OlrZ2dlq1aqVRo8eLUl67rnnNGXKFC1dulT16tXT/PnzTc9lM4rJiFq3bq26deteN2Gy2Wz6+OOPf+NtuEfdmi3dHQJQKX3bM8TdIQCV1k3vbSvT6yWEDLfsXIN+eMuyc/0WxVaYmjVrpo0bN5ZlLAAAAOWS6bICAAAAv4YnzoIuNmHq2LFjWcYBAAA8hDtfjVJail3pOzo6uizjAAAAKLdoyQEAAEs5b2AhyIqGhAkAAFjKE+cwmb58FwAAoLKjwgQAACzliZO+SZgAAIClystK31aiJQcAAGCCChMAALCU08KX75YXJEwAAMBSPCUHAABQCVFhAgAAlvLESd8kTAAAwFKeuKwALTkAAAATVJgAAIClPHHSNwkTAACwlCfOYaIlBwAAYIIKEwAAsJQnTvomYQIAAJbyxISJlhwAAIAJKkwAAMBShgdO+iZhAgAAlqIlBwAAUAlRYQIAAJbyxAoTCRMAALCUJ670TUsOAADABBUmAABgKU98NQoJEwAAsJQnzmGiJQcAAGCCChMAALCUJ1aYSJgAAICleEoOAACgEqLCBAAALMVTcgAAACY8cQ4TLTkAAAATVJgAAIClPHHSNwkTAACwlNMDUyZacgAAACaoMAEAAEt54qRvEiYAAGApz2vI0ZIDAAAwRYUJAABYipYcAACACU9c6ZuWHAAAgAkqTAAAwFKeuA4TCRMAALCU56VLtOQAAABMUWECAACW4ik5AAAAE8xhAgAAMOF56RJzmAAAAExRYQIAAJZiDhMAAIAJT5zDREsOAADABBUmAABgKc+rL1FhAgAAFnNauP0aCxcuVP/+/TVgwACtWLFCkrRr1y4NHDhQvXv31oIFC1zHHjlyROHh4erTp4+mT5+ugoKCEs9NwgQAACq8PXv26LPPPtP777+v9957T6tWrdK3336radOmacmSJdq8ebMOHTqk7du3S5KioqI0Y8YMbdmyRYZhaN26dSWen4QJAABYyrDwvxt155136s0335TdbtePP/4oh8OhrKwsNWrUSKGhobLb7Ro4cKASExOVkpKinJwctW3bVpIUHh6uxMTEEs/PHCYAAGApK5cVyMrKUlZWVpHxgIAABQQEFBrz9vbWK6+8ojfeeEN9+/ZVenq6goKCXPuDg4OVlpZWZDwoKEhpaWklxkGFCQAAlFtxcXH6wx/+UGSLi4u77vETJkzQ7t27lZqaqlOnTslms7n2GYYhm80mp9N53fGSUGECAACWsnIdpoiICA0ZMqTI+C+rS99//73y8vJ02223yc/PT71791ZiYqK8vLxcx2RkZCg4OFghISHKyMhwjWdmZio4OLjEOKgwAQAASxkWbgEBAWrYsGGR7ZcJ05kzZxQdHa28vDzl5eXp448/1rBhw3Ty5EklJSXJ4XBo06ZNCgsLU4MGDeTr66v9+/dLkhISEhQWFlbiPVFhAgAAFV63bt301VdfafDgwfLy8lLv3r01YMAABQYGKjIyUrm5uerWrZv69u0rSZo3b56io6OVnZ2tVq1aafTo0SWe32YYRpmuL3XkyBFdvnxZHTt2LMvLutSt2dIt1wUqu297hrg7BKDSuum9bWV6vTGNH7TsXK+eeteyc/0WZV5hGjdunMaOHeu2hAnl3ytL5+jI4WNauugNLXtzoZo0udm17+ZGDbV7516N/uNf1Ltvd73yz9lKSU517b+/30hdzr7sjrCBCs0vYqx8Ot8rZ/YlSZLz7Gldnh8jSbJV85f/Cwt15R+xcnx/9KexgJqqHjlNVYLqSoahy/+cJ8fRb9wWP8oXXr4LlKLmt96iOS/NUPsOd+jI4WOSpMdHP+Xa37Z9ay2LW6gpT//0S/z3ndpp6aIVWvjSq26JF/Ak9hatlb0gpkjSY2/fSdUeGacqwYUrhNWemKiCI18pZ9YaeTVuJv9ps3Vx/EgpL7cswwbKTJlO+h41apRSUlIUHR2tHj16KCwsTDExMerQoYMWLVqkKVOm6Omnny70PS1atNCuXbskSXl5eZo1a5buuusuderUSU899ZQyMzPL8hZQih59YoTWxK3X+xu3FNnn7e2tV5bO0bNTZ+tsyg+SpI53ttM9YZ30yY6NSvhwte7qQtUS+J/YveXVpLmqDv6jAua/oepRM2Wr89MTQ1X7D9XlhbPkPH/u/x9fxUveHTor99+bJEmOU8flSE2Rd7s73RE9yiF3LFxZ2so0YVq0aJFCQkI0ZcoUTZs2TWlpacrOztaGDRuu+8jgL82fP19ffPGFXn31Va1atUqGYWjMmDEq42lYKCXTop5X/PpN1903fPRQpf2Qrg83/ds1dv78ecW98Y563DNYs2bO14o1i1Wvft2yChfwGFUCa6vg0AFdfWu5siY/poJjh+X/zCxJUvYLf3W14a6xBdSUbFVkZF10jTl/zFCV2kECJPe9S640lWnCVKtWLXl5ecnf3181atSQJD3++OO6+eab1bBhwxK/9+rVq1q9erVmzpypNm3a6NZbb1VsbKyOHz/ueiwQnmvMXx7Rghf/WWjssZETtCnhp2q97Vj+AAAVg0lEQVTUns8OaN/nB9Wt+93uCA+o0JzpPyh71hQ5k09KknIT3pFXSP0ibTgXm0365R+qNknO8vTPG2Att6/D1KBBgxs6Ljk5Wfn5+RoxYoTatWundu3aqXPnzsrNzdXJkydLOUq4U+s7bpPd7qVdO/a4xgJq1tBT/zem0HE2m035+fllHR5Q4Xk1ukU+3XoVHrTZZBQ4rnu8cfGCZLPJ5l/DNVYlsI6cP2Zc93hUPp7YknP7pG9fX1/X179clrygoMD1tcPx0w/uqlWrXNWpawIDA0sxQrhbl7t/rx3//azQWPaly3r08eE6/t1J/ev9j9T6jtvUrsPtmjB2ipuiBCouw2nI77EJKjjytZzpP8i3zyA5kr6Xca6YBMjpUP6B3fLpNVC5G96SV6Nb5NWwkfK/+aJsA0e55Ym1RrcnTD/n7e2t8+fPuz4nJye7vg4NDZWXl5fOnz+v1q1bS5IuXbqkqKgoTZw4US1bsr6Sp2rStJGSk1IKjTmdTkUMH6e/x0brr1PHq6DAoT8/Olnnzl1wU5RAxeVMPqmry1+R/9TZUpUqcv6YoewFz5f4PVdee1nV/hIl3wUrflpW4JW/S1dY0gOeq8wTpurVq+vEiROqWbNmkX233367Zs6cqR07dqhu3bqaM2eOfHx8JEn+/v568MEH9fzzz2vmzJkKDg7WSy+9pGPHjqlx48ZlfBcoTU/9ZWqhz1Ofvv4v7i8PHtKAXsPKIiTA4+X9d6vy/ru12P1ZYwv/rBkXz+vy7GmlHRYqKKcHPoxV5gnTiBEjNHfuXMXHxxfZN2jQIB04cECRkZHy9/fXhAkTdPr0adf+qVOnKjY2VpMmTVJubq7at2+v5cuXq2rVqmV5CwAAoASely654dUo7sarUQD34NUogPuU9atRRjYKt+xcq5OKFljcoVzNYQIAABWf0wNrTCRMAADAUuVpOQCruH0dJgAAgPKOChMAALAU6zABAACY8MQ5TLTkAAAATFBhAgAAlvLESd8kTAAAwFKeOIeJlhwAAIAJKkwAAMBSnvgSERImAABgKZ6SAwAAqISoMAEAAEt54qRvEiYAAGApT1xWgJYcAACACSpMAADAUp446ZuECQAAWMoTlxWgJQcAAGCCChMAALAUT8kBAACY4Ck5AACASogKEwAAsBRPyQEAAJjgKTkAAIBKiAoTAACwFC05AAAAEzwlBwAAUAlRYQIAAJZyeuCkbxImAABgKc9Ll0iYAACAxTxx0jdzmAAAAExQYQIAAJbyxAoTCRMAALAUK30DAABUQlSYAACApWjJAQAAmGClbwAAgEqIChMAALCUJ076JmECAACW8sQ5TLTkAAAATFBhAgAAlqIlBwAAYIKWHAAAQCVEhQkAAFjKE9dhImECAACWcnrgHCZacgAAACZImAAAgKUMC/+7UYsXL9aAAQM0YMAAxcbGSpJ27dqlgQMHqnfv3lqwYIHr2CNHjig8PFx9+vTR9OnTVVBQYHp+EiYAAGApp2FYtt2IXbt2aceOHdqwYYM2btyob775Rps2bdK0adO0ZMkSbd68WYcOHdL27dslSVFRUZoxY4a2bNkiwzC0bt0602uQMAEAgAotKChIU6ZMkY+Pj7y9vdW0aVOdOnVKjRo1UmhoqOx2uwYOHKjExESlpKQoJydHbdu2lSSFh4crMTHR9BpM+gYAAJay8im5rKwsZWVlFRkPCAhQQECAJKl58+au8VOnTunDDz/UyJEjFRQU5BoPDg5WWlqa0tPTC40HBQUpLS3NNA4SJgAAYCkrn5KLi4vT4sWLi4yPHz9ekZGRhca+++47jRkzRn/961/l5eWlU6dOufYZhiGbzSan0ymbzVZk3AwJEwAAKLciIiI0ZMiQIuPXqkvX7N+/XxMmTNC0adM0YMAA7dmzRxkZGa79GRkZCg4OVkhISKHxzMxMBQcHm8ZBwgQAACxlZUvu56234qSmpmrcuHFasGCBOnfuLElq06aNTp48qaSkJDVs2FCbNm3S0KFD1aBBA/n6+mr//v3q0KGDEhISFBYWZhoHCRMAALBUWS9cuXz5cuXm5mrOnDmusWHDhmnOnDmKjIxUbm6uunXrpr59+0qS5s2bp+joaGVnZ6tVq1YaPXq06TVshie+UrgEdWu2dHcIQKX0bc8Qd4cAVFo3vbetTK/XtE57y871feYBy871W1BhAgAAluJdcgAAACYMw+nuECzHwpUAAAAmqDABAABLOWnJAQAAlMwTnyejJQcAAGCCChMAALAULTkAAAATtOQAAAAqISpMAADAUmX9apSyQMIEAAAs5YkrfdOSAwAAMEGFCQAAWMoTJ32TMAEAAEt54rICtOQAAABMUGECAACWoiUHAABgwhOXFaAlBwAAYIIKEwAAsBQtOQAAABM8JQcAAFAJUWECAACWoiUHAABggqfkAAAAKiEqTAAAwFKGB076JmECAACWoiUHAABQCVFhAgAAluIpOQAAABPMYQIAADDhiRUm5jABAACYoMIEAAAs5YkVJhImAABgKc9LlySb4YlpIAAAgIWYwwQAAGCChAkAAMAECRMAAIAJEiYAAAATJEwAAAAmSJgAAABMkDABAACYIGECAAAwQcIEAABggoQJAADABAkTAACACRImAAAAEyRMcLtr73/mPdBA2fr5z5zT6XRjJED5R8IEt7n2yzo/P1+S5HA4JPGLGyht1372rv3MSVKVKvxzAJTE7u4AUDkZhiGbzaZPP/1UmzdvVkZGhm6++WY99NBDatmypbvDAzzWz3/21q9fr4sXLyo4OFiPPvqomjZtKh8fH3eHCJRL/EkBt7DZbNq2bZvGjRun+vXrq2vXrjp79qyGDBmizMxMSbTogNJgs9m0fft2TZgwQQ0aNNAjjzyiw4cPa/LkyUpOTnZ3eEC5RYUJbuFwOLRx40Y9+uijioyMVFpamlauXKlHHnlEly5dUkFBgUJCQtwdJuBRnE6n8vPztWHDBo0ePVqTJk1Sdna2rly5ovvvv192u12pqamqV6+eqxIF4CdUmFDmDMOQw+FQamqq2rZtq6tXr+rBBx/UPffco8mTJysxMVFLlixRXl4eVSbAQlWqVJGvr6+cTqeaN2+utLQ09evXT126dNHEiRP11ltvaf78+ZJEsgT8AgkTysTPEx+bzSYfHx+1adNGr776qnr16qVevXppxowZ8vb2Vlpamk6fPi0fHx9+aQMW+e6773Tu3DlJUtWqVfX2229r+PDh6tGjh/72t79JkgICApSamurGKIHyi4QJpe5aaX/v3r1avny5ZsyYIcMw9Ic//EGGYahWrVoaP368vL29Jf2UUAUHBys/P58KE/AbGYahS5cuafDgwZo1a5YcDoeioqL0448/yuFwaObMmbLbf5qdkZKSojp16hR6eg7AT2wG/yKhlBQUFLh+EW/ZskXPPPOMunTpIh8fHz3zzDOqV6+eNm7cqA0bNujChQvq0qWLfvjhB23fvl1vv/22br31VjffAeA59u3bpyeeeEJ9+/bVtGnTdPToUY0fP15NmjRRkyZNVFBQoI8//lhr167lZw+4DhImWC4hIUG9evVStWrV5HQ6lZqaqj//+c964oknNHjwYF29elWpqak6evSomjVrptTUVH3++ef69ttvFRISokceeUTNmzd3920AFV5aWprq1q3r+nzw4EGNGjVK4eHh+utf/6qrV69q0aJFunz5svz8/BQREcHPHlAMEiZYKiUlRX/+858VEBCgFStWqGrVqvr+++/15JNP6u9//7saN26suXPn6quvvlJKSorq1q2refPmqX379iooKFCVKlVYQA+wwLFjxzR37lz16tVLw4YNc43v379fERERGjx4sJ599ln5+vpKKlwRBlAU/zLBUiEhIYqOjpaXl5cef/xxXblyRU2bNlVoaKgmTZqk7t27KyUlRcOGDdM333yjOnXqaOPGjZIku91OsgT8j37+t+++ffu0bds21axZU1u3blV8fLxrX4cOHTR37lxt3LhRsbGxSktLkyR5eXmVecxARcKfE7CMYRjy8vJSp06dJEkLFy7UmDFjtHz5csXExOjTTz9VjRo11K1bN9WoUUOSdPPNNxdqGQD4dXJyclS1alXXE6Xfffedxo0bp0WLFql79+5asWKFEhISZBiGhg4dKkmqVauWWrRooa+++qrQwxYAikdLDqXC4XDowIEDmjt3rvz9/bV06VL5+fkpOztbW7duVdWqVXXo0CG98847euedd9S0aVN3hwxUOIZhaPPmzQoNDdUdd9yhPXv26NVXX1WdOnU0Z84c2Ww2JSUl6bXXXtPZs2fVs2dPPfjgg1q6dKmcTqeeeOIJ+fv7u/s2gAqBhAmWuLZ0wJEjR5SRkaHAwEC1bt1aBw4c0OzZs+Xr66tly5YpOztb8+bN0969e1W/fn1NmzZNt912m7vDByqk7OxsPfroowoNDVXr1q21evVqXb58Wf7+/vrXv/6lqlWrSpKSkpL0xhtv6N///re8vb2VnZ2tN998U7/73e/cfAdAxUHChP/Z7t271aJFCwUGBkqSEhMTNWPGDPn6+iowMFCDBg3SY489pv3792vu3Lny8/PT66+/Lh8fH2VkZMjPz4+/boHfKDMzUw899JDOnj2r8ePH6+6779b48ePVqVMn16rdknTu3DmdOnVKp0+fVocOHRQaGurGqIGKhxm2+J8sWLBAUVFRromin332maZOnaqoqCi99dZbuuuuu7Rs2TKtXLlSHTp00JQpU5Sbm6uHHnpIV69eVVBQEMkSYIGAgAB5e3srKChIp0+flpeXl2JjY7Vr1y5FRUW5jgsMDFT79u01ePBgkiXgf0DChF8tPz9f3377rbp3766aNWsqNzdXycnJGjBggB588EEFBgZq7969atKkid5//32tXLlS7du31+TJk3XTTTe5Xs8A4Lfz8fFRQkKC1q5dq6+//lorVqxQjRo1NG/ePH366ad65pln3B0i4BG8/nbtJULADXI6ndq3b5/Onj2rb7/9Vn//+991/vx55eXlqX///nr55ZcVHBysyZMn6/jx41q/fr0yMzM1bNgw9evXTzfddJO7bwHwKHa7XQEBAbrzzju1Zs0anTlzRp06dVKfPn00e/Zs5eXlqXPnzu4OE6jQqDDhV/P29tazzz6r8+fPKy4uTn369NErr7yioUOH6tixYzp27Jg6duyoRo0aqWnTpgoMDNSuXbv0ww8/uBbJA2C9W2+9VQsXLtTRo0e1ZMkSxcXFKTg4WP3793d3aECFR8KE/0l+fr6OHz+uZs2a6dixY9q2bZu6d++uw4cP67vvvlPfvn0l/fRqhh49emjdunUKCQlxc9SA52vevLkWLlyo6tWr69KlS3rttdfUsmVLd4cFVHg8JYf/WXZ2tvLy8jRlyhRJ0ogRI1S7dm1NmTJF7dq1k7e3tzZv3qw1a9awzhJQxnJzc2UYhmtpAQC/DQkTfrPk5GQ9//zzstls6tGjh65evapt27bJ4XBo+vTp/HULAKjwSJhgieTkZMXExMjf3189evTQwIEDdeXKFVWrVs3doQEA8JsxhwmWCA0N1YwZM/TDDz9o69atunr1KskSAMBjUGGCpVJSUlSlShXVq1fP3aEAAGAZEiYAAAATtOQAAABMkDABAACYIGECAAAwQcIEAABggoQJAADABAkT4EHOnDmj2267TYMGDXJt999/v9avX/+bzz1mzBjFx8dLkgYNGqSsrKxij7106ZJGjx79q6+RmJioUaNGFRn//PPPdd9995l+f4sWLXTu3Llfdc0pU6Zo+fLlv+p7AFQ+dncHAMBaVatWVUJCgutzWlqa7rvvPrVu3dqy19T8/PzXc/HiRX399deWXAsAygMSJsDD1a1bV40aNdKpU6d0+PBhrV+/XlevXpW/v79WrVqld999V2vXrpXT6VStWrX07LPPqmnTpkpLS9OUKVOUnp6u+vXr68cff3Sds0WLFtq9e7cCAwP16quvasOGDbLb7WrUqJHmzJmjqVOnKicnR4MGDVJ8fLxOnTqlWbNm6cKFC3I4HBo1apQeeOABSdLChQv1wQcfqFatWmrUqJHp/Zw8eVIxMTG6fPmyMjIy1LJlS7388svy9fWVJL388sv6+uuv5XQ6NXHiRHXv3l2Sir1PALgRJEyAhzt48KBOnz6tNm3aaPfu3Tp+/Lg++eQT+fv7a8+ePdq4caPWrFkjPz8/7dixQ+PHj9eHH36omJgYtWnTRhMnTlRSUpIGDx5c5Nwff/yx4uPjtW7dOtWsWVOzZ8/W6tWrNXv2bA0cOFAJCQkqKCjQhAkTFBsbq1atWunSpUt6+OGH1axZM2VmZuqjjz7Sxo0bVbVqVY0bN870ftatW6fBgwdr0KBBys/PV3h4uLZt26Y+ffpIkho2bKiYmBgdO3ZMo0aN0ocffqjjx48Xe58AcCNImAAPc62yI0kOh0M33XSTXnzxRdfralq0aCF/f39J0rZt25SUlKRhw4a5vj8rK0sXLlzQrl279Mwzz0iSGjVqpE6dOhW51u7du9W3b1/VrFlTkjR16lRJP82luubUqVM6ffq0pk2bVijGw4cP6/vvv1evXr1c8QwdOlSrVq0q8f6ioqK0c+dOvf766zp16pTS09N15coV1/4//vGPkqRbb71VTZs21cGDB7V///5i7xMAbgQJE+BhfjmH6Zd+/lJkp9OpQYMGKSoqyvU5PT1dNWvWlM1m08/fnGS3F/114eXlJZvN5vqclZVVZDK4w+FQjRo1CsWUmZmpGjVqKDY2ttA1vLy8TO9v8uTJcjgc6tevn+69916lpqYWOkeVKv//WRan0ym73V7ifQLAjeApOaASu+eee/Svf/1L6enpkqS1a9cqIiJCktS1a1e98847kqSzZ8/q888/L/L9Xbp00datW5WdnS1JWrRokVauXCm73S6HwyHDMNSkSZNCSVxqaqruu+8+HTp0SGFhYUpMTFRWVpacTqfpZHJJ2rFjh8aNG6f+/ftLkr788ks5HA7X/g0bNkiSvvnmG1crsqT7BIAbQYUJqMTuuecePfHEE3rsscdks9nk7++vxYsXy2az6bnnntPUqVPVr18/hYSEXPcJu27duun48eOuNlizZs30/PPPy8/PT3fccYcGDBigNWvWaMmSJZo1a5aWLVumgoICPfXUU+rQoYMk6ejRoxo6dKgCAgLUsmVLnT9/vsSYJ02apHHjxqlatWry9/fX73//e50+fdq1Pzk5WYMHD5bNZtP8+fNVq1atEu8TAG6Ezfh5LRsAAABF0JIDAAAwQcIEAABggoQJAADABAkTAACACRImAAAAEyRMAAAAJkiYAAAATJAwAQAAmPh/XxQeDfZzx/gAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "oneHotDataFrame = getOneHotEncodeData(dataFrame)\n",
    "X_train, X_test, y_train, y_test = getTrainTestSplit(oneHotDataFrame)\n",
    "C = uniform(loc=0, scale=4).rvs(10)\n",
    "refitScore = 'precision_score'\n",
    "pca = decomposition.PCA(n_components=0.5, whiten=False)\n",
    "param_grid = [\n",
    "    {\n",
    "        'reduceDimensions__n_components': (0.5,0.6, 0.7, 0.8,0.9,None),\n",
    "        'reduceDimensions__whiten':(True,False),\n",
    "        'classifier__C': C,\n",
    "        'classifier__penalty':['l1', 'l2']\n",
    "    }\n",
    "]\n",
    "\n",
    "transformPipeline = Pipeline([\n",
    "    ('Initial drop cols', DFTransform(lambda X: X.drop([customerIdKey,'firstInvoiceDate'], axis=1))),\n",
    "    ('Remove catagorical', DFTransform(lambda X: X.select_dtypes(exclude=['object']))),\n",
    "    ('Remove skew value cols',DFTransform(RemoveSkew))\n",
    "])\n",
    "clfPipeline = Pipeline([\n",
    "    ('scaler',RobustScaler()),\n",
    "    ('reduceDimensions', pca),\n",
    "    ('classifier', LogisticRegression())\n",
    "])\n",
    "\n",
    "transformedDfX_test = transformPipeline.transform(X_train)\n",
    "bestModel = GridSearchCVOnPipeline(transformedDfX_test, y_train, clfPipeline, param_grid, refitScore)\n",
    "\n",
    "transformedDfX_test = transformPipeline.transform(X_test)\n",
    "BestModelScore(transformedDfX_test, y_test, bestModel, refitScore)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test classifiers - THIS IS SLOW!\n",
    "The output is:\n",
    "```\n",
    "{'classifier__activation': 'tanh', 'classifier__alpha': 1e-06, 'classifier__hidden_layer_sizes': 5, 'classifier__max_iter': 500, 'classifier__random_state': 3, 'classifier__solver': 'lbfgs'}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Only run this if you want to max out your CPU!\n",
    "oneHotDataFrame = getOneHotEncodeData(dataFrame)\n",
    "X_train, X_test, y_train, y_test = getTrainTestSplit(oneHotDataFrame)\n",
    "C = uniform(loc=0, scale=4).rvs(10)\n",
    "refitScore = 'precision_score'\n",
    "#pca = decomposition.PCA(n_components= None, whiten= True)\n",
    "n_features_to_test = np.arange(1, 11)\n",
    "reduceFeatures = (2,4, 6, 8,10,12,14,16,18,20,22,24,26,28,30)\n",
    "percentageFeatures = (0.5,0.6, 0.7, 0.8,0.9,None)\n",
    "alpha_to_test = 2.0**np.arange(-6, +6)\n",
    "lrPenatlies = ['l1', 'l2']\n",
    "scalersToTest = [StandardScaler(), RobustScaler(), QuantileTransformer()]\n",
    "classifiersToTest = [\n",
    "    KNeighborsClassifier(3),\n",
    "    SVC(kernel=\"linear\", C=0.025),\n",
    "    SVC(gamma=2, C=1),\n",
    "    GaussianProcessClassifier(1.0 * RBF(1.0)),\n",
    "    DecisionTreeClassifier(max_depth=5),\n",
    "    RandomForestClassifier(max_depth=5, n_estimators=10, max_features=30),\n",
    "    MLPClassifier(alpha=1),\n",
    "    AdaBoostClassifier(),\n",
    "    GaussianNB(),\n",
    "    QuadraticDiscriminantAnalysis()]\n",
    "\n",
    "param_grid = [\n",
    "    #'classifier__n_estimators': [10, 100, 1000], \n",
    "    #'classifier__max_features': [5, 10, 20],\n",
    "    #{\n",
    "        #'classifier':classifiersToTest,\n",
    "        #'scaler': scalersToTest,\n",
    "        #'reduceDimensions': [PCA()],\n",
    "        #'reduceDimensions__n_components': percentageFeatures,\n",
    "        #'reduceDimensions__whiten':(True,False)\n",
    "    #},\n",
    "    #{\n",
    "        #'classifier':classifiersToTest,\n",
    "        #'scaler': scalersToTest,\n",
    "        #'reduceDimensions': [SelectKBest(f_classif)], # ANOVA (f_classif) scoring\n",
    "        #'reduceDimensions__k': reduceFeatures\n",
    "    #}\n",
    "    {\n",
    "        'classifier__activation': [\"identity\", \"logistic\", \"tanh\", \"relu\"],\n",
    "        'classifier__solver': ['lbfgs'], \n",
    "        'classifier__max_iter': [500,1000,1500], \n",
    "        'classifier__alpha': 10.0 ** -np.arange(1, 7), \n",
    "        'classifier__hidden_layer_sizes':np.arange(5, 12), \n",
    "        'classifier__random_state':[0,1,2,3,4,5,6,7,8,9]\n",
    "    }\n",
    "]\n",
    "\n",
    "transformPipeline = Pipeline([\n",
    "    ('Initial drop cols', DFTransform(lambda X: X.drop([customerIdKey,'firstInvoiceDate'], axis=1))),\n",
    "    ('Remove catagorical', DFTransform(lambda X: X.select_dtypes(exclude=['object']))),\n",
    "    ('Remove skew value cols',DFTransform(RemoveSkew)),\n",
    "])\n",
    "clfPipeline = Pipeline([\n",
    "    ('scaler', RobustScaler()),\n",
    "    ('reduceDimensions', pca()),\n",
    "    #('feature_selection', SelectFromModel(LinearSVC(penalty=\"l1\"))),\n",
    "    #('classifier', RandomForestClassifier(n_estimators=1000))\n",
    "    ('classifier', MLPClassifier(alpha=1))\n",
    "])\n",
    "#MLPClassifier(alpha=1)\n",
    "\n",
    "transformedDfX_test = transformPipeline.transform(X_train)\n",
    "bestModel = GridSearchCVOnPipeline(transformedDfX_test, y_train, clfPipeline, param_grid, refitScore)\n",
    "\n",
    "transformedDfX_test = transformPipeline.transform(X_test)\n",
    "BestModelScore(transformedDfX_test, y_test, bestModel, refitScore)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using MLPClassifier for a NN, after some hyper parameter work (not slow)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y_train class distribution\n",
      "False    0.555875\n",
      "True     0.444125\n",
      "Name: isCancelled, dtype: float64\n",
      "y_test class distribution\n",
      "False    0.556347\n",
      "True     0.443653\n",
      "Name: isCancelled, dtype: float64\n",
      "Number of features 21\n",
      "Best params for precision_score\n",
      "{'classifier__activation': 'tanh', 'classifier__alpha': 1e-06, 'classifier__hidden_layer_sizes': 11, 'classifier__max_iter': 100, 'classifier__random_state': 3, 'classifier__solver': 'lbfgs'}\n",
      "\n",
      "Confusion matrix for precision_score on the test data:\n",
      "     pred_neg  pred_pos\n",
      "neg       760        99\n",
      "pos       184       501\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "      False       0.81      0.88      0.84       859\n",
      "       True       0.83      0.73      0.78       685\n",
      "\n",
      "avg / total       0.82      0.82      0.81      1544\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# after running the above overnight we get:\n",
    "#{'classifier__activation': 'tanh', 'classifier__alpha': 1e-06, 'classifier__hidden_layer_sizes': 5, 'classifier__max_iter': 500, 'classifier__random_state': 3, 'classifier__solver': 'lbfgs'}\n",
    "\n",
    "X_train, X_test, y_train, y_test = getTrainTestSplit(dataFrame)\n",
    "refitScore = 'precision_score'\n",
    "\n",
    "param_grid = [\n",
    "    {\n",
    "        'classifier__activation': [\"tanh\"],\n",
    "        'classifier__solver': ['lbfgs'], \n",
    "        'classifier__max_iter': [100,200,300,400,500], #200 giving a better score\n",
    "        'classifier__alpha': [1e-06], \n",
    "        'classifier__hidden_layer_sizes':[11], # changed from 5 after manual intervention\n",
    "        'classifier__random_state':[3]\n",
    "    }\n",
    "]\n",
    "\n",
    "transformPipeline = Pipeline([\n",
    "    ('Initial drop cols', DFTransform(lambda X: X.drop([customerIdKey,'firstInvoiceDate'], axis=1))),\n",
    "    ('Remove catagorical', DFTransform(lambda X: X.select_dtypes(exclude=['object']))),\n",
    "    ('Remove skew value cols',DFTransform(RemoveSkew)),\n",
    "])\n",
    "clfPipeline = Pipeline([\n",
    "    ('scaler', RobustScaler()),\n",
    "    ('reduceDimensions', PCA()),\n",
    "    ('classifier', MLPClassifier(alpha=1e-06))\n",
    "])\n",
    "\n",
    "transformedDfX_test = transformPipeline.transform(X_train)\n",
    "bestModel = GridSearchCVOnPipeline(transformedDfX_test, y_train, clfPipeline, param_grid, refitScore)\n",
    "\n",
    "transformedDfX_test = transformPipeline.transform(X_test)\n",
    "BestModelScore(transformedDfX_test, y_test, bestModel, refitScore)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Currently working on this section\n",
    "# Trying to improve the true -> false score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y_train class distribution\n",
      "False    0.555875\n",
      "True     0.444125\n",
      "Name: isCancelled, dtype: float64\n",
      "y_test class distribution\n",
      "False    0.556347\n",
      "True     0.443653\n",
      "Name: isCancelled, dtype: float64\n",
      "Number of features 21\n",
      "Best params for precision_score\n",
      "{'classifier__activation': 'tanh', 'classifier__alpha': 1e-06, 'classifier__hidden_layer_sizes': 11, 'classifier__max_iter': 100, 'classifier__random_state': 3, 'classifier__solver': 'lbfgs'}\n",
      "\n",
      "Confusion matrix for precision_score on the test data:\n",
      "     pred_neg  pred_pos\n",
      "neg       760        99\n",
      "pos       184       501\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "      False       0.81      0.88      0.84       859\n",
      "       True       0.83      0.73      0.78       685\n",
      "\n",
      "avg / total       0.82      0.82      0.81      1544\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_train, X_test, y_train, y_test = getTrainTestSplit(dataFrame)\n",
    "refitScore = 'precision_score'\n",
    "\n",
    "param_grid = [\n",
    "    {\n",
    "        'classifier__activation': [\"tanh\"],\n",
    "        'classifier__solver': ['lbfgs'], \n",
    "        'classifier__max_iter': [100], #after manual tweaking with the hidden layer size\n",
    "        'classifier__alpha': [1e-06], \n",
    "        'classifier__hidden_layer_sizes':[11], # changed from 5 after manual intervention\n",
    "        'classifier__random_state':[3]\n",
    "    }\n",
    "]\n",
    "#{'classifier__activation': 'tanh', 'classifier__alpha': 1e-06, 'classifier__hidden_layer_sizes': 5, 'classifier__max_iter': 500, 'classifier__random_state': 3, 'classifier__solver': 'lbfgs'}\n",
    "\n",
    "transformPipeline = Pipeline([\n",
    "    ('Initial drop cols', DFTransform(lambda X: X.drop([customerIdKey,'firstInvoiceDate'], axis=1))),\n",
    "    ('Remove catagorical', DFTransform(lambda X: X.select_dtypes(exclude=['object']))),\n",
    "    ('Remove skew Right value cols',DFTransform(RemoveSkew)),\n",
    "    #Removing this is important, causes worse prediction, work on col...\n",
    "    #('Remove Left skew column', DFTransform(lambda X: X.drop(['avgDaysToPay'], axis=1)))\n",
    "    #('Remove skew Left value cols',DFTransform(RemoveLeftSkew))\n",
    "])\n",
    "clfPipeline = Pipeline([\n",
    "    ('scaler', RobustScaler()),\n",
    "    ('reduceDimensions', PCA()),\n",
    "    ('classifier', MLPClassifier())\n",
    "])\n",
    "\n",
    "transformedDfX_test = transformPipeline.transform(X_train)\n",
    "bestModel = GridSearchCVOnPipeline(transformedDfX_test, y_train, clfPipeline, param_grid, refitScore)\n",
    "\n",
    "transformedDfX_test = transformPipeline.transform(X_test)\n",
    "BestModelScore(transformedDfX_test, y_test, bestModel, refitScore)"
   ]
  },
  {
   "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
}