Soft-Output Deep Neural Network-Based Decoding
Deep neural network (DNN)-based channel decoding is widely considered in the
literature. The existing solutions are investigated for the case of hard
output, i.e. when the decoder returns the estimated information word. At the
same time, soft-output decoding is of critical importance for iterative
receivers and decoders. In this paper, we focus on the soft-output DNN-based
decoding problem. We start with the syndrome-based approach proposed by
Bennatan et al. (2018) and modify it to provide soft output in the AWGN
channel. The new decoder can be considered as an approximation of the MAP
decoder with smaller computation complexity. We discuss various regularization
functions for joint DNN-MAP training and compare the resulting distributions
for [64, 45] BCH code. Finally, to demonstrate the soft-output quality we
consider the turbo-product code with [64, 45] BCH codes as row and column
codes. We show that the resulting DNN-based scheme is very close to the
MAP-based performance and significantly outperforms the solution based on the
Chase decoder. We come to the conclusion that the new method is prospective for
the challenging problem of DNN-based decoding of long codes consisting of short
component codes.
Dmitry Artemasov, Kirill Andreev, Pavel Rybin, Alexey Frolov
# Soft-Output Deep Neural Network-Based Decoding

###### Abstract

Deep neural network (DNN)-based channel decoding is widely considered in the literature. The existing solutions are investigated for the case of hard output, i.e. when the decoder returns the estimated information word. At the same time, soft-output decoding is of critical importance for iterative receivers and decoders. In this paper, we focus on the soft-output DNN-based decoding problem. We start with the syndrome-based approach proposed by Bennatan et al. (2018) and modify it to provide soft output in the AWGN channel. The new decoder can be considered as an approximation of the MAP decoder with smaller computation complexity. We discuss various regularization functions for joint DNN-MAP training and compare the resulting distributions for \([64,45]\) BCH code. Finally, to demonstrate the soft-output quality we consider the turbo-product code with \([64,45]\) BCH codes as row and column codes. We show that the resulting DNN-based scheme is very close to the MAP-based performance and significantly outperforms the solution based on the Chase decoder. We come to the conclusion that the new method is prospective for the challenging problem of DNN-based decoding of long codes consisting of short component codes.

 Channel decoding, machine learning, deep neural networks, soft-output, iterative codes

## I Introduction

Nowadays, the scope of application of machine learning algorithms and deep neural networks (DNN) is growing rapidly. In the past decade, the use of DNNs has allowed groundbreaking results to be achieved in applications such as image, video, and natural language processing [1]. All of these applications deal with natural signals. At the same time, much less attention has been devoted to the application of ML methods in communications. In this paper, we consider the application of ML algorithms for the channel decoding problem. To justify this research direction we note that the decoding problem is a classification problem: the channel output must correspond to one of the classes (codewords). The significant difference between this problem and a typical classification problem lies in the exponentially large number of classes.

The idea to use NNs in the channel decoding problem is not new, here we mention the early papers [2, 3]. But due to the lack of computation capabilities, these methods were forgotten until a recent paper [4]. The authors of [4] consider a binary input channel with additive white Gaussian noise (AWGN) and utilize a fully connected NN as a decoder. The major ML challenge is dataset collection and labeling but in the decoding task, this problem disappears as a dataset of any size can be generated easily. At the same time, the approach of [4] suffers from the "curse of dimensionality" problem, as the number of codewords is exponential in the number of information bits. Thus, for any reasonable parameters, it is not possible to train the NN on all the codewords. The only hope is that the NN can learn the code structure by observing a small number of codewords. Note that all the practical codes are linear ones and can be defined by a basis, so the basis vectors are sufficient to learn the code structure. The main outcome of [4] is that the fully connected NN cannot learn the code structure1 and thus the such method is applicable for very short codes only. The subsequent articles propose to combine the existing decoding algorithms and NNs. The articles [5, 6, 7, 8, 9, 10, 11] consider belief propagation algorithm (both Sum-Product and Min-Sum modifications) which is suitable for any linear code, but shows the best results for sparse-graph codes, such as Low-Density Parity-Check (LDPC) codes [12]. The idea is to unwrap (or unroll) the underlying Tanner graph and obtain a sparse NN, which repeats the decoder operations but is equipped with trainable weights. The improvements were obtained for BCH codes [5, 6, 10] and LDPC codes [7, 8, 11]. The next idea was to replace the activation functions, the architecture is called a hyper-network [13, 14]. Later, Cammerer et al. proposed to replace node and edge message updates with trainable functions, thus allowing NN to learn a generalized message passing algorithm [15]. Another approach proposed in [16] is to consider the syndrome-based decoding algorithm that is suitable for any linear codes. The basic syndrome-based decoding algorithm implies the use of the mapping (syndrome to the coset leader), which has the exponential (in the number of parity-check bits) size. The idea of [16] is to approximate this table with a NN. We note that the syndrome does not depend on the codeword and, therefore, we do not require the NN to have a special structure, it can be arbitrary, but the best results were obtained with recurrent NNs [16]. Later a syndrome-based approach was adapted to the transformer and denoising diffusion architectures [17, 18].
We also note the papers (see, e.g. [19]) devoted to DNN-based code construction. For additional literature and a more detailed overview, we refer the reader to [20].

