Although neural networks are really powerful models, computer vision is a complex problem to solve, since we need more specialized feature detectors for images. In this section, we'll explore edge detection as one of the fundamental techniques in computer vision for neural network architectures. Then, we'll visit horizontal and vertical edge detection, and finally, we'll understand why edge detection is doing so well.

Edges are the pixels where the sight color of the pixels dramatically changes from one side to the other. For example, let's look at the following image:

The edges in the preceding screenshot are where the pixel color changes dramatically...

Now, we'll see different type of filters and apply them to different images. Also, we'll explore how the neural network is using convolution or edge detection.

There are other types of filters apart from the vertical and horizontal filters we've seen so far:

Two other popular filters are as follows:

• Sobel: This filter simply adds a little bit more weight or value to the middle
• Scharr: Besides adding even more weight to the middle, this filter also adds weight to the sides

As we can see, the zeros are placed in the middle column of the Vertical, Sobel, and Scharr filters. Hence, we can say that Sobel and Scharr measure the difference between the left...

Let's see how convolution is done with color images, and how we can obtain multi-dimensional output matrices.

As we saw previously, a color image is represented as a three-dimensional matrix of numbers:

The third dimension is usually called all the channels. In this case, we have three channels: red, green, and blue. Considering how the convolution was done with the grayscale images, just convolving a two-dimensional matrix with one filter, one reasonable thing to do here—since we have three of the two-dimensional matrices—is to convolve with three filters:

Each of these filters will be convolved with one of the channels.

So far, we've seen 3 x 3 filters, but actually, the two dimensions can vary from x to ε.

This kind of operation will now produce three outputs:

Let's look in a bit more detail at what's happened...

We'll see how to increase the dimension of the output matrix by using padding, and how to greatly decrease it through use of the stride. You will recall from the previous section, that we're convolving a 6 x 6 x 3 input image with 3 x 3 filters, which gives us a 4 x 4 x 1 matrix output:

And as you may have guessed, these output dimensions can be described by a math formula, and that formula appears as follows:

In this equation, IM is just the input matrix dimension, OM is the output matrix dimension, and F refers to the filter size. So let's apply this formula:

We can do the same for the other dimension as well. Feel free to try a different size of input images with different filters, and see how this formula will actually work. You can do that even for the edge detection application. Regardless of this formula...

Let's see a slightly different type of layer, pooling layers, and, more specifically, we'll go in to the details of max pooling and average pooling.

Let's first explore how max pooling works. Similar to the convolution, we have the same parameters, the filter size is 2 x 2, the stride defines how big the step is, and we won't use any padding here:

Max pooling simply outputs the maximum of the selected values from the filter window, and, in this case, it would be nine.

It then moves the window on the right:

In this case, it moves two steps because of the stride, and outputs the maximum of the selected values, which is three.

It then moves down two steps and it outputs eight:

So far, we've examined all the building blocks needed to build a Convolutional Neural Network (CNN), and that's exactly what we are going to do in this section, where we explain why convolution is so efficient and widely used.

Here's the architecture of a CNN:

First, we start with a 28 x 28 grayscale image, so we have one channel that's just a black-and-white image. For now, it doesn't really matter, but these are handwritten digit images taken from the MNIST dataset that we saw in the previous chapter.

In the first layer, we'll apply a 5 x 5 filter, a convolution feed filter, with a stride of 1 and no padding, and, applying the formula we saw in the previous section will give us a 24 x 24 output matrix. But since we want a higher number of channels, in order to capture more features, we will apply...

Let's see how our CNN architecture will look when written in Java. We'll also run the Java application and test the improved model from the graphical user interface. We'll draw some digits and ask models for predictions, and maybe simulate a case when a convolution will outperform the simple neural network model.

Before checking out the code, let's first look at the CNN architecture that we saw in the previous section from a different point of view:

So, we have this table here, and in the extreme left, there are the layers. Then we have these two columns, which are the activation's. So the activations are just the input, hidden layers, or convolution layers, and one activation shows the shape of the matrix dimensions, while the other shows the complete size, which is just a multiplication of the...

We hope you enjoyed learning about edge detection, and creating an application to detect the edges of complex images using different types of filters. We took an in-depth look at convolution and worked with its layers, which helped us to understand complex convolution neural networks. We saw the benefit of pooling layers in building a CNNs—they reduce the number of parameters drastically. We saw why convolution is the ultimate technique for achieving better accuracy and proved it by building and training a CNN that showed how the accuracy percentage was improving consistently over time rather than sticking at 97%, as with the simple neural networks.

In the next chapter, we'll look at transfer learning and the deep convolution neural network architecture, which will enable us to achieve state-of-the-art accuracy.