Multi-task learning with compressible features for Collaborative Intelligence

TL;DR

This paper proposes a new loss function for multi-task collaborative intelligence that enhances feature compressibility, enabling around 20% bitrate reduction in transmitting features to the cloud without degrading task performance.

Contribution

It introduces a novel compression-friendly loss function that improves multi-task feature transmission efficiency in collaborative AI systems.

Findings

Achieves approximately 20% bitrate reduction.

Maintains performance across multiple vision tasks.

Enhances efficiency of feature transmission in collaborative AI.

Abstract

A promising way to deploy Artificial Intelligence (AI)-based services on mobile devices is to run a part of the AI model (a deep neural network) on the mobile itself, and the rest in the cloud. This is sometimes referred to as collaborative intelligence. In this framework, intermediate features from the deep network need to be transmitted to the cloud for further processing. We study the case where such features are used for multiple purposes in the cloud (multi-tasking) and where they need to be compressible in order to allow efficient transmission to the cloud. To this end, we introduce a new loss function that encourages feature compressibility while improving system performance on multiple tasks. Experimental results show that with the compression-friendly loss, one can achieve around 20% bitrate reduction without sacrificing the performance on several vision-related tasks.

Tables

Table 1. Table 1 : The average bitrate reduction over test images of the proposed method compared to the benchmark.

Relative bit-rate reduction vs. benchmark	Semantic segmentation	Disparity map estimation	Input reconstruction
Encoder1 ($8\times 16\times 512$)	$-7.81$%	$-2.12$%	$-4.37$%
Encoder2 ($16\times 32\times 256$)	$-20.68$%	$-5.15$%	$-6.09$%

Equations

$${\mathbf{D}}_{H\times H}=\left[\begin{array}{ccccc}1& -1& 0& \dots & 0\\ 0& 1& -1& \dots & 0\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ 0& 0& 0& \dots & -1\\ 0& 0& 0& \dots & 1\end{array}\right]$$

$${\mathbf{F}}_i^x={\mathbf{F}}_i{\mathbf{D}}_{W\times W},{\mathbf{F}}_i^y=({{\mathbf{F}}_i}^{\top }{\mathbf{D}}_{H\times H}{)}^{\top }={\mathbf{D}}_{H\times H}^{\top }{\mathbf{F}}_i$$

$${\mathbf{Z}}_i=\frac{1}{2}({\mathbf{F}}_i^y+{\mathbf{F}}_i^x)$$

$${\mathbf{T}}_i={\mathbf{M}}_c{\mathbf{Z}}_i{\mathbf{M}}_r^{\top }$$

$$L_r=\frac{1}{H\cdot W\cdot C}\sum _{i=1}^C\Vert {\mathbf{T}}_i{\Vert }_1$$

$$\begin{array}{rl}L& =\sum _{i=1}^3{w}_i{L}_i+w_r{L}_r+\log \sqrt{\frac{1}{w_1}}\\ & +\sum _{i=2}^3\log \sqrt{\frac{1}{2w_i}}+\log \sqrt{\frac{1}{2w_r}}\end{array}$$

Full text

**Index Terms— ** Multi-task learning, collaborative intelligence, deep feature compression

1 Introduction

With the advances in Artificial Intelligence (AI), computing, and communications infrastructure, AI-based applications are emerging for mobile devices. The common approach for running the current AI-based mobile applications is to send the data from the mobile device (front-end, or edge) to the cloud (back-end), run AI models in the cloud, and send the results back. New generations of mobile devices are capable of running deep neural models on board [1], however, this presents a great challenge due to limited power and computing resources available. In [2], it is shown that in many cases, the optimal strategy in terms of energy consumption and computation latency is to split the deep model and distribute the computation between the front-end and the back-end. This paradigm is referred to as Collaborative Intelligence (CI).

