In this article by **Antonio Gulli**, **Sujit Pal**, the authors of the book Deep Learning with Keras, we will learn about reinforcement learning, or more specifically deep reinforcement learning, that is, the application of deep neural networks to reinforcement learning. We will also see how convolutional neural networks leverage spatial information and they are therefore very well suited for classifying images.

*(For more resources related to this topic, see here.)*

# Deep convolutional neural network

A **Deep Convolutional Neural Network** (**DCCN**) consists of many neural network layers. Two different types of layers, convolutional and pooling, are typically alternated. The depth of each filter increases from left to right in the network. The last stage is typically made of one or more fully connected layers as shown here:

There are three key intuitions beyond ConvNets:

- Local receptive fields
- Shared weights
- Pooling

Let’s review them together.

## Local receptive fields

If we want to preserve the spatial information, then it is convenient to represent each image with a matrix of pixels. Then, a simple way to encode the local structure is to connect a submatrix of adjacent input neurons into one single hidden neuron belonging to the next layer. That single hidden neuron represents one local receptive field. Note that this operation is named **convolution** and it gives the name to this type of networks.

Of course we can encode more information by having overlapping submatrices. For instance let’s suppose that the size of each single submatrix is 5 x 5 and that those submatrices are used with MNIST images of 28 x 28 pixels, then we will be able to generate 23 x 23 local receptive field neurons in the next hidden layer. In fact it is possible to slide the submatrices by only 23 positions before touching the borders of the images. In Keras, the size of each single submatrix is called stride-length and this is an hyper-parameter which can be fine-tuned during the construction of our nets.

Let’s define the feature map from one layer to another layer. Of course we can have multiple feature maps which learn independently from each hidden layer. For instance we can start with 28 x 28 input neurons for processing MINST images, and then recall k feature maps of size 23 x 23 neurons each (again with stride of 5 x 5) in the next hidden layer.

## Shared weights and bias

Let’s suppose that we want to move away from the pixel representation in a row by gaining the ability of detecting the same feature independently from the location where it is placed in the input image. A simple intuition is to use the same set of weights and bias for all the neurons in the hidden layers. In this way each layer will learn a set of position-independent latent features derived from the image.

Assuming that the input image has shape *(256, 256)* on 3 channels with **tf** (** Tensorflow**) ordering, this is represented as *(256, 256, 3)*. Note that with **th** (**Theano**) mode the channels dimension (the depth) is at index *1*, in tf mode is it at index *3*.

In Keras if we want to add a convolutional layer with dimensionality of the output 32 and extension of each filter 3 x 3 we will write:

```
model = Sequential()
model.add(Convolution2D(32, 3, 3, input_shape=(256, 256, 3))
```

This means that we are applying a 3 x 3 convolution on 256 x 256 image with 3 input channels (or input filters) resulting in 32 output channels (or output filters).

An example of convolution is provided in the following diagram:

## Pooling layers

Let’s suppose that we want to summarize the output of a feature map. Again, we can use the spatial contiguity of the output produced from a single feature map and aggregate the values of a submatrix into one single output value synthetically describing the meaning associated with that physical region.

### Max pooling

One easy and common choice is the so-called max pooling operator which simply outputs the maximum activation as observed in the region. In Keras, if we want to define a max pooling layer of size 2 x 2 we will write:

`model.add(MaxPooling2D(pool_size = (2, 2)))`

An example of max pooling operation is given in the following diagram:

### Average pooling

Another choice is the average pooling which simply aggregates a region into the average values of the activations observed in that region.

Keras implements a large number of pooling layers and a complete list is available online. In short, all the pooling operations are nothing more than a summary operation on a given region.

# Reinforcement learning

Our objective is to build a neural network to play the game of catch. Each game starts with a ball being dropped from a random position from the top of the screen. The objective is to move a paddle at the bottom of the screen using the left and right arrow keys to catch the ball by the time it reaches the bottom. As games go, this is quite simple. At any point in time, the state of this game is given by the *(x, y)* coordinates of the ball and paddle. Most arcade games tend to have many more moving parts, so a general solution is to provide the entire current game screen image as the state. The following diagram shows four consecutive screenshots of our catch game:

