NN_MNIST_HW.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "NN_MNIST_HW.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "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.8.5"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/paddy3696/NN_from_scratch/blob/main/NN_MNIST_HW.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jqPJLUzrO2uD"
      },
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "#from keras.datasets import fashion_mnist\n",
        "from keras.datasets import mnist\n",
        "from sklearn.metrics import classification_report, accuracy_score, confusion_matrix\n",
        "from sklearn.model_selection import train_test_split"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "45EVqmwTiYtO"
      },
      "source": [
        "def one_hot(y, n_labels):\n",
        "    mat = np.zeros((len(y), n_labels))\n",
        "    for i, val in enumerate(y):\n",
        "        mat[i, val] = 1\n",
        "    return mat.T"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LZf4LhTynL-M"
      },
      "source": [
        "class MyNN(object):\n",
        "\n",
        "    def __init__(self,network_size,network_fns,wb_init='he',learning_rate=1e-3,loss_fn = 'crossE',\n",
        "                 optimizer = 'NADAM',keep_proba=1,regularize='l2',batch_size=32,\n",
        "                 max_epoch=30,alpha=0,beta_1=0.9,beta_2=0.999,seed=None,verbose=0):\n",
        "        \n",
        "        self.network_size = network_size\n",
        "        self.network_fns = network_fns\n",
        "        self.wb_init = wb_init\n",
        "        self.loss_fn = loss_fn\n",
        "        self.learning_rate = learning_rate\n",
        "        self.alpha = alpha\n",
        "        self.beta_1 = beta_1\n",
        "        self.beta_2 = beta_2\n",
        "        self.optimizer = optimizer\n",
        "        self.batch_size = batch_size\n",
        "        self.keep_proba = keep_proba\n",
        "        self.regularize = regularize\n",
        "        self.seed = seed\n",
        "        self.max_epoch = max_epoch\n",
        "        self.verbose = verbose\n",
        "\n",
        "    @staticmethod\n",
        "    def weights_init(network_size,wb_init='he',seed=None):\n",
        "        \n",
        "        np.random.seed(seed)\n",
        "        values = {}\n",
        "        opt_values = {}\n",
        "        L = len(network_size)            # number of layers in the network\n",
        "        if  wb_init == 'he':\n",
        "            for l in range(1, L):\n",
        "                values['W' + str(l)] = np.random.normal(0,np.sqrt(2.0/network_size[l-1]),(network_size[l], network_size[l-1]))\n",
        "                values['b' + str(l)] = np.random.normal(0,np.sqrt(2.0/network_size[l-1]),(network_size[l], 1))  \n",
        "               \n",
        "        elif wb_init == 'xavier_uniform':\n",
        "            for l in range(1, L):\n",
        "                values['W' + str(l)] = np.random.uniform(-(np.sqrt(6.0/(network_size[l]+network_size[l-1]))),\n",
        "                                                        (np.sqrt(6.0/(network_size[l]+network_size[l-1]))),\n",
        "                                                        (network_size[l], network_size[l-1]))\n",
        "                values['b' + str(l)] = np.random.uniform(-(np.sqrt(6.0/(network_size[l]+network_size[l-1]))),\n",
        "                                                        (np.sqrt(6.0/(network_size[l]+network_size[l-1]))),\n",
        "                                                        (network_size[l], 1))\n",
        "\n",
        "        return values\n",
        "    \n",
        "    @staticmethod\n",
        "    def ReLU(X,alpha=0,derivative=False):\n",
        "        X = np.array(X,dtype=np.float64)\n",
        "        if derivative == False:\n",
        "            return np.where(X<0,alpha*X,X)\n",
        "        elif derivative == True:\n",
        "            X_relu = np.ones_like(X,dtype=np.float64)\n",
        "            X_relu[X < 0] = alpha\n",
        "            return X_relu\n",
        "\n",
        "    @staticmethod\n",
        "    def sigmoid(X,derivative=False):\n",
        "        if derivative == False:\n",
        "            out = 1 / (1 + np.exp(-np.array(X)))\n",
        "        elif derivative == True:\n",
        "            s = 1 / (1 + np.exp(-np.array(X)))\n",
        "            out = s*(1-s)\n",
        "        return out\n",
        "    \n",
        "    @staticmethod\n",
        "    def Tanh(X,derivative=False):\n",
        "        X = np.array(X)\n",
        "        if derivative == False:\n",
        "            return np.tanh(X)\n",
        "        if derivative == True:\n",
        "            return 1 - (np.tanh(X))**2\n",
        "            \n",
        "    @staticmethod\n",
        "    def softmax(X):\n",
        "        return np.exp(X) / np.sum(np.exp(X),axis=0)\n",
        "    \n",
        "    @staticmethod\n",
        "    def forward_prop(X, network_fns,values,keep_prob=1,seed=None):\n",
        "    \n",
        "        if seed != None:\n",
        "            np.random.seed(seed)\n",
        "        caches = []\n",
        "        A = X\n",
        "        L = len(network_fns)\n",
        "        for l,act_fn in enumerate(network_fns,start=1):\n",
        "            A_prev = A \n",
        "        \n",
        "            Z = np.dot(values['W' + str(l)],A_prev)+values['b' + str(l)]\n",
        "            \n",
        "            if type(act_fn) is tuple:\n",
        "                \n",
        "                if  act_fn[0] == \"relu\":\n",
        "                    A = MyNN.ReLU(Z,act_fn[1])\n",
        "            else:\n",
        "                if act_fn == \"sigmoid\":\n",
        "                    A = MyNN.sigmoid(Z)\n",
        "                elif act_fn == \"tanh\":\n",
        "                    A = MyNN.Tanh(Z)\n",
        "                elif act_fn == \"softmax\":\n",
        "                    A = MyNN.softmax(Z)\n",
        "                elif  act_fn == \"relu\":\n",
        "                    A = MyNN.ReLU(Z)\n",
        "            \n",
        "            if keep_prob != 1 and l != L and l != 1:\n",
        "                D = np.random.rand(A.shape[0],A.shape[1])\n",
        "                D = (D<keep_prob)\n",
        "                A = np.multiply(A,D)\n",
        "                A = A / keep_prob\n",
        "                cache = ((A_prev, values['W' + str(l)],values['b' + str(l)],D), Z)\n",
        "                caches.append(cache)\n",
        "            else:\n",
        "                cache = ((A_prev, values['W' + str(l)],values['b' + str(l)]), Z)\n",
        "                #print(A.shape)\n",
        "                caches.append(cache)      \n",
        "        return A, caches\n",
        "\n",
        "    @staticmethod\n",
        "    def compute_loss(A, Y, values, alpha=0,regularize=None,loss_fn='crossE'):\n",
        "\n",
        "        m = Y.shape[1]\n",
        "    \n",
        "        if loss_fn == 'crossE':\n",
        "            loss = np.squeeze(-np.sum(np.multiply(np.log(A),Y))/m)    \n",
        "        elif loss_fn == 'mse':\n",
        "            loss = np.squeeze(np.sum((Y - A)**2)/m)\n",
        "\n",
        "        L = len(values)//2\n",
        "    \n",
        "        if regularize == 'l2' and alpha != 0:\n",
        "            sum_weights = 0\n",
        "            for l in range(1, L):\n",
        "                sum_weights = sum_weights + np.sum(np.square(values['W' + str(l)]))\n",
        "            loss = loss + sum_weights * (alpha/(2*m))\n",
        "        elif regularize == 'l1' and alpha != 0:\n",
        "            sum_weights = 0\n",
        "            for l in range(1, L):\n",
        "                sum_weights = sum_weights + np.sum(np.abs(values['W' + str(l)]))\n",
        "            loss = loss + sum_weights * (alpha/(2*m))\n",
        "        return loss\n",
        "\n",
        "    @staticmethod\n",
        "    def back_prop(AL, Y, caches, network_fns, keep_prob=1, regularize=None,alpha=0,loss_fn='crossE'):\n",
        "\n",
        "        grads = {}\n",
        "        L = len(caches)\n",
        "    \n",
        "        m = AL.shape[1]\n",
        "        Y = Y.reshape(AL.shape)\n",
        "    \n",
        "        # Initializing the backprop\n",
        "        if loss_fn == 'crossE':\n",
        "            dZL = AL - Y\n",
        "        elif loss_fn == 'mse':\n",
        "            dZL = 2 * (AL - Y)\n",
        "    \n",
        "        cache = caches[L-1]\n",
        "        linear_cache, activation_cache = cache\n",
        "        AL, W, b = linear_cache\n",
        "        grads[\"dW\" + str(L)] = np.dot(dZL,AL.T)/m\n",
        "        grads[\"db\" + str(L)] = np.sum(dZL,axis=1,keepdims=True)/m\n",
        "        grads[\"dA\" + str(L-1)] = np.dot(W.T,dZL)\n",
        "    \n",
        "            \n",
        "        v_dropout = 0\n",
        "        for l in reversed(range(L-1)):\n",
        "            cache = caches[l]\n",
        "            act_fn = network_fns[l]\n",
        "        \n",
        "            linear_cache, Z = cache\n",
        "            try:\n",
        "                A_prev, W, b = linear_cache\n",
        "            except:\n",
        "                A_prev, W, b, D = linear_cache\n",
        "                v_dropout = 1\n",
        "            \n",
        "            m = A_prev.shape[1]\n",
        "        \n",
        "            if keep_prob != 1 and v_dropout == 1:\n",
        "                dA_prev = np.multiply(grads[\"dA\" + str(l + 1)],D)\n",
        "                dA_prev = dA_prev/keep_prob\n",
        "                v_dropout = 0\n",
        "            else:\n",
        "                dA_prev = grads[\"dA\" + str(l + 1)]\n",
        "                v_dropout = 0\n",
        "            \n",
        "            \n",
        "            if type(act_fn) is tuple:\n",
        "                \n",
        "                if  act_fn[0] == \"relu\":\n",
        "                    dZ = np.multiply(dA_prev,MyNN.ReLU(Z,act_fn[1],derivative=True))\n",
        "\n",
        "            else:\n",
        "                if act_fn == \"sigmoid\":\n",
        "                    dZ = np.multiply(dA_prev,MyNN.sigmoid(Z,derivative=True))\n",
        "                elif act_fn == \"relu\":\n",
        "                    dZ = np.multiply(dA_prev,MyNN.ReLU(Z,derivative=True))\n",
        "                elif act_fn == \"tanh\":\n",
        "                    dZ = np.multiply(dA_prev,MyNN.Tanh(Z,derivative=True))\n",
        "            \n",
        "            grads[\"dA\" + str(l)] = np.dot(W.T,dZ)\n",
        "        \n",
        "            if regularize == 'l2':\n",
        "                grads[\"dW\" + str(l + 1)] = (np.dot(dZ,A_prev.T)/m)  + ((alpha * W)/m)\n",
        "            elif regularize == 'l1':\n",
        "                grads[\"dW\" + str(l + 1)] = (np.dot(dZ,A_prev.T)/m)  + ((alpha * np.sign(W+10**-8))/m)\n",
        "            else:\n",
        "                grads[\"dW\" + str(l + 1)] = (np.dot(dZ,A_prev.T)/m)\n",
        "            \n",
        "            grads[\"db\" + str(l + 1)] = np.sum(dZ,axis=1,keepdims=True)/m   \n",
        "        return grads\n",
        "    \n",
        "    @staticmethod\n",
        "    def update_values(values, grads,learning_rate,iter_no,method = 'SGD',opt_values=None,beta_1=0.9,beta_2=0.999):\n",
        "    \n",
        "        L = len(values) // 2 \n",
        "        if method == 'SGD':\n",
        "            for l in range(L):\n",
        "                values[\"W\" + str(l+1)] = values[\"W\" + str(l+1)] - learning_rate*grads[\"dW\" + str(l + 1)]\n",
        "                values[\"b\" + str(l+1)] = values[\"b\" + str(l+1)] - learning_rate*grads[\"db\" + str(l + 1)]\n",
        "            opt_values = None\n",
        "        elif method == 'SGDM':\n",
        "            for l in range(L):\n",
        "                opt_values['vdb'+str(l+1)] = beta_1*opt_values['vdb'+str(l+1)] + (1-beta_1)*grads[\"db\" + str(l + 1)]\n",
        "                opt_values['vdw'+str(l+1)] = beta_1*opt_values['vdw'+str(l+1)] + (1-beta_1)*grads[\"dW\" + str(l + 1)]\n",
        "                values[\"W\" + str(l+1)] = values[\"W\" + str(l+1)] - learning_rate*opt_values['vdw'+str(l+1)]\n",
        "                values[\"b\" + str(l+1)] = values[\"b\" + str(l+1)] - learning_rate*opt_values['vdb'+str(l+1)]\n",
        "        elif method == 'RMSP':\n",
        "            for l in range(L):\n",
        "                opt_values['sdb'+str(l+1)] = beta_2*opt_values['sdb'+str(l+1)] + \\\n",
        "                                                     (1-beta_2)*np.square(grads[\"db\" + str(l + 1)])\n",
        "                opt_values['sdw'+str(l+1)] = beta_2*opt_values['sdw'+str(l+1)] + \\\n",
        "                                                           (1-beta_2)*np.square(grads[\"dW\" + str(l + 1)])\n",
        "                values[\"W\" + str(l+1)] = values[\"W\" + str(l+1)] - \\\n",
        "                                       learning_rate*(grads[\"dW\" + str(l + 1)]/(np.sqrt(opt_values['sdw'+str(l+1)])+10**-8))\n",
        "                values[\"b\" + str(l+1)] = values[\"b\" + str(l+1)] - \\\n",
        "                                       learning_rate*(grads[\"db\" + str(l + 1)]/(np.sqrt(opt_values['sdb'+str(l+1)])+10**-8))\n",
        "        elif method == 'ADAM':\n",
        "            for l in range(L):\n",
        "                opt_values['vdb'+str(l+1)] = beta_1*opt_values['vdb'+str(l+1)] + (1-beta_1)*grads[\"db\" + str(l + 1)]\n",
        "                opt_values['vdw'+str(l+1)] = beta_1*opt_values['vdw'+str(l+1)] + (1-beta_1)*grads[\"dW\" + str(l + 1)]\n",
        "                opt_values['sdb'+str(l+1)] = beta_2*opt_values['sdb'+str(l+1)] + \\\n",
        "                                                                  (1-beta_2)*np.square(grads[\"db\" + str(l + 1)])\n",
        "                opt_values['sdw'+str(l+1)] = beta_2*opt_values['sdw'+str(l+1)] + \\\n",
        "                                                                   (1-beta_2)*np.square(grads[\"dW\" + str(l + 1)])\n",
        "            \n",
        "                learning_rate = learning_rate * np.sqrt((1-beta_2**iter_no)/((1-beta_1**iter_no)+10**-8))\n",
        "                values[\"W\" + str(l+1)] = values[\"W\" + str(l+1)] - \\\n",
        "                                       learning_rate*(opt_values['vdw'+str(l+1)]/\\\n",
        "                                                      (np.sqrt(opt_values['sdw'+str(l+1)])+10**-8))\n",
        "                values[\"b\" + str(l+1)] = values[\"b\" + str(l+1)] - \\\n",
        "                                       learning_rate*(opt_values['vdb'+str(l+1)]/\\\n",
        "                                                      (np.sqrt(opt_values['sdb'+str(l+1)])+10**-8))\n",
        "        \n",
        "        elif method == 'NADAM':\n",
        "            for l in range(L):\n",
        "                opt_values['vdb'+str(l+1)] = beta_1*opt_values['vdb'+str(l+1)] + (1-beta_1)*grads[\"db\" + str(l + 1)]\n",
        "                opt_values['vdw'+str(l+1)] = beta_1*opt_values['vdw'+str(l+1)] + (1-beta_1)*grads[\"dW\" + str(l + 1)]\n",
        "                opt_values['sdb'+str(l+1)] = beta_2*opt_values['sdb'+str(l+1)] + \\\n",
        "                                                                  (1-beta_2)*np.square(grads[\"db\" + str(l + 1)])\n",
        "                opt_values['sdw'+str(l+1)] = beta_2*opt_values['sdw'+str(l+1)] + \\\n",
        "                                                                   (1-beta_2)*np.square(grads[\"dW\" + str(l + 1)])\n",
        "            \n",
        "                \n",
        "                learning_rate = learning_rate * np.sqrt((1-beta_2**iter_no)/((1-beta_1**iter_no)+10**-8))\n",
        "                values[\"W\" + str(l+1)] = values[\"W\" + str(l+1)] - \\\n",
        "                                       learning_rate*((beta_1*opt_values['vdw'+str(l+1)])/\\\n",
        "                                                      (np.sqrt(opt_values['sdw'+str(l+1)])+10**-8))\n",
        "                values[\"b\" + str(l+1)] = values[\"b\" + str(l+1)] - \\\n",
        "                                       learning_rate*((beta_1*opt_values['vdb'+str(l+1)]+ (1-beta_1)*grads[\"db\" + str(l + 1)])/\\\n",
        "                                                      (np.sqrt(opt_values['sdb'+str(l+1)])+10**-8))\n",
        "        \n",
        "        return values,opt_values\n",
        "    \n",
        "    def fit(self,X,y,x_valid,y_valid):\n",
        "\n",
        "        x_train = X\n",
        "        y_train = y\n",
        "        X_valid = X\n",
        "        Y_valid = y\n",
        "        y = one_hot(y, 10)\n",
        "        np.random.seed(self.seed)\n",
        "        self.grads = {}\n",
        "        self.losss = []\n",
        "        M = X.shape[1]\n",
        "        opt_values = {}\n",
        "        \n",
        "        if self.verbose == 1:\n",
        "            print('Initilizing Weights...')\n",
        "        self.values = self.weights_init(self.network_size,self.wb_init,self.seed)\n",
        "        self.iter_no = 0\n",
        "        idx = np.arange(0,M)\n",
        "        \n",
        "        if self.optimizer != 'SGD':\n",
        "            for l in range(1, len(self.network_size)):\n",
        "                opt_values['vdw' + str(l)] = np.zeros((self.network_size[l], self.network_size[l-1]))\n",
        "                opt_values['vdb' + str(l)] = np.zeros((self.network_size[l], 1))\n",
        "                opt_values['sdw' + str(l)] = np.zeros((self.network_size[l], self.network_size[l-1]))\n",
        "                opt_values['sdb' + str(l)] = np.zeros((self.network_size[l], 1)) \n",
        "        \n",
        "        if self.verbose == 1:\n",
        "            print('Starting Training...')\n",
        "            \n",
        "        for epoch_no in range(1,self.max_epoch+1):\n",
        "            acc_epoch = []\n",
        "            np.random.shuffle(idx)\n",
        "            X = X[:,idx]\n",
        "            y = y[:,idx]\n",
        "            for i in range(0,M, self.batch_size):\n",
        "                self.iter_no = self.iter_no + 1\n",
        "                X_batch = X[:,i:i + self.batch_size]\n",
        "                y_batch = y[:,i:i + self.batch_size]\n",
        "                # Forward prop:\n",
        "                AL, cache = self.forward_prop(X_batch,self.network_fns,self.values,self.keep_proba,self.seed)\n",
        "                #loss\n",
        "                loss = self.compute_loss(AL, y_batch, self.values,self.alpha,self.regularize,self.loss_fn)\n",
        "                self.losss.append(loss)\n",
        "                \n",
        "                \n",
        "                #back prop\n",
        "                grads = self.back_prop(AL, y_batch, cache,self.network_fns,self.keep_proba,self.regularize,self.alpha,self.loss_fn)\n",
        "                \n",
        "                #update params\n",
        "                self.values,opt_values = self.update_values(self.values,grads,self.learning_rate,\n",
        "                                                                        self.iter_no-1,self.optimizer,\n",
        "                                                                        opt_values,self.beta_1,self.beta_2)\n",
        "                                \n",
        "                if self.verbose == 1:\n",
        "                    if self.iter_no % 1000 == 0:\n",
        "                        \n",
        "                        print(\"loss after iteration {}: {}\".format(self.iter_no, loss))\n",
        "                        #wandb.log({'Training Error' : loss}\n",
        "                \n",
        "                #wandb.log({'Training Loss' : loss})\n",
        "                \n",
        "\n",
        "            y_pred_train = self.predict(x_train)\n",
        "            y_pred_valid = self.predict(x_valid)\n",
        "\n",
        "            train_acc = accuracy_score(y_train, y_pred_train)\n",
        "            valid_acc = accuracy_score(y_valid, y_pred_valid)\n",
        "\n",
        "            if self.verbose == 1:\n",
        "              print('Train Accuracy: %.2f%%' % (train_acc * 100))\n",
        "              print('Validation Accuracy: %.2f%%' % (valid_acc * 100))\n",
        "            \n",
        "            #wandb.log({'Training accuracy per epoch' : train_acc})\n",
        "            #wandb.log({'Validation accuracy per epoch' : valid_acc})\n",
        "            acc_epoch.append(valid_acc)\n",
        "\n",
        "        acc_best = max(acc_epoch)\n",
        "        if self.verbose == 1:\n",
        "          print('Best Validation Accuracy: %.2f%%' % (acc_best * 100))\n",
        "          \n",
        "        #wandb.log({'accuracy' : valid_acc})\n",
        "        return self\n",
        "    def predict(self,X,proba=False):\n",
        "        \n",
        "        out, _ = self.forward_prop(X,self.network_fns,self.values,self.keep_proba,self.seed)\n",
        "        if proba == True:\n",
        "            return out.T\n",
        "        else:\n",
        "            return np.argmax(out, axis=0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 278
        },
        "id": "x07iER-4Y5os",
        "outputId": "b549e28d-d1e7-4358-feeb-82d49e9d1a28"
      },
      "source": [
        "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
        "\n",
        "\n",
        "class_num = 10\n",
        "num_row = 2\n",
        "num_col = 5# plot images\n",
        "fig, axes = plt.subplots(num_row, num_col, figsize=(1.5*num_col,2*num_row))\n",
        "for i in range(class_num):\n",
        "  ax = axes[i//num_col, i%num_col]\n",
        "  a = np.argmax(y_train == i)\n",
        "  ax.imshow(x_train[a], cmap='gray')\n",
        "  ax.set_title('Label: {}'.format(y_train[a]))\n",
        "plt.tight_layout()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 540x288 with 10 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N49PTE5dLDDX"
      },
      "source": [
        "x_train, x_valid, y_train, y_valid = train_test_split(x_train, y_train, test_size=0.1, random_state=0, stratify=y_train)\n",
        "\n",
        "x_train = x_train.reshape((len(x_train), 28*28))\n",
        "x_train = x_train.astype('float32') / 255\n",
        "\n",
        "x_valid = x_valid.reshape((len(x_valid), 28*28))\n",
        "x_valid = x_valid.astype('float32') / 255\n",
        "\n",
        "# Preprocessing test data\n",
        "x_test = x_test.reshape((len(x_test), 28 * 28))\n",
        "x_test = x_test.astype('float32') / 225\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IfiZKC08QBLD"
      },
      "source": [
        "def model_test(n_hidden,n_class,hidden_size,activation,max_epoch,alpha,batch_size,optimizer,learning_rate,wb_init,loss_fn):\n",
        "      \n",
        "  X = x_train.T\n",
        "  X_valid = x_valid.T\n",
        "  Y_valid = y_valid\n",
        "  Y = y_train\n",
        "  \n",
        "  layers = []\n",
        "  for i in range(n_hidden+2):\n",
        "    if i == 0:\n",
        "        layers.append(X.shape[0])\n",
        "    elif i == n_hidden+1:\n",
        "        layers.append(n_class)\n",
        "    else:\n",
        "        layers.append(hidden_size)\n",
        "    i = i+1\n",
        "\n",
        "  #print(layers)\n",
        "\n",
        "  o_act = 'softmax'\n",
        "  if activation == 'relu':\n",
        "    actvn_fn = ('relu',0)\n",
        "  else:\n",
        "    actvn_fn = activation\n",
        "\n",
        "  act = []\n",
        "  for i in range(n_hidden+1):\n",
        "    if i == n_hidden:\n",
        "      act.append(o_act)\n",
        "    else:\n",
        "      act.append(actvn_fn)\n",
        "    i = i+1\n",
        "\n",
        "  #print(act)\n",
        "\n",
        "  model = MyNN(network_size=layers,network_fns=act,batch_size = batch_size, loss_fn=loss_fn,\n",
        "             optimizer=optimizer,regularize= 'l2',alpha = alpha, wb_init = wb_init, learning_rate = learning_rate,\n",
        "             max_epoch=max_epoch,verbose=0,seed=25)\n",
        "    \n",
        "  model.fit(X,Y,X_valid,Y_valid)\n",
        "    \n",
        "  X_test = x_test.T\n",
        "  y_pred= model.predict(X_test)\n",
        "\n",
        "    #print(y_pred)\n",
        "  print('Test Accuracy: %.2f%%' % (accuracy_score(y_test, y_pred)*100))\n",
        "    \n",
        "  cf_matrix = confusion_matrix(y_test, y_pred)\n",
        "\n",
        "  import seaborn as sns\n",
        "  fig, ax = plt.subplots(figsize=(20,14))    \n",
        "  sns.heatmap(cf_matrix, cmap='viridis', annot=True, linewidths=.5, ax=ax)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s5mHt-UvQBLE",
        "outputId": "2c1a2e8f-2fc2-415e-d3e1-e56b571f8363"
      },
      "source": [
        "n_hidden = 4\n",
        "n_class = 10 #only 10 for MNIST \n",
        "hidden_size = 128\n",
        "activation = 'tanh' # 'tanh','relu','sigmoid'\n",
        "max_epoch = 5 \n",
        "alpha = 0\n",
        "batch_size = 64 \n",
        "optimizer = 'NADAM' # 'ADAM','NADAM','RMSP','SGDM','SGD'\n",
        "learning_rate = 1e-3\n",
        "wb_init = 'xavier_uniform' # 'xavier_uniform', 'he'\n",
        "loss_fn = 'crossE' # 'crossE','mse'\n",
        "\n",
        "model_test(n_hidden,n_class,hidden_size,activation,max_epoch,alpha,batch_size,optimizer,learning_rate,wb_init,loss_fn)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Test Accuracy: 96.40%\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x1008 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}