When completing RL models access to the right experience matters (fig:rainbow).
<FIGURE>Related work
Model completion
The closest well-studied phenomenon to model completion is unsupervised pretraining, first introduced by [1]}. In unsupervised pretraining a subset of the model, typically the lower layers, is trained in a first pass with an unsupervised reconstruction loss [2]}. The aim is to learn useful high-level representations that make a second pass with a supervised loss more computationally and sample efficient. This second pass could be thought as model completion.
In this paper we study vertical model completion where all parameters in one layer have to be completed. Instead we could have studied horizontal model completion where some parameters have to be completed in every layer. Horizontal model completion should be easy as suggested by the effectiveness of dropout as a regularizer [3]}, which trains a model to be resilient to horizontal parameter loss.
Pruning neural networks [4]} is in a sense the reverse operation to model completion. [5]} prune individual connections and [6]} prune entire feature maps using different techniques; their findings, lower layers are more important, are compatible with ours. [7]} present empirical evidence for the lottery ticket hypothesis: only a small subnetwork matters (the `lottery ticket') and the rest can be pruned away without loss of performance. The model completion problem for this lottery ticket (which is spread over all layers) would be trivial by definition. All of these works only consider removing parts of the model horizontally.
The model completion problem can also be viewed as transfer learning from one task to the same task, while only sharing a subset of the parameters [8]}, [9]}. [10]} investigate which layers in a deep convolutional model contain general versus task-specific representations; some of their experiments follow the same setup as we do here and their results are in line with ours, but they do not measure the hardness of model completion task.
Finally, our work has some connections to distillation of deep models [11]}, [12]}, [13]}, [14]}. Distillation can be understood as a `reverse' of model completion, where we want to find a smaller model with the same performance instead of completing a smaller, partial model.

Shared model governance
The literature revolves around two techniques for sharing model governance: homomorphic encryption (HE; [15]}) and secure multiparty computation (MPC; [16]}, [17]}). Both HE and MPC have been successfully applied to machine learning on small datasets like MNIST [18]}, [19]}, [20]}, [21]} and the Wisconsin Breast Cancer Data set [22]}.
HE is an encryption scheme that allows computation on encrypted numbers without decrypting them. It thus enables a model to be trained by an untrusted third party in encrypted form. The encryption key to these parameters can be cryptographically shared between several other parties who effectively retain control over how the model is used.
Using MPC numbers can be shared across several parties such that each share individually contains no information about these numbers. Nevertheless computational operations can be performed on the shared numbers if every party performs operations on their share. The result of the computation can be reconstructed by pooling the shares of the result.
While both HE and MPC fulfill a similar purpose, they face different tradeoffs for the additional security benefits: HE incurs a large computational overhead [23]} while MPC incurs a much smaller computational overhead in exchange for a greater communication overhead [24]}. Moreover, HE provides cryptographic security (reducing attacks to break the cipher on well-studied hard problems such as the discrete logarithm) while MPC provides perfect information-theoretic guarantees as long as the parties involved (3 or more) do not collude.
There are many applications where we would be happy to pay for the additional overhead because we cannot train the model any other way, for example in the health sector where privacy and security are critical. However, if we want to scale shared model governance to the training of large neural networks, both HE and MPC are ruled out because of their prohibitive overhead.
In contrast to HE and MPC, sharing governance via model splitting incurs minimal computational and manageable communication overhead. However, instead of strong security guarantees provided by HE and MPC, the security guarantee is bounded from above by the hardness of the model completion problem we study in this paper.

