NOLD: A Neural-Network Optimized Low-Resolution Decoder for LDPC Codes

I. INTRODUCTION

LOW-DENSITY parity-check (LDPC) codes which were first discovered by Gallager [1] in the 1960s have been theoretically proved to achieve the performance near the Shannonlimit under belief propagation (BP) decoding algorithms [2]. It is believed that LDPC codes are of sustaining potential in the future wireless communication system, which is conceived to be ultra-fast, low-latency, and ultra-reliable [3]–[6].

The min-sum (MS) decoding algorithm has been widely studied as one of the BP decoding algorithms [7]. Compared with its original form, known as the sum-product (SP) decoding algorithm, the MS decoding algorithm has a much lower computational complexity at the cost of slight performance degradation. The performance loss can be compensated by using a normalization factor or an offset factor [8], [9]. These two modified versions of the MS decoding algorithm are called normalized min-sum (NMS) decoding algorithm [8] and offset minsum (OMS) decoding algorithm [9], respectively. The scaling min-sum (SMS) decoding algorithm uses normalization factor and offset factor in synergy and can achieve better performance. Besides, they can narrow the oversized check-to-variable messages to approximate the SP algorithm.

The effects of scaling factors have been analyzed in [10]. It has been shown that SMS outperforms MS by approximating the check-to-variable messages to the SP algorithm. For the regular LDPC codes, fixed scaling factors can be used throughout the decoding process for each node since the performance is insensitive to the scaling factors. The work of [11] proposed a numerical method that directly computes the theoretical values of fixed scaling factors. However, fixed scaling factors are no longer effective for the irregular case. In general, it is supposed to vary the scaling factors from one node to another as well as from one iteration to the next [12].

The typical way is to optimize the values of scaling factors by the adaptive strategies, which design an adaptive rule that computes the optimal scaling factors from the decoder’s feedback at each iteration. The work of [13] utilized a pre-configured lookup table, wherein wherein the proportion of unsatisfied paritycheck equations adaptively determines the scaling factors. It has been shown in [14] that the scaling factors increase exponentially with the iterations and the final values are equal to 1. As a result, the authors of [14] used an exponential equation to calculate the scaling factors. In [15], The adaptive scaling factors are computed by the ratio of the second minimum and the maximum values among the variable-to-check messages. It is noted that these adaptive methods cannot effectively jointly optimize decoding parameters. Moreover, such adaptive processes add some complexity and increase the decoding delay.

Alternatively, the optimal value of the scaling factors can be determined by a probabilistic analytical method called density evolution (DE). The works of [16], [17] employed this numerical method to estimate the optimal scaling factors. In [16], the DE method was used to obtain the optimal scaling factors and then estimated the achievable performance gain induced by the scaling factor. Authors of [17] specified the DE optimization of two-dimensional scaling factors for the scaling min-sum algorithm. Afterward, they introduced a method to determine the two-dimensional scaling factors. The work of [18], [19] analyzed the bit error rate (BER) performance of the LDPC codes under the Rayleigh fading channel and asymmetric memoryless channels by DE, respectively. Nevertheless, there exist two problems with the DE method. On the one hand, the basic premise of DE is that the analyzed LDPC code has infinite code length or cycle-free Tanner graph under the condition of the symmetry channel. On the other hand, searching for the optimal scaling factors based on the DE method becomes intractable when the number of different node degrees is large.

On the other hand, it is an effective way to realize hardware implementation of the min-sum decoder by quantizing the floating belief messages into low-resolution (i.e., 2–4 bits) versions. A very recent work [25] proposed to reduce the hardware complexity by adopting the novel compressed structure of the network. As shown in the work of [24], a dynamic quantization can achieve better performance than a fixed quantization. Welldesigned adaptive rules can dynamically determine the quantization parameters. Authors of [26] proposed an adaptive quantization scheme called quasi-uniform quantization that can match the dynamic range of belief messages. The quasi-uniform quantization uses a uniform quantization interval for the message with a small magnitude and an exponentially increasing interval for the message with a large magnitude. In our previous work [28], the uniform quantization intervals are updated every iteration based on a low-complexity adaptive rule that calculates the numbers of satisfied check nodes. Another way to estimate the quantization parameters is the well-known discrete density evolution (DDE) method [29], which can evaluate the low-resolution performance of the BP decoder and design the quantizer for irregular LDPC codes in [30], [31].

Except for the adaptive optimization and DE optimization of decoding parameters, deep learning-based methods are of great potential since recent technological advancements make deep learning meet the requirements of future wireless networks [32], [33]. Authors of [34] utilized a machine learning technique to optimize the scaling factors of the scaling min-sum algorithm. The work of [35] established a neural network decoder with similar topological construction to the Tanner graph. The neurons corresponding to the edges in the Tanner graph are assigned in the trainable weights. In [38], the extrinsic messages of the BP decoder is jointly optimized by the supervised learning method and the annealing method. A novel decoding architecture proposed in [39], embedding the convolutional neural network (CNN) with a BP decoder, achieves significant performance gains under additive correlated Gaussian noise (ACGN). With the novel Finite-Alphabet Message Passing scheme [27], the authors proposed to optimize the classical iterative decoder of LDPC codes. Besides, the experimental results in [27] proved that the proposed method with 3-bit precision achieves comparable results with the min-sum algorithm.

