# (zhuan) Attention in Neural Networks and How to Use It

- 时间:
- 浏览:6

Soft attention, in its simplest variant, is no different for images than for vector-valued features and is implemented exactly as in equation 11. One of the early uses of this types of attention comes from the paper called Show, Attend and Tell: *attend* to specific parts of the image while generating the word describing that part.

The only problem with the above is that it is non-differentiable; to learn the parameters of the model, one must resort to *e.g.* the score-function estimator, briefly mentioned in my previous post.

I used this mechanism in HART, my recent paper on biologically-inspired object tracking with RNNs with attention. Here is an example with the input image on the left hand side and the attention glimpse on the right hand side; the glimpse shows the box marked in the main image in green:

Spatial Transformer (STN) allows for much more general transformation that just differentiable image-cropping, but image cropping is one of the possible use cases. It is made of two components: a grid generator and a sampler. The grid generator specifies a grid of points to be sampled from, while the sampler, well, samples. The Tensorflow implementation is particularly easy in Sonnet, a recent neural network library from DeepMind.

Gaussian attention works by exploiting parametrised one-dimensional Gaussian filters to create an image-sized attention map. Let ay∈Rhay∈Rh and ax∈Rwax∈Rw be attention vectors, which specify which part of the image should be attended to in yy and xx axis, respectively. The attention masks can be created as a=ayaTxa=ayaxT.

We can also write a function to directly extract a glimpse from the image:

Gaussian attention is an over-parametrised cropping mechanism: it requires six parameters, but there are only four degrees of freedom (y, x, height width). STN needs only four parameters.

To understand why attention is important, we have to think about what a neural network really is: a function approximator. Its ability to approximate different classes of functions depends on its architecture. A typical neural net is implemented as a chain of matrix multiplications and element-wise non-linearities, where elements of the input or feature vectors interact with each other only by addition.

Attention mechanisms compute a mask which is used to multiply features. This seemingly innocent extension has profound implications: suddenly, the space of functions that can be well approximated by a neural net is vastly expanded, making entirely new use-cases possible. Why? While I have no proof, the intuition is following: the theory says that neural networks are universal function approximators and can approximate an arbitrary function to arbitrary precision, but only in the limit of an infinite number of hidden units. In any practical setting, that is not the case: we are limited by the number of hidden units we can use. Consider the following example: we would like to approximate the product of NN inputs. A feed-forward neural network can do it only by simulating multiplications with (many) additions (plus non-linearities), and thus it requires a lot of neural-network real estate. If we introduce multiplicative interactions, it becomes simple and compact.

This type of soft attention is computationally wasteful, however. The blacked-out parts of the input do not contribute to the results but still need to be processed. It is also over-parametrised: sigmoid activations that implement the attention are independent of each other. It can select multiple objects at once, but in practice we often want to be selective and focus only on a single element of the scene. The two following mechanisms, introduced by DRAW and Spatial Transformer Networks, respectively, solve this issue. They can also resize the input, leading to further potential gains in performance.

Attention can be applied to any kind of inputs, regardless of their shape. In the case of matrix-valued inputs, such as images, we can talk about *visual attention*. Let I∈RH×WI∈RH×W be an image and g∈Rh×wg∈Rh×wan attention glimpse *i.e.* the result of applying an attention mechanism to the image II.

g=AyIATx.g=AyIAxT.

Informally, a neural attention mechanism equips a neural network with the ability to focus on a subset of its inputs (or features): it selects specific inputs. Let x∈Rdx∈Rd an input, z∈Rkz∈Rk a feature vector, a∈[0,1]ka∈[0,1]k an attention vector and fϕ(x)fϕ(x) an attention network. Typically, attention is implemented as

Attention in the above form is still wasteful, as it selects only a part of the image while blacking-out all the remaining parts. Instead of using the vectors directly, we can cast them into matrices Ay∈Rh×HAy∈Rh×Hand Ax∈Rw×WAx∈Rw×W, respectively. Now, each matrix has one Gaussian per row and the parameter ddspecifies distance (in column units) between centres of Gaussians in consecutive rows. Glimpse is now implemented as

Both Gaussian attention and Spatial Transformer can implement a very similar behaviour. How do we choose which to use? There are several nuances:

I haven’t run any tests yet, but STN *should be* faster. It relies on linear interpolation at sampling points, while the Gaussian attention has to perform two huge matrix multiplication. STN *could be* an order of magnitude faster (in terms of pixels in the input image).

Hard attention for images has been known for a very long time: image cropping. It is very easy conceptually, as it only requires indexing. Hard-attention can be implemented in Python (or Tensorflow) as

where ⊙⊙ is element-wise multiplication. We can talk about *soft attention*, which multiplies features with a (soft) mask of values between zero and one, or *hard attention*, when those values are constrained to be exactly zero or one, namely a∈{0,1}ka∈{0,1}k. In the latter case, we can use the hard attention mask to directly index the feature vector: za=z[a]za=z[a] (in Matlab notation), which changes its dimensionality.

**this blog comes from: http://akosiorek.github.io/ml/2017/10/14/visual-attention.html **

Attention mechanisms expand capabilities of neural networks: they allow approximating more complicated functions, or in more intuitive terms, they enable focusing on specific parts of the input. They have led to performance improvements on natural language benchmarks, as well as to entirely new capabilities such as image captioning, addressing in memory networks and neural programmers.

The code below lets you create one of the above matrix-valued masks for a mini-batch of samples in Tensorflow. If you want to create AyAy, you would call it as `Ay = gaussian_mask(u, s, d, h, H)`

, where `u, s, d`

are μ,σμ,σ and dd, in that order and specified in pixels.

The above definition of attention as multiplicative interactions allow us to consider a broader class of models if we relax the constrains on the values of the attention mask and let a∈Rka∈Rk. For example,Dynamic Filter Networks (DFN) use a filter-generating network, which computes filters (or weights of arbitrary magnitudes) based on inputs, and applies them to features, which effectively is a multiplicative interaction. The only difference with soft-attention mechanisms is that the attention weights are not constrained to lie between zero and one. Going further in that direction, it would be very interesting to learn which interactions should be additive and which multiplicative, a concept explored in A Differentiable Transition Between Additive and Multiplicative Neurons. The excellent distill blog provides a great overview of soft-attention mechanisms.

I believe that the most important cases in which attention is useful have not been yet discovered. For example, we know that objects in videos are consistent and coherent, *e.g.* they do not disappear into thin air between frames. Attention mechanisms can be used to express this consistency prior. How? Stay tuned.

Attention mechanisms in neural networks, otherwise known as *neural attention* or just *attention*, have recently attracted a lot of attention (pun intended). In this post, I will try to find a common denominator for different mechanisms and use-cases and I will describe (and implement!) two mechanisms of soft visual attention.

aza=fϕ(x),=a⊙z,(1)(1)a=fϕ(x),za=a⊙z,

Gaussian attention *should be* (no tests run) easier to train. This is because every pixel in the resulting glimpse can be a convex combination of a relatively big patch of pixels of the source image, which (informally) makes it easier to find the cause of any errors. STN, on the other hand, relies on linear interpolation, which means that gradient at every sampling point is non-zero only with respect to the two nearest pixels.