Think Again Networks and the Delta Loss

TL;DR

This paper introduces Think Again Networks (ThinkNet), an abstraction applicable to state-dependent functions like recurrent neural networks, aiming to enhance their flexibility and performance.

Contribution

The paper proposes ThinkNet, a novel abstraction that can be integrated into various state-dependent models to improve their adaptability.

Findings

ThinkNet effectively models state-dependent functions.

Application of ThinkNet improves neural network performance.

The abstraction is versatile across different neural architectures.

Abstract

This short paper introduces an abstraction called Think Again Networks (ThinkNet) which can be applied to any state-dependent function (such as a recurrent neural network).

Equations

$$\text{TN}(F,x,s,t)=\{\begin{array}{ll}F(x,s)& \text{mbox}ift=1\\ F(x,M([\text{TN}(F,x,s,1);\dots ;\text{TN}(F,x,s,t-1)]))& \text{mbox}otherwise\end{array}$$

$$\Delta \mathcal{L}(\mathcal{L},\text{TN}(F,.,.,T))=$$

$$=$$

Full text

1 Think Again Networks

Given an arbitrary state-dependent function $F(x,s)$ where $x$ is the input and $s$ is the state, a ThinkNet TN is given by:

[TABLE]

where $s$ is an initial state, $t\geq 1$ is a ThinkNet timestep, $M([z_{1};...;z_{t-1}])$ is a arbitrary mixing function (could be a static function or a trainable neural network) which combines all previous outputs into a new state. Rather than optimize a loss $\mathcal{L}(F(.,.))$ directly, one optimizes $\mathcal{L}(TN(F,.,.,T))$ instead.

Essentially, the Think Again abstraction extends any state-dependent function $F(x,s)$ by adding an additional level of recurrence to it. The idea is to run $F(x,s)$ repeatedly $t$ times (each run corresponds to a ThinkNet timestep), and have a mixing function $M$ prepare the initial state of the next execution. In order to do so, $M$ can be defined as a function over all previous outputs produced by the network. The metaphor for the Think Again abstraction is a human problem-solver completing a task in many passes: it is often useful to think about the problem at hand an additional time after one has already processed it and updated his “mental state” ($s$) about it. Conceptually, any problem can be approached in this framework: humans can learn to reason about all their previous answers ($z_{1},z_{2},\dots,z_{t-1}$) when attacking a problem an additional time (to do that, we train our own “mixing function” $M$). This makes sense both from the perspective of human problem-solvers and deep learning models, which may benefit from knowing in advance an internal representation of the problem while the are processing it. In the context of sentence/sequence encoding, one may benefit from knowing in advance how a sentence/sequence ends while reading it.

Although related works in multi-step processing (similar to our ThinkNet timesteps) [1, 2, 3, 4, 5, 6] and attention/self-attention (similar to our mixing function) [7, 8] have strong similarities to our work, they lack the abstract simplicity and resulting generality (applicable to any state-dependent function) of ThinkNets and, most importantly, do not consider processing and thinking beyond the number of timesteps used in training.

In future work, we will investigate using state-independent functions $G(x)$ within ThinkNets. We hypothesize that it is possible to transform a state-independent function such as Convolutional Neural Networks (CNN) — commonly used in vision tasks — via the addition of a recurrent layer near the input of these networks, making the subsequent layers state-dependent. CNNs can be over a hundred layers deep [9] and ThinkNets could transform this deep processing into a shallower, iterative reasoning task.

2 The Delta Loss

Having defined a ThinkNet, one can simply evaluate its loss after $T$ timesteps. We propose an alternative, the Delta Loss ($\Delta\mathcal{L}$):

[TABLE]

The first term in Equation 2 is the sum of all differences between subsequent losses at timesteps $t$ and $t+1$. Descending the gradient of this term encourages the model to maximize the rate with which its loss decreases at each timestep. That is, instead of encouraging the model to produce a satisfactory loss after $T$ iterations, we are encouraging it to improve its solution at each timestep. Our hypothesis is that this should promote convergence: models trained with Delta Loss should be able to extend their computation to more timesteps and yield better and better results. In contrast, training models only with the final $\mathcal{L}(\textit{TN}(F,.,.,T))$ could allow for poor intermediate states, which in turn could lead to divergence if they are used beyond $T$ timesteps. An interesting property of the sum-of-differences in eq. 2 is that it is telescopic: all but the first and the last terms cancel out, resulting in $\mathcal{L}(TN(F,.,.,T))-\mathcal{L}(TN(F,.,.,1))$. This renders the overall equation much simpler, although no more efficient as one would still have to iterate over all losses to compute the max. loss term.

Naturally, the model is free to learn to manipulate its input in order to artificially produce a very high loss at some point, only to decrease it and collect a large delta. This is prevented by adding the maximum loss over all iterations as an additional term to eq. 2.

A trivial extension to the Delta Loss is to make the maximum loss term in eq. 2 periodic: $\underset{(t-1)\bmod p=0}{\textit{max}}\mathcal{L}(\textit{TN}(F,.,.,t))$, where $p$ is the period. This allows the state to diverge in between periodic checkpoints. At test time, the network would be evaluated using ThinkNet timesteps which are multiples of $p$. We leave the evaluation of this extension for future work.

3 Final Remarks and Future Directions

In this short paper we have introduced Think Again Networks. ThinkNets can be seen as an abstraction which extends any state-dependent function $F(x,s)$ by adding an additional level of recurrence to it. Inspired by the metaphor of a human problem-solver attacking a task on many “passes”, we introduce the idea of augmenting a model with a level of recurrence which forces it to re-process the same input multiple times. In the same way that humans can learn to reason about all their previous answers when attacking a problem an additional time, we propose training a “mixing function” to update the state of the model with all of its previous outputs to prepare it for an additional pass. We argue that this proposal makes sense from the perspective both of humans and deep learning models, which may benefit from knowing in advance an internal representation of the input before processing it.

We additionally propose the companion concept of the Delta Loss to encourage a ThinkNet model to learn to improve its loss at each timestep, which contrasts with the usual approach of training recurrent models to minimize a final loss. We hypothesize that training recurrent models with the Delta Loss could promote convergence, enabling them to extend their computation for more timesteps than they were trained on.

We wish to apply the framework to various recurrent architectures such as neural sentence encoders and graph neural networks. We also hypothesize that Think Again Networks can be applied to state-independent functions as well via a suitable transformation to state-dependent functions, for example via the addition of a recurrent layer to in feed-forward neural networks such as CNNs.

Acknowledgments

This research was partly supported by the Brazilian Research Council (CNPq) and Coordenação de Aperfeiçoamento de Pessoal de Nível Superior (CAPES) – Finance Code 001.