The neural networks we’ve built so far have had a relatively simple structure. The input to each layer is *fully connected* to the output of the previous layer. For this reason, these layers are commonly called **fully connected** layers.

This has been mathematically convenient because we’ve been able to represent each layer’s output as a matrix multiplication of the previous layer’s output (a vector) with the current layer’s weights.

However, as we build more complex networks for image recognition, there are certain properties we want that are difficult to get from fully connected layers. Some of these properties include:

**Translational Invariance**– A fancy phrase for “A network trained to recognize cats should recognize cats equally well if they’re in the top left of the picture or the bottom right of the picture”. If we move the cat around the image, we should still expect to recognize it.**Local Connectivity**– This means that we should take advantage of features within a certain area of the image. Remember that in previous posts we treated the input as a single row of pixels. This meant that local features (e.g. edges, curves, loops) are very hard for our networks to identify and pick out. Ideally our network should try to identify patterns than occur within local regions of image and use these patterns to influence its predictions.

Today we’re going look at one of the most successful classes of neural networks: Convolutional Neural Networks. Convolutional Neural Networks have been shown to give us both translational invariance and local connectivity.

The building block of a convolutional neural network is a convolutional filter. It is a square (typically `3x3`

) set of weights. The convolutional filter looks at pieces of the input of the same shape. As it does, it takes the dot product of the weights with the input and saves the result in the output. The convolutional filter is dragged along the entire input until the entire input has been covered. Below is a simple example with a (random) `5x5`

input and a (random) `3x3`

filter.

So why is this useful? Consider the following examples with a vertical line in the input and a 3×3 filter with weights chosen specifically to detect vertical edges.

We can see that with hand-picked weights, we’re able to generate patterns in the output. In this example, light-to-dark transitions produce large positive values while dark-to-light transitions produce large negative values. Where there is no change at all, the filter will simply produce zeroes.

While we’ve chosen the above filter’s weights manually, it turns out that training our network via gradient descent ends up selecting very good weights for these filters. As we add more convolutional layers to our network they begin to be able to recognize more abstract concepts such as faces, whiskers, wheels etc.

## Padding

You may have noticed that the output above has a smaller width and height than the original input. If we pass this output to another convolutional layer it will continue to shrink. Without dealing with this shrinkage, we’ll find that this puts an upper bound on how many convolutional layers we can have in our network.

### SAME Padding

The most common way to deal with this shrinkage is to pad the entire image with enough zeroes such that the output shape will have the same width and height as the input. This is called `SAME`

padding and allows us to continue passing the output to more and more convolutional layers without worrying about shrinking width and height dimensions. Below we take our first example (5×5 input) and pad it with zeroes to make sure the output is still 5×5.

### VALID Padding

`VALID`

padding does not pad the input with anything. It probably would have made more sense to call it `NO`

padding or `NONE`

padding.

## Stride

So far we’ve been moving the convolutional filter across the input one pixel at a time. In other words, we’ve been using a `stride=1`

. Stride refers to the number of pixels we move the filter in the width and height dimension every time we compute a dot-product. The most common stride value is `stride=1`

, but certain algorithms require larger stride values. Below is an example using `stride=2`

.

Notice that larger stride values result in larger decreases in output height and width. Occasionally this is desirable near the start of a network when working with larger images. Smaller input width and height can make the calculations more manageable in deeper layers of the network.

## Input Depth

In our previous examples we’ve been working with inputs that have variable height and width dimensions, but no depth dimension. However, some images (e.g. RGB) have depth, and we need some way to account for it. The key is to extend our filter’s depth dimension to match the depth dimension of the input.

Unfortunately, I lack the animation skills to properly show an animated example of this, but the following image may help:

Above we have an input of size `5x5x2`

and a single filter of size `3x3x2`

. The filter is dragged across the input and once again the dot product is taken at each point. The difference here is that there are `18`

values being added up at each point (`9`

from each depth of the input image). The result is an output with a single depth dimension.

## Output Depth

We can also control the output depth by stacking up multiple convolutional filters. Each filter acts independently of one another while computing its results and then all of the results are stacked together to create the ouptut. This means we can control output depth simply by adding or removing convolutional filters.

Two convolutional filters result in a output depth of two.

It’s very important to note that there are two *distinct* convolutional filters above. The weights of each convolutional filter are distinct from the weights of the other convolutional filter. Each of these two filters has a shape of `3x3x2`

. If we wanted to get a deeper output, we could continue stacking more of these `3x3x2`

filters on top of one another.

Imagine for a moment that we stacked four convolutional filters on top of one another, each with a set of weights trained to recognize different patterns. One might recognize horizontal edges, one might recognize vertical edges, one might recognize diagonal edges from top-left to bottom-right and one might recognize diagonal edges from bottom-left to top-right. Each of these filters would produce one depth layer of the output with values where their respective edges were detected. Later layers of our network would be able to act on this information and build up even more complex representations of the input.

## Next up

There is a lot to process in this post. We’ve seen a brand new building block for our neural networks called the convolutional filter and a myriad of ways to customize it. In the next post we’ll implement our first convolutional neural network in TensorFlow and try to better understand practical ways to use this building block to build a better digit recognizer.

Thanks, I’m looking forward to the next part.

Can I scope the convolution filter to only a specific area of the data? I’d like to allow for variance in encoding of one-dimensional data (time), but I don’t want convolution over other areas.

I think so, though I haven’t done so myself. For example if you had a separate depth channel for time, you could extract that channel with something like tf.slice, perform a convolution operation on it, then re-attach that to your original input with something like tf.stack.

There’s a little bit more here about slicing and joining Tensors:

https://www.tensorflow.org/versions/r0.12/api_docs/python/array_ops/slicing_and_joining

Whether it makes sense probably depends a little bit on the problem, how your data is represented and what your goal is.