Real-Time Adaptive Image Compression

Real-Time Adaptive Image Compression

Oren Rippel    Lubomir Bourdev

Real-Time Adaptive Image Compression: Supplementary Material

Oren Rippel    Lubomir Bourdev
Abstract

We present a machine learning-based approach to lossy image compression which outperforms all existing codecs, while running in real-time.

Our algorithm typically produces files 2.5 times smaller than JPEG and JPEG 2000, 2 times smaller than WebP, and 1.7 times smaller than BPG on datasets of generic images across all quality levels. At the same time, our codec is designed to be lightweight and deployable: for example, it can encode or decode the Kodak dataset in around 10ms per image on GPU.

Our architecture is an autoencoder featuring pyramidal analysis, an adaptive coding module, and regularization of the expected codelength. We also supplement our approach with adversarial training specialized towards use in a compression setting: this enables us to produce visually pleasing reconstructions for very low bitrates.

boring formatting information, machine learning, ICML

1 Introduction

Streaming of digital media makes 70% of internet traffic, and is projected to reach 80% by 2020 (CIS, 2015). However, it has been challenging for existing commercial compression algorithms to adapt to the growing demand and the changing landscape of requirements and applications. While digital media are transmitted in a wide variety of settings, the available codecs are “one-size-fits-all”: they are hard-coded, and cannot be customized to particular use cases beyond high-level hyperparameter tuning.

In the last few years, deep learning has revolutionized many tasks such as machine translation, speech recognition, face recognition, and photo-realistic image generation. Even though the world of compression seems a natural domain for machine learning approaches, it has not yet benefited from these advancements, for two main reasons. First, our deep learning primitives, in their raw forms, are not well-suited to construct representations sufficiently compact. Recently, there have been a number of important efforts by Toderici et al. (2015, 2016), Theis et al. (2016), Ballé et al. (2016), and Johnston et al. (2017) towards alleviating this: see Section 2.2. Second, it is difficult to develop a deep learning compression approach sufficiently efficient for deployment in environments constrained by computation power, memory footprint and battery life.

Codec RGB file size (kb) YCbCr file size (kb) Encode time (ms) Decode time (ms)
Ours 21.4 (100%) 17.4 (100%) 8.6 9.9
JPEG 65.3 (304%) 43.6 (250%) 18.6 13.0
JP2 54.4 (254%) 43.8 (252%) 367.4 80.4
WebP 49.7 (232%) 37.6 (216%) 67.0 83.7
Table 1: Performance of different codecs on the RAISE-1k dataset for a representative MS-SSIM value of 0.98 in both RGB and YCbCr color spaces. Comprehensive results can be found in Section 5. We emphasize our codec was run on GPU.

JPEG
0.0826 BPP (7.5% bigger)
JPEG 2000
0.0778 BPP
WebP
0.0945 BPP (23% bigger)
Ours
0.0768 BPP
JPEG
0.111 BPP (10% bigger)
JPEG 2000
0.102 BPP
WebP
0.168 BPP (66% bigger)
Ours
0.101 BPP

Figure 1: Examples of reconstructions by different codecs for very low bits per pixel (BPP) values. The uncompressed size is 24 BPP, so the examples represent compression by around 250 times. We reduce the bitrates of other codecs by their header lengths for fair comparison. For each codec, we search over bitrates and present the reconstruction for the smallest BPP above ours. WebP and JPEG were not able to produce reconstructions for such low BPP: the reconstructions presented are for the smallest bitrate they offer. More examples can be found in the appendix.

In this work, we present progress on both performance and computational feasibility of ML-based image compression.

Our algorithm outperforms all existing image compression approaches, both traditional and ML-based: it typically produces files 2.5 times smaller than JPEG and JPEG 2000 (JP2), 2 times smaller than WebP, and 1.7 times smaller than BPG on the Kodak PhotoCD and RAISE-1k datasets across all of quality levels. At the same time, we designed our approach to be lightweight and efficiently deployable. On a GTX 980 Ti GPU, it takes around 9ms to encode and 10ms to decode an image from these datasets: for JPEG, encode/decode times are 18ms/12ms, for JP2 350ms/80ms and for WebP 70ms/80ms. Results for a representative quality level are presented in Table 1.

