Title: NECST: NEURAL JOINT SOURCE-CHANNEL CODING

Abstract: For reliable transmission across a noisy communication channel, classical results from information theory show that it is asymptotically optimal to separate out the source and channel coding processes. However, this decomposition can fall short in the finite bit-length regime, as it requires non-trivial tuning of hand-crafted codes and assumes infinite computational power for decoding. In this work, we propose Neural Error Correcting and Source Trimming (NECST) codes to jointly learn the encoding and decoding processes in an end-to-end fashion. By adding noise into the latent codes to simulate the channel during training, we learn to both compress and error-correct given a fixed bit-length and computational budget. We obtain codes that are not only competitive against several capacity-approaching channel codes, but also learn useful robust representations of the data for downstream tasks such as classification. Finally, we learn an extremely fast neural decoder, yielding almost an order of magnitude in speedup compared to standard decoding methods based on iterative belief propagation.

1. INTRODUCTION:

We consider the problem of encoding images as bit-strings so that they can be reliably transmitted across a noisy communication channel. Classical results from (Shannon (1948) ) show that for a memoryless communication channel, as the image size goes to infinity, it is optimal to separately: 1) compress the images as much as possible to remove redundant information (source coding) and 2) use an error-correcting code to re-introduce redundancy, which allows for reconstruction in the presence of noise (channel coding). This separation theorem has been studied in a wide variety of contexts and has also enjoyed great success in the development of new coding algorithms.

However, this elegant decomposition suffers from two critical limitations in the finite bit-length regime. First, without an infinite number of bits for transmission, the overall distortion (reconstruction quality) is a function of both source and channel coding errors. Thus optimizing for both: (1) the number of bits to allocate to each process and (2) the code designs themselves is an extremely difficult task. Second, maximum-likelihood decoding is in general NP-hard (Berlekamp et al. (1978) ). Thus obtaining the accuracy that is possible in theory is contingent on the availability of infinite computational power for decoding, which is impractical for real-world systems. Though several lines of work have explored various relaxations of this problem to achieve tractability (Koetter & Vontobel (2003) , Feldman et al. (2005) , Vontobel & Koetter (2007) ), many decoding systems rely on heuristics and early stopping of iterative approaches for scalability, which can be highly suboptimal.

To address these challenges we propose Neural Error Correcting and Source Trimming (NECST) codes, a deep learning framework for jointly learning to compress and error-correct an input image given a fixed bit-length budget. Three key steps are required. First, we use neural networks to encode each image into a suitable bit-string representation, sidestepping the need to rely on hand-designed coding schemes that require additional tuning for good performance. Second, we simulate a discrete channel within the model and inject noise directly into the latent codes to enforce robustness. Third, we amortize the decoding process such that after training, we can scale our model to massively large datasets. These components pose significant optimization challenges due to the inherent non-differentiability of discrete latent random variables. We overcome this issue by leveraging recent advances in unbiased low-variance gradient estimation for variational learning of discrete latent variable models, and train the model using a variational lower bound on the mutual information between the images and their binary representations to obtain good, robust codes. At its core, NECST can also be seen as an implicit deep generative model of the data derived from the perspective of the joint-source channel coding problem.

In experiments, we test NECST on several grayscale and RGB image datasets, obtaining improvements over industry-standard compression (e.g, JPEG) and error-correcting codes (e.g., low density parity check codes). We also learn an extremely fast neural decoder, yielding almost an order of magnitude (two orders for magnitude for GPU) in speedup compared to standard decoding methods based on iterative belief propagation. Additionally, we show that in the process we learn discrete representations of the input images that are useful for downstream tasks such as classification.

2. SOURCE AND CHANNEL CODING:



2.1. PRELIMINARIES:

We consider the problem of reliably communicating data across a noisy channel using a system that can detect and correct errors. Let X be a space of possible inputs (e.g., images), and p data (x) be a source distribution defined over x ∈ X . The goal of the communication system is to encode samples x ∼ p data (x) as messages in a codeword space Y = {0, 1} m . The messages are transmitted over a noisy communication channel, where they are corrupted to become noisy codewords in Y. Finally, a decoder produces a reconstruction x ∈ X of the original input x from a received noisy code y.