The problem of model completion
Let \(f_\theta \)  be a model parameterized by the vector \(\theta \) .
We consider two settings: supervised learning and reinforcement learning.
In our supervised learning experiments we evaluate the model \(f_\theta \)  by its performance on the test loss \(L(\theta )\) .
In reinforcement learning an agent interacts with an environment over a number of discrete time steps [25]}: In time step \(t\) , the agent takes an action \(a_t\)  and receives an observation \(o_{t+1}\)  and a reward \(r_{t+1} \in \mathbb {R}\)  from the environment. We consider the episodic setting in which there is a random final time step \(\tau \le K\)  for some constant \(K \in \mathbb {N}\) , after which we restart with timestep \(t = 1\) .
The agent's goal is to maximize the episodic return \(G := \sum _{t=1}^\tau r_t\) .
Its policy is a mapping from sequences of observations
to a distribution over actions parameterized by the model \(f_\theta \) .
To unify notation for SL and RL, we equate \(L(\theta ) = \mathbb {E}_{a_t \sim f_\theta (o_1, \ldots , o_{t-1})} [-G]\)  such that the loss function for RL is the negative expected episodic return.
Problem definition
To quantify training costs we measure the computational cost during (re)training. To simplify, we assume that training proceeds over a number of discrete steps. A step can be computation of gradients and parameter update for one minibatch in the case of supervised learning or one environment step in the case of reinforcement learning. We assume that computational cost are constant for each step, which is approximately true in our experiments. This allows us to measure training cost through the number of training steps executed.
Let \(T\)  denote the training procedure for the model \(f_\theta \)  and
let \(\theta _0, \theta _1, \ldots \)  be the sequence of parameter vectors during training where \(\theta _i\)  denotes the parameters in training step \(i\) .
Furthermore, let \(\ell ^* := \min \lbrace  L(\theta _i) \mid i \le N \rbrace \)  denote the best model performance during the training procedure \(T\)  (not necessarily the performance of the final weights).
We define the training cost as the random variable \(C_T(\ell ) := \arg \min _{ i \in \mathbb {N} } \lbrace  L(\theta _i) \le \ell \rbrace \) , the number of training steps until the loss falls below the given threshold \(\ell \in \mathbb {R}\) .
After we have trained the model \(f_\theta \)  for \(N\)  steps and thus end up with a set of trained parameters \(\theta _N\)  with loss \(L(\theta _N)\) , we split the parameters \(\theta _N = [\theta _N^1, \theta _N^2]\)  into two disjoint subvectors of parameters \(\theta _N^1\)  and \(\theta _N^2\) . For example, \(\theta _N^2\)  could be all parameters of one of the model's layers.
The model completion problem is, given the parameters \(\theta _N^1\)  but not \(\theta _N^2\) , recovering a model that has loss at most \(L(\theta _N)\) . This is illustrated in fig:model-completion-problem.

