*Article* **A CNN-MPSK Demodulation Architecture with Ultra-Light Weight and Low-Complexity for Communications**

**Bingrui Wang 1, Zhijian Lin 2,\* and Xingang Zhang <sup>1</sup>**

**\*** Correspondence: zlin@fzu.edu.cn

**Abstract:** Modulation is an indispensable component in modern communication systems and multiple phase shift keying (MPSK) is widely studied to improve the spectral efficiency. It is of great significance to study the MPSK modulations of symmetric phases in practice. Based on convolutional neural networks (CNNs), we propose a generic architecture for MPSK demodulation, referred to as CNN-MPSK. The architecture utilizes a single-layer CNN and a pooling trick to crop network parameters. In comparison with conventional coherent demodulation, the CNN-MPSK eliminates three modules, i.e., carrier multiplication, bandpass filter and sampling decision. Thus, we can avoid *π*-inverted phenomenon from the multiplication of two carrier waves with different phases, as the carrier multiplication is not employed. In addition, we can reduce errors introduced by sampling decision. Furthermore, we conduct bit-error-rate tests for binary-PSK, 4PSK, 8PSK, and 16PSK demodulation. Experimental results reveal that the performance of CNN-MPSK is almost the same to that of conventional coherent demodulation. However, the CNN-MPSK demodulation reduces computational complexity from *O*(*n*2) to *O*(*n*) as compared to the latter one. Additionally, the proposed scheme can be readily applied for demodulation of non-symmetric MPSK constellations that maybe distorted by linear and nonlinear impairments in communication systems.

**Keywords:** carrier multiplication; computational complexity; sampling decision; phase shift keying; coherent demodulation

#### **1. Introduction**

Modulation and demodulation techniques play an important role in data transmission. Original digital signals in communication systems may contain low-frequency components that are difficult to transmit directly through channels. Therefore, the original signals must be encoded onto high-frequency carrier signals for transmission. The encoded process is referred to as modulation [1]. The primary purpose of modulation is to match the frequency bandwidths between signals and channels [2]. Another purpose is to facilitate channel multiplexing [3]. Thus, after modulation, each signal is shifted to a different frequency band so that mutual interference will not occur during transmission. In particular, a multiple phase shift keying (MPSK) demodulation is used to convey data by changing the phase of a constant frequency reference signal. MPSK is a classic modulation that is practically displaced in the standard within orthogonal frequency-division multiplexing (OFDM) symbols for wireless communications. For instance, 4PSK is widely utilized in code division multiple access mobile communications, digital video broadcasting-satellitesecond generation communications, coherent optical communications and fiber optic communications. The constellations of MPSK signals are symmetric and zero-mean that is widely used for wireless local area networks and Bluetooth communications.

Recently, a lot of research related to modulation recognition have been undertaken using deep learning technology [4–6]. In particular, deep residual networks was investigated to perform radio signal classification, taking into account the effects of carrier

**Citation:** Wang, B.; Lin, Z.; Zhang, X. A CNN-MPSK Demodulation Architecture with Ultra-Light Weight and Low-Complexity for Communications. *Symmetry* **2022**, *14*, 873. https://doi.org/10.3390/ sym14050873

Academic Editor: Boris Malomed

Received: 28 March 2022 Accepted: 14 April 2022 Published: 25 April 2022

**Publisher's Note:** MDPI stays neutral with regard to jurisdictional claims in published maps and institutional affiliations.

