Skip to content

Instantly share code, notes, and snippets.

@kodamap

kodamap/mnist_digits_deepnn_v1b.ipynb

Created April 5, 2020 11:09
Show Gist options
  • Save kodamap/67db4dcd050cae03fb56ff53e28321aa to your computer and use it in GitHub Desktop.
Save kodamap/67db4dcd050cae03fb56ff53e28321aa to your computer and use it in GitHub Desktop.
Download ZIP
Display the source blob
Display the rendered blob
Raw
mnist_digits_deepnn_v1b.ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Deep Neural Network"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import pandas as pd\n",
"import statsmodels.api as sm\n",
"import seaborn as sns\n",
"import matplotlib.pyplot as plt\n",
"import time\n",
"import joblib\n",
"import os\n",
"from pprint import pprint\n",
"\n",
"%matplotlib inline"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Utils and activation functions"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"#from utils.utils import *\n",
"%reload_ext autoreload\n",
"%autoreload 2"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"# utils.py\n",
"import numpy as np\n",
"import pandas as pd\n",
"import matplotlib.pyplot as plt\n",
"\n",
"def plot_history(history_data, learning_rate=0.005):\n",
" plt.figure() \n",
" costs = history_data[0]\n",
" accus = history_data[1]\n",
" plt.plot(costs, label=\"cost\")\n",
" plt.plot(accus, label=\"accuracy\")\n",
" plt.ylabel('cost / accuracy')\n",
" plt.xlabel('iterations (per hundreds)')\n",
" plt.title(\"Learning rate = {}\".format(learning_rate))\n",
" plt.legend()\n",
" plt.show()\n",
" \n",
"def show_digits(X, Y, Y_pred=None, num=10):\n",
" # plot settings\n",
" cols = 10 # display 10 images per rows\n",
" rows = num // cols\n",
" font = {'family': 'DejaVu Sans',\n",
" 'color': 'darkred',\n",
" 'weight': 'normal',\n",
" 'size': 12,\n",
" } \n",
" plt.figure(figsize=(cols, rows + 1)) \n",
" plt.subplots_adjust(top=0.99, bottom=0.1, hspace=0.1, wspace=0.4)\n",
" plt.gray()\n",
" for i in range(num):\n",
" ax = plt.subplot(rows + 1, cols, i + 1)\n",
" if (type(Y_pred).__module__ == 'numpy') and (Y[i] != Y_pred[i]): \n",
" ax.set_title('{} (y:{})'.format(Y_pred[i], Y[i]), fontdict=font)\n",
" else:\n",
" ax.set_title('y:{}'.format(Y[i]))\n",
" ax.axis('off')\n",
" plt.imshow(X[i])\n",
" plt.show()\n",
"\n",
"def flatten_X(X_train,X_test):\n",
" m, w, h = X_train.shape\n",
" X_train = X_train.reshape(m, w * h) / 255.\n",
" m, w, h = X_test.shape\n",
" X_test = X_test.reshape(m, w * h) / 255.\n",
" return X_train, X_test\n",
"\n",
"def to_categorical(y, num_classes=None):\n",
" \"\"\"Converts a class vector (integers) to binary class matrix.\n",
" # ref: https://github.com/keras-team/keras/blob/master/keras/utils/np_utils.py\n",
" \"\"\"\n",
" y = np.array(y, dtype='int')\n",
" if not num_classes:\n",
" num_classes = np.max(y) + 1\n",
" input_shape = y.shape\n",
" categorical = np.zeros((input_shape[0], num_classes))\n",
" categorical[np.arange(input_shape[0]), y] = 1 \n",
" return categorical\n",
"\n",
"\n",
"def f1_score(y_true, y_pred):\n",
" \"\"\"\n",
" datatype of y_true, y_pred must be ndarray.\n",
" \"\"\"\n",
" try:\n",
" assert(type(y_true).__module__ == 'numpy')\n",
" except AssertionError as err:\n",
" y_true = y_true.values\n",
"\n",
" try:\n",
" assert(type(y_pred).__module__ == 'numpy')\n",
" except AssertionError as err:\n",
" y_pred = y_pred.values\n",
" \n",
" true_idx = np.where(y_true == y_pred)\n",
" false_idx = np.where(y_true != y_pred)\n",
"\n",
" TN = np.count_nonzero(y_true[true_idx] == 0)\n",
" TP = np.count_nonzero(y_true[true_idx] == 1)\n",
" # this means false positive (pred = 1)\n",
" FP = np.count_nonzero(y_true[false_idx] == 0)\n",
" # this means false negative (pred = 0)\n",
" FN = np.count_nonzero(y_true[false_idx] == 1)\n",
"\n",
" confusion_matrix = np.array(([TN, FP], [FN, TP]))\n",
" recall = TP / (TP + FN)\n",
" precision = TP / (TP + FP)\n",
" f_score = 2 * (recall * precision) / (recall + precision)\n",
" idxes = (true_idx, false_idx)\n",
" return f_score, idxes, confusion_matrix, recall, precision\n",
"\n",
"def show_confusion_matrix(f1_score, idxes, cm, recall, precision):\n",
" TN, FP, FN, TP = cm[0][0], cm[0][1], cm[1][0], cm[1][1] \n",
" print(\"-\"*40)\n",
" print(\"TN: {:04}, FP: {:04}\".format(TN, FP))\n",
" print(\"FN: {:04}, TP: {:04}\".format(FN, TP))\n",
" print(\"Recall: {:.2f}, Precision: {:.2f}\".format(recall, precision))\n",
" print(\"F1 Score: {:.2f}\".format(f1_score))\n",
" print(\"-\"*40)\n",
" \n",
"def ramdom_mini_batches(X, Y, mini_batch_size = 64, seed = 0):\n",
" \"\"\"expected shape\n",
" X: (m, 784)\n",
" Y: (1, m)\n",
" \"\"\"\n",
" np.random.seed(seed)\n",
" m = X.shape[0]\n",
" mini_batches = []\n",
" permutation = list(np.random.permutation(m))\n",
" shuffled_X = X[permutation]\n",
" if Y.shape[1] == 10:\n",
" shuffled_Y = Y[permutation]\n",
" num_complete_minibatches = m // mini_batch_size\n",
" for i in range(num_complete_minibatches):\n",
" mini_batch_X = shuffled_X[i * mini_batch_size : (i + 1) * mini_batch_size]\n",
" mini_batch_Y = shuffled_Y[i * mini_batch_size : (i + 1) * mini_batch_size]\n",
" mini_batch = (mini_batch_X, mini_batch_Y)\n",
" mini_batches.append(mini_batch)\n",
" \n",
" if m % mini_batch_size != 0:\n",
" mini_batch_X = shuffled_X[num_complete_minibatches * mini_batch_size : m]\n",
" mini_batch_Y = shuffled_Y[num_complete_minibatches * mini_batch_size : m]\n",
" mini_batch = (mini_batch_X, mini_batch_Y)\n",
" mini_batches.append(mini_batch)\n",
" else:\n",
" shuffled_Y = Y[:,permutation]\n",
" num_complete_minibatches = m // mini_batch_size\n",
" for i in range(num_complete_minibatches):\n",
" mini_batch_X = shuffled_X[i * mini_batch_size : (i + 1) * mini_batch_size]\n",
" mini_batch_Y = shuffled_Y[:, i * mini_batch_size : (i + 1) * mini_batch_size]\n",
" mini_batch = (mini_batch_X, mini_batch_Y)\n",
" mini_batches.append(mini_batch)\n",
" \n",
" if m % mini_batch_size != 0:\n",
" mini_batch_X = shuffled_X[num_complete_minibatches * mini_batch_size : m]\n",
" mini_batch_Y = shuffled_Y[:, num_complete_minibatches * mini_batch_size : m]\n",
" mini_batch = (mini_batch_X, mini_batch_Y)\n",
" mini_batches.append(mini_batch)\n",
" \n",
" return mini_batches"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"# activation functions\n",
"import numpy as np\n",
"import os\n",
"\n",
"def sigmoid(Z):\n",
" return 1 / (1 + np.exp(-Z))\n",
"\n",
"def softmax(Z):\n",
" e_x = np.exp(Z - np.max(Z, axis=1, keepdims=True))\n",
" return e_x / np.sum(e_x, axis=1, keepdims=True)\n",
"\n",
"def relu(Z):\n",
" return np.maximum(0,Z)\n",
"\n",
"def leakyrelu(Z):\n",
" A = Z.copy()\n",
" A[Z <= 0] *= 0.01\n",
" return A"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Data observation"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(60000, 28, 28) (10000, 28, 28)\n"
]
}
],
"source": [
"from keras.datasets import mnist\n",
"(X_train, Y_train), (X_test, Y_test) = mnist.load_data()\n",
"print(X_train.shape, X_test.shape)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 720x216 with 20 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"show_digits(X_train, Y_train, num=20)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Original\n",
"X_train:(60000, 784) Y_train:(60000,) X_test:(10000, 784) Y_test:(10000,)\n",
"Categorical\n",
"X_train:(60000, 784) Y_train:(60000, 10) X_test:(10000, 784) Y_test:(10000, 10)\n"
]
}
],
"source": [
"(X_train, Y_train), (X_test, Y_test) = mnist.load_data()\n",
"X_train, X_test = flatten_X(X_train, X_test)\n",
"print(\"Original\\nX_train:{} Y_train:{} X_test:{} Y_test:{}\".format(\n",
" X_train.shape, Y_train.shape, X_test.shape, Y_test.shape))\n",
"\n",
"# convert Y to categorical data\n",
"categorical_Y_train = to_categorical(Y_train)\n",
"categorical_Y_test = to_categorical(Y_test)\n",
"print(\"Categorical\\nX_train:{} Y_train:{} X_test:{} Y_test:{}\".format(\n",
" X_train.shape, categorical_Y_train.shape, X_test.shape, categorical_Y_test.shape))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Defining the deep neural network model \n",
"\n",
"Thease codes are based on **Coursera 01_Neural Networks and Deep Learning /week3/Planar data classification with one hidden layer \n",
"/week3/Planar data classification with one hidden layer**"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import time\n",
"import joblib\n",
"import os\n",
"from utils.utils import *\n",
"from utils.activation_function import softmax, sigmoid, relu, leakyrelu\n",
"\n",
"class DeepNN():\n",
"\n",
" def __init__(self):\n",
" self.layers = []\n",
" \n",
" def initialize_parameters(self):\n",
" np.random.seed(2) \n",
" parameters = {}\n",
" for l in range(1, len(self.layers)):\n",
" parameters['W' + str(l)] = np.random.randn(\n",
" self.layers[l-1]['input'], self.layers[l]['input']) * 0.01\n",
" parameters['b' + str(l)] = np.zeros((self.layers[l]['input'],))\n",
" return parameters\n",
"\n",
" def initialize_adam(self, parameters):\n",
" v = {}\n",
" s = {}\n",
" for l in range(1, len(self.layers)):\n",
" v['dW' + str(l)] = np.zeros((parameters['W' + str(l)].shape))\n",
" v['db' + str(l)] = np.zeros((parameters['b' + str(l)].shape))\n",
" s['dW' + str(l)] = np.zeros((parameters['W' + str(l)].shape))\n",
" s['db' + str(l)] = np.zeros((parameters['b' + str(l)].shape))\n",
" return v, s\n",
" \n",
" def initialize_parameters_he(self):\n",
" np.random.seed(2) \n",
" parameters = {}\n",
" for l in range(1, len(self.layers)):\n",
" parameters['W' + str(l)] = np.random.randn(\n",
" self.layers[l-1]['input'], self.layers[l]['input']) * np.sqrt(2./self.layers[l-1]['input'])\n",
" parameters['b' + str(l)] = np.zeros((self.layers[l]['input'],))\n",
" return parameters\n",
"\n",
" def add(self, input=0, activation=\"\"):\n",
" layer = {}\n",
" layer['input'] = input\n",
" layer['activation'] = activation\n",
" self.layers.append(layer)\n",
" \n",
" def forward_prop(self, W, b, A, activation):\n",
" A_prev = A.copy()\n",
" Z = np.dot(A, W) + b \n",
" \n",
" if activation == 'relu':\n",
" A = relu(Z)\n",
" if activation == 'leakyrelu':\n",
" A = leakyrelu(Z)\n",
" elif activation == 'tanh':\n",
" A = np.tanh(Z)\n",
" elif activation == 'sigmoid':\n",
" A = sigmoid(Z)\n",
" elif activation == 'softmax':\n",
" A = softmax(Z) \n",
" cache = {'A_prev':A_prev, 'Z':Z, 'W':W, 'b':b}\n",
" return A, cache\n",
"\n",
" def L_model_forward(self, parameters, X):\n",
" caches = []\n",
" L = len(parameters) // 2\n",
" A = X.copy()\n",
" for l in range(L):\n",
" activation = self.layers[l+1]['activation']\n",
" W = parameters['W' + str(l+1)]\n",
" b = parameters['b' + str(l+1)]\n",
" A, cache = self.forward_prop(W, b, A, activation)\n",
" caches.append(cache)\n",
" return A, caches\n",
" \n",
" def compute_cost(self, A, Y):\n",
" m = Y.shape[0]\n",
" try:\n",
" cost = -1 / m * np.sum(Y * np.log(A) + (1 - Y) * np.log(1 - A))\n",
" except ZeroDivisionError as err:\n",
" print(err) \n",
" os._exit(1)\n",
" return cost\n",
"\n",
" def backward_prop(self, dZ, cache, m, activation):\n",
" Z = cache['Z'] \n",
" A_prev = cache['A_prev'] \n",
" W = cache['W']\n",
" b = cache['b']\n",
" if activation == \"softmax\":\n",
" dW = 1/m * np.dot(A_prev.T, dZ)\n",
" db = 1/m * np.sum(dZ, axis=0)\n",
" dA_prev = np.dot(dZ, W.T) * (1-np.power(A_prev,2))\n",
" ##dA_prev = np.dot(dZ, W.T)\n",
" if activation == \"relu\":\n",
" dZ[Z <= 0] = 0\n",
" dW = 1/m * np.dot(A_prev.T, dZ)\n",
" db = 1/m * np.sum(dZ, axis=0)\n",
" dA_prev = np.dot(dZ, W.T)\n",
" if activation == \"leakyrelu\":\n",
" dZ[Z <= 0] * 0.01\n",
" dW = 1/m * np.dot(A_prev.T, dZ)\n",
" db = 1/m * np.sum(dZ, axis=0)\n",
" dA_prev = np.dot(dZ, W.T)\n",
" if activation == \"tanh\":\n",
" dW = 1/m * np.dot(A_prev.T, dZ)\n",
" db = 1/m * np.sum(dZ, axis=0)\n",
" dA_prev = np.dot(dZ, W.T)\n",
" return dA_prev, dW, db\n",
" \n",
" def L_model_backward(self, A, caches, X, Y):\n",
" \"\"\"\n",
" cache = {'Z':Z, 'A':A, 'A_prev':A_prev, 'W':W, 'b':b}\n",
" \"\"\"\n",
" grads = {}\n",
" m = X.shape[0]\n",
" L = len(caches)\n",
" dZ = A - Y\n",
" grads['dA_prev' + str(L)] = dZ\n",
" for l in reversed(range(L)):\n",
" # Softmax > relu\n",
" activation = self.layers[l+1]['activation']\n",
" dA_prev, dW, db = self.backward_prop(grads['dA_prev' + str(l+1)], caches[l], m, activation)\n",
" grads[\"dA_prev\" + str(l)] = dA_prev\n",
" grads[\"dW\" + str(l+1)] = dW\n",
" grads[\"db\" + str(l+1)] = db\n",
" return grads\n",
"\n",
" def update_parameters(self, parameters, grads, learning_rate):\n",
" L = len(parameters) // 2\n",
" for l in range(1, len(self.layers)):\n",
" parameters['W' + str(l)] = parameters['W' + str(l)] - learning_rate * grads['dW' + str(l)] # (m, hidden_size)\n",
" parameters['b' + str(l)] = parameters['b' + str(l)] - learning_rate * grads['db' + str(l)] # (m, hidden_size)\n",
" return parameters\n",
"\n",
" def update_parameters_with_adam(self, parameters, grads, v, s, t, learning_rate,\n",
" beta1=0.9, beta2=0.999, epsilon=1e-8):\n",
" v_corrected = {}\n",
" s_corrected = {}\n",
" for l in range(1, len(self.layers)):\n",
" v['dW' + str(l)] = beta1 * v['dW' + str(l)] + (1 - beta1) * grads['dW' + str(l)]\n",
" v['db' + str(l)] = beta1 * v['db' + str(l)] + (1 - beta1) * grads['db' + str(l)]\n",
" v_corrected['dW' + str(l)] = v['dW' + str(l)] / 1-np.power(beta1, t)\n",
" v_corrected['db' + str(l)] = v['db' + str(l)] / 1-np.power(beta1, t)\n",
" s['dW' + str(l)] = beta2 * s['dW' + str(l)] + (1 - beta2) * np.power(grads['dW' + str(l)], 2)\n",
" s['db' + str(l)] = beta2 * s['db' + str(l)] + (1 - beta2) * np.power(grads['db' + str(l)], 2)\n",
" s_corrected['dW' + str(l)] = s['dW' + str(l)] / 1-np.power(beta2, t)\n",
" s_corrected['db' + str(l)] = s['db' + str(l)] / 1-np.power(beta2, t)\n",
" parameters['W' + str(l)] = parameters['W' + str(l)] - learning_rate * (\n",
" v_corrected['dW' + str(l)] / (np.sqrt(np.abs(s_corrected['dW' + str(l)])) + epsilon))\n",
" parameters['b' + str(l)] = parameters['b' + str(l)] - learning_rate * (\n",
" v_corrected['db' + str(l)] / (np.sqrt(np.abs(s_corrected['db' + str(l)])) + epsilon))\n",
" return parameters, v, s\n",
" \n",
" def predict(self, parameters, X):\n",
" return self.L_model_forward(parameters, X)\n",
"\n",
" def evaluate(self, y_true, y_pred):\n",
" return np.sum(y_true * y_pred) / np.count_nonzero(y_true)\n",
" \n",
" def fit(self, X, Y, activation, optimizer, learning_rate=0.005, epochs=2,\n",
" batch_size=64, print_cost=True):\n",
" num_classes = Y.shape[1]\n",
" costs = []\n",
" accus = []\n",
" duration = 0\n",
" total_time = 0\n",
" \n",
" #parameters = self.initialize_parameters()\n",
" parameters = self.initialize_parameters_he()\n",
"\n",
" if optimizer == 'adam':\n",
" t = 0 # adam counter\n",
" v, s = self.initialize_adam(parameters)\n",
" elif optimizer == 'gd':\n",
" pass\n",
"\n",
" for i in range(1, epochs+1):\n",
" start = time.time()\n",
" mini_batches = ramdom_mini_batches(X, Y)\n",
" \n",
" for mini_batch in mini_batches:\n",
" mini_batch_X, mini_batch_Y = mini_batch\n",
" # 1. Forward propagation\n",
" A, caches = self.L_model_forward(parameters, mini_batch_X)\n",
" # 2. Compute cost\n",
" cost = self.compute_cost(A, mini_batch_Y)\n",
" # 3. Backward propagation\n",
" grads = self.L_model_backward(A, caches, mini_batch_X, mini_batch_Y)\n",
" # 4. Update parameters\n",
" if optimizer == 'adam':\n",
" t = t + 1 # Adam counter\n",
" parameters, v, s = self.update_parameters_with_adam(parameters, grads, v, s, t, learning_rate,\n",
" beta1=0.9, beta2=0.999, epsilon=1e-8)\n",
" elif optimizer == 'gd':\n",
" parameters = self.update_parameters(parameters, grads, learning_rate)\n",
" \n",
" # evalueate model\n",
" prob, _ = self.predict(parameters, X) # returns activation(probability) and cache\n",
" prob = to_categorical(prob.argmax(axis=1), num_classes)\n",
" acc = self.evaluate(Y, prob)\n",
" accus.append(acc)\n",
" costs.append(cost)\n",
" \n",
" end = time.time()\n",
" duration += (end - start)\n",
" total_time += duration\n",
" if print_cost and i % 1 == 0:\n",
" # evalueate model\n",
" print(\"{}/{} epochs time:{:.1f}s cost:{:.6f}, acc:{:.6f}\".format(i, epochs, duration, cost, acc))\n",
" duration = 0\n",
" \n",
" return parameters, costs, accus, total_time"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Training model\n",
"\n",
"Training model with following each step.\n",
"\n",
"1. L Model Forward propagation\n",
"1. Compute cost\n",
"1. L Model Backward propagation\n",
"1. Update parameters"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Hyper parameters"
]
},
{
"cell_type": "code",
"execution_count": 20,
"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>epochs</th>\n",
" <th>batch_size</th>\n",
" <th>activation</th>\n",
" <th>learning_rate</th>\n",
" <th>optimizer</th>\n",
" <th>lambd</th>\n",
" <th>regularization</th>\n",
" <th>print_cost</th>\n",
" <th>layer_dims</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>hyper params</th>\n",
" <td>6</td>\n",
" <td>128</td>\n",
" <td>tanh</td>\n",
" <td>0.05</td>\n",
" <td>gd</td>\n",
" <td>0.1</td>\n",
" <td>False</td>\n",
" <td>True</td>\n",
" <td>[784, 50, 10]</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" epochs batch_size activation learning_rate optimizer lambd \\\n",
"hyper params 6 128 tanh 0.05 gd 0.1 \n",
"\n",
" regularization print_cost layer_dims \n",
"hyper params False True [784, 50, 10] "
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"epochs = 6\n",
"batch_size = 128\n",
"optimizer = 'gd' # adam or gd(gradient descent)\n",
"lambd = 0.1\n",
"lr_activation = ('tanh', 0.05)\n",
"#lr_activation = ('tanh', 0.0007) #adam\n",
"#lr_activation = ('relu', 0.0075)\n",
"#lr_activation = ('relu', 0.0005) # adam\n",
"activation = lr_activation[0]\n",
"learning_rate = lr_activation[1]\n",
"regularization = False\n",
"print_cost = True\n",
"layer_dims = [784,50,10]\n",
"\n",
"hyper_params = {}\n",
"hyper_params['epochs'] = epochs\n",
"hyper_params['batch_size'] = batch_size\n",
"hyper_params['activation'] = activation\n",
"hyper_params['learning_rate'] = learning_rate\n",
"hyper_params['optimizer'] = optimizer\n",
"hyper_params['lambd'] = lambd \n",
"hyper_params['regularization'] = regularization\n",
"hyper_params['print_cost'] = print_cost\n",
"hyper_params['layer_dims'] = str(layer_dims)\n",
"\n",
"pd.DataFrame(hyper_params,index=[\"hyper params\",])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Define and train model"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[{'activation': '', 'input': 784},\n",
" {'activation': 'tanh', 'input': 50},\n",
" {'activation': 'softmax', 'input': 10}]\n"
]
}
],
"source": [
"model = DeepNN()\n",
"model.add(input=784)\n",
"model.add(input=50, activation=lr_activation[0])\n",
"model.add(input=10, activation='softmax')\n",
"pprint(model.layers)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"epochs:6\n",
"1/6 epochs time:3.2s cost:0.622414, acc:0.911883\n",
"2/6 epochs time:6.0s cost:0.535589, acc:0.926483\n",
"3/6 epochs time:6.2s cost:0.480691, acc:0.936250\n",
"4/6 epochs time:7.5s cost:0.434851, acc:0.942650\n",
"5/6 epochs time:5.6s cost:0.394968, acc:0.947933\n",
"6/6 epochs time:5.9s cost:0.360442, acc:0.952333\n",
"cost:0.360 accuracy:0.952 time:34.4s\n"
]
},
{
"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>epochs</th>\n",
" <th>batch_size</th>\n",
" <th>activation</th>\n",
" <th>learning_rate</th>\n",
" <th>optimizer</th>\n",
" <th>lambd</th>\n",
" <th>regularization</th>\n",
" <th>print_cost</th>\n",
" <th>layer_dims</th>\n",
" <th>cost</th>\n",
" <th>accuracy</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>deep_l3_tanh_w_6.gz</th>\n",
" <td>6</td>\n",
" <td>128</td>\n",
" <td>tanh</td>\n",
" <td>0.05</td>\n",
" <td>gd</td>\n",
" <td>0.1</td>\n",
" <td>False</td>\n",
" <td>True</td>\n",
" <td>[784, 50, 10]</td>\n",
" <td>0.360442</td>\n",
" <td>0.952333</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" epochs batch_size activation learning_rate optimizer \\\n",
"deep_l3_tanh_w_6.gz 6 128 tanh 0.05 gd \n",
"\n",
" lambd regularization print_cost layer_dims \\\n",
"deep_l3_tanh_w_6.gz 0.1 False True [784, 50, 10] \n",
"\n",
" cost accuracy \n",
"deep_l3_tanh_w_6.gz 0.360442 0.952333 "
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"weight_file = 'deep_l{}_{}_w_{}.gz'.format(len(layer_dims), activation, epochs) \n",
"history_file = 'deep_l{}_{}_h_{}.gz'.format(len(layer_dims), activation, epochs)\n",
"\n",
"history_data = []\n",
"print(\"\\nepochs:{}\".format(epochs))\n",
"if not os.path.exists(weight_file):\n",
" parameters, costs, accuracy, total_time = model.fit(X_train, \n",
" categorical_Y_train, \n",
" activation, \n",
" optimizer, \n",
" learning_rate,\n",
" epochs, \n",
" batch_size,\n",
" print_cost=print_cost)\n",
" history_data.append(costs)\n",
" history_data.append(accuracy)\n",
" hyper_params['cost'] = costs[-1]\n",
" hyper_params['accuracy']= accuracy[-1]\n",
" print(\"cost:{:.3f} accuracy:{:.3f} time:{:.1f}s\".format(costs[-1], accuracy[-1], total_time))\n",
" \n",
" # save model weight\n",
" parameters['h'] = hyper_params\n",
" with open(weight_file, 'wb') as f:\n",
" joblib.dump(parameters, f, compress='gzip')\n",
" with open(history_file, 'wb') as f:\n",
" joblib.dump(history_data, f, compress='gzip')\n",
"else:\n",
" with open(weight_file, 'rb') as f:\n",
" parameters = joblib.load(f)\n",
" with open(history_file, 'rb') as f:\n",
" history_data = joblib.load(f)\n",
" print(\"loading parameters from {}\".format(weight_file))\n",
" hyper_params = parameters['h'] \n",
"pd.DataFrame(hyper_params,index=[weight_file,])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Cost and accuracy"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"cost:0.360, accuracy:0.952\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"if os.path.exists(history_file):\n",
" with open(history_file, 'rb') as f:\n",
" history_data = joblib.load(f)\n",
" print(\"cost:{:.3f}, accuracy:{:.3f}\".format(history_data[0][-1],history_data[1][-1]))\n",
"plot_history(history_data, learning_rate=learning_rate)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Evaluate model"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Accuracy with Test data"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"train accuracy: 95.2333%\n",
"test accuracy: 94.8600%\n"
]
}
],
"source": [
"# get all prediction\n",
"prob_train, _ = model.predict(parameters, X_train)\n",
"prob_test, _ = model.predict(parameters, X_test)\n",
"\n",
"# convert probability to prediction(0 ~ 9) \n",
"Y_pred_train = prob_train.argmax(axis=1)\n",
"Y_pred_test = prob_test.argmax(axis=1)\n",
"\n",
"# convert prediction to categorial data\n",
"categorical_Y_pred_train = to_categorical(Y_pred_train, 10)\n",
"categorical_Y_pred_test = to_categorical(Y_pred_test, 10)\n",
"acc_train = model.evaluate(categorical_Y_train, categorical_Y_pred_train)\n",
"acc_test = model.evaluate(categorical_Y_test, categorical_Y_pred_test)\n",
"print(\"train accuracy: {:.4%}\".format(acc_train))\n",
"print(\"test accuracy: {:.4%}\".format(acc_test))"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"showing predction 20 examples randomly...\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 720x216 with 20 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"num = 20 \n",
"print(\"\\nshowing predction {} examples randomly...\".format(num))\n",
"rand_idx = list(np.random.permutation(num))\n",
"\n",
"show_digits(X_test[rand_idx].reshape(num, 28,28), Y_test[rand_idx], Y_pred=Y_pred_test[rand_idx], num=num)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Failed predictions"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Failed predictions (514/10000)\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 720x216 with 20 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"failed_idx = np.where(Y_test != Y_pred_test)[0]\n",
"print(\"Failed predictions ({}/{})\".format(len(failed_idx), Y_test.shape[0]))\n",
"show_digits(X_test[failed_idx].reshape(failed_idx.shape[0], 28,28), Y_test[failed_idx], Y_pred_test[failed_idx], num=20)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Confusion matrix and F1 Score"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"confusion_matrix\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 504x432 with 2 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"classification_report\n",
"\n",
" precision recall f1-score support\n",
"\n",
" 0 0.99 0.96 0.97 1012\n",
" 1 0.98 0.98 0.98 1136\n",
" 2 0.94 0.94 0.94 1030\n",
" 3 0.94 0.95 0.95 1004\n",
" 4 0.96 0.92 0.94 1028\n",
" 5 0.93 0.94 0.94 883\n",
" 6 0.94 0.96 0.95 946\n",
" 7 0.94 0.96 0.95 1010\n",
" 8 0.94 0.92 0.93 991\n",
" 9 0.91 0.96 0.93 960\n",
"\n",
" accuracy 0.95 10000\n",
" macro avg 0.95 0.95 0.95 10000\n",
"weighted avg 0.95 0.95 0.95 10000\n",
"\n"
]
}
],
"source": [
"from sklearn.metrics import classification_report, confusion_matrix\n",
"import pandas as pd\n",
"import seaborn as sns\n",
"\n",
"print('confusion_matrix')\n",
"plt.figure(figsize=(7, 6))\n",
"ax = plt.axes()\n",
"sns.heatmap(confusion_matrix(Y_pred_test, Y_test), cmap='Greys', annot=True, fmt=\"d\", ax=ax)\n",
"ax.set_title('mnist digits: lable {}'.format(\"Y_test\"))\n",
"plt.show()\n",
"\n",
"print('\\nclassification_report\\n\\n', classification_report(Y_pred_test, Y_test))\n",
"#report = classification_report(y_pred_test, Y_test, output_dict=True)\n",
"#pd.DataFrame(report).transpose()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Review result"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['./deep_l3_tanh_w_6.gz']\n"
]
},
{
"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>epochs</th>\n",
" <th>batch_size</th>\n",
" <th>activation</th>\n",
" <th>learning_rate</th>\n",
" <th>optimizer</th>\n",
" <th>lambd</th>\n",
" <th>regularization</th>\n",
" <th>print_cost</th>\n",
" <th>layer_dims</th>\n",
" <th>cost</th>\n",
" <th>accuracy</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>./deep_l3_tanh_w_6.gz</th>\n",
" <td>6</td>\n",
" <td>128</td>\n",
" <td>tanh</td>\n",
" <td>0.05</td>\n",
" <td>gd</td>\n",
" <td>0.1</td>\n",
" <td>False</td>\n",
" <td>True</td>\n",
" <td>[784, 50, 10]</td>\n",
" <td>0.360442</td>\n",
" <td>0.952333</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" epochs batch_size activation learning_rate optimizer \\\n",
"./deep_l3_tanh_w_6.gz 6 128 tanh 0.05 gd \n",
"\n",
" lambd regularization print_cost layer_dims \\\n",
"./deep_l3_tanh_w_6.gz 0.1 False True [784, 50, 10] \n",
"\n",
" cost accuracy \n",
"./deep_l3_tanh_w_6.gz 0.360442 0.952333 "
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from glob import glob\n",
"\n",
"weight_files = glob('./deep_l*_w_*.gz')\n",
"print(weight_files)\n",
"\n",
"for i, weight_file in enumerate(weight_files):\n",
" with open(weight_file, 'rb') as f:\n",
" parameters = joblib.load(f)\n",
" hyper_params= parameters['h'] \n",
" if i == 0:\n",
" df = pd.DataFrame(hyper_params,index=[weight_file,])\n",
" else:\n",
" df = df.append(pd.DataFrame(hyper_params,index=[weight_file,]))\n",
"df.sort_values(by=['accuracy'], ascending=False)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "scrach-ml",
"language": "python",
"name": "scrach-ml"
},
"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.9"
},
"toc": {
"base_numbering": 1,
"nav_menu": {},
"number_sections": true,
"sideBar": true,
"skip_h1_title": false,
"title_cell": "Table of Contents",
"title_sidebar": "Contents",
"toc_cell": false,
"toc_position": {
"height": "calc(100% - 180px)",
"left": "10px",
"top": "150px",
"width": "286.997px"
},
"toc_section_display": true,
"toc_window_display": true
},
"toc-autonumbering": true
},
"nbformat": 4,
"nbformat_minor": 4
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment