RNNbow: Visualizing Learning via Backpropagation Gradients in Recurrent Neural Networks

TL;DR

RNNbow is an interactive web tool that visualizes backpropagation gradients in RNNs, providing insights into learning dynamics, vanishing gradients, and training evolution during sequence processing.

Contribution

It introduces a novel visualization method for backpropagation gradients in RNNs, enhancing understanding of training processes and gradient flow.

Findings

Reveals vanishing gradient issues during training.

Shows how gradients evolve as RNN processes sequences.

Provides insights into RNN learning of code generation.

Abstract

We present RNNbow, an interactive tool for visualizing the gradient flow during backpropagation training in recurrent neural networks. RNNbow is a web application that displays the relative gradient contributions from Recurrent Neural Network (RNN) cells in a neighborhood of an element of a sequence. We describe the calculation of backpropagation through time (BPTT) that keeps track of itemized gradients, or gradient contributions from one element of a sequence to previous elements of a sequence. By visualizing the gradient, as opposed to activations, RNNbow offers insight into how the network is learning. We use it to explore the learning of an RNN that is trained to generate code in the C programming language. We show how it uncovers insights into the vanishing gradient as well as the evolution of training as the RNN works its way through a corpus.

Figures

Equations

$$h_i$$

$$y_i$$

$$L$$

$$\frac{\partial L}{\partial W}$$

$$\frac{\partial L_i}{\partial W}$$

$$=\frac{\partial L_i}{\partial y_i}\cdot \frac{\partial y_i}{\partial h_i}\cdot \frac{\partial h_i}{\partial W}$$

$$\frac{\partial h_i}{\partial W}$$

$$M_j$$

$$M_i$$

$$\frac{\partial L_i}{\partial W}$$

$$\frac{\partial L}{\partial W}$$

$$\frac{M_j}{M_{j+1}}=\frac{h_{j-1}}{h_j}W{\tanh }_j^{\prime }$$

$$S_k$$

$$\frac{\partial L}{\partial W}=$$

$$+\frac{\partial L_{n-1}}{\partial y_{n-1}}\cdot \frac{\partial y_{n-1}}{\partial h_{n-1}}\cdot \left[M_{n-1}+\cdots +M_1\right]$$

$$\cdots$$

$$+\frac{\partial L_1}{\partial y_1}\cdot \frac{\partial y_1}{\partial h_1}\cdot M_1$$

$$\frac{\partial L}{\partial W}=$$

$$+$$

$$\frac{\partial L}{\partial W}$$

$$N_j$$

$$N_i$$

Full text

\CCScatlist\CCScat

I.2.6Computing MethodologiesArtificial IntelligenceLearning; \CCScatG.1.6Mathematics of ComputingNumerical AnalysisOptimization; \CCScatH.1.2Information SystemsModels and PrinciplesUser/Machine Systems

Introduction

\copyrighttext

©2018 IEEE. Personal use of this material is permitted. Permission from IEEE must be obtained for all other uses, in any current or future media, including reprinting/republishing this material for advertising or promotional purposes, creating new collective works, for resale or redistribution to servers or lists, or reuse of any copyrighted component of this work in other works.

Artifical Neural Networks (ANNs) have made revolutionary improvements in classification in many domains, with particular attention given to their ability to classify images using convolutional filters[10]. A commonly-cited issue with all ANNs is that they act as a black box, with large numbers of hidden layers each individually learning their own weights resulting in a massive parameter space. Problems of interpretability are compounded by non-linear transformations which obfuscate interactions between each layer. Visualizations of activations within convolutional neural networks have seen some success in illuminating the inner workings of networks to both help understanding and to assist in hyperparameter settings[19]. However, such activation visualizations are specific to the domain of image processing, and primarily offer insight into how a network is functioning after training. In this work, we present RNNbow, a tool for providing insight into the training of Recurrent Neural Networks (RNNs). RNNbow visualizes values calculated during training in order to show the user if their network is learning long-term time dependencies over sequences, a necessary feature in most sequential models. It can be used to uncover problems with poorly parameterized networks early in training.

A key insight that differentiates this work from other visualizations for deep learning is that it visualizes the gradients, not the activations. Activations are the responses of the network during inference - when fed an input, what neurons are firing? While this is instructive in comprehending how the network makes decisions, it offers little insight into how the network learns. Learning in ANNs is typically accomplished via gradient descent, a method which minimizes loss over a training set by iteratively updating parameters in the direction dictated by the gradient of that loss. Thus, to analyze how the network is learning (or if it is learning at all), we must inspect the gradients.

RNNs are a particular class of ANNs that map input sequences to output sequences. As with all ANNs, their function depends on what they are fed in as inputs and what they are fed as desired outputs. They can learn to label each item in a sequence if their training data includes labels; a good example of this is training an RNN to do part-of-speech tagging. Alternatively, RNNs can be used to generate sequences that look like the training data. This is accomplished in a technique first proposed by Elman[3] in which, for a given training set $s_{1}\ldots s_{n}$ the input sequence is set to $s_{1}\ldots s_{n-1}$ and the output sequence is set to $s_{2}\ldots s_{n}$. In this way, the RNN learns to predict the succeeding element of a sequence. RNNs are behind some of Deep Learning’s most astonishing results, including language translation, generating image captions, and predicting medical outcomes.

RNNs have been called both “unreasonably effective”[7] and “difficult to train”[15]. One of the major issues with training RNNs is ensuring that the gradient descent updates propagate far enough back that long-term dependencies can be learned. Consider an RNN that tried to produce the following sentence.

In order for the RNN to be able to know the gender of the pronoun his, it must remember the gendered noun man 5 time steps earlier. Since RNNs learn via gradient descent, the only way to learn time dependencies of that distance is to have the gradient due to the loss incurred by an errant prediction propagate back to update the parameters that controlled how much the model learned at an earlier step. In other words, if the word his at $t=i+5$ is a function of the word man at $t=i$, then the gradient at $t=i$ with respect to the loss at $t=i+5$ must be greater than 0.

If an RNN is parameterized poorly, it may fall victim to the well-studied vanishing gradient problem[15], in which gradient only flows a few cells back, at which point the network may be no more capable than using frequency counts over the training set. To try to address this problem, the user must not only select numerical parameters like the size of the hidden layer or the number of layers, but also must choose between different architectures (stacks or grids) and different RNN cell types such as Long Short-Term Memory cells (LSTMs) or Gated Recurrent Units (GRUs). The theoretical distinctions involved in making these choices can be mystifying to many users of RNNs, and it can be confusing to try to diagnose learning issues resulting from poor RNN design. Tools are needed to reveal endemic issues in gradient flow in RNNs so that the user has early evidence of whether their network architecture is able to learn or not.

RNNbow is a tool to visualize the gradient flow during training of an RNN. It provides an overview of the magnitude of the gradient updates thorughout training, showing the user how quickly a model is learning, and how the regime of parameter updates changes over the course of training. It also allows users to drill down into a particular batch and view the individual influence of each of the RNN’s predictions on on parameter updates in the hidden layer. By breaking down the gradient update at each cell by each component’s origin, it makes the vanishing gradient apparent. It helps users assess their parameterization of their network during training. It also provides an illustration of the change in gradient behavior as a network trains. In the case of the earlier example, RNNbow can help the user detect if the loss incurred during the update of the word him is successfully propagated 5 steps back to the word man. At the time of writing, it is the only neural network visualization that visualizes gradient flow in RNNs that the authors are aware of.

Further, because RNNbow visualizes the gradient and not the input space, the use of the tool is agnostic to the domain of the problem. In contrast to many of the prevalent ANN visualizations that focus on convolutional neural networks that operate on images[12, 19], RNNbow could be used to visualize the gradient of any RNN. In this paper we use a character-level RNN as a demonstration, but RNNbow could be applied to show learning of other sequential data, including video frames and words.

For a use case, we repeat a well-known RNN experiment[8] to learn and generate statements in the C programming language via a character-level RNN. We present some insights that can be gleaned via RNNbow. We explain how traditional implementations of backpropagation can be modified to collect the itemized gradients visualized by RNNbow, and discuss complexity implications. We discuss the advantages of visualizing gradient over activation, discuss the role of visual analytics in deep learning, and conclude by considering future work in using RNNbow to compare different architectures.

1 Related Work

Prior to the recent explosion in big-data neural networks, artificial neural networks were generally small enough to allow for overview visualizations of all nodes and edges in their computation graph. Early work in visualizing neural network activity focused on “opening the black box” in this complicated computation graph. A good example can be found in Tzeng and Ma’s work to display three-layer networks as node-link diagrams, using the size and color of the nodes and edges to encode activation magnitude and uncertainty[17]. As the number of layers increases, such visualizations did not scale, and visualizations began to focus on either aggregate views of activations on particular inputs, or by viewing inputs that maximize activation of particular nodes[19]. Some visualizations of the popular Convolutional Neural Network take advantage of the visual form of the input space, integrating images into overviews of the node activations[12]. Some visualizations treat neural networks like other similar high-dimensional classifiers, visualizing 2-D projections of their classifications to provide insight into their decision boundaries[6].

Because of their sequential nature, RNNs proffer an opportunity for more concrete temporal visualizations. In an influential blog post and accompanying publication[8], Karpathy et al. used a variety of visualizations that overlayed some representation of node activation over subsets of the input space to show how different hidden nodes are responsible for different decision logic. There has also been work in interpreting the hidden state dynamics of a trained RNN [16, 13]. Their visualizations suggested that activations in the hidden layer contain information about the length of memory in a model.

Most of the tools listed are used after training to attempt to render interpretable the state of a trained network at test time. In contrast, RNNbow is used to visualize how the network has learned. Thus, it could be useful to view gradients during training, to know whether hyperparameters need to evolve or if the experiment needs to be rerun with a different set of hyperparameters. Mid-training visualization is one of the features of TensorBoard, a visualization tool built on top of Google’s TensorFlow[1]. TensorBoard allows users to write out values calculated during training to a log, and then generates basic visualizations, such as line graphs and bar charts, of those values throughout training. A typical use case is to plot the loss of a network as a function of the number of batches trained to confirm that the model is improving performance. While it would be possible to log gradients by patching the backpropagation calculation in a TensorFlow project, there is minimal support for visualizing those gradients beyond line graphs and bar charts at the time of writing. A recent work by Liu et. al. does visualize the training process for deep generative models [11] by plotting the data flow of activations through layers accompanied by basic measures of performance such as accuracy over time.