The deep learning based decoding algorithms [6], [27], [28], [34], paving a new way to decoding LDPC codes, can achieve superior performance at the cost of slightly higher computational complexity when compared to classical ones. In this paper, we propose a new neural-network optimized low-resolution LDPC decoder. The contributions of this work can be summarized as follows.

I. To reduce the min-sum decoder’s hardware cost, we propose to quantize the floating belief messages (i.e., checkto- variable messages and variable-to-check messages) into low-resolution (i.e., 2-4 bits) versions which are beneficial for hardware implementation. To deal with the finite precision effect, we propose a new neural network-based method. The decoding parameters, including scaling factors and quantization step for variable node and check node output messages, are jointly optimized.

II. To fully leverage the advantages of deep learning-based methods, we propose a new activation function whose outputs are close to the employed quantizer ones when network parameters are finally optimized offline. Besides, with the new activation function, the current decoder can be extended to an arbitrary resolution.

III. We verify the performance of the proposed method with numerous case studies. Our results reveal that the proposed decoder enables low-resolution belief messages without a significant performance loss in terms of coded bit error rate performance. What’s more, it is shown that, for both regular and irregular LDPC codes, the proposed approach significantly outperforms several conventional decoders over a wide range of channel conditions.

For reproductive results and possible extensions of the proposed method by interested readers, the decoder developed in this paper has been made publicly available².

²https://github.com/Leo-Chu/NOLD

The rest of the paper is organized as follows. Section II describes the system model. In Section III, we first present the MS decoding and then introduce the modification of MS decoding that operates scaling and quantization on the belief message of each node, which serves as the fundamental decoding scheme of our proposed algorithm. Section IV and Section V elaborates the proposed NOLD decoder and present the simulation results, respectively. Finally, Section VI concludes this paper.

II. SYSTEM MODEL

In this part, we introduce the system model of the lowresolution LDPC decoding. We consider the BPSK modulation over the three noise models.

A. LDPC Codes

At the transmitter, the base-band signals s of length K are encoded to binary coded bits u of length N. The encoded bits u is represented by

where [TeX:] $$\mathbf{H} \in \mathbb{F}_{\not \models}^{\mathbb{M} \times \mathbb{N}}$$ is a binary parity check matrix with M rows, N columns and E 1-elements. The associated Tanner graph G define byHhas N variable nodes,M check nodes and E edges. The variable node v is connected by an edge e to the check node c if the corresponding element in H is equal to 1. The number of check nodes (variable nodes, resp.) that are connected to a variable node v (check node c, resp.) is termed the degree of variable node v (check node c, resp.) and is different from one node to another in an irregular LDPC code. Since H is a sparse matrix, the number of the edges E is far less than [TeX:] $$M \times N.$$

B. Channel Noise Models

The N coded bits u are modulated by a binary-to-bipolar function where the binary signals [TeX:] $$\{0,1\}^{N}$$ are converted to [TeX:] $$\{1,-1\}^{N}.$$ Then the BPSK modulated signals x are sent through an additive white Gaussian noise (AWGN) channel:

where the noise vector n follows Gaussian distribution with zero mean and [TeX:] $$\sigma^{2}$$ variance.

However, practical channels can include fading noise and correlated noise caused by multi-path propagation and inter-symbol interference. The LDPC codes will confront severe performance degradation if the decoder can not deal with the fading and correlated noise.

B.1 Rayleigh Fading Noise Channel

The magnitude of transmit signal will vary randomly or fade when passing through a Rayleigh fading channel. Commonly, a Rayleigh fading model assumes that the real and imaginary parts of the received signal follow zero-mean Gaussian distribution so that the sum of such two independent and identically Gaussian random variables follows a Rayleigh distribution [18], [20]. The Rayleigh fading channel outputs are defined by:

where r is known to the receiver as the Rayleigh fading factor vector whose entries have density probability shown as [TeX:] $$p(r)=2 r \cdot e^{-r^{2}}.$$

B.2 Additive Correlated Gaussian Noise Channel

We analyze one-sided ACGN that has correlation along the temporal dimension instead of the block dimension. The correlated noise is modeled by [TeX:] $$\hat{\mathbf{n}}=\Phi^{\frac{1}{2}} \mathbf{n}$$ where n is an noise vector of length N and [TeX:] $$\Phi \text { is an } N \times N$$ matrix. The entries of n are i.i.d. Gaussian variables and are turned to correlated Gaussian variables by multiplying correlation matrix [TeX:] $$\Phi^{\frac{1}{2}}$$ [23].

To keep the same variance of [TeX:] $$\hat{\mathbf{n}} \text { as } \mathbf{n},$$ we consider [TeX:] $$(1 / K) \text { . }\operatorname{tr}(\Phi)=1$$ Besides, we use an exponential covariance model to define the entries of [TeX:] $$\Phi:$$

where [TeX:] $$\Phi_{i, j}$$ represents the (i, j)th entry of [TeX:] $$\Phi, \text { and } \varphi$$ is the correlation factor with [TeX:] $$|\varphi|<1.$$

The ACGN channel outputs are presented as:

Finally, the channel outputs y are sent to the decoder from the receiver.

C. Quantized Decoding

quantizer is required for the LDPC decoder in consideration of the hardware implementation. The quantizer can output belief messages that take finite discrete values and reduce the power consumption and storage cost [21], [22]. Commonly, [TeX:] $$4 \leq b \leq 7$$ are suitable values (see, e.g., [30] and references therein). The b-bit quantization is shown as follow:

