stage-4-classifier.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import sklearn as sk\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "train=pd.DataFrame(pd.read_csv('clean1Final.csv'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "import xgboost as xgb\n",
    "from xgboost.sklearn import XGBClassifier\n",
    "from sklearn import cross_validation, metrics   #Additional scklearn functions\n",
    "from sklearn.grid_search import GridSearchCV   #Perforing grid search\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: xgboost in /home/ekka/anaconda3/lib/python3.6/site-packages\r\n",
      "Requirement already satisfied: scikit-learn in /home/ekka/.local/lib/python3.6/site-packages (from xgboost)\r\n",
      "Requirement already satisfied: numpy in /home/ekka/anaconda3/lib/python3.6/site-packages (from xgboost)\r\n",
      "Requirement already satisfied: scipy in /home/ekka/anaconda3/lib/python3.6/site-packages (from xgboost)\r\n"
     ]
    }
   ],
   "source": [
    "!pip install xgboost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pylab as plt\n",
    "%matplotlib inline\n",
    "from matplotlib.pylab import rcParams\n",
    "rcParams['figure.figsize'] = 12, 4\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "target = 'mvar49'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.keys().size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "def modelfit(alg, dtrain, predictors,useTrainCV=True, cv_folds=5, early_stopping_rounds=50):\n",
    "    \n",
    "    if useTrainCV:\n",
    "        xgb_param = alg.get_xgb_params()\n",
    "        xgb_param['num_class']=4\n",
    "        xgtrain = xgb.DMatrix(dtrain[predictors].values, label=dtrain[target].values)\n",
    "        cvresult = xgb.cv(xgb_param, xgtrain, num_boost_round=alg.get_params()['n_estimators'], nfold=cv_folds,\n",
    "             early_stopping_rounds=early_stopping_rounds,stratified=True)\n",
    "        alg.set_params(n_estimators=cvresult.shape[0])\n",
    "    \n",
    "    #Fit the algorithm on the data\n",
    "    alg.fit(dtrain[predictors], dtrain[target],eval_metric='auc')\n",
    "        \n",
    "    #Predict training set:\n",
    "    dtrain_predictions = alg.predict(dtrain[predictors])\n",
    "    dtrain_predprob = alg.predict_proba(dtrain[predictors])[:,1]\n",
    "        \n",
    "    #Print model report:\n",
    "    print (\"\\nModel Report\")\n",
    "    print (\"Accuracy : %.4g\" % metrics.accuracy_score(dtrain[target].values, dtrain_predictions))\n",
    "    #print (\"AUC Score (Train): %f\" % metrics.roc_auc_score(dtrain[target], dtrain_predprob))\n",
    "                    \n",
    "    #feat_imp = pd.Series(alg.booster().get_fscore()).sort_values(ascending=False)\n",
    "    #feat_imp.plot(kind='bar', title='Feature Importances')\n",
    "    #plt.ylabel('Feature Importance Score')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Model Report\n",
      "Accuracy : 0.7862\n",
      "time 59.483579874038696\n"
     ]
    }
   ],
   "source": [
    "#Choose all predictors except target & IDcols\n",
    "t=time.time()\n",
    "predictors = [x for x in train.columns if x not in [target]]\n",
    "xgb1 = XGBClassifier(\n",
    " learning_rate =0.1,\n",
    " n_estimators=1000,\n",
    " max_depth=5,\n",
    " min_child_weight=1,\n",
    " gamma=0,\n",
    " subsample=0.8,\n",
    " colsample_bytree=0.8,\n",
    " objective= 'multi:softprob',\n",
    " nthread=4,\n",
    " scale_pos_weight=1,\n",
    " seed=27)\n",
    "modelfit(xgb1, train, predictors)\n",
    "\n",
    "print('time',time.time()-t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "df = pd.read_csv('leaderFinal2.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Unnamed: 0', 'mvar2', 'mvar3', 'mvar4', 'mvar5', 'mvar6', 'mvar7',\n",
       "       'mvar8', 'mvar9', 'mvar10', 'mvar11', 'mvar13', 'mvar14', 'mvar15',\n",
       "       'mvar16', 'mvar20', 'mvar24', 'mvar28', 'mvar32', 'mvar36', 'mvar40',\n",
       "       'mvar41', 'mvar42', 'cm_key'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [],
   "source": [
    "del df['Unnamed: 0']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['mvar2', 'mvar3', 'mvar4', 'mvar5', 'mvar6', 'mvar7', 'mvar8', 'mvar9',\n",
       "       'mvar10', 'mvar11', 'mvar13', 'mvar14', 'mvar15', 'mvar16', 'mvar20',\n",
       "       'mvar24', 'mvar28', 'mvar32', 'mvar36', 'mvar40', 'mvar41', 'mvar42',\n",
       "       'cm_key'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "del df['mvar3']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ids=df.pop('cm_key')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.73148692,  0.07840214,  0.12906398,  0.06104692],\n",
       "       [ 0.84004384,  0.05951865,  0.08278651,  0.01765098],\n",
       "       [ 0.64240271,  0.25653923,  0.00606078,  0.09499723],\n",
       "       ..., \n",
       "       [ 0.616687  ,  0.06364144,  0.00300308,  0.31666854],\n",
       "       [ 0.85041505,  0.03577263,  0.09381097,  0.02000134],\n",
       "       [ 0.83204246,  0.07513637,  0.0657521 ,  0.0270691 ]], dtype=float32)"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xgb1.predict_proba(df)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [],
   "source": [
    "xgb1.predict_proba(df)\n",
    "\n",
    "\n",
    "\n",
    "def answer(i):\n",
    "    if(i == 1): return \"Supp\"\n",
    "    elif(i == 2): return \"Elite\"\n",
    "    elif(i == 3): return \"Credit\"\n",
    "\n",
    "max_indices = np.argmax(xgb1.predict_proba(df)[:, 1:], axis=1)\n",
    "max_vals = np.amax(xgb1.predict_proba(df)[:, 1:], axis=1)\n",
    "\n",
    "y_final = 1 + np.argmax(xgb1.predict_proba(df)[:, 1:], axis=1)\n",
    "y_final = y_final[np.argsort(max_vals)[::-1]]\n",
    "class_final = [answer(i) for i in y_final]\n",
    "\n",
    "#ids = ids[np.argsort(max_vals)]\n",
    "ids = np.array(ids)[np.argsort(max_vals)[::-1]]\n",
    "\n",
    "submission = pd.DataFrame({'c1': ids[:1000], 'c2': class_final[:1000]})\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "submission.to_csv(\"Top_Floors_IITGuwahati_6.csv\", index = False, header = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1, 2, 3]), array([3770, 2877, 3353]))"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(y_final, return_counts=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time: 1184.8907115459442\n"
     ]
    }
   ],
   "source": [
    "t=time.time()\n",
    "param_test1 = [{\n",
    " 'max_depth':np.arange(4,6,1),\n",
    " 'min_child_weight':np.arange(4,6,1)\n",
    "}]\n",
    "\n",
    "gsearch1 = GridSearchCV(estimator = XGBClassifier( learning_rate =0.1, n_estimators=140, max_depth=5,\n",
    " min_child_weight=1, gamma=0, subsample=0.8, colsample_bytree=0.8,\n",
    " objective= 'multi:softprob', nthread=4, scale_pos_weight=1, seed=27), \n",
    " param_grid = param_test1,n_jobs=4,iid=False, cv=5)\n",
    "gsearch1.fit(train[predictors],train[target])\n",
    "gsearch1.grid_scores_, gsearch1.best_params_, gsearch1.best_score_\n",
    "\n",
    "print('time:',time.time()-t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[mean: 0.77887, std: 0.00080, params: {'max_depth': 3, 'min_child_weight': 1},\n",
       " mean: 0.77930, std: 0.00046, params: {'max_depth': 3, 'min_child_weight': 3},\n",
       " mean: 0.77925, std: 0.00059, params: {'max_depth': 3, 'min_child_weight': 5},\n",
       " mean: 0.77930, std: 0.00094, params: {'max_depth': 5, 'min_child_weight': 1},\n",
       " mean: 0.77920, std: 0.00086, params: {'max_depth': 5, 'min_child_weight': 3},\n",
       " mean: 0.77940, std: 0.00082, params: {'max_depth': 5, 'min_child_weight': 5},\n",
       " mean: 0.77722, std: 0.00146, params: {'max_depth': 7, 'min_child_weight': 1},\n",
       " mean: 0.77762, std: 0.00149, params: {'max_depth': 7, 'min_child_weight': 3},\n",
       " mean: 0.77805, std: 0.00075, params: {'max_depth': 7, 'min_child_weight': 5},\n",
       " mean: 0.77712, std: 0.00113, params: {'max_depth': 9, 'min_child_weight': 1},\n",
       " mean: 0.77724, std: 0.00079, params: {'max_depth': 9, 'min_child_weight': 3},\n",
       " mean: 0.77687, std: 0.00062, params: {'max_depth': 9, 'min_child_weight': 5}]"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gsearch1.grid_scores_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'max_depth': 5, 'min_child_weight': 5}"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gsearch1.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.42362470244154915"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gsearch1.best_score_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "df=pd.DataFrame(pd.read_csv('clean1Final.csv'))\n",
    "y=df.pop('mvar49')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.cross_validation import train_test_split\n",
    "from sklearn import model_selection\n",
    "xtrain, xtest, ytrain, ytest = train_test_split(df,y,test_size=0.3,stratify=y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "xtrain, xval, ytrain, yval = train_test_split(xtrain,ytrain,test_size=0.3,stratify=ytrain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.keys().size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cv score: 0.772922636103\n",
      "cv score: 0.777936962751\n",
      "cv score: 0.77805635148\n",
      "cv score: 0.778533906399\n",
      "cv score: 0.778772683859\n",
      "cv score: 0.779130850048\n",
      "cv score: 0.779250238777\n",
      "cv score: 0.779369627507\n",
      "cv score: 0.779608404967\n",
      "cv score: 0.779727793696\n",
      "cv score: 0.779966571156\n",
      "cv score: 0.780085959885\n",
      "Max n: 80\n",
      "Max m: 4\n",
      "train score: 1.0\n",
      "cv score: 0.780085959885\n",
      "test Score 0.777601337234\n",
      "time: 414.82312989234924\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "import time\n",
    "\n",
    "t=time.time()\n",
    "\n",
    "ranScore=0\n",
    "nMax=2\n",
    "mMax=2\n",
    "ranFinal=RandomForestClassifier()\n",
    "\n",
    "for m in range(1,10,1):\n",
    "    for n  in range(10,130,10):\n",
    "        ran=RandomForestClassifier(max_features=m,n_estimators=n,random_state=10).fit(xtrain,ytrain)\n",
    "        temp=ran.score(xval,yval)\n",
    "        #plt.scatter(n,temp,label=n)\n",
    "        if(temp>ranScore):\n",
    "            ranScore=temp\n",
    "            nMax=n\n",
    "            mMax=m\n",
    "            ranFinal=ran\n",
    "            print('cv score:',temp)\n",
    "            #print('test Score', ranFinal.score(xtest,ytest))\n",
    "    #plt.xlabel('no of trees')\n",
    "    #plt.ylabel('no of features: '+str(m))\n",
    "    #plt.legend()\n",
    "    #plt.show()\n",
    "    \n",
    "print('Max n:',nMax)\n",
    "print('Max m:',mMax)\n",
    "print('train score:', ranFinal.score(xtrain,ytrain))\n",
    "print('cv score:', ranFinal.score(xval,yval))\n",
    "print('test Score', ranFinal.score(xtest,ytest))\n",
    "\n",
    "print('time:', time.time()-t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.77826995403259502"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ranFinal.score(xtest,ytest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.03078782,  0.04960259,  0.08445443,  0.07131025,  0.0761748 ,\n",
       "        0.0435157 ,  0.06588855,  0.01311478,  0.08461555,  0.05861975,\n",
       "        0.01018137,  0.01706909,  0.07228277,  0.07259696,  0.07205608,\n",
       "        0.036057  ,  0.04094753,  0.08823134,  0.00851449,  0.00277868,\n",
       "        0.00120045])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ranFinal.feature_importances_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ranFinal.pred_proba(xtest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['mvar2', 'mvar4', 'mvar5', 'mvar6', 'mvar7', 'mvar8', 'mvar9', 'mvar10',\n",
       "       'mvar11', 'mvar13', 'mvar14', 'mvar15', 'mvar16', 'mvar20', 'mvar24',\n",
       "       'mvar28', 'mvar32', 'mvar36', 'mvar40', 'mvar41', 'mvar42'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ranran=ranFinal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cv error 0.778271303994\n",
      "cv error 0.778557798539\n",
      "cv error 0.778557901193\n",
      "Max n: 110\n",
      "Max m: 3\n",
      "10 -fold CV\n",
      "time: 243.38183522224426\n"
     ]
    }
   ],
   "source": [
    "#xtrain, xtest, ytrain, ytest = model_selection.train_test_split(pokemonDf,legends,test_size=0.2,random_state=100)\n",
    "\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "t=time.time()\n",
    "\n",
    "splits=10\n",
    "\n",
    "\n",
    "cv = model_selection.StratifiedKFold(n_splits=splits, shuffle=True, random_state=1)\n",
    "\n",
    "\n",
    "\n",
    "ranScore=0\n",
    "nMax=0\n",
    "mMax=0\n",
    "\n",
    "ranCV=[]\n",
    "tempRanCV=[]\n",
    "error=0\n",
    "scoreCVSmall=0\n",
    "tempScoreCV=0\n",
    "scoreCV=0\n",
    "testScore=0\n",
    "trainScore=0\n",
    "dMax=0\n",
    "splitsMax=0\n",
    "\n",
    "\n",
    "for m in range(3,4,1):\n",
    "    for n  in range(80,130,10):\n",
    "        scoreCVSmall=0\n",
    "        tempRanCV=[]\n",
    "        for traincv, testcv in cv.split(xtrain,ytrain):\n",
    "            ran=RandomForestClassifier(max_features=m,n_estimators=n,random_state=1).fit(xtrain.iloc[traincv],ytrain.iloc[traincv])\n",
    "            scoreCVSmall+=ran.score(xtrain.iloc[testcv],ytrain.iloc[testcv])\n",
    "            tempRanCV.append(ran)\n",
    "        tempScoreCV=scoreCVSmall/cv.n_splits\n",
    "\n",
    "        if(tempScoreCV>scoreCV):\n",
    "            scoreCV=tempScoreCV\n",
    "            nMax=n\n",
    "            mMax=m\n",
    "            ranCV=tempRanCV\n",
    "            splitsMax=splits\n",
    "            print('cv error', tempScoreCV)\n",
    "\n",
    "\n",
    "\n",
    "print('Max n:',nMax)\n",
    "print('Max m:',mMax)\n",
    "#print('Max d:',dMax)\n",
    "print(splits,'-fold CV')\n",
    "\n",
    "print('time:', time.time()-t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max n: 110\n",
      "Max m: 3\n",
      "Max d: 0\n",
      "10 -fold CV\n",
      "train Score1 0.977855786797\n",
      "test Score1 0.778403677392\n",
      "train Score2 1.0\n",
      "test Score2 0.778520685332\n"
     ]
    }
   ],
   "source": [
    "print('Max n:',nMax)\n",
    "print('Max m:',mMax)\n",
    "print('Max d:',dMax)\n",
    "print(splits,'-fold CV')\n",
    "\n",
    "trainScore=0\n",
    "for r in ranCV:\n",
    "    trainScore+=r.score(xtrain,ytrain)\n",
    "trainScore/=splitsMax\n",
    "print('train Score1', trainScore)\n",
    "\n",
    "testScore=0\n",
    "for r in ranCV:\n",
    "    testScore+=r.score(xtest,ytest)\n",
    "testScore/=splitsMax\n",
    "print('test Score1', testScore)\n",
    "\n",
    "###########################################\n",
    "\n",
    "for r in ranCV:\n",
    "    r.fit(xtrain,ytrain)\n",
    "\n",
    "trainScore=0\n",
    "for r in ranCV:\n",
    "    trainScore+=r.score(xtrain,ytrain)\n",
    "trainScore/=splitsMax\n",
    "print('train Score2', trainScore)\n",
    "\n",
    "\n",
    "testScore=0\n",
    "for r in ranCV:\n",
    "    testScore+=r.score(xtest,ytest)\n",
    "testScore/=splitsMax\n",
    "print('test Score2', testScore)\n",
    "\n",
    "#print('time:', time.time()-t)\n",
    "\n"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}