Measuring the hardness of model completion
How hard is the model completion problem? To answer this question, we use the parameters \(\theta ^{\prime }_0 := [\theta ^{\prime }_0{}^1, \theta ^{\prime }_0{}^2]\)  where \(\theta ^{\prime }_0{}^1 := \theta _N^1\)  are the previously trained parameters and \(\theta ^{\prime }_0{}^2\)  are freshly initialized parameters. We then execute a (second) retraining procedure \(T^{\prime } \in \mathcal {T}\)  from a fixed set of available retraining procedures \(\mathcal {T}\) .\(\mathcal {T}\)  should not include unrealistic retraining procedures like setting the weights to \(\theta _N\)  in one step. The aim of this retraining procedure is to complete the model, and it may be different from the initial training procedure \(T\) . We assume that \(T \in \mathcal {T}\)  since retraining the entire model from scratch (reinitializing all parameters) is a valid way to complete the model.
Let \(\theta ^{\prime }_0, \theta ^{\prime }_1, \ldots \)  be the sequence of parameter vectors obtained from running the retraining procedure \(T^{\prime } \in \mathcal {T}\) . Analogously to before, we define \(C_{T^{\prime }}^{\prime }(\ell ) := \arg \min _{ i \in \mathbb {N} } \lbrace  L(\theta ^{\prime }_i) \le \ell \rbrace \)  as the retraining cost to get a model whose test loss is below the given threshold \(\ell \in \mathbb {R}\) .
Note that by definition, for \(T^{\prime } = T\)  we have that \(C_{T^{\prime }}^{\prime }(\ell )\)  is equal to \(C_T(\ell )\)  in expectation.
In addition to recovering a model with the best original performance \(\ell ^*\) , we also consider partial model completion by using some higher thresholds \(\ell _\alpha ^* := \alpha \ell ^* + (1 - \alpha ) L(\theta _0)\)  for \(\alpha \in [0, 1]\) . These higher thresholds \(\ell _\alpha ^*\)  correspond to the relative progress \(\alpha \)  from the test loss of the untrained model parameters \(L(\theta _0)\)  to the best test loss \(\ell ^*\) . Note that \(\ell ^*_1 = \ell ^*\) .
We define the hardness of model completion as the expected cost to complete the model as a fraction of the original training cost for the fastest retraining procedure \(T^{\prime } \in \mathcal {T}\)  available:
\(\textrm {MC-hardness}_T(\alpha ) := \inf _{T^{\prime } \in \mathcal {T}} \mathbb {E} \left[ \frac{C_{T^{\prime }}^{\prime }(\ell ^*_\alpha )}{C_T(\ell ^*_\alpha )} \right],\) 
where the expectation is taken over all random events in the training procedures \(T\)  and \(T^{\prime }\) .
It is important to emphasize that the hardness of model completion is a relative measure, depending on the original training cost \(C_T(\ell ^*_\alpha )\) . This ensures that we can compare the hardness of model completion across different tasks and different domains. In particular, for different values of \(\alpha \)  we compare like with like: \(\textrm {MC-hardness}_T(\alpha )\)  is measured relative to how long it took to get the loss below the threshold \(\ell ^*_\alpha \)  during training. Importantly, it is not relative to how long it took to train the model to its best performance \(\ell ^*\) . This means that naively counter-intuitive results such as \(\textrm {MC-hardness}_T(0.8)\)  being less than \(\textrm {MC-hardness}_T(0.5)\)  are possible.
Since \(C_T(\ell )\)  and \(C_{T^{\prime }}(\ell )\)  are nonnegative, \(\textrm {MC-hardness}_T(\alpha )\)  is nonnegative. Moreover, since \(T \in \mathcal {T}\)  by assumption, we could retrain all model parameters from scratch (formally setting \(T^{\prime }\)  to \(T\) ). Thus we have \(\textrm {MC-hardness}_T(\alpha ) \le 1\) , and therefore \(\textrm {MC-hardness}\)  is bounded between 0 and 1.

Retraining procedures
eq:model-completion-difficulty denotes an infimum over available retraining procedures \(\mathcal {T}\) . However, in practice there is a vast number of possible retraining procedures we could use and we cannot enumerate and run all of them.
Instead, we take an empirical approach for estimating the hardness of model completion: we investigate the following set of retraining strategies \(\mathcal {T}\)  to complete the model. All the retraining strategies, if not noted otherwise, are built on top of the original training procedure \(T\) . Our best result are only an upper bound on the hardness of model completion. It is likely that much faster retraining procedures exist.
\(\mathbf {T_{1}}\)
Optimizing \(\theta ^{\prime }_0{}^1\)  and \(\theta ^{\prime }_0{}^2\)  jointly.
We repeat the original training procedure \(T\)  on the preserved parameters \(\theta ^{\prime }_0{}^1\)  and reinitialized parameters \(\theta ^{\prime }_0{}^2\) . The objective function is optimized with respect to all the trainable variables in the model. We might vary in hyperparameters such as learning rates or loss weighting schemes compared to \(T\) , but keep hyperparameters that change the structure of the model (e.g. size and number of layers) fixed.

\(\mathbf {T_{2}}\)
Optimizing \(\theta ^{\prime }_0{}^2\) , but not \(\theta ^{\prime }_0{}^1\) .
Similarly to \(\mathbf {T_{1}}\) , in this retraining procedure we keep the previous model structure.
However, we freeze the trained weights \(\theta ^{\prime }_0{}^1\) , and only train the reinitialized parameters \(\theta ^{\prime }_0{}^2\) .