The papers above focus on the performance of hard-output decoding, i.e. the decoder is required to return the estimated information word. At the same time, modern receivers (such as MIMO receivers [21]) and modern codes consisting of short component codes [22] require iterative (or turbo) decoders. Soft-output decoding is of critical importance for such schemes. We note that several papers (e.g. [15, 16]) mention the possibility of obtaining a soft output by the proposed DNN architectures, but to the best of our knowledge, the quality of such output was not investigated in the literature. In what follows, we fill this gap.

Our contribution is as follows. We start with a syndrome-based approach [16] and modify it to provide soft output. The major change is the training process and the loss function, including the regularization term, which controls the soft output quality. We demonstrate the performance of the new decoder for the \([64,45]\) BCH code on the binary input AWGN channel. We choose such parameters as maximum a-posteriori (MAP) decoding is feasible for this code but has large complexity, which prevents the use of such a method in practice. Our decoder can be considered as an approximation of the MAP decoder with smaller computation complexity, in other words, we require our DNN to reproduce the MAP output. We discuss various regularization functions and compare the resulting distributions. Finally, to demonstrate soft output quality, we consider the iterative decoding scheme, namely the turbo product code (TPC) with \([64,45]\) BCH codes as row and column codes. We show that the resulting DNN-based scheme is very close to MAP-based performance and significantly outperforms the Chase decoder-based solution [23] in combination with the soft output calculation [24].

The paper is organized as follows. In section II the proposed preprocessing procedure described, NN model architecture, and soft-output quality metrics are introduced and applied for distribution optimization. The section ends with the decoding performance results and their discussion. Section III provides a description of the proposed soft-decoding approach application in the TPC decoding scheme. The framework preprocessing steps for iterative decoding and model tuning steps are followed by a discussion of the results.

## II Soft-input soft-output DNN-based decoding

### _System model_

Let us describe the system model. The user aims to transmit a \(k\)-bit information word \(\mathbf{u}\in\{0,1\}^{k}\). We assume the use of a binary linear block code \(\mathcal{C}\) of length \(n\) and dimension \(k\). Let \(\mathbf{H}\) and \(\mathbf{G}\) denote parity-check and generator matrices of the code \(\mathcal{C}\) accordingly. The information word \(\mathbf{u}\) is first encoded into the codeword \(\mathbf{c}=(c_{1},\ldots,c_{n})=\mathbf{u}\mathbf{G}\in\{0,1\}^{n}\). Then the binary phase-shift keying (BPSK) modulation is applied, implying the following mapping.

\[\mathbf{x}=\tau(\mathbf{c}),\quad\tau(\mathbf{c})=(\tau(c_{1}),\ldots,\tau(c_ {n})),\]

where \(\tau:\{0,1\}\rightarrow\{1,-1\}\).

Modulated codeword \(\mathbf{x}\) is transmitted over the AWGN channel, thus the receiver obtains corrupted codeword

\[\mathbf{y}=\mathbf{x}+\mathbf{z},\]

where \(\mathbf{y}=(y_{1},\ldots,y_{n})\in\mathbb{R}^{n}\), \(\mathbf{z}\sim\mathcal{N}(0,\sigma^{2}\mathbf{I}_{n})\) and \(\mathbf{I}_{n}\) is the identity matrix of size \(n\times n\). In what follows by \(E_{s}/N_{0}\) we denote signal-to-noise ratio, \(E_{s}/N_{0}=1/2\sigma^{2}\).

As usual [25], the input of the decoder is presented as a vector \(\boldsymbol{\gamma}=(\gamma_{1},\ldots,\gamma_{n})\) of log-likelihood ratios, where

