user: text: Write a concise one-sentence TLDR summary of the scientific paper content below.

Title: Learning Implicitly Recurrent CNNs Through Parameter Sharing

Paper content:
We introduce a parameter sharing scheme, in which different layers of a convolutional neural network (CNN) are defined by a learned linear combination of parameter tensors from a global bank of templates.
Restricting the number of templates yields a flexible hybridization of traditional CNNs and recurrent networks.
Compared to traditional CNNs, we demonstrate substantial parameter savings on standard image classification tasks, while maintaining accuracy.
Our simple parameter sharing scheme, though defined via soft weights, in practice often yields trained networks with near strict recurrent structure; with negligible side effects, they convert into networks with actual loops.
Training these networks thus implicitly involves discovery of suitable recurrent architectures.
Though considering only the aspect of recurrent links, our trained networks achieve accuracy competitive with those built using state-of-the-art neural architecture search (NAS) procedures.
Our hybridization of recurrent and convolutional networks may also represent a beneficial architectural bias.
Specifically, on synthetic tasks which are algorithmic in nature, our hybrid networks both train faster and extrapolate better to test examples outside the span of the training set.
The architectural details of convolutional neural networks (CNNs) have undergone rapid exploration and improvement via both human hand-design BID33 BID11 BID13 BID45 and automated search methods BID46 ).
Yet, this vast array of work limits itself to a circuit-like view of neural networks.
Here, a CNN is regarded as a fixed-depth feed-forward circuit, with a distinct parameter governing each internal connection.
These circuits are often trained to perform tasks which, in a prior era, might have been (less accurately) accomplished by running a traditional computer program coded by humans.
Programs, and even traditional hardware circuits, have a more reusable internal structure, including subroutines or modules, loops, and associated control flow mechanisms.We bring one aspect of such modularity into CNNs, by making it possible to learn a set of parameters that is reused across multiple layers at different depths.
As the pattern of reuse is itself learned, our scheme effectively permits learning the length (iteration count) and content of multiple loops defining the resulting CNN.
We view this approach as a first step towards learning neural networks with internal organization reminiscent of computer programs.
Though we focus solely on loop-like structures, leaving subroutines and dynamic control flow to future work, this simple change suffices to yield substantial quantitative and qualitative benefits over the standard baseline CNN models.While recurrent neural networks (RNNs) possess a loop-like structure by definition, their loop structure is fixed a priori, rather than learned as part of training.
This can actually be a disadvantage in the event that the length of the loop is mismatched to the target task.
Our parameter sharing scheme for CNNs permits a mix of loops and feed-forward layers to emerge.
For example, trained with our scheme, a 50-layer CNN might learn a 2-layer loop that executes 5 times between layers 10 and 20, a 3-layer loop that runs 4 times from layers 30 to 42, while leaving the remaining layers to assume independent parameter sets.
Our approach generalizes both CNNs and RNNs, creating a hybrid.
where parameter templates T (1) , T (2) are shared among each layer i, which now only contains a 2-dimensional parameter α
(i) .
Weights W
(i) (no longer parameters, illustrated with dotted boxes) used by layer i are generated from α
(i) and templates T (1) , T (2) .
Right: If weights W
(i) are outputs of a linear function (as in our method), learning parameter templates can be viewed as learning layer templates, offering a new (although equivalent) perspective for the middle diagram.
Non-linearities are omitted for simplicity.
FIG0 diagrams the parameter sharing scheme facilitating this hybridization.
Inspired by dictionary learning, different network layers share, via weighted combination, global parameter templates.
This re-parameterization is fully differentiable, allowing learning of sharing weights and template parameters.
Section 3 elaborates, and also introduces tools for analyzing learned loop structures.Section 4 demonstrates advantages of our hybrid CNNs across multiple experimental settings.
Taking a modern CNN design as a baseline, and re-parameterizing it according to our scheme improves:• Parameter efficiency.
Here, we experiment with the standard task of image classification using modern residual networks BID11 BID41 .
This task is a good proxy for general usefulness in computer vision, as high-performance classification architectures often serve as a backbone for many other vision tasks, such as semantic segmentation BID1 BID44 .
Our parameter sharing scheme drastically reduces the number of unique parameters required to achieve a given accuracy on CIFAR BID20 ) or ImageNet (Russakovsky et al., 2015 classification tasks.
Re-parameterizing a standard residual network with our scheme cuts parameters, without triggering any drop in accuracy.
This suggests that standard CNNs may be overparameterized in part because, by design (and unlike RNNs), they lack capacity to learn reusable internal operations.•
Extrapolation and generalization. Here
, we explore whether our hybrid networks expand the class of tasks that one can expect to train neural networks to accomplish. This
line of inquiry, focusing on synthetic tasks, shares motivations with work on Neural Turing Machines BID5 . Specifically
, we would like neural networks to be capable of learning to perform tasks for which there are concise traditional solution algorithms. BID5 uses sorting
as an example task. As we examine an
extension of CNNs, our tasks take the form of queries about planar graphs encoded as image input. On these tasks,
we observe improvements to both generalization ability and learning speed for our hybrid CNNs, in comparison to standard CNNs or RNNs. Our parameter sharing
scheme, by virtue of providing an architectural bias towards networks with loops, appears to assist in learning to emulate traditional algorithms.An additional side effect, seen in practice in many of our experiments, is that two different learned layers often snap to the same parameter values. That is, layers i and
j, learn coefficient vectors α DISPLAYFORM0 and α (j) (see FIG0 ) that
converge to be the same (up to scaling). This is a form of architecture
discovery, as it permits representation of the CNN as a loopy wiring diagram between repeated layers. Section 4.3 presents example results
. We also draw comparisons to existing
neural architec-ture search (NAS) techniques. By simply learning recurrent structure
as byproduct of training with standard stochastic gradient descent, we achieve accuracy competitive with current NAS procedures.Before delving into the details of our method, Section 2 provides additional context in terms of prior work on recurrent models, parameter reduction techniques, and program emulation. Sections 3 and 4 describe our hybrid shared-parameter
CNN, experimental setup, and results. Section 5 concludes with commentary on our results and
possible future research pathways. 1 2 RELATED WORK Recurrent variants of CNNs are used extensively
for visual tasks. Recently, BID42 propose utilizing a convolutional LSTM BID32 as
a generic feedback architecture. RNN and CNN combinations have been used for scene labeling BID26
, image captioning with attention BID39 , and understanding video BID3 , among others. These works combine CNNs and RNNs at a coarse scale, and in a fixed
hand-crafted manner. In contrast, we learn the recurrence structure itself, blending it
into the inner workings of a CNN.Analysis of residual networks BID11 reveals possible connections to recurrent networks stemming from their design BID21 . BID7 provide evidence that residual networks learn to iteratively
refine feature representations, making an analogy between a very deep residual network and an unrolled loop. BID17 further explore this connection, and experiment with training
residual networks in which some layers are forced to share identical parameters. This hard parameter sharing scheme again builds a predetermined recurrence
structure into the network. It yields successfully trained networks, but does not exhibit the type of
performance gains that Section 4 demonstrates for our soft parameter sharing scheme.Closely related to our approach is the idea of hypernetworks BID9 , in which one part of a neural network is parameterized by another neural network. Our shared template-based reparameterization could be viewed as one simple
choice of hypernetwork implementation. Perhaps surprisingly, this class of ideas has not been well explored for the
purpose of reducing the size of neural networks. Rather, prior work has achieved parameter reduction through explicit representation
bottlenecks BID15 , sparsifying connection structure BID27 BID45 , and pruning trained networks .Orthogonal to the question of efficiency, there is substantial interest in extending
neural networks to tackle new kinds of tasks, including emulation of computer programs. Some approach this problem using additional supervision in the form of execution traces
(Reed & de Freitas, 2016; BID0 , while other focus on development of network architectures that can learn from input-output pairs alone BID5 BID29 BID43 BID36 . Our experiments on synthetic tasks fall into the latter camp. At the level of architectural
strategy, BID36 benefit from changing the form of activation
function to bias the network towards correctly extrapolating common mathematical formulae. We build in a different implicit bias, towards learning iterative procedures within a CNN,
and obtain a boost on correctly emulating programs.
In this work, we take a step toward more modular and compact CNNs by extracting recurrences from feed-forward models where parameters are shared among layers.
Experimentally, parameter sharing yields models with lower error on CIFAR and ImageNet, and can be used for parameter reduction by training in a regime with fewer parameter templates than layers.
Moreover, we observe that parameter sharing often leads to different layers being functionally equivalent after training, enabling us to collapse them into recurrent blocks.
Results on an algorithmic task suggest that our shared parameter structure beneficially biases extrapolation.
We gain a more flexible form of behavior typically attributed to RNNs, as our networks adapt better to out-of-domain examples.
Our form of architecture discovery is also competitive with neural architecture search (NAS) algorithms, while having a smaller training cost than state-of-the-art gradient-based NAS.As the only requirement for our method is for a network to have groups of layers with matching parameter sizes, it can be applied to a plethora of CNN model families, making it a general technique with negligible computational cost.
We hope to raise questions regarding the rigid definitions of CNNs and RNNs, and increase interest in models that fall between these definitions.
Adapting our method for models with non-uniform layer parameter sizes BID13 BID45 might be of particular future interest.A ADDITIONAL RESULTS FOR IMPLICIT RECURRENCES Section 4.3 presents an example of implicit recurrences and folding of a SWRN 28-10-4 trained on CIFAR-10, where, for example, the last 6 layers in the second stage of the network fold into 2 layers with a self-loop.
Figure 6 presents an additional example, where non-trivial recurrences (unlike the one in Figure 4 ) emerge naturally, resulting in a model that is rich in structure.
− 2 = 10 layers) trained with soft parameter sharing on CIFAR-10.
Each stage (originally with 12 layers -the first two do not participate in parameter sharing) can be folded to yield blocks with complex recurrences.
For clarity, we use colors to indicate the computational flow: red takes precedence over green, which in turn has precedence over blue.
Colored paths are only taken once per stage.
Although not trivial to see, recurrences in each stage's folded form are determined by row/column repetitions in the respective Layer Similarity Matrix.
For example, for stage 2 we have S5,3 ≈ S6,4 ≈ 1, meaning that layers 3, 4, 5 and 6 can be folded into layers 3 and 4 with a loop (captured by the red edge).
The same holds for S7,1, S8,2, S9,3 and S10,4, hence after the loop with layers 3 and 4, the flow returns to layer 1 and goes all the way to layer 4, which generates the stage's output.
Even though there is an approximation when folding the network (in this example, we are tying layers with similarity close to 0.8), the impact on the test error is less than 0.3%.
Also note that the folded model has a total of 24 layers (20 in the stage diagrams, plus 4 which are not shown, corresponding to the first layer of the network and three 1 × 1 convolutions in skip-connections), instead of the original 40.
Figure 7: LSMs of a SWRN 40-8-8 (composed of 3 stages, each with 10 layers sharing 8 templates) trained on CIFAR-10 for 5 runs with different random seeds.
Although the LSMs differ across different runs, hard parameter sharing can be observed in all cases (off-diagonal elements close to 1, depicted by white), characterizing implicit recurrences which would enable network folding.
Moreover, the underlying structure is similar across runs, with hard sharing typically happening among layers i and i + 2, leading to a "chessboard" pattern.

assistant: text: We propose a method that enables CNN folding to create recurrent connections