To our knowledge, this is the first ML-based approach to surpass all commercial image compression techniques, and moreover run in real-time.

We additionally supplement our algorithm with adversarial training specialized towards use in a compression setting. This enables us to produce convincing reconstructions for very low bitrates.

2 Background & Related Work

2.1 Traditional compression techniques

Compression, in general, is very closely related to pattern recognition. If we are able to discover structure in our input, we can eliminate this redundancy to represent it more succinctly. In traditional codecs such as JPEG and JP2, this is achieved via a pipeline which roughly breaks down into 3 modules: transformation, quantization, and encoding (Wallace (1992) and Rabbani & Joshi (2002) provide great overviews of the JPEG standards).

In traditional codecs, since all components are hard-coded, they are heavily engineered to fit together. For example, the coding scheme is custom-tailored to match the distribution of the outputs of the preceding transformation. JPEG, for instance, employs block DCT transforms, followed by run-length encoding which exploits the sparsity pattern of the resultant frequency coefficients. JP2 employs an adaptive arithmetic coder to capture the distribution of coefficient magnitudes produced by the preceding multi-resolution wavelet transform.

However, despite the careful construction and assembly of these pipelines, there still remains significant room for improvement of compression efficiency. For example, the transformation is fixed in place irrespective of the distribution of the inputs, and is not adapted to their statistics in any way. In addition, hard-coded approaches often compartmentalize the loss of information within the quantization step. As such, the transformation module is chosen to be bijective: however, this limits the ability to reduce redundancy prior to coding. Moreover, the encode-decode pipeline cannot be optimized for a particular metric beyond manual tweaking: even if we had the perfect metric for image quality assessment, traditional approaches cannot directly optimize their reconstructions for it.

Figure 2: Our overall model architecture. The feature extractor, described in Section 3.1, discovers structure and reduces redundancy via the pyramidal decomposition and interscale alignment modules. The lossless coding scheme, described in Section 3.2, further compresses the quantized tensor via bitplane decomposition and adaptive arithmetic coding. The adaptive codelength regularization then modulates the expected code length to a prescribed target bitrate. Distortions between the target and its reconstruction are penalized by the reconstruction loss. The discriminator loss, described in Section 4, encourages visually pleasing reconstructions by penalizing discrepancies between their distributions and the targets’.

2.2 ML-based lossy image compression

In approaches based on machine learning, structure is automatically discovered, rather than manually engineered.

One of the first such efforts by Bottou et al. (1998), for example, introduced the DjVu format for document image compression, which employs techniques such as segmentation and K-means clustering separate foreground from background, and analyze the document’s contents.

At a high level, one natural approach to implement the encoder-decoder image compression pipeline is to use an autoencoder to map the target through a bitrate bottleneck, and train the model to minimize a loss function penalizing it from its reconstruction. This requires carefully constructing a feature extractor and synthesizer for the encoder and decoder, selecting an appropriate objective, and possibly introducing a coding scheme to further compress the fixed-size representation to attain variable-length codes.

Many of the existing ML-based image compression approaches (including ours) follow this general strategy. Toderici et al. (2015, 2016) explored various transformations for binary feature extraction based on different types of recurrent neural networks; the binary representations were then entropy-coded. Johnston et al. (2017) enabled another considerable leap in performance by introducing a loss weighted with SSIM (Wang et al., 2004), and spatially-adaptive bit allocation. Theis et al. (2016) and Ballé et al. (2016) quantize rather than binarize, and propose strategies to approximate the entropy of the quantized representation: this provides them with a proxy to penalize it. Finally, Pied Piper has recently claimed to employ ML techniques in its Middle-Out algorithm (Judge et al., 2016), although their nature is shrouded in mystery.

2.3 Generative Adversarial Networks

One of the most exciting innovations in machine learning in the last few years is the idea of Generative Adversarial Networks (GANs) (Goodfellow et al., 2014). The idea is to construct a generator network whose goal is to synthesize outputs according to a target distribution , and a discriminator network whose goal is to distinguish between examples sampled from the ground truth distribution, and ones produced by the generator. This can be expressed concretely in terms of the minimax problem:

This idea has enabled significant progress in photo-realistic image generation (Denton et al., 2015; Radford et al., 2015; Salimans et al., 2016), single-image super-resolution (Ledig et al., 2016), image-to-image conditional translation (Isola et al., 2016), and various other important problems.