The goal is to minimize the overall distortion (reconstruction error) x -x in 1 or 2 norm while keeping the message length m as small as possible (rate). In the absence of channel noise, low reconstruction errors can be achieved using a compression scheme to encode inputs x ∼ p data (x) as succinctly as possible (e.g., JPEG). In the presence of channel noise, longer messages are typically needed to redundantly encode the information and recover from errors (e.g., parity check bits).

2.2. THE JOINT SOURCE-CHANNEL CODING PROBLEM:

Based on fundamental results due to Shannon (Shannon, 1948) , existing systems adhere to the following pipeline. A source encoder compresses the source image into a bit-string with the minimum number of bits possible. A channel encoder re-introduces redundancies, part of which were lost during source coding to prepare the codeword ŷ for transmission. The decoder then leverages the channel coding scheme to infer the original signal ŷ, producing an approximate reconstruction x.

In the separation theorem, Shannon proved that the above approach is optimal in the limit of infinitely long messages. That is, we can minimize distortion by optimizing the source and channel coding processes independently. However, given a finite bit-length budget, the relationship between rate and distortion becomes more complex. The more bits that we reserve for compression, the fewer bits we have remaining to construct the best error-correcting code and vice versa. Balancing the two sources of distortion through the optimal bit allocation, in addition to designing the best source and channel codes, makes this joint source-channel coding (JSCC) problem challenging.

In addition to these design challenges, real-world communication systems face computational and memory constraints that hinder the straightforward application of Shannon's results. Specifically, practical decoding algorithms rely on approximations that yield suboptimal reconstruction accuracies. The information theory community has studied this problem extensively, and proposed different bounds for finite bit-length JSCC in a wide variety of contexts (Pilc (1967) , Csiszar (1982) , Kostina & Verdú (2013) ). Rather than relying on hand-crafted coding schemes that may require additional tuning in practice, we propose to learn the appropriate bit allocations and coding mechanisms using a flexible deep learning framework.

3. NEURAL SOURCE AND CHANNEL CODES:

Given the above considerations, we explore a learning-based approach to the JSCC problem. To do so, we consider a flexible class of codes parameterized by a neural network and jointly optimize for the encoding and decoding procedure. This approach is inspired by recent successes in training (discrete) latent variable generative models, such as VAEs (Neal (1992) , Rolfe (2016), van den Oord et al. (2017) ). We explore the connection to different types of autoencoders in section 4.1.

3.1. CODING PROCESS:

Let X, Ŷ , Y, X be random variables denoting the inputs, codewords, noisy codewords, and reconstructions respectively. We model their joint distribution p(x, ŷ, y, x) using the following graphical model X → Ŷ → Y → X as: p(x, ŷ, y, x) = p data (x)q encoder ( y|x; φ)p channel (y| y; )p decoder (x|y; θ)

(1)

In equation 1, p data (x) denotes the distribution over inputs X . It is not known explicitly in practice, and only accessible through samples. p channel (y| y; ) is the channel model, where we specifically focus on the binary symmetric channel (BSC) case. The BSC independently flips each bit in the codeword with probability (e.g., 0 → 1). Therefore, Ŷ takes values in Ŷ = Y = {0, 1} m and

p channel (y| y; ) = m i=1 yi⊕ yi (1 -) yi⊕ yi⊕1

where ⊕ denotes addition modulo 2 (i.e., an eXclusive OR).

A stochastic encoder q encoder (ŷ|x; φ) generates a codeword ŷ given an input x. Specifically, we model each bit ŷi in the code with an independent Bernoulli random vector. We model the parameters of this Bernoulli with a neural network f φ (•) (an MLP or a CNN) parameterized by φ:

q encoder (ŷ|x, φ) = m i=1 σ(f φ (x i )) ŷi (1 -σ(f φ (x i ))) (1-ŷi)

where σ(z) denotes the sigmoid function.

Similarly, we posit a probabilistic decoder p decoder (x|y; θ) parameterized by an MLP/CNN that, given y, generates a decoded image x. We model each pixel as a factorized Gaussian with a fixed, isotropic covariance to yield: x|y ∼ N (f θ (y), σ 2 I), where f θ (•) denotes the decoder network.