**Copyright:** © 2022 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (https:// creativecommons.org/licenses/by/ 4.0/).

<sup>1</sup> Henan Intelligent Emergency Support Engineering Research Center, Nanyang Normal University, Nanyang 473061, China; toynbeescoot@alumni.hust.edu.cn (B.W.); xingzh6yaros@nynu.edu.cn (X.Z.)

<sup>2</sup> School of Advanced Manufacturing, Science Park of Fuzhou University, Jinjiang 362251, China

frequency offset, symbol rate, and multipath fading. The traditional convolutional neural networks (CNNs) achieve similar performance to residual networks, but with the increased trainable parameters [7]. A novel two-step training for CNN-based automatic modulation classification (CNN-AMC) was then proposed in order to handle complex tasks [8]. Simulation results indicate that the CNN-AMC approximates the optimal maximum likelihood (ML)-AMC. Regarding inference speed, the deep learning-based approach is more than a hundred times faster than ML-AMC by using parallel computation. The relatively simple neural network architectures were presented for space-time-block-codes multiple-input multiple-output systems (MIMO), which are sparse autoencoders-based deep neural networks (DNN) and radial basis function networks (RBFN) [9]. RBFN and DNN weights are optimized using the Broyden–Fletcher–Goldfarb–Shannon algorithm and the least square approach. For the classification of digitally modulated signals in varying channel conditions, Ali and Yang [10] proposed a fully linked two-layer feed-forward DNN with layerwise unsupervised pretraining. This system uses multiple hidden nodes and independent autoencoders for learning feature maps. The proposed DNN has good classification accuracy even when trained and tested at different signal-to-noise ratios (SNRs). To be more efficient in low SNR conditions, the deep belief network and spiking neural network were utilized to reduce execution latency associated with deep learning architectures [11]. Each feature-based AMC classifier is then studied to determine the upper and lower performance bounds within this adaptive framework.

By employing a CNN-based technique, an intelligent eye-diagram analyzer was proposed to recognize modulation formats and estimate optical SNR [12]. Aided by oscilloscope in simulation, the eye diagram images of four modulation formats can be obtained over a wide optical SNR range. It was showed that CNN achieves higher accuracy than other machine learning algorithms such as decision trees, *k*-nearest neighbors, backpropagation neural networks, and support vector machines. Using the strengths of the CNN and the long short-term memory (LSTM), the AMC is developed by dual-stream construction, which efficiently explores the feature interaction and spatial–temporal properties of raw complex temporal signals [13]. In particular, the signals first go through preprocessing to be converted to the temporal inphase/quadrature format and amplitude/phase representation. To improve modulation recognition accuracy at low SNRs, an algorithm for pre-denoising was proposed in [14] before modulation recognition. The pre-denoising algorithm consists of a fully CNN, which is similar to an auto-encoder. A residual learning is also used to speed up the learning process. Eye diagram measurements were further used to estimate coherent channel performance with deep learning [15]. The experimental results show that the proposed technique provides high accuracy in determining the modulation format, optical SNR, roll-off factor, and timing skew of a quadrature amplitude modulation. In [16], the modulation signals are transformed into two image representations of cyclic spectra and constellation diagram, respectively.

To integrate the features, a gradient descent strategy and a multi-feature fusion technique were exploited along with a two-branch CNN model. The novel framework was proposed for low-cost link adaptation for spatial modulation MIMO (SM-MIMO). Simulations demonstrate that the supervised-learning classifiers and DNN-based adaptive SM-MIMO outperform a variety of conventional optimization-driven designs [17]. The detection of modulations was presented for multi-relay cooperative MIMO systems of 5G communications in the presence of spatially correlated channels and imperfect channel state information. The simulation results show that the machine learning techniques provide gain in terms of both the modulation detection and complexity [18]. To blindly detect the modulation order of interference signals in downlink non-orthogonal multiple access systems, a machine learning algorithm based on Anderson–Darling test was investigated [19]. DNNs and machine learning were used to develop methods for monitoring optical performance, identifying modulation formats, multipath fading channels and orthogonal frequency-division multiplexing supported by compressed sensing assisted index modulation [20–23].

The previous related studies have yielded positive results. However, these studies utilize deep learning networks, which are deep and have a large output latency [24,25]. As the deep networks have a high degree of complexity, they are difficult to train and generate a large number of parameters, which is unsuitable for small embedded hardware systems. Several studies require the input data of a system to be in an image format. In such case, the received binary data have to be converted into images, and then feature extraction and other operations are carried out. Finally, the image is converted back into binary data. The exchange of binary data and images increases the delay and complexity. There are concerns regarding the system ability to process the received data in real time. Other studies perform pre-processing operations, which increases the amount of parameters and the complexity of the overall system [26,27]. Thus, it is hard to apply these studies for practical hardware implementations. Consequently, based on CNN and pooling techniques, we propose a shallow CNN-MPSK demodulation with ultra-light parameters to achieve a low complexity architecture. The goal of using CNNs with MPSK is to provide an alternative method for demodulation with the affordable computation complexity.

The sections of the study are organized as follows. In Section 2, we analyze the modulation principle of MPSK and the coherent demodulation process. In addition, the theoretical bit-error-rate (BER) formula for coherent demodulation is derived. Section 3 presents the architecture of CNN-MPSK and the computation consumed by each component. We then show the number of parameters generated by the CNN-MPSK architecture. In Section 4, we give a specific CNN-MPSK demodulation example to illustrate parameters training and perform BER tests under different SNRs. Afterwards, we discuss the multiplications and additions involved in CNN-MPSK and coherent demodulation, and conclude this paper in Section 5.

#### **2. Conventional Modulation and Demodulation of MPSK**

MPSK is one of the most widely used techniques due to its relative simplicity in modulation and demodulation. The modulation of such signals can be represented by

$$\begin{aligned} c\_i(t) &= \sqrt{\frac{2}{T\_c}} \sin(w\_i t + \theta), \\ \theta &= 2\pi i/M, i = \{0, 1, 2, \dots, M - 1\}, \end{aligned} \tag{1}$$

where *Tc* is the period of modulated signal *ci*(*t*), *Tc* = <sup>2</sup>*<sup>π</sup> wc* , *wc* and *θ* denote frequency and phase of the carrier, respectively.

The MPSK demodulation process typically consists of two BPSK demodulation. Figure 1 illustrates the simple case of coherent demodulation for BPSK [28,29]. First, the received BPSK signal *r*(*t*) is filtered to eliminate out-of-band noise using a bandpass filter. Afterwards, the filtered output *z*(*t*) is multiplied by a sin wave 2 sin(*wct*), resulting in an output *x*(*t*) that is twice the frequency of the input signal. The high frequency components in *x*(*t*) are removed by the lowpass filter. The signal is then passed to the decision circuit. Based on the synchronized clock in the timing synchronizer module, we obtain the final result *o*(*t*) which recovers the binary data stream. In particular, the key component in BPSK demodulation is the carrier generator. It needs to yield a local carrier with the identical frequency and phase as the input signal *r*(*t*). However, the local carrier may not be properly generated, leading to a phase difference between the generated carrier and the received carrier, resulting in negative consequences for demodulation [30–32].

**Figure 1.** Block diagram of a coherent binary-PSK (BPSK) receiver.

Figure 2 depicts the two conditional probability density functions (PDF) *f*0(*x*) and *<sup>f</sup>*1(*x*) for the transmitted bits 0 and 1 with mean values of <sup>√</sup>2/*Tc* and <sup>−</sup>√2/*Tc*, respectively.

**Figure 2.** Conditional bit error probability density functions for BPSK demodulated signals.

In the event that the bit 1 is transmitted and the receiver determines it as 0, the conditional probability of such an error is defined by

$$\begin{split}P(0/1) &= \int\_0^{+\infty} f\_1(\mathbf{x})d\mathbf{x} \\ &= \int\_{\frac{\sqrt{2/T\_c}}{\sqrt{2v\_n}}}^{\infty} \frac{1}{\sqrt{\pi t}} \exp[-u^2] du \end{split} \tag{2}$$

where

$$
\mu = \frac{(\mathbf{x} + \sqrt{2/T\_c})}{\sqrt{2}\sigma\_n}.\tag{3}
$$

The lower limit of integration in Equation (2) is simplified to

$$\frac{\sqrt{2/T\_c}}{\sqrt{2}\sigma\_n} = \frac{\sqrt{1/T\_c}}{\sqrt{N\_0B}} = \frac{\sqrt{1/T\_c}}{\sqrt{N\_0/T\_c}} = \frac{1}{\sqrt{N\_0}} = \sqrt{\frac{E\_b}{N\_0}} = \sqrt{snr},\tag{4}$$

where *Eb* is already normalized to one when BPSK signals are transmitted. Consequently, in terms of the complementary error function (erfc), assuming bits are equiprobable, the BER for BPSK coherent detection is given by

$$P\_{\mathbf{c}} = \frac{1}{2}P(0/1) + \frac{1}{2}P(1/0) = \frac{1}{2}\text{erfc}(\sqrt{snr}).\tag{5}$$

Similarly, the probability of symbol error of MPSK (*M* ≥ 4) is overbounded by [33]

$$\begin{split} P\_e &= \frac{2}{\sqrt{\pi N\_0}} \int\_{\sqrt{E\_s} \sin(\frac{\pi}{M})}^{\infty} \exp[\frac{-\mathbf{x}^2}{N\_0}] d\mathbf{x} \\ &= \frac{2}{\sqrt{\pi}} \int\_{\sqrt{\frac{E\_s}{N\_0}} \sin(\frac{\pi}{M})}^{\infty} \exp[-u^2] du \\ &= \operatorname{erfc}[\sqrt{\frac{E\_s}{N\_0}} \sin(\frac{\pi}{M})] \end{split} \tag{6}$$

where <sup>√</sup>*Es* is the average energy of the transmitted symbols.

#### **3. The Proposed CNN-MPSK Architecture**

#### *3.1. Architecture Presentation*

In Figure 3, the proposed architecture takes the received signal as input and then applies one-dimensional (1D) convolution to extract features. Afterwards, the signal flows to the activation module to become unlinear. The flow continues to input a pooling component, followed by a full connection to act as a classifier on the features.

**Figure 3.** The architecture of a neural network for MPSK demodulation.

Next, we present the components of the CNN architecture, which consist of 1D convolution, activation, pooling, and full connection. Among these modules, convolution is the most important one. From a mathematical standpoint, convolution can be regarded as an integral operation, or an accumulation. Convolution has the property that past data have an effect on future data, and adjacent data influence current data, which makes convolution convenient to extract features from data. Given a sequence *r* of length *d* as input and a vector *w* of length *k*, the 1D convolution operation is given by

$$y(m) = \sum\_{k} r(m+k)w(k). \tag{7}$$

The Equation (7) involves element-by-element multiplication and summation. In particular, the elements of vector *w* are called weights that the network needs to learn during training. Thus, the *w* is often interchangeably referred to as kernel. Typically, the kernels have small size. In this study, the size of kernel *w* is 1 × 3, and the 1D output vector *z* is given by

$$z(j) = y + b = \sum\_{i=0}^{2} r(j+i)w(i) + b, \; 0 \le j \le d-3,\tag{8}$$

where *z*(*j*) is the *j*-th element of the output, the *z* is also referred as extracted feature, and *b* is called bias which represents the baseline when all the inputs have values of zero. Note that the length of *z*(*j*) is *d* − 2. In order to make *z*(*j*) to have the same size as the input *r*, we add one zero to the first and last positions of *r*, respectively, which produces a new input vector *r*-=[0 *r* 0]. Thus, we can rewrite Equation (8) as

$$z'(j) = \sum\_{i=0}^{2} r'(j+i)w(i) + b, \, 0 \le j \le d-1. \tag{9}$$

The Equation (9) can be illustrated by Figure 4, which gives a visual explanation of how 1D convolution works. In Figure 4, the convolution multiplies the kernel *w* by the first three elements of *r*- , sums all the multiplications with *b*, and yields the first output *z*- (0). Following this, we shift the kernel *w* one element to the right and perform convolution to generate another output *z*- (1). In particular, the *r*- (0), *r*- (1), *r*- (*d*) and *r*- (*d* + 1) are equal to zero, *r*(0), *r*(*d* − 1) and zero, respectively. Thus, the first two items *z*- (0) and *z*- (1), and the last item *z*- (*d* − 1) are computed as

$$\begin{aligned} z'(0) &= r'(0)w(0) + r'(1)w(1) + r'(2)w(2) + b \\ &= r'(1)w(1) + r'(2)w(2) + b \\ &= r(0)w(1) + r(1)w(2) + b, \end{aligned} \tag{10}$$

$$\begin{split}z'(1) &= r'(1)w(0) + r'(2)w(1) + r'(3)w(2) + b\\ &= r(0)w(0) + r(1)w(1) + r(2)w(2) + b,\end{split} \tag{11}$$

and

$$\begin{split} z'(d-1) &= r'(d-1)w(0) + r'(d)w(1) + r'(d+1)w(2) + b \\ &= r'(d-1)w(0) + r'(d)w(1) + b \\ &= r(d-2)w(0) + r(d-1)w(1) + b. \end{split} \tag{12}$$

**Figure 4.** The operation of the 1D convolution.

It is noted that when the input data change, these three parameters, *w*(0), *w*(1) and *w*(2), do not change. We need to repeat the movement *d* − 1 times. This 1D convolution costs 3*d* multiplications and *d* additions in total.

Following by 1D convolution, there is an activation function that performs nonlinear transformation and enables the neural network to learn nonlinear features. CNNs commonly use rectifier linear units (ReLUs) as activating functions. A ReLU can lead to rapid computation with a threshold value 0. When the input is smaller than 0, the output is 0. Otherwise, the output is unchanged. Applying ReLU, the output can be represented as

$$f(j) = \max[0, z'(j)], \; 0 \le j \le d - 1. \tag{13}$$

The pooling is often performed after activation for sub-sampling features. In general, the reason to subsample is that the an important feature of a sequence is seldom contained in adjacent data. The sub-sampling can produce features that are invariant to scale, translation, pose, and rotation changes. Max pooling selects the maximum value from the adjacent data, and thus we have

$$p(m) = \max\{f[ms:(m+1)s-1]\}, 0 \le m \le d/s - 1,\tag{14}$$

where *s* is the slide step size and *p* is the output from max pooling. To provide classification results, a full connection needs to integrate useful and hierarchical features. In a full connection, each unit is connected to all the previous input units. The connection can be expressed as a matrix multiplication, i.e.,

$$\rho = \sum\_{m=0}^{d/s-1} p(m) w\_f(m) + b\_{f'} \tag{15}$$

where *bf* is a parameter known as bias, *wf* are weights, and *o* denotes a single unit. According to Equation (15), we can construct a structure to depict the full connection, as shown in Figure 5. In BPSK demodulation, we only need one output unit represented by bit 1 or 0. Thus, the full connection costs *d*/*s* multiplications and *d*/*s* additions for one output.

**Figure 5.** The operation of the full connection.

#### *3.2. Parameter Distribution of CNN-MPSK*

The CNN-MPSK network architecture is illustrated in Table 1. The network is rather straightforward. Table 1 shows the type of operation, shape of the input and output, and the number of parameters in the operation. The network takes the 1 × *n* × 1 single-channel data sequence as input. The convolution uses one 1 × 3 kernel and requires three weights and a bias. The 1 × *n* × 1 data are processed by activation. Then, the data are pooled down by a factor of 2, yielding a 1 × *n*/2 × 1 output. Following this, the full connection module converts the 1 × *n*/2 × 1 input to a 1 × *M* output with a *M* × *n*/2 kernel. Note that the activation as well as pooling has no parameters because there is nothing to learn. Thus, the total number of parameters is *M* × *n*/2 + *M* + 4, which includes *M* × *n*/2 + 3 weights and 1 + *M* biases. In particular, for BPSK, the value of *M* is equal to 1.



#### **4. Comparison between CNN-MPSK and Coherent Demodulation in Terms of Performance and Computational Complexity**

*4.1. The Accuracy and Loss Curves*

The proposed MPSK modulation assumes a sine wave of one period to represent a symbol. As an example, in BPSK modulation, a sine wave of one cycle represents a 0 or a 1. Our proposed modulation can also be applied for communication systems operated at at MHz or GHz. In order to facilitate comparison, we set the carrier frequency to be 300 KHz and sampling frequency is 6 MHz for BPSK, 4PSK, 8PSK and 16PSK demodulations. Thus, the input to the CNN-MPSK network consists of 20 bits. The training process are similar for these four demodulations. We demonstrate the process by using BPSK as an example. The CNN-BPSK network only requires *n*/2 + 5 = 15 parameters in total. We generate 1 million experimental data at random, half of which is used for training and half for validating. After training the CNN-BPSK network for 15 epochs, we obtain the accuracy and loss curves versus the number of epochs, as shown in Figure 6. The epoch number is on the *x*-axis, while accuracy and loss are on the *y*-axis.

**Figure 6.** A plot of accuracy and loss for the CNN-BPSK network.

The accuracy in Figure 6 takes a value very near 0.95 and the loss is close to 0.15. The training and validating accuracies improve as we train, while the losses decrease. In particular, the four curves change rapidly in the first two epochs, and the top and bottom parts tend to be 0.95 and 0.15, respectively. After the four epoch, the two accuracy curves almost overlap as well as the two loss curves. The training accuracy is stable, leading to a 94.4% accuracy.

#### *4.2. BER Comparison of CNN-MPSK and Coherent Demodulation*

This part presents the demodulation performance of CNN-MPSK. In this experiment, the SNR is *snr db* = [−5, −4, −3, −2, −1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9] in decibels. We need to restore the *snr db* to the initial value and perform 10(*snr*\_*db*/10) conversion. We utilize additive white Gaussian noise (AWGN) to simulate channel interference. The tested data for each SNR is 5 million bits, so the total number of noised data flows to CNN-MPSK network is 100 million. With the trained parameters, we predict the noised data and thus obtain the demodulated curve for BPSK, 4PSK, 8PSK and 16PSK, as shown in Figure 7. The blue BER curve is obtained by coherent demodulation. The horizontal axis represents the SNR in dB, while the vertical axis is the BER. The BER curves of the four demodulations from the CNN structure overlap heavily with those based on the conventional coherent demodulation.

**Figure 7.** BER comparisons of CNN-MPSK and coherent demodulation for BPSK, 4PSK, 8PSK and 16PSK demodulations.

#### *4.3. Comparison of Multiplications and Additions*

The coherent approach for MPSK involves phase demodulation, requiring linear-phase filters and stable outputs. Therefore, finite impulse response (FIR) filters are preferred. We are concerned with linear-phase FIR filters. The output of an this filter only depends on the present and previous inputs, which can be completely described by

$$\begin{split} y(n) &= \sum\_{k=0}^{L-1} \mathcal{g}\_k \mathbf{x}(n-k) \\ &= \mathcal{g}\_0 \mathbf{x}(n) + \mathcal{g}\_1 \mathbf{x}(n-1) + \dots + \mathcal{g}\_{L-1} \mathbf{x}(n-L+1), \end{split} \tag{16}$$

where *x*(*n*) is the input sequence of length *N*, *gk* denotes filter coefficients and *L* represents the FIR filter length. FIRs have no feedback and have stability and freedom from phase distortion. Each coefficient requires a register to hold a delayed input. With the length *L* of this filter and the *N* input samples, the length of output *y*(*n*) is *N* + *L* − 1. This process involves (*N* + *L* − 1)*L* multiplications and (*N* + *L* − 1)(*L* − 1) additions [34–36]. Consequently, the corresponding computational complexity of an FIR filter is described as *O*(*n*2).

According to equation (16), when the length of the received signal is *N* and the bandpass filter has *Lp* coefficients, the operation of the bandpass filter costs (*N* + *Lp* − 1)*Lp* multiplications and (*N* + *Lp* − 1)(*Lp* − 1) additions. The carrier multiplier module requires *N* multiplications. Moreover, let *Lf* represent the length of the lowpass filter coefficients, the operation of this filter involves (*N* + *Lf* − 1)*Lf* multiplications and (*N* + *Lf* − 1)(*Lf* − 1) additions. As a result, the coherent demodulation involves the total calculations, i.e., (*N* + *Lp* − <sup>1</sup>)*Lp* + *<sup>N</sup>* + (*<sup>N</sup>* + *Lf* − <sup>1</sup>)*Lf* <sup>=</sup> *<sup>N</sup>*(*Lp* + *Lf* + <sup>1</sup>) + *<sup>L</sup>*<sup>2</sup> *<sup>p</sup>* + *L*<sup>2</sup> *<sup>f</sup>* − (*Lp* + *Lf*) multiplications, and (*<sup>N</sup>* + *Lp* − <sup>1</sup>)(*Lp* − <sup>1</sup>)+(*<sup>N</sup>* + *Lf* − <sup>1</sup>)(*Lf* − <sup>1</sup>) <sup>=</sup> *<sup>N</sup>*(*Lp* − <sup>1</sup>) + *<sup>N</sup>*(*Lf* − <sup>1</sup>)+(*Lp* − <sup>1</sup>)<sup>2</sup> + (*Lf* − <sup>1</sup>)<sup>2</sup> additions. Demodulating the same input signal as the coherent demodulation, we utilize the proposed CNN-BPSK architecture. In the architecture, the convolution

operation requires 3*N* multiplications and *N* additions, and the full connection needs *N*/*s* multiplications and *N*/*s* additions, and *s* is the length of strides. The architecture involves 3*N* + *N*/*s* multiplications and *N* + *N*/*s* additions in total.

In comparison with the conventional demodulation, the number of multiplications and additions of the architecture are greatly reduced, as shown in Table 2. The calculation complexity of the proposed demodulation is *O*(*n*), while that of the conventional demodulation is *O*(*n*2).


**Table 2.** The comparison of calculation between coherent and CNN demodulation.

Table 3 presents a comparison between the proposed deep learning technique and the existing algorithms [7,11]. We approximate the number of parameters, and the number of operations by orders of magnitude. The last three columns of Table 3 represent the demodulation accuracy for different *Es*/*n*0. The proposed technique shows the similar demodulation performance as compared to the other schemes, but benefits from much reduced implementation complexity, i.e., much less operations and parameters to be trained.

**Table 3.** The comparison of the proposed algorithms and others.


#### **5. Conclusions**

This paper proposes a simplified and light-weight CNN-MPSK demodulation architecture based on deep learning technology. The proposed CNN-MPSK can be implemented without requiring the carrier synchronization and timing synchronization that make the system complex. Thus, the design complexity can be greatly reduced and the inverse *π* phenomenon is avoided. The simulation tests are conducted on BER performance of the proposed CNN structure for 4PSK, 8PSK and 16PSK, respectively. We see that the proposed CNN-MPSK shows the similar performance to the coherent demodulation and the existing deep learning demodulations. More importantly, the CNN-MPSK structure has the advantage of greatly reduced computational complexity. As compared with the coherent demodulation, the computation complexity of the proposed architecture is reduced from *O*(*n*2) to *O*(*n*). Thus, the proposed architecture can be seen as an alternative scheme for low-complexity signal demodulation in communications.

**Author Contributions:** Conceptualization, B.W. and Z.L.; methodology, B.W.; software, X.Z.; validation, B.W., Z.L. and X.Z.; formal analysis, Z.L.; investigation, Z.L.; resources, X.Z.; data curation, X.Z.; writing—original draft preparation, B.W.; writing—review and editing, Z.L.; visualization, X.Z.; supervision, X.Z.; project administration, B.W.; funding acquisition, Z.L. All authors have read and agreed to the published version of the manuscript.

**Funding:** This research was funded by Science and Technology Research Program of Henan Province (No. 202102310530), Nsf of fujian province (No. 2020J01301), and the key scientific research projects of colleges and universities in Henan Province (No. 21A520032, 21A520033).

**Institutional Review Board Statement:** Not applicable.

**Informed Consent Statement:** Not applicable.

**Data Availability Statement:** Not applicable.

**Acknowledgments:** The authors would like to thank the reviewers for their thoughtful remarks and recommendations, which considerably enhanced the paper's presentation.

**Conflicts of Interest:** The authors declare no conflict of interest.

#### **References**


### *Article* **Improving Decodability of Polar Codes by Adding Noise**

**Lingjun Kong 1, Haiyang Liu 2,\*, Wentao Hou <sup>3</sup> and Bin Dai <sup>4</sup>**


**Abstract:** This paper presents an online perturbed and directed neural-evolutionary (Online-PDNE) decoding algorithm for polar codes, in which the perturbation noise and online directed neuroevolutionary noise sequences are sequentially added to the received sequence for re-decoding if the standard polar decoding fails. The new decoding algorithm converts uncorrectable received sequences into error-correcting regions of their decoding space for correct decoding by adding specific noises. To reduce the decoding complexity and delay, the PDNE decoding algorithm and sole neural-evolutionary (SNE) decoding algorithm for polar codes are further proposed, which provide a considerable tradeoff between the decoding performance and complexity by acquiring the neural-evolutionary noise in an offline manner. Numerical results suggest that our proposed decoding algorithms outperform the other conventional decoding algorithms. At high signal-to-noise ratio (SNR) region, the Online-PDNE decoding algorithm improves bit error rate (BER) performance by more than four orders of magnitude compared with the conventional simplified successive cancellation (SSC) decoding algorithm. Furthermore, in the mid-high SNR region, the average normalized complexity of the proposed algorithm is almost the same as that of the SSC decoding algorithm, while preserving the decoding performance gain.

**Keywords:** fifth generation; channel coding; polar code; perturbation noise; neuro-evolution

#### **1. Introduction**

The development of fifth generation (5G) communication technology is driven not only by the requirements of faster and higher-capacity extreme mobile broadband (eMBB) applications, but also by the rapidly evolving area of Internet of Things (IoT) that needs a massive connectivity of devices with ultra-reliable and ultra-low-latency connectivity over Internet Protocol [1–4]. Channel coding is an integral part of any communication system, which plays an important role in meeting the system reliability requirements [5–7]. A prominent feature of 5G new radio (NR) is the adoption of a new class of error correction codes, i.e., polar codes, for control channels [8,9]. Future wireless communication technologies are proliferating in the connection between people and things, and their scenarios will place new requirements on the channel coding performances [10].

Polar codes were proposed by Arıkan [11] in 2009, who also originally indicated the symmetry of polar codes for binary-input discrete memoryless channels (B-DMCs). With the symmetry, the output vector can be divided into equivalence classes in terms of their transition probabilities. Based on the channel polarization theory that entails channel combining and channel splitting, this new coding scheme is capacity achieving as opposed to just capacity approaching in symmetric B-DMCs with efficient construction and low complexity [12,13]. Several decoding algorithms have recently been developed for polar

**Citation:** Kong, L.; Liu, H.; Hou, W.; Dai, B. Improving Decodability of Polar Codes by Adding Noise. *Symmetry* **2022**, *14*, 1156. https:// doi.org/10.3390/sym14061156

Academic Editors: Pingping Chen, Long Shi and Yi Fang

Received: 11 May 2022 Accepted: 1 June 2022 Published: 3 June 2022

**Publisher's Note:** MDPI stays neutral with regard to jurisdictional claims in published maps and institutional affiliations.

**Copyright:** © 2022 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (https:// creativecommons.org/licenses/by/ 4.0/).

codes in the literature [14–21]. The successive cancellation (SC) algorithm proposed by Arıkan [11] is an effective method for decoding polar codes. To reduce the decoding latency and algorithmic complexity of the SC decoder, a simplified successive cancellation (SSC) decoder was proposed in [14]. In [15], Tal and Vardy proposed the successive cancellation list (SCL) decoder to tackle the problem that only one decoding path was reserved for SC decoding, which may lead to the loss of the correct path. CRC (cyclic redundancy check)-aided decoding schemes were proposed to improve the performance of polar codes in [16]. In addition, the recent development of deep learning methods provides a new insight into the decoding of linear codes [22–27]. However, deep-learning-based channel decoding is doomed by the curse of dimensionality, in which the learning process is limited by the complexity as the number of information bits increases.

In the signal processing area, it can be shown that the performance of a suboptimal detector may be improved by adding noise to the received data under certain conditions [28,29]. Inspired by this method, some researchers have investigated how to improve the decoding performance of a (suboptimal) decoder by adding noise. In [30], a belief propagation list (BPL) decoding algorithm was proposed, in which adding a small amount of noise enables the decoder to handle non-convergent errors. A dynamic perturbation decoding method for Polar-CRC concatenation codes through dynamically controlling the interference noise was proposed in [31]. In [32], a generalized framework for multi-round BP decoding with input perturbation for short low-density parity-check (LDPC) codes was proposed, where the perturbation is done iteratively on a few symbols to widen the search space.

In [33], a CRC-assisted perturbation decoding algorithm for polar codes was proposed, which is called the PB-SSC decoding algorithm in this paper. When the CRC check of the SSC decoder fails, the PB-SSC decoding algorithm can provide multiple possible candidate vectors for re-decoding by adding disturbance noises. However, the performance gain achieved by the PB-SSC decoding algorithm is limited. A decoding algorithm for polar codes based on the perturbation with a convolution neural network (CNN) was proposed in [34]. In [35], a post-processing technique was proposed to improve the performance of the SSC polar decoder in the 2D intersymbol interference (ISI) data storage system, namely the post-processing SSC (PP-SSC) decoding algorithm, in which the perturbation algorithm and the genetic algorithm (GA) successively generate perturbation vectors that accelerate the convergence of the decoder. Unfortunately, the secondary generation of perturbation noise by the GA is performed online, which greatly increases the delay and complexity of the decoder.

In order to address these issues, this paper proposes several decoding algorithms for polar codes by applying the idea of adding noise, which generalizes the methods in our previous work [36]. However, more effective operations in the GA training process are used in this work. We first propose an online perturbed and directed neural-evolutionary (Online-PDNE) decoding algorithm. Then, a simplified version of Online-PDNE decoding algorithm, called the PDNE decoding algorithm, is proposed by using the genetic process in an offline manner. Finally, to further reduce the decoding complexity, we further propose a sole neural-evolutionary (SNE) decoding algorithm, which only invokes the pre-trained offline directed neuro-evolutionary noise and provides a considerable balance between the decoding performance and complexity. Simulation results suggest that our proposed decoding algorithms outperform the other conventional algorithms for decoding polar codes. In addition, the algorithms in this paper have more generality compared with the algorithm in [36].

The main contributions of this paper are summarized as follows:


The rest of the paper is organized as follows. Section 2 reviews the related work on polar decoding algorithms. In Section 3, the proposed decoding algorithms of polar codes are presented. Simulation results are provided in Section 4. Finally, Section 5 concludes the paper.

#### **2. Related Works**

In this paper, the error correction performance of polar codes is improved by adding specific noises. In this section, we briefly review the related works.

#### *2.1. Conventional Perturbation Based Decoding Algorithms*

The concept of stochastic perturbation opens a new perspective where systems can benefit from adding artificial noise. In 1981, Benzi [37] found that the addition of suitable noise under certain conditions leads to an increase in a measure of the quality of signal transmission performance, which could be explained by the phenomenon of stochastic resonance [38,39]. It can be shown that the performance of certain suboptimal detector may be improved by adding some white Gaussian noise [28], where the loss of detectability caused by lowering the signal-to-noise ratio (SNR) is offset by the increased sensitivity of the new noise.

Based on the similar concept, a perturbed decoding algorithm (PA) was proposed for a concatenated CRC and convolutional code system [40]. The original signal is first decoded by the conventional Viterbi algorithm. If the CRC check fails, a perturbed received signal is created and then decoded by the inner Viterbi decoder. The perturbation by artificial noise injection is expected to increase the possibility that the transmitted codeword is obtained.

In [30], a theoretical analysis was presented to gain further insight into stochastic resonance phenomenon, where the performance of a stochastic resonance enhanced detector was derived in terms of the probability of detection and the probability of false alarm. The theory behind PA was elaborated in [41]. The distribution of the numbers of perturbed decoding was derived for independent Gaussian perturbations. The dominant terms of the distribution indicate that the complexity of PA is highly dependent on the geometric structure of the error control code. If an ML decoder is employed as the inner decoder, the distribution for the numbers of perturbed decoding can be well approximated by a function of SNR, signal-to-perturbation-noise ratio (SPNR), and the two-centroid code spectrum, which provides theoretical support for related works.

A BPL decoder that relied on artificial noise as a frame error rate (FER) or bit error rate (BER) performance booster in a subject of coding theory was presented in [30]. Artificially generated noises with different intensities are added to the received signal to avoid false convergence in a BP-based decoder. A dynamic perturbation decoding method for polar-CRC cascaded codes was proposed in [31]. Dynamic perturbation decoding can adjust the variance of the added perturbation noise according to the currently decoded codeword, so that the sequences obtained after each perturbation are as different as possible. Based on the analysis of FER and BER, a noise-assisted decoding algorithm for polar codes was proposed to improve the decoding performance [42]. The algorithm is realized by adding

the human-made noise, which is a post-compensation processing method for the existing algorithms. The disadvantage of the algorithm is that the noise power needs to be set artificially, and a large number of decoding attempts are performed without any direction, which greatly increases the decoding complexity.

#### *2.2. GA Based Decoding Algortithms*

Since the overall search strategy in the optimization process of the GA does not depend on gradient information or other auxiliary knowledge [43], it provides a general framework for solving complex system problems in various areas, such as combinatorial optimization, machine learning, signal processing, and adaptive control.

The GA has been used in LDPC decoding [43,44]. However, its application in polar decoding is still in the early stages. The authors in [33,35] employed the GA to generate perturbation noise, so as to perturb the received signal that failed to decode. Inspired by the GA of AI technology, the authors in [45] used the mean of the log-likelihood ratio (LLR) distribution as the fitness function of each individual to update the successive cancellation flip (SCF) decoding algorithm of the population. Simulation results verified that the improved SCF decoding algorithm based on new constructed candidate flipping positions sets can achieve competitive decoding performance compared with some state-of-the-art SCF decoding algorithms.

In addition, the GA has also achieved good results in polar code constructions [46–49]. In [46], the authors proposed a GA-based framework to construct polar codes using the BER as the fitness function of the GA, thereby reducing the size of the SCL list and the number of iterations. In [47], the authors proposed a scheme for constructing polar codes based on a hash table update population, which reduced the computational complexity of repeated candidates. Aiming at the joint detector and decoder over the resistive random-access memory (ReRAM) channel model, effective polar codes were constructed using the GA in [48].

#### **3. Conventional Schemes**

In this section, we first provide the perturbation decoding principle. Then, we briefly summarize the recent related works, including the PB-SSC decoding algorithm [33] and the PP-SSC decoding algorithm [35].

#### *3.1. Perturbation Decoding Principle*

The perturbation of the received signal can make each received signal have multiple decoding outputs, which can improve the reliability of the transmission process and avoid retransmission of erroneously decoded information [34]. The perturbation of the received signal can be interpreted as adding independent random noise to improve the performance of suboptimal decoders.

As shown in Figure 1, for each valid codeword c(c ∈ {c1, c2,...,cS}), an error correction region a(a ∈ {a1, a2,...,aS}) in the decoding space is specified, where S is the total number of valid codewords. When the received signal y<sup>N</sup> falls into the error correction region, the decoder succeeds in decoding, where N is the code length. However, if the received signal y<sup>N</sup> falls outside the error correction region, the decoder fails in decoding. At this point, adding a random noise n to the received signal may convert the perturbed signal yN+n into the error correction region, resulting in a successful decoding.

**Figure 1.** Schematic diagram of perturbation decoding principle.

#### *3.2. PB-SSC Decoding Algorithm*

According to the perturbation decoding principle in Section 3.1, the PB-SSC decoding algorithm has been proposed to improve the performance of the SSC decoder in [33].

When the SSC decoding fails, the PB-SSC decoding algorithm is activated. The perturbed noise is added to the received signal y<sup>N</sup> to help the received signal to approach the error correction domain. The perturbed received signal yN <sup>1</sup> can be expressed by

$$\mathbf{y}\_1^N = \mathbf{y}^N + \mathbf{Q}\_\mathbf{p} \cdot \text{randn}(1, \mathbf{N}), \tag{1}$$

where Qp is the variance of the perturbed noise, and randn generates random numbers from the standard normal distribution. The decoding is an iterative process that continues until a valid codeword is obtained or the prescribed maximum number of iterations, T1, is reached. We refer the readers to [33] for further details on the PB-SSC decoding algorithm.

#### *3.3. PP-SSC Decoding Algorithm*

The PP-SSC decoding algorithm [35] has been proposed to improve the performance of polar codes in data storage systems, where the GA procedure is employed to enhance the iteration process by producing perturbation vectors that are inherently better than the directed perturbed ones.

The fitness function of an individual is evaluated as

$$\mathcal{F}\_{\mathbb{C}} = 1 / \sqrt{\sum\_{\mathbf{k} \in \mathbb{A}} \left[ \mathbf{d}(\mathbf{k}) - \mathbf{d}\_{\mathbb{P}}(\mathbf{k}) \right]^2 / |\mathcal{A}|} \tag{2}$$

where d and dp are the decoded sequences of the received signal and the perturbed signal, respectively, and A is the information set of the polar code.

Selection operations in the GA are used to select the parents of the next offspring at each evolution stage, where fitter individuals are forwarded as parents for the upcoming offspring. Then, the surviving individuals will then encounter evolutionary transformations, namely, mutations and crossovers, to generate offspring which would represent the new population. The perturbed vector generated by the GA process in the PP-SSC decoding algorithm will be added to the received signal y<sup>N</sup> again for decoding, until a valid codeword is obtained or the prescribed maximum number of generations T2 is reached. We refer the readers to [31] for further details on the PP-SSC decoding algorithm.

#### **4. Proposed Decoding Algorithms**

In this section, three decoding algorithms for polar codes are proposed by adding noise based on the perturbation decoding principle. The computational complexities are then analyzed.

#### *4.1. Online-PDNE Decoding Algorithm*

For the GA, the choice of the fitness function plays an important role in the quality of the final solution and the speed of convergence. The evolutionary search process of the GA is only based on the fitness of each individual in the population. Therefore, the selection of the fitness function directly affects the convergence speed of the GA and whether the optimal solution can be found.

In Equation (2), d is the failed decoding sequence output by the decoder, and dp is the corresponding perturbed decoded sequence. There is no guarantee that their difference can converge effectively unless d is the correct decoding result. However, in the PP-SSC decoder, the GA-based decoding is performed only if the previous perturbed decoding fails. Therefore, we need better fitness function to carry out the genetic process to find the optimal solution.

Similar to the PP-SSC decoder, we propose an online perturbed and directed neuralevolutionary (Online-PDNE) decoding algorithm for polar codes, which adopts the same decoding structure, but with a new fitness function:

$$\mathbf{F\_c} = 1 \;/\left(1 + \sum \text{CRC\\_Calc}(\mathbf{d\_p})\right),\tag{3}$$

where CRC\_Calc(·) is the CRC check operation [50].

Fitness function is used to measure whether an individual is the optimal solution in the GA process, which requires the individual's fitness value to be as high as possible. Depending on the fitness function and the selection algorithm, the population can continuously evolve towards the local optimal solution. In this paper, we take the sum of the CRC check remainders as the fitness function. When using Equation (3), it is ensured that the more number of zeros in the CRC remainder, the larger the value of Fc, which meets the requirements of the fitness function. To ensure the evolution direction of the GA population, the roulette wheel selection strategy is used to select the offspring, which is selected according to the cumulative probability. The fitness score of an individual is calculated by

$$\mathbf{F\_{s}} = \mathbf{F\_{c}(j)} \left/ \sum\_{j=1}^{T\_{1}} \mathbf{F\_{c}(j)} \right. \tag{4}$$

As shown in Figure 2, when the maximum number of decoding attempts T1 in the second round is exceeded, the directed neural-evolutionary noise (NE) <sup>n</sup>(k) ne will be generated online by the NE noise generator and added to the received signal yN as

$$\mathbf{y}\_2^{\rm N} = \mathbf{y}^{\rm N} + \mathbf{n}\_{\rm nc}^{(\rm k)}.\tag{5}$$

**Figure 2.** Block diagram of the Online-PDNE decoding algorithm.

In this paper, the GA is employed to realize neuro-evolution to obtain the required directed neural-evolutionary noise. The genetic process NE(·) is as follows:


**Algorithm 1:** Online-PDNE Decoding algorithm

Input: yN // Received signal Qp // Variance of the perturbed noise T1 // Maximum number of the perturbed attempts T2 // Maximum number of generations T // Number of individuals in the population Output: uˆ <sup>N</sup> <sup>1</sup> // Estimated codeword 1: Initialization: uˆ <sup>N</sup> <sup>1</sup> ← 0, i ← 1, k ← 1 . 2: uˆ <sup>N</sup> <sup>1</sup> <sup>←</sup> Polar\_decoder(yN) 3: if CRC(uˆ <sup>N</sup> <sup>1</sup> ) == success 4: break 5: else 6: while i ≤ T1 do 7: y<sup>N</sup> <sup>1</sup> <sup>=</sup> <sup>y</sup><sup>N</sup> <sup>+</sup> Qp · randn(1, N) 8: uˆ <sup>N</sup> <sup>1</sup> <sup>←</sup> Polar\_decoder(yN 1 ) 9: i ← i + 1 10: if CRC(uˆ <sup>N</sup> <sup>1</sup> ) == success 11: break 12: end if 13: end while 14: Initial population S(0) <sup>n</sup> <sup>=</sup> {n(i) ne |i = 1, 2, . . . , T} 15: for j = 1, . . . , T2 do 16: S(j) <sup>n</sup> = NE(S (j−1) <sup>n</sup> ) 17: while k ≤ T do 18: Choose n(k) ne <sup>∈</sup> <sup>S</sup> (j) n 19: yN <sup>2</sup> <sup>=</sup> yN <sup>+</sup> <sup>n</sup>(k) ne 20: uˆ <sup>N</sup> <sup>1</sup> <sup>←</sup> Polar\_decoder(y<sup>N</sup> 2 ) 21: k ← k + 1 22: if CRC(uˆ <sup>N</sup> <sup>1</sup> ) == success 23: break 24: end if 25: end while 26: end for 27: end if 28: Return uˆ <sup>N</sup> 1

#### *4.2. PDNE Decoding Algorithm*

On account of the iterative genetic evolution, the proposed online-PDNE decoding algorithm needs to seek the optimal solution in an online manner. Although the error correction performance of the polar code is greatly improved, it is achieved at the expense of increasing the complexity and delay of the decoder. To this end, a perturbed and directed neural-evolutionary (PDNE) decoding algorithm for polar codes is proposed, in which the perturbation noise and pre-trained offline directed neuro-evolutionary noise sequences are sequentially added to the received sequence for re-decoding, as given in Equations (1) and (5).

In the PDNE decoding algorithm, nne is chosen from a set S∗ <sup>n</sup> of noise patterns that is generated offline according to the method described in the following. This perturbed decoding process is performed until the cardinality Ts of the set S∗ <sup>n</sup> is reached.

In the offline training, population S (t) <sup>n</sup> at generation t (t = 0, 1, ... , T2 − 1) are constructed in an iterative process, where the initial population S (0) <sup>n</sup> is the first generation randomly created. The new population noise produced by each generation is sequentially and independently added to the decoding failed channel output sequence. The fitness function is defined as the same as Equation (5) in the proposed online-PDNE decoding algorithm. As shown in Figure 3, if the decoding is successful, the current neural-evolutionary noise nne will be stored in a set S∗ n. Otherwise, the genetic process is continued on the population noise until the correct directed individual is obtained or the maximum number of generations T2 is reached to reinitialize the population for the next round of evolution. The details of the PDNE decoding algorithm are given in Algorithm 2.

**Figure 3.** Block diagram of training a directed neural evolutionary noise in an offline manner.

Compared with the algorithm in [36], the proposed PDNE decoding algorithm in this paper has the following advantages:


**Algorithm 2:** PDNE Decoding algorithm

Input: yN // Received signal Qp // Variance of the perturbed noise T1 // Maximum number of the perturbed attempts Ts // Cardinality of the set S∗ n S∗ <sup>n</sup> // Set of the noise patterns Output: uˆ <sup>N</sup> <sup>1</sup> // Estimated codeword 1: Initialization: uˆ <sup>N</sup> <sup>1</sup> ← 0, i ← 1, j ← 1 . 2: uˆ <sup>N</sup> <sup>1</sup> <sup>←</sup> Polar\_decoder(yN) 3: if CRC(uˆ <sup>N</sup> <sup>1</sup> ) == success 4: break 5: else 6: while i ≤ T1 do 7: yN <sup>1</sup> <sup>=</sup> yN <sup>+</sup> Qp · randn(1, N) 8: uˆ <sup>N</sup> <sup>1</sup> <sup>←</sup> Polar\_decoder(yN 1 ) 9: i ← i + 1 10: if CRC(uˆ <sup>N</sup> <sup>1</sup> ) == success 11: break 12: end if 13: end while 14: while j ≤ Ts do 15: Choose n(j) ne ∈ S<sup>∗</sup> n 16: y<sup>N</sup> <sup>2</sup> <sup>=</sup> yN <sup>+</sup> <sup>n</sup>(j) ne 17: uˆ <sup>N</sup> <sup>1</sup> <sup>←</sup> Polar\_decoder(y<sup>N</sup> 2 ) 18: j ← j + 1 19: if CRC(uˆ <sup>N</sup> <sup>1</sup> ) == success 20: break 21: end if 22: end while 23: end if 24: Return uˆ <sup>N</sup> 1

#### *4.3. SNE Decoding Algorithm*

In order to further simplify the PDNE decoder structure and reduce the processing delay of the decoder, a sole neural-evolutionary (SNE) decoding algorithm of polar codes is proposed, in which only pre-trained offline directed neuro-evolutionary noise sequences are added to the received sequence for re-decoding. When the SSC decoding fails, the pre-trained neural-evolutionary noise is directly called, which greatly reduces the decoding delay. The details of the SNE decoding algorithm are given in Algorithm 3.

```
Algorithm 3: SNE Decoding algorithm
Input: yN //Received signal
        Ts // Cardinality of the set S∗
                                      n
        S∗
         n // Set of the noise patterns
Output: uˆ N
         1 // Estimated codeword
1: Initialization: uˆ N
                1 ← 0, j ← 1 .
2: uˆ N
   1 ← Polar_decoder(yN
                       1 )
3: if CRC(uˆ N
          1 ) == success
4: break
5: else
6: while j ≤ Ts do
7: Choose n(j)
                 ne ∈ S∗
                      n
8: yN
           2 = yN + n(j)
                     ne
9: uˆ N
           1 ← Polar_decoder(yN
                              2 )
10: j ← j + 1
11: if CRC(uˆ N
                   1 ) == success
12: break
13: end if
14: end while
15: end if
16: Return uˆ N
```
#### *4.4. Complexity Analysis*

1

The additional complexities required by the proposed three decoding algorithms for polar codes are discussed in this sub-section. Note that the complexity required for CRC check is ignored in the following analysis. Table 1 compares the computational complexity of the proposed algorithms and other decoding schemes, where Cp and Cg are the unit calculations required in the perturbation operation and genetic operation, as shown in Table 2.

**Table 1.** Computational complexity of different decoding algorithms.


**Table 2.** Unit calculations in GA process.


When the standard polar decoding fails, the Online-PDNE or PDNE decoding algorithm is activated, in which multiple perturbation noises are generated for the first T1

attempts. Given the code length N, the number of computations required to generate multiple candidate codewords by perturbing the output signal in the worst case is CpT1N. The number of computations required for the worst-case genetic operation process can be estimated as CgT2N. Therefore, the overall additional complexity brought by the proposed Online-PDNE decoder is CpT1N+CgT2N, which is the same as the PP-SSC decoder.

In the PDNE decoding algorithm, the genetic process runs in an offline manner, so the extra complexity required is only CpT1N, which is due to perturbation operations.

As for the SNE decoding algorithm, the pre-trained noise set S∗ <sup>n</sup> is directly called for secondary decoding when the SSC decoding fails. Compared with the PDNE decoding algorithm, the SNE decoding algorithm only needs to perform the addition operation C<sup>+</sup> p in the perturbation operation.

#### **5. Simulation Results**

In this section, the performance of the proposed decoding algorithms is evaluated on a BPSK-modulated additive white Gaussian noise (AWGN) channel, in which the SSC decoder is employed for the standard polar decoding. However, it can easily be extended for other decoding algorithms. In the simulations, we use the same polar codes from [10] with code rates 1/2 and 3/4, and both codes have length N = 1024. The parameters and related values used in the training process are shown in Table 3.

**Table 3.** Parameters of the training process.


Figures 4 and 5 illustrate the BER and the FER performances of the rate-1/2 polar code with the proposed decoding algorithms, the SSC algorithm [14], the PB-SSC algorithm [33], as well as the PP-SSC algorithm [35], respectively. As shown in Figure 4, the performance of the proposed three decoding algorithms is better than that of the other algorithms. The performance of the proposed Online-PDNE decoding algorithm is about 1.0 dB, 0.6 dB and 0.5 dB superior to that of the conventional SSC algorithm, the PB-SSC algorithm, and the PP-SSC algorithm at the BER of 10−5, respectively. When SNR = 3.5 dB, we can see from the figure that our proposed Online-PDNE decoding algorithm can improve BER performance by nearly four orders of magnitude compared with the SSC algorithm, nearly three orders of magnitude compared with the PB-SSC algorithm, and more than two orders of magnitude compared with the PP-SSC algorithm.

In addition, among the three proposed decoding algorithms, the Online-PDNE decoding algorithm has the best performance, followed by the PDNE decoding algorithm. The reason why the Online-PDNE decoding algorithm has the best performance is that the directed neural-evolutionary noise is generated online by the GA process for the uncorrectable sequence, which converts the received signal into the error correction region of its decoding space more accurately.

Since the PDNE decoding algorithm and the SNE decoding algorithm use the offline GA process to generate the directed neural-evolutionary noise, the decoding complexity and delay are greatly reduced compared with the Online-PDNE decoding algorithm. However, due to the limitation of the size of the directed noise set and uncorrectable error codewords not encountered during offline training, their performances suffer slightly. Compared with the PDNE decoding algorithm, the performance of the SNE decoding algorithm decreases

slightly, about 0.2 dB, but its decoding complexity and delay are the lowest, and it only depends on the directed neural-evolutionary noise of offline training to decode correctly.

**Figure 4.** BER performance of the (1024, 512) polar code with different decoding algorithms. The SSC algorithm is in [14], the PB-SSC algorithm is in [33], and the PP-SSC algorithm is in [35].

**Figure 5.** FER performance of the (1024, 512) polar code with different decoding algorithms. The SSC algorithm is in [14], the PB-SSC algorithm is in [33], and the PP-SSC algorithm is in [35].

From Figure 5, it can be seen that our proposed three decoding algorithms achieve better performance than the others. This conclusion agrees with the results in Figure 4. When SNR = 3.5 dB, we can see from the figure that our proposed Online-PDNE decoding algorithm can improve FER performance by three orders of magnitude compared with the SSC algorithm, more than one order of magnitude compared with the PB-SSC algorithm and the PP-SSC algorithm.

To further evaluate the error correction performance of the proposed decoding algorithms as described in Section 3, we also simulate the rate-3/4 polar code. In Figures 6 and 7, we compare the BER and FER performances of the designed decoding algorithms

with other decoding algorithms for the rate-3/4 polar code, respectively. We also see that the proposed decoding algorithms have better error correction performance than other decoding algorithms when the code rate increases.

**Figure 6.** BER performance of the (1024, 768) polar code with different decoding algorithms. The SSC algorithm is in [14], the PB-SSC algorithm is in [33], and the PP-SSC algorithm is in [35].

**Figure 7.** FER performance of the (1024, 768) polar code with different decoding algorithms. The SSC algorithm is in [14], the PB-SSC algorithm is in [33], and the PP-SSC algorithm is in [35].

In Figure 6, when SNR = 6.0 dB, we can see from the figure that our proposed Online-PDNE decoding algorithm can improve the BER performance by more than four orders of magnitude compared with the SSC algorithm, more than three orders of magnitude compared with the PB-SSC algorithm and the PP-SSC algorithm.

As can be seen from Figure 7 that when SNR = 6.0 dB, the proposed Online-PDNE decoding algorithm improves the FER performance by more than three orders of magnitude compared with the SSC algorithm and more than two orders of magnitude compared with the PB-SSC algorithm and PP-SSC algorithm. Note that compared to the proposed PDNE decoding algorithm, the SNE decoding algorithm significantly reduces the decoding complexity with negligible performance degradation, which coincide with the results in Figures 4 and 5.

In Figures 8 and 9, we compare the average normalized complexities of the proposed Online-PDNE decoding algorithm, the proposed PDNE decoding algorithm, the SNE decoding algorithm and other decoding algorithms for polar codes with two rates, respectively. The average normalized complexity of these algorithms is normalized by the SSC decoding algorithm.

**Figure 8.** The average normalized complexities for the (1024, 512) polar code. The SSC algorithm is in [14], the PB-SSC algorithm is in [33], and the PP-SSC algorithm is in [35].

**Figure 9.** The average normalized complexities for the (1024, 768) polar code. The SSC algorithm is in [14], the PB-SSC algorithm is in [33], and the PP-SSC algorithm is in [35].

It can be observed that the average normalized complexity of the proposed PDNE decoding algorithm and SNE decoding algorithm is much lower than that of the PP-SSC decoding algorithm, which is due to the offline training. Among the proposed decoding algorithms, the online-PDNE decoding algorithm has the best error correction performance and the highest complexity, but it is still much less complicated than the PP-SSC decoding algorithm. As the SNR increases, the complexity of the proposed decoding algorithms reduces to the same level as the SSC decoding algorithm. The proposed decoding algorithms can benefit from more reliable channel conditions and require smaller perturbation attempts to successfully decode, thereby reducing the normalized decoding delay.

It can also be seen from Figures 4 and 8 that the proposed PDNE and SNE decoding algorithms have slightly higher average normalized complexity compared with the PB-SSC algorithm at low SNR region. When SNR ≥ 2.5 dB, their complexities are almost the same, but the performance of the proposed PDNE and SNE algorithms is much better than that of the PB-SSC algorithm. In Figures 6 and 8, when SNR ≥ 5.5 dB, similar conclusions can be drawn, which coincides with the results in Figures 4 and 8.

Tables 4 and 5 provide the average normalized complexities corresponding to some fixed SNR values of polar codes with two rates under different decoding algorithms, respectively. Taking Table 4 as an example, when the SNR increases from 0.5 dB to 2.5 dB, the average normalized complexity of the proposed Online-PDNE decoding algorithm drops sharply from 767.300 to 1.293, which is the same order of magnitude as the SSC decoding algorithm.

**Table 4.** The average normalized complexities for the (1024, 512) polar code for certain SNR values.


**Table 5.** The average normalized complexities for the (1024, 768) polar code for certain SNR values.


#### **6. Conclusions**

In this paper, three decoding algorithms were proposed for polar codes by exploiting the perturbed and directed neural-evolutionary noise, in which uncorrectable received sequences can be transformed into error-corrected regions of their decoding space. In addition to the SSC decoding algorithm, the proposed algorithms are also applicable to other standard polar code decoding algorithms. Simulation results verified that our proposed Online-PDNE decoding algorithm can achieve better performance than other algorithms and obtain up to four orders of magnitude compared with the SSC algorithm, and no error floor is observed down to a BER of 10−9. The performance of the proposed Online-PDNE decoding algorithm is about 1.0 dB, 0.6 dB and 0.5 dB superior to that of the conventional SSC algorithm, the PB-SSC algorithm, and the PP-SSC algorithm at the BER of 10−5, respectively. This is due to the directed neural-evolutionary noise is generated online by the GA process for the uncorrectable sequences, which converts the received signal into the error correction region of its decoding space more accurately. To further reduce the decoding complexity and simplify the decoding structure, the PDNE and SNE

decoding algorithms were proposed. While ensuring the error correction performance, the complexity is reduced by employing the offline neuro-evolution. In addition, it is worth mentioning that the proposed decoding algorithms can be extended to other channel codes in a straightforward manner. As a future work, we plan to apply the proposed decoding algorithms to the polar codes in the 5G standard.

**Author Contributions:** Conceptualization, L.K. and H.L.; methodology, L.K. and H.L.; software, W.H. and L.K.; validation, W.H. and L.K.; formal analysis, W.H.; investigation, W.H. and B.D.; resources, W.H.; data curation, W.H.; writing—original draft preparation, L.K.; writing—review and editing, H.L.; visualization, W.H. and B.D.; supervision, B.D.; project administration, L.K. and H.L.; funding acquisition, L.K. and H.L. All authors have read and agreed to the published version of the manuscript.

**Funding:** This research was funded by the JITSF (grant No. jit-b-202110) and the NSFC (grant No. 61871376).

**Data Availability Statement:** Not applicable.

**Conflicts of Interest:** The authors declare no conflict of interest.

#### **References**