The adversarial training framework is particularly relevant to the compression world. In traditional codecs, distortions often take the form of blurriness, pixelation, and so on. These artifacts are unappealing, but are increasingly noticeable as the bitrate is lowered. We propose a multiscale adversarial training model to encourage reconstructions to match the statistics of their ground truth counterparts, resulting in sharp and visually pleasing results even for very low bitrates. As far as we know, we are the first to propose using GANs for image compression.

3 Model

Our model architecture is shown in Figure 2, and comprises a number of components which we briefly outline below. In this section, we limit our focus to operations performed by the encoder: since the decoder simply performs the counterpart inverse operations, we only address exceptions which require particular attention.

Feature extraction.

Images feature a number of different types of structure: across input channels, within individual scales, and across scales. We design our feature extraction architecture to recognize these. It consists of a pyramidal decomposition which analyzes individual scales, followed by an interscale alignment procedure which exploits structure shared across scales.

Code computation and regularization.

This module is responsible for further compressing the extracted features. It quantizes the features, and encodes them via an adaptive arithmetic coding scheme applied on their binary expansions. An adaptive codelength regularization is introduced to penalize the entropy of the features, which the coding scheme exploits to achieve better compression.

Discriminator loss.

We employ adversarial training to pursue realistic reconstructions. We dedicate Section 4 to describing our GAN formulation.

3.1 Feature extraction

3.1.1 Pyramidal decomposition

Our pyramidal decomposition encoder is loosely inspired by the use of wavelets for multiresolution analysis, in which an input is analyzed recursively via feature extraction and downsampling operators (Mallat, 1989). The JPEG 2000 standard, for example, employs discrete wavelet transforms with the Daubechies 9/7 kernels (Antonini et al., 1992; Rabbani & Joshi, 2002). This transform is in fact a linear operator, which can be entirely expressed via compositions of convolutions with only two hard-coded and separable filters applied irrespective of scale, and independently for each channel.

The idea of a pyramidal decomposition has been employed in machine learning: for instance, Mathieu et al. (2015) uses a pyramidal composition for next frame prediction, and Denton et al. (2015) uses it for image generation. The spectral representations of CNN activations have also been investigated by Rippel et al. (2015) to enable processing across a spectrum of scales, but this approach does not enable FIR processing as does wavelet analysis.

Figure 3: The coefficient extraction pipeline, illustrated for 3 scales. The pyramidal decomposition module discovers structure within individual scales. The extracted coefficient maps are then aligned to discover joint structure across the different scales.

We generalize the wavelet decomposition idea to learn optimal, nonlinear extractors individually for each scale. Let us assume an input to the model, and a total of scales. We perform recursive analysis: let us denote as the input to scale ; we set the input to the first scale as the input to the model. For each scale , we perform two operations: first, we extract coefficients via some parametrized function for output channels , height and width . Second, we compute the input to the next scale as where is some downsampling operator (either fixed or learned).

Our pyramidal decomposition architecture is illustrated in Figure 3. In practice, we extract across a total of scales. The feature extractors for the individual scales are composed of a sequence of convolutions with kernels or and ReLUs with a leak of . We learn all downsamplers as convolutions with a stride of 2.

3.1.2 Interscale alignment

Interscale alignment is designed to leverage information shared across different scales — a benefit not offered by the classic wavelet analysis. It takes in as input the set of coefficients extracted from the different scales , and produces a single tensor of a target output dimensionality .

To do this, we first map each input tensor to the target dimensionality via some parametrized function . This involves ensuring that this function spatially resamples to the appropriate output map size , and outputs the appropriate number of channels . We then sum , and apply another parametrized non-linear transformation for joint processing.

The interscale alignment module can be seen in Figure 3. We denote its output as . In practice, we choose each as a convolution or a deconvolution with an appropriate stride to produce the target spatial map size ; see Section 5.1 for a more detailed discussion. We choose simply as a sequence of convolutions.

3.2 Code computation and regularization

Given the extracted tensor , we proceed to quantize it and encode it. This pipeline involves a number of components which we overview here and describe in detail throughout this section.

Quantization.

The tensor is quantized to bit precision :

