Learning based Facial Image Compression with Semantic Fidelity Metric

TL;DR

This paper introduces a learning-based facial image compression framework that optimizes semantic fidelity, significantly reducing bitrate while maintaining face recognition accuracy, and automatically focusing on critical facial regions.

Contribution

The paper presents a novel LFIC framework with a Regionally Adaptive Pooling module and a hybrid semantic fidelity metric, including GAN integration, for improved facial image compression.

Findings

Achieved up to 71.41% bitrate savings over JPEG2000.

Demonstrated superior performance compared to recent facial image codecs.

Showed LFIC's ability to focus on critical facial regions for optimized compression.

Abstract

Surveillance and security scenarios usually require high efficient facial image compression scheme for face recognition and identification. While either traditional general image codecs or special facial image compression schemes only heuristically refine codec separately according to face verification accuracy metric. We propose a Learning based Facial Image Compression (LFIC) framework with a novel Regionally Adaptive Pooling (RAP) module whose parameters can be automatically optimized according to gradient feedback from an integrated hybrid semantic fidelity metric, including a successfully exploration to apply Generative Adversarial Network (GAN) as metric directly in image compression scheme. The experimental results verify the framework's efficiency by demonstrating performance improvement of 71.41%, 48.28% and 52.67% bitrate saving separately over JPEG2000, WebP and neural network-based codecs under the same face verification accuracy distortion metric. We also evaluate LFIC's superior performance gain compared with latest specific facial image codecs. Visual experiments also show some interesting insight on how LFIC can automatically capture the information in critical areas based on semantic distortion metrics for optimized compression, which is quite different from the heuristic way of optimization in traditional image compression algorithms.

Figures

Tables

Table 1. Table 1: Details of our decoder architecture. Each convolutional layers are optionally followed by several RBs (Residual Blocks).

Layer	RBs	Input	Filter Size /	BN	Activation	Output
			Stride
1	1	input	$5\times 5$ / 2	Y	ReLU	conv1
2	2	conv1	$3\times 3$ / 2	Y	ReLU	conv2
3	2	conv2	$3\times 3$ / 2	Y	ReLU	conv3
4	3	conv3	$3\times 3$ / 2	Y	ReLU	conv4
5	2	conv4	$3\times 3$ / 2	Y	ReLU	deconv5
6	2	deconv5, conv3	$3\times 3$ / 2	Y	ReLU	deconv6
7	1	deconv6, conv2	$3\times 3$ / 2	Y	ReLU	deconv7
8	-	deconv7, conv1	$3\times 3$ / 2	Y	ReLU	deconv8
9	1	deconv8, input	$3\times 3$ / 1	Y	ReLU	conv9
10	1	conv9	$3\times 3$ / 1	Y	ReLU	conv10
11	-	conv10	$3\times 3$ / 1	N	Tanh	conv11

Table 2. Table 2: Detailed architecture of RB (Residual Block)

Layer	Type	Input	Filter Size /	BN	Activation	Output
			Stride
1	Conv	input	3$\times$3 / 1	Y	ReLU	conv1
2	Conv	conv1	3$\times$3 / 1	N	ReLU	conv2
3	Add	input, conv2	-	-	-	output

Table 3. Table 3: Ratio of Bit Rate Saving of our scheme compared with benchmarks

	Ours
JPEG2000	-71.41%
WebP	-48.28%
Toderici et al. [21]	-52.67%

Table 4. Table 4: Comparison with specific facial image compression methods on ratio of Bit Rate Saving relative to JPEG2000

	JPEG2000
Elad et al. [8]	-47.18%
Bryt et al. [9]	-45.55%
Ram et al. [10]	-34.20%
Ferdowsi et al. [11]	-35.22%
Ours	-71.41%

Equations

$$\frac{d}{d{F}_{\theta }(x)}{Q}_{\phi }(F_{\theta }(x)):=\frac{d}{d{F}_{\theta }(x)}[F_{\theta }(x)]:=\frac{d}{d{F}_{\theta }(x)}R(F_{\theta }(x)),$$

$$\frac{\partial l}{\partial x}=\frac{\partial l}{\partial G_{\varphi }}\frac{\partial G_{\varphi }}{\partial Q_{\phi }}\frac{\partial Q_{\phi }}{\partial F_{\theta }}\frac{\partial F_{\theta }}{\partial x},$$