Our tool is unique in several ways. First, it visualizes gradient flow as opposed to activations. RNNbow is also used to assess the learning of a network during training, to determine if a change in hyperparameters is needed, as opposed to analyzing an ANN’s response during test time. Lastly, in contrast to the cited RNN visualizations, RNNbow is agnostic to type of input sequence (text characters, movie frames, medical records) since it does not use the input domain as a fundamental part of the visualization.

2 Recurrent Neural Networks

The goal of an RNN is to produce output given sequence input. Their advantage over other sequential learners such as Markov chains or Maximum Entropy Classifiers is that they are able to learn long-term dependencies via nonlinear dynamics in their hidden layer. The basic RNN architecture can be viewed as a graph with cycles, as seen in Figure 2. At any given point in inference, the input $x_{i}$ and the previous hidden state $h_{i-1}$ are used to calculate the new hidden state $h_{i}$, which is then used to calculate the emission $y_{i}$. Mathematically, this can be described as:

[TABLE]

Here, $W$, $U$, and $V$ are weight matrices, and $\sigma$ is the sigmoid function $\sigma(x)=\frac{1}{1-e^{-x}}$. Both $\tanh$ and $\sigma$ are common activation functions in the deep learning literature. Intuitively, the weight matrices perform a linear transformation on the data, and then the activation functions squash the values back to an interpretable, normalized range, with $\tanh$ bounded by $(-1,1)$, and $\sigma$ bounded by $(0,1)$. In addition, these activation functions add a nonlinearity into computation so that the RNN can fit more than polynomial functions.

During training, the training data set is partitioned into regular batches. An RNN trains on one batch at a time, in sequential order, by unrolling for a number of steps equal to the size of the batch. A batch size of 3 is seen in Figure 3; however, a typical batch size might range from a dozen elements to around a hundred. Within a batch, the RNN steps through input in order, taking in an input, calculating a hidden state, emitting an output, and then passing on the hidden state to be used for the next item in the sequence. The inputs are any data that can be sequenced (characters, words, frames, etc.), and the outputs can be classifications of or regression on those inputs, or distributions of potential classifications over the output range. The outputs are compared to the true labels, and a loss is calculated. The objective of training is to minimize the loss by choosing the optimal weight matrices $W$, $U$, and $V$. After total loss has been calculated for an entire batch, the gradient of the loss with respect to these weight matrices is calculated and they are then updated via gradient descent. These gradients are typically calculated using backpropagation, an efficient algorithm for calculating gradients in computational graphs. The newly updated weight matrices are used for the next batch. The batch size, the size of the hidden layer, and certain constants used in the updating of the weight matrices are all hyperparameters set by the user.

For example, in our use case described in section 4, we build an RNN to generate code for the C programming language. Before training, $W$, $U$, and $V$ are initialized randomly. If we used our RNN with these randomly-initialized weight matrices to generate text, it would be the same as sampling from a uniform distribution over all characters, and thus it would not look like code. By feeding our RNN input data that looks like valid code, we gradually update our weight matrices so that our RNN generates sequences that better match not only the distribution of characters in the training set but the transitions between characters as well. Examples of code generated by this RNN before and after training can be seen in Figure 4. For more examples of character level RNNs, including much more in-depth analysis of the generation of $C$ code, see [8].

Our full training dataset is the Linux kernel, which we split into batches of 25 characters. This also corresponds to unrolling our RNN 25 steps. Referring to the equations defined in (1) and (2), the character input $x_{i}$ could be encoded densely using a mapping such as ASCII, or it could use one-hot encoding. We use a hidden layer of 100 nodes, meaning that the weight matrix $U$ transforms our input $x_{i}$ into a 100-dimensional vector representation of the original input character. The hidden state vector is also 100 dimensions. $Wh_{i-1}$ and $Ux_{i}$ are added together and then squashed through the $\tanh$ activation function. That result is then multiplied by the weight matrix $V$, which projects back into the character-space encoding, providing a multinomial distribution over all possible characters.

To train on a given batch, the RNN starts with the first character as input, calculates a hidden state, and outputs a multinomial distribution for what it thinks the next character could be. In RNNbow, we show the most-likely character from that multinomial distribution, $\max(y_{i})$, as shown in area 2 of Figure 5. The true label for the first character in the batch is the second character in the batch, since in this experiment, we want the RNN to predict succeeding characters based on the current character and its context. We use a softmax loss, which generates high loss if our RNN suggests there is a low probability of the true label and a high probability of other labels. That loss is then used to calculate the gradient update for the weight matrices. In RNNbow, we only visualize the gradients of $W$, since $W$ is what controls the memory of the RNN.

3 RNNbow

RNNbow is a web application that visualizes the gradients used to update parameters during training of a recurrent neural network. In this section, we describe the interface, then we review how the gradient data is harvested during training via backpropagation through time (BPTT)[4].

3.1 Interface

