Convolutional Neural Networks Using Keras
In this tutorial, We will learn how to implement Convolutional Neural Networks using Keras in Python language.
CNN: A Brief Introduction
A Convolutional Neural Network works on the principle of Weights. There are many reasons why they are being used so extensively. They reduce processing power without the loss of important features. The main difference is the use of the Kernel Layer. It is also known as a filter. Its size is smaller than the Input layer. Used for Extraction of Important Features (Convolutes over the input).
When the dimension is reduced, it is known as valid padding. If it remains the same, it is known as the same padding. The Final Layer is just like a normal fully connected Neural Network. Keras has made it a whole lot easier to implement these networks with good optimization.
Implementation of Keras Convolutional Neural Networks
- Spyder or Any Python IDE
Keras has some built-in datasets which can be loaded easily. You can use any of the datasets from Datasets-Keras. I have used the MNIST digit Classification Dataset for this tutorial. So let’s start coding!
Step-1 Loading the Libraries
Not many Libraries Required. Will use built-in Keras’ Functions.
#Import Libraries import numpy as np import pandas as pd import keras
Step-2 Loading the Dataset
Layers Required for the CNN are:
- MaxPooling2D: Selects the Max value for the convoluted matrix. Better than Average Pooling.Co
- Conv2D: The Convolution layer.
- Dense: The fully connected layer as normal Neural Networks.
- Flatten Increases efficiency by converting data into a 1-D array.
- Dropout: Prevents Overfitting.
from keras.datasets import mnist from keras.models import Sequential from keras.layers import Conv2D,MaxPooling2D,Flatten,Dense from keras.utils import to_categorical from keras.layers import Dropout from keras.layers.advanced_activations import LeakyReLU #Load the Dataset (x_train,y_train),(x_test,y_test)=mnist.load_data() #x_train has 60k samples of size 28x28
Now the Data would be loaded, but it still needs to be preprocessed into 1 channel.
We will use Numpy’s Reshape Function.
Step-3 Preprocessing the Data.
Steps for Preprocessing:
- Reshape Into Single Channel
- Change datatype to “float32”
- x_test and x_train values to vary from 0-1
We will also “One Hot Encode” the output values. The given dataset has 10 classes (0-9). We will change it into a binary vector with 1 for the correct digit and 0 for others.
#Preprocess x_train=x_train.reshape(x_train.shape,28,28,1) x_test=x_test.reshape(x_test.shape,28,28,1) num_classes=np.unique(y_train) tot_classes=len(num_classes) x_train=x_train.astype('float32') x_test=x_test.astype('float32') x_train=x_train/255 x_test=x_test/255 y_train=to_categorical(y_train,tot_classes) y_test=to_categorical(y_test,tot_classes)
Step-4 Defining the Model
Building a “Sequential” Model using Keras.add function. Batch Size is the number of elements picked at once. One complete Representation of Dataset is Known as Epoch. Here I have trained for 10 epochs with a batch size of 128. You can Increase it if the dataset is large. It will require more computational power. If you want to learn more about Layers in Keras, you can visit Layers in Keras.
#Model batch_size = 128 num_classes = 10 epochs = 10 model = Sequential() model.add(Conv2D(32, kernel_size=(3,3),activation='relu',input_shape=(28,28,1))) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(256, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(num_classes, activation='softmax'))
Step-5 Training and Saving the Model
Verbose 0 will not show the training Steps. Verbose 1 will show accuracy after each step.
model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta() ,metrics=['accuracy']) hist = model.fit(x_train, y_train,batch_size=batch_size, epochs=epochs,verbose=1 ,validation_data=(x_test, y_test)) model.save('hand_wr.h5') print("Saved Succesfuly")
Training will take approx. 15 minutes on Intel(R) Core (TM) i7 CPU.
Step-6 Finding Accuracy
As this is not a very huge dataset, it achieves very high accuracy. The model is 99% percent accurate and not overfitting. Use “load_model” from Keras.
#model Accuracy from keras.models import load_model model=load_model('hand_wr.h5') values=model.evaluate(x_test,y_test,verbose=1) print('Test Loss: ',values) print('Test Accuracy: ',values)
So we understood the basics of a Convolutional Network. You can ask any doubt in the comments section.
Machine Learning is ❤️.