$$e^{(i,j)}=\{\begin{array}{rl}{x}^{(i,j)},& \text{if}i=1,j=1,\\ x^{(i,j)}-x^{(i,j-1)},& \text{if}i=1,j>1,\\ x^{(i,j)}-x^{(i-1,j)},& \text{otherwise},\end{array}$$

$$x_{concat}=[x_1,\dots ,x_n,\dots ,x_N],1\le n\le N,$$

$$x_{RAP}^{(i,j)}=\sum _{k=1}^{K\times N}(x_{concat}^{(i,j,k)}\times M^{(i,j,k)}),s.t.\sum _{k=1}^{K\times N}{M}^{(i,j,k)}=K,$$

$$M^{(i,j,k)}=\{\begin{array}{rl}1,& \text{if}k\ge K\times (N-1),\\ 0,& \text{otherwise},\end{array}$$

$$l_{adv}=\frac{1}{2}{\mathbb{E}}_{x\sim P_{data}(x)}[(D_{\pi }(G_{\varphi }(Q_{\phi }(F_{\theta }(x))))-1{)}^2],$$

$$l_{con}={\mathbb{E}}_{x\sim P_{data}(x)}[{\Vert G_{\varphi }(Q_{\phi }(F_{\theta }(x)))-x\Vert }_1],$$

$$l_{sem}={\mathbb{E}}_{x\sim P_{data}(x)}[{\Vert H_{\psi }(G_{\varphi }(Q_{\phi }(F_{\theta }(x))))-H_{\psi }(x)\Vert }_2^2],$$

$$l_{all}={\lambda }_{con}{l}_{con}+{\lambda }_{sem}{l}_{sem}+{\lambda }_{adv}{l}_{adv},$$

Full text

††journal: Neurocomputing

1 Introduction

Face verification/recognition has been developing rapidly in recent years, which facilitates a wide range of intelligent applications such as surveillance video analysis, mobile authentication, etc. Since these frequently-used applications generate a huge amount of data that requires to be transmitted or stored, a highly efficient facial image compression is broadly required as illustrated in Fig. 1.

Basically, facial image compression can be regarded as a special application of general image compression technology. While evolution of general image/video compression techniques has been focused on continuously improving Rate Distortion performance, viz. reducing the compressed bit rate under the same distortion between the reconstructed pixels and original pixels or reducing the distortion under the same bit rate. The apparent question is how to define the distortion metric, especially for specific application scenario such as face recognition in surveillance. Usually we can classify the distortion into three levels of distortion metrics: Pixel Fidelity, Perceptual Fidelity, and Semantic Fidelity, according to different levels of human cognition on image/video signals.

The most common metric is Pixel Fidelity, which measures the pixel level difference between the original image and compressed image, e.g., MSE (Mean Square Error) has been widely adopted in many existed image and video coding techniques and standards (e.g., MPEG-2, H.264, HEVC, etc.). It can be easily integrated into image/video hybrid compression framework as an in-loop metric for rate-distortion optimized compression. However, it’s obvious that pixel fidelity metric cannot fully reflect human perceptual viewing experience [1]. Therefore, many researchers have developed Perceptual Fidelity metrics to investigate objective metrics measuring human subjective viewing experience [2]. With the development of aforementioned intelligent applications, image/video signals will be captured and processed for semantic analysis. Consequently, there will be increasingly more requirements on research for Semantic Fidelity metric to study the semantic difference (e.g., difference of verification accuracy) between the original image and compressed image. There are few research work on this area [3, 4] and usually are task-specific.

The aforementioned various distortion metrics provide a criteria to measure the quality of reconstructed content. However, the ultimate target of image quality assessment is not only to measure the quality of images with different level of distortion, but also to apply these metrics to optimize image compression schemes. While it’s a contradictory that most complicated quality metrics with high performance are not able to be integrated easily into an image compression loop. Some research works tried to do this by adjusting image compression parameters (e.g., Quantization parameters) heuristically according to embedded quality metrics [5, 6], but they are still not fully automatic-optimized end-to-end image encoder with integration of complicated distortion metrics.

In this paper, we are trying to solve this problem by developing a Learning based Facial Image Compression (LFIC) framework, to make it feasible to automatically optimize coding parameters according to gradient feedback from the integrated hybrid facial image distortion metric calculation module. Different from traditional hybrid coding framework with prediction, transform, quantization and entropy coding modules, we separate these different modules inside or outside the end-to-end loop according to their derivable property. We demonstrated the efficiency of this framework with the simplest prediction, quantization and entropy coding module. We propose a new module called Regionally Adaptive Pooling (RAP) inside the end-to-end loop to improve the ability to configure compression performance. RAP has advantages of being able to control bit allocation according to distortion metrics’ feedback under a given bit budget. Face verification accuracy is adopted as one semantic distortion metric to be integrated into LFIC framework.

Although we adopt the simplest prediction, quantization and entropy coding module, the LFIC framework has shown great improvement over traditional codec like JPEG2000, WebP and neural network-based codecs, and also demonstrates much better performance compared with existing specific facial image compression schemes. The visualization as illustrated in Fig. 2 shows that more focus is on the distinguishable regions (e.g., eye, nose) according to face verification metric. Also, it demonstrates that our LFIC framework can automatically capture the information in critical areas based on semantic distortion metric.

In general, our contributions are four-folds: 1) a Learning based Facial Image Compression framework; 2) a novel pooling strategy called RAP; 3) a successful exploration to apply Generative Adversarial Network (GAN) as metric to compression directly; 4) a starting exploration for semantic based image compression.

