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

Title: Backprop with Approximate Activations for Memory-efficient Network Training

Paper content:
With innovations in architecture design, deeper and wider neural network models deliver improved performance on a diverse variety of tasks.
But the increased memory footprint of these models presents a challenge during training, when all intermediate layer activations need to be stored for back-propagation.
Limited GPU memory forces practitioners to make sub-optimal choices: either train inefficiently with smaller batches of examples; or limit the architecture to have lower depth and width, and fewer layers at higher spatial resolutions.
This work introduces an approximation strategy that significantly reduces a network's memory footprint during training, but has negligible effect on training performance and computational expense.
During the forward pass, we replace activations with lower-precision approximations immediately after they have been used by subsequent layers, thus freeing up memory.
The approximate activations are then used during the backward pass.
This approach limits the accumulation of errors across the forward and backward pass---because the forward computation across the network still happens at full precision, and the approximation has a limited effect when computing gradients to a layer's input.
Experiments, on CIFAR and ImageNet, show that using our approach with 8- and even 4-bit fixed-point approximations of 32-bit floating-point activations has only a minor effect on training and validation performance, while affording significant savings in memory usage.
Deeper neural network models are able to express more complex functions, and recent results have shown that with the use of residual BID7 and skip BID9 connections to address vanishing gradients, such networks can be trained effectively to leverage this additional capacity.
As a result, the use of deeper network architectures has become prevalent, especially for visual inference tasks BID8 .
The shift to larger architectures has delivered significant improvements in performance, but also increased demand on computational resources.
In particular, deeper network architectures require significantly more on-device memory during training-much more so than for inference.
This is because training requires retaining the computed activations of all intermediate layers since they are needed to compute gradients during the backward pass.The increased memory footprint means fewer training samples can fit in memory and be processed as a batch on a single GPU.
This is inefficient: smaller batches are not able to saturate all available parallel cores, especially because computation in "deeper" architectures is distributed to be more sequential.
Moreover, smaller batches also complicate the use of batch-normalization BID11 , since batch statistics are now computed over fewer samples making training less stable.
These considerations often force the choice of architecture to be based not just on optimality for inference, but also practical feasibility for training-for instance, deep residual networks for large images drop resolution early, so that most layers have smaller sized outputs.While prior work to address this has traded-off memory for computation BID13 BID4 BID3 , their focus has been on enabling exact gradient computation.
However, since stochastic gradient descent (SGD) inherently works with noisy gradients at each iteration, we propose an algorithm that computes reasonably approximate gradients, while significantly reducing a network's memory footprint and with virtually no additional computational cost.
Our work is motivated by distributed training algorithms Figure 1 : Proposed Approach.
We show the computations involved in the forward and backward pass during network training for a single "pre-activation" layer, with possible residual connections.
The forward pass is exact, but we discard full-precision activations right after use by subsequent layers (we store these in common global buffers, and overwrite activations once they have been used and no longer needed for forward computation).
Instead, we store a low-precision approximation of the activations which occupies less memory, and use these during back-propagation.
Our approach limits errors in the gradient flowing back to the input of a layer, and thus accumulation of errors across layers.
Since our approximation preserves the signs of activations, most of the computations along the path back to the input are exact-with the only source of error being the use of the approximate activations while back-propagating through the variance-computation in batch-normalization.that succeed despite working with approximate and noisy gradients aggregated across multiple devices BID15 BID2 Seide et al., 2014; Wen et al., 2017) .
We propose using low-precision approximate activations-that require less memory-to compute approximate gradients during back-propagation (backprop) on a single device.
Note that training with a lowerprecision of 16-instead of 32-bit floating-point representations is not un-common.
But this lower precision is used for all computation, and thus allows only for a modest lowering of precision, since the approximation error builds up across the forward and then backward pass through all layers.In this work, we propose a new backprop implementation that performs the forward pass through the network at full-precision, and incurs limited approximation error during the backward pass.
We use the full-precision version of a layer's activations to compute the activations of subsequent layers.
However, once these activations have been used in the forward pass, our method discards them and stores a low-precision approximation instead.
During the backward pass, gradients are propagated back through all the layers at full precision, but instead of using the original activations, we use their low-precision approximations.
As a result, we incur an approximation error at each layer when computing the gradients to the weights from multiplying the incoming gradient with the approximate activations, but ensure the error in gradients going back to the previous layer is minimal.Our experimental results show that even using only 4-bit fixed-point approximations, for the original 32-bit floating-point activations, causes only minor degradation in training quality.
This significantly lowers the memory required for training, which comes essentially for "free"-incurring only the negligible additional computational cost of converting activations to and from low precision representations.
Our memory-efficient version of backprop is thus able to use larger batch sizes at each iteration-to fully use available parallelism and compute stable batch statistics-and makes it practical for researchers to explore the use of much larger and deeper architectures than before.
We introduced a new algorithm for approximate gradient computation in neural network training, that significantly reduces the amount of required on-device memory.
Our experiments show that this comes at a minimal cost in terms of both quality of the learned models, and computational expense.
With a lower memory footprint, our method allows training with larger batches in each iterationimproving efficiency and stability-and exploration of deeper architectures that were previously impractical to train.
We will release our reference implementation on publication.Our method shows that SGD is reasonably robust to working with approximate activations.
While we used an extremely simple approximation strategy-uniform quantization-in this work, we are interested in exploring whether more sophisticated techniques-e.g., based on random projections or vector quantization-can provide better trade-offs, especially if informed by statistics of gradients and errors from prior iterations.
We are also interested in investigating whether our approach to partial approximation can be utilized in other settings, especially to reduce inter-device communication for distributed training with data or model parallelism.

assistant: text: An algorithm to reduce the amount of memory required for training deep networks, based on an approximation strategy.