\[\gamma_{i}=\log\frac{p(y_{i}|c_{i}=0)}{p(y_{i}|c_{i}=1)}=\frac{2y_{i}}{\sigma^ {2}},\ i=1,\ldots,n, \tag{1}\]

where \(\log(\cdot)\) stands for a natural logarithm and \(p(x)=1/\sqrt{2\pi\sigma^{2}}\exp\left[-x^{2}/(2\sigma^{2})\right]\) is the probability density function of a random variable distributed as \(\mathcal{N}(0,\sigma^{2})\).

Now, let us describe the decoding performance metric. Let us start with hard output decoding, and let \(\hat{\mathbf{u}}=(\hat{u}_{1},\ldots,\hat{u}_{k})\in\{0,1\}^{k}\) be the estimated information word. In what follows we utilize bit error rate (BER) \(P_{b}=\frac{1}{k}\sum_{i=1}^{k}\Pr[u_{i}\neq\hat{u}_{i}]\) and frame error rate (FER) \(P_{f}=\Pr[\mathbf{u}\neq\hat{\mathbf{u}}]\).

To assess soft output quality, we compare the decoder output to the bit-wise MAP output \(\boldsymbol{\gamma}^{*}=(\gamma_{1}^{*},\ldots,\gamma_{n}^{*})\), where for \(i=1,\ldots,n\) we have

\[\gamma_{i}^{*}=\log\frac{\Pr[c_{i}=0|\mathbf{y}]}{\Pr[c_{i}=1|\mathbf{y}]}= \log\frac{\sum_{\mathbf{c}\in\mathcal{C},c_{i}=0}\exp\left[(\mathbf{1}- \mathbf{c})\boldsymbol{\gamma}^{T}\right]}{\sum_{\mathbf{c}\in\mathcal{C},c_{i} =1}\exp\left[(\mathbf{1}-\mathbf{c})\boldsymbol{\gamma}^{T}\right]},\]

where \(\mathbf{1}\) is the all-one vector, \(\boldsymbol{\gamma}^{T}\) is the transpose of \(\boldsymbol{\gamma}\). We refer the reader to [26] for the derivation.

### _Syndrome-based approach_

The proposed soft-output decoding framework inherits the syndrome-based structure described by Bennatan et al. [16]. The original syndrome-based decoder implementation was designed for the system with multiplicative noise and its performance was discussed for hard decision decoding. In this paper, we propose to modify the pre- and postprocessing steps to adapt the framework for soft-output decoding in the AWGN channel.

In [16] authors propose to pass vector \([|\mathbf{y}|,\mathbf{s}]\) as the input to the noise estimator, where \([\cdot,\cdot]\) denotes concatenation, \(|\mathbf{y}|\) - reliability vector and \(\mathbf{s}=\text{bin}(\mathbf{y})\mathbf{H}^{T}\) - binary syndrome. In such notation \(\text{bin}(\cdot)\) implies a hard decision over the received vector. Instead, we propose to utilize the so-called _soft syndrome_ introduced by Lugosch et al. [27] to avoid the hard-decision step in preprocessing. Since there is an isomorphism in between \((\{0,1\},\oplus)\) and \((\{1,-1\},*)\), the syndrome can be expressed as follows

\[s_{i}=\prod_{j\in\mathcal{M}(i)}\text{sign}(y_{j}),\forall i\in[1,n-k] \tag{2}\]

where \(\mathcal{M}(i)\) is the set of columns in the \(i\)-th row of parity check matrix \(\mathbf{H}\) equal to \(1\).
Thus, the hard syndrome relaxation for input LLR vector \(\mathbf{\gamma}\) can be introduced as

\[\tilde{s}_{i}=\min_{j\in\mathcal{M}(i)}|\gamma_{j}|\prod_{j\in\mathcal{M}(i)} \text{sign}(\gamma_{j}),\forall i\in[1,n-k] \tag{3}\]

For following description we denote noise estimator input vector by \(\mathbf{d}=[|\mathbf{\gamma}|,\mathbf{\tilde{s}}]\in\mathbb{R}^{2n-k}\).

The proposed decoding algorithm is summarized in Algorithm 1. The noise estimation function is denoted by \(\mathcal{F}\). In what follows \(\mathcal{F}\) is chosen to be a DNN.