For simplicity, we shall model the quantizer as symmetric uniform quantizer with step size Δ and quantization bit b. We start by defining a set of quantization labels [TeX:] $$Q=\left\{q_{1}, q_{2}, \cdots, q_{2^{b}}\right\}$$ with entries

Moreover, let [TeX:] $$T=\left\{-\infty, t_{1}, \cdots, t_{2^{b}-1}, \infty\right\}$$ specify the set of quantization thresholds. For uniform quantizers, the quantization thresholds are given by

The uniform quantization can be uniquely determined by the set of quantization labels Q and the set of quantization thresholds T. Therefore, the mapping function [TeX:] $$Q u(\cdot)$$ can also be described by the quantization step size Δ and quantization bit b. The quantizer maps the floating inputs into the quantized outputs in the following way:

where [TeX:] $$\lfloor\cdot\rfloor$$ is the rounding down function. The messages that have values smaller than [TeX:] $$q_{1}$$ or larger than [TeX:] $$q_{2^{b}}$$ are respectively saturated to [TeX:] $$q_{1} \text { and } q_{2^{b}}.$$

Although the finite precision effect exacerbates the decoding performance, the uniform quantizer has low hardware complexity and is simple to be implemented. Moreover, the decoding system with uniform quantization obviates the floating-point operations and lookup table storing , reducing the hardware complexity and store memory.

III. MIN-SUM DECODING SCHEME

This section introduces the decoding scheme of our work. To elucidate our proposed algorithm, we first introduce the MS decoding. Then, we will describe MS decoding with lowresolution belief messages.

A. Min-sum Decoding

At the start of the MS decoding, the log-likelihood ratios (LLRs) computed from the channel outputs are sent to the variable nodes as initial variable-to-check messages for the first decoding iteration [7]. The LLRs of MS decoder [TeX:] $$l_{v}^{0}$$ are the channel outputs [TeX:] $$y_{v} \text { for } v=1,2, \cdots, N \text { : }$$

At the following iteration for [TeX:] $$i=1,2, \cdots, I$$ where I represents the maximum number of iterations, the check-node messages and variable-node message are updated as follow:

where [TeX:] $$l_{c, v}^{i}\left(l_{v, c}^{i}, \text { resp. }\right)$$ represents the message passed from check node c (variable node v) to variable node v (check node c) at iteration [TeX:] $$\text { i. } \mathcal{N}(\rfloor)(\mathcal{M}(\sqsubseteq), \text { resp. })$$ denotes the set of neighboring variable nodes (check nodes, resp.) of the check node c (variable node v, resp.).

When the Ith iteration arrives, the check-to-variable messages update as (11) but the variable-to-check updating is a bit different from (12). The variable node combines all the checkto- variable messages and computes the final decoding outputs [TeX:] $$\hat{x}_{v}$$ through a hard decision. The estimated code bits [TeX:] $$\hat{u}_{v}$$ can be obtained after demodulation:

where [TeX:] $$\operatorname{sgn}(\cdot)$$ represents the sign function and [TeX:] $$\mathcal{D}(\cdot)$$ is a BPSK demodulator that converts bipolar signals [TeX:] $$\{1,-1\}^{N}$$ to binary signals [TeX:] $$\{0,1\}^{N}.$$

B. Modification of Min-sum Decoding

Though the MS decoding simplifies the check-to-variable processing, it overestimates the check-to-variable messages and causes a performance loss compared with the SP decoding. The scaling MS algorithm compensates for the performance loss by narrowing the check-to-variable messages. This modified MS algorithm processes the belief messages in a one-dimensional manner without considering the variable-to-check messages. However, the outgoing messages from variable nodes are also the incoming messages to the check nodes in the next iteration. Thus, the variable-to-check messages also play an essential role in the iterative process, which suggests processing both the check-to-variable messages and variable-to-check messages [17]. This two-dimensional scaling MS algorithm can outperform the one-dimensional scaling MS algorithm. It is rational to apply quantization to the check node and variable node in the same light when considering the low-resolution case.

Let [TeX:] $$Q_{x}(\cdot)\left(Q_{y}(\cdot), \text { resp. }\right)$$ be the quantizer for check-tovariable messages (variable-to-check messages, resp.). [TeX:] $$\alpha_{x}$$ and [TeX:] $$\beta_{x}\left(\alpha_{y} \text { and } \beta_{y},\right. \text { resp.) }$$ denote the normalization factor and offset factor for check-node processing (variable-node processing, resp.), respectively. i represents the iteration numbers for [TeX:] $$i=1,2, \cdots, I$$ The channel initialization is shown as:

The check-node processing and variable-node processing are described as:

When it reaches the maximum iteration number I, the variable-to-check processing at iteration I can be represented by (13). As shown in (17) and (18), within one iteration, the outgoing messages from check nodes or variable nodes are scaled and quantized equally for each node. However, it is not efficient for irregular LDPC codes, and we should apply different scaling and quantization to each node for irregular LDPC codes. In this case, an effective method is required to optimize numerous decoding parameters.

IV. PROPOSED DECODING ALGORITHM

A. Proposed Neural Network

In [35], a deep neural network constructed by directly unfolding a Tanner graph optimizes the network parameters and processes the input signals just as an iterative BP decoder. In this part, we extend the trellis representation of the BP decoder to the proposed decoder. Similar to [35], we assign learnable parameters associated with the decoding parameters to each neuron in our neural network termed as NOLD network.