The user interface of RNNbow is a coordinated multiple view implemented in d3.js that provides both an overview of the data as well as details of particular elements of the training set. The interface can be seen in Figure 5. It takes in data on gradients recorded during a pass over a training set. The specific data-visual mappings and how such data is generated during training of an RNN model are both described in section 3.2. RNNbow provides both an overview of gradients across all batches and the ability to drill down and visualize the gradients from a single batch at a time, so that the gradients at individual locations in the training set can be seen clearly. Descriptions of the interface below will make repeated use of the numeric labels from Figure 5.

3.1.1 Area 1: Overview of Max Gradient of All Batches

Area 1 of the interface is a bar chart overview of the maximum gradient within each batch. Our data comprised of 300 batches of gradient data during training. Each bar in area 1 represents the maximum gradient across all time steps within that batch. Because RNNbow visualizes the maximum gradient in each batch as the height of a bar in a bar chart, the user is able to easily to navigate to parts of their training set where the most learning is happening. While visualizing the mean would also be valid in that it would show which batches were the most informative, visualizing the max instead shows which individual elements of the training set are the most informative.

The user is able to drill down into a particular batch by hovering over a particular bar, resulting in information about that batch being visualized in areas 2, 3, and 4. To fix that batch as the selected batch, the user may click on a bar. The currently selected batch is signified as a pink bar in area 4. Some basic information about the batch being visualized is displayed in text above area 1, including the batch number, which training cells it corresponded to, and the maximum gradient in that batch.

3.1.2 Area 2: Prediction and True Labels of a Single Batch

Area 2 provides details on demand for the batch selected in are 1. In the top row of characters in area 2, we can see the ground truth labels from the training set per element in the batch. Immediately underneath those labels, we see our RNN’s prediction for the label of that element. These predictions are colored according to whether they are correct (green) or incorrect (red). In this figure, the training set batch begins with the five characters “args; ”, and our RNN predicts the five characters “etn  ”. Showing the true and predicted labels helps ground the user in their data.

3.1.3 Area 3: Per Batch Gradients

Underneath each label, in area 3, gradients at each time step of the selected batch of training data are visualized as a stacked bar chart. The height of each bar represents the magnitude of the gradient used to update the weights of the RNN at that step in time, relative to the gradients within that specific batch. The bars are partitioned according to how far in the future that portion of the gradient resulted from. The lowest, darkest portion of the bar is the gradient due to the loss of the current point in time (due to the loss of the label immediately above the bar). Stepping up in the stacked bar, each new partition is gradient due to the loss accrued due to the succeeding label. In RNNbow, each vertical bar can show the gradient contribution from up to 5 time steps in the future. The number of steps was chosen empirically based on this use case; for other datasets, a larger horizon may be necessary. For more discussion, see section 3.2.2.

3.1.4 Area 4: Gradients Due to Individual Prediction

While seeing the breakdown of the sum of the gradient at each step may be informative, it is also interesting to see how gradient flows backwards from a particular time step - this would show how the network was learning long-term dependencies. By hovering over any portion of a bar in area 3, we highlight all portions in neighboring bars due to the same loss. In addition, the particular prediction and label that are responsible for that loss are highlighted with a darker gray background, as seen in the gray box behind the two “t” characters in Figure 5. For the sake of analysis, these portions are projected down into area 4 to highlight the rate at which the gradient decays.

As an example, in Figure 5, the cursor is hovering over the bottom component of the gradient bar below the true label ‘t‘. In area 4, we can see that the gradient due to this decision propagated back 5 time steps, albeit diminishing in magnitude. Each blue bar represents the amount the parameters are being updated at that point in time due to the prediction made at ‘t‘. The magnitude of these bars is a proxy for how large the influence is of a previously predicted character, such as the white space character instead of an ‘s‘ at the beginning of ‘struct‘, had on the prediction of the character ‘t‘ at the end of ‘struct‘. The faster this gradient decays, the shorter the time dependency is that the model is learning. We call this projected bar chart the gradient horizon, as it aims to show when the gradient contribution vanishes as it passes back. As the user sweeps the mouse up and down and across bars, area 4 changes which gradient horizon it displays, allowing the user to quickly navigate the decomposition of gradients.

3.2 Generating Gradient Data

Given a loss function, backpropagation passes that loss back to any parameters involved in the loss’s calculation, via the chain rule. In a Convolutional Neural Network, where one prediction is made, there is generally a single loss calculation, which is then passed along via gradients. In an RNN, there are multiple losses; loss is calculated at each output $y_{i}$. Calculating the gradient of $W$ is a difficult task since each hidden state and each output are compounded functions of $W$.

To account for the multiple losses, RNNs use a special form of an algorithm called backpropagation through time (BPTT)[4]. To use BPTT, RNNs are unrolled - that is, each cycle in the computation graph is represented as an additional copy of the RNN, to create a directed acyclic computation graph that backpropagation can then be used on, as seen in Figure 3.

Backpropagation is designed to be as computationally fast as possible, making extensive use of dynamic programming to memoize intermediate calculations so that the gradient can be calculated in a single pass backwards through time. However, fully utilizing dynamic programming will cause us to lose track of some of the intra-sequence effects that RNNbow aims to illuminate. Thus, we remove one level of dynamic programming, trading off increased computational complexity for the ability to record itemized gradients. To motivate this, in the following section we fully derive an expression for the gradient, pointing out what the mapping is between RNNbow and the terms in that expression. We also show how our implementation is equivalent to backpropagation.