2 Related Work

2.1 Image Compression

For image compression, standard image codecs such as JPEG, JPEG2000 and WebP have been widely used , which have made remarkable achievements in general applications over the past few decades. However, such compression schemes are becoming increasingly difficult to meet the needs for advanced applications of semantic analysis. There are some preliminary heuristic explorations such as Alakuijala et al. adopted the distortion metric from the perspective of perceptual-level to analogically optimize the JPEG encoder [5]. And Prakash et al. enhanced JPEG encoder by highlighting semantically-salient regions [7].

There are also some face-specific image compression schemes proposed in academic area, some attempts [8, 9, 10, 11] have been made to design dictionary-based coding schemes on this specific image type. Moreover, face verification in compressed domain is another solution due to its lower computational complexity[12].

Recently image compression with neural network attracts increasing interest recently. Ballé et al. optimized a model consisting of nonlinear transformations for a perceptual metric [13] and MSE [14], also relaxed the discontinuous quantization with additive uniform noise with the goal of end-to-end training. Theis et al. [15] used a similar architecture but dealt with quantization and entropy rate estimation in a different way. Consistent with the architecture of [15], Agustsson et al. [16] trained with a soft-to-hard entropy minimization scheme in the context of model and feature compression. Dumas et al. [17] introduced a competition mechanism between image patches binding to sparse representation. Li et al. [18] achieved spatially bit-allocation for image compression by introducing an importance map. Jiang et al. [19] realized a super-resolution-based image compression algorithm. As variable rate encoding is a fundamental requirement for compression, some efforts [20, 21, 22] have been devoted towards using autoencoders in a progressive manner, growing with the number of recurrent iterations. On the basis of these progressive autoencoders, Baig et al. introduced an inpainting scheme that exploits spatial coherence to reduce redundancy in image [23]. Chen et al. proposed an end-to-end framework for video compression [24]. With the rapid development of GANs, it has been proved that it is possible to adversarially generate images from a compact representation [25, 26]. In the last few months, the modeling of latent representation becomes an emerging direction [27, 28]. Typically, they learned a probability model of the latent distribution to improve the efficiency of entropy coding.

However, most of aforementioned works either employed pixel fidelity and perceptual fidelity metrics, or optimized by heuristically adjusting codec’s parameters. Instead, our framework is a neural network based scheme able to automatically optimize coding parameters with integrated hybrid distortion metrics, which demonstrates much higher performance improvement compared with these state of the art solutions.

2.2 Adaptive Pooling

Traditional block based pooling strategy applied in neural network based scheme is not suitable for integrated semantic metrics, since most semantic metrics are not block-wise, e.g. face verification accuracy metric is to define the verification accuracy of the whole facial image rather than to define the accuracy of each block in the facial image. Therefore we need to propose a new pooling operation able to deal with this issue.

The idea of spatial pooling is to produce informative statistics in a specific spatial area. In consideration of relatively fixed pattern it has, several works aimed at enhancing its flexibility. Some approaches adaptively learned regions that distinguishable for classification [29, 30]. Similar to Jia et al., some works tried to design better spatial regions for pooling to reduce the effect of background noise with the goal of image classification [31, 32] and object detection [33]. As traditional pooling operation adopt a fixed block size for each image, we propose a variable block size pooling scheme named RAP, which is configurable optimized on the basis of integrated distortion metrics and provide ability of preserving higher quality to crucial local areas.