In the NOLD network, the dimension of the input layer and output layer is N, which is the number of the variable nodes (i.e., the code block length). The input layer receives the channel outputs, and the output layer outputs the final marginalization. The other layers are the hidden layers that contain E neurons associated with the edges in the Tanner graph. The NOLD network with 2I hidden layers graphically represents the NOLD decoder with I total iterations.

We define the outputs of the vth neuron corresponding to the variable node v in the input layer (output layer, resp.) as [TeX:] $$x_{v}^{I n}$$ [TeX:] $$\left(x_{v}^{O t}, \text { resp. }\right).$$ We use [TeX:] $$x_{e v, c}^{H d_{i}}$$ to denote the outputs of the neuron corresponding to the edge [TeX:] $$e_{v, c}$$ that connects the variable node v and the check node c in the ith hidden layer.

In the input layer, the neurons receive the channel ouputs [TeX:] $$y_{v}$$ for [TeX:] $$v=1,2, \cdots, N:$$

For the first hidden layer (i.e., i = 1), the neuron associated with the edge [TeX:] $$e_{v, c}$$ is connected to the input neuron corresponding to the variable node v. This layer outputs the quantized and scaled LLRs:

For odd values of [TeX:] $$i(i>1),$$ the neuron associated with the edge [TeX:] $$e_{v, c}$$ is connected to all the neurons corresponding to the edges[TeX:] $$e_{v, c^{\prime}} \text { for } c^{\prime} \in \mathcal{M}(v) \backslash c$$ th layer and is additionally connected to the neuron corresponding to the edge [TeX:] $$e_{v, c}$$ in the first hidden layer. The neurons in this layer deal with the messages in the same way as the variable-to-check processing:

For even values of i, the neuron associated with the edge [TeX:] $$e_{v, c}$$ is connected to all the neurons corresponding to the edges [TeX:] $$e_{v^{\prime}, c}$$ for [TeX:] $$\left.v^{\prime} \in \mathcal{N}(\rfloor\right) \backslash \sqsubseteq \text { in the }(i-1)$$ th layer. The outputs of this layer are equivalent to check-to-variable messages given by:

The neuron that is associated with the vth variable node in the output layer is connected to all the neurons related to the edges [TeX:] $$e_{v, c} \text { for } c \in \mathcal{M}(\sqsubseteq)$$ in the last hidden layer and is also connected to the neuron corresponding to the edge [TeX:] $$e_{v, c}$$ in the first hidden layer. The final outputs of the network are shown as:

In this network, the trainable variables are scaling factors and quantization parameters. The trainable scaling factors are [TeX:] $$\alpha_{v}^{1}, \beta_{v}^{1}$$ for [TeX:] $$v=1,2, \cdots, N \text { and } \alpha_{e_{1}}^{i}, \beta_{e_{1} c}^{i} \text { for } e_{v, c}=1,2, \cdots, E, i=2,3, \cdots, 2 I.$$ The trainable quantization parameters are quantization level sets [TeX:] $$Q_{e_{v, c}}^{i}$$ and in particular for the uniform quantization, are the quantization steps [TeX:] $$\Delta_{e_{v, c}}^{i} \text { for } e_{v, c}=1,2, \cdots, E \text { and }i=1,2, \cdots, 2 I.$$

B. Neural Quantizer

The problem in the neural network is that the quantization function is non-differentiable at some points and its derived function is zero almost everywhere. This obstacle gets us in trouble for obtaining the gradient information from the backward computation process. Hence we can not evaluate the gradients by the backward propagation mechanism. A neural quantizer is needed to be designed for the neural network to train the learnable parameters.

To tackle this difficulty, we introduce a soft quantization function to the neural quantizer [36], [37]. The soft quantization function is suitable for the neural quantizer since it has non-zero derivative values and non-differentiable points. We assume a b- bit precision neural quantizer. The soft quantization function is represented by [TeX:] $$\operatorname{Qn}(\cdot).$$ Given an input x, the quantized outputs can be written as:

where [TeX:] $$Q=\left\{q_{1}, q_{2}, \cdots, q_{2^{b}}\right\}$$ is the quantization level set of the b-bit neural quantizer and [TeX:] $$\eta$$ is a shaping factor. It is also noteworthy that the soft quantization function (24) is the minimum mean square error (MMSE) estimator for a discrete signal over the AWGN channel [38].

A soft quantization function is determined by the quantization level set and smoothness factor. Thus, if the quantization levels are symmetric concerning the origin and each quantization level has the same intervals to its adjacent quantization levels, we can construct a uniform quantization. Fig. 1 shows a two-bit uniform quantization constructed by the soft quantization function. We keep the quantization level set unchanged and tune the shaping factor. It is depicted that the shaping factor significantly affects the shape of the function. As shown in Fig. 1, when [TeX:] $$\eta^{2} \rightarrow \infty,$$ the soft quantization asymptotically approaches the linear function and when [TeX:] $$\eta^{2} \rightarrow 0,$$ the soft quantization degenerates to a hard staircase quantization. Since the smoothness of the soft quantization function is controlled by the shaping factor [TeX:] $$\eta^{2},$$ the shaping factor[TeX:] $$\eta^{2}$$ should be tailored to the determined quantization level set Q. The shaping factor is set to a small number very close to zero according to the number of quantization levels at the training stage. It will be fixed to zero (i.e., hard staircase quantization) during the inference stage.