4. END-TO-END VARIATIONAL LEARNING OF NEURAL CODES:

In order to learn an effective coding scheme, we maximize the mutual information between the input X and the corresponding noisy codeword Y (Barber & Agakov (2006) ). That is, the code ŷ should be robust to partial corruption; even its noisy instantiation y should preserve as much information about the original input x as possible (MacKay ( 2003)).

First, we note that we can analytically compute the encoding distribution q noisy enc (y|x; , φ) after it has been perturbed by the channel by marginalizing over ŷ:

q noisy enc (y|x; , φ) = ŷ∈ Ŷ q encoder ( y|x; φ)p channel (y| y; )

which yields:

q noisy enc (y|x; φ, ) = m i=1 (σ(f φ (x i )) -2σ(f φ (x i )) + ) yi (1 -σ(f φ (x i )) + 2σ(f φ (x i )) -) (1-yi)

It is relatively straightforward to handle other types of channel noise; we provide additional examples of the binary erasure channel (BEC) and deletion channel in the Appendix.

We get the following optimization problem:

EQUATION

)

where p(x|y; , φ) is the true (and intractable) posterior from Eq. 1 and p decoder (x|y; θ) is an amortized variational approximation. The true posterior p(x|y; , φ) -the posterior probability over possible inputs x given the received noisy codeword y -is the best possible decoder. However, it is also often intractable to evaluate and optimize. We therefore use a tractable variational approximation p decoder (x|y; θ). Crucially, this variational approximation is amortized (Kingma & Welling ( 2013)), and is the inference distribution that will actually be used for decoding at test time. Because of amortization, decoding is guaranteed to be efficient, in contrast with existing error correcting codes, which typically involve NP-hard MPE inference queries.

Given any encoder (φ), we can find the best amortized variational approximation by maximizing the lower bound (3) as a function of θ. Therefore, the NECST training objective is given by:

max θ,φ E x∼pdata(x) E y∼qnoisy enc (y|x; ,φ) [log p decoder (x|y; θ)]

In practice, we approximate the expectation of the data distribution p data (x) with a finite dataset D:

EQUATION

Thus we can jointly learn the encoding and decoding scheme by optimizing the parameters φ and θ. In this way, the encoder (φ) is "aware" of the computational limitations of the decoder (θ), and is optimized accordingly. However, a main learning challenge is that we are not able to backpropagate directly through the discrete latent variable y; we elaborate upon this point further in Section 5.1.

The solution will depend on the number of available bits m, the noise level , and the structure of the input data x. For intuition, consider the case m = 0. In this case, no information can be transmitted, and the best decoder will fit a single Gaussian to the data. When m = 1 and = 0 (noiseless case), the model will learn a mixture of 2 m = 2 Gaussians. However, if m = 1 and = 0.5, again no information can be transmitted, and the best decoder will fit a single Gaussian to the data.

Adding noise forces the model to decide how it should effectively partition the data such that (1) similar items are grouped together in the same cluster; and (2) the clusters are "well-separated" (even when a few bits are flipped, they do not "cross over" to a different cluster that will be decoded incorrectly). Thus, from the perspective of unsupervised learning, NECST attempts to learn robust binary representations of the data.

4.1. NECST AS A GENERATIVE MODEL:

The objective function in equation ( 4) closely resembles those commonly used in generative modeling frameworks; in fact, NECST can also be viewed as a generative model. In its simplest form, our model with a noiseless channel (i.e., = 0), deterministic encoder, and deterministic decoder is identical to a traditional autoencoder (Bengio et al. (2007) ). Once channel noise is present ( > 0) and the encoder/decoder become probabilistic, NECST begins to more closely resemble other variational autoencoding frameworks. Specifically, NECST is similar to Denoising Autoencoders (DAE) (Vincent et al. (2008) ), except that it is explicitly trained for robustness to partial destruction of the latent space, as opposed to the input space.

NECST is also a variant of the VAE, with two nuanced distinctions. While both models learn a joint distribution over the observations and latent codes, the VAE: (1) optimizes a variational lower bound to the marginal log-likelihood p(X) as opposed to the mutual information I(X, Y ), and

