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

Title: Scalable Model Compression by Entropy Penalized Reparameterization

Paper content:
We describe a simple and general neural network weight compression approach, in which the network parameters (weights and biases) are represented in a “latent” space, amounting to a reparameterization.
This space is equipped with a learned probability model, which is used to impose an entropy penalty on the parameter representation during training, and to compress the representation using a simple arithmetic coder after training.
Classification accuracy and model compressibility is maximized jointly, with the bitrate--accuracy trade-off specified by a hyperparameter.
We evaluate the method on the MNIST, CIFAR-10 and ImageNet classification benchmarks using six distinct model architectures.
Our results show that state-of-the-art model compression can be achieved in a scalable and general way without requiring complex procedures such as multi-stage training.
Artificial neural networks (ANNs) have proven to be highly successful on a variety of tasks, and as a result, there is an increasing interest in their practical deployment.
However, ANN parameters tend to require a large amount of space compared to manually designed algorithms.
This can be problematic, for instance, when deploying models onto devices over the air, where the bottleneck is often network speed, or onto devices holding many stored models, with only few used at a time.
To make these models more practical, several authors have proposed to compress model parameters (Han et al., 2015; Louizos, Ullrich, et al., 2017; Molchanov et al., 2017; Havasi et al., 2018) .
While other desiderata often exist, such as minimizing the number of layers or filters of the network, we focus here simply on model compression algorithms that
1. minimize compressed size while maintaining an acceptable classification accuracy,
2. are conceptually simple and easy to implement, and
3. can be scaled easily to large models.
Classic data compression in a Shannon sense (Shannon, 1948) requires discrete-valued data (i.e., the data can only take on a countable number of states) and a probability model on that data known to both sender and receiver.
Practical compression algorithms are often lossy, and consist of two steps.
First, the data is subjected to (re-)quantization.
Then, a Shannon-style entropy coding method such as arithmetic coding (Rissanen and Langdon, 1981 ) is applied to the discrete values, bringing them into a binary representation which can be easily stored or transmitted.
Shannon's source coding theorem establishes the entropy of the discrete representation as a lower bound on the average length of this binary sequence (the bit rate), and arithmetic coding achieves this bound asymptotically.
Thus, entropy is an excellent proxy for the expected model size.
The type of quantization scheme affects both the fidelity of the representation (in this case, the precision of the model parameters, which in turn affects the prediction accuracy) as well as the bit rate, since a reduced number of states coincides with reduced entropy.
ANN parameters are typically represented as floating point numbers.
While these technically have a finite (but large) number of states, the best results in terms of both accuracy and bit rate are typically achieved for a significantly reduced number of states.
Existing approaches to model compression often acknowledge this by quantizing each individual linear filter coefficient in an ANN to a small number of pre-determined values (Louizos, Reisser, et al., 2018; Baskin et al., 2018; F. Li et al., 2016) .
This is known as scalar quantization (SQ).
Other methods explore vector quantization (VQ), which is closely related to k-means clustering, in which each vector of filter coefficients is quantized jointly (Chen, J. Wilson, et al., 2015; Ullrich et al., 2017) .
This is equivalent to enumerating a finite set of representers Figure 1 : Visualization of representers in scalar quantization vs. reparameterized quantization.
The axes represent two different model parameters (e.g., linear filter coefficients).
Small black dots are samples of the model parameters, red and blue discs are the representers.
Left: in scalar quantization, the representers must be given by a Kronecker product of scalar representers along the cardinal axes, even though the distribution of samples may be skewed.
Right: in reparameterized scalar quantization, the representers are still given by a Kronecker product, but in a transformed (here, rotated) space.
This allows a better adaptation of the representers to the parameter distribution.
(representable vectors), while in SQ the set of representers is given by the Kronecker product of representable scalar elements.
VQ is much more general than SQ, in the sense that representers can be placed arbitrarily: if the set of useful filter vectors all live in a subset of the entire space, there is no benefit in having representers outside of that subset, which may be unavoidable with SQ (Figure 1 , left).
Thus, VQ has the potential to yield better results, but it also suffers from the "curse of dimensionality": the number of necessary states grows exponentially with the number of dimensions, making it computationally infeasible to perform VQ for much more than a handful of dimensions.
One of the key insights leading to this paper is that the strengths of SQ and VQ can be combined by representing the data in a "latent" space.
This space can be an arbitrary rescaling, rotation, or otherwise warping of the original data space.
SQ in this space, while making quantization computationally feasible, can provide substantially more flexibility in the choice of representers compared to the SQ in the data space (Figure 1, right) .
This is in analogy to recent image compression methods based on autoencoders (Ballé, Laparra, et al., 2016; Theis et al., 2017) .
The contribution of this paper is two-fold.
First, we propose a novel end-to-end trainable model compression method that uses scalar quantization and entropy penalization in a reparameterized space of model parameters.
The reparameterization allows us to use efficient SQ, while achieving flexibility in representing the model parameters.
Second, we provide state-of-the-art results on a variety of network architectures on several datasets.
This demonstrates that more complicated strategies involving pretraining, multi-stage training, sparsification, adaptive coding, etc., as employed by many previous methods, are not necessary to achieve good performance.
Our method scales to modern large image datasets and neural network architectures such as ResNet-50 on ImageNet.
Existing model compression methods are typically built on a combination of pruning, quantization, or coding.
Pruning involves sparsifying the network either by removing individual parameters or higher level structures such as convolutional filters, layers, activations, etc.
Various strategies for pruning weights include looking at the Hessian (Cun et al., 1990) or just their p norm (Han et al., 2015) .
Srinivas and Babu (2015) focus on pruning individual units, and H. Li et al. (2016) prunes convolutional filters.
Louizos, Ullrich, et al. (2017) and Molchanov et al. (2017) (Louizos, Ullrich, et al., 2017) 18.2 KB (58x) 1.8% Bayesian Compression (GHS) (Louizos, Ullrich, et al., 2017) 18.0 KB (59x) 2.0% Sparse Variational Dropout (Molchanov et al., 2017) 9.38 KB (113x) 1.8% Our Method (SQ) 8.56 KB (124x) 1.9%
LeNet5-Caffe (MNIST) Uncompressed 1.72 MB 0.7% Sparse Variational Dropout (Molchanov et al., 2017) 4.71 KB (365x) 1.0% Bayesian Compression (GHS) (Louizos, Ullrich, et al., 2017) 2.23 KB (771x) 1.0% Minimal Random Code Learning (Havasi et al., 2018) 1.52 KB (1110x) 1.0% Our Method (SQ) 2.84 KB (606x) 0.9%
We describe a simple model compression method built on two ingredients: joint (i.e., end-to-end) optimization of compressibility and classification performance in only a single training stage, and reparameterization of model parameters, which increases the flexibility of the representation over scalar quantization, and is applicable to arbitrary network architectures.
We demonstrate that stateof-the-art model compression performance can be achieved with this simple framework, outperforming methods that rely on complex, multi-stage training procedures.
Due to its simplicity, the approach is particularly suitable for larger models, such as VGG and especially ResNets.
In future work, we may consider the potential benefits of even more flexible (deeper) parameter decoders.

assistant: text: An end-to-end trainable model compression method optimizing accuracy jointly with the expected model size.