The RNN abstraction

• On a high level, the RNN is a function that

  • Takes as input an arbitrary length ordered sequence of $n$ $d_{\text{in}}$-dimensional vectors $x_{1:n}=x_1,\dots ,x_n$, and
  • Returns as output a single $d_{\text{out}}$ dimensional vector $y_n$
  • The output vector $y_n$ is then used for further prediction $$\begin{array}{cc}& y_n=\text{RNN}\left(x_{1:n}\right)\\ & x_i\in R^{d_{\text{in}}},y_n\in R^{d_{\text{out}}}\end{array}$$

• This implicitly defines an output vector $y_i$ for each prefix $x_{1:i}$. We denote by RNN${}^{\ast }$ the function returning this sequence $$\begin{array}{cc}& y_{1:n}={\text{RNN}}^{\ast }\left(x_{1:n}\right)\\ & y_i=\text{RNN}\left(x_{1:i}\right)\\ & x_i\in R^{d_{\text{in}}},y_i\in R^{d_{\text{out}}}\end{array}$$

• The RNN function provides a framework for conditioning on the entire history $x_1,\dots ,x_i$ without the Markov assumption

The R function and the O function

• The RNN is defined recursively, by means of a function $R$ taking as the state vector $s_{i-1}$ and an input vector $x_i$ and returning a new state vector $s_i$

• The state vector $s_i$ is then mapped to an output vector $y_i$ using a simple deterministic function $O$ $$\begin{array}{cc}{s}_i& =R(s_{i-1},x_i)\\ y_i& =O\left(s_i\right)\end{array}$$

• The functions $R$ and $O$ are the same across the sequence positions, but the RNN keeps track of the states of computation through the state vector $s_i$ that is kept and being passed across invocations of $R$

An illustration of the RNN

• We include here the parameters $\theta$ in order to highlight the fact that the same parameters are shared across all time steps

An illustration of the RNN (unrolled)

Common RNN usage patterns: acceptor

• Acceptor: based on the supervision signal only at the final output vector $y_n$

  • Typically, the RNN’s output vector $y_n$ is fed into a fully connected layer or an MLP, which produce a prediction

Common RNN usage patterns: encoder

• Encoder: also only uses the final output vector $y_n$. Here $y_n$ is treated as an encoding of the information in the sequence, and is used as additional information together with other signals

Common RNN usage patterns: transducer

• Transducer: The loss of unrolled sequence will be used

• A natural use case of the transduction is for language modeling, where the sequence of words $x_{1:i}$ is used to predict a distribution over the $(i+1)$th word

• RNN based lanuage models are shown to provide vastly better perplxities than traditional language models

• Using RNNs as transducers allows us to relax the Markov assumption and condition on the entire prediction history

An illustration of transducer

Bidirectional RNNs (biRNN)

• A useful elaboration of an RNN is a biRNN

• Consider an input sequence $x_{1:n}$. The biRNN works by maintaining two separate states, $s_i^f$ and $s_i^b$ for each input position $i$

  • The forward state $s_i^f$ is based on $x_1,x_2,\dots ,x_i$
  • The backward state $s_i^b$ is based on $x_n,x_{n-1},\dots ,x_i$

• The output at position $i$ is based on the concatenation of the two output vectors $$y_i=[y_i^f;y_i^b]=\left[O^f\right(s_i^f);O^b(s_i^b\left)\right]$$

• Thus, we define biRNN as $$\text{biRNN}(x_{1:n},i)=y_i=\left[{\text{RNN}}^f\right(x_{1:i}),{\text{RNN}}^b(x_{n:i}\left)\right]$$

An illustration of biRNN

Deep (multi-layer stacked) RNNs

• The input for the first RNN are $x_{1:n}$, while the input of the $j$th RNN ($j\ge 2$) are the outputs of the RNN below it, $y_{1:n}^{j-1}$

• While it is not theoretically clear what is the additional power gained by the deeper architecture, it was observed empirically that deep RNNs work better than shallower ones on some tasks

• The author’s experience: using two or more layers indeed often improves over using a single one

A note on reading the literature