In CI, the mobile device runs a part of the deep model between the input and some layer, generates a set of deep features, and sends them to the cloud for further processing by the remainder of the deep model, which resides in the cloud. In this context, the issues of deep feature compression [3, 4, 5] and transmission [6] become important. In [3], a HEVC-based lossy deep feature codec was shown to reduce the bitrate by up to 70% without a drop in performance, compared to uploading images directly to the cloud. A near-lossless deep feature codec was proposed in [4] and tested on several deep models. In a recent study [5], deep feature coding efficiency of four general-purpose data codecs was examined. In [6], a simulator for deep feature transmission over packet-loss channels was presented. All these studies considered only task-specific deep models.

Multi-task (MT) models are expected to offer greater utility for CI because their intermediate features can support multiple tasks in the cloud. However, to our knowledge, MT models were not studied in the context of CI thus far. Some of the recent work on MT models includes [7], where a model is developed for simultaneous detection of faces, landmark localization, pose estimation, and gender recognition. Other recent MT models include [8], for detection of privacy-sensitive object classes, and [9], for joint semantic segmentation, detection, and classification. One issue in training MT models is choosing the loss function that accounts for all the tasks, a problem recently studied in [10].

In this paper we develop a MT learning framework with compressible features for CI. To accomplish this, we create a loss function that measures compressibility of intermediate features in the model, and then incorporate this term into an overall loss function, so that the model learns not only to perform multiple tasks, but to do so with features that can be efficiently compressed for upload to the cloud. To the best of our knowledge, this is the first work on the topic. Section 2 presents the proposed framework and the compression-related loss. Implementation details and experimental results are given in Section 3, followed by conclusions in Section 4.

2 The proposed framework

2.1 Multi-task collaborative intelligence

The MT model we consider in this work is shown in Fig. 1. It consists of an “encoder” part, which consists of layers from ResNet-34 [11] and resides on the mobile device. It produces features that will be quantized and compressed, and then transferred to the cloud to perform several tasks.

The inference tasks are executed in the cloud. In Fig. 1 there are three branches (Models 1-3), each responsible for one of the following tasks: semantic segmentation [12], disparity map estimation [12], and input reconstruction. All these models consists of convolutional and transpose convolutional (convolution with upsampling) layers, in order to make the resolution of their output equal to the resolution of the input image. Model 1 maps the received features to a semantic segmentation map, Model 2 maps the features to a disparity map, while Model 3 tries to reconstruct the original input image. We selected these tasks due to the availability of sufficient amount of ground truth, but the overall framework is not dependent on these specific tasks.

One point to note is that each of the three branches in the cloud uses the same set of features. This is in contrast to most of the recent work on MT models [7, 9], where features from different layers of the network are concatenated and then separated according to the tasks to be performed. In the context of CI, such approach would be less appropriate, since features from multiple layers would need to be transferred to the cloud, which would increase the bit rate. In our case (Fig. 1), we only transfer bottleneck features obtained from the last layer of the encoder. This may affect the performance of the our MT model compared to state of the art on each task, but it leads to a more practical CI solution.

Deep feature compression is accomplished following [4]. The Q-Layer in Fig. 1 implements uniform $n$-bit quantization. The quantized feature tensor is then re-arranged into an image tile (Fig. 2) and compressed using either lossless (e.g. PNG) or lossy (e.g. JPEG) image codec. Note that quantization in the Q-Layer is not differentiable, so during training, similar to the method in [13], uniform noise is added to the Q-Layer input to emulate quantization. This keeps the model differentiable, and it can be trained end-to-end. In the testing phase, quantization is applied as usual.

2.2 Deep feature compressibility loss

Loss functions for the three tasks in Fig. 1 are well-defined. The loss for semantic segmentation is the cross-entropy loss in [12]. Mean Squared Error (MSE) loss is chosen for depth prediction, and Mean Absolute Error (MAE) loss is chosen for input reconstruction. However, to be able to accomplish these tasks with compressible features, one needs to include the feature compressibility loss. Such a loss should be related to the bit rate needed to compress the features and it should be differentiable almost everywhere.