3.2.1 Derivation of Itemized Gradients

We are concerned with $\frac{\partial L}{\partial W}$, the rate at which the loss ($L$) changes with respect to the weights of the hidden layer ($W$). In training, we use that quantity to update $W$ via gradient descent. Because we are interested in the gradient contributions from each time step, we decompose the loss into loss contributed from the prediction made at each time step. Here, $L_{t}$ is defined as the loss due to predicting $y_{t}$, and $n$ is the size of the batch.

[TABLE]

For a given time step $t=i$, we have the following decomposition, via the chain rule.

[TABLE]

We can further decompose the rightmost term, $\frac{\partial h_{i}}{\partial W}$, but we must be careful: $h_{i}$ is a function of $W$, but it is also a function of $h_{i-1}$ which is in turn a function of $W$, so we must use the product rule.

[TABLE]

The leftmost term is the derivative of $\tanh(x)$, evaluated at $Ux_{i}+Wh_{i-1}$. Notice that we still must further expand the rightmost term, just like we had to with $\frac{\partial h_{i}}{\partial W}$. In the following derivations, the term $\tanh^{\prime}(Ux_{i}+Wh_{i-1})$ is truncated to $\tanh^{\prime}_{i}$ for the sake of readability.

[TABLE]

We would then have to expand $\frac{\partial h_{i-2}}{\partial W}$, and $\frac{\partial h_{i-3}}{\partial W}$, and on until we end up with the term $\frac{\partial h_{1}}{\partial W}$ which does not expand since $h_{0}$, our initialized hidden state, does not depend on $W$ - it is a hyperparameter set by the user. In this way, the loss due to our prediction at $t=i$ ends up propagating all the way back through the input sequence to $t=1$.

[TABLE]

If we were to expand out all of the products in (8), we would end up with summands that were only dependent on values available in ordered subsets of the sequence.

[TABLE]

Note that calculating the first summand only requires knowing $h_{i-1}$ and the additional arguments to $\tanh^{\prime}_{i}$, $U$, $W$, and $x_{i}$. Then, we can memoize the value of $\tanh^{\prime}_{i}$, and when calculating the next summand, we only need that memoized value and $U$, $W$, $h_{i-2}$, and $x_{i-1}$. Let $M_{j}$ be the $i-j$th summand of (9), so $M_{i}=\tanh^{\prime}_{i}h_{i-1}$, $M_{i-1}=\tanh^{\prime}_{i}W\tanh^{\prime}_{i-1}h_{i-2}$. Note that calculating $M_{j}$ depends only on the values $U$, $W$, $x_{j}$, $h_{j-1}$, $h_{j}$, and $M_{j+1}$.

[TABLE]

Then we can rewrite (5) in a way that clarifies our implementation of its calculation.

[TABLE]

In order to calculate the gradient for the entire batch, we would need to sum this over each time step, so we substitute (13) into (4).

[TABLE]

In order to use RNNbow, we record the summand of (14) for each value of $(t,j)$. We call these summands the itemized gradients, as they are itemized by the time step that was the source of their loss.

To calculate this in $O(n^{2}),\{M_{j}\}$ can be implemented as a one-dimensional dynamic programming table that is filled in from right to left. Then each can be calculated in a single backward pass of the batch, from $j=t$ down to $j=1$. As an example, suppose that we were training a character-level RNN, and had a batch to train on that was the six characters g u i t a r, but our RNN instead predicted the six characters b a n a n a. To calculate our gradient, we start at the last character, $t=6$, and see that we predicted a instead of r, and so we incorporate some loss. We record the gradient due to that prediction at $t=6$, and then pass back that loss via $M_{6}$ to $t=5,\cdots,t=1$. Once we have calculated all itemized gradients due to predicting a instead of r at $t=6$, we jump to $t=5$, calculate the loss due to predicting n instead of a, and pass a different set of $M_{j}$ back. This is based on an implementation of BPTT from [2].

The full area of the batch view seen in area 3 of Figure 5 represents the full value of $\frac{\partial L}{\partial W}$. The full area of the detailed gradient horizon seen in area 4 of Figure 5 represents the full value of $\frac{\partial L_{i}}{\partial W}$ described in (13), and each bar within area 3 corresponds to an individual summand. A vanishing gradient would correspond to the summands decreasing as $j$ decreases, which can be seen in Figure 8.

Traditional backpropagation only takes $O(n)$, but it doesn’t expose the itemized gradients that we need to record for RNNbow. A further exploration of the relationship between our calculation and traditional backpropagation is given in the appendix.

3.2.2 Computational Concerns vs. Estimation

In practice, it may be impractical and unadvised to calculate the itemized gradients throughout all of training. To begin with, this algorithm generates an immense amount of data, storing $O(HNn)$ gradients in a single pass over the training set, where $H$ is the number of nodes in the hidden layer, $N$ is the size of the training set, and $n$ is the batch size. In our use case, we used small batches and a small hidden layer ($n=25,H=100$) compared to many networks, and if we had used the entire training set, even using these small settings for $n$ and $H$ we would have created data that was 2500 times the size of our training data.