(2) explicitly posits a prior distribution p(Y ) over the latent variables. Their close relationship is evidenced by a line of work on rate-distortion optimization in the context of VAEs (Ballé et al. (2016) , Alemi et al. ( 2017)), as well as other information-theoretic interpretations of the VAE's information preference (Hinton & Van Camp (1993) , Honkela & Valpola (2004) , Chen et al. (2016) ).

We also note that existing autoencoders are aimed at compression, while for sufficiently large m NECST will attempt to learn lossless compression with added redundancy for error correction.

Finally, NECST can be seen as a discrete version of the Uncertainty Autoencoder (UAE) (Grover & Ermon (2018) ). The two models share identical objective functions with two notable differences: For NECST, (1) the latent codes Y are discrete random variables, and (2) the noise model is no longer continuous. The special properties of the continuous UAE carry over directly to its discrete counterpart. Grover & Ermon (2018) proved that under certain conditions, the UAE specifies an implicit generative model (Diggle & Gratton (1984) , Mohamed & Lakshminarayanan (2016) ). We restate their major theorem and extend their results here.

Starting from any data point x (0) ∼ X , we define a Markov chain over X × Y with the following transitions: y (t) ∼ q noisy enc (y|x (t) ; φ, ) , x (t+1) ∼ p decoder (x|y (t) ; θ) (5) Theorem 1. For any fixed value of φ and > 0, suppose that the NECST objective is globally maximized for some choice of θ * so that inequality (3) is tight. Then the Markov Chain (5) with parameters φ and θ * is ergodic and its stationary distribution is given by p data (x)q noisy enc (y | x; , φ).

Proof. See Appendix A.1.

Hence NECST has an intractable likelihood but can generate samples from p data by running the chain above. Samples initialized from both random noise and test data can be found in Appendix D.5.

5. EXPERIMENTAL RESULTS:

We first review the optimization challenges of training discrete latent variable models and elaborate on our training procedure. Then to validate our work, we first assess NECST's compression and error correction capabilities against a combination of two widely-used compression (JPEG, VAE) and channel coding (ideal code, LDPC (Gallager (1962) )) algorithms. We experiment on randomly generated length-100 bitstrings, MNIST (LeCun (1998)), Omniglot (Lake et al. ( 2015)), Street View Housing Numbers (SVHN) (Netzer et al. (2011) ), and CelebA (Liu et al. (2015) ) datasets to account for different image sizes and colors. Next, we test the decoding speed of NECST's neural decoder and find that it performs upwards of an order of magnitude faster than standard decoding algorithms based on iterative belief propagation (and two orders of magnitude on GPU). Finally, we assess the quality of the latent codes after training, and examine interpolations in latent space as well as how well the learned features perform for downstream classification tasks.

5.1. OPTIMIZATION PROCEDURE:

Recall the NECST objective in equation 4. While obtaining Monte Carlo-based gradient estimates with respect to θ is easy, gradient estimation with respect to φ is challenging because these parameters specify the Bernoulli random variable q noisy enc (y|x; , φ). The commonly used reparameterization trick cannot be applied in this setting, as the discrete stochastic unit in the computation graph renders the overall network non-differentiable (Schulman et al. (2015) ).

