Deep Residual Learning in the JPEG Transform Domain

TL;DR

This paper presents a method to perform residual network inference directly in the JPEG transform domain, enabling faster image processing with minimal accuracy loss by leveraging JPEG's linearity and sparsity.

Contribution

The authors introduce a novel approach for residual networks to operate in the JPEG domain, including a model conversion algorithm and approximation techniques for ReLU.

Findings

JPEG domain processing speeds up image inference

Minimal accuracy loss with JPEG domain methods

Applicable to image classification tasks

Abstract

We introduce a general method of performing Residual Network inference and learning in the JPEG transform domain that allows the network to consume compressed images as input. Our formulation leverages the linearity of the JPEG transform to redefine convolution and batch normalization with a tune-able numerical approximation for ReLu. The result is mathematically equivalent to the spatial domain network up to the ReLu approximation accuracy. A formulation for image classification and a model conversion algorithm for spatial domain networks are given as examples of the method. We show that the sparsity of the JPEG format allows for faster processing of images with little to no penalty in the network accuracy.

Tables

Table 1. Table 1 : Model conversion accuracies. Spatial and JPEG testing accuracies are the same to within floating point error.

Dataset	Spatial	JPEG	Deviation
MNIST	0.988	0.988	2.999e-06
CIFAR10	0.725	0.725	9e-06
CIFAR100	0.385	0.385	1e-06

Equations

$$p_m(t)=\frac{1}{\sqrt{n}}{y}_o+\sqrt{\frac{2}{n}}\sum _{k=1}^m{y}_k\cos \left(\frac{k(2t+1)\pi }{2n}\right)$$

$$e_m=\sum _{i=0}^n(p_m(i)-x_i{)}^2$$

$$I_{xyk}^{\prime }=J_{xyk}^{hw}{I}_{hw}$$