The problem of data size can be ameliorated by only calculating the itemized gradients periodically - in our use case, we only store the gradients every 100 batches, reverting to the optimized version of backpropagation for the other 99% of batches. Lastly, gradients are averaged between all nodes in the hidden layer, as our goal is to see the general rate of training, rather than drilling down into individual hidden nodes. Since this data is used for visualizations, visualizing data from all nodes would lead to occlusion problems, and the general trends of gradient can be viewed in the average.

It may also not be necessary to step all the way back through the batch when calculating itemized gradients. Equation (10) shows that the gradient due to a particular time step’s loss is decomposable into a sum of sequence. We can use (11) to analyze the rate of decay of that sequence.

[TABLE]

$W$ is generally initialized close to 0, and regularization is used to keep it having small magnitude during gradient descent. $\tanh^{\prime}$ has a range of $(0,1]$, and $\frac{h_{j-1}}{h_{j}}$ should generally be close to one. Thus, the sequence $\{M_{j}\}$ should decay as $j$ decrements. Then it would stand to reason that we might be able to choose a value $k$ such that we only have to step back $k$ steps to be close enough to the real gradient.

[TABLE]

In our use case, we empirically chose $k=5$ based on manual inspection of the data. However, it is highly likely that acceptable $k$ should vary with RNN architecture and cell choice. It might be possible to find a $k$ such that $||S_{k}-\frac{\partial h_{i}}{\partial W}||<\epsilon$ globally across a validation set. Since $k$ is loosely a measure of how far the gradient horizon is, it would stand to reason that a more sophisticated architecture would demand a larger $k$.

4 Use Case

To demonstrate the use of RNNbow, we trained a character-level RNN on the Linux Kernel to try to get it to generate code that looks like the $C$ programming language, replicating an experiment done in Karpathy et al.’s seminal RNN work[8]. We used batches of 25 characters, and recorded gradients every 100 batches over the first 50000 batches of the training data. We use a hidden layer of 100 nodes, but we average the gradients across all nodes. In this section, we outline several insights that can be found via RNNbow.

4.1 Overview of Gradients Over Time

Figure 5 shows the result of training an RNN using our approach. Looking at the overview section, seen as area 1 in Figure 5, the first insight is that the magnitude of the gradient starts very small, and then appears to plateau, albeit with a fair amount of variance. This suggests that early in training, the weights update slowly - there may be some burn-in required before the parameters are updating efficiently. The overview also points the user to batches with maximal gradient. It makes it easy for the user to view the elements of the training set that the RNN learns the most from.

It can also be instructive to compare the batch visualizations (area 2 in Figure 5) as they change from early in training to late in training. Figure 6 shows the gradients of a batch early in training, and Figure 7 shows the gradients of a batch late in training. At a glance, the darker the batch visualization is, the shorter the gradient horizon is; a larger portion of the update at each step comes from local losses. In Figure 6, most of the bars in the visualized batch are primarily composed of dark green bars. Compare that pattern to a batch later in training in Figure 7, where the gradient is much lighter; this corresponds to longer gradient horizons for training in this batch. Exploring the training patterns over training reveals that this particular RNN seemed to lengthen its time dependencies as training went on.

4.2 Vanishing Gradient

A well-known consequence of the activation functions used in RNNs, $\tanh$ and $\sigma$, is that they result in a gradient that decreases as it is passed back in time. For large swaths of the hyperparameter space, the gradient may decay incredibly fast, restricting any long-term dependency learning[15, 4].

The primary function of the projection of gradients in the visualization, area 4 in Figure 5, is to illustrate the rate at which the gradient decays. By mousing over a gradient bar, the user can see the rate at which that particular gradient due to a particular character’s loss vanishes. This can be seen in Figure 8.

4.3 Batches With Maximal Gradient

