deep learning is a division of machine learning and is considered as a crucial step taken by researchers in recent decades. the examples of deep learning implementation include applications like image recognition and speech recognition.

the two important types of deep neural networks are given below −

convolutional neural networks
recurrent neural networks.

in this chapter, we will be focusing on the first type, i.e., convolutional neural networks (cnn).

convolutional neural networks

convolutional neural networks are designed to process data through multiple layers of arrays. this type of neural networks are used in applications like image recognition or face recognition.

the primary difference between cnn and any other ordinary neural network is that cnn takes input as a two dimensional array and operates directly on the images rather than focusing on feature extraction which other neural networks focus on.

the dominant approach of cnn includes solution for problems of recognition. top companies like google and facebook have invested in research and development projects of recognition projects to get activities done with greater speed.

every convolutional neural network includes three basic ideas −

local respective fields
convolution
pooling

let us understand each of these terminologies in detail.

local respective fields

cnn utilize spatial correlations that exists within the input data. each in the concurrent layers of neural networks connects of some input neurons. this specific region is called local receptive field. it only focusses on hidden neurons. the hidden neuron will process the input data inside the mentioned field not realizing the changes outside the specific boundary.

the diagram representation of generating local respective fields is mentioned below −

convolution

in the above figure, we observe that each connection learns a weight of hidden neuron with an associated connection with movement from one layer to another. here, individual neurons perform a shift from time to time. this process is called convolution.

the mapping of connections from the input layer to the hidden feature map is defined as shared weights and bias included is called shared bias.

pooling

convolutional neural networks use pooling layers which are positioned immediately after cnn declaration. it takes the input from the user as a feature map which comes out convolutional networks and prepares a condensed feature map. pooling layers help in creating layers with neurons of previous layers.

implementation of pytorch

following steps are used to create a convolutional neural network using pytorch.

step 1

import the necessary packages for creating a simple neural network.

from torch.autograd import variable
import torch.nn.functional as f

step 2

create a class with batch representation of convolutional neural network. our batch shape for input x is with dimension of (3, 32, 32).

class simplecnn(torch.nn.module):
   def __init__(self):
      super(simplecnn, self).__init__()
      #input channels = 3, output channels = 18
      self.conv1 = torch.nn.conv2d(3, 18, kernel_size = 3, stride = 1, padding = 1)
      self.pool = torch.nn.maxpool2d(kernel_size = 2, stride = 2, padding = 0)
      #4608 input features, 64 output features (see sizing flow below)
      self.fc1 = torch.nn.linear(18 * 16 * 16, 64)
      #64 input features, 10 output features for our 10 defined classes
      self.fc2 = torch.nn.linear(64, 10)

step 3

compute the activation of the first convolution size changes from (3, 32, 32) to (18, 32, 32).

size of the dimension changes from (18, 32, 32) to (18, 16, 16). reshape data dimension of the input layer of the neural net due to which size changes from (18, 16, 16) to (1, 4608).

recall that -1 infers this dimension from the other given dimension.

def forward(self, x):
   x = f.relu(self.conv1(x))
   x = self.pool(x)
   x = x.view(-1, 18 * 16 *16)
   x = f.relu(self.fc1(x))
   #computes the second fully connected layer (activation applied later)
   #size changes from (1, 64) to (1, 10)
   x = self.fc2(x)
   return(x)

Save or share this article