Age Estimation With Deep Learning: Building CNN

• Download source - 121.6 KB

In this series of articles, we’ll show you how to use a Deep Neural Network (DNN) to estimate a person’s age from an image.

In the last article, we designed the CNN architecture for age estimation. In this – the fourth article of the series – we’ll build the network we’ve designed using the Keras framework. The Keras library helps you create CNNs with minimal code writing.

Define Instantiation Class

In the Python code below, we introduced a class with one static method for network instantiation.

from keras.models import Sequential
from keras.layers.convolutional import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.layers.core import Activation
from keras.layers.normalization import BatchNormalization
from keras.layers.core import Dropout
from keras.layers.core import Flatten
from keras.layers.core import Dense
 
class ClassLeNet:
    @staticmethod
    def create(width, height, kernels, hidden, classes):
        net = Sequential()
    	
        net.add(Conv2D(kernels, (5, 5), padding="same", input_shape=(height, width, 1)))
        net.add(Activation("relu"))
        net.add(BatchNormalization())
    	
        net.add(Conv2D(kernels, (5, 5), padding="same"))
        net.add(Activation("relu"))
        net.add(BatchNormalization())
        net.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
    	
        net.add(Conv2D(kernels, (3, 3), padding="same"))
        net.add(Activation("relu"))
        net.add(BatchNormalization())
    	
        net.add(Conv2D(kernels, (3, 3), padding="same"))
        net.add(Activation("relu"))
        net.add(BatchNormalization())
        net.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
    	
        net.add(Flatten())
        net.add(Dense(hidden))
        net.add(Activation("relu"))
        net.add(Dropout(0.5))
    	
        net.add(Dense(hidden))
        net.add(Activation("relu"))
    	
        net.add(Dense(classes))
        net.add(Activation("softmax"))
        return net

Import Classes and Packages

The above code imports the required Python packages and classes. Some remarks on the class names:

• The BatchNormalization class is an implementation of the normalization layer
• The Dense class implements a fully-connected layer
• The Flatten class is a special layer to convert data between the multidimensional and 1D layers

We believe that the rest of the package and class names are self-explanatory.

Define the Create Method

In the class we’ve defined, the create method has five parameters:

• width and height – the horizontal and vertical sizes of the input image data
• kernels – the number of learnable kernels in the convolutional layers
• hidden – the number of neurons in the hidden fully-connected layers
• classes – the number of classes to train the CNN on

As our network is a feedforward CNN, we instantiate the Sequential model class.

Add Layers

We use multiple add method calls to stack the layers in the required order. All constructors of the Conv2D convolutional layers are supplied with the following parameters:

• The number of kernels
• The size of the kernels (5 x 5 or 3 x 3)
• Padding= "same," for zero padding

The first convolutional layer is created with one additional parameter, input_shape, which specifies dimensions of the input images.

The activation layers use the ReLU activation function, which is specified by the relu parameter value. The last activation layer is an exception: it uses the SOFTMAX function to provide the output as the probabilities per class (age group).

The pooling layers are initialized with two parameters: pool_size of 2 x 2 and strides of 2 x 2. These parameter values make every pooling layer reduce the width and height by a factor of two.

There are three fully-connected (Dense) layers at the end part of the stack. Two hidden layers are instantiated with the number of neurons equal to the hidden parameter value. The last output layer has the number of neurons equal to the class number.

There is a dropout layer between the two fully-connected layers, with the probability of 0.5. Note the Flatten layer between the convolutional and fully-connected parts of the network. It is necessary because the convolutional output has three dimensions (width, height, and the number of kernels) while the fully connected input is one-dimensional. So, the convolved data must be converted to a 1D array before it can be used as the input for the dense layers.

Instantiate the Model

With the class for building our CNN model implemented, we can instantiate the model as follows:

from keras.optimizers import SGD
kernels = 16
hidden = 256
imgsize = 128
classes = 10
net = ClassLeNet.create(imgsize, imgsize, kernels, hidden, classes)
opt = SGD(lr=0.01)
net.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"])

First, we assign values to the model parameters:

• The image size is 128
• The number of learnable kernels in the convolutional layers is 16
• The number of neurons in the hidden FC layers is 256
• The number of classes (age groups) is 10

We then call the create method to instantiate the network model with the above parameter values. Also, we need to choose the optimization method to be used for training the model. The Stochastic Gradient Descent (SGD) optimizer is instantiated with the learning rate value lr=0.01.

Finally, the model is compiled with the above optimizer, using accuracy as the metrics, as well as cross-entropy as the loss function (a common choice for classification problems).

Next Step

In this article, we implemented and instantiated out CNN using the Keras framework. Our CNN instance is now ready for training.

The next article will show you how to feed the dataset images to the model and optimize it for the age estimation.