1 Introduction
A brain is a type of recurrent neural network, in the sense that it receives and sends information online, and consists of neurons with synapses as core computational components. This computational structure gives (many of) us a belief that there exists an artificial neural network (ANN) abstraction that is at least as capable as the human brain. Most commonly used ANN’s, such as LSTM, have given us impressive performance in a number of domains, with works such as
(Sutskever et al., 2014; Oord et al., 2016; Espeholt et al., 2018; Berner et al., 2019; Vinyals et al., 2019). The ANN’s update their activations according to operations parameterized by weights, while they update their weights by taking small steps of stochastic gradient descent on some locally computed objective. However, such weight update is likely too restrictive. Its clearest shortcoming is an inability to quickly store online information in weights, which therefore has to be stored in activations. However, utilization of a general weight update could be important for other purposes. Lack of this ability might make classic neural networks insufficient abstractions for capturing brains abilities on comparable size hardware. While a number of works discussed below aim to address this issue for classic neural networks, this begs the question: Can we simply learn the neural weight and activation update rules directly? In subsection
3.4 we will discuss some of the approaches taken in this direction so far.In this paper we pursue the idea that the activations and weights are updated based on local information (for example pre and post synaptic activations for a given synapse and synapse’s previous state) and we conjecture that this update is likely parameterizable by a small number of parameters. Can we learn these parameters? In previous works, evolution as well as long term backpropagation training for the objective have been applied to address this problem. In this paper, we aim to provide a novel parameterization of the update rules as well as motivate and explore another means of training such networks that might prove to be more tractable, especially in longer lifetimes: That of training to remember the past. To make the discussion and relation to other works understandable, we start by explaining the parameterization of neural update rules that we use. Then, in section 3 we discuss how learning of the rules is relevant to many topics in machine learning, as well as discuss the relationship of this paper to previous works. In section 4 we motivate the learning to remember objective. In section 5 we specify training protocol. In section 6 we explain functional form details of the update rules. In section 7 we present experiments and finally we conclude in section 8.
2 Parameterization of local update rules.
We model a neuron by the state (activation) of its body and the states of its synapses. As the real neurons and synapses are complex objects, we represent these states by small vectors, rather than scalars. We aim to parameterize the update rules that are applied at each computational step. The rules stated here are to different extents related to those proposed in other works, as we review in subsection 3.4.
Consider a neuron that receives information from other neurons . Let and be the activations of neurons , and be the weights between neuron and (the state of the synapse). The variables are small vectors.
The state of the neural network consists of all the neural activations , and states of the connections , where is the total number of neurons. The inputs and outputs are represented by special neurons.
At a given point in time the network updates its internal state according to some function:
(1) 
This is a function of many variables. We decompose it by enforcing locality: A given update can only depend on the activations of the other neurons through the synapses that connect to those neurons and on the neuron’s previous state. A given synapse can only be updated based on the activations of the neurons it is connecting and the synapse’s previous internal state.
There are many types of neurons in the brain and thus it is reasonable to have many types of artificial neurons as well. We could use completely separate update functions for each neuron type. However, during evolution/learning of the update rules, a discovery made for one type of the neuron could not translate to the other neurons. Different types of the neurons in the brain share much of the genetic code for making them. For our neurons, we propose to represent such sharing by using the same neural network for each neuron, but to represent the different neuron types by different learned embedding vectors, that control the update of the updaterulesneural networks. We denote by the type of the neuron, and by the embedding vector for a given neuron. The following are the full set of update equations.
(2)  
(3)  
(4) 
Let us discuss these equations. The first equation is the computation of the synapse. The synapse takes its state , and the activations of the presynaptic and post synaptic neurons , , and computes new state as well as the effect on the postsynaptic neuron used next.
The next equation integrates the effect of all the synapses of the neurons. We use . We could consider using a more complex rule, such as taking powers of and a power of the resulting sum. However, this rule can be implemented by modifying functions . We use the summation for the rest of the paper.
Finally, the last equation takes the integrated effect of all the synapses and the previous state of the neuron and computes the new state of the neuron.
In the implementation below we consider a system consisting of neuron types. The neurons are updated in sequence: All the neurons and synapses of a given type are updated first and the resulting values of these neurons are used for the next type of neuron. One could think of these as layers. However often times, a given neural layer (such as cortical layer) consists of several types of neurons, and the layer itself is repeated. Once a good way of finding the update rules is found, such architectures can be implemented and searched over.
3 What could finding update rules do for us? Relation to other works.
3.1 Episodic memory
Remembering information even a few steps back has been a problem for early instantiations of neural networks due to the vanishing gradients (Hochreiter et al., 2001)
. This problem has been addressed by long short term memory (LSTM)
(Hochreiter & Schmidhuber, 1997)  an architecture containing gates that protects the information in activations. This extended the ability to remember to lengths of perhaps hundreds of steps, depending on the problem. However, to go beoynd this window, to store larger amount of information than what can be easily put into activations, and to have an access to the past that does not depend on how for something happened, a number of architectures primarily based on attention mechanism (but not only) has been proposed (Bahdanau et al., 2014; Weston et al., 2014; Hung et al., 2019; Graves et al., 2014; Vaswani et al., 2017; Dai et al., 2019). In most of these cases, the information is stored in slots, which can be thought as a special type of fast weight: Each time we write, we allocate a special neuron, and fully change its weights (for example writing key into incoming and value into outcoming weights, related to (Hinton, 2019), private communication). Some architectures such as (Wu et al., 2018) aim to store in a compressed way, by updating many slots at once and already use matrices with fast writes for storage.Another set of works considers updates to weights that have fast components, (Ba et al., 2016; Miconi et al., 2020). In the latter they consider weights of the following form: . Here the Hebbian part is updated in a prescribed way using product of pre and post synaptic activations while ’s and ’s are trained using standard backpropagation.
3.2 MetaLearning
Another reason that a rule different from backpropagation might be appropriate is the following: The goal of agents is to perform well in the future, not on the data from the past. Agents discover new things through their life (or we might want to apply networks to situations that are different from the ones we trained on so far). To find how to do this, we can learn how to adapt/learn  which is often referred to as metalearning. The setting often used is one where the agent has an endless amount of lifetimes in changing environments. From this experience it needs to learn how to adapt when faced with a new changing environment (changing environment is often implemented as switching tasks or data). To solve this problem we in principle don’t need anything special other than long enough backpropagation: If the changes of environment are within backpropagation period, the recurrent network can learn how to adapt to the changes. This approach was pursued in (Duan et al., 2016; Wang et al., 2016). In this approach, if using a standard recurrent network such as LSTM, one is looking for one (fixed) set of weights, so that the activations could learn how to handle the changing environment. That means that all the adaptation would have to happen in the activations and not weights. That is, the agent would not be, what we often consider to be learning (changing weights) when faced with a new elements of an environment.
One step towards changing the weights during new experiences is to store these new experiences in slots, which can be thought of as fast weights, and make predictions based on the stored data using an attention mechanism  to use episodic memory. This was pursued in (Santoro et al., 2016; Vinyals et al., 2016)
, the latter in the context of classification, where few examples of novel classes were presented, stored, and then attended over when new examples to be classified were presented.
One model that does weight updates to the main network when adapting to the changing environment is model agnostic meta learning (Finn et al., 2017). It updates the weights using the standard gradient descent  taking the steps on the new examples. However, it aims to find the initial good weights, in such a way that subsequent steps in the new tasks would lead to a quick adaptation. Such weights are found by directly optimizing the novel tasks objective, which requires backpropagation through backpropagation, and constitutes a rather complex way of updating the weights.
A simpler weight update rule for achieving this purpose was proposed in (Nichol et al., 2018). The network contains slow and fast weights. Given a new task, several steps of gradient descent on the fast weights are taken. Subsequently, the slow weights are updated by taking a small step in the direction towards the fast weights.
The ultimate dream (not realized yet) of the approach described in this paper and related works is to figure out general weight and activation update rules that would (meta) learn and let the network decide how these weights should be used, whether similarly to the effect of classic backpropagation, or fast learning for storage, or the appropriate updates for adaptiation to new tasks using both activation and weight updates, or potentially other uses. For example the algorithm of the previous paragraph can be represented by making one component of the weight state being the slow weight and another component being the fast one. While achieving such general updates sounds like a difficult task, we reason that all we essentially need, as far as neural network is concerned, is to learn two, not so complex functions.
A step in this direction is taken in (Ravi & Larochelle, 2016). They again consider metalearning classification task  learning so that when presented with examples of new classes, the network learns to classify them quickly. Rather then taking a gradient on the new examples they feed this gradient (and other information) into weight update rules, that are parameterized by an LSTM, letting the LSTM decide how or how much to update a given weight on the new examples presented. Because of the nature of the problem  classifying the new examples  only a short backpropagation (over these examples) is needed to train the weight update rules. In our paper we are looking for general update rules, that work for long term and do not use gradient information.
3.3 Objectives
Standard neural networks compute gradients of some objective. In a (image) classification problem the loss seems relatively straightforward  a measure of an error of the prediction of label given input. However, even in this case, this might not be the best objective  because we might want the network to extrapolate out of distribution (or if we are in setting of having unlabeled examples), we might want a different form of training, such as metalearning, or to impose a structure understanding loss such as generative model (Oord et al., 2018; Donahue & Simonyan, 2019; Jaderberg et al., 2016; Gregor et al., 2019)
. The situation is even more complex in reinforcement learning, where the agent is not given the right targets (actions), it needs to explore, it determines its own data and where it is less clear what a good objective (reward) is. One approach
(Xu et al., 2018; Veeriah et al., 2019)is to metalearn an auxiliary loss function, such that its gradients implement a good RL algorithm. These gradients are a special way to produce weight updates, and we could possibly instead learn such updates directly.
3.4 Neuroevolution and metalearning neural networks.
Rather than designing neural networks architectures and the update rules by hand, there have been a number of works that attempt to find them automatically (Soltoggio et al., 2018; Stanley et al., 2019). There are two common ways to perform such search  evolution and (meta) gradients. In the former one keeps a population of neural networks and, one way or other, mutates them, computes fitness of each and performs natural selection. In the latter, one consider an entire experience or a long part of it and performs backpropagation.
Evolution can be applied to various aspects of neural networks. One type of application is to evolve the structure of a neural network, such as number of layers, connectivity and nonlinearities while using the standard backpropagation algorithm to update the weights (Bayer et al., 2009; Rawal & Miikkulainen, 2018; Real et al., 2019). Another approach is to take a given architecture and evolve the values of weights that solve a task (Wierstra et al., 2008; Salimans et al., 2017).
There are a number of works that aim to learn local neural network update rules (as done in our paper). In one of the earliest works, (Bengio et al., 1992), they consider finding an update rule of a (scalar) weight as a function of local information in the network: A linear combination of local products and nonlinearites of presynaptic and postsynaptic neural values, the previous values of weights and an overall modulatory signal. In HyperNEAT (Risi & Stanley, 2010), compositional pattern producing network (CPPN) is used to produce weights of the actual network. Neurons are laid out on a grid and the CPPN takes their coordinates and produces the weight value. The weights of the CPPN are evolved. In the adaptive version, presynaptic and postsynaptic activations, as well previous neural weights are passed to the CPPN as well, making the CPPN essentially implement (position dependent) local learning update rule. There are a number of other works in similar directions (Schmidhuber, 1992; Vassiliades & Christodoulou, 2013; Orchard & Wang, 2016; Miconi, 2016; Miconi et al., 2018; Gu et al., 2019; Munkhdalai et al., 2019).
The idea of representing activation and synapses by vectors and using general networks for their update was very recently, and independently proposed by (Bertens & Lee, 2019). As an application they evolve a system of seven such neurons to solve a Tmaze task. The differences in our work are the following: We train the network for next step prediction (language) model, motivate and investigate a different objective  that of remembering, (meta) train by backpropagation, study the computational abilities of these networks as a function of problem difficulty and various parameters, and find somewhat different update rules that work well.
Another hint why a vector representation is needed, is the existence of an online algorithm for calculating recurrent network gradients  real time recurrent learning (RTRL) (Williams & Zipser, 1989). The RTRL does not need to go back in time to calculate gradients. However it needs to store a nonlocal and an untractably large number of parameters online: derivatives of a given neuron with respect to all other weights (). One can consider a truncation of such rule that would only need much fewer parameters. Finding the weight update rules directly might effectively and in particular find a good truncation of such information.
A common theme for number of these works (including ours) is that one set of parameters (for the update rules)  metaparameters  parameterizes another set of parameters (weights and activations). These networks can be thought of as standard RNNs with unusual functional form where activations and weights together form what are normally activations (state) of an RNN and the meta parameters what are normally weights. The primary difference from the standard RNN’s is that we are looking for a small set of metaparameters, which means the algorithm needs to learn to store all information about the data in the network’s state (weights and activations) rather then in the metaparameters  see the detailed discussion on this in subsection 4.2 on backpropagation and long term training, and the discussion in section 7 on what it means for something to be a learning rule. However, one can relax the assumption of smallness and obtain a well performing system trained by standard backpropagation, as done in Hypernetworks (Ha et al., 2016). There, they use a set of parameters (hyperweights) that parameterizes the weights of convolutional networks and LSTM. However, it still contains on the order of 100K parameters (hyperweights), which means it is still sensible to train this system by direct, short term backpropagation for the objective, utilizing the metaparameters to store the information about the data.
3.5 AI generating algorithm
In (Clune, 2019) it was proposed that finding a general AI could proceed by metalearning/evolving three pillars: 1) Structures of neural networks, 2) Learning algorithms 3) Environments/training data. Structures of neural networks are properties such as connectivity of layers, sizes, nonlinearities and weight initializations. Learning algorithms are the ways the internal variables are updated during agent’s interactions with the environment. Metalearning/evolving the environments is a process by which more and more complex and diverse problems are produced for or by the agents. We propose that learning the parameters of two relatively simple functions proposed here might be a sufficient substrate for the second pillar.
4 Finding the rules
We need to find the functions in (2, 4) that solve complex problems we are interested in, such as sequence modeling or reinforcement learning. There are two basic ways for training such rules directly for the objective we are interested in  evolution and longterm backpropagation. We discuss what are their advantages and disadvantages and motivate the objective used in this paper, relating it to backpropagation training.
4.1 Evolution
We could evolve the parameters of the functions in (2, 4) to solve complex tasks or survive in an environment. Under standard settings, a population is created, run for their entire lifetime, and then natural selection is applied. The advantage of this approach is that it directly trains for what we are interested in, and the search is (often) nonlocal. However as the problems get more complex, this step of the evolution loop becomes longer and longer. It might be hard to be able to make enough evolutionary steps to find the right algorithm. There can be ways around this problem, such as not resetting the learned weights from scratch at every iteration (Jaderberg et al., 2017), and we certainly consider this to be an exciting direction of research.
4.2 Learning to remember
Let us ask a question  why can’t we train the function in the standard way  run the network forward steps, where is typically of the order of hundred, backpropagate and update ?
Consider training a next step prediction language model. First let us see what happens when we train a standard network such as LSTM. We consider the situation where we read the whole text in the order it is written. At some time , the state of the LSTM is described by where ’s are the weights of the LSTM. Next, we take the next inputs, keep ’s fixed, and update ’s times to arrive at state . Then we backpropagate and update the using a gradient step to obtain . This will increase the likelihood of the sequence we have just seen. What we are really interested though is to increase the likelihood of the sequences that we will see in the future. Why does this work?
A given snippet of text typically contains a structure within the backpropagation window. For instance, the letters ”dee” are usually followed by the letter ”p”. This structure might not appear again for thousands of steps. However, each time such structure is presented, the algorithm effectively memorizes a piece of this information because it is taking small steps of the gradient. It is not memorizing because it needs this information later, it is memorizing it because that’s how it is built  to slowly memorize (in a compressed fashion). The trouble arises when the structure spans much more then the backpropagation period. If an event (harvesting crops) follows an event (such as planting seeds) thousands of steps later, the connection is not found  it is not put into memory through gradient (or only accidentally). Our standard backpropagation algorithm is inadequate, and modifications needs to be found. Solutions to these problems are memory architectures.
In our case, we are only learning by backpropagation the small number of (meta) parameters that control how weights and activations are stirred in response to inputs. In fact we are looking for a single set of parameters of the update rules, so that starting from the beginning of training, the network learns to be good at the task. If training end to end (say for the next step prediction) any information that is present now needs to be stored only because it is useful later. For example the network needs to remember that follows
only because it will need this information thousands of the steps later. The problem that faced the standard neural networks only when long dependencies are considered, manifests itself here right from the start. But perhaps we could consider this to be an opportunity  figure out one principle that interpolates both cases.
There are essentially two solutions to this problem. One is to push hard the end to end approach. Figure out how to optimize the long term objective, either through evolution, long term backpropagation or some other yet not invented trick.
The other approach is to push the memorization all the way. Rather then taking a small step of parameters in the direction of gradient, we aim to memorize everything. This should include one shot memorization of what just happened and a long term memorization of the statistics of the data, with some tradeoff given by the capacity of the network and the objective we impose for this purpose. Such memorization is sometimes pursued by various memory architectures mentioned, which typically split the weights into slow weights trained by backpropagation and fast weights (such as memory slots) that are updated quickly in a particular, perhaps handdesigned way, for example by storing input or hidden state at every time point. In our approach, the hope is that the networks learn which weights should update slowly, which fast and which perhaps at an intermediate speed, acting for example as a working memory with higher capacity and perhaps easier to write to than what activations could provide.
Even in this approach, there are many ways one can imagine imposing a memorization objective. We propose one simple way, but this is very much an open problem. Finally, there are a few points we would like to make regarding potential advantages of this method.
a) It has been shown empirically that the networks that are trained long enough to produce zero training errors actually generalize well (Feldman, 2019). One explanation of this phenomenon is long tails. In a situation where a rare example arrives, if the network has memorized a previous similar rare example, it can make correct prediction.
b) Because of a limited capacity, the network trained to memorize might learn to compress the information, unlike many memory architectures which store all latent vectors in slots. Compressive models might be more efficient storage for search and predictions.
c) Finally the most basic approach to metalearning is simply a long enough backpropagation period. However, as discussed in the introduction, such method can only learn to adapt to changes using neural activations. Instead, several works approach metalearning by storing the past data, which is what our objective does, and use this storage to make predictions.
5 Data and training procedure
The problem we are going to study is a next step prediction in a sequence. As the data we take the text of the ”Wizard of Oz”, a book with approximately 232k characters. To keep the input dimension low, we convert all the characters to lower case and group all the nonletter characters into a single symbol. The resulting input is an onehot vector of size 27.
We use the following training process. We read character by character, wrapping around once the end of the text is reached. Every steps, we have a sequence of the last characters. We train to remember past sequences of length .
For the past, we pick a random time uniformly from an interval where determines how much past we are aiming to remember. We set the initial state of the network by taking the most recent weights and resetting activations to zeros: . We run the network on the sequence and compute the prediction loss (the is only reset for the past run and continues online without resetting). We train the meta parameters by backpropagation through the past and the current sequence (through steps).
6 Neural updates functional forms
Here we discuss the functions that we use in equations (2, 4). We use a number of functional forms that update the state of and of given their inputs. We drop the time index and instead use the upper index to denote components of the state. As mentioned, the states and are small vectors (with sizes between 214), with , denoting th component of these vectors (a scalar). We use the synaptic update of the form
(5)  
(6)  
(7) 
Where the is one of the operators is described in the next paragraph. We write the integration step, and the activation update as
(8)  
(9) 
For the we use the following list of operations. 1) MLP: One hidden layer feedfoward neural network. For the operations sigmoid nonlinearity is applied at the output, while for the update, no nonlinearity is applied, or, denoting MLPtanh, tanh nonlinearity is applied. The hidden layer nonlinearity of the MLP is tanh. 2) LSTM: Standard LSTM update is used where the state ( or ) is split into hidden and cells of the LSTM. We consider few variations. In the standard LSTM, the final operation is where is the cell and is the output gate. We denote LSTM when using and LSTMid when using . Finally, we also use the following operation for OP(, ) (with either or ), which we denote by GATED:
(10)  
(11)  
(12)  
(13) 
The overall architecture of the system consists of one or more hidden layers with the updates just described and an input layer. All layers are connected to all other layers including themselves. The operations of the input layer are as follows, with denoting the input to be predicted.
(14)  
(15)  
(16)  
(17)  
(18) 
The second equation is the softmax function. In the third equation, the first component of
is used as the probability. In the fourth equation, the standard crossentropy loss is calculated. In the final equation we replace the first component of
by and the last component by the prediction error . The weights were initialize at random at the beginning of training in the same way as if they were weights of standard neural network.7 Experiments
We made a number of experiments before we arrived at the functional forms stated above. We describe some observations we made during that time. First, note that the effect of the synapse on the neuron, the in (5), has a particularly simple form of multiplication. This, together with the summation over becomes the standard matrix multiplication used in neural networks, except that there are essentially neuron state size number of such operations (one for each in (5)). We experimented with merely using the OP in (7) to output this value, but we found that fails to learn well. Also note that we used 0th component of in (5) and the first component in equations (6, 13). We found this combination (using different components) to work well, but undoubtedly, significantly more exploration can be done in this direction.
Now we turn to the results based on the equations stated in the previous section. In Figure 1, left and middle, we analyze the effect of different OP’s in both and . We analyze the performance on delays of 10 and 80 (10 means up to steps into the past from the most recently seen datapoint). We are interested in the performance both early in the training and also once a lot of the curves have already converged. To get the early performance, we took the average of losses over the first 200k steps. This number was obtained roughly at the location after some of the curves dipped significantly. The final performance was taken at 1M time steps. For a given setting we made a number of runs. Out of this both the average curves and the best curves are interesting. Average means how does a given system performs on average. The best performance shows how well a given system can perform if the optimization succeeded more often (more about what is the potential of the functional form). We display the plots for the best performance, but the plots of the average performance give essentially the same conclusions.
The middle column Figure 1 shows the final performance. For short delays, essentially all combinations succeed in reaching good performance (except MLPtanh x MLPy). However for longer delays, there is a significant difference between the runs. What emerges is that gated network for the weight update consistently performs the best. However, for certain updates to , LSTMid performs well. MLP networks for weight updates generally fail. The reason for this probably is similar to why standard recurrent neural network doesn’t learn well compared to LSTM  the weights need a good mechanism for remembering. For example, in standard gradient descent, the update is . With the gated networks, the network could learn to implement close to this additive update for some neuron types, and fast updates for others, or it can learn to make fast update depending on the current input.
The left column of Figure 1 shows the performance early in training. This time, for longer delays, LSTM update on produces stronger performance.
Figure 1 right, shows performance of several runs for different settings. We consider state sizes of and (equal for both activation and weight states). We also run standard LSTM baseline on this task. We make a number of observations from this figure. First we see that there is quite a spread of the values that different runs of the same hyperparameter produce. Thus, there is clearly an optimization problem. Second, the larger state size ( compared to ) clearly works better. Third, we see that for delays up to 80, our system works significantly better than LSTM’s displayed.
It is interesting to compare our network to standard LSTM. Our network can be thought of as a classic neural network with an unusual functional form, where the metaparameters are the parameters trained by backpropagation and the activations and weights are what would normally be activations of the recurrent network  the recurrent state. In this interpretation, the size of the state in our network is significantly bigger than that of LSTM, while the number of parameters that control these activations is quite a bit smaller  this number is displayed in the Figure under variable . In our network we have a relatively small number of variables controlling a system with a very large state size.
The property of finding a small number of weights that controls a much larger state space has been encountered before in Hypernetwork (Ha et al., 2016) (where the ratio is not very large) and in non temporal setting of denoising autoencoder (Fernando et al., 2016). As this ratio gets smaller and smaller, the more the network updates have to resemble a learning algorithm  the more of the learning has to be learned. And, as we discussed in subsection 4.2, the less it is possible to learn this using direct backpropagation on short sequences, which is what motivated the learning to remember objective of this paper. Have we succeeded at what we would call learning rules? And what does it mean for something to be a learning rule, as opposed to just a network of small number of parameters, parameterizing a large state. First, a given learning rule should work rather generally  that is a given fixed set of metaparameters should be able to solve many problems. This would likely require producing a diversity of training, validation and testing problems and we hope such analysis will be done in the near future.
There is another, simpler property though that a learning rule should satisfy. In our networks, a given set of metaparameters is independent of the number of neurons. A good learning rule should be able to utilize these neurons, that is, the performance should increase as we increase the network size. Unfortunately, we haven’t found this to be the case in our system. We found that even with small number of neurons we get the above performance. There could be a number of reasons for this. First, the layer containing the inputs has self connections, and a lot of the computation the network needs to do could be done there. The hidden layer does have an effect especially early in the training (as seen in Figure 1 left), but it goes away more later on, possibly with the network learning to primarily utilize self connections. Second, we have seen that the optimization is a problem and it could be causing large network not to learn as well as they could.
While this scaling has not succeeded so far, there is significantly more exploration that can be done in this direction. We hope we have provided a interesting parameterization, analysis and insights into this problem that will be prove useful in the future.
8 Discussion and conclusions
In this paper we were motivated by a tantalizing possibility that all the learning algorithms that we need, from one shot learning, model learning, reinforcement learning could potentially be parameterized by two simple functions: The update rule for activations and the update rule for weights, with different neuron types represented by embedings that affect the update rules. We explored a tiny corner of this space  handsearched for the update rules, learned to remember and applied to text. Just like rectified linear units made a big difference for training deep networks, there are likely to be many innovations that could make this approach much better.
For the future, research can be done in several directions. First, we could perform evolutionary search both for the architectures of the update rules as well as the network architectures. Then, different training regimes and different approaches to optimizing these rules could be tried. Finally, the problems on which these networks are applied are likely just as important as the architectures and update rules (Clune, 2019).
Can a general learning algorithm be represented by such simple functions and an evolutionary search? The answer, we believe, is that this algorithm does not stand alone. As agents move through life, they not only acquire new experience but also improve the way they learn. A good learning algorithm is determined not only by the correct settings of the update rule parameters, but also by the values of the actual weights of the network. While we are born without much specific knowledge about the world, some of the initializations of these weights, as well as environmental settings, could prove important for starting the network at the right place at the beginning of agent’s life. We could aim to evolve/metalearn such initializations. Alternatively, since we don’t have a restriction of finite life on our agents, we could simply continue its life forever, or find some other mechanism for starting a new agent.
References
 Ba et al. (2016) Ba, J., Hinton, G. E., Mnih, V., Leibo, J. Z., and Ionescu, C. Using fast weights to attend to the recent past. In Advances in Neural Information Processing Systems, pp. 4331–4339, 2016.
 Bahdanau et al. (2014) Bahdanau, D., Cho, K., and Bengio, Y. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.
 Bayer et al. (2009) Bayer, J., Wierstra, D., Togelius, J., and Schmidhuber, J. Evolving memory cell structures for sequence learning. In International Conference on Artificial Neural Networks, pp. 755–764. Springer, 2009.
 Bengio et al. (1992) Bengio, S., Bengio, Y., Cloutier, J., and Gecsei, J. On the optimization of a synaptic learning rule. In Preprints Conf. Optimality in Artificial and Biological Neural Networks, volume 2. Univ. of Texas, 1992.
 Berner et al. (2019) Berner, C., Brockman, G., Chan, B., Cheung, V., Debiak, P., Dennison, C., Farhi, D., Fischer, Q., Hashme, S., Hesse, C., et al. Dota 2 with large scale deep reinforcement learning. arXiv preprint arXiv:1912.06680, 2019.
 Bertens & Lee (2019) Bertens, P. and Lee, S.W. Network of evolvable neural units: Evolving to learn at a synaptic level. arXiv preprint arXiv:1912.07589, 2019.
 Clune (2019) Clune, J. Aigas: Aigenerating algorithms, an alternate paradigm for producing general artificial intelligence. arXiv preprint arXiv:1905.10985, 2019.
 Dai et al. (2019) Dai, Z., Yang, Z., Yang, Y., Carbonell, J., Le, Q. V., and Salakhutdinov, R. Transformerxl: Attentive language models beyond a fixedlength context. arXiv preprint arXiv:1901.02860, 2019.
 Donahue & Simonyan (2019) Donahue, J. and Simonyan, K. Large scale adversarial representation learning. In Advances in Neural Information Processing Systems, pp. 10541–10551, 2019.
 Duan et al. (2016) Duan, Y., Schulman, J., Chen, X., Bartlett, P. L., Sutskever, I., and Abbeel, P. Rl2: Fast reinforcement learning via slow reinforcement learning. arXiv preprint arXiv:1611.02779, 2016.
 Espeholt et al. (2018) Espeholt, L., Soyer, H., Munos, R., Simonyan, K., Mnih, V., Ward, T., Doron, Y., Firoiu, V., Harley, T., Dunning, I., et al. Impala: Scalable distributed deeprl with importance weighted actorlearner architectures. arXiv preprint arXiv:1802.01561, 2018.
 Feldman (2019) Feldman, V. Does learning require memorization? a short tale about a long tail. arXiv preprint arXiv:1906.05271, 2019.

