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

Title: Improving generalization by regularizing in $L^2$ function space

Paper content:
Learning rules for neural networks necessarily include some form of regularization.
Most regularization techniques are conceptualized and implemented in the space of parameters.
However, it is also possible to regularize in the space of functions.
Here, we propose to measure networks in an $L^2$ Hilbert space, and test a learning rule that regularizes the distance a network can travel through $L^2$-space each update.
This approach is inspired by the slow movement of gradient descent through parameter space as well as by the natural gradient, which can be derived from a regularization term upon functional change.
The resulting learning rule, which we call Hilbert-constrained gradient descent (HCGD), is thus closely related to the natural gradient but regularizes a different and more calculable metric over the space of functions.
Experiments show that the HCGD is efficient and leads to considerably better generalization.
Large neural networks can overfit to training data, but we desire networks that instead learn general aspects that apply to new data.
A learning rule can encourage generalization through regularization, which may be implicit to the learning rule or explicitly added to the cost function.
Many regularization techniques introduce penalties in the space of network parameters.
Canonical examples include weight decay and the constraints upon parameter movement inherent to Stochastic Gradient Descent (SGD).
Ultimately, however, it is the complexity of the parameterized function that we seek to regularize, not pf the parameters themselves.
A well-known example of this more direct approach is the natural gradient, which constrains how much the output distribution of a network can change due to an update.Here, we introduce a new learning rule that, like the natural gradient, limits how much the output function can change during learning.
However, we use a different and more calculable metric over function space: the expected L 2 norm.
Since the L 2 -space is a Hilbert space, we term the rule Hilbert-constrained gradient descent (HCGD).The
interpretation of the natural gradient as resulting from regularization competes in the literature with many other interpretations and justifications. In
order to establish a foundation for the Hilbert constraint as analogous to the natural gradient, we begin by reviewing and discussing the natural gradient.
Neural networks encode functions, and it is important to consider the behavior of optimizers through the space of possible functions.
The L 2 Hilbert space defined over distribution of input examples is a tractable and useful space for analysis.
In this paper we propose to regularize the change in L 2 space between successive updates.
The idea is to limit the movement of the function, just as gradient descent limits movement of the parameters.
Our resulting learning rule, Hilbert-constrained gradient descent (HCGD), increases test performance on standard image classification architectures.
We hope that this work inspires more thought and analysis of behavior in L 2 -space.A alternative explanation of our algorithm is that it penalizes directions that are very sensitive controls of the outputs, similar to the natural gradient, while still allowing learning.
In addition, since we evaluate the change in L 2 -space and the gradient on different data, HCGD asks the model to learn from current examples only in ways that will not affect what has already been learned from other examples.
These intuitions are equivalent to the idea of limiting changes in L 2 -space.Given these empirical results, it would be desirable to theoretically prove better generalization bounds for a method regularized in L 2 -space.
One promising framework is stability analysis, which has recently been applied to establish some bounds on the generalization error of SGD itself BID7 ).
It can be shown that generalization error is bounded by the stability of an algorithm, defined as the expected difference of the loss when two networks are trained on datasets that are identical except for one example.
BID7 analyzes the stability of SGD in parameter space, then uses a Lipschitz condition to move to function space and bound the stability of the error.
We expect that bounding the movement through L 2 -space leads to increased error stability compared to bounding movement through parameter space (as is done by SGD), simply by removing reliance on the assumed Lipschitz condition.
We leave a proof of this idea to later work.It interesting to ask if there is support in neuroscience for learning rules that diminish the size of changes when that change would have a large effect on other tasks.
It is unlikely that the nervous system performs precisely the natural gradient or HCGD, but there is some evidence that some analog is in play.
One otherwise perplexing finding is that behavioral learning rates in motor tasks are dependent on the direction of an error but independent of the magnitude of that error BID6 ).
This result is not expected by most models of gradient descent, but would be expected if the size of the change in the output distribution (i.e. behavior) were regulated to be constant.
Regularization upon behavior change (rather than synaptic change) would predict that neurons that are central to many actions, like neurons in motor pools of the spinal cord, would learn very slowly after early development, despite the fact that their gradient to the error on any one task (if indeed it is calculated) is likely to be quite large.
Given our general resistance to overfitting during learning, and the great variety of roles of neurons, it is likely that some type of regularization of behavioral and perceptual change is at play.

assistant: text: It's important to consider optimization in function space, not just parameter space. We introduce a learning rule that reduces distance traveled in function space, just like SGD limits distance traveled in parameter space.