To be more specific, let $\mathbf{F}\in\mathbb{R}^{H\times W\times C}$ be the feature tensor at the output of the last layer at the encoder in Fig. 1, where $H$, $W$, and $C$ are the height, width, and channel depth of the feature tensor, respectively. $\mathbf{F}$ is a function of both the input image $\mathbf{X}$ and the weights $\mathbf{W}$ of the encoder model: $\mathbf{F}=f(\mathbf{X};\mathbf{W})$. Note that $f(\cdot)$, being a forward mapping of a neural network, is an (almost everywhere) differentiable function of the weights $\mathbf{W}$ - otherwise the model would not be able to train via backpropagation. What we want to construct is a loss function $L_{r}=g(\mathbf{F})$ that is related to the bit rate required for $\mathbf{F}$, and is differentiable with respect to $\mathbf{F}$ almost everywhere. Then, since $L_{r}=g(f(\mathbf{X};\mathbf{W}))$, this loss term would also be differentiable with respect to $\mathbf{W}$, which is needed for training.

One could easily compute the entropy of $\mathbf{F}$ by, say, quantizing its entries, creating a histogram of their values, and then computing the entropy from the normalized histogram. However, this process is not differentiable with respect to the values in $\mathbf{F}$, so we cannot use entropy as the loss term. Alternative solutions have been proposed in recent image codecs based on deep networks [14, 15, 16], where the feature value probabilities are predicted using another neural network (hence, in a differentiable manner) such as PixelCNN [17] and PixelRNN [18]. Another approach to obtain a bit rate-related quantity is $\rho$-domain analysis [19], where the fraction of non-zero DCT coefficients ($\rho$) is used for this purpose. Authors in [20] estimate the rate by calculating the $\ell_{1}$ norm of the DCT coefficients of either the original (grayscale) input image or the single-channel feature tensor (i.e. feature matrix) obtained from their proposed model.

In this paper we adopt a similar approach, except that we incorporate spatial prediction into the calculation of the loss. Since spatial prediction is used in high-performance image codecs such as HEVC-Intra, we believe this leads to a better estimate of the rate. In addition, our proposed loss can be used on multi-channel tensors as well.

Let $\mathbf{F}_{i}$ be the $i$-th channel of tensor $\mathbf{F}$, $i=1,2,...,C$. Spatial prediction is modeled as Differential Pulse Code Modulation (DPCM) along the rows and columns of $\mathbf{F}_{i}$. Such DPCM can be expressed as matrix multiplication. Let $\mathbf{D}_{H\times H}$ be an $H\times H$ matrix with $1$’s along the main diagonal and $-1$’s along an upper diagonal as shown below:

[TABLE]

Also, let $\mathbf{D}_{W\times W}$ be the $W\times W$ matrix defined analogously. Then horizontal and vertical differencing of $\mathbf{F}_{i}$ can be expressed as

[TABLE]

The horizontal and vertical difference are then averaged, to emulate spatial prediction of elements in $\mathbf{F}_{i}$ from top and left neighbors:

[TABLE]

$\mathbf{Z}_{i}$ now contains spatial prediction residuals of $\mathbf{F}_{i}$. Next, DCT is applied to the prediction residual signal as:

[TABLE]

where $\mathbf{M}_{r}$ and $\mathbf{M}_{c}$ are the DCT matrices for row and column transforms, respectively [21]. Finally, the feature compressibility loss $L_{r}$ is computed as:

[TABLE]

This loss is essentially the $\ell_{1}$ norm of the transformed prediction residual, averaged over the whole feature tensor. Since all the operations used to compute $L_{r}$ from $\mathbf{F}$ are differentiable almost everywhere, this loss satisfies our requirements and can be used in training. In practice, the derivative of the absolute value at [math] is set to $1$, to make the derivative well defined everywhere.

2.3 Multi-task learning loss

The multi-task model in Fig. 1 is trained end-to-end. For this purpose, a single loss function capturing all task-specific losses is needed. A common way to accomplish this is set the overall multi-task loss as a linear combination of task-specific losses. In our case, we have three actual tasks, and one loss term related to the compressibility of deep features.

