KerasNotebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "import scipy\n",
    "import pandas\n",
    "x = pandas.read_csv('train.csv',index_col='id')\n",
    "y = x['loss'].values\n",
    "x = x.drop(columns=['loss'])\n",
    "xTest = pandas.read_csv('test.csv',index_col='id')\n",
    "\n",
    "Xcont = x.drop(columns=[col for col in x.columns if col.startswith('cat')])\n",
    "Xcat = x.drop(columns=[col for col in x.columns if col.startswith('cont')])\n",
    "Xcombined = pandas.concat((x,xTest))\n",
    "XcombinedDummies = pandas.get_dummies(Xcombined,drop_first=True,columns = [col for col in x.columns if col.startswith('cat')])\n",
    "X = XcombinedDummies.iloc[:x.shape[0],:]\n",
    "Xtest = XcombinedDummies.iloc[x.shape[0]:,:]\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import decomposition\n",
    "from sklearn.model_selection import train_test_split\n",
    "import numpy\n",
    "\n",
    "from sklearn.ensemble import ExtraTreesRegressor, RandomForestRegressor, GradientBoostingRegressor\n",
    "from sklearn.neighbors import KNeighborsRegressor\n",
    "from sklearn.feature_selection import SelectFromModel\n",
    "from sklearn.linear_model import LinearRegression, RidgeCV\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "import time, numpy\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.ensemble import ExtraTreesRegressor, RandomForestRegressor, GradientBoostingRegressor\n",
    "from sklearn.linear_model import Lasso, LassoCV,LassoLarsCV, SGDRegressor, ElasticNetCV\n",
    "from sklearn.feature_selection import SelectFromModel\n",
    "\n",
    "def TestEstimator(name, estimator, X_train, y_train, X_test, y_test, tf = False):\n",
    "    t=time.time()\n",
    "    if tf:\n",
    "        y_train_ = numpy.log1p(y_train)\n",
    "    else:\n",
    "        y_train_ = y_train\n",
    "        \n",
    "    estimator.fit(X_train, y_train_)\n",
    "    trainTime = time.time()-t\n",
    "    t = time.time()\n",
    "    \n",
    "    y_pred = estimator.predict(X_test)\n",
    "    if tf:\n",
    "        y_pred = numpy.expm1(y_pred)\n",
    "    predictTime = time.time()-t\n",
    "    \n",
    "    y_train_pred = estimator.predict(X_train)\n",
    "    if tf:\n",
    "        y_train_pred = numpy.expm1(y_train_pred)\n",
    "    \n",
    "    error = numpy.sum(numpy.abs(y_pred - y_test)) / len(y_test)\n",
    "    error_train = numpy.sum(numpy.abs(y_train_pred - y_train)) / len(y_train)\n",
    "    #print(time.ctime(),name,error,trainTime,predictTime)\n",
    "    return error_train, error #a difference here indicates divergence\n",
    "\n",
    "def ExtractFeatures(estimator):\n",
    "    model = SelectFromModel(estimator, prefit=True)\n",
    "    return model\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gb:               1158.63 1172.11\n"
     ]
    }
   ],
   "source": [
    "#set up estimators:\n",
    "\n",
    "ridge = RidgeCV()\n",
    "lin = LinearRegression()\n",
    "lasso = Lasso()\n",
    "lassoCV = LassoCV()\n",
    "lassoLarsCV = LassoLarsCV()\n",
    "elastic = ElasticNetCV()\n",
    "\n",
    "#trees\n",
    "ef = ExtraTreesRegressor(n_estimators=130, n_jobs=-1)\n",
    "rf =  RandomForestRegressor(n_estimators=130, n_jobs=-1)\n",
    "\n",
    "\n",
    "sgd = SGDRegressor(loss='huber', penalty='elasticnet',tol = 1e-3,max_iter= 1000)\n",
    "\n",
    "print ('lasso-lars-cv:  %.2f %.2f'%TestEstimator('lassoLarsCV',lassoLarsCV, X_train, y_train, X_test, y_test, tf=True))\n",
    "\n",
    "featureReducer = ExtractFeatures(lassoLarsCV)\n",
    "svd = decomposition.TruncatedSVD(n_components=400)\n",
    "svd.fit(X_train.values.astype('float32'))\n",
    "featureReducer2 = svd\n",
    "\n",
    "X_train_ = featureReducer.transform(X_train)\n",
    "X_test_ = featureReducer.transform(X_test)\n",
    "X_train__ = featureReducer2.transform(X_train)\n",
    "X_test__ = featureReducer2.transform(X_test)\n",
    "print ('lasso-lars-cv-r2:  %.2f %.2f'%TestEstimator('lassoLarsCV',lassoLarsCV, X_train__, y_train, X_test__, y_test, tf=True))\n",
    "print ('lasso-full:  %.2f %.2f'%TestEstimator('lasso-full',lasso, X_train, y_train, X_test, y_test, tf=True))\n",
    "print ('lasso-cv:  %.2f %.2f'%TestEstimator('lassoCV',lassoCV, X_train, y_train, X_test, y_test, tf=True))\n",
    "\n",
    "print (\"elastic-full:     %.2f %.2f\"% TestEstimator('elastic',elastic, X_train, y_train, X_test, y_test, tf=True))\n",
    "print (\"elastic-reduced:  %.2f %.2f\"% TestEstimator('elastic',elastic, X_train_, y_train, X_test_, y_test, tf=True))\n",
    "print (\"elastic-reduced2: %.2f %.2f\"% TestEstimator('elastic',elastic, X_train__, y_train, X_test__, y_test, tf=True))\n",
    "\n",
    "print (\"lin-reduced:      %.2f %.2f\"% TestEstimator('lin',lin, X_train_, y_train, X_test_, y_test, tf=True))\n",
    "print (\"lin-reduced2:     %.2f %.2f\"% TestEstimator('lin',lin, X_train__, y_train, X_test__, y_test, tf=True))\n",
    "print (\"ridge-full:       %.2f %.2f\"% TestEstimator('ridge',ridge, X_train, y_train, X_test, y_test, tf=True))\n",
    "print (\"ridge-reduced:    %.2f %.2f\"% TestEstimator('ridge',ridge, X_train_, y_train, X_test_, y_test, tf=True))\n",
    "print (\"ridge-reduced2:   %.2f %.2f\"% TestEstimator('ridge',ridge, X_train__, y_train, X_test__, y_test, tf=True))\n",
    "print (\"ridge-full\", TestEstimator('ridge',ridge, X_train, y_train, X_test, y_test, tf=True))\n",
    "print (\"ridge-reduced\", TestEstimator('ridge',ridge, X_train_, y_train, X_test_, y_test, tf=True))\n",
    "\n",
    "gb = GradientBoostingRegressor(n_estimators=600, loss='huber')\n",
    "print (\"sgd:              %.2f %.2f\"% TestEstimator('sgd',sgd, X_train, y_train, X_test, y_test, tf=True))\n",
    "print (\"sgd-reduced:      %.2f %.2f\"% TestEstimator('sgd',sgd, X_train_, y_train, X_test_, y_test, tf=True))\n",
    "print (\"sgd-reduced2:     %.2f %.2f\"% TestEstimator('sgd',sgd, X_train__, y_train, X_test__, y_test, tf=True))\n",
    "\n",
    "print (\"gb-reduced:       %.2f %.2f\"% TestEstimator('gb',gb, X_train_, y_train, X_test_, y_test, tf=True))\n",
    "print (\"gb-reduced2:      %.2f %.2f\"% TestEstimator('gb',gb, X_train__, y_train, X_test__, y_test, tf=True))\n",
    "print (\"gb:               %.2f %.2f\"% TestEstimator('gb',gb, X_train, y_train, X_test, y_test, tf=True))\n",
    "#print (ExtractFeatures(lasso,100))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow, time\n",
    "import os\n",
    "import numpy\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Activation, BatchNormalization\n",
    "#from keras.callbacks import ModelCheckpoint\n",
    "from keras.layers import Dropout\n",
    "import keras.callbacks\n",
    "from keras import optimizers\n",
    "from keras import regularizers\n",
    "from keras.constraints import maxnorm\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.feature_selection import VarianceThreshold, SelectKBest, f_regression\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "def ContColumns(X):\n",
    "    contColumns = [c for c in X.columns if c.startswith('cont')]\n",
    "    return X[contColumns]\n",
    "\n",
    "def CatColumns(X):\n",
    "    catColumns = [c for c in X.columns if c.startswith('cat')]\n",
    "    return X[catColumns]\n",
    "\n",
    "def PCACont(X, components =6):\n",
    "    pcaIn = ContColumns(X)\n",
    "    ret = PCA(n_components = components).fit_transform(pcaIn)\n",
    "    #print(X.columns)\n",
    "    r = X.drop(columns=pcaIn.columns)\n",
    "    for i in range(components):\n",
    "        r['pca%d'%(i+1)]=ret[:,i]\n",
    "    #print (r.columns)\n",
    "    return r\n",
    "\n",
    "def SelectCategorical(X,thresh=0.05):\n",
    "    kbIn = CatColumns(X)\n",
    "    kb = VarianceThreshold(thresh)\n",
    "    ret = kb.fit_transform(kbIn)\n",
    "    r = X.drop(columns=kbIn.columns)\n",
    "    for i in range(ret.shape[1]):\n",
    "        r[\"cat%d\"%(i+1)] = ret[:,i]\n",
    "    return r\n",
    "\n",
    "\n",
    "class PrepareData:\n",
    "    def __init__(self, pcaCount, catK):\n",
    "        self.catK = catK\n",
    "        self.pcaCount = pcaCount\n",
    "        \n",
    "    def fit(self, X, y):\n",
    "        pcaIn = ContColumns(X)\n",
    "        self.pca = PCA(n_components = self.pcaCount)\n",
    "        self.pca.fit(pcaIn)\n",
    "        self.kbest = SelectKBest(score_func = f_regression, k = self.catK)\n",
    "        kbIn = CatColumns(X)\n",
    "        yIn = numpy.log1p(y)\n",
    "        self.kbest.fit(kbIn, yIn)\n",
    "    def transform(self, X):\n",
    "        pcaIn = ContColumns(X)\n",
    "        kbIn = CatColumns(X)\n",
    "        r1 = self.kbest.transform(kbIn)\n",
    "        r2 = self.pca.transform(pcaIn)\n",
    "        return numpy.c_[r1,r2]\n",
    "    \n",
    "EPOCHS = 100\n",
    "class CustomMLPRegressor:\n",
    "    \"\"\"provide a similar interface to the sklearn regressors\"\"\"\n",
    "    def LoadFromFile(self, filename):\n",
    "        self.model = keras.models.load_model(filename)\n",
    "        \n",
    "    def __init__(self, nodes, earlyStopping, dropout):\n",
    "      \n",
    "        if type(nodes) is int:\n",
    "            nodes = (nodes,)\n",
    "        self.nodes = nodes\n",
    "        self.dropout = dropout\n",
    "        self.earlyStopping = earlyStopping\n",
    "        \n",
    "    def fit(self, X, y):\n",
    "        #print (X,y)\n",
    "        inputDim = X.shape[1]\n",
    "        model = Sequential()\n",
    "        self.model = model\n",
    "        for i, nodeCount in enumerate(self.nodes):\n",
    "            if i == 0:\n",
    "                if len(self.nodes) == 1:\n",
    "                    self.model.add(Dense(nodeCount, input_dim = inputDim, activation='relu'))\n",
    "                else:\n",
    "                    self.model.add(Dense(nodeCount, input_dim = inputDim, activation='relu', kernel_constraint = maxnorm(3)))\n",
    "                    if self.dropout:\n",
    "                        model.add(Dropout(self.dropout))\n",
    "            else:\n",
    "                if len(self.nodes) > i+1:\n",
    "                    self.model.add(Dense(nodeCount,  activation='relu', kernel_constraint = maxnorm(3)))\n",
    "                    if self.dropout:\n",
    "                        model.add(Dropout(self.dropout))\n",
    "                else:\n",
    "                    self.model.add(Dense(nodeCount,  activation='relu'))\n",
    "        model.add(Dense(1))\n",
    "        opt = optimizers.Nadam()\n",
    "        model.compile(loss='mae', optimizer=opt)\n",
    "        #self.model = model\n",
    "        \n",
    "        callback_list = []\n",
    "        filepath=\"weights-best.hdf5\"\n",
    "        checkpoint = keras.callbacks.ModelCheckpoint(filepath, monitor='val_loss', verbose=0, save_best_only=True, mode='min')\n",
    "        callback_list.append(checkpoint)\n",
    "       \n",
    "        callback_list.append(keras.callbacks.EarlyStopping(min_delta=self.earlyStopping, patience=5,verbose=0))\n",
    "        history=model.fit(X.values.astype('float32'), y.astype('float32'), \n",
    "              epochs=EPOCHS, batch_size=1000,\n",
    "              verbose=2,validation_split=0.2,callbacks=callback_list)\n",
    "        bestModel = keras.models.load_model('weights-best.hdf5')\n",
    "        self.history = history\n",
    "        self.model =bestModel\n",
    "        return self\n",
    "    def predict(self, X):\n",
    "        #print ('predicting')\n",
    "        ret =  self.model.predict(X.astype('float32'))\n",
    "        #print (ret.shape)\n",
    "        return ret.flatten()\n",
    "def TestMLP(mlp):\n",
    "    e_train, e_test = TestEstimator('mlp',mlp, X_train, y_train, X_test, y_test, tf=False)\n",
    "    print(\"mlp-%s-%.2f: %.2f %.2f\"%(mlp.nodes,mlp.dropout,e_train, e_test))\n",
    "    try:\n",
    "        os.rename('weights-best.hdf5','weights-best-%.2f-%.2f-%s.hdf5'%(e_test,mlp.dropout,mlp.nodes))\n",
    "    except FileExistsError:\n",
    "        pass\n",
    "    return e_train, e_test\n",
    "#the following code was used to populate a results list.  \n",
    "# The lowest result for nodes/dropout pair was used to represent that point on the dataplot.\n",
    "for i in range(2):\n",
    "    nodes = 425+i*75\n",
    "    for j in range(3):\n",
    "        dropout =0.2+j*0.05\n",
    "        mlp = CustomMLPRegressor((nodes,50,10),0.0,dropout)\n",
    "        e_train, e = TestMLP(mlp)\n",
    "        results.append([nodes,dropout,e_train, e])\n",
    "        if e < bestE:\n",
    "            bestE = e\n",
    "            bestMLP = mlp\n",
    "\n",
    "#print ('mlp:  %.2f %.2f'%TestEstimator('mlp',mlp, X_train, y_train, X_test, y_test, tf=True))\n",
    "#print ('mlp:  %.2f %.2f'%TestEstimator('mlp',mlp, X_train, y_train, X_test, y_test, tf=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import scipy.stats\n",
    "import numpy\n",
    "import matplotlib.pyplot\n",
    "def Compare(statFunc):\n",
    "    ret = numpy.zeros((14,14))\n",
    "    for i in range(14):\n",
    "        colI = X[X.columns[i]]\n",
    "        for j in range(14):\n",
    "            colJ = X[X.columns[j]]\n",
    "\n",
    "            if (i == j):\n",
    "                ret[i,j] = 1\n",
    "            else:\n",
    "                ret[i,j] = statFunc(colI, colJ)[0]\n",
    "    return ret\n",
    "pearson = Compare(scipy.stats.pearsonr)\n",
    "kendallTau = Compare(scipy.stats.kendalltau)\n",
    "spearman = Compare(scipy.stats.spearmanr)\n",
    "matplotlib.pyplot.imshow(pearson, interpolation='nearest', cmap='RdGy',vmin=-1, vmax=1)\n",
    "matplotlib.pyplot.title('Pearson')\n",
    "matplotlib.pyplot.colorbar()\n",
    "matplotlib.pyplot.show()\n",
    "matplotlib.pyplot.imshow(kendallTau, interpolation='nearest', cmap='RdGy',vmin=-1, vmax=1)\n",
    "matplotlib.pyplot.title('kendallTau')\n",
    "matplotlib.pyplot.colorbar()\n",
    "matplotlib.pyplot.show()\n",
    "matplotlib.pyplot.imshow(spearman, interpolation='nearest', cmap='RdGy',vmin=-1, vmax=1)\n",
    "matplotlib.pyplot.title('spearman')\n",
    "matplotlib.pyplot.colorbar()\n",
    "matplotlib.pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CreateCSV(filename, estimator, X_test, tf=False):\n",
    "    y_test =estimator.predict(X_test)\n",
    "    ofile =open(filename,\"w\")\n",
    "    ofile.write(\"id,loss\\n\")\n",
    "    if tf:\n",
    "        y_test = numpy.expm1(y_test)\n",
    "\n",
    "    for ix,yval in zip(X_test.index, y_test):\n",
    "        ofile.write(\"%d,%.3f\\n\"%(ix,yval))\n",
    "    ofile.close()\n",
    "CreateCSV('test_submission4.csv',gb,Xtest,True)\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
}