MineVsRock.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas\n",
    "import keras\n",
    "import tensorflow as tf\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.wrappers.scikit_learn import KerasClassifier\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.utils import shuffle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "# seed to get same random number\n",
    "seed = 7\n",
    "np.random.seed(seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60,)"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# read dataset using pandas as dataframe\n",
    "dataframe = pandas.read_csv(\"sonar.csv\", header=None)\n",
    "\n",
    "dataset = dataframe.values\n",
    "\n",
    "X = dataset[:, 0:60].astype(float)\n",
    "y = dataset[:, 60]\n",
    "\n",
    "X[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# baseline model\n",
    "def baseline_model():\n",
    "    model = Sequential()\n",
    "    model.add(Dense(60, activation='relu', input_shape=(60,)))\n",
    "    model.add(Dense(60, activation='relu'))\n",
    "    model.add(Dense(1, activation='sigmoid'))\n",
    "    # Compile model, write code below\n",
    "    model.compile(optimizer='adam',\n",
    "              loss='binary_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# smaller model\n",
    "def smaller_model():\n",
    "    model = Sequential()\n",
    "    model.add(Dense(60, activation='relu', input_shape=(60,)))\n",
    "    model.add(Dense(30, activation='relu'))\n",
    "    model.add(Dense(1, activation='sigmoid'))\n",
    "    # Compile model, write code below\n",
    "    model.compile(optimizer='adam',\n",
    "              loss='binary_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# bigger model\n",
    "def bigger_model():\n",
    "    model = Sequential()\n",
    "    model.add(Dense(60, activation='relu', input_shape=(60,)))\n",
    "    model.add(Dense(60, activation='relu'))\n",
    "    model.add(Dense(30, activation='relu'))\n",
    "    model.add(Dense(1, activation='sigmoid'))\n",
    "    # Compile model, write code below\n",
    "    model.compile(optimizer='adam',\n",
    "              loss='binary_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# functional model\n",
    "def functional_model():\n",
    "    inputs = keras.Input(shape=(60,))\n",
    "    layer1 = Dense(60, activation='relu')(inputs)\n",
    "    layer2 = Dense(60, activation='relu')(layer1)\n",
    "    outputs = Dense(1, activation='sigmoid')(layer2)\n",
    "\n",
    "    model = keras.Model(inputs, outputs)\n",
    "    \n",
    "    # Compile model, write code below\n",
    "    model.compile(optimizer='adam',\n",
    "              loss='binary_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model subclassing\n",
    "class MyModel(tf.keras.Model):\n",
    "    def __init__(self):\n",
    "        super(MyModel).__init__()\n",
    "        self.dense1 = Dense(60, activation = 'relu')\n",
    "        self.dense2 = Dense(60, activation = 'relu')\n",
    "        self.dense3 = Dense(1, activation = 'sigmoid')\n",
    "\n",
    "    def call(self, inputs):\n",
    "        x = self.dense1(inputs)\n",
    "        x = self.dense2(x)\n",
    "        return self.dense3(x)\n",
    "    \n",
    "def subclass_model():\n",
    "    inputs = keras.Input(shape=(60,))\n",
    "    mymodel = MyModel()\n",
    "    outputs = mymodel.call(inputs)\n",
    "\n",
    "    model = keras.Model(inputs, outputs)\n",
    "\n",
    "    # Compile model, write code below\n",
    "    model.compile(optimizer='adam',\n",
    "              loss='binary_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "# encode labels\n",
    "le = LabelEncoder()\n",
    "encoded_y = le.fit(y).transform(y)\n",
    "# encoded_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Basline: Accuracy 84.13%, Error (5.68%)\n"
     ]
    }
   ],
   "source": [
    "# evaluate baseline model\n",
    "estimator = KerasClassifier(build_fn=baseline_model, epochs=100, batch_size=5, verbose=0)\n",
    "kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=seed)\n",
    "results = cross_val_score(estimator, X, encoded_y, cv=kfold)\n",
    "print(\"Basline: Accuracy %.2f%%, Error (%.2f%%)\" % (results.mean()*100, results.std()*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Standardized: Accuracy 84.59%, Error (3.67%)\n"
     ]
    }
   ],
   "source": [
    "# evaluate baseline model with standardized dataset\n",
    "np.random.seed(seed)\n",
    "estimators = []\n",
    "estimators.append(('standardize', StandardScaler()))\n",
    "estimators.append(('mlp', KerasClassifier(build_fn=baseline_model, epochs=100, batch_size=5, verbose=0)))\n",
    "pipeline = Pipeline(estimators)\n",
    "kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)\n",
    "results = cross_val_score(pipeline, X, encoded_y, cv=kfold)\n",
    "print(\"Standardized: Accuracy %.2f%%, Error (%.2f%%)\" % (results.mean()*100, results.std()*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# custom K-Fold without sci-kit & shuffle the data\n",
    "dataframe = shuffle(dataframe)\n",
    "\n",
    "dataset = dataframe.values\n",
    "\n",
    "X = dataset[:, 0:60].astype(float)\n",
    "y = dataset[:, 60]\n",
    "\n",
    "# label encoding\n",
    "le = LabelEncoder()\n",
    "encoded_y = le.fit(y).transform(y)\n",
    "\n",
    "k=10\n",
    "num_val_samples = len(X)//k\n",
    "num_epochs = 100\n",
    "\n",
    "all_acc = np.array([])\n",
    "# all_err = np.array([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing K-Fold # 1\n",
      "Processing K-Fold # 2\n",
      "Processing K-Fold # 3\n",
      "Processing K-Fold # 4\n",
      "Processing K-Fold # 5\n",
      "Processing K-Fold # 6\n",
      "Processing K-Fold # 7\n",
      "Processing K-Fold # 8\n",
      "Processing K-Fold # 9\n",
      "Processing K-Fold # 10\n",
      "+--------------------+\n",
      "Custom K-Folds: Accuracy 84.00%, Error (6.63%)\n"
     ]
    }
   ],
   "source": [
    "# processing k-folds\n",
    "for i in range(k):\n",
    "    print('Processing K-Fold #', i+1)\n",
    "    val_data = X[i * num_val_samples: (i + 1) * num_val_samples]\n",
    "    val_targets = encoded_y[i * num_val_samples: (i + 1) * num_val_samples]\n",
    "\n",
    "    partial_train_data = np.concatenate(\n",
    "        [X[:i * num_val_samples],\n",
    "         X[(i + 1) * num_val_samples:]],\n",
    "        axis=0)\n",
    "    \n",
    "    partial_train_targets = np.concatenate(\n",
    "        [encoded_y[:i * num_val_samples],\n",
    "         encoded_y[(i + 1) * num_val_samples:]],\n",
    "        axis=0)\n",
    "    \n",
    "    model = functional_model()\n",
    "    history = model.fit(partial_train_data, partial_train_targets,\n",
    "        epochs=num_epochs, batch_size=5, verbose=0, validation_data=(val_data, val_targets))\n",
    "    \n",
    "    results = model.evaluate(val_data, val_targets, verbose=0)\n",
    "    \n",
    "#     all_err = np.append(all_err, results[0])\n",
    "    all_acc = np.append(all_acc, results[1])\n",
    "    \n",
    "print(\"+--------------------+\")    \n",
    "print(\"Custom K-Folds: Accuracy %.2f%%, Error (%.2f%%)\" % (all_acc.mean()*100, all_acc.std()*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Smaller: Accuracy 86.49%, Error (4.82%)\n"
     ]
    }
   ],
   "source": [
    "# evaluate smaller model with standardized dataset\n",
    "np.random.seed(seed)\n",
    "estimators = []\n",
    "estimators.append(('standardize', StandardScaler()))\n",
    "estimators.append(('mlp', KerasClassifier(build_fn=smaller_model, epochs=100, batch_size=5, verbose=0)))\n",
    "pipeline = Pipeline(estimators)\n",
    "kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)\n",
    "results = cross_val_score(pipeline, X, encoded_y, cv=kfold)\n",
    "print(\"Smaller: Accuracy %.2f%%, Error (%.2f%%)\" % (results.mean()*100, results.std()*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bigger: Accuracy 84.52%, Error (6.51%)\n"
     ]
    }
   ],
   "source": [
    "# evaluate bigger model with standardized dataset\n",
    "np.random.seed(seed)\n",
    "estimators = []\n",
    "estimators.append(('standardize', StandardScaler()))\n",
    "estimators.append(('mlp', KerasClassifier(build_fn=bigger_model, epochs=100, batch_size=5, verbose=0)))\n",
    "pipeline = Pipeline(estimators)\n",
    "kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)\n",
    "results = cross_val_score(pipeline, X, encoded_y, cv=kfold)\n",
    "print(\"Bigger: Accuracy %.2f%%, Error (%.2f%%)\" % (results.mean()*100, results.std()*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Functional Api: Accuracy 85.93%, Error (6.47%)\n"
     ]
    }
   ],
   "source": [
    "# evaluate functional_api model with standardized dataset\n",
    "np.random.seed(seed)\n",
    "estimators = []\n",
    "estimators.append(('standardize', StandardScaler()))\n",
    "estimators.append(('mlp', KerasClassifier(build_fn=functional_model, epochs=100, batch_size=5, verbose=0)))\n",
    "pipeline = Pipeline(estimators)\n",
    "kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)\n",
    "results = cross_val_score(pipeline, X, encoded_y, cv=kfold)\n",
    "print(\"Functional Api: Accuracy %.2f%%, Error (%.2f%%)\" % (results.mean()*100, results.std()*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model Subclassing: Accuracy 86.43%, Error (6.54%)\n"
     ]
    }
   ],
   "source": [
    "# evaluate subclassing model with standardized dataset\n",
    "np.random.seed(seed)\n",
    "estimators = []\n",
    "estimators.append(('standardize', StandardScaler()))\n",
    "estimators.append(('mlp', KerasClassifier(build_fn=subclass_model, epochs=100, batch_size=5, verbose=0)))\n",
    "pipeline = Pipeline(estimators)\n",
    "kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)\n",
    "results = cross_val_score(pipeline, X, encoded_y, cv=kfold)\n",
    "print(\"Model Subclassing: Accuracy %.2f%%, Error (%.2f%%)\" % (results.mean()*100, results.std()*100))"
   ]
  }
 ],
 "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
}