In our NOLD network mentioned above, each layer’s activation function is replaced by the soft quantization function, increasing the neural network’s generalization ability by introducing nonlinearity and can train the quantization parameters through the quantization activation function.

C. Loss Function

A proper loss function significantly affects the final results. In [35], the sigmoid function is used to preprocess the outputs from the neural network before a cross-entropy function is used to calculate the loss. In [39], a normality test term is introduced to the loss function so that the distribution similarity between the residual noise and Gaussian noise can be evaluated. By minimizing the normality test, the distribution of a network’s outputs is shaped to approximate Gaussian distribution.

For the final output layer, we map the final marginalization to the code bits by the activation function which replaces the hard decision in the standard BP algorithm. However, the sign function we used in the BP decoder has zero derivation almost everywhere except for some non-differentiable point. We can obtain a soft sign function by utilizing the soft quantization function in (24). We set [TeX:] $$b=2, Q=\{-1,1\}$$ and get a neural sign function [TeX:] $$\operatorname{nsgn}(\cdot)$$ :

The BPSK demodulator [TeX:] $$\mathcal{D}(\cdot)$$ receives the neural decision and outputs the estimated code bits. We use [TeX:] $$\theta(\cdot)$$ to represent this final process:

Note that, if we set [TeX:] $$\eta^{2}=2, \theta(\cdot)$$ degenerates to a sigmoid function. The sigmoid activation function used in the output layer estimates the belief probability distribution of the code bit. Since the target outputs [TeX:] $$u_{v}$$ and actual outputs [TeX:] $$O_{v}$$ belong to interval [0, 1], we use the cross-entropy function to calculate the loss:

The cross-entropy loss function, which represents a measure of the divergence between [TeX:] $$u_{v} \text { and } O_{v},$$ has a fast convergence by using the gradient descent method [32]. The NOLD network minimizes the cross entropy in (27) and gets the optimized values of the decoding parameters.

D. The Proposed Neural-network Optimized Low-resolution Decoding Algorithm

The frame-chart of the proposed NOLD decoder is shown in Fig. 2, which can be divided into two stages: Offline training and Online decoding. At the offline training stage, the proposed NOLD network tries to obtain a global optimization of the decoding parameters. The network contains a four-layer network that optimizes one-iteration parameters. The network receives the irrelevant messages as the training data from the concatenated NOLD decoder. The decoding parameters that best fit the training data are chosen to configure the NOLD decoder for the next iteration. The network optimization will not stop until some criteria are satisfied. For the online decoding stage, the trained parameters (scaling factors and the quantization parameters) are sent to the decoder for further inference. The detailed analysis will be given in the following.

We start by introducing some assumptions. Let an irregular LDPC code has variable-node degree distribution [TeX:] $$\lambda(x)=\sum_{d=1}^{d v_{\max }} \lambda_{d} x^{d-1}$$ and check node degree distribution [TeX:] $$\sum_{d=1}^{d c_{\max }} \rho_{d} x^{d-1}.$$ Let dv (v) be the degree of the variable node v

for [TeX:] $$v=1,2, \cdots, N \text { and } d c(c)$$ be the degree of the check node c for [TeX:] $$c=1,2, \cdots, M . \alpha_{d v}^{i} \text { and } \beta_{d v}^{i}$$ denote the normalization factor and the offset factor for the variable nodes with degree dv at decoding iteration i for [TeX:] $$d v=1,2, \cdots, d v_{\max } . \alpha_{d c}^{i}$$ and [TeX:] $$\beta_{d c}^{i}$$ denote the normalization factor and the offset factor for the check nodes with degree dc at decoding iteration i for dc = [TeX:] $$1,2, \cdots, d c_{\max } . q_{d v}^{i}(\cdot)$$ represents the ith-iteration quantization for variable nodes with degree dv for [TeX:] $$d v=1,2, \cdots, d v_{\max }.q_{d c}^{i}(\cdot)$$ represents the ith-iteration quantization for check nodes with degree [TeX:] $$d c \text { for } d c=1,2, \cdots, d c_{\max }.$$

The network has a four-layer architecture that represents oneiteration decoding. The first layer, called the input layer, has E neurons corresponding to the edges in the Tanner graph. Each neuron associated with the edge [TeX:] $$e_{v, c}$$ in the input layer receives the ith-iteration check-to-variable message that passes through the edge [TeX:] $$e_{v, c}$$ from the NOLD decoder:

The second layer (i.e., the first hidden layer) carries out a similar procedure to the ith (i odd) hidden layer. Each neuron receives the extrinsic message in this layer, which is quantized and scaled LLR from the NOLD decoder. Besides, each neuron casts up all intrinsic messages from all connected neurons in the input layer. For variable-irregular LDPC codes, the variable-tocheck messages should be scaled and quantized considering the degree differences among the adjacent variable nodes. Thus, we assign the same parameters to the neurons associated with the variable nodes that have the same degree:

In the third layer, that is, the second hidden layer, the connection of the neurons to the previous layer is similar to the ith (i even) hidden layer. For check-irregular LDPC codes, we also consider the check-dimensional optimization of decoding parameters for different check node degrees. The outputs of this layer are:

It is noteworthy that if we consider highly popular checkregular LDPC codes³>, only variable-dimensional scaling is needed, and we can use the same quantization for both variable nodes and check nodes within an iteration. So, it is not necessary to assign learnable parameters in this layer. Thus, the computational complexity can be reduced by cutting down the number of trainable variables. Since the layer applies only minimization and symbolization operations, the messages outgoing from this layer have the same value as the incoming messages. We can omit the quantization in this layer, and the outputs are:

ㅣ6789 ³ The check-regular LDPC codes are highly popular since they are capacityachieving in a much stronger sense than other LDPC codes and have a more straightforward implementation in hardware.

The output layer represents the final hard decision step in the BP decoder and outputs the final marginalization. This layer has N neurons and the same connection to the previous layer as the second layer. It also receives irrelevant information from the concatenated NOLD decoder. The outputs of this layer are defined as:

The outputs are N-length messages associated with the NOLD decoding outputs at iteration i + 1. Before calculating the loss function, the outputs of the final layer should be preprocessed by an activation function [TeX:] $$\theta(\cdot)$$ in (26):

The network renews the parameters by minimizing the gap between the final outputs and target codewords. When the neural optimization stops, we obtain the optimized decoding parameters for the ith iteration. For the next iteration, and (i + 1)- iteration NOLD decoder is fed by the newly optimized parameters and outputs the training database for the initialized NOLD network. Then the network optimizes the parameters for the (i + 1)th iteration. The neural optimization for the parameters carries on until the maximum number of iteration is reached.

E. Discussions and Complexity Analysis

In the proposed NOLD algorithm, both the scaling and quantization parameters contribute to the LDPC decoding performance, but in very different ways. The scaling factors can narrow the MS messages to approximate the SP messages, which is beneficial for the decoding accuracy. At the same time, the low-resolution quantization reduces the memory cost and hardware complexity. To identify the contribution of scaling factors under low-resolution, we proposed two strategies for optimizing the NOLD decoder’s decoding parameters.

1) Joint Optimization. During the training stage, with such a strategy, both the scaling factors and the quantization parameters are jointly assigned to and optimized by the proposed network.

2) Single Optimization.We only optimize the quantization parameters by the proposed network off-line, thus yielding low computational complexity. The scaling factors are set to Α = 1.0 and Β = 0.0. See Section V.D for more explanations.

For the long-length codewords, a large number of parameters in the standard DNN lead to high computational complexity and strongly restrict the usability in budget-constrained devices even though for a four-layer shallow network. However, the proposed method introduced a quantization method that reduces memory usage or complexity during the learning phase while suffering from a minimal drop-in decoding performance compared to floating baselines. Besides, efficient implementations can benefit from the check-to-variable layers in which simple arithmetical multiplications follow complex hyperbolic tangent operations. Furthermore, The sharing weight for the nodes with the same degree reduces the number of network parameters.

It is noted that when comparing to the classical MS decoder with belief messages, the proposed method employed the quantized messages, which should be optimized by a neural network. The proposed method achieves some performance gain at the expense of an increased training budget. Let [TeX:] $$O\left(N_{L D P C}\right)$$ be the number of floating-point operations (FLOPs) by the classical LDPC decoder. As shown in Fig. 2, the proposed method has an additional training complexity from a four-layer neural network and some numeric operations (the minimization shown in Eq. (31)). Here, we borrow the analytic tools from [40] to give detailed complexity analysis (indicated by FLOPs). For one Multilayer Perceptron based network layer, we can compute the FLOPs [40] as

where [TeX:] $$D_{\text {in }} \text { and } D_{\text {out }}$$ are the input and output dimensionality, respectively. In out case, with the analysis shown in Section IV-D, we have [TeX:] $$F L O P s=O((2 E-1)(3 E+D)),$$ where E and N denote the numbers of edges and nodes, respectively. Overall, for the training stage, with K iterations, the proposed method will enjoy [TeX:] $$F L O P s=O(K((2 E-1)(3 E+D))+E)$$ over the well-established LDPC decoder (i.e., MS). However, for the Online inference, we only need to send the trained parameters (scaling factors and the quantization parameters) to the decoder, which indicates that the proposed method can have a similar computational complexity with the classical decoder.

V. SIMULATIONS

In all experiments, the simulations are implemented in the TensorFlow platform. The experimental LDPC codes are (1998; 1512) quasi-cyclic LDPC code and (155, 62) Tanner code taken from [41] and [42]. The two LDPC codes are labeled as I [(1998, 1512) quasi-cyclic LDPC code] and II [(155; 62) Tanner code] for future reference.

Before training the network, the training data is first generated under AWGN. In the following experiments, we use all-zero codewords. We pay particular attention to the range of SNR that corresponds to the [TeX:] $$\mathrm{BER}=10^{-4}-10^{-5}$$ and its proximity since it’s the critical SNR range in LDPC decoder implementations. The training data is generated under multiple SNRs in the critical SNR range (9 SNRs for a 2 dB-SNR range). For each SNR, we generate [TeX:] $$4 \times 10^{8}$$ bits of LDPC codes as training data. Another [TeX:] $$2 \times 10^{7}$$ bits of LDPC codes are generated as the validation data to achieve 100 codeword errors at the BER level of [TeX:] $$10^{-4}-10^{-5}.$$