3 Learning based Facial Image Compression Framework

This section introduces the general framework of facial image compression with integrated general distortion metric, as illuminated in Fig. 3.

Compression Flow. Consistent with conventional codec, our LFIC framework contains a compression flow and a decompression flow. In the compression flow, an image $x$ is fed into a differentiable encoder $F_{\theta}$ and a quantizer $Q_{\varphi}$, translated into a compact representation $c$: $c={Q_{\varphi}}(F_{\theta}(x))$, where subscripts refer to parameters (the same in the remaining of this section). The quantizer can attain a significant amount of data reduction, but still statistically redundant. Therefore, we further perform several generic or specific lossless compression schemes (i.e., transformation, prediction, entropy coding), formulated as $L(c)$, to achieve higher coding efficiency. After the lossless compression, $x$ is encoded into a bitstream $b$ that can be directly delivered to a storage device, or a dedicated link, etc.

Decompression Flow. In the decompression flow, due to the reversibility of lossless compression, $c$ can be recovered from the channel by $L^{-1}$. The reconstructed image $\hat{x}$ is ultimately obtained by a differentiable decoder $G_{\phi}$: $\hat{x}=G_{\phi}(c)$, where $c=L^{-1}(b)$.

Metric Transformation Flow. As mentioned before, a general distortion metric calculation module is integrated into our LFIC framework. This motivates the use of a transformation $H_{\psi}$, that bridge the gap between pixel domain and metric domain. We expect that, the difference between $s$ and $\hat{s}$, which are generated from $x$ and $\hat{x}$ respectively, represents distortion measured in our desired metric domain (i.e., pixel fidelity domain, perceptual fidelity domain, and semantic fidelity domain). After that, the loss $l$ can be propagated back to each component of the compression-decompression flow (i.e. $F_{\theta}$, $Q_{\varphi}$ and $G_{\phi}$) which needs to be differentiable.

Gradients Flow. Since $F_{\theta}$ and $G_{\phi}$ are both differentiable, therefore, the only inherently non-differentiable step here is quantization, which poses an undesirable obstacle for end-to-end optimization with gradient-based techniques. Some effective algorithms have been developed to tackle this challenging problem [13, 20]. We follow the works in [15], which regards quantization as rounding, by replacing its derivative in backpropagation:

[TABLE]

where $R$ is a smooth approximation, and square bracket depicts rounding a real number to the nearest integer value. We set $R(F_{\theta}(x))=F_{\theta}(x)$ here, which means perform backpropagation without modification through rounding. In general, the gradient of loss with respect to input image $x$ can be formulated as:

[TABLE]

In a word, during the entire pipeline of our framework, we separate distinct modules inside or outside the end-to-end loop according to their differentiable property. The modules like $F_{\theta}$, $Q_{\varphi}$, $G_{\phi}$ and $H_{\psi}$ are placed inside the loop, the parameters in these modules can be updated according to the gradient back-propagation from the loss measured by the distortion metric. The modules like $L$ and ${L^{-1}}$ are placed outside the loop, since it is non-differentiable and reversible.

4 Semantic-oriented Facial Image Compression

As described in Sec. 3, compared with ordinary compression pipeline, the main advantage of semantic-oriented compression is that we can automatically optimize parameters in encoder $F_{\theta}$, quantizer $Q_{\varphi}$ and decoder $G_{\phi}$ according to the semantic distortion metric supported by $H_{\psi}$. It is significant that, we can preserve semantic features while reducing redundancy in a full-automatic way rather than heuristically tuning coding parameters according to distortion metrics, which is very important for future intelligent media applications with necessary of transmitting images compressed by preserving semantic fidelity.

As mentioned in the introduction section, the proposed semantic-oriented facial image compression scheme incorporates the proposed pooling strategy, RAP (Regionally Adaptive Pooling), into the network, which is a differentiable and lossy operation that can use variable block size pooling for each image.

After RAP, We then implement a simple prediction as illustrated below:

[TABLE]

where $(i,j)$ denote coordinates of pixels. The output of prediction $e$ is followed by an arithmetic coding. As we showed previously, we merge a transformation $H_{\psi}$ to send back error measured in semantic domain, which will be illustrated with more details in next section.

4.1 Encoding with RAP