A simple alternative is to use the score function estimator in place of the gradient, as defined in the REINFORCE algorithm (Williams (1992)). However, this estimator suffers from high variance, and several others have explored different formulations and control variates to mitigate this issue (Wang et al. (2013) To preserve the hard "discreteness" of the latent codes, we used VIMCO (Mnih & Rezende (2016) ), a multi-sample variational lower bound objective for obtaining low-variance gradients. VIMCO constructs leave-one-out control variates using its samples, as opposed to the single-sample objective NVIL (Mnih & Gregor (2014) ) which requires learning additional baselines during training. Thus, we used the 5-sample VIMCO objective in subsequent experiments for the optimization procedure, leading us to our final multi-sample (K = 5) objective:

L K (φ, θ; x, ) = max θ,φ x∈D E y 1:K ∼qnoisy enc(y|x; ,φ) log 1 K K i=1 p decoder (x|y i ; θ) (6)

5.2. FIXED DISTORTION: JPEG + IDEAL CHANNEL CODE:

In this experiment, we compare the performances of: (1) NECST and (2) JPEG + ideal channel code in terms of compression. Specifically, we fix the number of bits m used by NECST to source and channel code and obtain the corresponding distortion levels (reconstruction errors) at various noise levels . For fixed m, distortion will increase with . Then, for each noise level we estimate the number of bits an alternate system using JPEG and an ideal channel code -the best that is theoretically possible -would have to use to match NECST's distortion levels. Assuming an ideal channel code implies that all messages will be transmitted perfectly across the noisy channel; thus the resulting distortion will only be a function of the compression mechanism. We note that some approximations commonly used in the information theory community are used to obtain the analytic expressions used for this estimate. Full details and additional results may be found in Appendix D.1.

We find that with the exception of random data (Appendix D.1), NECST excels at compression; Figure 1 shows that in order to achieve the same level of distortion as NECST, the JPEG-ideal channel code system requires a much larger number bits across all noise levels. In particular, we note that NECST is slightly more effective than JPEG at pure compression ( = 0), and becomes significantly better at higher noise levels (e.g., for = 0.4, NECST requires 20× less bits). The negative result for random bits is to be expected because the data has no exploitable statistical dependencies. 

5.3. FIXED RATE: SOURCE CODING + LDPC:

Next, we compare the performances of: (1) NECST and (2) discrete VAE + LDPC in terms of distortion. Specifically, we fix the bit-length budget for both systems and evaluate whether learning compression and error-correction jointly (NECST) improves reconstruction errors (distortion) for the same rate. We do not report a comparison against JPEG + LDPC as we were often unable to obtain valid JPEG files to compute distortions after imperfect LDPC decoding. However, as we have seen in the JPEG + ideal channel code experiment, we can reasonably assume that the JPEG-LDPC system would have displayed worse performance.

We experiment with a discrete VAE with a uniform prior over the latent codes for encoding. To fix the total number of bits that are transmitted through the channel, we double the length of the VAE encodings with an LDPC channel code to match NECST's latent code dimension m. We note from Figure 2a that although the resulting distortion is similar, NECST outperforms the VAE across all noise levels for image datasets. These results suggest that NECST's learned coding scheme performs at least as well as LDPCs, an industrial-strength, widely deployed class of error correcting codes.

5.4. DECODING TIME:

Another advantage of NECST over traditional channel codes is that after training, the amortized decoder can very efficiently map the transmitted code into its best reconstruction at test time. Other sparse graph-based coding schemes such as LDPC, however, are more time-consuming because decoding involves an NP-hard optimization problem typically approximated with multiple iterations of belief propagation.

To compare the speed of our neural decoder to LDPC's belief propagation, we fixed the number of bits that were transmitted across the channel and averaged the total amount of time taken for decoding across ten runs. The results are shown below in Figure 2b for the binarized MNIST and Omniglot datasets, and refer the reader to Appendix D.7 for the simulated random data. On CPU, NECST's decoder averages an order of magnitude faster than the LDPC decoder running for 50 iterations, which is based on an optimized C implementation. On GPU, NECST displays two orders of magnitude in speedup. 

6. NECST FOR ROBUST REPRESENTATION LEARNING:

In addition to its ability to source and channel code effectively, NECST also serves as an implicit generative model that yields robust and interpretable latent representations and realistic samples from the underlying data distribution. Specifically, in light of Theorem 1, we can think of q encoder ( y|x; φ) as mapping images x to latent representations y.

6.1. INTERPOLATION IN LATENT SPACE:

To assess whether the model has: (1) injected redundancies into the learned codes and (2) learned interesting features, we interpolate between different data points in latent space and qualitatively observe whether the model captures semantically meaningful variations in the data. We select two test points to be the start and end, sequentially flip one bit at a time in the latent code, and pass the altered code through the decoder to observe how the reconstruction changes. In Figure 3 , we show two illustrative examples from the MNIST digits. From the starting digit, each bit-flip slowly alters characteristic features such as rotation, thickness, and stroke style until the digit is reconstructed to something else entirely. We note that because NECST is trained to encode redundancies, we do not observe a drastic change per flip. Rather, it takes a significant level of corruption for the decoder to interpret the original digit as another. Also, due to the i.i.d. nature of the channel noise model, we observe that the sequence at which the bits are flipped do not have a significant effect on the reconstructions. Additional interpolations may be found in Appedix D.4. 

6.2. DOWNSTREAM CLASSIFICATION:

To demonstrate that the latent representations learned by NECST are useful for downstream classification tasks, we extract the binary features and train eight different classification algorithms: knearest neighbors (KNN), decision trees (DT), random forests (RF), multilayer perceptron (MLP), AdaBoost (AdaB), Quadratic Discriminant Analysis (QDA), and support vector machines (SVM).

As shown on the leftmost numbers in Table 1 , the simple classifiers perform reasonably well in the digit classification task for MNIST ( = 0). We observe that with the exception of KNN, all other classifiers achieve higher levels of accuracy when using features that were trained with simulated channel noise ( = 0.1, 0.2). To further test the hypothesis that NECST trained with the noisy channel learns more robust latent features, we freeze the pre-trained model and evaluate classification accuracy using a "noisy" MNIST dataset. We synthesized noisy MNIST by adding ∼ N (0, 0.5) noise to all pixel values in MNIST, and ran the same experiment as above. As shown in the rightmost numbers of Table 1 , we again observe that most algorithms show improved performance with added channel noise.

7. RELATED WORK:

There has been a recent surge of work applying deep learning and generative modeling techniques to lossy image compression, many of which compare favorably against industry standards such as JPEG, JPEG2000, and WebP (Toderici et al. (2015) , Ballé et al. (2016) , Toderici et al. (2017) ). Theis et al. (2017) use compressive autoencoders that learn the optimal number of bits to represent images based on their pixel frequencies. Ballé et al. (2018) (Goodfellow et al. (2014) ) to learn neural codecs for compressing images and videos using DCGAN-style ConvNets (Radford et al. (2015) ). Yet these methods focus on source coding only, and do not consider the setting where the compression must be robust to channel noise.

In a similar vein, there has been growing interest on leveraging these deep learning systems to sidestep the use of hand-designed codes. Several lines of work train neural decoders based on known coding schemes, sometimes learning more general decoding algorithms than before (Nachmani et al. (2016) , Gruber et al. (2017) , Cammerer et al. (2017) , Dorner et al. (2017) ). (Kim et al. (2018a) , Kim et al. (2018b) ) parameterize sequential codes with recurrent neural network (RNN) architectures that achieve comparable performance to capacity-approaching codes over the additive white noise Gaussian (AWGN) and bursty noise channels. However, source coding is out of the scope for these methods that focus on learning good channel codes.

The problem of end-to-end transmission of structured data, on the other hand, is less well-studied. Farsad et al. (2018) use RNNs to communicate text over a discrete, binary erasure channel (BEC) and are able to preserve the words' semantics. The most similar to our work is that of Bourtsoulatze et al. (2018) , who use autoencoders for transmitting images over the AWGN and slow Rayleigh fading channels, which are continuous. We provide a holistic treatment of various discrete noise models and show how NECST can also be used for unsupervised learning.

8. DISCUSSION:

We described how NECST can be used to learn an efficient joint source-channel coding scheme by simulating a noisy channel during training. We showed that the model: (1) is competitive against a combination of industry standard compression and error-correcting codes, (2) learns an extremely fast neural decoder through amortized inference, and (3) learns a latent code that is not only robust to corruption, but also useful for general downstream tasks such as classification.

One limitation of NECST is that we need to train the model separately for different code-lengths and datasets; in its current form, it can only handle fixed-length codes. Extending the model to streaming or adaptive learning scenarios that allow for learning variable-length codes is an exciting direction for future work. Another direction would be to analyze the characteristics and properties of the learned latent codes under different discrete channel models, such as erasure channels. The procedure is as follows:

• make-pchk to create a parity check matrix for a regular LDPC code with three 1's per column, eliminating cycles of length 4 (default setting). The number of parity check bits is: total number of bits allowedlength of codeword. • make-gen to create the generator matrix from the parity check matrix. We use the default dense setting to create a dense representation. • encode to encode the source bits into the LDPC encoding

• transmit to transmit the LDPC code through a bsc channel, with the appropriate level of channel noise specified (e.g. 0.1) • extract to obtain the actual decoded bits, or decode to directly obtain the bit errors from the source to the decoding.

LDPC-based channel codes require larger blocklengths to be effective. To perform an end-to-end experiment with the JPEG compression and LDPC channel codes, we form the input by concatenating multiple blocks of images together into a grid-like image. In the first step, the fixed rate of m is scaled by the total number of images combined, and this quantity is used to estimate the target f (d) to which we compress the concatenated images. In the second step, the compressed concatenated image is coded together by the LDPC code into a bit-string, so as to correct for any errors due to channel noise.

Finally, we decode the corrupted bit-string using the LDPC decoder. The plots compare the resulting distortion of the compressed concatenated block of images with the average distortion on compressing the images individually using NECST. Note that, the experiment gives a slight disadvantage to NECST as it compresses every image individually, while JPEG compresses multiple images together.

We report the average distortions for sampled images from the test set.

Unfortunately, we were unable to run the end-to-end for some scenarios and samples due to errors in the decoding (LDPC decoding, invalid JPEGs etc.).

D.3 VAE-LDPC SYSTEM:

For the VAE-LDPC system, we place a uniform prior over all the possible latent codes and compute the KL penalty term between this prior p(y) and the random variable q noisy enc (y|x; φ, ). The learning rate, batch size, and choice of architecture are data-dependent and fixed to match those of NECST as outlined in Section C. However, we use half the number of bits as allotted for NECST so that during LDPC channel coding, we can double the codeword length in order to match the rate of our model.

D.4 INTERPOLATION IN LATENT SPACE:

We show results from latent space interpolation for two additional datasets: SVHN and celebA. We used 500 bits for SVHN and 1000 bits for celebA across channel noise levels of [0.0, 0.1, 0.2, 0.3, 0.4, 0.5]. We observe that we can generate diverse samples from the data distribution after initializing the chain with both: (1) examples from the test set and (2) random Gaussian noise x 0 ∼ N (0, 0.5).

D.6 DOWNSTREAM CLASSIFICATION:

Following the setup of (Grover & Ermon (2018) ), we used standard implementations in sklearn with default parameters for all 8 classifiers with the following exceptions:

1. KNN: n neighbors=3 2. DF: max depth=5 3. RF: max depth=5, n estimators=10, max features=1 4. MLP: alpha=1 5. SVC: kernel=linear, C=0.025 

:



Figures and Tables:

,Gu et al. (2015),Ruiz et al. (2016), Tucker et al. (2017),Grathwohl et al. (2017)). Others have proposed a continuous relaxation of the discrete random variables, as in the Gumbel-softmax(Jang et al. (2016)) andConcrete (Maddison et al. (2016)) distributions.