The proposed network is set to two-bit resolution (i.e., b = 2). The initial value of the quantization parameter (i.e., quantization step Δ) is set to 2/3 and the initial quantization level set is set to [TeX:] $$\{-1,-1 / 3,1 / 3,1\}$$ As for the scaling factors, the initial values of the normalizing factor and offset factor are respectively set to Α = 1.0 and Β = 0.0.

We use the stochastic gradient descent during the network training to train the neural network with a training batch size of 1000. We use the Adam optimization method to search for the optimal decoding parameters. The loss will be checked every 100 epochs over the validation set, and the training process will reach an early stop if the loss does not drop for some time (800 epochs in our experiment).

Several state-of-art algorithms, such as the numerical method [11], the adaptive method [28] and the DE method [16] are included for decoding performance comparison. In detail, the adaptive method adds an adaptive module to select correct decoding parameters for the next iteration after each decoding iteration. The DE method computes the decoding error probability and searches for the decoding parameters that minimize the error probability. The MS decoder with infinite-resolution data converters serves as the benchmark for all compared methods. The maximum number of decoding iterations is fixed to 20. The decoding performance is measured by the coded bit error rate (BER). The above settings are the same throughout all experiments unless otherwise specified.

A. The Decoding Performance over Regular Codes and Irregular Codes

We first compare the 2-bit decoding performance of the proposed algorithm and other state-of-art algorithms under AWGN noise. For the numerical method in [11], the parameters are optimized in a specific SNR range for all SNR values and utilize the optimized parameters of the first iteration for all subsequent iterations. The adaptive method in [28] adopts the three sets of parameters and chooses one set of parameters from these three sets according to an adaptive rule for different iterations and SNRs. The DE decoder in [16] is also included for comparison. We present the results of all employed methods for three BER regions (labeled as “high BER region”, “medium BER region”, “low BER region”). Three BER regions represent a certain BER range that is respectively corresponding to: [TeX:] $$10^{-2}-10^{-3}, 10^{-3}-10^{-4} \text { , and } 10^{-4}-10^{-5}.$$ The BER performance of all the mentioned methods for the irregular code I and the regular code II is shown in Figs. 3 and 4, respectively.

In Fig. 3, the performance of the numerical method with three BER regions has a similar decoding performance to the adaptive method in their respective SNR range but can not achieve ideal performance out of that SNR region. This can be explained by the fact that the numerical method and the adaptive method use fixed parameters for the irregular LDPC codes. In fact, no matter what parameters the decoder chooses, the fixed parameters can not efficiently improve the decoding performance over a wide range of SNRs. On the other hand, as shown in Fig. 3, the adaptive decoder in [28] can support a wide range of SNRs. The DE method that uses different parameters for different iterations and SNRs can also get a good performance close to the adaptive method. The significant performance gains of both the adaptive method and the DE method suggest that we should apply dynamic decoding parameters for irregular LDPC codes. Our proposed NOLD decoder dynamically updates the parameters updating strategy with a neural network optimization method and achieves better performance than all competing methods, especially when BER is between [TeX:] $$10^{-3} \text { and } 10^{-5}$$

For the regular code II, we present the results of the numerical method for the SNR range from 0.5 dB to 1.0 dB that is corresponding to BER from [TeX:] $$10^{-4} \text { to } 10^{-5}$$ in Fig. 4. For the regular LDPC codes, all decoders’ performance improves linearly with the increased SNR, demonstrating that the decoding performance is less sensitive to the decoding parameters compared with the irregular LDPC codes. Fig. 4 also illustrates that the adaptive method and the DE method have similar decoding performance and achieve a slight performance gain compared with the numerical method. The NOLD algorithm slightly outperforms the DE method and obtains comparable performance with the floating MS algorithm.

Overall, the proposed method based on deep learning optimization strategy can get remarkable performance improvement over other compared methods for irregular LDPC codes and attain comparable performance with the floating MS algorithm in the regular LDPC codes with a wide range of SNRs. The results shown in Figs. 3 and 4 demonstrate the feasibility of lowresolution decoders and indicate the superiority of the proposed method.

B. Effect of Quantization Level

The quantization resolution is an important parameter that balances the trade-off between decoding accuracy and hardware cost. In hardware realization, the common quantization resolution values vary from 4 bits to 7 bits [30]. We will focus on the low-resolution case. In Figs. 3 and 4, we have presented the results of decoding performance under 2-bit resolution (b = 2), which show the significant performance gain of the proposed NOLD algorithm over all competing decoders. To illustrate the effect of the low-resolution quantization, we further report the simulation results under 3-bit (b = 3) and 4-bit (b = 4) resolutions in Fig. 5.

It is shown in Fig. 5 that the NOLD algorithm can achieve a noticeable performance gain compared with the adaptive method and the DE method at both 3-bit and 4-bit resolutions. At the 3-bit resolution, the NOLD method can achieve about 0.2 dB performance gain over the adaptive method and about 0.1 dB performance gain over the DE method when BER is

[TeX:] $$10^{-5}.$$ At the 4-bit resolution, the proposed algorithm can also improve the decoding performance to the same extent as the 3- bit resolution compared with the adaptive method and the DE method. The performance gap between the 4-bit resolution and the floating one (full-resolution) is almost negligible, indicating the feasibility of the low-resolution decoders.

C. Effect of Different Channel Noises

So far above simulation results are obtained under AWGN. The proposed algorithm will not be limited to a specific noise model. This should be rational since the neural network can learn to deal with different kinds of noise. The proposed algorithm remains effective under other noises by re-training the network. To verify this, we consider another two noise models as depicted in Sections II.B.

