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

Title: Deep Gradient Boosting -- Layer-wise Input Normalization of Neural Networks

Paper content:
Stochastic gradient descent (SGD) has been the dominant optimization method for training deep neural networks due to its many desirable properties.
One of the more remarkable and least understood quality of SGD is that it generalizes relatively well
on unseen data even when the neural network has millions of parameters.
We hypothesize that in certain cases it is desirable to relax its intrinsic generalization properties and introduce an extension of SGD called deep gradient boosting (DGB).
The key idea of DGB is that back-propagated gradients inferred using the chain rule can be viewed as pseudo-residual targets of a gradient boosting problem.
Thus at each layer of a neural network the weight update is calculated by solving the corresponding boosting problem using a linear base learner.
The resulting weight update formula can also be viewed as a normalization procedure of the data that arrives at each layer during the forward pass.
When implemented as a separate input normalization layer (INN) the new architecture shows improved performance on image recognition tasks when compared to the same architecture without normalization layers.
As opposed to batch normalization (BN), INN has no learnable parameters however it matches its performance on CIFAR10 and ImageNet classification tasks.
Boosting, along side deep learning, has been a very successful machine learning technique that consistently outperforms other methods on numerous data science challenges.
In a nutshell, the basic idea of boosting is to sequentially combine many simple predictors in such a way that their combined performance is better than each individual predictor.
Frequently, these so called weak learners are implemented as simple decision trees and one of the first successful embodiment of this idea was AdaBoost proposed by Freund & Schapire (1997) .
No too long after this, Breiman et al. (1998) and Friedman (2001) made the important observation that AdaBoost performs in fact a gradient descent in functional space and re-derived it as such.
Friedman (2001) went on to define a general statistical framework for training boosting-like classifiers and regressors using arbitrary loss functions.
Together with Mason et al. (2000) they showed that boosting minimizes a loss function by iteratively choosing a weak learner that approximately points in the negative gradient direction of a functional space.
Neural networks, in particular deep neural nets with many layers, are also trained using a form of gradient descent.
Stochastic gradient descent (SGD) (Robbins & Monro, 1951) has been the main optimization method for deep neural nets due to its many desirable properties like good generalization error and ability to scale well with large data sets.
At a basic level, neural networks are composed of stacked linear layers with differentiable non-linearities in between.
The output of the last layer is then compared to a target value using a differentiable loss function.
Training such a model using SGD involves updating the network parameters in the direction of the negative gradient of the loss function.
The crucial step of this algorithm is calculating the parameter gradients and this is efficiently done by the backpropagation algorithm (Rumelhart et al., 1988; Werbos, 1974) .
Backpropagation has many variations that try to achieve either faster convergence or better generalization through some form of regularization.
However, despite superior training outcomes, accelerated optimization methods such as Adam (Kingma & Ba, 2015) , Adagrad (Duchi et al., 2011) or RMSprop (Graves, 2013) have been found to generalize poorly compared to stochastic gradient descent (Wilson et al., 2017) .
Therefore even before using an explicit regularization method, like dropout (Srivastava et al., 2014) or batch normalization (Ioffe & Szegedy, 2015) , SGD shows very good performance on validation data sets when compared to other methods.
The prevalent explanation for this empirical observation has been that SGD prefers "flat" over "sharp" minima, which in turn makes these states robust to perturbations.
Despite its intuitive appeal, recent work by (Dinh et al., 2017) cast doubt on this explanation.
This work introduces a simple extension of SGD by combining backpropagation with gradient boosting.
We propose that each iteration of the backpropagation algorithm can be reinterpreted by solving, at each layer, a regularized linear regression problem where the independent variables are the layer inputs and the dependent variables are gradients at the output of each layer, before non-linearity is applied.
We call this approach deep gradient boosting (DGB), since it is effectively a layer-wise boosting approach where the typical decision trees are replaced by linear regressors.
Under this model, SGD naturally emerges as an extreme case where the network weights are highly regularized, in the L2 norm sense.
We hypothesize that for some learning problems the regularization criteria doesn't need to be too strict.
These could be cases where the data domain is more restricted or the learning task is posed as a matrix decomposition or another coding problem.
Based on this idea we further introduce INN, a novel layer normalization method free of learnable parameters and show that it achieves competitive results on benchmark image recognition problems when compared to batch normalization (BN).
This work introduces Deep Gradient Boosting (DGB), a simple extension of Stochastic Gradient Descent (SGD) that allows for finer control over the intrinsic generalization properties of SGD.
We empirically show how DGB can outperform SGD in certain cases among a variety of classification and regression tasks.
We then propose a faster approximation of DGB and extend it to convolutional layers (FDGB).
Finally, we reinterpret DGB as a layer-wise algebraic manipulation of the input data and implement it as a separate normalization layer (INN).
We then test INN on image classification tasks where its performance proves to be on par with batch normalization without the need for additional parameters.
A APPENDIX Table A4 : Performance on the Air data set measured as root mean squared error.
has singular values of the form
Let X = U ΣV T be the singular value decomposition of X then:
values of the form
Let X = U ΣV T be the singular value decomposition of X then:
For this experiment we used a version of the VGG11 network introduced by Simonyan & Zisserman (2014) that has 8 convolutional layers followed by a linear layer with 512 ReLU nodes, a dropout layer with probability 0.5 and then a final softmax layer for assigning the classification probabilities.
A second version of this architecture (VGG11 BN) has batch normalization applied at the output of each convolutional layer, before the ReLU activation as recommended by Ioffe & Szegedy (2015) We modified this architecture by first removing all the batch normalization and dropout layers.
We then either replaced all convolutional and linear layers with ones that implement the fast version of DGB for the FDGB(l) architecture or added INN(l) layers in front of each of the original convolutional and linear layers.
Both FDGB(l) and INN(l) models implement input normalization based on the left pseudo-inverse (see Eq. 12 & 16) in order to take advantage of its regularization effect.
All weights were initialized according to Simonyan & Zisserman (2014) and were trained using stochastic gradient descent with momentum 0.9 and batch size 128.
For the FDGB(l) model the gradients were calculated according to Eq. 12 for linear and 13 for convolutional layers.
Training was started with learning rate 0.1 and reduced to 0.01 after 250 epochs and continued for 350 epochs.
All experiments were repeated 10 times with different random seeds and performance was reported on the validation set as mean accuracy ± standard deviation.

assistant: text: What can we learn about training neural networks if we treat each layer as a gradient boosting problem?