• Unfortunately, it is often the case that inferring the exact model form from reading its description in a research paper can be quite challenging

• For example,
  • The inputs to the RNN can be either one-hot vectors or embedded representations
  • The input sequence can be padded with start-of-sequence and/or end-of-sequence symbols, or not

An illustration of deep RNN

Simple RNN (SRNN)

• The nonlinear function $g$ is usually tanh or ReLU

• The output function $O(\cdot )$ is the identify function $$\begin{array}{cc}{s}_i& =R_{\text{SRNN}}(x_i,s_{i-1})=g(s_{i-1}{W}^s+x_i{W}^x+b)\\ y_i& =O_{\text{SRNN}}\left(s_i\right)=s_i\end{array}$$ $$s_i,y_i\in R^{d_s},x_i\in R^{d_x},W^x\in R^{d_x\times d_s},W^s\in R^{d_s\times d_s},b\in R^{d_s}$$

• SRNN is hard to train effectively because of the vanishing gradients problem

Gated architectures

• An apparent problem with SRNN is that the memory access is not controlled. At each step of the computation, the entire memory state is read, and the entire memory state is written

• We denote the hadamard-product operation (element-wise product) as $\odot$

• To control memory access, consider a binary vector $g\in \{0,1{\}}^n$

• For a memory $s\in R^d$ and an input $x\in R^d$, the computation

$$s^{\prime }⟵g\odot x+(1-g)\odot s$$ “reads” the entries in $x$ that correspond to the 1 values in $g$, and writes them to the new memory $s^{\prime }$. Locations that weren’t read to are copied from the memory $s$ to the new memory $s^{\prime }$ through the use of the gate $(1-g)$

An illustration of binary gate

Differentiable gates

• The gates should not be static, but be controlled by the current memory state and the input, and their behavior should be learned

• Obstacle: learning in our framework entails being differentiable (because of the backpropagation algorithm), but the binary 0-1 values used in th e gates are not differentiable

• Solution: approximate the hard gating mechanism with a soft, but diffrentiable, gating mechanism

• To achieve these differentiable gates, we replace the requirement that $g\in \{0,1{\}}^n$, and allow arbitrary real numbers $g^{\prime }\in R^n$. These are then passed through a sigmoid function $\sigma \left(g^{\prime }\right)$, which take values in the range $(0,1)$

LSTM

• Long Short-Term Memory (LSTM): explicitly splits the state vector $s_i$ into two halves, where one half is treated as “memory cells” $c_j$, and the hidden state component $h_j$

$$s_j={\text{R}}_{\text{LSTM}}(s_{j-1},x_j)=[c_j;h_j]$$

• There are three gates, $i$nput, $f$orget, and $o$utput $$\begin{array}{cc}{c}_j& =f\odot c_{j-1}+i\odot z\\ z& =\text{tanh}(x_j{W}^{xz}+h_{j-1}{W}^{hz})\\ h_j& =o\odot \text{tanh}\left(c_j\right)\\ y_j& =O_{\text{LSTM}}\left(s_j\right)=h_j\end{array}$$

LSTM gates

• The gates are based on $x_j,h_{j-1}$ and are passed through a sigmoid activation function $$\begin{array}{cc}i& =\sigma (x_j{W}^{xi}+h_{j-1}{W}^{hi})\\ f& =\sigma (x_j{W}^{xf}+h_{j-1}{W}^{hf})\\ o& =\sigma (x_j{W}^{xo}+h_{j-1}{W}^{ho})\end{array}$$

• When training LSTM networks, it is strongly recommended to always initialize the bias term of the forget gate to be close to one

GRU

• Gated Recurrent Unit (GRU) is shown to perform comparably to the LSTM on several datasets

• GRU has substantially fewer gates that LSTM and doesn’t have a separate memory component $$\begin{array}{cc}{s}_j& ={\text{R}}_{\text{GRU}}(s_{j-1},x_j)=(1-z)\odot s_{j-1}+z\odot {\tilde{s}}_j\\ {\tilde{s}}_j& =\text{tanh}(x_j{W}^{xs}+(r\odot s_{j-1}\left)W^{sg}\right)\\ y_j& =O_{\text{GRU}}\left(s_j\right)=s_j\end{array}$$

