Learned Variable-Rate Image Compression with Residual Divisive Normalization

12/11/2019 ∙ by Mohammad Akbari, et al. ∙ Google Simon Fraser University Tencent 0

Recently it has been shown that deep learning-based image compression has shown the potential to outperform traditional codecs. However, most existing methods train multiple networks for multiple bit rates, which increases the implementation complexity. In this paper, we propose a variable-rate image compression framework, which employs more Generalized Divisive Normalization (GDN) layers than previous GDN-based methods. Novel GDN-based residual sub-networks are also developed in the encoder and decoder networks. Our scheme also uses a stochastic rounding-based scalable quantization. To further improve the performance, we encode the residual between the input and the reconstructed image from the decoder network as an enhancement layer. To enable a single model to operate with different bit rates and to learn multi-rate image features, a new objective function is introduced. Experimental results show that the proposed framework trained with variable-rate objective function outperforms all standard codecs such as H.265/HEVC-based BPG and state-of-the-art learning-based variable-rate methods.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

In the last few years, deep learning-based image compression [1, 2, 3, 4, 5, 6, 7] has made tremendous progresses, and has achieved better performance than JPEG2000 and the H.265/HEVC-based BPG image codec [8].

In [3]

, a generalized divisive normalization (GDN)-based scheme was proposed. The encoding network consists of three stages of convolution, subsampling, and GDN layers. Despite its simple architecture, it outperforms JPEG2000 in both PSNR and SSIM. A compressive autoencoder (AE) framework with residual connection as in ResNet was proposed in

[5], where the quantization was replaced by a smooth approximation, and a scaling approach was used to get different rates. In [1]

, a soft-to-hard vector quantization approach was introduced, and a unified framework was developed for both image compression and neural network model compression.

In [2], a deep semantic segmentation-based layered image compression (DSSLIC) was proposed, by taking advantage of the Generative Adversarial Network (GAN). A low-dimensional representation and segmentation map of the input were encoded. Moreover, the residual between the input and the synthesized image was also encoded. It outperforms the BPG codec (in RGB444 format) in both PSNR and MS-SSIM [9] across a large range of bit rates.

In [4], a context model of entropy coding for end-to-end optimized image compression was proposed, and a hyper-prior was augmented with the context. This method represents the state-of-the-art learning-based image compression, which outperforms BPG in terms of both PSNR and MS-SSIM. Another context-based model was proposed in [10], where an importance map for locally adaptive bit rate allocation was employed to handle the spatial variation of image content.

All the above-mentioned methods train multiple networks for multiple bit rates, which increases the implementation complexity. Therefore the variable-rate approach is desired in many scenarios, in which a single neural network model is trained to operate at multiple bit rates with satisfactory performance [6, 7, 11, 12].

In [6]

, long short-term memory (LSTM)-based recurrent neural networks (RNNs) and residual-based layer coding was used to compress thumbnail images. Better SSIM results than JPEG and WebP were reported. This approach was generalized in

[7]

, which proposed a variable-rate framework for full-resolution images by introducing a gated recurrent unit, residual scaling, and deep learning-based entropy coding. This method can outperform JPEG in terms of PSNR.

In [11], a CNN-based multi-scale decomposition transform was optimized for all scales. Rate allocation algorithms were also applied to determine the optimal scale of each image block. The results in [11] were reported to be better than BPG in MS-SSIM. In [12], a learned progressive image compression model was proposed, in which bit-plane decomposition was adopted. Bidirectional assembling gated units were also introduced to reduce the correlation between different bit-planes [12].

In this paper, we propose a new deep learning-based variable-rate image compression framework, which employs more GDN layers than [3, 4]. Two novel types of GDN-based residual sub-networks are also developed in the encoder and decoder networks, by incorporating the shortcut connection in ResNet [13]. Our scheme uses the stochastic rounding-based scalable quantization as in [14, 15, 6]. To further improve the performance, we encode the residual between the input and the reconstructed image from the decoder network as an enhancement layer. To enable a single model to operate with different bit rates and to learn multi-rate image features, a new variable-rate objective function is introduced that considers the performance at multiple rates. Experimental results show that the proposed framework trained with variable-rate objective function outperforms state-of-the-art learning-based variable-rate methods as well as all standard codecs including H.265/HEVC-based BPG (in all formats) in terms of MS-SSIM metric.