Pooling layer is commonly employed to down-sample an input representation immediately after convolutional layer in neural networks, on the assumption that features are contained in the sub-regions. In most of the widely used neural network structures, the pooling blocks are not overlapped and fixed block size is used in each image. However, in the context of image compression, such fixed block size pooling scheme is improper in the case of heterogeneous texture distribution. In order to address this issue and increase the flexibility, we propose RAP of using variable block sizes pooling scheme. The choice of block sizes used in each sub-region are represented as a mask.

Suppose an input image $x\in\mathbb{R}^{I\times J\times K}$, where $I,J,K$ denote the height, width, channel of $x$ respectively. The output of non-overlapping pooling operation with fixed block size $n$ can be denoted as $x_{(n)}$, where $x_{(n)}\in\mathbb{R}^{\frac{I}{n}\times\frac{J}{n}\times K}$. Then we interpolate $x_{(n)}$ to $x_{n}$, where $x_{n}\in\mathbb{R}^{I\times J\times K}$, and concatenate $x_{n}$ along the last dimension:

[TABLE]

where $x_{concat}\in\mathbb{R}^{I\times J\times(K\times N)}$, and $N$ indicate the maximum block size. We define a mask $M\in[0,1]^{I\times J\times(K\times N)}$, the output of RAP can be formulated as:

[TABLE]

where $i,j,k$ denote indexes of height, width, channel respectively.

In the training stage, the mask $M$ is random initialized to facilitate a robust learning process of neural networks. In the testing stage, at encoding time, $M$ is adaptively determined by: 1) a given bit rate budget; 2) the gradient feedback from the integrated semantic distortion metrics. We first initialize $M$ as:

[TABLE]

then automatically update $M$ according to Alg. 1. In practice, we first set a constraint on the mask according to bit rate budget, then adjust the mask based on gradient feedback. For example, smaller block size will be used in the location determined by gradient feedback if the bit rate budget is adequate. We encode $M$ with arithmetic coding as overhead (around 5%-10% of the total bit rate).

At decoding time, since the mask $M$ (transmitted as overhead) is available, we can completely restore the compact representation $c$ after arithmetic decoding. Finally, the reconstructed image is obtained by the decoder $G_{\phi}$.

Different from autoencoder-based compression, RAP provide the ability of preserving crucial local features that have great impact on face verification (e.g., the regions around eyes have larger gradient so that these regions should be pooled with smaller block size), which adds support of spatially adaptive bit allocation to our LFIC framework. We also believe that RAP has the potential to be embedded in the widely used convolutional neural network structure to provide the strong flexibility. The experimental results demonstrate that RAP served as a promising encoder component, and the restored faces retain the semantic property very well.

4.2 Decoding with Adversarial Networks

As a fast-growing architecture in the field of neural network, GANs achieve impressive success in lots of tasks. We apply such generative model to compression directly to reduce reconstruction error. We employ a discriminator $D_{\pi}$ training with decoder simultaneously, to force the decoded images to be indistinguishable from real images and to make the reconstruction process well constrained by incorporating prior knowledge of face distribution. Since standard procedures of GAN usually result in mode collapse and unstable training [34], therefore, we adopt the least square loss function in LSGAN [34], which yields minimizing the Pearson $\chi^{2}$ divergence instead of Jensen-Shannon divergence [35]. Our adversarial loss can be defined as follows:

[TABLE]

Adversarial losses can urge the reconstructed data distributed as the original one in theory. However, a network with large enough capability can learn any mapping functions between these two distributions, that cannot guarantee the learned mapping producing desired reconstructed images. Therefore, a constraint to mapping function is needed to reduce the space of mapping functions. This issue calls for the employment of pixel-wise L1 loss for content consistency:

[TABLE]

Decoder Architecture. Previous works [36] have shown that residual learning have the potential to train a very deep convolutional neural network. We employ several Convolution-BatchNorm-ReLU modules [37] and residual modules based on symmetric skip-connection architecture for the decoder, which allowing connection between a convolutional layer to its mirrored deconvolutional layer (Tab. 1). Any extra inputs are specified in the input column. Such design mix the information of different features extracted from various layers, and prevent training from suffering from gradient vanishing. For the discriminator network, we follow DCGAN [38] except for the least square loss function.

4.3 Training with Semantic Distortion Metric

Our main goal is to obtain a compact representation, and ideally, such representation is expressive enough to rebuild data under semantic distortion metric. As we have shown previously, each in-loop operation in our framework is differentiable to guarantee that the error will be propagated back.

