Neural Offset Min-Sum Decoding

TL;DR

This paper introduces a hardware-efficient neural decoding method for error-correcting codes that uses learnable offsets in min-sum decoding, achieving near-multiplicative performance with fewer computations.

Contribution

It proposes a multiplication-free, learnable offset min-sum decoding algorithm that improves error correction while being more suitable for hardware implementation.

Findings

Achieves within 0.1 dB of multiplicative neural decoding performance.

Outperforms traditional belief propagation by up to 1 dB.

Reduces parameter count and computational complexity.

Abstract

Recently, it was shown that if multiplicative weights are assigned to the edges of a Tanner graph used in belief propagation decoding, it is possible to use deep learning techniques to find values for the weights which improve the error-correction performance of the decoder. Unfortunately, this approach requires many multiplications, which are generally expensive operations. In this paper, we suggest a more hardware-friendly approach in which offset min-sum decoding is augmented with learnable offset parameters. Our method uses no multiplications and has a parameter count less than half that of the multiplicative algorithm. This both speeds up training and provides a feasible path to hardware architectures. After describing our method, we compare the performance of the two neural decoding algorithms and show that our method achieves error-correction performance within 0.1 dB of the multiplicative approach and as much as 1 dB better than traditional belief propagation for the codes under consideration.

Equations

$$l_v=\text{log}\left(\frac{p(Y_v=y_v|X_v=-1)}{p(Y_v=y_v|X_v=+1)}\right)=\frac{2y_v}{{\sigma }^2},$$