Figure 1: Theoretical m required for JPEG + ideal channel code to match NECST's distortion.

Figure 2: (Left) Reconstruction error of NECST vs. VAE + rate-1/2 LDPC codes. Lower is better. (Right) Average decoding times for NECST vs. 50 iterations of LDPC decoding.

Figure 3: Latent space interpolation, where each image is obtained by flipping one additional latent bit and passing through the decoder.

Figure 4: Theoretical m required for JPEG + ideal channel code to match NECST's distortion.

Figure 5: Latent space interpolation of 5 → 2 for SVHN, 500 bits at noise=0.1

Figure 7: Markov chain image generation after 9000 timesteps, sampled per 1000 steps

Classification accuracy on MNIST/noisy MNIST using 100-bit features from NECST.

Table content: <table><tr><td>Noise</td><td>KNN</td><td>DT</td><td>RF</td><td>MLP</td><td>AdaB</td><td>NB</td><td>QDA</td><td>SVM</td></tr><tr><td>0</td><td colspan="3">0.95/0.86 0.65/0.54 0.71/0.59</td><td>0.93/0.87</td><td colspan="4">0.72/0.65 0.75/0.65 0.56/0.28 0.88/0.81</td></tr><tr><td>0.1</td><td colspan="8">0.95/0.86 0.65/0.59 0.74/0.65 0.934/0.88 0.74/0.72 0.83/0.77 0.94/0.90 0.92/0.84</td></tr><tr><td>0.2</td><td colspan="3">0.94/0.86 0.78/0.69 0.81/0.76</td><td>0.93/0.89</td><td colspan="4">0.78/0.80 0.87/0.81 0.93/0.90 0.93/0.86</td></tr></table>

