How to Perform a GRU Implementation in TensorFlow

MLPs (Multi-Layer Perceptrons) are great for many classification and regression tasks, but it is hard for MLPs to do classification and regression on sequences. In this code tutorial, a GRU is implemented in TensorFlow.

Introduction

A sequence is an ordered set of items and sequences appear everywhere. In the stock market, the closing price is a sequence. Here, time is the ordering. In sentences, words follow a certain ordering. Therefore, sentences can be viewed as sequences. A gigantic MLP could learn parameters based on sequences, but this would be infeasible in terms of computation time. The family of Recurrent Neural Networks (RNNs) solve this by specifying hidden states which do not only depend on the input, but also on the previous hidden state. GRUs are one of the simplest RNNs. Vanilla RNNs are even simpler, but these models suffer from the Vanishing Gradient problem.

GRU Model

The key idea of GRUs is that the gradient chains do not vanish due to the length of sequences and this is done by allowing the model to pass values completely through the cells. The model is defined as the following [1]:

I had a hard time understanding this model, but it turns out that it is not too hard to understand. In the definitions,  is used as the Hadamard product, which is just a fancier name for element-wise multiplication.  is the Sigmoid function which is defined as . Both the Sigmoid function () and the Hyperbolic Tangent function () are used to squish the values between  and .

 functions as filter for the previous state. If  is low (near ), then a lot of the previous state is reused! The input at the current state () does not influence the output a lot. If  is high, then the output at the current step is influenced a lot by the current input (), but it is not influenced a lot by the previous state ().

 functions as forget gate (or reset gate). It allows the cell to forget certain parts of the state.

The Task

In the code example, a simple task is used for testing the GRU. Given two numbers  and , their sum is computed: . The numbers are first converted to reversed bitstrings to make it easier for the model to learn the dependencies. This is also what most people would do by adding up two numbers. You start at the right from the number and if the sum is larger than , you carry (memorize) a certain number. The model is capable of learning what to carry. As an example, consider the number  and . In bitstrings (of length 3), we have  and . In reversed bitstring representation, we have that  and . The sum of these numbers is  in reversed bitstring representation. This is  in normal bitstring representation and this is equivalent to . These are all the steps which are also done by the code automatically.

The Code

The code, which is published on GitHub, is self-explaining. If you have any questions, feel free to ask! Sharing (or Starring) is Caring :-)!

Results

After ~2000 iterations, the model has fully learned how to add 2 integer numbers!

Conclusion (TL;DR)

The implementation of the GRU in TensorFlow takes only ~30 lines of code! There are some issues with respect to parallelization, but these issues can be resolved using the TensorFlow API efficiently. In this tutorial, the model is capable of learning how to add two integer numbers (of any length).

References

[1] Chung, J., Gulcehre, C., Cho, K., & Bengio, Y. (2014). Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555.

The original blog post can be found on Data Blogger where you can find more technical articles and tutorials on Data Science. ‹