Good article for buliding an intuition on how to derive the backpropagation formula:https://medium.com/@pavisj/convolutions-and-backpropagations-46026a8f5d2c

Convolutions and Backpropagations

The back-propagation in CNN is done on the same principle of the chain rule, but the the the way it is actually done is not that easy. Of course if we have the gradient of the output we could do bunch of nested loops and calculate the gradients of the parameters and inputs, but this would be crazy inefficient. We need to search a way to vectorize this. We already implemented the forward propagation, and convolution operation is heavily involved in back propagation. The formulas for the gradients of the input are the following:(Suppose L is the cost function, F is the current filter, X is the current input)


Backpropagation in CNN

- The convolution operation, denoted by the asterisk (*), indicates mapping the filter matrix (kernel) to every possible position on the input matrix, multiplying each of the pairs of numbers, elementwise, and adding them up to calculate the corresponding element in the result matrix.


- In mathematics, the asterisk is the standard symbol for convolution but in Python, this is also used to denote multiplication or elementwise multiplication.


- Traditionally, the convolution operation before its application has a kernel mirroring step (left to right, and up to down). This allows associativity across convolutions to hold. In deep learning, this mirroring doesn't have a significant impact on the operations and thus is omitted. Also when the kernel is symmetric, the operations are identical. Hence, convolution in deep learning refers to cross-correlation. 

The Cross-Correlation (Convolution) Operation

The size of one dimension of the filter (kernel) matrix. Because it's usually a square matrix, we only consider the size of one dimension which is usually the same as the other dimension.

In machine vision, it is usually an **odd** number. So, we usually have a center cell in the filter (kernel) matrix.

Filter (Kernel) Size in Convolutional DNN

https://medium.com/@RosieCampbell/demystifying-deep-neural-nets-efb726eae941

Demystifying Deep Neural Nets

In a convolutional layer, instead of manually specifying numbers of cells of the filters (kernels), we define each of them as weights and we add a single bias number to each cell. Then, we train the model with these new parameters the same way as we optimize the weights and biases of neurons. So, the number of parameters in each filter (kernel) will be the number of its cells plus one bias.

The first ConvLayer is responsible for capturing the Low-Level features such as edges, color, gradient orientation, etc. With added layers, the architecture adapts to the high-level features as well, giving us a network which has the wholesome understanding of images in the dataset, similar to how we would.

Convolutional Layer (ConvLayer)

Three basic strategies for obtaining convolution kernels without supervised training:
- Initializing them randomly
- Setting each kernel to detect edges at a certain orientation or scale
- Item learning the kernels with an unsupervised criterion

Obtaining Kernels without Supervised Training

A “filter”, sometimes called a “kernel”, is passed over the image, viewing a few pixels at a time (for example, 3X3 or 5X5). The convolution operation is a dot product of the original pixel values with weights defined in the filter. The results are summed up into one number that represents all the pixels the filter observed.

University of Michigan - Ann Arbor

CNNs are made up of three-layer types—convolutional, pooling and fully-connected (FC).

In the convolutional layers, the input matrix is passed through a set of filters that output a feature map. This output is then sent to a pooling layer, which reduces the size of the feature map. This helps reduce the processing time by condensing the map to its most essential information.

The convolutional and pooling processes are repeated several times, with the number of repeats depending on the network, after which the condensed feature map outputs are sent to a series of FC layers. These FC layers then flatten the maps together and compare the probabilities of each feature occurring in conjunction with the others, until the best classification is determined.

Convolutional Neural Networks Architecture

A helpful website that introduces neural networks:
https://missinglink.ai/guides/neural-network-concepts/

Neural Network Reference

A helpful website for understanding how CNN works:
https://towardsdatascience.com/a-comprehensive-guide-to-convolutional-neural-networks-the-eli5-way-3bd2b1164a53

CNN Reference

*Pros:*
- The architecture allows CNNs to learn the position and scale of features in a variety of images, making them especially good at the classification of hierarchical or spatial data and the extraction of unlabeled features.
- Because of **Parameter sharing** and **Sparsity of connections** the neural network has significantly fewer parameters that allows it to train a smaller training sets and be less prone to overfitting.

*Cons:*
- Unfortunately, this structure requires CNNs to only accept fixed-size inputs—and it only allows them to provide fixed-size outputs.

Pros and Cons of CNN Architecture

Fully connected layer is a traditional multilayer perceptron structure. Its input is a one-dimensional vector representing the output of the previous layers. Its output is a list of probabilities for different possible labels attached to the image (e.g. dog, cat, bird). The label that receives the highest probability is the classification decision.

Fully Connected Layer - Classification

Here is a clear 3D representation of the convolution Neural Network for detecting a written number. You can see clearly which layer outputs depend on which inputs:
https://www.cs.ryerson.ca/~aharley/vis/conv/

3D Visualization of a Convolution Neural Network

Three classic networks

Convolution Filter (Kernel)

Pooling is the process of down-sampling, i.e., reducing the size of the matrix. A filter is passed over the results of the previous layer and outputs one number out of each group of values.

Pooling Layer in Convolutional Deep Learning

Example of a Convolutional Neural Network Architecture

- Artificial neural network that builds on constructs from pyramid cells in the cerebral cortex
- Residual neural network do this by using shortcuts to jump over some layers 


ResNets Convolutional Neural Network

There are three main classic neural network architectures:
- LeNet-5
- AlexNet
- VGG - 16

Classic Convolutional Neural Network Architectures for Object Detection in Images

An Inception network (GoogLeNet) is a 22 layer deep neural network that takes many Inception modules (including many convolutional layers) and puts them together, which allow for multiple feature detection.

GoogLeNet is highly accurate, however, because it has so many layers it is more prone to overfitting.

Inception Network (GoogLeNet)

The architecture means the overall structure of the network, where most neural networks are organized into groups of units called layers. Different network architecture can have different amount of layers and connections. The main thing to keep in mind when choosing an architecture design, is choosing the depth of the network and the width of each layer.

Architecture Design

We can compare convolution to a fully connected net, but with an inﬁnitely strong prior over its weights: 
                                                                                                                                                                           
1. the weights for one hidden unit must be identical to the weights of its neighbor but shifted in space. 
2. the weights must be zero, except for the small, spatially contiguous receptive ﬁeld assigned to that hidden unit.
                                                                                                                                                                           
Pooling is similar:  
                                                         
1. contains only local interactions and is equivariant to translation
2. each unit should be invariant to small translations.


Learn Before

Related

Learn After