```
0:\(\mathbf{\gamma}\in\mathbb{R}^{n}\) - input LLRs, \(\mathbf{\tilde{s}}\in\mathbb{R}^{n-k}\) - soft syndrome
0:\(\mathbf{\hat{\gamma}}\in\mathbb{R}^{n}\) - transmitted message LLRs estimation
1:\(\mathbf{\hat{z}}\leftarrow\mathcal{F}([\mathbf{\gamma}|,\mathbf{\tilde{s}}])\)
2:\(\mathbf{\hat{\gamma}}\leftarrow\mathbf{\gamma}-\text{sign}(\mathbf{\gamma})\odot\mathbf{ \hat{z}}\)
3:return\(\mathbf{\hat{\gamma}}\)
```

**Algorithm 1** Soft-output syndrome-based DNN decoding

### _NN model architecture_

The main goal of the neural network \(\mathcal{F}\) is to estimate the noise vector, and the choice of the best architecture remains an open question [16, 17, 18]. In this paper, we focus on estimating the ability of the neural network framework to perform soft decoding. Based on the analysis of hard decoding quality and the time required to train different architectures, we choose a Stacked-GRU architecture [16].

Stacked-GRU is a multi-layer Recurrent Neural Network (RNN) architecture composed of Gated Recurrent Unit (GRU) cells [28] with trainable "update" and "reset" gates. Each GRU cell can be described by the following equations (see Fig. 1 for more details).

\[\mathbf{g}_{t} =\sigma(\mathbf{W}_{g}\mathbf{d}_{t}+\mathbf{U}_{g}\mathbf{q}_{t- 1}+\mathbf{b}_{g}), \tag{4}\] \[\mathbf{r}_{t} =\sigma(\mathbf{W}_{r}\mathbf{d}_{t}+\mathbf{U}_{r}\mathbf{q}_{t- 1}+\mathbf{b}_{r}),\] (5) \[\mathbf{\hat{q}}_{t} =\tanh\big{(}\mathbf{W}_{h}\mathbf{d}_{t}+\mathbf{U}_{h}(\mathbf{ r}_{t}\odot\mathbf{q}_{t-1})+\mathbf{b}_{h}\big{)},\] (6) \[\mathbf{q}_{t} =\mathbf{g}_{t}\odot\mathbf{\hat{q}}_{t}+(\mathbf{1}-\mathbf{g}_ {t})\odot\mathbf{q}_{t-1}, \tag{7}\]

where \(\mathbf{d}_{t}\) is the input vector, \(\mathbf{q}_{t}\) - output vector, \(\mathbf{\hat{q}}_{t}\) - candidate output vector, \(\mathbf{g}_{t}\) - update gate vector, \(\mathbf{r}_{t}\) - reset gate vector, \(\mathbf{W},\mathbf{U}\) - trainable parameters matrices and \(\mathbf{b}\) - trainable bias vectors. \(\sigma(\cdot)\) denotes sigmoid function, \(\tanh(\cdot)\) hyperbolic tangent and \(\odot\) Hadamard product. This architecture is widely used for Natural Language Processing (NLP).

To form a Stacked-GRU architecture, cells are bundled in two dimensions. The first stacking dimension is similar to the general fully connected NN (FCNN) layers. The output \(\mathbf{q}_{t}\) of the preceding cell is passed to the feature input \(\mathbf{d}_{t}\) of the subsequent cell. By \(L\) we denote the total number of layers in the Stacked-GRU network. The second stacking dimension defines the recurrent structure of the network. The output of the preceding cells is passed as the hidden state \(\mathbf{q}_{t-1}\) to the following cells. The initial hidden state of the network \(\mathbf{q}_{0}\) is set to zero. We denote the total number of _time steps_ by \(T\).

For a single input vector, Stacked-GRU NN generates \(T\) vectors on the outputs of the last layer. We denote matrix of stacked output vectors by \(\mathbf{Q}^{(L)}=[\mathbf{q}_{1}^{(L)},\mathbf{q}_{T}^{(L)}]\in\mathbb{R}^{2n-k \times T}\), where superscript \(L\) denotes index of the last layer and subscript \(t\) denotes the GRU time step. In order to reduce the size of Stacked-GRU output, its vectorized representation \(\text{vec}(\mathbf{Q}^{(L)})\) is passed to the single FC layer. The complete architecture of the noise estimator model is depicted in Fig.2.

For model training, the loss is calculated from the framework soft output and binary codeword. The Binary Cross-Entropy (BCE) with sigmoid function is utilized.