As to facial compression, we select FaceNet [39] as the metric transformation $H_{\psi}$, a neural-network-based tool that maps face images to a compact Euclidean space. Such space amplifies distances of faces from distinct people, while reduce distances of faces from the same person. This model is pre-trained with triplet loss and center loss [40]. Specifically, we adopt L2 loss to facilitate semantic preserving on encoder and decoder:

[TABLE]

4.4 Full Objective

The overall objective is a weighted sum of three individual objectives:

[TABLE]

In practice, we also attempted a regularization term $l_{reg}$ and replace L1 norm with MSE, but did not observe obvious performance improvement.

5 Experiments

In this section, we will introduce the dataset and the specific experimental details for facial compression. We compared our proposed method with traditional codecs and specific facial image compression methods. The results demonstrate that our method not only produce more visually preferred images under very low bit rate, but also good at preserving semantic information in the context of face verification scenario.

Dataset. We used the publicly available CelebA aligned [41] dataset to train our model. CelebA contains 10,177 number of identities and 202,599 number of facial images. We eliminated the faces that cannot be detected by dlib 111http://dlib.net/, and that are judged to be profiles based on landmarks annotations. The remaining images were cropped to $144\times 112\times 3$, and randomly divided into training set (100,000 images, 9014 identities) and testing set (14,871 images, 1870 identities).

Evaluation. We adopt the accuracy (10-fold cross-validation) of face verification to represent the ability of semantic preservation, which means that lower verification accuracy represents higher semantic distortion during image compression progress. Face verification is a binary classification task that given a pair of images, to determine whether the two pictures represent the same individual. We randomly generate 6000 pairs in testing set for face verification, where the positive and negative samples are half to half. The bitstream was represented as Bit-Per-Pixel (BPP). The Peak Signal-to-Noise Ratio (PSNR) was calculated in RGB channel. Furthermore, in order to calculate the equivalent rate distortion difference between two compression schemes, we refer [42], which is widely used in international image/video compression standard. The only difference in implementation is that we replace BPS (Bits Per Second) by BPP as rate index, and replace PSNR by face verification accuracy as distortion index.

Pre-train for metric transformation. In our task, the metric transformation plays an important role in bridging pixel domain and semantic domain, where the distortion is measured to provide gradient feedback. We employed FaceNet [39], a learned mapping that translating facial images to a compact Euclidean space, where the distance representing facial similarity. We use the parameters pre-trained on MS-Celeb-1M dataset 222https://github.com/davidsandberg/facenet, with a competitive classification accuracy of 99.3% on LFW [43] and 97.5% on our generated pairs. In the training stage of compression network, the parameters of metric transformation will be fixed to ensure the reliability of semantic distortion measurement.

Implementation details. We implement all modules using TensorFlow, with training executed on NVIDIA Tesla K80 GPUs. We employ Adam optimization [44] to train our network with learning rate 0.0001. All parameters are trained with 20000 iterations (64 images / iteration), which cost about 24 GPU-hours. We heuristically set $\lambda_{con}=0.01$, $\lambda_{sem}=10$, $\lambda_{adv}=0.1$ in the experiments. The principle is to increase the weight of adversarial and semantic parts as much as possible, while avoiding disturbance to subjective quality of reconstructions. We adopt the block size of 4 or 8 as an instance to demonstrate the effectiveness of our scheme. We have also conducted our experiments with different block sizes (e.g., 16 or 32), but it doesn’t bring much rate distortion performance gain compared with current settings.

5.1 Comparison against Typical Image Compression Schemes