2 The Proposed Method

The overall framework of the proposed codec is shown in Fig. 1. At the encoder side, two layers of information are encoded: the encoder network output (code map) and the residual image. The code map is a low-dimensional feature map of the original image , obtained by the deep encoder , which is quantized by a uniform scalable quantizer , and then encoded by the FLIF lossless codec [16]. To further improve the performance, the reconstruction of the input image (denoted by ) from the quantized code map is obtained using the deep decoder , and the residual between the input and the reconstruction is encoded by the BPG codec as an enhancement layer [2]. At the decoder side, the reconstruction from the deep decoder and the decoded residual image are added to get the final reconstruction .

It has been shown that end-to-end optimization of a model including cascades of differentiable linear-nonlinear transforms has better performance over the traditional linear ones [3]. One example is the GDN, which is very efficient in gaussianizing local statistics of natural images. It also provides significant improvements when utilized as a prior for image compression when used with scalable quantization. GDN was first introduced in [3] for a learning-based image compression framework, which had a simple architecture of 3 downsampling convolutions, each is followed by a GDN layer.

Figure 1: Overall framework of the proposed codec (: deep encoder, : code map, : uniform scalar quantizer, : quantized code map, : deep decoder, : residual image).

The architecture of the proposed deep encoder and decoder networks are shown in Figure 2. Several modifications to the GDN-based schemes in [3, 4] are developed. First, we adopt a deeper architecture including 11 convolution layers, followed by GDN or inverse GDN (IGDN) in the encoder and decoder. Second, for deeper learning of image statistics and faster convergence, the concept of identity shortcut connection in the ResNet in [13] is introduced to some GDN and IGDN layers, denoted by ResGDN and ResIGDN. The architecture of the ResGDN and ResIGDN are shown in Figure 3

. Unlike the traditional residual blocks where the ReLU and batch (or instance) normalization are employed, we utilize GDN and IGDN layers in our residual blocks, which provide better performance and faster convergence rate.

Figure 2: Architecture of the proposed deep encoder and deep decoder networks. Conv/DeConv (n, kk, s): convolution/deconvolution with n filters of size k

k and stride of s.

Figure 3: Architecture of proposed ResGDN and ResIGDN transforms (n: the channel size used in the affine convolutions).

2.1 Deep Encoder

Let be the input image, the code map is generated using the parametric deep encoder as: , where is the parameter vector to be optimized. The encoder consists of 5 stages where the input to the th stage is denoted by . The image is then represented as , which is the input to the first stage of the encoder. Each stage begins with a convolution layer as:

(1)

where and are affine and down-sampling convolutions, respectively. Each convolution layer is followed by a GDN operation [3] defined as:

(2)

where and run over channels and

is the spatial location of a specific value of a tensor (e.g.,

). Except for the first and last stages, a ResGDN transform is applied at the end of each stage:

(3)

where is composed of two subsequent pairs of affine convolutions (Eq. 1 with ), each is followed by a GDN operation (Eq. 2).

2.2 Stochastic Rounding-Based Quantization

The output of the last stage of the encoder, , represents the code map with channels. Each channel denoted by is then quantized to a discrete-valued vector using a stochastic rounding-based uniform scalar quantizer as: where the function is defined as in [6, 14, 15]: where is produced by a uniform random number generator. and respectively represent the quantization step (scale) and the zero-point, which are defined as:

(4)

where , is the number of bits, and and are the input’s min and max values over the th channel, respectively. The zero-point

is an integer ensuring that zero is quantized with no error, which avoids quantization error in common operations such as zero padding

[17].

The stochastic rounding approach provides a better performance and convergence rate compared to round-to-nearest algorithm. Stochastic rounding is indeed an unbiased rounding scheme, which maintains a non-zero probability of small parameters. In other words, it possesses the desirable property that the expected rounding error is zero, i.e.