use a variational autoencoder (VAE) (Kingma & Welling (2013) Rezende et al. (2014)) with a learnable scale hyperprior to capture the image's partition structure as side information for more efficient compression. Santurkar et al. (2017) use adversarial training

Table content: <table/>

Peer review (iclr2019):
 Summary of paper: For the finite-bit case of the noisy communication channel model, it is suboptimal to optimize source coding (compression of input) and error correction (fault tolerance for inherent noise in the channel) separately. The authors propose a neural network model (NECST) that is very similar to the standard VAE, except using binary latents with corruption (e.g., random bit flipping in the style of a binary symmetric channel). They use VIMCO to optimize through the discrete units. In their experiments, they show that they can outperform a JPEG+ideal channel code model, but perform similarly to a VAE+LDPC (LDPC is a classic error correcting code) setup. First of all, the paper is quite well written and easily readable. Great work on explaining the motivation and the model -- the writing is clear and explains background knowledge extremely well. The main contribution in the model is the use of discrete binary latents, instead of the standard continuous latents in a VAE. However, I am uncertain about the novelty of this contribution. There have been numerous works examining discrete latent variables in autoencoders (a random sampling: [1, 2, 3, 4]) and beyond. Furthermore, the method of training through discrete latents is also standard (VIMCO, though one can also imagine using more recent advances like REBAR or RELAX). The only difference would be the addition of noise to the discrete. I would be curious to see how that compares to recent works that have also added noise to discrete latents [5]. Thus, it strikes me that the main contribution of this work would be in comparing against the current best techniques for coding. However, the experiments section is weak, and does not provide significant evidence that the NECST model is better than the alternatives. NECST outperforms JPEG+ideal channel coding, but doesn*t do much better than a VAE+LDPC baseline. This suggests that most of the gains comes from the encoder (source coding) model q(.hat{y} | x), instead of the joint training of source coding and error correcting code. It is not surprising that using a neural network to generate codes would provide significant gains. It*s not clear that error correcting code aspect (noise in the latents) is particularly important. Furthermore, in the classification results, the MLP model trained on the discrete codes gets 93% accuracy on noiseless MNIST inputs. You can easily get this accuracy by training logistic regression directly on the pixels. Despite what the authors write, this result suggests that the codes are not very useful for downstream learning. Furthermore, it is unclear why adding random noise to the inputs would significantly improve some of the weaker classifiers. The only reason I can think of is data augmentation, but this has nothing to do with the NECST model. In conclusion, this is a well written paper, but the novelty is not apparent and the experimental results are weak, and so I am not convinced this is suitable for ICLR. Additional Questions: * How is the runtime computed? Specifically, for NECST, do you batch the data and then divide the forward pass time by the batch size? If this is how runtime is computed, it*s not surprising that NECST does better, given that batching is cheap with modern hardware. If the actual forward pass time for a single example is cheaper than that of LDPC*s belief propagation, then that would be quite promising. * The authors state that VAEs optimize a lower bound on the marginal log-likelihood p(X), whereas NECST optimizes a lower bound on the mutual information I(X, Y), where Y is the noised code. The authors however do not discuss why one should optimize for mutual information compared to marginal log-likelihood. What are the advantages and disadvantages between the two? [1] Semi-Supervised Learning with Deep Generative Models (https://arxiv.org/abs/1406.5298) [2] Discrete Variational Autoencoders (https://arxiv.org/abs/1609.02200) [3] Neural Discrete Representation Learning (https://arxiv.org/abs/1711.00937) [4] Discrete Autoencoders for Sequence Models (https://arxiv.org/abs/1801.09797) [5] Theory and Experiments on Vector Quantized Autoencoders (https://arxiv.org/pdf/1805.11063.pdf)