\[\begin{split}\mathcal{L}_{BCE}(\mathbf{\hat{\gamma}},\mathbf{c})& =-\frac{1}{n}\sum_{i=1}^{n}c_{i}\log\sigma(-\hat{\gamma}_{i})+\\ &(1-c_{i})\log(1-\sigma(-\hat{\gamma}_{i}))\end{split} \tag{8}\]

### _Soft-output quality optimization_

In order to optimize the soft-output distribution we propose to introduce a regularization term into the loss function for the last epochs of a model training procedure. Three types of regularization are proposed: Mean Squared Error (MSE), Kullback-Leibler (KL) divergence and moments-based. MAP decoder output LLRs \(\mathbf{\gamma}^{\star}\) are used as a reference.

MSE \(\mathcal{L}_{MSE}\) and KL divergence \(\mathcal{L}_{KL}\) regularizations are defined in a pointwise manner. Moments-based regularization

Fig. 1: Gated Recurrent Unit cell

Fig. 2: Stacked-GRU model architecture
\(\mathcal{L}_{M}\) is expressed as the weighted sum of the MSEs of the first and second moments of the decoder output distributions.

\[\mathcal{L}_{\text{MSE}}(\boldsymbol{\gamma}^{*},\boldsymbol{\hat{\gamma}})= \frac{1}{n}\sum_{i=1}^{n}(\gamma_{i}^{*}-\hat{\gamma}_{i})^{2} \tag{9}\]

\[\mathcal{L}_{\text{KL}}(\boldsymbol{\gamma}^{*},\boldsymbol{\hat{\gamma}})= \sum_{i=1}^{n}\gamma_{i}^{*}\cdot\log\frac{\gamma_{i}^{*}}{\hat{\gamma}_{i}} \tag{10}\]

\[\mathcal{L}_{\text{M}}(\boldsymbol{\gamma}^{*},\boldsymbol{\hat{\gamma}})= \rho_{\text{M}}\Big{(}\mathbb{E}(|\boldsymbol{\gamma}^{*}|)-\mathbb{E}(| \boldsymbol{\hat{\gamma}}|)\Big{)}^{2}+ \tag{11}\]

The loss function with regularization term is expressed as

\[\mathcal{L}=\mathcal{L}_{\text{BCE}}+\alpha_{\text{Reg}}\mathcal{L}_{\text{Reg}} \tag{12}\]

where \(\mathcal{L}_{Reg}\) is the selected regularization metric and \(\alpha_{\text{Reg}}\) its weight coefficient.

The results of the described regularization terms applied for the optimization of the soft output distribution of the NN decoder are summarized in Table I and depicted in Fig.3 for the moments-based approach. Table I evaluates the NN-decoder output distribution similarity to the MAP decoder in terms of metrics used for regularizations. Results are provided for NN-decoder trained on \([64,45]\) BCH code with distribution evaluation on \(E_{s}/N_{0}=1dB\). Regularization terms weights were estimated empirically: \(\alpha_{\text{MSE}}=0.01\), \(\alpha_{\text{KL}}=10^{10}\), \(\alpha_{\text{M}}=0.1\), \(\rho_{\text{M}}=0.95\).

### _Simulation results_

To evaluate the decoding performance of the proposed framework, the Stacked-GRU model with a hidden size of \(5n\), 4 layers, and 5 time-steps, as in [16], was trained on zero codewords with a batch size of \(2^{13}\) codewords. The initial learning rate of Adam optimizer [29] was set to \(10^{-3}\) with a further decrease to \(10^{-6}\) by the "reduce on plateau" scheduler. Initial training was performed with BCE loss (8) only. MAP-based regularization terms were introduced for the last epochs only due to the high complexity of MAP decoding2.

Footnote 2: we note that proposed soft-output DNN can be utilized without joint DNN-MAP fine tuning stage, if such is restricted by the complexity reasons.

The performance of soft-output DNN decoder was compared with the Chase decoder, Belief propagation with 50 decoding iterations and NN-Tanner [7] with 20 decoding iterations.

## III NN iterative soft-output decoding

To work in iterative decoding schemes, the decoder must be able to produce a soft output. Turbo Product Code (TPC) scheme was chosen to demonstrate the potential of using the proposed framework in iterative decoding schemes.

### _Turbo product code_

Turbo Product Code (TPC) structure can be explained using the diagram in Fig.5. TPC is constructed from two component codes in the systematic form with parameters \((n_{1},k_{1})\) and

Fig. 4: Bit error rate results for \([64,45]\) BCH code