• Gate $r$ controls access to the previous state $s_{j-1}$ in ${\tilde{s}}_j$

• Gate $z$ controls the proportions of the interpolation between $s_{j-1}$ and ${\tilde{s}}_j$ when in the updated state $s_j$ $$\begin{array}{cc}z& =\sigma (x_j{W}^{xz}+s_{j-1}{W}^{sz})\\ r& =\sigma (x_j{W}^{xr}+s_{j-1}{W}^{sr})\end{array}$$

Acceptors

• The simplest use of RNN: read in an input sequence, and produce a binary of multi-class answer at the end

• The power of RNN is often not needed for many natural language classification tasks, because the word-order and sentence structure turn out to not be very important in many cases, and bag-of-words or bag-of-ngrams classifier often works just as well or even better than RNN acceptors

Sentiment classification: sentence level

• The sentence level sentiment classification is straightforward to model using an RNN acceptor:

  • Tokenization
  • RNN reads in the words of the sentence one at a time
  • The final RNN state is then fed into a MLP followed by a softmax-layer with two outputs
  • The network is trained with cross-entropy loss based on the gold sentiment labels $$\begin{array}{cc}p(\text{label}=k\mid w_{1:n})& ={\hat{y}}_{\left[k\right]}\\ \hat{y}& =\text{softmax}\left\{\text{MLP}\left[\text{RNN}\right(x_{1:n}\left)\right]\right\}\\ x_{1:n}& =E_{\left[w_1\right]},\dots ,E_{\left[w_n\right]}\end{array}$$

• biRNN: it is often helpful to extend the RNN model into the biRNN $$\hat{y}=\text{softmax}\left\{\text{MLP}\left[{\text{RNN}}^f\right(x_{1:n});{\text{RNN}}^b(x_{n:1}\left)\right]\right\}$$

Hierarchical biRNN

• For longer sentences, it can be useful to use a hierarchical architecture, in which the sentence is split into smaller spans based on punctuation

• Suppose a sentence $w_{1:n}$ is split into $m$ spans $w_{1:{\ell }_1}^1,\dots ,w_{1:{\ell }_m}^m$, then the architecture is $$\begin{array}{cc}p(\text{label}=k\mid w_{1:n})& ={\hat{y}}_{\left[k\right]}\\ \hat{y}& =\text{softmax}\left\{\text{MLP}\left[\text{RNN}\right(z_{1:m}\left)\right]\right\}\\ z_i& =\left[{\text{RNN}}^f\right(x_{1:{\ell }_i}^i),{\text{RNN}}^b(x_{{\ell }_i:1}^i\left)\right]\\ x_{1:{\ell }_i}^i& =E_{\left[w_1^i\right]},\dots ,E_{\left[w_{{\ell }_i}^i\right]}\end{array}$$

• Each of the $m$ different spans may convey a different sentiment

• The higher-level acceptor reads the summary $z_{1:m}$ produced by the lower level encoder, and decides on the overall sentiment

Document level sentiment classification

• Document level sentiment classification and harder than sentence level classification

• A hierarchical architecture is useful:

  • Each sentence $s_i$ is encoded using a gated RNN, producing a vector $z_i$
  • The vectors $z_{1:n}$ are then fed into a second gated RNN, producing a vector $h=\text{RNN}\left(z_{1:n}\right)$
  • $h$ is then used fro prediction $\hat{y}=\text{softmax}\left(\text{MLP}\right(h\left)\right)$

• Keeping all intermediate vectors of the document-level RNN produces slightly higher results in some cases $$\begin{array}{cc}{h}_{1:n}& ={\text{RNN}}^{\ast }\left(z_{1:n}\right)\\ \hat{y}& =\text{softmax}\left(\text{MLP}\left(\frac{1}{n}\sum _{i=1}^n{h}_i\right)\right)\end{array}$$

References

• Goldberg, Yoav. (2017). Neural Network Methods for Natural Language Processing, Morgan & Claypool