$$B^{hw}_{xymn}=\left\{\begin{array}[]{lr}1&\text{$h,w$ belongs in block $x,y$ at offset $m,n$}\\ 0&\text{otherwise}\end{array}\right.$$

$$D_{\alpha \beta }^{mn}=\frac{1}{4}V(\alpha )V(\beta )\cos \left(\frac{(2m+1)\alpha \pi }{16}\right)\cos \left(\frac{(2n+1)\beta \pi }{16}\right)$$

$$Z^{\alpha\beta}_{\gamma}=\left\{\begin{array}[]{lr}1&\text{$\alpha,\beta$ is at $\gamma$ under zigzag ordering}\\ 0&\text{otherwise}\end{array}\right.$$

$$S_k^{\gamma }=\frac{1}{q_k}$$

$$J_{xyk}^{hw}=B_{xymn}^{hw}{D}_{\alpha \beta }^{mn}{Z}_{\gamma }^{\alpha \beta }{S}_k^{\gamma }$$

$${\tilde{S}}_{\gamma }^k=q_k$$

$${\tilde{J}}_{hw}^{xyk}=B_{hw}^{xymn}{D}_{mn}^{\alpha \beta }{Z}_{\alpha \beta }^{\gamma }{\tilde{S}}_{\gamma }^k$$

$${\Xi }_{x^{\prime }{y}^{\prime }{k}^{\prime }}^{xyk}={\tilde{J}}_{hw}^{xyk}{C}_{h^{\prime }{w}^{\prime }}^{hw}{J}_{x^{\prime }{y}^{\prime }{k}^{\prime }}^{h^{\prime }{w}^{\prime }}$$

$${\hat{C}}^b=K\star {\hat{J}}^b$$

$${\Xi }_{p^{\prime }{x}^{\prime }{y}^{\prime }{k}^{\prime }}^{pxyk}={\tilde{C}}_{p^{\prime }hw}^{pxyk}{J}_{x^{\prime }{y}^{\prime }{k}^{\prime }}^{hw}$$

$$r(x)=\{\begin{array}{ll}x& x>0\\ 0& x\le 0\end{array}$$

$$H:A^{\ast }\otimes B^{\ast }\times M^{\ast }\otimes N^{\ast }\to A^{\ast }\otimes B^{\ast }$$

$$F_{{\alpha }^{\prime }{\beta }^{\prime }}^{\prime }=F^{\alpha \beta }[D_{\alpha \beta }^{mn}{D}_{{\alpha }^{\prime }{\beta }^{\prime }}^{mn}]G_{mn}$$

$$H_{{\alpha }^{\prime }{\beta }^{\prime }}^{\alpha \beta mn}=D^{\alpha \beta mn}{D}_{{\alpha }^{\prime }{\beta }^{\prime }}^{mn}$$

$$\mathrm{nnm}(x)=\{\begin{array}{ll}1& x>0\\ 0& x\le 0\end{array}$$

$$r(x)=\mathrm{nnm}(x)x$$

$$H_{k^{\prime }}^{kmn}=Z_{\gamma }^k{\tilde{S}}_{\alpha \beta }^{\gamma }{D}^{\alpha \beta mn}{D}_{{\alpha }^{\prime }{\beta }^{\prime }}^{mn}{S}_{{\gamma }^{\prime }}^{{\alpha }^{\prime }{\beta }^{\prime }}{Z}_{k^{\prime }}^{{\gamma }^{\prime }}$$

$$\text{BN}(I)=\gamma \frac{I-\mathrm{E}[I]}{\sqrt{\mathrm{Var}[I]}}+\beta$$

$$D_{00}=\frac{1}{2\sqrt{2N}}\sum _{x=0}^N\sum _{y=0}^N{I}_{xy}$$

$$\mathrm{Var}[X]=\mathrm{E}[Y^2]$$

$$J(\gamma I)=\gamma J(I)$$

$$J(F+G)=J(F)+J(G)$$

Full text

1 Introduction

The popularization of deep learning since the 2012 AlexNet [15] architecture has led to unprecedented gains for the field. Many applications that were once academic are now seeing widespread use of machine learning with success. Although the performance of deep neural networks far exceeds classical methods, there are still some major problems with the algorithms from a computational standpoint. Deep networks require massive amounts of data to learn effectively, especially for complex problems [18]. Further, the computational and memory demands of deep networks mean that for many large problems, only large institutions with GPU clusters can afford to train from scratch, leaving the average scientist to fine tune pre-trained weights.

This problem has been addressed many times in the literature. Batch normalization [12] is ubiquitous in modern networks to accelerate their convergence. Residual learning [11] allows for much deeper networks to learn effective mappings without overfitting. Techniques such as pruning and weight compression [9] are becoming more commonplace. As problems become even larger and more complex, these techniques are increasingly being relied upon for efficient training and inference.

We approach this problem at the level of the image representation. JPEG is the most widespread image file format. Traditionally, the first step in using JPEGs for machine learning is to decompress them. We propose to skip this step and instead reformulate the ResNet architecture to perform its operations directly on compressed images. The goal is to produce a new network that is mathematically equivalent to the spatial domain network, but which operates on compressed images by including the compression transform into the network weights, which can be done because they are both linear maps. Because the ReLu function is non-linear, we develop an approximation technique for it. This is a general method and, to our knowledge, is the first attempt at formulating a piecewise linear function in the transform domain.

The contributions of this work are as follows

The general method for expressing convolutional networks in the JPEG domain 2. 2.

Concrete formulation for residual blocks to perform classification 3. 3.

A model conversion algorithm to apply pretrained spatial domain networks to JPEG images 4. 4.

Approximated Spatial Masking: the first general technique for application of piecewise linear functions in the transform domain

By skipping the decompression step and by operating on the compressed format, we show a notable increase in speed for testing and a marginal speed for training.

2 Prior Work

We review prior work separated into three categories: compressed domain operations, machine learning in the compressed domain, and deep learning in the compressed domain.

2.1 Compressed Domain Operations

The expression of common operations in the compressed domain was an extremely active area of study in the late 80s and early 90s, motivated by the lack of computing power to quickly decompress, process, and recompress images and video. For JPEG, Smith and Rowe [25] formulate fast JPEG compatible algorithms for performing scalar and pixelwise addition and multiplication. This was extended by Shen and Sethi [23] to general blockwise operations and by Smith [24] to arbitrary linear maps. Natarajan and Vasudev [19] additionally formulate an extremely fast approximate algorithm for scaling JPEG images. For MPEG, Chang et al. [2] introduce the basic algorithms for manipulating compressed video. Chang and Messerschmitt [3] give a fast algorithm for decoding motion compensation before DCT which allows arbitrary video compositing operations to be performed.

2.2 Machine Learning in the Compressed Domain

Compressed domain machine learning grew out of the work in the mid 90s. Arman et al. [1] give the basic framework for image processing of compressed images. Feng and Jiang [5] show how image retrieval can be performed directly on compressed JPEGs. He et al. [10] extend their work with a hypothesis testing technique. Wu et al. [30] formulate the popular SIFT feature extraction in the DCT domain.

2.3 Deep Learning in the Compressed Domain

Because deep networks are non-linear maps, deep learning has received limited study in the compressed domain. Ghosh and Chellappa [7] use a DCT as part of their network’s first layer and show that it speeds up convergence for training. This is extended by Ulicny et al. [26] to create separate filters for each DCT basis function. Wu et al. [29] formulate a deep network for video action recognition that uses a separate network for i-frames and p-frames. Since the p-frame network functions on raw motion vectors and error residuals it is considered compressed domain processing, although it works in the spatial domain and not the quantized frequency domain as in this work. Wu et al. show a significant efficiency advantage compared to traditional 3D convolution architectures, which they attribute to the p-frame data being a minimal representation of the video motion. Gueguen et al. [8] formulate a traditional ResNet that operates on DCT coefficients directly instead of pixels, e.g. the DCT coefficients are fed to the network. They show that learning converges faster on this input, further motivating the JPEG representation.

3 Background

We briefly review the JPEG compression/decompression algorithm [27] and introduce the multilinear method that we use to formulate our networks [24].

3.1 JPEG Compression

The JPEG compression algorithm is defined as the following steps.

Divide the image into $8\times 8$ blocks 2. 2.

Compute the 2D forward Discrete Cosine Transform (DCT Type 2) of each block 3. 3.

Linearize the blocks using a zigzag order to produce a 64 component vector 4. 4.

Element-wise divide each vector by a quantization coefficient 5. 5.

Round the the vector elements to the nearest integer 6. 6.

Run-length code and entropy code the vectors

This process is repeated independently for each image plane. In most cases, the original image is transformed from the RGB color space to YUV and chroma subsampling is applied since the human visual system is less sensitive to small color changes than to small brightness changes [28]. The decompression algorithm is the inverse process. Note that the rounding step (step 5) must be skipped during decompression. This is the step in JPEG compression where information is lost and is the cause of artifacts in decompressed JPEG images.

The magnitude of the information loss can be tuned using the quantization coefficients. If a larger coefficient is applied in step 4, then the result will be closer to 0 which increases its likelihood of being dropped altogether during rounding. In this way, the JPEG transform forces sparsity on the representation, which is why it compresses image data so well. This is coupled with the tendency of the DCT to push the magnitude of the coefficients into the upper left corner (the DC coefficient and the lowest spatial frequency) resulting in high spatial frequencies being dropped. Not only do these high spatial frequencies contribute less response to the human visual system, but they are also the optimal set to drop for a least squares reconstruction of the original image:

Theorem 1** (DCT Least Squares Approximation Theorem).**

Given a set of $N$ samples of a signal $X=\{x_{0},...x_{N}\}$, let $Y=\{y_{0},...y_{N}\}$ be the DCT coefficients of $X$. Then, for any $1\leq m\leq N$, the approximation

[TABLE]

of $X$ minimizes the least squared error

[TABLE]

Theorem 2 states that a reconstruction using the $m$ lowest spatial frequencies is optimal with respect to any other set of $m$ spatial frequencies. Proof of Theorem 2 is given in the supplementary material.

3.2 JPEG Linear Map

A key observation of the JPEG algorithm, and the foundation of most compressed domain processing methods [2, 3, 19, 23, 22, 21, 25, 24] is that steps 1-4 of the JPEG compression algorithm are linear maps, so they can be composed, along with other linear operations, into a single linear map which performs the operations on the compressed representation. Step 5, the rounding step, is irreversible and ignored by decompression. Step 6, the entropy coding, is a nonlinear map and its form is computed from the data directly, so it is difficult to work with this representation. We define the JPEG Transform Domain as the output of Step 4 in the JPEG encoding algorithm. This is a standard convention of compressed domain processing. Inputs to the algorithms described here will be JPEGs after reversing the entropy coding.

Formally, we model a single plane image as the type (0, 2) tensor $I\in H^{*}\otimes W^{*}$ where $H$ and $W$ are vector spaces and $*$ denotes the dual space. We always use the standard orthonormal basis for these vector spaces which allows the free raising and lowering of indices without the use of a metric tensor. We define the JPEG transform as the type (2, 3) tensor $J\in H\otimes W\otimes X^{*}\otimes Y^{*}\otimes K^{*}$. $J$ represents a linear map $J:H^{*}\otimes W^{*}\rightarrow X^{*}\otimes Y^{*}\otimes K^{*}$ and is computed as (in Einstein notation)

[TABLE]

We say that $I^{\prime}$ is the representation of $I$ in the JPEG transform domain. The indices $h,w$ give pixel position, $x,y$ give block position, and $k$ gives the offset into the block.

The form of $J$ is constructed from the JPEG compression steps listed in the previous section. Let the linear map $B:H^{*}\otimes W^{*}\rightarrow X^{*}\otimes Y^{*}\otimes M^{*}\otimes N^{*}$ be defined as

[TABLE]

then $B$ can be used to break the image represented by $I$ into blocks of a given size such that the first two indices $x,y$ index the block position and the last two indices $m,n$ index the offset into the block.

Next, let the linear map $D:M^{*}\otimes N^{*}\rightarrow A^{*}\otimes B^{*}$ be defined as

[TABLE]

where $V(u)$ is a normalizing scale factor. Then $D$ represents the 2D discrete forward (and inverse) DCT. Let $Z:A^{*}\otimes B^{*}\rightarrow\Gamma^{*}$ be defined as

[TABLE]

then $Z$ creates the zigzag ordered vectors. Finally, let $S:\Gamma^{*}\rightarrow K^{*}$ be

[TABLE]

where $q_{k}$ is a quantization coefficient. This scales the vector entries by the quantization coefficients.

With linear maps for each step of the JPEG transform, we can then create the $J$ tensor described at the beginning of this section

[TABLE]

The inverse mapping also exists as a tensor $\widetilde{J}$ which can be defined using the same linear maps with the exception of $S$. Let $\widetilde{S}$ be

[TABLE]

Then

[TABLE]

Next consider a linear map $C:H^{*}\otimes W^{*}\rightarrow H^{*}\otimes W^{*}$ which performs an arbitrary pixel manipulation on an image plane $I$. To apply this mapping to a JPEG image $I^{\prime}$, we first decompress the image, apply $C$ to the result, then compress that result to get the final JPEG. Since compressing is an application of $J$ and decompressing is an application of $\widetilde{J}$, we can form a new linear map $\Xi:X^{*}\otimes Y^{*}\otimes K^{*}\rightarrow X^{*}\otimes Y^{*}\otimes K^{*}$ as

[TABLE]

which applies $C$ in the JPEG transform domain. There are two important points to note about $\Xi$. The first is that, although it encapsulates decompression, applying $C$ and compressing, it uses far fewer operations than doing these processes separately since the coefficients are multiplied out. The second is that it is mathematically equivalent to performing $C$ on the decompressed image and compressing the result. It is not an approximation.

4 JPEG Domain Residual Networks

The ResNet architecture, consists of blocks of four basic operations: Convolution (potentially strided), ReLu, Batch Normalization, and Component-wise addition, with the blocks terminating with a global average pooling operation [11] before a fully connected layer performs the final classification. Our goal will be to develop JPEG domain equivalents to these five operations. Network activations are given as a single tensor holding a batch of multi-channel images, that is $I\in N^{*}\otimes P^{*}\otimes H^{*}\otimes W^{*}$.

4.1 Convolution

The convolution operation follows directly from the discussion in Section 3.2. The convolution operation is a shorthand notation for a linear map $C:N^{*}\otimes P^{*}\otimes H^{*}\otimes W^{*}\rightarrow N^{*}\otimes P^{*}\otimes H^{*}\otimes W^{*}$. Since the same operation is applied to each image in the batch, we can represent $C$ with a type (3, 3) tensor. The entries of this tensor give the coefficient for a given pixel in a given input channel for each pixel in each output channel. We now develop the algorithm for representing discrete convolutional filters using this data structure.

A naive algorithm can simply copy randomly initialized convolution weights into this larger structure following the formula for convolution and then apply the JPEG compression and decompression tensors to the result. However, this is difficult to parallelize and incurs additional memory overhead to store the spatial domain operation. A more efficient algorithm would produce the JPEG domain operation directly and be easy to express as a compute kernel for a GPU. Start by considering the JPEG decompression tensor $\widetilde{J}$. Note that since $\widetilde{J}\in X\otimes Y\otimes K\otimes H^{*}\otimes W^{*}$ the last two indices of $\widetilde{J}$ form single channel image under our image model (e.g. the last two indices are in $H^{*}\otimes W^{*}$). If the convolution can be applied to this ”image”, then the resulting map would decompress and convolve simultaneously. We can formulate a new tensor $\widehat{J}\in N\otimes H^{*}\otimes W^{*}$ by reshaping $\widetilde{J}$ and treating this as a batch of images 111Consider as a concrete example using $32\times 32$ images. Then $\widetilde{J}$ is of shape $4\times 4\times 64\times 32\times 32$ and the described reshaping gives $\widehat{J}$ of shape $1024\times 1\times 32\times 32$ which can be treated as a batch of size 1024 of $32\times 32$ images for convolution.. Then, given randomly initialized filter weights, $K$ computing

[TABLE]

where $\star$ indicates the convolution operation and $\widehat{J}^{b}$ indexes $\widehat{J}$ in the batch dimension, gives us the desired map. After reshaping $\widehat{C}$ back to the original shape of $\widetilde{J}$ to give $\widetilde{C}$, the full compressed domain operation can be expressed as

[TABLE]

where $p$ and $p^{\prime}$ index the input and output channels of the image respectively. This algorithm skips the overhead of computing the spatial domain map explicitly and depends only on the batch convolution operation which is available in all GPU accelerated deep learning libraries. Further, the map can be precomputed to speed up inference by avoiding repeated applications of the convolution. At training time, the gradient of the compression and decompression operators is computed and used to find the gradient of the original convolution filter with respect to the previous layers error, then the map $\Xi$ is updated using the new filter. So, while inference efficiency of the convolution operation is greatly improved, training efficiency is limited by the more complex update. We show in Section 5.4 that the training throughput is still higher than the equivalent spatial domain model.

4.2 ReLu

Computing ReLu in the JPEG domain is not as straightforward since ReLu is a non-linear function. Recall that the ReLu function is given by

[TABLE]

We begin by defining the ReLu in the DCT domain and show how it can be trivially extended to the JPEG transform domain. To do this, we develop a general approximation technique called Approximated Spatial Masking that can apply any piecewise linear function to JPEG compressed images.

To develop this technique we must balance two seemingly competing criteria. The first is that we want to use the JPEG transform domain, since it has a computational advantage over the spatial domain. The second is that we want to compute a non-linear function which is incompatible with the JPEG transform. Can we balance these two constraints by sacrificing a third criterion? Consider an approximation of the spatial domain image that uses only a subset of the DCT coefficients. Computing this is fast, since it does not use the full set of coefficients, and gives us a spatial domain representation which is compatible with the non-linearity. What we sacrifice is accuracy. The accuracy-speed tradeoff is tunable to the problem by changing the size of the set of coefficients.

By Theorem 2 we use the lowest $m$ frequencies for an optimal reconstruction. For the $8\times 8$ DCT used in the JPEG algorithm, this gives 15 spatial frequencies total (numbered 0 to 14). We can then fix a maximum number of spatial frequencies $k$ and use all coefficients $\phi$ such that $\phi\leq k$ as our approximation.

If we now compute the piecewise linear function on this approximation directly there are two major problems. The first is that, although the form of the approximation is motivated by a least squares minimization, it is by no means guaranteed to reproduce the original values of any of the pixels. The second is that this gives the value of the function in the spatial domain, and to continue using a JPEG domain network we would need to compress the result which adds computational overhead.

To solve the first problem we examine the intervals that the linear pieces fall into. The larger these intervals are, the more likely we are to have produced a value in the correct interval 222For example if the original pixel value was 0.7 and the approximate value is 0.5, then the approximation is in the correct interval for ReLU ($\geq 0$) but its value is incorrect. in our approximation. Further, since the lowest $k$ frequencies minimize the least squared error, the higher the frequency, the less likely it is to push a pixel value out of the correct range. With this motivation, we can produce a binary mask for each piece of the function. The linear pieces can then be applied directly to the DCT coefficients, and then multiplied by their masks and summed to give the final result. This preserves all pixel values. The only errors would be in the mask which would result in the wrong linear piece being applied. This is the fundamental idea behind the Approximated Spatial Masking (ASM) technique.

The final problem is that we now have a mask in the spatial domain, but the original image is in the DCT domain. There is a well known algorithm for pixelwise multiplication of two DCT images [25], but it would require the mask to also be in the DCT domain. Fortunately, there is a straightforward solution that is a result of the multilinear analysis given in Section 3.2. Consider the bilinear map

[TABLE]

that takes a DCT block, $F$, and a spatial mask $G$, and produces the masked DCT block by pixelwise multiplication. Our task will be to derive the form of $H$. We proceed by construction. The steps of such an algorithm naively would be

Take the inverse DCT of F: $I_{mn}=D^{\alpha\beta}_{mn}F_{\alpha\beta}$ 2. 2.

Pixelwise multiply: $I^{\prime}_{mn}=I_{mn}G_{mn}$ 3. 3.

Take the DCT of $I^{\prime}$: $F^{\prime}_{\alpha^{\prime}\beta^{\prime}}=D^{mn}_{\alpha^{\prime}\beta^{\prime}}I^{\prime}_{mn}$.

Since these three steps are linear or bilinear maps, they can be combined

[TABLE]

Giving the final bilinear map $H$ as

[TABLE]

We call $H$ the Harmonic Mixing Tensor since it gives all the spatial frequency permutations that we need. $H$ can be precomputed to speed up computation.

To use this technique to compute the ReLu function, consider this alternative formulation

[TABLE]

We call the function $\mathrm{nnm}(x)$ the nonnegative mask of $x$. This is our binary mask for ASM. We express the ReLu function as

[TABLE]

This new function can be computed efficiently from fewer spatial frequencies with much higher accuracy since only the sign of the original function needs to be correct. Figure 1 gives an example of this algorithm on a random block and compares it to computing ReLu on the approximation directly. Note that in the ASM image the pixel values of all positive pixels are preserved, the only errors are in the mask. In the direct approximation, however, none of the pixel values are preserved and it suffers from masking errors. The magnitude of the error is tested in Section 5.3 and pseudocode for the ASM algorithm is given in the supplementary material.

To extend this method from the DCT domain to the JPEG transform domain, the rest of the missing JPEG tensor can simply be applied as follows:

[TABLE]

Since the operation is the same for each block, and there are no interactions between blocks, the blocking tensor $B$ can be skipped.

4.3 Batch Normalization

Batch normalization [12] has a simple and efficient formulation in the JPEG domain. Recall that batch normalization defines two learnable parameters: $\gamma$ and $\beta$. A given feature map $I$ is first centered and then normalized over the batch, then scaled by $\gamma$ and translated by $\beta$. The full formula is

[TABLE]

So to define the batch normalization operation in the JPEG domain, we need four parts: the mean, the variance, scalar multiplication and scalar addition. Again, we first derive the result in the DCT domain and trivially extend to the JPEG transform domain.

We start with the sample mean. Observe, from the definition of the DCT, the first DCT coefficient is given by

[TABLE]

In other words, the (0,0) DCT coefficient is proportional to the mean of the block. Further, since the DCT basis is orthonormal, we can be sure that the remaining DCT coefficients do not depend on the mean. This means that to center the image we need only set the (0,0) DCT coefficient to 0. For tracking the running mean, we simply read this value. Note that this is a much more efficient operation than the mean computation in the spatial domain.

Next, to get the variance, we use the following theorem:

Theorem 2** (The DCT Mean-Variance Theorem).**

Given a set of samples of a signal $X$ such that $\mathrm{E}[X]=0$, let $Y$ be the DCT coefficients of $X$. Then

[TABLE]

Intuitively this makes sense because the (0,0) coefficient represents the mean, the remaining DCT coefficients are essentially spatial oscillations around the mean, which should define the variance. Proof of this theorem is given in the supplementary material.

To apply $\gamma$ and the variance, we use scalar multiplication. Since JPEG is linear, this is unchanged

[TABLE]

For scalar addition to apply $\beta$, note that since the (0,0) coefficient is the mean, and adding $\beta$ to every pixel in the image is equivalent to raising the mean by $\beta$, we can simply add $\beta$ to the (0,0) coefficient.

To extend this to JPEG is simple. The proportionality constant for the (0,0) coefficient is $\frac{1}{2\sqrt{2\times 8}}=\frac{1}{8}$. For this reason, many quantization matrices use $8$ as the (0,0) quantization coefficient. This means that the 0th block entry for a block does not need any proportionality constant, it stores exactly the mean. So for adding $\beta$, we can simply set the 0th position to $\beta$ without performing additional operations. The other operations are unaffected.

4.4 Component-wise Addition

Component-wise addition is the simplest formulation in our network. This is a well known result detailed in [2, 21, 23, 25] among others. Since the JPEG transform, $J$, is a linear map, for two images $F$ and $G$, we have

[TABLE]

meaning that we can simply perform a component-wise addition of the JPEG compressed results with no need for further processing.

4.5 Global Average Pooling

Global average pooling also has a simple formulation in JPEG domain. Recall from the discussion of Batch Normalization (Section 4.3) that the 0th element of the block after quantization is equal to the mean of the block. Then this element can be extracted channel-wise from each block and the global average pooling result is the channel-wise mean of these elements.

Furthermore, our network architecture for classification will always reduce the input images to a single block, which can then have its mean extracted and reported as the global average pooling result directly. Note the efficiency of this process: rather than channel-wise averaging in a spatial domain network, we simply have an unconditional read operation, one per channel. This is illustrated in Figure 2.

4.6 Model Conversion

The previous sections described how to build the ResNet component operations in the JPEG domain. While this implies straightforward algorithms for both inference and learning on JPEGs, we can also convert pre-trained models for JPEG inference. This allows any model that was trained on spatial domain images to benefit from our algorithms at inference time. Consider Equation 12. In this equation, $K$ holds the randomly initialized convolution filter. By instead using pretrained spatial weights for $K$, the convoltion will work as expected on JPEGs. Similarly, pretrained $\alpha,\beta,\mu,\sigma$ for batch normalization can be provided. By doing this for each layer in a pretrained network, the network will operate on JPEGs. The only caveat is that the ReLu approximation accuracy can effect the final performance of the network since the weights were not trained to cope with it. This is tested in Section 5.3.

5 Experiments

We give experimental evidence for the efficacy of our method, starting with a discussion of the architectures we use and the datasets. We use model conversion as a sanity check, ensuring that the JPEG model with exact ReLu matches exactly the testing accuracy of a spatial domain model. Next we show how the ReLu approximation accuracy effects overall network performance. We conclude by showing the training and testing time advantage of our method.

5.1 Network Architectures and Datasets

Since we are concerned with reproducing the inference results of spatial domain networks, we choose the MNIST [16] and CIFAR-10/100 [14] datasets since they are easy to work with. The MNIST images are padded to $32\times 32$ to ensure an even number of JPEG blocks. Our network architecture is shown in Figure 3. The classification network consists of three residual blocks with the final two performing downsampling so that the final feature map consists of a single JPEG block. The goal of this architecture is not to get high accuracy, but rather to serve as a point of comparison for the spatial and JPEG algorithms.

5.2 Model Conversion

For this first experiment, we show empirically that the JPEG formulation is mathematically equivalent to the spatial domain network. To show this, we train 100 spatial domain models on each of the three datasets and give their mean testing accuracies. We then use model conversion to transform the pretrained models to the JPEG domain and give the mean testing accuracies of the JPEG models. The images are losslessly JPEG compressed for input to the JPEG networks and the exact (15 spatial frequency) ReLu formulation is used. The result of this test is given in Table 1. Since the accuracy difference between the networks is extremely small, the deviation is also included.

5.3 ReLu Approximation Accuracy

Next, we examine the impact of the ReLu approximation. We start by examining the raw error on individual $8\times 8$ blocks. For this test, we take random $4\times 4$ pixel blocks in the range $[-1,1]$ and scale them to $8\times 8$ using a box filter. Fully random $8\times 8$ blocks do not accurately represent the statistics of real images and are known to be a worst case for the DCT transform. The $4\times 4$ blocks allow for a large random sample size while still approximating real image statistics. We take 10 million blocks and compute the average RMSE of our ASM technique and compare it to computing ReLu directly on the approximation (APX). This test is repeated for all one to fifteen spatial frequencies. The result, shown in Figure 4(a) shows that our ASM method gives a better approximation (lower RMSE) through the range of spatial frequencies.

This test provides a strong motivation for the ASM method, so we move on to testing it in the model conversion setting. For this test, we again train 100 spatial domain models and then perform model conversion with the ReLu layers ranging from 1-15 spatial frequencies. We again compare our ASM method with the APX method. The result is given in Figure 4(b). Again the ASM method outperforms the APX method.

As a final test, we show that if the models are trained in the JPEG domain, the CNN weights will actually learn to cope with the approximation and fewer spatial frequencies are required for good accuracy. The result in Figure 4(c) shows that the ASM method again outperforms the APX method and that the network weights have learned to cope with the approximation.

5.4 Efficiency of Training and Testing

Finally, we show the throughput for training and testing. For this we test on all three datasets by training and testing a spatial model and training and testing a JPEG model and measuring the time taken. This is then converted to an average throughput measurement. The experiment is performed on an NVIDIA Pascal GPU with a batch size of 40 images. The results, shown in Figure 5, show that the JPEG model is able to outperform the spatial model in all cases, but that the performance on training is still limited. This is caused by the more complex gradient created by the convolution and ReLu operations. At inference time, however, performance is greatly improved over the spatial model.

6 Conclusion and Future Work

In this work we showed how to formulate deep residual learning in the JPEG transform domain, and that it provides a notable performance benefit in terms of processing time per image. Our method expresses convolutions as linear maps [24] and introduces a novel approximation technique for ReLu. We showed that the approximation can achieve highly performant results with little impact on classification accuracy.

Future work should focus on two main points. The first is efficiency of representation. Our linear maps take up more space than spatial domain convolutions. This makes it hard to scale the networks to datasets with large image sizes. Secondly, library support in commodity deep learning libraries for some of the features required by this algorithm are lacking. As of this writing, true sparse tensor support is missing in all of PyTorch [20], TensorFlow [17], and Caffe [13], with these tensors being represented as coordinate lists which are known to be highly non-performant. Additionally, the einsum function for evaluating multilinear expressions is not fully optimized in these libraries when compared to the speed of convolutions in libraries like CuDNN [4], though we make use of the opt_einsum [6] tool to partially mitigate this.

7 Acknowledgment

This research was partially funded by Facebook AI Research. We especially thank Dr. Ser-Nam Lim and his team at Facebook for their continued support of our work.