. As a consequence, the gradient information is preserved and the network is able to learn with low bits of precision without any significant loss in performance.

Each of the quantized code map channels, denoted by , is separately entropy-coded using the FLIF codec [16], which is a state-of-the-art lossless image codec.

2.3 Deep Decoder

At the decoder side, the quantized code map is dequantized using the following function: Given the dequantized code map , the parametric decoder (with the parameter vector ) reconstructs the image as follows: . Similar to the encoder, the decoder network is composed of 5 stages in which all the operations are reversed. Each stage at the decoder network starts with an IGDN operation computed as follows:

(5)

which is followed by a convolution layer defined as:

(6)

where denotes transposed convolution used for upsampling the input tensor. As the reverse of the encoder, each convolution at the middle stages is followed by a ResIGDN transform defined as:

(7)

where consists of two subsequent pairs of an IGDN operation (Eq. 5) followed by an affine convolution (Eq. 6 with ). The reconstructed image is finally resulted from the output of the decoder represented by .

Figure 4: Comparison results of proposed variable-rate approach with state-of-the-art variable-rate methods on Kodak test set in terms of PSNR (left) and MS-SSIM (right) vs. bpp (bits/pixel).

Original

ours (0.169bpp, 23.34dB, 0.947)

BPG (0.177bpp, 23.66dB, 0.891)

JPEG2000 (0.175bpp, 22.47dB, 0.866)
Figure 5: Kodak visual example (bits/pixel, PSNR, MS-SSIM). BPG: YUV4:4:4 format.

2.4 Residual Coding

As an enhancement layer to the bit-stream, the residual between the input image and the deep decoder’s output is further encoded by the BPG codec, as in [2]. To do this, the minimal and the maximal values of the residual image are first obtained, and the range between them is rescaled to [0,255], so that we can call the BPG codec directly to encode it as a regular 8-bit image. The minimal and maximal values are also sent to decoder for inverse scaling after BPG decoding.

2.5 Objective Function and Optimization

Our cost function is a combination of L2-norm loss denoted by , and MS-SSIM loss [18] denoted by as follows:

(8)

where and are the optimization parameter vectors of the deep encoder and decoder, respectively, each is defined as a full set of their parameters across all their 5 stages as: and where . In order to optimize the parameters such that our codec can operate at a variety of bit rates, we propose the following novel variable-rate objective functions for the and losses:

(9)

where denotes the reconstructed image with -bit quantizer (Eq. 4), and can take all possible values in a set . In this paper, is used for training variable-rate network model. The MS-SSIM metric use luminance , contrast , and structure to compare the pixels and their neighborhoods in and . Moreover, MS-SSIM operates at multiple scales where the images are iteratively downsampled by factors of , for . Note that other methods optimize for PSNR and MS-SSIM separately in order to get better performance in each of them. Our scheme jointly optimize for both of them. It will be shown later that we can still achieve satisfactory results in both metrics.

Our goal is to minimize the objective over the continuous parameters . However, both depend on the quantized values of whose derivative is discontinuous, which makes the quantizer non-differentiable [3]

. To overcome this issue, the fact that the exact derivatives of discrete variables are zero almost everywhere is considered, and the straight-through estimate (STE) approach in

[19] is employed to approximate the differentiation through discrete variables in the backward pass.

Figure 6: Ablation studies with different model configurations. ours: our variable-rate results. nCh: channels for the code map; ResGDN: ResGDN/IGDN transforms in the network architecture; ResReLU: conventional residual block with ReLU; noRes: neither ResGDN nor ResReLU is used; noGDN: GDN and IGDN layers in our main architecture replaced by ReLU.

3 Experimental Results

The ADE20K dataset [20] was used for training the proposed model. The images with at least 512 pixels in height or width were used (9272 images in total). All images were rescaled to and to have a fixed size for training. We set the downsampling factor and the channel size to get the code map of size 3232

8. The deep encoder and decoder models were jointly trained for 200 epochs with mini-batch stochastic gradient descent (SGD) and a mini-batch size of 16. The Adam solver with learning rate of 0.00002 was fixed for the first 100 epochs, and was gradually decreased to zero for the next 100 epochs. All the networks were trained in the RGB domain. The model was trained using 3 different bit rates, i.e.,