Bitplane decomposition.

The quantized tensor is transformed into a binary tensor suitable for encoding via a lossless bitplane decomposition:

Adaptive arithmetic coding.

The adaptive arithmetic coder (AAC) is trained to leverage the structure remaining in the data. It encodes into its final variable-length binary sequence of length :

Adaptive codelength regularization.

The adaptive codelength regularization (ACR) modulates the distribution of the quantized representation to achieve a target expected bit count across inputs:

3.2.1 Quantization

Given a desired precision of bits, we quantize our feature tensor into equal-sized bins as

For the special case , this reduces exactly to a binary quantization scheme. While some ML-based approaches to compression employ such thresholding, we found better performance with the smoother quantization described. We quantize with for all models in this paper.

3.2.2 Bitplane decomposition

We decompose into bitplanes. This transformation maps each value into its binary expansion of bits. Hence, each of the spatial maps of expands into binary bitplanes. We illustrate this transformation in Figure 4, and denote its output as . This transformation is lossless.

As described in Section 3.2.3, this decomposition will enable our entropy coder to exploit structure in the distribution of the activations in to achieve a compact representation. In Section 3.2.4, we introduce a strategy to encourage such exploitable structure to be featured.

3.2.3 Adaptive arithmetic coding

The output of the bitplane decomposition is a binary tensor, which contains significant structure: for example, higher bitplanes are sparser, and spatially neighboring bits often have the same value (in Section 3.2.4 we propose a technique to guarantee presence of these properties). We exploit this low entropy by lossless compression via adaptive arithmetic coding.

Namely, we associate each bit location in with a context, which comprises a set of features indicative of the bit value. These are based on the position of the bit as well as the values of neighboring bits. We train a classifier to predict the value of each bit from its context features, and then use these probabilities to compress via arithmetic coding.

During decoding, we decompress the code by performing the inverse operation. Namely, we interleave between computing the context of a particular bit using the values of previously decoded bits, and using this context to retrieve the activation probability of the bit and decode it. We note that this constrains the context of each bit to only include features composed of bits already decoded.

Figure 4: Each of the spatial maps of is decomposed into bitplanes as each element is expressed in its binary expansion. Each set of bitplanes is then fed to the adaptive arithmetic coder for variable-length encoding. The adaptive codelength regularization enables more compact codes for higher bitplanes by encouraging them to feature higher sparsity.
Figure 5: Compression results for the RAISE-1k dataset, measured in the RGB domain (top row) and YCbCr domain (bottom row). We compare against commercial codecs JPEG, JPEG 2000, WebP and BPG5.1 (4:2:0 for YCbCr and 4:4:4 for RGB). The plots on the left present average reconstruction quality, as function of the number of bits per pixel fixed for each image. The plots on the right show average compressed file sizes relative to ours for different target MS-SSIM values for each image. In Section 5.2 we discuss the curve generation procedures in detail.

3.2.4 Adaptive codelength regularization

One problem with classic autoencoder architectures is that their bottleneck has fixed capacity. The bottleneck may be too small to represent complex patterns well, which affects quality, and it may be too large for simple patterns, which results in inefficient compression. What we need is a model capable of generating long representations for complex patterns and short for simple ones, while maintaining an expected codelength target over large number of examples. To achieve this, the AAC is necessary, but not sufficient.

We extend the architecture by increasing the dimensionality of — but at the same time controlling its information content, thereby resulting in shorter compressed code . Specifically, we introduce the adaptive codelength regularization (ACR), which enables us to regulate the expected codelength to a target value . This penalty is designed to encourage structure exactly where the AAC is able to exploit it. Namely, we regularize our quantized tensor with

for iteration and difference index set . The first term penalizes the magnitude of each tensor element, and the second penalizes deviations between spatial neighbors. These enable better prediction by the AAC.

As we train our model, we continuously modulate the scalar coefficient to pursue our target codelength. We do this via a feedback loop. We use the AAC to monitor the mean number of effective bits. If it is too high, we increase ; if too low, we decrease it. In practice, the model reaches an equilibrium in a few hundred iterations, and is able to maintain it throughout training.