Fernando et al. (2016)
Fernando, C., Banarse, D., Reynolds, M., Besse, F., Pfau, D., Jaderberg, M.,
Lanctot, M., and Wierstra, D.
Convolution by evolution: Differentiable pattern producing networks.
In
Proceedings of the Genetic and Evolutionary Computation Conference 2016
, pp. 109–116, 2016.  Finn et al. (2017) Finn, C., Abbeel, P., and Levine, S. Modelagnostic metalearning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine LearningVolume 70, pp. 1126–1135. JMLR. org, 2017.
 Graves et al. (2014) Graves, A., Wayne, G., and Danihelka, I. Neural turing machines. arXiv preprint arXiv:1410.5401, 2014.
 Gregor et al. (2019) Gregor, K., Rezende, D. J., Besse, F., Wu, Y., Merzic, H., and van den Oord, A. Shaping belief states with generative environment models for rl. In Advances in Neural Information Processing Systems, pp. 13475–13487, 2019.
 Gu et al. (2019) Gu, K., Greydanus, S., Metz, L., Maheswaranathan, N., and SohlDickstein, J. Metalearning biologically plausible semisupervised update rules. bioRxiv, 2019.
 Ha et al. (2016) Ha, D., Dai, A., and Le, Q. V. Hypernetworks. arXiv preprint arXiv:1609.09106, 2016.
 Hinton (2019) Hinton, G. Private communication. 2019.
 Hochreiter & Schmidhuber (1997) Hochreiter, S. and Schmidhuber, J. Long shortterm memory. Neural computation, 9(8):1735–1780, 1997.
 Hochreiter et al. (2001) Hochreiter, S., Bengio, Y., Frasconi, P., Schmidhuber, J., et al. Gradient flow in recurrent nets: the difficulty of learning longterm dependencies, 2001.
 Hung et al. (2019) Hung, C.C., Lillicrap, T., Abramson, J., Wu, Y., Mirza, M., Carnevale, F., Ahuja, A., and Wayne, G. Optimizing agent behavior over long time scales by transporting value. Nature communications, 10(1):1–12, 2019.
 Jaderberg et al. (2016) Jaderberg, M., Mnih, V., Czarnecki, W. M., Schaul, T., Leibo, J. Z., Silver, D., and Kavukcuoglu, K. Reinforcement learning with unsupervised auxiliary tasks. arXiv preprint arXiv:1611.05397, 2016.
 Jaderberg et al. (2017) Jaderberg, M., Dalibard, V., Osindero, S., Czarnecki, W. M., Donahue, J., Razavi, A., Vinyals, O., Green, T., Dunning, I., Simonyan, K., et al. Population based training of neural networks. arXiv preprint arXiv:1711.09846, 2017.
 Miconi (2016) Miconi, T. Learning to learn with backpropagation of hebbian plasticity. arXiv preprint arXiv:1609.02228, 2016.
 Miconi et al. (2018) Miconi, T., Clune, J., and Stanley, K. O. Differentiable plasticity: training plastic neural networks with backpropagation. arXiv preprint arXiv:1804.02464, 2018.
 Miconi et al. (2020) Miconi, T., Rawal, A., Clune, J., and Stanley, K. O. Backpropamine: training selfmodifying neural networks with differentiable neuromodulated plasticity. arXiv preprint arXiv:2002.10585, 2020.
 Munkhdalai et al. (2019) Munkhdalai, T., Sordoni, A., Wang, T., and Trischler, A. Metalearned neural memory. In Advances in Neural Information Processing Systems, pp. 13310–13321, 2019.
 Nichol et al. (2018) Nichol, A., Achiam, J., and Schulman, J. On firstorder metalearning algorithms. arXiv preprint arXiv:1803.02999, 2018.
 Oord et al. (2016) Oord, A. v. d., Kalchbrenner, N., and Kavukcuoglu, K. Pixel recurrent neural networks. arXiv preprint arXiv:1601.06759, 2016.
 Oord et al. (2018) Oord, A. v. d., Li, Y., and Vinyals, O. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018.
 Orchard & Wang (2016) Orchard, J. and Wang, L. The evolution of a generalized neural learning rule. In 2016 International Joint Conference on Neural Networks (IJCNN), pp. 4688–4694. IEEE, 2016.
 Ravi & Larochelle (2016) Ravi, S. and Larochelle, H. Optimization as a model for fewshot learning. 2016.
 Rawal & Miikkulainen (2018) Rawal, A. and Miikkulainen, R. From nodes to networks: Evolving recurrent neural networks. arXiv preprint arXiv:1803.04439, 2018.

