When utilizing a pretrained convolutional neural network, such as ResNet-18, for feature extraction in a Fully Convolutional Network (FCN), the final classification layers must be removed. Specifically, the global average pooling layer and the fully connected layer are discarded because they collapse spatial dimensions and are unnecessary for dense pixel-level predictions. The remaining layers form the feature extraction backbone of the FCN, which produces feature maps with reduced spatial dimensions. For example, given an input with a height of $$320$$ and width of $$480$$, the forward propagation reduces the spatial dimensions by a factor of $$1/32$$, resulting in an output shape of $$10 \times 15$$. This extraction process can be implemented in frameworks like PyTorch or MXNet by explicitly selecting all layers except the final pooling and dense layers.

```python
# PyTorch
net = nn.Sequential(*list(pretrained_net.children())[:-2])
```

```python
# MXNet
net = nn.HybridSequential()
for layer in pretrained_net.features[:-2]:
    net.add(layer)
```

Feature Extraction in Fully Convolutional Networks

In a Fully Convolutional Network (FCN), after image features have been extracted by the backbone network, a $$1 \times 1$$ convolutional layer is applied. The purpose of this layer is to transform the number of output channels from the feature extractor to match the exact number of target classes (for example, $$21$$ classes for the Pascal VOC2012 dataset) without altering the spatial dimensions of the feature maps.

```python
# PyTorch
num_classes = 21
net.add_module('final_conv', nn.Conv2d(512, num_classes, kernel_size=1))
```

```python
# MXNet
num_classes = 21
net.add(nn.Conv2D(num_classes, kernel_size=1))
```

Channel Transformation in Fully Convolutional Networks

To restore the spatial dimensions of feature maps to the original input image size in a Fully Convolutional Network (FCN), a transposed convolutional layer is employed. If the spatial dimensions need to be increased by a factor of $$s$$, the transposed convolution is configured with a stride of $$s$$. To achieve the exact original dimensions, the padding is set to $$s/2$$ (assuming $$s/2$$ is an integer), and the height and width of the convolution kernel are set to $$2s$$. For instance, to upscale a feature map by $$32$$ times, the stride is $$32$$, the padding is $$16$$, and the kernel size is $$64$$.

```python
# PyTorch
net.add_module('transpose_conv', nn.ConvTranspose2d(num_classes, num_classes,
                                    kernel_size=64, padding=16, stride=32))
```

```python
# MXNet
net.add(nn.Conv2DTranspose(num_classes, kernel_size=64, padding=16, strides=32))
```

Transposed Convolution Configuration for FCN Upsampling

When evaluating the performance of a fully convolutional network in a semantic segmentation task, accuracy is determined at the pixel level rather than the image level. The accuracy calculation assesses the proportion of individual pixels across the entire input for which the model correctly predicted the semantic class. This means the overall metric reflects the correctness of the predicted classes for all pixels simultaneously, treating each spatial position as an independent classification instance.

Accuracy Calculation in Fully Convolutional Networks

In training a fully convolutional network for semantic segmentation, the loss function is fundamentally similar to that used in standard image classification tasks. However, because the network predicts a distinct class for every individual pixel, these predictions are represented by the output channels of the final transposed convolutional layer. Consequently, when calculating the loss—typically a cross-entropy loss—the computation must explicitly specify the channel dimension to correctly evaluate the predicted probabilities against the ground-truth classes for each spatial position.

```python
# PyTorch
def loss(inputs, targets):
    return F.cross_entropy(inputs, targets, reduction='none').mean(1).mean(1)
```

```python
# MXNet
loss = gluon.loss.SoftmaxCrossEntropyLoss(axis=1)
```

Loss Calculation in Fully Convolutional Networks

A Fully Convolutional Network (FCN) is designed for dense prediction tasks, such as semantic segmentation. The model architecture begins with a standard Convolutional Neural Network (CNN) to extract image features. Next, it employs a $$1 	imes 1$$ convolutional layer to transform the number of channels to match the number of target classes. Finally, it uses a transposed convolutional layer to scale the height and width of the feature maps back to the dimensions of the original input image. The resulting output has the same spatial dimensions as the input, with each output channel representing the predicted classes for the pixel at the corresponding spatial position.

Claude

Convolutional networks, also known as convolutional neural networks, or CNNs, are a specialized kind of neural network for processing data that has a known grid-like topology. Examples include time-series data, which can be thought of as a 1-D grid taking samples at regular time intervals, and image data, which can be thought of as a 2-D grid of pixels. 

