An** autoencoding algorithm** is an unsupervised learning algorithm which seeks to recreate its input after processing the output. The layer or layers between input and output then become a representation of the input, which may have fewer or more dimensions than the input.

If the internal layer is further restricted so that only a very few of its components are active for any given input, then it is a **sparse autoencoder**. Generally, if the dimension of the internal layer is less than that of the input layer, then the autoencoder is performing, appropriately enough, **dimension reduction**. If, however, the number of dimensions is greater, then we enter the realm of **feature detection**, which, to me anyway, is a much more interesting application of autoencoding. In addition, feature detection appears to be how the brain handles input.

One of the challenges of feature detection is to ensure the internal layers don't degenerate to a trivial representation of the input, that is, simply repeating the input so that each feature is simply an input feature.

I'll start by talking about autoencoding via backpropagation. Before we tackle this, I'd like to rehash the mathematics of backpropagation, but this time in matrix form, which will be much easier to handle. So feel free to skip if you're not really interested.

### Backpropagation, a more thorough derivation

We start with the same diagram as before:

This time, however, we'll use matrix notation. The equation for the vector of activations for layer *l* is as follows:

where:

*a*is a column vector of^{(l)}*s*elements (i.e. an_{l}*s*matrix), the activations of the neurons in layer_{l}x 1*l*,*b*is a column vector of s^{(l)}_{l}elements (i.e. an*s*matrix), the biases for layer_{l}x 1*l*, equivalent to a fixed input 1 multiplied by a bias weight, separated out so we don't have to deal with a separate and somewhat confusing input augmentation step,*W*is an^{(l-1)}*s*matrix for the weights between layer_{l}x s_{l-1}*l-1*and layer*l*, and*g*is a squashing function, which we can take to be the logistic function (for range 0 to 1) or the tanh function (for range -1 to 1). Or really any differentiable function.

A quick sanity check for *z = Wa + b*: *W* is *s _{l} x s_{l-1}*,

*a*is

*s*, so multiplying

_{l-1}x 1*W x a*cancels out the middle, yielding

*s*, which is consistent with the definitions for

_{l}x 1*z*and

*b*.

Now, the cost function for a single data point *x ^{(i)},y^{(i)}* is as follows:

*|| a - y ||* is simply the Euclidean distance between *a* and *y*, otherwise known as the L^{2} norm. Note also that it is a *scalar*, and not a vector or matrix.

The cost over all data points, and adding a regularization term, is:

That last term simply means to take every weight between every neuron and every other neuron in every layer, square it, and add. We don't take any of the bias terms into the regularization term, as usual.

Now, first, we want to determine how gradient descent moves *W ^{(L-1)}* and

*b*:

^{(L)}This just says that we move *W* downhill in "J-space" with respect to *W*, and the same with *b*. Note that since *W ^{(L-1)}* is an

*s*matrix, then so too must the derivative of

_{L}x s_{L-1}*J*with respect to

*W*be. And now let's compute those derivatives. First, the derivative with respect to the weights in the last layer:

^{(L-1)}Note that we just called the derivative of *g* with respect to its argument, *g'*. For the logistic and tanh functions, these are nice, compact derivatives:

Since the argument of *g* (being *z ^{(L,i)}*) is an

*s*matrix, so too is its derivative.

_{L}x 1*a*is an

^{(L-1,i)}*s*matrix, its transpose is a

_{L-1}x 1*1 x s*matrix, and thus

_{L-1}*g' x a*is an

*s*matrix, which is consistent with what we wanted the size of the derivative of

_{L}x s_{L-1}*J*with respect to

*W*to be.

^{(L-1)}And now with respect to the bias on the last layer:

Let us define:

Note that this is an *s _{L} x 1 *matrix. It is the contribution to the weight or bias gradient due to an "error" in output. We can now define our derivatives more compactly:

Now, what about the derivatives with respect to the previous layer weights and bias? The key insight in backpropagation is that we can generalize these derivatives as follows. For *l* from *L* to 2 (we start from L because these are recursive equations) we have:

A rigorous mathematical treatment for this is so completely outside the scope of this article as to be invisible :) But the general argument is that delta represents the contribution of a layer to the gradient based on the error between desired output and generated output. For the final layer, this is straightforward, and we can directly calculate it. However, for an internal layer, it is as if the errors from the next layer have propagated backwards through the weights, and so we can calculate, from output to input, the contributions of each layer.

### Backpropagation, the algorithm

First, zero out an accumulator for each layer. The accumulators have the same dimensions as the weight and bias matrices. So for *l* from 2 to *L*:

Second, compute all the forward activations a for a single data point. So, for *l* from 2 to *L*, we have:

Compute the delta terms for *l* from *L* to 2, and add to the accumulators:

Next, after doing the above two steps for each data point, we compute the gradients for *l* from 2 to *L*:

Finally, we use these gradients to go downhill, for *l* from 2 to *L*:

That is one round of updates. We start from zeroing out the accumulators to do the next iteration, and continue until it doesn't look like the cost is getting any lower.

Instead of the above, we could provide a function which, given *W* and *b*, computes the cost and the derivatives. Then we give that function to a library which does minimization. Sometimes minimization libraries do a better job at minimizing than manually doing gradient descent, and some of the libraries don't need a learning parameter (alpha).

### Adding a sparseness criterion

The whole reason for going through the derivation and not going straight to the algorithm was so that we could add a sparseness measure in the cost function, and see how that affects the algorithm.

First, if we have *d* dimensions in the input, then an autoencoder will be a *d*:1:*d* network.

We will first determine the average activation of layer 2 over all data points:

Note that this is an *s _{2} x 1 *matrix. To be sparse, we want the values of each element to be very low. If we're using a logistic function, this means near to zero. If we're using the tanh function, near to -1, but we will rescale the average activation to lie between 0 and 1 by adding 1 and dividing by 2.

Let us denote our target sparsity for each element as ρ, so that we want our measured sparsity to be close to that. Clearly we don't want ρ=0, because that would give us a trival solution: zero weights everywhere.

For a sparsity cost, we will use the following measure, known as the Kullback-Leibler divergence:

Note that the sum applies element-by-element to the measured sparsity vector, and so the cost is a *scalar*. This cost is zero when each measured sparsity element is equal to the desired sparsity, and rises otherwise.

We add this cost to our main cost function as follows:

where β is just a parameter whereby we can tune the importance of the sparsity cost.

Without going through the derivation, we use the following altered delta for layer 2 during backpropagation:

That *scalar* term added due to sparsity is computed only after all data points have been fed forwards through the network, because that is the only way to determine the average activation of layer 2. It is independent, therefore, of i. So the modification to backpropagation would require this:

- Going through the data set, compute all the way up to layer 2, and accumulate the sum of the activations for each neuron in layer 2.
- Divide the sums by
*m*, the number of points in the data set. - Perform one iteration of backpropagation.
- Go back to step 1.

### Why I don't like this

It is said that backpropagation is **not biologically plausible**, that is, it cannot be the algorithm used by the brain. There are several reasons for this, chief among which is that errors do not propagate backwards in the brain.

A sparse backpropagating autoencoder is doubly implausible, because not only does it rely on backpropagation, but it also requires that we wait until all data points are presented before determining the average activation. It would be much nicer if we had something more biologically plausible, if only because I have the suspicion that any algorithm that is not biologically plausible cannot lead to human-level intelligence.

So in the next article, I'll talk about a biologically plausible algorithm called the reverse Boltzmann machine.