CNN Filters

Convolutional neural networks, or CNNs, are particularly effective for a wide range of applications, including segmentation, object identification, and picture categorization. Convolutional kernels, often referred to as feature detectors or filters, are the brains behind CNNs. They are essential in the process of deriving significant features from unprocessed pixel values.

CNN filters are small, learnable matrices that slide over the input image to perform convolution operations. These filters act as feature extractors, detecting patterns, edges, textures, and other distinctive characteristics present in the image. Each filter learns to detect specific features during the training process, capturing different aspects of the input data.

Working of CNN Filters

Convolution is a mechanism that is involved in how CNN filters work. In essence, convolution is a mathematical technique that creates a third function by combining two functions. Convolution in the context of CNNs entails moving the filter across the input picture and calculating the element-wise product of the image's local receptive field and the filter. After that, the data are added together to create a single output value that is included in the feature map.

Types of CNN Filters

There are four types of CNN Filters that are:

• Edge Detection Filters: They identify gradients and edges in a picture and record abrupt variations in pixel intensity. Sobel, Prewitt, and Roberts filters are a few examples; these are frequently employed for edge detection applications.
• Blur and Smoothing Filters: Images may be made smoother and less noisy by using filters like Box blur and Gaussian blur. They aid in the elimination of high-frequency elements and the creation of a more homogeneous look.
• Sharpening Filters: These improve an image's edges and details, giving it a clearer, more defined appearance. Laplacian and Unsharp Mask filters are two examples that emphasize edges by amplifying high-frequency components.
• Feature Extraction Filters: Higher-level features like textures, forms, and object pieces may be extracted using feature extraction filters, which are trained during a CNN training phase. CNN's layers are made up of several filters, each of which focuses on capturing a certain aspect.

Code:

Now we will try to visualize the Filters

Visualizing Convolutional Layers

It's well known that neural network models are opaque. This indicates that they are not very good at providing context for a choice or forecast. Because of its structure and functionality, convolutional neural networks-which are meant to process picture data-should be easier to understand than other kinds of neural networks.

In particular, the models are made up of tiny linear filters and the output of filters known as activation maps, or feature maps in a broader sense. It is possible to visualize both feature maps and filters. As an illustration, we are able to create and comprehend tiny filters like line detectors. Perhaps understanding how a taught convolutional neural network functions can be gained by seeing its filters.

A pre-trained model that is part of the Keras Framework will be used. While there are other CNN models, we shall employ the VGG model. With 16 learned layers, it is deep and performs exceptionally well, so the filters and feature maps that arise will catch valuable features.

Importing Libraries

Output:

Visualizing Filters

The learned filters are, to use the language of neural networks, just weights; nevertheless, because of the unique two-dimensional structure of the filters, the weight values have a spatial connection to each other, and it makes sense (or may make sense) to plot each filter as a two-dimensional image. The model summary, which was printed in the preceding step, provides an overview of each layer's output shape, such as the final feature map shape. It merely provides the total number of weights per layer; it gives no indication of the actual form of the filters (weights) in the network. By using the model.layers property, we are able to access every layer in the model.

The naming convention for the convolutional layers is block#_conv#, where the '#' is an integer. Each layer has a layer.name attribute. As a result, we may look up each layer's name and ignore those that don't have the string "conv."

The weights of each convolutional layer are two sets. The filter block is one, while the bias value block is the other. These may be accessed with the method layer.get_weights(). These weights may be retrieved, and their form can then be summarized.

Output:

Each layer's 3x3 filters are visible.

As we are using a channel-last format, we can see that each filter has a depth of three for the input picture, which contains three channels for red, green, and blue. One filter may be represented as a plot of three pictures, one for each channel, or it could be compressed into a single color image. Another option is to just see the first channel and trust that the remaining channels would appear the same. The issue is that there are sixty-three more filters that we may want to visualize.

The following is how we may obtain the filters from the first layer:

The weight values will probably be tiny, with a 0.0 center for both positive and negative values.

To make them easier to see, we can normalize their values to fall between 0 and 1.

Six of the 64 filters from the first layer will be visualized.

Output:

It is evident that the first row shows instances when the filter is the same for all channels, whereas the last row shows instances where the filters are different. Large or excitatory weights are represented by the light squares, whereas tiny or inhibitory weights are shown by the dark squares. By applying this understanding, we can observe that the first row's filters identify a gradient that goes from light in the upper left corner to dark in the lower right corner.

We only see the first six filters out of the 64 in the first convolutional layer, despite having a visualization. It is possible to see all 64 filters in one photograph.

Unfortunately, this is not scalable. Upon examining the filters in the second convolutional layer, we find that, once more, there are 64 filters, but each filter has 64 channels in order to correspond with the input feature maps. It would take (64�64) 4,096 subplots to view all 64 channels in a row for all 64 filters, and it could be difficult to notice any detail in them.