Hence, we get a knob to tune: the ratio of total bits, namely the bits available in , to the target number of effective bits . This allows exploring the trade-off of increasing the number of channels or spatial map size of at the cost of increasing sparsity. We find that a total-to-target ratio of works well across all architectures we have explored.

Figure 6: Performance on the Kodak PhotoCD dataset measured in the RGB domain (top row) and YCbCr domain (bottom row). We compare against commercial codecs JPEG, JPEG 2000, WebP and BPG5.1 (4:2:0 for YCbCr and 4:4:4 for RGB), as well as recent ML-based compression work by Toderici et al. (2016)5.1, Theis et al. (2016)5.1, Ballé et al. (2016)5.1, and Johnston et al. (2017)5.1 in all settings where results exist. The plots on the left present average reconstruction quality, as function of the number of bits per pixel fixed for each image. The plots on the right show average compressed file sizes relative to ours for different target MS-SSIM values for each image.

4 Realistic Reconstructions via Multiscale Adversarial Training

4.1 Discriminator design

In our compression approach, we take the generator as the encoder-decoder pipeline, to which we append a discriminator — albeit with a few key differences from existing GAN formulations.

In many GAN approaches featuring both a reconstruction and a discrimination loss, the target and the reconstruction are treated independently: each is separately assigned a label indicating whether it is real or fake. In our formulation, we consider the target and its reconstruction jointly as a single example: we compare the two by asking which of the two images is the real one.

To do this, we first swap between the target and reconstruction in each input pair to the discriminator with uniform probability. Following the random swap, we propagate each set of examples through the network. However, instead of producing an output for classification at the very last layer of the pipeline, we accumulate scalar outputs along branches constructed along it at different depths. We average these to attain the final value provided to the terminal sigmoid function. This multiscale architecture allows aggregating information across different scales, and is motivated by the observation that undesirable artifacts vary as function of the scale in which they are exhibited. For example, high-frequency artifacts such as noise and blurriness are discovered by earlier scales, whereas more abstract discrepancies are found in deeper scales.

We apply our discriminator on the aggregate sum across scales, and proceed to formulate our objectives as described in Section 2.3. The complete discriminator architecture is illustrated in Figure 10.

4.2 Adversarial training

Training a GAN system can be tricky due to optimization instability. In our case, we were able to address this by designing a training scheme adaptive in two ways. First, the reconstructor is trained by both the confusion signal gradient as well as the reconstruction loss gradient: we balance the two as function of their gradient magnitudes. Second, at any point during training, we either train the discriminator or propagate confusion signal through the reconstructor, as function of the prediction accuracy of the discriminator.

More concretely, given lower and upper accuracy bounds and discriminator accuracy , we apply the following procedure:

  • If : freeze propagation of confusion signal through the reconstructor, and train the discriminator.

  • If : alternate between propagating confusion signal and training the disciminator.

  • If : propagate confusion signal through the reconstructor, and freeze the discriminator.

In practice we used . We compute the accuracy as a running average over mini-batches with a momentum of .

5 Results

5.1 Experimental setup

Similarity metric.

We trained and tested all models on the Multi-Scale Structural Similarity Index Metric (MS-SSIM) (Wang et al., 2003). This metric has been specifically designed to match the human visual system, and has been established to be significantly more representative than losses in the family and variants such as PSNR.

Color space.

Since the human visual system is much more sensitive to variations in brightness than color, most codecs represent colors in the YCbCr color space to devote more bandwidth towards encoding luma rather than chroma. In quantifying image similarity, then, it is common to assign the Y, Cb, Cr components weights . While many ML-based compression papers evaluate similarity in the RGB space with equal color weights, this does not allow fair comparison with standard codecs such as JPEG, JPEG 2000 and WebP, since they have not been designed to perform optimally in this domain. In this work, we provide comparisons with both traditional and ML-based codecs, and present results in both the RGB domain with equal color weights, as well as in YCbCr with weights as above.

Reported performance metrics.

We present both compression performance of our algorithm, but also its runtime. While the requirement of running the approach in real-time severely constrains the capacity of the model, it must be met to enable feasible deployment in real-life applications.

Training and deployment procedure.

We trained and tested all models on a GeForce GTX 980 Ti GPU and a custom codebase. We trained all models on patches sampled at random from the Yahoo Flickr Creative Commons 100 Million dataset (Thomee et al., 2016).