in Eq. 9. However, the trained model can operate at any bit rate in range at the test time.

In this section, we compare the performance of the proposed scheme with standard codecs (including JPEG, JPEG2000, WebP, and the H.265/HEVC intra coding-based BPG codec [8]) and the state-of-the-art learning-based variable-rate image compression methods in Cai2018 [11], Zhang2019 [7], and Toderici2017 [12], in which a single network was trained to generate multiple bit rates. We use both PSNR and MS-SSIM [9]

as the evaluation metrics.

The comparison results on the popular Kodak image set (averaged over 24 test images) are shown in Figure 4. Different points on the rate-distortion (R-D) curve of our variable-rate results are obtained from 5 different bit rates for the code maps in the base layer, i.e., . The corresponding residual images in the enhancement layer are coded by BPG (YUV4:4:4 format) with quantizer parameters of respectively. As shown in Figure 4, our method outperforms the state-of-the-art learning-based variable-rate image compression models and JPEG2000 in terms of both PSNR and MS-SSIM. Our PSNR results are slightly lower than BPG (in both YUV4:2:0 and YUV4:4:4 formats), but we achieve better MS-SSIM, especially at low rates.

The BPG-based residual coding in our scheme is exploited to avoid re-training the entire model for another bit rate and more importantly to boost the quality at high BPPs (bits/pixel). For the 5 points (low to high) in Figure 4, the percentage of BPPs used by residual image is {2%, 34%, 52%, 68%, 76%}. This shows that as the BPP increases, the residual coding has more significant contribution to the R-D performance.

One visual example from the Kodak image set is given in Figures 5 in which our results are compared with JPEG2000 and BPG (YUV4:4:4 format). As seen in the example, our proposed method provides the highest visual quality compared to the others. JPEG2000 has poor performance due to the ringing artifacts at edges. The BPG result is smoother compared to JPEG2000, but the details and fine structures (e.g., the grass on the ground) are not preserved in many areas.

In order to evaluate the performance of different components of the proposed framework, other ablation studies were performed. The results are shown in Figure 6.

Code map channel size: Figure 6 shows the results with channel sizes of 4 and 8 (i.e., ). It can be seen that has better results than . In general, we find that a larger code map channel size with smaller quantization bits provides a better performance, because deeper texture information of the input is preserved within the feature map.

GDN vs. ReLU: In order to show the performance of the proposed GDN-based architecture, we compare it with a ReLU-based variant of our model, denoted as . In this model, all GDN and IGDN layers in the deep encoder and decoder are removed; instead, instance normalization followed by ReLU are added to the end of all convolution layers. The last GDN and IGDN layers in the encoder and decoder are replaced by a Tanh layer. As shown in Fig. 6, the models with GDN structure outperform the ones without GDN.

Conventional vs. GDN/IGDN-based residual transforms: In this scenario, the model composed of the proposed ResGDN/ResIGDN transforms (denoted by ResGDN in Figure 6) is compared with the conventional ReLU-based residual block (denoted by ) in which all the GDN/IGDN layers are repalced by ReLU. The results with neither ResReLU nor ResGDN (yellow blocks in Figure 1), denoted by , are also included. As demonstrated in Figure 6, ResGDN achieves better performance compared to the other scenarios.

In terms of complexity, the average processing time of the deep encoder, quantizer, and deep decoder on Kodak are 65ms, 2ms, and 51ms on a TITAN X Pascal GPU, respectively.

4 Conclusion

In this paper, we propose a new variable-rate image compression framework, by applying more GDN layers and incorporating the shortcut connection in the ResNet. We also use a stochastic rounding-based scalable quantization. To further improve the performance, the residual between the input and the reconstructed image from the decoder network is encoded by BPG as an enhancement layer. A novel variable-rate objective function is proposed. Experimental results show that our variable-rate model can outperform all standard codecs including BPG, as well as state-of-the-art learning-based variable-rate methods. A future topic is the rate allocation optimization between the base layer and the enhancement layer.

References