The overview bar chart in area 1 of the interface shown in Figure 5 can be used to cue the user towards parts of the training set that the RNN learns the most from. For an example, we clicked on the rightmost bar of area 1 to change the focus of RNNbow to that batch, since that bar had the greatest height and thus the greatest maximal gradient. The stacked bar chart of the maximal gradient in that batch can be seen in Figure 9. The maximal gradient is due to predicting the character a instead of predicting the character (, in spite of the context of being in a for loop. Note that it also assumes some gradient from incorrectly predicting the subsequent characters as well. This suggests that our RNN has not learned the iterator grammar of the C programming language. It also confirms that our RNN is learning from actual mistakes and not overfitting the training set. As this maximal gradient comes late in our training set and is on a legitimate mistake, it cues the user that we have not trained enough and training must continue.

5 Discussion

5.1 Limitations

RNNbow is not intended to be a tool for power users of RNNs; such users would be better served with custom visualizations and custom analytics within their deep learning pipelines. RNNbow is most useful to the non-expert. The current implementation does have some scaling issues, both in the interface as well as in the implementation of backpropagation through time, described in section 3.2. However, it is more likely that a non-expert would use smaller networks that are executable on a personal computer; that is the scale we aim to currently support.

The design does have some visual layout issues with scale as well. This interface doesn’t support more than a few hundred batches, although this should be solvable with some aggregation and drilldown. In practice, RNNs may train over hundreds of thousands of batches. A heuristic could be used to point the user to particularly interesting batches within the training data. Similarly, the stacked bar chart might not scale to batch sizes of 50 or more. In the use case given in this work, with a batch size of 25 and $k=5$, the stacked bar chart was responsible for visualizing 125 pieces of data. A sophisticated RNN might have a batch size of 128 and would hopefully have a much larger memory; more iterations of design are needed to come up with an appropriate visualization of so many gradients. In addition, some form of aggregation would need to be defined for the predicted labels (in this case, characters) in large batch sizes. Perhaps the largest hurdle to supporting industry scale networks is the number of layers visualized. RNNbow currently supports a single layer; there are popular CNNs with more than a hundred layers, and RNNs are following suit[14]. It’s unclear how the stacked bar chart would scale to even a dozen layers. It may be that a higher resolution visualization of gradients between layers is needed.

Prior to the design of the visualization, basic experiments were run to estimate the gradient horizon throughout the first 50000 batches of training, and it was found that it varied from 2 to 5 characters before the gradient dropped below a certain $\epsilon>0$. Production-level RNNs, with sophisticated architectures, may need gradient horizons of tens or even hundreds of time steps. The current algorithm used may not be scalable to record the gradient that many steps back. This could be addressed by taking the gradients much less frequently than every 100 batches.

5.2 Visualizing Gradients

One of the key insights of RNNbow is that it visualizes the gradient, as opposed to the activation. Gradients are increasingly being accepted as a more salient representation of the learning surfaces and thus a more informative value to study than activation and loss[9]. Considering that the gradient is what dictates updates to the model, i.e. what is learned, its visualization is revealing of the training process. It is particularly salient in a visualization of RNNs, as the many-to-many relationship between losses and time steps can be difficult to intuit about. It proved useful in discovering endemic properties like vanishing gradients; there may be other endemic qualities in network training that cannot be noticed in visualizations of activations.

In this work, we focused on the gradient $\frac{\partial L_{i}}{\partial W}$, in part because this is a value that is already traditionally calculated during backpropagation, as it represents the quantity by which we update the tunable parameter $W$ in the RNN. This in turn led to calculating intermediate gradients including $\frac{\partial L_{i}}{\partial y_{i}}$ and $\frac{\partial h_{i}}{\partial W}$. There are other gradients, however, that could have been calculated during training. In particular, $\frac{\partial h_{i}}{\partial h_{j}}$ could have revealed interesting interplay between nodes within the hidden layer and how they kept track of memory. As we seek to crack open the black box of neural networks, it is important to remember that each gradient is a different tangent surface to the manifold on which the full parameter space of the network lies. In this work, we analyze a very specific tangent surface with the goal of understanding time dependencies. In work on visualizing CNNs, it is very common to consider gradients of the activations as they correspond to particular outcomes with a goal of determining what parts of the image are most sensitive to a network’s understanding of a label. In order to better understand the cross effects between parameters in a deep network, it may be necessary to explore several of these gradient surfaces, coupled with a visual analytics system that guides the user towards logical conclusions, as RNNbow does for the vanishing gradient. Each gradient surface may change drastically over different architectures and settings of hyperparameters. Comparing gradient surfaces generated by different networks may offer more insight into the sensitivity of network behavior to each hyperparameter.

5.3 Role of Visual Analytics in Deep Learning

It is not unreasonable to ask: is there even a role for Visual Analytics in Deep Learning? While it is clear that visualization has a role in helping a user build models that they trust, there are extenuating circumstances that make it hard to apply the same considerations to deep learning. A typical Support Vector Machine or Decision Tree has only a handful of hyperparemeters that need to be set by the user, and it learns only a dozen or so parameters during training. In contrast, the famous AlexNet CNN from 2012[10], a relative dinosaur in deep learning years, fits 60 million parameters. Users must choose architectures, cell types, learning rate, filter size, and a number of other hyperparameters. While this may sound like it offers a good opportunity for building an analytics system that abstracts away these decisions, in practice, it is impractical to infer these values. Generally, visual analytics systems that collaboratively build a model with a user do so by engendering an abstraction, or mental model, of the underlying parameters, and then enable the user to manipulate those parameters with intuitive interactions. In many cases, industry-size neural networks simply have too many underlying parameters, and these parameters tend to interact with one another in unintuitive ways. Once a user has trained enough to understand how those parameters work together, they likely have gained the ability to program their own scripts using one of the many fully-featured deep learning frameworks, at which point they may find a visual analytics sytem superfluous.

Perhaps because most builders of deep learning models were already able to write their own scripts, the most succesful visualizations related to deep learning were not incorporated into visual analytics systems, but were rather used to try to explain the inner workings of a deep learning model post-hoc, after it had been built, in order to gain insight into some of the structures that empirically were working. This led to static visualizations of cleverly calculated values, including gradients, typically overlaid on the input domain to ground the network in the data on which it had been trained. In their popularity, these visualizations suggested that it could be possible to apply some interactivity into model building if the right data was visualized.

The current usage of deep learning in the wild This landscape leads to very different recommendations for designing tools depending on the audience of the tool. Our tool is primarily targeted at nonexperts tuning simple one-layer RNNs, possibly in an educational setting. For that reason, we favored simple, low-dimensional visualizations, and used calculated values with a clear, unambiguous meaning. For an expert, the design decisions are drastically different. The designer can make an assumption that the user will be directly interacting with their model through a deep learning scripting framework and that this framework gives them the ability to calculate their own values of interest. Then these works can focus more on an overview of many different aspects of the network, almost like a monitoring system. Good examples of support for industry-scale model builders can be found in recent works by Google[18] and Facebook[6]. For a more thorough treatment of the state of visual analytics in deep learning, we direct the reader to a recent survey[5].

6 Future Work

The design space of RNNs is rich and constantly evolving, and much of the progress has the goal of having a longer gradient horizon. As visualizing this gradient horizon is the key feature of RNNbow, it should prove invaluable in comparing different approaches. One direction of RNN research focuses on making more sophisticated cells in which the calculation of the hidden state and outputs differs from the vanilla RNN equations, seen in (1) and (2). We would like to adapt RNNbow to visualize the gradient flow of these alternative cells. It should be illustrative in comparing a vanilla RNN to a Long Short Term Memory (LSTM). LSTMs have two hidden layers, one of which is supposed to hold short term memory, and one of which holds long term memory. It would be interesting to see if this is supported in visualizations of the gradients of each hidden layer. Another type of cell called a Gated Recurrent Unit (GRU) only has one hidden layer, but in practice accomplishes long-term dependencies similarly to LSTMs. It isn’t particularly clear why this should be. In both LSTMs and GRUs, the calculations of emissions require additional computation with each type of cell having several gates that supposedly lengthen the memory. Perhaps RNNbow would be able to be extended to reveal the gradient flow within a cell, not just between cells.

Beyond different cell types, different arrangements of cells have also proved helpful in practical RNNs. One type of cell architecture is a bidirectional RNN, in which two recurrent neural networks are run in parallel for each batch, with one running through the input sequence from left to right and the other in reverse. Their outputs are then combined through a learned linear combination. The bidirectional RNN allows learning former and future context, and viewing the gradient flow in both directions may aid in the understanding of its training. More advanced architectures results from adding layers of RNNs, either to match to multidimensional sequences, or to use multiple layers to capture different levels of abstraction in the input sequence as is typical in CNNs. These architectures are difficult to conceptualize; visualizing the gradient may help. However, their spatial complexity proves a challenge in the current layout of RNNbow; some cleverness will be necessary to determine a layout for such architectures.

In this work, we didn’t consider the separate nodes in the hidden layer - we just averaged the gradients together. This is in contrast to many of the works on interpreting ANNs, in particular because the activation of a single node tends to be a binary decision maker. Previous work suggests that individual nodes have unique responsibilities; in the same experiment as used in this work, Karpathy et al.[8] found that a single node was responsible for remembering the state of generated $C$ code as being in a parenthesis or out of a parenthesis. However, there is no scalable way to visualize all hidden nodes in RNNbow; some heuristic will need to be developed to cue the user to interesting nodes, and some overview of node performance other than the mean will need to be added.

7 Conclusion

We present RNNbow, a web-based visualization tool for analyzing gradient flow during training of a Recurrent Neural Network. We demonstrate how it can be used to find endemic properties in a network, and how it can provide insights into the learning process. We also show that it can be a useful educational tool for illuminating the vanishing gradient phenomenon. We review how to calculate the itemized gradients necessary for loading data into RNNbow. We discuss potential uses of the tool, especially the applications to other RNN architectures.

Acknowledgements.

This material is partially based on research sponsored by the Air Force Research Laboratory and DARPA under agreement number FA8750-17-2-0107. This work is also supported in part by the National Science Foundation: IIS-1452977 (CAREER).

Appendix A Itemized Gradients vs. Backpropagation

The calculation of (14) takes $O(n^{2})$, where $n$ is the size of the batch. It is possible to utilize dynamic programming further to speed it up to $O(n)$; this is used in most implementations of backpropagation. First, we expand both sums in (14).

[TABLE]

Next, we distribute, group the terms by $M_{j}$, and factor.

[TABLE]

Let $N_{j}=\left(\frac{\partial L_{n}}{\partial y_{n}}\cdot\frac{\partial y_{n}}{\partial h_{n}}+\ldots+\frac{\partial L_{j}}{\partial y_{j}}\cdot\frac{\partial y_{j}}{\partial h_{j}}\right)$. Then $\{N_{j}\}$ can be implemented with a dynamic programming table as with $\{M_{j}\}$, and we can calculate the gradient in a single pass.

[TABLE]

In optimized versions of backpropagation through an RNN, we only make a single pass backwards through time, passing back our accumulation of the gradients $N_{j}$, and adding on the gradient of the current time step. For RNNbow, we can’t use this method, however, because we lose track of the terms in the expanded product of (A) when we make use of the dynamic programming table for $\{N_{j}\}$. Thus, we need to use the $O(n^{2})$ version described by (14), saving each summand as we accumulate the sum. It is possible that, depending on the implementation library, keeping track of the intermediate $M_{j}$ and $N_{j}$, and then utilizing vector math, as is commonly used in the python library Numpy, could allow us to use traditional backpropagation.