We optimized all models with Adam (Kingma & Ba, 2014). We used an initial learning rate of , and reduced it twice by a factor of 5 during training. We chose a batch size of 16 and trained each model for a total of 400,000 iterations. We initialized the ACR coefficient as . During runtime we deployed the model on arbitrarily-sized images in a fully-convolutional way. To attain the rate-distortion (RD)curves presented in Section 5.2, we trained models for a range of target bitrates .

11footnotetext: The Kodak PhotoCD dataset can be found at http://r0k.us/graphics/kodak.22footnotetext: The results of Toderici et al. (2016) on the Kodak RGB dataset are available at http://github.com/tensorflow/models/tree/master/compression.33footnotetext: We have no access to reconstructions by Theis et al. (2016) and Johnston et al. (2017), so we carefully transcribed their results, only available in RGB, from the graphs in their paper.44footnotetext: Reconstructions by Ballé et al. (2016) of images in the Kodak dataset can be found at http://www.cns.nyu.edu/~lcv/iclr2017/ for both RGB and YCbCr and across a spectrum of BPPs. We use these to compute RD curves by the procedure described in this section.55footnotetext: An implementation of the BPG codec is available at http://bellard.org/bpg.

5.2 Performance

We present several types of results:

  1. Average MS-SSIM as function of the BPP fixed for each image, found in Figures 5 and 6, and Table 1.

  2. Average compressed file sizes relative to ours as function of the MS-SSIM fixed for each image, found in Figures 5 and 6, and Table 1.

  3. Encode and decode timings as function of MS-SSIM, found in Figure 7, in the appendix, and Table 1.

  4. Visual examples of reconstructions of different compression approaches for the same BPP, found in Figure 1 and in the appendix.

Test sets.

To enable comparison with other approaches, we first present performance on the Kodak PhotoCD dataset5.1. While the Kodak dataset is very popular for testing compression performance, it contains only 24 images, and hence is susceptible to overfitting and does not necessarily fully capture broader statistics of natural images. As such, we additionally present performance on the RAISE-1k dataset (Dang-Nguyen et al., 2015) which contains 1,000 raw images. We resized each image to size (backwards if vertical): we intend to release our preparation code to enable reproduction of the dataset used.

We remark it is important to use a dataset of raw, rather than previously compressed, images for codec evaluation. Compressing an image introduces artifacts with a bias particular to the codec used, which results in a more favorable RD curve if it compressed again with the same codec. See Figure 9 for a plot demonstrating this effect.

Figure 7: Average times to encode and decode images from the RAISE-1k dataset using our approach.
Codecs.

We compare against commercial compression techniques JPEG, JPEG 2000, WebP, as well as recent ML-based compression work by Toderici et al. (2016)5.1, Theis et al. (2016)5.1, Ballé et al. (2016)5.1, and Johnston et al. (2017)5.1 in all settings in which results are available. We also compare to BPG5.1 (4:2:0 and 4:4:4) which, while not widely used, surpassed all other codecs in the past. We use the best-performing configuration we can find of JPEG, JPEG 2000, WebP, and BPG, and reduce their bitrates by their respective header lengths for fair comparison.

Performance evaluation.

For each image in each test set, each compression approach, each color space, and for the selection of available compression rates, we recorded (1) the BPP, (2) the MS-SSIM (with components weighted appropriately for the color space), and (3) the computation times for encoding and decoding.

It is important to take great care in the design of the performance evaluation procedure. Each image has a separate RD curve computed from all available compression rates for a given codec: as Ballé et al. (2016) discusses in detail, different summaries of these RD curves lead to disparate results. In our evaluations, to compute a given curve, we sweep across values of the independent variable (such as bitrate). We interpolate each individual RD curve at this independent variable value, and average all the results. To ensure accurate interpolation, we sample densely across rates for each codec.

Acknowledgements

We are grateful to Trevor Darrell, Sven Strohband, Michael Gelbart, Robert Nishihara, Albert Azout, and Vinod Khosla for meaningful discussions and input.