Fig. 3: Output LLR distributions histogram for \(E_{s}/N_{0}=1dB\)\([64,45]\) BCH code. The moments-based approach is used for regularization.
\((n_{2},k_{2})\) respectively. The encoding is performed in two steps. Initially, the information submatrix \(k_{1}\times k_{2}\) is encoded by the "column code" producing the "column checks" submatrix. Then the information and column check submatrices are encoded with the "row code", thus producing the "row checks" and "checks-on-checks" submatrices. The aggregate code rate of TPC is \(R=(k_{1}k_{2})/(n_{1}n_{2})\)[25].

The iterative TPC decoding procedure is summarized in the algorithm 2. There by \(N\) we denote the number of decoding iterations, by \(\mathcal{D}_{c}(\cdot),\mathcal{D}_{r}(\cdot)\) column and row decoding functions, by \(\mathbf{L}_{c}\in\mathbb{R}^{n_{2}\times n_{1}}\), \(\mathbf{L}_{r}\in\mathbb{R}^{n_{1}\times n_{2}}\) extrinsic information matrices and by \(\alpha_{c}^{(i)},\alpha_{r}^{(i)}\in[0,1]\) extrinsic LLRs scale factors on \(i\)-th iteration.

### _NN TPC decoding_

To utilize the soft-output DNN decoder we pre-train the model for component code decoding, as described in Section II, and then fine-tune it in the iterative scheme.

One of the advantages of a syndrome-based approach lies in its robustness to overfitting. The noise estimation NN-model is trained on reliability vectors and syndromes, which do not depend on the transmitted codeword. Thus, the model can be trained on a zero codeword with different realizations of noise. However, the performance of the model trained on the defined range of Signal-to-Noise Ratios degrades for values over the range. This problem arises in the iterative schemes, since with each iteration the absolute value of the output LLRs grows. The proposed iterative decoding approach does not require training a separate model for each decoding iteration. The same pretrained DNN decoder is utilized for all TPC iterations. To solve the issue of growing LLRs we apply \(L^{1}\) batch normalization for the input of the decoding framework.

In the NN-TPC decoding scheme extrinsic LLRs scale factors \(\alpha_{c},\alpha_{r}\) are initialized as the trainable parameters, thus during the fine-tuning stage their optimal value is calculated by the gradient descent jointly with the decoding model.

The loss function for the NN-TPC fine-tuning stage is the exponentially weighted sum of BCE loss (8) of all decoding iterations.

\[\boldsymbol{\beta}=[e^{0},\ldots,e^{2N-1}] \tag{13}\] \[\mathcal{L}_{\text{NN-TPC}}=\frac{1}{2N\|\boldsymbol{\beta}\|_{1 }}\sum_{j=1}^{2N}\beta_{j}\mathcal{L}_{BCE}(\widehat{\mathbf{\Gamma}}_{j}, \mathbf{C}) \tag{14}\]

Where \(\widehat{\mathbf{\Gamma}}_{j}\) is decoded by columns/rows message LLRs on iteration \(\lceil j/2\rceil\) and \(\mathbf{C}\) is transmitted binary TPC message.

### _Simulation results_

To evaluate the proposed framework in an iterative decoding scheme, we use TPC with \([64,45]\) BCH as component code. Soft-output DNN model was initially trained on component code, as described in II-E. Then the model was fine-tuned in the TPC decoding scheme with a learning rate \(10^{-6}\) for 4000 epochs with a batch size of \(256\). The extrinsic scales \(\alpha_{c},\alpha_{r}\) were initialized by the value \(0.7\).

The performance of the soft-output DNN decoder is compared to the Chase-Pyndiah algorithm [24] for \(N=2\) and \(N=4\) TPC decoding iterations. Chase-Pyndiah results were obtained with the AFF3CT toolbox [30].

Further research directions are as follows. In the real-world applications with increasing requirements to latency,

Fig. 5: TPC structure

Fig. 6: FER results for TPC decoding scheme with BCH(64,45) as component code, 2 iterations
memory and power usage, there is a challenge of decoder complexity reduction without loss of decoding performance. DNN utilized for noise estimation in this paper has relatively high complexity (\(2.2\cdot 10^{6}\) parameters). The question of optimal architecture selection for soft-output decoding is an open question. Apart from that, we point out the model weights adaptive quantization [31, 32, 33], activation functions approximation [33] and model weights pruning [34] as the potential directions of soft-output DNN complexity reduction.
