{"cells":[{"metadata":{},"cell_type":"markdown","source":"# Lenet5 Architecture\nThis represents the simplest approach to implement the said topology. Most of the api are from keras. The parameters of each layer is stored in the imported .csv file. Other functions are used as well for creating figure, importing dataset and implementing methods e.g. early stop, cross-validation and learning rate scheduling.\n***\n#### EDIT #1 : Added exponential learning rate scheduling, batchnorm, dropout & confusion matrix!\n#### EDIT #2 : Added Data Augmentation using keras library (ImageDataGeneration)\nI am only adding a random rotation of (-20,20) degree range, since that is the onyl variation I expect in the generalization set. \n### Importing preliminary libraries"},{"metadata":{"trusted":true},"cell_type":"code","source":"from tensorflow.contrib.layers import fully_connected\nfrom tensorflow.keras.layers import Conv2D,MaxPool2D,Dense,BatchNormalization,Dropout\nfrom tensorflow.keras.preprocessing.image import ImageDataGenerator as IDG\nimport matplotlib.pyplot as plt\nfrom sklearn.metrics import confusion_matrix\nimport seaborn as sns\nimport tensorflow as tf\nimport pandas as pd\nimport numpy as np\nimport cv2","execution_count":24,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"I did not want to create each layer manually. Instead, The data is imported from the **lenet5.csv** file. Each of the layer's parameter are stored in rows of the stated file. Use **csv.head()** command to briefly look at the file. Since the file contained a mixed dtype, some of the values reuqired conversion to int, float and so on upon being called."},{"metadata":{"trusted":true},"cell_type":"code","source":"def obtain_params(layer_no,csv):\n    activ ={'relu':tf.nn.relu,'tanh':tf.tanh,'sigm':tf.sigmoid,'None':None}\n    bool = {'TRUE':True,'FALSE':False,'None':None,'Auto':tf.AUTO_REUSE}\n    type,filter,kernel,stride,padding,activation,scope,reuse,is_train,dropout = csv.iloc[layer_no]\n    if filter!='None':filter=int(filter)\n    if kernel!='None':kernel=int(kernel)\n    if stride!='None':stride=int(stride)\n    if dropout!='None':dropout=float(dropout)\n    activation = activ[activation]\n    reuse=bool[reuse];is_train = bool[is_train]\n    return(type,filter,kernel,stride,padding,activation,scope,reuse,is_train,dropout)","execution_count":25,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"The *update_params* function is used to update the weights obtained from the early stop process implementation. In future,I would work on implementing the **tf.keras.callbacks.EarlyStopping** to use the said method instead. \nAnother function implements learning rate scheduling based on the performace of the algorithm. Following function implements the creation of figure based on the size of output array obtained."},{"metadata":{"trusted":true},"cell_type":"code","source":"def update_weights(parameters):\n    a=[variable.name for variable in tf.trainable_variables()]\n    a=[a[i][:len(a[i])-2] for i in range(len(a))]\n    for i in range(len(a)):\n        ind = a[i].find('/')\n        with tf.variable_scope(a[i][:ind],reuse=True):\n            var = tf.get_variable(a[i][ind+1:])\n        forge = tf.assign(var,best_weights)\n    return forge.eval(feed_dict={best_weights:parameters[i]})\n\ndef check_accuracy(new_val,prev_val,counter,lr,lr_dec_limit,best_param):\n    if new_val>prev_val:\n        prev_val = new_val\n        best_param = sess.run(params)\n        counter = 0\n    else:\n        counter+=1\n    if counter>lr_dec_limit:\n        lr=lr/10\n        counter=0\n    return (prev_val,best_param,counter,lr)\n\ndef create_fig(output):\n    \"\"\"Create the figures of convolved feature maps from the output array\"\"\"\n    shape = output.shape[3]\n    factors = np.array(range(1,shape+1))\n    factors = factors[shape%factors==0]\n    n = len(factors)\n    if n%2!=0:\n        up=factors[np.int(n/2)]\n        lo=factors[np.int(n/2)]\n    else:\n        up=factors[int(n/2)]\n        lo=factors[int(n/2)-1]\n    for i in range(1,shape+1):\n        plt.subplot(up,lo,i)\n        plt.imshow(output[0,:,:,i-1],cmap=\"Greys\")\n    plt.show()\n    return()","execution_count":26,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Class fetch_mnist is used to obtain the data form the dataset"},{"metadata":{"trusted":true},"cell_type":"code","source":"df_train = pd.read_csv(\"../input/digit-recognizer/train.csv\").iloc[:]\ny_train = df_train.label\nX_train = df_train.drop([\"label\"],axis=1)\ndf_test = pd.read_csv(\"../input/digit-recognizer/test.csv\").iloc[:]\nclass fetch_mnist:\n    def __init__(self,X=X_train,y=y_train,Xt=df_test):\n        self.X_train = X/255\n        self.y_train = y\n        self.X_test = Xt/255\n    def fetch_train_batch(self,n,cnn=False):\n        rand_indx = np.random.permutation(len(self.X_train))\n        self.X_train = self.X_train.iloc[rand_indx]\n        self.y_train = self.y_train.iloc[rand_indx]\n        if cnn==False:\n            return(self.X_train[:n],self.y_train[:n])\n        if cnn==True:\n            shape = np.r_[n,28,28,1]\n            data=self.X_train[:n]\n            X_out = np.zeros(shape)\n            X_out[:,:,:,0] = [np.array(data.iloc[i]).reshape(28,28) for i in range(data.shape[0])]\n            return(X_out,self.y_train[:n])\n    def fetch_test_batch(self,n,cnn=False):\n        if cnn==False:\n            return(self.X_test[:n])\n        if cnn==True:\n            shape = np.r_[n,28,28,1]\n            data=self.X_test[:n]\n            X_out = np.zeros(shape)\n            X_out[:,:,:,0] = [np.array(data.iloc[i]).reshape(28,28) for i in range(data.shape[0])]\n            return(X_out)\n    def n_samples(self,tt):\n        if tt == \"train\":return(len(self.X_train))\n        if tt == \"test\":return(len(self.X_test))\n","execution_count":27,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Declaring Constants"},{"metadata":{"trusted":true},"cell_type":"code","source":"batch_size = 200\nlr = 0.01\nn_iteration = 300\na=fetch_mnist()\nx,y = a.fetch_train_batch(batch_size,cnn=True)\nbatch_norm_momentum=0.75\ncsv = pd.read_csv(\"../input/lenet5-parameters/lenet5.csv\")","execution_count":28,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Graph Construction\nAs stated earlier, the build would still be stuck with traditional tensorflow construction->execution style. In what follows, different variables and placeholders are declared. \n#### Edit#1: Implementing tf.train.exponential_decay as the learning rate schedule"},{"metadata":{"trusted":true},"cell_type":"code","source":"tf.reset_default_graph()\nX=tf.placeholder(dtype=tf.float32,shape=(None,28,28,1),name=\"Features\")\nY = tf.placeholder(dtype=tf.int32,shape=(None),name=\"Labels\")\npadded_input = tf.pad(X, [[0, 0], [2, 2], [2, 2], [0, 0]], \"CONSTANT\")\nglobal_step = tf.Variable(0,dtype=tf.int32,trainable=False)\nlearning_rate = tf.train.exponential_decay(lr,global_step,100000,0.95)\ndata_gen = IDG(rotation_range=15)","execution_count":29,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"#### Creating Layers\nLayers, (i.e. convolution or pooling) are created below. The data is imported from the **lenet5.csv** file. Each of the layer's parameter are stored in rows. Use **csv.head()** command to briefly look at the file.\n#### EDIT #1:Batch normalization implemented also!!"},{"metadata":{"trusted":true},"cell_type":"code","source":"################Convolution Layer 1\ntype,filter,kernel,stride,padding,activation,scope,reuse,is_train,dropout=obtain_params(0,csv)\nconv1 = Conv2D(filters=filter,kernel_size=[kernel,kernel],strides=[stride,stride],padding=padding,activation=activation)\nout=conv1(padded_input)\n#################Pooling Layer 1\ntype,filter,kernel,stride,padding,activation,scope,reuse,is_train,dropout=obtain_params(1,csv)\npool1 = MaxPool2D(pool_size=(kernel,kernel),strides=stride)\nout=pool1(out)\n#################Convolution Layer 2\nbatchnorm1=BatchNormalization(momentum=batch_norm_momentum)\ntype,filter,kernel,stride,padding,activation,scope,reuse,is_train,dropout=obtain_params(2,csv)\nconv2 = Conv2D(filters=filter,kernel_size=[kernel,kernel],strides=[stride,stride],padding=padding,activation=activation)\nout=conv2(batchnorm1(out))\n#################Pooling Layer 1\ntype,filter,kernel,stride,padding,activation,scope,reuse,is_train,dropout=obtain_params(3,csv)\npool2 = MaxPool2D(pool_size=(kernel,kernel),strides=stride)\nout=pool2(out)\n#################Convolution Layer 3\nbatchnorm2=BatchNormalization(momentum=batch_norm_momentum)\ntype,filter,kernel,stride,padding,activation,scope,reuse,is_train,dropout=obtain_params(4,csv)\nconv3 = Conv2D(filters=filter,kernel_size=[kernel,kernel],strides=[stride,stride],padding=padding,activation=activation)\nout=conv3(batchnorm2(out))\n################Fully Connected Layer 1\nout = tf.reshape(out,(tf.shape(out)[0],out.get_shape()[3]))\nbatchnorm3=BatchNormalization(momentum=batch_norm_momentum)\ndrop1=Dropout(0.1)\ntype,filter,kernel,stride,padding,activation,scope,reuse,is_train,dropout=obtain_params(5,csv)\nfc1 = Dense(units=kernel,activation=activation)\nout = fc1(drop1(batchnorm3(out)))\n################Fully Connected Layer 2\nbatchnorm4=BatchNormalization(momentum=batch_norm_momentum)\ndrop2=Dropout(0.2)\ntype,filter,kernel,stride,padding,activation,scope,reuse,is_train,dropout=obtain_params(6,csv)\nfc2 = Dense(units=kernel,activation=None)\nout = fc2(drop2(batchnorm4(out)))","execution_count":30,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"#### Evaluation\nThe following contruct would use the list of size 10 obtained from the last **FC**(fully connected) layer to evaluate the accuracy. The highest value in the list would be passed on as the predicted value. The index corresponding to that value would be the predicted number. \nOften in Classification modules, we utilize the softmax function to restrict the output value between 0-1. Afterwards, cross-entroy cost functions follows, which gives out a high value if the prediction is wrong, (i.e. highest probability is assigned to the wrong number). The **tf.nn.sparse_softmax_cross_entropy_with_logits** functions applies softmax function, and later evaluated the cross-entropy of the output."},{"metadata":{"trusted":true},"cell_type":"code","source":"xentry=tf.nn.sparse_softmax_cross_entropy_with_logits(labels=Y,logits=out)\nloss = tf.reduce_sum(xentry,axis=0)\noptimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)\ntraining_op = optimizer.minimize(loss,global_step=global_step)","execution_count":31,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"#### Accuracy Measurements\nThe last important step in the construction phase is to specify how to mesure the model. We will simply use accuracy as our performance measure. First, for each instance, determine if the neural network’s prediction is correct by checking whether or not the highest logit corresponds to the target class. For this you can use the **in_top_k()** function. This returns a 1D tensor full of boolean values, so we need to cast these booleans to floats and then compute the average. This will give us the network’s overall accuracy."},{"metadata":{"trusted":true},"cell_type":"code","source":"correct=tf.nn.in_top_k(out,Y,1)\nal_in = tf.reduce_mean(tf.cast(correct,tf.float32))\nparams = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,scope='')\nsaver = tf.train.Saver()\ninit = tf.global_variables_initializer()","execution_count":32,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Execution \nExecution of the above contructed graph.\n#### Edit #1: Inlcuding the operation to evaluate the confusion matrix. "},{"metadata":{"trusted":true},"cell_type":"code","source":"with tf.Session() as sess:\n    acc_val=np.empty((1))\n    sess.run(init)\n    X_data,y_data = a.fetch_train_batch(a.n_samples('train'),cnn=True)\n    for X_batch,y_batch in data_gen.flow(X_data,y_data,batch_size=batch_size):\n        sess.run(training_op,feed_dict={X:X_batch,Y:y_batch})\n        output=al_in.eval(feed_dict={X:X_batch,Y:y_batch})\n        acc_val=np.append(acc_val,output)\n        if global_step.eval()%50==0:print(\"Iteration:\",global_step.eval(),\"\\taccuracy\",output)\n        if global_step.eval()==2000:break\n# Obtaining prediction for all the samples\n    X_batch,y_val = a.fetch_train_batch(a.n_samples(\"train\"),cnn=True)\n    y_pred = np.argmax(out.eval(feed_dict={X:X_batch}),axis=1)\n    saver.save(sess,\"../working/cnn_mnist_2.ckpt\")\n    sess.close()","execution_count":42,"outputs":[{"output_type":"stream","text":"0.01\nIteration: 1 \taccuracy 0.27\nIteration: 2 \taccuracy 0.3\n0.009999989\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"#### Recording \nWe would also contain the values of accuracy to plot and observe the rate of convergence. In future implementation with different techniques, it would enlight us, in what gives the best result.\n#### Edit #1: Let us also draw the confusion matrix."},{"metadata":{"trusted":true},"cell_type":"code","source":"acc_val = np.delete(acc_val,0)\nplt.figure(figsize=(20,10))\nplt.title(\"Accuracy v/s Iterations\",fontdict={'fontsize':20})\nplt.grid(True)\nplt.xlabel(\"Iterations\")\nplt.ylabel(\"Accuracy\")\nplt.plot(acc_val)\nplt.show()\n#Evaluating the confusion matrix\ncm = confusion_matrix(y_val, y_pred) \n\n# Transform to df for easier plotting\ncm_df = pd.DataFrame(cm,\n                     index = [str(i) for i in range(10)], \n                     columns = [str(i) for i in range(10)])\n\nplt.figure(figsize=(13,10))\nsns.heatmap(cm_df, annot=True)\nplt.title(\"Confusion Matrix\",fontdict={'fontsize':20})\nplt.xlabel(\"Predictions\")\nplt.ylabel(\"Actual Values\")\nplt.show()","execution_count":37,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 1440x720 with 1 Axes>","image/png":"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\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 936x720 with 2 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"The graph is observed to fluctuate a lot, but the ordinate dictates that the division (the band) is about **0.86**. This division is quite small, relative to the accruacy values obtained. But anyway, we would attempt to:-\n* Decrease the flucations (**using early stop**) \n* Increase the convergence rate (**using learning rate scheduling**)\n* Reduce the steady state error(**using cross-validation**)\n\nFurthermore techniques e.g. batch normalization and dropout would be experimented with, as I am quite doubfull about them influencing the above three factors, specially Data-augmentation. Most user suggest that it helps in CNN, but I dont know, lets see. At about 65th iteration, the values could use a little less learning rate, so we would like to implement one which takes a major effect near that value.\n#### Edit #1: Confusion matrix\nThe following are the values which the algorithm gets confused with,\n1. 9 predicted as 4\n2. 0 predicted as 6\n3. 7 predicted as 2\n\n(What a dumb computer!)\nNow that we know which samples are contributing to most of the error, **we can train the network which majorly constitutes of these values**, or we can first use these smaller and easier accuracy improving tools and observe the improvements. Let us do the latter."},{"metadata":{"trusted":true},"cell_type":"code","source":"out_1 = conv1(padded_input)\nwith tf.Session() as sess:\n    saver.restore(sess,\"../working/cnn_mnist_2.ckpt\")\n    X_test=a.fetch_test_batch(1,cnn=True)\n    output = out_1.eval(feed_dict={X:X_test})\n    sess.close()\nplt.imshow(X_test[0,:,:,0],cmap=\"Greys\")\nplt.title(\"Original Figure\",fontdict={'fontsize':20})","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"fig = plt.figure(figsize=(10,10))\nplt.suptitle(\"Filter's effect from Convolution layer 1\",fontsize=20)\ncreate_fig(output)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Going Deeper, let us try the last Convolution Layer"},{"metadata":{"trusted":true},"cell_type":"code","source":"out_2 = conv3(conv2(pool1(conv1(padded_input))))\nwith tf.Session() as sess:\n    saver.restore(sess,\"../working/cnn_mnist_2.ckpt\")\n    X_test=a.fetch_test_batch(1,cnn=True)\n    output = out_2.eval(feed_dict={X:X_test})\n    sess.close()\nfig = plt.figure(figsize=(10,10))\nplt.suptitle(\"Filter's effect from Last Convolution layer\",fontsize=20)\ncreate_fig(output)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"And Finally the output file"},{"metadata":{"trusted":true},"cell_type":"code","source":"with tf.Session() as sess:\n    saver.restore(sess,\"../working/cnn_mnist_2.ckpt\")\n    X_test= a.fetch_test_batch(28000,cnn=True)\n    acc_test = out.eval(feed_dict={X:X_test})\n    out_put=np.argmax(acc_test,axis=1)\n    sess.close()\ndata = pd.DataFrame({'ImageId':range(1,len(X_test)+1),'Label':out_put})\ndata.to_csv(\"../working/cnn_mnist_1.csv\",index=False)\nprint(data.head())","execution_count":null,"outputs":[]}],"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.4"}},"nbformat":4,"nbformat_minor":1}