References

  • CIS (2015) White paper: Cisco vni forecast and methodology, 2015-2020. 2015.
  • Antonini et al. (1992) Antonini, Marc, Barlaud, Michel, Mathieu, Pierre, and Daubechies, Ingrid. Image coding using wavelet transform. IEEE Trans. Image Processing, 1992.
  • Ballé et al. (2016) Ballé, Johannes, Laparra, Valero, and Simoncelli, Eero P. End-to-end optimized image compression. preprint, 2016.
  • Bottou et al. (1998) Bottou, Léon, Haffner, Patrick, Howard, Paul G, Simard, Patrice, Bengio, Yoshua, and LeCun, Yann. High quality document image compression with djvu. 1998.
  • Dang-Nguyen et al. (2015) Dang-Nguyen, Duc-Tien, Pasquini, Cecilia, Conotter, Valentina, and Boato, Giulia. Raise: a raw images dataset for digital image forensics. In Proceedings of the 6th ACM Multimedia Systems Conference, pp. 219–224. ACM, 2015.
  • Denton et al. (2015) Denton, Emily L, Chintala, Soumith, Fergus, Rob, et al. Deep generative image models using a laplacian pyramid of adversarial networks. In NIPS, pp. 1486–1494, 2015.
  • Goodfellow et al. (2014) Goodfellow, Ian, Pouget-Abadie, Jean, Mirza, Mehdi, Xu, Bing, Warde-Farley, David, Ozair, Sherjil, Courville, Aaron, and Bengio, Yoshua. Generative adversarial nets. In NIPS, pp. 2672–2680, 2014.
  • Isola et al. (2016) Isola, Phillip, Zhu, Jun-Yan, Zhou, Tinghui, and Efros, Alexei A. Image-to-image translation with conditional adversarial networks. arXiv preprint arXiv:1611.07004, 2016.
  • Johnston et al. (2017) Johnston, Nick, Vincent, Damien, Minnen, David, Covell, Michele, Singh, Saurabh, Chinen, Troy, Hwang, Sung Jin, Shor, Joel, and Toderici, George. Improved lossy image compression with priming and spatially adaptive bit rates for recurrent networks. arXiv preprint arXiv:1703.10114, 2017.
  • Judge et al. (2016) Judge, Mike, Altschuler, John, and Krinsky, Dave. Silicon valley (tv series). 2016.
  • Kingma & Ba (2014) Kingma, Diederik and Ba, Jimmy. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
  • Ledig et al. (2016) Ledig, Christian, Theis, Lucas, Huszár, Ferenc, Caballero, Jose, Cunningham, Andrew, Acosta, Alejandro, Aitken, Andrew, Tejani, Alykhan, Totz, Johannes, Wang, Zehan, et al. Photo-realistic single image super-resolution using a generative adversarial network. arXiv preprint arXiv:1609.04802, 2016.
  • Mallat (1989) Mallat, S. G. A theory for multiresolution signal decomposition: The wavelet representation. IEEE Trans. Pattern Anal. Mach. Intell., 11(7):674–693, July 1989.
  • Mathieu et al. (2015) Mathieu, Michael, Couprie, Camille, and LeCun, Yann. Deep multi-scale video prediction beyond mean square error. arXiv preprint arXiv:1511.05440, 2015.
  • Rabbani & Joshi (2002) Rabbani, Majid and Joshi, Rajan. An overview of the jpeg 2000 still image compression standard. Signal processing: Image communication, 17(1):3–48, 2002.
  • Radford et al. (2015) Radford, Alec, Metz, Luke, and Chintala, Soumith. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.
  • Rippel et al. (2015) Rippel, Oren, Snoek, Jasper, and Adams, Ryan P. Spectral representations for convolutional neural networks. In Advances in Neural Information Processing Systems, pp. 2449–2457, 2015.
  • Salimans et al. (2016) Salimans, Tim, Goodfellow, Ian, Zaremba, Wojciech, Cheung, Vicki, Radford, Alec, and Chen, Xi. Improved techniques for training gans. In NIPS, pp. 2226–2234, 2016.
  • Theis et al. (2016) Theis, Lucas, Shi, Wenzhe, Cunningham, Andrew, and Huszar, Ferenc. Lossy image compression with compressive autoencoders. preprint, 2016.
  • Thomee et al. (2016) Thomee, Bart, Shamma, David A, Friedland, Gerald, Elizalde, Benjamin, Ni, Karl, Poland, Douglas, Borth, Damian, and Li, Li-Jia. Yfcc100m: The new data in multimedia research. Communications of the ACM, 2016.
  • Toderici et al. (2015) Toderici, George, O’Malley, Sean M, Hwang, Sung Jin, Vincent, Damien, Minnen, David, Baluja, Shumeet, Covell, Michele, and Sukthankar, Rahul. Variable rate image compression with recurrent neural networks. arXiv preprint arXiv:1511.06085, 2015.
  • Toderici et al. (2016) Toderici, George, Vincent, Damien, Johnston, Nick, Hwang, Sung Jin, Minnen, David, Shor, Joel, and Covell, Michele. Full resolution image compression with recurrent neural networks. arXiv preprint arXiv:1608.05148, 2016.
  • Wallace (1992) Wallace, Gregory K. The jpeg still picture compression standard. IEEE transactions on consumer electronics, 38(1):xviii–xxxiv, 1992.
  • Wang et al. (2003) Wang, Zhou, Simoncelli, Eero P, and Bovik, Alan C. Multiscale structural similarity for image quality assessment. In Signals, Systems and Computers, 2004., volume 2, pp. 1398–1402. Ieee, 2003.
  • Wang et al. (2004) Wang, Zhou, Bovik, Alan C, Sheikh, Hamid R, and Simoncelli, Eero P. Image quality assessment: from error visibility to structural similarity. IEEE transactions on image processing, 13(4):600–612, 2004.
