DeepLOB-QR: LLR Quantization via Deep Autoencoders

• The paper presents DeepLOB-QR, featuring a deep autoencoder that maps K soft bits to a three-dimensional latent space reflecting the sufficient statistics of the channel.
• It employs quantization-as-noise training to emulate finite-precision quantization, achieving nearly threefold compression with performance loss below 0.1 dB.
• The method offers practical benefits for LDPC decoders and HARQ buffers by leveraging domain-specific latent representations and a weighted reconstruction loss to prioritize critical soft bits.

Searching arXiv for the specified paper and closely related work. DeepLOB-QR, introduced in the arXiv paper "Deep Log-Likelihood Ratio Quantization" (Arvinte et al., 2019), is a deep learning-based method for lossy compression and finite-precision quantization of bit log-likelihood ratios in a single-input single-output uncorrelated fading communication setting. It uses a deep autoencoder to compress, quantize, and reconstruct the bit log-likelihood ratios corresponding to a single transmitted symbol, with the encoder mapping to a latent space of dimension equal to the number of sufficient statistics required to recover the inputs, namely three. The method is designed for settings in which real-valued LLRs must be stored using a small number of bits, such as in an LDPC decoder or an HARQ buffer, while preserving decoding performance under stringent storage constraints (Arvinte et al., 2019).

1. Channel model and compression objective

The formulation considers a single-input single-output memoryless fading channel

$$r = h\,s + n\,,\quad n\sim\mathcal{CN}(0,\sigma_n^2),\;h\sim\mathcal{CN}(0,1)\,.$$

A transmitter sends constellation points $s\in\mathcal C$ of size $2^K$, so each $s$ carries $K$ bits $\{b_i\}$. At the receiver, bitwise log-likelihood ratios are formed as

$$L_i \;=\;\ln\frac{P(b_i=1\mid r,h)}{P(b_i=0\mid r,h)}\,.$$

The central problem is that these LLRs are real-valued but, in practical receivers, must be stored with a small number of bits. DeepLOB-QR addresses this by designing a lossy compression and finite-precision quantization scheme for the vector of $K$ LLRs arising from each symbol, with the target that subsequent decoding performance degrades by less than about $0.1$ dB while achieving a large compression factor (Arvinte et al., 2019).

This positions DeepLOB-QR at the intersection of neural source coding and soft-information representation for coded modulation. A plausible implication is that the method treats LLR storage not as an isolated scalar quantization problem, but as a structured representation problem in which symbolwise dependencies among bit metrics can be exploited.

2. Sufficient statistics and soft-bit representation

Starting from the exact bit-LLR expression,

$$L_i\;=\;\ln\frac{\sum\limits_{s\in\mathcal C\,:\,b_i(s)=1}\exp\!\big(-\tfrac{|r-hs|^2}{\sigma_n^2}\big)} {\sum\limits_{s\in\mathcal C\,:\,b_i(s)=0}\exp\!\big(-\tfrac{|r-hs|^2}{\sigma_n^2}\big)},$$

the method factors out $s\in\mathcal C$0 and defines

$s\in\mathcal C$1

The real vector

$s\in\mathcal C$2

is sufficient to compute $s\in\mathcal C$3 (Arvinte et al., 2019).

In practice, the method works with soft bits

$s\in\mathcal C$4

which clamp extreme LLRs and yield a more numerically stable training target. The use of $s\in\mathcal C$5 rather than raw $s\in\mathcal C$6 is therefore both a numerical device and a representational choice (Arvinte et al., 2019).

The relationship between the three-dimensional sufficient-statistics domain and the $s\in\mathcal C$7-dimensional soft-bit domain is central. The paper states that the latent space dimension is set equal to the number of sufficient statistics required to recover the inputs. This suggests that the compression strategy is guided by the intrinsic dimensionality of the observation model rather than by the ambient dimensionality of the LLR vector.

3. Autoencoder design and latent-space construction

