CNN from scratch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Convolutional NN from scratch\n",
    "Train a deep neural network. Your network should work with different architecture parameters (number of layers, number of neurons on each layer, convolution window width, etc.) Try to find the best combination of parameters. Print confusion matrix heatmap as the result.\n",
    "\n",
    "This model features a basic variable CNN supported by a fully conncected Layer at the end.\n",
    "The model operates on the MNIST dataset and includes a dataloader for it. \n",
    "\n",
    "Certain restrictions were placed on the model: \n",
    " - filter stepsize = 1\n",
    " - only 1 channel\n",
    " - 2 dimensional input (black white pictures) \n",
    " - Quadratic filters (So there is no need for Padding)\n",
    " \n",
    "Certain features are included: \n",
    " - variable Number of convolutional and maxpooling layers\n",
    " - variable con and max layer sizes\n",
    " - Variable fully conncected head (size and hidden layers) \n",
    " - data loader and saver for trained weights\n",
    " - Heat map and accuracy score for the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 482,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mlxtend.data import loadlocal_mnist\n",
    "import math\n",
    "import numpy as np\n",
    "import seaborn as sn\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 500,
   "metadata": {},
   "outputs": [],
   "source": [
    "class NN_MNIST:\n",
    "        def __init__(self,structure,dimensions,hiddenLayers):\n",
    "            self.load_data()\n",
    "            self.CNN,self.bias_CNN, self.dim = \\\n",
    "            self.initialize_network_CNN(structure,dimensions)\n",
    "            self.FC,self.bias_FC = self.initialize_FC(hiddenLayers)\n",
    "            \n",
    "        def load_data(self):  #loads MNIST data into useful format\n",
    "            self.X, self.y = loadlocal_mnist(\n",
    "                    images_path='./data/MNIST/train-images.idx3-ubyte',\n",
    "                    labels_path='./data/MNIST/train-labels.idx1-ubyte')\n",
    "            self.X = self.X /255\n",
    "            self.X = self.X.reshape(60000,28,28)\n",
    "            #self.X = self.X[:1000]\n",
    "            #self.y = self.y[:1000]\n",
    "            self.X_test, self.y_test = loadlocal_mnist(\n",
    "                    images_path='./data/MNIST/t10k-images.idx3-ubyte',\n",
    "                    labels_path='./data/MNIST/t10k-labels.idx1-ubyte')\n",
    "            self.X_test = self.X_test /255\n",
    "            self.X_test = self.X_test.reshape(len(self.X_test),28,28)  #normalization step based on max pixel value\n",
    "            #self.X_test = self.X_test[:1000]\n",
    "            #self.y_test = self.y_test[:1000]\n",
    "            self.input = self.X[0].shape\n",
    "            self.output = 10\n",
    "            self.sizeX = self.X.shape[0]\n",
    "            self.sizeY = self.y.shape[0]\n",
    "            \n",
    "        def initialize_network_CNN(self,structure,dimensions):#CNN weight initialization\n",
    "            network = {}\n",
    "            current = 28\n",
    "            dims = []\n",
    "            bias = {}\n",
    "            for x in range (len(structure)):\n",
    "                network[x] = [structure[x],np.random.normal(0,0.1,(dimensions[x],dimensions[x]))]\n",
    "                current = current-dimensions[x]+1\n",
    "                dims.append(current)  \n",
    "                if structure[x] == \"con\":\n",
    "                    bias[x] = 0\n",
    "                else:\n",
    "                    bias[x] = None\n",
    "            return network,bias,dims\n",
    "        \n",
    "        def initialize_FC(self,hiddenLayers):   #FC weight initialization\n",
    "            weights = {}\n",
    "            bias = {}\n",
    "            if len(hiddenLayers) > 0:\n",
    "                if len(self.dim) > 0:\n",
    "                    weights[0] = np.random.normal(0,0.1,(hiddenLayers[0], self.dim[-1]**2))\n",
    "                else: \n",
    "                    weights[0] = np.random.normal(0,0.1,(hiddenLayers[0], 784))\n",
    "                bias[0] = np.random.normal(0,0.1,(hiddenLayers[0], 1))\n",
    "                for x in range(1,len(hiddenLayers)):\n",
    "                    weights[x] =  np.random.normal(0,0.1,(hiddenLayers[x], hiddenLayers[x-1]))\n",
    "                    bias[x] =  np.random.normal(0,0.1,(hiddenLayers[x], 1))\n",
    "                weights[len(hiddenLayers)] =  np.random.normal(0,0.1,(10, hiddenLayers[len(hiddenLayers)-1]))\n",
    "                bias[len(hiddenLayers)] =  np.random.normal(0,0.1,(10, 1))\n",
    "            else:\n",
    "                if len(self.dim) > 0:\n",
    "                    weights[len(hiddenLayers)] =  np.random.normal(0,0.1,(10, self.dim[-1]**2))\n",
    "                else:\n",
    "                    weights[len(hiddenLayers)] =  np.random.normal(0,0.1,(10, 784))\n",
    "                bias[len(hiddenLayers)] =  np.random.normal(0,0.1,(10, 1))\n",
    "            return weights,bias\n",
    "        \n",
    "        def relu(self,Z):    #Activation and loss functions\n",
    "            return np.where(Z<0,0.01*Z,Z)\n",
    "        \n",
    "        def relu_dev(self,x):\n",
    "            x = np.array(x)\n",
    "            return np.where(x<0,0.01,1)\n",
    "        \n",
    "        def softmax(self,X):\n",
    "            X = X - max(X)\n",
    "            return np.divide(np.exp(X),np.sum( np.exp(X),keepdims = True))\n",
    "            \n",
    "        def convolution(self,img,depth):       #convolution step for one layer and picture\n",
    "            f_size = len(self.CNN[depth][1]) \n",
    "            result = np.zeros((self.dim[depth],self.dim[depth]))\n",
    "            for x in range(self.dim[depth]):\n",
    "                for y in range(self.dim[depth]):\n",
    "                    out = (img[x:x+f_size,y:y+f_size]) * (self.CNN[depth][1])\n",
    "                    out = np.sum(out)\n",
    "                    out = out + self.bias_CNN[depth] #single bias shared over complete feature map! \n",
    "                    result[x][y] = out\n",
    "            out = self.relu(result)\n",
    "            return out, result\n",
    "        \n",
    "        def downsampling(self,img,depth): #downsampling step for single layer and picture\n",
    "            f_size = len(self.CNN[depth][1]) # filter dimensions\n",
    "            result = np.zeros((self.dim[depth],self.dim[depth]))\n",
    "            for x in range(self.dim[depth]):\n",
    "                for y in range(self.dim[depth]):\n",
    "                    out = img[x:x+f_size,y:y+f_size]\n",
    "                    out = np.max(out)\n",
    "                    result[x][y] = out\n",
    "            return (result)\n",
    "        \n",
    "        def fully_connected(self,out):  #Forward path for all FC layers\n",
    "            caches = []\n",
    "            for x in range (len(self.FC)-1):\n",
    "                cache = []\n",
    "                out = np.dot(self.FC[x],out) + self.bias_FC[x]\n",
    "                cache.append(out)\n",
    "                out = self.relu(out)\n",
    "                cache.append(out)\n",
    "                caches.append(cache)\n",
    "            cache = []\n",
    "            out = np.dot(self.FC[len(self.FC)-1],out) + self.bias_FC[len(self.FC)-1]\n",
    "            cache.append(out)\n",
    "            out = self.softmax(out)\n",
    "            cache.append(out)\n",
    "            caches.append(cache)\n",
    "            return out, caches\n",
    "            \n",
    "        def forward(self,img):  #forward propagation for 1 picture \n",
    "            current = img\n",
    "            caches = []\n",
    "            caches.append([[],img])\n",
    "            for x in range(len(self.dim)):\n",
    "                if self.CNN[x][0] == \"con\":\n",
    "                    current, cache = self.convolution(current,x)\n",
    "                    caches.append([current,cache])\n",
    "                else:\n",
    "                    current = self.downsampling(current,x)\n",
    "                    caches.append([[],current])\n",
    "            current = current.reshape(len(current)**2,1)\n",
    "            caches.append(current)\n",
    "            result,cache = self.fully_connected(current)\n",
    "            caches.append(cache)\n",
    "            return result.T[0],np.array(caches)\n",
    "        \n",
    "        def predict(self,what):    #predict the training or testing data\n",
    "            predictions = []\n",
    "            if what == \"train\":\n",
    "                for x in range (len(self.X)):\n",
    "                    out, cache = self.forward(self.X[x])\n",
    "                    out = np.argmax(out)\n",
    "                    predictions.append(out)\n",
    "            elif what == \"test\":\n",
    "                for x in range (len(self.X_test)):\n",
    "                    out, cache = self.forward(self.X_test[x])\n",
    "                    out = np.argmax(out)\n",
    "                    predictions.append(out)\n",
    "            return predictions\n",
    "        \n",
    "        def evaluate(self,what):   #compare predictions with actual labels\n",
    "            predictions = self.predict(what)\n",
    "            if what == \"train\":\n",
    "                CM = self.confusion_matrix(self.y,predictions)\n",
    "                print(\"The accuracy of the model is : \" + str(self.accuracy(self.y,predictions))+\"%\")\n",
    "            elif what == \"test\":\n",
    "                CM = self.confusion_matrix(self.y_test,predictions)\n",
    "                print(\"The accuracy of the model is : \" + str(self.accuracy(self.y_test,predictions))+\"%\")\n",
    "            df_cm = pd.DataFrame(CM, index = [i for i in \"0123456789\"],columns = [i for i in \"0123456789\"])\n",
    "            plt.figure(figsize = (10,7))\n",
    "            ax = plt.axes()\n",
    "            ax.set_title('True Labels = Rows, Predictions = Columms')\n",
    "            sn.set(font_scale=1)\n",
    "            sn.heatmap(df_cm, annot=True,cbar = False)\n",
    "\n",
    "        def confusion_matrix(self,labels,preds):   #metrics and helper functions\n",
    "            confusion = np.zeros((self.output,self.output))\n",
    "            for x in range(len(preds)):\n",
    "                confusion[int(labels[x])][int(preds[x])] +=1\n",
    "            return confusion\n",
    "        \n",
    "        def accuracy(self,labels,preds):\n",
    "            return (np.count_nonzero(np.equal(labels,preds))) / len(labels) *100 \n",
    "        \n",
    "        def oneHotEncoding(self,label):\n",
    "            encode = np.zeros((self.output,1))\n",
    "            encode[label] = 1\n",
    "            return encode\n",
    "        \n",
    "        def backward(self,cache,lr,index):   #full backpropagation for 1 picture\n",
    "            dOut = self.backward_FC(cache,lr,index)\n",
    "            if len(self.CNN) > 0: \n",
    "                dOut = dOut.reshape(self.dim[-1],self.dim[-1])\n",
    "                self.backward_CNN(cache,lr,dOut)\n",
    "        \n",
    "        def cross_entropy(self,pred,label):   #loss function\n",
    "            return - math.log(pred[label]+0.00000000000001)\n",
    "        \n",
    "        def backward_CNN(self,cache,lr,gradient):   #conv part backward prob\n",
    "            dWs = []\n",
    "            dBs = []\n",
    "            cache = cache[:len(self.dim)+1]\n",
    "            for w in range(len(self.dim)):\n",
    "                x = len(self.CNN)-1-w\n",
    "                f = len(self.CNN[x][1])\n",
    "                if self.bias_CNN[x] == None:\n",
    "                    dX = np.zeros((len(cache[x][1]),len(cache[x][1])))\n",
    "                    for z in range(f):\n",
    "                        for y in range(f):\n",
    "                            window = cache[x][1][z:z+f,y:y+f]\n",
    "                            dX[z:z+f,y:y+f] += np.where(window \\\n",
    "                            == np.max(window),gradient[z][y],0)\n",
    "                    dWs.append(\"NG\")\n",
    "                    gradient = dX\n",
    "                else:\n",
    "                    dZ = gradient * self.relu_dev(cache[x+1][0])\n",
    "                    dW = np.zeros((f,f))\n",
    "                    dX = np.zeros((len(cache[x][1]),len(cache[x][1])))\n",
    "                    for z in range(f):\n",
    "                        for y in range(f):\n",
    "                            dW += (cache[x][1][z:z+f,y:y+f]) * dZ[z][y]\n",
    "                            dX[z:z+f,y:y+f] += self.CNN[x][1] * dZ[z][y]\n",
    "                    dWs.append(dW/(f**2))\n",
    "                    gradient = dX       \n",
    "            for y in range(len(dWs)): \n",
    "                if not isinstance(dWs[len(dWs)-1-y],str) :\n",
    "                    self.CNN[y][1] = self.CNN[y][1]- dWs[len(dWs)-1-y]\n",
    "                     \n",
    "        def backward_FC(self,cache,lr,index):  #FC backward prob\n",
    "            result = cache[len(cache)-2]\n",
    "            cache = cache[len(cache)-1]\n",
    "            dWs = []\n",
    "            dBs = []\n",
    "            y = self.oneHotEncoding(self.y[index])\n",
    "            if len(self.FC)>1:\n",
    "                dZ = cache[len(cache)-1][1] - y\n",
    "                dW = np.dot(dZ, cache[len(cache)-2][1].T)\n",
    "                dB = np.sum(dZ, axis=1, keepdims=True)\n",
    "                dWs.append( lr * dW)\n",
    "                dBs.append( lr * dB)\n",
    "                for x in range (len(cache)-1,1,-1):\n",
    "                    dZ = np.dot(self.FC[x].T,dZ)*self.relu_dev(cache[x-1][0])\n",
    "                    dW = np.dot(dZ, cache[x-2][1].T)\n",
    "                    dB = np.sum(dZ, axis=1, keepdims=True)\n",
    "                    dWs.append( lr * dW)\n",
    "                    dBs.append( lr * dB)\n",
    "                dZ = np.dot(self.FC[1].T,dZ)*self.relu_dev(cache[0][0])\n",
    "                dW = np.dot(dZ, result.T)\n",
    "                dB = np.sum(dZ, axis=1, keepdims=True)\n",
    "                dWs.append( lr * dW)\n",
    "                dBs.append( lr * dB)\n",
    "                dOut = np.dot(self.FC[0].T,dZ)\n",
    "            else: \n",
    "                dZ = cache[len(cache)-1][1] - y\n",
    "                dW = np.dot(dZ, result.T)\n",
    "                dB = np.sum(dZ, axis=1, keepdims=True)\n",
    "                dOut = np.dot(self.FC[0].T,dZ)\n",
    "                dWs.append( lr * dW)\n",
    "                dBs.append( lr * dB)\n",
    "            for y in range(len(dWs)): \n",
    "                self.FC[y] = self.FC[y]- dWs[len(dWs)-1-y]\n",
    "                self.bias_FC[y] = self.bias_FC[y] - dBs[len(dWs)-1-y]\n",
    "            return dOut\n",
    "        \n",
    "        def train(self,lr,epochs):     #Train with stochastic gradient descent\n",
    "            for x in range(epochs):\n",
    "                Loss = 0\n",
    "                for y in range (len(self.X)):\n",
    "                    result,cache = self.forward(self.X[y])\n",
    "                    Loss += self.cross_entropy(result,self.y[y])\n",
    "                    self.backward(cache,lr,y)\n",
    "                print(Loss/self.sizeX)          \n",
    "        \n",
    "        def save_weights(self,location):  #save your weights or load preloaded weights\n",
    "            pickle_out = open(location  + \"/weights_CNN.pickle\",\"wb\")\n",
    "            pickle.dump(self.CNN, pickle_out)\n",
    "            pickle_out.close()\n",
    "            pickle_out = open(location  + \"/bias_CNN.pickle\",\"wb\")\n",
    "            pickle.dump(self.bias_CNN, pickle_out)\n",
    "            pickle_out.close()\n",
    "            pickle_out = open(location  + \"/weights_FC.pickle\",\"wb\")\n",
    "            pickle.dump(self.FC, pickle_out)\n",
    "            pickle_out.close()\n",
    "            pickle_out = open(location  + \"/bias_FC.pickle\",\"wb\")\n",
    "            pickle.dump(self.bias_FC, pickle_out)\n",
    "            pickle_out.close()\n",
    "            pickle_out = open(location  + \"/dim.pickle\",\"wb\")\n",
    "            pickle.dump(self.dim, pickle_out)\n",
    "            pickle_out.close()\n",
    "\n",
    "        def load_weights(self,location):\n",
    "            pickle_in = open(location  + \"/bias_CNN.pickle\",\"rb\")\n",
    "            self.bias_CNN = pickle.load(pickle_in)\n",
    "            pickle_in = open(location  + \"/weights_CNN.pickle\",\"rb\")\n",
    "            self.CNN = pickle.load(pickle_in)\n",
    "            pickle_in = open(location  + \"/bias_FC.pickle\",\"rb\")\n",
    "            self.bias_FC = pickle.load(pickle_in)\n",
    "            pickle_in = open(location  + \"/weights_FC.pickle\",\"rb\")\n",
    "            self.FC = pickle.load(pickle_in)\n",
    "            pickle_in = open(location  + \"/dim.pickle\",\"rb\")\n",
    "            self.dim = pickle.load(pickle_in)\n",
    "            \n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 501,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.2528871067843483\n",
      "0.7830216644162621\n",
      "0.6500680070695086\n",
      "0.5760206640561728\n",
      "0.5386987393197477\n",
      "0.5087028113334093\n",
      "0.48451219996263045\n",
      "0.46267508916187705\n",
      "0.4426800733145286\n",
      "0.4267353650332424\n"
     ]
    }
   ],
   "source": [
    "NN = NN_MNIST([\"con\",\"max\"],[5,5],[50])\n",
    "NN.load_weights(\"pretrain_cnn_2\")\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 504,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.34291358170494657\n",
      "0.33749050318539936\n",
      "0.33167714170298523\n",
      "0.32785125738964865\n",
      "0.32493050859904465\n",
      "0.3198583994661026\n",
      "0.3163459035573342\n",
      "0.31639734315094864\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-504-b7940fb5529e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mNN\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtrain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0.05\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mNN\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msave_weights\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"pretrain_cnn_2\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-500-967bc31a30cd>\u001b[0m in \u001b[0;36mtrain\u001b[1;34m(self, lr, epochs)\u001b[0m\n\u001b[0;32m    250\u001b[0m                 \u001b[0mLoss\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    251\u001b[0m                 \u001b[1;32mfor\u001b[0m \u001b[0my\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 252\u001b[1;33m                     \u001b[0mresult\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mcache\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    253\u001b[0m                     \u001b[0mLoss\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcross_entropy\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    254\u001b[0m                     \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcache\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mlr\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-500-967bc31a30cd>\u001b[0m in \u001b[0;36mforward\u001b[1;34m(self, img)\u001b[0m\n\u001b[0;32m    121\u001b[0m                     \u001b[0mcaches\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mcurrent\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mcache\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    122\u001b[0m                 \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 123\u001b[1;33m                     \u001b[0mcurrent\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdownsampling\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcurrent\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    124\u001b[0m                     \u001b[0mcaches\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mcurrent\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    125\u001b[0m             \u001b[0mcurrent\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcurrent\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcurrent\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m**\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-500-967bc31a30cd>\u001b[0m in \u001b[0;36mdownsampling\u001b[1;34m(self, img, depth)\u001b[0m\n\u001b[0;32m     91\u001b[0m                 \u001b[1;32mfor\u001b[0m \u001b[0my\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdim\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mdepth\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     92\u001b[0m                     \u001b[0mout\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mimg\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m:\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mf_size\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m:\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mf_size\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 93\u001b[1;33m                     \u001b[0mout\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mout\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     94\u001b[0m                     \u001b[0mresult\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mout\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     95\u001b[0m             \u001b[1;32mreturn\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\numpy\\core\\fromnumeric.py\u001b[0m in \u001b[0;36mamax\u001b[1;34m(a, axis, out, keepdims, initial)\u001b[0m\n\u001b[0;32m   2332\u001b[0m     \"\"\"\n\u001b[0;32m   2333\u001b[0m     return _wrapreduction(a, np.maximum, 'max', axis, None, out, keepdims=keepdims,\n\u001b[1;32m-> 2334\u001b[1;33m                           initial=initial)\n\u001b[0m\u001b[0;32m   2335\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2336\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\numpy\\core\\fromnumeric.py\u001b[0m in \u001b[0;36m_wrapreduction\u001b[1;34m(obj, ufunc, method, axis, dtype, out, **kwargs)\u001b[0m\n\u001b[0;32m     81\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[0mreduction\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mout\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mout\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mpasskwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     82\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 83\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0mufunc\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreduce\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mout\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mpasskwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     84\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     85\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "NN.train(0.05,10)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 507,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The accuracy of the model is : 89.95%\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "NN.evaluate(\"test\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimizer(data,maxFC,maxCNN,maxSIZE):\n",
    "    if data == \"MNIST\":\n",
    "        best = 0\n",
    "        bestModel = None\n",
    "        for x in range(len(maxFC)):\n",
    "            for y in range(len(maxCNN)):\n",
    "                NN = NN_MNIST([:len(maxCNN)-y],[:len(maxSIZE)-y],maxFC[:len(maxFC)-x])\n",
    "                NN.train(0.01,50)\n",
    "                result = NN.predict(\"test\")\n",
    "                accuracy = NN.accuracy(self.y_test,result)\n",
    "                if accuracy > best:\n",
    "                    bestModel = NN\n",
    "        return model,accuracy\n",
    "                \n",
    "                \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 455,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "1",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-455-e7298f019917>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mNN\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mFC\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 1"
     ]
    }
   ],
   "source": [
    "best,accuracy = optimizer(\"MNIST\",[\"con\",\"con\",\"max\"],[5,4,3],[50])"
   ]
  },
  {
   "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
}