Hyper-Param Tuning with Cross Validation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.pipeline import Pipeline\n",
    "import matplotlib.pyplot as mpl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection._split import _BaseKFold\n",
    "class PurgedKFold(_BaseKFold):\n",
    "    '''\n",
    "    Extend Kfold to work with labels that span intervals\n",
    "    the train is purged of observations overlapping test-label intervals\n",
    "    test set is assumed contiguous (shuffle=False), w/o training examples in between'''\n",
    "    def __init__(self, n_splits=3, t1=None, pctEmbargo=0.):\n",
    "        if not isinstance(t1, pd.Series):\n",
    "            raise ValueError('must be pd series')\n",
    "        super(PurgedKFold, self).__init__(n_splits, shuffle=False, random_state=None)\n",
    "        self.t1=t1\n",
    "        self.pctEmbargo=pctEmbargo\n",
    "    def split(self, X, y=None, groups=None):\n",
    "        if(X.index==self.t1.index).sum()!=len(self.t1):\n",
    "            raise ValueError('X and thruDateValues must have the same index')\n",
    "        indices = np.arange(X.shape[0])\n",
    "        mbrg = int(X.shape[0]*self.pctEmbargo)\n",
    "        test_starts=[(i[0], i[-1]+1) for i in np.array_split(np.arange(X.shape[0]), self.n_splits)]\n",
    "        for i,j in test_starts:\n",
    "            t0 = self.t1.index[i] #start of test set\n",
    "            test_indices = indices[i:j]\n",
    "            maxT1Idx = self.t1.index.searchsorted(self.t1[test_indices].max())\n",
    "            train_indices = self.t1.index.searchsorted(self.t1[self.t1<=t0].index)\n",
    "            train_indices = np.concatenate((train_indices, indices[maxT1Idx+mbrg:]))\n",
    "            yield train_indices, test_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyPipeline(Pipeline):\n",
    "    def fit(self, X, y, sample_weight=None, **fit_params):\n",
    "        if sample_weight is not None:\n",
    "            fit_params[self.steps[-1][0]+'__sample_weight']=sample_weight\n",
    "        return super(MyPipeline,self).fit(X,y, **fit_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#grid search cv\n",
    "def clfHyperFit(feat, lb1, t1, pipe_clf, param_grid, cv=3, bagging=[0, None, 1.], rngSearchIter=0, n_jobs=-1, pctEmbargo=0, **fit_params):\n",
    "    if set(lb1.values)=={0,1}:\n",
    "        scoring='f1'#use scoring method f1 for meta labeling because of high number of negatives in this use case\n",
    "    else: \n",
    "        scoring='neg_log_loss'\n",
    "    #1. Hyperparameter search, on training data\n",
    "    inner_cv= PurgedKFold(n_splits=cv, t1=t1, pctEmbargo=pctEmbargo)\n",
    "    if rndSearchIter==0:\n",
    "        gs = GridSearchCV(estimator=pipe_clf,param_grid=param_grid, scoring=scoring, cv=inner_cv, n_jobs=n_jobs, iid=False)\n",
    "    else:\n",
    "        gs = RandomizedSearchCV(estimator=pipe_clf, param_dsitributions=param_grid, scoring=scoring, cv=inner_cv, n_jobs=n_jobs, iid=False, n_iter=rndSearchIter)\n",
    "    gs = gs.fit(feat, lb1, **fit_params).best_estimator_ \n",
    "    #2. Fit validated model on the rest of the dataset\n",
    "    if bagging[1]>0:\n",
    "        gs = BaggingClassifier(base_estimator=MyPipeline(gs.steps), n_estimators=int(bagging[0]), max_samples=float(bagging[1]),max_features=float(bagging[2]), n_jobs=n_jobs)\n",
    "        gs = gs.fit(feat, lb1, sample_weight=fit_params[gs.base_estimator.steps[-1][0]+'__sample_weight'])\n",
    "        gs = Pipeline([('bag', gs)])\n",
    "    return gs\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KstestResult(statistic=0.008178548334759728, pvalue=0.5153847378549393)\n",
      "count    10000.000000\n",
      "mean        70.602278\n",
      "std        174.120001\n",
      "min          0.001001\n",
      "25%          0.029361\n",
      "50%          0.969305\n",
      "75%         28.917796\n",
      "max        999.480631\n",
      "dtype: float64\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy.stats import rv_continuous, kstest\n",
    "\n",
    "class logUniform_gen(rv_continuous):\n",
    "    #random numbers log-uniformely distributed between 1 and e\n",
    "    def _cdf(self, x):\n",
    "        return np.log(x/self.a)/np.log(self.b/self.a)\n",
    "def logUniform(a=1, b=np.exp(1)):\n",
    "    return logUniform_gen(a=a, b=b, name='logUniform')\n",
    "\n",
    "a,b,size = 1E-3, 1E3, 10000\n",
    "vals = logUniform(a=a, b=b).rvs(size=size)\n",
    "print(kstest(rvs=np.log(vals), cdf='uniform', args=(np.log(a), np.log(b/a)), N=size))\n",
    "print(pd.Series(vals).describe())\n",
    "mpl.subplot(121)\n",
    "pd.Series(np.log(vals)).hist()\n",
    "mpl.subplot(122)\n",
    "pd.Series(vals).hist()\n",
    "mpl.show()\n"
   ]
  },
  {
   "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
}