DeepLOB-QR uses a deep autoencoder that maps the $s\in\mathcal C$8-vector $s\in\mathcal C$9 into a latent space of dimension exactly $2^K$0, and then decodes back to $2^K$1 (Arvinte et al., 2019). The encoder

$2^K$2

consists of six fully-connected ReLU layers building down to dimension $2^K$3, with a final $2^K$4 activation constraining each latent component $2^K$5. The decoder

$2^K$6

is mirror-symmetric, using fully-connected ReLU layers ending in $2^K$7.

During training, a noise layer is inserted into the latent code:

$2^K$8

with $2^K$9. The decoder then reconstructs $s$0. In inference, the noisy latent vector is replaced by a quantized latent representation $s$1 (Arvinte et al., 2019).

The architecture is explicitly tied to the sufficient-statistics argument: by forcing the latent dimension to match the information-theoretic sufficient statistics, the autoencoder learns a bijective but highly nonlinear map

$s$2

This statement appears in the discussion of why the method works (Arvinte et al., 2019). The significance is that the network is not merely reducing dimension; it is attempting to discover a latent coordinate system that is better adapted to quantization than direct scalar quantization of the sufficient statistics.

4. Quantization-as-noise training and inference-time quantization

A hard quantizer is non-differentiable, so DeepLOB-QR imitates its effect during training by injecting Gaussian noise into the three-dimensional latent code:

$s$3

The decoder then attempts to reconstruct the perturbed representation. According to the paper, the Gaussian-noise layer during training induces robustness to finite-precision quantization (Arvinte et al., 2019).

At inference time, true scalar quantization is applied to each latent component $s$4. The procedure is described in four steps:

1. Clip $s$5 to $s$6, with $s$7.
2. Uniformly quantize to $s$8 bits:

$s$9

1. Send or store the three quantized scalars $K$0.
2. Reconstruct $K$1.

The paper also reports that scalar quantization of sufficient statistics $K$2 performs poorly, exhibiting a large error floor under the same bit budget (Arvinte et al., 2019). This is an important comparative point: the effectiveness of DeepLOB-QR is not simply a consequence of compressing to three real values, since a direct three-parameter representation exists but does not quantize well under the same constraints.

5. Loss design, optimization, and SNR-spanning training

DeepLOB-QR uses a weighted reconstruction loss motivated by the observation that not all soft bits are equally important, and that small $K$3 are highly sensitive in LDPC decoding (Arvinte et al., 2019). The distortion measure is

$K$4

with $K$5. Over a training set of $K$6 i.i.d. symbols, the total loss is

$K$7

The parameters $K$8 are optimized via Adadelta over a concatenation of many SNR points so that a single autoencoder works across a wide SNR range (Arvinte et al., 2019). The loss weighting prioritizes reconstruction accuracy for low-magnitude soft bits, which the paper identifies as critical for iterative decoding. This gives the method a task-aware distortion criterion rather than a uniform Euclidean fidelity objective.

A common misconception would be to treat LLR reconstruction quality as adequately characterized by unweighted mean-squared error. The weighted loss used here indicates that the objective is decoder relevance rather than purely signal-domain fidelity. This suggests that the compression mechanism is adapted to the operational semantics of soft information in LDPC message passing.

6. Compression factor, simulation results, and HARQ use case

The paper defines the finite-precision accounting explicitly. The original representation uses $K$9 soft bits, and prior work uses $\{b_i\}$0–$\{b_i\}$1 bits per LLR, so for example $\{b_i\}$2 LLRs $\{b_i\}$3 $\{b_i\}$4 bits gives $\{b_i\}$5 bits. The compressed representation uses three latent components, each quantized with $\{b_i\}$6 bits, giving $\{b_i\}$7 bits per symbol. The compression factor is

$\{b_i\}$8

For $\{b_i\}$9 corresponding to 256-QAM, $$L_i \;=\;\ln\frac{P(b_i=1\mid r,h)}{P(b_i=0\mid r,h)}\,.$$0, and $$L_i \;=\;\ln\frac{P(b_i=1\mid r,h)}{P(b_i=0\mid r,h)}\,.$$1,