(a) Encode times. (b) Decode times.
Figure 8: Average times to encode and decode images from the RAISE-1k dataset. Note our codec was run on GPU.
Figure 9: We used JPEG to compress the Kodak dataset at various quality levels. For each, we then use JPEG to recompress the images, and plot the resultant rate-distortion curve. It is evident that the more an image has been previously compressed with JPEG, the better JPEG is able to then recompress it.
Figure 10: The architecture of the discriminator used in our adversarial training procedure. The first module randomly swaps between the targets and the reconstructions. The goal of the discriminator is to infer which of the two inputs is then the real target, and which is its reconstruction. We accumulate scalar outputs along branches constructed along the processing pipeline, branched out at different depths. We average these to attain the final value provided to the objective sigmoid function. This multiscale architecture allows aggregating information across different scales. In Section 4 of the main text we discuss the motivation for these architectural choices in more detail.
  • JPEG
    0.0909 BPP
    0.1921 BPP
    0.4064 BPP

    JPEG 2000
    0.0847 BPP
    0.1859 BPP
    0.4002 BPP

    WebP
    0.1021 BPP
    0.1861 BPP
    0.4016 BPP

    Ours
    0.0840 BPP
    0.1851 BPP
    0.3963 BPP

  • JPEG
    0.0949 BPP
    0.1970 BPP
    0.4196 BPP

    JPEG 2000
    0.0941 BPP
    0.1953 BPP
    0.4069 BPP

    WebP
    0.1452 BPP
    0.1956 BPP
    0.4117 BPP

    Ours
    0.0928 BPP
    0.1939 BPP
    0.4035 BPP

  • JPEG
    0.1008 BPP
    0.2083 BPP
    0.3734 BPP

    JPEG 2000
    0.0953 BPP
    0.1939 BPP
    0.3690 BPP

    WebP
    0.1392 BPP
    0.1973 BPP
    0.3672 BPP

    Ours
    0.0949 BPP
    0.1921 BPP
    0.3643 BPP

  • JPEG
    0.1101 BPP
    0.2071 BPP
    0.4055 BPP

    JPEG 2000
    0.0947 BPP
    0.2014 BPP
    0.4002 BPP

    WebP
    0.1510 BPP
    0.1989 BPP
    0.4087 BPP

    Ours
    0.0941 BPP
    0.1940 BPP
    0.3971 BPP

  • JPEG
    0.0881 BPP
    0.1923 BPP
    0.4012 BPP

    JPEG 2000
    0.0846 BPP
    0.1889 BPP
    0.4002 BPP

    WebP
    0.0841 BPP
    0.1952 BPP
    0.4047 BPP

    Ours
    0.0828 BPP
    0.1885 BPP
    0.3996 BPP

Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
""
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
   
Add comment
Cancel
Loading ...
87193
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test
Test description