Difference between revisions of "neural Turing Machines"
m (→Neural Turing Machines: Cleaned up referencing and some wording) 
m (Conversion script moved page Neural Turing Machines to neural Turing Machines: Converting page titles to lowercase) 
(No difference)

Latest revision as of 09:46, 30 August 2017
Contents
Neural Turing Machines
Even though recurrent neural networks (RNNs) are Turing complete in theory, the control of logical flow and usage of external memory have been largely ignored in the machine learning literature. This might be due to the fact that the RNNs have to be wired properly to achieve the Turing completeness and this is not necessarily easy to achieve in practice. By adding an addressable memory, Graves et al. try to overcome this limitation and name their approach Neural Turing Machine (NTM) as analogy to Turing machines that are finitestate machines extended with an infinite memory<ref name="main">Graves, A., Wayne, G., & Danihelka, I. (2014). Neural Turing Machines. arXiv preprint arXiv:1410.5401.</ref>. Furthermore, every component of an NTM is differentiable, implying each component can be learned.
Theoretical Background
The authors state that the design of the NTM is inspired by past research spanning the disciplines of neuroscience, psychology, cognitive science and linguistics, and that the NTM can be thought of as a working memory system of the sort described in various accounts of cognitive architecture. However, the authors propose to ignore the known capacity limitations of working memory, and to introduce sophisticated gating and memory addressing operations that are typically absent in models of the sort developed throughout the computational neuroscience literature.
With respect to historical precedents in cognitive science and linguistics literature, the authors relate their work to a longstanding debate concerning the effectiveness of neural networks for cognitive modeling. They present their work as advancing a line of research on encoding recursivelystructured representations in neural networks that stemmed out of criticisms presented by Fodor and Pylyshyn in 1988 <ref name=fodor>Fodor, J. A., & Pylyshyn, Z. W. (1988). Connectionism and cognitive architecture: A critical analysis. Cognition, 28(1), 371.</ref> (though it is worth pointing out the authors give an incorrect summary of these criticisms  they state that Fodor and Pylyshyn argued that neural networks could not implement variable binding or perform tasks involving variable length structures, when in fact they argued that successful models of cognition require representations with constituent structure and processing mechanisms that strictly structure sensitive  see <ref name=fodor></ref> for details). The NTM is able to deal variable length inputs and arguably performs variable binding in the sense that the memory slots in the NTM can be treated as variables to which data is bound, but the authors do not revisit these issues in any detail after presenting the results of their simulations with the NTM.
Architecture
A Neural Turing Machine consists of a memory and a controller neural network. The controller receives input and produces output with help of the memory that is addressed with a content and location based addressing mechanism. Figure 1 presents a highlevel diagram of the NTM architecture.
Memory
The memory at time [math]t[/math] is given by an [math]N \times M[/math] matrix [math]M_t[/math], where [math]N[/math] is the number of memory locations and [math]M[/math] the vector size at each memory location. To address memory locations for reading or writing an [math]N[/math]element vector [math]w_t[/math] is used. The elements in this vector need to satisfy [math]0 \leq w_t(i) \leq 1[/math] and have to sum to 1. Thus, it gives weighting of memory locations and the access to a location might be blurry.
Reading
Given an address [math]w_t[/math] the read vector is just the weighted sum of memory locations:
[math]r_t \leftarrow \sum_i w_t(i) M_t(i)[/math]
which is clearly differentiable with respect to both the memory and the weighting.
Writing
The write process is split up into an erase and an add operation (inspired by the input and forget gates in LSTM). This allows the NTM to both overwrite or add to a memory location in a single time step. Otherwise it would be necessary to do a read for one of the operations first before the updated result can be written.
The erase update is given by
[math]\tilde{M}_t(i) \leftarrow M_{t1}(i) [1  w_t(i) e_t][/math]
with an [math]M[/math]element erase vector [math]e_t[/math] with elements in the range [math](0, 1)[/math] selecting which vector elements to reset at the memory locations selected by [math]w_t[/math].
Afterwords an add vector [math]a_t[/math] is added according to
[math]M_t(i) \leftarrow \tilde{M}_t(i) + w_t(i) a_t.[/math]
The order in which the adds are performed by multiple heads is irrelevant. The combined erase and add operations of all the write heads produced the final content of the memory at time t.
Addressing Mechanisms
Two methods, contentbased addressing and locationbased addressing, are employed to generate the read/write weightings [math]w_t[/math]. Depending on the task either mechanism can be more appropriate. These two methods of addressing are summarized in the figure below.
Contentbased addressing
For contentaddressing, each head (whether employed for reading or writing) first produces a length [math]M[/math] key vector [math]k_t[/math] that is compared to each vector [math]M_t (i)[/math] by a similarity measure [math]K[.,.][/math]. The contentbased system produces a normalised weighting [math]w_c^t[/math] based on the similarity and a positive key strength, [math]\beta_t[/math], which can amplify or attenuate the precision of the focus:
[math]
w_c^t \leftarrow \frac{exp(\beta_t K[K_t,M_t(i)])}{\sum_{j} exp(\beta_t K[K_t,M_t(j)])}
[/math]
In this current implementation, the similarity measure is cosine similarity:
[math] K[u,v] = \frac{u.v}{u.v} [/math]
Locationbased addressing
The locationbased addressing mechanism is designed to facilitate both simple iterations across the locations of the memory and randomaccess jumps. It does so by implementing a rotational shift of a weighting. Prior to rotation, each head emits a scalar interpolation gate [math]g_t[/math] in the range (0, 1). The value of [math]g[/math] is used to blend between the weighting [math]w_{t1}[/math] produced by the head at the previous timestep and the weighting [math]w_t^c[/math] produced by the content system at the current timestep, yielding the gated weighting [math]w_t^g[/math] :
[math] w_t^g \leftarrow g_t w_t^c + (1g_t) w_{t1} [/math]
After interpolation, each head emits a shift weighting [math]s_t[/math] that defines a normalised distribution over the allowed integer shifts. Each element in this vector gives the degree by which different integer shifts are performed. For example, if shifts of 1, 0, 1 are allowed a (0, 0.3, 0.7) shift vector would denote a shift of 1 with strength 0.7 and a shift of 0 (noshift) with strength 0.3. The actual shift is performed with a circular convolution
[math]\tilde{w}_t(i) \leftarrow \sum_{j=0}^{N1} w_t^g(j) s_t(i  j)[/math]
where all index arithmetic is modulo N. This circular convolution can lead to blurring of the weights and [math]_t[/math] will be sharpened with
[math]w_t(i) \leftarrow \frac{\tilde{w}_t(i)^{\gamma_t}}{\sum_j \tilde{w}_t(j)^{\gamma_t}}[/math]
where [math]_t 1[/math] is an additional scalar outputted by the write head.
Controller
The controller receives the external input and read head output and produces the addressing vectors and related values (for example shift weighting) for the read and write heads. It also produces an external output.
Different types of controllers can be used. The paper discusses feedforward and LSTM controllers. Feedforward controllers are simpler, but are more limited than LSTM controllers since the type of operations they can perform are limited by the number of concurrent read and write heads. The LSTM controller, given it's internal registerlike memory, does not suffer from this limitation.
Experiments
Team wanted to see if a network can be trained to copy sequences of length up to 20 could copy a sequence of length 100 with no further training. For all of the experiments, three architectures were compared: NTM with a feedforward controller, TML with an LSTM controller, and a standard LSTM network. All the tasks were supervised learning problems with binary targets; all networks had logistic sigmoid output layers and were trained with the crossentropy objective function. Sequence prediction errors are reported in bitspersequence.
Results
The authors tested the NTM with a feedforward and an LSTM controller against a pure LSTM on multiple tasks:
 Copy Task: An input sequence has to reproduced.
 Repeat Copy Task: An input sequence has to reproduced multiple times.
 Associative Recall: After providing an input sequence the network is queried with one item of the sequence and has to produce the next.
 Dynamic NGrams: Predict the probability of the next bit being 0 or 1 given the last six bits.
 Priority Sort: Sort an input sequence according to given priorities.
In all tasks the combination of NTM with Feedforward or LTSM converges faster and obtains better generalization than a pure LSTM controller.
Discussion
 While the experimental results show great promise of the NTM architecture, the paper could be serviced with a more indepth experimental results discussion as to why NTM performs very well when combined with Feedforward or LTSM compared to a pure LTSM.
 The convergence performance difference between choosing NTM controller with FeedForward vs LTSM appears to hinge on whether the task requires LTSM's internal memory or NTM's external memory as an effective way to store data. Otherwise both controllers are comparable in terms of performance with each other.
 A bit skeptical about the efforts in tuning LTSM, the paper gives the feeling that the authors spent a lot of time tuning the NTM with different number of heads and controller size in order to achieve desired results for publication.
 Interested in knowing quantitatively how it would compare against other algorithms such as Genetic Programming to evolve a turing machines <ref>Naidoo, Amashini, and Nelishia Pillay. "Using genetic programming for turing machine induction." Genetic Programming. Springer Berlin Heidelberg, 2008. 350361.</ref>, where by its output is a "Program" which theoretically should be better because it doesn't use weights, the "Program" should be more robust, and will require a lot less parameters.
References
<references/>