Real et al. (2019)
Real, E., Aggarwal, A., Huang, Y., and Le, Q. V.
Regularized evolution for image classifier architecture search.
In
Proceedings of the aaai conference on artificial intelligence
, volume 33, pp. 4780–4789, 2019.  Risi & Stanley (2010) Risi, S. and Stanley, K. O. Indirectly encoding neural plasticity as a pattern of local rules. In International Conference on Simulation of Adaptive Behavior, pp. 533–543. Springer, 2010.
 Salimans et al. (2017) Salimans, T., Ho, J., Chen, X., Sidor, S., and Sutskever, I. Evolution strategies as a scalable alternative to reinforcement learning. arXiv preprint arXiv:1703.03864, 2017.
 Santoro et al. (2016) Santoro, A., Bartunov, S., Botvinick, M., Wierstra, D., and Lillicrap, T. Oneshot learning with memoryaugmented neural networks. arXiv preprint arXiv:1605.06065, 2016.
 Schmidhuber (1992) Schmidhuber, J. Learning to control fastweight memories: An alternative to dynamic recurrent networks. Neural Computation, 4(1):131–139, 1992.
 Soltoggio et al. (2018) Soltoggio, A., Stanley, K. O., and Risi, S. Born to learn: the inspiration, progress, and future of evolved plastic artificial neural networks. Neural Networks, 108:48–67, 2018.
 Stanley et al. (2019) Stanley, K. O., Clune, J., Lehman, J., and Miikkulainen, R. Designing neural networks through neuroevolution. Nature Machine Intelligence, 1(1):24–35, 2019.
 Sutskever et al. (2014) Sutskever, I., Vinyals, O., and Le, Q. V. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104–3112, 2014.
 Vassiliades & Christodoulou (2013) Vassiliades, V. and Christodoulou, C. Toward nonlinear local reinforcement learning rules through neuroevolution. Neural computation, 25(11):3020–3043, 2013.
 Vaswani et al. (2017) Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł., and Polosukhin, I. Attention is all you need. In Advances in neural information processing systems, pp. 5998–6008, 2017.
 Veeriah et al. (2019) Veeriah, V., Hessel, M., Xu, Z., Rajendran, J., Lewis, R. L., Oh, J., van Hasselt, H. P., Silver, D., and Singh, S. Discovery of useful questions as auxiliary tasks. In Advances in Neural Information Processing Systems, pp. 9306–9317, 2019.
 Vinyals et al. (2016) Vinyals, O., Blundell, C., Lillicrap, T., Wierstra, D., et al. Matching networks for one shot learning. In Advances in neural information processing systems, pp. 3630–3638, 2016.
 Vinyals et al. (2019) Vinyals, O., Babuschkin, I., Czarnecki, W. M., Mathieu, M., Dudzik, A., Chung, J., Choi, D. H., Powell, R., Ewalds, T., Georgiev, P., et al. Grandmaster level in starcraft ii using multiagent reinforcement learning. Nature, 575(7782):350–354, 2019.
 Wang et al. (2016) Wang, J. X., KurthNelson, Z., Tirumala, D., Soyer, H., Leibo, J. Z., Munos, R., Blundell, C., Kumaran, D., and Botvinick, M. Learning to reinforcement learn. arXiv preprint arXiv:1611.05763, 2016.
 Weston et al. (2014) Weston, J., Chopra, S., and Bordes, A. Memory networks. arXiv preprint arXiv:1410.3916, 2014.
 Wierstra et al. (2008) Wierstra, D., Schaul, T., Peters, J., and Schmidhuber, J. Natural evolution strategies. In 2008 IEEE Congress on Evolutionary Computation (IEEE World Congress on Computational Intelligence), pp. 3381–3387. IEEE, 2008.
 Williams & Zipser (1989) Williams, R. J. and Zipser, D. A learning algorithm for continually running fully recurrent neural networks. Neural computation, 1(2):270–280, 1989.
 Wu et al. (2018) Wu, Y., Wayne, G., Graves, A., and Lillicrap, T. The kanerva machine: A generative distributed memory. arXiv preprint arXiv:1804.01756, 2018.
 Xu et al. (2018) Xu, Z., van Hasselt, H. P., and Silver, D. Metagradient reinforcement learning. In Advances in neural information processing systems, pp. 2396–2407, 2018.