The network employs a mathematical operation called convolution. Convolution is a specialized kind of linear operation. Convolutional networks are simply neural networks that use convolution in place of general matrix multiplication in at least one of their layers.

The CNN gets its power from the following concepts:
- Sparse connectivity
- Parameter sharing

Convolutional Neural Network (CNN)

Dive into Deep Learning

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

CNN Reference

CNNs are currently being applied to several applications, including:

 - Computer vision—medical image analysis, image recognition, face detection and video classification
 - Natural Language Processing (NLP)—semantic parsing, sentence modeling and search query retrieval
 - Drug discovery—the discovery of chemical features and prediction of medicinal benefits

Applications of Convolutional Neural Networks

CNNs and RNNs are not mutually exclusive, as both can perform classification of image and text inputs, creating an opportunity to combine the two network types for increased effectiveness. This is especially true if the input to be classified is visually complex with added temporal characteristics that a CNN alone would be unable to process.

Typically, when these two network types are combined, sometimes referred to as a CRNN, inputs are first processed by CNN layers whose outputs are then fed to RNN layers. CNN Long Short-Term Memory (LSTM) architectures are particularly promising, as they facilitate analysis of inputs over longer periods than could be achieved with lower-level RNN architecture types.

Currently, these hybrid architectures are being explored for use in applications like video scene labeling, emotion detection or gesture recognition, video identification or gait recognition, and DNA sequence prediction.

Hybrid of Convolutional and Recurrent Neural Network

- Python: conv_forward
- TensorFlow: tf.nn.conv2d
- Keras: Conv2D
- Pytorch: torch.nn.Conv2d
- Caffe: message ConvolutionParameter
- Theano: theano.tensor.nnet.conv.conv2d

Methods to Calculate Convolution in Python

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 3D CNN is similar to a 2D CNN except that it differs in (non-exhaustive listing):
1- 3D Convolution Layers

2- 3D MaxPool Layers

3D Convolutional Neural Network

Visualizing and Understanding Convolutional Networks Paper

- Convolutional neural network can be used for obtaining high- dimensional images rather than being used in class prediction for logistic regression  or value prediction for regression problem

- Output of the CNN model can be a tensor S(i,j,k) which represent the pixel(j,k) of ith class, such a collaborative  effort can be used to precisely form a perfect image as the output.

Strategies to get output dimension same as the input are 

- Pooling is completely avoided or can use pooling with unit stride.

- Pixel-wise labelling involves initial guess of image pixels and refining this guess by interacting with neighboring pixels by parameter sharing.

Structured Output from CNN

A Convolutional Recurrent Neural Network (CRNN) is a combination of a Convolutional Neural Network (CNN) and a Recurrent Neural Network (RNN). 
-CNN are specialized networks for processing data that use a specialized, linear mathematical operation, also known as a convolution. 
-RNN is specialized for processing a sequence of inputs $x^{(1)}, . . . , x^{(τ)}$ and each time adds additional layers of comprehension on top of the previous inputs. 
-The goal of a CRNN is to take advantage of CNNs for local feature extraction and RNNs for temporal summarization of the extracted features.


Convolutional Recurrent Neural Network (CRNN) 

Questions about the ReLU.

The Neocognitron, introduced by Fukushima in 1982, represents one of the earliest architectures and foundational references in the development of Convolutional Neural Networks (CNNs).

Neocognitron

In object detection, a recognition system should not be overly concerned with the precise location of an object within an image. For instance, similar to finding the character Waldo in chaotic scenes, a detector can sweep an image to assign likelihood scores to different patches, indicating where the target might be. Convolutional Neural Networks (CNNs) systematize this spatial invariance, exploiting it to learn useful representations with fewer parameters.

Spatial Invariance in Object Detection

The locality principle asserts that the earliest layers of a computer vision network should focus exclusively on local regions, without regard for the contents of the image in distant areas. Mathematically, this constrains the network's parameters such that outside a localized range ($$|a| > \Delta$$ or $$|b| > \Delta$$), the convolution weights are set to zero ($$[\mathbf{V}]_{a, b} = 0$$). The hidden representation is computed as:

$$[\mathbf{H}]_{i, j} = u + \sum_{a = -\Delta}^{\Delta} \sum_{b = -\Delta}^{\Delta} [\mathbf{V}]_{a, b} [\mathbf{X}]_{i+a, j+b}$$

By restricting the network to glean relevant information only from a bounded window around each pixel, this principle drastically reduces the number of learnable parameters (e.g., from $$4 \times 10^6$$ down to $$4 \Delta^2$$).

Learn Before

Related

Learn After