We compare our model against typical widely used image compression codecs (JPEG2000 333http://www.openjpeg.org/ (v2.1.2), WebP 444https://developers.google.com/speed/webp/ (v0.6.0-rc3)), a neural network-based image compression method of Toderici et al. 555https://github.com/tensorflow/models/tree/master/research/compression [21] and specific facial image compression methods [8, 9, 10, 11].

We refer [42] to calculate the equivalent rate distortion difference between two compression schemes. We replaced BPS by BPP, which is averaged over testing set. We also replaced PSNR by face verification accuracy, which is described in aforementioned section. The results outperform JPEG2000 and WebP codecs, as well as Toderici’s solution significantly, as shown in Table.3.

Some considered efforts have been made to specific facial image compression [8, 9, 10, 11]. But instead of automatically optimizing with integrated hybrid metrics (e.g., semantic fidelity), they adjusted compression parameters heuristically (e.g., bit allocation) and evaluated their performance of methods on gray-scale images with PSNR/SSIM only (34.20% $\sim$ 47.18% bit rate reduction over JPEG2000 as Tab. 4 demonstrates 666A fixed header size of 100 bytes in JPEG2000 is added for all results., these results are extracted from their papers since the authors don’t release their source code for comparison).

As mentioned in introduction section, pixel fidelity cannot fully reflect semantic difference. For instance, in Fig. 5, we can observe that RAP at 0.110 BPP has a much higher face verification rate and better visual experience than JPEG2000 and WebP at 0.193 BPP, even though RAP has lower PSNR/SSIM in this case. On the other hand, Delac et al. [12] found out that most traditional compression algorithms have face verification rate dropped significantly under the bit rate range of 0.2 $\sim$ 0.6 BPP. In contrast, our scheme can keep face verification accuracy without significantly deterioration even under the very low bit rate of 0.05 BPP.

We calculate the time consuming of our scheme and traditional codecs on the same machine (CPU: i7-4790K, GPU: NVIDIA GTX 1080). The overall computational complexity of our implementation is about $13$ times that of WebP. It should be noted that our scheme is just a preliminary exploration of learning-based framework for image compression and each part is implemented without any optimization.

5.2 Rate Distortion Performance Analysis

To evaluate the effectiveness of spatially adaptively bit allocation, we compared RAP with its non-adaptive counterpart, namely, Regionally Fixed Pooling (RFP), whose block sizes are all fixed. Acting in this way, RFP could not adjust block sizes to achieve variable rate at testing time as RAP does. Therefore, we trained RFP model with different quantization step to realize variable rate for comparison. As Fig. 7 illustrates, with the increase of bit budget, the performance of RAP is much higher than RFP. We also provide detailed comparison in Fig. 6 which demonstrates that RAP can automatically preserving better quality than RFP on the distinguishable regions under the same bit rate.

We also analyze the influence of adversarial loss $l_{adv}$ and semantic loss $l_{sem}$ by comparing the performance of RAP/RFP, RAP/RFP without adversarial loss (RFP w/o GAN) and RAP/RFP without semantic loss (RFP w/o Sem). We observed that both of these losses make contributions to our delightful results, and the semantic loss shows much higher influence than adversarial loss. Note that RAP without $l_{sem}$ is worse than RFP due to its failure to allocate more bits on distinguishable regions as illustrated in Fig. 2.

6 Conclusion

We introduce a LFIC framework integrated with the proposed Region Adaptive Pooling module and a general semantic distortion metric calculation module for task-driven facial image compression. The LFIC enables the image encoder to automatically optimize codec configuration according to integrated semantic distortion metric in an end-to-end optimization manner. Comprehensive experiment has been done to demonstrate the superior performance on our proposed framework compare with some typical image codecs and specific image codecs for facial image compression. We expect to refine prediction and entropy coding modules to further improve compression performance and apply the framework to more general scenarios in future work.

7 Acknowledgement

This work was supported in part by the National Key Research and Development Program of China under Grant No. 2016YFC0801001, the National Program on Key Basic Research Projects (973 Program) under Grant 2015CB351803, NSFC under Grant 61571413, 61632001, 61390514.

Appendix A More Experiments

We give more qualitative results in Figure 8 and Figure 9. Note that, as explained in paper, several specific facial image compression algorithms evaluated their performance using PSNR/SSIM only, and these algorithms’ performance are ranged in $34.20$% $\sim$ $47.18$% bit rate reduction over JPEG2000, which are extracted from their published papers since the authors don’t want to open their code for comparison. On the other hand, for most of specific facial compression algorithms, verification rate drops significantly under $0.2\sim 0.6$ BPP. In contrast, our scheme does not deteriorate significantly even under $0.05$ BPP. We also compared our results with Toderici et al. 777https://github.com/tensorflow/models/tree/master/research/compression without entropy coding, since they didn’t release their trained model for entropy coding.

To achieve this results, we integrate different metrics: adversarial loss, L1 loss and semantic loss. We leverage semantic metric to retain identity, while the use of content loss here is to constrain mapping between pixel space and semantic space. Accordingly, the weight of each metrics is a trade-off in this scheme and we heuristically adjust this hyperparameters at present. The principle is to increase the weight of semantic part as much as possible, while avoiding disturbance to subjective quality of reconstructions.