Astute readers might note that our problem could be modeled as a classification problem, where the input to the network are the game screen images and the output is one of three actions – move left, stay, or move right. However, this would require us to provide the network with training examples, possibly from recordings of games played by experts. An alternative and simpler approach might be to build a network and have it play the game repeatedly, giving it feedback based on whether it succeeds in catching the ball or not. This approach is also more intuitive and is closer to the way humans and animals learn.

The most common way to represent such a problem is through a **Markov Decision Process** (**MDP**). Our game is the environment within which the agent is trying to learn. The state of the environment at time step *t* is given by *st* (and contains the location of the ball and paddle). The agent can perform certain actions at (such as moving the paddle left or right). These actions can sometimes result in a reward *rt*, which can be positive or negative (such as an increase or decrease in the score). Actions change the environment and can lead to a new state *st+1*, where the agent can perform another action *at+1*, and so on. The set of states, actions and rewards, together with the rules for transitioning from one state to the other, make up a Markov decision process. A single game is one episode of this process, and is represented by a finite sequence of states, actions and rewards:

Since this is a Markov decision process, the probability of state *st+1* depends only on current state *st* and action *at*.

## Maximizing future rewards

As an agent, our objective is to maximize the total reward from each game. The total reward can be represented as follows:

In order to maximize the total reward, the agent should try to maximize the total reward from any time point *t* in the game. The total reward at time step *t* is given by *Rt* and is represented as:

However, it is harder to predict the value of the rewards the further we go into the future. In order to take this into consideration, our agent should try to maximize the total discounted future reward at time *t* instead. This is done by discounting the reward at each future time step by a factor *γ* over the previous time step. If *γ* is *0*, then our network does not consider future rewards at all, and if *γ* is *1*, then our network is completely deterministic. A good value for *γ* is around *0.9*. Factoring the equation allows us to express the total discounted future reward at a given time step recursively as the sum of the current reward and the total discounted future reward at the next time step:

## Q-learning

Deep reinforcement learning utilizes a model-free reinforcement learning technique called **Q-learning**. Q-learning can be used to find an optimal action for any given state in a finite Markov decision process. Q-learning tries to maximize the value of the Q-function which represents the maximum discounted future reward when we perform action *a* in state *s*:

Once we know the Q-function, the optimal action a at a state s is the one with the highest Q-value. We can then define a policy *π(s)* that gives us the optimal action at any state:

We can define the Q-function for a transition point *(st, at, rt, st+1)* in terms of the Q-function at the next point *(st+1, at+1, rt+1, st+2)* similar to how we did with the total discounted future reward. This equation is known as the **Bellmann equation**.

The Q-function can be approximated using the Bellman equation. You can think of the Q-function as a lookup table (called a **Q-table**) where the states (denoted by *s*) are rows and actions (denoted by *a*) are columns, and the elements (denoted by *Q(s, a)*) are the rewards that you get if you are in the state given by the row and take the action given by the column. The best action to take at any state is the one with the highest reward. We start by randomly initializing the Q-table, then carry out random actions and observe the rewards to update the Q-table iteratively according to the following algorithm:

```
initialize Q-table Q
observe initial state s
repeat
select and carry out action a
observe reward r and move to new state s'
Q(s, a) = Q(s, a) + α(r + γ maxa' Q(s', a') - Q(s, a))
s = s'
until game over
```

You will realize that the algorithm is basically doing stochastic gradient descent on the Bellman equation, backpropagating the reward through the state space (or episode) and averaging over many trials (or epochs). Here *α* is the learning rate that determines how much of the difference between the previous Q-value and the discounted new maximum Q-value should be incorporated.

# Summary

We have seen the application of deep neural networks, reinforcement learning. We have also seen convolutional neural networks and how they are well suited for classifying images.

# Resources for Article:

**Further resources on this subject:**

- Deep learning and regression analysis [article]
- Training neural networks efficiently using Keras [article]
- Implementing Artificial Neural Networks with TensorFlow [article]