$$L_i \;=\;\ln\frac{P(b_i=1\mid r,h)}{P(b_i=0\mid r,h)}\,.$$2

Under this configuration, the block-error-rate loss is below $$L_i \;=\;\ln\frac{P(b_i=1\mid r,h)}{P(b_i=0\mid r,h)}\,.$$3 dB at $$L_i \;=\;\ln\frac{P(b_i=1\mid r,h)}{P(b_i=0\mid r,h)}\,.$$4 BER (Arvinte et al., 2019).

The simulation setup and reported results are summarized below.

Item	Reported configuration or outcome
Channel code	IEEE 802.11 rate-½ LDPC, $$L_i \;=\;\ln\frac{P(b_i=1\mid r,h)}{P(b_i=0\mid r,h)}\,.$$5 symbols
Modulation	256-QAM, $$L_i \;=\;\ln\frac{P(b_i=1\mid r,h)}{P(b_i=0\mid r,h)}\,.$$6 bits per symbol
SNR range	Typically 15–21 dB for $$L_i \;=\;\ln\frac{P(b_i=1\mid r,h)}{P(b_i=0\mid r,h)}\,.$$7–$$L_i \;=\;\ln\frac{P(b_i=1\mid r,h)}{P(b_i=0\mid r,h)}\,.$$8 BLER
Reference quantization	Uniform scalar quantization of each $$L_i \;=\;\ln\frac{P(b_i=1\mid r,h)}{P(b_i=0\mid r,h)}\,.$$9 in $K$0 using 4 bits, giving 32 bits/symbol
Autoencoder result	Latent $K$1, 12 bits/symbol, BLER within 0.1 dB of full-precision decoding
Sufficient-statistics baseline	Performs poorly with a large error floor under the same bit budget

The abstract states that, when applied to a standard rate-1/2 low-density parity-check code, a finite precision compression factor of nearly three times is achieved when storing an entire codeword, with an incurred loss of performance lower than $K$2 dB compared to straightforward scalar quantization of the log-likelihood ratios (Arvinte et al., 2019).

The paper also considers an HARQ scenario with two transmissions, the first quantized and the second full-precision, yielding an effective rate of $K$3. In that case, a compression factor of approximately $K$4 is achieved, corresponding to $K$5 versus $K$6 bits, at negligible performance loss. Even with $K$7 bits total, approximately $K$8 compression, the performance remains close to the hard-output bound (Arvinte et al., 2019).

7. Interpretation, scope, and technical significance

DeepLOB-QR is characterized in the paper as a three-dimensional autoencoder of the $K$9 soft bits, trained with an SNR-spanning dataset and a noise-injection layer to mimic quantization, and using a simple uniform scalar quantizer in the latent space at inference (Arvinte et al., 2019). Its technical significance follows from three stated mechanisms: the latent dimension matches the sufficient-statistics dimension, the Gaussian-noise layer induces robustness to finite-precision quantization, and the weighted loss prioritizes the reconstruction of small LLRs that are critical for iterative decoding.

The method is described specifically for a single-input single-output uncorrelated fading communication setting. That scope is important: the sufficient-statistics argument, the latent dimensionality of three, and the reported performance are tied directly to that setting. A plausible implication is that extensions to other channel models or receiver architectures would require re-examining the sufficient-statistics structure and possibly the latent-space dimension rather than transferring the architecture unchanged.

Another possible misconception is that the method is a generic vector quantizer for arbitrary LLR collections. The paper instead presents it as a symbolwise compression scheme grounded in the structure of the underlying channel model and coded modulation system. Its encoder does not merely reduce storage; it exploits the fact that the bit LLRs associated with a single transmitted symbol are jointly determined by a low-dimensional set of sufficient statistics. In that respect, DeepLOB-QR can be understood as a domain-specific latent representation for soft information storage under finite precision constraints (Arvinte et al., 2019).