\(\mathbf {T_{3}}\)
Overparametrizing the missing layers.
This builds on retraining procedure \(\mathbf {T_{1}}\) . Overparametrization is a common trick in computer vision, where a model is given a lot more parameters than required, allowing for faster learning. This idea is supported by the `lottery ticket hypothesis' [7]}: a larger number of parameters increases the odds of a subpart of the network having random initialization that is more conducive to optimization.

\(\mathbf {T_{4}}\)
Reinitializing parameters \(\theta ^{\prime }_0{}^2\)  using a different initialization scheme.
Previous research shows that parameter initialization schemes can have a big impact on convergence properties of deep neural networks [27]}, [28]}. In \(\mathbf {T_{1}}\)  our parameters are initialized using a glorot uniform scheme. This retraining procedure is identical to \(\mathbf {T_{1}}\)  except that we reinitialize \(\theta ^{\prime }_0{}^2\)  using one of the following weight initialization schemes: glorot normal [27]}, msra [30]} or caffe [31]}.

Experimental setup
Our main experimental results establish upper bounds on the hardness of model completion in the context of several state of the art models for both supervised learning and reinforcement learning.
In all the experiments, we train a model to a desired performance level (this does not have to be state-of-the-art performance), and then reinitialize a specific part of the network and start the retraining procedure.
Each experiment is run with 3 seeds, except IMPALA (5 seeds) and A3C (10 seeds).
Supervised learning.
We train AlexNet [32]} and ResNet50 [33]} on the ImageNet dataset [34]} to minimize cross-entropy loss. The test loss is the top-1 error rate on the test set. AlexNet is an eight layer convolutional network consisting of five convolutional layers with max-pooling, followed by two fully connected layers and a softmax output layer. ResNet50 is a 50 layer convolutional residual network: The first convolutional layer with max-pooling is followed by four sections, each with a number of ResNet blocks (consisting of two convolutional layers with skip connections and batch normalization), followed by average pooling, a fully connected layer and a softmax output layer.
We apply retraining procedures \(\mathbf {T_{1}}\)  and \(\mathbf {T_{2}}\)  and use a different learning rate schedule than in the original training procedure because it performs better during retraining. All other hyperparameters are kept the same.

Reinforcement learning.
We consider three different state of the art agents: A3C [35]}, Rainbow [36]} and the IMPALA reinforcement learning agent [37]}. A3C comes from a family of actor-critic methods which combine value learning and policy gradient approaches in order to reduce the variance of the gradients. Rainbow is an extension of the standard DQN [38]} agent, which combines double Q-learning [39]},
dueling networks [40]}, distributional RL [41]} and noisy nets [42]}.
Moreover, it is equipped with a replay buffer that stores the previous million transitions of the form \((o_t, a_t, r_{t+1}, o_{t+1})\) , which is then sampled using a prioritized weighting scheme based on temporal difference errors [43]}.
Finally, IMPALA is an extension of A3C, which uses the standard actor-critic architecture with off-policy corrections in order to scale effectively to a large scale distributed setup. We train IMPALA with population based training [44]}.
For A3C and Rainbow we use the Atari 2600 domain [45]} and for IMPALA DeepMind Lab [46]}. In both cases, we treat the list of games/levels as a single learning problem by averaging across games in Atari and training the agent on all level in parallel in case of DeepMind Lab. In order to reduce the noise in the MC-hardness metric, caused by agents being unable to learn the task and behaving randomly, we filter out the levels in which the original trained agent performs poorly.
We apply the retraining procedures \(\mathbf {T_{1}}\) , \(\mathbf {T_{2}}\)  on all the models, and on A3C we apply additionally \(\mathbf {T_{3}}\)  and \(\mathbf {T_{4}}\) . All the hyperparameters are kept the same during the training and retraining procedures.
Further details of the training and retraining procedures for all models can be found in app:experimental-details, and the parameter counts of the layers are listed in app:parameter-counts.

Key findings
Our experimental results on the hardness of the model completion problem are reported in Figures REF –REF .
These figures show on the x-axis different experiments with different layers being reinitialized (lower to higher layers from left to right). We plot \(\textrm {MC-hardness}_T(\alpha )\)  as a bar plot with error bars showing the standard deviation over multiple experiment runs with different seeds; the colors indicate different values of \(\alpha \) .
The numbers are provided in app:experimental-data.
In the following we discuss the results.
<FIGURE><FIGURE><FIGURE><FIGURE><FIGURE>0. In the majority of cases, \(\mathbf {T_{1}}\)  is the best of our retraining procedures.
From the retraining procedures listed in ssec:retraining-procedures we use \(\mathbf {T_{1}}\)  and \(\mathbf {T_{2}}\)  in all experiments and find that \(\mathbf {T_{1}}\)  performs substantially better in all settings except two: First, for A3C, starting from the third convolutional layer, \(\mathbf {T_{2}}\)  has lower \(\textrm {MC-hardness}\)  for all the threshold levels (fig:a3c). Second, \(\mathbf {T_{2}}\)  performs well on all the layers when retraining ResNet-50, for all \(\alpha \le 0.9\)  (fig:resnet50); the difference is especially visible at \(\alpha = 0.9\) .
For A3C we use all four retraining procedures. The difference between \(\mathbf {T_{1}}\)  and \(\mathbf {T_{2}}\)  are shown in fig:a3c. For \(\mathbf {T_{3}}\)  we tried replacing the first convolutional layer with two convolutional layers using a different kernel size, as well as replacing a fully connected layer with two fully connected layers of varying sizes. The results were worse than using the same architecture and we were often unable to retrieve \(100\%\)  of the original performance. With \(\mathbf {T_{4}}\)  we do not see any statistically significant difference in retraining time between the initialization schemes glorot normal, msra, and caffe.

1. Residual networks are easier to complete.
Comparing our SL results in fig:alexnet and fig:resnet50 for \(\mathbf {T_{1}}\) , the model hardness for threshold \(\alpha = 0.5\)  and \(\alpha = 0.8\)  is much lower for ResNet50 than for AlexNet. However, to get the original model performance (\(\alpha = 1\) ), both models need about 40% of the original training cost. As mentioned above, \(\mathbf {T_{2}}\)  works better than \(\mathbf {T_{1}}\)  on ResNet50 for \(\alpha \le 0.9\) .
An intact skip connection helps retraining for \(\alpha \le 0.9\)  and \(\mathbf {T_{1}}\) , but not \(\mathbf {T_{2}}\) , as illustrated in the experiment S4 B1 -W (fig:resnet50). A noticeable outlier is S4 B1 at \(\alpha = 0.9\) ; it is unclear what causes this effect, but it reproduced every time we ran this experiment.
Residual neural networks use skip connections across two or more layers [33]}. This causes the features in those layers to be additive with respect to the incoming features, rather than replacing them as in non-residual networks. Thus lower-level and higher-level representations tend to be more spread out across the network, rather than being confined to lower and higher layers, respectively. This would explain why model completion in residual networks is more independent of the location of the layer.

2. For A3C lower layers are often harder to complete than upper layers.
fig:a3c shows that for A3C
the lower layers are harder to complete than the higher layers since for each value of \(\alpha \)  the \(\textrm {MC-hardness}\)  decreases from left to right. However, this effect is much smaller for Rainbow (fig:rainbow) and AlexNet (fig:alexnet).
In nonresidual networks lower convolutional layers typically learn much simpler and more general features that are more task independent [10]}. Moreover, noise perturbations of lower layers have a significantly higher impact on the performance of deep learning models since noise grows exponentially through the network layers [49]}. Higher level activations are functions of the lower level ones; if a lower layer is reset, all subsequent activations will be invalidated. This could imply that the gradients on the higher layers are incorrect and thus slow down training.

3. The absolute number of parameters has a minimal effect on the hardness of model completion.
If information content is spread uniformly across the model, then model completion should be a linear function in the number of parameters that we remove. However, the number of parameters in deep models usually vary greatly between layers; the lower-level convolutional layers have 2–3 orders of magnitude fewer parameters than the higher level fully connected layers and LSTMs (see app:parameter-counts).
In order to test this explicitly, we performed an experiment on AlexNet both increasing and decreasing the total number of feature maps and fully connected units in every layer by 50%, resulting in approximately an order of magnitude difference in terms of parameters between the two models. We found that there is no significant difference in \(\textrm {MC-hardness}\)  across all threshold levels.

4. RL models are harder to complete than SL models.
Across all of our experiments, the model completion of individual layers for threshold \(\alpha = 1\)  in SL (fig:alexnet and fig:resnet50) is easier than the model completion in RL (fig:a3c, fig:rainbow, and fig:impala). In many cases the same holds from lower thresholds as well.
By resetting one layer of the model we lose access to the agent's ability to generate useful experience from interaction with the environment. As we retrain the model, the agent has to re-explore the environment to gather the right experience again, which takes extra training time.
While this effect is also present during the training procedure \(T\) , it is possible that resetting one layer makes the exploration problem harder than acting from a randomly initialized network.

5. When completing RL models access to the right experience matters.
To understand this effect better, we allow the retraining procedure access to Rainbow's replay buffer. At the start of retraining this replay buffer is filled with experience from the fully trained policy. fig:rainbow shows that the model completion hardness becomes much easier with access to this replay buffer: the three left bar plots are lower than the three right.
This result is supported by the benefits of kickstarting [50]}, where a newly trained agent gets access to an expert agent's policy. Moreover, this is consistent with findings by [51]}, who show performance benefits by adding expert trajectories to the replay buffer.

Discussion
Our results shed some initial glimpse on the model completion problem and its hardness. Our findings include: residual networks are easier to complete than non-residual networks, lower layers are often harder to complete than higher layers, and RL models are harder to complete than SL models. Nevertheless several question remain unanswered: Why is the difference in \(\textrm {MC-hardness}\)  less pronounced between lower and higher layers in Rainbow and AlexNet than in A3C? Why is the absolute number of parameters insubstantial? Are there retraining procedures that are faster than \(\mathbf {T_{1}}\) ?
Furthermore, our definition of hardness of the model completion problem creates an opportunity to modulate the hardness of model completion. For example, we could devise model architectures with the explicit objective that model completion be easy (to encourage robustness) or hard (to increase security when sharing governance through model splitting). Importantly, since eq:model-completion-difficulty can be evaluated automatically, we can readily combine this with architecture search [52]}.
Our experiments show that when we want to recover \(100\%\)  of the original performance, model completion may be quite costly: \(\sim \!\!40\%\)  of the original training costs in many settings; lower performance levels often retrain significantly faster. In scenarios where a model gets trained over many months or years, \(40\%\)  of the cost may be prohibitively expensive. However, this number also has to be taken with a grain of salt because there are many possible retraining procedures that we did not try.
The security properties of model splitting as a method for shared governance require further investigation: in addition to more effective retraining procedures, an attacker may also have access to previous activations or be able to inject their own training data.
Yet our experiments suggest that model splitting could be a promising method for shared governance. In contrast to MPC and HE it has a substantial advantage because it is cost-competitiveness with normal training and inference.
Acknowledgements
We are grateful to Wojtek Czarnecki, Simon Schmitt, Morten Dahl, Simon Osindero, Relja Arandjelovic, Carl Doersch, Ali Eslami, Koray Kavukcuoglu, Jelena Luketina, and David Krueger for valuable feedback and discussions.

Experimental details
AlexNet
We train this model for 120e3 batches, with batch size of 256. We apply batch normalization on the convolutional layers and \(\ell _2\) -regularization of 1e-4. Optimization is done using Momentum SGD with momentum of 0.9 and the learning rate schedule which is shown in tab:AlexNet-lr. Note that the learning schedule during retraining is 50% faster than during training (for \(\mathbf {T_{1}}\)  and \(\mathbf {T_{2}}\) ).
For both retraining procedures \(\mathbf {T_{1}}\)  and \(\mathbf {T_{2}}\) , we perform reset for each of the first 5 convolutional layers and the following 2 fully connected layers. tab:alexnet-parameters shows the number of trainable parameters for each of the layers.
<TABLE>
ResNet50
We perform all training and retraining procedures for 60e3 batches, with batch size of 64 and \(\ell _2\) -regularization of 1e-4. Optimization is done using Momentum SGD with momentum of 0.9 and the learning rate schedule shown in tab:ResNet50-lr.
For our experiments, we reinitialize the very first convolutional layer, as well as the first ResNet block for each of the four subsequent network sections. In the `S4 B1 -W' experiment, we leave out resetting the learned skip connection. Finally, we also reset the last fully connected layer containing logits.
<TABLE>
A3C
Each agent is trained on a single Atari level for 5e7 environment steps, over 10 seeds. We use the standard Atari architecture consisting of 3 convolutional layers, 1 fully connected layer and 2 fully connected `heads' for policy and value function. The number of parameters for each of those layers is shown in tab:a3c-parameters. For optimization, we use RMSProp optimizer with \(\epsilon = 0.1\) , decay of 0.99 and \(\alpha =\)  6e-4 that is linearly annealed to 0. For all the other hyperparameters we refer to [35]}. Finally, while calculating reported statistics we removed the following Atari levels, due to poor behaviour of the trained agent: Montezuma's Revenge, Venture, Solaris, Enduro, Battle Zone, Gravitar, Kangaroo, Skiing, Krull, Video pinball, Freeway, Centipede, and Robotank.

Rainbow
Each agent is trained on a single Atari level for 20e6 environment frames, over 3 seeds. Due to agent behaving randomly, we remove the following Atari games from our \(\textrm {MC-hardness}\)  calculations: Montezuma's Revenge, Venture, and Solaris.
For our experiments, we use the same network architecture and hyperparameters as reported in [36]} and target the first 3 convolutional layers. tab:rainbow-parameters has the total number of parameters for each of the 3 layers.

IMPALA
We train a single agent over a suite of 28 DeepMind Lab levels for a total of 1 billion steps over all the environments, over 5 seeds. During training we apply population based training (PBT; [44]}) with population of size 12, in order to evolve the entropy cost, learning rate and \(\epsilon \)  for RMSProp. For language modelling a separated LSTM channel is used. In the results we report, we removed two DeepMind Lab levels due to poor behavior of the trained agent: `language_execute_random_task' and `psychlab_visual_search'. All the other hyperparameters are retained from [37]}.
For our experiments, we reinitialize the first convolutional layer in each of the 3 ResNet sections, as well as the final fully connected layer and the weights of the LSTM. The absolute number of parameters for each of the aforementioned layers is available in tab:impala-parameters.
<FIGURE>
Parameter counts
<TABLE> 
<TABLE> 
<TABLE> 
<TABLE> 
<TABLE>
Experimental data
AlexNet
<TABLE>
 
<TABLE>
 
<TABLE>
 
<TABLE>

ResNet50
<TABLE>
 
<TABLE>
 
<TABLE>
 
<TABLE>

A3C
Retraining procedure \(\mathbf {T_{1}}\)
<TABLE>
 
<TABLE>
 
<TABLE>

Retraining procedure \(\mathbf {T_{2}}\)
<TABLE>
 
<TABLE>
 
<TABLE>

Rainbow
<TABLE>
 
<TABLE>
 
<TABLE>

IMPALA reinforcement learning agent
<TABLE>
 
<TABLE>
 
<TABLE>