The next question is how to assign weights for these loss terms in the overall loss function. This question has recently been studied in [10], where the tasks are divided into segmentation-type tasks and regression-type tasks. Each task-specific loss receives a trainable weight and a correction term that helps suppress trivial solutions where the loss is reduced by setting a task-specific weight to zero. In our case, Task 1 (semantic segmentation) is a segmentation-type task, while other tasks (including compressibility) are treated as regression-type tasks. In this case, the optimal overall loss function (see [10] for details) is

[TABLE]

where $L_{i}$ and $w_{i}$, $i=1,2,3$, are the task-specific losses and their weights, respectively, while $L_{r}$ and $w_{r}$ are the compressibility loss and its weight. Note that the weights $w_{i}$ and $w_{r}$ are trainable parameters [10], and are updated using the Adam optimizer [22] after each epoch.

3 Experimental Results

The MT model in Fig. 1 was implemented in Pytorch [23]. Cityscapes dataset [24] was used for training and testing. Cityscapes has 2,975 training images with the corresponding semantic segmentation and disparity map labels available for each image. Testing was done on the 500 images available in the validation set. To avoid memory limitations on GPU, the resolution of the input images was reduced to $512\times 256$. The training was done for 250 epochs with the Adam optimizer [22], with polynomial decay applied to the initial learning rate of $10^{-3}$. The training batch size is 20. The training and testing was performed on a GeForce GTX 1080 GPU. In the testing phase, the deep features were obtained from the encoder network, quantized, rearranged into a tiled image (Fig. 2) and then encoded using an image codec, as explained below. The reverse process takes place on the cloud side and the decoded features are used for the three tasks. Some visual examples are shown in Fig. 3.

Two encoder networks are used in the experiments. One is the entire ResNet-34 (excluding the top classification layer), which produces $8\times 16\times 512$ feature tensors, and which we call Encoder1. The other is ResNet-34 with the last convolutional block excluded (also excluding the top classification layer), which produces feature tensors of size $16\times 32\times 256$, and which we call Encoder2. For each encoder, a separate inference network is trained for each task.

The metrics for evaluating the performance of the tasks are mean Intersection over Union (IoU) for segmentation, Inverse Root Mean Square Error (IRMSE) for disparity estimation, and Peak Signal to Noise Ratio (PSNR) for input reconstruction. Since we are interested in the impact of feature compression on these metrics, we show these against Bits Per Feature Element (BPFE) in Fig. 4. Five points are obtained on each curve: one with the lossless PNG codec, and four with lossy JPEG coding with quality parameters 95, 90, 85, 80. 111Code to reproduce the results in Fig. 4 is available at https://github.com/saeedranjbar12/mtlcfci

The benchmark system is the same model in Fig. 1 but trained without the feature compressibility loss term $L_{r}$ and its weight $w_{r}$ in the overall loss function (6). Hence, the comparison with the benchmark shows whether the compressibility loss was useful in improving the system performance. As seen in Fig. 4, the proposed system is able to achieve better performance than the benchmark on all tasks at most bit rates. Improvements are especially visible in the mIoU plots for the segmentation task in Fig. 4(a) and (b).

To summarize the differences between performance curves in Fig. 4, we use the Bjontegaard delta (BD) approach [25], which measures the average bit rate saving for the same performance metric value between two curves. The results are shown in Table 1 for both encoders, where the bit rate saving of the proposed method compared to the benchmark is shown. Here, negative numbers mean bit rate reduction, which is the desirable outcome. The results show that up to 20% of bits can be saved on some tasks using an appropriate compressibility loss.

The results in Fig. 4 indicate that all three tasks reach a reasonably high performance. However, these numbers are not the current state-of-the-art on each task. As mentioned before, state-of-the-art task-specific models generally avoid bottleneck features and use various connections between multiple layers, making them unsuitable for CI. Our goal here was to study multi-task models in the context of CI, which requires a single set of compressible features to serve all tasks.

4 Conclusion

In this paper we proposed a multi-task learning framework for collaborative intelligence. We developed a differentiable loss term to measure compressibility of bottleneck features and used it in end-to-end training of a multi-task model. The experimental results show that the proposed approach is able to achieve up to 20% bit rate savings on some tasks compared to the model trained without the compressibility loss term, without reduction in performance.