$${\hat{x}}_v^t=\{\begin{array}{ll}1,& \text{if }{s}_v^t>0\\ 0,& \text{otherwise.}\end{array}$$

$${\mu }_{v,c}^t=l_v+\sum _{c^{\prime }\in \mathcal{N}(v)\backslash c}{\mu }_{c^{\prime },v}^{t-1},$$

$${\mu }_{c,v}^t=2{\text{tanh}}^{-1}\left(\prod _{v^{\prime }\in \mathcal{M}(c)\backslash v}\text{tanh}\left(\frac{{\mu }_{v^{\prime },c}^t}{2}\right)\right),$$

$$s_v^t=l_v+\sum _{c^{\prime }\in \mathcal{N}(v)}{\mu }_{c^{\prime },v}^t.$$

$${\mu }_{c,v}^t=\underset{v^{\prime }\in \mathcal{M}(c)\backslash v}{\min }(|{\mu }_{v^{\prime },c}^t|)\prod _{v^{\prime }\in \mathcal{M}(c)\backslash v}\text{sign}({\mu }_{v^{\prime },c}^t).$$

$$\begin{array}{r}{\mu }_{c,v}^t=\max \left(\underset{v^{\prime }\in \mathcal{M}(c)\backslash v}{\min }(|{\mu }_{v^{\prime },c}^t|)-\beta ,0\right)\\ \cdot \prod _{v^{\prime }\in \mathcal{M}(c)\backslash v}\text{sign}({\mu }_{v^{\prime },c}^t),\end{array}$$

$${\mu }_{v,c}^t=\text{tanh}\left(\frac{1}{2}\left(w_{v,in}^t{l}_v+\sum _{c^{\prime }\in \mathcal{N}(v)\backslash c}{w}_{c^{\prime },v,c}^t{\mu }_{c^{\prime },v}^{t-1}\right)\right)$$

$${\mu }_{c,v}^t=2{\text{tanh}}^{-1}\left(\prod _{v^{\prime }\in \mathcal{M}(c)\backslash v}{\mu }_{v^{\prime },c}^t\right)$$

$$s_v^t=w_{v,out}{l}_v+\sum _{c^{\prime }\in \mathcal{N}(v)}{w}_{c^{\prime },v,c,out}{\mu }_{c^{\prime },v}^t,$$

$$J(w)=\mathbb{E}[H(X,S)],$$

$$H(X,S)=-\frac{1}{n}\sum _v{X}_v\text{log}(\sigma (S_v))+(1-X_v)\text{log}(1-\sigma (S_v)),$$

$$\sigma (x)=\frac{1}{1+e^{-x}}.$$

$$\text{ReLU}(x)=\max (x,0).$$

$${\mu }_{c,v}^t=\text{ReLU}\left(\underset{v^{\prime }}{\min }(|{\mu }_{v^{\prime },c}^t|)-\beta \right)\prod _{v^{\prime }}\text{sign}({\mu }_{v^{\prime },c}^t)$$

$${\mu }_{c,v}^t=\text{ReLU}\left(\underset{v^{\prime }}{\min }(|{\mu }_{v^{\prime },c}^t|)-{\beta }_{c,v}^t\right)\prod _{v^{\prime }}\text{sign}({\mu }_{v^{\prime },c}^t),$$

Full text

I Introduction

Deep learning has enabled great improvement in the last few years in many inference and modelling tasks, such as speech recognition [1], object identification in images [2], and game playing [3]. One of the more recent applications for which deep learning has shown promise is the design of belief propagation (BP) decoders for error-correcting codes. BP is a decoding method which proceeds in iterations of message passing. In [4], Nachmani et al. showed that if the Tanner graph (the graph on which messages are passed) is “unrolled” (that is, each iteration is considered separately) and multiplicative weights are placed on the edges of the graph, the resulting decoder is a neural network that can be trained using gradient-based methods. Such “neural decoders” outperform traditional BP, as they learn to use their weights to mitigate the detrimental effect of cycles in the code structure. Neural decoders also require many fewer iterations and in some cases achieve a bit error rate close to that of the maximum likelihood decoder for certain high-density codes that normally decode poorly using belief propagation.

The approach presented in [4] requires numerous multiplications: the cost of these operations can be high and prevents efficient implementation of these decoders in complexity-critical frameworks, such as real-time hardware implementations. In this paper, we present a modification to offset min-sum decoding (an approximation to BP decoding [5]) in which check nodes learn an additive offset parameter for each edge, rather than a multiplicative weight. Our decoding method achieves error-correction performance similar to the multiplicative weight approach in [4] yet uses no multiplications. It can be optimized using machine learning techniques but requires comparatively few parameters. Moreover, it incurs no extra arithmetic operations, making it fast to train.

The remainder of the paper is structured as follows. Section II describes BP and neural BP. Section III describes the proposed technique, which is validated through a set of experiments in Section IV. We compare our technique with related work in the literature in Section V, and we conclude with Section VI.

II Belief Propagation Decoding

Before describing our contribution, we review the existing methods for belief propagation decoding of linear error-correcting codes.

II-A Traditional Belief Propagation

Consider a communication system that uses a binary code and binary phase shift keying (BPSK) modulation. The transmitter sends a random vector $X\in\{-1,+1\}^{n}$, where $n$ is the code length. The random vector received from the communication channel is $Y=X+Z$, where $Z\in\mathbb{R}^{n}$ is the channel noise vector. If the channel noise is additive white Gaussian noise (AWGN), then the log-likelihood ratio (LLR) of the $v$’th received value is computed using

[TABLE]

where $\sigma^{2}$ is the variance of the channel noise and $y$ is the observed vector of received values.

In BP decoding, probability messages are exchanged between processing nodes to compute the posterior LLRs of the received vector in an iterative fashion. At each iteration $t$, the decoder produces a “soft output” vector $s^{t}$ that converges to the posterior LLRs over the iterations. The recovered binary word can be extracted from $s^{t}$ using a hard decision:

[TABLE]

The Tanner graph, a bipartite graph derived from the parity check matrix of the code [6], defines a set of variable nodes (VNs) and check nodes (CNs) used to compute the soft output. If the ($i$,$j$)-th element of the parity check matrix is a 1, then the $i$’th CN is connected to the $j$’th VN. The message $\mu_{v,c}^{t}$ from VN $v$ to CN $c$ for iteration $t$ is computed using

[TABLE]

where $\mathcal{N}(v)$ is the set of CNs connected to VN $v$, and $\mu_{c,v}^{0}=0$.

The message $\mu_{c,v}^{t}$ from CN $c$ to VN $v$ for iteration $t$ is computed using

[TABLE]

where $\mathcal{M}(c)$ is the set of VNs connected to CN $c$.

Finally, the soft output for iteration $t$ is computed using

[TABLE]

The algorithm obtained from iteratively computing messages and outputs using Equations (2) to (4) is an instance of the sum-product algorithm (SPA) described in [7] and hence is referred to as “SPA decoding”. CNs in SPA decoding must perform multiplications and hyperbolic functions to implement Equation (3). To simplify the CN message computation, Equation (3) can be replaced with the “min-sum” approximation [7]:

[TABLE]

The min-sum approximation causes non-negligible degradation in bit error rate (BER) compared to SPA. Different techniques have been proposed to overcome this issue: one of the most effective is the offset min-sum (OMS) technique [5], in which (5) is replaced with Equation (6):

[TABLE]

where $\beta$ is the correction offset. Proper selection of $\beta$ allows OMS to yield error-correction performance close to that of SPA decoding.

II-B Neural Belief Propagation

If there are no cycles in the Tanner graph, then SPA exactly computes the posterior LLRs, and a hard decision on the soft output gives the optimal error-correction performance for that code. However, cycle-less codes have poor optimal performance, so codes with cycles are used in practice [8]. BP decoding often performs well for codes with cycles, but it is not guaranteed to be optimal. High-density parity check (HDPC) codes, which have many short cycles, have poor BER when decoded using traditional SPA [9].

A novel method for bringing the performance of BP closer to the optimal performance was introduced in [4]. In this method, the input LLRs and the messages sent between nodes are weighted using multiplicative parameters. Thus, to compute messages and outputs, Equations (2), (3), and (4) are replaced with Equations (7), (8), and (9), respectively:

[TABLE]

[TABLE]

[TABLE]

where $w_{v,in}^{t}$, $w_{c^{\prime},v,c}^{t}$, $w_{v,out}$, and $w_{c^{\prime},v,c,out}$ are the aforementioned multiplicative weights. Note that if these weights are equal to 1, then this approach, which we will refer to as “neural SPA”, is equivalent to SPA decoding. While [4] uses SPA as the underlying BP algorithm, we have found that min-sum decoding also achieves excellent results with multiplicative weights, with minimal BER degradation compared to SPA.

A neural SPA decoder is a composition of affine functions and nonlinear functions parametrized by a set of weights, and hence can be considered a kind of neural network. Neural networks are trained using some form of gradient descent: the gradient of the “training loss” (a measure of how poorly the network models the training data) is computed, and the gradient is used to update the weight vector. The updates continue until the training loss is minimized or acceptably low. The gradient is calculated efficiently using backpropagation, an algorithm in which the partial derivatives (informally referred to as the “gradients”) with respect to each layer of the network are calculated recursively using the chain rule. Typically, minibatch stochastic optimization is used: instead of using all training data available, an estimate of the gradient is computed using a small minibatch of examples drawn at random from the training dataset.

The work in [4] shows that it is possible to use minibatch stochastic gradient descent to find weights that improve the error-correction performance of a neural SPA decoder in an offline training phase. Let $w$ be the multiplicative weight vector, and let $J(w)$, the training loss to be minimized, equal

[TABLE]

that is, the expected cross-entropy between the decoder output $S$ and the transmitted codeword in binary format $X$. The cross-entropy, $H(X,S)$, is defined as

[TABLE]

where $\sigma()$, the sigmoid nonlinearity, is a soft, differentiable version of the hard decision,

[TABLE]

The value of $J(w)$ for a particular $w$ can be estimated by computing the average cross-entropy across a minibatch of training codewords. Since every operation in neural SPA is differentiable, it is possible to compute the gradient of $J$ with respect to the parameters, $\nabla_{w}J$, using backpropagation. The parameters can then be incrementally updated using the gradient descent update rule or a variant thereof [10].

Since CN and VN operations in neural SPA satisfy the message passing symmetry conditions in [11], the probability of error is independent of the transmitted codeword. Thus, training data can be formed by adding AWGN to the all-zeros codeword.

III Neural Offset Min-Sum Decoding

In this section, we introduce neural offset min-sum (NOMS) decoding, a learning algorithm which achieves performance similar to that of neural SPA but is more efficient and potentially easier to implement in hardware. NOMS is a generalization of OMS; unlike OMS, which uses a single global offset, NOMS uses multiple learnable offset parameters. The learnable offsets serve the dual purpose of reducing error caused by the min-sum approximation and attenuating cycles in the Tanner graph. In this section, we describe how decoding and training proceed in NOMS.

III-A Decoding

Let ReLU(), the “rectifier” activation function commonly used in deep learning [12], be defined as

[TABLE]

Thus, it is possible to rewrite Equation (6) more compactly as

[TABLE]

for $v^{\prime}\in\mathcal{M}(c)\backslash v$.

Messages between VNs and CNs in NOMS are computed using the same equations as OMS, except Equation (14) is replaced with

[TABLE]

where $\beta_{c,v}^{t}$ is a learnable offset parameter for the edge connecting CN $c$ to VN $v$ during iteration $t$. As is the case for neural SPA decoders, the error-correction performance of a NOMS decoder is independent of the transmitted codeword.

III-B Training

Since all of the operations used in NOMS decoding are differentiable, the offset parameters can be learned using minibatch stochastic gradient descent in an offline phase, as described in Section II. A potential problem for backpropagation arises in that some of the constituent operations (ReLU(), min(), abs(), and sign()) are not differentiable at certain points. Deep learning frameworks such as TensorFlow overcome this problem by simply choosing one of the subgradients at the points of non-differentiability in order to backpropagate through piecewise differentiable operations [13]. This is the approach we take to train NOMS decoders. (Note that since the derivative of sign() is equal to 0 almost everywhere, gradients in the NOMS decoder effectively only flow through the ReLU() branch of the CN.)

III-C Implementation Cost

NOMS can achieve good performance while using substantially fewer operations and parameters than the version of neural SPA presented above. For an $(n,k)$ code with $E$ edges in the Tanner graph and check nodes of degree $d_{c}$, with $T$ iterations of BP unrolled, neural SPA requires $nT+ET(d_{c}-1)+n+nE$ parameters, whereas our approach requires only $ET$ parameters. Likewise, decoding a received vector using neural SPA requires $nT+ET(d_{c}-1)+n+nE$ additional multiplications, while our approach, like OMS, requires $ET$ additions compared to pure min-sum decoding (and therefore no additional arithmetic operations compared to OMS).

III-D Constraining Offset Count

While we only present results in this paper for the case when each edge has its own learnable offset, the number of offsets used by the decoder can be reduced by constraining multiple edges to using the same offset. In particular, if the decoder is constrained to use a single offset for all edges, then NOMS reverts to OMS. Indeed, constraining the decoder to learning a single offset yields a new way to choose the offset for OMS, in addition to the existing methods of simulation and density evolution.

IV Experiments

IV-A Experimental Setup

We compared the performance of NOMS decoding with both traditional SPA and neural SPA, unrolled to 5 iterations. The codes we tested were the same codes as were used in [4], namely, BCH(63,36), BCH(63,45), and BCH(127,106). BCH codes typically do not decode well using traditional BP algorithms, and are therefore a good test case for highlighting the improvement due to learnable parameters. Note that we reduced the number of weights in the neural SPA decoder for the BCH(127,106) code.

To evaluate the performance of the decoders, we performed Monte-Carlo simulation. We created test data by generating random binary messages, encoding them using the BCH generator matrices, modulating the codewords using BPSK, and adding AWGN channel noise. To minimize the variance of the BER estimates, we required a minimum of 100 frame errors to be detected and 100,000 frames to be simulated for each signal-to-noise ratio (SNR).

To train the decoders, we used 20,000 minibatches of 120 received words drawn uniformly from each SNR to simulate and using only the all-zeros codeword as the transmitted codeword. We initialized the offsets to random values drawn from the standard normal distribution. To update the offsets after calculating the gradients, we used the Adam optimizer [14] with a learning rate of 0.1.

IV-B Results

Fig. 1-3 show the performance of the different decoding methods. At low SNRs, both neural decoding methods have roughly the same BER as SPA decoding. At higher SNRs, the neural decoders outperform SPA by as much as 1 dB. NOMS performs close to neural SPA until the highest SNRs simulated.

Another noteworthy aspect of the decoder is the offset distribution. Fig. 4 and Fig. 5 show 20-bin histograms of the offsets for different iterations after the decoder has been trained on 100 minibatches and 3,000 minibatches, respectively. Early in the training process (Fig. 4), the range of values which the offsets are shown to take on remains for the most part close to the standard normal distribution to which all offsets are initialized. Offsets for the third, fourth, and fifth iterations take on values consistent with common values for $\beta$ reported in the OMS literature (see e.g. [15]), suggesting that early in training, the network has at least partly learned to correct the min-sum approximation. Later (Fig. 5), a second mode appears in the histogram for each iteration in a much higher range (at a value of around 7). This occurs when the BER curve of the NOMS decoder starts to match the BER curve of the neural SPA decoder, meaning that after this much training, the NOMS decoder is now no longer only correcting the min-sum approximation, but has also discovered a way to attenuate cycles.

V Related Work

In [16], Zhang et al. note that for irregular LDPC codes, OMS can incur a significant BER degradation compared to SPA decoding. To fight this effect, they suggest having each CN of degree $d$ use offset $\beta_{d}$, rather than a global $\beta$. The authors use a genetic algorithm to choose the offsets for each degree and, interestingly, find that this offsetting scheme not only matches the performance of SPA but can also lower the BER error floor exhibited by some codes.

The approach given in [16] is similar to NOMS in that it uses more than just one global offset. The main difference between this approach and NOMS is that the offsets found by [16] do not depend on particular paths through the Tanner graph, and thus in general may have difficulty overcoming the effect of short cycles, especially if the code has only a few different check node degrees. For the BCH codes considered in this work, for example, every check node has the same degree, so the approach in [16] would yield a single $\beta_{d}$, thus reverting to OMS. NOMS, on the contrary, has the potential to improve performance even for regular codes. Finally, the genetic algorithm used to learn the offsets in [16] is a random heuristic method, which, unlike gradient-based optimization methods, has been found to perform poorly as the size of the optimization problem increases [17].

VI Conclusion

In this work, we proposed NOMS, a new decoding algorithm which generalizes OMS decoding using additive offsets optimized by treating the decoder as a deep neural network. NOMS grants substantial error-correction performance improvements (up to 1 dB for the codes considered here) at a small cost in complexity. In the future, we plan to explore the effect of constraining the number of offsets on BER compared to unconstrained NOMS. We also plan to test NOMS on various other types of codes, such as LDPC codes.

Acknowledgment

The authors would like to thank NVIDIA’s Academic Grant Program for providing the GPU we used for training and testing the decoders. We would also like to thank Dr. Carlo Condo for his helpful comments in the preparation of this paper.