C.1 Rayleigh Fading Noise

In Fig. 6, we show the 2-bit decoding performance of all the employed methods over the Rayleigh fading noise channel. The

numerical method that chooses the best parameters in the SNR range corresponding to BER from 10􀀀4 and 10􀀀5 (labeled as “medium SNR”) can not successfully deal with the Rayleigh fading noise and suffers a 0.2 dB performance loss compared with the adaptive method. A performance gain of 0.2 dB compared to the adaptive approach is observed over the DE method. We can also see that the NOLD algorithm and the DE method have similar performance for SNR lower than 9 dB. When SNR is higher than 9 dB, the NOLD algorithm can achieve about 0.25 dB performance gain over the DE method.

We execute the 3-bit and 4-bit decoding for the employed methods and compare their decoding performance under the same SNR range as the 2-bit resolution. The low-resolution decoding performance under Rayleigh fading noise is shown in Fig. 7. At the 3-bit resolution, the DE method has comparable performance with the adaptive method. The NOLD algorithm can obtain about 0.2 dB performance at [TeX:] $$\mathrm{BER}=10^{-5}-10^{-6}$$ compared with the two methods. At the 4-bit resolution, the DE method achieves about 0.2 dB performance gain over the adaptive method. Our proposed algorithm significantly outperforms the compared methods and achieves comparable performance with the floating MS decoder when SNR is 8–9 dB.

C.2 Additive Correlated Gaussian Noise

In Fig. 8, we report the simulation results under ACGN with a strong correlation [TeX:] $$(\varphi=0.8)$$ at the 2-bit resolution for all considered methods. It is shown in Fig. 8 that the adaptive method can achieve about 0.1 dB performance gain over the numerical method for the SNR range that corresponds to BER from [TeX:] $$10^{-4}$$ to [TeX:] $$10^{-5}$$ (labeled as “medium SNR”). The DE method outperforms the adaptive method with about 0.25 dB gain at the same SNR range and can achieve comparable performance with the proposed NOLD algorithm.

We also present the results of the 3-bit and 4-bit resolution under strong correlation [TeX:] $$(\varphi=0.8)$$ in Fig. 9. It should be noted that the tested SNRs are from 2.5 dB to 4.5 dB which are the same as the 2-bit resolution. Under the tested SNRs, the DE method performs better than the adaptive method but is worse

than the proposed NOLD algorithm. The proposed method can reach a performance near the floating MS decoder, suggesting that the 4-bit resolution is favored for implementation.

Overall, the proposed decoder has robust performance in all considered cases, confirming that the proposed algorithm can support different noises.

D. The Decoding Performance under Joint Optimization and Single Optimization

In this subsection, we report the simulation results in Fig. 10, using different optimization strategies for the NOLD algorithm and the DE method. It is shown in Fig. 10 that the NOLD algorithm can outperform the DE method for both joint optimization and single optimization. The joint optimization delivers better performance than the single optimization at the cost of higher computational complexity. This performance gain is about 0.1 dB for the NOLD algorithm and 0.05 dB for the DE method when BER is [TeX:] $$10^{-4}-10^{-5}$$ dB. It is suggested that the proposed method with single optimization can be adopted for

practical implementation since the quantization parameters can be optimized off-line.

E. Effect of Decoding Iteration

We have only presented the results of the proposed NOLD algorithm with 20 iterations. However, the iteration number is designed to be as low as possible in a low-latency scenario. We first set the iteration number to I = 5 and then compare the BER performance of all employed methods. We also plot the performance of 15 iterations and 20 iterations for comparison. As shown in Fig. 11 increasing the decoding iterations can enhance the performance gain, and 20 iterations can improve the decoding performance by 0.6 dB at [TeX:] $$\mathrm{BER}=10^{-4}$$ compared with five iterations. Besides, we also notice that after 15 decoding iterations, the performance improvement becomes smaller. The reason is that the decoder has almost reached its maximum capacity and cannot further correct the error codewords.

At the low iteration number (I = 5), the adaptive method can get similar performance to the DE method in SNR range from

1 dB to 3 dB. And the NOLD algorithm has a significant performance gain over these decoding methods. The same results can be observed for I = 15 and I = 20. Although it is unknown whether such an optimal local solution of each iteration is guaranteed to be globally optimal, our proposed method can accelerate the decoder’s convergence speed and get remarkable performance regardless of the iteration number. Thus we conclude that it is efficient to replace the end-to-end optimization algorithm with our proposed NOLD algorithm.

VI. CONCLUSIONS

This paper has introduced the modified MS decoding scheme, which operates scaling and quantization on different variablenode and check-node messages. The NOLD algorithm based on a deep learning optimization strategy has been proposed to optimize decoding parameters. The introduced neural quantizer can handle the discrete variables optimization problems incurred by the low-resolution quantization. Various experiments have been conducted to verify the performance of the proposed method. For both regular and irregular LDPC codes, the experimental results demonstrate that the proposed NOLD algorithm outperforms all competing techniques with various conditions, i.e., quantization levels, noises, and iterations. For our future work, we will investigate the proposed decoder over the intelligent reflecting surface assisted multiple-input multiple-output (MIMO) systems, which is foreseen to be the critical enabler of the future communication systems [43]–[45].